jpeglib.asm

Application sources:A084.ZIP

        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