kolibrios/programs/other/mhc/trunk/mhc.asm

;
; MHC archiver for MenuetOS - very fast compression tool
;
; version 0.09
;
; Written by Nikita Lesnikov (nlo_one@mail.ru, Republic of Belarus, Sluck)
;

;==============================================================================

;
; Brief file format description:
;
;                  +-----------+------------------------+
;  File structure: | Method ID | Compressed data        |
;                  +-----------+------------------------+
;
;  Methods list:
;
;    0. LZP (order-2 specified specially for *.ASM,*.RAW and MeOS executables)
;
;  New methods can be easily added without loss of compatibility
; with older versions
;

;==============================================================================

; SYSTEM HEADER

use32

  org 0x0
  db "MENUET01"
  dd 0x01
  dd ENTRANCE
  dd MHC_END
  dd 0x300000  ; 3 megs of memory needed
  dd 0x2FF000
  dd 0x0
  dd 0x0

include 'lang.inc'
include 'macros.inc'
; CODE AREA

ENTRANCE:

; ======== user interface =========


 call draw_window             ; draw the window

 still:

 mov eax,10                   ; wait for event
 int 0x40

 cmp eax,1                    ; redraw?
 jnz no_redraw
 call draw_window
 no_redraw:

 cmp eax,2                    ; key pressed?
 jz key

 cmp eax,3                    ; button pressed?
 jz button

 jmp still

 ; Key handler

 key:
 mov eax,2   ; read it
 int 0x40
 shr eax,8

 cmp byte [editstate],0
 jz  still

 cmp al,8    ; backspace
 jnz no_bksp
 cmp byte [editpos],0
 jz  no_del_last
 dec byte [editpos]
 xor ebx,ebx
 mov bl,byte [editpos]
 add ebx,cmfile
 cmp byte [editstate],2
 jnz no_add_base_1
 add ebx,12
 no_add_base_1:
 mov byte [ebx],32
 no_del_last:
 call draw_info
 jmp still
 no_bksp:

 cmp al,13            ; enter
 jnz no_enter
 mov byte [editstate],0
 call draw_info
 jmp still
 no_enter:

 cmp eax,dword 31
 jbe no_lit
 cmp eax,dword 95
 jb  capital
 sub eax,32
 capital:
 xor ebx,ebx
 mov bl,byte [editpos]
 add ebx,cmfile
 cmp byte [editstate],2
 jnz no_add_base_2
 add ebx,12
 no_add_base_2:
 mov byte [ebx],al
 inc byte [editpos]
 cmp byte [editpos],12
 jnz no_null_state
 mov byte [editstate],0
 no_null_state:
 call draw_info
 no_lit:

 jmp still

 ; Button handler

 button:

 mov eax,17
 int 0x40

 cmp ah,1
 jnz no_quit
 mov eax,-1
 int 0x40
 no_quit:

 cmp ah,4
 jnz nofirst
 cld
 mov byte [editstate],1
 mov edi,cmfile
 mov eax,0x20202020
 mov ecx,3
 rep stosd
 mov byte [editpos],0
 mov byte [msgid],0
 call draw_info
 nofirst:

 cmp ah,5
 jnz nosecond
 cld
 mov byte [editstate],2
 mov edi,iofile
 mov eax,0x20202020
 mov ecx,3
 rep stosd
 mov byte [editpos],0
 mov byte [msgid],0
 call draw_info
 nosecond:

 cmp ah,2
 jnz no_compress
 call compress
 no_compress:

 cmp ah,3
 jnz no_decompress
 call decompress
 no_decompress:

 cmp ah,6
 jnz no_delete_io
 pusha
 mov eax,32
 mov ebx,iofile
 int 0x40
 popa
 no_delete_io:

 cmp ah,7
 jnz  no_delete_archive
 pusha
 mov eax,32
 mov ebx,cmfile
 int 0x40
 popa
 no_delete_archive:

 jmp still

 ; WINDOW DRAW

 draw_window:

 mov eax,12  ; Start redrawing
 mov ebx,1
 int 0x40

 xor eax,eax           ; Define window
 mov ebx,100*65536+240
 mov ecx,100*65536+130
 mov edx,0x02AAAAAA
 mov esi,0x80777777
 mov edi,0x00777777
 int 0x40

 mov eax,4              ; Draw all needed texts
 mov ebx,8*65536+8
 mov ecx,0x00FFFFFF
 mov edx,title
 mov esi,arclab-title
 int 0x40

 xor ecx,ecx
 mov edx,arclab
 mov esi,unplab-arclab
 add ebx,10*65536+28
 int 0x40

 mov edx,unplab
 mov esi,fin_text-unplab
 add ebx,18
 int 0x40

 pusha

 mov eax,8            ; Buttons
 mov ebx,222*65536+10
 mov ecx,6*65536+10
 mov edx,1
 mov esi,0x555555
 int 0x40

 mov ebx,15*65536+100
 mov ecx,70*65536+13
 inc edx
 int 0x40

 inc edx
 add ebx,110*65536
 int 0x40

 inc edx
 mov ebx,214*65536+11
 mov ecx,33*65536+11
 int 0x40

 inc edx
 add ecx,18*65536
 int 0x40

 inc edx
 mov ebx,15*65536+100
 mov ecx,86*65536+13
 int 0x40

 inc edx
 add ebx,110*65536
 int 0x40

 popa

 mov ecx,0x00FFFFFF
 mov edx,keylab
 mov esi,dellab-keylab
 add ebx,19
 int 0x40

 mov edx,dellab
 mov esi,title-dellab
 add ebx,16
 int 0x40

 call draw_info

 mov eax,12          ; Finish redrawing
 mov ebx,2
 int 0x40

 ret

 draw_info:          ; Draw filenames and compressor state

 activecolor equ 0x00112299

 pusha ; Save registers

 mov eax,13               ; Clean draw area
 mov ebx,127*65536+85
 mov ecx,33*65536+33
 mov edx,0x00AAAAAA
 int 0x40

 mov eax,4 ; Draw filenames
 mov ebx,134*65536+36
 mov edx,cmfile
 xor ecx,ecx
 mov esi,12
 cmp byte [editstate],1
 jnz no_active_1
 mov ecx,activecolor
 no_active_1:
 int 0x40
 xor ecx,ecx
 cmp byte [editstate],2
 jnz no_active_2
 mov ecx,activecolor
 no_active_2:
 add ebx,18
 add edx,12
 int 0x40

 mov eax,13             ; Clean info area
 mov ebx,14*65536+210
 mov ecx,107*65536+14
 mov edx,0x00AAAAAA
 int 0x40

 cmp byte [msgid],0     ; Draw info string
 jz notype
 mov ebx,16*65536+110
 xor ecx,ecx
 mov esi,16
 mov al, byte [msgid]
 dec al
 shl al,4
 xor ah,ah
 xor edx,edx
 mov dx,ax
 add edx,msgtable
 mov eax,4
 int 0x40
 notype:

 popa ; Restore registers

 ret

 ; interface data

 keylab db "    COMPRESS         DECOMPRESS"
 dellab db "   DELETE I/O       DELETE *.MHC"
 title  db "MHC 0.09"
 arclab db "COMPRESSED FILE:"
 unplab db "INPUT/OUTPUT FILE:"
 fin_text:

 cmfile db "FILENAME.MHC"
 iofile db "FILENAME.XYZ"

 editstate db 0
 editpos db 0
 msgid db 0

 msgtable:
 db "COMPRESSING...  "
 db "DECOMPRESSING..."
 db "I/O NOT FOUND!  "
 db "*.MHC NOT FOUND!"
 db "INVALID METHOD! "

; ======== compression/decompression engine ========

; Adresses declaration

 hashtable equ  MHC_END
 ifile     equ  hashtable+65536*4
 ofile     equ  ifile+1000000

 compress:   ; File compression

 call fill_filebufs

 mov eax,6
 mov ebx,iofile
 xor ecx,ecx
 mov edx,ecx
 not edx
 mov esi,ifile
 int 0x40

 cmp eax,0xFFFFFFFF
 jnz  compress_filefound              ; i/o file not found
 mov byte [msgid],3
 call draw_info
 ret

 compress_filefound:

 mov byte [msgid],1
 call draw_info

 jmp lzp_compress                    ; compress with order-2 LZP
 compress_dumpdata:

 push edx

 mov eax,32
 mov ebx,cmfile
 int 0x40

 mov eax,33
 pop edx
 mov ebx,cmfile
 mov ecx,ofile
 xor esi,esi
 int 0x40

 mov byte [msgid],0
 call draw_info

 ret


 decompress: ; File decompression

 call fill_filebufs

 mov  eax,6
 mov ebx,cmfile
 xor ecx,ecx
 mov edx,ecx
 not edx
 mov esi,ofile
 int 0x40

 cmp eax,0xFFFFFFFF
 jnz  decompress_filefound              ; *.mhc file not found
 mov byte [msgid],4
 call draw_info
 ret

 decompress_filefound:

 cmp byte [ofile],0                     ; Invalid method!
 jz  right_method
 mov byte [msgid],5
 call draw_info
 ret

 right_method:
 mov byte [msgid],2
 call draw_info

 jmp lzp_decompress
 decompress_dumpdata:

 push edx

 mov eax,32
 mov ebx,iofile
 int 0x40

 mov eax,33
 pop edx
 mov ebx,iofile
 mov ecx,ifile
 xor esi,esi
 int 0x40

 mov byte [msgid],0
 call draw_info

 ret

 fill_filebufs:             ; Fill filebufs with garbage to simplify matching
 pusha
 cld
 mov eax,0xF7D9A03F         ; <- "magic number" :) just garbage...
 mov ecx,2000000/4
 mov edi,ifile
 rep stosd
 popa
 ret

; ==== algorithms section ====

; Method 0: LZP compression algorithm

 lzp_compress:           ; EDX - how much bytes to dump

 cld                     ; clear direction flag

 mov esi,ifile           ; init pointers
 mov edi,ofile

 push eax                ; write header: ID0+4bfilesize => total 5 bytes
 xor eax,eax
 stosb
 pop eax
 stosd

 pusha                   ; fill hash table
 mov eax,ifile
 mov edi,hashtable
 mov ecx,65536
 rep stosd
 popa

 add eax,esi              ; calculate endpointer
 mov dword [endpointer],eax

 movsw                    ; copy three bytes
 movsb

 mov dword [controlp],edi
 inc edi

 mov byte [controld],0
 mov byte [controlb],0

 c_loop:
 cmp dword [endpointer],esi  ; check end of file
 ja  c_loop_ok
 jmp finish_c_loop
 c_loop_ok:

 call chash
 call compare
 jz   two_match_c

 lodsb
 mov byte [literal],al
 call chash
 call compare
 jz   lit_match_c

 mov  al,0
 call putbit
 mov  al,byte [literal]
 stosb
 movsb
 jmp  end_c_loop

 lit_match_c:
 mov al,1
 call putbit
 mov al,0
 call putbit
 mov al,byte [literal]
 stosb
 jmp encode_match

 two_match_c:
 mov al,1
 call putbit
 call putbit

 encode_match:
 call incpos
 call compare
 jz one_c
 mov al,0
 call putbit
 jmp end_c_loop
 one_c:

 call incpos
 mov  al,1
 call putbit

 call compare
 jnz ec1
 call incpos
 call compare
 jnz ec2
 call incpos
 call compare
 jnz ec3
 call incpos
 mov al,1
 call putbit
 call putbit
 call compare
 jnz ec4
 call incpos
 call compare
 jnz ec5
 call incpos
 call compare
 jnz ec6
 call incpos
 call compare
 jnz ec7
 call incpos
 call compare
 jnz ec8
 call incpos
 call compare
 jnz ec9
 call incpos
 call compare
 jnz ec10
 call incpos

 mov al,1
 call putbit
 call putbit
 call putbit
 xor  ecx,ecx

 match_loop_c:
 cmp  esi,dword [endpointer]
 jae   out_match_loop_c
 call compare
 jnz  out_match_loop_c
 inc  ecx
 call incpos
 jmp  match_loop_c
 out_match_loop_c:

 mov al,0xFF
 out_lg:
 cmp ecx,255
 jb  out_lg_out
 stosb
 sub ecx,255
 jmp out_lg
 out_lg_out:
 mov al,cl
 stosb
 jmp end_c_loop

 ec10:
 mov al,1
 call putbit
 call putbit
 mov al,0
 call putbit
 jmp end_c_loop

 ec9:
 mov al,1
 call putbit
 mov al,0
 call putbit
 mov al,1
 call putbit
 jmp end_c_loop

 ec8:
 mov al,1
 call putbit
 mov al,0
 call putbit
 call putbit
 jmp end_c_loop

 ec7:
 mov al,0
 call putbit
 mov al,1
 call putbit
 call putbit
 jmp end_c_loop

 ec6:
 mov al,0
 call putbit
 mov al,1
 call putbit
 mov al,0
 call putbit
 jmp end_c_loop

 ec5:
 mov al,0
 call putbit
 call putbit
 mov al,1
 call putbit
 jmp end_c_loop

 ec4:
 mov al,0
 call putbit
 call putbit
 call putbit
 jmp end_c_loop

 ec3:
 mov al,1
 call putbit
 mov al,0
 call putbit
 jmp end_c_loop

 ec2:
 mov al,0
 call putbit
 mov al,1
 call putbit
 jmp end_c_loop

 ec1:
 mov al,0
 call putbit
 call putbit

 end_c_loop:
 jmp c_loop

 finish_c_loop:

 mov eax,dword [controlp] ; store last tagbyte
 mov bl,byte [controld]
 mov [eax], byte bl

 sub edi,ofile ; calculate dump size
 mov edx,edi

 jmp compress_dumpdata

; LZP decompression algorithm

 lzp_decompress:                        ; EDX - how much bytes to dump

 cld

 mov edi,ifile
 mov esi,ofile+1

 pusha                   ; fill hash table
 mov eax,ifile
 mov edi,hashtable
 mov ecx,65536
 rep stosd
 popa

 lodsd

 mov ebx,edi
 add ebx,eax
 mov dword [endpointer],ebx

 movsw
 movsb

 lodsb
 mov byte [controld],al
 mov byte [controlb],0

 d_loop:
 cmp dword [endpointer],edi
 ja d_loop_ok
 jmp finish_d_loop
 d_loop_ok:

 call getbit
 cmp  al,0
 jnz  match_d
 call dhash
 movsb
 call dhash
 movsb
 jmp end_d_loop

 match_d:

 call getbit
 cmp  al,0
 jnz  no_literal_before_match
 call dhash
 movsb
 no_literal_before_match:

 call dhash
 mov ecx,1
 call copymatch

 call getbit
 cmp  al,0
 jz   end_d_loop
 mov  ecx,1
 call copymatch
 call getbit
 cmp  al,0
 jz   dc2
 mov  ecx,2
 call copymatch
 call getbit
 cmp  al,0
 jz   end_d_loop
 mov  ecx,1
 call copymatch
 call getbit
 cmp  al,0
 jz   dc4
 mov  ecx,4
 call copymatch
 call getbit
 cmp  al,0
 jz   dc5
 call getbit
 cmp  al,0
 jz   dc6
 mov  ecx,3
 call copymatch

 do:
 lodsb
 xor  ecx,ecx
 mov  cl,al
 call copymatch
 cmp  al,0xFF
 jnz  end_do
 jmp do
 end_do:
 jmp end_d_loop

 dc6:
 mov ecx,2
 call copymatch
 jmp  end_d_loop

 dc5:
 call getbit
 cmp  al,0
 jz   ndc5
 mov  ecx,1
 call copymatch
 ndc5:
 jmp  end_d_loop

 dc4:
 call getbit
 cmp  al,0
 jz   ndc4
 call getbit
 mov  ecx,3
 cmp  al,1
 jz   ndcc4
 dec  ecx
 ndcc4:
 call copymatch
 jmp  end_d_loop
 ndc4:
 call getbit
 cmp  al,0
 jz   ndccc4
 mov  ecx,1
 call copymatch
 ndccc4:
 jmp  end_d_loop

 dc2:
 call getbit
 cmp al,0
 jz  ndc2
 mov ecx,1
 call copymatch
 ndc2:

 end_d_loop:
 jmp d_loop
 finish_d_loop:

 mov edx, dword [ofile+1]

 jmp decompress_dumpdata

; LZP subroutines

 putbit:                  ; bit -> byte tag, AL holds bit for output
 pusha
 mov cl,byte [controlb]
 shl al,cl
 mov bl,byte [controld]
 or  bl,al
 mov byte [controld],bl
 inc cl
 cmp cl,8
 jnz just_increment
 mov byte [controlb],0
 mov byte [controld],0
 push edi
 mov  edi, dword [controlp]
 mov  al,bl
 stosb
 pop  edi
 mov dword [controlp],edi
 popa
 inc edi
 ret
 just_increment:
 mov byte [controlb],cl
 popa
 ret

 getbit:                       ; tag byte -> bit, AL holds input
 push ecx
 mov al,byte [controld]
 mov cl,byte [controlb]
 shr al,cl
 and al,1
 inc cl
 cmp cl,8
 jnz just_increment_d
 mov byte [controlb],0
 push eax
 lodsb
 mov byte [controld],al
 pop  eax
 pop  ecx
 ret
 just_increment_d:
 mov byte [controlb],cl
 pop ecx
 ret

 chash:                        ; calculate hash -> mp -> fill position
 pusha
 xor  eax,eax
 mov  al, byte [esi-1]
 mov  ah, byte [esi-2]
 shl  eax,2
 add  eax,hashtable
 mov  edx,dword [eax]
 mov  dword [mp],edx
 mov  dword [eax],esi
 popa
 ret

 dhash:                        ; calculate hash -> mp -> fill position
 pusha
 xor  eax,eax
 mov  al, byte [edi-1]
 mov  ah, byte [edi-2]
 shl  eax,2
 add  eax,hashtable
 mov  edx,dword [eax]
 mov  dword [mp],edx
 mov  dword [eax],edi
 popa
 ret

 copymatch:                    ; ECX bytes from [mp] to [rp]
 push esi
 mov  esi,dword [mp]
 rep  movsb
 mov  dword [mp],esi
 pop  esi
 ret

 compare:                      ; compare [mp] with [cpos]
 push edi
 push esi
 mov  edi,dword [mp]
 cmpsb
 pop  esi
 pop  edi
 ret

 incpos:
 inc  dword [mp]
 inc  esi
 ret


; LZP algorithm data

 endpointer     dd      0
 controlp       dd      0
 controlb       db      0
 controld       db      0
 mp  dd 0
 literal        db      0

MHC_END: ; the end... - Nikita Lesnikov (nlo_one)