git.sesse.net Git - ffmpeg/blob - libavcodec/mpegvideo_enc.c

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