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