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