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