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

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