Merge commit '79dad2a932534d1155079f937649e099f9e5cc27'
authorMichael Niedermayer <michaelni@gmx.at>
Thu, 7 Feb 2013 12:09:35 +0000 (13:09 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Thu, 7 Feb 2013 12:09:35 +0000 (13:09 +0100)
* commit '79dad2a932534d1155079f937649e099f9e5cc27':
  dsputil: Separate h264chroma

Conflicts:
libavcodec/dsputil_template.c
libavcodec/ppc/dsputil_ppc.c
libavcodec/vc1dec.c
libavcodec/vc1dsp.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
38 files changed:
1  2 
configure
libavcodec/Makefile
libavcodec/arm/dsputil_init_neon.c
libavcodec/arm/h264chroma_init_arm.c
libavcodec/cavs.c
libavcodec/cavs.h
libavcodec/dsputil.c
libavcodec/dsputil.h
libavcodec/dsputil_template.c
libavcodec/h264.c
libavcodec/h264.h
libavcodec/h264_mb_template.c
libavcodec/h264chroma.c
libavcodec/h264chroma.h
libavcodec/h264chroma_template.c
libavcodec/mpegvideo.c
libavcodec/mpegvideo.h
libavcodec/ppc/dsputil_altivec.h
libavcodec/ppc/dsputil_ppc.c
libavcodec/ppc/h264_qpel.c
libavcodec/ppc/h264_qpel_template.c
libavcodec/ppc/h264chroma_init.c
libavcodec/ppc/h264chroma_template.c
libavcodec/ppc/vc1dsp_altivec.c
libavcodec/rv30dsp.c
libavcodec/sh4/dsputil_align.c
libavcodec/sh4/h264chroma_init.c
libavcodec/sh4/qpel.c
libavcodec/vc1.h
libavcodec/vc1dec.c
libavcodec/vc1dsp.c
libavcodec/vc1dsp.h
libavcodec/vp56.c
libavcodec/vp56.h
libavcodec/vp6.c
libavcodec/x86/Makefile
libavcodec/x86/dsputil_mmx.c
libavcodec/x86/h264chroma_init.c

diff --cc configure
Simple merge
Simple merge
Simple merge
index 0000000,6f36553..13f7e0d
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,51 +1,51 @@@
 - * This file is part of Libav.
+ /*
+  * ARM NEON optimised H.264 chroma functions
+  * Copyright (c) 2008 Mans Rullgard <mans@mansr.com>
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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 <stdint.h>
+ #include "libavutil/attributes.h"
+ #include "libavutil/cpu.h"
+ #include "libavutil/arm/cpu.h"
+ #include "libavcodec/h264chroma.h"
+ void ff_put_h264_chroma_mc8_neon(uint8_t *, uint8_t *, int, int, int, int);
+ void ff_put_h264_chroma_mc4_neon(uint8_t *, uint8_t *, int, int, int, int);
+ void ff_put_h264_chroma_mc2_neon(uint8_t *, uint8_t *, int, int, int, int);
+ void ff_avg_h264_chroma_mc8_neon(uint8_t *, uint8_t *, int, int, int, int);
+ void ff_avg_h264_chroma_mc4_neon(uint8_t *, uint8_t *, int, int, int, int);
+ void ff_avg_h264_chroma_mc2_neon(uint8_t *, uint8_t *, int, int, int, int);
+ av_cold void ff_h264chroma_init_arm(H264ChromaContext *c, int bit_depth)
+ {
+     const int high_bit_depth = bit_depth > 8;
+     int cpu_flags = av_get_cpu_flags();
+     if (have_neon(cpu_flags) && !high_bit_depth) {
+         c->put_h264_chroma_pixels_tab[0] = ff_put_h264_chroma_mc8_neon;
+         c->put_h264_chroma_pixels_tab[1] = ff_put_h264_chroma_mc4_neon;
+         c->put_h264_chroma_pixels_tab[2] = ff_put_h264_chroma_mc2_neon;
+         c->avg_h264_chroma_pixels_tab[0] = ff_avg_h264_chroma_mc8_neon;
+         c->avg_h264_chroma_pixels_tab[1] = ff_avg_h264_chroma_mc4_neon;
+         c->avg_h264_chroma_pixels_tab[2] = ff_avg_h264_chroma_mc2_neon;
+     }
+ }
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -992,10 -976,8 +993,12 @@@ static av_cold void common_init(H264Con
      s->height   = s->avctx->height;
      s->codec_id = s->avctx->codec->id;
  
 +    s->avctx->bits_per_raw_sample = 8;
 +    h->cur_chroma_format_idc = 1;
 +
      ff_h264dsp_init(&h->h264dsp, 8, 1);
++    av_assert0(h->sps.bit_depth_chroma == 0);
+     ff_h264chroma_init(&h->h264chroma, h->sps.bit_depth_chroma);
      ff_h264qpel_init(&h->h264qpel, 8);
      ff_h264_pred_init(&h->hpc, s->codec_id, 8, 1);
  
@@@ -2633,6 -2567,6 +2637,7 @@@ static int h264_slice_header_init(H264C
              memcpy(c, h->s.thread_context[i], sizeof(MpegEncContext));
              memset(&c->s + 1, 0, sizeof(H264Context) - sizeof(MpegEncContext));
              c->h264dsp     = h->h264dsp;
++            c->h264chroma  = h->h264chroma;
              c->h264qpel    = h->h264qpel;
              c->sps         = h->sps;
              c->pps         = h->pps;
Simple merge
Simple merge
index 0000000,2bd2df3..31004a5
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,64 +1,64 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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 "config.h"
+ #include "h264chroma.h"
+ #define BIT_DEPTH 8
+ #include "h264chroma_template.c"
+ #undef BIT_DEPTH
+ #define BIT_DEPTH 9
+ #include "h264chroma_template.c"
+ #undef BIT_DEPTH
+ #define BIT_DEPTH 10
+ #include "h264chroma_template.c"
+ #undef BIT_DEPTH
+ #define SET_CHROMA(depth)                                                   \
+     c->put_h264_chroma_pixels_tab[0] = put_h264_chroma_mc8_ ## depth ## _c; \
+     c->put_h264_chroma_pixels_tab[1] = put_h264_chroma_mc4_ ## depth ## _c; \
+     c->put_h264_chroma_pixels_tab[2] = put_h264_chroma_mc2_ ## depth ## _c; \
+     c->avg_h264_chroma_pixels_tab[0] = avg_h264_chroma_mc8_ ## depth ## _c; \
+     c->avg_h264_chroma_pixels_tab[1] = avg_h264_chroma_mc4_ ## depth ## _c; \
+     c->avg_h264_chroma_pixels_tab[2] = avg_h264_chroma_mc2_ ## depth ## _c; \
+ void ff_h264chroma_init(H264ChromaContext *c, int bit_depth)
+ {
+     switch (bit_depth) {
+     case 10:
+         SET_CHROMA(10);
+         break;
+     case 9:
+         SET_CHROMA(9);
+         break;
+     default:
+         SET_CHROMA(8);
+         break;
+     }
+     if (ARCH_ARM)
+         ff_h264chroma_init_arm(c, bit_depth);
+     if (ARCH_PPC)
+         ff_h264chroma_init_ppc(c, bit_depth);
+     if (ARCH_SH4)
+         ff_h264chroma_init_sh4(c, bit_depth);
+     if (ARCH_X86)
+         ff_h264chroma_init_x86(c, bit_depth);
+ }
index 0000000,7e1e2ed..4e035b0
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,38 +1,38 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
+  */
+ #ifndef AVCODEC_H264CHROMA_H
+ #define AVCODEC_H264CHROMA_H
+ #include <stdint.h>
+ typedef void (*h264_chroma_mc_func)(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int srcStride, int h, int x, int y);
+ typedef struct H264ChromaContext {
+     h264_chroma_mc_func put_h264_chroma_pixels_tab[3];
+     h264_chroma_mc_func avg_h264_chroma_pixels_tab[3];
+ } H264ChromaContext;
+ void ff_h264chroma_init(H264ChromaContext *c, int bit_depth);
+ void ff_h264chroma_init_arm(H264ChromaContext *c, int bit_depth);
+ void ff_h264chroma_init_ppc(H264ChromaContext *c, int bit_depth);
+ void ff_h264chroma_init_sh4(H264ChromaContext *c, int bit_depth);
+ void ff_h264chroma_init_x86(H264ChromaContext *c, int bit_depth);
+ #endif /* AVCODEC_H264CHROMA_H */
index 0000000,351d9d2..93559d7
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,142 +1,142 @@@
 - * This file is part of Libav.
+ /*
+  * Copyright (c) 2000, 2001 Fabrice Bellard
+  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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
 -#include <assert.h>
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
 -    stride /= sizeof(pixel);\
++#include "libavutil/avassert.h"
+ #include "bit_depth_template.c"
+ #define H264_CHROMA_MC(OPNAME, OP)\
+ static void FUNCC(OPNAME ## h264_chroma_mc2)(uint8_t *_dst/*align 8*/, uint8_t *_src/*align 1*/, int stride, int h, int x, int y){\
+     pixel *dst = (pixel*)_dst;\
+     pixel *src = (pixel*)_src;\
+     const int A=(8-x)*(8-y);\
+     const int B=(  x)*(8-y);\
+     const int C=(8-x)*(  y);\
+     const int D=(  x)*(  y);\
+     int i;\
 -    assert(x<8 && y<8 && x>=0 && y>=0);\
++    stride >>= sizeof(pixel)-1;\
+     \
 -    stride /= sizeof(pixel);\
++    av_assert2(x<8 && y<8 && x>=0 && y>=0);\
+ \
+     if(D){\
+         for(i=0; i<h; i++){\
+             OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1]));\
+             OP(dst[1], (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2]));\
+             dst+= stride;\
+             src+= stride;\
+         }\
+     }else{\
+         const int E= B+C;\
+         const int step= C ? stride : 1;\
+         for(i=0; i<h; i++){\
+             OP(dst[0], (A*src[0] + E*src[step+0]));\
+             OP(dst[1], (A*src[1] + E*src[step+1]));\
+             dst+= stride;\
+             src+= stride;\
+         }\
+     }\
+ }\
+ \
+ static void FUNCC(OPNAME ## h264_chroma_mc4)(uint8_t *_dst/*align 8*/, uint8_t *_src/*align 1*/, int stride, int h, int x, int y){\
+     pixel *dst = (pixel*)_dst;\
+     pixel *src = (pixel*)_src;\
+     const int A=(8-x)*(8-y);\
+     const int B=(  x)*(8-y);\
+     const int C=(8-x)*(  y);\
+     const int D=(  x)*(  y);\
+     int i;\
 -    assert(x<8 && y<8 && x>=0 && y>=0);\
++    stride >>= sizeof(pixel)-1;\
+     \
 -    stride /= sizeof(pixel);\
++    av_assert2(x<8 && y<8 && x>=0 && y>=0);\
+ \
+     if(D){\
+         for(i=0; i<h; i++){\
+             OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1]));\
+             OP(dst[1], (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2]));\
+             OP(dst[2], (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3]));\
+             OP(dst[3], (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4]));\
+             dst+= stride;\
+             src+= stride;\
+         }\
+     }else{\
+         const int E= B+C;\
+         const int step= C ? stride : 1;\
+         for(i=0; i<h; i++){\
+             OP(dst[0], (A*src[0] + E*src[step+0]));\
+             OP(dst[1], (A*src[1] + E*src[step+1]));\
+             OP(dst[2], (A*src[2] + E*src[step+2]));\
+             OP(dst[3], (A*src[3] + E*src[step+3]));\
+             dst+= stride;\
+             src+= stride;\
+         }\
+     }\
+ }\
+ \
+ static void FUNCC(OPNAME ## h264_chroma_mc8)(uint8_t *_dst/*align 8*/, uint8_t *_src/*align 1*/, int stride, int h, int x, int y){\
+     pixel *dst = (pixel*)_dst;\
+     pixel *src = (pixel*)_src;\
+     const int A=(8-x)*(8-y);\
+     const int B=(  x)*(8-y);\
+     const int C=(8-x)*(  y);\
+     const int D=(  x)*(  y);\
+     int i;\
 -    assert(x<8 && y<8 && x>=0 && y>=0);\
++    stride >>= sizeof(pixel)-1;\
+     \
++    av_assert2(x<8 && y<8 && x>=0 && y>=0);\
+ \
+     if(D){\
+         for(i=0; i<h; i++){\
+             OP(dst[0], (A*src[0] + B*src[1] + C*src[stride+0] + D*src[stride+1]));\
+             OP(dst[1], (A*src[1] + B*src[2] + C*src[stride+1] + D*src[stride+2]));\
+             OP(dst[2], (A*src[2] + B*src[3] + C*src[stride+2] + D*src[stride+3]));\
+             OP(dst[3], (A*src[3] + B*src[4] + C*src[stride+3] + D*src[stride+4]));\
+             OP(dst[4], (A*src[4] + B*src[5] + C*src[stride+4] + D*src[stride+5]));\
+             OP(dst[5], (A*src[5] + B*src[6] + C*src[stride+5] + D*src[stride+6]));\
+             OP(dst[6], (A*src[6] + B*src[7] + C*src[stride+6] + D*src[stride+7]));\
+             OP(dst[7], (A*src[7] + B*src[8] + C*src[stride+7] + D*src[stride+8]));\
+             dst+= stride;\
+             src+= stride;\
+         }\
+     }else{\
+         const int E= B+C;\
+         const int step= C ? stride : 1;\
+         for(i=0; i<h; i++){\
+             OP(dst[0], (A*src[0] + E*src[step+0]));\
+             OP(dst[1], (A*src[1] + E*src[step+1]));\
+             OP(dst[2], (A*src[2] + E*src[step+2]));\
+             OP(dst[3], (A*src[3] + E*src[step+3]));\
+             OP(dst[4], (A*src[4] + E*src[step+4]));\
+             OP(dst[5], (A*src[5] + E*src[step+5]));\
+             OP(dst[6], (A*src[6] + E*src[step+6]));\
+             OP(dst[7], (A*src[7] + E*src[step+7]));\
+             dst+= stride;\
+             src+= stride;\
+         }\
+     }\
+ }
+ #define op_avg(a, b) a = (((a)+(((b) + 32)>>6)+1)>>1)
+ #define op_put(a, b) a = (((b) + 32)>>6)
+ H264_CHROMA_MC(put_       , op_put)
+ H264_CHROMA_MC(avg_       , op_avg)
+ #undef op_avg
+ #undef op_put
@@@ -30,6 -30,6 +30,7 @@@
  #include "libavutil/imgutils.h"
  #include "avcodec.h"
  #include "dsputil.h"
++#include "h264chroma.h"
  #include "internal.h"
  #include "mathops.h"
  #include "mpegvideo.h"
@@@ -181,6 -184,6 +182,7 @@@ const uint8_t *avpriv_mpv_find_start_co
  av_cold int ff_dct_common_init(MpegEncContext *s)
  {
      ff_dsputil_init(&s->dsp, s->avctx);
++    ff_h264chroma_init(&s->h264chroma, 8); //for lowres
      ff_videodsp_init(&s->vdsp, s->avctx->bits_per_raw_sample);
  
      s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
@@@ -2039,381 -2048,6 +2041,381 @@@ void ff_print_debug_info(MpegEncContex
      }
  }
  
-                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
 +static inline int hpel_motion_lowres(MpegEncContext *s,
 +                                     uint8_t *dest, uint8_t *src,
 +                                     int field_based, int field_select,
 +                                     int src_x, int src_y,
 +                                     int width, int height, int stride,
 +                                     int h_edge_pos, int v_edge_pos,
 +                                     int w, int h, h264_chroma_mc_func *pix_op,
 +                                     int motion_x, int motion_y)
 +{
 +    const int lowres   = s->avctx->lowres;
 +    const int op_index = FFMIN(lowres, 2);
 +    const int s_mask   = (2 << lowres) - 1;
 +    int emu = 0;
 +    int sx, sy;
 +
 +    if (s->quarter_sample) {
 +        motion_x /= 2;
 +        motion_y /= 2;
 +    }
 +
 +    sx = motion_x & s_mask;
 +    sy = motion_y & s_mask;
 +    src_x += motion_x >> lowres + 1;
 +    src_y += motion_y >> lowres + 1;
 +
 +    src   += src_y * stride + src_x;
 +
 +    if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w,                 0) ||
 +        (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
 +        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w + 1,
 +                                (h + 1) << field_based, src_x,
 +                                src_y   << field_based,
 +                                h_edge_pos,
 +                                v_edge_pos);
 +        src = s->edge_emu_buffer;
 +        emu = 1;
 +    }
 +
 +    sx = (sx << 2) >> lowres;
 +    sy = (sy << 2) >> lowres;
 +    if (field_select)
 +        src += s->linesize;
 +    pix_op[op_index](dest, src, stride, h, sx, sy);
 +    return emu;
 +}
 +
 +/* apply one mpeg motion vector to the three components */
 +static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
 +                                                uint8_t *dest_y,
 +                                                uint8_t *dest_cb,
 +                                                uint8_t *dest_cr,
 +                                                int field_based,
 +                                                int bottom_field,
 +                                                int field_select,
 +                                                uint8_t **ref_picture,
 +                                                h264_chroma_mc_func *pix_op,
 +                                                int motion_x, int motion_y,
 +                                                int h, int mb_y)
 +{
 +    uint8_t *ptr_y, *ptr_cb, *ptr_cr;
 +    int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy,
 +        uvsx, uvsy;
 +    const int lowres     = s->avctx->lowres;
 +    const int op_index   = FFMIN(lowres-1+s->chroma_x_shift, 2);
 +    const int block_s    = 8>>lowres;
 +    const int s_mask     = (2 << lowres) - 1;
 +    const int h_edge_pos = s->h_edge_pos >> lowres;
 +    const int v_edge_pos = s->v_edge_pos >> lowres;
 +    linesize   = s->current_picture.f.linesize[0] << field_based;
 +    uvlinesize = s->current_picture.f.linesize[1] << field_based;
 +
 +    // FIXME obviously not perfect but qpel will not work in lowres anyway
 +    if (s->quarter_sample) {
 +        motion_x /= 2;
 +        motion_y /= 2;
 +    }
 +
 +    if(field_based){
 +        motion_y += (bottom_field - field_select)*((1 << lowres)-1);
 +    }
 +
 +    sx = motion_x & s_mask;
 +    sy = motion_y & s_mask;
 +    src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
 +    src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
 +
 +    if (s->out_format == FMT_H263) {
 +        uvsx    = ((motion_x >> 1) & s_mask) | (sx & 1);
 +        uvsy    = ((motion_y >> 1) & s_mask) | (sy & 1);
 +        uvsrc_x = src_x >> 1;
 +        uvsrc_y = src_y >> 1;
 +    } else if (s->out_format == FMT_H261) {
 +        // even chroma mv's are full pel in H261
 +        mx      = motion_x / 4;
 +        my      = motion_y / 4;
 +        uvsx    = (2 * mx) & s_mask;
 +        uvsy    = (2 * my) & s_mask;
 +        uvsrc_x = s->mb_x * block_s + (mx >> lowres);
 +        uvsrc_y =    mb_y * block_s + (my >> lowres);
 +    } else {
 +        if(s->chroma_y_shift){
 +            mx      = motion_x / 2;
 +            my      = motion_y / 2;
 +            uvsx    = mx & s_mask;
 +            uvsy    = my & s_mask;
 +            uvsrc_x = s->mb_x * block_s                 + (mx >> lowres + 1);
 +            uvsrc_y =   (mb_y * block_s >> field_based) + (my >> lowres + 1);
 +        } else {
 +            if(s->chroma_x_shift){
 +            //Chroma422
 +                mx = motion_x / 2;
 +                uvsx = mx & s_mask;
 +                uvsy = motion_y & s_mask;
 +                uvsrc_y = src_y;
 +                uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
 +            } else {
 +            //Chroma444
 +                uvsx = motion_x & s_mask;
 +                uvsy = motion_y & s_mask;
 +                uvsrc_x = src_x;
 +                uvsrc_y = src_y;
 +            }
 +        }
 +    }
 +
 +    ptr_y  = ref_picture[0] + src_y   * linesize   + src_x;
 +    ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
 +    ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
 +
 +    if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s,       0) ||
 +        (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
 +        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
 +                                linesize >> field_based, 17, 17 + field_based,
 +                                src_x, src_y << field_based, h_edge_pos,
 +                                v_edge_pos);
 +        ptr_y = s->edge_emu_buffer;
 +        if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
 +            uint8_t *uvbuf = s->edge_emu_buffer + 18 * s->linesize;
 +            s->vdsp.emulated_edge_mc(uvbuf , ptr_cb, uvlinesize >> field_based, 9,
 +                                    9 + field_based,
 +                                    uvsrc_x, uvsrc_y << field_based,
 +                                    h_edge_pos >> 1, v_edge_pos >> 1);
 +            s->vdsp.emulated_edge_mc(uvbuf + 16, ptr_cr, uvlinesize >> field_based, 9,
 +                                    9 + field_based,
 +                                    uvsrc_x, uvsrc_y << field_based,
 +                                    h_edge_pos >> 1, v_edge_pos >> 1);
 +            ptr_cb = uvbuf;
 +            ptr_cr = uvbuf + 16;
 +        }
 +    }
 +
 +    // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data
 +    if (bottom_field) {
 +        dest_y  += s->linesize;
 +        dest_cb += s->uvlinesize;
 +        dest_cr += s->uvlinesize;
 +    }
 +
 +    if (field_select) {
 +        ptr_y   += s->linesize;
 +        ptr_cb  += s->uvlinesize;
 +        ptr_cr  += s->uvlinesize;
 +    }
 +
 +    sx = (sx << 2) >> lowres;
 +    sy = (sy << 2) >> lowres;
 +    pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
 +
 +    if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
 +        uvsx = (uvsx << 2) >> lowres;
 +        uvsy = (uvsy << 2) >> lowres;
 +        if (h >> s->chroma_y_shift) {
 +            pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
 +            pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
 +        }
 +    }
 +    // FIXME h261 lowres loop filter
 +}
 +
 +static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
 +                                            uint8_t *dest_cb, uint8_t *dest_cr,
 +                                            uint8_t **ref_picture,
 +                                            h264_chroma_mc_func * pix_op,
 +                                            int mx, int my)
 +{
 +    const int lowres     = s->avctx->lowres;
 +    const int op_index   = FFMIN(lowres, 2);
 +    const int block_s    = 8 >> lowres;
 +    const int s_mask     = (2 << lowres) - 1;
 +    const int h_edge_pos = s->h_edge_pos >> lowres + 1;
 +    const int v_edge_pos = s->v_edge_pos >> lowres + 1;
 +    int emu = 0, src_x, src_y, offset, sx, sy;
 +    uint8_t *ptr;
 +
 +    if (s->quarter_sample) {
 +        mx /= 2;
 +        my /= 2;
 +    }
 +
 +    /* In case of 8X8, we construct a single chroma motion vector
 +       with a special rounding */
 +    mx = ff_h263_round_chroma(mx);
 +    my = ff_h263_round_chroma(my);
 +
 +    sx = mx & s_mask;
 +    sy = my & s_mask;
 +    src_x = s->mb_x * block_s + (mx >> lowres + 1);
 +    src_y = s->mb_y * block_s + (my >> lowres + 1);
 +
 +    offset = src_y * s->uvlinesize + src_x;
 +    ptr = ref_picture[1] + offset;
 +    if (s->flags & CODEC_FLAG_EMU_EDGE) {
 +        if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
 +            (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
 +            s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize,
 +                                    9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
 +            ptr = s->edge_emu_buffer;
 +            emu = 1;
 +        }
 +    }
 +    sx = (sx << 2) >> lowres;
 +    sy = (sy << 2) >> lowres;
 +    pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
 +
 +    ptr = ref_picture[2] + offset;
 +    if (emu) {
 +        s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9,
 +                                src_x, src_y, h_edge_pos, v_edge_pos);
 +        ptr = s->edge_emu_buffer;
 +    }
 +    pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
 +}
 +
 +/**
 + * motion compensation of a single macroblock
 + * @param s context
 + * @param dest_y luma destination pointer
 + * @param dest_cb chroma cb/u destination pointer
 + * @param dest_cr chroma cr/v destination pointer
 + * @param dir direction (0->forward, 1->backward)
 + * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
 + * @param pix_op halfpel motion compensation function (average or put normally)
 + * the motion vectors are taken from s->mv and the MV type from s->mv_type
 + */
 +static inline void MPV_motion_lowres(MpegEncContext *s,
 +                                     uint8_t *dest_y, uint8_t *dest_cb,
 +                                     uint8_t *dest_cr,
 +                                     int dir, uint8_t **ref_picture,
 +                                     h264_chroma_mc_func *pix_op)
 +{
 +    int mx, my;
 +    int mb_x, mb_y, i;
 +    const int lowres  = s->avctx->lowres;
 +    const int block_s = 8 >>lowres;
 +
 +    mb_x = s->mb_x;
 +    mb_y = s->mb_y;
 +
 +    switch (s->mv_type) {
 +    case MV_TYPE_16X16:
 +        mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
 +                           0, 0, 0,
 +                           ref_picture, pix_op,
 +                           s->mv[dir][0][0], s->mv[dir][0][1],
 +                           2 * block_s, mb_y);
 +        break;
 +    case MV_TYPE_8X8:
 +        mx = 0;
 +        my = 0;
 +        for (i = 0; i < 4; i++) {
 +            hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
 +                               s->linesize) * block_s,
 +                               ref_picture[0], 0, 0,
 +                               (2 * mb_x + (i & 1)) * block_s,
 +                               (2 * mb_y + (i >> 1)) * block_s,
 +                               s->width, s->height, s->linesize,
 +                               s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
 +                               block_s, block_s, pix_op,
 +                               s->mv[dir][i][0], s->mv[dir][i][1]);
 +
 +            mx += s->mv[dir][i][0];
 +            my += s->mv[dir][i][1];
 +        }
 +
 +        if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY))
 +            chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
 +                                     pix_op, mx, my);
 +        break;
 +    case MV_TYPE_FIELD:
 +        if (s->picture_structure == PICT_FRAME) {
 +            /* top field */
 +            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
 +                               1, 0, s->field_select[dir][0],
 +                               ref_picture, pix_op,
 +                               s->mv[dir][0][0], s->mv[dir][0][1],
 +                               block_s, mb_y);
 +            /* bottom field */
 +            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
 +                               1, 1, s->field_select[dir][1],
 +                               ref_picture, pix_op,
 +                               s->mv[dir][1][0], s->mv[dir][1][1],
 +                               block_s, mb_y);
 +        } else {
 +            if (s->picture_structure != s->field_select[dir][0] + 1 &&
 +                s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
 +                ref_picture = s->current_picture_ptr->f.data;
 +
 +            }
 +            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
 +                               0, 0, s->field_select[dir][0],
 +                               ref_picture, pix_op,
 +                               s->mv[dir][0][0],
 +                               s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
 +            }
 +        break;
 +    case MV_TYPE_16X8:
 +        for (i = 0; i < 2; i++) {
 +            uint8_t **ref2picture;
 +
 +            if (s->picture_structure == s->field_select[dir][i] + 1 ||
 +                s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
 +                ref2picture = ref_picture;
 +            } else {
 +                ref2picture = s->current_picture_ptr->f.data;
 +            }
 +
 +            mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
 +                               0, 0, s->field_select[dir][i],
 +                               ref2picture, pix_op,
 +                               s->mv[dir][i][0], s->mv[dir][i][1] +
 +                               2 * block_s * i, block_s, mb_y >> 1);
 +
 +            dest_y  +=  2 * block_s *  s->linesize;
 +            dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
 +            dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
 +        }
 +        break;
 +    case MV_TYPE_DMV:
 +        if (s->picture_structure == PICT_FRAME) {
 +            for (i = 0; i < 2; i++) {
 +                int j;
 +                for (j = 0; j < 2; j++) {
 +                    mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
 +                                       1, j, j ^ i,
 +                                       ref_picture, pix_op,
 +                                       s->mv[dir][2 * i + j][0],
 +                                       s->mv[dir][2 * i + j][1],
 +                                       block_s, mb_y);
 +                }
-                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
++                pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
 +            }
 +        } else {
 +            for (i = 0; i < 2; i++) {
 +                mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
 +                                   0, 0, s->picture_structure != i + 1,
 +                                   ref_picture, pix_op,
 +                                   s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
 +                                   2 * block_s, mb_y >> 1);
 +
 +                // after put we make avg of the same block
++                pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
 +
 +                // opposite parity is always in the same
 +                // frame if this is second field
 +                if (!s->first_field) {
 +                    ref_picture = s->current_picture_ptr->f.data;
 +                }
 +            }
 +        }
 +        break;
 +    default:
 +        av_assert2(0);
 +    }
 +}
 +
  /**
   * find the lowest MB row referenced in the MVs
   */
@@@ -2619,31 -2253,19 +2621,31 @@@ void MPV_decode_mb_internal(MpegEncCont
                      }
                  }
  
 -                op_qpix= s->me.qpel_put;
 -                if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
 -                    op_pix = s->dsp.put_pixels_tab;
 +                if(lowres_flag){
-                     h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
++                    h264_chroma_mc_func *op_pix = s->h264chroma.put_h264_chroma_pixels_tab;
 +
 +                    if (s->mv_dir & MV_DIR_FORWARD) {
 +                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix);
-                         op_pix = s->dsp.avg_h264_chroma_pixels_tab;
++                        op_pix = s->h264chroma.avg_h264_chroma_pixels_tab;
 +                    }
 +                    if (s->mv_dir & MV_DIR_BACKWARD) {
 +                        MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix);
 +                    }
                  }else{
 -                    op_pix = s->dsp.put_no_rnd_pixels_tab;
 -                }
 -                if (s->mv_dir & MV_DIR_FORWARD) {
 -                    ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
 -                    op_pix = s->dsp.avg_pixels_tab;
 -                    op_qpix= s->me.qpel_avg;
 -                }
 -                if (s->mv_dir & MV_DIR_BACKWARD) {
 -                    ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
 +                    op_qpix= s->me.qpel_put;
 +                    if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
 +                        op_pix = s->dsp.put_pixels_tab;
 +                    }else{
 +                        op_pix = s->dsp.put_no_rnd_pixels_tab;
 +                    }
 +                    if (s->mv_dir & MV_DIR_FORWARD) {
 +                        ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
 +                        op_pix = s->dsp.avg_pixels_tab;
 +                        op_qpix= s->me.qpel_avg;
 +                    }
 +                    if (s->mv_dir & MV_DIR_BACKWARD) {
 +                        ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
 +                    }
                  }
              }
  
@@@ -31,6 -31,6 +31,7 @@@
  #include "avcodec.h"
  #include "dsputil.h"
  #include "get_bits.h"
++#include "h264chroma.h"
  #include "put_bits.h"
  #include "ratecontrol.h"
  #include "parser.h"
@@@ -359,6 -354,6 +360,7 @@@ typedef struct MpegEncContext 
      int h263_long_vectors;      ///< use horrible h263v1 long vector mode
  
      DSPContext dsp;             ///< pointers for accelerated dsp functions
++    H264ChromaContext h264chroma;
      VideoDSPContext vdsp;
      int f_code;                 ///< forward MV resolution
      int b_code;                 ///< backward MV resolution for B Frames (mpeg4)
Simple merge
@@@ -165,9 -157,7 +165,7 @@@ av_cold void ff_dsputil_init_ppc(DSPCon
      }
  
  #if HAVE_ALTIVEC
-     if(CONFIG_H264_DECODER) ff_dsputil_h264_init_ppc(c, avctx);
 -    if (av_get_cpu_flags() & AV_CPU_FLAG_ALTIVEC) {
 +    if (mm_flags & AV_CPU_FLAG_ALTIVEC) {
          ff_dsputil_init_altivec(c, avctx);
          ff_int_init_altivec(c, avctx);
          c->gmc1 = ff_gmc1_altivec;
Simple merge
Simple merge
index 0000000,06456ec..f9e2a76
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,64 +1,64 @@@
 - * This file is part of Libav.
+ /*
+  * Copyright (c) 2004 Romain Dolbeau <romain@dolbeau.org>
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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 "config.h"
+ #include "libavutil/attributes.h"
+ #include "libavcodec/h264chroma.h"
+ #if HAVE_ALTIVEC
+ #include "libavutil/cpu.h"
+ #include "libavutil/intreadwrite.h"
+ #include "libavutil/ppc/types_altivec.h"
+ #include "libavutil/ppc/util_altivec.h"
+ #include "dsputil_altivec.h"
+ #define PUT_OP_U8_ALTIVEC(d, s, dst) d = s
+ #define AVG_OP_U8_ALTIVEC(d, s, dst) d = vec_avg(dst, s)
+ #define OP_U8_ALTIVEC                          PUT_OP_U8_ALTIVEC
+ #define PREFIX_h264_chroma_mc8_altivec         put_h264_chroma_mc8_altivec
+ #define PREFIX_h264_chroma_mc8_num             altivec_put_h264_chroma_mc8_num
+ #include "h264chroma_template.c"
+ #undef OP_U8_ALTIVEC
+ #undef PREFIX_h264_chroma_mc8_altivec
+ #undef PREFIX_h264_chroma_mc8_num
+ #define OP_U8_ALTIVEC                          AVG_OP_U8_ALTIVEC
+ #define PREFIX_h264_chroma_mc8_altivec         avg_h264_chroma_mc8_altivec
+ #define PREFIX_h264_chroma_mc8_num             altivec_avg_h264_chroma_mc8_num
+ #include "h264chroma_template.c"
+ #undef OP_U8_ALTIVEC
+ #undef PREFIX_h264_chroma_mc8_altivec
+ #undef PREFIX_h264_chroma_mc8_num
+ #endif /* HAVE_ALTIVEC */
+ av_cold void ff_h264chroma_init_ppc(H264ChromaContext *c, int bit_depth)
+ {
+ #if HAVE_ALTIVEC
+     const int high_bit_depth = bit_depth > 8;
+     if (av_get_cpu_flags() & AV_CPU_FLAG_ALTIVEC) {
+     if (!high_bit_depth) {
+         c->put_h264_chroma_pixels_tab[0] = put_h264_chroma_mc8_altivec;
+         c->avg_h264_chroma_pixels_tab[0] = avg_h264_chroma_mc8_altivec;
+     }
+     }
+ #endif /* HAVE_ALTIVEC */
+ }
index 0000000,293fef5..7436e11
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,289 +1,289 @@@
 - * This file is part of Libav.
+ /*
+  * Copyright (c) 2004 Romain Dolbeau <romain@dolbeau.org>
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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 "libavutil/mem.h"
+ /* this code assume that stride % 16 == 0 */
+ #define CHROMA_MC8_ALTIVEC_CORE(BIAS1, BIAS2) \
+         vsrc2ssH = (vec_s16)vec_mergeh(zero_u8v,(vec_u8)vsrc2uc);\
+         vsrc3ssH = (vec_s16)vec_mergeh(zero_u8v,(vec_u8)vsrc3uc);\
+ \
+         psum = vec_mladd(vA, vsrc0ssH, BIAS1);\
+         psum = vec_mladd(vB, vsrc1ssH, psum);\
+         psum = vec_mladd(vC, vsrc2ssH, psum);\
+         psum = vec_mladd(vD, vsrc3ssH, psum);\
+         psum = BIAS2(psum);\
+         psum = vec_sr(psum, v6us);\
+ \
+         vdst = vec_ld(0, dst);\
+         ppsum = (vec_u8)vec_pack(psum, psum);\
+         vfdst = vec_perm(vdst, ppsum, fperm);\
+ \
+         OP_U8_ALTIVEC(fsum, vfdst, vdst);\
+ \
+         vec_st(fsum, 0, dst);\
+ \
+         vsrc0ssH = vsrc2ssH;\
+         vsrc1ssH = vsrc3ssH;\
+ \
+         dst += stride;\
+         src += stride;
+ #define CHROMA_MC8_ALTIVEC_CORE_SIMPLE \
+ \
+         vsrc0ssH = (vec_s16)vec_mergeh(zero_u8v,(vec_u8)vsrc0uc);\
+         vsrc1ssH = (vec_s16)vec_mergeh(zero_u8v,(vec_u8)vsrc1uc);\
+ \
+         psum = vec_mladd(vA, vsrc0ssH, v32ss);\
+         psum = vec_mladd(vE, vsrc1ssH, psum);\
+         psum = vec_sr(psum, v6us);\
+ \
+         vdst = vec_ld(0, dst);\
+         ppsum = (vec_u8)vec_pack(psum, psum);\
+         vfdst = vec_perm(vdst, ppsum, fperm);\
+ \
+         OP_U8_ALTIVEC(fsum, vfdst, vdst);\
+ \
+         vec_st(fsum, 0, dst);\
+ \
+         dst += stride;\
+         src += stride;
+ #define noop(a) a
+ #define add28(a) vec_add(v28ss, a)
+ #ifdef PREFIX_h264_chroma_mc8_altivec
+ static void PREFIX_h264_chroma_mc8_altivec(uint8_t * dst, uint8_t * src,
+                                     int stride, int h, int x, int y) {
+     DECLARE_ALIGNED(16, signed int, ABCD)[4] =
+                         {((8 - x) * (8 - y)),
+                          ((    x) * (8 - y)),
+                          ((8 - x) * (    y)),
+                          ((    x) * (    y))};
+     register int i;
+     vec_u8 fperm;
+     const vec_s32 vABCD = vec_ld(0, ABCD);
+     const vec_s16 vA = vec_splat((vec_s16)vABCD, 1);
+     const vec_s16 vB = vec_splat((vec_s16)vABCD, 3);
+     const vec_s16 vC = vec_splat((vec_s16)vABCD, 5);
+     const vec_s16 vD = vec_splat((vec_s16)vABCD, 7);
+     LOAD_ZERO;
+     const vec_s16 v32ss = vec_sl(vec_splat_s16(1),vec_splat_u16(5));
+     const vec_u16 v6us = vec_splat_u16(6);
+     register int loadSecond = (((unsigned long)src) % 16) <= 7 ? 0 : 1;
+     register int reallyBadAlign = (((unsigned long)src) % 16) == 15 ? 1 : 0;
+     vec_u8 vsrcAuc, av_uninit(vsrcBuc), vsrcperm0, vsrcperm1;
+     vec_u8 vsrc0uc, vsrc1uc;
+     vec_s16 vsrc0ssH, vsrc1ssH;
+     vec_u8 vsrcCuc, vsrc2uc, vsrc3uc;
+     vec_s16 vsrc2ssH, vsrc3ssH, psum;
+     vec_u8 vdst, ppsum, vfdst, fsum;
+     if (((unsigned long)dst) % 16 == 0) {
+         fperm = (vec_u8){0x10, 0x11, 0x12, 0x13,
+                          0x14, 0x15, 0x16, 0x17,
+                          0x08, 0x09, 0x0A, 0x0B,
+                          0x0C, 0x0D, 0x0E, 0x0F};
+     } else {
+         fperm = (vec_u8){0x00, 0x01, 0x02, 0x03,
+                          0x04, 0x05, 0x06, 0x07,
+                          0x18, 0x19, 0x1A, 0x1B,
+                          0x1C, 0x1D, 0x1E, 0x1F};
+     }
+     vsrcAuc = vec_ld(0, src);
+     if (loadSecond)
+         vsrcBuc = vec_ld(16, src);
+     vsrcperm0 = vec_lvsl(0, src);
+     vsrcperm1 = vec_lvsl(1, src);
+     vsrc0uc = vec_perm(vsrcAuc, vsrcBuc, vsrcperm0);
+     if (reallyBadAlign)
+         vsrc1uc = vsrcBuc;
+     else
+         vsrc1uc = vec_perm(vsrcAuc, vsrcBuc, vsrcperm1);
+     vsrc0ssH = (vec_s16)vec_mergeh(zero_u8v,(vec_u8)vsrc0uc);
+     vsrc1ssH = (vec_s16)vec_mergeh(zero_u8v,(vec_u8)vsrc1uc);
+     if (ABCD[3]) {
+         if (!loadSecond) {// -> !reallyBadAlign
+             for (i = 0 ; i < h ; i++) {
+                 vsrcCuc = vec_ld(stride + 0, src);
+                 vsrc2uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0);
+                 vsrc3uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm1);
+                 CHROMA_MC8_ALTIVEC_CORE(v32ss, noop)
+             }
+         } else {
+             vec_u8 vsrcDuc;
+             for (i = 0 ; i < h ; i++) {
+                 vsrcCuc = vec_ld(stride + 0, src);
+                 vsrcDuc = vec_ld(stride + 16, src);
+                 vsrc2uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0);
+                 if (reallyBadAlign)
+                     vsrc3uc = vsrcDuc;
+                 else
+                     vsrc3uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm1);
+                 CHROMA_MC8_ALTIVEC_CORE(v32ss, noop)
+             }
+         }
+     } else {
+         const vec_s16 vE = vec_add(vB, vC);
+         if (ABCD[2]) { // x == 0 B == 0
+             if (!loadSecond) {// -> !reallyBadAlign
+                 for (i = 0 ; i < h ; i++) {
+                     vsrcCuc = vec_ld(stride + 0, src);
+                     vsrc1uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0);
+                     CHROMA_MC8_ALTIVEC_CORE_SIMPLE
+                     vsrc0uc = vsrc1uc;
+                 }
+             } else {
+                 vec_u8 vsrcDuc;
+                 for (i = 0 ; i < h ; i++) {
+                     vsrcCuc = vec_ld(stride + 0, src);
+                     vsrcDuc = vec_ld(stride + 15, src);
+                     vsrc1uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0);
+                     CHROMA_MC8_ALTIVEC_CORE_SIMPLE
+                     vsrc0uc = vsrc1uc;
+                 }
+             }
+         } else { // y == 0 C == 0
+             if (!loadSecond) {// -> !reallyBadAlign
+                 for (i = 0 ; i < h ; i++) {
+                     vsrcCuc = vec_ld(0, src);
+                     vsrc0uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0);
+                     vsrc1uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm1);
+                     CHROMA_MC8_ALTIVEC_CORE_SIMPLE
+                 }
+             } else {
+                 vec_u8 vsrcDuc;
+                 for (i = 0 ; i < h ; i++) {
+                     vsrcCuc = vec_ld(0, src);
+                     vsrcDuc = vec_ld(15, src);
+                     vsrc0uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0);
+                     if (reallyBadAlign)
+                         vsrc1uc = vsrcDuc;
+                     else
+                         vsrc1uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm1);
+                     CHROMA_MC8_ALTIVEC_CORE_SIMPLE
+                 }
+             }
+         }
+     }
+ }
+ #endif
+ /* this code assume that stride % 16 == 0 */
+ #ifdef PREFIX_no_rnd_vc1_chroma_mc8_altivec
+ static void PREFIX_no_rnd_vc1_chroma_mc8_altivec(uint8_t * dst, uint8_t * src, int stride, int h, int x, int y) {
+    DECLARE_ALIGNED(16, signed int, ABCD)[4] =
+                         {((8 - x) * (8 - y)),
+                          ((    x) * (8 - y)),
+                          ((8 - x) * (    y)),
+                          ((    x) * (    y))};
+     register int i;
+     vec_u8 fperm;
+     const vec_s32 vABCD = vec_ld(0, ABCD);
+     const vec_s16 vA = vec_splat((vec_s16)vABCD, 1);
+     const vec_s16 vB = vec_splat((vec_s16)vABCD, 3);
+     const vec_s16 vC = vec_splat((vec_s16)vABCD, 5);
+     const vec_s16 vD = vec_splat((vec_s16)vABCD, 7);
+     LOAD_ZERO;
+     const vec_s16 v28ss = vec_sub(vec_sl(vec_splat_s16(1),vec_splat_u16(5)),vec_splat_s16(4));
+     const vec_u16 v6us  = vec_splat_u16(6);
+     register int loadSecond     = (((unsigned long)src) % 16) <= 7 ? 0 : 1;
+     register int reallyBadAlign = (((unsigned long)src) % 16) == 15 ? 1 : 0;
+     vec_u8 vsrcAuc, av_uninit(vsrcBuc), vsrcperm0, vsrcperm1;
+     vec_u8 vsrc0uc, vsrc1uc;
+     vec_s16 vsrc0ssH, vsrc1ssH;
+     vec_u8 vsrcCuc, vsrc2uc, vsrc3uc;
+     vec_s16 vsrc2ssH, vsrc3ssH, psum;
+     vec_u8 vdst, ppsum, vfdst, fsum;
+     if (((unsigned long)dst) % 16 == 0) {
+         fperm = (vec_u8){0x10, 0x11, 0x12, 0x13,
+                          0x14, 0x15, 0x16, 0x17,
+                          0x08, 0x09, 0x0A, 0x0B,
+                          0x0C, 0x0D, 0x0E, 0x0F};
+     } else {
+         fperm = (vec_u8){0x00, 0x01, 0x02, 0x03,
+                          0x04, 0x05, 0x06, 0x07,
+                          0x18, 0x19, 0x1A, 0x1B,
+                          0x1C, 0x1D, 0x1E, 0x1F};
+     }
+     vsrcAuc = vec_ld(0, src);
+     if (loadSecond)
+         vsrcBuc = vec_ld(16, src);
+     vsrcperm0 = vec_lvsl(0, src);
+     vsrcperm1 = vec_lvsl(1, src);
+     vsrc0uc = vec_perm(vsrcAuc, vsrcBuc, vsrcperm0);
+     if (reallyBadAlign)
+         vsrc1uc = vsrcBuc;
+     else
+         vsrc1uc = vec_perm(vsrcAuc, vsrcBuc, vsrcperm1);
+     vsrc0ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc0uc);
+     vsrc1ssH = (vec_s16)vec_mergeh(zero_u8v, (vec_u8)vsrc1uc);
+     if (!loadSecond) {// -> !reallyBadAlign
+         for (i = 0 ; i < h ; i++) {
+             vsrcCuc = vec_ld(stride + 0, src);
+             vsrc2uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm0);
+             vsrc3uc = vec_perm(vsrcCuc, vsrcCuc, vsrcperm1);
+             CHROMA_MC8_ALTIVEC_CORE(vec_splat_s16(0), add28)
+         }
+     } else {
+         vec_u8 vsrcDuc;
+         for (i = 0 ; i < h ; i++) {
+             vsrcCuc = vec_ld(stride + 0, src);
+             vsrcDuc = vec_ld(stride + 16, src);
+             vsrc2uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm0);
+             if (reallyBadAlign)
+                 vsrc3uc = vsrcDuc;
+             else
+                 vsrc3uc = vec_perm(vsrcCuc, vsrcDuc, vsrcperm1);
+             CHROMA_MC8_ALTIVEC_CORE(vec_splat_s16(0), add28)
+         }
+     }
+ }
+ #endif
+ #undef noop
+ #undef add28
+ #undef CHROMA_MC8_ALTIVEC_CORE
Simple merge
Simple merge
Simple merge
index 0000000,5681a24..d15f0ae
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,132 +1,132 @@@
 - * This file is part of Libav.
+ /*
+  * aligned/packed access motion
+  *
+  * Copyright (c) 2001-2003 BERO <bero@geocities.co.jp>
+  *
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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 <assert.h>
+ #include <stdint.h>
+ #include "libavutil/attributes.h"
+ #include "libavcodec/h264chroma.h"
+ #define H264_CHROMA_MC(OPNAME, OP)\
+ static void OPNAME ## h264_chroma_mc2_sh4(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int x, int y){\
+     const int A=(8-x)*(8-y);\
+     const int B=(  x)*(8-y);\
+     const int C=(8-x)*(  y);\
+     const int D=(  x)*(  y);\
+     \
+     assert(x<8 && y<8 && x>=0 && y>=0);\
+ \
+     do {\
+         int t0,t1,t2,t3; \
+         uint8_t *s0 = src; \
+         uint8_t *s1 = src+stride; \
+         t0 = *s0++; t2 = *s1++; \
+         t1 = *s0++; t3 = *s1++; \
+         OP(dst[0], (A*t0 + B*t1 + C*t2 + D*t3));\
+         t0 = *s0++; t2 = *s1++; \
+         OP(dst[1], (A*t1 + B*t0 + C*t3 + D*t2));\
+         dst+= stride;\
+         src+= stride;\
+     }while(--h);\
+ }\
+ \
+ static void OPNAME ## h264_chroma_mc4_sh4(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int x, int y){\
+     const int A=(8-x)*(8-y);\
+     const int B=(  x)*(8-y);\
+     const int C=(8-x)*(  y);\
+     const int D=(  x)*(  y);\
+     \
+     assert(x<8 && y<8 && x>=0 && y>=0);\
+ \
+     do {\
+         int t0,t1,t2,t3; \
+         uint8_t *s0 = src; \
+         uint8_t *s1 = src+stride; \
+         t0 = *s0++; t2 = *s1++; \
+         t1 = *s0++; t3 = *s1++; \
+         OP(dst[0], (A*t0 + B*t1 + C*t2 + D*t3));\
+         t0 = *s0++; t2 = *s1++; \
+         OP(dst[1], (A*t1 + B*t0 + C*t3 + D*t2));\
+         t1 = *s0++; t3 = *s1++; \
+         OP(dst[2], (A*t0 + B*t1 + C*t2 + D*t3));\
+         t0 = *s0++; t2 = *s1++; \
+         OP(dst[3], (A*t1 + B*t0 + C*t3 + D*t2));\
+         dst+= stride;\
+         src+= stride;\
+     }while(--h);\
+ }\
+ \
+ static void OPNAME ## h264_chroma_mc8_sh4(uint8_t *dst/*align 8*/, uint8_t *src/*align 1*/, int stride, int h, int x, int y){\
+     const int A=(8-x)*(8-y);\
+     const int B=(  x)*(8-y);\
+     const int C=(8-x)*(  y);\
+     const int D=(  x)*(  y);\
+     \
+     assert(x<8 && y<8 && x>=0 && y>=0);\
+ \
+     do {\
+         int t0,t1,t2,t3; \
+         uint8_t *s0 = src; \
+         uint8_t *s1 = src+stride; \
+         t0 = *s0++; t2 = *s1++; \
+         t1 = *s0++; t3 = *s1++; \
+         OP(dst[0], (A*t0 + B*t1 + C*t2 + D*t3));\
+         t0 = *s0++; t2 = *s1++; \
+         OP(dst[1], (A*t1 + B*t0 + C*t3 + D*t2));\
+         t1 = *s0++; t3 = *s1++; \
+         OP(dst[2], (A*t0 + B*t1 + C*t2 + D*t3));\
+         t0 = *s0++; t2 = *s1++; \
+         OP(dst[3], (A*t1 + B*t0 + C*t3 + D*t2));\
+         t1 = *s0++; t3 = *s1++; \
+         OP(dst[4], (A*t0 + B*t1 + C*t2 + D*t3));\
+         t0 = *s0++; t2 = *s1++; \
+         OP(dst[5], (A*t1 + B*t0 + C*t3 + D*t2));\
+         t1 = *s0++; t3 = *s1++; \
+         OP(dst[6], (A*t0 + B*t1 + C*t2 + D*t3));\
+         t0 = *s0++; t2 = *s1++; \
+         OP(dst[7], (A*t1 + B*t0 + C*t3 + D*t2));\
+         dst+= stride;\
+         src+= stride;\
+     }while(--h);\
+ }
+ #define op_avg(a, b) a = (((a)+(((b) + 32)>>6)+1)>>1)
+ #define op_put(a, b) a = (((b) + 32)>>6)
+ H264_CHROMA_MC(put_       , op_put)
+ H264_CHROMA_MC(avg_       , op_avg)
+ #undef op_avg
+ #undef op_put
+ av_cold void ff_h264chroma_init_sh4(H264ChromaContext *c, int bit_depth)
+ {
+     const int high_bit_depth = bit_depth > 8;
+     if (!high_bit_depth) {
+     c->put_h264_chroma_pixels_tab[0]= put_h264_chroma_mc8_sh4;
+     c->put_h264_chroma_pixels_tab[1]= put_h264_chroma_mc4_sh4;
+     c->put_h264_chroma_pixels_tab[2]= put_h264_chroma_mc2_sh4;
+     c->avg_h264_chroma_pixels_tab[0]= avg_h264_chroma_mc8_sh4;
+     c->avg_h264_chroma_pixels_tab[1]= avg_h264_chroma_mc4_sh4;
+     c->avg_h264_chroma_pixels_tab[2]= avg_h264_chroma_mc2_sh4;
+     }
+ }
Simple merge
Simple merge
@@@ -5186,15 -5167,7 +5189,17 @@@ static av_cold int vc1_decode_init(AVCo
  
      if (ff_vc1_init_common(v) < 0)
          return -1;
 +    // ensure static VLC tables are initialized
 +    if (ff_msmpeg4_decode_init(avctx) < 0)
 +        return -1;
 +    if (ff_vc1_decode_init_alloc_tables(v) < 0)
 +        return -1;
 +    // Hack to ensure the above functions will be called
 +    // again once we know all necessary settings.
 +    // That this is necessary might indicate a bug.
 +    ff_vc1_decode_end(avctx);
++
+     ff_h264chroma_init(&v->h264chroma, 8);
      ff_vc1dsp_init(&v->vc1dsp);
  
      if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
   *
   */
  
- #include "vc1dsp.h"
 +#include "libavutil/avassert.h"
  #include "libavutil/common.h"
+ #include "h264chroma.h"
+ #include "vc1dsp.h"
  
  
  /** Apply overlap transform to horizontal edge
  #define AVCODEC_VC1DSP_H
  
  #include "dsputil.h"
+ #include "h264chroma.h"
  
 +typedef void (*vc1op_pixels_func)(uint8_t *block/*align width (8 or 16)*/, const uint8_t *pixels/*align 1*/, int line_size, int h);
 +
  typedef struct VC1DSPContext {
      /* vc1 functions */
      void (*vc1_inv_trans_8x8)(int16_t *b);
Simple merge
Simple merge
Simple merge
@@@ -47,11 -41,10 +47,12 @@@ MMX-OBJS-$(CONFIG_VC1_DECODER)         
  YASM-OBJS-$(CONFIG_AAC_DECODER)        += x86/sbrdsp.o
  YASM-OBJS-$(CONFIG_AC3DSP)             += x86/ac3dsp.o
  YASM-OBJS-$(CONFIG_DCT)                += x86/dct32.o
 +YASM-OBJS-$(CONFIG_DIRAC_DECODER)      += x86/diracdsp_mmx.o x86/diracdsp_yasm.o\
 +                                          x86/dwt_yasm.o
  YASM-OBJS-$(CONFIG_ENCODERS)           += x86/dsputilenc.o
  YASM-OBJS-$(CONFIG_FFT)                += x86/fft.o
- YASM-OBJS-$(CONFIG_H264CHROMA)         += x86/h264_chromamc.o           \
+ YASM-OBJS-$(CONFIG_H264CHROMA)         += x86/h264chroma_init.o         \
+                                           x86/h264_chromamc.o           \
                                            x86/h264_chromamc_10bit.o
  YASM-OBJS-$(CONFIG_H264DSP)            += x86/h264_deblock.o            \
                                            x86/h264_deblock_10bit.o      \
Simple merge
index 0000000,f1f3a19..b9783d6
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,116 +1,116 @@@
 - * This file is part of Libav.
+ /*
 - * Libav is free software; you can redistribute it and/or
++ * This file is part of FFmpeg.
+  *
 - * Libav is distributed in the hope that it will be useful,
++ * 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.
+  *
 - * License along with Libav; if not, write to the Free Software
++ * 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 <stdint.h>
+ #include "config.h"
+ #include "libavutil/cpu.h"
+ #include "libavutil/x86/cpu.h"
+ #include "libavcodec/h264chroma.h"
+ void ff_put_h264_chroma_mc8_rnd_mmx  (uint8_t *dst, uint8_t *src,
+                                       int stride, int h, int x, int y);
+ void ff_avg_h264_chroma_mc8_rnd_mmxext(uint8_t *dst, uint8_t *src,
+                                        int stride, int h, int x, int y);
+ void ff_avg_h264_chroma_mc8_rnd_3dnow(uint8_t *dst, uint8_t *src,
+                                       int stride, int h, int x, int y);
+ void ff_put_h264_chroma_mc4_mmx      (uint8_t *dst, uint8_t *src,
+                                       int stride, int h, int x, int y);
+ void ff_avg_h264_chroma_mc4_mmxext   (uint8_t *dst, uint8_t *src,
+                                       int stride, int h, int x, int y);
+ void ff_avg_h264_chroma_mc4_3dnow    (uint8_t *dst, uint8_t *src,
+                                       int stride, int h, int x, int y);
+ void ff_put_h264_chroma_mc2_mmxext   (uint8_t *dst, uint8_t *src,
+                                       int stride, int h, int x, int y);
+ void ff_avg_h264_chroma_mc2_mmxext   (uint8_t *dst, uint8_t *src,
+                                       int stride, int h, int x, int y);
+ void ff_put_h264_chroma_mc8_rnd_ssse3(uint8_t *dst, uint8_t *src,
+                                       int stride, int h, int x, int y);
+ void ff_put_h264_chroma_mc4_ssse3    (uint8_t *dst, uint8_t *src,
+                                       int stride, int h, int x, int y);
+ void ff_avg_h264_chroma_mc8_rnd_ssse3(uint8_t *dst, uint8_t *src,
+                                       int stride, int h, int x, int y);
+ void ff_avg_h264_chroma_mc4_ssse3    (uint8_t *dst, uint8_t *src,
+                                       int stride, int h, int x, int y);
+ #define CHROMA_MC(OP, NUM, DEPTH, OPT)                                  \
+ void ff_ ## OP ## _h264_chroma_mc ## NUM ## _ ## DEPTH ## _ ## OPT      \
+                                       (uint8_t *dst, uint8_t *src,      \
+                                        int stride, int h, int x, int y);
+ CHROMA_MC(put, 2, 10, mmxext)
+ CHROMA_MC(avg, 2, 10, mmxext)
+ CHROMA_MC(put, 4, 10, mmxext)
+ CHROMA_MC(avg, 4, 10, mmxext)
+ CHROMA_MC(put, 8, 10, sse2)
+ CHROMA_MC(avg, 8, 10, sse2)
+ CHROMA_MC(put, 8, 10, avx)
+ CHROMA_MC(avg, 8, 10, avx)
+ void ff_h264chroma_init_x86(H264ChromaContext *c, int bit_depth)
+ {
+     int high_bit_depth = bit_depth > 8;
+     int mm_flags       = av_get_cpu_flags();
+     if (EXTERNAL_MMX(mm_flags) && !high_bit_depth) {
+         c->put_h264_chroma_pixels_tab[0] = ff_put_h264_chroma_mc8_rnd_mmx;
+         c->put_h264_chroma_pixels_tab[1] = ff_put_h264_chroma_mc4_mmx;
+     }
+     if (EXTERNAL_AMD3DNOW(mm_flags) && !high_bit_depth) {
+         c->avg_h264_chroma_pixels_tab[0] = ff_avg_h264_chroma_mc8_rnd_3dnow;
+         c->avg_h264_chroma_pixels_tab[1] = ff_avg_h264_chroma_mc4_3dnow;
+     }
+     if (EXTERNAL_MMXEXT(mm_flags) && !high_bit_depth) {
+         c->avg_h264_chroma_pixels_tab[0] = ff_avg_h264_chroma_mc8_rnd_mmxext;
+         c->avg_h264_chroma_pixels_tab[1] = ff_avg_h264_chroma_mc4_mmxext;
+         c->avg_h264_chroma_pixels_tab[2] = ff_avg_h264_chroma_mc2_mmxext;
+         c->put_h264_chroma_pixels_tab[2] = ff_put_h264_chroma_mc2_mmxext;
+     }
+     if (EXTERNAL_MMXEXT(mm_flags) && bit_depth == 10) {
+         c->put_h264_chroma_pixels_tab[2] = ff_put_h264_chroma_mc2_10_mmxext;
+         c->avg_h264_chroma_pixels_tab[2] = ff_avg_h264_chroma_mc2_10_mmxext;
+         c->put_h264_chroma_pixels_tab[1] = ff_put_h264_chroma_mc4_10_mmxext;
+         c->avg_h264_chroma_pixels_tab[1] = ff_avg_h264_chroma_mc4_10_mmxext;
+     }
+     if (EXTERNAL_SSE2(mm_flags) && bit_depth == 10) {
+         c->put_h264_chroma_pixels_tab[0] = ff_put_h264_chroma_mc8_10_sse2;
+         c->avg_h264_chroma_pixels_tab[0] = ff_avg_h264_chroma_mc8_10_sse2;
+     }
+     if (EXTERNAL_SSSE3(mm_flags) && !high_bit_depth) {
+         c->put_h264_chroma_pixels_tab[0] = ff_put_h264_chroma_mc8_rnd_ssse3;
+         c->avg_h264_chroma_pixels_tab[0] = ff_avg_h264_chroma_mc8_rnd_ssse3;
+         c->put_h264_chroma_pixels_tab[1] = ff_put_h264_chroma_mc4_ssse3;
+         c->avg_h264_chroma_pixels_tab[1] = ff_avg_h264_chroma_mc4_ssse3;
+     }
+     if (EXTERNAL_AVX(mm_flags) && bit_depth == 10) {
+         // AVX implies !cache64.
+         // TODO: Port cache(32|64) detection from x264.
+         c->put_h264_chroma_pixels_tab[0] = ff_put_h264_chroma_mc8_10_avx;
+         c->avg_h264_chroma_pixels_tab[0] = ff_avg_h264_chroma_mc8_10_avx;
+     }
+ }