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