git.sesse.net Git - ffmpeg/blob - libavcodec/mpegvideo_enc.c

   1 /*
   2  * The simplest mpeg encoder (well, it was the simplest!)
   3  * Copyright (c) 2000,2001 Fabrice Bellard
   4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   5  *
   6  * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
   7  *
   8  * This file is part of FFmpeg.
   9  *
  10  * FFmpeg is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * FFmpeg is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with FFmpeg; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  23  */
  24
  25 /*
  26  * non linear quantizers with large QPs and VBV with restrictive qmin fixes sponsored by NOA GmbH
  27  */
  28
  29 /**
  30  * @file
  31  * The simplest mpeg encoder (well, it was the simplest!).
  32  */
  33
  34 #include <stdint.h>
  35
  36 #include "libavutil/internal.h"
  37 #include "libavutil/intmath.h"
  38 #include "libavutil/mathematics.h"
  39 #include "libavutil/mem_internal.h"
  40 #include "libavutil/pixdesc.h"
  41 #include "libavutil/opt.h"
  42 #include "libavutil/thread.h"
  43 #include "avcodec.h"
  44 #include "dct.h"
  45 #include "idctdsp.h"
  46 #include "mpeg12.h"
  47 #include "mpegvideo.h"
  48 #include "mpegvideodata.h"
  49 #include "h261.h"
  50 #include "h263.h"
  51 #include "h263data.h"
  52 #include "mjpegenc_common.h"
  53 #include "mathops.h"
  54 #include "mpegutils.h"
  55 #include "mjpegenc.h"
  56 #include "speedhqenc.h"
  57 #include "msmpeg4.h"
  58 #include "pixblockdsp.h"
  59 #include "qpeldsp.h"
  60 #include "faandct.h"
  61 #include "thread.h"
  62 #include "aandcttab.h"
  63 #include "flv.h"
  64 #include "mpeg4video.h"
  65 #include "internal.h"
  66 #include "bytestream.h"
  67 #include "wmv2.h"
  68 #include "rv10.h"
  69 #include "packet_internal.h"
  70 #include <limits.h>
  71 #include "sp5x.h"
  72
  73 #define QUANT_BIAS_SHIFT 8
  74
  75 #define QMAT_SHIFT_MMX 16
  76 #define QMAT_SHIFT 21
  77
  78 static int encode_picture(MpegEncContext *s, int picture_number);
  79 static int dct_quantize_refine(MpegEncContext *s, int16_t *block, int16_t *weight, int16_t *orig, int n, int qscale);
  80 static int sse_mb(MpegEncContext *s);
  81 static void denoise_dct_c(MpegEncContext *s, int16_t *block);
  82 static int dct_quantize_trellis_c(MpegEncContext *s, int16_t *block, int n, int qscale, int *overflow);
  83
  84 static uint8_t default_mv_penalty[MAX_FCODE + 1][MAX_DMV * 2 + 1];
  85 static uint8_t default_fcode_tab[MAX_MV * 2 + 1];
  86
  87 const AVOption ff_mpv_generic_options[] = {
  88     FF_MPV_COMMON_OPTS
  89     { NULL },
  90 };
  91
  92 void ff_convert_matrix(MpegEncContext *s, int (*qmat)[64],
  93                        uint16_t (*qmat16)[2][64],
  94                        const uint16_t *quant_matrix,
  95                        int bias, int qmin, int qmax, int intra)
  96 {
  97     FDCTDSPContext *fdsp = &s->fdsp;
  98     int qscale;
  99     int shift = 0;
 100
 101     for (qscale = qmin; qscale <= qmax; qscale++) {
 102         int i;
 103         int qscale2;
 104
 105         if (s->q_scale_type) qscale2 = ff_mpeg2_non_linear_qscale[qscale];
 106         else                 qscale2 = qscale << 1;
 107
 108         if (fdsp->fdct == ff_jpeg_fdct_islow_8  ||
 109 #if CONFIG_FAANDCT
 110             fdsp->fdct == ff_faandct            ||
 111 #endif /* CONFIG_FAANDCT */
 112             fdsp->fdct == ff_jpeg_fdct_islow_10) {
 113             for (i = 0; i < 64; i++) {
 114                 const int j = s->idsp.idct_permutation[i];
 115                 int64_t den = (int64_t) qscale2 * quant_matrix[j];
 116                 /* 16 <= qscale * quant_matrix[i] <= 7905
 117                  * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
 118                  *             19952 <=              x  <= 249205026
 119                  * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
 120                  *           3444240 >= (1 << 36) / (x) >= 275 */
 121
 122                 qmat[qscale][i] = (int)((UINT64_C(2) << QMAT_SHIFT) / den);
 123             }
 124         } else if (fdsp->fdct == ff_fdct_ifast) {
 125             for (i = 0; i < 64; i++) {
 126                 const int j = s->idsp.idct_permutation[i];
 127                 int64_t den = ff_aanscales[i] * (int64_t) qscale2 * quant_matrix[j];
 128                 /* 16 <= qscale * quant_matrix[i] <= 7905
 129                  * Assume x = ff_aanscales[i] * qscale * quant_matrix[i]
 130                  *             19952 <=              x  <= 249205026
 131                  * (1 << 36) / 19952 >= (1 << 36) / (x) >= (1 << 36) / 249205026
 132                  *           3444240 >= (1 << 36) / (x) >= 275 */
 133
 134                 qmat[qscale][i] = (int)((UINT64_C(2) << (QMAT_SHIFT + 14)) / den);
 135             }
 136         } else {
 137             for (i = 0; i < 64; i++) {
 138                 const int j = s->idsp.idct_permutation[i];
 139                 int64_t den = (int64_t) qscale2 * quant_matrix[j];
 140                 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
 141                  * Assume x = qscale * quant_matrix[i]
 142                  * So             16 <=              x  <= 7905
 143                  * so (1 << 19) / 16 >= (1 << 19) / (x) >= (1 << 19) / 7905
 144                  * so          32768 >= (1 << 19) / (x) >= 67 */
 145                 qmat[qscale][i] = (int)((UINT64_C(2) << QMAT_SHIFT) / den);
 146                 //qmat  [qscale][i] = (1 << QMAT_SHIFT_MMX) /
 147                 //                    (qscale * quant_matrix[i]);
 148                 qmat16[qscale][0][i] = (2 << QMAT_SHIFT_MMX) / den;
 149
 150                 if (qmat16[qscale][0][i] == 0 ||
 151                     qmat16[qscale][0][i] == 128 * 256)
 152                     qmat16[qscale][0][i] = 128 * 256 - 1;
 153                 qmat16[qscale][1][i] =
 154                     ROUNDED_DIV(bias * (1<<(16 - QUANT_BIAS_SHIFT)),
 155                                 qmat16[qscale][0][i]);
 156             }
 157         }
 158
 159         for (i = intra; i < 64; i++) {
 160             int64_t max = 8191;
 161             if (fdsp->fdct == ff_fdct_ifast) {
 162                 max = (8191LL * ff_aanscales[i]) >> 14;
 163             }
 164             while (((max * qmat[qscale][i]) >> shift) > INT_MAX) {
 165                 shift++;
 166             }
 167         }
 168     }
 169     if (shift) {
 170         av_log(s->avctx, AV_LOG_INFO,
 171                "Warning, QMAT_SHIFT is larger than %d, overflows possible\n",
 172                QMAT_SHIFT - shift);
 173     }
 174 }
 175
 176 static inline void update_qscale(MpegEncContext *s)
 177 {
 178     if (s->q_scale_type == 1 && 0) {
 179         int i;
 180         int bestdiff=INT_MAX;
 181         int best = 1;
 182
 183         for (i = 0 ; i<FF_ARRAY_ELEMS(ff_mpeg2_non_linear_qscale); i++) {
 184             int diff = FFABS((ff_mpeg2_non_linear_qscale[i]<<(FF_LAMBDA_SHIFT + 6)) - (int)s->lambda * 139);
 185             if (ff_mpeg2_non_linear_qscale[i] < s->avctx->qmin ||
 186                 (ff_mpeg2_non_linear_qscale[i] > s->avctx->qmax && !s->vbv_ignore_qmax))
 187                 continue;
 188             if (diff < bestdiff) {
 189                 bestdiff = diff;
 190                 best = i;
 191             }
 192         }
 193         s->qscale = best;
 194     } else {
 195         s->qscale = (s->lambda * 139 + FF_LAMBDA_SCALE * 64) >>
 196                     (FF_LAMBDA_SHIFT + 7);
 197         s->qscale = av_clip(s->qscale, s->avctx->qmin, s->vbv_ignore_qmax ? 31 : s->avctx->qmax);
 198     }
 199
 200     s->lambda2 = (s->lambda * s->lambda + FF_LAMBDA_SCALE / 2) >>
 201                  FF_LAMBDA_SHIFT;
 202 }
 203
 204 void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
 205 {
 206     int i;
 207
 208     if (matrix) {
 209         put_bits(pb, 1, 1);
 210         for (i = 0; i < 64; i++) {
 211             put_bits(pb, 8, matrix[ff_zigzag_direct[i]]);
 212         }
 213     } else
 214         put_bits(pb, 1, 0);
 215 }
 216
 217 /**
 218  * init s->current_picture.qscale_table from s->lambda_table
 219  */
 220 void ff_init_qscale_tab(MpegEncContext *s)
 221 {
 222     int8_t * const qscale_table = s->current_picture.qscale_table;
 223     int i;
 224
 225     for (i = 0; i < s->mb_num; i++) {
 226         unsigned int lam = s->lambda_table[s->mb_index2xy[i]];
 227         int qp = (lam * 139 + FF_LAMBDA_SCALE * 64) >> (FF_LAMBDA_SHIFT + 7);
 228         qscale_table[s->mb_index2xy[i]] = av_clip(qp, s->avctx->qmin,
 229                                                   s->avctx->qmax);
 230     }
 231 }
 232
 233 static void update_duplicate_context_after_me(MpegEncContext *dst,
 234                                               MpegEncContext *src)
 235 {
 236 #define COPY(a) dst->a= src->a
 237     COPY(pict_type);
 238     COPY(current_picture);
 239     COPY(f_code);
 240     COPY(b_code);
 241     COPY(qscale);
 242     COPY(lambda);
 243     COPY(lambda2);
 244     COPY(picture_in_gop_number);
 245     COPY(gop_picture_number);
 246     COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
 247     COPY(progressive_frame);    // FIXME don't set in encode_header
 248     COPY(partitioned_frame);    // FIXME don't set in encode_header
 249 #undef COPY
 250 }
 251
 252 static void mpv_encode_init_static(void)
 253 {
 254    for (int i = -16; i < 16; i++)
 255         default_fcode_tab[i + MAX_MV] = 1;
 256 }
 257
 258 /**
 259  * Set the given MpegEncContext to defaults for encoding.
 260  * the changed fields will not depend upon the prior state of the MpegEncContext.
 261  */
 262 static void mpv_encode_defaults(MpegEncContext *s)
 263 {
 264     static AVOnce init_static_once = AV_ONCE_INIT;
 265
 266     ff_mpv_common_defaults(s);
 267
 268     ff_thread_once(&init_static_once, mpv_encode_init_static);
 269
 270     s->me.mv_penalty = default_mv_penalty;
 271     s->fcode_tab     = default_fcode_tab;
 272
 273     s->input_picture_number  = 0;
 274     s->picture_in_gop_number = 0;
 275 }
 276
 277 av_cold int ff_dct_encode_init(MpegEncContext *s)
 278 {
 279     if (ARCH_X86)
 280         ff_dct_encode_init_x86(s);
 281
 282     if (CONFIG_H263_ENCODER)
 283         ff_h263dsp_init(&s->h263dsp);
 284     if (!s->dct_quantize)
 285         s->dct_quantize = ff_dct_quantize_c;
 286     if (!s->denoise_dct)
 287         s->denoise_dct  = denoise_dct_c;
 288     s->fast_dct_quantize = s->dct_quantize;
 289     if (s->avctx->trellis)
 290         s->dct_quantize  = dct_quantize_trellis_c;
 291
 292     return 0;
 293 }
 294
 295 /* init video encoder */
 296 av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
 297 {
 298     MpegEncContext *s = avctx->priv_data;
 299     AVCPBProperties *cpb_props;
 300     int i, ret, format_supported;
 301
 302     mpv_encode_defaults(s);
 303
 304     switch (avctx->codec_id) {
 305     case AV_CODEC_ID_MPEG2VIDEO:
 306         if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
 307             avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
 308             av_log(avctx, AV_LOG_ERROR,
 309                    "only YUV420 and YUV422 are supported\n");
 310             return AVERROR(EINVAL);
 311         }
 312         break;
 313     case AV_CODEC_ID_MJPEG:
 314     case AV_CODEC_ID_AMV:
 315         format_supported = 0;
 316         /* JPEG color space */
 317         if (avctx->pix_fmt == AV_PIX_FMT_YUVJ420P ||
 318             avctx->pix_fmt == AV_PIX_FMT_YUVJ422P ||
 319             avctx->pix_fmt == AV_PIX_FMT_YUVJ444P ||
 320             (avctx->color_range == AVCOL_RANGE_JPEG &&
 321              (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
 322               avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
 323               avctx->pix_fmt == AV_PIX_FMT_YUV444P)))
 324             format_supported = 1;
 325         /* MPEG color space */
 326         else if (avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL &&
 327                  (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
 328                   avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
 329                   avctx->pix_fmt == AV_PIX_FMT_YUV444P))
 330             format_supported = 1;
 331
 332         if (!format_supported) {
 333             av_log(avctx, AV_LOG_ERROR, "colorspace not supported in jpeg\n");
 334             return AVERROR(EINVAL);
 335         }
 336         break;
 337     case AV_CODEC_ID_SPEEDHQ:
 338         if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
 339             avctx->pix_fmt != AV_PIX_FMT_YUV422P &&
 340             avctx->pix_fmt != AV_PIX_FMT_YUV444P) {
 341             av_log(avctx, AV_LOG_ERROR,
 342                    "only YUV420/YUV422/YUV444 are supported (no alpha support yet)\n");
 343             return AVERROR(EINVAL);
 344         }
 345         break;
 346     default:
 347         if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
 348             av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
 349             return AVERROR(EINVAL);
 350         }
 351     }
 352
 353     switch (avctx->pix_fmt) {
 354     case AV_PIX_FMT_YUVJ444P:
 355     case AV_PIX_FMT_YUV444P:
 356         s->chroma_format = CHROMA_444;
 357         break;
 358     case AV_PIX_FMT_YUVJ422P:
 359     case AV_PIX_FMT_YUV422P:
 360         s->chroma_format = CHROMA_422;
 361         break;
 362     case AV_PIX_FMT_YUVJ420P:
 363     case AV_PIX_FMT_YUV420P:
 364     default:
 365         s->chroma_format = CHROMA_420;
 366         break;
 367     }
 368
 369     avctx->bits_per_raw_sample = av_clip(avctx->bits_per_raw_sample, 0, 8);
 370
 371 #if FF_API_PRIVATE_OPT
 372 FF_DISABLE_DEPRECATION_WARNINGS
 373     if (avctx->rtp_payload_size)
 374         s->rtp_payload_size = avctx->rtp_payload_size;
 375     if (avctx->me_penalty_compensation)
 376         s->me_penalty_compensation = avctx->me_penalty_compensation;
 377     if (avctx->pre_me)
 378         s->me_pre = avctx->pre_me;
 379 FF_ENABLE_DEPRECATION_WARNINGS
 380 #endif
 381
 382     s->bit_rate = avctx->bit_rate;
 383     s->width    = avctx->width;
 384     s->height   = avctx->height;
 385     if (avctx->gop_size > 600 &&
 386         avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
 387         av_log(avctx, AV_LOG_WARNING,
 388                "keyframe interval too large!, reducing it from %d to %d\n",
 389                avctx->gop_size, 600);
 390         avctx->gop_size = 600;
 391     }
 392     s->gop_size     = avctx->gop_size;
 393     s->avctx        = avctx;
 394     if (avctx->max_b_frames > MAX_B_FRAMES) {
 395         av_log(avctx, AV_LOG_ERROR, "Too many B-frames requested, maximum "
 396                "is %d.\n", MAX_B_FRAMES);
 397         avctx->max_b_frames = MAX_B_FRAMES;
 398     }
 399     s->max_b_frames = avctx->max_b_frames;
 400     s->codec_id     = avctx->codec->id;
 401     s->strict_std_compliance = avctx->strict_std_compliance;
 402     s->quarter_sample     = (avctx->flags & AV_CODEC_FLAG_QPEL) != 0;
 403     s->rtp_mode           = !!s->rtp_payload_size;
 404     s->intra_dc_precision = avctx->intra_dc_precision;
 405
 406     // workaround some differences between how applications specify dc precision
 407     if (s->intra_dc_precision < 0) {
 408         s->intra_dc_precision += 8;
 409     } else if (s->intra_dc_precision >= 8)
 410         s->intra_dc_precision -= 8;
 411
 412     if (s->intra_dc_precision < 0) {
 413         av_log(avctx, AV_LOG_ERROR,
 414                 "intra dc precision must be positive, note some applications use"
 415                 " 0 and some 8 as base meaning 8bit, the value must not be smaller than that\n");
 416         return AVERROR(EINVAL);
 417     }
 418
 419     if (avctx->codec_id == AV_CODEC_ID_AMV || (avctx->active_thread_type & FF_THREAD_SLICE))
 420         s->huffman = 0;
 421
 422     if (s->intra_dc_precision > (avctx->codec_id == AV_CODEC_ID_MPEG2VIDEO ? 3 : 0)) {
 423         av_log(avctx, AV_LOG_ERROR, "intra dc precision too large\n");
 424         return AVERROR(EINVAL);
 425     }
 426     s->user_specified_pts = AV_NOPTS_VALUE;
 427
 428     if (s->gop_size <= 1) {
 429         s->intra_only = 1;
 430         s->gop_size   = 12;
 431     } else {
 432         s->intra_only = 0;
 433     }
 434
 435     /* Fixed QSCALE */
 436     s->fixed_qscale = !!(avctx->flags & AV_CODEC_FLAG_QSCALE);
 437
 438     s->adaptive_quant = (avctx->lumi_masking ||
 439                          avctx->dark_masking ||
 440                          avctx->temporal_cplx_masking ||
 441                          avctx->spatial_cplx_masking  ||
 442                          avctx->p_masking      ||
 443                          s->border_masking ||
 444                          (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
 445                         !s->fixed_qscale;
 446
 447     s->loop_filter = !!(avctx->flags & AV_CODEC_FLAG_LOOP_FILTER);
 448
 449     if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
 450         switch(avctx->codec_id) {
 451         case AV_CODEC_ID_MPEG1VIDEO:
 452         case AV_CODEC_ID_MPEG2VIDEO:
 453             avctx->rc_buffer_size = FFMAX(avctx->rc_max_rate, 15000000) * 112LL / 15000000 * 16384;
 454             break;
 455         case AV_CODEC_ID_MPEG4:
 456         case AV_CODEC_ID_MSMPEG4V1:
 457         case AV_CODEC_ID_MSMPEG4V2:
 458         case AV_CODEC_ID_MSMPEG4V3:
 459             if       (avctx->rc_max_rate >= 15000000) {
 460                 avctx->rc_buffer_size = 320 + (avctx->rc_max_rate - 15000000LL) * (760-320) / (38400000 - 15000000);
 461             } else if(avctx->rc_max_rate >=  2000000) {
 462                 avctx->rc_buffer_size =  80 + (avctx->rc_max_rate -  2000000LL) * (320- 80) / (15000000 -  2000000);
 463             } else if(avctx->rc_max_rate >=   384000) {
 464                 avctx->rc_buffer_size =  40 + (avctx->rc_max_rate -   384000LL) * ( 80- 40) / ( 2000000 -   384000);
 465             } else
 466                 avctx->rc_buffer_size = 40;
 467             avctx->rc_buffer_size *= 16384;
 468             break;
 469         }
 470         if (avctx->rc_buffer_size) {
 471             av_log(avctx, AV_LOG_INFO, "Automatically choosing VBV buffer size of %d kbyte\n", avctx->rc_buffer_size/8192);
 472         }
 473     }
 474
 475     if ((!avctx->rc_max_rate) != (!avctx->rc_buffer_size)) {
 476         av_log(avctx, AV_LOG_ERROR, "Either both buffer size and max rate or neither must be specified\n");
 477         return AVERROR(EINVAL);
 478     }
 479
 480     if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
 481         av_log(avctx, AV_LOG_INFO,
 482                "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
 483     }
 484
 485     if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
 486         av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
 487         return AVERROR(EINVAL);
 488     }
 489
 490     if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
 491         av_log(avctx, AV_LOG_ERROR, "bitrate above max bitrate\n");
 492         return AVERROR(EINVAL);
 493     }
 494
 495     if (avctx->rc_max_rate &&
 496         avctx->rc_max_rate == avctx->bit_rate &&
 497         avctx->rc_max_rate != avctx->rc_min_rate) {
 498         av_log(avctx, AV_LOG_INFO,
 499                "impossible bitrate constraints, this will fail\n");
 500     }
 501
 502     if (avctx->rc_buffer_size &&
 503         avctx->bit_rate * (int64_t)avctx->time_base.num >
 504             avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
 505         av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
 506         return AVERROR(EINVAL);
 507     }
 508
 509     if (!s->fixed_qscale &&
 510         avctx->bit_rate * av_q2d(avctx->time_base) >
 511             avctx->bit_rate_tolerance) {
 512         av_log(avctx, AV_LOG_WARNING,
 513                "bitrate tolerance %d too small for bitrate %"PRId64", overriding\n", avctx->bit_rate_tolerance, avctx->bit_rate);
 514         avctx->bit_rate_tolerance = 5 * avctx->bit_rate * av_q2d(avctx->time_base);
 515     }
 516
 517     if (avctx->rc_max_rate &&
 518         avctx->rc_min_rate == avctx->rc_max_rate &&
 519         (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
 520          s->codec_id == AV_CODEC_ID_MPEG2VIDEO) &&
 521         90000LL * (avctx->rc_buffer_size - 1) >
 522             avctx->rc_max_rate * 0xFFFFLL) {
 523         av_log(avctx, AV_LOG_INFO,
 524                "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
 525                "specified vbv buffer is too large for the given bitrate!\n");
 526     }
 527
 528     if ((avctx->flags & AV_CODEC_FLAG_4MV) && s->codec_id != AV_CODEC_ID_MPEG4 &&
 529         s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P &&
 530         s->codec_id != AV_CODEC_ID_FLV1) {
 531         av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
 532         return AVERROR(EINVAL);
 533     }
 534
 535     if (s->obmc && avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
 536         av_log(avctx, AV_LOG_ERROR,
 537                "OBMC is only supported with simple mb decision\n");
 538         return AVERROR(EINVAL);
 539     }
 540
 541     if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
 542         av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
 543         return AVERROR(EINVAL);
 544     }
 545
 546     if (s->max_b_frames                    &&
 547         s->codec_id != AV_CODEC_ID_MPEG4      &&
 548         s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
 549         s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
 550         av_log(avctx, AV_LOG_ERROR, "B-frames not supported by codec\n");
 551         return AVERROR(EINVAL);
 552     }
 553     if (s->max_b_frames < 0) {
 554         av_log(avctx, AV_LOG_ERROR,
 555                "max b frames must be 0 or positive for mpegvideo based encoders\n");
 556         return AVERROR(EINVAL);
 557     }
 558
 559     if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
 560          s->codec_id == AV_CODEC_ID_H263  ||
 561          s->codec_id == AV_CODEC_ID_H263P) &&
 562         (avctx->sample_aspect_ratio.num > 255 ||
 563          avctx->sample_aspect_ratio.den > 255)) {
 564         av_log(avctx, AV_LOG_WARNING,
 565                "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
 566                avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
 567         av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
 568                    avctx->sample_aspect_ratio.num,  avctx->sample_aspect_ratio.den, 255);
 569     }
 570
 571     if ((s->codec_id == AV_CODEC_ID_H263  ||
 572          s->codec_id == AV_CODEC_ID_H263P) &&
 573         (avctx->width  > 2048 ||
 574          avctx->height > 1152 )) {
 575         av_log(avctx, AV_LOG_ERROR, "H.263 does not support resolutions above 2048x1152\n");
 576         return AVERROR(EINVAL);
 577     }
 578     if ((s->codec_id == AV_CODEC_ID_H263  ||
 579          s->codec_id == AV_CODEC_ID_H263P) &&
 580         ((avctx->width &3) ||
 581          (avctx->height&3) )) {
 582         av_log(avctx, AV_LOG_ERROR, "w/h must be a multiple of 4\n");
 583         return AVERROR(EINVAL);
 584     }
 585
 586     if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO &&
 587         (avctx->width  > 4095 ||
 588          avctx->height > 4095 )) {
 589         av_log(avctx, AV_LOG_ERROR, "MPEG-1 does not support resolutions above 4095x4095\n");
 590         return AVERROR(EINVAL);
 591     }
 592
 593     if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO &&
 594         (avctx->width  > 16383 ||
 595          avctx->height > 16383 )) {
 596         av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support resolutions above 16383x16383\n");
 597         return AVERROR(EINVAL);
 598     }
 599
 600     if (s->codec_id == AV_CODEC_ID_RV10 &&
 601         (avctx->width &15 ||
 602          avctx->height&15 )) {
 603         av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 16\n");
 604         return AVERROR(EINVAL);
 605     }
 606
 607     if (s->codec_id == AV_CODEC_ID_RV20 &&
 608         (avctx->width &3 ||
 609          avctx->height&3 )) {
 610         av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 4\n");
 611         return AVERROR(EINVAL);
 612     }
 613
 614     if ((s->codec_id == AV_CODEC_ID_WMV1 ||
 615          s->codec_id == AV_CODEC_ID_WMV2) &&
 616          avctx->width & 1) {
 617         av_log(avctx, AV_LOG_ERROR, "width must be multiple of 2\n");
 618         return AVERROR(EINVAL);
 619     }
 620
 621     if ((avctx->flags & (AV_CODEC_FLAG_INTERLACED_DCT | AV_CODEC_FLAG_INTERLACED_ME)) &&
 622         s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
 623         av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
 624         return AVERROR(EINVAL);
 625     }
 626
 627 #if FF_API_PRIVATE_OPT
 628     FF_DISABLE_DEPRECATION_WARNINGS
 629     if (avctx->mpeg_quant)
 630         s->mpeg_quant = 1;
 631     FF_ENABLE_DEPRECATION_WARNINGS
 632 #endif
 633
 634     // FIXME mpeg2 uses that too
 635     if (s->mpeg_quant && (   s->codec_id != AV_CODEC_ID_MPEG4
 636                           && s->codec_id != AV_CODEC_ID_MPEG2VIDEO)) {
 637         av_log(avctx, AV_LOG_ERROR,
 638                "mpeg2 style quantization not supported by codec\n");
 639         return AVERROR(EINVAL);
 640     }
 641
 642     if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
 643         av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
 644         return AVERROR(EINVAL);
 645     }
 646
 647     if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
 648         avctx->mb_decision != FF_MB_DECISION_RD) {
 649         av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
 650         return AVERROR(EINVAL);
 651     }
 652
 653     if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
 654             (s->codec_id == AV_CODEC_ID_AMV ||
 655              s->codec_id == AV_CODEC_ID_MJPEG)) {
 656         // Used to produce garbage with MJPEG.
 657         av_log(avctx, AV_LOG_ERROR,
 658                "QP RD is no longer compatible with MJPEG or AMV\n");
 659         return AVERROR(EINVAL);
 660     }
 661
 662 #if FF_API_PRIVATE_OPT
 663 FF_DISABLE_DEPRECATION_WARNINGS
 664     if (avctx->scenechange_threshold)
 665         s->scenechange_threshold = avctx->scenechange_threshold;
 666 FF_ENABLE_DEPRECATION_WARNINGS
 667 #endif
 668
 669     if (s->scenechange_threshold < 1000000000 &&
 670         (avctx->flags & AV_CODEC_FLAG_CLOSED_GOP)) {
 671         av_log(avctx, AV_LOG_ERROR,
 672                "closed gop with scene change detection are not supported yet, "
 673                "set threshold to 1000000000\n");
 674         return AVERROR_PATCHWELCOME;
 675     }
 676
 677     if (avctx->flags & AV_CODEC_FLAG_LOW_DELAY) {
 678         if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
 679             s->strict_std_compliance >= FF_COMPLIANCE_NORMAL) {
 680             av_log(avctx, AV_LOG_ERROR,
 681                    "low delay forcing is only available for mpeg2, "
 682                    "set strict_std_compliance to 'unofficial' or lower in order to allow it\n");
 683             return AVERROR(EINVAL);
 684         }
 685         if (s->max_b_frames != 0) {
 686             av_log(avctx, AV_LOG_ERROR,
 687                    "B-frames cannot be used with low delay\n");
 688             return AVERROR(EINVAL);
 689         }
 690     }
 691
 692     if (s->q_scale_type == 1) {
 693         if (avctx->qmax > 28) {
 694             av_log(avctx, AV_LOG_ERROR,
 695                    "non linear quant only supports qmax <= 28 currently\n");
 696             return AVERROR_PATCHWELCOME;
 697         }
 698     }
 699
 700     if (avctx->slices > 1 &&
 701         (avctx->codec_id == AV_CODEC_ID_FLV1 || avctx->codec_id == AV_CODEC_ID_H261)) {
 702         av_log(avctx, AV_LOG_ERROR, "Multiple slices are not supported by this codec\n");
 703         return AVERROR(EINVAL);
 704     }
 705
 706     if (avctx->thread_count > 1         &&
 707         s->codec_id != AV_CODEC_ID_MPEG4      &&
 708         s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
 709         s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
 710         s->codec_id != AV_CODEC_ID_MJPEG      &&
 711         (s->codec_id != AV_CODEC_ID_H263P)) {
 712         av_log(avctx, AV_LOG_ERROR,
 713                "multi threaded encoding not supported by codec\n");
 714         return AVERROR_PATCHWELCOME;
 715     }
 716
 717     if (avctx->thread_count < 1) {
 718         av_log(avctx, AV_LOG_ERROR,
 719                "automatic thread number detection not supported by codec, "
 720                "patch welcome\n");
 721         return AVERROR_PATCHWELCOME;
 722     }
 723
 724     if (!avctx->time_base.den || !avctx->time_base.num) {
 725         av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
 726         return AVERROR(EINVAL);
 727     }
 728
 729 #if FF_API_PRIVATE_OPT
 730 FF_DISABLE_DEPRECATION_WARNINGS
 731     if (avctx->b_frame_strategy)
 732         s->b_frame_strategy = avctx->b_frame_strategy;
 733     if (avctx->b_sensitivity != 40)
 734         s->b_sensitivity = avctx->b_sensitivity;
 735 FF_ENABLE_DEPRECATION_WARNINGS
 736 #endif
 737
 738     if (s->b_frame_strategy && (avctx->flags & AV_CODEC_FLAG_PASS2)) {
 739         av_log(avctx, AV_LOG_INFO,
 740                "notice: b_frame_strategy only affects the first pass\n");
 741         s->b_frame_strategy = 0;
 742     }
 743
 744     i = av_gcd(avctx->time_base.den, avctx->time_base.num);
 745     if (i > 1) {
 746         av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
 747         avctx->time_base.den /= i;
 748         avctx->time_base.num /= i;
 749         //return -1;
 750     }
 751
 752     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 || s->codec_id == AV_CODEC_ID_SPEEDHQ) {
 753         // (a + x * 3 / 8) / x
 754         s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
 755         s->inter_quant_bias = 0;
 756     } else {
 757         s->intra_quant_bias = 0;
 758         // (a - x / 4) / x
 759         s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
 760     }
 761
 762     if (avctx->qmin > avctx->qmax || avctx->qmin <= 0) {
 763         av_log(avctx, AV_LOG_ERROR, "qmin and or qmax are invalid, they must be 0 < min <= max\n");
 764         return AVERROR(EINVAL);
 765     }
 766
 767     av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
 768
 769     if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
 770         avctx->time_base.den > (1 << 16) - 1) {
 771         av_log(avctx, AV_LOG_ERROR,
 772                "timebase %d/%d not supported by MPEG 4 standard, "
 773                "the maximum admitted value for the timebase denominator "
 774                "is %d\n", avctx->time_base.num, avctx->time_base.den,
 775                (1 << 16) - 1);
 776         return AVERROR(EINVAL);
 777     }
 778     s->time_increment_bits = av_log2(avctx->time_base.den - 1) + 1;
 779
 780     switch (avctx->codec->id) {
 781     case AV_CODEC_ID_MPEG1VIDEO:
 782         s->out_format = FMT_MPEG1;
 783         s->low_delay  = !!(avctx->flags & AV_CODEC_FLAG_LOW_DELAY);
 784         avctx->delay  = s->low_delay ? 0 : (s->max_b_frames + 1);
 785         break;
 786     case AV_CODEC_ID_MPEG2VIDEO:
 787         s->out_format = FMT_MPEG1;
 788         s->low_delay  = !!(avctx->flags & AV_CODEC_FLAG_LOW_DELAY);
 789         avctx->delay  = s->low_delay ? 0 : (s->max_b_frames + 1);
 790         s->rtp_mode   = 1;
 791         break;
 792     case AV_CODEC_ID_MJPEG:
 793     case AV_CODEC_ID_AMV:
 794         s->out_format = FMT_MJPEG;
 795         s->intra_only = 1; /* force intra only for jpeg */
 796         if (!CONFIG_MJPEG_ENCODER)
 797             return AVERROR_ENCODER_NOT_FOUND;
 798         if ((ret = ff_mjpeg_encode_init(s)) < 0)
 799             return ret;
 800         avctx->delay = 0;
 801         s->low_delay = 1;
 802         break;
 803     case AV_CODEC_ID_SPEEDHQ:
 804         s->out_format = FMT_SPEEDHQ;
 805         s->intra_only = 1; /* force intra only for SHQ */
 806         if (!CONFIG_SPEEDHQ_ENCODER)
 807             return AVERROR_ENCODER_NOT_FOUND;
 808         if ((ret = ff_speedhq_encode_init(s)) < 0)
 809             return ret;
 810         avctx->delay = 0;
 811         s->low_delay = 1;
 812         break;
 813     case AV_CODEC_ID_H261:
 814         if (!CONFIG_H261_ENCODER)
 815             return AVERROR_ENCODER_NOT_FOUND;
 816         if (ff_h261_get_picture_format(s->width, s->height) < 0) {
 817             av_log(avctx, AV_LOG_ERROR,
 818                    "The specified picture size of %dx%d is not valid for the "
 819                    "H.261 codec.\nValid sizes are 176x144, 352x288\n",
 820                     s->width, s->height);
 821             return AVERROR(EINVAL);
 822         }
 823         s->out_format = FMT_H261;
 824         avctx->delay  = 0;
 825         s->low_delay  = 1;
 826         s->rtp_mode   = 0; /* Sliced encoding not supported */
 827         break;
 828     case AV_CODEC_ID_H263:
 829         if (!CONFIG_H263_ENCODER)
 830             return AVERROR_ENCODER_NOT_FOUND;
 831         if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
 832                              s->width, s->height) == 8) {
 833             av_log(avctx, AV_LOG_ERROR,
 834                    "The specified picture size of %dx%d is not valid for "
 835                    "the H.263 codec.\nValid sizes are 128x96, 176x144, "
 836                    "352x288, 704x576, and 1408x1152. "
 837                    "Try H.263+.\n", s->width, s->height);
 838             return AVERROR(EINVAL);
 839         }
 840         s->out_format = FMT_H263;
 841         avctx->delay  = 0;
 842         s->low_delay  = 1;
 843         break;
 844     case AV_CODEC_ID_H263P:
 845         s->out_format = FMT_H263;
 846         s->h263_plus  = 1;
 847         /* Fx */
 848         s->h263_aic        = (avctx->flags & AV_CODEC_FLAG_AC_PRED) ? 1 : 0;
 849         s->modified_quant  = s->h263_aic;
 850         s->loop_filter     = (avctx->flags & AV_CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
 851         s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
 852
 853         /* /Fx */
 854         /* These are just to be sure */
 855         avctx->delay = 0;
 856         s->low_delay = 1;
 857         break;
 858     case AV_CODEC_ID_FLV1:
 859         s->out_format      = FMT_H263;
 860         s->h263_flv        = 2; /* format = 1; 11-bit codes */
 861         s->unrestricted_mv = 1;
 862         s->rtp_mode  = 0; /* don't allow GOB */
 863         avctx->delay = 0;
 864         s->low_delay = 1;
 865         break;
 866     case AV_CODEC_ID_RV10:
 867         s->out_format = FMT_H263;
 868         avctx->delay  = 0;
 869         s->low_delay  = 1;
 870         break;
 871     case AV_CODEC_ID_RV20:
 872         s->out_format      = FMT_H263;
 873         avctx->delay       = 0;
 874         s->low_delay       = 1;
 875         s->modified_quant  = 1;
 876         s->h263_aic        = 1;
 877         s->h263_plus       = 1;
 878         s->loop_filter     = 1;
 879         s->unrestricted_mv = 0;
 880         break;
 881     case AV_CODEC_ID_MPEG4:
 882         s->out_format      = FMT_H263;
 883         s->h263_pred       = 1;
 884         s->unrestricted_mv = 1;
 885         s->low_delay       = s->max_b_frames ? 0 : 1;
 886         avctx->delay       = s->low_delay ? 0 : (s->max_b_frames + 1);
 887         break;
 888     case AV_CODEC_ID_MSMPEG4V2:
 889         s->out_format      = FMT_H263;
 890         s->h263_pred       = 1;
 891         s->unrestricted_mv = 1;
 892         s->msmpeg4_version = 2;
 893         avctx->delay       = 0;
 894         s->low_delay       = 1;
 895         break;
 896     case AV_CODEC_ID_MSMPEG4V3:
 897         s->out_format        = FMT_H263;
 898         s->h263_pred         = 1;
 899         s->unrestricted_mv   = 1;
 900         s->msmpeg4_version   = 3;
 901         s->flipflop_rounding = 1;
 902         avctx->delay         = 0;
 903         s->low_delay         = 1;
 904         break;
 905     case AV_CODEC_ID_WMV1:
 906         s->out_format        = FMT_H263;
 907         s->h263_pred         = 1;
 908         s->unrestricted_mv   = 1;
 909         s->msmpeg4_version   = 4;
 910         s->flipflop_rounding = 1;
 911         avctx->delay         = 0;
 912         s->low_delay         = 1;
 913         break;
 914     case AV_CODEC_ID_WMV2:
 915         s->out_format        = FMT_H263;
 916         s->h263_pred         = 1;
 917         s->unrestricted_mv   = 1;
 918         s->msmpeg4_version   = 5;
 919         s->flipflop_rounding = 1;
 920         avctx->delay         = 0;
 921         s->low_delay         = 1;
 922         break;
 923     default:
 924         return AVERROR(EINVAL);
 925     }
 926
 927 #if FF_API_PRIVATE_OPT
 928     FF_DISABLE_DEPRECATION_WARNINGS
 929     if (avctx->noise_reduction)
 930         s->noise_reduction = avctx->noise_reduction;
 931     FF_ENABLE_DEPRECATION_WARNINGS
 932 #endif
 933
 934     avctx->has_b_frames = !s->low_delay;
 935
 936     s->encoding = 1;
 937
 938     s->progressive_frame    =
 939     s->progressive_sequence = !(avctx->flags & (AV_CODEC_FLAG_INTERLACED_DCT |
 940                                                 AV_CODEC_FLAG_INTERLACED_ME) ||
 941                                 s->alternate_scan);
 942
 943     /* init */
 944     ff_mpv_idct_init(s);
 945     if ((ret = ff_mpv_common_init(s)) < 0)
 946         return ret;
 947
 948     ff_fdctdsp_init(&s->fdsp, avctx);
 949     ff_me_cmp_init(&s->mecc, avctx);
 950     ff_mpegvideoencdsp_init(&s->mpvencdsp, avctx);
 951     ff_pixblockdsp_init(&s->pdsp, avctx);
 952     ff_qpeldsp_init(&s->qdsp);
 953
 954     if (s->msmpeg4_version) {
 955         int ac_stats_size = 2 * 2 * (MAX_LEVEL + 1) *  (MAX_RUN + 1) * 2 * sizeof(int);
 956         if (!(s->ac_stats = av_mallocz(ac_stats_size)))
 957             return AVERROR(ENOMEM);
 958     }
 959
 960     if (!(avctx->stats_out = av_mallocz(256))               ||
 961         !FF_ALLOCZ_TYPED_ARRAY(s->q_intra_matrix,          32) ||
 962         !FF_ALLOCZ_TYPED_ARRAY(s->q_chroma_intra_matrix,   32) ||
 963         !FF_ALLOCZ_TYPED_ARRAY(s->q_inter_matrix,          32) ||
 964         !FF_ALLOCZ_TYPED_ARRAY(s->q_intra_matrix16,        32) ||
 965         !FF_ALLOCZ_TYPED_ARRAY(s->q_chroma_intra_matrix16, 32) ||
 966         !FF_ALLOCZ_TYPED_ARRAY(s->q_inter_matrix16,        32) ||
 967         !FF_ALLOCZ_TYPED_ARRAY(s->input_picture,           MAX_PICTURE_COUNT) ||
 968         !FF_ALLOCZ_TYPED_ARRAY(s->reordered_input_picture, MAX_PICTURE_COUNT))
 969         return AVERROR(ENOMEM);
 970
 971     if (s->noise_reduction) {
 972         if (!FF_ALLOCZ_TYPED_ARRAY(s->dct_offset, 2))
 973             return AVERROR(ENOMEM);
 974     }
 975
 976     ff_dct_encode_init(s);
 977
 978     if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
 979         s->chroma_qscale_table = ff_h263_chroma_qscale_table;
 980
 981     if (s->slice_context_count > 1) {
 982         s->rtp_mode = 1;
 983
 984         if (avctx->codec_id == AV_CODEC_ID_H263P)
 985             s->h263_slice_structured = 1;
 986     }
 987
 988     s->quant_precision = 5;
 989
 990 #if FF_API_PRIVATE_OPT
 991 FF_DISABLE_DEPRECATION_WARNINGS
 992     if (avctx->frame_skip_threshold)
 993         s->frame_skip_threshold = avctx->frame_skip_threshold;
 994     if (avctx->frame_skip_factor)
 995         s->frame_skip_factor = avctx->frame_skip_factor;
 996     if (avctx->frame_skip_exp)
 997         s->frame_skip_exp = avctx->frame_skip_exp;
 998     if (avctx->frame_skip_cmp != FF_CMP_DCTMAX)
 999         s->frame_skip_cmp = avctx->frame_skip_cmp;
1000 FF_ENABLE_DEPRECATION_WARNINGS
1001 #endif
1002
1003     ff_set_cmp(&s->mecc, s->mecc.ildct_cmp,      avctx->ildct_cmp);
1004     ff_set_cmp(&s->mecc, s->mecc.frame_skip_cmp, s->frame_skip_cmp);
1005
1006     if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
1007         ff_h261_encode_init(s);
1008     if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
1009         ff_h263_encode_init(s);
1010     if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
1011         ff_msmpeg4_encode_init(s);
1012     if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
1013         && s->out_format == FMT_MPEG1)
1014         ff_mpeg1_encode_init(s);
1015
1016     /* init q matrix */
1017     for (i = 0; i < 64; i++) {
1018         int j = s->idsp.idct_permutation[i];
1019         if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
1020             s->mpeg_quant) {
1021             s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1022             s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1023         } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1024             s->intra_matrix[j] =
1025             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1026         } else if (CONFIG_SPEEDHQ_ENCODER && s->codec_id == AV_CODEC_ID_SPEEDHQ) {
1027             s->intra_matrix[j] =
1028             s->inter_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1029         } else {
1030             /* MPEG-1/2 */
1031             s->chroma_intra_matrix[j] =
1032             s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1033             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1034         }
1035         if (avctx->intra_matrix)
1036             s->intra_matrix[j] = avctx->intra_matrix[i];
1037         if (avctx->inter_matrix)
1038             s->inter_matrix[j] = avctx->inter_matrix[i];
1039     }
1040
1041     /* precompute matrix */
1042     /* for mjpeg, we do include qscale in the matrix */
1043     if (s->out_format != FMT_MJPEG) {
1044         ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
1045                           s->intra_matrix, s->intra_quant_bias, avctx->qmin,
1046                           31, 1);
1047         ff_convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16,
1048                           s->inter_matrix, s->inter_quant_bias, avctx->qmin,
1049                           31, 0);
1050     }
1051
1052     if ((ret = ff_rate_control_init(s)) < 0)
1053         return ret;
1054
1055 #if FF_API_PRIVATE_OPT
1056     FF_DISABLE_DEPRECATION_WARNINGS
1057     if (avctx->brd_scale)
1058         s->brd_scale = avctx->brd_scale;
1059
1060     if (avctx->prediction_method)
1061         s->pred = avctx->prediction_method + 1;
1062     FF_ENABLE_DEPRECATION_WARNINGS
1063 #endif
1064
1065     if (s->b_frame_strategy == 2) {
1066         for (i = 0; i < s->max_b_frames + 2; i++) {
1067             s->tmp_frames[i] = av_frame_alloc();
1068             if (!s->tmp_frames[i])
1069                 return AVERROR(ENOMEM);
1070
1071             s->tmp_frames[i]->format = AV_PIX_FMT_YUV420P;
1072             s->tmp_frames[i]->width  = s->width  >> s->brd_scale;
1073             s->tmp_frames[i]->height = s->height >> s->brd_scale;
1074
1075             ret = av_frame_get_buffer(s->tmp_frames[i], 0);
1076             if (ret < 0)
1077                 return ret;
1078         }
1079     }
1080
1081     cpb_props = ff_add_cpb_side_data(avctx);
1082     if (!cpb_props)
1083         return AVERROR(ENOMEM);
1084     cpb_props->max_bitrate = avctx->rc_max_rate;
1085     cpb_props->min_bitrate = avctx->rc_min_rate;
1086     cpb_props->avg_bitrate = avctx->bit_rate;
1087     cpb_props->buffer_size = avctx->rc_buffer_size;
1088
1089     return 0;
1090 }
1091
1092 av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
1093 {
1094     MpegEncContext *s = avctx->priv_data;
1095     int i;
1096
1097     ff_rate_control_uninit(s);
1098
1099     ff_mpv_common_end(s);
1100     if (CONFIG_MJPEG_ENCODER &&
1101         s->out_format == FMT_MJPEG)
1102         ff_mjpeg_encode_close(s);
1103
1104     av_freep(&avctx->extradata);
1105
1106     for (i = 0; i < FF_ARRAY_ELEMS(s->tmp_frames); i++)
1107         av_frame_free(&s->tmp_frames[i]);
1108
1109     ff_free_picture_tables(&s->new_picture);
1110     ff_mpeg_unref_picture(avctx, &s->new_picture);
1111
1112     av_freep(&avctx->stats_out);
1113     av_freep(&s->ac_stats);
1114
1115     if(s->q_chroma_intra_matrix   != s->q_intra_matrix  ) av_freep(&s->q_chroma_intra_matrix);
1116     if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
1117     s->q_chroma_intra_matrix=   NULL;
1118     s->q_chroma_intra_matrix16= NULL;
1119     av_freep(&s->q_intra_matrix);
1120     av_freep(&s->q_inter_matrix);
1121     av_freep(&s->q_intra_matrix16);
1122     av_freep(&s->q_inter_matrix16);
1123     av_freep(&s->input_picture);
1124     av_freep(&s->reordered_input_picture);
1125     av_freep(&s->dct_offset);
1126
1127     return 0;
1128 }
1129
1130 static int get_sae(uint8_t *src, int ref, int stride)
1131 {
1132     int x,y;
1133     int acc = 0;
1134
1135     for (y = 0; y < 16; y++) {
1136         for (x = 0; x < 16; x++) {
1137             acc += FFABS(src[x + y * stride] - ref);
1138         }
1139     }
1140
1141     return acc;
1142 }
1143
1144 static int get_intra_count(MpegEncContext *s, uint8_t *src,
1145                            uint8_t *ref, int stride)
1146 {
1147     int x, y, w, h;
1148     int acc = 0;
1149
1150     w = s->width  & ~15;
1151     h = s->height & ~15;
1152
1153     for (y = 0; y < h; y += 16) {
1154         for (x = 0; x < w; x += 16) {
1155             int offset = x + y * stride;
1156             int sad  = s->mecc.sad[0](NULL, src + offset, ref + offset,
1157                                       stride, 16);
1158             int mean = (s->mpvencdsp.pix_sum(src + offset, stride) + 128) >> 8;
1159             int sae  = get_sae(src + offset, mean, stride);
1160
1161             acc += sae + 500 < sad;
1162         }
1163     }
1164     return acc;
1165 }
1166
1167 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared)
1168 {
1169     return ff_alloc_picture(s->avctx, pic, &s->me, &s->sc, shared, 1,
1170                             s->chroma_x_shift, s->chroma_y_shift, s->out_format,
1171                             s->mb_stride, s->mb_width, s->mb_height, s->b8_stride,
1172                             &s->linesize, &s->uvlinesize);
1173 }
1174
1175 static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
1176 {
1177     Picture *pic = NULL;
1178     int64_t pts;
1179     int i, display_picture_number = 0, ret;
1180     int encoding_delay = s->max_b_frames ? s->max_b_frames
1181                                          : (s->low_delay ? 0 : 1);
1182     int flush_offset = 1;
1183     int direct = 1;
1184
1185     if (pic_arg) {
1186         pts = pic_arg->pts;
1187         display_picture_number = s->input_picture_number++;
1188
1189         if (pts != AV_NOPTS_VALUE) {
1190             if (s->user_specified_pts != AV_NOPTS_VALUE) {
1191                 int64_t last = s->user_specified_pts;
1192
1193                 if (pts <= last) {
1194                     av_log(s->avctx, AV_LOG_ERROR,
1195                            "Invalid pts (%"PRId64") <= last (%"PRId64")\n",
1196                            pts, last);
1197                     return AVERROR(EINVAL);
1198                 }
1199
1200                 if (!s->low_delay && display_picture_number == 1)
1201                     s->dts_delta = pts - last;
1202             }
1203             s->user_specified_pts = pts;
1204         } else {
1205             if (s->user_specified_pts != AV_NOPTS_VALUE) {
1206                 s->user_specified_pts =
1207                 pts = s->user_specified_pts + 1;
1208                 av_log(s->avctx, AV_LOG_INFO,
1209                        "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
1210                        pts);
1211             } else {
1212                 pts = display_picture_number;
1213             }
1214         }
1215
1216         if (!pic_arg->buf[0] ||
1217             pic_arg->linesize[0] != s->linesize ||
1218             pic_arg->linesize[1] != s->uvlinesize ||
1219             pic_arg->linesize[2] != s->uvlinesize)
1220             direct = 0;
1221         if ((s->width & 15) || (s->height & 15))
1222             direct = 0;
1223         if (((intptr_t)(pic_arg->data[0])) & (STRIDE_ALIGN-1))
1224             direct = 0;
1225         if (s->linesize & (STRIDE_ALIGN-1))
1226             direct = 0;
1227
1228         ff_dlog(s->avctx, "%d %d %"PTRDIFF_SPECIFIER" %"PTRDIFF_SPECIFIER"\n", pic_arg->linesize[0],
1229                 pic_arg->linesize[1], s->linesize, s->uvlinesize);
1230
1231         i = ff_find_unused_picture(s->avctx, s->picture, direct);
1232         if (i < 0)
1233             return i;
1234
1235         pic = &s->picture[i];
1236         pic->reference = 3;
1237
1238         if (direct) {
1239             if ((ret = av_frame_ref(pic->f, pic_arg)) < 0)
1240                 return ret;
1241         }
1242         ret = alloc_picture(s, pic, direct);
1243         if (ret < 0)
1244             return ret;
1245
1246         if (!direct) {
1247             if (pic->f->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1248                 pic->f->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1249                 pic->f->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1250                 // empty
1251             } else {
1252                 int h_chroma_shift, v_chroma_shift;
1253                 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1254                                                  &h_chroma_shift,
1255                                                  &v_chroma_shift);
1256
1257                 for (i = 0; i < 3; i++) {
1258                     int src_stride = pic_arg->linesize[i];
1259                     int dst_stride = i ? s->uvlinesize : s->linesize;
1260                     int h_shift = i ? h_chroma_shift : 0;
1261                     int v_shift = i ? v_chroma_shift : 0;
1262                     int w = s->width  >> h_shift;
1263                     int h = s->height >> v_shift;
1264                     uint8_t *src = pic_arg->data[i];
1265                     uint8_t *dst = pic->f->data[i];
1266                     int vpad = 16;
1267
1268                     if (   s->codec_id == AV_CODEC_ID_MPEG2VIDEO
1269                         && !s->progressive_sequence
1270                         && FFALIGN(s->height, 32) - s->height > 16)
1271                         vpad = 32;
1272
1273                     if (!s->avctx->rc_buffer_size)
1274                         dst += INPLACE_OFFSET;
1275
1276                     if (src_stride == dst_stride)
1277                         memcpy(dst, src, src_stride * h);
1278                     else {
1279                         int h2 = h;
1280                         uint8_t *dst2 = dst;
1281                         while (h2--) {
1282                             memcpy(dst2, src, w);
1283                             dst2 += dst_stride;
1284                             src += src_stride;
1285                         }
1286                     }
1287                     if ((s->width & 15) || (s->height & (vpad-1))) {
1288                         s->mpvencdsp.draw_edges(dst, dst_stride,
1289                                                 w, h,
1290                                                 16 >> h_shift,
1291                                                 vpad >> v_shift,
1292                                                 EDGE_BOTTOM);
1293                     }
1294                 }
1295                 emms_c();
1296             }
1297         }
1298         ret = av_frame_copy_props(pic->f, pic_arg);
1299         if (ret < 0)
1300             return ret;
1301
1302         pic->f->display_picture_number = display_picture_number;
1303         pic->f->pts = pts; // we set this here to avoid modifying pic_arg
1304     } else {
1305         /* Flushing: When we have not received enough input frames,
1306          * ensure s->input_picture[0] contains the first picture */
1307         for (flush_offset = 0; flush_offset < encoding_delay + 1; flush_offset++)
1308             if (s->input_picture[flush_offset])
1309                 break;
1310
1311         if (flush_offset <= 1)
1312             flush_offset = 1;
1313         else
1314             encoding_delay = encoding_delay - flush_offset + 1;
1315     }
1316
1317     /* shift buffer entries */
1318     for (i = flush_offset; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1319         s->input_picture[i - flush_offset] = s->input_picture[i];
1320
1321     s->input_picture[encoding_delay] = (Picture*) pic;
1322
1323     return 0;
1324 }
1325
1326 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1327 {
1328     int x, y, plane;
1329     int score = 0;
1330     int64_t score64 = 0;
1331
1332     for (plane = 0; plane < 3; plane++) {
1333         const int stride = p->f->linesize[plane];
1334         const int bw = plane ? 1 : 2;
1335         for (y = 0; y < s->mb_height * bw; y++) {
1336             for (x = 0; x < s->mb_width * bw; x++) {
1337                 int off = p->shared ? 0 : 16;
1338                 uint8_t *dptr = p->f->data[plane] + 8 * (x + y * stride) + off;
1339                 uint8_t *rptr = ref->f->data[plane] + 8 * (x + y * stride);
1340                 int v = s->mecc.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1341
1342                 switch (FFABS(s->frame_skip_exp)) {
1343                 case 0: score    =  FFMAX(score, v);          break;
1344                 case 1: score   += FFABS(v);                  break;
1345                 case 2: score64 += v * (int64_t)v;                       break;
1346                 case 3: score64 += FFABS(v * (int64_t)v * v);            break;
1347                 case 4: score64 += (v * (int64_t)v) * (v * (int64_t)v);  break;
1348                 }
1349             }
1350         }
1351     }
1352     emms_c();
1353
1354     if (score)
1355         score64 = score;
1356     if (s->frame_skip_exp < 0)
1357         score64 = pow(score64 / (double)(s->mb_width * s->mb_height),
1358                       -1.0/s->frame_skip_exp);
1359
1360     if (score64 < s->frame_skip_threshold)
1361         return 1;
1362     if (score64 < ((s->frame_skip_factor * (int64_t) s->lambda) >> 8))
1363         return 1;
1364     return 0;
1365 }
1366
1367 static int encode_frame(AVCodecContext *c, AVFrame *frame, AVPacket *pkt)
1368 {
1369     int ret;
1370     int size = 0;
1371
1372     ret = avcodec_send_frame(c, frame);
1373     if (ret < 0)
1374         return ret;
1375
1376     do {
1377         ret = avcodec_receive_packet(c, pkt);
1378         if (ret >= 0) {
1379             size += pkt->size;
1380             av_packet_unref(pkt);
1381         } else if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
1382             return ret;
1383     } while (ret >= 0);
1384
1385     return size;
1386 }
1387
1388 static int estimate_best_b_count(MpegEncContext *s)
1389 {
1390     const AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1391     AVPacket *pkt;
1392     const int scale = s->brd_scale;
1393     int width  = s->width  >> scale;
1394     int height = s->height >> scale;
1395     int i, j, out_size, p_lambda, b_lambda, lambda2;
1396     int64_t best_rd  = INT64_MAX;
1397     int best_b_count = -1;
1398     int ret = 0;
1399
1400     av_assert0(scale >= 0 && scale <= 3);
1401
1402     pkt = av_packet_alloc();
1403     if (!pkt)
1404         return AVERROR(ENOMEM);
1405
1406     //emms_c();
1407     //s->next_picture_ptr->quality;
1408     p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1409     //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1410     b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1411     if (!b_lambda) // FIXME we should do this somewhere else
1412         b_lambda = p_lambda;
1413     lambda2  = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1414                FF_LAMBDA_SHIFT;
1415
1416     for (i = 0; i < s->max_b_frames + 2; i++) {
1417         Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1418                                                 s->next_picture_ptr;
1419         uint8_t *data[4];
1420
1421         if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1422             pre_input = *pre_input_ptr;
1423             memcpy(data, pre_input_ptr->f->data, sizeof(data));
1424
1425             if (!pre_input.shared && i) {
1426                 data[0] += INPLACE_OFFSET;
1427                 data[1] += INPLACE_OFFSET;
1428                 data[2] += INPLACE_OFFSET;
1429             }
1430
1431             s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[0],
1432                                        s->tmp_frames[i]->linesize[0],
1433                                        data[0],
1434                                        pre_input.f->linesize[0],
1435                                        width, height);
1436             s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[1],
1437                                        s->tmp_frames[i]->linesize[1],
1438                                        data[1],
1439                                        pre_input.f->linesize[1],
1440                                        width >> 1, height >> 1);
1441             s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[2],
1442                                        s->tmp_frames[i]->linesize[2],
1443                                        data[2],
1444                                        pre_input.f->linesize[2],
1445                                        width >> 1, height >> 1);
1446         }
1447     }
1448
1449     for (j = 0; j < s->max_b_frames + 1; j++) {
1450         AVCodecContext *c;
1451         int64_t rd = 0;
1452
1453         if (!s->input_picture[j])
1454             break;
1455
1456         c = avcodec_alloc_context3(NULL);
1457         if (!c) {
1458             ret = AVERROR(ENOMEM);
1459             goto fail;
1460         }
1461
1462         c->width        = width;
1463         c->height       = height;
1464         c->flags        = AV_CODEC_FLAG_QSCALE | AV_CODEC_FLAG_PSNR;
1465         c->flags       |= s->avctx->flags & AV_CODEC_FLAG_QPEL;
1466         c->mb_decision  = s->avctx->mb_decision;
1467         c->me_cmp       = s->avctx->me_cmp;
1468         c->mb_cmp       = s->avctx->mb_cmp;
1469         c->me_sub_cmp   = s->avctx->me_sub_cmp;
1470         c->pix_fmt      = AV_PIX_FMT_YUV420P;
1471         c->time_base    = s->avctx->time_base;
1472         c->max_b_frames = s->max_b_frames;
1473
1474         ret = avcodec_open2(c, codec, NULL);
1475         if (ret < 0)
1476             goto fail;
1477
1478
1479         s->tmp_frames[0]->pict_type = AV_PICTURE_TYPE_I;
1480         s->tmp_frames[0]->quality   = 1 * FF_QP2LAMBDA;
1481
1482         out_size = encode_frame(c, s->tmp_frames[0], pkt);
1483         if (out_size < 0) {
1484             ret = out_size;
1485             goto fail;
1486         }
1487
1488         //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1489
1490         for (i = 0; i < s->max_b_frames + 1; i++) {
1491             int is_p = i % (j + 1) == j || i == s->max_b_frames;
1492
1493             s->tmp_frames[i + 1]->pict_type = is_p ?
1494                                      AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1495             s->tmp_frames[i + 1]->quality   = is_p ? p_lambda : b_lambda;
1496
1497             out_size = encode_frame(c, s->tmp_frames[i + 1], pkt);
1498             if (out_size < 0) {
1499                 ret = out_size;
1500                 goto fail;
1501             }
1502
1503             rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1504         }
1505
1506         /* get the delayed frames */
1507         out_size = encode_frame(c, NULL, pkt);
1508         if (out_size < 0) {
1509             ret = out_size;
1510             goto fail;
1511         }
1512         rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1513
1514         rd += c->error[0] + c->error[1] + c->error[2];
1515
1516         if (rd < best_rd) {
1517             best_rd = rd;
1518             best_b_count = j;
1519         }
1520
1521 fail:
1522         avcodec_free_context(&c);
1523         av_packet_unref(pkt);
1524         if (ret < 0) {
1525             best_b_count = ret;
1526             break;
1527         }
1528     }
1529
1530     av_packet_free(&pkt);
1531
1532     return best_b_count;
1533 }
1534
1535 static int select_input_picture(MpegEncContext *s)
1536 {
1537     int i, ret;
1538
1539     for (i = 1; i < MAX_PICTURE_COUNT; i++)
1540         s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1541     s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1542
1543     /* set next picture type & ordering */
1544     if (!s->reordered_input_picture[0] && s->input_picture[0]) {
1545         if (s->frame_skip_threshold || s->frame_skip_factor) {
1546             if (s->picture_in_gop_number < s->gop_size &&
1547                 s->next_picture_ptr &&
1548                 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1549                 // FIXME check that the gop check above is +-1 correct
1550                 av_frame_unref(s->input_picture[0]->f);
1551
1552                 ff_vbv_update(s, 0);
1553
1554                 goto no_output_pic;
1555             }
1556         }
1557
1558         if (/*s->picture_in_gop_number >= s->gop_size ||*/
1559             !s->next_picture_ptr || s->intra_only) {
1560             s->reordered_input_picture[0] = s->input_picture[0];
1561             s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_I;
1562             s->reordered_input_picture[0]->f->coded_picture_number =
1563                 s->coded_picture_number++;
1564         } else {
1565             int b_frames = 0;
1566
1567             if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
1568                 for (i = 0; i < s->max_b_frames + 1; i++) {
1569                     int pict_num = s->input_picture[0]->f->display_picture_number + i;
1570
1571                     if (pict_num >= s->rc_context.num_entries)
1572                         break;
1573                     if (!s->input_picture[i]) {
1574                         s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1575                         break;
1576                     }
1577
1578                     s->input_picture[i]->f->pict_type =
1579                         s->rc_context.entry[pict_num].new_pict_type;
1580                 }
1581             }
1582
1583             if (s->b_frame_strategy == 0) {
1584                 b_frames = s->max_b_frames;
1585                 while (b_frames && !s->input_picture[b_frames])
1586                     b_frames--;
1587             } else if (s->b_frame_strategy == 1) {
1588                 for (i = 1; i < s->max_b_frames + 1; i++) {
1589                     if (s->input_picture[i] &&
1590                         s->input_picture[i]->b_frame_score == 0) {
1591                         s->input_picture[i]->b_frame_score =
1592                             get_intra_count(s,
1593                                             s->input_picture[i    ]->f->data[0],
1594                                             s->input_picture[i - 1]->f->data[0],
1595                                             s->linesize) + 1;
1596                     }
1597                 }
1598                 for (i = 0; i < s->max_b_frames + 1; i++) {
1599                     if (!s->input_picture[i] ||
1600                         s->input_picture[i]->b_frame_score - 1 >
1601                             s->mb_num / s->b_sensitivity)
1602                         break;
1603                 }
1604
1605                 b_frames = FFMAX(0, i - 1);
1606
1607                 /* reset scores */
1608                 for (i = 0; i < b_frames + 1; i++) {
1609                     s->input_picture[i]->b_frame_score = 0;
1610                 }
1611             } else if (s->b_frame_strategy == 2) {
1612                 b_frames = estimate_best_b_count(s);
1613                 if (b_frames < 0)
1614                     return b_frames;
1615             }
1616
1617             emms_c();
1618
1619             for (i = b_frames - 1; i >= 0; i--) {
1620                 int type = s->input_picture[i]->f->pict_type;
1621                 if (type && type != AV_PICTURE_TYPE_B)
1622                     b_frames = i;
1623             }
1624             if (s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_B &&
1625                 b_frames == s->max_b_frames) {
1626                 av_log(s->avctx, AV_LOG_ERROR,
1627                        "warning, too many B-frames in a row\n");
1628             }
1629
1630             if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1631                 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1632                     s->gop_size > s->picture_in_gop_number) {
1633                     b_frames = s->gop_size - s->picture_in_gop_number - 1;
1634                 } else {
1635                     if (s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP)
1636                         b_frames = 0;
1637                     s->input_picture[b_frames]->f->pict_type = AV_PICTURE_TYPE_I;
1638                 }
1639             }
1640
1641             if ((s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP) && b_frames &&
1642                 s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_I)
1643                 b_frames--;
1644
1645             s->reordered_input_picture[0] = s->input_picture[b_frames];
1646             if (s->reordered_input_picture[0]->f->pict_type != AV_PICTURE_TYPE_I)
1647                 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_P;
1648             s->reordered_input_picture[0]->f->coded_picture_number =
1649                 s->coded_picture_number++;
1650             for (i = 0; i < b_frames; i++) {
1651                 s->reordered_input_picture[i + 1] = s->input_picture[i];
1652                 s->reordered_input_picture[i + 1]->f->pict_type =
1653                     AV_PICTURE_TYPE_B;
1654                 s->reordered_input_picture[i + 1]->f->coded_picture_number =
1655                     s->coded_picture_number++;
1656             }
1657         }
1658     }
1659 no_output_pic:
1660     ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1661
1662     if (s->reordered_input_picture[0]) {
1663         s->reordered_input_picture[0]->reference =
1664            s->reordered_input_picture[0]->f->pict_type !=
1665                AV_PICTURE_TYPE_B ? 3 : 0;
1666
1667         if ((ret = ff_mpeg_ref_picture(s->avctx, &s->new_picture, s->reordered_input_picture[0])))
1668             return ret;
1669
1670         if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
1671             // input is a shared pix, so we can't modify it -> allocate a new
1672             // one & ensure that the shared one is reuseable
1673
1674             Picture *pic;
1675             int i = ff_find_unused_picture(s->avctx, s->picture, 0);
1676             if (i < 0)
1677                 return i;
1678             pic = &s->picture[i];
1679
1680             pic->reference = s->reordered_input_picture[0]->reference;
1681             if (alloc_picture(s, pic, 0) < 0) {
1682                 return -1;
1683             }
1684
1685             ret = av_frame_copy_props(pic->f, s->reordered_input_picture[0]->f);
1686             if (ret < 0)
1687                 return ret;
1688
1689             /* mark us unused / free shared pic */
1690             av_frame_unref(s->reordered_input_picture[0]->f);
1691             s->reordered_input_picture[0]->shared = 0;
1692
1693             s->current_picture_ptr = pic;
1694         } else {
1695             // input is not a shared pix -> reuse buffer for current_pix
1696             s->current_picture_ptr = s->reordered_input_picture[0];
1697             for (i = 0; i < 4; i++) {
1698                 if (s->new_picture.f->data[i])
1699                     s->new_picture.f->data[i] += INPLACE_OFFSET;
1700             }
1701         }
1702         ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1703         if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1704                                        s->current_picture_ptr)) < 0)
1705             return ret;
1706
1707         s->picture_number = s->new_picture.f->display_picture_number;
1708     }
1709     return 0;
1710 }
1711
1712 static void frame_end(MpegEncContext *s)
1713 {
1714     if (s->unrestricted_mv &&
1715         s->current_picture.reference &&
1716         !s->intra_only) {
1717         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1718         int hshift = desc->log2_chroma_w;
1719         int vshift = desc->log2_chroma_h;
1720         s->mpvencdsp.draw_edges(s->current_picture.f->data[0],
1721                                 s->current_picture.f->linesize[0],
1722                                 s->h_edge_pos, s->v_edge_pos,
1723                                 EDGE_WIDTH, EDGE_WIDTH,
1724                                 EDGE_TOP | EDGE_BOTTOM);
1725         s->mpvencdsp.draw_edges(s->current_picture.f->data[1],
1726                                 s->current_picture.f->linesize[1],
1727                                 s->h_edge_pos >> hshift,
1728                                 s->v_edge_pos >> vshift,
1729                                 EDGE_WIDTH >> hshift,
1730                                 EDGE_WIDTH >> vshift,
1731                                 EDGE_TOP | EDGE_BOTTOM);
1732         s->mpvencdsp.draw_edges(s->current_picture.f->data[2],
1733                                 s->current_picture.f->linesize[2],
1734                                 s->h_edge_pos >> hshift,
1735                                 s->v_edge_pos >> vshift,
1736                                 EDGE_WIDTH >> hshift,
1737                                 EDGE_WIDTH >> vshift,
1738                                 EDGE_TOP | EDGE_BOTTOM);
1739     }
1740
1741     emms_c();
1742
1743     s->last_pict_type                 = s->pict_type;
1744     s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f->quality;
1745     if (s->pict_type!= AV_PICTURE_TYPE_B)
1746         s->last_non_b_pict_type = s->pict_type;
1747
1748 #if FF_API_CODED_FRAME
1749 FF_DISABLE_DEPRECATION_WARNINGS
1750     av_frame_unref(s->avctx->coded_frame);
1751     av_frame_copy_props(s->avctx->coded_frame, s->current_picture.f);
1752 FF_ENABLE_DEPRECATION_WARNINGS
1753 #endif
1754 #if FF_API_ERROR_FRAME
1755 FF_DISABLE_DEPRECATION_WARNINGS
1756     memcpy(s->current_picture.f->error, s->current_picture.encoding_error,
1757            sizeof(s->current_picture.encoding_error));
1758 FF_ENABLE_DEPRECATION_WARNINGS
1759 #endif
1760 }
1761
1762 static void update_noise_reduction(MpegEncContext *s)
1763 {
1764     int intra, i;
1765
1766     for (intra = 0; intra < 2; intra++) {
1767         if (s->dct_count[intra] > (1 << 16)) {
1768             for (i = 0; i < 64; i++) {
1769                 s->dct_error_sum[intra][i] >>= 1;
1770             }
1771             s->dct_count[intra] >>= 1;
1772         }
1773
1774         for (i = 0; i < 64; i++) {
1775             s->dct_offset[intra][i] = (s->noise_reduction *
1776                                        s->dct_count[intra] +
1777                                        s->dct_error_sum[intra][i] / 2) /
1778                                       (s->dct_error_sum[intra][i] + 1);
1779         }
1780     }
1781 }
1782
1783 static int frame_start(MpegEncContext *s)
1784 {
1785     int ret;
1786
1787     /* mark & release old frames */
1788     if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1789         s->last_picture_ptr != s->next_picture_ptr &&
1790         s->last_picture_ptr->f->buf[0]) {
1791         ff_mpeg_unref_picture(s->avctx, s->last_picture_ptr);
1792     }
1793
1794     s->current_picture_ptr->f->pict_type = s->pict_type;
1795     s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1796
1797     ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1798     if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1799                                    s->current_picture_ptr)) < 0)
1800         return ret;
1801
1802     if (s->pict_type != AV_PICTURE_TYPE_B) {
1803         s->last_picture_ptr = s->next_picture_ptr;
1804         if (!s->droppable)
1805             s->next_picture_ptr = s->current_picture_ptr;
1806     }
1807
1808     if (s->last_picture_ptr) {
1809         ff_mpeg_unref_picture(s->avctx, &s->last_picture);
1810         if (s->last_picture_ptr->f->buf[0] &&
1811             (ret = ff_mpeg_ref_picture(s->avctx, &s->last_picture,
1812                                        s->last_picture_ptr)) < 0)
1813             return ret;
1814     }
1815     if (s->next_picture_ptr) {
1816         ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1817         if (s->next_picture_ptr->f->buf[0] &&
1818             (ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture,
1819                                        s->next_picture_ptr)) < 0)
1820             return ret;
1821     }
1822
1823     if (s->picture_structure!= PICT_FRAME) {
1824         int i;
1825         for (i = 0; i < 4; i++) {
1826             if (s->picture_structure == PICT_BOTTOM_FIELD) {
1827                 s->current_picture.f->data[i] +=
1828                     s->current_picture.f->linesize[i];
1829             }
1830             s->current_picture.f->linesize[i] *= 2;
1831             s->last_picture.f->linesize[i]    *= 2;
1832             s->next_picture.f->linesize[i]    *= 2;
1833         }
1834     }
1835
1836     if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1837         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1838         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1839     } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1840         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1841         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1842     } else {
1843         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1844         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1845     }
1846
1847     if (s->dct_error_sum) {
1848         av_assert2(s->noise_reduction && s->encoding);
1849         update_noise_reduction(s);
1850     }
1851
1852     return 0;
1853 }
1854
1855 int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1856                           const AVFrame *pic_arg, int *got_packet)
1857 {
1858     MpegEncContext *s = avctx->priv_data;
1859     int i, stuffing_count, ret;
1860     int context_count = s->slice_context_count;
1861
1862     s->vbv_ignore_qmax = 0;
1863
1864     s->picture_in_gop_number++;
1865
1866     if (load_input_picture(s, pic_arg) < 0)
1867         return -1;
1868
1869     if (select_input_picture(s) < 0) {
1870         return -1;
1871     }
1872
1873     /* output? */
1874     if (s->new_picture.f->data[0]) {
1875         int growing_buffer = context_count == 1 && !pkt->data && !s->data_partitioning;
1876         int pkt_size = growing_buffer ? FFMAX(s->mb_width*s->mb_height*64+10000, avctx->internal->byte_buffer_size) - AV_INPUT_BUFFER_PADDING_SIZE
1877                                               :
1878                                               s->mb_width*s->mb_height*(MAX_MB_BYTES+100)+10000;
1879         if ((ret = ff_alloc_packet2(avctx, pkt, pkt_size, 0)) < 0)
1880             return ret;
1881         if (s->mb_info) {
1882             s->mb_info_ptr = av_packet_new_side_data(pkt,
1883                                  AV_PKT_DATA_H263_MB_INFO,
1884                                  s->mb_width*s->mb_height*12);
1885             s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1886         }
1887
1888         for (i = 0; i < context_count; i++) {
1889             int start_y = s->thread_context[i]->start_mb_y;
1890             int   end_y = s->thread_context[i]->  end_mb_y;
1891             int h       = s->mb_height;
1892             uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1893             uint8_t *end   = pkt->data + (size_t)(((int64_t) pkt->size) *   end_y / h);
1894
1895             init_put_bits(&s->thread_context[i]->pb, start, end - start);
1896         }
1897
1898         s->pict_type = s->new_picture.f->pict_type;
1899         //emms_c();
1900         ret = frame_start(s);
1901         if (ret < 0)
1902             return ret;
1903 vbv_retry:
1904         ret = encode_picture(s, s->picture_number);
1905         if (growing_buffer) {
1906             av_assert0(s->pb.buf == avctx->internal->byte_buffer);
1907             pkt->data = s->pb.buf;
1908             pkt->size = avctx->internal->byte_buffer_size;
1909         }
1910         if (ret < 0)
1911             return -1;
1912
1913 #if FF_API_STAT_BITS
1914 FF_DISABLE_DEPRECATION_WARNINGS
1915         avctx->header_bits = s->header_bits;
1916         avctx->mv_bits     = s->mv_bits;
1917         avctx->misc_bits   = s->misc_bits;
1918         avctx->i_tex_bits  = s->i_tex_bits;
1919         avctx->p_tex_bits  = s->p_tex_bits;
1920         avctx->i_count     = s->i_count;
1921         // FIXME f/b_count in avctx
1922         avctx->p_count     = s->mb_num - s->i_count - s->skip_count;
1923         avctx->skip_count  = s->skip_count;
1924 FF_ENABLE_DEPRECATION_WARNINGS
1925 #endif
1926
1927         frame_end(s);
1928
1929         if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1930             ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);
1931
1932         if (avctx->rc_buffer_size) {
1933             RateControlContext *rcc = &s->rc_context;
1934             int max_size = FFMAX(rcc->buffer_index * avctx->rc_max_available_vbv_use, rcc->buffer_index - 500);
1935             int hq = (avctx->mb_decision == FF_MB_DECISION_RD || avctx->trellis);
1936             int min_step = hq ? 1 : (1<<(FF_LAMBDA_SHIFT + 7))/139;
1937
1938             if (put_bits_count(&s->pb) > max_size &&
1939                 s->lambda < s->lmax) {
1940                 s->next_lambda = FFMAX(s->lambda + min_step, s->lambda *
1941                                        (s->qscale + 1) / s->qscale);
1942                 if (s->adaptive_quant) {
1943                     int i;
1944                     for (i = 0; i < s->mb_height * s->mb_stride; i++)
1945                         s->lambda_table[i] =
1946                             FFMAX(s->lambda_table[i] + min_step,
1947                                   s->lambda_table[i] * (s->qscale + 1) /
1948                                   s->qscale);
1949                 }
1950                 s->mb_skipped = 0;        // done in frame_start()
1951                 // done in encode_picture() so we must undo it
1952                 if (s->pict_type == AV_PICTURE_TYPE_P) {
1953                     if (s->flipflop_rounding          ||
1954                         s->codec_id == AV_CODEC_ID_H263P ||
1955                         s->codec_id == AV_CODEC_ID_MPEG4)
1956                         s->no_rounding ^= 1;
1957                 }
1958                 if (s->pict_type != AV_PICTURE_TYPE_B) {
1959                     s->time_base       = s->last_time_base;
1960                     s->last_non_b_time = s->time - s->pp_time;
1961                 }
1962                 for (i = 0; i < context_count; i++) {
1963                     PutBitContext *pb = &s->thread_context[i]->pb;
1964                     init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1965                 }
1966                 s->vbv_ignore_qmax = 1;
1967                 av_log(avctx, AV_LOG_VERBOSE, "reencoding frame due to VBV\n");
1968                 goto vbv_retry;
1969             }
1970
1971             av_assert0(avctx->rc_max_rate);
1972         }
1973
1974         if (avctx->flags & AV_CODEC_FLAG_PASS1)
1975             ff_write_pass1_stats(s);
1976
1977         for (i = 0; i < 4; i++) {
1978             s->current_picture_ptr->encoding_error[i] = s->current_picture.encoding_error[i];
1979             avctx->error[i] += s->current_picture_ptr->encoding_error[i];
1980         }
1981         ff_side_data_set_encoder_stats(pkt, s->current_picture.f->quality,
1982                                        s->current_picture_ptr->encoding_error,
1983                                        (avctx->flags&AV_CODEC_FLAG_PSNR) ? 4 : 0,
1984                                        s->pict_type);
1985
1986         if (avctx->flags & AV_CODEC_FLAG_PASS1)
1987             assert(put_bits_count(&s->pb) == s->header_bits + s->mv_bits +
1988                                              s->misc_bits + s->i_tex_bits +
1989                                              s->p_tex_bits);
1990         flush_put_bits(&s->pb);
1991         s->frame_bits  = put_bits_count(&s->pb);
1992
1993         stuffing_count = ff_vbv_update(s, s->frame_bits);
1994         s->stuffing_bits = 8*stuffing_count;
1995         if (stuffing_count) {
1996             if (put_bytes_left(&s->pb, 0) < stuffing_count + 50) {
1997                 av_log(avctx, AV_LOG_ERROR, "stuffing too large\n");
1998                 return -1;
1999             }
2000
2001             switch (s->codec_id) {
2002             case AV_CODEC_ID_MPEG1VIDEO:
2003             case AV_CODEC_ID_MPEG2VIDEO:
2004                 while (stuffing_count--) {
2005                     put_bits(&s->pb, 8, 0);
2006                 }
2007             break;
2008             case AV_CODEC_ID_MPEG4:
2009                 put_bits(&s->pb, 16, 0);
2010                 put_bits(&s->pb, 16, 0x1C3);
2011                 stuffing_count -= 4;
2012                 while (stuffing_count--) {
2013                     put_bits(&s->pb, 8, 0xFF);
2014                 }
2015             break;
2016             default:
2017                 av_log(avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2018             }
2019             flush_put_bits(&s->pb);
2020             s->frame_bits  = put_bits_count(&s->pb);
2021         }
2022
2023         /* update MPEG-1/2 vbv_delay for CBR */
2024         if (avctx->rc_max_rate                          &&
2025             avctx->rc_min_rate == avctx->rc_max_rate &&
2026             s->out_format == FMT_MPEG1                     &&
2027             90000LL * (avctx->rc_buffer_size - 1) <=
2028                 avctx->rc_max_rate * 0xFFFFLL) {
2029             AVCPBProperties *props;
2030             size_t props_size;
2031
2032             int vbv_delay, min_delay;
2033             double inbits  = avctx->rc_max_rate *
2034                              av_q2d(avctx->time_base);
2035             int    minbits = s->frame_bits - 8 *
2036                              (s->vbv_delay_ptr - s->pb.buf - 1);
2037             double bits    = s->rc_context.buffer_index + minbits - inbits;
2038
2039             if (bits < 0)
2040                 av_log(avctx, AV_LOG_ERROR,
2041                        "Internal error, negative bits\n");
2042
2043             av_assert1(s->repeat_first_field == 0);
2044
2045             vbv_delay = bits * 90000 / avctx->rc_max_rate;
2046             min_delay = (minbits * 90000LL + avctx->rc_max_rate - 1) /
2047                         avctx->rc_max_rate;
2048
2049             vbv_delay = FFMAX(vbv_delay, min_delay);
2050
2051             av_assert0(vbv_delay < 0xFFFF);
2052
2053             s->vbv_delay_ptr[0] &= 0xF8;
2054             s->vbv_delay_ptr[0] |= vbv_delay >> 13;
2055             s->vbv_delay_ptr[1]  = vbv_delay >> 5;
2056             s->vbv_delay_ptr[2] &= 0x07;
2057             s->vbv_delay_ptr[2] |= vbv_delay << 3;
2058
2059             props = av_cpb_properties_alloc(&props_size);
2060             if (!props)
2061                 return AVERROR(ENOMEM);
2062             props->vbv_delay = vbv_delay * 300;
2063
2064             ret = av_packet_add_side_data(pkt, AV_PKT_DATA_CPB_PROPERTIES,
2065                                           (uint8_t*)props, props_size);
2066             if (ret < 0) {
2067                 av_freep(&props);
2068                 return ret;
2069             }
2070
2071 #if FF_API_VBV_DELAY
2072 FF_DISABLE_DEPRECATION_WARNINGS
2073             avctx->vbv_delay     = vbv_delay * 300;
2074 FF_ENABLE_DEPRECATION_WARNINGS
2075 #endif
2076         }
2077         s->total_bits     += s->frame_bits;
2078 #if FF_API_STAT_BITS
2079 FF_DISABLE_DEPRECATION_WARNINGS
2080         avctx->frame_bits  = s->frame_bits;
2081 FF_ENABLE_DEPRECATION_WARNINGS
2082 #endif
2083
2084
2085         pkt->pts = s->current_picture.f->pts;
2086         if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
2087             if (!s->current_picture.f->coded_picture_number)
2088                 pkt->dts = pkt->pts - s->dts_delta;
2089             else
2090                 pkt->dts = s->reordered_pts;
2091             s->reordered_pts = pkt->pts;
2092         } else
2093             pkt->dts = pkt->pts;
2094         if (s->current_picture.f->key_frame)
2095             pkt->flags |= AV_PKT_FLAG_KEY;
2096         if (s->mb_info)
2097             av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
2098     } else {
2099         s->frame_bits = 0;
2100     }
2101
2102     /* release non-reference frames */
2103     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
2104         if (!s->picture[i].reference)
2105             ff_mpeg_unref_picture(avctx, &s->picture[i]);
2106     }
2107
2108     av_assert1((s->frame_bits & 7) == 0);
2109
2110     pkt->size = s->frame_bits / 8;
2111     *got_packet = !!pkt->size;
2112     return 0;
2113 }
2114
2115 static inline void dct_single_coeff_elimination(MpegEncContext *s,
2116                                                 int n, int threshold)
2117 {
2118     static const char tab[64] = {
2119         3, 2, 2, 1, 1, 1, 1, 1,
2120         1, 1, 1, 1, 1, 1, 1, 1,
2121         1, 1, 1, 1, 1, 1, 1, 1,
2122         0, 0, 0, 0, 0, 0, 0, 0,
2123         0, 0, 0, 0, 0, 0, 0, 0,
2124         0, 0, 0, 0, 0, 0, 0, 0,
2125         0, 0, 0, 0, 0, 0, 0, 0,
2126         0, 0, 0, 0, 0, 0, 0, 0
2127     };
2128     int score = 0;
2129     int run = 0;
2130     int i;
2131     int16_t *block = s->block[n];
2132     const int last_index = s->block_last_index[n];
2133     int skip_dc;
2134
2135     if (threshold < 0) {
2136         skip_dc = 0;
2137         threshold = -threshold;
2138     } else
2139         skip_dc = 1;
2140
2141     /* Are all we could set to zero already zero? */
2142     if (last_index <= skip_dc - 1)
2143         return;
2144
2145     for (i = 0; i <= last_index; i++) {
2146         const int j = s->intra_scantable.permutated[i];
2147         const int level = FFABS(block[j]);
2148         if (level == 1) {
2149             if (skip_dc && i == 0)
2150                 continue;
2151             score += tab[run];
2152             run = 0;
2153         } else if (level > 1) {
2154             return;
2155         } else {
2156             run++;
2157         }
2158     }
2159     if (score >= threshold)
2160         return;
2161     for (i = skip_dc; i <= last_index; i++) {
2162         const int j = s->intra_scantable.permutated[i];
2163         block[j] = 0;
2164     }
2165     if (block[0])
2166         s->block_last_index[n] = 0;
2167     else
2168         s->block_last_index[n] = -1;
2169 }
2170
2171 static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
2172                                int last_index)
2173 {
2174     int i;
2175     const int maxlevel = s->max_qcoeff;
2176     const int minlevel = s->min_qcoeff;
2177     int overflow = 0;
2178
2179     if (s->mb_intra) {
2180         i = 1; // skip clipping of intra dc
2181     } else
2182         i = 0;
2183
2184     for (; i <= last_index; i++) {
2185         const int j = s->intra_scantable.permutated[i];
2186         int level = block[j];
2187
2188         if (level > maxlevel) {
2189             level = maxlevel;
2190             overflow++;
2191         } else if (level < minlevel) {
2192             level = minlevel;
2193             overflow++;
2194         }
2195
2196         block[j] = level;
2197     }
2198
2199     if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
2200         av_log(s->avctx, AV_LOG_INFO,
2201                "warning, clipping %d dct coefficients to %d..%d\n",
2202                overflow, minlevel, maxlevel);
2203 }
2204
2205 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
2206 {
2207     int x, y;
2208     // FIXME optimize
2209     for (y = 0; y < 8; y++) {
2210         for (x = 0; x < 8; x++) {
2211             int x2, y2;
2212             int sum = 0;
2213             int sqr = 0;
2214             int count = 0;
2215
2216             for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
2217                 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
2218                     int v = ptr[x2 + y2 * stride];
2219                     sum += v;
2220                     sqr += v * v;
2221                     count++;
2222                 }
2223             }
2224             weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
2225         }
2226     }
2227 }
2228
2229 static av_always_inline void encode_mb_internal(MpegEncContext *s,
2230                                                 int motion_x, int motion_y,
2231                                                 int mb_block_height,
2232                                                 int mb_block_width,
2233                                                 int mb_block_count)
2234 {
2235     int16_t weight[12][64];
2236     int16_t orig[12][64];
2237     const int mb_x = s->mb_x;
2238     const int mb_y = s->mb_y;
2239     int i;
2240     int skip_dct[12];
2241     int dct_offset = s->linesize * 8; // default for progressive frames
2242     int uv_dct_offset = s->uvlinesize * 8;
2243     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2244     ptrdiff_t wrap_y, wrap_c;
2245
2246     for (i = 0; i < mb_block_count; i++)
2247         skip_dct[i] = s->skipdct;
2248
2249     if (s->adaptive_quant) {
2250         const int last_qp = s->qscale;
2251         const int mb_xy = mb_x + mb_y * s->mb_stride;
2252
2253         s->lambda = s->lambda_table[mb_xy];
2254         update_qscale(s);
2255
2256         if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
2257             s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
2258             s->dquant = s->qscale - last_qp;
2259
2260             if (s->out_format == FMT_H263) {
2261                 s->dquant = av_clip(s->dquant, -2, 2);
2262
2263                 if (s->codec_id == AV_CODEC_ID_MPEG4) {
2264                     if (!s->mb_intra) {
2265                         if (s->pict_type == AV_PICTURE_TYPE_B) {
2266                             if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
2267                                 s->dquant = 0;
2268                         }
2269                         if (s->mv_type == MV_TYPE_8X8)
2270                             s->dquant = 0;
2271                     }
2272                 }
2273             }
2274         }
2275         ff_set_qscale(s, last_qp + s->dquant);
2276     } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
2277         ff_set_qscale(s, s->qscale + s->dquant);
2278
2279     wrap_y = s->linesize;
2280     wrap_c = s->uvlinesize;
2281     ptr_y  = s->new_picture.f->data[0] +
2282              (mb_y * 16 * wrap_y)              + mb_x * 16;
2283     ptr_cb = s->new_picture.f->data[1] +
2284              (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2285     ptr_cr = s->new_picture.f->data[2] +
2286              (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2287
2288     if((mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
2289         uint8_t *ebuf = s->sc.edge_emu_buffer + 38 * wrap_y;
2290         int cw = (s->width  + s->chroma_x_shift) >> s->chroma_x_shift;
2291         int ch = (s->height + s->chroma_y_shift) >> s->chroma_y_shift;
2292         s->vdsp.emulated_edge_mc(ebuf, ptr_y,
2293                                  wrap_y, wrap_y,
2294                                  16, 16, mb_x * 16, mb_y * 16,
2295                                  s->width, s->height);
2296         ptr_y = ebuf;
2297         s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y, ptr_cb,
2298                                  wrap_c, wrap_c,
2299                                  mb_block_width, mb_block_height,
2300                                  mb_x * mb_block_width, mb_y * mb_block_height,
2301                                  cw, ch);
2302         ptr_cb = ebuf + 16 * wrap_y;
2303         s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y + 16, ptr_cr,
2304                                  wrap_c, wrap_c,
2305                                  mb_block_width, mb_block_height,
2306                                  mb_x * mb_block_width, mb_y * mb_block_height,
2307                                  cw, ch);
2308         ptr_cr = ebuf + 16 * wrap_y + 16;
2309     }
2310
2311     if (s->mb_intra) {
2312         if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
2313             int progressive_score, interlaced_score;
2314
2315             s->interlaced_dct = 0;
2316             progressive_score = s->mecc.ildct_cmp[4](s, ptr_y, NULL, wrap_y, 8) +
2317                                 s->mecc.ildct_cmp[4](s, ptr_y + wrap_y * 8,
2318                                                      NULL, wrap_y, 8) - 400;
2319
2320             if (progressive_score > 0) {
2321                 interlaced_score = s->mecc.ildct_cmp[4](s, ptr_y,
2322                                                         NULL, wrap_y * 2, 8) +
2323                                    s->mecc.ildct_cmp[4](s, ptr_y + wrap_y,
2324                                                         NULL, wrap_y * 2, 8);
2325                 if (progressive_score > interlaced_score) {
2326                     s->interlaced_dct = 1;
2327
2328                     dct_offset = wrap_y;
2329                     uv_dct_offset = wrap_c;
2330                     wrap_y <<= 1;
2331                     if (s->chroma_format == CHROMA_422 ||
2332                         s->chroma_format == CHROMA_444)
2333                         wrap_c <<= 1;
2334                 }
2335             }
2336         }
2337
2338         s->pdsp.get_pixels(s->block[0], ptr_y,                  wrap_y);
2339         s->pdsp.get_pixels(s->block[1], ptr_y + 8,              wrap_y);
2340         s->pdsp.get_pixels(s->block[2], ptr_y + dct_offset,     wrap_y);
2341         s->pdsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
2342
2343         if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2344             skip_dct[4] = 1;
2345             skip_dct[5] = 1;
2346         } else {
2347             s->pdsp.get_pixels(s->block[4], ptr_cb, wrap_c);
2348             s->pdsp.get_pixels(s->block[5], ptr_cr, wrap_c);
2349             if (!s->chroma_y_shift && s->chroma_x_shift) { /* 422 */
2350                 s->pdsp.get_pixels(s->block[6], ptr_cb + uv_dct_offset, wrap_c);
2351                 s->pdsp.get_pixels(s->block[7], ptr_cr + uv_dct_offset, wrap_c);
2352             } else if (!s->chroma_y_shift && !s->chroma_x_shift) { /* 444 */
2353                 s->pdsp.get_pixels(s->block[ 6], ptr_cb + 8, wrap_c);
2354                 s->pdsp.get_pixels(s->block[ 7], ptr_cr + 8, wrap_c);
2355                 s->pdsp.get_pixels(s->block[ 8], ptr_cb + uv_dct_offset, wrap_c);
2356                 s->pdsp.get_pixels(s->block[ 9], ptr_cr + uv_dct_offset, wrap_c);
2357                 s->pdsp.get_pixels(s->block[10], ptr_cb + uv_dct_offset + 8, wrap_c);
2358                 s->pdsp.get_pixels(s->block[11], ptr_cr + uv_dct_offset + 8, wrap_c);
2359             }
2360         }
2361     } else {
2362         op_pixels_func (*op_pix)[4];
2363         qpel_mc_func (*op_qpix)[16];
2364         uint8_t *dest_y, *dest_cb, *dest_cr;
2365
2366         dest_y  = s->dest[0];
2367         dest_cb = s->dest[1];
2368         dest_cr = s->dest[2];
2369
2370         if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
2371             op_pix  = s->hdsp.put_pixels_tab;
2372             op_qpix = s->qdsp.put_qpel_pixels_tab;
2373         } else {
2374             op_pix  = s->hdsp.put_no_rnd_pixels_tab;
2375             op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab;
2376         }
2377
2378         if (s->mv_dir & MV_DIR_FORWARD) {
2379             ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0,
2380                           s->last_picture.f->data,
2381                           op_pix, op_qpix);
2382             op_pix  = s->hdsp.avg_pixels_tab;
2383             op_qpix = s->qdsp.avg_qpel_pixels_tab;
2384         }
2385         if (s->mv_dir & MV_DIR_BACKWARD) {
2386             ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1,
2387                           s->next_picture.f->data,
2388                           op_pix, op_qpix);
2389         }
2390
2391         if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
2392             int progressive_score, interlaced_score;
2393
2394             s->interlaced_dct = 0;
2395             progressive_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y, wrap_y, 8) +
2396                                 s->mecc.ildct_cmp[0](s, dest_y + wrap_y * 8,
2397                                                      ptr_y + wrap_y * 8,
2398                                                      wrap_y, 8) - 400;
2399
2400             if (s->avctx->ildct_cmp == FF_CMP_VSSE)
2401                 progressive_score -= 400;
2402
2403             if (progressive_score > 0) {
2404                 interlaced_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y,
2405                                                         wrap_y * 2, 8) +
2406                                    s->mecc.ildct_cmp[0](s, dest_y + wrap_y,
2407                                                         ptr_y + wrap_y,
2408                                                         wrap_y * 2, 8);
2409
2410                 if (progressive_score > interlaced_score) {
2411                     s->interlaced_dct = 1;
2412
2413                     dct_offset = wrap_y;
2414                     uv_dct_offset = wrap_c;
2415                     wrap_y <<= 1;
2416                     if (s->chroma_format == CHROMA_422)
2417                         wrap_c <<= 1;
2418                 }
2419             }
2420         }
2421
2422         s->pdsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
2423         s->pdsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2424         s->pdsp.diff_pixels(s->block[2], ptr_y + dct_offset,
2425                             dest_y + dct_offset, wrap_y);
2426         s->pdsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
2427                             dest_y + dct_offset + 8, wrap_y);
2428
2429         if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2430             skip_dct[4] = 1;
2431             skip_dct[5] = 1;
2432         } else {
2433             s->pdsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2434             s->pdsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2435             if (!s->chroma_y_shift) { /* 422 */
2436                 s->pdsp.diff_pixels(s->block[6], ptr_cb + uv_dct_offset,
2437                                     dest_cb + uv_dct_offset, wrap_c);
2438                 s->pdsp.diff_pixels(s->block[7], ptr_cr + uv_dct_offset,
2439                                     dest_cr + uv_dct_offset, wrap_c);
2440             }
2441         }
2442         /* pre quantization */
2443         if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
2444                 2 * s->qscale * s->qscale) {
2445             // FIXME optimize
2446             if (s->mecc.sad[1](NULL, ptr_y, dest_y, wrap_y, 8) < 20 * s->qscale)
2447                 skip_dct[0] = 1;
2448             if (s->mecc.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 * s->qscale)
2449                 skip_dct[1] = 1;
2450             if (s->mecc.sad[1](NULL, ptr_y + dct_offset, dest_y + dct_offset,
2451                                wrap_y, 8) < 20 * s->qscale)
2452                 skip_dct[2] = 1;
2453             if (s->mecc.sad[1](NULL, ptr_y + dct_offset + 8, dest_y + dct_offset + 8,
2454                                wrap_y, 8) < 20 * s->qscale)
2455                 skip_dct[3] = 1;
2456             if (s->mecc.sad[1](NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 * s->qscale)
2457                 skip_dct[4] = 1;
2458             if (s->mecc.sad[1](NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 * s->qscale)
2459                 skip_dct[5] = 1;
2460             if (!s->chroma_y_shift) { /* 422 */
2461                 if (s->mecc.sad[1](NULL, ptr_cb + uv_dct_offset,
2462                                    dest_cb + uv_dct_offset,
2463                                    wrap_c, 8) < 20 * s->qscale)
2464                     skip_dct[6] = 1;
2465                 if (s->mecc.sad[1](NULL, ptr_cr + uv_dct_offset,
2466                                    dest_cr + uv_dct_offset,
2467                                    wrap_c, 8) < 20 * s->qscale)
2468                     skip_dct[7] = 1;
2469             }
2470         }
2471     }
2472
2473     if (s->quantizer_noise_shaping) {
2474         if (!skip_dct[0])
2475             get_visual_weight(weight[0], ptr_y                 , wrap_y);
2476         if (!skip_dct[1])
2477             get_visual_weight(weight[1], ptr_y              + 8, wrap_y);
2478         if (!skip_dct[2])
2479             get_visual_weight(weight[2], ptr_y + dct_offset    , wrap_y);
2480         if (!skip_dct[3])
2481             get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2482         if (!skip_dct[4])
2483             get_visual_weight(weight[4], ptr_cb                , wrap_c);
2484         if (!skip_dct[5])
2485             get_visual_weight(weight[5], ptr_cr                , wrap_c);
2486         if (!s->chroma_y_shift) { /* 422 */
2487             if (!skip_dct[6])
2488                 get_visual_weight(weight[6], ptr_cb + uv_dct_offset,
2489                                   wrap_c);
2490             if (!skip_dct[7])
2491                 get_visual_weight(weight[7], ptr_cr + uv_dct_offset,
2492                                   wrap_c);
2493         }
2494         memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2495     }
2496
2497     /* DCT & quantize */
2498     av_assert2(s->out_format != FMT_MJPEG || s->qscale == 8);
2499     {
2500         for (i = 0; i < mb_block_count; i++) {
2501             if (!skip_dct[i]) {
2502                 int overflow;
2503                 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2504                 // FIXME we could decide to change to quantizer instead of
2505                 // clipping
2506                 // JS: I don't think that would be a good idea it could lower
2507                 //     quality instead of improve it. Just INTRADC clipping
2508                 //     deserves changes in quantizer
2509                 if (overflow)
2510                     clip_coeffs(s, s->block[i], s->block_last_index[i]);
2511             } else
2512                 s->block_last_index[i] = -1;
2513         }
2514         if (s->quantizer_noise_shaping) {
2515             for (i = 0; i < mb_block_count; i++) {
2516                 if (!skip_dct[i]) {
2517                     s->block_last_index[i] =
2518                         dct_quantize_refine(s, s->block[i], weight[i],
2519                                             orig[i], i, s->qscale);
2520                 }
2521             }
2522         }
2523
2524         if (s->luma_elim_threshold && !s->mb_intra)
2525             for (i = 0; i < 4; i++)
2526                 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2527         if (s->chroma_elim_threshold && !s->mb_intra)
2528             for (i = 4; i < mb_block_count; i++)
2529                 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2530
2531         if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2532             for (i = 0; i < mb_block_count; i++) {
2533                 if (s->block_last_index[i] == -1)
2534                     s->coded_score[i] = INT_MAX / 256;
2535             }
2536         }
2537     }
2538
2539     if ((s->avctx->flags & AV_CODEC_FLAG_GRAY) && s->mb_intra) {
2540         s->block_last_index[4] =
2541         s->block_last_index[5] = 0;
2542         s->block[4][0] =
2543         s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2544         if (!s->chroma_y_shift) { /* 422 / 444 */
2545             for (i=6; i<12; i++) {
2546                 s->block_last_index[i] = 0;
2547                 s->block[i][0] = s->block[4][0];
2548             }
2549         }
2550     }
2551
2552     // non c quantize code returns incorrect block_last_index FIXME
2553     if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2554         for (i = 0; i < mb_block_count; i++) {
2555             int j;
2556             if (s->block_last_index[i] > 0) {
2557                 for (j = 63; j > 0; j--) {
2558                     if (s->block[i][s->intra_scantable.permutated[j]])
2559                         break;
2560                 }
2561                 s->block_last_index[i] = j;
2562             }
2563         }
2564     }
2565
2566     /* huffman encode */
2567     switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2568     case AV_CODEC_ID_MPEG1VIDEO:
2569     case AV_CODEC_ID_MPEG2VIDEO:
2570         if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2571             ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2572         break;
2573     case AV_CODEC_ID_MPEG4:
2574         if (CONFIG_MPEG4_ENCODER)
2575             ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2576         break;
2577     case AV_CODEC_ID_MSMPEG4V2:
2578     case AV_CODEC_ID_MSMPEG4V3:
2579     case AV_CODEC_ID_WMV1:
2580         if (CONFIG_MSMPEG4_ENCODER)
2581             ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2582         break;
2583     case AV_CODEC_ID_WMV2:
2584         if (CONFIG_WMV2_ENCODER)
2585             ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2586         break;
2587     case AV_CODEC_ID_H261:
2588         if (CONFIG_H261_ENCODER)
2589             ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2590         break;
2591     case AV_CODEC_ID_H263:
2592     case AV_CODEC_ID_H263P:
2593     case AV_CODEC_ID_FLV1:
2594     case AV_CODEC_ID_RV10:
2595     case AV_CODEC_ID_RV20:
2596         if (CONFIG_H263_ENCODER)
2597             ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2598         break;
2599     case AV_CODEC_ID_MJPEG:
2600     case AV_CODEC_ID_AMV:
2601         if (CONFIG_MJPEG_ENCODER)
2602             ff_mjpeg_encode_mb(s, s->block);
2603         break;
2604     case AV_CODEC_ID_SPEEDHQ:
2605         if (CONFIG_SPEEDHQ_ENCODER)
2606             ff_speedhq_encode_mb(s, s->block);
2607         break;
2608     default:
2609         av_assert1(0);
2610     }
2611 }
2612
2613 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2614 {
2615     if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y,  8, 8, 6);
2616     else if (s->chroma_format == CHROMA_422) encode_mb_internal(s, motion_x, motion_y, 16, 8, 8);
2617     else encode_mb_internal(s, motion_x, motion_y, 16, 16, 12);
2618 }
2619
2620 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2621     int i;
2622
2623     memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2624
2625     /* MPEG-1 */
2626     d->mb_skip_run= s->mb_skip_run;
2627     for(i=0; i<3; i++)
2628         d->last_dc[i] = s->last_dc[i];
2629
2630     /* statistics */
2631     d->mv_bits= s->mv_bits;
2632     d->i_tex_bits= s->i_tex_bits;
2633     d->p_tex_bits= s->p_tex_bits;
2634     d->i_count= s->i_count;
2635     d->f_count= s->f_count;
2636     d->b_count= s->b_count;
2637     d->skip_count= s->skip_count;
2638     d->misc_bits= s->misc_bits;
2639     d->last_bits= 0;
2640
2641     d->mb_skipped= 0;
2642     d->qscale= s->qscale;
2643     d->dquant= s->dquant;
2644
2645     d->esc3_level_length= s->esc3_level_length;
2646 }
2647
2648 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2649     int i;
2650
2651     memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2652     memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2653
2654     /* MPEG-1 */
2655     d->mb_skip_run= s->mb_skip_run;
2656     for(i=0; i<3; i++)
2657         d->last_dc[i] = s->last_dc[i];
2658
2659     /* statistics */
2660     d->mv_bits= s->mv_bits;
2661     d->i_tex_bits= s->i_tex_bits;
2662     d->p_tex_bits= s->p_tex_bits;
2663     d->i_count= s->i_count;
2664     d->f_count= s->f_count;
2665     d->b_count= s->b_count;
2666     d->skip_count= s->skip_count;
2667     d->misc_bits= s->misc_bits;
2668
2669     d->mb_intra= s->mb_intra;
2670     d->mb_skipped= s->mb_skipped;
2671     d->mv_type= s->mv_type;
2672     d->mv_dir= s->mv_dir;
2673     d->pb= s->pb;
2674     if(s->data_partitioning){
2675         d->pb2= s->pb2;
2676         d->tex_pb= s->tex_pb;
2677     }
2678     d->block= s->block;
2679     for(i=0; i<8; i++)
2680         d->block_last_index[i]= s->block_last_index[i];
2681     d->interlaced_dct= s->interlaced_dct;
2682     d->qscale= s->qscale;
2683
2684     d->esc3_level_length= s->esc3_level_length;
2685 }
2686
2687 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2688                            PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2689                            int *dmin, int *next_block, int motion_x, int motion_y)
2690 {
2691     int score;
2692     uint8_t *dest_backup[3];
2693
2694     copy_context_before_encode(s, backup, type);
2695
2696     s->block= s->blocks[*next_block];
2697     s->pb= pb[*next_block];
2698     if(s->data_partitioning){
2699         s->pb2   = pb2   [*next_block];
2700         s->tex_pb= tex_pb[*next_block];
2701     }
2702
2703     if(*next_block){
2704         memcpy(dest_backup, s->dest, sizeof(s->dest));
2705         s->dest[0] = s->sc.rd_scratchpad;
2706         s->dest[1] = s->sc.rd_scratchpad + 16*s->linesize;
2707         s->dest[2] = s->sc.rd_scratchpad + 16*s->linesize + 8;
2708         av_assert0(s->linesize >= 32); //FIXME
2709     }
2710
2711     encode_mb(s, motion_x, motion_y);
2712
2713     score= put_bits_count(&s->pb);
2714     if(s->data_partitioning){
2715         score+= put_bits_count(&s->pb2);
2716         score+= put_bits_count(&s->tex_pb);
2717     }
2718
2719     if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2720         ff_mpv_reconstruct_mb(s, s->block);
2721
2722         score *= s->lambda2;
2723         score += sse_mb(s) << FF_LAMBDA_SHIFT;
2724     }
2725
2726     if(*next_block){
2727         memcpy(s->dest, dest_backup, sizeof(s->dest));
2728     }
2729
2730     if(score<*dmin){
2731         *dmin= score;
2732         *next_block^=1;
2733
2734         copy_context_after_encode(best, s, type);
2735     }
2736 }
2737
2738 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2739     const uint32_t *sq = ff_square_tab + 256;
2740     int acc=0;
2741     int x,y;
2742
2743     if(w==16 && h==16)
2744         return s->mecc.sse[0](NULL, src1, src2, stride, 16);
2745     else if(w==8 && h==8)
2746         return s->mecc.sse[1](NULL, src1, src2, stride, 8);
2747
2748     for(y=0; y<h; y++){
2749         for(x=0; x<w; x++){
2750             acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2751         }
2752     }
2753
2754     av_assert2(acc>=0);
2755
2756     return acc;
2757 }
2758
2759 static int sse_mb(MpegEncContext *s){
2760     int w= 16;
2761     int h= 16;
2762
2763     if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2764     if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2765
2766     if(w==16 && h==16)
2767       if(s->avctx->mb_cmp == FF_CMP_NSSE){
2768         return s->mecc.nsse[0](s, s->new_picture.f->data[0] + s->mb_x * 16 + s->mb_y * s->linesize   * 16, s->dest[0], s->linesize,   16) +
2769                s->mecc.nsse[1](s, s->new_picture.f->data[1] + s->mb_x *  8 + s->mb_y * s->uvlinesize *  8, s->dest[1], s->uvlinesize,  8) +
2770                s->mecc.nsse[1](s, s->new_picture.f->data[2] + s->mb_x *  8 + s->mb_y * s->uvlinesize *  8, s->dest[2], s->uvlinesize,  8);
2771       }else{
2772         return s->mecc.sse[0](NULL, s->new_picture.f->data[0] + s->mb_x * 16 + s->mb_y * s->linesize   * 16, s->dest[0], s->linesize,   16) +
2773                s->mecc.sse[1](NULL, s->new_picture.f->data[1] + s->mb_x *  8 + s->mb_y * s->uvlinesize *  8, s->dest[1], s->uvlinesize,  8) +
2774                s->mecc.sse[1](NULL, s->new_picture.f->data[2] + s->mb_x *  8 + s->mb_y * s->uvlinesize *  8, s->dest[2], s->uvlinesize,  8);
2775       }
2776     else
2777         return  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)
2778                +sse(s, s->new_picture.f->data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[1], w>>1, h>>1, s->uvlinesize)
2779                +sse(s, s->new_picture.f->data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*8,s->dest[2], w>>1, h>>1, s->uvlinesize);
2780 }
2781
2782 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2783     MpegEncContext *s= *(void**)arg;
2784
2785
2786     s->me.pre_pass=1;
2787     s->me.dia_size= s->avctx->pre_dia_size;
2788     s->first_slice_line=1;
2789     for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2790         for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2791             ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2792         }
2793         s->first_slice_line=0;
2794     }
2795
2796     s->me.pre_pass=0;
2797
2798     return 0;
2799 }
2800
2801 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2802     MpegEncContext *s= *(void**)arg;
2803
2804     s->me.dia_size= s->avctx->dia_size;
2805     s->first_slice_line=1;
2806     for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2807         s->mb_x=0; //for block init below
2808         ff_init_block_index(s);
2809         for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2810             s->block_index[0]+=2;
2811             s->block_index[1]+=2;
2812             s->block_index[2]+=2;
2813             s->block_index[3]+=2;
2814
2815             /* compute motion vector & mb_type and store in context */
2816             if(s->pict_type==AV_PICTURE_TYPE_B)
2817                 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2818             else
2819                 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2820         }
2821         s->first_slice_line=0;
2822     }
2823     return 0;
2824 }
2825
2826 static int mb_var_thread(AVCodecContext *c, void *arg){
2827     MpegEncContext *s= *(void**)arg;
2828     int mb_x, mb_y;
2829
2830     for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2831         for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2832             int xx = mb_x * 16;
2833             int yy = mb_y * 16;
2834             uint8_t *pix = s->new_picture.f->data[0] + (yy * s->linesize) + xx;
2835             int varc;
2836             int sum = s->mpvencdsp.pix_sum(pix, s->linesize);
2837
2838             varc = (s->mpvencdsp.pix_norm1(pix, s->linesize) -
2839                     (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2840
2841             s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2842             s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2843             s->me.mb_var_sum_temp    += varc;
2844         }
2845     }
2846     return 0;
2847 }
2848
2849 static void write_slice_end(MpegEncContext *s){
2850     if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2851         if(s->partitioned_frame){
2852             ff_mpeg4_merge_partitions(s);
2853         }
2854
2855         ff_mpeg4_stuffing(&s->pb);
2856     }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2857         ff_mjpeg_encode_stuffing(s);
2858     } else if (CONFIG_SPEEDHQ_ENCODER && s->out_format == FMT_SPEEDHQ) {
2859         ff_speedhq_end_slice(s);
2860     }
2861
2862     flush_put_bits(&s->pb);
2863
2864     if ((s->avctx->flags & AV_CODEC_FLAG_PASS1) && !s->partitioned_frame)
2865         s->misc_bits+= get_bits_diff(s);
2866 }
2867
2868 static void write_mb_info(MpegEncContext *s)
2869 {
2870     uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2871     int offset = put_bits_count(&s->pb);
2872     int mba  = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2873     int gobn = s->mb_y / s->gob_index;
2874     int pred_x, pred_y;
2875     if (CONFIG_H263_ENCODER)
2876         ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2877     bytestream_put_le32(&ptr, offset);
2878     bytestream_put_byte(&ptr, s->qscale);
2879     bytestream_put_byte(&ptr, gobn);
2880     bytestream_put_le16(&ptr, mba);
2881     bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2882     bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2883     /* 4MV not implemented */
2884     bytestream_put_byte(&ptr, 0); /* hmv2 */
2885     bytestream_put_byte(&ptr, 0); /* vmv2 */
2886 }
2887
2888 static void update_mb_info(MpegEncContext *s, int startcode)
2889 {
2890     if (!s->mb_info)
2891         return;
2892     if (put_bytes_count(&s->pb, 0) - s->prev_mb_info >= s->mb_info) {
2893         s->mb_info_size += 12;
2894         s->prev_mb_info = s->last_mb_info;
2895     }
2896     if (startcode) {
2897         s->prev_mb_info = put_bytes_count(&s->pb, 0);
2898         /* This might have incremented mb_info_size above, and we return without
2899          * actually writing any info into that slot yet. But in that case,
2900          * this will be called again at the start of the after writing the
2901          * start code, actually writing the mb info. */
2902         return;
2903     }
2904
2905     s->last_mb_info = put_bytes_count(&s->pb, 0);
2906     if (!s->mb_info_size)
2907         s->mb_info_size += 12;
2908     write_mb_info(s);
2909 }
2910
2911 int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t size_increase)
2912 {
2913     if (put_bytes_left(&s->pb, 0) < threshold
2914         && s->slice_context_count == 1
2915         && s->pb.buf == s->avctx->internal->byte_buffer) {
2916         int lastgob_pos = s->ptr_lastgob - s->pb.buf;
2917         int vbv_pos     = s->vbv_delay_ptr - s->pb.buf;
2918
2919         uint8_t *new_buffer = NULL;
2920         int new_buffer_size = 0;
2921
2922         if ((s->avctx->internal->byte_buffer_size + size_increase) >= INT_MAX/8) {
2923             av_log(s->avctx, AV_LOG_ERROR, "Cannot reallocate putbit buffer\n");
2924             return AVERROR(ENOMEM);
2925         }
2926
2927         emms_c();
2928
2929         av_fast_padded_malloc(&new_buffer, &new_buffer_size,
2930                               s->avctx->internal->byte_buffer_size + size_increase);
2931         if (!new_buffer)
2932             return AVERROR(ENOMEM);
2933
2934         memcpy(new_buffer, s->avctx->internal->byte_buffer, s->avctx->internal->byte_buffer_size);
2935         av_free(s->avctx->internal->byte_buffer);
2936         s->avctx->internal->byte_buffer      = new_buffer;
2937         s->avctx->internal->byte_buffer_size = new_buffer_size;
2938         rebase_put_bits(&s->pb, new_buffer, new_buffer_size);
2939         s->ptr_lastgob   = s->pb.buf + lastgob_pos;
2940         s->vbv_delay_ptr = s->pb.buf + vbv_pos;
2941     }
2942     if (put_bytes_left(&s->pb, 0) < threshold)
2943         return AVERROR(EINVAL);
2944     return 0;
2945 }
2946
2947 static int encode_thread(AVCodecContext *c, void *arg){
2948     MpegEncContext *s= *(void**)arg;
2949     int mb_x, mb_y, mb_y_order;
2950     int chr_h= 16>>s->chroma_y_shift;
2951     int i, j;
2952     MpegEncContext best_s = { 0 }, backup_s;
2953     uint8_t bit_buf[2][MAX_MB_BYTES];
2954     uint8_t bit_buf2[2][MAX_MB_BYTES];
2955     uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2956     PutBitContext pb[2], pb2[2], tex_pb[2];
2957
2958     for(i=0; i<2; i++){
2959         init_put_bits(&pb    [i], bit_buf    [i], MAX_MB_BYTES);
2960         init_put_bits(&pb2   [i], bit_buf2   [i], MAX_MB_BYTES);
2961         init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2962     }
2963
2964     s->last_bits= put_bits_count(&s->pb);
2965     s->mv_bits=0;
2966     s->misc_bits=0;
2967     s->i_tex_bits=0;
2968     s->p_tex_bits=0;
2969     s->i_count=0;
2970     s->f_count=0;
2971     s->b_count=0;
2972     s->skip_count=0;
2973
2974     for(i=0; i<3; i++){
2975         /* init last dc values */
2976         /* note: quant matrix value (8) is implied here */
2977         s->last_dc[i] = 128 << s->intra_dc_precision;
2978
2979         s->current_picture.encoding_error[i] = 0;
2980     }
2981     if(s->codec_id==AV_CODEC_ID_AMV){
2982         s->last_dc[0] = 128*8/13;
2983         s->last_dc[1] = 128*8/14;
2984         s->last_dc[2] = 128*8/14;
2985     }
2986     s->mb_skip_run = 0;
2987     memset(s->last_mv, 0, sizeof(s->last_mv));
2988
2989     s->last_mv_dir = 0;
2990
2991     switch(s->codec_id){
2992     case AV_CODEC_ID_H263:
2993     case AV_CODEC_ID_H263P:
2994     case AV_CODEC_ID_FLV1:
2995         if (CONFIG_H263_ENCODER)
2996             s->gob_index = H263_GOB_HEIGHT(s->height);
2997         break;
2998     case AV_CODEC_ID_MPEG4:
2999         if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
3000             ff_mpeg4_init_partitions(s);
3001         break;
3002     }
3003
3004     s->resync_mb_x=0;
3005     s->resync_mb_y=0;
3006     s->first_slice_line = 1;
3007     s->ptr_lastgob = s->pb.buf;
3008     for (mb_y_order = s->start_mb_y; mb_y_order < s->end_mb_y; mb_y_order++) {
3009         if (CONFIG_SPEEDHQ_ENCODER && s->codec_id == AV_CODEC_ID_SPEEDHQ) {
3010             int first_in_slice;
3011             mb_y = ff_speedhq_mb_y_order_to_mb(mb_y_order, s->mb_height, &first_in_slice);
3012             if (first_in_slice && mb_y_order != s->start_mb_y)
3013                 ff_speedhq_end_slice(s);
3014             s->last_dc[0] = s->last_dc[1] = s->last_dc[2] = 1024 << s->intra_dc_precision;
3015         } else {
3016             mb_y = mb_y_order;
3017         }
3018         s->mb_x=0;
3019         s->mb_y= mb_y;
3020
3021         ff_set_qscale(s, s->qscale);
3022         ff_init_block_index(s);
3023
3024         for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3025             int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
3026             int mb_type= s->mb_type[xy];
3027 //            int d;
3028             int dmin= INT_MAX;
3029             int dir;
3030             int size_increase =  s->avctx->internal->byte_buffer_size/4
3031                                + s->mb_width*MAX_MB_BYTES;
3032
3033             ff_mpv_reallocate_putbitbuffer(s, MAX_MB_BYTES, size_increase);
3034             if (put_bytes_left(&s->pb, 0) < MAX_MB_BYTES){
3035                 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
3036                 return -1;
3037             }
3038             if(s->data_partitioning){
3039                 if (put_bytes_left(&s->pb2,    0) < MAX_MB_BYTES ||
3040                     put_bytes_left(&s->tex_pb, 0) < MAX_MB_BYTES) {
3041                     av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
3042                     return -1;
3043                 }
3044             }
3045
3046             s->mb_x = mb_x;
3047             s->mb_y = mb_y;  // moved into loop, can get changed by H.261
3048             ff_update_block_index(s);
3049
3050             if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
3051                 ff_h261_reorder_mb_index(s);
3052                 xy= s->mb_y*s->mb_stride + s->mb_x;
3053                 mb_type= s->mb_type[xy];
3054             }
3055
3056             /* write gob / video packet header  */
3057             if(s->rtp_mode){
3058                 int current_packet_size, is_gob_start;
3059
3060                 current_packet_size = put_bytes_count(&s->pb, 1)
3061                                       - (s->ptr_lastgob - s->pb.buf);
3062
3063                 is_gob_start = s->rtp_payload_size &&
3064                                current_packet_size >= s->rtp_payload_size &&
3065                                mb_y + mb_x > 0;
3066
3067                 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
3068
3069                 switch(s->codec_id){
3070                 case AV_CODEC_ID_H263:
3071                 case AV_CODEC_ID_H263P:
3072                     if(!s->h263_slice_structured)
3073                         if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
3074                     break;
3075                 case AV_CODEC_ID_MPEG2VIDEO:
3076                     if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
3077                 case AV_CODEC_ID_MPEG1VIDEO:
3078                     if(s->mb_skip_run) is_gob_start=0;
3079                     break;
3080                 case AV_CODEC_ID_MJPEG:
3081                     if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
3082                     break;
3083                 }
3084
3085                 if(is_gob_start){
3086                     if(s->start_mb_y != mb_y || mb_x!=0){
3087                         write_slice_end(s);
3088
3089                         if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
3090                             ff_mpeg4_init_partitions(s);
3091                         }
3092                     }
3093
3094                     av_assert2((put_bits_count(&s->pb)&7) == 0);
3095                     current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
3096
3097                     if (s->error_rate && s->resync_mb_x + s->resync_mb_y > 0) {
3098                         int r = put_bytes_count(&s->pb, 0) + s->picture_number + 16 + s->mb_x + s->mb_y;
3099                         int d = 100 / s->error_rate;
3100                         if(r % d == 0){
3101                             current_packet_size=0;
3102                             s->pb.buf_ptr= s->ptr_lastgob;
3103                             av_assert1(put_bits_ptr(&s->pb) == s->ptr_lastgob);
3104                         }
3105                     }
3106
3107 #if FF_API_RTP_CALLBACK
3108 FF_DISABLE_DEPRECATION_WARNINGS
3109                     if (s->avctx->rtp_callback){
3110                         int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
3111                         s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
3112                     }
3113 FF_ENABLE_DEPRECATION_WARNINGS
3114 #endif
3115                     update_mb_info(s, 1);
3116
3117                     switch(s->codec_id){
3118                     case AV_CODEC_ID_MPEG4:
3119                         if (CONFIG_MPEG4_ENCODER) {
3120                             ff_mpeg4_encode_video_packet_header(s);
3121                             ff_mpeg4_clean_buffers(s);
3122                         }
3123                     break;
3124                     case AV_CODEC_ID_MPEG1VIDEO:
3125                     case AV_CODEC_ID_MPEG2VIDEO:
3126                         if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
3127                             ff_mpeg1_encode_slice_header(s);
3128                             ff_mpeg1_clean_buffers(s);
3129                         }
3130                     break;
3131                     case AV_CODEC_ID_H263:
3132                     case AV_CODEC_ID_H263P:
3133                         if (CONFIG_H263_ENCODER)
3134                             ff_h263_encode_gob_header(s, mb_y);
3135                     break;
3136                     }
3137
3138                     if (s->avctx->flags & AV_CODEC_FLAG_PASS1) {
3139                         int bits= put_bits_count(&s->pb);
3140                         s->misc_bits+= bits - s->last_bits;
3141                         s->last_bits= bits;
3142                     }
3143
3144                     s->ptr_lastgob += current_packet_size;
3145                     s->first_slice_line=1;
3146                     s->resync_mb_x=mb_x;
3147                     s->resync_mb_y=mb_y;
3148                 }
3149             }
3150
3151             if(  (s->resync_mb_x   == s->mb_x)
3152                && s->resync_mb_y+1 == s->mb_y){
3153                 s->first_slice_line=0;
3154             }
3155
3156             s->mb_skipped=0;
3157             s->dquant=0; //only for QP_RD
3158
3159             update_mb_info(s, 0);
3160
3161             if (mb_type & (mb_type-1) || (s->mpv_flags & FF_MPV_FLAG_QP_RD)) { // more than 1 MB type possible or FF_MPV_FLAG_QP_RD
3162                 int next_block=0;
3163                 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
3164
3165                 copy_context_before_encode(&backup_s, s, -1);
3166                 backup_s.pb= s->pb;
3167                 best_s.data_partitioning= s->data_partitioning;
3168                 best_s.partitioned_frame= s->partitioned_frame;
3169                 if(s->data_partitioning){
3170                     backup_s.pb2= s->pb2;
3171                     backup_s.tex_pb= s->tex_pb;
3172                 }
3173
3174                 if(mb_type&CANDIDATE_MB_TYPE_INTER){
3175                     s->mv_dir = MV_DIR_FORWARD;
3176                     s->mv_type = MV_TYPE_16X16;
3177                     s->mb_intra= 0;
3178                     s->mv[0][0][0] = s->p_mv_table[xy][0];
3179                     s->mv[0][0][1] = s->p_mv_table[xy][1];
3180                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
3181                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3182                 }
3183                 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
3184                     s->mv_dir = MV_DIR_FORWARD;
3185                     s->mv_type = MV_TYPE_FIELD;
3186                     s->mb_intra= 0;
3187                     for(i=0; i<2; i++){
3188                         j= s->field_select[0][i] = s->p_field_select_table[i][xy];
3189                         s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
3190                         s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
3191                     }
3192                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
3193                                  &dmin, &next_block, 0, 0);
3194                 }
3195                 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
3196                     s->mv_dir = MV_DIR_FORWARD;
3197                     s->mv_type = MV_TYPE_16X16;
3198                     s->mb_intra= 0;
3199                     s->mv[0][0][0] = 0;
3200                     s->mv[0][0][1] = 0;
3201                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
3202                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3203                 }
3204                 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
3205                     s->mv_dir = MV_DIR_FORWARD;
3206                     s->mv_type = MV_TYPE_8X8;
3207                     s->mb_intra= 0;
3208                     for(i=0; i<4; i++){
3209                         s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
3210                         s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3211                     }
3212                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
3213                                  &dmin, &next_block, 0, 0);
3214                 }
3215                 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
3216                     s->mv_dir = MV_DIR_FORWARD;
3217                     s->mv_type = MV_TYPE_16X16;
3218                     s->mb_intra= 0;
3219                     s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3220                     s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3221                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
3222                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
3223                 }
3224                 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
3225                     s->mv_dir = MV_DIR_BACKWARD;
3226                     s->mv_type = MV_TYPE_16X16;
3227                     s->mb_intra= 0;
3228                     s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3229                     s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3230                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
3231                                  &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
3232                 }
3233                 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
3234                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3235                     s->mv_type = MV_TYPE_16X16;
3236                     s->mb_intra= 0;
3237                     s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3238                     s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3239                     s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3240                     s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3241                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
3242                                  &dmin, &next_block, 0, 0);
3243                 }
3244                 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
3245                     s->mv_dir = MV_DIR_FORWARD;
3246                     s->mv_type = MV_TYPE_FIELD;
3247                     s->mb_intra= 0;
3248                     for(i=0; i<2; i++){
3249                         j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3250                         s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3251                         s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3252                     }
3253                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
3254                                  &dmin, &next_block, 0, 0);
3255                 }
3256                 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
3257                     s->mv_dir = MV_DIR_BACKWARD;
3258                     s->mv_type = MV_TYPE_FIELD;
3259                     s->mb_intra= 0;
3260                     for(i=0; i<2; i++){
3261                         j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3262                         s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3263                         s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3264                     }
3265                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
3266                                  &dmin, &next_block, 0, 0);
3267                 }
3268                 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
3269                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3270                     s->mv_type = MV_TYPE_FIELD;
3271                     s->mb_intra= 0;
3272                     for(dir=0; dir<2; dir++){
3273                         for(i=0; i<2; i++){
3274                             j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3275                             s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3276                             s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3277                         }
3278                     }
3279                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
3280                                  &dmin, &next_block, 0, 0);
3281                 }
3282                 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
3283                     s->mv_dir = 0;
3284                     s->mv_type = MV_TYPE_16X16;
3285                     s->mb_intra= 1;
3286                     s->mv[0][0][0] = 0;
3287                     s->mv[0][0][1] = 0;
3288                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
3289                                  &dmin, &next_block, 0, 0);
3290                     if(s->h263_pred || s->h263_aic){
3291                         if(best_s.mb_intra)
3292                             s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
3293                         else
3294                             ff_clean_intra_table_entries(s); //old mode?
3295                     }
3296                 }
3297
3298                 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
3299                     if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
3300                         const int last_qp= backup_s.qscale;
3301                         int qpi, qp, dc[6];
3302                         int16_t ac[6][16];
3303                         const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
3304                         static const int dquant_tab[4]={-1,1,-2,2};
3305                         int storecoefs = s->mb_intra && s->dc_val[0];
3306
3307                         av_assert2(backup_s.dquant == 0);
3308
3309                         //FIXME intra
3310                         s->mv_dir= best_s.mv_dir;
3311                         s->mv_type = MV_TYPE_16X16;
3312                         s->mb_intra= best_s.mb_intra;
3313                         s->mv[0][0][0] = best_s.mv[0][0][0];
3314                         s->mv[0][0][1] = best_s.mv[0][0][1];
3315                         s->mv[1][0][0] = best_s.mv[1][0][0];
3316                         s->mv[1][0][1] = best_s.mv[1][0][1];
3317
3318                         qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
3319                         for(; qpi<4; qpi++){
3320                             int dquant= dquant_tab[qpi];
3321                             qp= last_qp + dquant;
3322                             if(qp < s->avctx->qmin || qp > s->avctx->qmax)
3323                                 continue;
3324                             backup_s.dquant= dquant;
3325                             if(storecoefs){
3326                                 for(i=0; i<6; i++){
3327                                     dc[i]= s->dc_val[0][ s->block_index[i] ];
3328                                     memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
3329                                 }
3330                             }
3331
3332                             encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
3333                                          &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
3334                             if(best_s.qscale != qp){
3335                                 if(storecoefs){
3336                                     for(i=0; i<6; i++){
3337                                         s->dc_val[0][ s->block_index[i] ]= dc[i];
3338                                         memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
3339                                     }
3340                                 }
3341                             }
3342                         }
3343                     }
3344                 }
3345                 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
3346                     int mx= s->b_direct_mv_table[xy][0];
3347                     int my= s->b_direct_mv_table[xy][1];
3348
3349                     backup_s.dquant = 0;
3350                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3351                     s->mb_intra= 0;
3352                     ff_mpeg4_set_direct_mv(s, mx, my);
3353                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
3354                                  &dmin, &next_block, mx, my);
3355                 }
3356                 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
3357                     backup_s.dquant = 0;
3358                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
3359                     s->mb_intra= 0;
3360                     ff_mpeg4_set_direct_mv(s, 0, 0);
3361                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
3362                                  &dmin, &next_block, 0, 0);
3363                 }
3364                 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
3365                     int coded=0;
3366                     for(i=0; i<6; i++)
3367                         coded |= s->block_last_index[i];
3368                     if(coded){
3369                         int mx,my;
3370                         memcpy(s->mv, best_s.mv, sizeof(s->mv));
3371                         if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
3372                             mx=my=0; //FIXME find the one we actually used
3373                             ff_mpeg4_set_direct_mv(s, mx, my);
3374                         }else if(best_s.mv_dir&MV_DIR_BACKWARD){
3375                             mx= s->mv[1][0][0];
3376                             my= s->mv[1][0][1];
3377                         }else{
3378                             mx= s->mv[0][0][0];
3379                             my= s->mv[0][0][1];
3380                         }
3381
3382                         s->mv_dir= best_s.mv_dir;
3383                         s->mv_type = best_s.mv_type;
3384                         s->mb_intra= 0;
3385 /*                        s->mv[0][0][0] = best_s.mv[0][0][0];
3386                         s->mv[0][0][1] = best_s.mv[0][0][1];
3387                         s->mv[1][0][0] = best_s.mv[1][0][0];
3388                         s->mv[1][0][1] = best_s.mv[1][0][1];*/
3389                         backup_s.dquant= 0;
3390                         s->skipdct=1;
3391                         encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
3392                                         &dmin, &next_block, mx, my);
3393                         s->skipdct=0;
3394                     }
3395                 }
3396
3397                 s->current_picture.qscale_table[xy] = best_s.qscale;
3398
3399                 copy_context_after_encode(s, &best_s, -1);
3400
3401                 pb_bits_count= put_bits_count(&s->pb);
3402                 flush_put_bits(&s->pb);
3403                 ff_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
3404                 s->pb= backup_s.pb;
3405
3406                 if(s->data_partitioning){
3407                     pb2_bits_count= put_bits_count(&s->pb2);
3408                     flush_put_bits(&s->pb2);
3409                     ff_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
3410                     s->pb2= backup_s.pb2;
3411
3412                     tex_pb_bits_count= put_bits_count(&s->tex_pb);
3413                     flush_put_bits(&s->tex_pb);
3414                     ff_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
3415                     s->tex_pb= backup_s.tex_pb;
3416                 }
3417                 s->last_bits= put_bits_count(&s->pb);
3418
3419                 if (CONFIG_H263_ENCODER &&
3420                     s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3421                     ff_h263_update_motion_val(s);
3422
3423                 if(next_block==0){ //FIXME 16 vs linesize16
3424                     s->hdsp.put_pixels_tab[0][0](s->dest[0], s->sc.rd_scratchpad                     , s->linesize  ,16);
3425                     s->hdsp.put_pixels_tab[1][0](s->dest[1], s->sc.rd_scratchpad + 16*s->linesize    , s->uvlinesize, 8);
3426                     s->hdsp.put_pixels_tab[1][0](s->dest[2], s->sc.rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
3427                 }
3428
3429                 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
3430                     ff_mpv_reconstruct_mb(s, s->block);
3431             } else {
3432                 int motion_x = 0, motion_y = 0;
3433                 s->mv_type=MV_TYPE_16X16;
3434                 // only one MB-Type possible
3435
3436                 switch(mb_type){
3437                 case CANDIDATE_MB_TYPE_INTRA:
3438                     s->mv_dir = 0;
3439                     s->mb_intra= 1;
3440                     motion_x= s->mv[0][0][0] = 0;
3441                     motion_y= s->mv[0][0][1] = 0;
3442                     break;
3443                 case CANDIDATE_MB_TYPE_INTER:
3444                     s->mv_dir = MV_DIR_FORWARD;
3445                     s->mb_intra= 0;
3446                     motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3447                     motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3448                     break;
3449                 case CANDIDATE_MB_TYPE_INTER_I:
3450                     s->mv_dir = MV_DIR_FORWARD;
3451                     s->mv_type = MV_TYPE_FIELD;
3452                     s->mb_intra= 0;
3453                     for(i=0; i<2; i++){
3454                         j= s->field_select[0][i] = s->p_field_select_table[i][xy];
3455                         s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
3456                         s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
3457                     }
3458                     break;
3459                 case CANDIDATE_MB_TYPE_INTER4V:
3460                     s->mv_dir = MV_DIR_FORWARD;
3461                     s->mv_type = MV_TYPE_8X8;
3462                     s->mb_intra= 0;
3463                     for(i=0; i<4; i++){
3464                         s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
3465                         s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3466                     }
3467                     break;
3468                 case CANDIDATE_MB_TYPE_DIRECT:
3469                     if (CONFIG_MPEG4_ENCODER) {
3470                         s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3471                         s->mb_intra= 0;
3472                         motion_x=s->b_direct_mv_table[xy][0];
3473                         motion_y=s->b_direct_mv_table[xy][1];
3474                         ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3475                     }
3476                     break;
3477                 case CANDIDATE_MB_TYPE_DIRECT0:
3478                     if (CONFIG_MPEG4_ENCODER) {
3479                         s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3480                         s->mb_intra= 0;
3481                         ff_mpeg4_set_direct_mv(s, 0, 0);
3482                     }
3483                     break;
3484                 case CANDIDATE_MB_TYPE_BIDIR:
3485                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3486                     s->mb_intra= 0;
3487                     s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3488                     s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3489                     s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3490                     s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3491                     break;
3492                 case CANDIDATE_MB_TYPE_BACKWARD:
3493                     s->mv_dir = MV_DIR_BACKWARD;
3494                     s->mb_intra= 0;
3495                     motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3496                     motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3497                     break;
3498                 case CANDIDATE_MB_TYPE_FORWARD:
3499                     s->mv_dir = MV_DIR_FORWARD;
3500                     s->mb_intra= 0;
3501                     motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3502                     motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3503                     break;
3504                 case CANDIDATE_MB_TYPE_FORWARD_I:
3505                     s->mv_dir = MV_DIR_FORWARD;
3506                     s->mv_type = MV_TYPE_FIELD;
3507                     s->mb_intra= 0;
3508                     for(i=0; i<2; i++){
3509                         j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3510                         s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3511                         s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3512                     }
3513                     break;
3514                 case CANDIDATE_MB_TYPE_BACKWARD_I:
3515                     s->mv_dir = MV_DIR_BACKWARD;
3516                     s->mv_type = MV_TYPE_FIELD;
3517                     s->mb_intra= 0;
3518                     for(i=0; i<2; i++){
3519                         j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3520                         s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3521                         s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3522                     }
3523                     break;
3524                 case CANDIDATE_MB_TYPE_BIDIR_I:
3525                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3526                     s->mv_type = MV_TYPE_FIELD;
3527                     s->mb_intra= 0;
3528                     for(dir=0; dir<2; dir++){
3529                         for(i=0; i<2; i++){
3530                             j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3531                             s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3532                             s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3533                         }
3534                     }
3535                     break;
3536                 default:
3537                     av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3538                 }
3539
3540                 encode_mb(s, motion_x, motion_y);
3541
3542                 // RAL: Update last macroblock type
3543                 s->last_mv_dir = s->mv_dir;
3544
3545                 if (CONFIG_H263_ENCODER &&
3546                     s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3547                     ff_h263_update_motion_val(s);
3548
3549                 ff_mpv_reconstruct_mb(s, s->block);
3550             }
3551
3552             /* clean the MV table in IPS frames for direct mode in B-frames */
3553             if(s->mb_intra /* && I,P,S_TYPE */){
3554                 s->p_mv_table[xy][0]=0;
3555                 s->p_mv_table[xy][1]=0;
3556             }
3557
3558             if (s->avctx->flags & AV_CODEC_FLAG_PSNR) {
3559                 int w= 16;
3560                 int h= 16;
3561
3562                 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3563                 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3564
3565                 s->current_picture.encoding_error[0] += sse(
3566                     s, s->new_picture.f->data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3567                     s->dest[0], w, h, s->linesize);
3568                 s->current_picture.encoding_error[1] += sse(
3569                     s, s->new_picture.f->data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*chr_h,
3570                     s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3571                 s->current_picture.encoding_error[2] += sse(
3572                     s, s->new_picture.f->data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*chr_h,
3573                     s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3574             }
3575             if(s->loop_filter){
3576                 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3577                     ff_h263_loop_filter(s);
3578             }
3579             ff_dlog(s->avctx, "MB %d %d bits\n",
3580                     s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3581         }
3582     }
3583
3584     //not beautiful here but we must write it before flushing so it has to be here
3585     if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3586         ff_msmpeg4_encode_ext_header(s);
3587
3588     write_slice_end(s);
3589
3590 #if FF_API_RTP_CALLBACK
3591 FF_DISABLE_DEPRECATION_WARNINGS
3592     /* Send the last GOB if RTP */
3593     if (s->avctx->rtp_callback) {
3594         int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3595         int pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3596         /* Call the RTP callback to send the last GOB */
3597         emms_c();
3598         s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3599     }
3600 FF_ENABLE_DEPRECATION_WARNINGS
3601 #endif
3602
3603     return 0;
3604 }
3605
3606 #define MERGE(field) dst->field += src->field; src->field=0
3607 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3608     MERGE(me.scene_change_score);
3609     MERGE(me.mc_mb_var_sum_temp);
3610     MERGE(me.mb_var_sum_temp);
3611 }
3612
3613 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3614     int i;
3615
3616     MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3617     MERGE(dct_count[1]);
3618     MERGE(mv_bits);
3619     MERGE(i_tex_bits);
3620     MERGE(p_tex_bits);
3621     MERGE(i_count);
3622     MERGE(f_count);
3623     MERGE(b_count);
3624     MERGE(skip_count);
3625     MERGE(misc_bits);
3626     MERGE(er.error_count);
3627     MERGE(padding_bug_score);
3628     MERGE(current_picture.encoding_error[0]);
3629     MERGE(current_picture.encoding_error[1]);
3630     MERGE(current_picture.encoding_error[2]);
3631
3632     if (dst->noise_reduction){
3633         for(i=0; i<64; i++){
3634             MERGE(dct_error_sum[0][i]);
3635             MERGE(dct_error_sum[1][i]);
3636         }
3637     }
3638
3639     av_assert1(put_bits_count(&src->pb) % 8 ==0);
3640     av_assert1(put_bits_count(&dst->pb) % 8 ==0);
3641     ff_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3642     flush_put_bits(&dst->pb);
3643 }
3644
3645 static int estimate_qp(MpegEncContext *s, int dry_run){
3646     if (s->next_lambda){
3647         s->current_picture_ptr->f->quality =
3648         s->current_picture.f->quality = s->next_lambda;
3649         if(!dry_run) s->next_lambda= 0;
3650     } else if (!s->fixed_qscale) {
3651         int quality = ff_rate_estimate_qscale(s, dry_run);
3652         s->current_picture_ptr->f->quality =
3653         s->current_picture.f->quality = quality;
3654         if (s->current_picture.f->quality < 0)
3655             return -1;
3656     }
3657
3658     if(s->adaptive_quant){
3659         switch(s->codec_id){
3660         case AV_CODEC_ID_MPEG4:
3661             if (CONFIG_MPEG4_ENCODER)
3662                 ff_clean_mpeg4_qscales(s);
3663             break;
3664         case AV_CODEC_ID_H263:
3665         case AV_CODEC_ID_H263P:
3666         case AV_CODEC_ID_FLV1:
3667             if (CONFIG_H263_ENCODER)
3668                 ff_clean_h263_qscales(s);
3669             break;
3670         default:
3671             ff_init_qscale_tab(s);
3672         }
3673
3674         s->lambda= s->lambda_table[0];
3675         //FIXME broken
3676     }else
3677         s->lambda = s->current_picture.f->quality;
3678     update_qscale(s);
3679     return 0;
3680 }
3681
3682 /* must be called before writing the header */
3683 static void set_frame_distances(MpegEncContext * s){
3684     av_assert1(s->current_picture_ptr->f->pts != AV_NOPTS_VALUE);
3685     s->time = s->current_picture_ptr->f->pts * s->avctx->time_base.num;
3686
3687     if(s->pict_type==AV_PICTURE_TYPE_B){
3688         s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3689         av_assert1(s->pb_time > 0 && s->pb_time < s->pp_time);
3690     }else{
3691         s->pp_time= s->time - s->last_non_b_time;
3692         s->last_non_b_time= s->time;
3693         av_assert1(s->picture_number==0 || s->pp_time > 0);
3694     }
3695 }
3696
3697 static int encode_picture(MpegEncContext *s, int picture_number)
3698 {
3699     int i, ret;
3700     int bits;
3701     int context_count = s->slice_context_count;
3702
3703     s->picture_number = picture_number;
3704
3705     /* Reset the average MB variance */
3706     s->me.mb_var_sum_temp    =
3707     s->me.mc_mb_var_sum_temp = 0;
3708
3709     /* we need to initialize some time vars before we can encode B-frames */
3710     // RAL: Condition added for MPEG1VIDEO
3711     if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3712         set_frame_distances(s);
3713     if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3714         ff_set_mpeg4_time(s);
3715
3716     s->me.scene_change_score=0;
3717
3718 //    s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3719
3720     if(s->pict_type==AV_PICTURE_TYPE_I){
3721         if(s->msmpeg4_version >= 3) s->no_rounding=1;
3722         else                        s->no_rounding=0;
3723     }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3724         if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3725             s->no_rounding ^= 1;
3726     }
3727
3728     if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
3729         if (estimate_qp(s,1) < 0)
3730             return -1;
3731         ff_get_2pass_fcode(s);
3732     } else if (!(s->avctx->flags & AV_CODEC_FLAG_QSCALE)) {
3733         if(s->pict_type==AV_PICTURE_TYPE_B)
3734             s->lambda= s->last_lambda_for[s->pict_type];
3735         else
3736             s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3737         update_qscale(s);
3738     }
3739
3740     if(s->codec_id != AV_CODEC_ID_AMV && s->codec_id != AV_CODEC_ID_MJPEG){
3741         if(s->q_chroma_intra_matrix   != s->q_intra_matrix  ) av_freep(&s->q_chroma_intra_matrix);
3742         if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
3743         s->q_chroma_intra_matrix   = s->q_intra_matrix;
3744         s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
3745     }
3746
3747     s->mb_intra=0; //for the rate distortion & bit compare functions
3748     for(i=1; i<context_count; i++){
3749         ret = ff_update_duplicate_context(s->thread_context[i], s);
3750         if (ret < 0)
3751             return ret;
3752     }
3753
3754     if(ff_init_me(s)<0)
3755         return -1;
3756
3757     /* Estimate motion for every MB */
3758     if(s->pict_type != AV_PICTURE_TYPE_I){
3759         s->lambda  = (s->lambda  * s->me_penalty_compensation + 128) >> 8;
3760         s->lambda2 = (s->lambda2 * (int64_t) s->me_penalty_compensation + 128) >> 8;
3761         if (s->pict_type != AV_PICTURE_TYPE_B) {
3762             if ((s->me_pre && s->last_non_b_pict_type == AV_PICTURE_TYPE_I) ||
3763                 s->me_pre == 2) {
3764                 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3765             }
3766         }
3767
3768         s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3769     }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3770         /* I-Frame */
3771         for(i=0; i<s->mb_stride*s->mb_height; i++)
3772             s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3773
3774         if(!s->fixed_qscale){
3775             /* finding spatial complexity for I-frame rate control */
3776             s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3777         }
3778     }
3779     for(i=1; i<context_count; i++){
3780         merge_context_after_me(s, s->thread_context[i]);
3781     }
3782     s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3783     s->current_picture.   mb_var_sum= s->current_picture_ptr->   mb_var_sum= s->me.   mb_var_sum_temp;
3784     emms_c();
3785
3786     if (s->me.scene_change_score > s->scenechange_threshold &&
3787         s->pict_type == AV_PICTURE_TYPE_P) {
3788         s->pict_type= AV_PICTURE_TYPE_I;
3789         for(i=0; i<s->mb_stride*s->mb_height; i++)
3790             s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3791         if(s->msmpeg4_version >= 3)
3792             s->no_rounding=1;
3793         ff_dlog(s, "Scene change detected, encoding as I Frame %"PRId64" %"PRId64"\n",
3794                 s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3795     }
3796
3797     if(!s->umvplus){
3798         if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3799             s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3800
3801             if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME) {
3802                 int a,b;
3803                 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3804                 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3805                 s->f_code= FFMAX3(s->f_code, a, b);
3806             }
3807
3808             ff_fix_long_p_mvs(s, s->intra_penalty ? CANDIDATE_MB_TYPE_INTER : CANDIDATE_MB_TYPE_INTRA);
3809             ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, !!s->intra_penalty);
3810             if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME) {
3811                 int j;
3812                 for(i=0; i<2; i++){
3813                     for(j=0; j<2; j++)
3814                         ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3815                                         s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, !!s->intra_penalty);
3816                 }
3817             }
3818         }
3819
3820         if(s->pict_type==AV_PICTURE_TYPE_B){
3821             int a, b;
3822
3823             a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3824             b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3825             s->f_code = FFMAX(a, b);
3826
3827             a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3828             b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3829             s->b_code = FFMAX(a, b);
3830
3831             ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3832             ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3833             ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3834             ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3835             if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME) {
3836                 int dir, j;
3837                 for(dir=0; dir<2; dir++){
3838                     for(i=0; i<2; i++){
3839                         for(j=0; j<2; j++){
3840                             int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3841                                           : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3842                             ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3843                                             s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3844                         }
3845                     }
3846                 }
3847             }
3848         }
3849     }
3850
3851     if (estimate_qp(s, 0) < 0)
3852         return -1;
3853
3854     if (s->qscale < 3 && s->max_qcoeff <= 128 &&
3855         s->pict_type == AV_PICTURE_TYPE_I &&
3856         !(s->avctx->flags & AV_CODEC_FLAG_QSCALE))
3857         s->qscale= 3; //reduce clipping problems
3858
3859     if (s->out_format == FMT_MJPEG) {
3860         const uint16_t *  luma_matrix = ff_mpeg1_default_intra_matrix;
3861         const uint16_t *chroma_matrix = ff_mpeg1_default_intra_matrix;
3862
3863         if (s->avctx->intra_matrix) {
3864             chroma_matrix =
3865             luma_matrix = s->avctx->intra_matrix;
3866         }
3867         if (s->avctx->chroma_intra_matrix)
3868             chroma_matrix = s->avctx->chroma_intra_matrix;
3869
3870         /* for mjpeg, we do include qscale in the matrix */
3871         for(i=1;i<64;i++){
3872             int j = s->idsp.idct_permutation[i];
3873
3874             s->chroma_intra_matrix[j] = av_clip_uint8((chroma_matrix[i] * s->qscale) >> 3);
3875             s->       intra_matrix[j] = av_clip_uint8((  luma_matrix[i] * s->qscale) >> 3);
3876         }
3877         s->y_dc_scale_table=
3878         s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3879         s->chroma_intra_matrix[0] =
3880         s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3881         ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
3882                        s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3883         ff_convert_matrix(s, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3884                        s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3885         s->qscale= 8;
3886     }
3887     if(s->codec_id == AV_CODEC_ID_AMV){
3888         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};
3889         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};
3890         for(i=1;i<64;i++){
3891             int j= s->idsp.idct_permutation[ff_zigzag_direct[i]];
3892
3893             s->intra_matrix[j]        = sp5x_qscale_five_quant_table[0][i];
3894             s->chroma_intra_matrix[j] = sp5x_qscale_five_quant_table[1][i];
3895         }
3896         s->y_dc_scale_table= y;
3897         s->c_dc_scale_table= c;
3898         s->intra_matrix[0] = 13;
3899         s->chroma_intra_matrix[0] = 14;
3900         ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
3901                        s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3902         ff_convert_matrix(s, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3903                        s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3904         s->qscale= 8;
3905     }
3906
3907     if (s->out_format == FMT_SPEEDHQ) {
3908         s->y_dc_scale_table=
3909         s->c_dc_scale_table= ff_mpeg2_dc_scale_table[3];
3910     }
3911
3912     //FIXME var duplication
3913     s->current_picture_ptr->f->key_frame =
3914     s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3915     s->current_picture_ptr->f->pict_type =
3916     s->current_picture.f->pict_type = s->pict_type;
3917
3918     if (s->current_picture.f->key_frame)
3919         s->picture_in_gop_number=0;
3920
3921     s->mb_x = s->mb_y = 0;
3922     s->last_bits= put_bits_count(&s->pb);
3923     switch(s->out_format) {
3924     case FMT_MJPEG:
3925         if (CONFIG_MJPEG_ENCODER && s->huffman != HUFFMAN_TABLE_OPTIMAL)
3926             ff_mjpeg_encode_picture_header(s->avctx, &s->pb, &s->intra_scantable,
3927                                            s->pred, s->intra_matrix, s->chroma_intra_matrix);
3928         break;
3929     case FMT_SPEEDHQ:
3930         if (CONFIG_SPEEDHQ_ENCODER)
3931             ff_speedhq_encode_picture_header(s);
3932         break;
3933     case FMT_H261:
3934         if (CONFIG_H261_ENCODER)
3935             ff_h261_encode_picture_header(s, picture_number);
3936         break;
3937     case FMT_H263:
3938         if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3939             ff_wmv2_encode_picture_header(s, picture_number);
3940         else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3941             ff_msmpeg4_encode_picture_header(s, picture_number);
3942         else if (CONFIG_MPEG4_ENCODER && s->h263_pred) {
3943             ret = ff_mpeg4_encode_picture_header(s, picture_number);
3944             if (ret < 0)
3945                 return ret;
3946         } else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10) {
3947             ret = ff_rv10_encode_picture_header(s, picture_number);
3948             if (ret < 0)
3949                 return ret;
3950         }
3951         else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3952             ff_rv20_encode_picture_header(s, picture_number);
3953         else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3954             ff_flv_encode_picture_header(s, picture_number);
3955         else if (CONFIG_H263_ENCODER)
3956             ff_h263_encode_picture_header(s, picture_number);
3957         break;
3958     case FMT_MPEG1:
3959         if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3960             ff_mpeg1_encode_picture_header(s, picture_number);
3961         break;
3962     default:
3963         av_assert0(0);
3964     }
3965     bits= put_bits_count(&s->pb);
3966     s->header_bits= bits - s->last_bits;
3967
3968     for(i=1; i<context_count; i++){
3969         update_duplicate_context_after_me(s->thread_context[i], s);
3970     }
3971     s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3972     for(i=1; i<context_count; i++){
3973         if (s->pb.buf_end == s->thread_context[i]->pb.buf)
3974             set_put_bits_buffer_size(&s->pb, FFMIN(s->thread_context[i]->pb.buf_end - s->pb.buf, INT_MAX/8-BUF_BITS));
3975         merge_context_after_encode(s, s->thread_context[i]);
3976     }
3977     emms_c();
3978     return 0;
3979 }
3980
3981 static void denoise_dct_c(MpegEncContext *s, int16_t *block){
3982     const int intra= s->mb_intra;
3983     int i;
3984
3985     s->dct_count[intra]++;
3986
3987     for(i=0; i<64; i++){
3988         int level= block[i];
3989
3990         if(level){
3991             if(level>0){
3992                 s->dct_error_sum[intra][i] += level;
3993                 level -= s->dct_offset[intra][i];
3994                 if(level<0) level=0;
3995             }else{
3996                 s->dct_error_sum[intra][i] -= level;
3997                 level += s->dct_offset[intra][i];
3998                 if(level>0) level=0;
3999             }
4000             block[i]= level;
4001         }
4002     }
4003 }
4004
4005 static int dct_quantize_trellis_c(MpegEncContext *s,
4006                                   int16_t *block, int n,
4007                                   int qscale, int *overflow){
4008     const int *qmat;
4009     const uint16_t *matrix;
4010     const uint8_t *scantable;
4011     const uint8_t *perm_scantable;
4012     int max=0;
4013     unsigned int threshold1, threshold2;
4014     int bias=0;
4015     int run_tab[65];
4016     int level_tab[65];
4017     int score_tab[65];
4018     int survivor[65];
4019     int survivor_count;
4020     int last_run=0;
4021     int last_level=0;
4022     int last_score= 0;
4023     int last_i;
4024     int coeff[2][64];
4025     int coeff_count[64];
4026     int qmul, qadd, start_i, last_non_zero, i, dc;
4027     const int esc_length= s->ac_esc_length;
4028     uint8_t * length;
4029     uint8_t * last_length;
4030     const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
4031     int mpeg2_qscale;
4032
4033     s->fdsp.fdct(block);
4034
4035     if(s->dct_error_sum)
4036         s->denoise_dct(s, block);
4037     qmul= qscale*16;
4038     qadd= ((qscale-1)|1)*8;
4039
4040     if (s->q_scale_type) mpeg2_qscale = ff_mpeg2_non_linear_qscale[qscale];
4041     else                 mpeg2_qscale = qscale << 1;
4042
4043     if (s->mb_intra) {
4044         int q;
4045         scantable= s->intra_scantable.scantable;
4046         perm_scantable= s->intra_scantable.permutated;
4047         if (!s->h263_aic) {
4048             if (n < 4)
4049                 q = s->y_dc_scale;
4050             else
4051                 q = s->c_dc_scale;
4052             q = q << 3;
4053         } else{
4054             /* For AIC we skip quant/dequant of INTRADC */
4055             q = 1 << 3;
4056             qadd=0;
4057         }
4058
4059         /* note: block[0] is assumed to be positive */
4060         block[0] = (block[0] + (q >> 1)) / q;
4061         start_i = 1;
4062         last_non_zero = 0;
4063         qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4064         matrix = n < 4 ? s->intra_matrix : s->chroma_intra_matrix;
4065         if(s->mpeg_quant || s->out_format == FMT_MPEG1 || s->out_format == FMT_MJPEG)
4066             bias= 1<<(QMAT_SHIFT-1);
4067
4068         if (n > 3 && s->intra_chroma_ac_vlc_length) {
4069             length     = s->intra_chroma_ac_vlc_length;
4070             last_length= s->intra_chroma_ac_vlc_last_length;
4071         } else {
4072             length     = s->intra_ac_vlc_length;
4073             last_length= s->intra_ac_vlc_last_length;
4074         }
4075     } else {
4076         scantable= s->inter_scantable.scantable;
4077         perm_scantable= s->inter_scantable.permutated;
4078         start_i = 0;
4079         last_non_zero = -1;
4080         qmat = s->q_inter_matrix[qscale];
4081         matrix = s->inter_matrix;
4082         length     = s->inter_ac_vlc_length;
4083         last_length= s->inter_ac_vlc_last_length;
4084     }
4085     last_i= start_i;
4086
4087     threshold1= (1<<QMAT_SHIFT) - bias - 1;
4088     threshold2= (threshold1<<1);
4089
4090     for(i=63; i>=start_i; i--) {
4091         const int j = scantable[i];
4092         int level = block[j] * qmat[j];
4093
4094         if(((unsigned)(level+threshold1))>threshold2){
4095             last_non_zero = i;
4096             break;
4097         }
4098     }
4099
4100     for(i=start_i; i<=last_non_zero; i++) {
4101         const int j = scantable[i];
4102         int level = block[j] * qmat[j];
4103
4104 //        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
4105 //           || bias-level >= (1<<(QMAT_SHIFT - 3))){
4106         if(((unsigned)(level+threshold1))>threshold2){
4107             if(level>0){
4108                 level= (bias + level)>>QMAT_SHIFT;
4109                 coeff[0][i]= level;
4110                 coeff[1][i]= level-1;
4111 //                coeff[2][k]= level-2;
4112             }else{
4113                 level= (bias - level)>>QMAT_SHIFT;
4114                 coeff[0][i]= -level;
4115                 coeff[1][i]= -level+1;
4116 //                coeff[2][k]= -level+2;
4117             }
4118             coeff_count[i]= FFMIN(level, 2);
4119             av_assert2(coeff_count[i]);
4120             max |=level;
4121         }else{
4122             coeff[0][i]= (level>>31)|1;
4123             coeff_count[i]= 1;
4124         }
4125     }
4126
4127     *overflow= s->max_qcoeff < max; //overflow might have happened
4128
4129     if(last_non_zero < start_i){
4130         memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
4131         return last_non_zero;
4132     }
4133
4134     score_tab[start_i]= 0;
4135     survivor[0]= start_i;
4136     survivor_count= 1;
4137
4138     for(i=start_i; i<=last_non_zero; i++){
4139         int level_index, j, zero_distortion;
4140         int dct_coeff= FFABS(block[ scantable[i] ]);
4141         int best_score=256*256*256*120;
4142
4143         if (s->fdsp.fdct == ff_fdct_ifast)
4144             dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
4145         zero_distortion= dct_coeff*dct_coeff;
4146
4147         for(level_index=0; level_index < coeff_count[i]; level_index++){
4148             int distortion;
4149             int level= coeff[level_index][i];
4150             const int alevel= FFABS(level);
4151             int unquant_coeff;
4152
4153             av_assert2(level);
4154
4155             if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4156                 unquant_coeff= alevel*qmul + qadd;
4157             } else if(s->out_format == FMT_MJPEG) {
4158                 j = s->idsp.idct_permutation[scantable[i]];
4159                 unquant_coeff = alevel * matrix[j] * 8;
4160             }else{ // MPEG-1
4161                 j = s->idsp.idct_permutation[scantable[i]]; // FIXME: optimize
4162                 if(s->mb_intra){
4163                         unquant_coeff = (int)(  alevel  * mpeg2_qscale * matrix[j]) >> 4;
4164                         unquant_coeff =   (unquant_coeff - 1) | 1;
4165                 }else{
4166                         unquant_coeff = (((  alevel  << 1) + 1) * mpeg2_qscale * ((int) matrix[j])) >> 5;
4167                         unquant_coeff =   (unquant_coeff - 1) | 1;
4168                 }
4169                 unquant_coeff<<= 3;
4170             }
4171
4172             distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
4173             level+=64;
4174             if((level&(~127)) == 0){
4175                 for(j=survivor_count-1; j>=0; j--){
4176                     int run= i - survivor[j];
4177                     int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4178                     score += score_tab[i-run];
4179
4180                     if(score < best_score){
4181                         best_score= score;
4182                         run_tab[i+1]= run;
4183                         level_tab[i+1]= level-64;
4184                     }
4185                 }
4186
4187                 if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4188                     for(j=survivor_count-1; j>=0; j--){
4189                         int run= i - survivor[j];
4190                         int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
4191                         score += score_tab[i-run];
4192                         if(score < last_score){
4193                             last_score= score;
4194                             last_run= run;
4195                             last_level= level-64;
4196                             last_i= i+1;
4197                         }
4198                     }
4199                 }
4200             }else{
4201                 distortion += esc_length*lambda;
4202                 for(j=survivor_count-1; j>=0; j--){
4203                     int run= i - survivor[j];
4204                     int score= distortion + score_tab[i-run];
4205
4206                     if(score < best_score){
4207                         best_score= score;
4208                         run_tab[i+1]= run;
4209                         level_tab[i+1]= level-64;
4210                     }
4211                 }
4212
4213                 if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4214                   for(j=survivor_count-1; j>=0; j--){
4215                         int run= i - survivor[j];
4216                         int score= distortion + score_tab[i-run];
4217                         if(score < last_score){
4218                             last_score= score;
4219                             last_run= run;
4220                             last_level= level-64;
4221                             last_i= i+1;
4222                         }
4223                     }
4224                 }
4225             }
4226         }
4227
4228         score_tab[i+1]= best_score;
4229
4230         // Note: there is a vlc code in MPEG-4 which is 1 bit shorter then another one with a shorter run and the same level
4231         if(last_non_zero <= 27){
4232             for(; survivor_count; survivor_count--){
4233                 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
4234                     break;
4235             }
4236         }else{
4237             for(; survivor_count; survivor_count--){
4238                 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
4239                     break;
4240             }
4241         }
4242
4243         survivor[ survivor_count++ ]= i+1;
4244     }
4245
4246     if(s->out_format != FMT_H263 && s->out_format != FMT_H261){
4247         last_score= 256*256*256*120;
4248         for(i= survivor[0]; i<=last_non_zero + 1; i++){
4249             int score= score_tab[i];
4250             if (i)
4251                 score += lambda * 2; // FIXME more exact?
4252
4253             if(score < last_score){
4254                 last_score= score;
4255                 last_i= i;
4256                 last_level= level_tab[i];
4257                 last_run= run_tab[i];
4258             }
4259         }
4260     }
4261
4262     s->coded_score[n] = last_score;
4263
4264     dc= FFABS(block[0]);
4265     last_non_zero= last_i - 1;
4266     memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
4267
4268     if(last_non_zero < start_i)
4269         return last_non_zero;
4270
4271     if(last_non_zero == 0 && start_i == 0){
4272         int best_level= 0;
4273         int best_score= dc * dc;
4274
4275         for(i=0; i<coeff_count[0]; i++){
4276             int level= coeff[i][0];
4277             int alevel= FFABS(level);
4278             int unquant_coeff, score, distortion;
4279
4280             if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
4281                     unquant_coeff= (alevel*qmul + qadd)>>3;
4282             } else{ // MPEG-1
4283                     unquant_coeff = (((  alevel  << 1) + 1) * mpeg2_qscale * ((int) matrix[0])) >> 5;
4284                     unquant_coeff =   (unquant_coeff - 1) | 1;
4285             }
4286             unquant_coeff = (unquant_coeff + 4) >> 3;
4287             unquant_coeff<<= 3 + 3;
4288
4289             distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
4290             level+=64;
4291             if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
4292             else                    score= distortion + esc_length*lambda;
4293
4294             if(score < best_score){
4295                 best_score= score;
4296                 best_level= level - 64;
4297             }
4298         }
4299         block[0]= best_level;
4300         s->coded_score[n] = best_score - dc*dc;
4301         if(best_level == 0) return -1;
4302         else                return last_non_zero;
4303     }
4304
4305     i= last_i;
4306     av_assert2(last_level);
4307
4308     block[ perm_scantable[last_non_zero] ]= last_level;
4309     i -= last_run + 1;
4310
4311     for(; i>start_i; i -= run_tab[i] + 1){
4312         block[ perm_scantable[i-1] ]= level_tab[i];
4313     }
4314
4315     return last_non_zero;
4316 }
4317
4318 static int16_t basis[64][64];
4319
4320 static void build_basis(uint8_t *perm){
4321     int i, j, x, y;
4322     emms_c();
4323     for(i=0; i<8; i++){
4324         for(j=0; j<8; j++){
4325             for(y=0; y<8; y++){
4326                 for(x=0; x<8; x++){
4327                     double s= 0.25*(1<<BASIS_SHIFT);
4328                     int index= 8*i + j;
4329                     int perm_index= perm[index];
4330                     if(i==0) s*= sqrt(0.5);
4331                     if(j==0) s*= sqrt(0.5);
4332                     basis[perm_index][8*x + y]= lrintf(s * cos((M_PI/8.0)*i*(x+0.5)) * cos((M_PI/8.0)*j*(y+0.5)));
4333                 }
4334             }
4335         }
4336     }
4337 }
4338
4339 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
4340                         int16_t *block, int16_t *weight, int16_t *orig,
4341                         int n, int qscale){
4342     int16_t rem[64];
4343     LOCAL_ALIGNED_16(int16_t, d1, [64]);
4344     const uint8_t *scantable;
4345     const uint8_t *perm_scantable;
4346 //    unsigned int threshold1, threshold2;
4347 //    int bias=0;
4348     int run_tab[65];
4349     int prev_run=0;
4350     int prev_level=0;
4351     int qmul, qadd, start_i, last_non_zero, i, dc;
4352     uint8_t * length;
4353     uint8_t * last_length;
4354     int lambda;
4355     int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
4356
4357     if(basis[0][0] == 0)
4358         build_basis(s->idsp.idct_permutation);
4359
4360     qmul= qscale*2;
4361     qadd= (qscale-1)|1;
4362     if (s->mb_intra) {
4363         scantable= s->intra_scantable.scantable;
4364         perm_scantable= s->intra_scantable.permutated;
4365         if (!s->h263_aic) {
4366             if (n < 4)
4367                 q = s->y_dc_scale;
4368             else
4369                 q = s->c_dc_scale;
4370         } else{
4371             /* For AIC we skip quant/dequant of INTRADC */
4372             q = 1;
4373             qadd=0;
4374         }
4375         q <<= RECON_SHIFT-3;
4376         /* note: block[0] is assumed to be positive */
4377         dc= block[0]*q;
4378 //        block[0] = (block[0] + (q >> 1)) / q;
4379         start_i = 1;
4380 //        if(s->mpeg_quant || s->out_format == FMT_MPEG1)
4381 //            bias= 1<<(QMAT_SHIFT-1);
4382         if (n > 3 && s->intra_chroma_ac_vlc_length) {
4383             length     = s->intra_chroma_ac_vlc_length;
4384             last_length= s->intra_chroma_ac_vlc_last_length;
4385         } else {
4386             length     = s->intra_ac_vlc_length;
4387             last_length= s->intra_ac_vlc_last_length;
4388         }
4389     } else {
4390         scantable= s->inter_scantable.scantable;
4391         perm_scantable= s->inter_scantable.permutated;
4392         dc= 0;
4393         start_i = 0;
4394         length     = s->inter_ac_vlc_length;
4395         last_length= s->inter_ac_vlc_last_length;
4396     }
4397     last_non_zero = s->block_last_index[n];
4398
4399     dc += (1<<(RECON_SHIFT-1));
4400     for(i=0; i<64; i++){
4401         rem[i] = dc - (orig[i] << RECON_SHIFT); // FIXME use orig directly instead of copying to rem[]
4402     }
4403
4404     sum=0;
4405     for(i=0; i<64; i++){
4406         int one= 36;
4407         int qns=4;
4408         int w;
4409
4410         w= FFABS(weight[i]) + qns*one;
4411         w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
4412
4413         weight[i] = w;
4414 //        w=weight[i] = (63*qns + (w/2)) / w;
4415
4416         av_assert2(w>0);
4417         av_assert2(w<(1<<6));
4418         sum += w*w;
4419     }
4420     lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
4421
4422     run=0;
4423     rle_index=0;
4424     for(i=start_i; i<=last_non_zero; i++){
4425         int j= perm_scantable[i];
4426         const int level= block[j];
4427         int coeff;
4428
4429         if(level){
4430             if(level<0) coeff= qmul*level - qadd;
4431             else        coeff= qmul*level + qadd;
4432             run_tab[rle_index++]=run;
4433             run=0;
4434
4435             s->mpvencdsp.add_8x8basis(rem, basis[j], coeff);
4436         }else{
4437             run++;
4438         }
4439     }
4440
4441     for(;;){
4442         int best_score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0], 0);
4443         int best_coeff=0;
4444         int best_change=0;
4445         int run2, best_unquant_change=0, analyze_gradient;
4446         analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
4447
4448         if(analyze_gradient){
4449             for(i=0; i<64; i++){
4450                 int w= weight[i];
4451
4452                 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
4453             }
4454             s->fdsp.fdct(d1);
4455         }
4456
4457         if(start_i){
4458             const int level= block[0];
4459             int change, old_coeff;
4460
4461             av_assert2(s->mb_intra);
4462
4463             old_coeff= q*level;
4464
4465             for(change=-1; change<=1; change+=2){
4466                 int new_level= level + change;
4467                 int score, new_coeff;
4468
4469                 new_coeff= q*new_level;
4470                 if(new_coeff >= 2048 || new_coeff < 0)
4471                     continue;
4472
4473                 score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0],
4474                                                   new_coeff - old_coeff);
4475                 if(score<best_score){
4476                     best_score= score;
4477                     best_coeff= 0;
4478                     best_change= change;
4479                     best_unquant_change= new_coeff - old_coeff;
4480                 }
4481             }
4482         }
4483
4484         run=0;
4485         rle_index=0;
4486         run2= run_tab[rle_index++];
4487         prev_level=0;
4488         prev_run=0;
4489
4490         for(i=start_i; i<64; i++){
4491             int j= perm_scantable[i];
4492             const int level= block[j];
4493             int change, old_coeff;
4494
4495             if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
4496                 break;
4497
4498             if(level){
4499                 if(level<0) old_coeff= qmul*level - qadd;
4500                 else        old_coeff= qmul*level + qadd;
4501                 run2= run_tab[rle_index++]; //FIXME ! maybe after last
4502             }else{
4503                 old_coeff=0;
4504                 run2--;
4505                 av_assert2(run2>=0 || i >= last_non_zero );
4506             }
4507
4508             for(change=-1; change<=1; change+=2){
4509                 int new_level= level + change;
4510                 int score, new_coeff, unquant_change;
4511
4512                 score=0;
4513                 if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
4514                    continue;
4515
4516                 if(new_level){
4517                     if(new_level<0) new_coeff= qmul*new_level - qadd;
4518                     else            new_coeff= qmul*new_level + qadd;
4519                     if(new_coeff >= 2048 || new_coeff <= -2048)
4520                         continue;
4521                     //FIXME check for overflow
4522
4523                     if(level){
4524                         if(level < 63 && level > -63){
4525                             if(i < last_non_zero)
4526                                 score +=   length[UNI_AC_ENC_INDEX(run, new_level+64)]
4527                                          - length[UNI_AC_ENC_INDEX(run, level+64)];
4528                             else
4529                                 score +=   last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
4530                                          - last_length[UNI_AC_ENC_INDEX(run, level+64)];
4531                         }
4532                     }else{
4533                         av_assert2(FFABS(new_level)==1);
4534
4535                         if(analyze_gradient){
4536                             int g= d1[ scantable[i] ];
4537                             if(g && (g^new_level) >= 0)
4538                                 continue;
4539                         }
4540
4541                         if(i < last_non_zero){
4542                             int next_i= i + run2 + 1;
4543                             int next_level= block[ perm_scantable[next_i] ] + 64;
4544
4545                             if(next_level&(~127))
4546                                 next_level= 0;
4547
4548                             if(next_i < last_non_zero)
4549                                 score +=   length[UNI_AC_ENC_INDEX(run, 65)]
4550                                          + length[UNI_AC_ENC_INDEX(run2, next_level)]
4551                                          - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4552                             else
4553                                 score +=  length[UNI_AC_ENC_INDEX(run, 65)]
4554                                         + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4555                                         - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4556                         }else{
4557                             score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4558                             if(prev_level){
4559                                 score +=  length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4560                                         - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4561                             }
4562                         }
4563                     }
4564                 }else{
4565                     new_coeff=0;
4566                     av_assert2(FFABS(level)==1);
4567
4568                     if(i < last_non_zero){
4569                         int next_i= i + run2 + 1;
4570                         int next_level= block[ perm_scantable[next_i] ] + 64;
4571
4572                         if(next_level&(~127))
4573                             next_level= 0;
4574
4575                         if(next_i < last_non_zero)
4576                             score +=   length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4577                                      - length[UNI_AC_ENC_INDEX(run2, next_level)]
4578                                      - length[UNI_AC_ENC_INDEX(run, 65)];
4579                         else
4580                             score +=   last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4581                                      - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4582                                      - length[UNI_AC_ENC_INDEX(run, 65)];
4583                     }else{
4584                         score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4585                         if(prev_level){
4586                             score +=  last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4587                                     - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4588                         }
4589                     }
4590                 }
4591
4592                 score *= lambda;
4593
4594                 unquant_change= new_coeff - old_coeff;
4595                 av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
4596
4597                 score += s->mpvencdsp.try_8x8basis(rem, weight, basis[j],
4598                                                    unquant_change);
4599                 if(score<best_score){
4600                     best_score= score;
4601                     best_coeff= i;
4602                     best_change= change;
4603                     best_unquant_change= unquant_change;
4604                 }
4605             }
4606             if(level){
4607                 prev_level= level + 64;
4608                 if(prev_level&(~127))
4609                     prev_level= 0;
4610                 prev_run= run;
4611                 run=0;
4612             }else{
4613                 run++;
4614             }
4615         }
4616
4617         if(best_change){
4618             int j= perm_scantable[ best_coeff ];
4619
4620             block[j] += best_change;
4621
4622             if(best_coeff > last_non_zero){
4623                 last_non_zero= best_coeff;
4624                 av_assert2(block[j]);
4625             }else{
4626                 for(; last_non_zero>=start_i; last_non_zero--){
4627                     if(block[perm_scantable[last_non_zero]])
4628                         break;
4629                 }
4630             }
4631
4632             run=0;
4633             rle_index=0;
4634             for(i=start_i; i<=last_non_zero; i++){
4635                 int j= perm_scantable[i];
4636                 const int level= block[j];
4637
4638                  if(level){
4639                      run_tab[rle_index++]=run;
4640                      run=0;
4641                  }else{
4642                      run++;
4643                  }
4644             }
4645
4646             s->mpvencdsp.add_8x8basis(rem, basis[j], best_unquant_change);
4647         }else{
4648             break;
4649         }
4650     }
4651
4652     return last_non_zero;
4653 }
4654
4655 /**
4656  * Permute an 8x8 block according to permutation.
4657  * @param block the block which will be permuted according to
4658  *              the given permutation vector
4659  * @param permutation the permutation vector
4660  * @param last the last non zero coefficient in scantable order, used to
4661  *             speed the permutation up
4662  * @param scantable the used scantable, this is only used to speed the
4663  *                  permutation up, the block is not (inverse) permutated
4664  *                  to scantable order!
4665  */
4666 void ff_block_permute(int16_t *block, uint8_t *permutation,
4667                       const uint8_t *scantable, int last)
4668 {
4669     int i;
4670     int16_t temp[64];
4671
4672     if (last <= 0)
4673         return;
4674     //FIXME it is ok but not clean and might fail for some permutations
4675     // if (permutation[1] == 1)
4676     // return;
4677
4678     for (i = 0; i <= last; i++) {
4679         const int j = scantable[i];
4680         temp[j] = block[j];
4681         block[j] = 0;
4682     }
4683
4684     for (i = 0; i <= last; i++) {
4685         const int j = scantable[i];
4686         const int perm_j = permutation[j];
4687         block[perm_j] = temp[j];
4688     }
4689 }
4690
4691 int ff_dct_quantize_c(MpegEncContext *s,
4692                         int16_t *block, int n,
4693                         int qscale, int *overflow)
4694 {
4695     int i, j, level, last_non_zero, q, start_i;
4696     const int *qmat;
4697     const uint8_t *scantable;
4698     int bias;
4699     int max=0;
4700     unsigned int threshold1, threshold2;
4701
4702     s->fdsp.fdct(block);
4703
4704     if(s->dct_error_sum)
4705         s->denoise_dct(s, block);
4706
4707     if (s->mb_intra) {
4708         scantable= s->intra_scantable.scantable;
4709         if (!s->h263_aic) {
4710             if (n < 4)
4711                 q = s->y_dc_scale;
4712             else
4713                 q = s->c_dc_scale;
4714             q = q << 3;
4715         } else
4716             /* For AIC we skip quant/dequant of INTRADC */
4717             q = 1 << 3;
4718
4719         /* note: block[0] is assumed to be positive */
4720         block[0] = (block[0] + (q >> 1)) / q;
4721         start_i = 1;
4722         last_non_zero = 0;
4723         qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4724         bias= s->intra_quant_bias*(1<<(QMAT_SHIFT - QUANT_BIAS_SHIFT));
4725     } else {
4726         scantable= s->inter_scantable.scantable;
4727         start_i = 0;
4728         last_non_zero = -1;
4729         qmat = s->q_inter_matrix[qscale];
4730         bias= s->inter_quant_bias*(1<<(QMAT_SHIFT - QUANT_BIAS_SHIFT));
4731     }
4732     threshold1= (1<<QMAT_SHIFT) - bias - 1;
4733     threshold2= (threshold1<<1);
4734     for(i=63;i>=start_i;i--) {
4735         j = scantable[i];
4736         level = block[j] * qmat[j];
4737
4738         if(((unsigned)(level+threshold1))>threshold2){
4739             last_non_zero = i;
4740             break;
4741         }else{
4742             block[j]=0;
4743         }
4744     }
4745     for(i=start_i; i<=last_non_zero; i++) {
4746         j = scantable[i];
4747         level = block[j] * qmat[j];
4748
4749 //        if(   bias+level >= (1<<QMAT_SHIFT)
4750 //           || bias-level >= (1<<QMAT_SHIFT)){
4751         if(((unsigned)(level+threshold1))>threshold2){
4752             if(level>0){
4753                 level= (bias + level)>>QMAT_SHIFT;
4754                 block[j]= level;
4755             }else{
4756                 level= (bias - level)>>QMAT_SHIFT;
4757                 block[j]= -level;
4758             }
4759             max |=level;
4760         }else{
4761             block[j]=0;
4762         }
4763     }
4764     *overflow= s->max_qcoeff < max; //overflow might have happened
4765
4766     /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4767     if (s->idsp.perm_type != FF_IDCT_PERM_NONE)
4768         ff_block_permute(block, s->idsp.idct_permutation,
4769                       scantable, last_non_zero);
4770
4771     return last_non_zero;
4772 }
4773
4774 #define OFFSET(x) offsetof(MpegEncContext, x)
4775 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4776 static const AVOption h263_options[] = {
4777     { "obmc",         "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4778     { "mb_info",      "emit macroblock info for RFC 2190 packetization, the parameter value is the maximum payload size", OFFSET(mb_info), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE },
4779     FF_MPV_COMMON_OPTS
4780     { NULL },
4781 };
4782
4783 static const AVClass h263_class = {
4784     .class_name = "H.263 encoder",
4785     .item_name  = av_default_item_name,
4786     .option     = h263_options,
4787     .version    = LIBAVUTIL_VERSION_INT,
4788 };
4789
4790 AVCodec ff_h263_encoder = {
4791     .name           = "h263",
4792     .long_name      = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4793     .type           = AVMEDIA_TYPE_VIDEO,
4794     .id             = AV_CODEC_ID_H263,
4795     .priv_data_size = sizeof(MpegEncContext),
4796     .init           = ff_mpv_encode_init,
4797     .encode2        = ff_mpv_encode_picture,
4798     .close          = ff_mpv_encode_end,
4799     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
4800     .pix_fmts= (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},
4801     .priv_class     = &h263_class,
4802 };
4803
4804 static const AVOption h263p_options[] = {
4805     { "umv",        "Use unlimited motion vectors.",    OFFSET(umvplus),       AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4806     { "aiv",        "Use alternative inter VLC.",       OFFSET(alt_inter_vlc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4807     { "obmc",       "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
4808     { "structured_slices", "Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE},
4809     FF_MPV_COMMON_OPTS
4810     { NULL },
4811 };
4812 static const AVClass h263p_class = {
4813     .class_name = "H.263p encoder",
4814     .item_name  = av_default_item_name,
4815     .option     = h263p_options,
4816     .version    = LIBAVUTIL_VERSION_INT,
4817 };
4818
4819 AVCodec ff_h263p_encoder = {
4820     .name           = "h263p",
4821     .long_name      = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4822     .type           = AVMEDIA_TYPE_VIDEO,
4823     .id             = AV_CODEC_ID_H263P,
4824     .priv_data_size = sizeof(MpegEncContext),
4825     .init           = ff_mpv_encode_init,
4826     .encode2        = ff_mpv_encode_picture,
4827     .close          = ff_mpv_encode_end,
4828     .capabilities   = AV_CODEC_CAP_SLICE_THREADS,
4829     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
4830     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4831     .priv_class     = &h263p_class,
4832 };
4833
4834 static const AVClass msmpeg4v2_class = {
4835     .class_name = "msmpeg4v2 encoder",
4836     .item_name  = av_default_item_name,
4837     .option     = ff_mpv_generic_options,
4838     .version    = LIBAVUTIL_VERSION_INT,
4839 };
4840
4841 AVCodec ff_msmpeg4v2_encoder = {
4842     .name           = "msmpeg4v2",
4843     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4844     .type           = AVMEDIA_TYPE_VIDEO,
4845     .id             = AV_CODEC_ID_MSMPEG4V2,
4846     .priv_data_size = sizeof(MpegEncContext),
4847     .init           = ff_mpv_encode_init,
4848     .encode2        = ff_mpv_encode_picture,
4849     .close          = ff_mpv_encode_end,
4850     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
4851     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4852     .priv_class     = &msmpeg4v2_class,
4853 };
4854
4855 static const AVClass msmpeg4v3_class = {
4856     .class_name = "msmpeg4v3 encoder",
4857     .item_name  = av_default_item_name,
4858     .option     = ff_mpv_generic_options,
4859     .version    = LIBAVUTIL_VERSION_INT,
4860 };
4861
4862 AVCodec ff_msmpeg4v3_encoder = {
4863     .name           = "msmpeg4",
4864     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4865     .type           = AVMEDIA_TYPE_VIDEO,
4866     .id             = AV_CODEC_ID_MSMPEG4V3,
4867     .priv_data_size = sizeof(MpegEncContext),
4868     .init           = ff_mpv_encode_init,
4869     .encode2        = ff_mpv_encode_picture,
4870     .close          = ff_mpv_encode_end,
4871     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
4872     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4873     .priv_class     = &msmpeg4v3_class,
4874 };
4875
4876 static const AVClass wmv1_class = {
4877     .class_name = "wmv1 encoder",
4878     .item_name  = av_default_item_name,
4879     .option     = ff_mpv_generic_options,
4880     .version    = LIBAVUTIL_VERSION_INT,
4881 };
4882
4883 AVCodec ff_wmv1_encoder = {
4884     .name           = "wmv1",
4885     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4886     .type           = AVMEDIA_TYPE_VIDEO,
4887     .id             = AV_CODEC_ID_WMV1,
4888     .priv_data_size = sizeof(MpegEncContext),
4889     .init           = ff_mpv_encode_init,
4890     .encode2        = ff_mpv_encode_picture,
4891     .close          = ff_mpv_encode_end,
4892     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
4893     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4894     .priv_class     = &wmv1_class,
4895 };