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