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

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