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