Merge commit '835f798c7d20bca89eb4f3593846251ad0d84e4b'
authorMichael Niedermayer <michaelni@gmx.at>
Fri, 15 Aug 2014 18:00:34 +0000 (20:00 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Fri, 15 Aug 2014 18:11:56 +0000 (20:11 +0200)
* commit '835f798c7d20bca89eb4f3593846251ad0d84e4b':
  mpegvideo: cosmetics: Lowercase ugly uppercase MPV_ function name prefixes

Conflicts:
libavcodec/h261dec.c
libavcodec/intrax8.c
libavcodec/mjpegenc.c
libavcodec/mpeg12dec.c
libavcodec/mpeg12enc.c
libavcodec/mpeg4videoenc.c
libavcodec/mpegvideo.c
libavcodec/mpegvideo.h
libavcodec/mpegvideo_enc.c
libavcodec/rv10.c
libavcodec/x86/mpegvideoenc.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
31 files changed:
1  2 
libavcodec/alpha/mpegvideo_alpha.c
libavcodec/arm/mpegvideo_arm.c
libavcodec/arm/mpegvideo_arm.h
libavcodec/arm/mpegvideo_armv5te.c
libavcodec/avcodec.h
libavcodec/flvenc.c
libavcodec/h261dec.c
libavcodec/h261enc.c
libavcodec/h263dec.c
libavcodec/h264_slice.c
libavcodec/intrax8.c
libavcodec/mjpegenc.c
libavcodec/mpeg12dec.c
libavcodec/mpeg12enc.c
libavcodec/mpeg4videoenc.c
libavcodec/mpegvideo.c
libavcodec/mpegvideo.h
libavcodec/mpegvideo_enc.c
libavcodec/mpegvideo_motion.c
libavcodec/mpegvideo_xvmc.c
libavcodec/mss2.c
libavcodec/neon/mpegvideo.c
libavcodec/ppc/mpegvideo_altivec.c
libavcodec/rv10.c
libavcodec/rv10enc.c
libavcodec/rv20enc.c
libavcodec/rv34.c
libavcodec/svq1enc.c
libavcodec/vc1dec.c
libavcodec/wmv2enc.c
libavcodec/x86/mpegvideo.c

index 7ba0f2e,0000000..126fe26
mode 100644,000000..100644
--- /dev/null
@@@ -1,110 -1,0 +1,110 @@@
- av_cold void ff_MPV_common_init_axp(MpegEncContext *s)
 +/*
 + * Alpha optimized DSP utils
 + * Copyright (c) 2002 Falk Hueffner <falk@debian.org>
 + *
 + * This file is part of FFmpeg.
 + *
 + * FFmpeg is free software; you can redistribute it and/or
 + * modify it under the terms of the GNU Lesser General Public
 + * License as published by the Free Software Foundation; either
 + * version 2.1 of the License, or (at your option) any later version.
 + *
 + * FFmpeg is distributed in the hope that it will be useful,
 + * but WITHOUT ANY WARRANTY; without even the implied warranty of
 + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 + * Lesser General Public License for more details.
 + *
 + * You should have received a copy of the GNU Lesser General Public
 + * License along with FFmpeg; if not, write to the Free Software
 + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 + */
 +
 +#include "libavutil/attributes.h"
 +#include "libavcodec/mpegvideo.h"
 +#include "asm.h"
 +
 +static void dct_unquantize_h263_axp(int16_t *block, int n_coeffs,
 +                                    uint64_t qscale, uint64_t qadd)
 +{
 +    uint64_t qmul = qscale << 1;
 +    uint64_t correction = WORD_VEC(qmul * 255 >> 8);
 +    int i;
 +
 +    qadd = WORD_VEC(qadd);
 +
 +    for(i = 0; i <= n_coeffs; block += 4, i += 4) {
 +        uint64_t levels, negmask, zeros, add, sub;
 +
 +        levels = ldq(block);
 +        if (levels == 0)
 +            continue;
 +
 +#ifdef __alpha_max__
 +        /* I don't think the speed difference justifies runtime
 +           detection.  */
 +        negmask = maxsw4(levels, -1); /* negative -> ffff (-1) */
 +        negmask = minsw4(negmask, 0); /* positive -> 0000 (0) */
 +#else
 +        negmask = cmpbge(WORD_VEC(0x7fff), levels);
 +        negmask &= (negmask >> 1) | (1 << 7);
 +        negmask = zap(-1, negmask);
 +#endif
 +
 +        zeros = cmpbge(0, levels);
 +        zeros &= zeros >> 1;
 +        /* zeros |= zeros << 1 is not needed since qadd <= 255, so
 +           zapping the lower byte suffices.  */
 +
 +        levels *= qmul;
 +        levels -= correction & (negmask << 16);
 +
 +        add = qadd & ~negmask;
 +        sub = qadd &  negmask;
 +        /* Set qadd to 0 for levels == 0.  */
 +        add = zap(add, zeros);
 +        levels += add;
 +        levels -= sub;
 +
 +        stq(levels, block);
 +    }
 +}
 +
 +static void dct_unquantize_h263_intra_axp(MpegEncContext *s, int16_t *block,
 +                                    int n, int qscale)
 +{
 +    int n_coeffs;
 +    uint64_t qadd;
 +    int16_t block0 = block[0];
 +
 +    if (!s->h263_aic) {
 +        if (n < 4)
 +            block0 *= s->y_dc_scale;
 +        else
 +            block0 *= s->c_dc_scale;
 +        qadd = (qscale - 1) | 1;
 +    } else {
 +        qadd = 0;
 +    }
 +
 +    if(s->ac_pred)
 +        n_coeffs = 63;
 +    else
 +        n_coeffs = s->inter_scantable.raster_end[s->block_last_index[n]];
 +
 +    dct_unquantize_h263_axp(block, n_coeffs, qscale, qadd);
 +
 +    block[0] = block0;
 +}
 +
 +static void dct_unquantize_h263_inter_axp(MpegEncContext *s, int16_t *block,
 +                                    int n, int qscale)
 +{
 +    int n_coeffs = s->inter_scantable.raster_end[s->block_last_index[n]];
 +    dct_unquantize_h263_axp(block, n_coeffs, qscale, (qscale - 1) | 1);
 +}
 +
++av_cold void ff_mpv_common_init_axp(MpegEncContext *s)
 +{
 +    s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_axp;
 +    s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_axp;
 +}
Simple merge
Simple merge
Simple merge
@@@ -3304,17 -2982,6 +3304,17 @@@ typedef struct AVHWAccel 
       */
      int frame_priv_data_size;
  
-      * XvMC uses it to replace the ff_MPV_decode_mb().
 +    /**
 +     * Called for every Macroblock in a slice.
 +     *
++     * XvMC uses it to replace the ff_mpv_decode_mb().
 +     * Instead of decoding to raw picture, MB parameters are
 +     * stored in an array provided by the video driver.
 +     *
 +     * @param s the mpeg context
 +     */
 +    void (*decode_mb)(struct MpegEncContext *s);
 +
      /**
       * Initialize the hwaccel private data.
       *
Simple merge
@@@ -609,10 -600,11 +609,10 @@@ retry
          s->parse_context = pc;
      }
  
 -    if (!s->context_initialized)
 +    if (!s->context_initialized) {
-         if ((ret = ff_MPV_common_init(s)) < 0)
+         if ((ret = ff_mpv_common_init(s)) < 0)
              return ret;
  
 -    if (!s->context_initialized) {
          ret = ff_set_dimensions(avctx, s->width, s->height);
          if (ret < 0)
              return ret;
              break;
          h261_decode_gob(h);
      }
-     ff_MPV_frame_end(s);
+     ff_mpv_frame_end(s);
  
 -    assert(s->current_picture.f->pict_type == s->current_picture_ptr->f->pict_type);
 -    assert(s->current_picture.f->pict_type == s->pict_type);
 +    av_assert0(s->current_picture.f->pict_type == s->current_picture_ptr->f->pict_type);
 +    av_assert0(s->current_picture.f->pict_type == s->pict_type);
  
      if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
          return ret;
Simple merge
@@@ -115,15 -111,11 +115,15 @@@ av_cold int ff_h263_decode_init(AVCodec
      }
      s->codec_id    = avctx->codec->id;
  
 +    if (avctx->stream_codec_tag == AV_RL32("l263") && avctx->extradata_size == 56 && avctx->extradata[0] == 1)
 +        s->ehc_mode = 1;
 +
      /* for h263, we allocate the images after having read the header */
      if (avctx->codec->id != AV_CODEC_ID_H263 &&
 +        avctx->codec->id != AV_CODEC_ID_H263P &&
          avctx->codec->id != AV_CODEC_ID_MPEG4) {
          ff_mpv_idct_init(s);
-         if ((ret = ff_MPV_common_init(s)) < 0)
+         if ((ret = ff_mpv_common_init(s)) < 0)
              return ret;
      }
  
@@@ -643,11 -613,8 +643,11 @@@ frame_end
              return ret;
      }
  
-     ff_MPV_frame_end(s);
+     ff_mpv_frame_end(s);
  
 +    if (CONFIG_MPEG4_DECODER && avctx->codec_id == AV_CODEC_ID_MPEG4)
 +        ff_mpeg4_frame_end(avctx, buf, buf_size);
 +
      if (!s->divx_packed && avctx->hwaccel)
          ff_thread_finish_setup(avctx);
  
@@@ -542,19 -510,14 +542,19 @@@ int ff_h264_update_thread_context(AVCod
          }
          context_reinitialized = 1;
  
 -        /* update linesize on resize. The decoder doesn't
 -         * necessarily call h264_frame_start in the new thread */
 -        h->linesize   = h1->linesize;
 -        h->uvlinesize = h1->uvlinesize;
 -
 -        /* copy block_offset since frame_start may not be called */
 -        memcpy(h->block_offset, h1->block_offset, sizeof(h->block_offset));
 +#if 0
 +        h264_set_parameter_from_sps(h);
 +        //Note we set context_reinitialized which will cause h264_set_parameter_from_sps to be reexecuted
 +        h->cur_chroma_format_idc = h1->cur_chroma_format_idc;
 +#endif
      }
-      * necessarily call ff_MPV_frame_start in the new thread */
 +    /* update linesize on resize for h264. The h264 decoder doesn't
++     * necessarily call ff_mpv_frame_start in the new thread */
 +    h->linesize   = h1->linesize;
 +    h->uvlinesize = h1->uvlinesize;
 +
 +    /* copy block_offset since frame_start may not be called */
 +    memcpy(h->block_offset, h1->block_offset, sizeof(h->block_offset));
  
      if (!inited) {
          for (i = 0; i < MAX_SPS_COUNT; i++)
@@@ -781,9 -717,23 +781,9 @@@ static int h264_frame_start(H264Contex
          h->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7) << pixel_shift) + 8 * h->uvlinesize * ((scan8[i] - scan8[0]) >> 3);
      }
  
 -    /* can't be in alloc_tables because linesize isn't known there.
 -     * FIXME: redo bipred weight to not require extra buffer? */
 -    for (i = 0; i < h->slice_context_count; i++)
 -        if (h->thread_context[i]) {
 -            ret = alloc_scratch_buffers(h->thread_context[i], h->linesize);
 -            if (ret < 0)
 -                return ret;
 -        }
 -
 -    /* Some macroblocks can be accessed before they're available in case
 -     * of lost slices, MBAFF or threading. */
 -    memset(h->slice_table, -1,
 -           (h->mb_height * h->mb_stride - 1) * sizeof(*h->slice_table));
 -
      /* We mark the current picture as non-reference after allocating it, so
       * that if we break out due to an error it can be released automatically
-      * in the next ff_MPV_frame_start().
+      * in the next ff_mpv_frame_start().
       */
      h->cur_pic_ptr->reference = 0;
  
@@@ -719,10 -718,9 +719,10 @@@ av_cold void ff_intrax8_common_end(Intr
  /**
   * Decode single IntraX8 frame.
   * The parent codec must fill s->loopfilter and s->gb (bitstream).
-  * The parent codec must call MPV_frame_start(), ff_er_frame_start() before calling this function.
-  * The parent codec must call ff_er_frame_end(), MPV_frame_end() after calling this function.
-  * This function does not use MPV_decode_mb().
+  * The parent codec must call ff_mpv_frame_start(), ff_er_frame_start() before calling this function.
+  * The parent codec must call ff_er_frame_end(), ff_mpv_frame_end() after calling this function.
+  * This function does not use ff_mpv_decode_mb().
 + * lowres decoding is theoretically impossible.
   * @param w pointer to IntraX8Context
   * @param dquant doubled quantizer, it would be odd in case of VC-1 halfpq==1.
   * @param quant_offset offset away from zero
@@@ -174,72 -153,15 +174,72 @@@ void ff_mjpeg_encode_mb(MpegEncContext 
      s->i_tex_bits += get_bits_diff(s);
  }
  
-     ret = ff_MPV_encode_picture(avctx, pkt, pic, got_packet);
 +// maximum over s->mjpeg_vsample[i]
 +#define V_MAX 2
 +static int amv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
 +                              const AVFrame *pic_arg, int *got_packet)
 +
 +{
 +    MpegEncContext *s = avctx->priv_data;
 +    AVFrame *pic;
 +    int i, ret;
 +    int chroma_h_shift, chroma_v_shift;
 +
 +    av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
 +
 +    //CODEC_FLAG_EMU_EDGE have to be cleared
 +    if(s->avctx->flags & CODEC_FLAG_EMU_EDGE)
 +        return AVERROR(EINVAL);
 +
 +    if ((avctx->height & 15) && avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) {
 +        av_log(avctx, AV_LOG_ERROR,
 +               "Heights which are not a multiple of 16 might fail with some decoders, "
 +               "use vstrict=-1 / -strict -1 to use %d anyway.\n", avctx->height);
 +        av_log(avctx, AV_LOG_WARNING, "If you have a device that plays AMV videos, please test if videos "
 +               "with such heights work with it and report your findings to ffmpeg-devel@ffmpeg.org\n");
 +        return AVERROR_EXPERIMENTAL;
 +    }
 +
 +    pic = av_frame_clone(pic_arg);
 +    if (!pic)
 +        return AVERROR(ENOMEM);
 +    //picture should be flipped upside-down
 +    for(i=0; i < 3; i++) {
 +        int vsample = i ? 2 >> chroma_v_shift : 2;
 +        pic->data[i] += pic->linesize[i] * (vsample * s->height / V_MAX - 1);
 +        pic->linesize[i] *= -1;
 +    }
++    ret = ff_mpv_encode_picture(avctx, pkt, pic, got_packet);
 +    av_frame_free(&pic);
 +    return ret;
 +}
 +
 +#if CONFIG_MJPEG_ENCODER
  AVCodec ff_mjpeg_encoder = {
      .name           = "mjpeg",
      .long_name      = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
      .type           = AVMEDIA_TYPE_VIDEO,
      .id             = AV_CODEC_ID_MJPEG,
      .priv_data_size = sizeof(MpegEncContext),
-     .init           = ff_MPV_encode_init,
-     .encode2        = ff_MPV_encode_picture,
-     .close          = ff_MPV_encode_end,
+     .init           = ff_mpv_encode_init,
+     .encode2        = ff_mpv_encode_picture,
+     .close          = ff_mpv_encode_end,
 +    .capabilities   = CODEC_CAP_SLICE_THREADS | CODEC_CAP_FRAME_THREADS | CODEC_CAP_INTRA_ONLY,
 +    .pix_fmts       = (const enum AVPixelFormat[]){
 +        AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_NONE
 +    },
 +};
 +#endif
 +#if CONFIG_AMV_ENCODER
 +AVCodec ff_amv_encoder = {
 +    .name           = "amv",
 +    .long_name      = NULL_IF_CONFIG_SMALL("AMV Video"),
 +    .type           = AVMEDIA_TYPE_VIDEO,
 +    .id             = AV_CODEC_ID_AMV,
 +    .priv_data_size = sizeof(MpegEncContext),
-     .init           = ff_MPV_encode_init,
++    .init           = ff_mpv_encode_init,
 +    .encode2        = amv_encode_picture,
-     .close          = ff_MPV_encode_end,
++    .close          = ff_mpv_encode_end,
      .pix_fmts       = (const enum AVPixelFormat[]){
          AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_NONE
      },
@@@ -1268,9 -1221,8 +1268,9 @@@ static int mpeg_decode_postinit(AVCodec
          if (s1->mpeg_enc_ctx_allocated) {
              ParseContext pc = s->parse_context;
              s->parse_context.buffer = 0;
-             ff_MPV_common_end(s);
+             ff_mpv_common_end(s);
              s->parse_context = pc;
 +            s1->mpeg_enc_ctx_allocated = 0;
          }
  
          if ((s->width == 0) || (s->height == 0))
@@@ -1854,17 -1837,17 +1854,17 @@@ static int mpeg_decode_slice(MpegEncCon
              }
          }
  
 -        s->dest[0] += 16;
 -        s->dest[1] += 16 >> s->chroma_x_shift;
 -        s->dest[2] += 16 >> s->chroma_x_shift;
 +        s->dest[0] += 16 >> lowres;
 +        s->dest[1] +=(16 >> lowres) >> s->chroma_x_shift;
 +        s->dest[2] +=(16 >> lowres) >> s->chroma_x_shift;
  
-         ff_MPV_decode_mb(s, s->block);
+         ff_mpv_decode_mb(s, s->block);
  
          if (++s->mb_x >= s->mb_width) {
 -            const int mb_size = 16;
 +            const int mb_size = 16 >> s->avctx->lowres;
  
              ff_mpeg_draw_horiz_band(s, mb_size * (s->mb_y >> field_pic), mb_size);
-             ff_MPV_report_decode_progress(s);
+             ff_mpv_report_decode_progress(s);
  
              s->mb_x  = 0;
              s->mb_y += 1 << field_pic;
@@@ -2175,8 -2133,7 +2175,8 @@@ static int vcr2_init_sequence(AVCodecCo
      /* start new MPEG-1 context decoding */
      s->out_format = FMT_MPEG1;
      if (s1->mpeg_enc_ctx_allocated) {
-         ff_MPV_common_end(s);
+         ff_mpv_common_end(s);
 +        s1->mpeg_enc_ctx_allocated = 0;
      }
      s->width            = avctx->coded_width;
      s->height           = avctx->coded_height;
      s->low_delay        = 1;
  
      avctx->pix_fmt = mpeg_get_pixelformat(avctx);
 -
 -#if FF_API_XVMC
 -    if ((avctx->pix_fmt == AV_PIX_FMT_XVMC_MPEG2_IDCT || avctx->hwaccel) &&
 -        avctx->idct_algo == FF_IDCT_AUTO)
 -#else
 -    if (avctx->hwaccel && avctx->idct_algo == FF_IDCT_AUTO)
 -#endif /* FF_API_XVMC */
 -        avctx->idct_algo = FF_IDCT_SIMPLE;
 +    setup_hwaccel_for_pixfmt(avctx);
  
      ff_mpv_idct_init(s);
-     if (ff_MPV_common_init(s) < 0)
+     if (ff_mpv_common_init(s) < 0)
          return -1;
      s1->mpeg_enc_ctx_allocated = 1;
  
@@@ -144,10 -130,7 +144,10 @@@ static av_cold int encode_init(AVCodecC
  {
      MpegEncContext *s = avctx->priv_data;
  
-     if (ff_MPV_encode_init(avctx) < 0)
 +    if (avctx->codec_id == AV_CODEC_ID_MPEG1VIDEO && avctx->height > 2800)
 +        avctx->thread_count = 1;
 +
+     if (ff_mpv_encode_init(avctx) < 0)
          return -1;
  
      if (find_frame_rate_index(s) < 0) {
@@@ -1165,9 -1098,9 +1165,9 @@@ AVCodec ff_mpeg2video_encoder = 
      .id                   = AV_CODEC_ID_MPEG2VIDEO,
      .priv_data_size       = sizeof(MpegEncContext),
      .init                 = encode_init,
-     .encode2              = ff_MPV_encode_picture,
-     .close                = ff_MPV_encode_end,
+     .encode2              = ff_mpv_encode_picture,
+     .close                = ff_mpv_encode_end,
 -    .supported_framerates = ff_mpeg12_frame_rate_tab + 1,
 +    .supported_framerates = ff_mpeg2_frame_rate_tab,
      .pix_fmts             = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
                                                             AV_PIX_FMT_YUV422P,
                                                             AV_PIX_FMT_NONE },
@@@ -1295,12 -1287,7 +1295,12 @@@ static av_cold int encode_init(AVCodecC
      int ret;
      static int done = 0;
  
-     if ((ret = ff_MPV_encode_init(avctx)) < 0)
 +    if (avctx->width >= (1<<13) || avctx->height >= (1<<13)) {
 +        av_log(avctx, AV_LOG_ERROR, "dimensions too large for MPEG-4\n");
 +        return AVERROR(EINVAL);
 +    }
 +
+     if ((ret = ff_mpv_encode_init(avctx)) < 0)
          return ret;
  
      if (!done) {
@@@ -359,23 -370,10 +359,23 @@@ static void mpeg_er_decode_mb(void *opa
      s->dest[1] = s->current_picture.f->data[1] + (s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16 >> s->chroma_x_shift);
      s->dest[2] = s->current_picture.f->data[2] + (s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16 >> s->chroma_x_shift);
  
 -    assert(ref == 0);
 +    if (ref)
 +        av_log(s->avctx, AV_LOG_DEBUG, "Interlaced error concealment is not fully implemented\n");
-     ff_MPV_decode_mb(s, s->block);
+     ff_mpv_decode_mb(s, s->block);
  }
  
 +static void gray16(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
 +{
 +    while(h--)
 +        memset(dst + h*linesize, 128, 16);
 +}
 +
 +static void gray8(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
 +{
 +    while(h--)
 +        memset(dst + h*linesize, 128, 8);
 +}
 +
  /* init common dct for both encoder and decoder */
  static av_cold int dct_init(MpegEncContext *s)
  {
      s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
  
      if (HAVE_INTRINSICS_NEON)
-         ff_MPV_common_init_neon(s);
+         ff_mpv_common_init_neon(s);
  
-         ff_MPV_common_init_axp(s);
 +    if (ARCH_ALPHA)
++        ff_mpv_common_init_axp(s);
      if (ARCH_ARM)
-         ff_MPV_common_init_arm(s);
+         ff_mpv_common_init_arm(s);
      if (ARCH_PPC)
-         ff_MPV_common_init_ppc(s);
+         ff_mpv_common_init_ppc(s);
      if (ARCH_X86)
-         ff_MPV_common_init_x86(s);
+         ff_mpv_common_init_x86(s);
  
      return 0;
  }
@@@ -960,24 -914,17 +960,24 @@@ int ff_mpeg_update_thread_context(AVCod
          s->bitstream_buffer      = NULL;
          s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
  
 -        ff_mpv_idct_init(s);
 -        ff_mpv_common_init(s);
 +        if (s1->context_initialized){
 +//             s->picture_range_start  += MAX_PICTURE_COUNT;
 +//             s->picture_range_end    += MAX_PICTURE_COUNT;
 +            ff_mpv_idct_init(s);
-             if((ret = ff_MPV_common_init(s)) < 0){
++            if((ret = ff_mpv_common_init(s)) < 0){
 +                memset(s, 0, sizeof(MpegEncContext));
 +                s->avctx = dst;
 +                return ret;
 +            }
 +        }
      }
  
      if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
          s->context_reinit = 0;
          s->height = s1->height;
          s->width  = s1->width;
-         if ((ret = ff_MPV_common_frame_size_change(s)) < 0)
 -        if ((err = ff_mpv_common_frame_size_change(s)) < 0)
 -            return err;
++        if ((ret = ff_mpv_common_frame_size_change(s)) < 0)
 +            return ret;
      }
  
      s->avctx->coded_height  = s1->avctx->coded_height;
@@@ -1975,8 -1889,18 +1975,8 @@@ int ff_mpv_frame_start(MpegEncContext *
  }
  
  /* called after a frame has been decoded. */
- void ff_MPV_frame_end(MpegEncContext *s)
+ void ff_mpv_frame_end(MpegEncContext *s)
  {
 -#if FF_API_XVMC
 -FF_DISABLE_DEPRECATION_WARNINGS
 -    /* redraw edges for the frame if decoding didn't complete */
 -    // just to make sure that all data is rendered.
 -    if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
 -        ff_xvmc_field_end(s);
 -    } else
 -FF_ENABLE_DEPRECATION_WARNINGS
 -#endif /* FF_API_XVMC */
 -
      emms_c();
  
      if (s->current_picture.reference)
@@@ -2910,8 -2116,8 +2910,8 @@@ void ff_clean_intra_table_entries(MpegE
     s->interlaced_dct : true if interlaced dct used (mpeg2)
   */
  static av_always_inline
- void MPV_decode_mb_internal(MpegEncContext *s, int16_t block[12][64],
+ void mpv_decode_mb_internal(MpegEncContext *s, int16_t block[12][64],
 -                            int is_mpeg12)
 +                            int lowres_flag, int is_mpeg12)
  {
      const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
  
                      }
                  }
  
 -                op_qpix= s->me.qpel_put;
 -                if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
 -                    op_pix = s->hdsp.put_pixels_tab;
 +                if(lowres_flag){
 +                    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->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->hdsp.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->hdsp.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->hdsp.put_pixels_tab;
 +                    }else{
 +                        op_pix = s->hdsp.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);
++                        ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix, op_qpix);
 +                        op_pix = s->hdsp.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);
++                        ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix, op_qpix);
 +                    }
                  }
              }
  
@@@ -3156,15 -2351,14 +3156,16 @@@ skip_idct
      }
  }
  
- void ff_MPV_decode_mb(MpegEncContext *s, int16_t block[12][64]){
+ void ff_mpv_decode_mb(MpegEncContext *s, int16_t block[12][64])
+ {
  #if !CONFIG_SMALL
      if(s->out_format == FMT_MPEG1) {
-         if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
-         else                 MPV_decode_mb_internal(s, block, 0, 1);
 -        mpv_decode_mb_internal(s, block, 1);
++        if(s->avctx->lowres) mpv_decode_mb_internal(s, block, 1, 1);
++        else                 mpv_decode_mb_internal(s, block, 0, 1);
      } else
  #endif
-     if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
-     else                  MPV_decode_mb_internal(s, block, 0, 0);
 -        mpv_decode_mb_internal(s, block, 0);
++    if(s->avctx->lowres) mpv_decode_mb_internal(s, block, 1, 0);
++    else                  mpv_decode_mb_internal(s, block, 0, 0);
  }
  
  void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
@@@ -711,25 -689,33 +711,36 @@@ static const AVClass name ## _class = {
   * and decoding).  The changed fields will not depend upon the prior
   * state of the MpegEncContext.
   */
- void ff_MPV_common_defaults(MpegEncContext *s);
- void ff_MPV_decode_defaults(MpegEncContext *s);
- int ff_MPV_common_init(MpegEncContext *s);
- int ff_MPV_common_frame_size_change(MpegEncContext *s);
- void ff_MPV_common_end(MpegEncContext *s);
- void ff_MPV_decode_mb(MpegEncContext *s, int16_t block[12][64]);
- int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx);
- void ff_MPV_frame_end(MpegEncContext *s);
- int ff_MPV_encode_init(AVCodecContext *avctx);
- int ff_MPV_encode_end(AVCodecContext *avctx);
- int ff_MPV_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
-                           const AVFrame *frame, int *got_packet);
+ void ff_mpv_common_defaults(MpegEncContext *s);
 +void ff_dct_encode_init_x86(MpegEncContext *s);
- void ff_MPV_common_init_x86(MpegEncContext *s);
- void ff_MPV_common_init_axp(MpegEncContext *s);
- void ff_MPV_common_init_arm(MpegEncContext *s);
- void ff_MPV_common_init_neon(MpegEncContext *s);
- void ff_MPV_common_init_ppc(MpegEncContext *s);
++
+ int ff_mpv_common_init(MpegEncContext *s);
+ void ff_mpv_common_init_arm(MpegEncContext *s);
++void ff_mpv_common_init_axp(MpegEncContext *s);
+ void ff_mpv_common_init_neon(MpegEncContext *s);
+ void ff_mpv_common_init_ppc(MpegEncContext *s);
+ void ff_mpv_common_init_x86(MpegEncContext *s);
+ int ff_mpv_common_frame_size_change(MpegEncContext *s);
+ void ff_mpv_common_end(MpegEncContext *s);
+ void ff_mpv_decode_defaults(MpegEncContext *s);
+ void ff_mpv_decode_mb(MpegEncContext *s, int16_t block[12][64]);
+ void ff_mpv_report_decode_progress(MpegEncContext *s);
+ int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx);
+ void ff_mpv_frame_end(MpegEncContext *s);
+ int ff_mpv_lowest_referenced_row(MpegEncContext *s, int dir);
+ int ff_mpv_encode_init(AVCodecContext *avctx);
+ void ff_mpv_encode_init_x86(MpegEncContext *s);
+ int ff_mpv_encode_end(AVCodecContext *avctx);
+ int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
+                           const AVFrame *frame, int *got_packet);
  void ff_clean_intra_table_entries(MpegEncContext *s);
  void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h);
  void ff_mpeg_flush(AVCodecContext *avctx);
@@@ -233,25 -233,8 +233,25 @@@ static void mpv_encode_defaults(MpegEnc
      s->picture_in_gop_number = 0;
  }
  
 +av_cold int ff_dct_encode_init(MpegEncContext *s) {
 +    if (ARCH_X86)
 +        ff_dct_encode_init_x86(s);
 +
 +    if (CONFIG_H263_ENCODER)
 +        ff_h263dsp_init(&s->h263dsp);
 +    if (!s->dct_quantize)
 +        s->dct_quantize = ff_dct_quantize_c;
 +    if (!s->denoise_dct)
 +        s->denoise_dct  = denoise_dct_c;
 +    s->fast_dct_quantize = s->dct_quantize;
 +    if (s->avctx->trellis)
 +        s->dct_quantize  = dct_quantize_trellis_c;
 +
 +    return 0;
 +}
 +
  /* init video encoder */
- av_cold int ff_MPV_encode_init(AVCodecContext *avctx)
+ av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
  {
      MpegEncContext *s = avctx->priv_data;
      int i, ret, format_supported;
  
      /* init */
      ff_mpv_idct_init(s);
-     if (ff_MPV_common_init(s) < 0)
+     if (ff_mpv_common_init(s) < 0)
          return -1;
  
 -    if (ARCH_X86)
 -        ff_mpv_encode_init_x86(s);
 -
      ff_fdctdsp_init(&s->fdsp, avctx);
      ff_me_cmp_init(&s->mecc, avctx);
      ff_mpegvideoencdsp_init(&s->mpvencdsp, avctx);
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -374,21 -370,10 +374,21 @@@ static int rv20_decode_picture_header(R
              new_h = rv->orig_height;
          }
          if (new_w != s->width || new_h != s->height) {
 +            AVRational old_aspect = s->avctx->sample_aspect_ratio;
              av_log(s->avctx, AV_LOG_DEBUG,
                     "attempting to change resolution to %dx%d\n", new_w, new_h);
-             ff_MPV_common_end(s);
 +            if (av_image_check_size(new_w, new_h, 0, s->avctx) < 0)
 +                return AVERROR_INVALIDDATA;
+             ff_mpv_common_end(s);
  
 +            // attempt to keep aspect during typical resolution switches
 +            if (!old_aspect.num)
 +                old_aspect = (AVRational){1, 1};
 +            if (2 * new_w * s->height == new_h * s->width)
 +                s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){2, 1});
 +            if (new_w * s->height == 2 * new_h * s->width)
 +                s->avctx->sample_aspect_ratio = av_mul_q(old_aspect, (AVRational){1, 2});
 +
              ret = ff_set_dimensions(s->avctx, new_w, new_h);
              if (ret < 0)
                  return ret;
Simple merge
Simple merge
@@@ -1687,11 -1661,11 +1687,11 @@@ int ff_rv34_decode_frame(AVCodecContex
  
      /* first slice */
      if (si.start == 0) {
 -        if (s->mb_num_left > 0) {
 -            av_log(avctx, AV_LOG_ERROR, "New frame but still %d MB left.",
 +        if (s->mb_num_left > 0 && s->current_picture_ptr) {
 +            av_log(avctx, AV_LOG_ERROR, "New frame but still %d MB left.\n",
                     s->mb_num_left);
              ff_er_frame_end(&s->er);
-             ff_MPV_frame_end(s);
+             ff_mpv_frame_end(s);
          }
  
          if (s->width != si.width || s->height != si.height) {
Simple merge
Simple merge
Simple merge
@@@ -442,11 -442,11 +442,11 @@@ __asm__ volatile
          );
  }
  
 -#endif /* HAVE_INLINE_ASM */
 +#endif /* HAVE_MMX_INLINE */
  
- av_cold void ff_MPV_common_init_x86(MpegEncContext *s)
+ av_cold void ff_mpv_common_init_x86(MpegEncContext *s)
  {
 -#if HAVE_INLINE_ASM
 +#if HAVE_MMX_INLINE
      int cpu_flags = av_get_cpu_flags();
  
      if (INLINE_MMX(cpu_flags)) {