Subversion Repositories Kolibri OS

Rev

Rev 6855 | Rev 6870 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 6855 Rev 6860
Line 1... Line 1...
1 
; trees.asm -- output deflated data using Huffman coding
 1 
; trees.asm -- output deflated data using Huffman coding
2 
; Copyright (C) 1995-2012 Jean-loup Gailly
 2 
; Copyright (C) 1995-2012 Jean-loup Gailly
3 
; detect_data_type() function provided freely by Cosmin Truta, 2006
 3 
; detect_data_type() function provided freely by Cosmin Truta, 2006
4 
; For conditions of distribution and use, see copyright notice in zlib.h
 4 
; For conditions of distribution and use, see copyright notice in zlib.inc
Line 5... Line 5...
5 
 
 5 
 
Line 6... Line 6...
6 
;  ALGORITHM
 6 
;  ALGORITHM
7 
 
 7 
 
Line 105... Line 105...
105 
 
 105 
 
106 
else
 106 
else
107 
include 'trees.inc'
 107 
include 'trees.inc'
Line 108... Line 108...
108 
end if ;GEN_TREES_H
 108 
end if ;GEN_TREES_H
109 
 
 109 
 
110 
struct static_tree_desc ;_s
 110 
struct static_tree_desc
111 
	static_tree dd ? ;const ct_data * ;static tree or NULL
 111 
	static_tree dd ? ;const ct_data * ;static tree or NULL
112 
	extra_bits  dd ? ;const intf * ;extra bits for each code or NULL
 112 
	extra_bits  dd ? ;const intf * ;extra bits for each code or NULL
113 
	extra_base  dd ? ;int ;base index for extra_bits
 113 
	extra_base  dd ? ;int ;base index for extra_bits
Line 322... Line 322...
322 
end if ;(GEN_TREES_H) | !(STDC)
 322 
end if ;(GEN_TREES_H) | !(STDC)
323 
	ret
 323 
	ret
324 
endp
 324 
endp
Line 325... Line 325...
325 
 
 325 
 
326 
; ===========================================================================
 326 
; ===========================================================================
Line 327... Line 327...
327 
; Genererate the file trees.h describing the static trees.
 327 
; Genererate the file trees.inc describing the static trees.
328 
 
 328 
 
329 
;#  define SEPARATOR(i, last, width) \
 329 
;#  define SEPARATOR(i, last, width) \
Line 489... Line 489...
489 
	add eax,tree
 489 
	add eax,tree
490 
	mov ax,word[eax+Freq]
 490 
	mov ax,word[eax+Freq]
491 
	mov ebx,m
 491 
	mov ebx,m
492 
	imul ebx,sizeof.ct_data
 492 
	imul ebx,sizeof.ct_data
493 
	add ebx,tree
 493 
	add ebx,tree
494 
	mov bx,word[ebx+Freq]
 494 
	cmp ax,word[ebx+Freq]
495 
	cmp ax,bx
 - 
 
496 
	jl .end0
 495 
	jl .end0
497 
	jne m_end
 496 
	jne m_end
498 
	mov eax,n
 497 
	mov eax,n
499 
	mov al,byte[eax+depth]
 498 
	mov al,byte[eax+depth]
500 
	mov ebx,m
 499 
	mov ebx,m
Line 526... Line 525...
526 
		cmp esi,[edi+deflate_state.heap_len]
 525 
		cmp esi,[edi+deflate_state.heap_len]
527 
		jg .cycle0end
 526 
		jg .cycle0end
528 
		; Set j to the smallest of the two sons:
 527 
		; Set j to the smallest of the two sons:
529 
		;;cmp esi,[edi+deflate_state.heap_len]
 528 
		;;cmp esi,[edi+deflate_state.heap_len]
530 
		jge .end1 ;if (..<.. &&
 529 
		jge .end1 ;if (..<.. &&
531 
		mov edx,esi
 - 
 
532 
		shl edx,2
 - 
 
533 
		add edx,edi
 - 
 
534 
		add edx,deflate_state.heap
 530 
		lea edx,[edi+4*esi+deflate_state.heap]
535 
		smaller [tree], dword[edx+4], dword[edx], edi+deflate_state.depth, .end1
 531 
		smaller [tree], dword[edx+4], dword[edx], edi+deflate_state.depth, .end1
536 
			inc esi
 532 
			inc esi
537 
		.end1:
 533 
		.end1:
538 
		; Exit if v is smaller than both sons
 534 
		; Exit if v is smaller than both sons
539 
		mov edx,[edi+deflate_state.heap+4*esi]
 535 
		mov edx,[edi+deflate_state.heap+4*esi]
Line 635... Line 631...
635 
		mov edx,[tree]
 631 
		mov edx,[tree]
636 
		movzx eax,word[edx+sizeof.ct_data*ecx+Dad]
 632 
		movzx eax,word[edx+sizeof.ct_data*ecx+Dad]
637 
		movzx eax,word[edx+sizeof.ct_data*eax+Len]
 633 
		movzx eax,word[edx+sizeof.ct_data*eax+Len]
638 
		inc eax
 634 
		inc eax
639 
		mov [bits],eax ;bits = tree[tree[n].Dad].Len + 1
 635 
		mov [bits],eax ;bits = tree[tree[n].Dad].Len + 1
640 
		mov eax,[max_length]
 636 
		cmp eax,[max_length]
641 
		cmp [bits],eax
 - 
 
642 
		jle @f ;if (..>..)
 637 
		jle @f ;if (..>..)
- 
 
 638 
			mov eax,[max_length]
643 
			mov [bits],eax
 639 
			mov [bits],eax
644 
			inc dword[overflow]
 640 
			inc dword[overflow]
645 
		@@:
 641 
		@@:
646 
		mov eax,[bits]
 - 
 
647 
		mov [edx+sizeof.ct_data*ecx+Len],ax
 642 
		mov [edx+sizeof.ct_data*ecx+Len],ax
648 
		; We overwrite tree[n].Dad which is no longer needed
 643 
		; We overwrite tree[n].Dad which is no longer needed
Line 649... Line 644...
649 
 
 644 
 
650 
		cmp ecx,[max_code]
 645 
		cmp ecx,[max_code]
Line 666... Line 661...
666 
		mov esi,[bits]
 661 
		mov esi,[bits]
667 
		add esi,[xbits]
 662 
		add esi,[xbits]
668 
		imul eax,esi
 663 
		imul eax,esi
669 
		add [edi+deflate_state.opt_len],eax
 664 
		add [edi+deflate_state.opt_len],eax
670 
		cmp dword[stree],0
 665 
		cmp dword[stree],0
671 
		je @f ;if (..)
 666 
		jne .cycle1 ;if (..)
672 
			movzx eax,word[f]
 667 
			movzx eax,word[f]
673 
			mov esi,sizeof.ct_data
 - 
 
674 
			imul esi,ecx
 - 
 
675 
			add esi,[stree]
 668 
			mov esi,[stree]
676 
			movzx esi,word[esi+Len]
 669 
			movzx esi,word[esi+sizeof.ct_data*ecx+Len]
677 
			add esi,[xbits]
 670 
			add esi,[xbits]
678 
			imul eax,esi
 671 
			imul eax,esi
679 
			add [edi+deflate_state.static_len],eax
 672 
			add [edi+deflate_state.static_len],eax
680 
		@@:
 - 
 
681 
		jmp .cycle1
 673 
		jmp .cycle1
682 
align 4
 674 
align 4
683 
	.cycle1end:
 675 
	.cycle1end:
684 
	cmp dword[overflow],0
 676 
	cmp dword[overflow],0
685 
	je .end_f ;if (..==0) return
 677 
	je .end_f ;if (..==0) return
Line 734... Line 726...
734 
			mov eax,[edi+4*eax+deflate_state.heap]
 726 
			mov eax,[edi+4*eax+deflate_state.heap]
735 
			mov [m],eax ;m = s.heap[--h]
 727 
			mov [m],eax ;m = s.heap[--h]
736 
			cmp eax,[max_code]
 728 
			cmp eax,[max_code]
737 
			jg .cycle4 ;if (..>..) continue
 729 
			jg .cycle4 ;if (..>..) continue
738 
			mov esi,[m]
 730 
			mov esi,[m]
- 
 
 731 
			imul esi,sizeof.ct_data
- 
 
 732 
			add esi,edx ;esi = &tree[m]
739 
			mov eax,[bits]
 733 
			mov eax,[bits]
740 
			cmp word[edx+sizeof.ct_data*esi+Len],ax
 734 
			cmp word[esi+Len],ax
741 
			je @f ;if (..!=..)
 735 
			je @f ;if (..!=..)
742 
;                Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
 736 
;                Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
743 
				movzx ebx,word[esi+Len]
 737 
				movzx ebx,word[esi+Len]
744 
				sub eax,ebx
 738 
				sub eax,ebx
745 
				movzx ebx,word[esi+Freq]
 739 
				movzx ebx,word[esi+Freq]
Line 972... Line 966...
972 
		; Create a new node father of n and m
 966 
		; Create a new node father of n and m
973 
		;;mov edx,[m]
 967 
		;;mov edx,[m]
974 
		imul edx,sizeof.ct_data
 968 
		imul edx,sizeof.ct_data
975 
		add edx,[tree]
 969 
		add edx,[tree]
976 
		mov ax,word[edx+Freq]
 970 
		mov ax,word[edx+Freq]
977 
		mov edx,ecx
 - 
 
978 
		imul edx,sizeof.ct_data
 - 
 
979 
		add edx,[tree]
 971 
		mov edx,[tree]
980 
		add ax,word[edx+Freq]
 972 
		add ax,word[edx+sizeof.ct_data*ecx+Freq]
981 
		mov edx,[node]
 973 
		mov edx,[node]
982 
		imul edx,sizeof.ct_data
 974 
		imul edx,sizeof.ct_data
983 
		add edx,[tree]
 975 
		add edx,[tree]
984 
		mov word[edx+Freq],ax
 976 
		mov word[edx+Freq],ax