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

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