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