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

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