home *** CD-ROM | disk | FTP | other *** search
/ High Voltage Shareware / high1.zip / high1 / DIR2 / DVPG30FS.ZIP / JREVDCT.ASM < prev    next >
Assembly Source File  |  1993-11-27  |  34KB  |  1,567 lines
  1.     .386p
  2.     ifndef    ??version
  3. ?debug    macro
  4.     endm
  5. publicdll macro    name
  6.     public    name
  7.     endm
  8.     endif
  9.     ?debug    V 300h
  10.     ?debug    S "JREVDCT.C"
  11.     ?debug    C E9057E7B1B094A5245564443542E43
  12.     ?debug    C E9CC8DEB1A0A4A494E434C5544452E48
  13.     ?debug    C E94019CA181B443A5C424F524C414E44435C494E434C5544455C53+
  14.     ?debug    C 5444494F2E48
  15.     ?debug    C E94019CA181B443A5C424F524C414E44435C494E434C5544455C5F+
  16.     ?debug    C 444546532E48
  17.     ?debug    C E94019CA181C443A5C424F524C414E44435C494E434C5544455C5F+
  18.     ?debug    C 4E46494C452E48
  19.     ?debug    C E94019CA181B443A5C424F524C414E44435C494E434C5544455C5F+
  20.     ?debug    C 4E554C4C2E48
  21.     ?debug    C E94019CA181C443A5C424F524C414E44435C494E434C5544455C53+
  22.     ?debug    C 5452494E472E48
  23.     ?debug    C E9F696681B094A434F4E4649472E48
  24.     ?debug    C E90D95161B0A4A504547444154412E48
  25. JREVDCT_TEXT    segment byte public use16 'CODE'
  26. JREVDCT_TEXT    ends
  27. DGROUP    group    _DATA,_BSS
  28.     assume    cs:JREVDCT_TEXT,ds:DGROUP
  29. _DATA    segment word public use16 'DATA'
  30. d@    label    byte
  31. d@w    label    word
  32. _DATA    ends
  33. _BSS    segment word public use16 'BSS'
  34. b@    label    byte
  35. b@w    label    word
  36. _BSS    ends
  37. JREVDCT_TEXT    segment byte public use16 'CODE'
  38.    ;    
  39.    ;    j_rev_dct (DCTBLOCK data)
  40.    ;    
  41.     assume    cs:JREVDCT_TEXT
  42. _j_rev_dct    proc    near
  43.     push    bp
  44.     mov    bp,sp
  45.     sub    sp,28
  46.     push    si
  47.     push    di
  48.    ;    
  49.    ;    {
  50.    ;      int tmp0, tmp1, tmp2, tmp3;
  51.    ;      int    tmp10, tmp11, tmp12, tmp13;
  52.    ;      int z1, z2, z3, z4, z5;
  53.    ;      register DCTELEM *dataptr;
  54.    ;      JSAMPROW data_ptr;
  55.    ;      int rowctr;
  56.    ;      SHIFT_TEMPS
  57.    ;    
  58.    ;      /* Pass 2: process columns. */
  59.    ;      /* Note that we must descale the results by a factor of 8 == 2**3, */
  60.    ;      /* and also undo the PASS1_BITS scaling. */
  61.    ;    
  62.    ;      dataptr = data;
  63.    ;    
  64.     mov    si,word ptr [bp+4]
  65.    ;    
  66.    ;      for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--) {
  67.    ;    
  68.     mov    word ptr [bp-26],7
  69.     jmp    @1@170
  70. @1@58:
  71.    ;    
  72.    ;         /* Columns of zeroes can be exploited in the same way as we did with rows.
  73.    ;          * However, the row calculation has created many nonzero AC terms, so the
  74.     ;          * simplification applies less often (typically 5% to 10% of the time).
  75.    ;          * On machines with very fast multiplication, it's possible that the
  76.    ;          * test takes more time than it's worth.  In that case this section
  77.    ;          * may be commented out.
  78.     ;          */
  79.    ;    
  80.    ;    #ifndef NO_ZERO_COLUMN_TEST
  81.    ;         if ((dataptr[DCTSIZE*1] | dataptr[DCTSIZE*2] | dataptr[DCTSIZE*3] |
  82.    ;    
  83.    ;    
  84.    ;         dataptr[DCTSIZE*4] | dataptr[DCTSIZE*5] | dataptr[DCTSIZE*6] |
  85.    ;         dataptr[DCTSIZE*7]) == 0) {
  86.    ;    
  87.     mov    ax,word ptr [si+16]
  88.     or    ax,word ptr [si+32]
  89.     or    ax,word ptr [si+48]
  90.     or    ax,word ptr [si+64]
  91.     or    ax,word ptr [si+80]
  92.     or    ax,word ptr [si+96]
  93.     or    ax,word ptr [si+112]
  94.     jne    short @1@114
  95.    ;    
  96.    ;            /* AC terms all zero */
  97.    ;            DCTELEM dcval = (DCTELEM) (dataptr[0] << PASS1_BITS);
  98.    ;    
  99.     mov    dx,word ptr [si]
  100.     shl    dx,0
  101.    ;    
  102.    ;    /*        DCTELEM dcval = (DCTELEM) DESCALE((int) dataptr[0], PASS1_BITS);*/
  103.    ;    
  104.    ;            dataptr[DCTSIZE*0] = dcval;
  105.    ;    
  106.     mov    word ptr [si],dx
  107.    ;    
  108.    ;            dataptr[DCTSIZE*1] = dcval;
  109.    ;    
  110.     mov    word ptr [si+16],dx
  111.    ;    
  112.    ;            dataptr[DCTSIZE*2] = dcval;
  113.    ;    
  114.     mov    word ptr [si+32],dx
  115.    ;    
  116.    ;            dataptr[DCTSIZE*3] = dcval;
  117.    ;    
  118.     mov    word ptr [si+48],dx
  119.     ;
  120.    ;            dataptr[DCTSIZE*4] = dcval;
  121.    ;    
  122.     mov    word ptr [si+64],dx
  123.     ;
  124.    ;            dataptr[DCTSIZE*5] = dcval;
  125.    ;    
  126.     mov    word ptr [si+80],dx
  127.    ;    
  128.    ;            dataptr[DCTSIZE*6] = dcval;
  129.    ;    
  130.     mov    word ptr [si+96],dx
  131.    ;    
  132.    ;            dataptr[DCTSIZE*7] = dcval;
  133.    ;    
  134.     mov    word ptr [si+112],dx
  135.    ;    
  136.    ;    
  137.    ;            dataptr++;        /* advance pointer to next column */
  138.    ;    
  139.     add    si,2
  140.    ;    
  141.    ;            continue;
  142.    ;    
  143.     jmp    @1@142
  144. @1@114:
  145.    ;    
  146.    ;         }
  147.    ;    #endif
  148.    ;    
  149.    ;         /* Even part: reverse the even part of the forward DCT. */
  150.    ;         /* The rotator is sqrt(2)*c(-6). */
  151.    ;    
  152.    ;         z2 = (int) dataptr[DCTSIZE*2];
  153.    ;    
  154.     mov    ax,word ptr [si+32]
  155.     mov    word ptr [bp-16],ax
  156.    ;    
  157.    ;         z3 = (int) dataptr[DCTSIZE*6];
  158.    ;    
  159.     mov    bx,word ptr [si+96]
  160.    ;    
  161.    ;    
  162.    ;         z1 = MULTIPLY(z2 + z3, FIX_0_541196100);
  163.    ;    
  164.     add    ax,bx
  165.     mov    dx,9
  166.     imul    dx
  167.     mov    word ptr [bp-14],ax
  168.     ;
  169.    ;         tmp2 = z1 + MULTIPLY(z3, - FIX_1_847759065);
  170.    ;    
  171.     mov    ax,bx
  172.     mov    dx,-30
  173.     imul    dx
  174.     mov    dx,word ptr [bp-14]
  175.     add    dx,ax
  176.     mov    word ptr [bp-2],dx
  177.    ;    
  178.    ;         tmp3 = z1 + MULTIPLY(z2, FIX_0_765366865);
  179.    ;    
  180.     mov    ax,word ptr [bp-16]
  181.     mov    dx,12
  182.     imul    dx
  183.     mov    dx,word ptr [bp-14]
  184.     add    dx,ax
  185.     mov    word ptr [bp-4],dx
  186.    ;    
  187.    ;    
  188.    ;         tmp1 = ((int) dataptr[DCTSIZE*0] - (int) dataptr[DCTSIZE*4]) << CONST_BITS;
  189.    ;    
  190.     mov    ax,word ptr [si]
  191.     mov    dx,ax
  192.     sub    ax,word ptr [si+64]
  193.     shl    ax,4
  194.     mov    di,ax
  195.    ;    
  196.    ;         tmp0 = ((int) dataptr[DCTSIZE*0] + (int) dataptr[DCTSIZE*4]) << CONST_BITS;
  197.    ;    
  198.     mov    ax,dx
  199.     add    ax,word ptr [si+64]
  200.     shl    ax,4
  201.     mov    cx,ax
  202.    ;    
  203.    ;    
  204.    ;         tmp10 = tmp0 + tmp3;
  205.    ;    
  206.     add    ax,word ptr [bp-4]
  207.     mov    word ptr [bp-6],ax
  208.    ;    
  209.     ;         tmp13 = tmp0 - tmp3;
  210.    ;    
  211.     mov    ax,cx
  212.     sub    ax,word ptr [bp-4]
  213.     mov    word ptr [bp-12],ax
  214.    ;    
  215.    ;         tmp11 = tmp1 + tmp2;
  216.    ;    
  217.     mov    ax,di
  218.     add    ax,word ptr [bp-2]
  219.     mov    word ptr [bp-8],ax
  220.    ;    
  221.    ;         tmp12 = tmp1 - tmp2;
  222.    ;    
  223.     mov    ax,di
  224.     sub    ax,word ptr [bp-2]
  225.     mov    word ptr [bp-10],ax
  226.    ;    
  227.    ;    
  228.    ;         /* Odd part per figure 8; the matrix is unitary and hence its
  229.    ;          * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
  230.    ;          */
  231.    ;    
  232.    ;         tmp0 = (int) dataptr[DCTSIZE*7];
  233.    ;    
  234.     mov    cx,word ptr [si+112]
  235.    ;    
  236.    ;         tmp3 = (int) dataptr[DCTSIZE*1];
  237.    ;    
  238.     mov    ax,word ptr [si+16]
  239.     mov    word ptr [bp-4],ax
  240.    ;    
  241.    ;    
  242.    ;         z1 = tmp0 + tmp3;
  243.    ;    
  244.     mov    ax,cx
  245.     add    ax,word ptr [bp-4]
  246.     mov    word ptr [bp-14],ax
  247.    ;    
  248.    ;         z1 = MULTIPLY(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */
  249.    ;    
  250.     mov    dx,-14
  251.     imul    dx
  252.     mov    word ptr [bp-14],ax
  253.    ;    
  254.     ;         tmp1 = (int) dataptr[DCTSIZE*5];
  255.    ;    
  256.     mov    di,word ptr [si+80]
  257.    ;    
  258.     ;         tmp2 = (int) dataptr[DCTSIZE*3];
  259.    ;    
  260.     mov    ax,word ptr [si+48]
  261.     mov    word ptr [bp-2],ax
  262.    ;    
  263.    ;         z2 = tmp1 + tmp2;
  264.    ;    
  265.     mov    ax,di
  266.     add    ax,word ptr [bp-2]
  267.     mov    word ptr [bp-16],ax
  268.    ;    
  269.    ;         z2 = MULTIPLY(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
  270.    ;    
  271.     mov    dx,-41
  272.     imul    dx
  273.     mov    word ptr [bp-16],ax
  274.    ;    
  275.    ;         z3 = tmp0 + tmp2;
  276.    ;    
  277.     mov    bx,cx
  278.     add    bx,word ptr [bp-2]
  279.    ;    
  280.    ;         z4 = tmp1 + tmp3;
  281.    ;    
  282.     mov    ax,di
  283.     add    ax,word ptr [bp-4]
  284.     mov    word ptr [bp-18],ax
  285.    ;    
  286.    ;         z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */
  287.    ;    
  288.     mov    ax,bx
  289.     add    ax,word ptr [bp-18]
  290.     mov    dx,19
  291.     imul    dx
  292.     mov    word ptr [bp-20],ax
  293.    ;    
  294.    ;    
  295.    ;         tmp0 = MULTIPLY(tmp0, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */
  296.    ;    
  297.     mov    ax,cx
  298. shl cx, 2
  299. add cx, ax
  300. ;    mov    dx,5
  301. ;    imul    dx
  302. ;    mov    cx,ax
  303.     ;
  304.     ;         tmp1 = MULTIPLY(tmp1, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */
  305.     ;
  306.     mov    ax,di
  307. shl ax, 5
  308. add di, ax
  309. ;    mov    dx,33
  310. ;    imul    dx
  311. ;    mov    di,ax
  312.    ;    
  313.    ;         tmp2 = MULTIPLY(tmp2, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */
  314.    ;    
  315.     mov    ax,word ptr [bp-2]
  316.     mov    dx,49
  317.     imul    dx
  318.     mov    word ptr [bp-2],ax
  319.    ;    
  320.    ;         tmp3 = MULTIPLY(tmp3, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */
  321.    ;    
  322.     mov    ax,word ptr [bp-4]
  323.     mov    dx,24
  324.     imul    dx
  325.     mov    word ptr [bp-4],ax
  326.    ;    
  327.    ;         z4 = MULTIPLY(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */
  328.    ;    
  329.     mov    ax,word ptr [bp-18]
  330.     mov    dx,-6
  331.     imul    dx
  332.     mov    word ptr [bp-18],ax
  333.    ;    
  334.    ;         z3 = MULTIPLY(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
  335.    ;    
  336.     mov    ax,bx
  337.     mov    dx,-31
  338.     imul    dx
  339.     mov    bx,ax
  340.    ;    
  341.    ;    
  342.     ;         z3 += z5;
  343.    ;    
  344.     add    bx,word ptr [bp-20]
  345.    ;    
  346.    ;         z4 += z5;
  347.     ;
  348.     mov    ax,word ptr [bp-20]
  349.     add    word ptr [bp-18],ax
  350.    ;    
  351.    ;    
  352.    ;         tmp1 += z2 + z4;
  353.    ;    
  354.     mov    ax,word ptr [bp-16]
  355.     add    ax,word ptr [bp-18]
  356.     add    di,ax
  357.    ;    
  358.    ;         tmp3 += z1 + z4;
  359.    ;    
  360.     mov    ax,word ptr [bp-14]
  361.     add    ax,word ptr [bp-18]
  362.     add    word ptr [bp-4],ax
  363.    ;    
  364.    ;         tmp0 += z1 + z3;
  365.    ;    
  366.     mov    ax,word ptr [bp-14]
  367.     add    ax,bx
  368.     add    cx,ax
  369.    ;    
  370.    ;         tmp2 += z2 + z3;
  371.    ;    
  372.     mov    ax,word ptr [bp-16]
  373.     add    ax,bx
  374.     add    word ptr [bp-2],ax
  375.    ;    
  376.    ;    
  377.    ;         /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
  378.    ;    
  379.    ;         dataptr[DCTSIZE*1] = (DCTELEM) DESCALE(tmp11 + tmp2,
  380.    ;    
  381.    ;    
  382.     ;                            CONST_BITS-PASS1_BITS);
  383.    ;    
  384.     mov    ax,word ptr [bp-8]
  385.     add    ax,word ptr [bp-2]
  386.     add    ax,8
  387.     sar    ax,4
  388.     mov    word ptr [si+16],ax
  389.    ;    
  390.     ;         dataptr[DCTSIZE*6] = (DCTELEM) DESCALE(tmp11 - tmp2,
  391.    ;    
  392.    ;    
  393.     ;                            CONST_BITS-PASS1_BITS);
  394.    ;    
  395.     mov    ax,word ptr [bp-8]
  396.     sub    ax,word ptr [bp-2]
  397.     add    ax,8
  398.     sar    ax,4
  399.     mov    word ptr [si+96],ax
  400.    ;    
  401.    ;         dataptr[DCTSIZE*0] = (DCTELEM) DESCALE(tmp10 + tmp3,
  402.    ;    
  403.    ;    
  404.    ;                            CONST_BITS-PASS1_BITS);
  405.    ;    
  406.     mov    ax,word ptr [bp-6]
  407.     add    ax,word ptr [bp-4]
  408.     add    ax,8
  409.     sar    ax,4
  410.     mov    word ptr [si],ax
  411.    ;    
  412.    ;         dataptr[DCTSIZE*7] = (DCTELEM) DESCALE(tmp10 - tmp3,
  413.    ;    
  414.    ;    
  415.    ;                            CONST_BITS-PASS1_BITS);
  416.    ;    
  417.     mov    ax,word ptr [bp-6]
  418.     sub    ax,word ptr [bp-4]
  419.     add    ax,8
  420.     sar    ax,4
  421.     mov    word ptr [si+112],ax
  422.    ;    
  423.    ;         dataptr[DCTSIZE*2] = (DCTELEM) DESCALE(tmp12 + tmp1,
  424.    ;    
  425.    ;    
  426.    ;                            CONST_BITS-PASS1_BITS);
  427.     ;
  428.     mov    ax,word ptr [bp-10]
  429.     add    ax,di
  430.     add    ax,8
  431.     sar    ax,4
  432.     mov    word ptr [si+32],ax
  433.     ;
  434.    ;         dataptr[DCTSIZE*5] = (DCTELEM) DESCALE(tmp12 - tmp1,
  435.    ;    
  436.    ;    
  437.    ;                            CONST_BITS-PASS1_BITS);
  438.     ;
  439.     mov    ax,word ptr [bp-10]
  440.     sub    ax,di
  441.     add    ax,8
  442.     sar    ax,4
  443.     mov    word ptr [si+80],ax
  444.    ;    
  445.    ;         dataptr[DCTSIZE*3] = (DCTELEM) DESCALE(tmp13 + tmp0,
  446.    ;    
  447.    ;    
  448.    ;                            CONST_BITS-PASS1_BITS);
  449.    ;    
  450.     mov    ax,word ptr [bp-12]
  451.     add    ax,cx
  452.     add    ax,8
  453.     sar    ax,4
  454.     mov    word ptr [si+48],ax
  455.    ;    
  456.    ;         dataptr[DCTSIZE*4] = (DCTELEM) DESCALE(tmp13 - tmp0,
  457.    ;    
  458.    ;    
  459.    ;                            CONST_BITS-PASS1_BITS);
  460.    ;    
  461.     mov    ax,word ptr [bp-12]
  462.     sub    ax,cx
  463.     add    ax,8
  464.     sar    ax,4
  465.     mov    word ptr [si+64],ax
  466.    ;    
  467.    ;    
  468.    ;         dataptr++;            /* advance pointer to next column */
  469.    ;    
  470.     add    si,2
  471. @1@142:
  472.     dec    word ptr [bp-26]
  473. @1@170:
  474.     cmp    word ptr [bp-26],0
  475.     jl short    @@0
  476.     jmp    @1@58
  477. @@0:
  478.    ;    
  479.    ;      }
  480.    ;    
  481.    ;      /* Pass 1: process rows. */
  482.    ;      /* Note results are scaled up by sqrt(8) compared to a true IDCT; */
  483.     ;      /* furthermore, we scale the results by 2**PASS1_BITS. */
  484.    ;    
  485.    ;    
  486.    ;      dataptr = data;
  487.    ;    
  488.     mov    si,word ptr [bp+4]
  489.    ;    
  490.    ;      for (rowctr = DCTSIZE-1; rowctr >= 0; rowctr--) {
  491.    ;    
  492.     mov    word ptr [bp-26],7
  493.     mov    word ptr [bp-28],4
  494.     jmp    @1@394
  495. @1@254:
  496.    ;    
  497.    ;    /*    tmp0 = srowptr[DCTSIZE - rowctr - 1];*/
  498.    ;        data_ptr = elemptr + srowptr[DCTSIZE - rowctr - 1];
  499.    ;    
  500.     mov    bx,word ptr [bp-28]
  501.     add    bx,word ptr DGROUP:_srowptr
  502.     mov    ax,word ptr [bx-2]
  503.     mov    dx,word ptr [bx-4]
  504.     add    dx,word ptr DGROUP:_elemptr
  505.     mov    word ptr [bp-22],ax
  506.     mov    word ptr [bp-24],dx
  507.    ;    
  508.    ;    
  509.    ;         /* Due to quantization, we will usually find that many of the input
  510.    ;          * coefficients are zero, especially the AC terms.  We can exploit this
  511.    ;          * by short-circuiting the IDCT calculation for any row in which all
  512.    ;          * the AC terms are zero.  In that case each output is equal to the
  513.    ;          * DC coefficient (with scale factor as needed).
  514.    ;          * With typical images and quantization tables, half or more of the
  515.    ;          * row DCT calculations can be simplified this way.
  516.    ;          */
  517.     ;
  518.    ;         if ((dataptr[1] | dataptr[2] | dataptr[3] | dataptr[4] |
  519.     ;
  520.    ;    
  521.    ;         dataptr[5] | dataptr[6] | dataptr[7]) == 0) {
  522.     ;
  523.     mov    ax,word ptr [si+2]
  524.     or    ax,word ptr [si+4]
  525.     or    ax,word ptr [si+6]
  526.     or    ax,word ptr [si+8]
  527.     or    ax,word ptr [si+10]
  528.     or    ax,word ptr [si+12]
  529.     or    ax,word ptr [si+14]
  530.     jne    short @1@310
  531.    ;    
  532.    ;            /* AC terms all zero */
  533.    ;    /*        DCTELEM dcval = (DCTELEM) (dataptr[0] << (CONST_BITS + PASS1_BITS))  - CENTERJSAMPLE;*/
  534.    ;            DCTELEM dcval = (DCTELEM) DESCALE((int) dataptr[0], PASS1_BITS+3) - CENTERJSAMPLE;
  535.    ;    
  536.     mov    dx,word ptr [si]
  537.     add    dx,4
  538.     sar    dx,3
  539.     add    dx,-128
  540.    ;    
  541.    ;    
  542.    ;            data_ptr[0] = dcval;
  543.    ;    
  544.     les    bx,dword ptr [bp-24]
  545.     mov    byte ptr es:[bx],dl
  546.    ;    
  547.    ;            data_ptr[1] = dcval;
  548.    ;    
  549.     mov    byte ptr es:[bx+1],dl
  550.    ;    
  551.    ;            data_ptr[2] = dcval;
  552.    ;    
  553.     mov    byte ptr es:[bx+2],dl
  554.    ;    
  555.    ;            data_ptr[3] = dcval;
  556.    ;    
  557.     mov    byte ptr es:[bx+3],dl
  558.    ;    
  559.    ;            data_ptr[4] = dcval;
  560.    ;    
  561.     mov    byte ptr es:[bx+4],dl
  562.     ;
  563.    ;            data_ptr[5] = dcval;
  564.    ;    
  565.     mov    byte ptr es:[bx+5],dl
  566.    ;    
  567.     ;            data_ptr[6] = dcval;
  568.    ;    
  569.     mov    byte ptr es:[bx+6],dl
  570.    ;    
  571.    ;            data_ptr[7] = dcval;
  572.    ;    
  573.     mov    byte ptr es:[bx+7],dl
  574.    ;    
  575.    ;    
  576.    ;            dataptr += DCTSIZE;    /* advance pointer to next row */
  577.    ;    
  578.     add    si,16
  579.    ;    
  580.    ;            continue;
  581.    ;    
  582.     jmp    @1@338
  583. @1@310:
  584.    ;    
  585.    ;         }
  586.    ;    
  587.    ;         /* Even part: reverse the even part of the forward DCT. */
  588.    ;         /* The rotator is sqrt(2)*c(-6). */
  589.    ;    
  590.    ;         z2 = (int) dataptr[2];
  591.    ;    
  592.     mov    ax,word ptr [si+4]
  593.     mov    word ptr [bp-16],ax
  594.    ;    
  595.    ;         z3 = (int) dataptr[6];
  596.    ;    
  597.     mov    bx,word ptr [si+12]
  598.    ;    
  599.    ;    
  600.     ;         z1 = MULTIPLY(z2 + z3, FIX_0_541196100);
  601.     ;
  602.     add    ax,bx
  603. mov dx, ax
  604. shl ax, 3
  605. add ax, dx
  606. ;    mov    dx,9
  607. ;    imul    dx
  608.     mov    word ptr [bp-14],ax
  609.     ;
  610.     ;        tmp2 = z1 + MULTIPLY(z3, - FIX_1_847759065);
  611.     ;
  612.     mov    ax,bx
  613.     mov    dx,-30
  614.     imul    dx
  615.     mov    dx,word ptr [bp-14]
  616.     add    dx,ax
  617.     mov    word ptr [bp-2],dx
  618.     ;
  619.     ;        tmp3 = z1 + MULTIPLY(z2, FIX_0_765366865);
  620.     ;
  621.     mov    ax,word ptr [bp-16]
  622.     mov    dx,12
  623.     imul    dx
  624.     mov    dx,word ptr [bp-14]
  625.     add    dx,ax
  626.     mov    word ptr [bp-4],dx
  627.     ;
  628.    ;    
  629.    ;         tmp1 = ((int) dataptr[0] - (int) dataptr[4]) << CONST_BITS;
  630.    ;    
  631.     mov    ax,word ptr [si]
  632.     mov    dx,ax
  633.     sub    ax,word ptr [si+8]
  634.     shl    ax,4
  635.     mov    di,ax
  636.    ;    
  637.    ;         tmp0 = ((int) dataptr[0] + (int) dataptr[4]) << CONST_BITS;
  638.    ;    
  639.     mov    ax,dx
  640.     add    ax,word ptr [si+8]
  641.     shl    ax,4
  642.     mov    cx,ax
  643.    ;    
  644.    ;    
  645.     ;         tmp10 = tmp0 + tmp3;
  646.    ;    
  647.     add    ax,word ptr [bp-4]
  648.     mov    word ptr [bp-6],ax
  649.    ;    
  650.    ;         tmp13 = tmp0 - tmp3;
  651.    ;    
  652.     mov    ax,cx
  653.     sub    ax,word ptr [bp-4]
  654.     mov    word ptr [bp-12],ax
  655.    ;    
  656.    ;         tmp11 = tmp1 + tmp2;
  657.     ;
  658.     mov    ax,di
  659.     add    ax,word ptr [bp-2]
  660.     mov    word ptr [bp-8],ax
  661.    ;    
  662.    ;         tmp12 = tmp1 - tmp2;
  663.     ;
  664.     mov    ax,di
  665.     sub    ax,word ptr [bp-2]
  666.     mov    word ptr [bp-10],ax
  667.    ;    
  668.    ;    
  669.    ;         /* Odd part per figure 8; the matrix is unitary and hence its
  670.    ;          * transpose is its inverse.  i0..i3 are y7,y5,y3,y1 respectively.
  671.    ;          */
  672.    ;    
  673.    ;         tmp1 = (int) dataptr[5];
  674.    ;    
  675.     mov    di,word ptr [si+10]
  676.    ;    
  677.    ;         tmp2 = (int) dataptr[3];
  678.    ;    
  679.     mov    ax,word ptr [si+6]
  680.     mov    word ptr [bp-2],ax
  681.    ;    
  682.    ;         tmp0 = (int) dataptr[7];
  683.    ;    
  684.     mov    cx,word ptr [si+14]
  685.     ;
  686.     ;         tmp3 = (int) dataptr[1];
  687.     ;
  688.     mov    ax,word ptr [si+2]
  689.     mov    word ptr [bp-4],ax
  690.     ;
  691.     ;
  692.     ;         z1 = tmp0 + tmp3;
  693.     ;
  694.     mov    ax,cx
  695.     add    ax,word ptr [bp-4]
  696.     mov    word ptr [bp-14],ax
  697.     ;
  698.     ;         z2 = tmp1 + tmp2;
  699.     ;
  700.     mov    ax,di
  701.     add    ax,word ptr [bp-2]
  702.     mov    word ptr [bp-16],ax
  703.    ;    
  704.    ;         z3 = tmp0 + tmp2;
  705.    ;    
  706.     mov    bx,cx
  707.     add    bx,word ptr [bp-2]
  708.     ;
  709.    ;         z4 = tmp1 + tmp3;
  710.    ;    
  711.     mov    ax,di
  712.     add    ax,word ptr [bp-4]
  713.     mov    word ptr [bp-18],ax
  714.    ;    
  715.    ;         z5 = MULTIPLY(z3 + z4, FIX_1_175875602); /* sqrt(2) * c3 */
  716.    ;    
  717.     mov    ax,bx
  718.     add    ax,word ptr [bp-18]
  719.     mov    dx,19
  720.     imul    dx
  721.     mov    word ptr [bp-20],ax
  722.    ;    
  723.    ;    
  724.    ;         tmp0 = MULTIPLY(tmp0, FIX_0_298631336); /* sqrt(2) * (-c1+c3+c5-c7) */
  725.    ;    
  726.     mov    ax,cx
  727. shl cx, 2
  728. add cx, ax
  729. ;    mov    dx,5
  730. ;    imul    dx
  731. ;    mov    cx,ax
  732.    ;    
  733.    ;         tmp1 = MULTIPLY(tmp1, FIX_2_053119869); /* sqrt(2) * ( c1+c3-c5+c7) */
  734.    ;    
  735.     mov    ax,di
  736.     mov    dx,33
  737.     imul    dx
  738.     mov    di,ax
  739.    ;    
  740.    ;         tmp2 = MULTIPLY(tmp2, FIX_3_072711026); /* sqrt(2) * ( c1+c3+c5-c7) */
  741.    ;    
  742.     mov    ax,word ptr [bp-2]
  743.     mov    dx,49
  744.     imul    dx
  745.     mov    word ptr [bp-2],ax
  746.    ;    
  747.     ;         tmp3 = MULTIPLY(tmp3, FIX_1_501321110); /* sqrt(2) * ( c1+c3-c5-c7) */
  748.    ;    
  749.     mov    ax,word ptr [bp-4]
  750.     mov    dx,24
  751.     imul    dx
  752.     mov    word ptr [bp-4],ax
  753.     ;
  754.    ;         z1 = MULTIPLY(z1, - FIX_0_899976223); /* sqrt(2) * (c7-c3) */
  755.    ;    
  756.     mov    ax,word ptr [bp-14]
  757.     mov    dx,-14
  758.     imul    dx
  759.     mov    word ptr [bp-14],ax
  760.    ;    
  761.    ;         z2 = MULTIPLY(z2, - FIX_2_562915447); /* sqrt(2) * (-c1-c3) */
  762.    ;    
  763.     mov    ax,word ptr [bp-16]
  764.     mov    dx,-41
  765.     imul    dx
  766.     mov    word ptr [bp-16],ax
  767.    ;    
  768.    ;         z4 = MULTIPLY(z4, - FIX_0_390180644); /* sqrt(2) * (c5-c3) */
  769.    ;    
  770.     mov    ax,word ptr [bp-18]
  771.     mov    dx,-6
  772.     imul    dx
  773.     mov    word ptr [bp-18],ax
  774.     ;
  775.     ;         z3 = MULTIPLY(z3, - FIX_1_961570560); /* sqrt(2) * (-c3-c5) */
  776.     ;
  777.     mov    ax,bx
  778.     mov    dx,-31
  779.     imul    dx
  780.     mov    bx,ax
  781.     ;
  782.     ;
  783.     ;         z3 += z5;
  784.     ;
  785.     add    bx,word ptr [bp-20]
  786.     ;
  787.     ;         z4 += z5;
  788.     ;
  789.     mov    ax,word ptr [bp-20]
  790.     add    word ptr [bp-18],ax
  791.     ;
  792.     ;
  793.     ;         tmp1 += z2 + z4;
  794.     ;
  795.     mov    ax,word ptr [bp-16]
  796.     add    ax,word ptr [bp-18]
  797.     add    di,ax
  798. mov word ptr [bp-18], di
  799.     ;
  800.     ;         tmp0 += z1 + z3;
  801.     ;
  802.     mov    ax,word ptr [bp-14]
  803.     add    ax,bx
  804.     add    cx,ax
  805.    ;    
  806.    ;         tmp2 += z2 + z3;
  807.    ;    
  808.     mov    ax,word ptr [bp-16]
  809.     add    ax,bx
  810.     add    word ptr [bp-2],ax
  811.    ;    
  812.    ;         tmp3 += z1 + z4;
  813.     ;
  814.     mov    ax,word ptr [bp-14]
  815.     add    ax,word ptr [bp-18]
  816.     add    word ptr [bp-4],ax
  817.    ;    
  818.    ;    
  819.    ;         /* Final output stage: inputs are tmp10..tmp13, tmp0..tmp3 */
  820.     ;
  821.     ;         data_ptr[0] = range_limit[(DCTELEM) DESCALE(tmp10 + tmp3, CONST_BITS+PASS1_BITS+3)];
  822.     ;
  823. les    di,dword ptr [bp-24]
  824.     mov    bx,word ptr [bp-6]
  825.     add    bx,word ptr [bp-4]
  826.     add    bx,64
  827.     sar    bx,7
  828. mov    dx,word ptr DGROUP:_range_limit
  829.     add    bx,dx
  830.     mov    al,byte ptr [bx]
  831. ;    les    bx,dword ptr [bp-24]
  832.     mov    byte ptr es:[di],al
  833.     ;
  834.     ;         data_ptr[5] = range_limit[(DCTELEM) DESCALE(tmp12 - tmp1, CONST_BITS+PASS1_BITS+3)];
  835.     ;
  836.     mov    bx,word ptr [bp-10]
  837.     sub    bx,word ptr [bp-18]
  838.     add    bx,64
  839.     sar    bx,7
  840. ;    mov    bx,word ptr DGROUP:_range_limit
  841.     add    bx,dx
  842.     mov    al,byte ptr [bx]
  843. ;    mov    bx,word ptr [bp-24]
  844.     mov    byte ptr es:[di+5],al
  845.     ;
  846.     ;         data_ptr[2] = range_limit[(DCTELEM) DESCALE(tmp12 + tmp1, CONST_BITS+PASS1_BITS+3)];
  847.     ;
  848.     mov    bx,word ptr [bp-10]
  849.     add    bx,word ptr [bp-18]
  850.     add    bx,64
  851.     sar    bx,7
  852. ;    mov    bx,word ptr DGROUP:_range_limit
  853.     add    bx,dx
  854.     mov    al,byte ptr [bx]
  855. ;    mov    bx,word ptr [bp-24]
  856.     mov    byte ptr es:[di+2],al
  857.     ;
  858.     ;         data_ptr[1] = range_limit[(DCTELEM) DESCALE(tmp11 + tmp2, CONST_BITS+PASS1_BITS+3)];
  859.     ;
  860.     mov    bx,word ptr [bp-8]
  861.     add    bx,word ptr [bp-2]
  862.     add    bx,64
  863.     sar    bx,7
  864. ;    mov    bx,word ptr DGROUP:_range_limit
  865.     add    bx,dx
  866.     mov    al,byte ptr [bx]
  867. ;    mov    bx,word ptr [bp-24]
  868.     mov    byte ptr es:[di+1],al
  869.     ;
  870.     ;         data_ptr[3] = range_limit[(DCTELEM) DESCALE(tmp13 + tmp0, CONST_BITS+PASS1_BITS+3)];
  871.     ;
  872.     mov    bx,word ptr [bp-12]
  873.     add    bx,cx
  874.     add    bx,64
  875.     sar    bx,7
  876. ;    mov    bx,word ptr DGROUP:_range_limit
  877.     add    bx,dx
  878.     mov    al,byte ptr [bx]
  879. ;    mov    bx,word ptr [bp-24]
  880.     mov    byte ptr es:[di+3],al
  881.     ;
  882.     ;         data_ptr[4] = range_limit[(DCTELEM) DESCALE(tmp13 - tmp0, CONST_BITS+PASS1_BITS+3)];
  883.     ;
  884.     mov    bx,word ptr [bp-12]
  885.     sub    bx,cx
  886.     add    bx,64
  887.     sar    bx,7
  888. ;    mov    bx,word ptr DGROUP:_range_limit
  889.     add    bx,dx
  890.     mov    al,byte ptr [bx]
  891. ;    mov    bx,word ptr [bp-24]
  892.     mov    byte ptr es:[di+4],al
  893.     ;
  894.     ;         data_ptr[6] = range_limit[(DCTELEM) DESCALE(tmp11 - tmp2, CONST_BITS+PASS1_BITS+3)];
  895.     ;
  896.     mov    bx,word ptr [bp-8]
  897.     sub    bx,word ptr [bp-2]
  898.     add    bx,64
  899.     sar    bx,7
  900. ;    mov    bx,word ptr DGROUP:_range_limit
  901.     add    bx,dx
  902.     mov    al,byte ptr [bx]
  903. ;    mov    bx,word ptr [bp-24]
  904.     mov    byte ptr es:[di+6],al
  905.     ;
  906.     ;         data_ptr[7] = range_limit[(DCTELEM) DESCALE(tmp10 - tmp3, CONST_BITS+PASS1_BITS+3)];
  907.     ;
  908.     mov    bx,word ptr [bp-6]
  909.     sub    bx,word ptr [bp-4]
  910.     add    bx,64
  911.     sar    bx,7
  912. ;    mov    bx,word ptr DGROUP:_range_limit
  913.     add    bx,dx
  914.     mov    al,byte ptr [bx]
  915. ;    mov    bx,word ptr [bp-24]
  916.     mov    byte ptr es:[di+7],al
  917.     ;
  918.     ;
  919.     ;         dataptr += DCTSIZE;        /* advance pointer to next row */
  920.     ;
  921.     add    si,16
  922. @1@338:
  923.     add    word ptr [bp-28],4
  924.     dec    word ptr [bp-26]
  925. @1@394:
  926.     cmp    word ptr [bp-26],0
  927.     jl short    @@1
  928.     jmp    @1@254
  929. @@1:
  930.     ;
  931.    ;      }
  932.    ;    
  933.     ;    }
  934.    ;    
  935.     pop    di
  936.     pop    si
  937.     leave    
  938.     ret    
  939. _j_rev_dct    endp
  940.    ;    
  941.    ;    disassemble_noninterleaved_MCU (decompress_info_ptr cinfo,
  942.    ;    
  943.     assume    cs:JREVDCT_TEXT
  944. disassemble_noninterleaved_MCU    proc    far
  945.     push    bp
  946.     mov    bp,sp
  947.     sub    sp,8
  948.     push    si
  949.     push    di
  950.     mov    si,word ptr [bp+6]
  951.     mov    di,word ptr [bp+8]
  952.    ;    
  953.    ;                    JBLOCKIMAGE image_data)
  954.    ;    {
  955.    ;      JBLOCKROW MCU_data[1];
  956.    ;      long mcuindex;
  957.    ;    
  958.    ;      /* this is pretty easy since there is one component and one block per MCU */
  959.    ;    
  960.    ;      /* Pre-zero the target area to speed up entropy decoder */
  961.    ;      /* (we assume wholesale zeroing is faster than retail) */
  962.    ;      jzero_far((void FAR *) image_data[0][0],
  963.    ;    
  964.    ;    
  965.    ;            (size_t) (cinfo->MCUs_per_row * SIZEOF(JBLOCK)));
  966.    ;    
  967.     mov    ax,word ptr [si+165]
  968.     shl    ax,7
  969.     push    ax
  970.     mov    bx,word ptr [di]
  971.     push    dword ptr [bx]
  972.     call    far ptr _jzero_far
  973.     add    sp,6
  974.    ;    
  975.    ;    
  976.    ;      for (mcuindex = 0; mcuindex < cinfo->MCUs_per_row; mcuindex++) {
  977.    ;    
  978.     mov    dword ptr [bp-8],large 0
  979.     jmp    short @2@114
  980. @2@58:
  981.    ;    
  982.    ;        /* Point to the proper spot in the image array for this MCU */
  983.    ;        MCU_data[0] = image_data[0][0] + mcuindex;
  984.    ;    
  985.     mov    bx,word ptr [di]
  986.     mov    ax,word ptr [bx+2]
  987.     mov    dx,word ptr [bx]
  988.     mov    bx,word ptr [bp-8]
  989.     shl    bx,7
  990.     add    dx,bx
  991.     mov    word ptr [bp-2],ax
  992.     mov    word ptr [bp-4],dx
  993.    ;    
  994.    ;        /* Fetch the coefficient data */
  995.    ;        (*cinfo->methods->entropy_decode) (cinfo, MCU_data);
  996.    ;    
  997.     lea    ax,word ptr [bp-4]
  998.     push    ax
  999.     push    si
  1000.     mov    bx,word ptr [si]
  1001.     call    dword ptr [bx+44]
  1002.     add    sp,4
  1003.     inc    dword ptr [bp-8]
  1004. @2@114:
  1005.     mov    eax,dword ptr [si+165]
  1006.     cmp    eax,dword ptr [bp-8]
  1007.     jg    short @2@58
  1008.    ;    
  1009.    ;      }
  1010.    ;    }
  1011.    ;    
  1012.     pop    di
  1013.     pop    si
  1014.     leave    
  1015.     ret    
  1016. disassemble_noninterleaved_MCU    endp
  1017.    ;    
  1018.    ;    disassemble_interleaved_MCU (decompress_info_ptr cinfo,
  1019.    ;    
  1020.     assume    cs:JREVDCT_TEXT
  1021. disassemble_interleaved_MCU    proc    far
  1022.     push    bp
  1023.     mov    bp,sp
  1024.     sub    sp,66
  1025.     push    si
  1026.     push    di
  1027.    ;    
  1028.    ;                     JBLOCKIMAGE image_data)
  1029.    ;    {
  1030.    ;      JBLOCKROW MCU_data[MAX_BLOCKS_IN_MCU];
  1031.    ;      long mcuindex;
  1032.    ;      short blkn, ci, xpos, ypos;
  1033.    ;      jpeg_component_info * compptr;
  1034.    ;      JBLOCKROW image_ptr;
  1035.    ;    
  1036.    ;      /* Pre-zero the target area to speed up entropy decoder */
  1037.    ;      /* (we assume wholesale zeroing is faster than retail) */
  1038.    ;      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
  1039.    ;    
  1040.     mov    word ptr [bp-6],0
  1041.     mov    ax,word ptr [bp+6]
  1042.     add    ax,157
  1043.     mov    word ptr [bp-14],ax
  1044.     mov    ax,word ptr [bp+8]
  1045.     mov    word ptr [bp-16],ax
  1046.     jmp    short @3@338
  1047. @3@86:
  1048.    ;    
  1049.    ;        compptr = cinfo->cur_comp_info[ci];
  1050.    ;    
  1051.     mov    bx,word ptr [bp-14]
  1052.     mov    si,word ptr [bx]
  1053.    ;    
  1054.    ;        for (ypos = 0; ypos < compptr->MCU_height; ypos++) {
  1055.    ;    
  1056.     mov    word ptr [bp-8],0
  1057.     xor    di,di
  1058.     jmp    short @3@226
  1059. @3@142:
  1060.    ;    
  1061.    ;          jzero_far((void FAR *) image_data[ci][ypos],
  1062.    ;    
  1063.    ;    
  1064.    ;            (size_t) (cinfo->MCUs_per_row * compptr->MCU_width * SIZEOF(JBLOCK)));
  1065.    ;    
  1066.     movsx    eax,word ptr [si+22]
  1067.     mov    bx,word ptr [bp+6]
  1068.     mov    edx,dword ptr [bx+165]
  1069.     imul    edx,eax
  1070.     shl    dx,7
  1071.     push    dx
  1072.     mov    bx,word ptr [bp-16]
  1073.     mov    bx,word ptr [bx]
  1074.     add    bx,di
  1075.     push    dword ptr [bx]
  1076.     call    far ptr _jzero_far
  1077.     add    sp,6
  1078.     add    di,4
  1079.     inc    word ptr [bp-8]
  1080. @3@226:
  1081.     mov    ax,word ptr [si+24]
  1082.     cmp    ax,word ptr [bp-8]
  1083.     jg    short @3@142
  1084.     add    word ptr [bp-14],2
  1085.     add    word ptr [bp-16],2
  1086.     inc    word ptr [bp-6]
  1087. @3@338:
  1088.     mov    bx,word ptr [bp+6]
  1089.     mov    ax,word ptr [bx+155]
  1090.     cmp    ax,word ptr [bp-6]
  1091.     jg    short @3@86
  1092.    ;    
  1093.    ;        }
  1094.    ;      }
  1095.    ;    
  1096.    ;      for (mcuindex = 0; mcuindex < cinfo->MCUs_per_row; mcuindex++) {
  1097.    ;    
  1098.     mov    dword ptr [bp-4],large 0
  1099.     jmp    @3@982
  1100. @3@394:
  1101.    ;    
  1102.    ;        /* Point to the proper spots in the image array for this MCU */
  1103.    ;        blkn = 0;
  1104.    ;    
  1105.    ;    
  1106.    ;         for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
  1107.    ;    
  1108.     mov    word ptr [bp-6],0
  1109.     lea    ax,word ptr [bp-66]
  1110.     mov    word ptr [bp-22],ax
  1111.     mov    ax,word ptr [bp+6]
  1112.     add    ax,157
  1113.     mov    word ptr [bp-24],ax
  1114.     mov    ax,word ptr [bp+8]
  1115.     mov    word ptr [bp-26],ax
  1116.     jmp    @3@898
  1117. @3@450:
  1118.    ;    
  1119.    ;          compptr = cinfo->cur_comp_info[ci];
  1120.    ;    
  1121.     mov    bx,word ptr [bp-24]
  1122.     mov    si,word ptr [bx]
  1123.    ;    
  1124.    ;          for (ypos = 0; ypos < compptr->MCU_height; ypos++) {
  1125.    ;    
  1126.     mov    word ptr [bp-8],0
  1127.     mov    ax,word ptr [bp-22]
  1128.     mov    word ptr [bp-18],ax
  1129.     mov    word ptr [bp-20],0
  1130.     jmp    short @3@786
  1131. @3@506:
  1132.    ;    
  1133.    ;        image_ptr = image_data[ci][ypos] + (mcuindex * compptr->MCU_width);
  1134.    ;    
  1135.     movsx    eax,word ptr [si+22]
  1136.     mov    edx,dword ptr [bp-4]
  1137.     imul    edx,eax
  1138.     shl    dx,7
  1139.     mov    bx,word ptr [bp-26]
  1140.     mov    bx,word ptr [bx]
  1141.     add    bx,word ptr [bp-20]
  1142.     mov    ax,word ptr [bx+2]
  1143.     mov    bx,word ptr [bx]
  1144.     add    bx,dx
  1145.     mov    word ptr [bp-10],ax
  1146.     mov    word ptr [bp-12],bx
  1147.    ;    
  1148.    ;        for (xpos = 0; xpos < compptr->MCU_width; xpos++) {
  1149.    ;    
  1150.     xor    cx,cx
  1151.     mov    di,word ptr [bp-18]
  1152.     jmp    short @3@702
  1153. @3@562:
  1154.    ;    
  1155.    ;          MCU_data[blkn] = image_ptr;
  1156.    ;    
  1157.     mov    ax,word ptr [bp-10]
  1158.     mov    dx,word ptr [bp-12]
  1159.     mov    word ptr [di+2],ax
  1160.     mov    word ptr [di],dx
  1161.    ;    
  1162.    ;          image_ptr++;
  1163.    ;    
  1164.     add    word ptr [bp-12],128
  1165.    ;    
  1166.    ;          blkn++;
  1167.    ;    
  1168.     add    di,4
  1169.     add    word ptr [bp-18],4
  1170.     add    word ptr [bp-22],4
  1171.     inc    cx
  1172. @3@702:
  1173.     cmp    word ptr [si+22],cx
  1174.     jg    short @3@562
  1175.     add    word ptr [bp-20],4
  1176.     inc    word ptr [bp-8]
  1177. @3@786:
  1178.     mov    ax,word ptr [si+24]
  1179.     cmp    ax,word ptr [bp-8]
  1180.     jg    short @3@506
  1181.     add    word ptr [bp-24],2
  1182.     add    word ptr [bp-26],2
  1183.     inc    word ptr [bp-6]
  1184. @3@898:
  1185.     mov    bx,word ptr [bp+6]
  1186.     mov    ax,word ptr [bx+155]
  1187.     cmp    ax,word ptr [bp-6]
  1188.     jle short    @@2
  1189.     jmp    @3@450
  1190. @@2:
  1191.    ;    
  1192.    ;        }
  1193.    ;          }
  1194.    ;        }
  1195.    ;        /* Fetch the coefficient data */
  1196.    ;        (*cinfo->methods->entropy_decode) (cinfo, MCU_data);
  1197.    ;    
  1198.     lea    ax,word ptr [bp-66]
  1199.     push    ax
  1200.     push    bx
  1201.     mov    bx,word ptr [bx]
  1202.     call    dword ptr [bx+44]
  1203.     add    sp,4
  1204.     inc    dword ptr [bp-4]
  1205. @3@982:
  1206.     mov    bx,word ptr [bp+6]
  1207.     mov    eax,dword ptr [bx+165]
  1208.     cmp    eax,dword ptr [bp-4]
  1209.     jle short    @@3
  1210.     jmp    @3@394
  1211. @@3:
  1212.    ;    
  1213.    ;      }
  1214.    ;    }
  1215.    ;    
  1216.     pop    di
  1217.     pop    si
  1218.     leave    
  1219.     ret    
  1220. disassemble_interleaved_MCU    endp
  1221.    ;    
  1222.    ;    reverse_DCT (decompress_info_ptr cinfo,
  1223.    ;    
  1224.     assume    cs:JREVDCT_TEXT
  1225. reverse_DCT    proc    far
  1226.     push    bp
  1227.     mov    bp,sp
  1228.     sub    sp,160
  1229.     push    si
  1230.     push    di
  1231.     mov    di,word ptr [bp+6]
  1232.    ;    
  1233.    ;              JBLOCKIMAGE coeff_data, JSAMPIMAGE output_data, int start_row)
  1234.    ;    {
  1235.    ;      DCTBLOCK block;
  1236.    ;      JBLOCKROW browptr;
  1237.    ;      jpeg_component_info * compptr;
  1238.    ;      long blocksperrow, bi;
  1239.    ;      short numrows, ri;
  1240.    ;      short ci;
  1241.    ;    
  1242.    ;      for (ci = 0; ci < cinfo->comps_in_scan; ci++) {
  1243.    ;    
  1244.     mov    word ptr [bp-18],0
  1245.     mov    ax,di
  1246.     add    ax,157
  1247.     mov    word ptr [bp-24],ax
  1248.     mov    ax,word ptr [bp+8]
  1249.     mov    word ptr [bp-26],ax
  1250.     mov    ax,word ptr [bp+10]
  1251.     mov    word ptr [bp-28],ax
  1252.     jmp    @4@618
  1253. @4@86:
  1254.    ;    
  1255.    ;        compptr = cinfo->cur_comp_info[ci];
  1256.    ;    
  1257.     mov    bx,word ptr [bp-24]
  1258.     mov    si,word ptr [bx]
  1259.    ;    
  1260.    ;        /* don't bother to IDCT an uninteresting component */
  1261.    ;         if (! compptr->component_needed)
  1262.    ;    
  1263.     cmp    word ptr [si+36],0
  1264.     jne short    @@4
  1265.     jmp    @4@506
  1266. @@4:
  1267.    ;    
  1268.    ;          continue;
  1269.    ;        /* calculate size of an MCU row in this component */
  1270.    ;         blocksperrow = compptr->downsampled_width / DCTSIZE;
  1271.    ;    
  1272.     mov    eax,dword ptr [si+28]
  1273.     mov    ebx,large 8
  1274.     cdq    
  1275.     idiv    ebx
  1276.     mov    dword ptr [bp-8],eax
  1277.    ;    
  1278.    ;        numrows = compptr->MCU_height;
  1279.    ;    
  1280.     mov    ax,word ptr [si+24]
  1281.     mov    word ptr [bp-14],ax
  1282.    ;    
  1283.    ;        /* iterate through all blocks in MCU row */
  1284.    ;        for (ri = 0; ri < numrows; ri++) {
  1285.    ;    
  1286.     mov    word ptr [bp-16],0
  1287.     mov    word ptr [bp-20],0
  1288.     mov    ax,word ptr [bp+12]
  1289.     shl    ax,2
  1290.     mov    word ptr [bp-22],ax
  1291.     mov    ax,word ptr [bp-16]
  1292.     cmp    ax,word ptr [bp-14]
  1293.     jl short    @@5
  1294.     jmp    @4@506
  1295. @@5:
  1296. @4@198:
  1297.    ;    
  1298.    ;          browptr = coeff_data[ci][ri];
  1299.    ;    
  1300.     mov    bx,word ptr [bp-26]
  1301.     mov    bx,word ptr [bx]
  1302.     add    bx,word ptr [bp-20]
  1303.     mov    ax,word ptr [bx+2]
  1304.     mov    dx,word ptr [bx]
  1305.     mov    word ptr [bp-2],ax
  1306.     mov    word ptr [bp-4],dx
  1307.    ;    
  1308.    ;          srowptr = output_data[ci] + (ri * DCTSIZE + start_row);
  1309.    ;    
  1310.     mov    bx,word ptr [bp-28]
  1311.     mov    ax,word ptr [bx]
  1312.     add    ax,word ptr [bp-22]
  1313.     mov    word ptr DGROUP:_srowptr,ax
  1314.    ;    
  1315.    ;          for (bi = 0; bi < blocksperrow; bi++) {
  1316.    ;    
  1317.     mov    dword ptr [bp-12],large 0
  1318.     jmp    short @4@366
  1319. @4@226:
  1320.    ;    
  1321.    ;        /* copy the data into a local DCTBLOCK.  This allows for change of
  1322.    ;         * representation (if DCTELEM != JCOEF).  On 80x86 machines it also
  1323.    ;         * brings the data back from FAR storage to NEAR storage.
  1324.    ;         */
  1325.    ;        { register JCOEFPTR elemptr = browptr[bi];
  1326.    ;    
  1327.     mov    ax,word ptr [bp-12]
  1328.     shl    ax,7
  1329.     mov    dx,word ptr [bp-2]
  1330.     mov    bx,word ptr [bp-4]
  1331.     add    bx,ax
  1332.     mov    word ptr [bp-30],dx
  1333.     mov    word ptr [bp-32],bx
  1334.    ;    
  1335.    ;          register DCTELEM *localblkptr = block;
  1336.    ;    
  1337.     lea    si,word ptr [bp-160]
  1338.    ;    
  1339.    ;          register int elem = DCTSIZE2;
  1340.    ;    
  1341. mov cx, di
  1342.     les    di,dword ptr [bp-32]
  1343.     mov    dx,64
  1344.     jmp    short @4@282
  1345. @4@254:
  1346.     ;
  1347.     ;
  1348.     ;          while (--elem >= 0)
  1349.     ;             *localblkptr++ = (DCTELEM) *elemptr++;
  1350.     ;
  1351. ;    les    bx,dword ptr [bp-32]
  1352.     mov    ax,word ptr es:[di]
  1353.     mov    word ptr [si],ax
  1354. add di, 2
  1355. ;    add    word ptr [bp-32],2
  1356.     add    si,2
  1357. @4@282:
  1358.     dec    dx
  1359.     jge    short @4@254
  1360. mov di, cx
  1361.     ;
  1362.    ;        }
  1363.    ;    
  1364.    ;        range_limit = cinfo->sample_range_limit +    CENTERJSAMPLE;
  1365.    ;    
  1366.     mov    ax,word ptr [di+145]
  1367.     add    ax,128
  1368.     mov    word ptr DGROUP:_range_limit,ax
  1369.    ;    
  1370.    ;        elemptr = bi * DCTSIZE;
  1371.    ;    
  1372.     mov    ax,word ptr [bp-12]
  1373.     shl    ax,3
  1374.     mov    word ptr DGROUP:_elemptr,ax
  1375.    ;    
  1376.    ;        j_rev_dct(block);    /* perform inverse DCT */
  1377.    ;    
  1378.     lea    ax,word ptr [bp-160]
  1379.     push    ax
  1380.     call    near ptr _j_rev_dct
  1381.     add    sp,2
  1382.     inc    dword ptr [bp-12]
  1383. @4@366:
  1384.     mov    eax,dword ptr [bp-12]
  1385.     cmp    eax,dword ptr [bp-8]
  1386.     jl    short @4@226
  1387.     add    word ptr [bp-20],4
  1388.     add    word ptr [bp-22],32
  1389.     inc    word ptr [bp-16]
  1390.     mov    ax,word ptr [bp-16]
  1391.     cmp    ax,word ptr [bp-14]
  1392.     jge short    @@6
  1393.     jmp    @4@198
  1394. @@6:
  1395. @4@506:
  1396.     add    word ptr [bp-24],2
  1397.     add    word ptr [bp-26],2
  1398.     add    word ptr [bp-28],2
  1399.     inc    word ptr [bp-18]
  1400. @4@618:
  1401.     mov    ax,word ptr [di+155]
  1402.     cmp    ax,word ptr [bp-18]
  1403.     jle short    @@7
  1404.     jmp    @4@86
  1405. @@7:
  1406.    ;    
  1407.    ;    
  1408.    ;    #if pigs_fly
  1409.    ;        /* Output the data into the sample array.
  1410.    ;         * Note change from signed to unsigned representation:
  1411.    ;         * DCT calculation works with values +-CENTERJSAMPLE,
  1412.    ;         * but sample arrays always hold 0..MAXJSAMPLE.
  1413.    ;         * We have to do range-limiting because of quantization errors in the
  1414.    ;         * DCT/IDCT phase.  We use the sample_range_limit[] table to do this
  1415.    ;         * quickly; the CENTERJSAMPLE offset is folded into table indexing.
  1416.    ;         */
  1417.    ;        { register JSAMPROW elemptr;
  1418.    ;          register DCTELEM *localblkptr = block;
  1419.    ;          register JSAMPLE *range_limit = cinfo->sample_range_limit +
  1420.    ;                            CENTERJSAMPLE;
  1421.    ;    #if DCTSIZE != 8
  1422.    ;          register int elemc;
  1423.    ;    #endif
  1424.    ;          register int elemr;
  1425.    ;    
  1426.    ;          for (elemr = 0; elemr < DCTSIZE; elemr++) {
  1427.    ;    #if DCTSIZE == 8        /* unroll the inner loop */
  1428.    ;             *elemptr++ = range_limit[*localblkptr++];
  1429.    ;             *elemptr++ = range_limit[*localblkptr++];
  1430.    ;             *elemptr++ = range_limit[*localblkptr++];
  1431.    ;             *elemptr++ = range_limit[*localblkptr++];
  1432.    ;             *elemptr++ = range_limit[*localblkptr++];
  1433.    ;             *elemptr++ = range_limit[*localblkptr++];
  1434.    ;             *elemptr++ = range_limit[*localblkptr++];
  1435.    ;             *elemptr = range_limit[*localblkptr++];
  1436.    ;    #else
  1437.    ;             for (elemc = DCTSIZE; elemc > 0; elemc--) {
  1438.    ;                *elemptr++ = range_limit[*localblkptr++];
  1439.    ;             }
  1440.    ;    #endif
  1441.    ;          }
  1442.    ;        }
  1443.    ;    #endif
  1444.    ;            }
  1445.    ;         }
  1446.    ;      }
  1447.    ;    }
  1448.    ;    
  1449.     pop    di
  1450.     pop    si
  1451.     leave    
  1452.     ret    
  1453. reverse_DCT    endp
  1454.    ;    
  1455.    ;    disassemble_init (decompress_info_ptr cinfo)
  1456.    ;    
  1457.     assume    cs:JREVDCT_TEXT
  1458. disassemble_init    proc    far
  1459.     push    bp
  1460.     mov    bp,sp
  1461.    ;    
  1462.    ;    {
  1463.    ;      /* no work for now */
  1464.    ;    }
  1465.    ;    
  1466.     pop    bp
  1467.     ret    
  1468. disassemble_init    endp
  1469.    ;    
  1470.    ;    disassemble_term (decompress_info_ptr cinfo)
  1471.    ;    
  1472.     assume    cs:JREVDCT_TEXT
  1473. disassemble_term    proc    far
  1474.     push    bp
  1475.     mov    bp,sp
  1476.    ;    
  1477.    ;    {
  1478.    ;      /* no work for now */
  1479.    ;    }
  1480.    ;    
  1481.     pop    bp
  1482.     ret    
  1483. disassemble_term    endp
  1484.    ;    
  1485.    ;    jseldmcu (decompress_info_ptr cinfo)
  1486.    ;    
  1487.     assume    cs:JREVDCT_TEXT
  1488. _jseldmcu    proc    far
  1489.     push    bp
  1490.     mov    bp,sp
  1491.     push    si
  1492.     mov    si,word ptr [bp+6]
  1493.    ;    
  1494.    ;    {
  1495.    ;      if (cinfo->comps_in_scan == 1)
  1496.    ;    
  1497.     cmp    word ptr [si+155],1
  1498.     jne    short @7@86
  1499.    ;    
  1500.    ;        cinfo->methods->disassemble_MCU = disassemble_noninterleaved_MCU;
  1501.    ;    
  1502.     mov    bx,word ptr [si]
  1503.     mov    word ptr [bx+58],seg disassemble_noninterleaved_MCU
  1504.     mov    word ptr [bx+56],offset disassemble_noninterleaved_MCU
  1505.     jmp    short @7@114
  1506. @7@86:
  1507.    ;    
  1508.    ;      else
  1509.    ;        cinfo->methods->disassemble_MCU = disassemble_interleaved_MCU;
  1510.    ;    
  1511.     mov    bx,word ptr [si]
  1512.     mov    word ptr [bx+58],seg disassemble_interleaved_MCU
  1513.     mov    word ptr [bx+56],offset disassemble_interleaved_MCU
  1514. @7@114:
  1515.    ;    
  1516.    ;      cinfo->methods->reverse_DCT = reverse_DCT;
  1517.    ;    
  1518.     mov    bx,word ptr [si]
  1519.     mov    word ptr [bx+62],seg reverse_DCT
  1520.     mov    word ptr [bx+60],offset reverse_DCT
  1521.    ;    
  1522.    ;      cinfo->methods->disassemble_init = disassemble_init;
  1523.    ;    
  1524.     mov    word ptr [bx+54],seg disassemble_init
  1525.     mov    word ptr [bx+52],offset disassemble_init
  1526.    ;    
  1527.    ;      cinfo->methods->disassemble_term = disassemble_term;
  1528.    ;    
  1529.     mov    word ptr [bx+66],seg disassemble_term
  1530.     mov    word ptr [bx+64],offset disassemble_term
  1531.    ;    
  1532.    ;    }
  1533.    ;    
  1534.     pop    si
  1535.     pop    bp
  1536.     ret    
  1537. _jseldmcu    endp
  1538. JREVDCT_TEXT    ends
  1539. _BSS    segment word public use16 'BSS'
  1540. _srowptr    label    word
  1541.     db    2 dup (?)
  1542. _range_limit    label    word
  1543.     db    2 dup (?)
  1544. _elemptr    label    word
  1545.     db    2 dup (?)
  1546.     ?debug    C E9
  1547.     ?debug    C FA15010000
  1548. _BSS    ends
  1549. _DATA    segment word public use16 'DATA'
  1550. s@    label    byte
  1551. _DATA    ends
  1552. JREVDCT_TEXT    segment byte public use16 'CODE'
  1553. JREVDCT_TEXT    ends
  1554. _disassemble_term    equ    disassemble_term
  1555. _disassemble_init    equ    disassemble_init
  1556. _reverse_DCT    equ    reverse_DCT
  1557. _disassemble_interleaved_MCU    equ    disassemble_interleaved_MCU
  1558. _disassemble_noninterleaved_MCU    equ    disassemble_noninterleaved_MCU
  1559.     public    _srowptr
  1560.     public    _range_limit
  1561.     public    _elemptr
  1562.     public    _jseldmcu
  1563.     extrn    _jzero_far:far
  1564.     public    _j_rev_dct
  1565. _s@    equ    s@
  1566.     end
  1567.