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