git.sesse.net Git - ffmpeg/blob - libavcodec/mpegvideo_enc.c

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