home *** CD-ROM | disk | FTP | other *** search
/ Computer Shopper 275 / DPCS0111DVD.ISO / Toolkit / Audio-Visual / VirtualDub / Source / VirtualDub-1.9.10-src.7z / src / Meia / source / idct_scalar_asm.inl < prev    next >
Encoding:
Text File  |  2009-09-14  |  11.7 KB  |  615 lines
  1. #pragma warning(push)
  2. #pragma warning(disable: 4733)    // warning C4733: Inline asm assigning to 'FS:0' : handler not registered as safe handler
  3.  
  4. static void __declspec(naked) __cdecl scalar_idct_feig_winograd_8x8_temp(int *d) {
  5.     __asm {
  6.         push    ebp
  7.         push    edi
  8.         push    esi
  9.         push    ebx
  10.  
  11.         mov        edi, [esp+16+4]
  12.  
  13.         //---- round
  14.  
  15.         add        dword ptr [edi], 256
  16.  
  17.         // apply horizontal R2 (R18) transform [64a]
  18.         mov        ebp, 7*32
  19.  
  20. horiz_r2_loop:
  21.         mov        eax, [edi+ebp+2*4]        ;eax = x2
  22.         mov        ebx, [edi+ebp+3*4]        ;ebx = x3
  23.  
  24.         mov        edx, [edi+ebp+4*4]        ;edx = x4
  25.         mov        esi, [edi+ebp+6*4]        ;esi = x6
  26.  
  27.         lea        ecx, [eax+ebx]            ;ecx = y3 = x2+x3
  28.         sub        eax, ebx                ;eax = y2 = x2-x3
  29.  
  30.         mov        [edi+ebp+2*4], eax
  31.         mov        [edi+ebp+3*4], ecx
  32.  
  33.         mov        eax, [edi+ebp+5*4]        ;eax = x5
  34.         mov        ecx, [edi+ebp+7*4]        ;ecx = x7
  35.  
  36.         lea        ebx, [edx+esi]            ;ebx = y6 = x4+x6
  37.         sub        edx, esi                ;edx = y4 = x4-x6
  38.  
  39.         lea        esi, [ecx+eax]            ;esi = y5 = x7+x5
  40.         sub        ecx, eax                ;ecx = y7 = x7-x5
  41.  
  42.         mov        [edi+ebp+6*4], ebx
  43.         mov        [edi+ebp+7*4], ecx
  44.  
  45.         lea        eax, [esi+edx]            ;eax = y5+y4
  46.         sub        esi, edx                ;esi = y5-y4
  47.  
  48.         mov        [edi+ebp+4*4], eax
  49.         mov        [edi+ebp+5*4], esi
  50.  
  51.         sub        ebp, 32
  52.         jnc        horiz_r2_loop
  53.  
  54.         // apply vertical R2 transform [64a]
  55.  
  56.         mov        ebp, 7*4
  57.  
  58. vert_r2_loop:
  59.         mov        eax, [edi+ebp+2*32]        ;eax = x2
  60.         mov        ebx, [edi+ebp+3*32]        ;ebx = x3
  61.  
  62.         mov        edx, [edi+ebp+4*32]        ;edx = x4
  63.         mov        esi, [edi+ebp+6*32]        ;esi = x6
  64.  
  65.         lea        ecx, [eax+ebx]            ;ecx = y3 = x2+x3
  66.         sub        eax, ebx                ;eax = y2 = x2-x3
  67.  
  68.         mov        [edi+ebp+2*32], eax
  69.         mov        [edi+ebp+3*32], ecx
  70.  
  71.         mov        eax, [edi+ebp+5*32]        ;eax = x5
  72.         mov        ecx, [edi+ebp+7*32]        ;ecx = x7
  73.  
  74.         lea        ebx, [esi+edx]            ;ebx = y6 = x4+x6
  75.         sub        edx, esi                ;edx = y4 = x4-x6
  76.  
  77.         lea        esi, [ecx+eax]            ;esi = y7 = x7+x5
  78.         sub        ecx, eax                ;ecx = y5 = x7-x5
  79.  
  80.         mov        [edi+ebp+6*32], ebx
  81.         mov        [edi+ebp+7*32], ecx
  82.  
  83.         lea        eax, [esi+edx]            ;eax = y5+y4
  84.         sub        esi, edx                ;esi = y5-y4
  85.  
  86.         mov        [edi+ebp+4*32], eax
  87.         mov        [edi+ebp+5*32], esi
  88.  
  89.         sub        ebp, 4
  90.         jnc        vert_r2_loop
  91.  
  92.         // apply M1/M2 and R1 to first 6 rows
  93.  
  94.         mov        ebp, [esp+16+4]
  95.         add        ebp, 0*32
  96.         call    m1
  97.         mov        ebp, [esp+16+4]
  98.         add        ebp, 1*32
  99.         call    m1
  100.         mov        ebp, [esp+16+4]
  101.         add        ebp, 2*32
  102.         call    m1
  103.         mov        ebp, [esp+16+4]
  104.         add        ebp, 5*32
  105.         call    m1
  106.         mov        ebp, [esp+16+4]
  107.         add        ebp, 3*32
  108.         call    m2
  109.         mov        ebp, [esp+16+4]
  110.         add        ebp, 4*32
  111.         call    m2
  112.  
  113.         // Apply M3 and R2 to last two rows together
  114.         //
  115.         // NOTE: Swaps around columns 4<->5 and 6<->7 to make R1 easier.
  116.  
  117.         mov        ebp, [esp+16+4]
  118.  
  119. #define x0 [ebp+0*4+6*32]
  120. #define x1 [ebp+1*4+6*32]
  121. #define x2 [ebp+2*4+6*32]
  122. #define x3 [ebp+3*4+6*32]
  123. #define x4 [ebp+4*4+6*32]
  124. #define x5 [ebp+5*4+6*32]
  125. #define x6 [ebp+6*4+6*32]
  126. #define x7 [ebp+7*4+6*32]
  127. #define y0 [ebp+0*4+7*32]
  128. #define y1 [ebp+1*4+7*32]
  129. #define y2 [ebp+2*4+7*32]
  130. #define y3 [ebp+3*4+7*32]
  131. #define y4 [ebp+4*4+7*32]
  132. #define y5 [ebp+5*4+7*32]
  133. #define y6 [ebp+6*4+7*32]
  134. #define y7 [ebp+7*4+7*32]
  135.  
  136.         mov        eax, x0
  137.         mov        ebx, y0
  138.         imul    ecx, eax, -8867
  139.         add        eax, ebx
  140.         imul    eax, 15137
  141.         imul    ebx, 21407
  142.         add        ecx, eax
  143.         sub        ebx, eax
  144.         mov        x0, ecx
  145.         mov        y0, ebx
  146.  
  147.         mov        eax, x1
  148.         mov        ebx, y1
  149.         imul    ecx, eax, -8867
  150.         add        eax, ebx
  151.         imul    eax, 15137
  152.         imul    ebx, 21407
  153.         add        ecx, eax
  154.         sub        ebx, eax
  155.         mov        x1, ecx
  156.         mov        y1, ebx
  157.  
  158.         mov        eax, x2
  159.         mov        ebx, y2
  160.         imul    ecx, eax, -8867
  161.         add        eax, ebx
  162.         imul    eax, 15137
  163.         imul    ebx, 21407
  164.         add        ecx, eax
  165.         sub        ebx, eax
  166.         mov        x2, ecx
  167.         mov        y2, ebx
  168.  
  169.         mov        eax, x3
  170.         mov        ebx, y3
  171.         imul    ecx, eax, -12540
  172.         add        eax, ebx
  173.         imul    eax, 21407
  174.         imul    ebx, 30274
  175.         add        ecx, eax
  176.         sub        ebx, eax
  177.         mov        x3, ecx
  178.         mov        y3, ebx
  179.  
  180.         mov        eax, x4
  181.         mov        ebx, y4
  182.         imul    ecx, eax, -12540
  183.         add        eax, ebx
  184.         imul    eax, 21407
  185.         imul    ebx, 30274
  186.         add        ecx, eax
  187.         sub        ebx, eax
  188.         mov        x4, ecx
  189.         mov        y4, ebx
  190.  
  191.         mov        eax, x5
  192.         mov        ebx, y5
  193.         imul    ecx, eax, -8867
  194.         add        eax, ebx
  195.         imul    eax, 15137
  196.         imul    ebx, 21407
  197.         add        ecx, eax
  198.         sub        ebx, eax
  199.         mov        x5, ecx
  200.         mov        y5, ebx
  201.  
  202.         mov        eax, y7                ;eax = x77
  203.         mov        ebx, x7                ;ebx = x67
  204.         mov        ecx, y6                ;ecx = x76
  205.         mov        edx, x6                ;edx = x66
  206.         lea        esi, [eax+edx]        ;esi = y66 = x77+x66
  207.         sub        eax, edx            ;eax = y77 = x77-x66
  208.         lea        edi, [ebx+ecx]        ;edi = y67 = x67+x76
  209.         sub        ebx, ecx            ;ebx = y76 = x67-x76
  210.  
  211.         shl        ebx, 14                ;ebx = x76' = y76 << SCALE_BITS
  212.         shl        esi, 14                ;esi = x66' = y66 << SCALE_BITS
  213.  
  214.         lea        ecx, [eax+edi]        ;ecx = y77+y67
  215.         sub        eax, edi            ;eax = y77-y67
  216.  
  217.         imul    ecx, 11585            ;ecx = x77' = (y77+y67) * inv_c0
  218.         imul    eax, 11585            ;eax = x67' = (y77-y67) * inv_c0
  219.  
  220.         lea        edx, [eax+ebx]        ;edx = y67' = x67'+x76'
  221.         sub        eax, ebx            ;eax = y76' = x67'-x76'
  222.         lea        ebx, [esi+ecx]        ;ebx = y66' = x66'+x77'
  223.         sub        esi, ecx            ;esi = y77' = x66'-x77'
  224.  
  225.         mov        x6, ebx
  226.         mov        x7, edx
  227.         mov        y6, eax
  228.         mov        y7, esi
  229.  
  230. #undef y7
  231. #undef y6
  232. #undef y5
  233. #undef y4
  234. #undef y3
  235. #undef y2
  236. #undef y1
  237. #undef y0
  238. #undef x7
  239. #undef x6
  240. #undef x5
  241. #undef x4
  242. #undef x3
  243. #undef x2
  244. #undef x1
  245. #undef x0
  246.  
  247.  
  248.         // Apply horizontal R1 (B1t * B2 * B3) [144a]
  249.         //
  250.         //    x0 = d[i+0];
  251.         //    x1 = d[i+1];
  252.         //    x2 = d[i+2];
  253.         //    x3 = d[i+3];
  254.         //    x4 = d[i+4];
  255.         //    x5 = d[i+5];
  256.         //    x6 = d[i+6];
  257.         //    x7 = d[i+7];
  258.         //
  259.         //    y0 = x0+x1;
  260.         //    y1 = x0-x1;
  261.         //    y2 = x2;
  262.         //    y3 = x2+x3;
  263.         //
  264.         //    y5 = x5;
  265.         //    y7 = x5-x7;
  266.         //    y4 = y7-x4;
  267.         //    y6 = y4+x6;
  268.         //
  269.         //    z0 = y0+y3;
  270.         //    z1 = y1+y2;
  271.         //    z2 = y1-y2;
  272.         //    z3 = y0-y3;
  273.         //    z4 = y4;
  274.         //    z5 = y5;
  275.         //    z6 = y6;
  276.         //    z7 = y7;
  277.         //
  278.         //    d[i+ 0] = (z0+z7)>>(PRESCALE_BITS + SCALE_BITS);
  279.         //    d[i+ 8] = (z1-z6)>>(PRESCALE_BITS + SCALE_BITS);
  280.         //    d[i+16] = (z2+z5)>>(PRESCALE_BITS + SCALE_BITS);
  281.         //    d[i+24] = (z3+z4)>>(PRESCALE_BITS + SCALE_BITS);
  282.         //    d[i+32] = (z3-z4)>>(PRESCALE_BITS + SCALE_BITS);
  283.         //    d[i+40] = (z2-z5)>>(PRESCALE_BITS + SCALE_BITS);
  284.         //    d[i+48] = (z1+z6)>>(PRESCALE_BITS + SCALE_BITS);
  285.         //    d[i+56] = (z0-z7)>>(PRESCALE_BITS + SCALE_BITS);
  286.  
  287.  
  288.  
  289. #define x0 [esp+ebp+0*4]
  290. #define x1 [esp+ebp+1*4]
  291. #define x2 [esp+ebp+2*4]
  292. #define x3 [esp+ebp+3*4]
  293. #define x4 [esp+ebp+4*4]
  294. #define x5 [esp+ebp+5*4]
  295. #define x6 [esp+ebp+6*4]
  296. #define x7 [esp+ebp+7*4]
  297.  
  298.         mov        edi, [esp+16+4]
  299.         push    0
  300.         push    dword ptr fs:[0]
  301.         mov        dword ptr fs:[0], esp
  302.         mov        ebp, 7*32
  303.         mov        esp, edi
  304.  
  305. horiz_R1_loop:
  306.         mov        eax, x0
  307.         mov        ebx, x1
  308.  
  309.         mov        ecx, x2                ;ecx = y2 = x2
  310.         mov        edx, x3
  311.  
  312.         lea        edi, [eax+ebx]        ;edi = y0 = x0+x1
  313.         sub        eax, ebx            ;eax = y1 = x0-x1
  314.  
  315.         add        edx, ecx            ;edx = y3 = x2+x3
  316.         mov        ebx, x5                ;ebx = z5 = y5 = x5
  317.  
  318.         lea        esi, [eax+ecx]        ;esi = z1 = y1+y2
  319.         sub        eax, ecx            ;eax = z2 = y1-y2
  320.  
  321.         mov        ecx, eax
  322.         sub        eax, ebx            ;eax = o5 = z2-z5
  323.  
  324.         mov        x5, eax
  325.         add        ecx, ebx            ;ecx = o2 = z2+z5
  326.  
  327.         lea        eax, [edi+edx]        ;eax = z0 = y0+y3
  328.         mov        x2, ecx
  329.  
  330.         sub        edi, edx            ;edi = z3 = y0-y3
  331.         mov        edx, x7
  332.  
  333.         sub        ebx, edx            ;ebx = z7 = y5-y7
  334.         mov        ecx, eax
  335.  
  336.         add        ecx, ebx            ;ecx = o0 = z0+z7
  337.         mov        edx, x4
  338.  
  339.         sub        eax, ebx            ;eax = o7 = z0-z7
  340.         sub        ebx, edx            ;ebx = z4 = y7-x4
  341.  
  342.         mov        x0, ecx
  343.         mov        x7, eax
  344.  
  345.         lea        ecx, [edi+ebx]        ;ecx = o3 = z3+z4
  346.         mov        edx, x6
  347.  
  348.         sub        edi, ebx            ;edi = o4 = z3-z4
  349.         add        ebx, edx            ;ebx = z6 = y4+x6
  350.  
  351.         mov        x3, ecx
  352.         mov        x4, edi
  353.  
  354.         lea        eax, [esi+ebx]        ;eax = o6 = z1+z6
  355.         sub        esi, ebx            ;esi = o1 = z1-z6
  356.  
  357.         mov        x6, eax
  358.         mov        x1, esi
  359.  
  360.         sub        ebp, 32
  361.         jnc        horiz_R1_loop
  362.  
  363. #undef x7
  364. #undef x6
  365. #undef x5
  366. #undef x4
  367. #undef x3
  368. #undef x2
  369. #undef x1
  370. #undef x0
  371.  
  372.         // Apply vertical R1 [144a].
  373.  
  374.         ;    for(i=0; i<8; i++) {
  375.         ;        int x0, x1, x2, x3, x4, x5, x6, x7;
  376.         ;        int y0, y1, y2, y3, y4, y5, y6, y7;
  377.         ;        int z0, z1, z2, z3, z4, z5, z6, z7;
  378.  
  379.         ;        x0 = d[i+0];
  380.         ;        x1 = d[i+8];
  381.         ;        x2 = d[i+16];
  382.         ;        x3 = d[i+24];
  383.         ;        x4 = d[i+32];
  384.         ;        x5 = d[i+40];
  385.         ;        x6 = d[i+48];
  386.         ;        x7 = d[i+56];
  387.             
  388.         ;        y0 = x0+x1;
  389.         ;        y1 = x0-x1;
  390.         ;        y2 = x2;
  391.         ;        y3 = x2+x3;
  392.  
  393.         ;        y5 = x5;
  394.         ;        y7 = x5-x7;
  395.         ;        y4 = y7-x4;
  396.         ;        y6 = y4+x6;
  397.  
  398.         ;        z0 = y0+y3;
  399.         ;        z1 = y1+y2;
  400.         ;        z2 = y1-y2;
  401.         ;        z3 = y0-y3;
  402.         ;        z4 = y4;
  403.         ;        z5 = y5;
  404.         ;        z6 = y6;
  405.         ;        z7 = y7;
  406.  
  407.         ;        d[i+ 0] = (z0+z7)>>(PRESCALE_BITS + SCALE_BITS);
  408.         ;        d[i+ 8] = (z1-z6)>>(PRESCALE_BITS + SCALE_BITS);
  409.         ;        d[i+16] = (z2+z5)>>(PRESCALE_BITS + SCALE_BITS);
  410.         ;        d[i+24] = (z3+z4)>>(PRESCALE_BITS + SCALE_BITS);
  411.         ;        d[i+32] = (z3-z4)>>(PRESCALE_BITS + SCALE_BITS);
  412.         ;        d[i+40] = (z2-z5)>>(PRESCALE_BITS + SCALE_BITS);
  413.         ;        d[i+48] = (z1+z6)>>(PRESCALE_BITS + SCALE_BITS);
  414.         ;        d[i+56] = (z0-z7)>>(PRESCALE_BITS + SCALE_BITS);
  415.         ;    }
  416.  
  417.  
  418. #define x0 [esp+ebp+0*32]
  419. #define x1 [esp+ebp+1*32]
  420. #define x2 [esp+ebp+2*32]
  421. #define x3 [esp+ebp+3*32]
  422. #define x4 [esp+ebp+4*32]
  423. #define x5 [esp+ebp+5*32]
  424. #define x6 [esp+ebp+6*32]
  425. #define x7 [esp+ebp+7*32]
  426.  
  427.  
  428.         mov        ebp, 7*4
  429. vert_R1_loop:
  430.         mov        eax, x0
  431.         mov        ebx, x1
  432.  
  433.         mov        ecx, x2                ;ecx = y2 = x2
  434.         mov        edx, x3
  435.  
  436.         lea        edi, [eax+ebx]        ;edi = y0 = x0+x1
  437.         sub        eax, ebx            ;eax = y1 = x0-x1
  438.  
  439.         add        edx, ecx            ;edx = y3 = x2+x3
  440.         mov        ebx, x5                ;ebx = z5 = y5 = x5
  441.  
  442.         lea        esi, [eax+ecx]        ;esi = z1 = y1+y2
  443.         sub        eax, ecx            ;eax = z2 = y1-y2
  444.  
  445.         mov        ecx, eax
  446.         sub        eax, ebx            ;eax = o5 = z2-z5
  447.  
  448.         sar        eax, 22
  449.         add        ecx, ebx            ;ecx = o2 = z2+z5
  450.  
  451.         mov        x5, eax
  452.         lea        eax, [edi+edx]        ;eax = z0 = y0+y3
  453.  
  454.         sar        ecx, 22
  455.         sub        edi, edx            ;edi = z3 = y0-y3
  456.  
  457.         mov        edx, x7
  458.         mov        x2, ecx
  459.  
  460.         sub        ebx, edx            ;ebx = z7 = y5-y7
  461.         mov        ecx, eax
  462.  
  463.         mov        edx, x4
  464.         add        ecx, ebx            ;ecx = o0 = z0+z7
  465.  
  466.         sar        ecx, 22
  467.         sub        eax, ebx            ;eax = o7 = z0-z7
  468.  
  469.         sar        eax, 22
  470.         sub        ebx, edx            ;ebx = z4 = y7-x4
  471.  
  472.         mov        x0, ecx
  473.         lea        ecx, [edi+ebx]        ;ecx = o3 = z3+z4
  474.  
  475.         mov        x7, eax
  476.         mov        edx, x6
  477.  
  478.         sar        ecx, 22
  479.         sub        edi, ebx            ;edi = o4 = z3-z4
  480.  
  481.         sar        edi, 22
  482.         add        ebx, edx            ;ebx = z6 = y4+x6
  483.  
  484.         mov        x3, ecx
  485.         lea        eax, [esi+ebx]        ;eax = o6 = z1+z6
  486.  
  487.         sar        eax, 22
  488.         sub        esi, ebx            ;esi = o1 = z1-z6
  489.  
  490.         sar        esi, 22
  491.         mov        x4, edi
  492.  
  493.         mov        x6, eax
  494.         mov        x1, esi
  495.  
  496.         sub        ebp, 4
  497.         jnc        vert_R1_loop
  498.  
  499.         mov        esp, dword ptr fs:[0]
  500.         pop        dword ptr fs:[0]
  501.         pop        eax
  502.  
  503. #undef x7
  504. #undef x6
  505. #undef x5
  506. #undef x4
  507. #undef x3
  508. #undef x2
  509. #undef x1
  510. #undef x0
  511.  
  512.  
  513.  
  514.  
  515.         pop        ebx
  516.         pop        esi
  517.         pop        edi
  518.         pop        ebp
  519.         ret
  520.  
  521. #define x0 [ebp+0*4]
  522. #define x1 [ebp+1*4]
  523. #define x2 [ebp+2*4]
  524. #define x3 [ebp+3*4]
  525. #define x4 [ebp+4*4]
  526. #define x5 [ebp+5*4]
  527. #define x6 [ebp+6*4]
  528. #define x7 [ebp+7*4]
  529.  
  530. m1:
  531.         mov        eax, x0
  532.         mov        ebx, x1
  533.         mov        ecx, x2
  534.         mov        edx, x5
  535.  
  536.         shl        eax, 13
  537.         shl        ebx, 13
  538.         shl        ecx, 13
  539.         shl        edx, 13
  540.         mov        x0, eax
  541.         mov        x1, ebx
  542.         mov        x2, ecx
  543.         imul    eax, x3, 11585        ;inv_a0
  544.         imul    ebx, x4, 11585        ;inv_a0
  545.         mov        x5, edx
  546.  
  547.         mov        ecx, x6
  548.         mov        esi, x7
  549.         mov        edx, esi
  550.         add        esi, ecx            ;esi = x6+x7
  551.         imul    ecx, -8868            ;ecx = x6*inv_a3
  552.         imul    edx, 21407            ;edx = x7*inv_a1
  553.         imul    esi, -15137            ;esi = (x6+x7)*inv_a2
  554.         mov        x3, eax
  555.         mov        x4, ebx
  556.         sub        ecx, esi
  557.         add        edx, esi
  558.         mov        x6, ecx
  559.         mov        x7, edx
  560.         ret
  561.  
  562. m2:
  563.         imul    eax, x0, 11585
  564.         imul    ebx, x1, 11585
  565.         imul    ecx, x2, 11585
  566.         imul    edx, x5, 11585
  567.  
  568.         mov        x0, eax
  569.         mov        x1, ebx
  570.  
  571.         mov        esi, x3
  572.         mov        edi, x4
  573.         shl        esi, 14
  574.         shl        edi, 14
  575.  
  576.         mov        x2, ecx
  577.         mov        x5, edx
  578.         mov        x3, esi
  579.         mov        x4, edi
  580.  
  581.         mov        ecx, x6
  582.         mov        esi, x7
  583.         mov        edx, esi
  584.         add        esi, ecx            ;esi = x6+x7
  585.  
  586.         imul    ecx, -12541            ;ecx = x6*inv_b3
  587.         imul    edx, 30274            ;edx = x7*inv_b1
  588.         imul    esi, -21407            ;esi = (x6+x7)*inv_b2
  589.         sub        ecx, esi
  590.         add        edx, esi
  591.         mov        x6, ecx
  592.         mov        x7, edx
  593.         ret
  594.  
  595. #undef x7
  596. #undef x6
  597. #undef x5
  598. #undef x4
  599. #undef x3
  600. #undef x2
  601. #undef x1
  602. #undef x0
  603.     }
  604. }
  605.  
  606. static void scalar_idct_feig_winograd_8x8(int *d) {
  607.     scalar_idct_feig_winograd_8x8_temp(d);
  608. }
  609.  
  610. static void scalar_idct_feig_winograd_4x4(int *d) {
  611.     scalar_idct_feig_winograd_8x8(d);
  612. }
  613.  
  614. #pragma warning(pop)
  615.