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