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