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