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