Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Thu, 5 Jul 2012 19:23:37 +0000 (21:23 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Thu, 5 Jul 2012 19:55:31 +0000 (21:55 +0200)
* qatar/master:
  qdm2: remove broken and disabled dump_context() debug function
  x86: h264_intrapred: use newly introduced SPLAT* and PSHUFLW macros
  x86inc: add SPLATB_LOAD, SPLATB_REG, PSHUFLW macros
  x86inc: modify ALIGN to not generate long nops on i586
  x86: h264_intrapred: port to cpuflag macros
  avplay: update input filter pointer when the filtergraph is reset.
  avconv: fix parsing of -force_key_frames option.
  h264: use templates to avoid excessive inlining
  xtea: Make the count parameter match the documentation
  blowfish: Make the count parameter match the documentation
  mpegvideo: Don't use ff_mspel_motion() for vc1
  xtea: invert branch and loop precedence
  blowfish: invert branch and loop precedence
  flvdec: optionally trust the metadata
  avconv: Set audio filter time base to the sample rate
  vp8: Add ifdef guards around the sse2 loopfilter in the sse2slow branch too

Conflicts:
ffmpeg.c
ffplay.c
libavcodec/h264.c
libavcodec/mpegvideo_common.h

Merged-by: Michael Niedermayer <michaelni@gmx.at>
15 files changed:
1  2 
ffmpeg.c
libavcodec/h264.c
libavcodec/h264_mb_template.c
libavcodec/h264_mc_template.c
libavcodec/mpegvideo_common.h
libavcodec/qdm2.c
libavcodec/x86/h264_intrapred.asm
libavcodec/x86/h264_intrapred_init.c
libavcodec/x86/vp8dsp-init.c
libavcodec/x86/vp8dsp.asm
libavformat/flvdec.c
libavutil/blowfish.c
libavutil/x86/x86inc.asm
libavutil/x86/x86util.asm
libavutil/xtea.c

diff --cc ffmpeg.c
+++ b/ffmpeg.c
@@@ -2451,8 -2029,12 +2451,12 @@@ static int decode_audio(InputStream *is
              }
      }
  
+     if (decoded_frame->pts != AV_NOPTS_VALUE)
+         decoded_frame->pts = av_rescale_q(decoded_frame->pts,
+                                           ist->st->time_base,
+                                           (AVRational){1, ist->st->codec->sample_rate});
      for (i = 0; i < ist->nb_filters; i++)
 -        av_buffersrc_write_frame(ist->filters[i]->filter, decoded_frame);
 +        av_buffersrc_add_frame(ist->filters[i]->filter, decoded_frame, 0);
  
      return ret;
  }
Simple merge
index 0000000,b7856cb..d82562b
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,380 +1,379 @@@
 - * This file is part of Libav.
+ /*
+  * H.26L/H.264/AVC/JVT/14496-10/... decoder
+  * Copyright (c) 2003 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
 -            const int bit_depth = h->sps.bit_depth_luma;
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #undef FUNC
+ #undef PIXEL_SHIFT
+ #if SIMPLE
+ #   define FUNC(n) AV_JOIN(n ## _simple_, BITS)
+ #   define PIXEL_SHIFT (BITS >> 4)
+ #else
+ #   define FUNC(n) n ## _complex
+ #   define PIXEL_SHIFT h->pixel_shift
+ #endif
+ #undef  CHROMA_IDC
+ #define CHROMA_IDC 1
+ #include "h264_mc_template.c"
+ #undef  CHROMA_IDC
+ #define CHROMA_IDC 2
+ #include "h264_mc_template.c"
+ static av_noinline void FUNC(hl_decode_mb)(H264Context *h)
+ {
+     MpegEncContext *const s = &h->s;
+     const int mb_x    = s->mb_x;
+     const int mb_y    = s->mb_y;
+     const int mb_xy   = h->mb_xy;
+     const int mb_type = s->current_picture.f.mb_type[mb_xy];
+     uint8_t *dest_y, *dest_cb, *dest_cr;
+     int linesize, uvlinesize /*dct_offset*/;
+     int i, j;
+     int *block_offset = &h->block_offset[0];
+     const int transform_bypass = !SIMPLE && (s->qscale == 0 && h->sps.transform_bypass);
+     /* is_h264 should always be true if SVQ3 is disabled. */
+     const int is_h264 = !CONFIG_SVQ3_DECODER || SIMPLE || s->codec_id == CODEC_ID_H264;
+     void (*idct_add)(uint8_t *dst, DCTELEM *block, int stride);
+     const int block_h   = 16 >> s->chroma_y_shift;
+     const int chroma422 = CHROMA422;
+     dest_y  = s->current_picture.f.data[0] + ((mb_x << PIXEL_SHIFT)     + mb_y * s->linesize)  * 16;
+     dest_cb = s->current_picture.f.data[1] +  (mb_x << PIXEL_SHIFT) * 8 + mb_y * s->uvlinesize * block_h;
+     dest_cr = s->current_picture.f.data[2] +  (mb_x << PIXEL_SHIFT) * 8 + mb_y * s->uvlinesize * block_h;
+     s->dsp.prefetch(dest_y  + (s->mb_x & 3) * 4 * s->linesize   + (64 << PIXEL_SHIFT), s->linesize,       4);
+     s->dsp.prefetch(dest_cb + (s->mb_x & 7)     * s->uvlinesize + (64 << PIXEL_SHIFT), dest_cr - dest_cb, 2);
+     h->list_counts[mb_xy] = h->list_count;
+     if (!SIMPLE && MB_FIELD) {
+         linesize     = h->mb_linesize = s->linesize * 2;
+         uvlinesize   = h->mb_uvlinesize = s->uvlinesize * 2;
+         block_offset = &h->block_offset[48];
+         if (mb_y & 1) { // FIXME move out of this function?
+             dest_y  -= s->linesize * 15;
+             dest_cb -= s->uvlinesize * (block_h - 1);
+             dest_cr -= s->uvlinesize * (block_h - 1);
+         }
+         if (FRAME_MBAFF) {
+             int list;
+             for (list = 0; list < h->list_count; list++) {
+                 if (!USES_LIST(mb_type, list))
+                     continue;
+                 if (IS_16X16(mb_type)) {
+                     int8_t *ref = &h->ref_cache[list][scan8[0]];
+                     fill_rectangle(ref, 4, 4, 8, (16 + *ref) ^ (s->mb_y & 1), 1);
+                 } else {
+                     for (i = 0; i < 16; i += 4) {
+                         int ref = h->ref_cache[list][scan8[i]];
+                         if (ref >= 0)
+                             fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2,
+                                            8, (16 + ref) ^ (s->mb_y & 1), 1);
+                     }
+                 }
+             }
+         }
+     } else {
+         linesize   = h->mb_linesize   = s->linesize;
+         uvlinesize = h->mb_uvlinesize = s->uvlinesize;
+         // dct_offset = s->linesize * 16;
+     }
+     if (!SIMPLE && IS_INTRA_PCM(mb_type)) {
++        const int bit_depth = h->sps.bit_depth_luma;
+         if (PIXEL_SHIFT) {
 -                        for (j = 0; j < 8; j++)
 -                            tmp_cb[j] = 1 << (bit_depth - 1);
 -                    }
 -                    for (i = 0; i < block_h; i++) {
+             int j;
+             GetBitContext gb;
+             init_get_bits(&gb, (uint8_t *)h->mb,
+                           ff_h264_mb_sizes[h->sps.chroma_format_idc] * bit_depth);
+             for (i = 0; i < 16; i++) {
+                 uint16_t *tmp_y = (uint16_t *)(dest_y + i * linesize);
+                 for (j = 0; j < 16; j++)
+                     tmp_y[j] = get_bits(&gb, bit_depth);
+             }
+             if (SIMPLE || !CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
+                 if (!h->sps.chroma_format_idc) {
+                     for (i = 0; i < block_h; i++) {
+                         uint16_t *tmp_cb = (uint16_t *)(dest_cb + i * uvlinesize);
 -                        for (j = 0; j < 8; j++)
 -                            tmp_cr[j] = 1 << (bit_depth - 1);
+                         uint16_t *tmp_cr = (uint16_t *)(dest_cr + i * uvlinesize);
 -                    for (i = 0; i < block_h; i++) {
 -                        memset(dest_cb + i * uvlinesize, 128, 8);
 -                        memset(dest_cr + i * uvlinesize, 128, 8);
++                        for (j = 0; j < 8; j++) {
++                            tmp_cb[j] = tmp_cr[j] = 1 << (bit_depth - 1);
++                        }
+                     }
+                 } else {
+                     for (i = 0; i < block_h; i++) {
+                         uint16_t *tmp_cb = (uint16_t *)(dest_cb + i * uvlinesize);
+                         for (j = 0; j < 8; j++)
+                             tmp_cb[j] = get_bits(&gb, bit_depth);
+                     }
+                     for (i = 0; i < block_h; i++) {
+                         uint16_t *tmp_cr = (uint16_t *)(dest_cr + i * uvlinesize);
+                         for (j = 0; j < 8; j++)
+                             tmp_cr[j] = get_bits(&gb, bit_depth);
+                     }
+                 }
+             }
+         } else {
+             for (i = 0; i < 16; i++)
+                 memcpy(dest_y + i * linesize, (uint8_t *)h->mb + i * 16, 16);
+             if (SIMPLE || !CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
+                 if (!h->sps.chroma_format_idc) {
++                    for (i = 0; i < 8; i++) {
++                        memset(dest_cb + i*uvlinesize, 1 << (bit_depth - 1), 8);
++                        memset(dest_cr + i*uvlinesize, 1 << (bit_depth - 1), 8);
+                     }
+                 } else {
+                     uint8_t *src_cb = (uint8_t *)h->mb + 256;
+                     uint8_t *src_cr = (uint8_t *)h->mb + 256 + block_h * 8;
+                     for (i = 0; i < block_h; i++) {
+                         memcpy(dest_cb + i * uvlinesize, src_cb + i * 8, 8);
+                         memcpy(dest_cr + i * uvlinesize, src_cr + i * 8, 8);
+                     }
+                 }
+             }
+         }
+     } else {
+         if (IS_INTRA(mb_type)) {
+             if (h->deblocking_filter)
+                 xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize,
+                                uvlinesize, 1, 0, SIMPLE, PIXEL_SHIFT);
+             if (SIMPLE || !CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
++                if (CHROMA) {
+                 h->hpc.pred8x8[h->chroma_pred_mode](dest_cb, uvlinesize);
+                 h->hpc.pred8x8[h->chroma_pred_mode](dest_cr, uvlinesize);
++                }
+             }
+             hl_decode_mb_predict_luma(h, mb_type, is_h264, SIMPLE,
+                                       transform_bypass, PIXEL_SHIFT,
+                                       block_offset, linesize, dest_y, 0);
+             if (h->deblocking_filter)
+                 xchg_mb_border(h, dest_y, dest_cb, dest_cr, linesize,
+                                uvlinesize, 0, 0, SIMPLE, PIXEL_SHIFT);
+         } else if (is_h264) {
+             if (chroma422) {
+                 FUNC(hl_motion_422)(h, dest_y, dest_cb, dest_cr,
+                               s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,
+                               s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,
+                               h->h264dsp.weight_h264_pixels_tab,
+                               h->h264dsp.biweight_h264_pixels_tab);
+             } else {
+                 FUNC(hl_motion_420)(h, dest_y, dest_cb, dest_cr,
+                               s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,
+                               s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,
+                               h->h264dsp.weight_h264_pixels_tab,
+                               h->h264dsp.biweight_h264_pixels_tab);
+             }
+         }
+         hl_decode_mb_idct_luma(h, mb_type, is_h264, SIMPLE, transform_bypass,
+                                PIXEL_SHIFT, block_offset, linesize, dest_y, 0);
+         if ((SIMPLE || !CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) &&
+             (h->cbp & 0x30)) {
+             uint8_t *dest[2] = { dest_cb, dest_cr };
+             if (transform_bypass) {
+                 if (IS_INTRA(mb_type) && h->sps.profile_idc == 244 &&
+                     (h->chroma_pred_mode == VERT_PRED8x8 ||
+                      h->chroma_pred_mode == HOR_PRED8x8)) {
+                     h->hpc.pred8x8_add[h->chroma_pred_mode](dest[0],
+                                                             block_offset + 16,
+                                                             h->mb + (16 * 16 * 1 << PIXEL_SHIFT),
+                                                             uvlinesize);
+                     h->hpc.pred8x8_add[h->chroma_pred_mode](dest[1],
+                                                             block_offset + 32,
+                                                             h->mb + (16 * 16 * 2 << PIXEL_SHIFT),
+                                                             uvlinesize);
+                 } else {
+                     idct_add = s->dsp.add_pixels4;
+                     for (j = 1; j < 3; j++) {
+                         for (i = j * 16; i < j * 16 + 4; i++)
+                             if (h->non_zero_count_cache[scan8[i]] ||
+                                 dctcoef_get(h->mb, PIXEL_SHIFT, i * 16))
+                                 idct_add(dest[j - 1] + block_offset[i],
+                                          h->mb + (i * 16 << PIXEL_SHIFT),
+                                          uvlinesize);
+                         if (chroma422) {
+                             for (i = j * 16 + 4; i < j * 16 + 8; i++)
+                                 if (h->non_zero_count_cache[scan8[i + 4]] ||
+                                     dctcoef_get(h->mb, PIXEL_SHIFT, i * 16))
+                                     idct_add(dest[j - 1] + block_offset[i + 4],
+                                              h->mb + (i * 16 << PIXEL_SHIFT),
+                                              uvlinesize);
+                         }
+                     }
+                 }
+             } else {
+                 if (is_h264) {
+                     int qp[2];
+                     if (chroma422) {
+                         qp[0] = h->chroma_qp[0] + 3;
+                         qp[1] = h->chroma_qp[1] + 3;
+                     } else {
+                         qp[0] = h->chroma_qp[0];
+                         qp[1] = h->chroma_qp[1];
+                     }
+                     if (h->non_zero_count_cache[scan8[CHROMA_DC_BLOCK_INDEX + 0]])
+                         h->h264dsp.h264_chroma_dc_dequant_idct(h->mb + (16 * 16 * 1 << PIXEL_SHIFT),
+                                                                h->dequant4_coeff[IS_INTRA(mb_type) ? 1 : 4][qp[0]][0]);
+                     if (h->non_zero_count_cache[scan8[CHROMA_DC_BLOCK_INDEX + 1]])
+                         h->h264dsp.h264_chroma_dc_dequant_idct(h->mb + (16 * 16 * 2 << PIXEL_SHIFT),
+                                                                h->dequant4_coeff[IS_INTRA(mb_type) ? 2 : 5][qp[1]][0]);
+                     h->h264dsp.h264_idct_add8(dest, block_offset,
+                                               h->mb, uvlinesize,
+                                               h->non_zero_count_cache);
+                 } else if (CONFIG_SVQ3_DECODER) {
+                     h->h264dsp.h264_chroma_dc_dequant_idct(h->mb + 16 * 16 * 1,
+                                                            h->dequant4_coeff[IS_INTRA(mb_type) ? 1 : 4][h->chroma_qp[0]][0]);
+                     h->h264dsp.h264_chroma_dc_dequant_idct(h->mb + 16 * 16 * 2,
+                                                            h->dequant4_coeff[IS_INTRA(mb_type) ? 2 : 5][h->chroma_qp[1]][0]);
+                     for (j = 1; j < 3; j++) {
+                         for (i = j * 16; i < j * 16 + 4; i++)
+                             if (h->non_zero_count_cache[scan8[i]] || h->mb[i * 16]) {
+                                 uint8_t *const ptr = dest[j - 1] + block_offset[i];
+                                 ff_svq3_add_idct_c(ptr, h->mb + i * 16,
+                                                    uvlinesize,
+                                                    ff_h264_chroma_qp[0][s->qscale + 12] - 12, 2);
+                             }
+                     }
+                 }
+             }
+         }
+     }
+     if (h->cbp || IS_INTRA(mb_type)) {
+         s->dsp.clear_blocks(h->mb);
+         s->dsp.clear_blocks(h->mb + (24 * 16 << PIXEL_SHIFT));
+     }
+ }
+ #if !SIMPLE || BITS == 8
+ #undef  CHROMA_IDC
+ #define CHROMA_IDC 3
+ #include "h264_mc_template.c"
+ static av_noinline void FUNC(hl_decode_mb_444)(H264Context *h)
+ {
+     MpegEncContext *const s = &h->s;
+     const int mb_x    = s->mb_x;
+     const int mb_y    = s->mb_y;
+     const int mb_xy   = h->mb_xy;
+     const int mb_type = s->current_picture.f.mb_type[mb_xy];
+     uint8_t *dest[3];
+     int linesize;
+     int i, j, p;
+     int *block_offset = &h->block_offset[0];
+     const int transform_bypass = !SIMPLE && (s->qscale == 0 && h->sps.transform_bypass);
+     const int plane_count      = (SIMPLE || !CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) ? 3 : 1;
+     for (p = 0; p < plane_count; p++) {
+         dest[p] = s->current_picture.f.data[p] +
+                   ((mb_x << PIXEL_SHIFT) + mb_y * s->linesize) * 16;
+         s->dsp.prefetch(dest[p] + (s->mb_x & 3) * 4 * s->linesize + (64 << PIXEL_SHIFT),
+                         s->linesize, 4);
+     }
+     h->list_counts[mb_xy] = h->list_count;
+     if (!SIMPLE && MB_FIELD) {
+         linesize     = h->mb_linesize = h->mb_uvlinesize = s->linesize * 2;
+         block_offset = &h->block_offset[48];
+         if (mb_y & 1) // FIXME move out of this function?
+             for (p = 0; p < 3; p++)
+                 dest[p] -= s->linesize * 15;
+         if (FRAME_MBAFF) {
+             int list;
+             for (list = 0; list < h->list_count; list++) {
+                 if (!USES_LIST(mb_type, list))
+                     continue;
+                 if (IS_16X16(mb_type)) {
+                     int8_t *ref = &h->ref_cache[list][scan8[0]];
+                     fill_rectangle(ref, 4, 4, 8, (16 + *ref) ^ (s->mb_y & 1), 1);
+                 } else {
+                     for (i = 0; i < 16; i += 4) {
+                         int ref = h->ref_cache[list][scan8[i]];
+                         if (ref >= 0)
+                             fill_rectangle(&h->ref_cache[list][scan8[i]], 2, 2,
+                                            8, (16 + ref) ^ (s->mb_y & 1), 1);
+                     }
+                 }
+             }
+         }
+     } else {
+         linesize = h->mb_linesize = h->mb_uvlinesize = s->linesize;
+     }
+     if (!SIMPLE && IS_INTRA_PCM(mb_type)) {
+         if (PIXEL_SHIFT) {
+             const int bit_depth = h->sps.bit_depth_luma;
+             GetBitContext gb;
+             init_get_bits(&gb, (uint8_t *)h->mb, 768 * bit_depth);
+             for (p = 0; p < plane_count; p++)
+                 for (i = 0; i < 16; i++) {
+                     uint16_t *tmp = (uint16_t *)(dest[p] + i * linesize);
+                     for (j = 0; j < 16; j++)
+                         tmp[j] = get_bits(&gb, bit_depth);
+                 }
+         } else {
+             for (p = 0; p < plane_count; p++)
+                 for (i = 0; i < 16; i++)
+                     memcpy(dest[p] + i * linesize,
+                            (uint8_t *)h->mb + p * 256 + i * 16, 16);
+         }
+     } else {
+         if (IS_INTRA(mb_type)) {
+             if (h->deblocking_filter)
+                 xchg_mb_border(h, dest[0], dest[1], dest[2], linesize,
+                                linesize, 1, 1, SIMPLE, PIXEL_SHIFT);
+             for (p = 0; p < plane_count; p++)
+                 hl_decode_mb_predict_luma(h, mb_type, 1, SIMPLE,
+                                           transform_bypass, PIXEL_SHIFT,
+                                           block_offset, linesize, dest[p], p);
+             if (h->deblocking_filter)
+                 xchg_mb_border(h, dest[0], dest[1], dest[2], linesize,
+                                linesize, 0, 1, SIMPLE, PIXEL_SHIFT);
+         } else {
+             FUNC(hl_motion_444)(h, dest[0], dest[1], dest[2],
+                       s->me.qpel_put, s->dsp.put_h264_chroma_pixels_tab,
+                       s->me.qpel_avg, s->dsp.avg_h264_chroma_pixels_tab,
+                       h->h264dsp.weight_h264_pixels_tab,
+                       h->h264dsp.biweight_h264_pixels_tab);
+         }
+         for (p = 0; p < plane_count; p++)
+             hl_decode_mb_idct_luma(h, mb_type, 1, SIMPLE, transform_bypass,
+                                    PIXEL_SHIFT, block_offset, linesize,
+                                    dest[p], p);
+     }
+     if (h->cbp || IS_INTRA(mb_type)) {
+         s->dsp.clear_blocks(h->mb);
+         s->dsp.clear_blocks(h->mb + (24 * 16 << PIXEL_SHIFT));
+     }
+ }
+ #endif
index 0000000,a3af39b..43a3ecf
mode 000000,100644..100644
--- /dev/null
@@@ -1,0 -1,160 +1,160 @@@
 - * This file is part of Libav.
+ /*
+  * H.26L/H.264/AVC/JVT/14496-10/... decoder
+  * Copyright (c) 2003 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
++ * License along with FFmpeg; if not, write to the Free Software
+  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+  */
+ #undef MCFUNC
+ #if   CHROMA_IDC == 1
+ #   define MCFUNC(n) FUNC(n ## _420)
+ #elif CHROMA_IDC == 2
+ #   define MCFUNC(n) FUNC(n ## _422)
+ #elif CHROMA_IDC == 3
+ #   define MCFUNC(n) FUNC(n ## _444)
+ #endif
+ #undef  mc_part
+ #define mc_part MCFUNC(mc_part)
+ static void mc_part(H264Context *h, int n, int square,
+                     int height, int delta,
+                     uint8_t *dest_y, uint8_t *dest_cb,
+                     uint8_t *dest_cr,
+                     int x_offset, int y_offset,
+                     qpel_mc_func *qpix_put,
+                     h264_chroma_mc_func chroma_put,
+                     qpel_mc_func *qpix_avg,
+                     h264_chroma_mc_func chroma_avg,
+                     h264_weight_func *weight_op,
+                     h264_biweight_func *weight_avg,
+                     int list0, int list1)
+ {
+     if ((h->use_weight == 2 && list0 && list1 &&
+          (h->implicit_weight[h->ref_cache[0][scan8[n]]][h->ref_cache[1][scan8[n]]][h->s.mb_y & 1] != 32)) ||
+         h->use_weight == 1)
+         mc_part_weighted(h, n, square, height, delta, dest_y, dest_cb, dest_cr,
+                          x_offset, y_offset, qpix_put, chroma_put,
+                          weight_op[0], weight_op[1], weight_avg[0],
+                          weight_avg[1], list0, list1, PIXEL_SHIFT, CHROMA_IDC);
+     else
+         mc_part_std(h, n, square, height, delta, dest_y, dest_cb, dest_cr,
+                     x_offset, y_offset, qpix_put, chroma_put, qpix_avg,
+                     chroma_avg, list0, list1, PIXEL_SHIFT, CHROMA_IDC);
+ }
+ static void MCFUNC(hl_motion)(H264Context *h, uint8_t *dest_y,
+                               uint8_t *dest_cb, uint8_t *dest_cr,
+                               qpel_mc_func(*qpix_put)[16],
+                               h264_chroma_mc_func(*chroma_put),
+                               qpel_mc_func(*qpix_avg)[16],
+                               h264_chroma_mc_func(*chroma_avg),
+                               h264_weight_func *weight_op,
+                               h264_biweight_func *weight_avg)
+ {
+     MpegEncContext *const s = &h->s;
+     const int mb_xy   = h->mb_xy;
+     const int mb_type = s->current_picture.f.mb_type[mb_xy];
+     assert(IS_INTER(mb_type));
+     if (HAVE_THREADS && (s->avctx->active_thread_type & FF_THREAD_FRAME))
+         await_references(h);
+     prefetch_motion(h, 0, PIXEL_SHIFT, CHROMA_IDC);
+     if (IS_16X16(mb_type)) {
+         mc_part(h, 0, 1, 16, 0, dest_y, dest_cb, dest_cr, 0, 0,
+                 qpix_put[0], chroma_put[0], qpix_avg[0], chroma_avg[0],
+                 weight_op, weight_avg,
+                 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
+     } else if (IS_16X8(mb_type)) {
+         mc_part(h, 0, 0, 8, 8 << PIXEL_SHIFT, dest_y, dest_cb, dest_cr, 0, 0,
+                 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
+                 weight_op, weight_avg,
+                 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
+         mc_part(h, 8, 0, 8, 8 << PIXEL_SHIFT, dest_y, dest_cb, dest_cr, 0, 4,
+                 qpix_put[1], chroma_put[0], qpix_avg[1], chroma_avg[0],
+                 weight_op, weight_avg,
+                 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));
+     } else if (IS_8X16(mb_type)) {
+         mc_part(h, 0, 0, 16, 8 * h->mb_linesize, dest_y, dest_cb, dest_cr, 0, 0,
+                 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
+                 &weight_op[1], &weight_avg[1],
+                 IS_DIR(mb_type, 0, 0), IS_DIR(mb_type, 0, 1));
+         mc_part(h, 4, 0, 16, 8 * h->mb_linesize, dest_y, dest_cb, dest_cr, 4, 0,
+                 qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
+                 &weight_op[1], &weight_avg[1],
+                 IS_DIR(mb_type, 1, 0), IS_DIR(mb_type, 1, 1));
+     } else {
+         int i;
+         assert(IS_8X8(mb_type));
+         for (i = 0; i < 4; i++) {
+             const int sub_mb_type = h->sub_mb_type[i];
+             const int n  = 4 * i;
+             int x_offset = (i & 1) << 2;
+             int y_offset = (i & 2) << 1;
+             if (IS_SUB_8X8(sub_mb_type)) {
+                 mc_part(h, n, 1, 8, 0, dest_y, dest_cb, dest_cr,
+                         x_offset, y_offset,
+                         qpix_put[1], chroma_put[1], qpix_avg[1], chroma_avg[1],
+                         &weight_op[1], &weight_avg[1],
+                         IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
+             } else if (IS_SUB_8X4(sub_mb_type)) {
+                 mc_part(h, n, 0, 4, 4 << PIXEL_SHIFT, dest_y, dest_cb, dest_cr,
+                         x_offset, y_offset,
+                         qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
+                         &weight_op[1], &weight_avg[1],
+                         IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
+                 mc_part(h, n + 2, 0, 4, 4 << PIXEL_SHIFT,
+                         dest_y, dest_cb, dest_cr, x_offset, y_offset + 2,
+                         qpix_put[2], chroma_put[1], qpix_avg[2], chroma_avg[1],
+                         &weight_op[1], &weight_avg[1],
+                         IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
+             } else if (IS_SUB_4X8(sub_mb_type)) {
+                 mc_part(h, n, 0, 8, 4 * h->mb_linesize,
+                         dest_y, dest_cb, dest_cr, x_offset, y_offset,
+                         qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
+                         &weight_op[2], &weight_avg[2],
+                         IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
+                 mc_part(h, n + 1, 0, 8, 4 * h->mb_linesize,
+                         dest_y, dest_cb, dest_cr, x_offset + 2, y_offset,
+                         qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
+                         &weight_op[2], &weight_avg[2],
+                         IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
+             } else {
+                 int j;
+                 assert(IS_SUB_4X4(sub_mb_type));
+                 for (j = 0; j < 4; j++) {
+                     int sub_x_offset = x_offset + 2 * (j & 1);
+                     int sub_y_offset = y_offset + (j & 2);
+                     mc_part(h, n + j, 1, 4, 0,
+                             dest_y, dest_cb, dest_cr, sub_x_offset, sub_y_offset,
+                             qpix_put[2], chroma_put[2], qpix_avg[2], chroma_avg[2],
+                             &weight_op[2], &weight_avg[2],
+                             IS_DIR(sub_mb_type, 0, 0), IS_DIR(sub_mb_type, 0, 1));
+                 }
+             }
+         }
+     }
+     prefetch_motion(h, 1, PIXEL_SHIFT, CHROMA_IDC);
+ }
Simple merge
Simple merge
@@@ -103,15 -103,8 +103,15 @@@ cglobal pred16x16_horizontal, 2,
  %else
      punpcklbw m0, m0
      punpcklbw m1, m1
- %ifidn %1, mmxext
 -    SPLATW    m0, m0, 3
 -    SPLATW    m1, m1, 3
++%if cpuflag(mmx2)
 +    pshufw    m0, m0, 0xff
 +    pshufw    m1, m1, 0xff
 +%else
 +    punpckhwd m0, m0
 +    punpckhwd m1, m1
 +    punpckhdq m0, m0
 +    punpckhdq m1, m1
 +%endif
      mova [r0+r1*0+8], m0
      mova [r0+r1*1+8], m1
  %endif
@@@ -158,20 -153,10 +160,20 @@@ cglobal pred16x16_dc, 2,
      add       r5d, r6d
      lea       r2d, [r2+r5+16]
      shr       r2d, 5
- %ifidn %1, mmxext
+ %if cpuflag(ssse3)
+     pxor       m1, m1
 +    movd       m0, r2d
-     punpcklbw  m0, m0
-     pshufw     m0, m0, 0
- %elifidn %1, sse2
++    pshufb     m0, m1
++%elif cpuflag(sse2)
 +    movd       m0, r2d
 +    punpcklbw  m0, m0
 +    pshuflw    m0, m0, 0
 +    punpcklqdq m0, m0
- %elifidn %1, ssse3
-     pxor       m1, m1
++%elif cpuflag(mmx2)
 +    movd       m0, r2d
-     pshufb     m0, m1
++    punpcklbw  m0, m0
++    pshufw     m0, m0, 0
  %endif
 -    SPLATB_REG m0, r2d, m1
  
  %if mmsize==8
      mov       r3d, 8
@@@ -223,12 -210,7 +227,12 @@@ cglobal pred16x16_tm_vp8, 2,
      movzx     r2d, byte [r0+r1-1]
      sub       r2d, r3d
      movd      mm4, r2d
- %ifidn %1, mmx
 -    SPLATW    mm4, mm4, 0
++%if cpuflag(mmx2)
++    pshufw    mm4, mm4, 0
++%else
 +    punpcklwd mm4, mm4
 +    punpckldq mm4, mm4
- %else
-     pshufw    mm4, mm4, 0
 +%endif
      movq      mm5, mm4
      movq      mm6, mm4
      movq      mm7, mm4
@@@ -325,22 -310,18 +332,22 @@@ cglobal pred16x16_plane_%1, 2,9,
      movhlps      m1, m0
  %endif
      paddw        m0, m1
- %ifidn %1, mmx
 -%if cpuflag(mmx2)
 -    PSHUFLW      m1, m0, 0xE
++%if cpuflag(sse2)
++    pshuflw      m1, m0, 0xE
++%elif cpuflag(mmx2)
++    pshufw       m1, m0, 0xE
+ %elif cpuflag(mmx)
      mova         m1, m0
      psrlq        m1, 32
- %elifidn %1, mmx2
-     pshufw       m1, m0, 0xE
- %else ; mmsize == 16
-     pshuflw      m1, m0, 0xE
  %endif
      paddw        m0, m1
- %ifidn %1, mmx
 -%if cpuflag(mmx2)
 -    PSHUFLW      m1, m0, 0x1
++%if cpuflag(sse2)
++    pshuflw      m1, m0, 0x1
++%elif cpuflag(mmx2)
++    pshufw       m1, m0, 0x1
+ %elif cpuflag(mmx)
      mova         m1, m0
      psrlq        m1, 16
- %elifidn %1, mmx2
-     pshufw       m1, m0, 0x1
- %else
-     pshuflw      m1, m0, 0x1
  %endif
      paddw        m0, m1           ; sum of H coefficients
  
  
      movd         m1, r5d
      movd         m3, r3d
- %ifidn %1, mmx
-     punpcklwd    m0, m0
-     punpcklwd    m1, m1
-     punpcklwd    m3, m3
-     punpckldq    m0, m0
-     punpckldq    m1, m1
-     punpckldq    m3, m3
- %elifidn %1, mmx2
-     pshufw       m0, m0, 0x0
-     pshufw       m1, m1, 0x0
-     pshufw       m3, m3, 0x0
- %else
 -    SPLATW       m0, m0, 0        ; H
 -    SPLATW       m1, m1, 0        ; V
 -    SPLATW       m3, m3, 0        ; a
++%if cpuflag(sse2)
 +    pshuflw      m0, m0, 0x0
 +    pshuflw      m1, m1, 0x0
 +    pshuflw      m3, m3, 0x0
 +    punpcklqdq   m0, m0           ; splat H (words)
 +    punpcklqdq   m1, m1           ; splat V (words)
 +    punpcklqdq   m3, m3           ; splat a (words)
++%elif cpuflag(mmx2)
++    pshufw       m0, m0, 0x0
++    pshufw       m1, m1, 0x0
++    pshufw       m3, m3, 0x0
++%elif cpuflag(mmx)
++    punpcklwd    m0, m0
++    punpcklwd    m1, m1
++    punpcklwd    m3, m3
++    punpckldq    m0, m0
++    punpckldq    m1, m1
++    punpckldq    m3, m3
 +%endif
- %ifidn %3, svq3
+ %ifidn %1, svq3
      SWAP          0, 1
  %endif
      mova         m2, m0
@@@ -615,25 -583,21 +625,25 @@@ cglobal pred8x8_plane, 2,9,
  %endif
      paddw        m0, m1
  
- %ifnidn %1, ssse3
- %ifidn %1, mmx
+ %if notcpuflag(ssse3)
 -%if cpuflag(mmx2)
 -    PSHUFLW      m1, m0, 0xE
++%if cpuflag(sse2) ; mmsize == 16
++    pshuflw      m1, m0, 0xE
++%elif cpuflag(mmx2)
++    pshufw       m1, m0, 0xE
+ %elif cpuflag(mmx)
      mova         m1, m0
      psrlq        m1, 32
- %elifidn %1, mmx2
-     pshufw       m1, m0, 0xE
- %else ; mmsize == 16
-     pshuflw      m1, m0, 0xE
  %endif
      paddw        m0, m1
  %endif ; !ssse3
  
- %ifidn %1, mmx
 -%if cpuflag(mmx2)
 -    PSHUFLW      m1, m0, 0x1
++%if cpuflag(sse2)
++    pshuflw      m1, m0, 0x1
++%elif cpuflag(mmx2)
++    pshufw       m1, m0, 0x1
+ %elif cpuflag(mmx)
      mova         m1, m0
      psrlq        m1, 16
- %elifidn %1, mmx2
-     pshufw       m1, m0, 0x1
- %else
-     pshuflw      m1, m0, 0x1
  %endif
      paddw        m0, m1           ; sum of H coefficients
  
  
      movd         m1, r5d
      movd         m3, r3d
- %ifidn %1, mmx
-     punpcklwd    m0, m0
-     punpcklwd    m1, m1
-     punpcklwd    m3, m3
-     punpckldq    m0, m0
-     punpckldq    m1, m1
-     punpckldq    m3, m3
- %elifidn %1, mmx2
-     pshufw       m0, m0, 0x0
-     pshufw       m1, m1, 0x0
-     pshufw       m3, m3, 0x0
- %else
 -    SPLATW       m0, m0, 0        ; H
 -    SPLATW       m1, m1, 0        ; V
 -    SPLATW       m3, m3, 0        ; a
++%if cpuflag(sse2)
 +    pshuflw      m0, m0, 0x0
 +    pshuflw      m1, m1, 0x0
 +    pshuflw      m3, m3, 0x0
 +    punpcklqdq   m0, m0           ; splat H (words)
 +    punpcklqdq   m1, m1           ; splat V (words)
 +    punpcklqdq   m3, m3           ; splat a (words)
++%elif cpuflag(mmx2)
++    pshufw       m0, m0, 0x0
++    pshufw       m1, m1, 0x0
++    pshufw       m3, m3, 0x0
++%elif cpuflag(mmx)
++    punpcklwd    m0, m0
++    punpcklwd    m1, m1
++    punpcklwd    m3, m3
++    punpckldq    m0, m0
++    punpckldq    m1, m1
++    punpckldq    m3, m3
 +%endif
  %if mmsize == 8
      mova         m2, m0
  %endif
@@@ -802,24 -753,8 +815,24 @@@ cglobal pred8x8_horizontal, 2,
      mova      m2, [pb_3]
  %endif
  .loop:
 -    SPLATB_LOAD m0, r0+r1*0-1, m2
 -    SPLATB_LOAD m1, r0+r1*1-1, m2
 +    movd      m0, [r0+r1*0-4]
 +    movd      m1, [r0+r1*1-4]
- %ifidn %1, ssse3
++%if cpuflag(ssse3)
 +    pshufb    m0, m2
 +    pshufb    m1, m2
 +%else
 +    punpcklbw m0, m0
 +    punpcklbw m1, m1
- %ifidn %1, mmxext
++%if cpuflag(mmx2)
 +    pshufw    m0, m0, 0xff
 +    pshufw    m1, m1, 0xff
 +%else
 +    punpckhwd m0, m0
 +    punpckhwd m1, m1
 +    punpckhdq m0, m0
 +    punpckhdq m1, m1
 +%endif
 +%endif
      mova [r0+r1*0], m0
      mova [r0+r1*1], m1
      lea       r0, [r0+r1*2]
@@@ -984,15 -922,8 +1000,15 @@@ cglobal pred8x8_tm_vp8, 2,
      sub       r3d, r4d
      movd      mm2, r2d
      movd      mm4, r3d
- %ifidn %1, mmx
 -    SPLATW    mm2, mm2, 0
 -    SPLATW    mm4, mm4, 0
++%if cpuflag(mmx2)
++    pshufw    mm2, mm2, 0
++    pshufw    mm4, mm4, 0
++%else
 +    punpcklwd mm2, mm2
 +    punpcklwd mm4, mm4
 +    punpckldq mm2, mm2
 +    punpckldq mm4, mm4
- %else
-     pshufw    mm2, mm2, 0
-     pshufw    mm4, mm4, 0
 +%endif
      movq      mm3, mm2
      movq      mm5, mm4
      paddw     mm2, mm0
Simple merge
Simple merge
Simple merge
  #define VALIDATE_INDEX_TS_THRESH 2500
  
  typedef struct {
+     const AVClass *class; ///< Class for private options.
+     int trust_metadata; ///< configure streams according onMetaData
      int wrong_dts; ///< wrong dts due to negative cts
 -    uint8_t *new_extradata[2];
 -    int      new_extradata_size[2];
 +    uint8_t *new_extradata[FLV_STREAM_TYPE_NB];
 +    int      new_extradata_size[FLV_STREAM_TYPE_NB];
      int      last_sample_rate;
      int      last_channels;
      struct {
Simple merge
Simple merge
Simple merge
Simple merge