ffmpeg roll of source to mar 9 version...

patched-ffmpeg-mt/libavcodec/x86/h264dsp_mmx.c

 /*
  * Copyright (c) 2004-2005 Michael Niedermayer, Loren Merritt
  *
  * This file is part of FFmpeg.
  *
  * FFmpeg is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * FFmpeg is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with FFmpeg; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
 #include "dsputil_mmx.h"
 
-DECLARE_ALIGNED_8 (static const uint64_t, ff_pb_3_1  ) = 0x0103010301030103ULL;
-DECLARE_ALIGNED_8 (static const uint64_t, ff_pb_7_3  ) = 0x0307030703070307ULL;
+DECLARE_ALIGNED(8, static const uint64_t, ff_pb_3_1  ) = 0x0103010301030103ULL;
+DECLARE_ALIGNED(8, static const uint64_t, ff_pb_7_3  ) = 0x0307030703070307ULL;
 
 /***********************************/
 /* IDCT */
 
 #define SUMSUB_BADC( a, b, c, d ) \
     "paddw "#b", "#a" \n\t"\
     "paddw "#d", "#c" \n\t"\
     "paddw "#b", "#b" \n\t"\
     "paddw "#d", "#d" \n\t"\
     "psubw "#a", "#b" \n\t"\
@@ skipping 115 matching lines @@
         SUMSUB_BA( %%mm5, %%mm4 )
         SUMSUB_BA( %%mm3, %%mm2 )
         SUMSUB_BA( %%mm1, %%mm0 )
         :: "r"(block)
     );
 }
 
 static void ff_h264_idct8_add_mmx(uint8_t *dst, int16_t *block, int stride)
 {
     int i;
-    DECLARE_ALIGNED_8(int16_t, b2)[64];
+    DECLARE_ALIGNED(8, int16_t, b2)[64];
 
     block[0] += 32;
 
     for(i=0; i<2; i++){
-        DECLARE_ALIGNED_8(uint64_t, tmp);
+        DECLARE_ALIGNED(8, uint64_t, tmp);
 
         h264_idct8_1d(block+4*i);
 
         __asm__ volatile(
             "movq   %%mm7,    %0   \n\t"
             TRANSPOSE4( %%mm0, %%mm2, %%mm4, %%mm6, %%mm7 )
             "movq   %%mm0,  8(%1)  \n\t"
             "movq   %%mm6, 24(%1)  \n\t"
             "movq   %%mm7, 40(%1)  \n\t"
             "movq   %%mm4, 56(%1)  \n\t"
@@ skipping 445 matching lines @@
         "psubusb  "#tmp", "#q2"    \n\t" /* (p2+((p0+q0+1)>>1))>>1 */\
         "movq     "#p1",  "#tmp"   \n\t"\
         "psubusb  "#tc0", "#tmp"   \n\t"\
         "paddusb  "#p1",  "#tc0"   \n\t"\
         "pmaxub   "#tmp", "#q2"    \n\t"\
         "pminub   "#tc0", "#q2"    \n\t"\
         "movq     "#q2",  "q1addr" \n\t"
 
 static inline void h264_loop_filter_luma_mmx2(uint8_t *pix, int stride, int alpha1, int beta1, int8_t *tc0)
 {
-    DECLARE_ALIGNED_8(uint64_t, tmp0)[2];
+    DECLARE_ALIGNED(8, uint64_t, tmp0)[2];
 
     __asm__ volatile(
         "movq    (%2,%4), %%mm0    \n\t" //p1
         "movq    (%2,%4,2), %%mm1  \n\t" //p0
         "movq    (%3),    %%mm2    \n\t" //q0
         "movq    (%3,%4), %%mm3    \n\t" //q1
         H264_DEBLOCK_MASK(%7, %8)
 
         "movd      %6,    %%mm4    \n\t"
         "punpcklbw %%mm4, %%mm4    \n\t"
@@ skipping 41 matching lines @@
 {
     if((tc0[0] & tc0[1]) >= 0)
         h264_loop_filter_luma_mmx2(pix, stride, alpha-1, beta-1, tc0);
     if((tc0[2] & tc0[3]) >= 0)
         h264_loop_filter_luma_mmx2(pix+8, stride, alpha-1, beta-1, tc0+2);
 }
 static void h264_h_loop_filter_luma_mmx2(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
 {
     //FIXME: could cut some load/stores by merging transpose with filter
     // also, it only needs to transpose 6x8
-    DECLARE_ALIGNED_8(uint8_t, trans)[8*8];
+    DECLARE_ALIGNED(8, uint8_t, trans)[8*8];
     int i;
     for(i=0; i<2; i++, pix+=8*stride, tc0+=2) {
         if((tc0[0] & tc0[1]) < 0)
             continue;
         transpose4x4(trans,       pix-4,          8, stride);
         transpose4x4(trans  +4*8, pix,            8, stride);
         transpose4x4(trans+4,     pix-4+4*stride, 8, stride);
         transpose4x4(trans+4+4*8, pix  +4*stride, 8, stride);
         h264_loop_filter_luma_mmx2(trans+4*8, 8, alpha-1, beta-1, tc0);
         transpose4x4(pix-2,          trans  +2*8, stride, 8);
@@ skipping 23 matching lines @@
 }
 
 static void h264_v_loop_filter_chroma_mmx2(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
 {
     h264_loop_filter_chroma_mmx2(pix, stride, alpha-1, beta-1, tc0);
 }
 
 static void h264_h_loop_filter_chroma_mmx2(uint8_t *pix, int stride, int alpha, int beta, int8_t *tc0)
 {
     //FIXME: could cut some load/stores by merging transpose with filter
-    DECLARE_ALIGNED_8(uint8_t, trans)[8*4];
+    DECLARE_ALIGNED(8, uint8_t, trans)[8*4];
     transpose4x4(trans, pix-2, 8, stride);
     transpose4x4(trans+4, pix-2+4*stride, 8, stride);
     h264_loop_filter_chroma_mmx2(trans+2*8, 8, alpha-1, beta-1, tc0);
     transpose4x4(pix-2, trans, stride, 8);
     transpose4x4(pix-2+4*stride, trans+4, stride, 8);
 }
 
 // p0 = (p0 + q1 + 2*p1 + 2) >> 2
 #define H264_FILTER_CHROMA4(p0, p1, q1, one) \
     "movq    "#p0", %%mm4  \n\t"\
@@ skipping 29 matching lines @@
 }
 
 static void h264_v_loop_filter_chroma_intra_mmx2(uint8_t *pix, int stride, int alpha, int beta)
 {
     h264_loop_filter_chroma_intra_mmx2(pix, stride, alpha-1, beta-1);
 }
 
 static void h264_h_loop_filter_chroma_intra_mmx2(uint8_t *pix, int stride, int alpha, int beta)
 {
     //FIXME: could cut some load/stores by merging transpose with filter
-    DECLARE_ALIGNED_8(uint8_t, trans)[8*4];
+    DECLARE_ALIGNED(8, uint8_t, trans)[8*4];
     transpose4x4(trans, pix-2, 8, stride);
     transpose4x4(trans+4, pix-2+4*stride, 8, stride);
     h264_loop_filter_chroma_intra_mmx2(trans+2*8, 8, alpha-1, beta-1);
     transpose4x4(pix-2, trans, stride, 8);
     transpose4x4(pix-2+4*stride, trans+4, stride, 8);
 }
 
 static void h264_loop_filter_strength_mmx2( int16_t bS[2][4][4], uint8_t nnz[40], int8_t ref[2][40], int16_t mv[2][40][2],
                                             int bidir, int edges, int step, int mask_mv0, int mask_mv1, int field ) {
     int dir;
@@ skipping 10 matching lines @@
     __asm__ volatile(
         "movq  %%mm6, %%mm5 \n"
         "paddb %%mm5, %%mm5 \n"
     :);
 
     // could do a special case for dir==0 && edges==1, but it only reduces the
     // average filter time by 1.2%
     for( dir=1; dir>=0; dir-- ) {
         const x86_reg d_idx = dir ? -8 : -1;
         const int mask_mv = dir ? mask_mv1 : mask_mv0;
-        DECLARE_ALIGNED_8(const uint64_t, mask_dir) = dir ? 0 : 0xffffffffffffffffULL;
+        DECLARE_ALIGNED(8, const uint64_t, mask_dir) = dir ? 0 : 0xffffffffffffffffULL;
         int b_idx, edge;
         for( b_idx=12, edge=0; edge<edges; edge+=step, b_idx+=8*step ) {
             __asm__ volatile(
                 "pand %0, %%mm0 \n\t"
                 ::"m"(mask_dir)
             );
             if(!(mask_mv & edge)) {
                 if(bidir) {
                     __asm__ volatile(
                         "movd         (%1,%0), %%mm2 \n"
@@ skipping 1270 matching lines @@
 H264_MC_4816(3dnow)
 H264_MC_4816(mmx2)
 H264_MC_816(H264_MC_V, sse2)
 H264_MC_816(H264_MC_HV, sse2)
 #if HAVE_SSSE3
 H264_MC_816(H264_MC_H, ssse3)
 H264_MC_816(H264_MC_HV, ssse3)
 #endif
 
 /* rnd interleaved with rnd div 8, use p+1 to access rnd div 8 */
-DECLARE_ALIGNED_8(static const uint64_t, h264_rnd_reg)[4] = {
+DECLARE_ALIGNED(8, static const uint64_t, h264_rnd_reg)[4] = {
     0x0020002000200020ULL, 0x0004000400040004ULL, 0x001C001C001C001CULL, 0x0003000300030003ULL
 };
 
 #define H264_CHROMA_OP(S,D)
 #define H264_CHROMA_OP4(S,D,T)
 #define H264_CHROMA_MC8_TMPL put_h264_chroma_generic_mc8_mmx
 #define H264_CHROMA_MC4_TMPL put_h264_chroma_generic_mc4_mmx
 #define H264_CHROMA_MC2_TMPL put_h264_chroma_mc2_mmx2
 #define H264_CHROMA_MC8_MV0 put_pixels8_mmx
 #include "dsputil_h264_template_mmx.c"
@@ skipping 196 matching lines @@
 
 H264_WEIGHT(16,16)
 H264_WEIGHT(16, 8)
 H264_WEIGHT( 8,16)
 H264_WEIGHT( 8, 8)
 H264_WEIGHT( 8, 4)
 H264_WEIGHT( 4, 8)
 H264_WEIGHT( 4, 4)
 H264_WEIGHT( 4, 2)