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 static int alloc_picture(MpegEncContext *s, Picture *pic, int shared)
 945 {
 946     return ff_alloc_picture(s->avctx, pic, &s->me, &s->sc, shared, 1,
 947                             s->chroma_x_shift, s->chroma_y_shift, s->out_format,
 948                             s->mb_stride, s->mb_height, s->b8_stride,
 949                             &s->linesize, &s->uvlinesize);
 950 }
 951
 952 static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
 953 {
 954     Picture *pic = NULL;
 955     int64_t pts;
 956     int i, display_picture_number = 0, ret;
 957     const int encoding_delay = s->max_b_frames ? s->max_b_frames :
 958                                                  (s->low_delay ? 0 : 1);
 959     int direct = 1;
 960
 961     if (pic_arg) {
 962         pts = pic_arg->pts;
 963         display_picture_number = s->input_picture_number++;
 964
 965         if (pts != AV_NOPTS_VALUE) {
 966             if (s->user_specified_pts != AV_NOPTS_VALUE) {
 967                 int64_t time = pts;
 968                 int64_t last = s->user_specified_pts;
 969
 970                 if (time <= last) {
 971                     av_log(s->avctx, AV_LOG_ERROR,
 972                            "Error, Invalid timestamp=%"PRId64", "
 973                            "last=%"PRId64"\n", pts, s->user_specified_pts);
 974                     return -1;
 975                 }
 976
 977                 if (!s->low_delay && display_picture_number == 1)
 978                     s->dts_delta = time - last;
 979             }
 980             s->user_specified_pts = pts;
 981         } else {
 982             if (s->user_specified_pts != AV_NOPTS_VALUE) {
 983                 s->user_specified_pts =
 984                 pts = s->user_specified_pts + 1;
 985                 av_log(s->avctx, AV_LOG_INFO,
 986                        "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
 987                        pts);
 988             } else {
 989                 pts = display_picture_number;
 990             }
 991         }
 992     }
 993
 994     if (pic_arg) {
 995         if (!pic_arg->buf[0] ||
 996             pic_arg->linesize[0] != s->linesize ||
 997             pic_arg->linesize[1] != s->uvlinesize ||
 998             pic_arg->linesize[2] != s->uvlinesize)
 999             direct = 0;
1000         if ((s->width & 15) || (s->height & 15))
1001             direct = 0;
1002
1003         ff_dlog(s->avctx, "%d %d %td %td\n", pic_arg->linesize[0],
1004                 pic_arg->linesize[1], s->linesize, s->uvlinesize);
1005
1006         i = ff_find_unused_picture(s->avctx, s->picture, direct);
1007         if (i < 0)
1008             return i;
1009
1010         pic = &s->picture[i];
1011         pic->reference = 3;
1012
1013         if (direct) {
1014             if ((ret = av_frame_ref(pic->f, pic_arg)) < 0)
1015                 return ret;
1016         }
1017         ret = alloc_picture(s, pic, direct);
1018         if (ret < 0)
1019             return ret;
1020
1021         if (!direct) {
1022             if (pic->f->data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1023                 pic->f->data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1024                 pic->f->data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1025                 // empty
1026             } else {
1027                 int h_chroma_shift, v_chroma_shift;
1028                 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1029                                                  &h_chroma_shift,
1030                                                  &v_chroma_shift);
1031
1032                 for (i = 0; i < 3; i++) {
1033                     int src_stride = pic_arg->linesize[i];
1034                     int dst_stride = i ? s->uvlinesize : s->linesize;
1035                     int h_shift = i ? h_chroma_shift : 0;
1036                     int v_shift = i ? v_chroma_shift : 0;
1037                     int w = s->width  >> h_shift;
1038                     int h = s->height >> v_shift;
1039                     uint8_t *src = pic_arg->data[i];
1040                     uint8_t *dst = pic->f->data[i];
1041
1042                     if (!s->avctx->rc_buffer_size)
1043                         dst += INPLACE_OFFSET;
1044
1045                     if (src_stride == dst_stride)
1046                         memcpy(dst, src, src_stride * h);
1047                     else {
1048                         int h2 = h;
1049                         uint8_t *dst2 = dst;
1050                         while (h2--) {
1051                             memcpy(dst2, src, w);
1052                             dst2 += dst_stride;
1053                             src += src_stride;
1054                         }
1055                     }
1056                     if ((s->width & 15) || (s->height & 15)) {
1057                         s->mpvencdsp.draw_edges(dst, dst_stride,
1058                                                 w, h,
1059                                                 16 >> h_shift,
1060                                                 16 >> v_shift,
1061                                                 EDGE_BOTTOM);
1062                     }
1063                 }
1064             }
1065         }
1066         ret = av_frame_copy_props(pic->f, pic_arg);
1067         if (ret < 0)
1068             return ret;
1069
1070         pic->f->display_picture_number = display_picture_number;
1071         pic->f->pts = pts; // we set this here to avoid modifiying pic_arg
1072     }
1073
1074     /* shift buffer entries */
1075     for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1076         s->input_picture[i - 1] = s->input_picture[i];
1077
1078     s->input_picture[encoding_delay] = (Picture*) pic;
1079
1080     return 0;
1081 }
1082
1083 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1084 {
1085     int x, y, plane;
1086     int score = 0;
1087     int64_t score64 = 0;
1088
1089     for (plane = 0; plane < 3; plane++) {
1090         const int stride = p->f->linesize[plane];
1091         const int bw = plane ? 1 : 2;
1092         for (y = 0; y < s->mb_height * bw; y++) {
1093             for (x = 0; x < s->mb_width * bw; x++) {
1094                 int off = p->shared ? 0 : 16;
1095                 uint8_t *dptr = p->f->data[plane] + 8 * (x + y * stride) + off;
1096                 uint8_t *rptr = ref->f->data[plane] + 8 * (x + y * stride);
1097                 int v = s->mecc.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1098
1099                 switch (s->avctx->frame_skip_exp) {
1100                 case 0: score    =  FFMAX(score, v);          break;
1101                 case 1: score   += FFABS(v);                  break;
1102                 case 2: score   += v * v;                     break;
1103                 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1104                 case 4: score64 += v * v * (int64_t)(v * v);  break;
1105                 }
1106             }
1107         }
1108     }
1109
1110     if (score)
1111         score64 = score;
1112
1113     if (score64 < s->avctx->frame_skip_threshold)
1114         return 1;
1115     if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1116         return 1;
1117     return 0;
1118 }
1119
1120 static int encode_frame(AVCodecContext *c, AVFrame *frame)
1121 {
1122     AVPacket pkt = { 0 };
1123     int ret, got_output;
1124
1125     av_init_packet(&pkt);
1126     ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1127     if (ret < 0)
1128         return ret;
1129
1130     ret = pkt.size;
1131     av_free_packet(&pkt);
1132     return ret;
1133 }
1134
1135 static int estimate_best_b_count(MpegEncContext *s)
1136 {
1137     AVCodec *codec    = avcodec_find_encoder(s->avctx->codec_id);
1138     AVCodecContext *c = avcodec_alloc_context3(NULL);
1139     const int scale = s->avctx->brd_scale;
1140     int i, j, out_size, p_lambda, b_lambda, lambda2;
1141     int64_t best_rd  = INT64_MAX;
1142     int best_b_count = -1;
1143
1144     if (!c)
1145         return AVERROR(ENOMEM);
1146     assert(scale >= 0 && scale <= 3);
1147
1148     //emms_c();
1149     //s->next_picture_ptr->quality;
1150     p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1151     //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1152     b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1153     if (!b_lambda) // FIXME we should do this somewhere else
1154         b_lambda = p_lambda;
1155     lambda2  = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1156                FF_LAMBDA_SHIFT;
1157
1158     c->width        = s->width  >> scale;
1159     c->height       = s->height >> scale;
1160     c->flags        = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR;
1161     c->flags       |= s->avctx->flags & CODEC_FLAG_QPEL;
1162     c->mb_decision  = s->avctx->mb_decision;
1163     c->me_cmp       = s->avctx->me_cmp;
1164     c->mb_cmp       = s->avctx->mb_cmp;
1165     c->me_sub_cmp   = s->avctx->me_sub_cmp;
1166     c->pix_fmt      = AV_PIX_FMT_YUV420P;
1167     c->time_base    = s->avctx->time_base;
1168     c->max_b_frames = s->max_b_frames;
1169
1170     if (avcodec_open2(c, codec, NULL) < 0)
1171         return -1;
1172
1173     for (i = 0; i < s->max_b_frames + 2; i++) {
1174         Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1175                                                 s->next_picture_ptr;
1176
1177         if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1178             pre_input = *pre_input_ptr;
1179
1180             if (!pre_input.shared && i) {
1181                 pre_input.f->data[0] += INPLACE_OFFSET;
1182                 pre_input.f->data[1] += INPLACE_OFFSET;
1183                 pre_input.f->data[2] += INPLACE_OFFSET;
1184             }
1185
1186             s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[0],
1187                                        s->tmp_frames[i]->linesize[0],
1188                                        pre_input.f->data[0],
1189                                        pre_input.f->linesize[0],
1190                                        c->width, c->height);
1191             s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[1],
1192                                        s->tmp_frames[i]->linesize[1],
1193                                        pre_input.f->data[1],
1194                                        pre_input.f->linesize[1],
1195                                        c->width >> 1, c->height >> 1);
1196             s->mpvencdsp.shrink[scale](s->tmp_frames[i]->data[2],
1197                                        s->tmp_frames[i]->linesize[2],
1198                                        pre_input.f->data[2],
1199                                        pre_input.f->linesize[2],
1200                                        c->width >> 1, c->height >> 1);
1201         }
1202     }
1203
1204     for (j = 0; j < s->max_b_frames + 1; j++) {
1205         int64_t rd = 0;
1206
1207         if (!s->input_picture[j])
1208             break;
1209
1210         c->error[0] = c->error[1] = c->error[2] = 0;
1211
1212         s->tmp_frames[0]->pict_type = AV_PICTURE_TYPE_I;
1213         s->tmp_frames[0]->quality   = 1 * FF_QP2LAMBDA;
1214
1215         out_size = encode_frame(c, s->tmp_frames[0]);
1216
1217         //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1218
1219         for (i = 0; i < s->max_b_frames + 1; i++) {
1220             int is_p = i % (j + 1) == j || i == s->max_b_frames;
1221
1222             s->tmp_frames[i + 1]->pict_type = is_p ?
1223                                      AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1224             s->tmp_frames[i + 1]->quality   = is_p ? p_lambda : b_lambda;
1225
1226             out_size = encode_frame(c, s->tmp_frames[i + 1]);
1227
1228             rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1229         }
1230
1231         /* get the delayed frames */
1232         while (out_size) {
1233             out_size = encode_frame(c, NULL);
1234             rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1235         }
1236
1237         rd += c->error[0] + c->error[1] + c->error[2];
1238
1239         if (rd < best_rd) {
1240             best_rd = rd;
1241             best_b_count = j;
1242         }
1243     }
1244
1245     avcodec_close(c);
1246     av_freep(&c);
1247
1248     return best_b_count;
1249 }
1250
1251 static int select_input_picture(MpegEncContext *s)
1252 {
1253     int i, ret;
1254
1255     for (i = 1; i < MAX_PICTURE_COUNT; i++)
1256         s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1257     s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1258
1259     /* set next picture type & ordering */
1260     if (!s->reordered_input_picture[0] && s->input_picture[0]) {
1261         if (/*s->picture_in_gop_number >= s->gop_size ||*/
1262             !s->next_picture_ptr || s->intra_only) {
1263             s->reordered_input_picture[0] = s->input_picture[0];
1264             s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_I;
1265             s->reordered_input_picture[0]->f->coded_picture_number =
1266                 s->coded_picture_number++;
1267         } else {
1268             int b_frames;
1269
1270             if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1271                 if (s->picture_in_gop_number < s->gop_size &&
1272                     skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1273                     // FIXME check that te gop check above is +-1 correct
1274                     av_frame_unref(s->input_picture[0]->f);
1275
1276                     emms_c();
1277                     ff_vbv_update(s, 0);
1278
1279                     goto no_output_pic;
1280                 }
1281             }
1282
1283             if (s->avctx->flags & CODEC_FLAG_PASS2) {
1284                 for (i = 0; i < s->max_b_frames + 1; i++) {
1285                     int pict_num = s->input_picture[0]->f->display_picture_number + i;
1286
1287                     if (pict_num >= s->rc_context.num_entries)
1288                         break;
1289                     if (!s->input_picture[i]) {
1290                         s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1291                         break;
1292                     }
1293
1294                     s->input_picture[i]->f->pict_type =
1295                         s->rc_context.entry[pict_num].new_pict_type;
1296                 }
1297             }
1298
1299             if (s->avctx->b_frame_strategy == 0) {
1300                 b_frames = s->max_b_frames;
1301                 while (b_frames && !s->input_picture[b_frames])
1302                     b_frames--;
1303             } else if (s->avctx->b_frame_strategy == 1) {
1304                 for (i = 1; i < s->max_b_frames + 1; i++) {
1305                     if (s->input_picture[i] &&
1306                         s->input_picture[i]->b_frame_score == 0) {
1307                         s->input_picture[i]->b_frame_score =
1308                             get_intra_count(s,
1309                                             s->input_picture[i    ]->f->data[0],
1310                                             s->input_picture[i - 1]->f->data[0],
1311                                             s->linesize) + 1;
1312                     }
1313                 }
1314                 for (i = 0; i < s->max_b_frames + 1; i++) {
1315                     if (!s->input_picture[i] ||
1316                         s->input_picture[i]->b_frame_score - 1 >
1317                             s->mb_num / s->avctx->b_sensitivity)
1318                         break;
1319                 }
1320
1321                 b_frames = FFMAX(0, i - 1);
1322
1323                 /* reset scores */
1324                 for (i = 0; i < b_frames + 1; i++) {
1325                     s->input_picture[i]->b_frame_score = 0;
1326                 }
1327             } else if (s->avctx->b_frame_strategy == 2) {
1328                 b_frames = estimate_best_b_count(s);
1329             } else {
1330                 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1331                 b_frames = 0;
1332             }
1333
1334             emms_c();
1335
1336             for (i = b_frames - 1; i >= 0; i--) {
1337                 int type = s->input_picture[i]->f->pict_type;
1338                 if (type && type != AV_PICTURE_TYPE_B)
1339                     b_frames = i;
1340             }
1341             if (s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_B &&
1342                 b_frames == s->max_b_frames) {
1343                 av_log(s->avctx, AV_LOG_ERROR,
1344                        "warning, too many b frames in a row\n");
1345             }
1346
1347             if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1348                 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1349                     s->gop_size > s->picture_in_gop_number) {
1350                     b_frames = s->gop_size - s->picture_in_gop_number - 1;
1351                 } else {
1352                     if (s->avctx->flags & CODEC_FLAG_CLOSED_GOP)
1353                         b_frames = 0;
1354                     s->input_picture[b_frames]->f->pict_type = AV_PICTURE_TYPE_I;
1355                 }
1356             }
1357
1358             if ((s->avctx->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
1359                 s->input_picture[b_frames]->f->pict_type == AV_PICTURE_TYPE_I)
1360                 b_frames--;
1361
1362             s->reordered_input_picture[0] = s->input_picture[b_frames];
1363             if (s->reordered_input_picture[0]->f->pict_type != AV_PICTURE_TYPE_I)
1364                 s->reordered_input_picture[0]->f->pict_type = AV_PICTURE_TYPE_P;
1365             s->reordered_input_picture[0]->f->coded_picture_number =
1366                 s->coded_picture_number++;
1367             for (i = 0; i < b_frames; i++) {
1368                 s->reordered_input_picture[i + 1] = s->input_picture[i];
1369                 s->reordered_input_picture[i + 1]->f->pict_type =
1370                     AV_PICTURE_TYPE_B;
1371                 s->reordered_input_picture[i + 1]->f->coded_picture_number =
1372                     s->coded_picture_number++;
1373             }
1374         }
1375     }
1376 no_output_pic:
1377     if (s->reordered_input_picture[0]) {
1378         s->reordered_input_picture[0]->reference =
1379            s->reordered_input_picture[0]->f->pict_type !=
1380                AV_PICTURE_TYPE_B ? 3 : 0;
1381
1382         ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1383         if ((ret = ff_mpeg_ref_picture(s->avctx, &s->new_picture, s->reordered_input_picture[0])))
1384             return ret;
1385
1386         if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
1387             // input is a shared pix, so we can't modifiy it -> alloc a new
1388             // one & ensure that the shared one is reuseable
1389
1390             Picture *pic;
1391             int i = ff_find_unused_picture(s->avctx, s->picture, 0);
1392             if (i < 0)
1393                 return i;
1394             pic = &s->picture[i];
1395
1396             pic->reference = s->reordered_input_picture[0]->reference;
1397             if (alloc_picture(s, pic, 0) < 0) {
1398                 return -1;
1399             }
1400
1401             ret = av_frame_copy_props(pic->f, s->reordered_input_picture[0]->f);
1402             if (ret < 0)
1403                 return ret;
1404
1405             /* mark us unused / free shared pic */
1406             av_frame_unref(s->reordered_input_picture[0]->f);
1407             s->reordered_input_picture[0]->shared = 0;
1408
1409             s->current_picture_ptr = pic;
1410         } else {
1411             // input is not a shared pix -> reuse buffer for current_pix
1412             s->current_picture_ptr = s->reordered_input_picture[0];
1413             for (i = 0; i < 4; i++) {
1414                 s->new_picture.f->data[i] += INPLACE_OFFSET;
1415             }
1416         }
1417         ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1418         if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1419                                        s->current_picture_ptr)) < 0)
1420             return ret;
1421
1422         s->picture_number = s->new_picture.f->display_picture_number;
1423     } else {
1424         ff_mpeg_unref_picture(s->avctx, &s->new_picture);
1425     }
1426     return 0;
1427 }
1428
1429 static void frame_end(MpegEncContext *s)
1430 {
1431     int i;
1432
1433     if (s->unrestricted_mv &&
1434         s->current_picture.reference &&
1435         !s->intra_only) {
1436         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1437         int hshift = desc->log2_chroma_w;
1438         int vshift = desc->log2_chroma_h;
1439         s->mpvencdsp.draw_edges(s->current_picture.f->data[0], s->linesize,
1440                                 s->h_edge_pos, s->v_edge_pos,
1441                                 EDGE_WIDTH, EDGE_WIDTH,
1442                                 EDGE_TOP | EDGE_BOTTOM);
1443         s->mpvencdsp.draw_edges(s->current_picture.f->data[1], s->uvlinesize,
1444                                 s->h_edge_pos >> hshift,
1445                                 s->v_edge_pos >> vshift,
1446                                 EDGE_WIDTH >> hshift,
1447                                 EDGE_WIDTH >> vshift,
1448                                 EDGE_TOP | EDGE_BOTTOM);
1449         s->mpvencdsp.draw_edges(s->current_picture.f->data[2], s->uvlinesize,
1450                                 s->h_edge_pos >> hshift,
1451                                 s->v_edge_pos >> vshift,
1452                                 EDGE_WIDTH >> hshift,
1453                                 EDGE_WIDTH >> vshift,
1454                                 EDGE_TOP | EDGE_BOTTOM);
1455     }
1456
1457     emms_c();
1458
1459     s->last_pict_type                 = s->pict_type;
1460     s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f->quality;
1461     if (s->pict_type!= AV_PICTURE_TYPE_B)
1462         s->last_non_b_pict_type = s->pict_type;
1463
1464     if (s->encoding) {
1465         /* release non-reference frames */
1466         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1467             if (!s->picture[i].reference)
1468                 ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
1469         }
1470     }
1471
1472     s->avctx->coded_frame = s->current_picture_ptr->f;
1473
1474 }
1475
1476 static void update_noise_reduction(MpegEncContext *s)
1477 {
1478     int intra, i;
1479
1480     for (intra = 0; intra < 2; intra++) {
1481         if (s->dct_count[intra] > (1 << 16)) {
1482             for (i = 0; i < 64; i++) {
1483                 s->dct_error_sum[intra][i] >>= 1;
1484             }
1485             s->dct_count[intra] >>= 1;
1486         }
1487
1488         for (i = 0; i < 64; i++) {
1489             s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1490                                        s->dct_count[intra] +
1491                                        s->dct_error_sum[intra][i] / 2) /
1492                                       (s->dct_error_sum[intra][i] + 1);
1493         }
1494     }
1495 }
1496
1497 static int frame_start(MpegEncContext *s)
1498 {
1499     int ret;
1500
1501     /* mark & release old frames */
1502     if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1503         s->last_picture_ptr != s->next_picture_ptr &&
1504         s->last_picture_ptr->f->buf[0]) {
1505         ff_mpeg_unref_picture(s->avctx, s->last_picture_ptr);
1506     }
1507
1508     s->current_picture_ptr->f->pict_type = s->pict_type;
1509     s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1510
1511     ff_mpeg_unref_picture(s->avctx, &s->current_picture);
1512     if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
1513                                    s->current_picture_ptr)) < 0)
1514         return ret;
1515
1516     if (s->pict_type != AV_PICTURE_TYPE_B) {
1517         s->last_picture_ptr = s->next_picture_ptr;
1518         if (!s->droppable)
1519             s->next_picture_ptr = s->current_picture_ptr;
1520     }
1521
1522     if (s->last_picture_ptr) {
1523         ff_mpeg_unref_picture(s->avctx, &s->last_picture);
1524         if (s->last_picture_ptr->f->buf[0] &&
1525             (ret = ff_mpeg_ref_picture(s->avctx, &s->last_picture,
1526                                        s->last_picture_ptr)) < 0)
1527             return ret;
1528     }
1529     if (s->next_picture_ptr) {
1530         ff_mpeg_unref_picture(s->avctx, &s->next_picture);
1531         if (s->next_picture_ptr->f->buf[0] &&
1532             (ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture,
1533                                        s->next_picture_ptr)) < 0)
1534             return ret;
1535     }
1536
1537     if (s->picture_structure!= PICT_FRAME) {
1538         int i;
1539         for (i = 0; i < 4; i++) {
1540             if (s->picture_structure == PICT_BOTTOM_FIELD) {
1541                 s->current_picture.f->data[i] +=
1542                     s->current_picture.f->linesize[i];
1543             }
1544             s->current_picture.f->linesize[i] *= 2;
1545             s->last_picture.f->linesize[i]    *= 2;
1546             s->next_picture.f->linesize[i]    *= 2;
1547         }
1548     }
1549
1550     if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1551         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1552         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1553     } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1554         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1555         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1556     } else {
1557         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1558         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1559     }
1560
1561     if (s->dct_error_sum) {
1562         assert(s->avctx->noise_reduction && s->encoding);
1563         update_noise_reduction(s);
1564     }
1565
1566     return 0;
1567 }
1568
1569 int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
1570                           const AVFrame *pic_arg, int *got_packet)
1571 {
1572     MpegEncContext *s = avctx->priv_data;
1573     int i, stuffing_count, ret;
1574     int context_count = s->slice_context_count;
1575
1576     s->picture_in_gop_number++;
1577
1578     if (load_input_picture(s, pic_arg) < 0)
1579         return -1;
1580
1581     if (select_input_picture(s) < 0) {
1582         return -1;
1583     }
1584
1585     /* output? */
1586     if (s->new_picture.f->data[0]) {
1587         if (!pkt->data &&
1588             (ret = ff_alloc_packet(pkt, s->mb_width*s->mb_height*MAX_MB_BYTES)) < 0)
1589             return ret;
1590         if (s->mb_info) {
1591             s->mb_info_ptr = av_packet_new_side_data(pkt,
1592                                  AV_PKT_DATA_H263_MB_INFO,
1593                                  s->mb_width*s->mb_height*12);
1594             s->prev_mb_info = s->last_mb_info = s->mb_info_size = 0;
1595         }
1596
1597         for (i = 0; i < context_count; i++) {
1598             int start_y = s->thread_context[i]->start_mb_y;
1599             int   end_y = s->thread_context[i]->  end_mb_y;
1600             int h       = s->mb_height;
1601             uint8_t *start = pkt->data + (size_t)(((int64_t) pkt->size) * start_y / h);
1602             uint8_t *end   = pkt->data + (size_t)(((int64_t) pkt->size) *   end_y / h);
1603
1604             init_put_bits(&s->thread_context[i]->pb, start, end - start);
1605         }
1606
1607         s->pict_type = s->new_picture.f->pict_type;
1608         //emms_c();
1609         ret = frame_start(s);
1610         if (ret < 0)
1611             return ret;
1612 vbv_retry:
1613         if (encode_picture(s, s->picture_number) < 0)
1614             return -1;
1615
1616         avctx->header_bits = s->header_bits;
1617         avctx->mv_bits     = s->mv_bits;
1618         avctx->misc_bits   = s->misc_bits;
1619         avctx->i_tex_bits  = s->i_tex_bits;
1620         avctx->p_tex_bits  = s->p_tex_bits;
1621         avctx->i_count     = s->i_count;
1622         // FIXME f/b_count in avctx
1623         avctx->p_count     = s->mb_num - s->i_count - s->skip_count;
1624         avctx->skip_count  = s->skip_count;
1625
1626         frame_end(s);
1627
1628         if (CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG)
1629             ff_mjpeg_encode_picture_trailer(&s->pb, s->header_bits);
1630
1631         if (avctx->rc_buffer_size) {
1632             RateControlContext *rcc = &s->rc_context;
1633             int max_size = rcc->buffer_index * avctx->rc_max_available_vbv_use;
1634
1635             if (put_bits_count(&s->pb) > max_size &&
1636                 s->lambda < s->lmax) {
1637                 s->next_lambda = FFMAX(s->lambda + 1, s->lambda *
1638                                        (s->qscale + 1) / s->qscale);
1639                 if (s->adaptive_quant) {
1640                     int i;
1641                     for (i = 0; i < s->mb_height * s->mb_stride; i++)
1642                         s->lambda_table[i] =
1643                             FFMAX(s->lambda_table[i] + 1,
1644                                   s->lambda_table[i] * (s->qscale + 1) /
1645                                   s->qscale);
1646                 }
1647                 s->mb_skipped = 0;        // done in frame_start()
1648                 // done in encode_picture() so we must undo it
1649                 if (s->pict_type == AV_PICTURE_TYPE_P) {
1650                     if (s->flipflop_rounding          ||
1651                         s->codec_id == AV_CODEC_ID_H263P ||
1652                         s->codec_id == AV_CODEC_ID_MPEG4)
1653                         s->no_rounding ^= 1;
1654                 }
1655                 if (s->pict_type != AV_PICTURE_TYPE_B) {
1656                     s->time_base       = s->last_time_base;
1657                     s->last_non_b_time = s->time - s->pp_time;
1658                 }
1659                 for (i = 0; i < context_count; i++) {
1660                     PutBitContext *pb = &s->thread_context[i]->pb;
1661                     init_put_bits(pb, pb->buf, pb->buf_end - pb->buf);
1662                 }
1663                 goto vbv_retry;
1664             }
1665
1666             assert(s->avctx->rc_max_rate);
1667         }
1668
1669         if (s->avctx->flags & CODEC_FLAG_PASS1)
1670             ff_write_pass1_stats(s);
1671
1672         for (i = 0; i < 4; i++) {
1673             s->current_picture_ptr->f->error[i] = s->current_picture.f->error[i];
1674             avctx->error[i] += s->current_picture_ptr->f->error[i];
1675         }
1676
1677         if (s->avctx->flags & CODEC_FLAG_PASS1)
1678             assert(avctx->header_bits + avctx->mv_bits + avctx->misc_bits +
1679                    avctx->i_tex_bits + avctx->p_tex_bits ==
1680                        put_bits_count(&s->pb));
1681         flush_put_bits(&s->pb);
1682         s->frame_bits  = put_bits_count(&s->pb);
1683
1684         stuffing_count = ff_vbv_update(s, s->frame_bits);
1685         if (stuffing_count) {
1686             if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
1687                     stuffing_count + 50) {
1688                 av_log(s->avctx, AV_LOG_ERROR, "stuffing too large\n");
1689                 return -1;
1690             }
1691
1692             switch (s->codec_id) {
1693             case AV_CODEC_ID_MPEG1VIDEO:
1694             case AV_CODEC_ID_MPEG2VIDEO:
1695                 while (stuffing_count--) {
1696                     put_bits(&s->pb, 8, 0);
1697                 }
1698             break;
1699             case AV_CODEC_ID_MPEG4:
1700                 put_bits(&s->pb, 16, 0);
1701                 put_bits(&s->pb, 16, 0x1C3);
1702                 stuffing_count -= 4;
1703                 while (stuffing_count--) {
1704                     put_bits(&s->pb, 8, 0xFF);
1705                 }
1706             break;
1707             default:
1708                 av_log(s->avctx, AV_LOG_ERROR, "vbv buffer overflow\n");
1709             }
1710             flush_put_bits(&s->pb);
1711             s->frame_bits  = put_bits_count(&s->pb);
1712         }
1713
1714         /* update mpeg1/2 vbv_delay for CBR */
1715         if (s->avctx->rc_max_rate                          &&
1716             s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
1717             s->out_format == FMT_MPEG1                     &&
1718             90000LL * (avctx->rc_buffer_size - 1) <=
1719                 s->avctx->rc_max_rate * 0xFFFFLL) {
1720             int vbv_delay, min_delay;
1721             double inbits  = s->avctx->rc_max_rate *
1722                              av_q2d(s->avctx->time_base);
1723             int    minbits = s->frame_bits - 8 *
1724                              (s->vbv_delay_ptr - s->pb.buf - 1);
1725             double bits    = s->rc_context.buffer_index + minbits - inbits;
1726
1727             if (bits < 0)
1728                 av_log(s->avctx, AV_LOG_ERROR,
1729                        "Internal error, negative bits\n");
1730
1731             assert(s->repeat_first_field == 0);
1732
1733             vbv_delay = bits * 90000 / s->avctx->rc_max_rate;
1734             min_delay = (minbits * 90000LL + s->avctx->rc_max_rate - 1) /
1735                         s->avctx->rc_max_rate;
1736
1737             vbv_delay = FFMAX(vbv_delay, min_delay);
1738
1739             assert(vbv_delay < 0xFFFF);
1740
1741             s->vbv_delay_ptr[0] &= 0xF8;
1742             s->vbv_delay_ptr[0] |= vbv_delay >> 13;
1743             s->vbv_delay_ptr[1]  = vbv_delay >> 5;
1744             s->vbv_delay_ptr[2] &= 0x07;
1745             s->vbv_delay_ptr[2] |= vbv_delay << 3;
1746             avctx->vbv_delay     = vbv_delay * 300;
1747         }
1748         s->total_bits     += s->frame_bits;
1749         avctx->frame_bits  = s->frame_bits;
1750
1751         pkt->pts = s->current_picture.f->pts;
1752         if (!s->low_delay && s->pict_type != AV_PICTURE_TYPE_B) {
1753             if (!s->current_picture.f->coded_picture_number)
1754                 pkt->dts = pkt->pts - s->dts_delta;
1755             else
1756                 pkt->dts = s->reordered_pts;
1757             s->reordered_pts = pkt->pts;
1758         } else
1759             pkt->dts = pkt->pts;
1760         if (s->current_picture.f->key_frame)
1761             pkt->flags |= AV_PKT_FLAG_KEY;
1762         if (s->mb_info)
1763             av_packet_shrink_side_data(pkt, AV_PKT_DATA_H263_MB_INFO, s->mb_info_size);
1764     } else {
1765         s->frame_bits = 0;
1766     }
1767     assert((s->frame_bits & 7) == 0);
1768
1769     pkt->size = s->frame_bits / 8;
1770     *got_packet = !!pkt->size;
1771     return 0;
1772 }
1773
1774 static inline void dct_single_coeff_elimination(MpegEncContext *s,
1775                                                 int n, int threshold)
1776 {
1777     static const char tab[64] = {
1778         3, 2, 2, 1, 1, 1, 1, 1,
1779         1, 1, 1, 1, 1, 1, 1, 1,
1780         1, 1, 1, 1, 1, 1, 1, 1,
1781         0, 0, 0, 0, 0, 0, 0, 0,
1782         0, 0, 0, 0, 0, 0, 0, 0,
1783         0, 0, 0, 0, 0, 0, 0, 0,
1784         0, 0, 0, 0, 0, 0, 0, 0,
1785         0, 0, 0, 0, 0, 0, 0, 0
1786     };
1787     int score = 0;
1788     int run = 0;
1789     int i;
1790     int16_t *block = s->block[n];
1791     const int last_index = s->block_last_index[n];
1792     int skip_dc;
1793
1794     if (threshold < 0) {
1795         skip_dc = 0;
1796         threshold = -threshold;
1797     } else
1798         skip_dc = 1;
1799
1800     /* Are all we could set to zero already zero? */
1801     if (last_index <= skip_dc - 1)
1802         return;
1803
1804     for (i = 0; i <= last_index; i++) {
1805         const int j = s->intra_scantable.permutated[i];
1806         const int level = FFABS(block[j]);
1807         if (level == 1) {
1808             if (skip_dc && i == 0)
1809                 continue;
1810             score += tab[run];
1811             run = 0;
1812         } else if (level > 1) {
1813             return;
1814         } else {
1815             run++;
1816         }
1817     }
1818     if (score >= threshold)
1819         return;
1820     for (i = skip_dc; i <= last_index; i++) {
1821         const int j = s->intra_scantable.permutated[i];
1822         block[j] = 0;
1823     }
1824     if (block[0])
1825         s->block_last_index[n] = 0;
1826     else
1827         s->block_last_index[n] = -1;
1828 }
1829
1830 static inline void clip_coeffs(MpegEncContext *s, int16_t *block,
1831                                int last_index)
1832 {
1833     int i;
1834     const int maxlevel = s->max_qcoeff;
1835     const int minlevel = s->min_qcoeff;
1836     int overflow = 0;
1837
1838     if (s->mb_intra) {
1839         i = 1; // skip clipping of intra dc
1840     } else
1841         i = 0;
1842
1843     for (; i <= last_index; i++) {
1844         const int j = s->intra_scantable.permutated[i];
1845         int level = block[j];
1846
1847         if (level > maxlevel) {
1848             level = maxlevel;
1849             overflow++;
1850         } else if (level < minlevel) {
1851             level = minlevel;
1852             overflow++;
1853         }
1854
1855         block[j] = level;
1856     }
1857
1858     if (overflow && s->avctx->mb_decision == FF_MB_DECISION_SIMPLE)
1859         av_log(s->avctx, AV_LOG_INFO,
1860                "warning, clipping %d dct coefficients to %d..%d\n",
1861                overflow, minlevel, maxlevel);
1862 }
1863
1864 static void get_visual_weight(int16_t *weight, uint8_t *ptr, int stride)
1865 {
1866     int x, y;
1867     // FIXME optimize
1868     for (y = 0; y < 8; y++) {
1869         for (x = 0; x < 8; x++) {
1870             int x2, y2;
1871             int sum = 0;
1872             int sqr = 0;
1873             int count = 0;
1874
1875             for (y2 = FFMAX(y - 1, 0); y2 < FFMIN(8, y + 2); y2++) {
1876                 for (x2= FFMAX(x - 1, 0); x2 < FFMIN(8, x + 2); x2++) {
1877                     int v = ptr[x2 + y2 * stride];
1878                     sum += v;
1879                     sqr += v * v;
1880                     count++;
1881                 }
1882             }
1883             weight[x + 8 * y]= (36 * ff_sqrt(count * sqr - sum * sum)) / count;
1884         }
1885     }
1886 }
1887
1888 static av_always_inline void encode_mb_internal(MpegEncContext *s,
1889                                                 int motion_x, int motion_y,
1890                                                 int mb_block_height,
1891                                                 int mb_block_count)
1892 {
1893     int16_t weight[8][64];
1894     int16_t orig[8][64];
1895     const int mb_x = s->mb_x;
1896     const int mb_y = s->mb_y;
1897     int i;
1898     int skip_dct[8];
1899     int dct_offset = s->linesize * 8; // default for progressive frames
1900     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1901     ptrdiff_t wrap_y, wrap_c;
1902
1903     for (i = 0; i < mb_block_count; i++)
1904         skip_dct[i] = s->skipdct;
1905
1906     if (s->adaptive_quant) {
1907         const int last_qp = s->qscale;
1908         const int mb_xy = mb_x + mb_y * s->mb_stride;
1909
1910         s->lambda = s->lambda_table[mb_xy];
1911         update_qscale(s);
1912
1913         if (!(s->mpv_flags & FF_MPV_FLAG_QP_RD)) {
1914             s->qscale = s->current_picture_ptr->qscale_table[mb_xy];
1915             s->dquant = s->qscale - last_qp;
1916
1917             if (s->out_format == FMT_H263) {
1918                 s->dquant = av_clip(s->dquant, -2, 2);
1919
1920                 if (s->codec_id == AV_CODEC_ID_MPEG4) {
1921                     if (!s->mb_intra) {
1922                         if (s->pict_type == AV_PICTURE_TYPE_B) {
1923                             if (s->dquant & 1 || s->mv_dir & MV_DIRECT)
1924                                 s->dquant = 0;
1925                         }
1926                         if (s->mv_type == MV_TYPE_8X8)
1927                             s->dquant = 0;
1928                     }
1929                 }
1930             }
1931         }
1932         ff_set_qscale(s, last_qp + s->dquant);
1933     } else if (s->mpv_flags & FF_MPV_FLAG_QP_RD)
1934         ff_set_qscale(s, s->qscale + s->dquant);
1935
1936     wrap_y = s->linesize;
1937     wrap_c = s->uvlinesize;
1938     ptr_y  = s->new_picture.f->data[0] +
1939              (mb_y * 16 * wrap_y)              + mb_x * 16;
1940     ptr_cb = s->new_picture.f->data[1] +
1941              (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1942     ptr_cr = s->new_picture.f->data[2] +
1943              (mb_y * mb_block_height * wrap_c) + mb_x * 8;
1944
1945     if (mb_x * 16 + 16 > s->width || mb_y * 16 + 16 > s->height) {
1946         uint8_t *ebuf = s->sc.edge_emu_buffer + 32;
1947         s->vdsp.emulated_edge_mc(ebuf, ptr_y,
1948                                  wrap_y, wrap_y,
1949                                  16, 16, mb_x * 16, mb_y * 16,
1950                                  s->width, s->height);
1951         ptr_y = ebuf;
1952         s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y, ptr_cb,
1953                                  wrap_c, wrap_c,
1954                                  8, mb_block_height, mb_x * 8, mb_y * 8,
1955                                  s->width >> 1, s->height >> 1);
1956         ptr_cb = ebuf + 18 * wrap_y;
1957         s->vdsp.emulated_edge_mc(ebuf + 18 * wrap_y + 8, ptr_cr,
1958                                  wrap_c, wrap_c,
1959                                  8, mb_block_height, mb_x * 8, mb_y * 8,
1960                                  s->width >> 1, s->height >> 1);
1961         ptr_cr = ebuf + 18 * wrap_y + 8;
1962     }
1963
1964     if (s->mb_intra) {
1965         if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
1966             int progressive_score, interlaced_score;
1967
1968             s->interlaced_dct = 0;
1969             progressive_score = s->mecc.ildct_cmp[4](s, ptr_y, NULL, wrap_y, 8) +
1970                                 s->mecc.ildct_cmp[4](s, ptr_y + wrap_y * 8,
1971                                                      NULL, wrap_y, 8) - 400;
1972
1973             if (progressive_score > 0) {
1974                 interlaced_score = s->mecc.ildct_cmp[4](s, ptr_y,
1975                                                         NULL, wrap_y * 2, 8) +
1976                                    s->mecc.ildct_cmp[4](s, ptr_y + wrap_y,
1977                                                         NULL, wrap_y * 2, 8);
1978                 if (progressive_score > interlaced_score) {
1979                     s->interlaced_dct = 1;
1980
1981                     dct_offset = wrap_y;
1982                     wrap_y <<= 1;
1983                     if (s->chroma_format == CHROMA_422)
1984                         wrap_c <<= 1;
1985                 }
1986             }
1987         }
1988
1989         s->pdsp.get_pixels(s->block[0], ptr_y,                  wrap_y);
1990         s->pdsp.get_pixels(s->block[1], ptr_y + 8,              wrap_y);
1991         s->pdsp.get_pixels(s->block[2], ptr_y + dct_offset,     wrap_y);
1992         s->pdsp.get_pixels(s->block[3], ptr_y + dct_offset + 8, wrap_y);
1993
1994         if (s->avctx->flags & CODEC_FLAG_GRAY) {
1995             skip_dct[4] = 1;
1996             skip_dct[5] = 1;
1997         } else {
1998             s->pdsp.get_pixels(s->block[4], ptr_cb, wrap_c);
1999             s->pdsp.get_pixels(s->block[5], ptr_cr, wrap_c);
2000             if (!s->chroma_y_shift) { /* 422 */
2001                 s->pdsp.get_pixels(s->block[6],
2002                                    ptr_cb + (dct_offset >> 1), wrap_c);
2003                 s->pdsp.get_pixels(s->block[7],
2004                                    ptr_cr + (dct_offset >> 1), wrap_c);
2005             }
2006         }
2007     } else {
2008         op_pixels_func (*op_pix)[4];
2009         qpel_mc_func (*op_qpix)[16];
2010         uint8_t *dest_y, *dest_cb, *dest_cr;
2011
2012         dest_y  = s->dest[0];
2013         dest_cb = s->dest[1];
2014         dest_cr = s->dest[2];
2015
2016         if ((!s->no_rounding) || s->pict_type == AV_PICTURE_TYPE_B) {
2017             op_pix  = s->hdsp.put_pixels_tab;
2018             op_qpix = s->qdsp.put_qpel_pixels_tab;
2019         } else {
2020             op_pix  = s->hdsp.put_no_rnd_pixels_tab;
2021             op_qpix = s->qdsp.put_no_rnd_qpel_pixels_tab;
2022         }
2023
2024         if (s->mv_dir & MV_DIR_FORWARD) {
2025             ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0,
2026                           s->last_picture.f->data,
2027                           op_pix, op_qpix);
2028             op_pix  = s->hdsp.avg_pixels_tab;
2029             op_qpix = s->qdsp.avg_qpel_pixels_tab;
2030         }
2031         if (s->mv_dir & MV_DIR_BACKWARD) {
2032             ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1,
2033                           s->next_picture.f->data,
2034                           op_pix, op_qpix);
2035         }
2036
2037         if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
2038             int progressive_score, interlaced_score;
2039
2040             s->interlaced_dct = 0;
2041             progressive_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y, wrap_y, 8) +
2042                                 s->mecc.ildct_cmp[0](s, dest_y + wrap_y * 8,
2043                                                      ptr_y + wrap_y * 8,
2044                                                      wrap_y, 8) - 400;
2045
2046             if (s->avctx->ildct_cmp == FF_CMP_VSSE)
2047                 progressive_score -= 400;
2048
2049             if (progressive_score > 0) {
2050                 interlaced_score = s->mecc.ildct_cmp[0](s, dest_y, ptr_y,
2051                                                         wrap_y * 2, 8) +
2052                                    s->mecc.ildct_cmp[0](s, dest_y + wrap_y,
2053                                                         ptr_y + wrap_y,
2054                                                         wrap_y * 2, 8);
2055
2056                 if (progressive_score > interlaced_score) {
2057                     s->interlaced_dct = 1;
2058
2059                     dct_offset = wrap_y;
2060                     wrap_y <<= 1;
2061                     if (s->chroma_format == CHROMA_422)
2062                         wrap_c <<= 1;
2063                 }
2064             }
2065         }
2066
2067         s->pdsp.diff_pixels(s->block[0], ptr_y, dest_y, wrap_y);
2068         s->pdsp.diff_pixels(s->block[1], ptr_y + 8, dest_y + 8, wrap_y);
2069         s->pdsp.diff_pixels(s->block[2], ptr_y + dct_offset,
2070                             dest_y + dct_offset, wrap_y);
2071         s->pdsp.diff_pixels(s->block[3], ptr_y + dct_offset + 8,
2072                             dest_y + dct_offset + 8, wrap_y);
2073
2074         if (s->avctx->flags & CODEC_FLAG_GRAY) {
2075             skip_dct[4] = 1;
2076             skip_dct[5] = 1;
2077         } else {
2078             s->pdsp.diff_pixels(s->block[4], ptr_cb, dest_cb, wrap_c);
2079             s->pdsp.diff_pixels(s->block[5], ptr_cr, dest_cr, wrap_c);
2080             if (!s->chroma_y_shift) { /* 422 */
2081                 s->pdsp.diff_pixels(s->block[6], ptr_cb + (dct_offset >> 1),
2082                                     dest_cb + (dct_offset >> 1), wrap_c);
2083                 s->pdsp.diff_pixels(s->block[7], ptr_cr + (dct_offset >> 1),
2084                                     dest_cr + (dct_offset >> 1), wrap_c);
2085             }
2086         }
2087         /* pre quantization */
2088         if (s->current_picture.mc_mb_var[s->mb_stride * mb_y + mb_x] <
2089                 2 * s->qscale * s->qscale) {
2090             // FIXME optimize
2091             if (s->mecc.sad[1](NULL, ptr_y, dest_y, wrap_y, 8) < 20 * s->qscale)
2092                 skip_dct[0] = 1;
2093             if (s->mecc.sad[1](NULL, ptr_y + 8, dest_y + 8, wrap_y, 8) < 20 * s->qscale)
2094                 skip_dct[1] = 1;
2095             if (s->mecc.sad[1](NULL, ptr_y + dct_offset, dest_y + dct_offset,
2096                                wrap_y, 8) < 20 * s->qscale)
2097                 skip_dct[2] = 1;
2098             if (s->mecc.sad[1](NULL, ptr_y + dct_offset + 8, dest_y + dct_offset + 8,
2099                                wrap_y, 8) < 20 * s->qscale)
2100                 skip_dct[3] = 1;
2101             if (s->mecc.sad[1](NULL, ptr_cb, dest_cb, wrap_c, 8) < 20 * s->qscale)
2102                 skip_dct[4] = 1;
2103             if (s->mecc.sad[1](NULL, ptr_cr, dest_cr, wrap_c, 8) < 20 * s->qscale)
2104                 skip_dct[5] = 1;
2105             if (!s->chroma_y_shift) { /* 422 */
2106                 if (s->mecc.sad[1](NULL, ptr_cb + (dct_offset >> 1),
2107                                    dest_cb + (dct_offset >> 1),
2108                                    wrap_c, 8) < 20 * s->qscale)
2109                     skip_dct[6] = 1;
2110                 if (s->mecc.sad[1](NULL, ptr_cr + (dct_offset >> 1),
2111                                    dest_cr + (dct_offset >> 1),
2112                                    wrap_c, 8) < 20 * s->qscale)
2113                     skip_dct[7] = 1;
2114             }
2115         }
2116     }
2117
2118     if (s->quantizer_noise_shaping) {
2119         if (!skip_dct[0])
2120             get_visual_weight(weight[0], ptr_y                 , wrap_y);
2121         if (!skip_dct[1])
2122             get_visual_weight(weight[1], ptr_y              + 8, wrap_y);
2123         if (!skip_dct[2])
2124             get_visual_weight(weight[2], ptr_y + dct_offset    , wrap_y);
2125         if (!skip_dct[3])
2126             get_visual_weight(weight[3], ptr_y + dct_offset + 8, wrap_y);
2127         if (!skip_dct[4])
2128             get_visual_weight(weight[4], ptr_cb                , wrap_c);
2129         if (!skip_dct[5])
2130             get_visual_weight(weight[5], ptr_cr                , wrap_c);
2131         if (!s->chroma_y_shift) { /* 422 */
2132             if (!skip_dct[6])
2133                 get_visual_weight(weight[6], ptr_cb + (dct_offset >> 1),
2134                                   wrap_c);
2135             if (!skip_dct[7])
2136                 get_visual_weight(weight[7], ptr_cr + (dct_offset >> 1),
2137                                   wrap_c);
2138         }
2139         memcpy(orig[0], s->block[0], sizeof(int16_t) * 64 * mb_block_count);
2140     }
2141
2142     /* DCT & quantize */
2143     assert(s->out_format != FMT_MJPEG || s->qscale == 8);
2144     {
2145         for (i = 0; i < mb_block_count; i++) {
2146             if (!skip_dct[i]) {
2147                 int overflow;
2148                 s->block_last_index[i] = s->dct_quantize(s, s->block[i], i, s->qscale, &overflow);
2149                 // FIXME we could decide to change to quantizer instead of
2150                 // clipping
2151                 // JS: I don't think that would be a good idea it could lower
2152                 //     quality instead of improve it. Just INTRADC clipping
2153                 //     deserves changes in quantizer
2154                 if (overflow)
2155                     clip_coeffs(s, s->block[i], s->block_last_index[i]);
2156             } else
2157                 s->block_last_index[i] = -1;
2158         }
2159         if (s->quantizer_noise_shaping) {
2160             for (i = 0; i < mb_block_count; i++) {
2161                 if (!skip_dct[i]) {
2162                     s->block_last_index[i] =
2163                         dct_quantize_refine(s, s->block[i], weight[i],
2164                                             orig[i], i, s->qscale);
2165                 }
2166             }
2167         }
2168
2169         if (s->luma_elim_threshold && !s->mb_intra)
2170             for (i = 0; i < 4; i++)
2171                 dct_single_coeff_elimination(s, i, s->luma_elim_threshold);
2172         if (s->chroma_elim_threshold && !s->mb_intra)
2173             for (i = 4; i < mb_block_count; i++)
2174                 dct_single_coeff_elimination(s, i, s->chroma_elim_threshold);
2175
2176         if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
2177             for (i = 0; i < mb_block_count; i++) {
2178                 if (s->block_last_index[i] == -1)
2179                     s->coded_score[i] = INT_MAX / 256;
2180             }
2181         }
2182     }
2183
2184     if ((s->avctx->flags & CODEC_FLAG_GRAY) && s->mb_intra) {
2185         s->block_last_index[4] =
2186         s->block_last_index[5] = 0;
2187         s->block[4][0] =
2188         s->block[5][0] = (1024 + s->c_dc_scale / 2) / s->c_dc_scale;
2189     }
2190
2191     // non c quantize code returns incorrect block_last_index FIXME
2192     if (s->alternate_scan && s->dct_quantize != ff_dct_quantize_c) {
2193         for (i = 0; i < mb_block_count; i++) {
2194             int j;
2195             if (s->block_last_index[i] > 0) {
2196                 for (j = 63; j > 0; j--) {
2197                     if (s->block[i][s->intra_scantable.permutated[j]])
2198                         break;
2199                 }
2200                 s->block_last_index[i] = j;
2201             }
2202         }
2203     }
2204
2205     /* huffman encode */
2206     switch(s->codec_id){ //FIXME funct ptr could be slightly faster
2207     case AV_CODEC_ID_MPEG1VIDEO:
2208     case AV_CODEC_ID_MPEG2VIDEO:
2209         if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
2210             ff_mpeg1_encode_mb(s, s->block, motion_x, motion_y);
2211         break;
2212     case AV_CODEC_ID_MPEG4:
2213         if (CONFIG_MPEG4_ENCODER)
2214             ff_mpeg4_encode_mb(s, s->block, motion_x, motion_y);
2215         break;
2216     case AV_CODEC_ID_MSMPEG4V2:
2217     case AV_CODEC_ID_MSMPEG4V3:
2218     case AV_CODEC_ID_WMV1:
2219         if (CONFIG_MSMPEG4_ENCODER)
2220             ff_msmpeg4_encode_mb(s, s->block, motion_x, motion_y);
2221         break;
2222     case AV_CODEC_ID_WMV2:
2223         if (CONFIG_WMV2_ENCODER)
2224             ff_wmv2_encode_mb(s, s->block, motion_x, motion_y);
2225         break;
2226     case AV_CODEC_ID_H261:
2227         if (CONFIG_H261_ENCODER)
2228             ff_h261_encode_mb(s, s->block, motion_x, motion_y);
2229         break;
2230     case AV_CODEC_ID_H263:
2231     case AV_CODEC_ID_H263P:
2232     case AV_CODEC_ID_FLV1:
2233     case AV_CODEC_ID_RV10:
2234     case AV_CODEC_ID_RV20:
2235         if (CONFIG_H263_ENCODER)
2236             ff_h263_encode_mb(s, s->block, motion_x, motion_y);
2237         break;
2238     case AV_CODEC_ID_MJPEG:
2239         if (CONFIG_MJPEG_ENCODER)
2240             ff_mjpeg_encode_mb(s, s->block);
2241         break;
2242     default:
2243         assert(0);
2244     }
2245 }
2246
2247 static av_always_inline void encode_mb(MpegEncContext *s, int motion_x, int motion_y)
2248 {
2249     if (s->chroma_format == CHROMA_420) encode_mb_internal(s, motion_x, motion_y,  8, 6);
2250     else                                encode_mb_internal(s, motion_x, motion_y, 16, 8);
2251 }
2252
2253 static inline void copy_context_before_encode(MpegEncContext *d, MpegEncContext *s, int type){
2254     int i;
2255
2256     memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2257
2258     /* mpeg1 */
2259     d->mb_skip_run= s->mb_skip_run;
2260     for(i=0; i<3; i++)
2261         d->last_dc[i] = s->last_dc[i];
2262
2263     /* statistics */
2264     d->mv_bits= s->mv_bits;
2265     d->i_tex_bits= s->i_tex_bits;
2266     d->p_tex_bits= s->p_tex_bits;
2267     d->i_count= s->i_count;
2268     d->f_count= s->f_count;
2269     d->b_count= s->b_count;
2270     d->skip_count= s->skip_count;
2271     d->misc_bits= s->misc_bits;
2272     d->last_bits= 0;
2273
2274     d->mb_skipped= 0;
2275     d->qscale= s->qscale;
2276     d->dquant= s->dquant;
2277
2278     d->esc3_level_length= s->esc3_level_length;
2279 }
2280
2281 static inline void copy_context_after_encode(MpegEncContext *d, MpegEncContext *s, int type){
2282     int i;
2283
2284     memcpy(d->mv, s->mv, 2*4*2*sizeof(int));
2285     memcpy(d->last_mv, s->last_mv, 2*2*2*sizeof(int)); //FIXME is memcpy faster than a loop?
2286
2287     /* mpeg1 */
2288     d->mb_skip_run= s->mb_skip_run;
2289     for(i=0; i<3; i++)
2290         d->last_dc[i] = s->last_dc[i];
2291
2292     /* statistics */
2293     d->mv_bits= s->mv_bits;
2294     d->i_tex_bits= s->i_tex_bits;
2295     d->p_tex_bits= s->p_tex_bits;
2296     d->i_count= s->i_count;
2297     d->f_count= s->f_count;
2298     d->b_count= s->b_count;
2299     d->skip_count= s->skip_count;
2300     d->misc_bits= s->misc_bits;
2301
2302     d->mb_intra= s->mb_intra;
2303     d->mb_skipped= s->mb_skipped;
2304     d->mv_type= s->mv_type;
2305     d->mv_dir= s->mv_dir;
2306     d->pb= s->pb;
2307     if(s->data_partitioning){
2308         d->pb2= s->pb2;
2309         d->tex_pb= s->tex_pb;
2310     }
2311     d->block= s->block;
2312     for(i=0; i<8; i++)
2313         d->block_last_index[i]= s->block_last_index[i];
2314     d->interlaced_dct= s->interlaced_dct;
2315     d->qscale= s->qscale;
2316
2317     d->esc3_level_length= s->esc3_level_length;
2318 }
2319
2320 static inline void encode_mb_hq(MpegEncContext *s, MpegEncContext *backup, MpegEncContext *best, int type,
2321                            PutBitContext pb[2], PutBitContext pb2[2], PutBitContext tex_pb[2],
2322                            int *dmin, int *next_block, int motion_x, int motion_y)
2323 {
2324     int score;
2325     uint8_t *dest_backup[3];
2326
2327     copy_context_before_encode(s, backup, type);
2328
2329     s->block= s->blocks[*next_block];
2330     s->pb= pb[*next_block];
2331     if(s->data_partitioning){
2332         s->pb2   = pb2   [*next_block];
2333         s->tex_pb= tex_pb[*next_block];
2334     }
2335
2336     if(*next_block){
2337         memcpy(dest_backup, s->dest, sizeof(s->dest));
2338         s->dest[0] = s->sc.rd_scratchpad;
2339         s->dest[1] = s->sc.rd_scratchpad + 16*s->linesize;
2340         s->dest[2] = s->sc.rd_scratchpad + 16*s->linesize + 8;
2341         assert(s->linesize >= 32); //FIXME
2342     }
2343
2344     encode_mb(s, motion_x, motion_y);
2345
2346     score= put_bits_count(&s->pb);
2347     if(s->data_partitioning){
2348         score+= put_bits_count(&s->pb2);
2349         score+= put_bits_count(&s->tex_pb);
2350     }
2351
2352     if(s->avctx->mb_decision == FF_MB_DECISION_RD){
2353         ff_mpv_decode_mb(s, s->block);
2354
2355         score *= s->lambda2;
2356         score += sse_mb(s) << FF_LAMBDA_SHIFT;
2357     }
2358
2359     if(*next_block){
2360         memcpy(s->dest, dest_backup, sizeof(s->dest));
2361     }
2362
2363     if(score<*dmin){
2364         *dmin= score;
2365         *next_block^=1;
2366
2367         copy_context_after_encode(best, s, type);
2368     }
2369 }
2370
2371 static int sse(MpegEncContext *s, uint8_t *src1, uint8_t *src2, int w, int h, int stride){
2372     uint32_t *sq = ff_square_tab + 256;
2373     int acc=0;
2374     int x,y;
2375
2376     if(w==16 && h==16)
2377         return s->mecc.sse[0](NULL, src1, src2, stride, 16);
2378     else if(w==8 && h==8)
2379         return s->mecc.sse[1](NULL, src1, src2, stride, 8);
2380
2381     for(y=0; y<h; y++){
2382         for(x=0; x<w; x++){
2383             acc+= sq[src1[x + y*stride] - src2[x + y*stride]];
2384         }
2385     }
2386
2387     assert(acc>=0);
2388
2389     return acc;
2390 }
2391
2392 static int sse_mb(MpegEncContext *s){
2393     int w= 16;
2394     int h= 16;
2395
2396     if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
2397     if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
2398
2399     if(w==16 && h==16)
2400       if(s->avctx->mb_cmp == FF_CMP_NSSE){
2401         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) +
2402                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) +
2403                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);
2404       }else{
2405         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) +
2406                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) +
2407                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);
2408       }
2409     else
2410         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)
2411                +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)
2412                +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);
2413 }
2414
2415 static int pre_estimate_motion_thread(AVCodecContext *c, void *arg){
2416     MpegEncContext *s= *(void**)arg;
2417
2418
2419     s->me.pre_pass=1;
2420     s->me.dia_size= s->avctx->pre_dia_size;
2421     s->first_slice_line=1;
2422     for(s->mb_y= s->end_mb_y-1; s->mb_y >= s->start_mb_y; s->mb_y--) {
2423         for(s->mb_x=s->mb_width-1; s->mb_x >=0 ;s->mb_x--) {
2424             ff_pre_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2425         }
2426         s->first_slice_line=0;
2427     }
2428
2429     s->me.pre_pass=0;
2430
2431     return 0;
2432 }
2433
2434 static int estimate_motion_thread(AVCodecContext *c, void *arg){
2435     MpegEncContext *s= *(void**)arg;
2436
2437     s->me.dia_size= s->avctx->dia_size;
2438     s->first_slice_line=1;
2439     for(s->mb_y= s->start_mb_y; s->mb_y < s->end_mb_y; s->mb_y++) {
2440         s->mb_x=0; //for block init below
2441         ff_init_block_index(s);
2442         for(s->mb_x=0; s->mb_x < s->mb_width; s->mb_x++) {
2443             s->block_index[0]+=2;
2444             s->block_index[1]+=2;
2445             s->block_index[2]+=2;
2446             s->block_index[3]+=2;
2447
2448             /* compute motion vector & mb_type and store in context */
2449             if(s->pict_type==AV_PICTURE_TYPE_B)
2450                 ff_estimate_b_frame_motion(s, s->mb_x, s->mb_y);
2451             else
2452                 ff_estimate_p_frame_motion(s, s->mb_x, s->mb_y);
2453         }
2454         s->first_slice_line=0;
2455     }
2456     return 0;
2457 }
2458
2459 static int mb_var_thread(AVCodecContext *c, void *arg){
2460     MpegEncContext *s= *(void**)arg;
2461     int mb_x, mb_y;
2462
2463     for(mb_y=s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2464         for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2465             int xx = mb_x * 16;
2466             int yy = mb_y * 16;
2467             uint8_t *pix = s->new_picture.f->data[0] + (yy * s->linesize) + xx;
2468             int varc;
2469             int sum = s->mpvencdsp.pix_sum(pix, s->linesize);
2470
2471             varc = (s->mpvencdsp.pix_norm1(pix, s->linesize) -
2472                     (((unsigned) sum * sum) >> 8) + 500 + 128) >> 8;
2473
2474             s->current_picture.mb_var [s->mb_stride * mb_y + mb_x] = varc;
2475             s->current_picture.mb_mean[s->mb_stride * mb_y + mb_x] = (sum+128)>>8;
2476             s->me.mb_var_sum_temp    += varc;
2477         }
2478     }
2479     return 0;
2480 }
2481
2482 static void write_slice_end(MpegEncContext *s){
2483     if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4){
2484         if(s->partitioned_frame){
2485             ff_mpeg4_merge_partitions(s);
2486         }
2487
2488         ff_mpeg4_stuffing(&s->pb);
2489     }else if(CONFIG_MJPEG_ENCODER && s->out_format == FMT_MJPEG){
2490         ff_mjpeg_encode_stuffing(&s->pb);
2491     }
2492
2493     avpriv_align_put_bits(&s->pb);
2494     flush_put_bits(&s->pb);
2495
2496     if ((s->avctx->flags & CODEC_FLAG_PASS1) && !s->partitioned_frame)
2497         s->misc_bits+= get_bits_diff(s);
2498 }
2499
2500 static void write_mb_info(MpegEncContext *s)
2501 {
2502     uint8_t *ptr = s->mb_info_ptr + s->mb_info_size - 12;
2503     int offset = put_bits_count(&s->pb);
2504     int mba  = s->mb_x + s->mb_width * (s->mb_y % s->gob_index);
2505     int gobn = s->mb_y / s->gob_index;
2506     int pred_x, pred_y;
2507     if (CONFIG_H263_ENCODER)
2508         ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
2509     bytestream_put_le32(&ptr, offset);
2510     bytestream_put_byte(&ptr, s->qscale);
2511     bytestream_put_byte(&ptr, gobn);
2512     bytestream_put_le16(&ptr, mba);
2513     bytestream_put_byte(&ptr, pred_x); /* hmv1 */
2514     bytestream_put_byte(&ptr, pred_y); /* vmv1 */
2515     /* 4MV not implemented */
2516     bytestream_put_byte(&ptr, 0); /* hmv2 */
2517     bytestream_put_byte(&ptr, 0); /* vmv2 */
2518 }
2519
2520 static void update_mb_info(MpegEncContext *s, int startcode)
2521 {
2522     if (!s->mb_info)
2523         return;
2524     if (put_bits_count(&s->pb) - s->prev_mb_info*8 >= s->mb_info*8) {
2525         s->mb_info_size += 12;
2526         s->prev_mb_info = s->last_mb_info;
2527     }
2528     if (startcode) {
2529         s->prev_mb_info = put_bits_count(&s->pb)/8;
2530         /* This might have incremented mb_info_size above, and we return without
2531          * actually writing any info into that slot yet. But in that case,
2532          * this will be called again at the start of the after writing the
2533          * start code, actually writing the mb info. */
2534         return;
2535     }
2536
2537     s->last_mb_info = put_bits_count(&s->pb)/8;
2538     if (!s->mb_info_size)
2539         s->mb_info_size += 12;
2540     write_mb_info(s);
2541 }
2542
2543 static int encode_thread(AVCodecContext *c, void *arg){
2544     MpegEncContext *s= *(void**)arg;
2545     int mb_x, mb_y, pdif = 0;
2546     int chr_h= 16>>s->chroma_y_shift;
2547     int i, j;
2548     MpegEncContext best_s = { 0 }, backup_s;
2549     uint8_t bit_buf[2][MAX_MB_BYTES];
2550     uint8_t bit_buf2[2][MAX_MB_BYTES];
2551     uint8_t bit_buf_tex[2][MAX_MB_BYTES];
2552     PutBitContext pb[2], pb2[2], tex_pb[2];
2553
2554     for(i=0; i<2; i++){
2555         init_put_bits(&pb    [i], bit_buf    [i], MAX_MB_BYTES);
2556         init_put_bits(&pb2   [i], bit_buf2   [i], MAX_MB_BYTES);
2557         init_put_bits(&tex_pb[i], bit_buf_tex[i], MAX_MB_BYTES);
2558     }
2559
2560     s->last_bits= put_bits_count(&s->pb);
2561     s->mv_bits=0;
2562     s->misc_bits=0;
2563     s->i_tex_bits=0;
2564     s->p_tex_bits=0;
2565     s->i_count=0;
2566     s->f_count=0;
2567     s->b_count=0;
2568     s->skip_count=0;
2569
2570     for(i=0; i<3; i++){
2571         /* init last dc values */
2572         /* note: quant matrix value (8) is implied here */
2573         s->last_dc[i] = 128 << s->intra_dc_precision;
2574
2575         s->current_picture.f->error[i] = 0;
2576     }
2577     s->mb_skip_run = 0;
2578     memset(s->last_mv, 0, sizeof(s->last_mv));
2579
2580     s->last_mv_dir = 0;
2581
2582     switch(s->codec_id){
2583     case AV_CODEC_ID_H263:
2584     case AV_CODEC_ID_H263P:
2585     case AV_CODEC_ID_FLV1:
2586         if (CONFIG_H263_ENCODER)
2587             s->gob_index = H263_GOB_HEIGHT(s->height);
2588         break;
2589     case AV_CODEC_ID_MPEG4:
2590         if(CONFIG_MPEG4_ENCODER && s->partitioned_frame)
2591             ff_mpeg4_init_partitions(s);
2592         break;
2593     }
2594
2595     s->resync_mb_x=0;
2596     s->resync_mb_y=0;
2597     s->first_slice_line = 1;
2598     s->ptr_lastgob = s->pb.buf;
2599     for(mb_y= s->start_mb_y; mb_y < s->end_mb_y; mb_y++) {
2600         s->mb_x=0;
2601         s->mb_y= mb_y;
2602
2603         ff_set_qscale(s, s->qscale);
2604         ff_init_block_index(s);
2605
2606         for(mb_x=0; mb_x < s->mb_width; mb_x++) {
2607             int xy= mb_y*s->mb_stride + mb_x; // removed const, H261 needs to adjust this
2608             int mb_type= s->mb_type[xy];
2609 //            int d;
2610             int dmin= INT_MAX;
2611             int dir;
2612
2613             if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < MAX_MB_BYTES){
2614                 av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2615                 return -1;
2616             }
2617             if(s->data_partitioning){
2618                 if(   s->pb2   .buf_end - s->pb2   .buf - (put_bits_count(&s->    pb2)>>3) < MAX_MB_BYTES
2619                    || s->tex_pb.buf_end - s->tex_pb.buf - (put_bits_count(&s->tex_pb )>>3) < MAX_MB_BYTES){
2620                     av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
2621                     return -1;
2622                 }
2623             }
2624
2625             s->mb_x = mb_x;
2626             s->mb_y = mb_y;  // moved into loop, can get changed by H.261
2627             ff_update_block_index(s);
2628
2629             if(CONFIG_H261_ENCODER && s->codec_id == AV_CODEC_ID_H261){
2630                 ff_h261_reorder_mb_index(s);
2631                 xy= s->mb_y*s->mb_stride + s->mb_x;
2632                 mb_type= s->mb_type[xy];
2633             }
2634
2635             /* write gob / video packet header  */
2636             if(s->rtp_mode){
2637                 int current_packet_size, is_gob_start;
2638
2639                 current_packet_size= ((put_bits_count(&s->pb)+7)>>3) - (s->ptr_lastgob - s->pb.buf);
2640
2641                 is_gob_start= s->avctx->rtp_payload_size && current_packet_size >= s->avctx->rtp_payload_size && mb_y + mb_x>0;
2642
2643                 if(s->start_mb_y == mb_y && mb_y > 0 && mb_x==0) is_gob_start=1;
2644
2645                 switch(s->codec_id){
2646                 case AV_CODEC_ID_H263:
2647                 case AV_CODEC_ID_H263P:
2648                     if(!s->h263_slice_structured)
2649                         if(s->mb_x || s->mb_y%s->gob_index) is_gob_start=0;
2650                     break;
2651                 case AV_CODEC_ID_MPEG2VIDEO:
2652                     if(s->mb_x==0 && s->mb_y!=0) is_gob_start=1;
2653                 case AV_CODEC_ID_MPEG1VIDEO:
2654                     if(s->mb_skip_run) is_gob_start=0;
2655                     break;
2656                 }
2657
2658                 if(is_gob_start){
2659                     if(s->start_mb_y != mb_y || mb_x!=0){
2660                         write_slice_end(s);
2661
2662                         if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
2663                             ff_mpeg4_init_partitions(s);
2664                         }
2665                     }
2666
2667                     assert((put_bits_count(&s->pb)&7) == 0);
2668                     current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2669
2670                     if (s->error_rate && s->resync_mb_x + s->resync_mb_y > 0) {
2671                         int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2672                         int d = 100 / s->error_rate;
2673                         if(r % d == 0){
2674                             current_packet_size=0;
2675                             s->pb.buf_ptr= s->ptr_lastgob;
2676                             assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2677                         }
2678                     }
2679
2680                     if (s->avctx->rtp_callback){
2681                         int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2682                         s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2683                     }
2684                     update_mb_info(s, 1);
2685
2686                     switch(s->codec_id){
2687                     case AV_CODEC_ID_MPEG4:
2688                         if (CONFIG_MPEG4_ENCODER) {
2689                             ff_mpeg4_encode_video_packet_header(s);
2690                             ff_mpeg4_clean_buffers(s);
2691                         }
2692                     break;
2693                     case AV_CODEC_ID_MPEG1VIDEO:
2694                     case AV_CODEC_ID_MPEG2VIDEO:
2695                         if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2696                             ff_mpeg1_encode_slice_header(s);
2697                             ff_mpeg1_clean_buffers(s);
2698                         }
2699                     break;
2700                     case AV_CODEC_ID_H263:
2701                     case AV_CODEC_ID_H263P:
2702                         if (CONFIG_H263_ENCODER)
2703                             ff_h263_encode_gob_header(s, mb_y);
2704                     break;
2705                     }
2706
2707                     if (s->avctx->flags & CODEC_FLAG_PASS1) {
2708                         int bits= put_bits_count(&s->pb);
2709                         s->misc_bits+= bits - s->last_bits;
2710                         s->last_bits= bits;
2711                     }
2712
2713                     s->ptr_lastgob += current_packet_size;
2714                     s->first_slice_line=1;
2715                     s->resync_mb_x=mb_x;
2716                     s->resync_mb_y=mb_y;
2717                 }
2718             }
2719
2720             if(  (s->resync_mb_x   == s->mb_x)
2721                && s->resync_mb_y+1 == s->mb_y){
2722                 s->first_slice_line=0;
2723             }
2724
2725             s->mb_skipped=0;
2726             s->dquant=0; //only for QP_RD
2727
2728             update_mb_info(s, 0);
2729
2730             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
2731                 int next_block=0;
2732                 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2733
2734                 copy_context_before_encode(&backup_s, s, -1);
2735                 backup_s.pb= s->pb;
2736                 best_s.data_partitioning= s->data_partitioning;
2737                 best_s.partitioned_frame= s->partitioned_frame;
2738                 if(s->data_partitioning){
2739                     backup_s.pb2= s->pb2;
2740                     backup_s.tex_pb= s->tex_pb;
2741                 }
2742
2743                 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2744                     s->mv_dir = MV_DIR_FORWARD;
2745                     s->mv_type = MV_TYPE_16X16;
2746                     s->mb_intra= 0;
2747                     s->mv[0][0][0] = s->p_mv_table[xy][0];
2748                     s->mv[0][0][1] = s->p_mv_table[xy][1];
2749                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2750                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2751                 }
2752                 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2753                     s->mv_dir = MV_DIR_FORWARD;
2754                     s->mv_type = MV_TYPE_FIELD;
2755                     s->mb_intra= 0;
2756                     for(i=0; i<2; i++){
2757                         j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2758                         s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2759                         s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2760                     }
2761                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2762                                  &dmin, &next_block, 0, 0);
2763                 }
2764                 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2765                     s->mv_dir = MV_DIR_FORWARD;
2766                     s->mv_type = MV_TYPE_16X16;
2767                     s->mb_intra= 0;
2768                     s->mv[0][0][0] = 0;
2769                     s->mv[0][0][1] = 0;
2770                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2771                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2772                 }
2773                 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2774                     s->mv_dir = MV_DIR_FORWARD;
2775                     s->mv_type = MV_TYPE_8X8;
2776                     s->mb_intra= 0;
2777                     for(i=0; i<4; i++){
2778                         s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2779                         s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
2780                     }
2781                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2782                                  &dmin, &next_block, 0, 0);
2783                 }
2784                 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2785                     s->mv_dir = MV_DIR_FORWARD;
2786                     s->mv_type = MV_TYPE_16X16;
2787                     s->mb_intra= 0;
2788                     s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2789                     s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2790                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2791                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2792                 }
2793                 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2794                     s->mv_dir = MV_DIR_BACKWARD;
2795                     s->mv_type = MV_TYPE_16X16;
2796                     s->mb_intra= 0;
2797                     s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2798                     s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2799                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2800                                  &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2801                 }
2802                 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2803                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2804                     s->mv_type = MV_TYPE_16X16;
2805                     s->mb_intra= 0;
2806                     s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2807                     s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2808                     s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2809                     s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2810                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2811                                  &dmin, &next_block, 0, 0);
2812                 }
2813                 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2814                     s->mv_dir = MV_DIR_FORWARD;
2815                     s->mv_type = MV_TYPE_FIELD;
2816                     s->mb_intra= 0;
2817                     for(i=0; i<2; i++){
2818                         j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2819                         s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2820                         s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2821                     }
2822                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2823                                  &dmin, &next_block, 0, 0);
2824                 }
2825                 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2826                     s->mv_dir = MV_DIR_BACKWARD;
2827                     s->mv_type = MV_TYPE_FIELD;
2828                     s->mb_intra= 0;
2829                     for(i=0; i<2; i++){
2830                         j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2831                         s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2832                         s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2833                     }
2834                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2835                                  &dmin, &next_block, 0, 0);
2836                 }
2837                 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2838                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2839                     s->mv_type = MV_TYPE_FIELD;
2840                     s->mb_intra= 0;
2841                     for(dir=0; dir<2; dir++){
2842                         for(i=0; i<2; i++){
2843                             j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2844                             s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2845                             s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2846                         }
2847                     }
2848                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2849                                  &dmin, &next_block, 0, 0);
2850                 }
2851                 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2852                     s->mv_dir = 0;
2853                     s->mv_type = MV_TYPE_16X16;
2854                     s->mb_intra= 1;
2855                     s->mv[0][0][0] = 0;
2856                     s->mv[0][0][1] = 0;
2857                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2858                                  &dmin, &next_block, 0, 0);
2859                     if(s->h263_pred || s->h263_aic){
2860                         if(best_s.mb_intra)
2861                             s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2862                         else
2863                             ff_clean_intra_table_entries(s); //old mode?
2864                     }
2865                 }
2866
2867                 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
2868                     if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2869                         const int last_qp= backup_s.qscale;
2870                         int qpi, qp, dc[6];
2871                         int16_t ac[6][16];
2872                         const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2873                         static const int dquant_tab[4]={-1,1,-2,2};
2874
2875                         assert(backup_s.dquant == 0);
2876
2877                         //FIXME intra
2878                         s->mv_dir= best_s.mv_dir;
2879                         s->mv_type = MV_TYPE_16X16;
2880                         s->mb_intra= best_s.mb_intra;
2881                         s->mv[0][0][0] = best_s.mv[0][0][0];
2882                         s->mv[0][0][1] = best_s.mv[0][0][1];
2883                         s->mv[1][0][0] = best_s.mv[1][0][0];
2884                         s->mv[1][0][1] = best_s.mv[1][0][1];
2885
2886                         qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
2887                         for(; qpi<4; qpi++){
2888                             int dquant= dquant_tab[qpi];
2889                             qp= last_qp + dquant;
2890                             if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2891                                 continue;
2892                             backup_s.dquant= dquant;
2893                             if(s->mb_intra && s->dc_val[0]){
2894                                 for(i=0; i<6; i++){
2895                                     dc[i]= s->dc_val[0][ s->block_index[i] ];
2896                                     memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
2897                                 }
2898                             }
2899
2900                             encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2901                                          &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2902                             if(best_s.qscale != qp){
2903                                 if(s->mb_intra && s->dc_val[0]){
2904                                     for(i=0; i<6; i++){
2905                                         s->dc_val[0][ s->block_index[i] ]= dc[i];
2906                                         memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
2907                                     }
2908                                 }
2909                             }
2910                         }
2911                     }
2912                 }
2913                 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
2914                     int mx= s->b_direct_mv_table[xy][0];
2915                     int my= s->b_direct_mv_table[xy][1];
2916
2917                     backup_s.dquant = 0;
2918                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2919                     s->mb_intra= 0;
2920                     ff_mpeg4_set_direct_mv(s, mx, my);
2921                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2922                                  &dmin, &next_block, mx, my);
2923                 }
2924                 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
2925                     backup_s.dquant = 0;
2926                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2927                     s->mb_intra= 0;
2928                     ff_mpeg4_set_direct_mv(s, 0, 0);
2929                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2930                                  &dmin, &next_block, 0, 0);
2931                 }
2932                 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
2933                     int coded=0;
2934                     for(i=0; i<6; i++)
2935                         coded |= s->block_last_index[i];
2936                     if(coded){
2937                         int mx,my;
2938                         memcpy(s->mv, best_s.mv, sizeof(s->mv));
2939                         if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
2940                             mx=my=0; //FIXME find the one we actually used
2941                             ff_mpeg4_set_direct_mv(s, mx, my);
2942                         }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2943                             mx= s->mv[1][0][0];
2944                             my= s->mv[1][0][1];
2945                         }else{
2946                             mx= s->mv[0][0][0];
2947                             my= s->mv[0][0][1];
2948                         }
2949
2950                         s->mv_dir= best_s.mv_dir;
2951                         s->mv_type = best_s.mv_type;
2952                         s->mb_intra= 0;
2953 /*                        s->mv[0][0][0] = best_s.mv[0][0][0];
2954                         s->mv[0][0][1] = best_s.mv[0][0][1];
2955                         s->mv[1][0][0] = best_s.mv[1][0][0];
2956                         s->mv[1][0][1] = best_s.mv[1][0][1];*/
2957                         backup_s.dquant= 0;
2958                         s->skipdct=1;
2959                         encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2960                                         &dmin, &next_block, mx, my);
2961                         s->skipdct=0;
2962                     }
2963                 }
2964
2965                 s->current_picture.qscale_table[xy] = best_s.qscale;
2966
2967                 copy_context_after_encode(s, &best_s, -1);
2968
2969                 pb_bits_count= put_bits_count(&s->pb);
2970                 flush_put_bits(&s->pb);
2971                 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2972                 s->pb= backup_s.pb;
2973
2974                 if(s->data_partitioning){
2975                     pb2_bits_count= put_bits_count(&s->pb2);
2976                     flush_put_bits(&s->pb2);
2977                     avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2978                     s->pb2= backup_s.pb2;
2979
2980                     tex_pb_bits_count= put_bits_count(&s->tex_pb);
2981                     flush_put_bits(&s->tex_pb);
2982                     avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2983                     s->tex_pb= backup_s.tex_pb;
2984                 }
2985                 s->last_bits= put_bits_count(&s->pb);
2986
2987                 if (CONFIG_H263_ENCODER &&
2988                     s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
2989                     ff_h263_update_motion_val(s);
2990
2991                 if(next_block==0){ //FIXME 16 vs linesize16
2992                     s->hdsp.put_pixels_tab[0][0](s->dest[0], s->sc.rd_scratchpad                     , s->linesize  ,16);
2993                     s->hdsp.put_pixels_tab[1][0](s->dest[1], s->sc.rd_scratchpad + 16*s->linesize    , s->uvlinesize, 8);
2994                     s->hdsp.put_pixels_tab[1][0](s->dest[2], s->sc.rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
2995                 }
2996
2997                 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
2998                     ff_mpv_decode_mb(s, s->block);
2999             } else {
3000                 int motion_x = 0, motion_y = 0;
3001                 s->mv_type=MV_TYPE_16X16;
3002                 // only one MB-Type possible
3003
3004                 switch(mb_type){
3005                 case CANDIDATE_MB_TYPE_INTRA:
3006                     s->mv_dir = 0;
3007                     s->mb_intra= 1;
3008                     motion_x= s->mv[0][0][0] = 0;
3009                     motion_y= s->mv[0][0][1] = 0;
3010                     break;
3011                 case CANDIDATE_MB_TYPE_INTER:
3012                     s->mv_dir = MV_DIR_FORWARD;
3013                     s->mb_intra= 0;
3014                     motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
3015                     motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
3016                     break;
3017                 case CANDIDATE_MB_TYPE_INTER_I:
3018                     s->mv_dir = MV_DIR_FORWARD;
3019                     s->mv_type = MV_TYPE_FIELD;
3020                     s->mb_intra= 0;
3021                     for(i=0; i<2; i++){
3022                         j= s->field_select[0][i] = s->p_field_select_table[i][xy];
3023                         s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
3024                         s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
3025                     }
3026                     break;
3027                 case CANDIDATE_MB_TYPE_INTER4V:
3028                     s->mv_dir = MV_DIR_FORWARD;
3029                     s->mv_type = MV_TYPE_8X8;
3030                     s->mb_intra= 0;
3031                     for(i=0; i<4; i++){
3032                         s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
3033                         s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
3034                     }
3035                     break;
3036                 case CANDIDATE_MB_TYPE_DIRECT:
3037                     if (CONFIG_MPEG4_ENCODER) {
3038                         s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3039                         s->mb_intra= 0;
3040                         motion_x=s->b_direct_mv_table[xy][0];
3041                         motion_y=s->b_direct_mv_table[xy][1];
3042                         ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
3043                     }
3044                     break;
3045                 case CANDIDATE_MB_TYPE_DIRECT0:
3046                     if (CONFIG_MPEG4_ENCODER) {
3047                         s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
3048                         s->mb_intra= 0;
3049                         ff_mpeg4_set_direct_mv(s, 0, 0);
3050                     }
3051                     break;
3052                 case CANDIDATE_MB_TYPE_BIDIR:
3053                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3054                     s->mb_intra= 0;
3055                     s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
3056                     s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
3057                     s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
3058                     s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
3059                     break;
3060                 case CANDIDATE_MB_TYPE_BACKWARD:
3061                     s->mv_dir = MV_DIR_BACKWARD;
3062                     s->mb_intra= 0;
3063                     motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
3064                     motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
3065                     break;
3066                 case CANDIDATE_MB_TYPE_FORWARD:
3067                     s->mv_dir = MV_DIR_FORWARD;
3068                     s->mb_intra= 0;
3069                     motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
3070                     motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
3071                     break;
3072                 case CANDIDATE_MB_TYPE_FORWARD_I:
3073                     s->mv_dir = MV_DIR_FORWARD;
3074                     s->mv_type = MV_TYPE_FIELD;
3075                     s->mb_intra= 0;
3076                     for(i=0; i<2; i++){
3077                         j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
3078                         s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
3079                         s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
3080                     }
3081                     break;
3082                 case CANDIDATE_MB_TYPE_BACKWARD_I:
3083                     s->mv_dir = MV_DIR_BACKWARD;
3084                     s->mv_type = MV_TYPE_FIELD;
3085                     s->mb_intra= 0;
3086                     for(i=0; i<2; i++){
3087                         j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3088                         s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3089                         s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3090                     }
3091                     break;
3092                 case CANDIDATE_MB_TYPE_BIDIR_I:
3093                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3094                     s->mv_type = MV_TYPE_FIELD;
3095                     s->mb_intra= 0;
3096                     for(dir=0; dir<2; dir++){
3097                         for(i=0; i<2; i++){
3098                             j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3099                             s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3100                             s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3101                         }
3102                     }
3103                     break;
3104                 default:
3105                     av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3106                 }
3107
3108                 encode_mb(s, motion_x, motion_y);
3109
3110                 // RAL: Update last macroblock type
3111                 s->last_mv_dir = s->mv_dir;
3112
3113                 if (CONFIG_H263_ENCODER &&
3114                     s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3115                     ff_h263_update_motion_val(s);
3116
3117                 ff_mpv_decode_mb(s, s->block);
3118             }
3119
3120             /* clean the MV table in IPS frames for direct mode in B frames */
3121             if(s->mb_intra /* && I,P,S_TYPE */){
3122                 s->p_mv_table[xy][0]=0;
3123                 s->p_mv_table[xy][1]=0;
3124             }
3125
3126             if (s->avctx->flags & CODEC_FLAG_PSNR) {
3127                 int w= 16;
3128                 int h= 16;
3129
3130                 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3131                 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3132
3133                 s->current_picture.f->error[0] += sse(
3134                     s, s->new_picture.f->data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3135                     s->dest[0], w, h, s->linesize);
3136                 s->current_picture.f->error[1] += sse(
3137                     s, s->new_picture.f->data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*chr_h,
3138                     s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3139                 s->current_picture.f->error[2] += sse(
3140                     s, s->new_picture.f->data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*chr_h,
3141                     s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3142             }
3143             if(s->loop_filter){
3144                 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3145                     ff_h263_loop_filter(s);
3146             }
3147             ff_dlog(s->avctx, "MB %d %d bits\n",
3148                     s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3149         }
3150     }
3151
3152     //not beautiful here but we must write it before flushing so it has to be here
3153     if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3154         ff_msmpeg4_encode_ext_header(s);
3155
3156     write_slice_end(s);
3157
3158     /* Send the last GOB if RTP */
3159     if (s->avctx->rtp_callback) {
3160         int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3161         pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3162         /* Call the RTP callback to send the last GOB */
3163         emms_c();
3164         s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3165     }
3166
3167     return 0;
3168 }
3169
3170 #define MERGE(field) dst->field += src->field; src->field=0
3171 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3172     MERGE(me.scene_change_score);
3173     MERGE(me.mc_mb_var_sum_temp);
3174     MERGE(me.mb_var_sum_temp);
3175 }
3176
3177 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3178     int i;
3179
3180     MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3181     MERGE(dct_count[1]);
3182     MERGE(mv_bits);
3183     MERGE(i_tex_bits);
3184     MERGE(p_tex_bits);
3185     MERGE(i_count);
3186     MERGE(f_count);
3187     MERGE(b_count);
3188     MERGE(skip_count);
3189     MERGE(misc_bits);
3190     MERGE(er.error_count);
3191     MERGE(padding_bug_score);
3192     MERGE(current_picture.f->error[0]);
3193     MERGE(current_picture.f->error[1]);
3194     MERGE(current_picture.f->error[2]);
3195
3196     if(dst->avctx->noise_reduction){
3197         for(i=0; i<64; i++){
3198             MERGE(dct_error_sum[0][i]);
3199             MERGE(dct_error_sum[1][i]);
3200         }
3201     }
3202
3203     assert(put_bits_count(&src->pb) % 8 ==0);
3204     assert(put_bits_count(&dst->pb) % 8 ==0);
3205     avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3206     flush_put_bits(&dst->pb);
3207 }
3208
3209 static int estimate_qp(MpegEncContext *s, int dry_run){
3210     if (s->next_lambda){
3211         s->current_picture_ptr->f->quality =
3212         s->current_picture.f->quality = s->next_lambda;
3213         if(!dry_run) s->next_lambda= 0;
3214     } else if (!s->fixed_qscale) {
3215         s->current_picture_ptr->f->quality =
3216         s->current_picture.f->quality = ff_rate_estimate_qscale(s, dry_run);
3217         if (s->current_picture.f->quality < 0)
3218             return -1;
3219     }
3220
3221     if(s->adaptive_quant){
3222         switch(s->codec_id){
3223         case AV_CODEC_ID_MPEG4:
3224             if (CONFIG_MPEG4_ENCODER)
3225                 ff_clean_mpeg4_qscales(s);
3226             break;
3227         case AV_CODEC_ID_H263:
3228         case AV_CODEC_ID_H263P:
3229         case AV_CODEC_ID_FLV1:
3230             if (CONFIG_H263_ENCODER)
3231                 ff_clean_h263_qscales(s);
3232             break;
3233         default:
3234             ff_init_qscale_tab(s);
3235         }
3236
3237         s->lambda= s->lambda_table[0];
3238         //FIXME broken
3239     }else
3240         s->lambda = s->current_picture.f->quality;
3241     update_qscale(s);
3242     return 0;
3243 }
3244
3245 /* must be called before writing the header */
3246 static void set_frame_distances(MpegEncContext * s){
3247     assert(s->current_picture_ptr->f->pts != AV_NOPTS_VALUE);
3248     s->time = s->current_picture_ptr->f->pts * s->avctx->time_base.num;
3249
3250     if(s->pict_type==AV_PICTURE_TYPE_B){
3251         s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3252         assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3253     }else{
3254         s->pp_time= s->time - s->last_non_b_time;
3255         s->last_non_b_time= s->time;
3256         assert(s->picture_number==0 || s->pp_time > 0);
3257     }
3258 }
3259
3260 static int encode_picture(MpegEncContext *s, int picture_number)
3261 {
3262     int i, ret;
3263     int bits;
3264     int context_count = s->slice_context_count;
3265
3266     s->picture_number = picture_number;
3267
3268     /* Reset the average MB variance */
3269     s->me.mb_var_sum_temp    =
3270     s->me.mc_mb_var_sum_temp = 0;
3271
3272     /* we need to initialize some time vars before we can encode b-frames */
3273     // RAL: Condition added for MPEG1VIDEO
3274     if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3275         set_frame_distances(s);
3276     if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3277         ff_set_mpeg4_time(s);
3278
3279     s->me.scene_change_score=0;
3280
3281 //    s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3282
3283     if(s->pict_type==AV_PICTURE_TYPE_I){
3284         if(s->msmpeg4_version >= 3) s->no_rounding=1;
3285         else                        s->no_rounding=0;
3286     }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3287         if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3288             s->no_rounding ^= 1;
3289     }
3290
3291     if (s->avctx->flags & CODEC_FLAG_PASS2) {
3292         if (estimate_qp(s,1) < 0)
3293             return -1;
3294         ff_get_2pass_fcode(s);
3295     } else if (!(s->avctx->flags & CODEC_FLAG_QSCALE)) {
3296         if(s->pict_type==AV_PICTURE_TYPE_B)
3297             s->lambda= s->last_lambda_for[s->pict_type];
3298         else
3299             s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3300         update_qscale(s);
3301     }
3302
3303     s->mb_intra=0; //for the rate distortion & bit compare functions
3304     for(i=1; i<context_count; i++){
3305         ret = ff_update_duplicate_context(s->thread_context[i], s);
3306         if (ret < 0)
3307             return ret;
3308     }
3309
3310     if(ff_init_me(s)<0)
3311         return -1;
3312
3313     /* Estimate motion for every MB */
3314     if(s->pict_type != AV_PICTURE_TYPE_I){
3315         s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3316         s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
3317         if (s->pict_type != AV_PICTURE_TYPE_B) {
3318             if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
3319                 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3320             }
3321         }
3322
3323         s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3324     }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3325         /* I-Frame */
3326         for(i=0; i<s->mb_stride*s->mb_height; i++)
3327             s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3328
3329         if(!s->fixed_qscale){
3330             /* finding spatial complexity for I-frame rate control */
3331             s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3332         }
3333     }
3334     for(i=1; i<context_count; i++){
3335         merge_context_after_me(s, s->thread_context[i]);
3336     }
3337     s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3338     s->current_picture.   mb_var_sum= s->current_picture_ptr->   mb_var_sum= s->me.   mb_var_sum_temp;
3339     emms_c();
3340
3341     if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == AV_PICTURE_TYPE_P){
3342         s->pict_type= AV_PICTURE_TYPE_I;
3343         for(i=0; i<s->mb_stride*s->mb_height; i++)
3344             s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3345         ff_dlog(s, "Scene change detected, encoding as I Frame %d %d\n",
3346                 s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3347     }
3348
3349     if(!s->umvplus){
3350         if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3351             s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3352
3353             if (s->avctx->flags & CODEC_FLAG_INTERLACED_ME) {
3354                 int a,b;
3355                 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3356                 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3357                 s->f_code= FFMAX3(s->f_code, a, b);
3358             }
3359
3360             ff_fix_long_p_mvs(s);
3361             ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3362             if (s->avctx->flags & CODEC_FLAG_INTERLACED_ME) {
3363                 int j;
3364                 for(i=0; i<2; i++){
3365                     for(j=0; j<2; j++)
3366                         ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3367                                         s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3368                 }
3369             }
3370         }
3371
3372         if(s->pict_type==AV_PICTURE_TYPE_B){
3373             int a, b;
3374
3375             a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3376             b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3377             s->f_code = FFMAX(a, b);
3378
3379             a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3380             b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3381             s->b_code = FFMAX(a, b);
3382
3383             ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3384             ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3385             ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3386             ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3387             if (s->avctx->flags & CODEC_FLAG_INTERLACED_ME) {
3388                 int dir, j;
3389                 for(dir=0; dir<2; dir++){
3390                     for(i=0; i<2; i++){
3391                         for(j=0; j<2; j++){
3392                             int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3393                                           : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3394                             ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3395                                             s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3396                         }
3397                     }
3398                 }
3399             }
3400         }
3401     }
3402
3403     if (estimate_qp(s, 0) < 0)
3404         return -1;
3405
3406     if (s->qscale < 3 && s->max_qcoeff <= 128 &&
3407         s->pict_type == AV_PICTURE_TYPE_I &&
3408         !(s->avctx->flags & CODEC_FLAG_QSCALE))
3409         s->qscale= 3; //reduce clipping problems
3410
3411     if (s->out_format == FMT_MJPEG) {
3412         /* for mjpeg, we do include qscale in the matrix */
3413         for(i=1;i<64;i++){
3414             int j = s->idsp.idct_permutation[i];
3415
3416             s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3417         }
3418         s->y_dc_scale_table=
3419         s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3420         s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3421         ff_convert_matrix(s, s->q_intra_matrix, s->q_intra_matrix16,
3422                        s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3423         s->qscale= 8;
3424     }
3425
3426     //FIXME var duplication
3427     s->current_picture_ptr->f->key_frame =
3428     s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3429     s->current_picture_ptr->f->pict_type =
3430     s->current_picture.f->pict_type = s->pict_type;
3431
3432     if (s->current_picture.f->key_frame)
3433         s->picture_in_gop_number=0;
3434
3435     s->last_bits= put_bits_count(&s->pb);
3436     switch(s->out_format) {
3437     case FMT_MJPEG:
3438         if (CONFIG_MJPEG_ENCODER)
3439             ff_mjpeg_encode_picture_header(s->avctx, &s->pb, &s->intra_scantable,
3440                                            s->intra_matrix);
3441         break;
3442     case FMT_H261:
3443         if (CONFIG_H261_ENCODER)
3444             ff_h261_encode_picture_header(s, picture_number);
3445         break;
3446     case FMT_H263:
3447         if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3448             ff_wmv2_encode_picture_header(s, picture_number);
3449         else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3450             ff_msmpeg4_encode_picture_header(s, picture_number);
3451         else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3452             ff_mpeg4_encode_picture_header(s, picture_number);
3453         else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10) {
3454             ret = ff_rv10_encode_picture_header(s, picture_number);
3455             if (ret < 0)
3456                 return ret;
3457         }
3458         else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3459             ff_rv20_encode_picture_header(s, picture_number);
3460         else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3461             ff_flv_encode_picture_header(s, picture_number);
3462         else if (CONFIG_H263_ENCODER)
3463             ff_h263_encode_picture_header(s, picture_number);
3464         break;
3465     case FMT_MPEG1:
3466         if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3467             ff_mpeg1_encode_picture_header(s, picture_number);
3468         break;
3469     default:
3470         assert(0);
3471     }
3472     bits= put_bits_count(&s->pb);
3473     s->header_bits= bits - s->last_bits;
3474
3475     for(i=1; i<context_count; i++){
3476         update_duplicate_context_after_me(s->thread_context[i], s);
3477     }
3478     s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3479     for(i=1; i<context_count; i++){
3480         merge_context_after_encode(s, s->thread_context[i]);
3481     }
3482     emms_c();
3483     return 0;
3484 }
3485
3486 static void denoise_dct_c(MpegEncContext *s, int16_t *block){
3487     const int intra= s->mb_intra;
3488     int i;
3489
3490     s->dct_count[intra]++;
3491
3492     for(i=0; i<64; i++){
3493         int level= block[i];
3494
3495         if(level){
3496             if(level>0){
3497                 s->dct_error_sum[intra][i] += level;
3498                 level -= s->dct_offset[intra][i];
3499                 if(level<0) level=0;
3500             }else{
3501                 s->dct_error_sum[intra][i] -= level;
3502                 level += s->dct_offset[intra][i];
3503                 if(level>0) level=0;
3504             }
3505             block[i]= level;
3506         }
3507     }
3508 }
3509
3510 static int dct_quantize_trellis_c(MpegEncContext *s,
3511                                   int16_t *block, int n,
3512                                   int qscale, int *overflow){
3513     const int *qmat;
3514     const uint8_t *scantable= s->intra_scantable.scantable;
3515     const uint8_t *perm_scantable= s->intra_scantable.permutated;
3516     int max=0;
3517     unsigned int threshold1, threshold2;
3518     int bias=0;
3519     int run_tab[65];
3520     int level_tab[65];
3521     int score_tab[65];
3522     int survivor[65];
3523     int survivor_count;
3524     int last_run=0;
3525     int last_level=0;
3526     int last_score= 0;
3527     int last_i;
3528     int coeff[2][64];
3529     int coeff_count[64];
3530     int qmul, qadd, start_i, last_non_zero, i, dc;
3531     const int esc_length= s->ac_esc_length;
3532     uint8_t * length;
3533     uint8_t * last_length;
3534     const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3535
3536     s->fdsp.fdct(block);
3537
3538     if(s->dct_error_sum)
3539         s->denoise_dct(s, block);
3540     qmul= qscale*16;
3541     qadd= ((qscale-1)|1)*8;
3542
3543     if (s->mb_intra) {
3544         int q;
3545         if (!s->h263_aic) {
3546             if (n < 4)
3547                 q = s->y_dc_scale;
3548             else
3549                 q = s->c_dc_scale;
3550             q = q << 3;
3551         } else{
3552             /* For AIC we skip quant/dequant of INTRADC */
3553             q = 1 << 3;
3554             qadd=0;
3555         }
3556
3557         /* note: block[0] is assumed to be positive */
3558         block[0] = (block[0] + (q >> 1)) / q;
3559         start_i = 1;
3560         last_non_zero = 0;
3561         qmat = s->q_intra_matrix[qscale];
3562         if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3563             bias= 1<<(QMAT_SHIFT-1);
3564         length     = s->intra_ac_vlc_length;
3565         last_length= s->intra_ac_vlc_last_length;
3566     } else {
3567         start_i = 0;
3568         last_non_zero = -1;
3569         qmat = s->q_inter_matrix[qscale];
3570         length     = s->inter_ac_vlc_length;
3571         last_length= s->inter_ac_vlc_last_length;
3572     }
3573     last_i= start_i;
3574
3575     threshold1= (1<<QMAT_SHIFT) - bias - 1;
3576     threshold2= (threshold1<<1);
3577
3578     for(i=63; i>=start_i; i--) {
3579         const int j = scantable[i];
3580         int level = block[j] * qmat[j];
3581
3582         if(((unsigned)(level+threshold1))>threshold2){
3583             last_non_zero = i;
3584             break;
3585         }
3586     }
3587
3588     for(i=start_i; i<=last_non_zero; i++) {
3589         const int j = scantable[i];
3590         int level = block[j] * qmat[j];
3591
3592 //        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
3593 //           || bias-level >= (1<<(QMAT_SHIFT - 3))){
3594         if(((unsigned)(level+threshold1))>threshold2){
3595             if(level>0){
3596                 level= (bias + level)>>QMAT_SHIFT;
3597                 coeff[0][i]= level;
3598                 coeff[1][i]= level-1;
3599 //                coeff[2][k]= level-2;
3600             }else{
3601                 level= (bias - level)>>QMAT_SHIFT;
3602                 coeff[0][i]= -level;
3603                 coeff[1][i]= -level+1;
3604 //                coeff[2][k]= -level+2;
3605             }
3606             coeff_count[i]= FFMIN(level, 2);
3607             assert(coeff_count[i]);
3608             max |=level;
3609         }else{
3610             coeff[0][i]= (level>>31)|1;
3611             coeff_count[i]= 1;
3612         }
3613     }
3614
3615     *overflow= s->max_qcoeff < max; //overflow might have happened
3616
3617     if(last_non_zero < start_i){
3618         memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3619         return last_non_zero;
3620     }
3621
3622     score_tab[start_i]= 0;
3623     survivor[0]= start_i;
3624     survivor_count= 1;
3625
3626     for(i=start_i; i<=last_non_zero; i++){
3627         int level_index, j, zero_distortion;
3628         int dct_coeff= FFABS(block[ scantable[i] ]);
3629         int best_score=256*256*256*120;
3630
3631         if (s->fdsp.fdct == ff_fdct_ifast)
3632             dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
3633         zero_distortion= dct_coeff*dct_coeff;
3634
3635         for(level_index=0; level_index < coeff_count[i]; level_index++){
3636             int distortion;
3637             int level= coeff[level_index][i];
3638             const int alevel= FFABS(level);
3639             int unquant_coeff;
3640
3641             assert(level);
3642
3643             if(s->out_format == FMT_H263){
3644                 unquant_coeff= alevel*qmul + qadd;
3645             }else{ //MPEG1
3646                 j = s->idsp.idct_permutation[scantable[i]]; // FIXME: optimize
3647                 if(s->mb_intra){
3648                         unquant_coeff = (int)(  alevel  * qscale * s->intra_matrix[j]) >> 3;
3649                         unquant_coeff =   (unquant_coeff - 1) | 1;
3650                 }else{
3651                         unquant_coeff = (((  alevel  << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3652                         unquant_coeff =   (unquant_coeff - 1) | 1;
3653                 }
3654                 unquant_coeff<<= 3;
3655             }
3656
3657             distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3658             level+=64;
3659             if((level&(~127)) == 0){
3660                 for(j=survivor_count-1; j>=0; j--){
3661                     int run= i - survivor[j];
3662                     int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3663                     score += score_tab[i-run];
3664
3665                     if(score < best_score){
3666                         best_score= score;
3667                         run_tab[i+1]= run;
3668                         level_tab[i+1]= level-64;
3669                     }
3670                 }
3671
3672                 if(s->out_format == FMT_H263){
3673                     for(j=survivor_count-1; j>=0; j--){
3674                         int run= i - survivor[j];
3675                         int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3676                         score += score_tab[i-run];
3677                         if(score < last_score){
3678                             last_score= score;
3679                             last_run= run;
3680                             last_level= level-64;
3681                             last_i= i+1;
3682                         }
3683                     }
3684                 }
3685             }else{
3686                 distortion += esc_length*lambda;
3687                 for(j=survivor_count-1; j>=0; j--){
3688                     int run= i - survivor[j];
3689                     int score= distortion + score_tab[i-run];
3690
3691                     if(score < best_score){
3692                         best_score= score;
3693                         run_tab[i+1]= run;
3694                         level_tab[i+1]= level-64;
3695                     }
3696                 }
3697
3698                 if(s->out_format == FMT_H263){
3699                   for(j=survivor_count-1; j>=0; j--){
3700                         int run= i - survivor[j];
3701                         int score= distortion + score_tab[i-run];
3702                         if(score < last_score){
3703                             last_score= score;
3704                             last_run= run;
3705                             last_level= level-64;
3706                             last_i= i+1;
3707                         }
3708                     }
3709                 }
3710             }
3711         }
3712
3713         score_tab[i+1]= best_score;
3714
3715         //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3716         if(last_non_zero <= 27){
3717             for(; survivor_count; survivor_count--){
3718                 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3719                     break;
3720             }
3721         }else{
3722             for(; survivor_count; survivor_count--){
3723                 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3724                     break;
3725             }
3726         }
3727
3728         survivor[ survivor_count++ ]= i+1;
3729     }
3730
3731     if(s->out_format != FMT_H263){
3732         last_score= 256*256*256*120;
3733         for(i= survivor[0]; i<=last_non_zero + 1; i++){
3734             int score= score_tab[i];
3735             if(i) score += lambda*2; //FIXME exacter?
3736
3737             if(score < last_score){
3738                 last_score= score;
3739                 last_i= i;
3740                 last_level= level_tab[i];
3741                 last_run= run_tab[i];
3742             }
3743         }
3744     }
3745
3746     s->coded_score[n] = last_score;
3747
3748     dc= FFABS(block[0]);
3749     last_non_zero= last_i - 1;
3750     memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3751
3752     if(last_non_zero < start_i)
3753         return last_non_zero;
3754
3755     if(last_non_zero == 0 && start_i == 0){
3756         int best_level= 0;
3757         int best_score= dc * dc;
3758
3759         for(i=0; i<coeff_count[0]; i++){
3760             int level= coeff[i][0];
3761             int alevel= FFABS(level);
3762             int unquant_coeff, score, distortion;
3763
3764             if(s->out_format == FMT_H263){
3765                     unquant_coeff= (alevel*qmul + qadd)>>3;
3766             }else{ //MPEG1
3767                     unquant_coeff = (((  alevel  << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
3768                     unquant_coeff =   (unquant_coeff - 1) | 1;
3769             }
3770             unquant_coeff = (unquant_coeff + 4) >> 3;
3771             unquant_coeff<<= 3 + 3;
3772
3773             distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3774             level+=64;
3775             if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
3776             else                    score= distortion + esc_length*lambda;
3777
3778             if(score < best_score){
3779                 best_score= score;
3780                 best_level= level - 64;
3781             }
3782         }
3783         block[0]= best_level;
3784         s->coded_score[n] = best_score - dc*dc;
3785         if(best_level == 0) return -1;
3786         else                return last_non_zero;
3787     }
3788
3789     i= last_i;
3790     assert(last_level);
3791
3792     block[ perm_scantable[last_non_zero] ]= last_level;
3793     i -= last_run + 1;
3794
3795     for(; i>start_i; i -= run_tab[i] + 1){
3796         block[ perm_scantable[i-1] ]= level_tab[i];
3797     }
3798
3799     return last_non_zero;
3800 }
3801
3802 //#define REFINE_STATS 1
3803 static int16_t basis[64][64];
3804
3805 static void build_basis(uint8_t *perm){
3806     int i, j, x, y;
3807     emms_c();
3808     for(i=0; i<8; i++){
3809         for(j=0; j<8; j++){
3810             for(y=0; y<8; y++){
3811                 for(x=0; x<8; x++){
3812                     double s= 0.25*(1<<BASIS_SHIFT);
3813                     int index= 8*i + j;
3814                     int perm_index= perm[index];
3815                     if(i==0) s*= sqrt(0.5);
3816                     if(j==0) s*= sqrt(0.5);
3817                     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)));
3818                 }
3819             }
3820         }
3821     }
3822 }
3823
3824 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
3825                         int16_t *block, int16_t *weight, int16_t *orig,
3826                         int n, int qscale){
3827     int16_t rem[64];
3828     LOCAL_ALIGNED_16(int16_t, d1, [64]);
3829     const uint8_t *scantable= s->intra_scantable.scantable;
3830     const uint8_t *perm_scantable= s->intra_scantable.permutated;
3831 //    unsigned int threshold1, threshold2;
3832 //    int bias=0;
3833     int run_tab[65];
3834     int prev_run=0;
3835     int prev_level=0;
3836     int qmul, qadd, start_i, last_non_zero, i, dc;
3837     uint8_t * length;
3838     uint8_t * last_length;
3839     int lambda;
3840     int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
3841 #ifdef REFINE_STATS
3842 static int count=0;
3843 static int after_last=0;
3844 static int to_zero=0;
3845 static int from_zero=0;
3846 static int raise=0;
3847 static int lower=0;
3848 static int messed_sign=0;
3849 #endif
3850
3851     if(basis[0][0] == 0)
3852         build_basis(s->idsp.idct_permutation);
3853
3854     qmul= qscale*2;
3855     qadd= (qscale-1)|1;
3856     if (s->mb_intra) {
3857         if (!s->h263_aic) {
3858             if (n < 4)
3859                 q = s->y_dc_scale;
3860             else
3861                 q = s->c_dc_scale;
3862         } else{
3863             /* For AIC we skip quant/dequant of INTRADC */
3864             q = 1;
3865             qadd=0;
3866         }
3867         q <<= RECON_SHIFT-3;
3868         /* note: block[0] is assumed to be positive */
3869         dc= block[0]*q;
3870 //        block[0] = (block[0] + (q >> 1)) / q;
3871         start_i = 1;
3872 //        if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3873 //            bias= 1<<(QMAT_SHIFT-1);
3874         length     = s->intra_ac_vlc_length;
3875         last_length= s->intra_ac_vlc_last_length;
3876     } else {
3877         dc= 0;
3878         start_i = 0;
3879         length     = s->inter_ac_vlc_length;
3880         last_length= s->inter_ac_vlc_last_length;
3881     }
3882     last_non_zero = s->block_last_index[n];
3883
3884 #ifdef REFINE_STATS
3885 {START_TIMER
3886 #endif
3887     dc += (1<<(RECON_SHIFT-1));
3888     for(i=0; i<64; i++){
3889         rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME  use orig dirrectly instead of copying to rem[]
3890     }
3891 #ifdef REFINE_STATS
3892 STOP_TIMER("memset rem[]")}
3893 #endif
3894     sum=0;
3895     for(i=0; i<64; i++){
3896         int one= 36;
3897         int qns=4;
3898         int w;
3899
3900         w= FFABS(weight[i]) + qns*one;
3901         w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
3902
3903         weight[i] = w;
3904 //        w=weight[i] = (63*qns + (w/2)) / w;
3905
3906         assert(w>0);
3907         assert(w<(1<<6));
3908         sum += w*w;
3909     }
3910     lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
3911 #ifdef REFINE_STATS
3912 {START_TIMER
3913 #endif
3914     run=0;
3915     rle_index=0;
3916     for(i=start_i; i<=last_non_zero; i++){
3917         int j= perm_scantable[i];
3918         const int level= block[j];
3919         int coeff;
3920
3921         if(level){
3922             if(level<0) coeff= qmul*level - qadd;
3923             else        coeff= qmul*level + qadd;
3924             run_tab[rle_index++]=run;
3925             run=0;
3926
3927             s->mpvencdsp.add_8x8basis(rem, basis[j], coeff);
3928         }else{
3929             run++;
3930         }
3931     }
3932 #ifdef REFINE_STATS
3933 if(last_non_zero>0){
3934 STOP_TIMER("init rem[]")
3935 }
3936 }
3937
3938 {START_TIMER
3939 #endif
3940     for(;;){
3941         int best_score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0], 0);
3942         int best_coeff=0;
3943         int best_change=0;
3944         int run2, best_unquant_change=0, analyze_gradient;
3945 #ifdef REFINE_STATS
3946 {START_TIMER
3947 #endif
3948         analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
3949
3950         if(analyze_gradient){
3951 #ifdef REFINE_STATS
3952 {START_TIMER
3953 #endif
3954             for(i=0; i<64; i++){
3955                 int w= weight[i];
3956
3957                 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
3958             }
3959 #ifdef REFINE_STATS
3960 STOP_TIMER("rem*w*w")}
3961 {START_TIMER
3962 #endif
3963             s->fdsp.fdct(d1);
3964 #ifdef REFINE_STATS
3965 STOP_TIMER("dct")}
3966 #endif
3967         }
3968
3969         if(start_i){
3970             const int level= block[0];
3971             int change, old_coeff;
3972
3973             assert(s->mb_intra);
3974
3975             old_coeff= q*level;
3976
3977             for(change=-1; change<=1; change+=2){
3978                 int new_level= level + change;
3979                 int score, new_coeff;
3980
3981                 new_coeff= q*new_level;
3982                 if(new_coeff >= 2048 || new_coeff < 0)
3983                     continue;
3984
3985                 score = s->mpvencdsp.try_8x8basis(rem, weight, basis[0],
3986                                                   new_coeff - old_coeff);
3987                 if(score<best_score){
3988                     best_score= score;
3989                     best_coeff= 0;
3990                     best_change= change;
3991                     best_unquant_change= new_coeff - old_coeff;
3992                 }
3993             }
3994         }
3995
3996         run=0;
3997         rle_index=0;
3998         run2= run_tab[rle_index++];
3999         prev_level=0;
4000         prev_run=0;
4001
4002         for(i=start_i; i<64; i++){
4003             int j= perm_scantable[i];
4004             const int level= block[j];
4005             int change, old_coeff;
4006
4007             if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
4008                 break;
4009
4010             if(level){
4011                 if(level<0) old_coeff= qmul*level - qadd;
4012                 else        old_coeff= qmul*level + qadd;
4013                 run2= run_tab[rle_index++]; //FIXME ! maybe after last
4014             }else{
4015                 old_coeff=0;
4016                 run2--;
4017                 assert(run2>=0 || i >= last_non_zero );
4018             }
4019
4020             for(change=-1; change<=1; change+=2){
4021                 int new_level= level + change;
4022                 int score, new_coeff, unquant_change;
4023
4024                 score=0;
4025                 if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
4026                    continue;
4027
4028                 if(new_level){
4029                     if(new_level<0) new_coeff= qmul*new_level - qadd;
4030                     else            new_coeff= qmul*new_level + qadd;
4031                     if(new_coeff >= 2048 || new_coeff <= -2048)
4032                         continue;
4033                     //FIXME check for overflow
4034
4035                     if(level){
4036                         if(level < 63 && level > -63){
4037                             if(i < last_non_zero)
4038                                 score +=   length[UNI_AC_ENC_INDEX(run, new_level+64)]
4039                                          - length[UNI_AC_ENC_INDEX(run, level+64)];
4040                             else
4041                                 score +=   last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
4042                                          - last_length[UNI_AC_ENC_INDEX(run, level+64)];
4043                         }
4044                     }else{
4045                         assert(FFABS(new_level)==1);
4046
4047                         if(analyze_gradient){
4048                             int g= d1[ scantable[i] ];
4049                             if(g && (g^new_level) >= 0)
4050                                 continue;
4051                         }
4052
4053                         if(i < last_non_zero){
4054                             int next_i= i + run2 + 1;
4055                             int next_level= block[ perm_scantable[next_i] ] + 64;
4056
4057                             if(next_level&(~127))
4058                                 next_level= 0;
4059
4060                             if(next_i < last_non_zero)
4061                                 score +=   length[UNI_AC_ENC_INDEX(run, 65)]
4062                                          + length[UNI_AC_ENC_INDEX(run2, next_level)]
4063                                          - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4064                             else
4065                                 score +=  length[UNI_AC_ENC_INDEX(run, 65)]
4066                                         + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4067                                         - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4068                         }else{
4069                             score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4070                             if(prev_level){
4071                                 score +=  length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4072                                         - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4073                             }
4074                         }
4075                     }
4076                 }else{
4077                     new_coeff=0;
4078                     assert(FFABS(level)==1);
4079
4080                     if(i < last_non_zero){
4081                         int next_i= i + run2 + 1;
4082                         int next_level= block[ perm_scantable[next_i] ] + 64;
4083
4084                         if(next_level&(~127))
4085                             next_level= 0;
4086
4087                         if(next_i < last_non_zero)
4088                             score +=   length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4089                                      - length[UNI_AC_ENC_INDEX(run2, next_level)]
4090                                      - length[UNI_AC_ENC_INDEX(run, 65)];
4091                         else
4092                             score +=   last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4093                                      - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4094                                      - length[UNI_AC_ENC_INDEX(run, 65)];
4095                     }else{
4096                         score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4097                         if(prev_level){
4098                             score +=  last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4099                                     - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4100                         }
4101                     }
4102                 }
4103
4104                 score *= lambda;
4105
4106                 unquant_change= new_coeff - old_coeff;
4107                 assert((score < 100*lambda && score > -100*lambda) || lambda==0);
4108
4109                 score += s->mpvencdsp.try_8x8basis(rem, weight, basis[j],
4110                                                    unquant_change);
4111                 if(score<best_score){
4112                     best_score= score;
4113                     best_coeff= i;
4114                     best_change= change;
4115                     best_unquant_change= unquant_change;
4116                 }
4117             }
4118             if(level){
4119                 prev_level= level + 64;
4120                 if(prev_level&(~127))
4121                     prev_level= 0;
4122                 prev_run= run;
4123                 run=0;
4124             }else{
4125                 run++;
4126             }
4127         }
4128 #ifdef REFINE_STATS
4129 STOP_TIMER("iterative step")}
4130 #endif
4131
4132         if(best_change){
4133             int j= perm_scantable[ best_coeff ];
4134
4135             block[j] += best_change;
4136
4137             if(best_coeff > last_non_zero){
4138                 last_non_zero= best_coeff;
4139                 assert(block[j]);
4140 #ifdef REFINE_STATS
4141 after_last++;
4142 #endif
4143             }else{
4144 #ifdef REFINE_STATS
4145 if(block[j]){
4146     if(block[j] - best_change){
4147         if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4148             raise++;
4149         }else{
4150             lower++;
4151         }
4152     }else{
4153         from_zero++;
4154     }
4155 }else{
4156     to_zero++;
4157 }
4158 #endif
4159                 for(; last_non_zero>=start_i; last_non_zero--){
4160                     if(block[perm_scantable[last_non_zero]])
4161                         break;
4162                 }
4163             }
4164 #ifdef REFINE_STATS
4165 count++;
4166 if(256*256*256*64 % count == 0){
4167     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);
4168 }
4169 #endif
4170             run=0;
4171             rle_index=0;
4172             for(i=start_i; i<=last_non_zero; i++){
4173                 int j= perm_scantable[i];
4174                 const int level= block[j];
4175
4176                  if(level){
4177                      run_tab[rle_index++]=run;
4178                      run=0;
4179                  }else{
4180                      run++;
4181                  }
4182             }
4183
4184             s->mpvencdsp.add_8x8basis(rem, basis[j], best_unquant_change);
4185         }else{
4186             break;
4187         }
4188     }
4189 #ifdef REFINE_STATS
4190 if(last_non_zero>0){
4191 STOP_TIMER("iterative search")
4192 }
4193 }
4194 #endif
4195
4196     return last_non_zero;
4197 }
4198
4199 /**
4200  * Permute an 8x8 block according to permuatation.
4201  * @param block the block which will be permuted according to
4202  *              the given permutation vector
4203  * @param permutation the permutation vector
4204  * @param last the last non zero coefficient in scantable order, used to
4205  *             speed the permutation up
4206  * @param scantable the used scantable, this is only used to speed the
4207  *                  permutation up, the block is not (inverse) permutated
4208  *                  to scantable order!
4209  */
4210 static void block_permute(int16_t *block, uint8_t *permutation,
4211                           const uint8_t *scantable, int last)
4212 {
4213     int i;
4214     int16_t temp[64];
4215
4216     if (last <= 0)
4217         return;
4218     //FIXME it is ok but not clean and might fail for some permutations
4219     // if (permutation[1] == 1)
4220     // return;
4221
4222     for (i = 0; i <= last; i++) {
4223         const int j = scantable[i];
4224         temp[j] = block[j];
4225         block[j] = 0;
4226     }
4227
4228     for (i = 0; i <= last; i++) {
4229         const int j = scantable[i];
4230         const int perm_j = permutation[j];
4231         block[perm_j] = temp[j];
4232     }
4233 }
4234
4235 int ff_dct_quantize_c(MpegEncContext *s,
4236                         int16_t *block, int n,
4237                         int qscale, int *overflow)
4238 {
4239     int i, j, level, last_non_zero, q, start_i;
4240     const int *qmat;
4241     const uint8_t *scantable= s->intra_scantable.scantable;
4242     int bias;
4243     int max=0;
4244     unsigned int threshold1, threshold2;
4245
4246     s->fdsp.fdct(block);
4247
4248     if(s->dct_error_sum)
4249         s->denoise_dct(s, block);
4250
4251     if (s->mb_intra) {
4252         if (!s->h263_aic) {
4253             if (n < 4)
4254                 q = s->y_dc_scale;
4255             else
4256                 q = s->c_dc_scale;
4257             q = q << 3;
4258         } else
4259             /* For AIC we skip quant/dequant of INTRADC */
4260             q = 1 << 3;
4261
4262         /* note: block[0] is assumed to be positive */
4263         block[0] = (block[0] + (q >> 1)) / q;
4264         start_i = 1;
4265         last_non_zero = 0;
4266         qmat = s->q_intra_matrix[qscale];
4267         bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4268     } else {
4269         start_i = 0;
4270         last_non_zero = -1;
4271         qmat = s->q_inter_matrix[qscale];
4272         bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4273     }
4274     threshold1= (1<<QMAT_SHIFT) - bias - 1;
4275     threshold2= (threshold1<<1);
4276     for(i=63;i>=start_i;i--) {
4277         j = scantable[i];
4278         level = block[j] * qmat[j];
4279
4280         if(((unsigned)(level+threshold1))>threshold2){
4281             last_non_zero = i;
4282             break;
4283         }else{
4284             block[j]=0;
4285         }
4286     }
4287     for(i=start_i; i<=last_non_zero; i++) {
4288         j = scantable[i];
4289         level = block[j] * qmat[j];
4290
4291 //        if(   bias+level >= (1<<QMAT_SHIFT)
4292 //           || bias-level >= (1<<QMAT_SHIFT)){
4293         if(((unsigned)(level+threshold1))>threshold2){
4294             if(level>0){
4295                 level= (bias + level)>>QMAT_SHIFT;
4296                 block[j]= level;
4297             }else{
4298                 level= (bias - level)>>QMAT_SHIFT;
4299                 block[j]= -level;
4300             }
4301             max |=level;
4302         }else{
4303             block[j]=0;
4304         }
4305     }
4306     *overflow= s->max_qcoeff < max; //overflow might have happened
4307
4308     /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4309     if (s->idsp.perm_type != FF_IDCT_PERM_NONE)
4310         block_permute(block, s->idsp.idct_permutation,
4311                       scantable, last_non_zero);
4312
4313     return last_non_zero;
4314 }
4315
4316 #define OFFSET(x) offsetof(MpegEncContext, x)
4317 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4318 static const AVOption h263_options[] = {
4319     { "obmc",         "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4320     { "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},
4321     { "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 },
4322     FF_MPV_COMMON_OPTS
4323     { NULL },
4324 };
4325
4326 static const AVClass h263_class = {
4327     .class_name = "H.263 encoder",
4328     .item_name  = av_default_item_name,
4329     .option     = h263_options,
4330     .version    = LIBAVUTIL_VERSION_INT,
4331 };
4332
4333 AVCodec ff_h263_encoder = {
4334     .name           = "h263",
4335     .long_name      = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4336     .type           = AVMEDIA_TYPE_VIDEO,
4337     .id             = AV_CODEC_ID_H263,
4338     .priv_data_size = sizeof(MpegEncContext),
4339     .init           = ff_mpv_encode_init,
4340     .encode2        = ff_mpv_encode_picture,
4341     .close          = ff_mpv_encode_end,
4342     .pix_fmts= (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},
4343     .priv_class     = &h263_class,
4344 };
4345
4346 static const AVOption h263p_options[] = {
4347     { "umv",        "Use unlimited motion vectors.",    OFFSET(umvplus), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4348     { "aiv",        "Use alternative inter VLC.",       OFFSET(alt_inter_vlc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4349     { "obmc",       "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4350     { "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},
4351     FF_MPV_COMMON_OPTS
4352     { NULL },
4353 };
4354 static const AVClass h263p_class = {
4355     .class_name = "H.263p encoder",
4356     .item_name  = av_default_item_name,
4357     .option     = h263p_options,
4358     .version    = LIBAVUTIL_VERSION_INT,
4359 };
4360
4361 AVCodec ff_h263p_encoder = {
4362     .name           = "h263p",
4363     .long_name      = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4364     .type           = AVMEDIA_TYPE_VIDEO,
4365     .id             = AV_CODEC_ID_H263P,
4366     .priv_data_size = sizeof(MpegEncContext),
4367     .init           = ff_mpv_encode_init,
4368     .encode2        = ff_mpv_encode_picture,
4369     .close          = ff_mpv_encode_end,
4370     .capabilities   = CODEC_CAP_SLICE_THREADS,
4371     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4372     .priv_class     = &h263p_class,
4373 };
4374
4375 FF_MPV_GENERIC_CLASS(msmpeg4v2)
4376
4377 AVCodec ff_msmpeg4v2_encoder = {
4378     .name           = "msmpeg4v2",
4379     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4380     .type           = AVMEDIA_TYPE_VIDEO,
4381     .id             = AV_CODEC_ID_MSMPEG4V2,
4382     .priv_data_size = sizeof(MpegEncContext),
4383     .init           = ff_mpv_encode_init,
4384     .encode2        = ff_mpv_encode_picture,
4385     .close          = ff_mpv_encode_end,
4386     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4387     .priv_class     = &msmpeg4v2_class,
4388 };
4389
4390 FF_MPV_GENERIC_CLASS(msmpeg4v3)
4391
4392 AVCodec ff_msmpeg4v3_encoder = {
4393     .name           = "msmpeg4",
4394     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4395     .type           = AVMEDIA_TYPE_VIDEO,
4396     .id             = AV_CODEC_ID_MSMPEG4V3,
4397     .priv_data_size = sizeof(MpegEncContext),
4398     .init           = ff_mpv_encode_init,
4399     .encode2        = ff_mpv_encode_picture,
4400     .close          = ff_mpv_encode_end,
4401     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4402     .priv_class     = &msmpeg4v3_class,
4403 };
4404
4405 FF_MPV_GENERIC_CLASS(wmv1)
4406
4407 AVCodec ff_wmv1_encoder = {
4408     .name           = "wmv1",
4409     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4410     .type           = AVMEDIA_TYPE_VIDEO,
4411     .id             = AV_CODEC_ID_WMV1,
4412     .priv_data_size = sizeof(MpegEncContext),
4413     .init           = ff_mpv_encode_init,
4414     .encode2        = ff_mpv_encode_picture,
4415     .close          = ff_mpv_encode_end,
4416     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4417     .priv_class     = &wmv1_class,
4418 };