bufer_size=1024*16+2
fichero=4
mcu_ptr=8
color_ptr=12
estado=16
color_c=17
nbits=color_c
idct=20
tmp_bits=24
actable=28
matriz_limit=32
sourcebits=36
sourcebits_index=40
sourcebits_limit=44
qt_ptrs=48
ht_dc_ptrs=64
ht_ac_ptrs=80
matrices=96
tmp_bufer=100
x_org=104
y_org=108
x_mcu=112
y_mcu=116
x_size=120
y_size=124
x_org2=128
y_org2=132
x_mcu2=136
y_mcu2=140
x_size2=144
y_size2=148
q_ptr=152
dc=164
position=204
draw_ptr=208
struct_size=212
saveDX	dd 0  ;ccc

jpeg_info:  ; eax = File
	    ; ebp = Returns
	xor ebp,ebp
	pushad
	mov ebp,esp
	mov ecx,6
	sub esp,ecx
	mov edi,esp
	call read
	pop dx
	cmp dx,0d8ffh
	je .l1
	mov esp,ebp
	popad
	mov [saveDX],0xfffffff
	ret
   .l1: push eax
	mov ecx,struct_size
	call mallocz
	mov [edi],ebp
	mov ebp,edi
	pop dword [ebp+fichero]
	pop ax
	pop cx
	jmp .l3
   .l2: mov ebx,[ebp+tmp_bufer]
	add ebx,[ebx-4]
	mov cx,[ebx-2]
	mov ax,[ebx-4]
   .l3: push .l2
	xchg cl,ch
	add cx,2
	cmp ch,3
	jnc .l4
	cmp al,0ffh
	jne eoi
	cmp ah,0dbh
	je dqt
	cmp ah,0c4h
	je dht
	cmp ah,0c0h
	je sof0
	cmp ah,0dah
	je sos
	cmp ah,0c2h
	je eoi
	cmp ah,0c9h
	je eoi
	cmp ah,0d9h
	je eoi
   .l4: lea edx,[ecx-4]
	xor ecx,ecx
	mov eax,[ebp+fichero]
	call skip
	mov ecx,4
	call READ
	cmp ecx,[edi-4]
	jne eoi
	ret

eoi:
      mov esp,[ebp]
      call jpeg_close
      popad
      ret

jpeg_close:
      test ebp,ebp
      jz .l2
      pushad
      mov eax,[ebp+fichero]
      call close
      mov edi,[ebp+sourcebits]
      call free
      lea esi,[ebp+qt_ptrs]
      mov ecx,14
 .l1: mov edi,[esi]
      add esi,4
      call free
      loop .l1
      mov edi,ebp
      call free
      popad
 .l2: ret

dqt:  call READ
      mov esi,edi
      lea eax,[edi+ecx]
      push eax
 .l1: xor eax,eax
      lodsb
      cmp al,4
      jnc eoi
      lea ebx,[ebp+qt_ptrs+eax*4]
      test dword [ebx],-1
      jnz eoi
      mov ecx,64
      xor eax,eax
      sub esp,128
      mov edi,esp
 .l2: lodsb
      stosw
      loop .l2
      mov ecx,256
      call malloc
      mov [ebx],edi
      mov eax,esi
      mov esi,esp
      pushad
      mov ebp,zigzag
      fninit
      mov cl,64
      xor eax,eax
  .l3: fild word[esi]
      mov al,[ebp]
      and al,-2
      add ebp,2
      add esi,2
      mov ebx,eax
      and ebx,28
      fmul dword [ebx+k2]
      mov ebx,eax
      shr ebx,3
      and ebx,4+8+16
      fmul dword [ebx+k2]
      fstp dword [edi+eax]
      dec cl
      jnz .l3
      popad
      mov esi,eax
      add esp,128
      mov eax,[esp]
      sub eax,esi
      jc eoi
      cmp eax,4
      ja .l1
      jne eoi
      pop eax
      ret

sof0:  call READ
       cmp byte [edi],8
       jne eoi	;precision
       mov ax,[edi+1]
       xchg al,ah
;;;;;;;;;;;;;;;;;;;;;;;;;      This because the Y size needs to div by 16, We may need to do it to the X
       mov  word[YsizeImage],ax
       test ax,1111b
       jz  DevideOK
       shr  ax,4
       inc  ax
       shl  ax,4
DevideOK:
;;;;;;;;;;;;;;;;;;;;;;;;;
       mov [ebp+y_size],ax
       mov ax,[edi+3]
       xchg al,ah
       mov [ebp+x_size],ax
       mov al,[edi+5] ;ncomponentes
       mov cl,al
       mov [ebp+color_c],al
       mov edx,modes
       dec al
       jz .l1
       dec al
       dec al
       jnz eoi
       mov al,[edi+10]
       mov ah,[edi+13]
       cmp ax,1111h
       jne eoi
       mov al,[edi+7]
       add edx,16
       cmp al,11h
       je .l1
       add edx,16
       cmp al,21h
       je .l1
       add edx,16
       cmp al,22h
       jne eoi
  .l1: lea ebx,[ebp+q_ptr]
       lea esi,[ebp+qt_ptrs]
       mov [ebp+mcu_ptr],edx
  .l2: movzx eax,byte [edi+8]
       add edi,3
       cmp al,4
       jnc eoi
       lea eax,[eax*4+esi]
       mov [ebx],eax
       add ebx,16
       dec cl
       jnz .l2
       ret

READ:  mov eax,[ebp+fichero]
       mov edi,[ebp+tmp_bufer]
       movzx ecx,cx
       call mresize
       mov [ebp+tmp_bufer],edi
       jmp read

dht:	call READ
	mov esi,edi
	lea eax,[edi+ecx]
	push eax
   .l1: lodsb
	mov edi,esi
	mov ebx,3+16
	and bl,al
	cmp bl,al
	jne eoi
	shr bl,2
	and al,3
	or bl,al
	lea ebx,[ebp+ht_dc_ptrs+ebx*4]
	test dword [ebx],-1
	jnz eoi
	mov cl,15
	mov al,[edi]
   .l2: inc edi  ;calcular numero de codigos
	add al,[edi]
	jc eoi
	dec cl
	jnz .l2
	movzx ecx,al
	lea ecx,[ecx*4+2]
	call malloc
	mov [ebx],edi
	call arbol_hf
	mov eax,[esp]
	sub eax,ebx
	jc eoi
	mov esi,ebx
	cmp eax,4
	ja .l1
	jne eoi
	pop eax
	ret

arbol_hf:   ;esi= ht edi= Memory for the tree
	    ;Returns in ebx  The end of ht
	    ;codigos: bits 0-3=Nbits the following number
	    ;         bits 4-7=Number of zeros
	    ;         bits 8-14=Length of this code or error if =127
	    ;         bit 15=Code / pointer
	push ebp
	lea ebx,[edi-2]
	add ebx,[ebx-2]
	mov word [ebx],-1 ;Error code if found
	push ebx
	push esi
	lea ebx,[esi+16]
	mov ebp,esp
	xor ecx,ecx
	push edi
	push ecx
	add edi,2
	mov dx,1
	add dh,[esi]
	jz .l3
	jmp .l2
  .l1:	push edi
	push ecx
	add edi,2
  .l2:	inc cl
	cmp cl,dl
	jc .l1
	mov al,[ebx]
	inc ebx
	mov ah,128 ;Mark code
	or ah,dl
	cmp edi,[ebp+4]
	jnc .l5
	stosw
	cmp esp,ebp
	jnc .l5
	pop ecx
	pop esi
	lea eax,[edi-2]
	sub eax,esi
	mov [esi],ax
	dec dh
	jnz .l2 ;ncodigos
	mov esi,[ebp]
   .l3: inc esi
	inc dl
	cmp dl,17
	jnc .l4
	add dh,[esi]
	jz .l3
	mov [ebp],esi
	jmp .l2
   .l4: lea esp,[ebp+8]
	pop ebp
	ret
   .l5: mov ebp,[ebp+8]
	jmp eoi

sos:   sub ecx,4  ;Below are data Image
       call READ
       mov eax,[ebp+fichero]
       call ftell
       mov [ebp+position],edx
       mov esi,edi
       lea edi,[ebp+q_ptr]
       lodsb ;Number of components
       sub [ebp+color_c],al
       jnz eoi
       mov dh,al
  .l1: mov ebx,[edi]
       mov eax,[ebx]
       stosd
       lodsw
       mov cl,ah
       and eax,0f00h
       and ecx,0f0h
       shr eax,6
       shr ecx,2
       lea ebx,[ebp+ht_ac_ptrs+eax]
       mov eax,[ebx]
       lea ebx,[ebp+ht_dc_ptrs+ecx]
       mov ecx,[ebx]
       test eax,eax
       jz eoi
       test ecx,ecx
       jz eoi
       stosd
       mov eax,ecx
       stosd
       add edi,4
       dec dh
       jnz .l1
       mov edx,[ebp+mcu_ptr]
       cmp edx,modes
       jne .l2
       lea esi,[ebp+q_ptr]
       lea edi,[ebp+q_ptr+32]
       movsd
       movsd
       movsd
   .l2:
       mov esi,edx
       push dword [esi]
       pop dword [ebp+mcu_ptr]
       push dword [esi+4]
       pop dword[ebp+color_ptr]
       push dword [esi+12]
       pop dword [ebp+y_mcu]
       push dword [esi+8]
       pop dword [ebp+x_mcu]
       mov ecx,64*18
       call malloc
       mov [ebp+matrices],edi
       mov ecx,bufer_size
       call malloc
       mov [ebp+sourcebits],edi
       mov esp,[ebp]
       mov [esp+8],ebp
       popad
       ret

jpeg_display:
       test ebp,ebp
       jnz .inicio ;Start
       ret
      .inicio:
       pushad
       mov [ebp],esp
       mov eax,[ebp+fichero]
       mov edx,[ebp+position]
       call lseek
       mov edi,[ebp+sourcebits]
       add edi,bufer_size
       mov [ebp+sourcebits_index],edi
       sub edi,2
       mov [ebp+sourcebits_limit],edi
       mov edi,[ebp+matrices]
       mov [ebp+matriz_limit],edi
       xor eax,eax
       mov [esp+8],eax
       mov [ebp+estado],eax
       mov [ebp+tmp_bits],eax
       mov [ebp+dc],eax
       mov [ebp+dc+16],eax
       mov [ebp+dc+32],eax

       mov eax,[ebp+y_mcu]
       mov ecx,[ebp+y_org]
       sub ecx,eax
       mov [ebp+y_org2],ecx
       mov [ebp+y_mcu2],eax
       push dword [ebp+y_size]
       pop dword [ebp+y_size2]
  .l3: push dword [ebp+x_org]
       pop dword [ebp+x_org2]
       push dword [ebp+x_mcu]
       pop dword [ebp+x_mcu2]
       push dword [ebp+x_size]
       pop dword [ebp+x_size2]
       mov eax,[ebp+y_mcu2]
       add [ebp+y_org2],eax
       sub [ebp+y_size2],eax
       jnc .l4
       add eax,[ebp+y_size2]
       jnz .cont
       mov [esp+8],ebp
       popad
       ret
     .cont:
       mov dword [ebp+y_size2],0
       mov [ebp+y_mcu2],eax
      .l4:
	mov eax,[ebp+x_mcu2]
	sub [ebp+x_size2],eax
	jnc .l5
	add eax,[ebp+x_size2]
	jz .l3
	mov dword [ebp+x_size2],0
	mov [ebp+x_mcu2],eax
	call dword [ebp+mcu_ptr]
	mov eax,[ebp+x_mcu]
	mov ecx,[ebp+x_mcu2]
	mov edx,[ebp+y_mcu2]
	call recortar
	jmp .l6
      .l5:
	call dword [ebp+mcu_ptr]
	mov ecx,[ebp+x_mcu2]
	mov edx,[ebp+y_mcu2]
      .l6:
	mov eax,[ebp+x_org2]
	mov ebx,[ebp+y_org2]
	call  put_image 		    ;[ebp+draw_ptr]
	add [ebp+x_org2],ecx
	mov ax,[ebp+estado]
	test al,15
	jz .l4
	cmp ah,8
	jnc .l4
	xor edx,edx
	mov [ebp+tmp_bits],edx
	mov [ebp+dc],edx
	mov [ebp+dc+16],edx
	mov [ebp+dc+32],edx
	add dword [ebp+sourcebits_index],2
	and word [ebp+estado],0c0h
	test al,32
	jz .l4
	jmp .l3

color100:
	push edi
    .l1: lodsw
	mov dl,ah
	mov ah,al
	stosw
	mov ah,dl
	stosb
	mov al,dl
	stosb
	stosw
	dec cl
	jnz .l1
	pop edi
	ret

color111:
	push edi
   .l1: lodsw
	mov bx,[esi+62]
	mov dx,[esi+126]
	xchg ah,bh
	xchg ah,dl
	xchg ah,bl
	stosw
	mov ax,bx
	stosw
	mov ax,dx
	stosw
	dec cl
	jnz .l1
	pop edi
	mov ecx,64*3
	jmp ybr_bgr

color411:
	push ebp
	push edi
	lea ebp,[esi+ecx*8]
     .l1: push ecx
	mov ax,[esi]
	mov cx,[ebp]
	mov dx,[ebp+64]
	add ebp,2
	xchg ch,dl
	mov bx,ax
	mov ah,cl
	mov bl,ch
	mov [edi],ax
	mov [edi+2],bx
	mov [edi+4],cx
	mov ax,[esi+8]
	mov bh,ah
	mov ah,cl
	mov [edi+48],ax
	mov [edi+48+2],bx
	mov [edi+48+4],cx
	mov ax,[esi+2]
	mov bx,ax
	mov ah,dl
	mov bl,dh
	mov [edi+6],ax
	mov [edi+2+6],bx
	mov [edi+4+6],dx
	mov ax,[esi+8+2]
	mov bh,ah
	mov ah,dl
	mov [edi+48+6],ax
	mov [edi+48+2+6],bx
	mov [edi+48+4+6],dx
	pop ecx
	add edi,12
	dec ecx
	add esi,4
	test cl,1
	jnz .l1
	add esi,64-8
	test cl,2
	jnz .l1
	sub esi,128-16
	add edi,48
	test cl,15
	jnz .l1
	add esi,64
	test cl,cl
	jnz .l1
	pop edi
	pop ebp
	mov ecx,64*4*3
	jmp ybr_bgr

color211:
	push ebp
	push edi
	lea ebp,[esi+ecx*4]
    .l1: push ecx
	mov ax,[esi]
	mov cx,[ebp]
	mov dx,[ebp+64]
	add ebp,2
	xchg ch,dl
	mov bx,ax
	mov ah,cl
	mov bl,ch
	mov [edi],ax
	mov [edi+2],bx
	mov [edi+4],cx
	mov ax,[esi+2]
	mov bx,ax
	mov ah,dl
	mov bl,dh
	mov [edi+6],ax
	mov [edi+2+6],bx
	mov [edi+4+6],dx
	pop ecx
	add edi,12
	dec cl
	add esi,4
	test cl,1
	jnz .l1
	add esi,64-8
	test cl,2
	jnz .l1
	sub esi,128-8
	test cl,cl
	jnz .l1
	pop edi
	pop ebp
	mov ecx,64*3*2
	jmp ybr_bgr


mcu411: lea ebx,[ebp+q_ptr]
	call hufdecode
	lea ebx,[ebp+q_ptr]
	call hufdecode
mcu211: lea ebx,[ebp+q_ptr]
	call hufdecode
mcu111: lea ebx,[ebp+q_ptr]
	call hufdecode
	lea ebx,[ebp+q_ptr+16]
	call hufdecode
mcu100: lea ebx,[ebp+q_ptr+32]
	call hufdecode
	mov esi,[ebp+matrices]
	mov dword [ebp+matriz_limit],esi
	mov ecx,32
	lea edi,[esi+64*6]
	jmp dword [ebp+color_ptr]

cargar_bits: ;edx=bits,cl=nbits,
	     ;bp=data struct
	     ;cr: cl,edx,eax,si
	     ;ncr bx,bp,di,ch

	mov esi,[ebp+sourcebits_index]
	cmp esi,[ebp+sourcebits_limit]
	jnc .l6
	movzx eax,byte [esi]
	inc esi
	add cl,8
	cmp al,-1
	je .l2
	mov ah,al
	lodsb
	add cl,8
	cmp al,-1
	je .l2
   .l1: ror eax,cl
	or edx,eax
	mov [ebp+sourcebits_index],esi
	ret
   .l2: lodsb
	test al,al
	jnz .l3
	mov al,-1
	call .l1
	cmp cl,16
	jc cargar_bits
	ret
   .l3: sub esi,2
	sub cl,8
	sub al,0d0h
	cmp al,8
	jc .l4
	sub al,9
	mov al,63
	jz .l4
	mov al,127
    .l4: inc al
	or [ebp+estado],al
	movzx eax,ah
	jmp .l1
    .l5: mov [ebp+sourcebits_limit],edi
	mov word [edi],0d9ffh
	popad
	jmp cargar_bits
   .l6: ;read file
	pushad
	mov ecx,bufer_size-2
	mov edx,[ebp+sourcebits_limit]
	mov edi,[ebp+sourcebits]
	mov ax,[edx]
	sub edx,edi
	stosw
	sub esi,edx
	mov [ebp+sourcebits_index],esi
	cmp edx,ecx
	jne .l5
	mov eax,[ebp+fichero]
	call read
	lea ecx,[edi+ecx-2]
	mov [ebp+sourcebits_limit],ecx
	popad
	jmp cargar_bits


hufdecode:  ;si->dctable [bp+20]->actable di->outbufer edx->bits cl->bits en edx
	    ;[bp+24]->sourcebits
	    ;[bp+22]=outbufer+128
	    ;[bx]       q ptr para aa&n
	    ;[bx+2]     a ptr
	    ;[bx+4]     d ptr
	    ;[bx+8]     dc componente
	fninit
	push dword [ebx]
	mov cl,[ebp+nbits]
	mov edx,[ebp+tmp_bits]
	cmp cl,16
	jnc .l1
	call cargar_bits
    .l1: mov eax,[ebx+4]
	mov esi,[ebx+8]
	mov [ebp+actable],eax
	movzx eax,word [esi]
	add esi,2
   .l2: add edx,edx
	jnc .l3
	add esi,eax
   .l3: lodsw
	test ax,ax
	jns .l2
	;codigo encontrado
	and ax,7f0fh
	mov edi,[ebp+matriz_limit] ;arrays
	sub cl,ah
	jns .l4
	fldz
   .error:
	xor ecx,ecx
	or byte [ebp+estado],32
	jmp .l12
   .l4: cmp cl,al
	jnc .l5
	push eax
	call cargar_bits
	pop eax
   .l5: sub cl,al
	mov ch,cl
	mov cl,al
	mov eax,edx
	shl edx,cl
	sar eax,17
	xor ax,8000h
	xor cl,15
	sar ax,cl
	mov cl,ch
	mov ch,2
	add ax,8000h ;incrementar si negativo
	adc ax,8000h
	add [ebx+12],ax
	fild word [ebx+12]
	push ecx
	mov ecx,64
	xor eax,eax
	add [ebp+matriz_limit],ecx
	rep stosd
	pop ecx
	sub edi,64*4
	mov ebx,[esp]
	fmul dword [ebx]
    .l6: cmp cl,16
	jnc .l7
	call cargar_bits
   .l7: mov esi,[ebp+actable]
	movzx eax,word[esi]
	add esi,2
   .l8: add edx,edx
	jnc .l9
	add esi,eax
   .l9: lodsw
	test ax,ax
	jns .l8
	;codigo encontrado
	and ah,127
	xor ebx,ebx
	sub cl,ah
	js .error
	or bl,al
	jz .l12
	and al,0f0h
	shr al,3
	add ch,al
	js .error
	and bl,0fh
	jz .l11
	cmp cl,bl
	jnc .l10
	call cargar_bits
    .l10: sub cl,bl
	xchg bl,cl
	mov eax,edx
	shl edx,cl
	sar eax,17
	xor cl,15
	xor ax,8000h
	sar ax,cl
	add ax,8000h ;incrementar si negativo
	adc ax,8000h
	mov cl,bl
	mov bl,ch
	mov [ebp+tmp_bits],ax
	mov ax,[ebx+zigzag]
	mov ebx,[esp]
	fild word [ebp+tmp_bits]
	or [ebp+idct],ax
	and eax,11111100b
	fmul dword [ebx+eax]
	fstp dword [edi+eax]
  .l11: add ch,2
	jns .l6
  .l12: mov [ebp+nbits],cl
	mov [ebp+tmp_bits],edx
	xor ebx,ebx
	add esp,4
	xchg ebx,[ebp+idct]
	cmp ch,2
	je idctf1
	fstp dword [edi]
	test bh,0feh
	jnz idctf3
idctf2a: test bh,1
	mov esi,edi
	jz .l1
	test bl,1
	jnz idctf3
	push idctf2b
	jmp idctf3b
   .l1: call idctf3a
	mov cl,4
	call limit
	mov eax,[edi-8]
	mov edx,[edi-4]
	mov cl,7
   .l2: mov [edi],eax
	mov [edi+4],edx
	add edi,8
	dec cl
	jnz .l2
	ret

idctf1: fistp word[edi+64]
	mov ax,128
	add ax,[edi+64]
	jz .l2
	test ah,ah
	jz .l1
	mov al,-1
	js .l2
   .l1: mov ah,al
	stosw
	stosw
	mov eax,[edi-4]
	mov ecx,15
	rep stosd
   .l2: ret

idctf3: mov bl,8
	mov esi,edi
    .l1: rcr bh,1
	jc .l3
	mov eax,[esi]
	test eax,eax
	jz .l4
	mov cl,7
    .l2: add esi,32
	mov [esi],eax
	dec cl
	jnz .l2
	sub esi,32*7-4
	dec bl
	jnz .l1
	jmp .l5
   .l3: call idctf3b
   .l4: add esi,4
	dec bl
	jnz .l1
   .l5: mov esi,edi
	mov cl,8
   .l6: call idctf3a
	add esi,32
	add edi,16
	dec cl
	jnz .l6
	sub edi,128
	mov esi,edi
	mov cl,32
limit:	mov dx,[esi]
	mov bx,[esi+2]
	add esi,4
	add dx,128
	add bx,128
	test dh,dh
	mov ax,dx
	jz .l1
	mov al,0
	js .l1
	mov al,-1
   .l1: test bh,bh
	mov ah,bl
	jz .l2
	mov ah,0
	js .l2
	mov ah,-1
   .l2: stosw
	dec cl
	jnz limit
	ret

idctf2b:
	mov dl,8
  .l1:	fld dword[esi]
	add esi,32
	mov ax,128
	fistp word [edi]
	add ax,[edi]
	test ah,ah
	jz .l2
	mov al,0
	js .l2
	mov al,-1
  .l2:	mov ah,al
	stosw
	stosw
	stosw
	stosw
	dec dl
	jnz .l1
	ret

idctf3a: ;si(d float),di(w int) ncr
fld dword[esi+1*4]	;f1                ;t21=f1+f7
fld st0
fld dword[esi+7*4]	    ;f7
fadd st2,st0
fsubp st1,st0	       ;t22=f1-f7
fld dword[esi+5*4]
fld st0 	  ;f5       ;t23=f5+f3
fld dword[esi+3*4]		     ;f3
fadd st2,st0
fsubp st1,st0	       ;t20=f5-f3
fld st0
fadd st0,st3		    ;t25=(t20+t22)*k2
fmul dword[k+4] 		;k2 ;t25,t20,t23,t22,t21
fld st4 			;t7=t21+t23
fadd st0,st3			    ;t7,t25,t20,t23,t22,t21
fld dword[k+12] 		;k4     ;t6=k4*t20+t25-t7
fmulp st3,st0
fsub st2,st0
fld st1
faddp st3,st0			;t7,t25,t6,t23,t22,t21
fld st5 			;t5=(t21-t23)*k1-t6
fsub st0,st4
fmul dword[k]	       ;k1
fsub st0,st3
fstp st6	       ;t7,t25,t6,t23,t22,t5
fstp st3			;t25,t6,t7,t22,t5
fxch st3
fmul dword[k+8]    ;k3      ;t4=k3*t22-t25+t5
fadd st0,st4			    ;t22*k3+t5,t6,t7,t25,t5
fsubrp st3,st0			;t6,t7,t4,t5
fld dword[esi]			     ;f0           ;t10=f0+f4
fst st5 			;f0,t4,t5,t6,t7,f0
fld dword[esi+4*4]		     ;f4
fsub st6,st0			;t11=f0-f4
faddp st1,st0
fld st0 	      ;t10,t10,t6,t7,t4,t5,t11
fld dword[esi+2*4]		     ;f2      ;t13=f2+f6
fadd dword[esi+6*4]		     ;f6      ;t13,t10,t10,t6,t7,t4,t5,t11
fadd st2,st0			;t13,t10,t0,t6,t7,t4,t5,t11 ;t0=t10+t13
fsubp st1,st0			   ;t3,t0,t6,t7,t4,t5,t11 ;t3=t10-t13
fld st0 			;p3=t3-t4
fsub st0,st5
fistp word [edi+3*2]	    ;p3
fadd st0,st4			    ;p4=t3+t4
fld dword[esi+2*4]		     ;f2
fstp st5
fistp word [edi+4*2]	    ;p4 ;t0,t6,t7,f2,t5,t11
fld st0 			;p0=t0+t7
fsub st0,st3
fistp word [edi+7*2]	    ;p7
fadd st0,st2			    ;p7=t0-t7
fistp word [edi]		     ;p0 ;t6,t7,f2,t5,t11
fld st2 			;f2  ;f2,t6,t7,f2,t5,t11  ;t12=(f2-f6)*k1-t13
fld dword[esi+6*4]		     ;f6
fadd st4,st0			;f6,f2,t6,t7,t13,t5,t11
fsubp st1,st0
fmul dword[k]	      ;k1
fsub st0,st3
fst st3 	       ;t12,t6,t7,t12,t5,t11
fadd st0,st5			    ;t1=t11+t12
fst st2 			;t1,t6,t1,t12,t5,t11
fadd st0,st1			    ;p1=t1+t6
fistp word [edi+2]		     ;p1    ;t6,t1,t12,t5,t11
fsubp st1,st0			    ;p6=t1-t6
fistp word [edi+6*2]		     ;p6  ;t12,t5,t11
fsubp st2,st0			;t2=t11-t12  ;t5,t2
fld st0
fadd st0,st2		    ;p2=t2+t5
fistp word [edi+2*2]		     ;p2
fsubp st1,st0			    ;p5=t2-t5   ;t5,t2
fistp word [edi+5*2]
ret		;p5




idctf3b: ;si ncr
fld dword[esi+1*32]
fld st0 	 ;f1       ;t21=f1+f7
fld dword[esi+7*32]
fadd st2,st0	 ;f7
fsubp st1,st0			    ;t22=f1-f7
fld dword[esi+5*32]
fld st0 	 ;f5       ;t23=f5+f3
fld dword[esi+3*32]		     ;f3
fadd st2,st0
fsubp st1,st0
fld st0  ;t20=f5-f3
fadd st0,st3			    ;t25=(t20+t22)*k2
fmul dword[k+4] 		;k2 ;t25,t20,t23,t22,t21
fld st4 			;t7=t21+t23
fadd st0,st3			    ;t7,t25,t20,t23,t22,t21
fld dword[k+12] 		;k4     ;t6=k4*t20+t25-t7
fmulp st3,st0
fsub st2,st0
fld st1
faddp st3,st0			;t7,t25,t6,t23,t22,t21
fld st5 			;t5=(t21-t23)*k1-t6
fsub st0,st4
fmul dword[k]	       ;k1
fsub st0,st3
fstp st6	       ;t7,t25,t6,t23,t22,t5
fstp st3
fxch st3	       ;t25,t6,t7,t22,t5
fmul dword[k+8] 		;k3      ;t4=k3*t22-t25+t5
fadd st0,st4			    ;t22*k3+t5,t6,t7,t25,t5
fsubrp st3,st0			;t6,t7,t4,t5
fld dword[esi]			     ;f0           ;t10=f0+f4
fst st5 			;f0,t4,t5,t6,t7,f0
fld dword[esi+4*32]		     ;f4
fsub st6,st0			;t11=f0-f4
faddp st1,st0
fld st0 	      ;t10,t10,t6,t7,t4,t5,t11
fld dword[esi+2*32]		     ;f2      ;t13=f2+f6
fadd dword[esi+6*32]		     ;f6      ;t13,t10,t10,t6,t7,t4,t5,t11
fadd st2,st0			;t13,t10,t0,t6,t7,t4,t5,t11 ;t0=t10+t13
fsubp st1,st0			    ;t3,t0,t6,t7,t4,t5,t11 ;t3=t10-t13
fld st0 			;p3=t3-t4
fsub st0,st5
fstp dword[esi+3*32]	    ;p3
fadd st0,st4			    ;p4=t3+t4
fld dword[esi+2*32]		     ;f2
fstp st5
fstp dword[esi+4*32]	    ;p4 ;t0,t6,t7,f2,t5,t11
fld st0
fsub st0,st3		    ;p0=t0+t7
fstp dword[esi+7*32]		     ;p7
fadd st0,st2			    ;p7=t0-t7
fstp dword[esi] 		     ;p0 ;t6,t7,f2,t5,t11
fld st2 			;f2  ;f2,t6,t7,f2,t5,t11  ;t12=(f2-f6)*k1-t13
fld dword[esi+6*32]		     ;f6
fadd st4,st0			;f6,f2,t6,t7,t13,t5,t11
fsubp st1,st0
fmul dword[k]	      ;k1
fsub st0,st3
fst st3 	       ;t12,t6,t7,t12,t5,t11
fadd st0,st5			    ;t1=t11+t12
fst st2 			;t1,t6,t1,t12,t5,t11
fadd st0,st1			    ;p1=t1+t6
fstp dword[esi+1*32]		     ;p1    ;t6,t1,t12,t5,t11
fsubp st1,st0			    ;p6=t1-t6
fstp dword[esi+6*32]		     ;p6  ;t12,t5,t11
fsubp st2,st0
fld st0 	  ;t2=t11-t12  ;t5,t2
fadd st0,st2			    ;p2=t2+t5
fstp dword[esi+2*32]		     ;p2
fsubp st1,st0			    ;p5=t2-t5   ;t5,t2
fstp dword[esi+5*32]
ret		;p5

ybr_bgr:  ;edi=bmp ecx=n_BYTES
	  ;retorna edi+=ecx
	pushad
	mov esi,edi
	add edi,ecx
	push edi
	mov edi,[colortabla]
   .l1: movzx ebx,word [esi+1] ;cb cr
	xor edx,edx
	mov ecx,1
	xchg bh,cl
	mov ax,[ebx*2+edi] ;cb
	xchg dl,ah
	mov bx,[ecx*2+edi] ;cr
	xor ecx,ecx
	xchg cl,bh
	add ax,cx
	mov cl,[esi]
	add ax,cx  ;g
	sub cx,128
	add bx,cx ;b
	add dx,cx
	dec ah
	jz .l2
	mov al,0
	js .l2
	mov al,-1
    .l2: test dh,dh
       jz .l3
       mov dl,0
       js .l3
       mov dl,-1
   .l3: test bh,bh
       mov dh,al
       jz .l4
       mov bl,0
       js .l4
       mov bl,-1
   .l4: mov [esi+2],bl
       mov [esi+1],dh
       mov [esi],dl
       add esi,3
       cmp esi,[esp]
       jc .l1
      pop edi
      popad
      ret

colorprecalc: ;Prepares the table to convert ycb to rgb
	 mov ecx,1024
	 call malloc
	 mov [colortabla],edi
	 fninit
	 fld dword[colortabla+8]
	 fld dword[colortabla+4]
	 mov dl,0
	 call .l1
	 fld dword[colortabla+16]
	 fld dword[colortabla+12]
	 fchs
     .l1: mov cx,-128
     .l2: mov [edi],cx
	 inc cx
	 fild word [edi]
	 fld st0
	 fmul st0,st2
	 fistp word [edi]
	 fmul st0,st2
	 mov bx,[edi]
	 fistp word [edi]
	 add bx,128
	 test bh,bh
	 mov al,bl
	 jz .l3
	 mov al,0
	 js .l3
	 mov al,-1
   .l3:  mov bx,[edi]
	 add bx,128
	 test bh,bh
	 mov ah,bl
	 jz .l4
	 mov ah,0
	 js .l4
	 mov ah,-1
    .l4: stosw
	 inc dl
	 jnz .l2
	 ret
;Cut
recortar:  ;edi = Buffer, Eax = width in pixels, (Ecx, edx) size or desired
	pushad
	dec edx
	jz .l2
	lea ebx,[ecx*3]
	lea eax,[eax*3]
	lea esi,[edi+eax]
	add edi,ebx
	sub eax,ebx
  .l1:	mov ecx,ebx
	call movedata
	add esi,eax
	dec edx
	jnz .l1
   .l2: popad
	ret

YsizeImage dw 0      ; Add by C