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