Merge commit 'cf7d2f2d2134c0854edf2db91e7436ac2bc9874f'
authorHendrik Leppkes <h.leppkes@gmail.com>
Tue, 29 Sep 2015 13:27:59 +0000 (15:27 +0200)
committerHendrik Leppkes <h.leppkes@gmail.com>
Tue, 29 Sep 2015 13:27:59 +0000 (15:27 +0200)
* commit 'cf7d2f2d2134c0854edf2db91e7436ac2bc9874f':
  lavc: Simplify checking quant bias option

Merged-by: Hendrik Leppkes <h.leppkes@gmail.com>
1  2 
libavcodec/dnxhdenc.c
libavcodec/mpegvideo_enc.c

diff --combined libavcodec/dnxhdenc.c
@@@ -6,20 -6,20 +6,20 @@@
   * VC-3 encoder funded by the British Broadcasting Corporation
   * 10 bit support added by MirriAd Ltd, Joseph Artsimovich <joseph@mirriad.com>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * 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.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * 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 Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -36,7 -36,6 +36,7 @@@
  #include "pixblockdsp.h"
  #include "dnxhdenc.h"
  
 +
  // The largest value that will not lead to overflow for 10bit samples.
  #define DNX10BIT_QMAT_SHIFT 18
  #define RC_VARIANCE 1 // use variance or ssd for fast rc
@@@ -48,18 -47,18 +48,18 @@@ static const AVOption options[] = 
          offsetof(DNXHDEncContext, nitris_compat), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
      { "ibias", "intra quant bias",
          offsetof(DNXHDEncContext, intra_quant_bias), AV_OPT_TYPE_INT,
 -        { .i64 = FF_DEFAULT_QUANT_BIAS }, INT_MIN, INT_MAX, VE },
 +        { .i64 = 0 }, INT_MIN, INT_MAX, VE },
      { NULL }
  };
  
 -static const AVClass class = {
 -    "dnxhd",
 -    av_default_item_name,
 -    options,
 -    LIBAVUTIL_VERSION_INT
 +static const AVClass dnxhd_class = {
 +    .class_name = "dnxhd",
 +    .item_name  = av_default_item_name,
 +    .option     = options,
 +    .version    = LIBAVUTIL_VERSION_INT,
  };
  
 -static void dnxhd_8bit_get_pixels_8x4_sym(int16_t *restrict block,
 +static void dnxhd_8bit_get_pixels_8x4_sym(int16_t *av_restrict block,
                                            const uint8_t *pixels,
                                            ptrdiff_t line_size)
  {
  }
  
  static av_always_inline
 -void dnxhd_10bit_get_pixels_8x4_sym(int16_t *restrict block,
 +void dnxhd_10bit_get_pixels_8x4_sym(int16_t *av_restrict block,
                                      const uint8_t *pixels,
                                      ptrdiff_t line_size)
  {
      int i;
 -
 -    block += 32;
 +    const uint16_t* pixels16 = (const uint16_t*)pixels;
 +    line_size >>= 1;
  
      for (i = 0; i < 4; i++) {
 -        memcpy(block + i * 8, pixels + i * line_size, 8 * sizeof(*block));
 -        memcpy(block - (i + 1) * 8, pixels + i * line_size, 8 * sizeof(*block));
 +        block[0] = pixels16[0]; block[1] = pixels16[1];
 +        block[2] = pixels16[2]; block[3] = pixels16[3];
 +        block[4] = pixels16[4]; block[5] = pixels16[5];
 +        block[6] = pixels16[6]; block[7] = pixels16[7];
 +        pixels16 += line_size;
 +        block += 8;
      }
 +    memcpy(block,      block -  8, sizeof(*block) * 8);
 +    memcpy(block +  8, block - 16, sizeof(*block) * 8);
 +    memcpy(block + 16, block - 24, sizeof(*block) * 8);
 +    memcpy(block + 24, block - 32, sizeof(*block) * 8);
  }
  
  static int dnxhd_10bit_dct_quantize(MpegEncContext *ctx, int16_t *block,
                                      int n, int qscale, int *overflow)
  {
      const uint8_t *scantable= ctx->intra_scantable.scantable;
 -    const int *qmat = ctx->q_intra_matrix[qscale];
 +    const int *qmat = n<4 ? ctx->q_intra_matrix[qscale] : ctx->q_chroma_intra_matrix[qscale];
      int last_non_zero = 0;
      int i;
  
@@@ -136,10 -127,10 +136,10 @@@ static av_cold int dnxhd_init_vlc(DNXHD
      int i, j, level, run;
      int max_level = 1 << (ctx->cid_table->bit_depth + 2);
  
 -    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->vlc_codes,
 -                      max_level * 4 * sizeof(*ctx->vlc_codes), fail);
 -    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->vlc_bits,
 -                      max_level * 4 * sizeof(*ctx->vlc_bits), fail);
 +    FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->vlc_codes,
 +                      max_level, 4 * sizeof(*ctx->vlc_codes), fail);
 +    FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->vlc_bits,
 +                      max_level, 4 * sizeof(*ctx->vlc_bits), fail);
      FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->run_codes,
                        63 * 2, fail);
      FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->run_bits,
                  alevel -= offset << 6;
              }
              for (j = 0; j < 257; j++) {
 -                if (ctx->cid_table->ac_level[j] == alevel &&
 -                    (!offset || (ctx->cid_table->ac_index_flag[j] && offset)) &&
 -                    (!run    || (ctx->cid_table->ac_run_flag  [j] && run))) {
 -                    assert(!ctx->vlc_codes[index]);
 +                if (ctx->cid_table->ac_level[j] >> 1 == alevel &&
 +                    (!offset || (ctx->cid_table->ac_flags[j] & 1) && offset) &&
 +                    (!run    || (ctx->cid_table->ac_flags[j] & 2) && run)) {
 +                    av_assert1(!ctx->vlc_codes[index]);
                      if (alevel) {
                          ctx->vlc_codes[index] =
                              (ctx->cid_table->ac_codes[j] << 1) | (sign & 1);
                      break;
                  }
              }
 -            assert(!alevel || j < 257);
 +            av_assert0(!alevel || j < 257);
              if (offset) {
                  ctx->vlc_codes[index] =
                      (ctx->vlc_codes[index] << ctx->cid_table->index_bits) | offset;
      }
      for (i = 0; i < 62; i++) {
          int run = ctx->cid_table->run[i];
 -        assert(run < 63);
 +        av_assert0(run < 63);
          ctx->run_codes[run] = ctx->cid_table->run_codes[i];
          ctx->run_bits[run]  = ctx->cid_table->run_bits[i];
      }
@@@ -200,15 -191,15 +200,15 @@@ static av_cold int dnxhd_init_qmat(DNXH
      const uint8_t *luma_weight_table   = ctx->cid_table->luma_weight;
      const uint8_t *chroma_weight_table = ctx->cid_table->chroma_weight;
  
 -    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_l,
 -                      (ctx->m.avctx->qmax + 1) * 64 * sizeof(int), fail);
 -    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_c,
 -                      (ctx->m.avctx->qmax + 1) * 64 * sizeof(int), fail);
 -    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_l16,
 -                      (ctx->m.avctx->qmax + 1) * 64 * 2 * sizeof(uint16_t),
 +    FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->qmatrix_l,
 +                      (ctx->m.avctx->qmax + 1), 64 * sizeof(int), fail);
 +    FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->qmatrix_c,
 +                      (ctx->m.avctx->qmax + 1), 64 * sizeof(int), fail);
 +    FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->qmatrix_l16,
 +                      (ctx->m.avctx->qmax + 1), 64 * 2 * sizeof(uint16_t),
                        fail);
 -    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_c16,
 -                      (ctx->m.avctx->qmax + 1) * 64 * 2 * sizeof(uint16_t),
 +    FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->qmatrix_c16,
 +                      (ctx->m.avctx->qmax + 1), 64 * 2 * sizeof(uint16_t),
                        fail);
  
      if (ctx->cid_table->bit_depth == 8) {
          }
      }
  
 +    ctx->m.q_chroma_intra_matrix16 = ctx->qmatrix_c16;
 +    ctx->m.q_chroma_intra_matrix   = ctx->qmatrix_c;
 +    ctx->m.q_intra_matrix16        = ctx->qmatrix_l16;
 +    ctx->m.q_intra_matrix          = ctx->qmatrix_l;
 +
      return 0;
  fail:
      return AVERROR(ENOMEM);
  
  static av_cold int dnxhd_init_rc(DNXHDEncContext *ctx)
  {
 -    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_rc,
 -                      8160 * ctx->m.avctx->qmax * sizeof(RCEntry), fail);
 +    FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->mb_rc, (ctx->m.avctx->qmax + 1), 8160 * sizeof(RCEntry), fail);
      if (ctx->m.avctx->mb_decision != FF_MB_DECISION_RD)
 -        FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_cmp,
 -                          ctx->m.mb_num * sizeof(RCCMPEntry), fail);
 +        FF_ALLOCZ_ARRAY_OR_GOTO(ctx->m.avctx, ctx->mb_cmp,
 +                          ctx->m.mb_num, sizeof(RCCMPEntry), fail);
  
      ctx->frame_bits = (ctx->cid_table->coding_unit_size -
                         640 - 4 - ctx->min_padding) * 8;
@@@ -309,15 -296,14 +309,15 @@@ static av_cold int dnxhd_encode_init(AV
      ctx->cid = ff_dnxhd_find_cid(avctx, bit_depth);
      if (!ctx->cid) {
          av_log(avctx, AV_LOG_ERROR,
 -               "video parameters incompatible with DNxHD\n");
 +               "video parameters incompatible with DNxHD. Valid DNxHD profiles:\n");
 +        ff_dnxhd_print_profiles(avctx, AV_LOG_ERROR);
          return AVERROR(EINVAL);
      }
      av_log(avctx, AV_LOG_DEBUG, "cid %d\n", ctx->cid);
  
      index = ff_dnxhd_get_cid_table(ctx->cid);
 -    if (index < 0)
 -        return index;
 +    av_assert0(index >= 0);
 +
      ctx->cid_table = &ff_dnxhd_cid_table[index];
  
      ctx->m.avctx    = avctx;
      ff_mpv_idct_init(&ctx->m);
      ff_mpegvideoencdsp_init(&ctx->m.mpvencdsp, avctx);
      ff_pixblockdsp_init(&ctx->m.pdsp, avctx);
 +    ff_dct_encode_init(&ctx->m);
 +
      if (!ctx->m.dct_quantize)
          ctx->m.dct_quantize = ff_dct_quantize_c;
  
  
  #if FF_API_QUANT_BIAS
  FF_DISABLE_DEPRECATION_WARNINGS
-     if (ctx->intra_quant_bias == FF_DEFAULT_QUANT_BIAS &&
-         avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
+     if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
          ctx->intra_quant_bias = avctx->intra_quant_bias;
  FF_ENABLE_DEPRECATION_WARNINGS
  #endif
@@@ -400,11 -383,6 +399,11 @@@ FF_ENABLE_DEPRECATION_WARNING
          return AVERROR(EINVAL);
      }
  
 +    if (avctx->qmax <= 1) {
 +        av_log(avctx, AV_LOG_ERROR, "qmax must be at least 2\n");
 +        return AVERROR(EINVAL);
 +    }
 +
      ctx->thread[0] = ctx;
      for (i = 1; i < avctx->thread_count; i++) {
          ctx->thread[i] = av_malloc(sizeof(DNXHDEncContext));
@@@ -419,7 -397,7 +418,7 @@@ fail:  // for FF_ALLOCZ_OR_GOT
  static int dnxhd_write_header(AVCodecContext *avctx, uint8_t *buf)
  {
      DNXHDEncContext *ctx = avctx->priv_data;
 -    const uint8_t header_prefix[5] = { 0x00, 0x00, 0x02, 0x80, 0x01 };
 +    static const uint8_t header_prefix[5] = { 0x00, 0x00, 0x02, 0x80, 0x01 };
  
      memset(buf, 0, 640);
  
@@@ -458,7 -436,7 +457,7 @@@ static av_always_inline void dnxhd_enco
      }
      put_bits(&ctx->m.pb, ctx->cid_table->dc_bits[nbits] + nbits,
               (ctx->cid_table->dc_codes[nbits] << nbits) +
 -             (diff & ((1 << nbits) - 1)));
 +             av_mod_uintp2(diff, nbits));
  }
  
  static av_always_inline
@@@ -612,8 -590,15 +611,8 @@@ void dnxhd_get_blocks(DNXHDEncContext *
  static av_always_inline
  int dnxhd_switch_matrix(DNXHDEncContext *ctx, int i)
  {
 -    if (i & 2) {
 -        ctx->m.q_intra_matrix16 = ctx->qmatrix_c16;
 -        ctx->m.q_intra_matrix   = ctx->qmatrix_c;
 -        return 1 + (i & 1);
 -    } else {
 -        ctx->m.q_intra_matrix16 = ctx->qmatrix_l16;
 -        ctx->m.q_intra_matrix   = ctx->qmatrix_l;
 -        return 0;
 -    }
 +    const static uint8_t component[8]={0,0,1,2,0,0,1,2};
 +    return component[i];
  }
  
  static int dnxhd_calc_bits_thread(AVCodecContext *avctx, void *arg,
              int n = dnxhd_switch_matrix(ctx, i);
  
              memcpy(block, src_block, 64 * sizeof(*block));
 -            last_index = ctx->m.dct_quantize(&ctx->m, block, i,
 +            last_index = ctx->m.dct_quantize(&ctx->m, block, 4 & (2*i),
                                               qscale, &overflow);
              ac_bits   += dnxhd_calc_ac_bits(ctx, block, last_index);
  
              else
                  nbits = av_log2_16bit(2 * diff);
  
 -            assert(nbits < ctx->cid_table->bit_depth + 4);
 +            av_assert1(nbits < ctx->cid_table->bit_depth + 4);
              dc_bits += ctx->cid_table->dc_bits[nbits] + nbits;
  
              ctx->m.last_dc[n] = block[0];
@@@ -696,7 -681,7 +695,7 @@@ static int dnxhd_encode_thread(AVCodecC
          for (i = 0; i < 8; i++) {
              int16_t *block = ctx->blocks[i];
              int overflow, n = dnxhd_switch_matrix(ctx, i);
 -            int last_index = ctx->m.dct_quantize(&ctx->m, block, i,
 +            int last_index = ctx->m.dct_quantize(&ctx->m, block, 4 & (2*i),
                                                   qscale, &overflow);
              // START_TIMER;
              dnxhd_encode_block(ctx, block, last_index, n);
@@@ -955,13 -940,13 +954,13 @@@ static void radix_count(const RCCMPEntr
              buckets[j][get_bucket(v, 0)]++;
              v >>= BUCKET_BITS;
          }
 -        assert(!v);
 +        av_assert1(!v);
      }
      for (j = 0; j < RADIX_PASSES; j++) {
          int offset = size;
          for (i = NBUCKETS - 1; i >= 0; i--)
              buckets[j][i] = offset -= buckets[j][i];
 -        assert(!buckets[j][0]);
 +        av_assert1(!buckets[j][0]);
      }
  }
  
@@@ -980,7 -965,7 +979,7 @@@ static void radix_sort_pass(RCCMPEntry 
  static void radix_sort(RCCMPEntry *data, int size)
  {
      int buckets[RADIX_PASSES][NBUCKETS];
 -    RCCMPEntry *tmp = av_malloc(sizeof(*tmp) * size);
 +    RCCMPEntry *tmp = av_malloc_array(size, sizeof(*tmp));
      radix_count(data, size, buckets);
      radix_sort_pass(tmp, data, size, buckets[0], 0);
      radix_sort_pass(data, tmp, size, buckets[1], 1);
@@@ -1058,10 -1043,13 +1057,10 @@@ static int dnxhd_encode_picture(AVCodec
      DNXHDEncContext *ctx = avctx->priv_data;
      int first_field = 1;
      int offset, i, ret;
 -    uint8_t *buf, *sd;
 +    uint8_t *buf;
  
 -    if ((ret = ff_alloc_packet(pkt, ctx->cid_table->frame_size)) < 0) {
 -        av_log(avctx, AV_LOG_ERROR,
 -               "output buffer is too small to compress picture\n");
 +    if ((ret = ff_alloc_packet2(avctx, pkt, ctx->cid_table->frame_size, 0)) < 0)
          return ret;
 -    }
      buf = pkt->data;
  
      dnxhd_load_picture(ctx, frame);
@@@ -1091,12 -1079,12 +1090,12 @@@ encode_coding_unit
      for (i = 0; i < ctx->m.mb_height; i++) {
          AV_WB32(ctx->msip + i * 4, offset);
          offset += ctx->slice_size[i];
 -        assert(!(ctx->slice_size[i] & 3));
 +        av_assert1(!(ctx->slice_size[i] & 3));
      }
  
      avctx->execute2(avctx, dnxhd_encode_thread, buf, NULL, ctx->m.mb_height);
  
 -    assert(640 + offset + 4 <= ctx->cid_table->coding_unit_size);
 +    av_assert1(640 + offset + 4 <= ctx->cid_table->coding_unit_size);
      memset(buf + 640 + offset, 0,
             ctx->cid_table->coding_unit_size - 4 - offset - 640);
  
@@@ -1115,7 -1103,10 +1114,7 @@@ FF_DISABLE_DEPRECATION_WARNING
  FF_ENABLE_DEPRECATION_WARNINGS
  #endif
  
 -    sd = av_packet_new_side_data(pkt, AV_PKT_DATA_QUALITY_FACTOR, sizeof(int));
 -    if (!sd)
 -        return AVERROR(ENOMEM);
 -    *(int *)sd = ctx->qscale * FF_QP2LAMBDA;
 +    ff_side_data_set_encoder_stats(pkt, ctx->qscale * FF_QP2LAMBDA, NULL, 0, AV_PICTURE_TYPE_I);
  
      pkt->flags |= AV_PKT_FLAG_KEY;
      *got_packet = 1;
@@@ -1151,11 -1142,6 +1150,11 @@@ static av_cold int dnxhd_encode_end(AVC
      return 0;
  }
  
 +static const AVCodecDefault dnxhd_defaults[] = {
 +    { "qmax", "1024" }, /* Maximum quantization scale factor allowed for VC-3 */
 +    { NULL },
 +};
 +
  AVCodec ff_dnxhd_encoder = {
      .name           = "dnxhd",
      .long_name      = NULL_IF_CONFIG_SMALL("VC3/DNxHD"),
          AV_PIX_FMT_YUV422P10,
          AV_PIX_FMT_NONE
      },
 -    .priv_class     = &class,
 +    .priv_class     = &dnxhd_class,
 +    .defaults       = dnxhd_defaults,
  };
@@@ -5,27 -5,23 +5,27 @@@
   *
   * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * 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.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * 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 Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
 +/*
 + * non linear quantizers with large QPs and VBV with restrictive qmin fixes sponsored by NOA GmbH
 + */
 +
  /**
   * @file
   * The simplest mpeg encoder (well, it was the simplest!).
  #include "wmv2.h"
  #include "rv10.h"
  #include <limits.h>
 +#include "sp5x.h"
  
  #define QUANT_BIAS_SHIFT 8
  
  #define QMAT_SHIFT_MMX 16
 -#define QMAT_SHIFT 22
 +#define QMAT_SHIFT 21
  
  static int encode_picture(MpegEncContext *s, int picture_number);
  static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);
@@@ -97,11 -92,6 +97,11 @@@ void ff_convert_matrix(MpegEncContext *
  
      for (qscale = qmin; qscale <= qmax; qscale++) {
          int i;
 +        int qscale2;
 +
 +        if (s->q_scale_type) qscale2 = ff_mpeg2_non_linear_qscale[qscale];
 +        else                 qscale2 = qscale << 1;
 +
          if (fdsp->fdct == ff_jpeg_fdct_islow_8  ||
  #if CONFIG_FAANDCT
              fdsp->fdct == ff_faandct            ||
              fdsp->fdct == ff_jpeg_fdct_islow_10) {
              for (i = 0; i < 64; i++) {
                  const int j = s->idsp.idct_permutation[i];
 -                int64_t den = (int64_t) qscale * quant_matrix[j];
 +                int64_t den = (int64_t) qscale2 * quant_matrix[j];
                  /* 16 <= qscale * quant_matrix[i] <= 7905
                   * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
                   *             19952 <=              x  <= 249205026
                   * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
                   *           3444240 >= (1 << 36) / (x) >= 275 */
  
 -                qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / den);
 +                qmat[qscale][i] = (int)((UINT64_C(2) << QMAT_SHIFT) / den);
              }
          } else if (fdsp->fdct == ff_fdct_ifast) {
              for (i = 0; i < 64; i++) {
                  const int j = s->idsp.idct_permutation[i];
 -                int64_t den = ff_aanscales[i] * (int64_t) qscale * quant_matrix[j];
 +                int64_t den = ff_aanscales[i] * (int64_t) qscale2 * quant_matrix[j];
                  /* 16 <= qscale * quant_matrix[i] <= 7905
                   * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
                   *             19952 <=              x  <= 249205026
                   * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
                   *           3444240 >= (1 << 36) / (x) >= 275 */
  
 -                qmat[qscale][i] = (int)((UINT64_C(1) << (QMAT_SHIFT + 14)) / den);
 +                qmat[qscale][i] = (int)((UINT64_C(2) << (QMAT_SHIFT + 14)) / den);
              }
          } else {
              for (i = 0; i < 64; i++) {
                  const int j = s->idsp.idct_permutation[i];
 -                int64_t den = (int64_t) qscale * quant_matrix[j];
 +                int64_t den = (int64_t) qscale2 * quant_matrix[j];
                  /* We can safely suppose that 16 <= quant_matrix[i] <= 255
                   * Assume x = qscale * quant_matrix[i]
                   * So             16 <=              x  <= 7905
                   * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
                   * so          32768 >= (1 << 19) / (x) >= 67 */
 -                qmat[qscale][i] = (int)((UINT64_C(1) << QMAT_SHIFT) / den);
 +                qmat[qscale][i] = (int)((UINT64_C(2) << QMAT_SHIFT) / den);
                  //qmat  [qscale][i] = (1 << QMAT_SHIFT_MMX) /
                  //                    (qscale * quant_matrix[i]);
 -                qmat16[qscale][0][i] = (1 << QMAT_SHIFT_MMX) / den;
 +                qmat16[qscale][0][i] = (2 << QMAT_SHIFT_MMX) / den;
  
                  if (qmat16[qscale][0][i] == 0 ||
                      qmat16[qscale][0][i] == 128 * 256)
  
  static inline void update_qscale(MpegEncContext *s)
  {
 -    s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
 -                (FF_LAMBDA_SHIFT + 7);
 -    s->qscale = av_clip(s->qscale, s->avctx->qmin, s->avctx->qmax);
 +    if (s->q_scale_type == 1 && 0) {
 +        int i;
 +        int bestdiff=INT_MAX;
 +        int best = 1;
 +
 +        for (i = 0 ; i<FF_ARRAY_ELEMS(ff_mpeg2_non_linear_qscale); i++) {
 +            int diff = FFABS((ff_mpeg2_non_linear_qscale[i]<<(FF_LAMBDA_SHIFT + 6)) - (int)s->lambda * 139);
 +            if (ff_mpeg2_non_linear_qscale[i] < s->avctx->qmin ||
 +                (ff_mpeg2_non_linear_qscale[i] > s->avctx->qmax && !s->vbv_ignore_qmax))
 +                continue;
 +            if (diff < bestdiff) {
 +                bestdiff = diff;
 +                best = i;
 +            }
 +        }
 +        s->qscale = best;
 +    } else {
 +        s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
 +                    (FF_LAMBDA_SHIFT + 7);
 +        s->qscale = av_clip(s->qscale, s->avctx->qmin, s->vbv_ignore_qmax ? 31 : s->avctx->qmax);
 +    }
  
      s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
                   FF_LAMBDA_SHIFT;
@@@ -265,23 -237,6 +265,23 @@@ 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)
  {
          }
          break;
      case AV_CODEC_ID_MJPEG:
 +    case AV_CODEC_ID_AMV:
          format_supported = 0;
          /* JPEG color space */
          if (avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
              avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
 +            avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
              (avctx->color_range == AVCOL_RANGE_JPEG &&
               (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
 -              avctx->pix_fmt == AV_PIX_FMT_YUV422P)))
 +              avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
 +              avctx->pix_fmt == AV_PIX_FMT_YUV444P)))
              format_supported = 1;
          /* MPEG color space */
          else if (avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL &&
                   (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
 -                  avctx->pix_fmt == AV_PIX_FMT_YUV422P))
 +                  avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
 +                  avctx->pix_fmt == AV_PIX_FMT_YUV444P))
              format_supported = 1;
  
          if (!format_supported) {
      }
  
      switch (avctx->pix_fmt) {
 +    case AV_PIX_FMT_YUVJ444P:
 +    case AV_PIX_FMT_YUV444P:
 +        s->chroma_format = CHROMA_444;
 +        break;
      case AV_PIX_FMT_YUVJ422P:
      case AV_PIX_FMT_YUV422P:
          s->chroma_format = CHROMA_422;
      s->height   = avctx->height;
      if (avctx->gop_size > 600 &&
          avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
 -        av_log(avctx, AV_LOG_ERROR,
 -               "Warning keyframe interval too large! reducing it ...\n");
 +        av_log(avctx, AV_LOG_WARNING,
 +               "keyframe interval too large!, reducing it from %d to %d\n",
 +               avctx->gop_size, 600);
          avctx->gop_size = 600;
      }
      s->gop_size     = avctx->gop_size;
      if (avctx->max_b_frames > MAX_B_FRAMES) {
          av_log(avctx, AV_LOG_ERROR, "Too many B-frames requested, maximum "
                 "is %d.\n", MAX_B_FRAMES);
 +        avctx->max_b_frames = MAX_B_FRAMES;
      }
      s->max_b_frames = avctx->max_b_frames;
      s->codec_id     = avctx->codec->id;
      s->mpeg_quant         = avctx->mpeg_quant;
      s->rtp_mode           = !!avctx->rtp_payload_size;
      s->intra_dc_precision = avctx->intra_dc_precision;
 +
 +    // workaround some differences between how applications specify dc precision
 +    if (s->intra_dc_precision < 0) {
 +        s->intra_dc_precision += 8;
 +    } else if (s->intra_dc_precision >= 8)
 +        s->intra_dc_precision -= 8;
 +
 +    if (s->intra_dc_precision < 0) {
 +        av_log(avctx, AV_LOG_ERROR,
 +                "intra dc precision must be positive, note some applications use"
 +                " 0 and some 8 as base meaning 8bit, the value must not be smaller than that\n");
 +        return AVERROR(EINVAL);
 +    }
 +
 +    if (s->intra_dc_precision > (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO ? 3 : 0)) {
 +        av_log(avctx, AV_LOG_ERROR, "intra dc precision too large\n");
 +        return AVERROR(EINVAL);
 +    }
      s->user_specified_pts = AV_NOPTS_VALUE;
  
      if (s->gop_size <= 1) {
@@@ -425,33 -352,9 +425,33 @@@ FF_ENABLE_DEPRECATION_WARNING
      s->loop_filter = !!(s->avctx->flags & AV_CODEC_FLAG_LOOP_FILTER);
  
      if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
 -        av_log(avctx, AV_LOG_ERROR,
 -               "a vbv buffer size is needed, "
 -               "for encoding with a maximum bitrate\n");
 +        switch(avctx->codec_id) {
 +        case AV_CODEC_ID_MPEG1VIDEO:
 +        case AV_CODEC_ID_MPEG2VIDEO:
 +            avctx->rc_buffer_size = FFMAX(avctx->rc_max_rate, 15000000) * 112LL / 15000000 * 16384;
 +            break;
 +        case AV_CODEC_ID_MPEG4:
 +        case AV_CODEC_ID_MSMPEG4V1:
 +        case AV_CODEC_ID_MSMPEG4V2:
 +        case AV_CODEC_ID_MSMPEG4V3:
 +            if       (avctx->rc_max_rate >= 15000000) {
 +                avctx->rc_buffer_size = 320 + (avctx->rc_max_rate - 15000000LL) * (760-320) / (38400000 - 15000000);
 +            } else if(avctx->rc_max_rate >=  2000000) {
 +                avctx->rc_buffer_size =  80 + (avctx->rc_max_rate -  2000000LL) * (320- 80) / (15000000 -  2000000);
 +            } else if(avctx->rc_max_rate >=   384000) {
 +                avctx->rc_buffer_size =  40 + (avctx->rc_max_rate -   384000LL) * ( 80- 40) / ( 2000000 -   384000);
 +            } else
 +                avctx->rc_buffer_size = 40;
 +            avctx->rc_buffer_size *= 16384;
 +            break;
 +        }
 +        if (avctx->rc_buffer_size) {
 +            av_log(avctx, AV_LOG_INFO, "Automatically choosing VBV buffer size of %d kbyte\n", avctx->rc_buffer_size/8192);
 +        }
 +    }
 +
 +    if ((!avctx->rc_max_rate) != (!avctx->rc_buffer_size)) {
 +        av_log(avctx, AV_LOG_ERROR, "Either both buffer size and max rate or neither must be specified\n");
          return -1;
      }
  
      }
  
      if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
 -        av_log(avctx, AV_LOG_INFO, "bitrate above max bitrate\n");
 +        av_log(avctx, AV_LOG_ERROR, "bitrate above max bitrate\n");
          return -1;
      }
  
      if (!s->fixed_qscale &&
          avctx->bit_rate * av_q2d(avctx->time_base) >
              avctx->bit_rate_tolerance) {
 -        av_log(avctx, AV_LOG_ERROR,
 -               "bitrate tolerance too small for bitrate\n");
 -        return -1;
 +        av_log(avctx, AV_LOG_WARNING,
 +               "bitrate tolerance %d too small for bitrate %"PRId64", overriding\n", avctx->bit_rate_tolerance, (int64_t)avctx->bit_rate);
 +        avctx->bit_rate_tolerance = 5 * avctx->bit_rate * av_q2d(avctx->time_base);
      }
  
      if (s->avctx->rc_max_rate &&
          av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
          return -1;
      }
 +    if (s->max_b_frames < 0) {
 +        av_log(avctx, AV_LOG_ERROR,
 +               "max b frames must be 0 or positive for mpegvideo based encoders\n");
 +        return -1;
 +    }
  
      if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
           s->codec_id == AV_CODEC_ID_H263  ||
           s->codec_id == AV_CODEC_ID_H263P) &&
          (avctx->sample_aspect_ratio.num > 255 ||
           avctx->sample_aspect_ratio.den > 255)) {
 -        av_log(avctx, AV_LOG_ERROR,
 -               "Invalid pixel aspect ratio %i/%i, limit is 255/255\n",
 +        av_log(avctx, AV_LOG_WARNING,
 +               "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
                 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
 +        av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
 +                   avctx->sample_aspect_ratio.num,  avctx->sample_aspect_ratio.den, 255);
 +    }
 +
 +    if ((s->codec_id == AV_CODEC_ID_H263  ||
 +         s->codec_id == AV_CODEC_ID_H263P) &&
 +        (avctx->width  > 2048 ||
 +         avctx->height > 1152 )) {
 +        av_log(avctx, AV_LOG_ERROR, "H.263 does not support resolutions above 2048x1152\n");
 +        return -1;
 +    }
 +    if ((s->codec_id == AV_CODEC_ID_H263  ||
 +         s->codec_id == AV_CODEC_ID_H263P) &&
 +        ((avctx->width &3) ||
 +         (avctx->height&3) )) {
 +        av_log(avctx, AV_LOG_ERROR, "w/h must be a multiple of 4\n");
          return -1;
      }
  
 +    if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO &&
 +        (avctx->width  > 4095 ||
 +         avctx->height > 4095 )) {
 +        av_log(avctx, AV_LOG_ERROR, "MPEG-1 does not support resolutions above 4095x4095\n");
 +        return -1;
 +    }
 +
 +    if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO &&
 +        (avctx->width  > 16383 ||
 +         avctx->height > 16383 )) {
 +        av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support resolutions above 16383x16383\n");
 +        return -1;
 +    }
 +
 +    if (s->codec_id == AV_CODEC_ID_RV10 &&
 +        (avctx->width &15 ||
 +         avctx->height&15 )) {
 +        av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 16\n");
 +        return AVERROR(EINVAL);
 +    }
 +
 +    if (s->codec_id == AV_CODEC_ID_RV20 &&
 +        (avctx->width &3 ||
 +         avctx->height&3 )) {
 +        av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 4\n");
 +        return AVERROR(EINVAL);
 +    }
 +
 +    if ((s->codec_id == AV_CODEC_ID_WMV1 ||
 +         s->codec_id == AV_CODEC_ID_WMV2) &&
 +         avctx->width & 1) {
 +         av_log(avctx, AV_LOG_ERROR, "width must be multiple of 2\n");
 +         return -1;
 +    }
 +
      if ((s->avctx->flags & (AV_CODEC_FLAG_INTERLACED_DCT | AV_CODEC_FLAG_INTERLACED_ME)) &&
          s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
          av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
      }
  
      // FIXME mpeg2 uses that too
 -    if (s->mpeg_quant && s->codec_id != AV_CODEC_ID_MPEG4) {
 +    if (s->mpeg_quant && (   s->codec_id != AV_CODEC_ID_MPEG4
 +                          && s->codec_id != AV_CODEC_ID_MPEG2VIDEO)) {
          av_log(avctx, AV_LOG_ERROR,
                 "mpeg2 style quantization not supported by codec\n");
          return -1;
      }
  
      if (s->q_scale_type == 1) {
 -        if (avctx->qmax > 12) {
 +        if (avctx->qmax > 28) {
              av_log(avctx, AV_LOG_ERROR,
 -                   "non linear quant only supports qmax <= 12 currently\n");
 +                   "non linear quant only supports qmax <= 28 currently\n");
              return -1;
          }
      }
          s->codec_id != AV_CODEC_ID_MPEG4      &&
          s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
          s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
 +        s->codec_id != AV_CODEC_ID_MJPEG      &&
          (s->codec_id != AV_CODEC_ID_H263P)) {
          av_log(avctx, AV_LOG_ERROR,
                 "multi threaded encoding not supported by codec\n");
  
      if (s->avctx->thread_count < 1) {
          av_log(avctx, AV_LOG_ERROR,
 -               "automatic thread number detection not supported by codec,"
 +               "automatic thread number detection not supported by codec, "
                 "patch welcome\n");
          return -1;
      }
  
 -    if (s->avctx->thread_count > 1)
 +    if (s->avctx->slices > 1 || s->avctx->thread_count > 1)
          s->rtp_mode = 1;
  
 +    if (s->avctx->thread_count > 1 && s->codec_id == AV_CODEC_ID_H263P)
 +        s->h263_slice_structured = 1;
 +
      if (!avctx->time_base.den || !avctx->time_base.num) {
          av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
          return -1;
          //return -1;
      }
  
 -    if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
 -        s->codec_id == AV_CODEC_ID_MPEG2VIDEO || s->codec_id == AV_CODEC_ID_MJPEG) {
 +    if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || s->codec_id == AV_CODEC_ID_MJPEG || s->codec_id==AV_CODEC_ID_AMV) {
          // (a + x * 3 / 8) / x
          s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
          s->inter_quant_bias = 0;
          s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
      }
  
 +    if (avctx->qmin > avctx->qmax || avctx->qmin <= 0) {
 +        av_log(avctx, AV_LOG_ERROR, "qmin and or qmax are invalid, they must be 0 < min <= max\n");
 +        return AVERROR(EINVAL);
 +    }
 +
  #if FF_API_QUANT_BIAS
  FF_DISABLE_DEPRECATION_WARNINGS
-     if (s->intra_quant_bias == FF_DEFAULT_QUANT_BIAS &&
-         avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
+     if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
          s->intra_quant_bias = avctx->intra_quant_bias;
-     if (s->inter_quant_bias == FF_DEFAULT_QUANT_BIAS &&
-         avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
+     if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
          s->inter_quant_bias = avctx->inter_quant_bias;
  FF_ENABLE_DEPRECATION_WARNINGS
  #endif
  
 +    av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
 +
      if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
          s->avctx->time_base.den > (1 << 16) - 1) {
          av_log(avctx, AV_LOG_ERROR,
          s->rtp_mode   = 1;
          break;
      case AV_CODEC_ID_MJPEG:
 +    case AV_CODEC_ID_AMV:
          s->out_format = FMT_MJPEG;
          s->intra_only = 1; /* force intra only for jpeg */
          if (!CONFIG_MJPEG_ENCODER ||
          break;
      case AV_CODEC_ID_H263:
          if (!CONFIG_H263_ENCODER)
 -        return -1;
 +            return -1;
          if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
                               s->width, s->height) == 8) {
 -            av_log(avctx, AV_LOG_INFO,
 +            av_log(avctx, AV_LOG_ERROR,
                     "The specified picture size of %dx%d is not valid for "
                     "the H.263 codec.\nValid sizes are 128x96, 176x144, "
 -                   "352x288, 704x576, and 1408x1152."
 +                   "352x288, 704x576, and 1408x1152. "
                     "Try H.263+.\n", s->width, s->height);
              return -1;
          }
      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);
      FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
  
      FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix,   64 * 32 * sizeof(int), fail);
 +    FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix, 64 * 32 * sizeof(int), fail);
      FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix,   64 * 32 * sizeof(int), fail);
      FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
 +    FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
      FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail);
      FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture,
                        MAX_PICTURE_COUNT * sizeof(Picture *), fail);
                            2 * 64 * sizeof(uint16_t), fail);
      }
  
 -    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 (avctx->trellis)
 -        s->dct_quantize  = dct_quantize_trellis_c;
 +    ff_dct_encode_init(s);
  
      if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
          s->chroma_qscale_table = ff_h263_chroma_qscale_table;
              s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
          } else {
              /* mpeg1/2 */
 +            s->chroma_intra_matrix[j] =
              s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
              s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
          }
@@@ -1060,10 -901,6 +1058,10 @@@ av_cold int ff_mpv_encode_end(AVCodecCo
      av_freep(&s->avctx->stats_out);
      av_freep(&s->ac_stats);
  
 +    if(s->q_chroma_intra_matrix   != s->q_intra_matrix  ) av_freep(&s->q_chroma_intra_matrix);
 +    if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
 +    s->q_chroma_intra_matrix=   NULL;
 +    s->q_chroma_intra_matrix16= NULL;
      av_freep(&s->q_intra_matrix);
      av_freep(&s->q_inter_matrix);
      av_freep(&s->q_intra_matrix16);
@@@ -1116,7 -953,7 +1114,7 @@@ static int alloc_picture(MpegEncContex
  {
      return ff_alloc_picture(s->avctx, pic, &s->me, &s->sc, shared, 1,
                              s->chroma_x_shift, s->chroma_y_shift, s->out_format,
 -                            s->mb_stride, s->mb_height, s->b8_stride,
 +                            s->mb_stride, s->mb_width, s->mb_height, s->b8_stride,
                              &s->linesize, &s->uvlinesize);
  }
  
@@@ -1135,17 -972,18 +1133,17 @@@ static int load_input_picture(MpegEncCo
  
          if (pts != AV_NOPTS_VALUE) {
              if (s->user_specified_pts != AV_NOPTS_VALUE) {
 -                int64_t time = pts;
                  int64_t last = s->user_specified_pts;
  
 -                if (time <= last) {
 +                if (pts <= last) {
                      av_log(s->avctx, AV_LOG_ERROR,
 -                           "Error, Invalid timestamp=%"PRId64", "
 -                           "last=%"PRId64"\n", pts, s->user_specified_pts);
 -                    return -1;
 +                           "Invalid pts (%"PRId64") <= last (%"PRId64")\n",
 +                           pts, last);
 +                    return AVERROR(EINVAL);
                  }
  
                  if (!s->low_delay && display_picture_number == 1)
 -                    s->dts_delta = time - last;
 +                    s->dts_delta = pts - last;
              }
              s->user_specified_pts = pts;
          } else {
              direct = 0;
          if ((s->width & 15) || (s->height & 15))
              direct = 0;
 +        if (((intptr_t)(pic_arg->data[0])) & (STRIDE_ALIGN-1))
 +            direct = 0;
 +        if (s->linesize & (STRIDE_ALIGN-1))
 +            direct = 0;
  
 -        ff_dlog(s->avctx, "%d %d %td %td\n", pic_arg->linesize[0],
 +        ff_dlog(s->avctx, "%d %d %"PTRDIFF_SPECIFIER" %"PTRDIFF_SPECIFIER"\n", pic_arg->linesize[0],
                  pic_arg->linesize[1], s->linesize, s->uvlinesize);
  
          i = ff_find_unused_picture(s->avctx, s->picture, direct);
                      int h = s->height >> v_shift;
                      uint8_t *src = pic_arg->data[i];
                      uint8_t *dst = pic->f->data[i];
 +                    int vpad = 16;
 +
 +                    if (   s->codec_id == AV_CODEC_ID_MPEG2VIDEO
 +                        && !s->progressive_sequence
 +                        && FFALIGN(s->height, 32) - s->height > 16)
 +                        vpad = 32;
  
                      if (!s->avctx->rc_buffer_size)
                          dst += INPLACE_OFFSET;
                              src += src_stride;
                          }
                      }
 -                    if ((s->width & 15) || (s->height & 15)) {
 +                    if ((s->width & 15) || (s->height & (vpad-1))) {
                          s->mpvencdsp.draw_edges(dst, dst_stride,
                                                  w, h,
                                                  16 >> h_shift,
 -                                                16 >> v_shift,
 +                                                vpad >> v_shift,
                                                  EDGE_BOTTOM);
                      }
                  }
@@@ -1276,23 -1104,19 +1274,23 @@@ static int skip_check(MpegEncContext *s
                  uint8_t *rptr = ref->f->data[plane] + 8 * (x + y * stride);
                  int v = s->mecc.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
  
 -                switch (s->avctx->frame_skip_exp) {
 +                switch (FFABS(s->avctx->frame_skip_exp)) {
                  case 0: score    =  FFMAX(score, v);          break;
                  case 1: score   += FFABS(v);                  break;
 -                case 2: score   += v * v;                     break;
 -                case 3: score64 += FFABS(v * v * (int64_t)v); break;
 -                case 4: score64 += v * v * (int64_t)(v * v);  break;
 +                case 2: score64 += v * (int64_t)v;                       break;
 +                case 3: score64 += FFABS(v * (int64_t)v * v);            break;
 +                case 4: score64 += (v * (int64_t)v) * (v * (int64_t)v);  break;
                  }
              }
          }
      }
 +    emms_c();
  
      if (score)
          score64 = score;
 +    if (s->avctx->frame_skip_exp < 0)
 +        score64 = pow(score64 / (double)(s->mb_width * s->mb_height),
 +                      -1.0/s->avctx->frame_skip_exp);
  
      if (score64 < s->avctx->frame_skip_threshold)
          return 1;
@@@ -1327,7 -1151,7 +1325,7 @@@ static int estimate_best_b_count(MpegEn
  
      if (!c)
          return AVERROR(ENOMEM);
 -    assert(scale >= 0 && scale <= 3);
 +    av_assert0(scale >= 0 && scale <= 3);
  
      //emms_c();
      //s->next_picture_ptr->quality;
      for (i = 0; i < s->max_b_frames + 2; i++) {
          Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
                                                  s->next_picture_ptr;
 +        uint8_t *data[4];
  
          if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
              pre_input = *pre_input_ptr;
 +            memcpy(data, pre_input_ptr->f->data, sizeof(data));
  
              if (!pre_input.shared && i) {
 -                pre_input.f->data[0] += INPLACE_OFFSET;
 -                pre_input.f->data[1] += INPLACE_OFFSET;
 -                pre_input.f->data[2] += INPLACE_OFFSET;
 +                data[0] += INPLACE_OFFSET;
 +                data[1] += INPLACE_OFFSET;
 +                data[2] += INPLACE_OFFSET;
              }
  
              s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[0],
                                         s->tmp_frames[i]->linesize[0],
 -                                       pre_input.f->data[0],
 +                                       data[0],
                                         pre_input.f->linesize[0],
                                         c->width, c->height);
              s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[1],
                                         s->tmp_frames[i]->linesize[1],
 -                                       pre_input.f->data[1],
 +                                       data[1],
                                         pre_input.f->linesize[1],
                                         c->width >> 1, c->height >> 1);
              s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[2],
                                         s->tmp_frames[i]->linesize[2],
 -                                       pre_input.f->data[2],
 +                                       data[2],
                                         pre_input.f->linesize[2],
                                         c->width >> 1, c->height >> 1);
          }
@@@ -1444,19 -1266,6 +1442,19 @@@ static int select_input_picture(MpegEnc
  
      /* set next picture type & ordering */
      if (!s->reordered_input_picture[0] && s->input_picture[0]) {
 +        if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
 +            if (s->picture_in_gop_number < s->gop_size &&
 +                s->next_picture_ptr &&
 +                skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
 +                // FIXME check that te gop check above is +-1 correct
 +                av_frame_unref(s->input_picture[0]->f);
 +
 +                ff_vbv_update(s, 0);
 +
 +                goto no_output_pic;
 +            }
 +        }
 +
          if (/*s->picture_in_gop_number >= s->gop_size ||*/
              !s->next_picture_ptr || s->intra_only) {
              s->reordered_input_picture[0] = s->input_picture[0];
          } else {
              int b_frames;
  
 -            if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
 -                if (s->picture_in_gop_number < s->gop_size &&
 -                    skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
 -                    // FIXME check that te gop check above is +-1 correct
 -                    av_frame_unref(s->input_picture[0]->f);
 -
 -                    emms_c();
 -                    ff_vbv_update(s, 0);
 -
 -                    goto no_output_pic;
 -                }
 -            }
 -
              if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
                  for (i = 0; i < s->max_b_frames + 1; i++) {
                      int pict_num = s->input_picture[0]->f->display_picture_number + i;
@@@ -1614,26 -1436,25 +1612,26 @@@ no_output_pic
  
  static void frame_end(MpegEncContext *s)
  {
 -    int i;
 -
      if (s->unrestricted_mv &&
          s->current_picture.reference &&
          !s->intra_only) {
          const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
          int hshift = desc->log2_chroma_w;
          int vshift = desc->log2_chroma_h;
 -        s->mpvencdsp.draw_edges(s->current_picture.f->data[0], s->linesize,
 +        s->mpvencdsp.draw_edges(s->current_picture.f->data[0],
 +                                s->current_picture.f->linesize[0],
                                  s->h_edge_pos, s->v_edge_pos,
                                  EDGE_WIDTH, EDGE_WIDTH,
                                  EDGE_TOP | EDGE_BOTTOM);
 -        s->mpvencdsp.draw_edges(s->current_picture.f->data[1], s->uvlinesize,
 +        s->mpvencdsp.draw_edges(s->current_picture.f->data[1],
 +                                s->current_picture.f->linesize[1],
                                  s->h_edge_pos >> hshift,
                                  s->v_edge_pos >> vshift,
                                  EDGE_WIDTH >> hshift,
                                  EDGE_WIDTH >> vshift,
                                  EDGE_TOP | EDGE_BOTTOM);
 -        s->mpvencdsp.draw_edges(s->current_picture.f->data[2], s->uvlinesize,
 +        s->mpvencdsp.draw_edges(s->current_picture.f->data[2],
 +                                s->current_picture.f->linesize[2],
                                  s->h_edge_pos >> hshift,
                                  s->v_edge_pos >> vshift,
                                  EDGE_WIDTH >> hshift,
      if (s->pict_type!= AV_PICTURE_TYPE_B)
          s->last_non_b_pict_type = s->pict_type;
  
 -    if (s->encoding) {
 -        /* release non-reference frames */
 -        for (i = 0; i < MAX_PICTURE_COUNT; i++) {
 -            if (!s->picture[i].reference)
 -                ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
 -        }
 -    }
 -
  #if FF_API_CODED_FRAME
  FF_DISABLE_DEPRECATION_WARNINGS
      av_frame_copy_props(s->avctx->coded_frame, s->current_picture.f);
@@@ -1741,7 -1570,7 +1739,7 @@@ static int frame_start(MpegEncContext *
      }
  
      if (s->dct_error_sum) {
 -        assert(s->avctx->noise_reduction && s->encoding);
 +        av_assert2(s->avctx->noise_reduction && s->encoding);
          update_noise_reduction(s);
      }
  
@@@ -1755,8 -1584,6 +1753,8 @@@ int ff_mpv_encode_picture(AVCodecContex
      int i, stuffing_count, ret;
      int context_count = s->slice_context_count;
  
 +    s->vbv_ignore_qmax = 0;
 +
      s->picture_in_gop_number++;
  
      if (load_input_picture(s, pic_arg) < 0)
  
      /* output? */
      if (s->new_picture.f->data[0]) {
 -        uint8_t *sd;
 -        if (!pkt->data &&
 -            (ret = ff_alloc_packet(pkt, s->mb_width*s->mb_height*MAX_MB_BYTES)) < 0)
 +        int growing_buffer = context_count == 1 && !pkt->data && !s->data_partitioning;
 +        int pkt_size = growing_buffer ? FFMAX(s->mb_width*s->mb_height*64+10000, avctx->internal->byte_buffer_size) - AV_INPUT_BUFFER_PADDING_SIZE
 +                                              :
 +                                              s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000;
 +        if ((ret = ff_alloc_packet2(avctx, pkt, pkt_size, 0)) < 0)
              return ret;
          if (s->mb_info) {
              s->mb_info_ptr = av_packet_new_side_data(pkt,
          if (ret < 0)
              return ret;
  vbv_retry:
 -        if (encode_picture(s, s->picture_number) < 0)
 +        ret = encode_picture(s, s->picture_number);
 +        if (growing_buffer) {
 +            av_assert0(s->pb.buf == avctx->internal->byte_buffer);
 +            pkt->data = s->pb.buf;
 +            pkt->size = avctx->internal->byte_buffer_size;
 +        }
 +        if (ret < 0)
              return -1;
  
          avctx->header_bits = s->header_bits;
  
          frame_end(s);
  
 -        sd = av_packet_new_side_data(pkt, AV_PKT_DATA_QUALITY_FACTOR,
 -                                     sizeof(int));
 -        if (!sd)
 -            return AVERROR(ENOMEM);
 -        *(int *)sd = s->current_picture.f->quality;
 -
          if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
              ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);
  
          if (avctx->rc_buffer_size) {
              RateControlContext *rcc = &s->rc_context;
 -            int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
 +            int max_size = FFMAX(rcc->buffer_index * avctx->rc_max_available_vbv_use, rcc->buffer_index - 500);
 +            int hq = (s->avctx->mb_decision == FF_MB_DECISION_RD || s->avctx->trellis);
 +            int min_step = hq ? 1 : (1<<(FF_LAMBDA_SHIFT + 7))/139;
  
              if (put_bits_count(&s->pb) > max_size &&
                  s->lambda < s->lmax) {
 -                s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
 +                s->next_lambda = FFMAX(s->lambda + min_step, s->lambda *
                                         (s->qscale + 1) / s->qscale);
                  if (s->adaptive_quant) {
                      int i;
                      for (i = 0; i < s->mb_height * s->mb_stride; i++)
                          s->lambda_table[i] =
 -                            FFMAX(s->lambda_table[i] + 1,
 +                            FFMAX(s->lambda_table[i] + min_step,
                                    s->lambda_table[i] * (s->qscale + 1) /
                                    s->qscale);
                  }
                      PutBitContext *pb = &s->thread_context[i]->pb;
                      init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
                  }
 +                s->vbv_ignore_qmax = 1;
 +                av_log(s->avctx, AV_LOG_VERBOSE, "reencoding frame due to VBV\n");
                  goto vbv_retry;
              }
  
 -            assert(s->avctx->rc_max_rate);
 +            av_assert0(s->avctx->rc_max_rate);
          }
  
          if (s->avctx->flags & AV_CODEC_FLAG_PASS1)
              ff_write_pass1_stats(s);
  
          for (i = 0; i < 4; i++) {
 -            s->current_picture_ptr->f->error[i] = s->current_picture.f->error[i];
 +            s->current_picture_ptr->f->error[i] =
 +            s->current_picture.f->error[i] =
 +                s->current_picture.error[i];
              avctx->error[i] += s->current_picture_ptr->f->error[i];
          }
 +        ff_side_data_set_encoder_stats(pkt, s->current_picture.f->quality,
 +                                       s->current_picture_ptr->f->error,
 +                                       (s->avctx->flags&AV_CODEC_FLAG_PSNR) ? 4 : 0,
 +                                       s->pict_type);
  
          if (s->avctx->flags & AV_CODEC_FLAG_PASS1)
              assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
          s->frame_bits  = put_bits_count(&s->pb);
  
          stuffing_count = ff_vbv_update(s, s->frame_bits);
 +        s->stuffing_bits = 8*stuffing_count;
          if (stuffing_count) {
              if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
                      stuffing_count + 50) {
  
              vbv_delay = FFMAX(vbv_delay, min_delay);
  
 -            assert(vbv_delay < 0xFFFF);
 +            av_assert0(vbv_delay < 0xFFFF);
  
              s->vbv_delay_ptr[0] &= 0xF8;
              s->vbv_delay_ptr[0] |= vbv_delay >> 13;
      } else {
          s->frame_bits = 0;
      }
 -    assert((s->frame_bits & 7) == 0);
 +
 +    /* release non-reference frames */
 +    for (i = 0; i < MAX_PICTURE_COUNT; i++) {
 +        if (!s->picture[i].reference)
 +            ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
 +    }
 +
 +    av_assert1((s->frame_bits & 7) == 0);
  
      pkt->size = s->frame_bits / 8;
      *got_packet = !!pkt->size;
@@@ -2099,17 -1906,15 +2097,17 @@@ static void get_visual_weight(int16_t *
  static av_always_inline void encode_mb_internal(MpegEncContext *s,
                                                  int motion_x, int motion_y,
                                                  int mb_block_height,
 +                                                int mb_block_width,
                                                  int mb_block_count)
  {
 -    int16_t weight[8][64];
 -    int16_t orig[8][64];
 +    int16_t weight[12][64];
 +    int16_t orig[12][64];
      const int mb_x = s->mb_x;
      const int mb_y = s->mb_y;
      int i;
 -    int skip_dct[8];
 +    int skip_dct[12];
      int dct_offset = s->linesize * 8; // default for progressive frames
 +    int uv_dct_offset = s->uvlinesize * 8;
      uint8_t *ptr_y, *ptr_cb, *ptr_cr;
      ptrdiff_t wrap_y, wrap_c;
  
      ptr_y  = s->new_picture.f->data[0] +
               (mb_y * 16 * wrap_y)              + mb_x * 16;
      ptr_cb = s->new_picture.f->data[1] +
 -             (mb_y * mb_block_height * wrap_c) + mb_x * 8;
 +             (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
      ptr_cr = s->new_picture.f->data[2] +
 -             (mb_y * mb_block_height * wrap_c) + mb_x * 8;
 +             (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
  
 -    if (mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) {
 -        uint8_t *ebuf = s->sc.edge_emu_buffer + 32;
 +    if((mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
 +        uint8_t *ebuf = s->sc.edge_emu_buffer + 36 * wrap_y;
 +        int cw = (s->width  + s->chroma_x_shift) >> s->chroma_x_shift;
 +        int ch = (s->height + s->chroma_y_shift) >> s->chroma_y_shift;
          s->vdsp.emulated_edge_mc(ebuf, ptr_y,
                                   wrap_y, wrap_y,
                                   16, 16, mb_x * 16, mb_y * 16,
                                   s->width, s->height);
          ptr_y = ebuf;
 -        s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb,
 +        s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y, ptr_cb,
                                   wrap_c, wrap_c,
 -                                 8, mb_block_height, mb_x * 8, mb_y * 8,
 -                                 s->width >> 1, s->height >> 1);
 -        ptr_cb = ebuf + 18 * wrap_y;
 -        s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr,
 +                                 mb_block_width, mb_block_height,
 +                                 mb_x * mb_block_width, mb_y * mb_block_height,
 +                                 cw, ch);
 +        ptr_cb = ebuf + 16 * wrap_y;
 +        s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y + 16, ptr_cr,
                                   wrap_c, wrap_c,
 -                                 8, mb_block_height, mb_x * 8, mb_y * 8,
 -                                 s->width >> 1, s->height >> 1);
 -        ptr_cr = ebuf + 18 * wrap_y + 8;
 +                                 mb_block_width, mb_block_height,
 +                                 mb_x * mb_block_width, mb_y * mb_block_height,
 +                                 cw, ch);
 +        ptr_cr = ebuf + 16 * wrap_y + 16;
      }
  
      if (s->mb_intra) {
                      s->interlaced_dct = 1;
  
                      dct_offset = wrap_y;
 +                    uv_dct_offset = wrap_c;
                      wrap_y <<= 1;
 -                    if (s->chroma_format == CHROMA_422)
 +                    if (s->chroma_format == CHROMA_422 ||
 +                        s->chroma_format == CHROMA_444)
                          wrap_c <<= 1;
                  }
              }
          } else {
              s->pdsp.get_pixels(s->block[4], ptr_cb, wrap_c);
              s->pdsp.get_pixels(s->block[5], ptr_cr, wrap_c);
 -            if (!s->chroma_y_shift) { /* 422 */
 -                s->pdsp.get_pixels(s->block[6],
 -                                   ptr_cb + (dct_offset >> 1), wrap_c);
 -                s->pdsp.get_pixels(s->block[7],
 -                                   ptr_cr + (dct_offset >> 1), wrap_c);
 +            if (!s->chroma_y_shift && s->chroma_x_shift) { /* 422 */
 +                s->pdsp.get_pixels(s->block[6], ptr_cb + uv_dct_offset, wrap_c);
 +                s->pdsp.get_pixels(s->block[7], ptr_cr + uv_dct_offset, wrap_c);
 +            } else if (!s->chroma_y_shift && !s->chroma_x_shift) { /* 444 */
 +                s->pdsp.get_pixels(s->block[ 6], ptr_cb + 8, wrap_c);
 +                s->pdsp.get_pixels(s->block[ 7], ptr_cr + 8, wrap_c);
 +                s->pdsp.get_pixels(s->block[ 8], ptr_cb + uv_dct_offset, wrap_c);
 +                s->pdsp.get_pixels(s->block[ 9], ptr_cr + uv_dct_offset, wrap_c);
 +                s->pdsp.get_pixels(s->block[10], ptr_cb + uv_dct_offset + 8, wrap_c);
 +                s->pdsp.get_pixels(s->block[11], ptr_cr + uv_dct_offset + 8, wrap_c);
              }
          }
      } else {
                      s->interlaced_dct = 1;
  
                      dct_offset = wrap_y;
 +                    uv_dct_offset = wrap_c;
                      wrap_y <<= 1;
                      if (s->chroma_format == CHROMA_422)
                          wrap_c <<= 1;
              s->pdsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
              s->pdsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
              if (!s->chroma_y_shift) { /* 422 */
 -                s->pdsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1),
 -                                    dest_cb + (dct_offset >> 1), wrap_c);
 -                s->pdsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1),
 -                                    dest_cr + (dct_offset >> 1), wrap_c);
 +                s->pdsp.diff_pixels(s->block[6], ptr_cb + uv_dct_offset,
 +                                    dest_cb + uv_dct_offset, wrap_c);
 +                s->pdsp.diff_pixels(s->block[7], ptr_cr + uv_dct_offset,
 +                                    dest_cr + uv_dct_offset, wrap_c);
              }
          }
          /* pre quantization */
              if (s->mecc.sad[1](NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 * s->qscale)
                  skip_dct[5] = 1;
              if (!s->chroma_y_shift) { /* 422 */
 -                if (s->mecc.sad[1](NULL, ptr_cb + (dct_offset >> 1),
 -                                   dest_cb + (dct_offset >> 1),
 +                if (s->mecc.sad[1](NULL, ptr_cb + uv_dct_offset,
 +                                   dest_cb + uv_dct_offset,
                                     wrap_c, 8) < 20 * s->qscale)
                      skip_dct[6] = 1;
 -                if (s->mecc.sad[1](NULL, ptr_cr + (dct_offset >> 1),
 -                                   dest_cr + (dct_offset >> 1),
 +                if (s->mecc.sad[1](NULL, ptr_cr + uv_dct_offset,
 +                                   dest_cr + uv_dct_offset,
                                     wrap_c, 8) < 20 * s->qscale)
                      skip_dct[7] = 1;
              }
              get_visual_weight(weight[5], ptr_cr                , wrap_c);
          if (!s->chroma_y_shift) { /* 422 */
              if (!skip_dct[6])
 -                get_visual_weight(weight[6], ptr_cb + (dct_offset >> 1),
 +                get_visual_weight(weight[6], ptr_cb + uv_dct_offset,
                                    wrap_c);
              if (!skip_dct[7])
 -                get_visual_weight(weight[7], ptr_cr + (dct_offset >> 1),
 +                get_visual_weight(weight[7], ptr_cr + uv_dct_offset,
                                    wrap_c);
          }
          memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
      }
  
      /* DCT & quantize */
 -    assert(s->out_format != FMT_MJPEG || s->qscale == 8);
 +    av_assert2(s->out_format != FMT_MJPEG || s->qscale == 8);
      {
          for (i = 0; i < mb_block_count; i++) {
              if (!skip_dct[i]) {
          s->block_last_index[5] = 0;
          s->block[4][0] =
          s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
 +        if (!s->chroma_y_shift) { /* 422 / 444 */
 +            for (i=6; i<12; i++) {
 +                s->block_last_index[i] = 0;
 +                s->block[i][0] = s->block[4][0];
 +            }
 +        }
      }
  
      // non c quantize code returns incorrect block_last_index FIXME
              ff_h263_encode_mb(s, s->block, motion_x, motion_y);
          break;
      case AV_CODEC_ID_MJPEG:
 +    case AV_CODEC_ID_AMV:
          if (CONFIG_MJPEG_ENCODER)
              ff_mjpeg_encode_mb(s, s->block);
          break;
      default:
 -        assert(0);
 +        av_assert1(0);
      }
  }
  
  static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
  {
 -    if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y,  8, 6);
 -    else                                encode_mb_internal(s, motion_x, motion_y, 16, 8);
 +    if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y,  8, 8, 6);
 +    else if (s->chroma_format == CHROMA_422) encode_mb_internal(s, motion_x, motion_y, 16, 8, 8);
 +    else encode_mb_internal(s, motion_x, motion_y, 16, 16, 12);
  }
  
  static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
@@@ -2571,7 -2356,7 +2569,7 @@@ static inline void encode_mb_hq(MpegEnc
          s->dest[0] = s->sc.rd_scratchpad;
          s->dest[1] = s->sc.rd_scratchpad + 16*s->linesize;
          s->dest[2] = s->sc.rd_scratchpad + 16*s->linesize + 8;
 -        assert(s->linesize >= 32); //FIXME
 +        av_assert0(s->linesize >= 32); //FIXME
      }
  
      encode_mb(s, motion_x, motion_y);
@@@ -2617,7 -2402,7 +2615,7 @@@ static int sse(MpegEncContext *s, uint8
          }
      }
  
 -    assert(acc>=0);
 +    av_assert2(acc>=0);
  
      return acc;
  }
@@@ -2667,8 -2452,6 +2665,8 @@@ static int pre_estimate_motion_thread(A
  static int estimate_motion_thread(AVCodecContext *c, void *arg){
      MpegEncContext *s= *(void**)arg;
  
 +    ff_check_alignment();
 +
      s->me.dia_size= s->avctx->dia_size;
      s->first_slice_line=1;
      for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
@@@ -2695,8 -2478,6 +2693,8 @@@ static int mb_var_thread(AVCodecContex
      MpegEncContext *s= *(void**)arg;
      int mb_x, mb_y;
  
 +    ff_check_alignment();
 +
      for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
          for(mb_x=0; mb_x < s->mb_width; mb_x++) {
              int xx = mb_x * 16;
@@@ -2724,7 -2505,7 +2722,7 @@@ static void write_slice_end(MpegEncCont
  
          ff_mpeg4_stuffing(&s->pb);
      }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
 -        ff_mjpeg_encode_stuffing(&s->pb);
 +        ff_mjpeg_encode_stuffing(s);
      }
  
      avpriv_align_put_bits(&s->pb);
@@@ -2777,35 -2558,6 +2775,35 @@@ static void update_mb_info(MpegEncConte
      write_mb_info(s);
  }
  
 +int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t size_increase)
 +{
 +    if (   s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < threshold
 +        && s->slice_context_count == 1
 +        && s->pb.buf == s->avctx->internal->byte_buffer) {
 +        int lastgob_pos = s->ptr_lastgob - s->pb.buf;
 +        int vbv_pos     = s->vbv_delay_ptr - s->pb.buf;
 +
 +        uint8_t *new_buffer = NULL;
 +        int new_buffer_size = 0;
 +
 +        av_fast_padded_malloc(&new_buffer, &new_buffer_size,
 +                              s->avctx->internal->byte_buffer_size + size_increase);
 +        if (!new_buffer)
 +            return AVERROR(ENOMEM);
 +
 +        memcpy(new_buffer, s->avctx->internal->byte_buffer, s->avctx->internal->byte_buffer_size);
 +        av_free(s->avctx->internal->byte_buffer);
 +        s->avctx->internal->byte_buffer      = new_buffer;
 +        s->avctx->internal->byte_buffer_size = new_buffer_size;
 +        rebase_put_bits(&s->pb, new_buffer, new_buffer_size);
 +        s->ptr_lastgob   = s->pb.buf + lastgob_pos;
 +        s->vbv_delay_ptr = s->pb.buf + vbv_pos;
 +    }
 +    if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < threshold)
 +        return AVERROR(EINVAL);
 +    return 0;
 +}
 +
  static int encode_thread(AVCodecContext *c, void *arg){
      MpegEncContext *s= *(void**)arg;
      int mb_x, mb_y, pdif = 0;
      uint8_t bit_buf_tex[2][MAX_MB_BYTES];
      PutBitContext pb[2], pb2[2], tex_pb[2];
  
 +    ff_check_alignment();
 +
      for(i=0; i<2; i++){
          init_put_bits(&pb    [i], bit_buf    [i], MAX_MB_BYTES);
          init_put_bits(&pb2   [i], bit_buf2   [i], MAX_MB_BYTES);
          /* note: quant matrix value (8) is implied here */
          s->last_dc[i] = 128 << s->intra_dc_precision;
  
 -        s->current_picture.f->error[i] = 0;
 +        s->current_picture.error[i] = 0;
 +    }
 +    if(s->codec_id==AV_CODEC_ID_AMV){
 +        s->last_dc[0] = 128*8/13;
 +        s->last_dc[1] = 128*8/14;
 +        s->last_dc[2] = 128*8/14;
      }
      s->mb_skip_run = 0;
      memset(s->last_mv, 0, sizeof(s->last_mv));
  //            int d;
              int dmin= INT_MAX;
              int dir;
 +            int size_increase =  s->avctx->internal->byte_buffer_size/4
 +                               + s->mb_width*MAX_MB_BYTES;
  
 +            ff_mpv_reallocate_putbitbuffer(s, MAX_MB_BYTES, size_increase);
              if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
                  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
                  return -1;
              if(s->data_partitioning){
                  if(   s->pb2   .buf_end - s->pb2   .buf - (put_bits_count(&s->    pb2)>>3) < MAX_MB_BYTES
                     || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
 -                    av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
 +                    av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
                      return -1;
                  }
              }
                  case AV_CODEC_ID_MPEG1VIDEO:
                      if(s->mb_skip_run) is_gob_start=0;
                      break;
 +                case AV_CODEC_ID_MJPEG:
 +                    if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
 +                    break;
                  }
  
                  if(is_gob_start){
                          }
                      }
  
 -                    assert((put_bits_count(&s->pb)&7) == 0);
 +                    av_assert2((put_bits_count(&s->pb)&7) == 0);
                      current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
  
                      if (s->error_rate && s->resync_mb_x + s->resync_mb_y > 0) {
                          int16_t ac[6][16];
                          const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
                          static const int dquant_tab[4]={-1,1,-2,2};
 +                        int storecoefs = s->mb_intra && s->dc_val[0];
  
 -                        assert(backup_s.dquant == 0);
 +                        av_assert2(backup_s.dquant == 0);
  
                          //FIXME intra
                          s->mv_dir= best_s.mv_dir;
                              if(qp < s->avctx->qmin || qp > s->avctx->qmax)
                                  continue;
                              backup_s.dquant= dquant;
 -                            if(s->mb_intra && s->dc_val[0]){
 +                            if(storecoefs){
                                  for(i=0; i<6; i++){
                                      dc[i]= s->dc_val[0][ s->block_index[i] ];
                                      memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
                              encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
                                           &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
                              if(best_s.qscale != qp){
 -                                if(s->mb_intra && s->dc_val[0]){
 +                                if(storecoefs){
                                      for(i=0; i<6; i++){
                                          s->dc_val[0][ s->block_index[i] ]= dc[i];
                                          memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
                  if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
                  if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
  
 -                s->current_picture.f->error[0] += sse(
 +                s->current_picture.error[0] += sse(
                      s, s->new_picture.f->data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
                      s->dest[0], w, h, s->linesize);
 -                s->current_picture.f->error[1] += sse(
 +                s->current_picture.error[1] += sse(
                      s, s->new_picture.f->data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*chr_h,
                      s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
 -                s->current_picture.f->error[2] += sse(
 +                s->current_picture.error[2] += sse(
                      s, s->new_picture.f->data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*chr_h,
                      s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
              }
@@@ -3469,9 -3207,9 +3467,9 @@@ static void merge_context_after_encode(
      MERGE(misc_bits);
      MERGE(er.error_count);
      MERGE(padding_bug_score);
 -    MERGE(current_picture.f->error[0]);
 -    MERGE(current_picture.f->error[1]);
 -    MERGE(current_picture.f->error[2]);
 +    MERGE(current_picture.error[0]);
 +    MERGE(current_picture.error[1]);
 +    MERGE(current_picture.error[2]);
  
      if(dst->avctx->noise_reduction){
          for(i=0; i<64; i++){
@@@ -3524,7 -3262,7 +3522,7 @@@ static int estimate_qp(MpegEncContext *
  
  /* must be called before writing the header */
  static void set_frame_distances(MpegEncContext * s){
 -    assert(s->current_picture_ptr->f->pts != AV_NOPTS_VALUE);
 +    av_assert1(s->current_picture_ptr->f->pts != AV_NOPTS_VALUE);
      s->time = s->current_picture_ptr->f->pts * s->avctx->time_base.num;
  
      if(s->pict_type==AV_PICTURE_TYPE_B){
@@@ -3580,13 -3318,6 +3578,13 @@@ static int encode_picture(MpegEncContex
          update_qscale(s);
      }
  
 +    if(s->codec_id != AV_CODEC_ID_AMV && s->codec_id != AV_CODEC_ID_MJPEG){
 +        if(s->q_chroma_intra_matrix   != s->q_intra_matrix  ) av_freep(&s->q_chroma_intra_matrix);
 +        if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
 +        s->q_chroma_intra_matrix   = s->q_intra_matrix;
 +        s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
 +    }
 +
      s->mb_intra=0; //for the rate distortion & bit compare functions
      for(i=1; i<context_count; i++){
          ret = ff_update_duplicate_context(s->thread_context[i], s);
          s->pict_type= AV_PICTURE_TYPE_I;
          for(i=0; i<s->mb_stride*s->mb_height; i++)
              s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
 -        ff_dlog(s, "Scene change detected, encoding as I Frame %d %d\n",
 +        if(s->msmpeg4_version >= 3)
 +            s->no_rounding=1;
 +        ff_dlog(s, "Scene change detected, encoding as I Frame %"PRId64" %"PRId64"\n",
                  s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
      }
  
          s->qscale= 3; //reduce clipping problems
  
      if (s->out_format == FMT_MJPEG) {
 +        const uint16_t *  luma_matrix = ff_mpeg1_default_intra_matrix;
 +        const uint16_t *chroma_matrix = ff_mpeg1_default_intra_matrix;
 +
 +        if (s->avctx->intra_matrix) {
 +            chroma_matrix =
 +            luma_matrix = s->avctx->intra_matrix;
 +        }
 +        if (s->avctx->chroma_intra_matrix)
 +            chroma_matrix = s->avctx->chroma_intra_matrix;
 +
          /* for mjpeg, we do include qscale in the matrix */
          for(i=1;i<64;i++){
              int j = s->idsp.idct_permutation[i];
  
 -            s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
 +            s->chroma_intra_matrix[j] = av_clip_uint8((chroma_matrix[i] * s->qscale) >> 3);
 +            s->       intra_matrix[j] = av_clip_uint8((  luma_matrix[i] * s->qscale) >> 3);
          }
          s->y_dc_scale_table=
          s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
 +        s->chroma_intra_matrix[0] =
          s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
          ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
                         s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
 +        ff_convert_matrix(s, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
 +                       s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
 +        s->qscale= 8;
 +    }
 +    if(s->codec_id == AV_CODEC_ID_AMV){
 +        static const uint8_t y[32]={13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13,13};
 +        static const uint8_t c[32]={14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14,14};
 +        for(i=1;i<64;i++){
 +            int j= s->idsp.idct_permutation[ff_zigzag_direct[i]];
 +
 +            s->intra_matrix[j] = sp5x_quant_table[5*2+0][i];
 +            s->chroma_intra_matrix[j] = sp5x_quant_table[5*2+1][i];
 +        }
 +        s->y_dc_scale_table= y;
 +        s->c_dc_scale_table= c;
 +        s->intra_matrix[0] = 13;
 +        s->chroma_intra_matrix[0] = 14;
 +        ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
 +                       s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
 +        ff_convert_matrix(s, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
 +                       s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
          s->qscale= 8;
      }
  
      if (s->current_picture.f->key_frame)
          s->picture_in_gop_number=0;
  
 +    s->mb_x = s->mb_y = 0;
      s->last_bits= put_bits_count(&s->pb);
      switch(s->out_format) {
      case FMT_MJPEG:
          if (CONFIG_MJPEG_ENCODER)
              ff_mjpeg_encode_picture_header(s->avctx, &s->pb, &s->intra_scantable,
 -                                           s->intra_matrix);
 +                                           s->intra_matrix, s->chroma_intra_matrix);
          break;
      case FMT_H261:
          if (CONFIG_H261_ENCODER)
              ff_mpeg1_encode_picture_header(s, picture_number);
          break;
      default:
 -        assert(0);
 +        av_assert0(0);
      }
      bits= put_bits_count(&s->pb);
      s->header_bits= bits - s->last_bits;
      }
      s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
      for(i=1; i<context_count; i++){
 +        if (s->pb.buf_end == s->thread_context[i]->pb.buf)
 +            set_put_bits_buffer_size(&s->pb, FFMIN(s->thread_context[i]->pb.buf_end - s->pb.buf, INT_MAX/8-32));
          merge_context_after_encode(s, s->thread_context[i]);
      }
      emms_c();
@@@ -3836,7 -3529,6 +3834,7 @@@ static int dct_quantize_trellis_c(MpegE
                                    int16_t *block, int n,
                                    int qscale, int *overflow){
      const int *qmat;
 +    const uint16_t *matrix;
      const uint8_t *scantable= s->intra_scantable.scantable;
      const uint8_t *perm_scantable= s->intra_scantable.permutated;
      int max=0;
      uint8_t * length;
      uint8_t * last_length;
      const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
 +    int mpeg2_qscale;
  
      s->fdsp.fdct(block);
  
      qmul= qscale*16;
      qadd= ((qscale-1)|1)*8;
  
 +    if (s->q_scale_type) mpeg2_qscale = ff_mpeg2_non_linear_qscale[qscale];
 +    else                 mpeg2_qscale = qscale << 1;
 +
      if (s->mb_intra) {
          int q;
          if (!s->h263_aic) {
          block[0] = (block[0] + (q >> 1)) / q;
          start_i = 1;
          last_non_zero = 0;
 -        qmat = s->q_intra_matrix[qscale];
 -        if(s->mpeg_quant || s->out_format == FMT_MPEG1)
 +        qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
 +        matrix = n < 4 ? s->intra_matrix : s->chroma_intra_matrix;
 +        if(s->mpeg_quant || s->out_format == FMT_MPEG1 || s->out_format == FMT_MJPEG)
              bias= 1<<(QMAT_SHIFT-1);
 -        length     = s->intra_ac_vlc_length;
 -        last_length= s->intra_ac_vlc_last_length;
 +
 +        if (n > 3 && s->intra_chroma_ac_vlc_length) {
 +            length     = s->intra_chroma_ac_vlc_length;
 +            last_length= s->intra_chroma_ac_vlc_last_length;
 +        } else {
 +            length     = s->intra_ac_vlc_length;
 +            last_length= s->intra_ac_vlc_last_length;
 +        }
      } else {
          start_i = 0;
          last_non_zero = -1;
          qmat = s->q_inter_matrix[qscale];
 +        matrix = s->inter_matrix;
          length     = s->inter_ac_vlc_length;
          last_length= s->inter_ac_vlc_last_length;
      }
  //                coeff[2][k]= -level+2;
              }
              coeff_count[i]= FFMIN(level, 2);
 -            assert(coeff_count[i]);
 +            av_assert2(coeff_count[i]);
              max |=level;
          }else{
              coeff[0][i]= (level>>31)|1;
              const int alevel= FFABS(level);
              int unquant_coeff;
  
 -            assert(level);
 +            av_assert2(level);
  
 -            if(s->out_format == FMT_H263){
 +            if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
                  unquant_coeff= alevel*qmul + qadd;
 +            } else if(s->out_format == FMT_MJPEG) {
 +                j = s->idsp.idct_permutation[scantable[i]];
 +                unquant_coeff = alevel * matrix[j] * 8;
              }else{ //MPEG1
                  j = s->idsp.idct_permutation[scantable[i]]; // FIXME: optimize
                  if(s->mb_intra){
 -                        unquant_coeff = (int)(  alevel  * qscale * s->intra_matrix[j]) >> 3;
 +                        unquant_coeff = (int)(  alevel  * mpeg2_qscale * matrix[j]) >> 4;
                          unquant_coeff =   (unquant_coeff - 1) | 1;
                  }else{
 -                        unquant_coeff = (((  alevel  << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
 +                        unquant_coeff = (((  alevel  << 1) + 1) * mpeg2_qscale * ((int) matrix[j])) >> 5;
                          unquant_coeff =   (unquant_coeff - 1) | 1;
                  }
                  unquant_coeff<<= 3;
                      }
                  }
  
 -                if(s->out_format == FMT_H263){
 +                if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
                      for(j=survivor_count-1; j>=0; j--){
                          int run= i - survivor[j];
                          int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
                      }
                  }
  
 -                if(s->out_format == FMT_H263){
 +                if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
                    for(j=survivor_count-1; j>=0; j--){
                          int run= i - survivor[j];
                          int score= distortion + score_tab[i-run];
          survivor[ survivor_count++ ]= i+1;
      }
  
 -    if(s->out_format != FMT_H263){
 +    if(s->out_format != FMT_H263 && s->out_format != FMT_H261){
          last_score= 256*256*256*120;
          for(i= survivor[0]; i<=last_non_zero + 1; i++){
              int score= score_tab[i];
              int alevel= FFABS(level);
              int unquant_coeff, score, distortion;
  
 -            if(s->out_format == FMT_H263){
 +            if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
                      unquant_coeff= (alevel*qmul + qadd)>>3;
              }else{ //MPEG1
 -                    unquant_coeff = (((  alevel  << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
 +                    unquant_coeff = (((  alevel  << 1) + 1) * mpeg2_qscale * ((int) matrix[0])) >> 5;
                      unquant_coeff =   (unquant_coeff - 1) | 1;
              }
              unquant_coeff = (unquant_coeff + 4) >> 3;
      }
  
      i= last_i;
 -    assert(last_level);
 +    av_assert2(last_level);
  
      block[ perm_scantable[last_non_zero] ]= last_level;
      i -= last_run + 1;
@@@ -4212,13 -3889,8 +4210,13 @@@ static int messed_sign=0
          start_i = 1;
  //        if(s->mpeg_quant || s->out_format == FMT_MPEG1)
  //            bias= 1<<(QMAT_SHIFT-1);
 -        length     = s->intra_ac_vlc_length;
 -        last_length= s->intra_ac_vlc_last_length;
 +        if (n > 3 && s->intra_chroma_ac_vlc_length) {
 +            length     = s->intra_chroma_ac_vlc_length;
 +            last_length= s->intra_chroma_ac_vlc_last_length;
 +        } else {
 +            length     = s->intra_ac_vlc_length;
 +            last_length= s->intra_ac_vlc_last_length;
 +        }
      } else {
          dc= 0;
          start_i = 0;
@@@ -4249,8 -3921,8 +4247,8 @@@ STOP_TIMER("memset rem[]")
          weight[i] = w;
  //        w=weight[i] = (63*qns + (w/2)) / w;
  
 -        assert(w>0);
 -        assert(w<(1<<6));
 +        av_assert2(w>0);
 +        av_assert2(w<(1<<6));
          sum += w*w;
      }
      lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
@@@ -4316,7 -3988,7 +4314,7 @@@ STOP_TIMER("dct")
              const int level= block[0];
              int change, old_coeff;
  
 -            assert(s->mb_intra);
 +            av_assert2(s->mb_intra);
  
              old_coeff= q*level;
  
              }else{
                  old_coeff=0;
                  run2--;
 -                assert(run2>=0 || i >= last_non_zero );
 +                av_assert2(run2>=0 || i >= last_non_zero );
              }
  
              for(change=-1; change<=1; change+=2){
                                           - last_length[UNI_AC_ENC_INDEX(run, level+64)];
                          }
                      }else{
 -                        assert(FFABS(new_level)==1);
 +                        av_assert2(FFABS(new_level)==1);
  
                          if(analyze_gradient){
                              int g= d1[ scantable[i] ];
                      }
                  }else{
                      new_coeff=0;
 -                    assert(FFABS(level)==1);
 +                    av_assert2(FFABS(level)==1);
  
                      if(i < last_non_zero){
                          int next_i= i + run2 + 1;
                  score *= lambda;
  
                  unquant_change= new_coeff - old_coeff;
 -                assert((score < 100*lambda && score > -100*lambda) || lambda==0);
 +                av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
  
                  score += s->mpvencdsp.try_8x8basis(rem, weight, basis[j],
                                                     unquant_change);
@@@ -4482,7 -4154,7 +4480,7 @@@ STOP_TIMER("iterative step")
  
              if(best_coeff > last_non_zero){
                  last_non_zero= best_coeff;
 -                assert(block[j]);
 +                av_assert2(block[j]);
  #ifdef REFINE_STATS
  after_last++;
  #endif
@@@ -4510,7 -4182,7 +4508,7 @@@ if(block[j])
  #ifdef REFINE_STATS
  count++;
  if(256*256*256*64 % count == 0){
 -    printf("after_last:%d to_zero:%d from_zero:%d raise:%d lower:%d sign:%d xyp:%d/%d/%d\n", after_last, to_zero, from_zero, raise, lower, messed_sign, s->mb_x, s->mb_y, s->picture_number);
 +    av_log(s->avctx, AV_LOG_DEBUG, "after_last:%d to_zero:%d from_zero:%d raise:%d lower:%d sign:%d xyp:%d/%d/%d\n", after_last, to_zero, from_zero, raise, lower, messed_sign, s->mb_x, s->mb_y, s->picture_number);
  }
  #endif
              run=0;
@@@ -4609,13 -4281,13 +4607,13 @@@ int ff_dct_quantize_c(MpegEncContext *s
          block[0] = (block[0] + (q >> 1)) / q;
          start_i = 1;
          last_non_zero = 0;
 -        qmat = s->q_intra_matrix[qscale];
 -        bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
 +        qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
 +        bias= s->intra_quant_bias*(1<<(QMAT_SHIFT - QUANT_BIAS_SHIFT));
      } else {
          start_i = 0;
          last_non_zero = -1;
          qmat = s->q_inter_matrix[qscale];
 -        bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
 +        bias= s->inter_quant_bias*(1<<(QMAT_SHIFT - QUANT_BIAS_SHIFT));
      }
      threshold1= (1<<QMAT_SHIFT) - bias - 1;
      threshold2= (threshold1<<1);