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