home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
High Voltage Shareware
/
high1.zip
/
high1
/
DIR2
/
DVPG30FS.ZIP
/
JREV.ASM
< prev
next >
Wrap
Assembly Source File
|
1993-11-27
|
34KB
|
1,626 lines
.386p
ifndef ??version
?debug macro
endm
publicdll macro name
public name
endm
endif
JREVDCT_TEXT segment byte public use16 'CODE'
JREVDCT_TEXT ends
DGROUP group _DATA,_BSS
assume cs:JREVDCT_TEXT,ds:DGROUP
_DATA segment word public use16 'DATA'
d@ label byte
d@w label word
_DATA ends
_BSS segment word public use16 'BSS'
b@ label byte
b@w label word
_BSS ends
JREVDCT_TEXT segment byte public use16 'CODE'
;
; j_rev_dct (DCTBLOCK data)
;
assume cs:JREVDCT_TEXT
_j_rev_dct proc near
push bp
mov bp,sp
sub sp,22
push si
push di
;
; {
; int tmp0, tmp1, tmp2, tmp3;
; int tmp10, tmp11, tmp12, tmp13;
; int z1, z2, z3, z4, z5;
; register DCTELEM *dataptr;
; int rowctr;
; SHIFT_TEMPS
;
; /* Pass 1: process rows. */
; /* Note results are scaled up by sqrt(8) compared to a true IDCT; */
; /* furthermore, we scale the results by 2**PASS1_BITS. */
;
; dataptr = data;
;
mov si,word ptr [bp+4]
;
; for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--) {
;
mov word ptr [bp-22],7
jmp @1@170
@1@58:
;
; /* Due to quantization, we will usually find that many of the input
; * coefficients are zero, especially the AC terms. We can exploit this
; * by short-circuiting the IDCT calculation for any row in which all
; * the AC terms are zero. In that case each output is equal to the
; * DC coefficient (with scale factor as needed).
; * With typical images and quantization tables, half or more of the
; * row DCT calculations can be simplified this way.
; */
;
; if ((dataptr[1] | dataptr[2] | dataptr[3] | dataptr[4] |
;
;
; dataptr[5] | dataptr[6] | dataptr[7]) == 0) {
;
mov ax,word ptr [si+2]
or ax,word ptr [si+4]
or ax,word ptr [si+6]
or ax,word ptr [si+8]
or ax,word ptr [si+10]
or ax,word ptr [si+12]
or ax,word ptr [si+14]
jne short @1@114
;
; /* AC terms all zero */
; DCTELEM dcval = (DCTELEM) (dataptr[0] << PASS1_BITS);
;
mov dx,word ptr [si]
; shl dx,0
;
;
; dataptr[0] = dcval;
;
mov word ptr [si],dx
;
; dataptr[1] = dcval;
;
mov word ptr [si+2],dx
;
; dataptr[2] = dcval;
;
mov word ptr [si+4],dx
;
; dataptr[3] = dcval;
;
mov word ptr [si+6],dx
;
; dataptr[4] = dcval;
;
mov word ptr [si+8],dx
;
; dataptr[5] = dcval;
;
mov word ptr [si+10],dx
;
; dataptr[6] = dcval;
;
mov word ptr [si+12],dx
;
; dataptr[7] = dcval;
;
mov word ptr [si+14],dx
;
;
; dataptr += DCTSIZE; /* advance pointer to next row */
;
add si,16
;
; continue;
;
jmp @1@142
@1@114:
;
; }
;
; /* Even part: reverse the even part of the forward DCT. */
; /* The rotator is sqrt(2)*c(-6). */
;
; z2 = (int) dataptr[2];
;
mov ax,word ptr [si+4]
mov word ptr [bp-16],ax
;
; z3 = (int) dataptr[6];
;
mov bx,word ptr [si+12]
;
;
; z1 = MULTIPLY(z2 + z3, FIX_0_541196100);
;
add ax,bx
mov dx, ax
shl dx, 3
add ax, dx
; mov dx,9
; imul dx
mov word ptr [bp-14],ax
;
; tmp2 = z1 + MULTIPLY(z3, - FIX_1_847759065);
;
mov ax,bx
mov dx,-30
imul dx
mov dx,word ptr [bp-14]
add dx,ax
mov word ptr [bp-2],dx
;
; tmp3 = z1 + MULTIPLY(z2, FIX_0_765366865);
;
mov ax,word ptr [bp-16]
mov dx, ax
shl dx, 3
shl ax, 2
add dx, ax
add dx, word ptr [bp-14]
; mov dx,12
; imul dx
; mov dx,word ptr [bp-14]
; add dx,ax
mov word ptr [bp-4],dx
;
;
; tmp1 = ((int) dataptr[0] - (int) dataptr[4]) << CONST_BITS;
;
mov ax,word ptr [si]
mov dx,ax
sub ax,word ptr [si+8]
shl ax,4
mov di,ax
;
; tmp0 = ((int) dataptr[0] + (int) dataptr[4]) << CONST_BITS;
;
mov ax,dx
add ax,word ptr [si+8]
shl ax,4
mov cx,ax
;
;
; tmp10 = tmp0 + tmp3;
;
add ax,word ptr [bp-4]
mov word ptr [bp-6],ax
;
; tmp13 = tmp0 - tmp3;
;
mov ax,cx
sub ax,word ptr [bp-4]
mov word ptr [bp-12],ax
;
; tmp11 = tmp1 + tmp2;
;
mov ax,di
add ax,word ptr [bp-2]
mov word ptr [bp-8],ax
;
; tmp12 = tmp1 - tmp2;
;
mov ax,di
sub ax,word ptr [bp-2]
mov word ptr [bp-10],ax
;
;
; /* Odd part per figure 8; the matrix is unitary and hence its
; * transpose is its inverse. i0..i3 are y7,y5,y3,y1 respectively.
; */
;
; tmp1 = (int) dataptr[5];
;
mov di,word ptr [si+10]
;
; tmp2 = (int) dataptr[3];
;
mov ax,word ptr [si+6]
mov word ptr [bp-2],ax
;
; tmp0 = (int) dataptr[7];
;
mov cx,word ptr [si+14]
;
; tmp3 = (int) dataptr[1];
;
mov ax,word ptr [si+2]
mov word ptr [bp-4],ax
;
;
; z1 = tmp0 + tmp3;
;
mov ax,cx
add ax,word ptr [bp-4]
mov word ptr [bp-14],ax
;
; z2 = tmp1 + tmp2;
;
mov ax,di
add ax,word ptr [bp-2]
mov word ptr [bp-16],ax
;
; z3 = tmp0 + tmp2;
;
mov bx,cx
add bx,word ptr [bp-2]
;
; z4 = tmp1 + tmp3;
;
mov ax,di
add ax,word ptr [bp-4]
mov word ptr [bp-18],ax
;
; z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */
;
mov ax,bx
add ax,word ptr [bp-18]
mov dx,19
imul dx
mov word ptr [bp-20],ax
;
;
; tmp0 = MULTIPLY(tmp0, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */
;
mov ax,cx
shl ax, 2
add cx, ax
; mov dx,5
; imul dx
; mov cx,ax
;
; tmp1 = MULTIPLY(tmp1, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */
;
mov ax,di
mov dx, ax
shl dx, 5
add ax, dx
; mov dx,33
; imul dx
mov di,ax
;
; tmp2 = MULTIPLY(tmp2, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */
;
mov ax,word ptr [bp-2]
mov dx,49
imul dx
mov word ptr [bp-2],ax
;
; tmp3 = MULTIPLY(tmp3, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */
;
mov ax,word ptr [bp-4]
mov dx, ax
shl dx, 4
shl ax, 3
add ax, dx
; mov dx,24
; imul dx
mov word ptr [bp-4],ax
;
; z1 = MULTIPLY(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */
;
mov ax,word ptr [bp-14]
mov dx,-14
imul dx
mov word ptr [bp-14],ax
;
; z2 = MULTIPLY(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
;
mov ax,word ptr [bp-16]
mov dx,-41
imul dx
mov word ptr [bp-16],ax
;
; z4 = MULTIPLY(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */
;
mov ax,word ptr [bp-18]
mov dx,-6
imul dx
mov word ptr [bp-18],ax
;
; z3 = MULTIPLY(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
;
mov ax,bx
mov dx,-31
imul dx
mov bx,ax
;
;
; z3 += z5;
;
add bx,word ptr [bp-20]
;
; z4 += z5;
;
mov ax,word ptr [bp-20]
add word ptr [bp-18],ax
;
;
; tmp1 += z2 + z4;
;
mov ax,word ptr [bp-16]
add ax,word ptr [bp-18]
add di,ax
;
; tmp0 += z1 + z3;
;
mov ax,word ptr [bp-14]
add ax,bx
add cx,ax
;
; tmp2 += z2 + z3;
;
mov ax,word ptr [bp-16]
add ax,bx
add word ptr [bp-2],ax
;
; tmp3 += z1 + z4;
;
mov ax,word ptr [bp-14]
add ax,word ptr [bp-18]
add word ptr [bp-4],ax
;
;
; /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
;
; dataptr[0] = (DCTELEM) DESCALE(tmp10 + tmp3, CONST_BITS-PASS1_BITS);
;
mov ax,word ptr [bp-6]
add ax,word ptr [bp-4]
add ax,8
sar ax,4
mov word ptr [si],ax
;
; dataptr[7] = (DCTELEM) DESCALE(tmp10 - tmp3, CONST_BITS-PASS1_BITS);
;
mov ax,word ptr [bp-6]
sub ax,word ptr [bp-4]
add ax,8
sar ax,4
mov word ptr [si+14],ax
;
; dataptr[1] = (DCTELEM) DESCALE(tmp11 + tmp2, CONST_BITS-PASS1_BITS);
;
mov ax,word ptr [bp-8]
add ax,word ptr [bp-2]
add ax,8
sar ax,4
mov word ptr [si+2],ax
;
; dataptr[6] = (DCTELEM) DESCALE(tmp11 - tmp2, CONST_BITS-PASS1_BITS);
;
mov ax,word ptr [bp-8]
sub ax,word ptr [bp-2]
add ax,8
sar ax,4
mov word ptr [si+12],ax
;
; dataptr[2] = (DCTELEM) DESCALE(tmp12 + tmp1, CONST_BITS-PASS1_BITS);
;
mov ax,word ptr [bp-10]
add ax,di
add ax,8
sar ax,4
mov word ptr [si+4],ax
;
; dataptr[5] = (DCTELEM) DESCALE(tmp12 - tmp1, CONST_BITS-PASS1_BITS);
;
mov ax,word ptr [bp-10]
sub ax,di
add ax,8
sar ax,4
mov word ptr [si+10],ax
;
; dataptr[3] = (DCTELEM) DESCALE(tmp13 + tmp0, CONST_BITS-PASS1_BITS);
;
mov ax,word ptr [bp-12]
add ax,cx
add ax,8
sar ax,4
mov word ptr [si+6],ax
;
; dataptr[4] = (DCTELEM) DESCALE(tmp13 - tmp0, CONST_BITS-PASS1_BITS);
;
mov ax,word ptr [bp-12]
sub ax,cx
add ax,8
sar ax,4
mov word ptr [si+8],ax
;
;
; dataptr += DCTSIZE; /* advance pointer to next row */
;
add si,16
@1@142:
dec word ptr [bp-22]
@1@170:
cmp word ptr [bp-22],0
jl short @@10
jmp @1@58
@@10:
;
; }
;
; /* Pass 2: process columns. */
; /* Note that we must descale the results by a factor of 8 == 2**3, */
; /* and also undo the PASS1_BITS scaling. */
;
; dataptr = data;
;
mov si,word ptr [bp+4]
;
; for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--) {
;
mov word ptr [bp-22],7
jmp @1@338
@1@226:
;
; /* Columns of zeroes can be exploited in the same way as we did with rows.
; * However, the row calculation has created many nonzero AC terms, so the
; * simplification applies less often (typically 5% to 10% of the time).
; * On machines with very fast multiplication, it's possible that the
; * test takes more time than it's worth. In that case this section
; * may be commented out.
; */
;
; #ifndef NO_ZERO_COLUMN_TEST
; if ((dataptr[DCTSIZE*1] | dataptr[DCTSIZE*2] | dataptr[DCTSIZE*3] |
;
;
; dataptr[DCTSIZE*4] | dataptr[DCTSIZE*5] | dataptr[DCTSIZE*6] |
; dataptr[DCTSIZE*7]) == 0) {
;
mov ax,word ptr [si+16]
or ax,word ptr [si+32]
or ax,word ptr [si+48]
or ax,word ptr [si+64]
or ax,word ptr [si+80]
or ax,word ptr [si+96]
or ax,word ptr [si+112]
jne short @1@282
;
; /* AC terms all zero */
; DCTELEM dcval = (DCTELEM) DESCALE((int) dataptr[0], PASS1_BITS+3);
;
mov dx,word ptr [si]
add dx,4
sar dx,3
;
;
; dataptr[DCTSIZE*0] = dcval;
;
mov word ptr [si],dx
;
; dataptr[DCTSIZE*1] = dcval;
;
mov word ptr [si+16],dx
;
; dataptr[DCTSIZE*2] = dcval;
;
mov word ptr [si+32],dx
;
; dataptr[DCTSIZE*3] = dcval;
;
mov word ptr [si+48],dx
;
; dataptr[DCTSIZE*4] = dcval;
;
mov word ptr [si+64],dx
;
; dataptr[DCTSIZE*5] = dcval;
;
mov word ptr [si+80],dx
;
; dataptr[DCTSIZE*6] = dcval;
;
mov word ptr [si+96],dx
;
; dataptr[DCTSIZE*7] = dcval;
;
mov word ptr [si+112],dx
;
;
; dataptr++; /* advance pointer to next column */
;
add si,2
;
; continue;
;
jmp @1@310
@1@282:
;
; }
; #endif
;
; /* Even part: reverse the even part of the forward DCT. */
; /* The rotator is sqrt(2)*c(-6). */
;
; z2 = (int) dataptr[DCTSIZE*2];
;
mov ax,word ptr [si+32]
mov word ptr [bp-16],ax
;
; z3 = (int) dataptr[DCTSIZE*6];
;
mov bx,word ptr [si+96]
;
;
; z1 = MULTIPLY(z2 + z3, FIX_0_541196100);
;
add ax,bx
mov dx, ax
shl dx, 3
add ax, dx
; mov dx,9
; imul dx
mov word ptr [bp-14],ax
;
; tmp2 = z1 + MULTIPLY(z3, - FIX_1_847759065);
;
mov ax,bx
mov dx,-30
imul dx
mov dx,word ptr [bp-14]
add dx,ax
mov word ptr [bp-2],dx
;
; tmp3 = z1 + MULTIPLY(z2, FIX_0_765366865);
;
mov ax,word ptr [bp-16]
mov dx, ax
shl dx, 2
shl ax, 3
add dx, ax
add dx, word ptr [bp-14]
; mov dx,12
; imul dx
; mov dx,word ptr [bp-14]
; add dx,ax
mov word ptr [bp-4],dx
;
;
; tmp1 = ((int) dataptr[DCTSIZE*0] - (int) dataptr[DCTSIZE*4]) << CONST_BITS;
;
mov ax,word ptr [si]
mov dx,ax
sub ax,word ptr [si+64]
shl ax,4
mov di,ax
;
; tmp0 = ((int) dataptr[DCTSIZE*0] + (int) dataptr[DCTSIZE*4]) << CONST_BITS;
;
mov ax,dx
add ax,word ptr [si+64]
shl ax,4
mov cx,ax
;
;
; tmp10 = tmp0 + tmp3;
;
add ax,word ptr [bp-4]
mov word ptr [bp-6],ax
;
; tmp13 = tmp0 - tmp3;
;
mov ax,cx
sub ax,word ptr [bp-4]
mov word ptr [bp-12],ax
;
; tmp11 = tmp1 + tmp2;
;
mov ax,di
add ax,word ptr [bp-2]
mov word ptr [bp-8],ax
;
; tmp12 = tmp1 - tmp2;
;
mov ax,di
sub ax,word ptr [bp-2]
mov word ptr [bp-10],ax
;
;
; /* Odd part per figure 8; the matrix is unitary and hence its
; * transpose is its inverse. i0..i3 are y7,y5,y3,y1 respectively.
; */
;
; tmp0 = (int) dataptr[DCTSIZE*7];
;
mov cx,word ptr [si+112]
;
; tmp3 = (int) dataptr[DCTSIZE*1];
;
mov ax,word ptr [si+16]
mov word ptr [bp-4],ax
;
;
; z1 = tmp0 + tmp3;
;
mov ax,cx
add ax,word ptr [bp-4]
mov word ptr [bp-14],ax
;
; z1 = MULTIPLY(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */
;
mov dx,-14
imul dx
mov word ptr [bp-14],ax
;
; tmp1 = (int) dataptr[DCTSIZE*5];
;
mov di,word ptr [si+80]
;
; tmp2 = (int) dataptr[DCTSIZE*3];
;
mov ax,word ptr [si+48]
mov word ptr [bp-2],ax
;
; z2 = tmp1 + tmp2;
;
mov ax,di
add ax,word ptr [bp-2]
mov word ptr [bp-16],ax
;
; z2 = MULTIPLY(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
;
mov dx,-41
imul dx
mov word ptr [bp-16],ax
;
; z3 = tmp0 + tmp2;
;
mov bx,cx
add bx,word ptr [bp-2]
;
; z4 = tmp1 + tmp3;
;
mov ax,di
add ax,word ptr [bp-4]
mov word ptr [bp-18],ax
;
; z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */
;
mov ax,bx
add ax,word ptr [bp-18]
mov dx,19
imul dx
mov word ptr [bp-20],ax
;
;
; tmp0 = MULTIPLY(tmp0, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */
;
mov ax,cx
shl ax, 2
add cx, ax
; mov dx,5
; imul dx
; mov cx,ax
;
; tmp1 = MULTIPLY(tmp1, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */
;
mov ax,di
mov dx, ax
shl dx, 5
add ax, dx
; mov dx,33
; imul dx
mov di,ax
;
; tmp2 = MULTIPLY(tmp2, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */
;
mov ax,word ptr [bp-2]
mov dx,49
imul dx
mov word ptr [bp-2],ax
;
; tmp3 = MULTIPLY(tmp3, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */
;
mov ax,word ptr [bp-4]
mov dx, ax
shl dx, 4
shl ax, 3
add ax, dx
; mov dx,24
; imul dx
mov word ptr [bp-4],ax
;
; z4 = MULTIPLY(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */
;
mov ax,word ptr [bp-18]
mov dx,-6
imul dx
mov word ptr [bp-18],ax
;
; z3 = MULTIPLY(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
;
mov ax,bx
mov dx,-31
imul dx
mov bx,ax
;
;
; z3 += z5;
;
add bx,word ptr [bp-20]
;
; z4 += z5;
;
mov ax,word ptr [bp-20]
add word ptr [bp-18],ax
;
;
; tmp1 += z2 + z4;
;
mov ax,word ptr [bp-16]
add ax,word ptr [bp-18]
add di,ax
;
; tmp3 += z1 + z4;
;
mov ax,word ptr [bp-14]
add ax,word ptr [bp-18]
add word ptr [bp-4],ax
;
; tmp0 += z1 + z3;
;
mov ax,word ptr [bp-14]
add ax,bx
add cx,ax
;
; tmp2 += z2 + z3;
;
mov ax,word ptr [bp-16]
add ax,bx
add word ptr [bp-2],ax
;
;
; /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
;
; dataptr[DCTSIZE*1] = (DCTELEM) DESCALE(tmp11 + tmp2,
;
;
; CONST_BITS+PASS1_BITS+3);
;
mov ax,word ptr [bp-8]
add ax,word ptr [bp-2]
add ax,64
sar ax,7
mov word ptr [si+16],ax
;
; dataptr[DCTSIZE*6] = (DCTELEM) DESCALE(tmp11 - tmp2,
;
;
; CONST_BITS+PASS1_BITS+3);
;
mov ax,word ptr [bp-8]
sub ax,word ptr [bp-2]
add ax,64
sar ax,7
mov word ptr [si+96],ax
;
; dataptr[DCTSIZE*0] = (DCTELEM) DESCALE(tmp10 + tmp3,
;
;
; CONST_BITS+PASS1_BITS+3);
;
mov ax,word ptr [bp-6]
add ax,word ptr [bp-4]
add ax,64
sar ax,7
mov word ptr [si],ax
;
; dataptr[DCTSIZE*7] = (DCTELEM) DESCALE(tmp10 - tmp3,
;
;
; CONST_BITS+PASS1_BITS+3);
;
mov ax,word ptr [bp-6]
sub ax,word ptr [bp-4]
add ax,64
sar ax,7
mov word ptr [si+112],ax
;
; dataptr[DCTSIZE*2] = (DCTELEM) DESCALE(tmp12 + tmp1,
;
;
; CONST_BITS+PASS1_BITS+3);
;
mov ax,word ptr [bp-10]
add ax,di
add ax,64
sar ax,7
mov word ptr [si+32],ax
;
; dataptr[DCTSIZE*5] = (DCTELEM) DESCALE(tmp12 - tmp1,
;
;
; CONST_BITS+PASS1_BITS+3);
;
mov ax,word ptr [bp-10]
sub ax,di
add ax,64
sar ax,7
mov word ptr [si+80],ax
;
; dataptr[DCTSIZE*3] = (DCTELEM) DESCALE(tmp13 + tmp0,
;
;
; CONST_BITS+PASS1_BITS+3);
;
mov ax,word ptr [bp-12]
add ax,cx
add ax,64
sar ax,7
mov word ptr [si+48],ax
;
; dataptr[DCTSIZE*4] = (DCTELEM) DESCALE(tmp13 - tmp0,
;
;
; CONST_BITS+PASS1_BITS+3);
;
mov ax,word ptr [bp-12]
sub ax,cx
add ax,64
sar ax,7
mov word ptr [si+64],ax
;
;
; dataptr++; /* advance pointer to next column */
;
add si,2
@1@310:
dec word ptr [bp-22]
@1@338:
cmp word ptr [bp-22],0
jl short @@11
jmp @1@226
@@11:
;
; }
; }
;
pop di
pop si
leave
ret
_j_rev_dct endp
;
; disassemble_noninterleaved_MCU (decompress_info_ptr cinfo,
;
assume cs:JREVDCT_TEXT
disassemble_noninterleaved_MCU proc far
push bp
mov bp,sp
sub sp,8
push si
push di
mov si,word ptr [bp+6]
mov di,word ptr [bp+8]
;
; JBLOCKIMAGE image_data)
; {
; JBLOCKROW MCU_data[1];
; long mcuindex;
;
; /* this is pretty easy since there is one component and one block per MCU */
;
; /* Pre-zero the target area to speed up entropy decoder */
; /* (we assume wholesale zeroing is faster than retail) */
; jzero_far((void FAR *) image_data[0][0],
;
;
; (size_t) (cinfo->MCUs_per_row * SIZEOF(JBLOCK)));
;
mov ax,word ptr [si+165]
shl ax,7
push ax
mov bx,word ptr [di]
push dword ptr [bx]
call far ptr _jzero_far
add sp,6
;
;
; for (mcuindex = 0; mcuindex < cinfo->MCUs_per_row; mcuindex++) {
;
mov dword ptr [bp-8],large 0
jmp short @2@114
@2@58:
;
; /* Point to the proper spot in the image array for this MCU */
; MCU_data[0] = image_data[0][0] + mcuindex;
;
mov bx,word ptr [di]
mov ax,word ptr [bx+2]
mov dx,word ptr [bx]
mov bx,word ptr [bp-8]
shl bx,7
add dx,bx
mov word ptr [bp-2],ax
mov word ptr [bp-4],dx
;
; /* Fetch the coefficient data */
; (*cinfo->methods->entropy_decode) (cinfo, MCU_data);
;
lea ax,word ptr [bp-4]
push ax
push si
mov bx,word ptr [si]
call dword ptr [bx+44]
add sp,4
inc dword ptr [bp-8]
@2@114:
mov eax,dword ptr [si+165]
cmp eax,dword ptr [bp-8]
jg short @2@58
;
; }
; }
;
pop di
pop si
leave
ret
disassemble_noninterleaved_MCU endp
;
; disassemble_interleaved_MCU (decompress_info_ptr cinfo,
;
assume cs:JREVDCT_TEXT
disassemble_interleaved_MCU proc far
push bp
mov bp,sp
sub sp,66
push si
push di
;
; JBLOCKIMAGE image_data)
; {
; JBLOCKROW MCU_data[MAX_BLOCKS_IN_MCU];
; long mcuindex;
; short blkn, ci, xpos, ypos;
; jpeg_component_info * compptr;
; JBLOCKROW image_ptr;
;
; /* Pre-zero the target area to speed up entropy decoder */
; /* (we assume wholesale zeroing is faster than retail) */
; for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
;
mov word ptr [bp-6],0
mov ax,word ptr [bp+6]
add ax,157
mov word ptr [bp-14],ax
mov ax,word ptr [bp+8]
mov word ptr [bp-16],ax
jmp short @3@338
@3@86:
;
; compptr = cinfo->cur_comp_info[ci];
;
mov bx,word ptr [bp-14]
mov si,word ptr [bx]
;
; for (ypos = 0; ypos < compptr->MCU_height; ypos++) {
;
mov word ptr [bp-8],0
xor di,di
jmp short @3@226
@3@142:
;
; jzero_far((void FAR *) image_data[ci][ypos],
;
;
; (size_t) (cinfo->MCUs_per_row * compptr->MCU_width * SIZEOF(JBLOCK)));
;
movsx eax,word ptr [si+22]
mov bx,word ptr [bp+6]
mov edx,dword ptr [bx+165]
imul edx,eax
shl dx,7
push dx
mov bx,word ptr [bp-16]
mov bx,word ptr [bx]
add bx,di
push dword ptr [bx]
call far ptr _jzero_far
add sp,6
add di,4
inc word ptr [bp-8]
@3@226:
mov ax,word ptr [si+24]
cmp ax,word ptr [bp-8]
jg short @3@142
add word ptr [bp-14],2
add word ptr [bp-16],2
inc word ptr [bp-6]
@3@338:
mov bx,word ptr [bp+6]
mov ax,word ptr [bx+155]
cmp ax,word ptr [bp-6]
jg short @3@86
;
; }
; }
;
; for (mcuindex = 0; mcuindex < cinfo->MCUs_per_row; mcuindex++) {
;
mov dword ptr [bp-4],large 0
jmp @3@982
@3@394:
;
; /* Point to the proper spots in the image array for this MCU */
; blkn = 0;
;
;
; for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
;
mov word ptr [bp-6],0
lea ax,word ptr [bp-66]
mov word ptr [bp-22],ax
mov ax,word ptr [bp+6]
add ax,157
mov word ptr [bp-24],ax
mov ax,word ptr [bp+8]
mov word ptr [bp-26],ax
jmp @3@898
@3@450:
;
; compptr = cinfo->cur_comp_info[ci];
;
mov bx,word ptr [bp-24]
mov si,word ptr [bx]
;
; for (ypos = 0; ypos < compptr->MCU_height; ypos++) {
;
mov word ptr [bp-8],0
mov ax,word ptr [bp-22]
mov word ptr [bp-18],ax
mov word ptr [bp-20],0
jmp short @3@786
@3@506:
;
; image_ptr = image_data[ci][ypos] + (mcuindex * compptr->MCU_width);
;
movsx eax,word ptr [si+22]
mov edx,dword ptr [bp-4]
imul edx,eax
shl dx,7
mov bx,word ptr [bp-26]
mov bx,word ptr [bx]
add bx,word ptr [bp-20]
mov ax,word ptr [bx+2]
mov bx,word ptr [bx]
add bx,dx
mov word ptr [bp-10],ax
mov word ptr [bp-12],bx
;
; for (xpos = 0; xpos < compptr->MCU_width; xpos++) {
;
xor cx,cx
mov di,word ptr [bp-18]
jmp short @3@702
@3@562:
;
; MCU_data[blkn] = image_ptr;
;
mov ax,word ptr [bp-10]
mov dx,word ptr [bp-12]
mov word ptr [di+2],ax
mov word ptr [di],dx
;
; image_ptr++;
;
add word ptr [bp-12],128
;
; blkn++;
;
add di,4
add word ptr [bp-18],4
add word ptr [bp-22],4
inc cx
@3@702:
cmp word ptr [si+22],cx
jg short @3@562
add word ptr [bp-20],4
inc word ptr [bp-8]
@3@786:
mov ax,word ptr [si+24]
cmp ax,word ptr [bp-8]
jg short @3@506
add word ptr [bp-24],2
add word ptr [bp-26],2
inc word ptr [bp-6]
@3@898:
mov bx,word ptr [bp+6]
mov ax,word ptr [bx+155]
cmp ax,word ptr [bp-6]
jle short @@12
jmp @3@450
@@12:
;
; }
; }
; }
; /* Fetch the coefficient data */
; (*cinfo->methods->entropy_decode) (cinfo, MCU_data);
;
lea ax,word ptr [bp-66]
push ax
push bx
mov bx,word ptr [bx]
call dword ptr [bx+44]
add sp,4
inc dword ptr [bp-4]
@3@982:
mov bx,word ptr [bp+6]
mov eax,dword ptr [bx+165]
cmp eax,dword ptr [bp-4]
jle short @@13
jmp @3@394
@@13:
;
; }
; }
;
pop di
pop si
leave
ret
disassemble_interleaved_MCU endp
;
; reverse_DCT (decompress_info_ptr cinfo,
;
assume cs:JREVDCT_TEXT
reverse_DCT proc far
push bp
mov bp,sp
sub sp,164
push si
push di
;
; JBLOCKIMAGE coeff_data, JSAMPIMAGE output_data, int start_row)
; {
; DCTBLOCK block;
; JBLOCKROW browptr;
; JSAMPARRAY srowptr;
; jpeg_component_info * compptr;
; int blocksperrow, bi;
; /* long blocksperrow, bi;*/
; short numrows, ri;
; short ci;
;
; for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
;
mov word ptr [bp-16],0
mov ax,word ptr [bp+6]
add ax,157
mov word ptr [bp-28],ax
mov ax,word ptr [bp+8]
mov word ptr [bp-30],ax
mov ax,word ptr [bp+10]
mov word ptr [bp-32],ax
jmp @4@898
@4@86:
;
; compptr = cinfo->cur_comp_info[ci];
;
mov bx,word ptr [bp-28]
mov si,word ptr [bx]
;
; /* don't bother to IDCT an uninteresting component */
; if (! compptr->component_needed)
;
cmp word ptr [si+36],0
jne short @@14
jmp @4@786
@@14:
;
; continue;
; /* calculate size of an MCU row in this component */
; blocksperrow = compptr->downsampled_width / DCTSIZE;
;
mov eax,dword ptr [si+28]
mov ebx,large 8
cdq
idiv ebx
mov word ptr [bp-8],ax
;
; numrows = compptr->MCU_height;
;
mov ax,word ptr [si+24]
mov word ptr [bp-12],ax
;
; /* iterate through all blocks in MCU row */
; for (ri = 0; ri < numrows; ri++) {
;
mov word ptr [bp-14],0
mov word ptr [bp-24],0
mov ax,word ptr [bp+12]
shl ax,2
mov word ptr [bp-26],ax
mov ax,word ptr [bp-14]
cmp ax,word ptr [bp-12]
jl short @@15
jmp @4@786
@@15:
@4@198:
;
; browptr = coeff_data[ci][ri];
;
mov bx,word ptr [bp-30]
mov bx,word ptr [bx]
add bx,word ptr [bp-24]
mov ax,word ptr [bx+2]
mov dx,word ptr [bx]
mov word ptr [bp-2],ax
mov word ptr [bp-4],dx
;
; srowptr = output_data[ci] + (ri * DCTSIZE + start_row);
;
mov bx,word ptr [bp-32]
mov ax,word ptr [bx]
add ax,word ptr [bp-26]
mov word ptr [bp-6],ax
;
; for (bi = 0; bi < blocksperrow; bi++) {
;
mov word ptr [bp-10],0
mov ax,word ptr [bp-4]
mov word ptr [bp-20],ax
mov word ptr [bp-22],0
mov ax,word ptr [bp-10]
cmp ax,word ptr [bp-8]
jl short @@16
jmp @4@674
@@16:
@4@282:
;
; /* copy the data into a local DCTBLOCK. This allows for change of
; * representation (if DCTELEM != JCOEF). On 80x86 machines it also
; * brings the data back from FAR storage to NEAR storage.
; */
; { register JCOEFPTR elemptr = browptr[bi];
;
mov ax,word ptr [bp-2]
mov dx,word ptr [bp-20]
mov word ptr [bp-34],ax
mov word ptr [bp-36],dx
;
; register DCTELEM *localblkptr = block;
;
lea si,word ptr [bp-164]
;
; register int elem = DCTSIZE2;
;
mov cx, di
les di,dword ptr [bp-36]
mov dx,64
jmp short @4@338
@4@310:
;
;
; while (--elem >= 0)
; *localblkptr++ = (DCTELEM) *elemptr++;
;
; les bx,dword ptr [bp-36]
mov ax,word ptr es:[di]
mov word ptr [si],ax
add di, 2
; add word ptr [bp-36],2
add si,2
@4@338:
dec dx
jge short @4@310
mov di, cx
;
; }
;
; j_rev_dct(block); /* perform inverse DCT */
;
lea ax,word ptr [bp-164]
push ax
call near ptr _j_rev_dct
add sp,2
;
;
; /* Output the data into the sample array.
; * Note change from signed to unsigned representation:
; * DCT calculation works with values +-CENTERJSAMPLE,
; * but sample arrays always hold 0..MAXJSAMPLE.
; * We have to do range-limiting because of quantization errors in the
; * DCT/IDCT phase. We use the sample_range_limit[] table to do this
; * quickly; the CENTERJSAMPLE offset is folded into table indexing.
; */
; { register JSAMPROW elemptr;
; register DCTELEM *localblkptr = block;
;
lea si,word ptr [bp-164]
;
; register JSAMPLE *range_limit = cinfo->sample_range_limit +
;
;
; CENTERJSAMPLE;
;
mov bx,word ptr [bp+6]
mov cx,word ptr [bx+145]
add cx,128
;
; #if DCTSIZE != 8
; register int elemc;
; #endif
; register int elemr;
;
; for (elemr = 0; elemr < DCTSIZE; elemr++) {
;
xor di,di
mov ax,word ptr [bp-6]
mov word ptr [bp-18],ax
@4@450:
;
; elemptr = srowptr[elemr] + (bi * DCTSIZE);
;
mov bx,word ptr [bp-18]
mov ax,word ptr [bx+2]
mov dx,word ptr [bx]
add dx,word ptr [bp-22]
mov word ptr [bp-34],ax
mov word ptr [bp-36],dx
;
; #if DCTSIZE == 8 /* unroll the inner loop */
; *elemptr++ = range_limit[*localblkptr++];
;
mov dx, di
les di,dword ptr [bp-36]
mov bx,cx
add bx,word ptr [si]
;mov bx,ax
mov al,byte ptr [bx]
; les bx,dword ptr [bp-36]
mov byte ptr es:[di],al
add si,2
inc di
; inc word ptr [bp-36]
;
; *elemptr++ = range_limit[*localblkptr++];
;
mov bx,cx
add bx,word ptr [si]
; mov bx,ax
mov al,byte ptr [bx]
; les bx,dword ptr [bp-36]
mov byte ptr es:[di],al
add si,2
inc di
; inc word ptr [bp-36]
;
; *elemptr++ = range_limit[*localblkptr++];
;
mov bx,cx
add bx,word ptr [si]
; mov bx,ax
mov al,byte ptr [bx]
; les bx,dword ptr [bp-36]
mov byte ptr es:[di],al
add si,2
inc di
; inc word ptr [bp-36]
;
; *elemptr++ = range_limit[*localblkptr++];
;
mov bx,cx
add bx,word ptr [si]
; mov bx,ax
mov al,byte ptr [bx]
; les bx,dword ptr [bp-36]
mov byte ptr es:[di],al
add si,2
inc di
; inc word ptr [bp-36]
;
; *elemptr++ = range_limit[*localblkptr++];
;
mov bx,cx
add bx,word ptr [si]
; mov bx,ax
mov al,byte ptr [bx]
; les bx,dword ptr [bp-36]
mov byte ptr es:[di],al
add si,2
inc di
; inc word ptr [bp-36]
;
; *elemptr++ = range_limit[*localblkptr++];
;
mov bx,cx
add bx,word ptr [si]
; mov bx,ax
mov al,byte ptr [bx]
; les bx,dword ptr [bp-36]
mov byte ptr es:[di],al
add si,2
inc di
; inc word ptr [bp-36]
;
; *elemptr++ = range_limit[*localblkptr++];
;
mov bx,cx
add bx,word ptr [si]
; mov bx,ax
mov al,byte ptr [bx]
; les bx,dword ptr [bp-36]
mov byte ptr es:[di],al
add si,2
inc di
; inc word ptr [bp-36]
;
; *elemptr = range_limit[*localblkptr++];
;
mov bx,cx
add bx,word ptr [si]
; mov bx,ax
mov al,byte ptr [bx]
; les bx,dword ptr [bp-36]
mov byte ptr es:[di],al
add si,2
add word ptr [bp-18],4
mov di, dx
inc di
cmp di,8
jge short @@17
jmp @4@450
@@17:
add word ptr [bp-20],128
add word ptr [bp-22],8
inc word ptr [bp-10]
mov ax,word ptr [bp-10]
cmp ax,word ptr [bp-8]
jge short @@18
jmp @4@282
@@18:
@4@674:
add word ptr [bp-24],4
add word ptr [bp-26],32
inc word ptr [bp-14]
mov ax,word ptr [bp-14]
cmp ax,word ptr [bp-12]
jge short @@19
jmp @4@198
@@19:
@4@786:
add word ptr [bp-28],2
add word ptr [bp-30],2
add word ptr [bp-32],2
inc word ptr [bp-16]
@4@898:
mov bx,word ptr [bp+6]
mov ax,word ptr [bx+155]
cmp ax,word ptr [bp-16]
jle short @@20
jmp @4@86
@@20:
;
; #else
; for (elemc = DCTSIZE; elemc > 0; elemc--) {
; *elemptr++ = range_limit[*localblkptr++];
; }
; #endif
; }
; }
; }
; }
; }
; }
;
pop di
pop si
leave
ret
reverse_DCT endp
;
; disassemble_init (decompress_info_ptr cinfo)
;
assume cs:JREVDCT_TEXT
disassemble_init proc far
push bp
mov bp,sp
;
; {
; /* no work for now */
; }
;
pop bp
ret
disassemble_init endp
;
; disassemble_term (decompress_info_ptr cinfo)
;
assume cs:JREVDCT_TEXT
disassemble_term proc far
push bp
mov bp,sp
;
; {
; /* no work for now */
; }
;
pop bp
ret
disassemble_term endp
;
; jseldmcu (decompress_info_ptr cinfo)
;
assume cs:JREVDCT_TEXT
_jseldmcu proc far
push bp
mov bp,sp
push si
mov si,word ptr [bp+6]
;
; {
; if (cinfo->comps_in_scan == 1)
;
cmp word ptr [si+155],1
jne short @7@86
;
; cinfo->methods->disassemble_MCU = disassemble_noninterleaved_MCU;
;
mov bx,word ptr [si]
mov word ptr [bx+58],seg disassemble_noninterleaved_MCU
mov word ptr [bx+56],offset disassemble_noninterleaved_MCU
jmp short @7@114
@7@86:
;
; else
; cinfo->methods->disassemble_MCU = disassemble_interleaved_MCU;
;
mov bx,word ptr [si]
mov word ptr [bx+58],seg disassemble_interleaved_MCU
mov word ptr [bx+56],offset disassemble_interleaved_MCU
@7@114:
;
; cinfo->methods->reverse_DCT = reverse_DCT;
;
mov bx,word ptr [si]
mov word ptr [bx+62],seg reverse_DCT
mov word ptr [bx+60],offset reverse_DCT
;
; cinfo->methods->disassemble_init = disassemble_init;
;
mov word ptr [bx+54],seg disassemble_init
mov word ptr [bx+52],offset disassemble_init
;
; cinfo->methods->disassemble_term = disassemble_term;
;
mov word ptr [bx+66],seg disassemble_term
mov word ptr [bx+64],offset disassemble_term
;
; }
;
pop si
pop bp
ret
_jseldmcu endp
?debug C E9
?debug C FA15010000
JREVDCT_TEXT ends
_DATA segment word public use16 'DATA'
s@ label byte
_DATA ends
JREVDCT_TEXT segment byte public use16 'CODE'
JREVDCT_TEXT ends
_disassemble_term equ disassemble_term
_disassemble_init equ disassemble_init
_reverse_DCT equ reverse_DCT
_disassemble_interleaved_MCU equ disassemble_interleaved_MCU
_disassemble_noninterleaved_MCU equ disassemble_noninterleaved_MCU
public _jseldmcu
extrn _jzero_far:far
public _j_rev_dct
_s@ equ s@
end