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