WebSVN – Kolibri OS – Diff – /programs/media/jpegview/trunk/jpeglib.asm


;405 412 586
;
;
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
 
jpeg_info:  ;fichero en eax
            ;retorna ebp
        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
        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]
; do not close file - this will be done by caller
        and       dword [ebp+fichero], 0
      call jpeg_close
      popad
      xor ebp,ebp
      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
       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=memoria para el arbol
            ;retorna en ebx  el final de ht
            ;codigos: bits 0-3=nbits del siguiente numero
            ;         bits 4-7=numero de zeros
            ;         bits 8-14=longitud de este codigo o error si =127
            ;         bit 15=codigo/puntero
        push ebp
        lea ebx,[edi-2]
        add ebx,[ebx-2]
        mov word [ebx],-1 ;codigo de error si encontrado
        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 ;marca de codigo
        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  ;a continuacion vienen los datos de la imagen
       call READ
       mov eax,[ebp+fichero]
       call ftell
       mov [ebp+position],edx
       mov esi,edi
       lea edi,[ebp+q_ptr]
       lodsb ;numero de componentes
       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
       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 dword [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: lodsw
	movzx ebx,ah
	movzx ebp,al
	movzx eax,al
	movzx ecx,byte[esi]
	lea ebx,[ebx*4+edi+1024]
	lea ecx,[ecx*4+edi]
	add eax,[ebx] ;cb   ;solo se usan 16 bits
	mov edx,[ebx+2]     ;pero el codigo de 32 bits es mas rapido
	mov ebx,[ecx] ;cr
	add eax,[ecx+2]
	add ebx,ebp ;b
	add edx,ebp ;r
	test ah,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],dx
	mov [esi],bl
	inc esi
	cmp esi,[esp]
	jc .l1
	pop edi
	popad
	ret
 
recortar:  ;edi=bufer eax=ancho en pixels (ecx,edx)tama¤o deseado
        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
 
;R = Y                    + 1.402  *(Cr-128)
;G = Y - 0.34414*(Cb-128) - 0.71414*(Cr-128)
;B = Y + 1.772  *(Cb-128)
 
colortabla: dd 0
 
colorprecalc: ;prepara la tabla para convertir ycb a rgb
	 mov ecx,1024*2
	 call malloc
	 mov [colortabla],edi
	 fninit
	 fld dword [.k+4]
	 fld dword [.k]
	 mov dl,0
	 call .l1
	 fld dword [.k+12]
	 fld dword[.k+8]
    .l1: mov cx,-128
    .l2: mov [edi],ecx
	 inc ecx
	 fild word[edi]
	 fld st0
	 fmul st0,st2
	 fistp word[edi]
	 fmul st0,st2
	 fistp word[edi+2]
	 add edi,4
	 inc dl
	 jnz .l2
	 ret
 
     .k: dd 1.402,-0.71414,-0.34414,+1.772

Rev 109	Rev 135
1	;405 412 586	1	;405 412 586
2	;	2	;
3	;	3	;
4	bufer_size=1024*16+2	4	bufer_size=1024*16+2
5	fichero=4	5	fichero=4
6	mcu_ptr=8	6	mcu_ptr=8
7	color_ptr=12	7	color_ptr=12
8	estado=16	8	estado=16
9	color_c=17	9	color_c=17
10	nbits=color_c	10	nbits=color_c
11	idct=20	11	idct=20
12	tmp_bits=24	12	tmp_bits=24
13	actable=28	13	actable=28
14	matriz_limit=32	14	matriz_limit=32
15	sourcebits=36	15	sourcebits=36
16	sourcebits_index=40	16	sourcebits_index=40
17	sourcebits_limit=44	17	sourcebits_limit=44
18	qt_ptrs=48	18	qt_ptrs=48
19	ht_dc_ptrs=64	19	ht_dc_ptrs=64
20	ht_ac_ptrs=80	20	ht_ac_ptrs=80
21	matrices=96	21	matrices=96
22	tmp_bufer=100	22	tmp_bufer=100
23	x_org=104	23	x_org=104
24	y_org=108	24	y_org=108
25	x_mcu=112	25	x_mcu=112
26	y_mcu=116	26	y_mcu=116
27	x_size=120	27	x_size=120
28	y_size=124	28	y_size=124
29	x_org2=128	29	x_org2=128
30	y_org2=132	30	y_org2=132
31	x_mcu2=136	31	x_mcu2=136
32	y_mcu2=140	32	y_mcu2=140
33	x_size2=144	33	x_size2=144
34	y_size2=148	34	y_size2=148
35	q_ptr=152	35	q_ptr=152
36	dc=164	36	dc=164
37	position=204	37	position=204
38	draw_ptr=208	38	draw_ptr=208
39	struct_size=212	39	struct_size=212
40		40
41	jpeg_info: ;fichero en eax	41	jpeg_info: ;fichero en eax
42	;retorna ebp	42	;retorna ebp
43	xor ebp,ebp	43	xor ebp,ebp
44	pushad	44	pushad
45	mov ebp,esp	45	mov ebp,esp
46	mov ecx,6	46	mov ecx,6
47	sub esp,ecx	47	sub esp,ecx
48	mov edi,esp	48	mov edi,esp
49	call read	49	call read
50	pop dx	50	pop dx
51	cmp dx,0d8ffh	51	cmp dx,0d8ffh
52	je .l1	52	je .l1
53	mov esp,ebp	53	mov esp,ebp
54	popad	54	popad
55	ret	55	ret
56	.l1: push eax	56	.l1: push eax
57	mov ecx,struct_size	57	mov ecx,struct_size
58	call mallocz	58	call mallocz
59	mov [edi],ebp	59	mov [edi],ebp
60	mov ebp,edi	60	mov ebp,edi
61	pop dword [ebp+fichero]	61	pop dword [ebp+fichero]
62	pop ax	62	pop ax
63	pop cx	63	pop cx
64	jmp .l3	64	jmp .l3
65	.l2: mov ebx,[ebp+tmp_bufer]	65	.l2: mov ebx,[ebp+tmp_bufer]
66	add ebx,[ebx-4]	66	add ebx,[ebx-4]
67	mov cx,[ebx-2]	67	mov cx,[ebx-2]
68	mov ax,[ebx-4]	68	mov ax,[ebx-4]
69	.l3: push .l2	69	.l3: push .l2
70	xchg cl,ch	70	xchg cl,ch
71	add cx,2	71	add cx,2
72	cmp ch,3	72	cmp ch,3
73	jnc .l4	73	jnc .l4
74	cmp al,0ffh	74	cmp al,0ffh
75	jne eoi	75	jne eoi
76	cmp ah,0dbh	76	cmp ah,0dbh
77	je dqt	77	je dqt
78	cmp ah,0c4h	78	cmp ah,0c4h
79	je dht	79	je dht
80	cmp ah,0c0h	80	cmp ah,0c0h
81	je sof0	81	je sof0
82	cmp ah,0dah	82	cmp ah,0dah
83	je sos	83	je sos
84	cmp ah,0c2h	84	cmp ah,0c2h
85	je eoi	85	je eoi
86	cmp ah,0c9h	86	cmp ah,0c9h
87	je eoi	87	je eoi
88	cmp ah,0d9h	88	cmp ah,0d9h
89	je eoi	89	je eoi
90	.l4: lea edx,[ecx-4]	90	.l4: lea edx,[ecx-4]
91	xor ecx,ecx	91	xor ecx,ecx
92	mov eax,[ebp+fichero]	92	mov eax,[ebp+fichero]
93	call skip	93	call skip
94	mov ecx,4	94	mov ecx,4
95	call READ	95	call READ
96	cmp ecx,[edi-4]	96	cmp ecx,[edi-4]
97	jne eoi	97	jne eoi
98	ret	98	ret
99		99
100	eoi:	100	eoi:
101	mov esp,[ebp]	101	mov esp,[ebp]
-		102	; do not close file - this will be done by caller
-		103	and dword [ebp+fichero], 0
102	call jpeg_close	104	call jpeg_close
103	popad	105	popad
104	xor ebp,ebp	106	xor ebp,ebp
105	ret	107	ret
106		108
107	jpeg_close:	109	jpeg_close:
108	test ebp,ebp	110	test ebp,ebp
109	jz .l2	111	jz .l2
110	pushad	112	pushad
111	mov eax,[ebp+fichero]	113	mov eax,[ebp+fichero]
112	call close	114	call close
113	mov edi,[ebp+sourcebits]	115	mov edi,[ebp+sourcebits]
114	call free	116	call free
115	lea esi,[ebp+qt_ptrs]	117	lea esi,[ebp+qt_ptrs]
116	mov ecx,14	118	mov ecx,14
117	.l1: mov edi,[esi]	119	.l1: mov edi,[esi]
118	add esi,4	120	add esi,4
119	call free	121	call free
120	loop .l1	122	loop .l1
121	mov edi,ebp	123	mov edi,ebp
122	call free	124	call free
123	popad	125	popad
124	.l2: ret	126	.l2: ret
125		127
126	dqt: call READ	128	dqt: call READ
127	mov esi,edi	129	mov esi,edi
128	lea eax,[edi+ecx]	130	lea eax,[edi+ecx]
129	push eax	131	push eax
130	.l1: xor eax,eax	132	.l1: xor eax,eax
131	lodsb	133	lodsb
132	cmp al,4	134	cmp al,4
133	jnc eoi	135	jnc eoi
134	lea ebx,[ebp+qt_ptrs+eax*4]	136	lea ebx,[ebp+qt_ptrs+eax*4]
135	test dword [ebx],-1	137	test dword [ebx],-1
136	jnz eoi	138	jnz eoi
137	mov ecx,64	139	mov ecx,64
138	xor eax,eax	140	xor eax,eax
139	sub esp,128	141	sub esp,128
140	mov edi,esp	142	mov edi,esp
141	.l2: lodsb	143	.l2: lodsb
142	stosw	144	stosw
143	loop .l2	145	loop .l2
144	mov ecx,256	146	mov ecx,256
145	call malloc	147	call malloc
146	mov [ebx],edi	148	mov [ebx],edi
147	mov eax,esi	149	mov eax,esi
148	mov esi,esp	150	mov esi,esp
149	pushad	151	pushad
150	mov ebp,zigzag	152	mov ebp,zigzag
151	fninit	153	fninit
152	mov cl,64	154	mov cl,64
153	xor eax,eax	155	xor eax,eax
154	.l3: fild word[esi]	156	.l3: fild word[esi]
155	mov al,[ebp]	157	mov al,[ebp]
156	and al,-2	158	and al,-2
157	add ebp,2	159	add ebp,2
158	add esi,2	160	add esi,2
159	mov ebx,eax	161	mov ebx,eax
160	and ebx,28	162	and ebx,28
161	fmul dword [ebx+k2]	163	fmul dword [ebx+k2]
162	mov ebx,eax	164	mov ebx,eax
163	shr ebx,3	165	shr ebx,3
164	and ebx,4+8+16	166	and ebx,4+8+16
165	fmul dword [ebx+k2]	167	fmul dword [ebx+k2]
166	fstp dword [edi+eax]	168	fstp dword [edi+eax]
167	dec cl	169	dec cl
168	jnz .l3	170	jnz .l3
169	popad	171	popad
170	mov esi,eax	172	mov esi,eax
171	add esp,128	173	add esp,128
172	mov eax,[esp]	174	mov eax,[esp]
173	sub eax,esi	175	sub eax,esi
174	jc eoi	176	jc eoi
175	cmp eax,4	177	cmp eax,4
176	ja .l1	178	ja .l1
177	jne eoi	179	jne eoi
178	pop eax	180	pop eax
179	ret	181	ret
180		182
181	sof0: call READ	183	sof0: call READ
182	cmp byte [edi],8	184	cmp byte [edi],8
183	jne eoi ;precision	185	jne eoi ;precision
184	mov ax,[edi+1]	186	mov ax,[edi+1]
185	xchg al,ah	187	xchg al,ah
186	mov [ebp+y_size],ax	188	mov [ebp+y_size],ax
187	mov ax,[edi+3]	189	mov ax,[edi+3]
188	xchg al,ah	190	xchg al,ah
189	mov [ebp+x_size],ax	191	mov [ebp+x_size],ax
190	mov al,[edi+5] ;ncomponentes	192	mov al,[edi+5] ;ncomponentes
191	mov cl,al	193	mov cl,al
192	mov [ebp+color_c],al	194	mov [ebp+color_c],al
193	mov edx,modes	195	mov edx,modes
194	dec al	196	dec al
195	jz .l1	197	jz .l1
196	dec al	198	dec al
197	dec al	199	dec al
198	jnz eoi	200	jnz eoi
199	mov al,[edi+10]	201	mov al,[edi+10]
200	mov ah,[edi+13]	202	mov ah,[edi+13]
201	cmp ax,1111h	203	cmp ax,1111h
202	jne eoi	204	jne eoi
203	mov al,[edi+7]	205	mov al,[edi+7]
204	add edx,16	206	add edx,16
205	cmp al,11h	207	cmp al,11h
206	je .l1	208	je .l1
207	add edx,16	209	add edx,16
208	cmp al,21h	210	cmp al,21h
209	je .l1	211	je .l1
210	add edx,16	212	add edx,16
211	cmp al,22h	213	cmp al,22h
212	jne eoi	214	jne eoi
213	.l1: lea ebx,[ebp+q_ptr]	215	.l1: lea ebx,[ebp+q_ptr]
214	lea esi,[ebp+qt_ptrs]	216	lea esi,[ebp+qt_ptrs]
215	mov [ebp+mcu_ptr],edx	217	mov [ebp+mcu_ptr],edx
216	.l2: movzx eax,byte [edi+8]	218	.l2: movzx eax,byte [edi+8]
217	add edi,3	219	add edi,3
218	cmp al,4	220	cmp al,4
219	jnc eoi	221	jnc eoi
220	lea eax,[eax*4+esi]	222	lea eax,[eax*4+esi]
221	mov [ebx],eax	223	mov [ebx],eax
222	add ebx,16	224	add ebx,16
223	dec cl	225	dec cl
224	jnz .l2	226	jnz .l2
225	ret	227	ret
226		228
227	READ: mov eax,[ebp+fichero]	229	READ: mov eax,[ebp+fichero]
228	mov edi,[ebp+tmp_bufer]	230	mov edi,[ebp+tmp_bufer]
229	movzx ecx,cx	231	movzx ecx,cx
230	call mresize	232	call mresize
231	mov [ebp+tmp_bufer],edi	233	mov [ebp+tmp_bufer],edi
232	jmp read	234	jmp read
233		235
234	dht: call READ	236	dht: call READ
235	mov esi,edi	237	mov esi,edi
236	lea eax,[edi+ecx]	238	lea eax,[edi+ecx]
237	push eax	239	push eax
238	.l1: lodsb	240	.l1: lodsb
239	mov edi,esi	241	mov edi,esi
240	mov ebx,3+16	242	mov ebx,3+16
241	and bl,al	243	and bl,al
242	cmp bl,al	244	cmp bl,al
243	jne eoi	245	jne eoi
244	shr bl,2	246	shr bl,2
245	and al,3	247	and al,3
246	or bl,al	248	or bl,al
247	lea ebx,[ebp+ht_dc_ptrs+ebx*4]	249	lea ebx,[ebp+ht_dc_ptrs+ebx*4]
248	test dword [ebx],-1	250	test dword [ebx],-1
249	jnz eoi	251	jnz eoi
250	mov cl,15	252	mov cl,15
251	mov al,[edi]	253	mov al,[edi]
252	.l2: inc edi ;calcular numero de codigos	254	.l2: inc edi ;calcular numero de codigos
253	add al,[edi]	255	add al,[edi]
254	jc eoi	256	jc eoi
255	dec cl	257	dec cl
256	jnz .l2	258	jnz .l2
257	movzx ecx,al	259	movzx ecx,al
258	lea ecx,[ecx*4+2]	260	lea ecx,[ecx*4+2]
259	call malloc	261	call malloc
260	mov [ebx],edi	262	mov [ebx],edi
261	call arbol_hf	263	call arbol_hf
262	mov eax,[esp]	264	mov eax,[esp]
263	sub eax,ebx	265	sub eax,ebx
264	jc eoi	266	jc eoi
265	mov esi,ebx	267	mov esi,ebx
266	cmp eax,4	268	cmp eax,4
267	ja .l1	269	ja .l1
268	jne eoi	270	jne eoi
269	pop eax	271	pop eax
270	ret	272	ret
271		273
272	arbol_hf: ;esi=ht edi=memoria para el arbol	274	arbol_hf: ;esi=ht edi=memoria para el arbol
273	;retorna en ebx el final de ht	275	;retorna en ebx el final de ht
274	;codigos: bits 0-3=nbits del siguiente numero	276	;codigos: bits 0-3=nbits del siguiente numero
275	; bits 4-7=numero de zeros	277	; bits 4-7=numero de zeros
276	; bits 8-14=longitud de este codigo o error si =127	278	; bits 8-14=longitud de este codigo o error si =127
277	; bit 15=codigo/puntero	279	; bit 15=codigo/puntero
278	push ebp	280	push ebp
279	lea ebx,[edi-2]	281	lea ebx,[edi-2]
280	add ebx,[ebx-2]	282	add ebx,[ebx-2]
281	mov word [ebx],-1 ;codigo de error si encontrado	283	mov word [ebx],-1 ;codigo de error si encontrado
282	push ebx	284	push ebx
283	push esi	285	push esi
284	lea ebx,[esi+16]	286	lea ebx,[esi+16]
285	mov ebp,esp	287	mov ebp,esp
286	xor ecx,ecx	288	xor ecx,ecx
287	push edi	289	push edi
288	push ecx	290	push ecx
289	add edi,2	291	add edi,2
290	mov dx,1	292	mov dx,1
291	add dh,[esi]	293	add dh,[esi]
292	jz .l3	294	jz .l3
293	jmp .l2	295	jmp .l2
294	.l1: push edi	296	.l1: push edi
295	push ecx	297	push ecx
296	add edi,2	298	add edi,2
297	.l2: inc cl	299	.l2: inc cl
298	cmp cl,dl	300	cmp cl,dl
299	jc .l1	301	jc .l1
300	mov al,[ebx]	302	mov al,[ebx]
301	inc ebx	303	inc ebx
302	mov ah,128 ;marca de codigo	304	mov ah,128 ;marca de codigo
303	or ah,dl	305	or ah,dl
304	cmp edi,[ebp+4]	306	cmp edi,[ebp+4]
305	jnc .l5	307	jnc .l5
306	stosw	308	stosw
307	cmp esp,ebp	309	cmp esp,ebp
308	jnc .l5	310	jnc .l5
309	pop ecx	311	pop ecx
310	pop esi	312	pop esi
311	lea eax,[edi-2]	313	lea eax,[edi-2]
312	sub eax,esi	314	sub eax,esi
313	mov [esi],ax	315	mov [esi],ax
314	dec dh	316	dec dh
315	jnz .l2 ;ncodigos	317	jnz .l2 ;ncodigos
316	mov esi,[ebp]	318	mov esi,[ebp]
317	.l3: inc esi	319	.l3: inc esi
318	inc dl	320	inc dl
319	cmp dl,17	321	cmp dl,17
320	jnc .l4	322	jnc .l4
321	add dh,[esi]	323	add dh,[esi]
322	jz .l3	324	jz .l3
323	mov [ebp],esi	325	mov [ebp],esi
324	jmp .l2	326	jmp .l2
325	.l4: lea esp,[ebp+8]	327	.l4: lea esp,[ebp+8]
326	pop ebp	328	pop ebp
327	ret	329	ret
328	.l5: mov ebp,[ebp+8]	330	.l5: mov ebp,[ebp+8]
329	jmp eoi	331	jmp eoi
330		332
331	sos: sub ecx,4 ;a continuacion vienen los datos de la imagen	333	sos: sub ecx,4 ;a continuacion vienen los datos de la imagen
332	call READ	334	call READ
333	mov eax,[ebp+fichero]	335	mov eax,[ebp+fichero]
334	call ftell	336	call ftell
335	mov [ebp+position],edx	337	mov [ebp+position],edx
336	mov esi,edi	338	mov esi,edi
337	lea edi,[ebp+q_ptr]	339	lea edi,[ebp+q_ptr]
338	lodsb ;numero de componentes	340	lodsb ;numero de componentes
339	sub [ebp+color_c],al	341	sub [ebp+color_c],al
340	jnz eoi	342	jnz eoi
341	mov dh,al	343	mov dh,al
342	.l1: mov ebx,[edi]	344	.l1: mov ebx,[edi]
343	mov eax,[ebx]	345	mov eax,[ebx]
344	stosd	346	stosd
345	lodsw	347	lodsw
346	mov cl,ah	348	mov cl,ah
347	and eax,0f00h	349	and eax,0f00h
348	and ecx,0f0h	350	and ecx,0f0h
349	shr eax,6	351	shr eax,6
350	shr ecx,2	352	shr ecx,2
351	lea ebx,[ebp+ht_ac_ptrs+eax]	353	lea ebx,[ebp+ht_ac_ptrs+eax]
352	mov eax,[ebx]	354	mov eax,[ebx]
353	lea ebx,[ebp+ht_dc_ptrs+ecx]	355	lea ebx,[ebp+ht_dc_ptrs+ecx]
354	mov ecx,[ebx]	356	mov ecx,[ebx]
355	test eax,eax	357	test eax,eax
356	jz eoi	358	jz eoi
357	test ecx,ecx	359	test ecx,ecx
358	jz eoi	360	jz eoi
359	stosd	361	stosd
360	mov eax,ecx	362	mov eax,ecx
361	stosd	363	stosd
362	add edi,4	364	add edi,4
363	dec dh	365	dec dh
364	jnz .l1	366	jnz .l1
365	mov edx,[ebp+mcu_ptr]	367	mov edx,[ebp+mcu_ptr]
366	cmp edx,modes	368	cmp edx,modes
367	jne .l2	369	jne .l2
368	lea esi,[ebp+q_ptr]	370	lea esi,[ebp+q_ptr]
369	lea edi,[ebp+q_ptr+32]	371	lea edi,[ebp+q_ptr+32]
370	movsd	372	movsd
371	movsd	373	movsd
372	movsd	374	movsd
373	.l2:	375	.l2:
374	mov esi,edx	376	mov esi,edx
375	push dword [esi]	377	push dword [esi]
376	pop dword [ebp+mcu_ptr]	378	pop dword [ebp+mcu_ptr]
377	push dword [esi+4]	379	push dword [esi+4]
378	pop dword[ebp+color_ptr]	380	pop dword[ebp+color_ptr]
379	push dword [esi+12]	381	push dword [esi+12]
380	pop dword [ebp+y_mcu]	382	pop dword [ebp+y_mcu]
381	push dword [esi+8]	383	push dword [esi+8]
382	pop dword [ebp+x_mcu]	384	pop dword [ebp+x_mcu]
383	mov ecx,64*18	385	mov ecx,64*18
384	call malloc	386	call malloc
385	mov [ebp+matrices],edi	387	mov [ebp+matrices],edi
386	mov ecx,bufer_size	388	mov ecx,bufer_size
387	call malloc	389	call malloc
388	mov [ebp+sourcebits],edi	390	mov [ebp+sourcebits],edi
389	mov esp,[ebp]	391	mov esp,[ebp]
390	mov [esp+8],ebp	392	mov [esp+8],ebp
391	popad	393	popad
392	ret	394	ret
393		395
394	jpeg_display:	396	jpeg_display:
395	test ebp,ebp	397	test ebp,ebp
396	jnz .inicio	398	jnz .inicio
397	ret	399	ret
398	.inicio:	400	.inicio:
399	pushad	401	pushad
400	mov [ebp],esp	402	mov [ebp],esp
401	mov eax,[ebp+fichero]	403	mov eax,[ebp+fichero]
402	mov edx,[ebp+position]	404	mov edx,[ebp+position]
403	call lseek	405	call lseek
404	mov edi,[ebp+sourcebits]	406	mov edi,[ebp+sourcebits]
405	add edi,bufer_size	407	add edi,bufer_size
406	mov [ebp+sourcebits_index],edi	408	mov [ebp+sourcebits_index],edi
407	sub edi,2	409	sub edi,2
408	mov [ebp+sourcebits_limit],edi	410	mov [ebp+sourcebits_limit],edi
409	mov edi,[ebp+matrices]	411	mov edi,[ebp+matrices]
410	mov [ebp+matriz_limit],edi	412	mov [ebp+matriz_limit],edi
411	xor eax,eax	413	xor eax,eax
412	mov [esp+8],eax	414	mov [esp+8],eax
413	mov [ebp+estado],eax	415	mov [ebp+estado],eax
414	mov [ebp+tmp_bits],eax	416	mov [ebp+tmp_bits],eax
415	mov [ebp+dc],eax	417	mov [ebp+dc],eax
416	mov [ebp+dc+16],eax	418	mov [ebp+dc+16],eax
417	mov [ebp+dc+32],eax	419	mov [ebp+dc+32],eax
418		420
419	mov eax,[ebp+y_mcu]	421	mov eax,[ebp+y_mcu]
420	mov ecx,[ebp+y_org]	422	mov ecx,[ebp+y_org]
421	sub ecx,eax	423	sub ecx,eax
422	mov [ebp+y_org2],ecx	424	mov [ebp+y_org2],ecx
423	mov [ebp+y_mcu2],eax	425	mov [ebp+y_mcu2],eax
424	push dword [ebp+y_size]	426	push dword [ebp+y_size]
425	pop dword [ebp+y_size2]	427	pop dword [ebp+y_size2]
426	.l3: push dword [ebp+x_org]	428	.l3: push dword [ebp+x_org]
427	pop dword [ebp+x_org2]	429	pop dword [ebp+x_org2]
428	push dword [ebp+x_mcu]	430	push dword [ebp+x_mcu]
429	pop dword [ebp+x_mcu2]	431	pop dword [ebp+x_mcu2]
430	push dword [ebp+x_size]	432	push dword [ebp+x_size]
431	pop dword [ebp+x_size2]	433	pop dword [ebp+x_size2]
432	mov eax,[ebp+y_mcu2]	434	mov eax,[ebp+y_mcu2]
433	add [ebp+y_org2],eax	435	add [ebp+y_org2],eax
434	sub [ebp+y_size2],eax	436	sub [ebp+y_size2],eax
435	jnc .l4	437	jnc .l4
436	add eax,[ebp+y_size2]	438	add eax,[ebp+y_size2]
437	jnz .cont	439	jnz .cont
438	mov [esp+8],ebp	440	mov [esp+8],ebp
439	popad	441	popad
440	ret	442	ret
441	.cont:	443	.cont:
442	mov dword [ebp+y_size2],0	444	mov dword [ebp+y_size2],0
443	mov [ebp+y_mcu2],eax	445	mov [ebp+y_mcu2],eax
444	.l4:	446	.l4:
445	mov eax,[ebp+x_mcu2]	447	mov eax,[ebp+x_mcu2]
446	sub [ebp+x_size2],eax	448	sub [ebp+x_size2],eax
447	jnc .l5	449	jnc .l5
448	add eax,[ebp+x_size2]	450	add eax,[ebp+x_size2]
449	jz .l3	451	jz .l3
450	mov dword [ebp+x_size2],0	452	mov dword [ebp+x_size2],0
451	mov [ebp+x_mcu2],eax	453	mov [ebp+x_mcu2],eax
452	call dword [ebp+mcu_ptr]	454	call dword [ebp+mcu_ptr]
453	mov eax,[ebp+x_mcu]	455	mov eax,[ebp+x_mcu]
454	mov ecx,[ebp+x_mcu2]	456	mov ecx,[ebp+x_mcu2]
455	mov edx,[ebp+y_mcu2]	457	mov edx,[ebp+y_mcu2]
456	call recortar	458	call recortar
457	jmp .l6	459	jmp .l6
458	.l5:	460	.l5:
459	call dword [ebp+mcu_ptr]	461	call dword [ebp+mcu_ptr]
460	mov ecx,[ebp+x_mcu2]	462	mov ecx,[ebp+x_mcu2]
461	mov edx,[ebp+y_mcu2]	463	mov edx,[ebp+y_mcu2]
462	.l6:	464	.l6:
463	mov eax,[ebp+x_org2]	465	mov eax,[ebp+x_org2]
464	mov ebx,[ebp+y_org2]	466	mov ebx,[ebp+y_org2]
465	call dword [ebp+draw_ptr]	467	call dword [ebp+draw_ptr]
466	add [ebp+x_org2],ecx	468	add [ebp+x_org2],ecx
467	mov ax,[ebp+estado]	469	mov ax,[ebp+estado]
468	test al,15	470	test al,15
469	jz .l4	471	jz .l4
470	cmp ah,8	472	cmp ah,8
471	jnc .l4	473	jnc .l4
472	xor edx,edx	474	xor edx,edx
473	mov [ebp+tmp_bits],edx	475	mov [ebp+tmp_bits],edx
474	mov [ebp+dc],edx	476	mov [ebp+dc],edx
475	mov [ebp+dc+16],edx	477	mov [ebp+dc+16],edx
476	mov [ebp+dc+32],edx	478	mov [ebp+dc+32],edx
477	add dword [ebp+sourcebits_index],2	479	add dword [ebp+sourcebits_index],2
478	and word [ebp+estado],0c0h	480	and word [ebp+estado],0c0h
479	test al,32	481	test al,32
480	jz .l4	482	jz .l4
481	jmp .l3	483	jmp .l3
482		484
483	color100:	485	color100:
484	push edi	486	push edi
485	.l1: lodsw	487	.l1: lodsw
486	mov dl,ah	488	mov dl,ah
487	mov ah,al	489	mov ah,al
488	stosw	490	stosw
489	mov ah,dl	491	mov ah,dl
490	stosb	492	stosb
491	mov al,dl	493	mov al,dl
492	stosb	494	stosb
493	stosw	495	stosw
494	dec cl	496	dec cl
495	jnz .l1	497	jnz .l1
496	pop edi	498	pop edi
497	ret	499	ret
498		500

Subversion Repositories Kolibri OS

(root)/programs/media/jpegview/trunk/jpeglib.asm @ 135 – Rev 109 → 135