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