Cinelerra: hvirtual/quicktime/ffmpeg/libavcodec/i386/vp3dsp

00001 /*
00002  * Copyright (C) 2004 the ffmpeg project
00003  *
00004  * This library is free software; you can redistribute it and/or
00005  * modify it under the terms of the GNU Lesser General Public
00006  * License as published by the Free Software Foundation; either
00007  * version 2 of the License, or (at your option) any later version.
00008  *
00009  * This library is distributed in the hope that it will be useful,
00010  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00011  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00012  * Lesser General Public License for more details.
00013  *
00014  * You should have received a copy of the GNU Lesser General Public
00015  * License along with this library; if not, write to the Free Software
00016  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00017  */
00018 
00024 #include "../dsputil.h"
00025 #include "mmx.h"
00026 
00027 #define IdctAdjustBeforeShift 8
00028 
00029 /* (12 * 4) 2-byte memory locations ( = 96 bytes total)
00030  * idct_constants[0..15] = Mask table (M(I))
00031  * idct_constants[16..43] = Cosine table (C(I))
00032  * idct_constants[44..47] = 8
00033  */
00034 static uint16_t idct_constants[(4 + 7 + 1) * 4];
00035 static const uint16_t idct_cosine_table[7] = {
00036     64277, 60547, 54491, 46341, 36410, 25080, 12785
00037 };
00038 
00039 #define r0 mm0
00040 #define r1 mm1
00041 #define r2 mm2
00042 #define r3 mm3
00043 #define r4 mm4
00044 #define r5 mm5
00045 #define r6 mm6
00046 #define r7 mm7
00047 
00048 /* from original comments: The Macro does IDct on 4 1-D Dcts */
00049 #define BeginIDCT() { \
00050     movq_m2r(*I(3), r2); \
00051     movq_m2r(*C(3), r6); \
00052     movq_r2r(r2, r4); \
00053     movq_m2r(*J(5), r7); \
00054     pmulhw_r2r(r6, r4);       /* r4 = c3*i3 - i3 */ \
00055     movq_m2r(*C(5), r1); \
00056     pmulhw_r2r(r7, r6);       /* r6 = c3*i5 - i5 */ \
00057     movq_r2r(r1, r5); \
00058     pmulhw_r2r(r2, r1);       /* r1 = c5*i3 - i3 */ \
00059     movq_m2r(*I(1), r3); \
00060     pmulhw_r2r(r7, r5);       /* r5 = c5*i5 - i5 */ \
00061     movq_m2r(*C(1), r0);      /* (all registers are in use) */ \
00062     paddw_r2r(r2, r4);        /* r4 = c3*i3 */ \
00063     paddw_r2r(r7, r6);        /* r6 = c3*i5 */ \
00064     paddw_r2r(r1, r2);        /* r2 = c5*i3 */ \
00065     movq_m2r(*J(7), r1); \
00066     paddw_r2r(r5, r7);        /* r7 = c5*i5 */ \
00067     movq_r2r(r0, r5);         /* r5 = c1 */ \
00068     pmulhw_r2r(r3, r0);       /* r0 = c1*i1 - i1 */ \
00069     paddsw_r2r(r7, r4);       /* r4 = C = c3*i3 + c5*i5 */ \
00070     pmulhw_r2r(r1, r5);       /* r5 = c1*i7 - i7 */ \
00071     movq_m2r(*C(7), r7); \
00072     psubsw_r2r(r2, r6);       /* r6 = D = c3*i5 - c5*i3 */ \
00073     paddw_r2r(r3, r0);        /* r0 = c1*i1 */ \
00074     pmulhw_r2r(r7, r3);       /* r3 = c7*i1 */ \
00075     movq_m2r(*I(2), r2); \
00076     pmulhw_r2r(r1, r7);       /* r7 = c7*i7 */ \
00077     paddw_r2r(r1, r5);        /* r5 = c1*i7 */ \
00078     movq_r2r(r2, r1);         /* r1 = i2 */ \
00079     pmulhw_m2r(*C(2), r2);    /* r2 = c2*i2 - i2 */ \
00080     psubsw_r2r(r5, r3);       /* r3 = B = c7*i1 - c1*i7 */ \
00081     movq_m2r(*J(6), r5); \
00082     paddsw_r2r(r7, r0);       /* r0 = A = c1*i1 + c7*i7 */ \
00083     movq_r2r(r5, r7);         /* r7 = i6 */ \
00084     psubsw_r2r(r4, r0);       /* r0 = A - C */ \
00085     pmulhw_m2r(*C(2), r5);    /* r5 = c2*i6 - i6 */ \
00086     paddw_r2r(r1, r2);        /* r2 = c2*i2 */ \
00087     pmulhw_m2r(*C(6), r1);    /* r1 = c6*i2 */ \
00088     paddsw_r2r(r4, r4);       /* r4 = C + C */ \
00089     paddsw_r2r(r0, r4);       /* r4 = C. = A + C */ \
00090     psubsw_r2r(r6, r3);       /* r3 = B - D */ \
00091     paddw_r2r(r7, r5);        /* r5 = c2*i6 */ \
00092     paddsw_r2r(r6, r6);       /* r6 = D + D */ \
00093     pmulhw_m2r(*C(6), r7);    /* r7 = c6*i6 */ \
00094     paddsw_r2r(r3, r6);       /* r6 = D. = B + D */ \
00095     movq_r2m(r4, *I(1));      /* save C. at I(1) */ \
00096     psubsw_r2r(r5, r1);       /* r1 = H = c6*i2 - c2*i6 */ \
00097     movq_m2r(*C(4), r4); \
00098     movq_r2r(r3, r5);         /* r5 = B - D */ \
00099     pmulhw_r2r(r4, r3);       /* r3 = (c4 - 1) * (B - D) */ \
00100     paddsw_r2r(r2, r7);       /* r7 = G = c6*i6 + c2*i2 */ \
00101     movq_r2m(r6, *I(2));      /* save D. at I(2) */ \
00102     movq_r2r(r0, r2);         /* r2 = A - C */ \
00103     movq_m2r(*I(0), r6); \
00104     pmulhw_r2r(r4, r0);       /* r0 = (c4 - 1) * (A - C) */ \
00105     paddw_r2r(r3, r5);        /* r5 = B. = c4 * (B - D) */ \
00106     movq_m2r(*J(4), r3); \
00107     psubsw_r2r(r1, r5);       /* r5 = B.. = B. - H */ \
00108     paddw_r2r(r0, r2);        /* r0 = A. = c4 * (A - C) */ \
00109     psubsw_r2r(r3, r6);       /* r6 = i0 - i4 */ \
00110     movq_r2r(r6, r0); \
00111     pmulhw_r2r(r4, r6);       /* r6 = (c4 - 1) * (i0 - i4) */ \
00112     paddsw_r2r(r3, r3);       /* r3 = i4 + i4 */ \
00113     paddsw_r2r(r1, r1);       /* r1 = H + H */ \
00114     paddsw_r2r(r0, r3);       /* r3 = i0 + i4 */ \
00115     paddsw_r2r(r5, r1);       /* r1 = H. = B + H */ \
00116     pmulhw_r2r(r3, r4);       /* r4 = (c4 - 1) * (i0 + i4) */ \
00117     paddsw_r2r(r0, r6);       /* r6 = F = c4 * (i0 - i4) */ \
00118     psubsw_r2r(r2, r6);       /* r6 = F. = F - A. */ \
00119     paddsw_r2r(r2, r2);       /* r2 = A. + A. */ \
00120     movq_m2r(*I(1), r0);      /* r0 = C. */ \
00121     paddsw_r2r(r6, r2);       /* r2 = A.. = F + A. */ \
00122     paddw_r2r(r3, r4);        /* r4 = E = c4 * (i0 + i4) */ \
00123     psubsw_r2r(r1, r2);       /* r2 = R2 = A.. - H. */ \
00124 }
00125 
00126 /* RowIDCT gets ready to transpose */
00127 #define RowIDCT() { \
00128     \
00129     BeginIDCT(); \
00130     \
00131     movq_m2r(*I(2), r3);   /* r3 = D. */ \
00132     psubsw_r2r(r7, r4);    /* r4 = E. = E - G */ \
00133     paddsw_r2r(r1, r1);    /* r1 = H. + H. */ \
00134     paddsw_r2r(r7, r7);    /* r7 = G + G */ \
00135     paddsw_r2r(r2, r1);    /* r1 = R1 = A.. + H. */ \
00136     paddsw_r2r(r4, r7);    /* r7 = G. = E + G */ \
00137     psubsw_r2r(r3, r4);    /* r4 = R4 = E. - D. */ \
00138     paddsw_r2r(r3, r3); \
00139     psubsw_r2r(r5, r6);    /* r6 = R6 = F. - B.. */ \
00140     paddsw_r2r(r5, r5); \
00141     paddsw_r2r(r4, r3);    /* r3 = R3 = E. + D. */ \
00142     paddsw_r2r(r6, r5);    /* r5 = R5 = F. + B.. */ \
00143     psubsw_r2r(r0, r7);    /* r7 = R7 = G. - C. */ \
00144     paddsw_r2r(r0, r0); \
00145     movq_r2m(r1, *I(1));   /* save R1 */ \
00146     paddsw_r2r(r7, r0);    /* r0 = R0 = G. + C. */ \
00147 }
00148 
00149 /* Column IDCT normalizes and stores final results */
00150 #define ColumnIDCT() { \
00151     \
00152     BeginIDCT(); \
00153     \
00154     paddsw_m2r(*Eight, r2);    /* adjust R2 (and R1) for shift */ \
00155     paddsw_r2r(r1, r1);        /* r1 = H. + H. */ \
00156     paddsw_r2r(r2, r1);        /* r1 = R1 = A.. + H. */ \
00157     psraw_i2r(4, r2);          /* r2 = NR2 */ \
00158     psubsw_r2r(r7, r4);        /* r4 = E. = E - G */ \
00159     psraw_i2r(4, r1);          /* r1 = NR1 */ \
00160     movq_m2r(*I(2), r3);       /* r3 = D. */ \
00161     paddsw_r2r(r7, r7);        /* r7 = G + G */ \
00162     movq_r2m(r2, *I(2));       /* store NR2 at I2 */ \
00163     paddsw_r2r(r4, r7);        /* r7 = G. = E + G */ \
00164     movq_r2m(r1, *I(1));       /* store NR1 at I1 */ \
00165     psubsw_r2r(r3, r4);        /* r4 = R4 = E. - D. */ \
00166     paddsw_m2r(*Eight, r4);    /* adjust R4 (and R3) for shift */ \
00167     paddsw_r2r(r3, r3);        /* r3 = D. + D. */ \
00168     paddsw_r2r(r4, r3);        /* r3 = R3 = E. + D. */ \
00169     psraw_i2r(4, r4);          /* r4 = NR4 */ \
00170     psubsw_r2r(r5, r6);        /* r6 = R6 = F. - B.. */ \
00171     psraw_i2r(4, r3);          /* r3 = NR3 */ \
00172     paddsw_m2r(*Eight, r6);    /* adjust R6 (and R5) for shift */ \
00173     paddsw_r2r(r5, r5);        /* r5 = B.. + B.. */ \
00174     paddsw_r2r(r6, r5);        /* r5 = R5 = F. + B.. */ \
00175     psraw_i2r(4, r6);          /* r6 = NR6 */ \
00176     movq_r2m(r4, *J(4));       /* store NR4 at J4 */ \
00177     psraw_i2r(4, r5);          /* r5 = NR5 */ \
00178     movq_r2m(r3, *I(3));       /* store NR3 at I3 */ \
00179     psubsw_r2r(r0, r7);        /* r7 = R7 = G. - C. */ \
00180     paddsw_m2r(*Eight, r7);    /* adjust R7 (and R0) for shift */ \
00181     paddsw_r2r(r0, r0);        /* r0 = C. + C. */ \
00182     paddsw_r2r(r7, r0);        /* r0 = R0 = G. + C. */ \
00183     psraw_i2r(4, r7);          /* r7 = NR7 */ \
00184     movq_r2m(r6, *J(6));       /* store NR6 at J6 */ \
00185     psraw_i2r(4, r0);          /* r0 = NR0 */ \
00186     movq_r2m(r5, *J(5));       /* store NR5 at J5 */ \
00187     movq_r2m(r7, *J(7));       /* store NR7 at J7 */ \
00188     movq_r2m(r0, *I(0));       /* store NR0 at I0 */ \
00189 }
00190 
00191 /* Following macro does two 4x4 transposes in place.
00192 
00193   At entry (we assume):
00194 
00195     r0 = a3 a2 a1 a0
00196     I(1) = b3 b2 b1 b0
00197     r2 = c3 c2 c1 c0
00198     r3 = d3 d2 d1 d0
00199 
00200     r4 = e3 e2 e1 e0
00201     r5 = f3 f2 f1 f0
00202     r6 = g3 g2 g1 g0
00203     r7 = h3 h2 h1 h0
00204 
00205   At exit, we have:
00206 
00207     I(0) = d0 c0 b0 a0
00208     I(1) = d1 c1 b1 a1
00209     I(2) = d2 c2 b2 a2
00210     I(3) = d3 c3 b3 a3
00211     
00212     J(4) = h0 g0 f0 e0
00213     J(5) = h1 g1 f1 e1
00214     J(6) = h2 g2 f2 e2
00215     J(7) = h3 g3 f3 e3
00216 
00217    I(0) I(1) I(2) I(3)  is the transpose of r0 I(1) r2 r3.
00218    J(4) J(5) J(6) J(7)  is the transpose of r4 r5 r6 r7.
00219 
00220    Since r1 is free at entry, we calculate the Js first. */
00221 
00222 #define Transpose() { \
00223     movq_r2r(r4, r1);         /* r1 = e3 e2 e1 e0 */ \
00224     punpcklwd_r2r(r5, r4);    /* r4 = f1 e1 f0 e0 */ \
00225     movq_r2m(r0, *I(0));      /* save a3 a2 a1 a0 */ \
00226     punpckhwd_r2r(r5, r1);    /* r1 = f3 e3 f2 e2 */ \
00227     movq_r2r(r6, r0);         /* r0 = g3 g2 g1 g0 */ \
00228     punpcklwd_r2r(r7, r6);    /* r6 = h1 g1 h0 g0 */ \
00229     movq_r2r(r4, r5);         /* r5 = f1 e1 f0 e0 */ \
00230     punpckldq_r2r(r6, r4);    /* r4 = h0 g0 f0 e0 = R4 */ \
00231     punpckhdq_r2r(r6, r5);    /* r5 = h1 g1 f1 e1 = R5 */ \
00232     movq_r2r(r1, r6);         /* r6 = f3 e3 f2 e2 */ \
00233     movq_r2m(r4, *J(4)); \
00234     punpckhwd_r2r(r7, r0);    /* r0 = h3 g3 h2 g2 */ \
00235     movq_r2m(r5, *J(5)); \
00236     punpckhdq_r2r(r0, r6);    /* r6 = h3 g3 f3 e3 = R7 */ \
00237     movq_m2r(*I(0), r4);      /* r4 = a3 a2 a1 a0 */ \
00238     punpckldq_r2r(r0, r1);    /* r1 = h2 g2 f2 e2 = R6 */ \
00239     movq_m2r(*I(1), r5);      /* r5 = b3 b2 b1 b0 */ \
00240     movq_r2r(r4, r0);         /* r0 = a3 a2 a1 a0 */ \
00241     movq_r2m(r6, *J(7)); \
00242     punpcklwd_r2r(r5, r0);    /* r0 = b1 a1 b0 a0 */ \
00243     movq_r2m(r1, *J(6)); \
00244     punpckhwd_r2r(r5, r4);    /* r4 = b3 a3 b2 a2 */ \
00245     movq_r2r(r2, r5);         /* r5 = c3 c2 c1 c0 */ \
00246     punpcklwd_r2r(r3, r2);    /* r2 = d1 c1 d0 c0 */ \
00247     movq_r2r(r0, r1);         /* r1 = b1 a1 b0 a0 */ \
00248     punpckldq_r2r(r2, r0);    /* r0 = d0 c0 b0 a0 = R0 */ \
00249     punpckhdq_r2r(r2, r1);    /* r1 = d1 c1 b1 a1 = R1 */ \
00250     movq_r2r(r4, r2);         /* r2 = b3 a3 b2 a2 */ \
00251     movq_r2m(r0, *I(0)); \
00252     punpckhwd_r2r(r3, r5);    /* r5 = d3 c3 d2 c2 */ \
00253     movq_r2m(r1, *I(1)); \
00254     punpckhdq_r2r(r5, r4);    /* r4 = d3 c3 b3 a3 = R3 */ \
00255     punpckldq_r2r(r5, r2);    /* r2 = d2 c2 b2 a2 = R2 */ \
00256     movq_r2m(r4, *I(3)); \
00257     movq_r2m(r2, *I(2)); \
00258 }
00259 
00260 void ff_vp3_dsp_init_mmx(void)
00261 {
00262     int j = 16;
00263     uint16_t *p;
00264 
00265     j = 1;
00266     do {
00267         p = idct_constants + ((j + 3) << 2);
00268         p[0] = p[1] = p[2] = p[3] = idct_cosine_table[j - 1];
00269     } while (++j <= 7);
00270 
00271     idct_constants[44] = idct_constants[45] =
00272     idct_constants[46] = idct_constants[47] = IdctAdjustBeforeShift;
00273 }
00274 
00275 void ff_vp3_idct_mmx(int16_t *output_data)
00276 {
00277     /* eax = quantized input
00278      * ebx = dequantizer matrix
00279      * ecx = IDCT constants
00280      *  M(I) = ecx + MaskOffset(0) + I * 8
00281      *  C(I) = ecx + CosineOffset(32) + (I-1) * 8
00282      * edx = output
00283      * r0..r7 = mm0..mm7
00284      */
00285 
00286 #define C(x) (idct_constants + 16 + (x - 1) * 4)
00287 #define Eight (idct_constants + 44)
00288 
00289     /* at this point, function has completed dequantization + dezigzag +
00290      * partial transposition; now do the idct itself */
00291 #define I(K) (output_data + K * 8)
00292 #define J(K) (output_data + ((K - 4) * 8) + 4)
00293 
00294     RowIDCT();
00295     Transpose();
00296 
00297 #undef I
00298 #undef J
00299 #define I(K) (output_data + (K * 8) + 32)
00300 #define J(K) (output_data + ((K - 4) * 8) + 36)
00301 
00302     RowIDCT();
00303     Transpose();
00304 
00305 #undef I
00306 #undef J
00307 #define I(K) (output_data + K * 8)
00308 #define J(K) (output_data + K * 8)
00309 
00310     ColumnIDCT();
00311 
00312 #undef I
00313 #undef J
00314 #define I(K) (output_data + (K * 8) + 4)
00315 #define J(K) (output_data + (K * 8) + 4)
00316 
00317     ColumnIDCT();
00318 
00319 #undef I
00320 #undef J
00321 
00322 }
hvirtual/quicktime/ffmpeg/libavcodec/i386/vp3dsp_mmx.c
