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 = avctx->mpeg_quant;
 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         if ((ret = ff_msmpeg4_encode_init(s)) < 0)
1012             return ret;
1013     if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
1014         && s->out_format == FMT_MPEG1)
1015         ff_mpeg1_encode_init(s);
1016
1017     /* init q matrix */
1018     for (i = 0; i < 64; i++) {
1019         int j = s->idsp.idct_permutation[i];
1020         if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
1021             s->mpeg_quant) {
1022             s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
1023             s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
1024         } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1025             s->intra_matrix[j] =
1026             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1027         } else if (CONFIG_SPEEDHQ_ENCODER && s->codec_id == AV_CODEC_ID_SPEEDHQ) {
1028             s->intra_matrix[j] =
1029             s->inter_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1030         } else {
1031             /* MPEG-1/2 */
1032             s->chroma_intra_matrix[j] =
1033             s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
1034             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
1035         }
1036         if (avctx->intra_matrix)
1037             s->intra_matrix[j] = avctx->intra_matrix[i];
1038         if (avctx->inter_matrix)
1039             s->inter_matrix[j] = avctx->inter_matrix[i];
1040     }
1041
1042     /* precompute matrix */
1043     /* for mjpeg, we do include qscale in the matrix */
1044     if (s->out_format != FMT_MJPEG) {
1045         ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
1046                           s->intra_matrix, s->intra_quant_bias, avctx->qmin,
1047                           31, 1);
1048         ff_convert_matrix(s, s->q_inter_matrix, s->q_inter_matrix16,
1049                           s->inter_matrix, s->inter_quant_bias, avctx->qmin,
1050                           31, 0);
1051     }
1052
1053     if ((ret = ff_rate_control_init(s)) < 0)
1054         return ret;
1055
1056 #if FF_API_PRIVATE_OPT
1057     FF_DISABLE_DEPRECATION_WARNINGS
1058     if (avctx->brd_scale)
1059         s->brd_scale = avctx->brd_scale;
1060
1061     if (avctx->prediction_method)
1062         s->pred = avctx->prediction_method + 1;
1063     FF_ENABLE_DEPRECATION_WARNINGS
1064 #endif
1065
1066     if (s->b_frame_strategy == 2) {
1067         for (i = 0; i < s->max_b_frames + 2; i++) {
1068             s->tmp_frames[i] = av_frame_alloc();
1069             if (!s->tmp_frames[i])
1070                 return AVERROR(ENOMEM);
1071
1072             s->tmp_frames[i]->format = AV_PIX_FMT_YUV420P;
1073             s->tmp_frames[i]->width  = s->width  >> s->brd_scale;
1074             s->tmp_frames[i]->height = s->height >> s->brd_scale;
1075
1076             ret = av_frame_get_buffer(s->tmp_frames[i], 0);
1077             if (ret < 0)
1078                 return ret;
1079         }
1080     }
1081
1082     cpb_props = ff_add_cpb_side_data(avctx);
1083     if (!cpb_props)
1084         return AVERROR(ENOMEM);
1085     cpb_props->max_bitrate = avctx->rc_max_rate;
1086     cpb_props->min_bitrate = avctx->rc_min_rate;
1087     cpb_props->avg_bitrate = avctx->bit_rate;
1088     cpb_props->buffer_size = avctx->rc_buffer_size;
1089
1090     return 0;
1091 }
1092
1093 av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
1094 {
1095     MpegEncContext *s = avctx->priv_data;
1096     int i;
1097
1098     ff_rate_control_uninit(s);
1099
1100     ff_mpv_common_end(s);
1101     if (CONFIG_MJPEG_ENCODER &&
1102         s->out_format == FMT_MJPEG)
1103         ff_mjpeg_encode_close(s);
1104
1105     av_freep(&avctx->extradata);
1106
1107     for (i = 0; i < FF_ARRAY_ELEMS(s->tmp_frames); i++)
1108         av_frame_free(&s->tmp_frames[i]);
1109
1110     ff_free_picture_tables(&s->new_picture);
1111     ff_mpeg_unref_picture(avctx, &s->new_picture);
1112
1113     av_freep(&avctx->stats_out);
1114     av_freep(&s->ac_stats);
1115
1116     if(s->q_chroma_intra_matrix   != s->q_intra_matrix  ) av_freep(&s->q_chroma_intra_matrix);
1117     if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
1118     s->q_chroma_intra_matrix=   NULL;
1119     s->q_chroma_intra_matrix16= NULL;
1120     av_freep(&s->q_intra_matrix);
1121     av_freep(&s->q_inter_matrix);
1122     av_freep(&s->q_intra_matrix16);
1123     av_freep(&s->q_inter_matrix16);
1124     av_freep(&s->input_picture);
1125     av_freep(&s->reordered_input_picture);
1126     av_freep(&s->dct_offset);
1127
1128     return 0;
1129 }
1130
1131 static int get_sae(uint8_t *src, int ref, int stride)
1132 {
1133     int x,y;
1134     int acc = 0;
1135
1136     for (y = 0; y < 16; y++) {
1137         for (x = 0; x < 16; x++) {
1138             acc += FFABS(src[x + y * stride] - ref);
1139         }
1140     }
1141
1142     return acc;
1143 }
1144
1145 static int get_intra_count(MpegEncContext *s, uint8_t *src,
1146                            uint8_t *ref, int stride)
1147 {
1148     int x, y, w, h;
1149     int acc = 0;
1150
1151     w = s->width  & ~15;
1152     h = s->height & ~15;
1153
1154     for (y = 0; y < h; y += 16) {
1155         for (x = 0; x < w; x += 16) {
1156             int offset = x + y * stride;
1157             int sad  = s->mecc.sad[0](NULL, src + offset, ref + offset,
1158                                       stride, 16);
1159             int mean = (s->mpvencdsp.pix_sum(src + offset, stride) + 128) >> 8;
1160             int sae  = get_sae(src + offset, mean, stride);
1161
1162             acc += sae + 500 < sad;
1163         }
1164     }
1165     return acc;
1166 }
1167
1168 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared)
1169 {
1170     return ff_alloc_picture(s->avctx, pic, &s->me, &s->sc, shared, 1,
1171                             s->chroma_x_shift, s->chroma_y_shift, s->out_format,
1172                             s->mb_stride, s->mb_width, s->mb_height, s->b8_stride,
1173                             &s->linesize, &s->uvlinesize);
1174 }
1175
1176 static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
1177 {
1178     Picture *pic = NULL;
1179     int64_t pts;
1180     int i, display_picture_number = 0, ret;
1181     int encoding_delay = s->max_b_frames ? s->max_b_frames
1182                                          : (s->low_delay ? 0 : 1);
1183     int flush_offset = 1;
1184     int direct = 1;
1185
1186     if (pic_arg) {
1187         pts = pic_arg->pts;
1188         display_picture_number = s->input_picture_number++;
1189
1190         if (pts != AV_NOPTS_VALUE) {
1191             if (s->user_specified_pts != AV_NOPTS_VALUE) {
1192                 int64_t last = s->user_specified_pts;
1193
1194                 if (pts <= last) {
1195                     av_log(s->avctx, AV_LOG_ERROR,
1196                            "Invalid pts (%"PRId64") <= last (%"PRId64")\n",
1197                            pts, last);
1198                     return AVERROR(EINVAL);
1199                 }
1200
1201                 if (!s->low_delay && display_picture_number == 1)
1202                     s->dts_delta = pts - last;
1203             }
1204             s->user_specified_pts = pts;
1205         } else {
1206             if (s->user_specified_pts != AV_NOPTS_VALUE) {
1207                 s->user_specified_pts =
1208                 pts = s->user_specified_pts + 1;
1209                 av_log(s->avctx, AV_LOG_INFO,
1210                        "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
1211                        pts);
1212             } else {
1213                 pts = display_picture_number;
1214             }
1215         }
1216
1217         if (!pic_arg->buf[0] ||
1218             pic_arg->linesize[0] != s->linesize ||
1219             pic_arg->linesize[1] != s->uvlinesize ||
1220             pic_arg->linesize[2] != s->uvlinesize)
1221             direct = 0;
1222         if ((s->width & 15) || (s->height & 15))
1223             direct = 0;
1224         if (((intptr_t)(pic_arg->data[0])) & (STRIDE_ALIGN-1))
1225             direct = 0;
1226         if (s->linesize & (STRIDE_ALIGN-1))
1227             direct = 0;
1228
1229         ff_dlog(s->avctx, "%d %d %"PTRDIFF_SPECIFIER" %"PTRDIFF_SPECIFIER"\n", pic_arg->linesize[0],
1230                 pic_arg->linesize[1], s->linesize, s->uvlinesize);
1231
1232         i = ff_find_unused_picture(s->avctx, s->picture, direct);
1233         if (i < 0)
1234             return i;
1235
1236         pic = &s->picture[i];
1237         pic->reference = 3;
1238
1239         if (direct) {
1240             if ((ret = av_frame_ref(pic->f, pic_arg)) < 0)
1241                 return ret;
1242         }
1243         ret = alloc_picture(s, pic, direct);
1244         if (ret < 0)
1245             return ret;
1246
1247         if (!direct) {
1248             if (pic->f->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1249                 pic->f->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1250                 pic->f->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1251                 // empty
1252             } else {
1253                 int h_chroma_shift, v_chroma_shift;
1254                 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1255                                                  &h_chroma_shift,
1256                                                  &v_chroma_shift);
1257
1258                 for (i = 0; i < 3; i++) {
1259                     int src_stride = pic_arg->linesize[i];
1260                     int dst_stride = i ? s->uvlinesize : s->linesize;
1261                     int h_shift = i ? h_chroma_shift : 0;
1262                     int v_shift = i ? v_chroma_shift : 0;
1263                     int w = s->width  >> h_shift;
1264                     int h = s->height >> v_shift;
1265                     uint8_t *src = pic_arg->data[i];
1266                     uint8_t *dst = pic->f->data[i];
1267                     int vpad = 16;
1268
1269                     if (   s->codec_id == AV_CODEC_ID_MPEG2VIDEO
1270                         && !s->progressive_sequence
1271                         && FFALIGN(s->height, 32) - s->height > 16)
1272                         vpad = 32;
1273
1274                     if (!s->avctx->rc_buffer_size)
1275                         dst += INPLACE_OFFSET;
1276
1277                     if (src_stride == dst_stride)
1278                         memcpy(dst, src, src_stride * h);
1279                     else {
1280                         int h2 = h;
1281                         uint8_t *dst2 = dst;
1282                         while (h2--) {
1283                             memcpy(dst2, src, w);
1284                             dst2 += dst_stride;
1285                             src += src_stride;
1286                         }
1287                     }
1288                     if ((s->width & 15) || (s->height & (vpad-1))) {
1289                         s->mpvencdsp.draw_edges(dst, dst_stride,
1290                                                 w, h,
1291                                                 16 >> h_shift,
1292                                                 vpad >> v_shift,
1293                                                 EDGE_BOTTOM);
1294                     }
1295                 }
1296                 emms_c();
1297             }
1298         }
1299         ret = av_frame_copy_props(pic->f, pic_arg);
1300         if (ret < 0)
1301             return ret;
1302
1303         pic->f->display_picture_number = display_picture_number;
1304         pic->f->pts = pts; // we set this here to avoid modifying pic_arg
1305     } else {
1306         /* Flushing: When we have not received enough input frames,
1307          * ensure s->input_picture[0] contains the first picture */
1308         for (flush_offset = 0; flush_offset < encoding_delay + 1; flush_offset++)
1309             if (s->input_picture[flush_offset])
1310                 break;
1311
1312         if (flush_offset <= 1)
1313             flush_offset = 1;
1314         else
1315             encoding_delay = encoding_delay - flush_offset + 1;
1316     }
1317
1318     /* shift buffer entries */
1319     for (i = flush_offset; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1320         s->input_picture[i - flush_offset] = s->input_picture[i];
1321
1322     s->input_picture[encoding_delay] = (Picture*) pic;
1323
1324     return 0;
1325 }
1326
1327 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1328 {
1329     int x, y, plane;
1330     int score = 0;
1331     int64_t score64 = 0;
1332
1333     for (plane = 0; plane < 3; plane++) {
1334         const int stride = p->f->linesize[plane];
1335         const int bw = plane ? 1 : 2;
1336         for (y = 0; y < s->mb_height * bw; y++) {
1337             for (x = 0; x < s->mb_width * bw; x++) {
1338                 int off = p->shared ? 0 : 16;
1339                 uint8_t *dptr = p->f->data[plane] + 8 * (x + y * stride) + off;
1340                 uint8_t *rptr = ref->f->data[plane] + 8 * (x + y * stride);
1341                 int v = s->mecc.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1342
1343                 switch (FFABS(s->frame_skip_exp)) {
1344                 case 0: score    =  FFMAX(score, v);          break;
1345                 case 1: score   += FFABS(v);                  break;
1346                 case 2: score64 += v * (int64_t)v;                       break;
1347                 case 3: score64 += FFABS(v * (int64_t)v * v);            break;
1348                 case 4: score64 += (v * (int64_t)v) * (v * (int64_t)v);  break;
1349                 }
1350             }
1351         }
1352     }
1353     emms_c();
1354
1355     if (score)
1356         score64 = score;
1357     if (s->frame_skip_exp < 0)
1358         score64 = pow(score64 / (double)(s->mb_width * s->mb_height),
1359                       -1.0/s->frame_skip_exp);
1360
1361     if (score64 < s->frame_skip_threshold)
1362         return 1;
1363     if (score64 < ((s->frame_skip_factor * (int64_t) s->lambda) >> 8))
1364         return 1;
1365     return 0;
1366 }
1367
1368 static int encode_frame(AVCodecContext *c, AVFrame *frame, AVPacket *pkt)
1369 {
1370     int ret;
1371     int size = 0;
1372
1373     ret = avcodec_send_frame(c, frame);
1374     if (ret < 0)
1375         return ret;
1376
1377     do {
1378         ret = avcodec_receive_packet(c, pkt);
1379         if (ret >= 0) {
1380             size += pkt->size;
1381             av_packet_unref(pkt);
1382         } else if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
1383             return ret;
1384     } while (ret >= 0);
1385
1386     return size;
1387 }
1388
1389 static int estimate_best_b_count(MpegEncContext *s)
1390 {
1391     const AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
1392     AVPacket *pkt;
1393     const int scale = s->brd_scale;
1394     int width  = s->width  >> scale;
1395     int height = s->height >> scale;
1396     int i, j, out_size, p_lambda, b_lambda, lambda2;
1397     int64_t best_rd  = INT64_MAX;
1398     int best_b_count = -1;
1399     int ret = 0;
1400
1401     av_assert0(scale >= 0 && scale <= 3);
1402
1403     pkt = av_packet_alloc();
1404     if (!pkt)
1405         return AVERROR(ENOMEM);
1406
1407     //emms_c();
1408     //s->next_picture_ptr->quality;
1409     p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1410     //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1411     b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1412     if (!b_lambda) // FIXME we should do this somewhere else
1413         b_lambda = p_lambda;
1414     lambda2  = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1415                FF_LAMBDA_SHIFT;
1416
1417     for (i = 0; i < s->max_b_frames + 2; i++) {
1418         Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1419                                                 s->next_picture_ptr;
1420         uint8_t *data[4];
1421
1422         if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1423             pre_input = *pre_input_ptr;
1424             memcpy(data, pre_input_ptr->f->data, sizeof(data));
1425
1426             if (!pre_input.shared && i) {
1427                 data[0] += INPLACE_OFFSET;
1428                 data[1] += INPLACE_OFFSET;
1429                 data[2] += INPLACE_OFFSET;
1430             }
1431
1432             s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[0],
1433                                        s->tmp_frames[i]->linesize[0],
1434                                        data[0],
1435                                        pre_input.f->linesize[0],
1436                                        width, height);
1437             s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[1],
1438                                        s->tmp_frames[i]->linesize[1],
1439                                        data[1],
1440                                        pre_input.f->linesize[1],
1441                                        width >> 1, height >> 1);
1442             s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[2],
1443                                        s->tmp_frames[i]->linesize[2],
1444                                        data[2],
1445                                        pre_input.f->linesize[2],
1446                                        width >> 1, height >> 1);
1447         }
1448     }
1449
1450     for (j = 0; j < s->max_b_frames + 1; j++) {
1451         AVCodecContext *c;
1452         int64_t rd = 0;
1453
1454         if (!s->input_picture[j])
1455             break;
1456
1457         c = avcodec_alloc_context3(NULL);
1458         if (!c) {
1459             ret = AVERROR(ENOMEM);
1460             goto fail;
1461         }
1462
1463         c->width        = width;
1464         c->height       = height;
1465         c->flags        = AV_CODEC_FLAG_QSCALE | AV_CODEC_FLAG_PSNR;
1466         c->flags       |= s->avctx->flags & AV_CODEC_FLAG_QPEL;
1467         c->mb_decision  = s->avctx->mb_decision;
1468         c->me_cmp       = s->avctx->me_cmp;
1469         c->mb_cmp       = s->avctx->mb_cmp;
1470         c->me_sub_cmp   = s->avctx->me_sub_cmp;
1471         c->pix_fmt      = AV_PIX_FMT_YUV420P;
1472         c->time_base    = s->avctx->time_base;
1473         c->max_b_frames = s->max_b_frames;
1474
1475         ret = avcodec_open2(c, codec, NULL);
1476         if (ret < 0)
1477             goto fail;
1478
1479
1480         s->tmp_frames[0]->pict_type = AV_PICTURE_TYPE_I;
1481         s->tmp_frames[0]->quality   = 1 * FF_QP2LAMBDA;
1482
1483         out_size = encode_frame(c, s->tmp_frames[0], pkt);
1484         if (out_size < 0) {
1485             ret = out_size;
1486             goto fail;
1487         }
1488
1489         //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1490
1491         for (i = 0; i < s->max_b_frames + 1; i++) {
1492             int is_p = i % (j + 1) == j || i == s->max_b_frames;
1493
1494             s->tmp_frames[i + 1]->pict_type = is_p ?
1495                                      AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1496             s->tmp_frames[i + 1]->quality   = is_p ? p_lambda : b_lambda;
1497
1498             out_size = encode_frame(c, s->tmp_frames[i + 1], pkt);
1499             if (out_size < 0) {
1500                 ret = out_size;
1501                 goto fail;
1502             }
1503
1504             rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1505         }
1506
1507         /* get the delayed frames */
1508         out_size = encode_frame(c, NULL, pkt);
1509         if (out_size < 0) {
1510             ret = out_size;
1511             goto fail;
1512         }
1513         rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1514
1515         rd += c->error[0] + c->error[1] + c->error[2];
1516
1517         if (rd < best_rd) {
1518             best_rd = rd;
1519             best_b_count = j;
1520         }
1521
1522 fail:
1523         avcodec_free_context(&c);
1524         av_packet_unref(pkt);
1525         if (ret < 0) {
1526             best_b_count = ret;
1527             break;
1528         }
1529     }
1530
1531     av_packet_free(&pkt);
1532
1533     return best_b_count;
1534 }
1535
1536 static int select_input_picture(MpegEncContext *s)
1537 {
1538     int i, ret;
1539
1540     for (i = 1; i < MAX_PICTURE_COUNT; i++)
1541         s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1542     s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1543
1544     /* set next picture type & ordering */
1545     if (!s->reordered_input_picture[0] && s->input_picture[0]) {
1546         if (s->frame_skip_threshold || s->frame_skip_factor) {
1547             if (s->picture_in_gop_number < s->gop_size &&
1548                 s->next_picture_ptr &&
1549                 skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1550                 // FIXME check that the gop check above is +-1 correct
1551                 av_frame_unref(s->input_picture[0]->f);
1552
1553                 ff_vbv_update(s, 0);
1554
1555                 goto no_output_pic;
1556             }
1557         }
1558
1559         if (/*s->picture_in_gop_number >= s->gop_size ||*/
1560             !s->next_picture_ptr || s->intra_only) {
1561             s->reordered_input_picture[0] = s->input_picture[0];
1562             s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_I;
1563             s->reordered_input_picture[0]->f->coded_picture_number =
1564                 s->coded_picture_number++;
1565         } else {
1566             int b_frames = 0;
1567
1568             if (s->avctx->flags & AV_CODEC_FLAG_PASS2) {
1569                 for (i = 0; i < s->max_b_frames + 1; i++) {
1570                     int pict_num = s->input_picture[0]->f->display_picture_number + i;
1571
1572                     if (pict_num >= s->rc_context.num_entries)
1573                         break;
1574                     if (!s->input_picture[i]) {
1575                         s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1576                         break;
1577                     }
1578
1579                     s->input_picture[i]->f->pict_type =
1580                         s->rc_context.entry[pict_num].new_pict_type;
1581                 }
1582             }
1583
1584             if (s->b_frame_strategy == 0) {
1585                 b_frames = s->max_b_frames;
1586                 while (b_frames && !s->input_picture[b_frames])
1587                     b_frames--;
1588             } else if (s->b_frame_strategy == 1) {
1589                 for (i = 1; i < s->max_b_frames + 1; i++) {
1590                     if (s->input_picture[i] &&
1591                         s->input_picture[i]->b_frame_score == 0) {
1592                         s->input_picture[i]->b_frame_score =
1593                             get_intra_count(s,
1594                                             s->input_picture[i    ]->f->data[0],
1595                                             s->input_picture[i - 1]->f->data[0],
1596                                             s->linesize) + 1;
1597                     }
1598                 }
1599                 for (i = 0; i < s->max_b_frames + 1; i++) {
1600                     if (!s->input_picture[i] ||
1601                         s->input_picture[i]->b_frame_score - 1 >
1602                             s->mb_num / s->b_sensitivity)
1603                         break;
1604                 }
1605
1606                 b_frames = FFMAX(0, i - 1);
1607
1608                 /* reset scores */
1609                 for (i = 0; i < b_frames + 1; i++) {
1610                     s->input_picture[i]->b_frame_score = 0;
1611                 }
1612             } else if (s->b_frame_strategy == 2) {
1613                 b_frames = estimate_best_b_count(s);
1614                 if (b_frames < 0)
1615                     return b_frames;
1616             }
1617
1618             emms_c();
1619
1620             for (i = b_frames - 1; i >= 0; i--) {
1621                 int type = s->input_picture[i]->f->pict_type;
1622                 if (type && type != AV_PICTURE_TYPE_B)
1623                     b_frames = i;
1624             }
1625             if (s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_B &&
1626                 b_frames == s->max_b_frames) {
1627                 av_log(s->avctx, AV_LOG_ERROR,
1628                        "warning, too many B-frames in a row\n");
1629             }
1630
1631             if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1632                 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1633                     s->gop_size > s->picture_in_gop_number) {
1634                     b_frames = s->gop_size - s->picture_in_gop_number - 1;
1635                 } else {
1636                     if (s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP)
1637                         b_frames = 0;
1638                     s->input_picture[b_frames]->f->pict_type = AV_PICTURE_TYPE_I;
1639                 }
1640             }
1641
1642             if ((s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP) && b_frames &&
1643                 s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_I)
1644                 b_frames--;
1645
1646             s->reordered_input_picture[0] = s->input_picture[b_frames];
1647             if (s->reordered_input_picture[0]->f->pict_type != AV_PICTURE_TYPE_I)
1648                 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_P;
1649             s->reordered_input_picture[0]->f->coded_picture_number =
1650                 s->coded_picture_number++;
1651             for (i = 0; i < b_frames; i++) {
1652                 s->reordered_input_picture[i + 1] = s->input_picture[i];
1653                 s->reordered_input_picture[i + 1]->f->pict_type =
1654                     AV_PICTURE_TYPE_B;
1655                 s->reordered_input_picture[i + 1]->f->coded_picture_number =
1656                     s->coded_picture_number++;
1657             }
1658         }
1659     }
1660 no_output_pic:
1661     ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1662
1663     if (s->reordered_input_picture[0]) {
1664         s->reordered_input_picture[0]->reference =
1665            s->reordered_input_picture[0]->f->pict_type !=
1666                AV_PICTURE_TYPE_B ? 3 : 0;
1667
1668         if ((ret = ff_mpeg_ref_picture(s->avctx, &s->new_picture, s->reordered_input_picture[0])))
1669             return ret;
1670
1671         if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
1672             // input is a shared pix, so we can't modify it -> allocate a new
1673             // one & ensure that the shared one is reuseable
1674
1675             Picture *pic;
1676             int i = ff_find_unused_picture(s->avctx, s->picture, 0);
1677             if (i < 0)
1678                 return i;
1679             pic = &s->picture[i];
1680
1681             pic->reference = s->reordered_input_picture[0]->reference;
1682             if (alloc_picture(s, pic, 0) < 0) {
1683                 return -1;
1684             }
1685
1686             ret = av_frame_copy_props(pic->f, s->reordered_input_picture[0]->f);
1687             if (ret < 0)
1688                 return ret;
1689
1690             /* mark us unused / free shared pic */
1691             av_frame_unref(s->reordered_input_picture[0]->f);
1692             s->reordered_input_picture[0]->shared = 0;
1693
1694             s->current_picture_ptr = pic;
1695         } else {
1696             // input is not a shared pix -> reuse buffer for current_pix
1697             s->current_picture_ptr = s->reordered_input_picture[0];
1698             for (i = 0; i < 4; 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 (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1997                     stuffing_count + 50) {
1998                 av_log(avctx, AV_LOG_ERROR, "stuffing too large\n");
1999                 return -1;
2000             }
2001
2002             switch (s->codec_id) {
2003             case AV_CODEC_ID_MPEG1VIDEO:
2004             case AV_CODEC_ID_MPEG2VIDEO:
2005                 while (stuffing_count--) {
2006                     put_bits(&s->pb, 8, 0);
2007                 }
2008             break;
2009             case AV_CODEC_ID_MPEG4:
2010                 put_bits(&s->pb, 16, 0);
2011                 put_bits(&s->pb, 16, 0x1C3);
2012                 stuffing_count -= 4;
2013                 while (stuffing_count--) {
2014                     put_bits(&s->pb, 8, 0xFF);
2015                 }
2016             break;
2017             default:
2018                 av_log(avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
2019             }
2020             flush_put_bits(&s->pb);
2021             s->frame_bits  = put_bits_count(&s->pb);
2022         }
2023
2024         /* update MPEG-1/2 vbv_delay for CBR */
2025         if (avctx->rc_max_rate                          &&
2026             avctx->rc_min_rate == avctx->rc_max_rate &&
2027             s->out_format == FMT_MPEG1                     &&
2028             90000LL * (avctx->rc_buffer_size - 1) <=
2029                 avctx->rc_max_rate * 0xFFFFLL) {
2030             AVCPBProperties *props;
2031             size_t props_size;
2032
2033             int vbv_delay, min_delay;
2034             double inbits  = avctx->rc_max_rate *
2035                              av_q2d(avctx->time_base);
2036             int    minbits = s->frame_bits - 8 *
2037                              (s->vbv_delay_ptr - s->pb.buf - 1);
2038             double bits    = s->rc_context.buffer_index + minbits - inbits;
2039
2040             if (bits < 0)
2041                 av_log(avctx, AV_LOG_ERROR,
2042                        "Internal error, negative bits\n");
2043
2044             av_assert1(s->repeat_first_field == 0);
2045
2046             vbv_delay = bits * 90000 / avctx->rc_max_rate;
2047             min_delay = (minbits * 90000LL + avctx->rc_max_rate - 1) /
2048                         avctx->rc_max_rate;
2049
2050             vbv_delay = FFMAX(vbv_delay, min_delay);
2051
2052             av_assert0(vbv_delay < 0xFFFF);
2053
2054             s->vbv_delay_ptr[0] &= 0xF8;
2055             s->vbv_delay_ptr[0] |= vbv_delay >> 13;
2056             s->vbv_delay_ptr[1]  = vbv_delay >> 5;
2057             s->vbv_delay_ptr[2] &= 0x07;
2058             s->vbv_delay_ptr[2] |= vbv_delay << 3;
2059
2060             props = av_cpb_properties_alloc(&props_size);
2061             if (!props)
2062                 return AVERROR(ENOMEM);
2063             props->vbv_delay = vbv_delay * 300;
2064
2065             ret = av_packet_add_side_data(pkt, AV_PKT_DATA_CPB_PROPERTIES,
2066                                           (uint8_t*)props, props_size);
2067             if (ret < 0) {
2068                 av_freep(&props);
2069                 return ret;
2070             }
2071
2072 #if FF_API_VBV_DELAY
2073 FF_DISABLE_DEPRECATION_WARNINGS
2074             avctx->vbv_delay     = vbv_delay * 300;
2075 FF_ENABLE_DEPRECATION_WARNINGS
2076 #endif
2077         }
2078         s->total_bits     += s->frame_bits;
2079 #if FF_API_STAT_BITS
2080 FF_DISABLE_DEPRECATION_WARNINGS
2081         avctx->frame_bits  = s->frame_bits;
2082 FF_ENABLE_DEPRECATION_WARNINGS
2083 #endif
2084
2085
2086         pkt->pts = s->current_picture.f->pts;
2087         if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
2088             if (!s->current_picture.f->coded_picture_number)
2089                 pkt->dts = pkt->pts - s->dts_delta;
2090             else
2091                 pkt->dts = s->reordered_pts;
2092             s->reordered_pts = pkt->pts;
2093         } else
2094             pkt->dts = pkt->pts;
2095         if (s->current_picture.f->key_frame)
2096             pkt->flags |= AV_PKT_FLAG_KEY;
2097         if (s->mb_info)
2098             av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
2099     } else {
2100         s->frame_bits = 0;
2101     }
2102
2103     /* release non-reference frames */
2104     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
2105         if (!s->picture[i].reference)
2106             ff_mpeg_unref_picture(avctx, &s->picture[i]);
2107     }
2108
2109     av_assert1((s->frame_bits & 7) == 0);
2110
2111     pkt->size = s->frame_bits / 8;
2112     *got_packet = !!pkt->size;
2113     return 0;
2114 }
2115
2116 static inline void dct_single_coeff_elimination(MpegEncContext *s,
2117                                                 int n, int threshold)
2118 {
2119     static const char tab[64] = {
2120         3, 2, 2, 1, 1, 1, 1, 1,
2121         1, 1, 1, 1, 1, 1, 1, 1,
2122         1, 1, 1, 1, 1, 1, 1, 1,
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         0, 0, 0, 0, 0, 0, 0, 0
2128     };
2129     int score = 0;
2130     int run = 0;
2131     int i;
2132     int16_t *block = s->block[n];
2133     const int last_index = s->block_last_index[n];
2134     int skip_dc;
2135
2136     if (threshold < 0) {
2137         skip_dc = 0;
2138         threshold = -threshold;
2139     } else
2140         skip_dc = 1;
2141
2142     /* Are all we could set to zero already zero? */
2143     if (last_index <= skip_dc - 1)
2144         return;
2145
2146     for (i = 0; i <= last_index; i++) {
2147         const int j = s->intra_scantable.permutated[i];
2148         const int level = FFABS(block[j]);
2149         if (level == 1) {
2150             if (skip_dc && i == 0)
2151                 continue;
2152             score += tab[run];
2153             run = 0;
2154         } else if (level > 1) {
2155             return;
2156         } else {
2157             run++;
2158         }
2159     }
2160     if (score >= threshold)
2161         return;
2162     for (i = skip_dc; i <= last_index; i++) {
2163         const int j = s->intra_scantable.permutated[i];
2164         block[j] = 0;
2165     }
2166     if (block[0])
2167         s->block_last_index[n] = 0;
2168     else
2169         s->block_last_index[n] = -1;
2170 }
2171
2172 static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
2173                                int last_index)
2174 {
2175     int i;
2176     const int maxlevel = s->max_qcoeff;
2177     const int minlevel = s->min_qcoeff;
2178     int overflow = 0;
2179
2180     if (s->mb_intra) {
2181         i = 1; // skip clipping of intra dc
2182     } else
2183         i = 0;
2184
2185     for (; i <= last_index; i++) {
2186         const int j = s->intra_scantable.permutated[i];
2187         int level = block[j];
2188
2189         if (level > maxlevel) {
2190             level = maxlevel;
2191             overflow++;
2192         } else if (level < minlevel) {
2193             level = minlevel;
2194             overflow++;
2195         }
2196
2197         block[j] = level;
2198     }
2199
2200     if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
2201         av_log(s->avctx, AV_LOG_INFO,
2202                "warning, clipping %d dct coefficients to %d..%d\n",
2203                overflow, minlevel, maxlevel);
2204 }
2205
2206 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
2207 {
2208     int x, y;
2209     // FIXME optimize
2210     for (y = 0; y < 8; y++) {
2211         for (x = 0; x < 8; x++) {
2212             int x2, y2;
2213             int sum = 0;
2214             int sqr = 0;
2215             int count = 0;
2216
2217             for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
2218                 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
2219                     int v = ptr[x2 + y2 * stride];
2220                     sum += v;
2221                     sqr += v * v;
2222                     count++;
2223                 }
2224             }
2225             weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
2226         }
2227     }
2228 }
2229
2230 static av_always_inline void encode_mb_internal(MpegEncContext *s,
2231                                                 int motion_x, int motion_y,
2232                                                 int mb_block_height,
2233                                                 int mb_block_width,
2234                                                 int mb_block_count)
2235 {
2236     int16_t weight[12][64];
2237     int16_t orig[12][64];
2238     const int mb_x = s->mb_x;
2239     const int mb_y = s->mb_y;
2240     int i;
2241     int skip_dct[12];
2242     int dct_offset = s->linesize * 8; // default for progressive frames
2243     int uv_dct_offset = s->uvlinesize * 8;
2244     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2245     ptrdiff_t wrap_y, wrap_c;
2246
2247     for (i = 0; i < mb_block_count; i++)
2248         skip_dct[i] = s->skipdct;
2249
2250     if (s->adaptive_quant) {
2251         const int last_qp = s->qscale;
2252         const int mb_xy = mb_x + mb_y * s->mb_stride;
2253
2254         s->lambda = s->lambda_table[mb_xy];
2255         update_qscale(s);
2256
2257         if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
2258             s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
2259             s->dquant = s->qscale - last_qp;
2260
2261             if (s->out_format == FMT_H263) {
2262                 s->dquant = av_clip(s->dquant, -2, 2);
2263
2264                 if (s->codec_id == AV_CODEC_ID_MPEG4) {
2265                     if (!s->mb_intra) {
2266                         if (s->pict_type == AV_PICTURE_TYPE_B) {
2267                             if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
2268                                 s->dquant = 0;
2269                         }
2270                         if (s->mv_type == MV_TYPE_8X8)
2271                             s->dquant = 0;
2272                     }
2273                 }
2274             }
2275         }
2276         ff_set_qscale(s, last_qp + s->dquant);
2277     } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
2278         ff_set_qscale(s, s->qscale + s->dquant);
2279
2280     wrap_y = s->linesize;
2281     wrap_c = s->uvlinesize;
2282     ptr_y  = s->new_picture.f->data[0] +
2283              (mb_y * 16 * wrap_y)              + mb_x * 16;
2284     ptr_cb = s->new_picture.f->data[1] +
2285              (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2286     ptr_cr = s->new_picture.f->data[2] +
2287              (mb_y * mb_block_height * wrap_c) + mb_x * mb_block_width;
2288
2289     if((mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) && s->codec_id != AV_CODEC_ID_AMV){
2290         uint8_t *ebuf = s->sc.edge_emu_buffer + 38 * wrap_y;
2291         int cw = (s->width  + s->chroma_x_shift) >> s->chroma_x_shift;
2292         int ch = (s->height + s->chroma_y_shift) >> s->chroma_y_shift;
2293         s->vdsp.emulated_edge_mc(ebuf, ptr_y,
2294                                  wrap_y, wrap_y,
2295                                  16, 16, mb_x * 16, mb_y * 16,
2296                                  s->width, s->height);
2297         ptr_y = ebuf;
2298         s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y, ptr_cb,
2299                                  wrap_c, wrap_c,
2300                                  mb_block_width, mb_block_height,
2301                                  mb_x * mb_block_width, mb_y * mb_block_height,
2302                                  cw, ch);
2303         ptr_cb = ebuf + 16 * wrap_y;
2304         s->vdsp.emulated_edge_mc(ebuf + 16 * wrap_y + 16, ptr_cr,
2305                                  wrap_c, wrap_c,
2306                                  mb_block_width, mb_block_height,
2307                                  mb_x * mb_block_width, mb_y * mb_block_height,
2308                                  cw, ch);
2309         ptr_cr = ebuf + 16 * wrap_y + 16;
2310     }
2311
2312     if (s->mb_intra) {
2313         if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
2314             int progressive_score, interlaced_score;
2315
2316             s->interlaced_dct = 0;
2317             progressive_score = s->mecc.ildct_cmp[4](s, ptr_y, NULL, wrap_y, 8) +
2318                                 s->mecc.ildct_cmp[4](s, ptr_y + wrap_y * 8,
2319                                                      NULL, wrap_y, 8) - 400;
2320
2321             if (progressive_score > 0) {
2322                 interlaced_score = s->mecc.ildct_cmp[4](s, ptr_y,
2323                                                         NULL, wrap_y * 2, 8) +
2324                                    s->mecc.ildct_cmp[4](s, ptr_y + wrap_y,
2325                                                         NULL, wrap_y * 2, 8);
2326                 if (progressive_score > interlaced_score) {
2327                     s->interlaced_dct = 1;
2328
2329                     dct_offset = wrap_y;
2330                     uv_dct_offset = wrap_c;
2331                     wrap_y <<= 1;
2332                     if (s->chroma_format == CHROMA_422 ||
2333                         s->chroma_format == CHROMA_444)
2334                         wrap_c <<= 1;
2335                 }
2336             }
2337         }
2338
2339         s->pdsp.get_pixels(s->block[0], ptr_y,                  wrap_y);
2340         s->pdsp.get_pixels(s->block[1], ptr_y + 8,              wrap_y);
2341         s->pdsp.get_pixels(s->block[2], ptr_y + dct_offset,     wrap_y);
2342         s->pdsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
2343
2344         if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2345             skip_dct[4] = 1;
2346             skip_dct[5] = 1;
2347         } else {
2348             s->pdsp.get_pixels(s->block[4], ptr_cb, wrap_c);
2349             s->pdsp.get_pixels(s->block[5], ptr_cr, wrap_c);
2350             if (!s->chroma_y_shift && s->chroma_x_shift) { /* 422 */
2351                 s->pdsp.get_pixels(s->block[6], ptr_cb + uv_dct_offset, wrap_c);
2352                 s->pdsp.get_pixels(s->block[7], ptr_cr + uv_dct_offset, wrap_c);
2353             } else if (!s->chroma_y_shift && !s->chroma_x_shift) { /* 444 */
2354                 s->pdsp.get_pixels(s->block[ 6], ptr_cb + 8, wrap_c);
2355                 s->pdsp.get_pixels(s->block[ 7], ptr_cr + 8, wrap_c);
2356                 s->pdsp.get_pixels(s->block[ 8], ptr_cb + uv_dct_offset, wrap_c);
2357                 s->pdsp.get_pixels(s->block[ 9], ptr_cr + uv_dct_offset, wrap_c);
2358                 s->pdsp.get_pixels(s->block[10], ptr_cb + uv_dct_offset + 8, wrap_c);
2359                 s->pdsp.get_pixels(s->block[11], ptr_cr + uv_dct_offset + 8, wrap_c);
2360             }
2361         }
2362     } else {
2363         op_pixels_func (*op_pix)[4];
2364         qpel_mc_func (*op_qpix)[16];
2365         uint8_t *dest_y, *dest_cb, *dest_cr;
2366
2367         dest_y  = s->dest[0];
2368         dest_cb = s->dest[1];
2369         dest_cr = s->dest[2];
2370
2371         if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
2372             op_pix  = s->hdsp.put_pixels_tab;
2373             op_qpix = s->qdsp.put_qpel_pixels_tab;
2374         } else {
2375             op_pix  = s->hdsp.put_no_rnd_pixels_tab;
2376             op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab;
2377         }
2378
2379         if (s->mv_dir & MV_DIR_FORWARD) {
2380             ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0,
2381                           s->last_picture.f->data,
2382                           op_pix, op_qpix);
2383             op_pix  = s->hdsp.avg_pixels_tab;
2384             op_qpix = s->qdsp.avg_qpel_pixels_tab;
2385         }
2386         if (s->mv_dir & MV_DIR_BACKWARD) {
2387             ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1,
2388                           s->next_picture.f->data,
2389                           op_pix, op_qpix);
2390         }
2391
2392         if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
2393             int progressive_score, interlaced_score;
2394
2395             s->interlaced_dct = 0;
2396             progressive_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y, wrap_y, 8) +
2397                                 s->mecc.ildct_cmp[0](s, dest_y + wrap_y * 8,
2398                                                      ptr_y + wrap_y * 8,
2399                                                      wrap_y, 8) - 400;
2400
2401             if (s->avctx->ildct_cmp == FF_CMP_VSSE)
2402                 progressive_score -= 400;
2403
2404             if (progressive_score > 0) {
2405                 interlaced_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y,
2406                                                         wrap_y * 2, 8) +
2407                                    s->mecc.ildct_cmp[0](s, dest_y + wrap_y,
2408                                                         ptr_y + wrap_y,
2409                                                         wrap_y * 2, 8);
2410
2411                 if (progressive_score > interlaced_score) {
2412                     s->interlaced_dct = 1;
2413
2414                     dct_offset = wrap_y;
2415                     uv_dct_offset = wrap_c;
2416                     wrap_y <<= 1;
2417                     if (s->chroma_format == CHROMA_422)
2418                         wrap_c <<= 1;
2419                 }
2420             }
2421         }
2422
2423         s->pdsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
2424         s->pdsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2425         s->pdsp.diff_pixels(s->block[2], ptr_y + dct_offset,
2426                             dest_y + dct_offset, wrap_y);
2427         s->pdsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
2428                             dest_y + dct_offset + 8, wrap_y);
2429
2430         if (s->avctx->flags & AV_CODEC_FLAG_GRAY) {
2431             skip_dct[4] = 1;
2432             skip_dct[5] = 1;
2433         } else {
2434             s->pdsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2435             s->pdsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2436             if (!s->chroma_y_shift) { /* 422 */
2437                 s->pdsp.diff_pixels(s->block[6], ptr_cb + uv_dct_offset,
2438                                     dest_cb + uv_dct_offset, wrap_c);
2439                 s->pdsp.diff_pixels(s->block[7], ptr_cr + uv_dct_offset,
2440                                     dest_cr + uv_dct_offset, wrap_c);
2441             }
2442         }
2443         /* pre quantization */
2444         if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
2445                 2 * s->qscale * s->qscale) {
2446             // FIXME optimize
2447             if (s->mecc.sad[1](NULL, ptr_y, dest_y, wrap_y, 8) < 20 * s->qscale)
2448                 skip_dct[0] = 1;
2449             if (s->mecc.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 * s->qscale)
2450                 skip_dct[1] = 1;
2451             if (s->mecc.sad[1](NULL, ptr_y + dct_offset, dest_y + dct_offset,
2452                                wrap_y, 8) < 20 * s->qscale)
2453                 skip_dct[2] = 1;
2454             if (s->mecc.sad[1](NULL, ptr_y + dct_offset + 8, dest_y + dct_offset + 8,
2455                                wrap_y, 8) < 20 * s->qscale)
2456                 skip_dct[3] = 1;
2457             if (s->mecc.sad[1](NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 * s->qscale)
2458                 skip_dct[4] = 1;
2459             if (s->mecc.sad[1](NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 * s->qscale)
2460                 skip_dct[5] = 1;
2461             if (!s->chroma_y_shift) { /* 422 */
2462                 if (s->mecc.sad[1](NULL, ptr_cb + uv_dct_offset,
2463                                    dest_cb + uv_dct_offset,
2464                                    wrap_c, 8) < 20 * s->qscale)
2465                     skip_dct[6] = 1;
2466                 if (s->mecc.sad[1](NULL, ptr_cr + uv_dct_offset,
2467                                    dest_cr + uv_dct_offset,
2468                                    wrap_c, 8) < 20 * s->qscale)
2469                     skip_dct[7] = 1;
2470             }
2471         }
2472     }
2473
2474     if (s->quantizer_noise_shaping) {
2475         if (!skip_dct[0])
2476             get_visual_weight(weight[0], ptr_y                 , wrap_y);
2477         if (!skip_dct[1])
2478             get_visual_weight(weight[1], ptr_y              + 8, wrap_y);
2479         if (!skip_dct[2])
2480             get_visual_weight(weight[2], ptr_y + dct_offset    , wrap_y);
2481         if (!skip_dct[3])
2482             get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2483         if (!skip_dct[4])
2484             get_visual_weight(weight[4], ptr_cb                , wrap_c);
2485         if (!skip_dct[5])
2486             get_visual_weight(weight[5], ptr_cr                , wrap_c);
2487         if (!s->chroma_y_shift) { /* 422 */
2488             if (!skip_dct[6])
2489                 get_visual_weight(weight[6], ptr_cb + uv_dct_offset,
2490                                   wrap_c);
2491             if (!skip_dct[7])
2492                 get_visual_weight(weight[7], ptr_cr + uv_dct_offset,
2493                                   wrap_c);
2494         }
2495         memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2496     }
2497
2498     /* DCT & quantize */
2499     av_assert2(s->out_format != FMT_MJPEG || s->qscale == 8);
2500     {
2501         for (i = 0; i < mb_block_count; i++) {
2502             if (!skip_dct[i]) {
2503                 int overflow;
2504                 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2505                 // FIXME we could decide to change to quantizer instead of
2506                 // clipping
2507                 // JS: I don't think that would be a good idea it could lower
2508                 //     quality instead of improve it. Just INTRADC clipping
2509                 //     deserves changes in quantizer
2510                 if (overflow)
2511                     clip_coeffs(s, s->block[i], s->block_last_index[i]);
2512             } else
2513                 s->block_last_index[i] = -1;
2514         }
2515         if (s->quantizer_noise_shaping) {
2516             for (i = 0; i < mb_block_count; i++) {
2517                 if (!skip_dct[i]) {
2518                     s->block_last_index[i] =
2519                         dct_quantize_refine(s, s->block[i], weight[i],
2520                                             orig[i], i, s->qscale);
2521                 }
2522             }
2523         }
2524
2525         if (s->luma_elim_threshold && !s->mb_intra)
2526             for (i = 0; i < 4; i++)
2527                 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2528         if (s->chroma_elim_threshold && !s->mb_intra)
2529             for (i = 4; i < mb_block_count; i++)
2530                 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2531
2532         if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2533             for (i = 0; i < mb_block_count; i++) {
2534                 if (s->block_last_index[i] == -1)
2535                     s->coded_score[i] = INT_MAX / 256;
2536             }
2537         }
2538     }
2539
2540     if ((s->avctx->flags & AV_CODEC_FLAG_GRAY) && s->mb_intra) {
2541         s->block_last_index[4] =
2542         s->block_last_index[5] = 0;
2543         s->block[4][0] =
2544         s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2545         if (!s->chroma_y_shift) { /* 422 / 444 */
2546             for (i=6; i<12; i++) {
2547                 s->block_last_index[i] = 0;
2548                 s->block[i][0] = s->block[4][0];
2549             }
2550         }
2551     }
2552
2553     // non c quantize code returns incorrect block_last_index FIXME
2554     if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2555         for (i = 0; i < mb_block_count; i++) {
2556             int j;
2557             if (s->block_last_index[i] > 0) {
2558                 for (j = 63; j > 0; j--) {
2559                     if (s->block[i][s->intra_scantable.permutated[j]])
2560                         break;
2561                 }
2562                 s->block_last_index[i] = j;
2563             }
2564         }
2565     }
2566
2567     /* huffman encode */
2568     switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2569     case AV_CODEC_ID_MPEG1VIDEO:
2570     case AV_CODEC_ID_MPEG2VIDEO:
2571         if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2572             ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2573         break;
2574     case AV_CODEC_ID_MPEG4:
2575         if (CONFIG_MPEG4_ENCODER)
2576             ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2577         break;
2578     case AV_CODEC_ID_MSMPEG4V2:
2579     case AV_CODEC_ID_MSMPEG4V3:
2580     case AV_CODEC_ID_WMV1:
2581         if (CONFIG_MSMPEG4_ENCODER)
2582             ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2583         break;
2584     case AV_CODEC_ID_WMV2:
2585         if (CONFIG_WMV2_ENCODER)
2586             ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2587         break;
2588     case AV_CODEC_ID_H261:
2589         if (CONFIG_H261_ENCODER)
2590             ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2591         break;
2592     case AV_CODEC_ID_H263:
2593     case AV_CODEC_ID_H263P:
2594     case AV_CODEC_ID_FLV1:
2595     case AV_CODEC_ID_RV10:
2596     case AV_CODEC_ID_RV20:
2597         if (CONFIG_H263_ENCODER)
2598             ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2599         break;
2600     case AV_CODEC_ID_MJPEG:
2601     case AV_CODEC_ID_AMV:
2602         if (CONFIG_MJPEG_ENCODER)
2603             ff_mjpeg_encode_mb(s, s->block);
2604         break;
2605     case AV_CODEC_ID_SPEEDHQ:
2606         if (CONFIG_SPEEDHQ_ENCODER)
2607             ff_speedhq_encode_mb(s, s->block);
2608         break;
2609     default:
2610         av_assert1(0);
2611     }
2612 }
2613
2614 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2615 {
2616     if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y,  8, 8, 6);
2617     else if (s->chroma_format == CHROMA_422) encode_mb_internal(s, motion_x, motion_y, 16, 8, 8);
2618     else encode_mb_internal(s, motion_x, motion_y, 16, 16, 12);
2619 }
2620
2621 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2622     int i;
2623
2624     memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2625
2626     /* MPEG-1 */
2627     d->mb_skip_run= s->mb_skip_run;
2628     for(i=0; i<3; i++)
2629         d->last_dc[i] = s->last_dc[i];
2630
2631     /* statistics */
2632     d->mv_bits= s->mv_bits;
2633     d->i_tex_bits= s->i_tex_bits;
2634     d->p_tex_bits= s->p_tex_bits;
2635     d->i_count= s->i_count;
2636     d->f_count= s->f_count;
2637     d->b_count= s->b_count;
2638     d->skip_count= s->skip_count;
2639     d->misc_bits= s->misc_bits;
2640     d->last_bits= 0;
2641
2642     d->mb_skipped= 0;
2643     d->qscale= s->qscale;
2644     d->dquant= s->dquant;
2645
2646     d->esc3_level_length= s->esc3_level_length;
2647 }
2648
2649 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2650     int i;
2651
2652     memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2653     memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2654
2655     /* MPEG-1 */
2656     d->mb_skip_run= s->mb_skip_run;
2657     for(i=0; i<3; i++)
2658         d->last_dc[i] = s->last_dc[i];
2659
2660     /* statistics */
2661     d->mv_bits= s->mv_bits;
2662     d->i_tex_bits= s->i_tex_bits;
2663     d->p_tex_bits= s->p_tex_bits;
2664     d->i_count= s->i_count;
2665     d->f_count= s->f_count;
2666     d->b_count= s->b_count;
2667     d->skip_count= s->skip_count;
2668     d->misc_bits= s->misc_bits;
2669
2670     d->mb_intra= s->mb_intra;
2671     d->mb_skipped= s->mb_skipped;
2672     d->mv_type= s->mv_type;
2673     d->mv_dir= s->mv_dir;
2674     d->pb= s->pb;
2675     if(s->data_partitioning){
2676         d->pb2= s->pb2;
2677         d->tex_pb= s->tex_pb;
2678     }
2679     d->block= s->block;
2680     for(i=0; i<8; i++)
2681         d->block_last_index[i]= s->block_last_index[i];
2682     d->interlaced_dct= s->interlaced_dct;
2683     d->qscale= s->qscale;
2684
2685     d->esc3_level_length= s->esc3_level_length;
2686 }
2687
2688 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2689                            PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2690                            int *dmin, int *next_block, int motion_x, int motion_y)
2691 {
2692     int score;
2693     uint8_t *dest_backup[3];
2694
2695     copy_context_before_encode(s, backup, type);
2696
2697     s->block= s->blocks[*next_block];
2698     s->pb= pb[*next_block];
2699     if(s->data_partitioning){
2700         s->pb2   = pb2   [*next_block];
2701         s->tex_pb= tex_pb[*next_block];
2702     }
2703
2704     if(*next_block){
2705         memcpy(dest_backup, s->dest, sizeof(s->dest));
2706         s->dest[0] = s->sc.rd_scratchpad;
2707         s->dest[1] = s->sc.rd_scratchpad + 16*s->linesize;
2708         s->dest[2] = s->sc.rd_scratchpad + 16*s->linesize + 8;
2709         av_assert0(s->linesize >= 32); //FIXME
2710     }
2711
2712     encode_mb(s, motion_x, motion_y);
2713
2714     score= put_bits_count(&s->pb);
2715     if(s->data_partitioning){
2716         score+= put_bits_count(&s->pb2);
2717         score+= put_bits_count(&s->tex_pb);
2718     }
2719
2720     if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2721         ff_mpv_reconstruct_mb(s, s->block);
2722
2723         score *= s->lambda2;
2724         score += sse_mb(s) << FF_LAMBDA_SHIFT;
2725     }
2726
2727     if(*next_block){
2728         memcpy(s->dest, dest_backup, sizeof(s->dest));
2729     }
2730
2731     if(score<*dmin){
2732         *dmin= score;
2733         *next_block^=1;
2734
2735         copy_context_after_encode(best, s, type);
2736     }
2737 }
2738
2739 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2740     const uint32_t *sq = ff_square_tab + 256;
2741     int acc=0;
2742     int x,y;
2743
2744     if(w==16 && h==16)
2745         return s->mecc.sse[0](NULL, src1, src2, stride, 16);
2746     else if(w==8 && h==8)
2747         return s->mecc.sse[1](NULL, src1, src2, stride, 8);
2748
2749     for(y=0; y<h; y++){
2750         for(x=0; x<w; x++){
2751             acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2752         }
2753     }
2754
2755     av_assert2(acc>=0);
2756
2757     return acc;
2758 }
2759
2760 static int sse_mb(MpegEncContext *s){
2761     int w= 16;
2762     int h= 16;
2763
2764     if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2765     if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2766
2767     if(w==16 && h==16)
2768       if(s->avctx->mb_cmp == FF_CMP_NSSE){
2769         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) +
2770                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) +
2771                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);
2772       }else{
2773         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) +
2774                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) +
2775                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);
2776       }
2777     else
2778         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)
2779                +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)
2780                +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);
2781 }
2782
2783 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2784     MpegEncContext *s= *(void**)arg;
2785
2786
2787     s->me.pre_pass=1;
2788     s->me.dia_size= s->avctx->pre_dia_size;
2789     s->first_slice_line=1;
2790     for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2791         for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2792             ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2793         }
2794         s->first_slice_line=0;
2795     }
2796
2797     s->me.pre_pass=0;
2798
2799     return 0;
2800 }
2801
2802 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2803     MpegEncContext *s= *(void**)arg;
2804
2805     s->me.dia_size= s->avctx->dia_size;
2806     s->first_slice_line=1;
2807     for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2808         s->mb_x=0; //for block init below
2809         ff_init_block_index(s);
2810         for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2811             s->block_index[0]+=2;
2812             s->block_index[1]+=2;
2813             s->block_index[2]+=2;
2814             s->block_index[3]+=2;
2815
2816             /* compute motion vector & mb_type and store in context */
2817             if(s->pict_type==AV_PICTURE_TYPE_B)
2818                 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2819             else
2820                 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2821         }
2822         s->first_slice_line=0;
2823     }
2824     return 0;
2825 }
2826
2827 static int mb_var_thread(AVCodecContext *c, void *arg){
2828     MpegEncContext *s= *(void**)arg;
2829     int mb_x, mb_y;
2830
2831     for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2832         for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2833             int xx = mb_x * 16;
2834             int yy = mb_y * 16;
2835             uint8_t *pix = s->new_picture.f->data[0] + (yy * s->linesize) + xx;
2836             int varc;
2837             int sum = s->mpvencdsp.pix_sum(pix, s->linesize);
2838
2839             varc = (s->mpvencdsp.pix_norm1(pix, s->linesize) -
2840                     (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2841
2842             s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2843             s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2844             s->me.mb_var_sum_temp    += varc;
2845         }
2846     }
2847     return 0;
2848 }
2849
2850 static void write_slice_end(MpegEncContext *s){
2851     if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2852         if(s->partitioned_frame){
2853             ff_mpeg4_merge_partitions(s);
2854         }
2855
2856         ff_mpeg4_stuffing(&s->pb);
2857     }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2858         ff_mjpeg_encode_stuffing(s);
2859     } else if (CONFIG_SPEEDHQ_ENCODER && s->out_format == FMT_SPEEDHQ) {
2860         ff_speedhq_end_slice(s);
2861     }
2862
2863     flush_put_bits(&s->pb);
2864
2865     if ((s->avctx->flags & AV_CODEC_FLAG_PASS1) && !s->partitioned_frame)
2866         s->misc_bits+= get_bits_diff(s);
2867 }
2868
2869 static void write_mb_info(MpegEncContext *s)
2870 {
2871     uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2872     int offset = put_bits_count(&s->pb);
2873     int mba  = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2874     int gobn = s->mb_y / s->gob_index;
2875     int pred_x, pred_y;
2876     if (CONFIG_H263_ENCODER)
2877         ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2878     bytestream_put_le32(&ptr, offset);
2879     bytestream_put_byte(&ptr, s->qscale);
2880     bytestream_put_byte(&ptr, gobn);
2881     bytestream_put_le16(&ptr, mba);
2882     bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2883     bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2884     /* 4MV not implemented */
2885     bytestream_put_byte(&ptr, 0); /* hmv2 */
2886     bytestream_put_byte(&ptr, 0); /* vmv2 */
2887 }
2888
2889 static void update_mb_info(MpegEncContext *s, int startcode)
2890 {
2891     if (!s->mb_info)
2892         return;
2893     if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2894         s->mb_info_size += 12;
2895         s->prev_mb_info = s->last_mb_info;
2896     }
2897     if (startcode) {
2898         s->prev_mb_info = put_bits_count(&s->pb)/8;
2899         /* This might have incremented mb_info_size above, and we return without
2900          * actually writing any info into that slot yet. But in that case,
2901          * this will be called again at the start of the after writing the
2902          * start code, actually writing the mb info. */
2903         return;
2904     }
2905
2906     s->last_mb_info = put_bits_count(&s->pb)/8;
2907     if (!s->mb_info_size)
2908         s->mb_info_size += 12;
2909     write_mb_info(s);
2910 }
2911
2912 int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t size_increase)
2913 {
2914     if (   s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < threshold
2915         && s->slice_context_count == 1
2916         && s->pb.buf == s->avctx->internal->byte_buffer) {
2917         int lastgob_pos = s->ptr_lastgob - s->pb.buf;
2918         int vbv_pos     = s->vbv_delay_ptr - s->pb.buf;
2919
2920         uint8_t *new_buffer = NULL;
2921         int new_buffer_size = 0;
2922
2923         if ((s->avctx->internal->byte_buffer_size + size_increase) >= INT_MAX/8) {
2924             av_log(s->avctx, AV_LOG_ERROR, "Cannot reallocate putbit buffer\n");
2925             return AVERROR(ENOMEM);
2926         }
2927
2928         emms_c();
2929
2930         av_fast_padded_malloc(&new_buffer, &new_buffer_size,
2931                               s->avctx->internal->byte_buffer_size + size_increase);
2932         if (!new_buffer)
2933             return AVERROR(ENOMEM);
2934
2935         memcpy(new_buffer, s->avctx->internal->byte_buffer, s->avctx->internal->byte_buffer_size);
2936         av_free(s->avctx->internal->byte_buffer);
2937         s->avctx->internal->byte_buffer      = new_buffer;
2938         s->avctx->internal->byte_buffer_size = new_buffer_size;
2939         rebase_put_bits(&s->pb, new_buffer, new_buffer_size);
2940         s->ptr_lastgob   = s->pb.buf + lastgob_pos;
2941         s->vbv_delay_ptr = s->pb.buf + vbv_pos;
2942     }
2943     if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < threshold)
2944         return AVERROR(EINVAL);
2945     return 0;
2946 }
2947
2948 static int encode_thread(AVCodecContext *c, void *arg){
2949     MpegEncContext *s= *(void**)arg;
2950     int mb_x, mb_y, mb_y_order;
2951     int chr_h= 16>>s->chroma_y_shift;
2952     int i, j;
2953     MpegEncContext best_s = { 0 }, backup_s;
2954     uint8_t bit_buf[2][MAX_MB_BYTES];
2955     uint8_t bit_buf2[2][MAX_MB_BYTES];
2956     uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2957     PutBitContext pb[2], pb2[2], tex_pb[2];
2958
2959     for(i=0; i<2; i++){
2960         init_put_bits(&pb    [i], bit_buf    [i], MAX_MB_BYTES);
2961         init_put_bits(&pb2   [i], bit_buf2   [i], MAX_MB_BYTES);
2962         init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2963     }
2964
2965     s->last_bits= put_bits_count(&s->pb);
2966     s->mv_bits=0;
2967     s->misc_bits=0;
2968     s->i_tex_bits=0;
2969     s->p_tex_bits=0;
2970     s->i_count=0;
2971     s->f_count=0;
2972     s->b_count=0;
2973     s->skip_count=0;
2974
2975     for(i=0; i<3; i++){
2976         /* init last dc values */
2977         /* note: quant matrix value (8) is implied here */
2978         s->last_dc[i] = 128 << s->intra_dc_precision;
2979
2980         s->current_picture.encoding_error[i] = 0;
2981     }
2982     if(s->codec_id==AV_CODEC_ID_AMV){
2983         s->last_dc[0] = 128*8/13;
2984         s->last_dc[1] = 128*8/14;
2985         s->last_dc[2] = 128*8/14;
2986     }
2987     s->mb_skip_run = 0;
2988     memset(s->last_mv, 0, sizeof(s->last_mv));
2989
2990     s->last_mv_dir = 0;
2991
2992     switch(s->codec_id){
2993     case AV_CODEC_ID_H263:
2994     case AV_CODEC_ID_H263P:
2995     case AV_CODEC_ID_FLV1:
2996         if (CONFIG_H263_ENCODER)
2997             s->gob_index = H263_GOB_HEIGHT(s->height);
2998         break;
2999     case AV_CODEC_ID_MPEG4:
3000         if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
3001             ff_mpeg4_init_partitions(s);
3002         break;
3003     }
3004
3005     s->resync_mb_x=0;
3006     s->resync_mb_y=0;
3007     s->first_slice_line = 1;
3008     s->ptr_lastgob = s->pb.buf;
3009     for (mb_y_order = s->start_mb_y; mb_y_order < s->end_mb_y; mb_y_order++) {
3010         if (CONFIG_SPEEDHQ_ENCODER && s->codec_id == AV_CODEC_ID_SPEEDHQ) {
3011             int first_in_slice;
3012             mb_y = ff_speedhq_mb_y_order_to_mb(mb_y_order, s->mb_height, &first_in_slice);
3013             if (first_in_slice && mb_y_order != s->start_mb_y)
3014                 ff_speedhq_end_slice(s);
3015             s->last_dc[0] = s->last_dc[1] = s->last_dc[2] = 1024 << s->intra_dc_precision;
3016         } else {
3017             mb_y = mb_y_order;
3018         }
3019         s->mb_x=0;
3020         s->mb_y= mb_y;
3021
3022         ff_set_qscale(s, s->qscale);
3023         ff_init_block_index(s);
3024
3025         for(mb_x=0; mb_x < s->mb_width; mb_x++) {
3026             int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
3027             int mb_type= s->mb_type[xy];
3028 //            int d;
3029             int dmin= INT_MAX;
3030             int dir;
3031             int size_increase =  s->avctx->internal->byte_buffer_size/4
3032                                + s->mb_width*MAX_MB_BYTES;
3033
3034             ff_mpv_reallocate_putbitbuffer(s, MAX_MB_BYTES, size_increase);
3035             if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
3036                 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
3037                 return -1;
3038             }
3039             if(s->data_partitioning){
3040                 if(   s->pb2   .buf_end - s->pb2   .buf - (put_bits_count(&s->    pb2)>>3) < MAX_MB_BYTES
3041                    || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
3042                     av_log(s->avctx, AV_LOG_ERROR, "encoded partitioned frame too large\n");
3043                     return -1;
3044                 }
3045             }
3046
3047             s->mb_x = mb_x;
3048             s->mb_y = mb_y;  // moved into loop, can get changed by H.261
3049             ff_update_block_index(s);
3050
3051             if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
3052                 ff_h261_reorder_mb_index(s);
3053                 xy= s->mb_y*s->mb_stride + s->mb_x;
3054                 mb_type= s->mb_type[xy];
3055             }
3056
3057             /* write gob / video packet header  */
3058             if(s->rtp_mode){
3059                 int current_packet_size, is_gob_start;
3060
3061                 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (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_bits_count(&s->pb)/8 + 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 };