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 update_duplicate_context_after_me(MpegEncContext *dst,
 186                                               MpegEncContext *src)
 187 {
 188 #define COPY(a) dst->a= src->a
 189     COPY(pict_type);
 190     COPY(current_picture);
 191     COPY(f_code);
 192     COPY(b_code);
 193     COPY(qscale);
 194     COPY(lambda);
 195     COPY(lambda2);
 196     COPY(picture_in_gop_number);
 197     COPY(gop_picture_number);
 198     COPY(frame_pred_frame_dct); // FIXME don't set in encode_header
 199     COPY(progressive_frame);    // FIXME don't set in encode_header
 200     COPY(partitioned_frame);    // FIXME don't set in encode_header
 201 #undef COPY
 202 }
 203
 204 /**
 205  * Set the given MpegEncContext to defaults for encoding.
 206  * the changed fields will not depend upon the prior state of the MpegEncContext.
 207  */
 208 static void MPV_encode_defaults(MpegEncContext *s)
 209 {
 210     int i;
 211     ff_MPV_common_defaults(s);
 212
 213     for (i = -16; i < 16; i++) {
 214         default_fcode_tab[i + MAX_MV] = 1;
 215     }
 216     s->me.mv_penalty = default_mv_penalty;
 217     s->fcode_tab     = default_fcode_tab;
 218 }
 219
 220 av_cold int ff_dct_encode_init(MpegEncContext *s) {
 221     if (ARCH_X86)
 222         ff_dct_encode_init_x86(s);
 223
 224     if (!s->dct_quantize)
 225         s->dct_quantize = ff_dct_quantize_c;
 226     if (!s->denoise_dct)
 227         s->denoise_dct  = denoise_dct_c;
 228     s->fast_dct_quantize = s->dct_quantize;
 229     if (s->avctx->trellis)
 230         s->dct_quantize  = dct_quantize_trellis_c;
 231
 232     return 0;
 233 }
 234
 235 /* init video encoder */
 236 av_cold int ff_MPV_encode_init(AVCodecContext *avctx)
 237 {
 238     MpegEncContext *s = avctx->priv_data;
 239     int i;
 240     int chroma_h_shift, chroma_v_shift;
 241
 242     MPV_encode_defaults(s);
 243
 244     switch (avctx->codec_id) {
 245     case AV_CODEC_ID_MPEG2VIDEO:
 246         if (avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
 247             avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
 248             av_log(avctx, AV_LOG_ERROR,
 249                    "only YUV420 and YUV422 are supported\n");
 250             return -1;
 251         }
 252         break;
 253     case AV_CODEC_ID_LJPEG:
 254         if (avctx->pix_fmt != AV_PIX_FMT_YUVJ420P &&
 255             avctx->pix_fmt != AV_PIX_FMT_YUVJ422P &&
 256             avctx->pix_fmt != AV_PIX_FMT_YUVJ444P &&
 257             avctx->pix_fmt != AV_PIX_FMT_BGR0     &&
 258             avctx->pix_fmt != AV_PIX_FMT_BGRA     &&
 259             avctx->pix_fmt != AV_PIX_FMT_BGR24    &&
 260             ((avctx->pix_fmt != AV_PIX_FMT_YUV420P &&
 261               avctx->pix_fmt != AV_PIX_FMT_YUV422P &&
 262               avctx->pix_fmt != AV_PIX_FMT_YUV444P) ||
 263              avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL)) {
 264             av_log(avctx, AV_LOG_ERROR, "colorspace not supported in LJPEG\n");
 265             return -1;
 266         }
 267         break;
 268     case AV_CODEC_ID_MJPEG:
 269     case AV_CODEC_ID_AMV:
 270         if (avctx->pix_fmt != AV_PIX_FMT_YUVJ420P &&
 271             avctx->pix_fmt != AV_PIX_FMT_YUVJ422P &&
 272             avctx->pix_fmt != AV_PIX_FMT_YUVJ444P &&
 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 jpeg\n");
 278             return -1;
 279         }
 280         break;
 281     default:
 282         if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
 283             av_log(avctx, AV_LOG_ERROR, "only YUV420 is supported\n");
 284             return -1;
 285         }
 286     }
 287
 288     switch (avctx->pix_fmt) {
 289     case AV_PIX_FMT_YUVJ444P:
 290     case AV_PIX_FMT_YUV444P:
 291         s->chroma_format = CHROMA_444;
 292         break;
 293     case AV_PIX_FMT_YUVJ422P:
 294     case AV_PIX_FMT_YUV422P:
 295         s->chroma_format = CHROMA_422;
 296         break;
 297     case AV_PIX_FMT_YUVJ420P:
 298     case AV_PIX_FMT_YUV420P:
 299     default:
 300         s->chroma_format = CHROMA_420;
 301         break;
 302     }
 303
 304     s->bit_rate = avctx->bit_rate;
 305     s->width    = avctx->width;
 306     s->height   = avctx->height;
 307     if (avctx->gop_size > 600 &&
 308         avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
 309         av_log(avctx, AV_LOG_WARNING,
 310                "keyframe interval too large!, reducing it from %d to %d\n",
 311                avctx->gop_size, 600);
 312         avctx->gop_size = 600;
 313     }
 314     s->gop_size     = avctx->gop_size;
 315     s->avctx        = avctx;
 316     s->flags        = avctx->flags;
 317     s->flags2       = avctx->flags2;
 318     s->max_b_frames = avctx->max_b_frames;
 319     s->codec_id     = avctx->codec->id;
 320     s->strict_std_compliance = avctx->strict_std_compliance;
 321     s->quarter_sample     = (avctx->flags & CODEC_FLAG_QPEL) != 0;
 322     s->mpeg_quant         = avctx->mpeg_quant;
 323     s->rtp_mode           = !!avctx->rtp_payload_size;
 324     s->intra_dc_precision = avctx->intra_dc_precision;
 325     s->user_specified_pts = AV_NOPTS_VALUE;
 326
 327     if (s->gop_size <= 1) {
 328         s->intra_only = 1;
 329         s->gop_size   = 12;
 330     } else {
 331         s->intra_only = 0;
 332     }
 333
 334     s->me_method = avctx->me_method;
 335
 336     /* Fixed QSCALE */
 337     s->fixed_qscale = !!(avctx->flags & CODEC_FLAG_QSCALE);
 338
 339     s->adaptive_quant = (s->avctx->lumi_masking ||
 340                          s->avctx->dark_masking ||
 341                          s->avctx->temporal_cplx_masking ||
 342                          s->avctx->spatial_cplx_masking  ||
 343                          s->avctx->p_masking      ||
 344                          s->avctx->border_masking ||
 345                          (s->mpv_flags & FF_MPV_FLAG_QP_RD)) &&
 346                         !s->fixed_qscale;
 347
 348     s->loop_filter      = !!(s->flags & CODEC_FLAG_LOOP_FILTER);
 349
 350     if (avctx->rc_max_rate && !avctx->rc_buffer_size) {
 351         switch(avctx->codec_id) {
 352         case AV_CODEC_ID_MPEG1VIDEO:
 353         case AV_CODEC_ID_MPEG2VIDEO:
 354             avctx->rc_buffer_size = FFMAX(avctx->rc_max_rate, 15000000) * 112L / 15000000 * 16384;
 355             break;
 356         case AV_CODEC_ID_MPEG4:
 357         case AV_CODEC_ID_MSMPEG4V1:
 358         case AV_CODEC_ID_MSMPEG4V2:
 359         case AV_CODEC_ID_MSMPEG4V3:
 360             if       (avctx->rc_max_rate >= 15000000) {
 361                 avctx->rc_buffer_size = 320 + (avctx->rc_max_rate - 15000000L) * (760-320) / (38400000 - 15000000);
 362             } else if(avctx->rc_max_rate >=  2000000) {
 363                 avctx->rc_buffer_size =  80 + (avctx->rc_max_rate -  2000000L) * (320- 80) / (15000000 -  2000000);
 364             } else if(avctx->rc_max_rate >=   384000) {
 365                 avctx->rc_buffer_size =  40 + (avctx->rc_max_rate -   384000L) * ( 80- 40) / ( 2000000 -   384000);
 366             } else
 367                 avctx->rc_buffer_size = 40;
 368             avctx->rc_buffer_size *= 16384;
 369             break;
 370         }
 371         if (avctx->rc_buffer_size) {
 372             av_log(avctx, AV_LOG_INFO, "Automatically choosing VBV buffer size of %d kbyte\n", avctx->rc_buffer_size/8192);
 373         }
 374     }
 375
 376     if ((!avctx->rc_max_rate) != (!avctx->rc_buffer_size)) {
 377         av_log(avctx, AV_LOG_ERROR, "Either both buffer size and max rate or neither must be specified\n");
 378         if (avctx->rc_max_rate && !avctx->rc_buffer_size)
 379             return -1;
 380     }
 381
 382     if (avctx->rc_min_rate && avctx->rc_max_rate != avctx->rc_min_rate) {
 383         av_log(avctx, AV_LOG_INFO,
 384                "Warning min_rate > 0 but min_rate != max_rate isn't recommended!\n");
 385     }
 386
 387     if (avctx->rc_min_rate && avctx->rc_min_rate > avctx->bit_rate) {
 388         av_log(avctx, AV_LOG_ERROR, "bitrate below min bitrate\n");
 389         return -1;
 390     }
 391
 392     if (avctx->rc_max_rate && avctx->rc_max_rate < avctx->bit_rate) {
 393         av_log(avctx, AV_LOG_ERROR, "bitrate above max bitrate\n");
 394         return -1;
 395     }
 396
 397     if (avctx->rc_max_rate &&
 398         avctx->rc_max_rate == avctx->bit_rate &&
 399         avctx->rc_max_rate != avctx->rc_min_rate) {
 400         av_log(avctx, AV_LOG_INFO,
 401                "impossible bitrate constraints, this will fail\n");
 402     }
 403
 404     if (avctx->rc_buffer_size &&
 405         avctx->bit_rate * (int64_t)avctx->time_base.num >
 406             avctx->rc_buffer_size * (int64_t)avctx->time_base.den) {
 407         av_log(avctx, AV_LOG_ERROR, "VBV buffer too small for bitrate\n");
 408         return -1;
 409     }
 410
 411     if (!s->fixed_qscale &&
 412         avctx->bit_rate * av_q2d(avctx->time_base) >
 413             avctx->bit_rate_tolerance) {
 414         av_log(avctx, AV_LOG_ERROR,
 415                "bitrate tolerance too small for bitrate\n");
 416         return -1;
 417     }
 418
 419     if (s->avctx->rc_max_rate &&
 420         s->avctx->rc_min_rate == s->avctx->rc_max_rate &&
 421         (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
 422          s->codec_id == AV_CODEC_ID_MPEG2VIDEO) &&
 423         90000LL * (avctx->rc_buffer_size - 1) >
 424             s->avctx->rc_max_rate * 0xFFFFLL) {
 425         av_log(avctx, AV_LOG_INFO,
 426                "Warning vbv_delay will be set to 0xFFFF (=VBR) as the "
 427                "specified vbv buffer is too large for the given bitrate!\n");
 428     }
 429
 430     if ((s->flags & CODEC_FLAG_4MV)  && s->codec_id != AV_CODEC_ID_MPEG4 &&
 431         s->codec_id != AV_CODEC_ID_H263 && s->codec_id != AV_CODEC_ID_H263P &&
 432         s->codec_id != AV_CODEC_ID_FLV1) {
 433         av_log(avctx, AV_LOG_ERROR, "4MV not supported by codec\n");
 434         return -1;
 435     }
 436
 437     if (s->obmc && s->avctx->mb_decision != FF_MB_DECISION_SIMPLE) {
 438         av_log(avctx, AV_LOG_ERROR,
 439                "OBMC is only supported with simple mb decision\n");
 440         return -1;
 441     }
 442
 443     if (s->quarter_sample && s->codec_id != AV_CODEC_ID_MPEG4) {
 444         av_log(avctx, AV_LOG_ERROR, "qpel not supported by codec\n");
 445         return -1;
 446     }
 447
 448     if (s->max_b_frames                    &&
 449         s->codec_id != AV_CODEC_ID_MPEG4      &&
 450         s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
 451         s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
 452         av_log(avctx, AV_LOG_ERROR, "b frames not supported by codec\n");
 453         return -1;
 454     }
 455     if (s->max_b_frames < 0) {
 456         av_log(avctx, AV_LOG_ERROR,
 457                "max b frames must be 0 or positive for mpegvideo based encoders\n");
 458         return -1;
 459     }
 460
 461     if ((s->codec_id == AV_CODEC_ID_MPEG4 ||
 462          s->codec_id == AV_CODEC_ID_H263  ||
 463          s->codec_id == AV_CODEC_ID_H263P) &&
 464         (avctx->sample_aspect_ratio.num > 255 ||
 465          avctx->sample_aspect_ratio.den > 255)) {
 466         av_log(avctx, AV_LOG_WARNING,
 467                "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
 468                avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
 469         av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
 470                    avctx->sample_aspect_ratio.num,  avctx->sample_aspect_ratio.den, 255);
 471     }
 472
 473     if ((s->codec_id == AV_CODEC_ID_H263  ||
 474          s->codec_id == AV_CODEC_ID_H263P) &&
 475         (avctx->width  > 2048 ||
 476          avctx->height > 1152 )) {
 477         av_log(avctx, AV_LOG_ERROR, "H.263 does not support resolutions above 2048x1152\n");
 478         return -1;
 479     }
 480     if ((s->codec_id == AV_CODEC_ID_H263  ||
 481          s->codec_id == AV_CODEC_ID_H263P) &&
 482         ((avctx->width &3) ||
 483          (avctx->height&3) )) {
 484         av_log(avctx, AV_LOG_ERROR, "w/h must be a multiple of 4\n");
 485         return -1;
 486     }
 487
 488     if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO &&
 489         (avctx->width  > 4095 ||
 490          avctx->height > 4095 )) {
 491         av_log(avctx, AV_LOG_ERROR, "MPEG-1 does not support resolutions above 4095x4095\n");
 492         return -1;
 493     }
 494
 495     if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO &&
 496         (avctx->width  > 16383 ||
 497          avctx->height > 16383 )) {
 498         av_log(avctx, AV_LOG_ERROR, "MPEG-2 does not support resolutions above 16383x16383\n");
 499         return -1;
 500     }
 501
 502     if (s->codec_id == AV_CODEC_ID_RV10 &&
 503         (avctx->width &15 ||
 504          avctx->height&15 )) {
 505         av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 16\n");
 506         return AVERROR(EINVAL);
 507     }
 508
 509     if (s->codec_id == AV_CODEC_ID_RV20 &&
 510         (avctx->width &3 ||
 511          avctx->height&3 )) {
 512         av_log(avctx, AV_LOG_ERROR, "width and height must be a multiple of 4\n");
 513         return AVERROR(EINVAL);
 514     }
 515
 516     if ((s->codec_id == AV_CODEC_ID_WMV1 ||
 517          s->codec_id == AV_CODEC_ID_WMV2) &&
 518          avctx->width & 1) {
 519          av_log(avctx, AV_LOG_ERROR, "width must be multiple of 2\n");
 520          return -1;
 521     }
 522
 523     if ((s->flags & (CODEC_FLAG_INTERLACED_DCT | CODEC_FLAG_INTERLACED_ME)) &&
 524         s->codec_id != AV_CODEC_ID_MPEG4 && s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
 525         av_log(avctx, AV_LOG_ERROR, "interlacing not supported by codec\n");
 526         return -1;
 527     }
 528
 529     // FIXME mpeg2 uses that too
 530     if (s->mpeg_quant && (   s->codec_id != AV_CODEC_ID_MPEG4
 531                           && s->codec_id != AV_CODEC_ID_MPEG2VIDEO)) {
 532         av_log(avctx, AV_LOG_ERROR,
 533                "mpeg2 style quantization not supported by codec\n");
 534         return -1;
 535     }
 536
 537     if ((s->mpv_flags & FF_MPV_FLAG_CBP_RD) && !avctx->trellis) {
 538         av_log(avctx, AV_LOG_ERROR, "CBP RD needs trellis quant\n");
 539         return -1;
 540     }
 541
 542     if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) &&
 543         s->avctx->mb_decision != FF_MB_DECISION_RD) {
 544         av_log(avctx, AV_LOG_ERROR, "QP RD needs mbd=2\n");
 545         return -1;
 546     }
 547
 548     if (s->avctx->scenechange_threshold < 1000000000 &&
 549         (s->flags & CODEC_FLAG_CLOSED_GOP)) {
 550         av_log(avctx, AV_LOG_ERROR,
 551                "closed gop with scene change detection are not supported yet, "
 552                "set threshold to 1000000000\n");
 553         return -1;
 554     }
 555
 556     if (s->flags & CODEC_FLAG_LOW_DELAY) {
 557         if (s->codec_id != AV_CODEC_ID_MPEG2VIDEO) {
 558             av_log(avctx, AV_LOG_ERROR,
 559                   "low delay forcing is only available for mpeg2\n");
 560             return -1;
 561         }
 562         if (s->max_b_frames != 0) {
 563             av_log(avctx, AV_LOG_ERROR,
 564                    "b frames cannot be used with low delay\n");
 565             return -1;
 566         }
 567     }
 568
 569     if (s->q_scale_type == 1) {
 570         if (avctx->qmax > 12) {
 571             av_log(avctx, AV_LOG_ERROR,
 572                    "non linear quant only supports qmax <= 12 currently\n");
 573             return -1;
 574         }
 575     }
 576
 577     if (s->avctx->thread_count > 1         &&
 578         s->codec_id != AV_CODEC_ID_MPEG4      &&
 579         s->codec_id != AV_CODEC_ID_MPEG1VIDEO &&
 580         s->codec_id != AV_CODEC_ID_MPEG2VIDEO &&
 581         s->codec_id != AV_CODEC_ID_MJPEG      &&
 582         (s->codec_id != AV_CODEC_ID_H263P)) {
 583         av_log(avctx, AV_LOG_ERROR,
 584                "multi threaded encoding not supported by codec\n");
 585         return -1;
 586     }
 587
 588     if (s->avctx->thread_count < 1) {
 589         av_log(avctx, AV_LOG_ERROR,
 590                "automatic thread number detection not supported by codec, "
 591                "patch welcome\n");
 592         return -1;
 593     }
 594
 595     if (s->avctx->slices > 1 || s->avctx->thread_count > 1)
 596         s->rtp_mode = 1;
 597
 598     if (s->avctx->thread_count > 1 && s->codec_id == AV_CODEC_ID_H263P)
 599         s->h263_slice_structured = 1;
 600
 601     if (!avctx->time_base.den || !avctx->time_base.num) {
 602         av_log(avctx, AV_LOG_ERROR, "framerate not set\n");
 603         return -1;
 604     }
 605
 606     i = (INT_MAX / 2 + 128) >> 8;
 607     if (avctx->mb_threshold >= i) {
 608         av_log(avctx, AV_LOG_ERROR, "mb_threshold too large, max is %d\n",
 609                i - 1);
 610         return -1;
 611     }
 612
 613     if (avctx->b_frame_strategy && (avctx->flags & CODEC_FLAG_PASS2)) {
 614         av_log(avctx, AV_LOG_INFO,
 615                "notice: b_frame_strategy only affects the first pass\n");
 616         avctx->b_frame_strategy = 0;
 617     }
 618
 619     i = av_gcd(avctx->time_base.den, avctx->time_base.num);
 620     if (i > 1) {
 621         av_log(avctx, AV_LOG_INFO, "removing common factors from framerate\n");
 622         avctx->time_base.den /= i;
 623         avctx->time_base.num /= i;
 624         //return -1;
 625     }
 626
 627     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) {
 628         // (a + x * 3 / 8) / x
 629         s->intra_quant_bias = 3 << (QUANT_BIAS_SHIFT - 3);
 630         s->inter_quant_bias = 0;
 631     } else {
 632         s->intra_quant_bias = 0;
 633         // (a - x / 4) / x
 634         s->inter_quant_bias = -(1 << (QUANT_BIAS_SHIFT - 2));
 635     }
 636
 637     if (avctx->qmin > avctx->qmax || avctx->qmin <= 0) {
 638         av_log(avctx, AV_LOG_ERROR, "qmin and or qmax are invalid, they must be 0 < min <= max\n");
 639         return AVERROR(EINVAL);
 640     }
 641
 642     if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
 643         s->intra_quant_bias = avctx->intra_quant_bias;
 644     if (avctx->inter_quant_bias != FF_DEFAULT_QUANT_BIAS)
 645         s->inter_quant_bias = avctx->inter_quant_bias;
 646
 647     av_log(avctx, AV_LOG_DEBUG, "intra_quant_bias = %d inter_quant_bias = %d\n",s->intra_quant_bias,s->inter_quant_bias);
 648
 649     avcodec_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
 650
 651     if (avctx->codec_id == AV_CODEC_ID_MPEG4 &&
 652         s->avctx->time_base.den > (1 << 16) - 1) {
 653         av_log(avctx, AV_LOG_ERROR,
 654                "timebase %d/%d not supported by MPEG 4 standard, "
 655                "the maximum admitted value for the timebase denominator "
 656                "is %d\n", s->avctx->time_base.num, s->avctx->time_base.den,
 657                (1 << 16) - 1);
 658         return -1;
 659     }
 660     s->time_increment_bits = av_log2(s->avctx->time_base.den - 1) + 1;
 661
 662     switch (avctx->codec->id) {
 663     case AV_CODEC_ID_MPEG1VIDEO:
 664         s->out_format = FMT_MPEG1;
 665         s->low_delay  = !!(s->flags & CODEC_FLAG_LOW_DELAY);
 666         avctx->delay  = s->low_delay ? 0 : (s->max_b_frames + 1);
 667         break;
 668     case AV_CODEC_ID_MPEG2VIDEO:
 669         s->out_format = FMT_MPEG1;
 670         s->low_delay  = !!(s->flags & CODEC_FLAG_LOW_DELAY);
 671         avctx->delay  = s->low_delay ? 0 : (s->max_b_frames + 1);
 672         s->rtp_mode   = 1;
 673         break;
 674     case AV_CODEC_ID_LJPEG:
 675     case AV_CODEC_ID_MJPEG:
 676     case AV_CODEC_ID_AMV:
 677         s->out_format = FMT_MJPEG;
 678         s->intra_only = 1; /* force intra only for jpeg */
 679         if (avctx->codec->id == AV_CODEC_ID_LJPEG &&
 680             (avctx->pix_fmt == AV_PIX_FMT_BGR0
 681              || s->avctx->pix_fmt == AV_PIX_FMT_BGRA
 682              || s->avctx->pix_fmt == AV_PIX_FMT_BGR24)) {
 683             s->mjpeg_vsample[0] = s->mjpeg_hsample[0] =
 684             s->mjpeg_vsample[1] = s->mjpeg_hsample[1] =
 685             s->mjpeg_vsample[2] = s->mjpeg_hsample[2] = 1;
 686         } else if (avctx->pix_fmt == AV_PIX_FMT_YUV444P || avctx->pix_fmt == AV_PIX_FMT_YUVJ444P) {
 687             s->mjpeg_vsample[0] = s->mjpeg_vsample[1] = s->mjpeg_vsample[2] = 2;
 688             s->mjpeg_hsample[0] = s->mjpeg_hsample[1] = s->mjpeg_hsample[2] = 1;
 689         } else {
 690             s->mjpeg_vsample[0] = 2;
 691             s->mjpeg_vsample[1] = 2 >> chroma_v_shift;
 692             s->mjpeg_vsample[2] = 2 >> chroma_v_shift;
 693             s->mjpeg_hsample[0] = 2;
 694             s->mjpeg_hsample[1] = 2 >> chroma_h_shift;
 695             s->mjpeg_hsample[2] = 2 >> chroma_h_shift;
 696         }
 697         if (!(CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) ||
 698             ff_mjpeg_encode_init(s) < 0)
 699             return -1;
 700         avctx->delay = 0;
 701         s->low_delay = 1;
 702         break;
 703     case AV_CODEC_ID_H261:
 704         if (!CONFIG_H261_ENCODER)
 705             return -1;
 706         if (ff_h261_get_picture_format(s->width, s->height) < 0) {
 707             av_log(avctx, AV_LOG_ERROR,
 708                    "The specified picture size of %dx%d is not valid for the "
 709                    "H.261 codec.\nValid sizes are 176x144, 352x288\n",
 710                     s->width, s->height);
 711             return -1;
 712         }
 713         s->out_format = FMT_H261;
 714         avctx->delay  = 0;
 715         s->low_delay  = 1;
 716         break;
 717     case AV_CODEC_ID_H263:
 718         if (!CONFIG_H263_ENCODER)
 719             return -1;
 720         if (ff_match_2uint16(ff_h263_format, FF_ARRAY_ELEMS(ff_h263_format),
 721                              s->width, s->height) == 8) {
 722             av_log(avctx, AV_LOG_ERROR,
 723                    "The specified picture size of %dx%d is not valid for "
 724                    "the H.263 codec.\nValid sizes are 128x96, 176x144, "
 725                    "352x288, 704x576, and 1408x1152. "
 726                    "Try H.263+.\n", s->width, s->height);
 727             return -1;
 728         }
 729         s->out_format = FMT_H263;
 730         avctx->delay  = 0;
 731         s->low_delay  = 1;
 732         break;
 733     case AV_CODEC_ID_H263P:
 734         s->out_format = FMT_H263;
 735         s->h263_plus  = 1;
 736         /* Fx */
 737         s->h263_aic        = (avctx->flags & CODEC_FLAG_AC_PRED) ? 1 : 0;
 738         s->modified_quant  = s->h263_aic;
 739         s->loop_filter     = (avctx->flags & CODEC_FLAG_LOOP_FILTER) ? 1 : 0;
 740         s->unrestricted_mv = s->obmc || s->loop_filter || s->umvplus;
 741
 742         /* /Fx */
 743         /* These are just to be sure */
 744         avctx->delay = 0;
 745         s->low_delay = 1;
 746         break;
 747     case AV_CODEC_ID_FLV1:
 748         s->out_format      = FMT_H263;
 749         s->h263_flv        = 2; /* format = 1; 11-bit codes */
 750         s->unrestricted_mv = 1;
 751         s->rtp_mode  = 0; /* don't allow GOB */
 752         avctx->delay = 0;
 753         s->low_delay = 1;
 754         break;
 755     case AV_CODEC_ID_RV10:
 756         s->out_format = FMT_H263;
 757         avctx->delay  = 0;
 758         s->low_delay  = 1;
 759         break;
 760     case AV_CODEC_ID_RV20:
 761         s->out_format      = FMT_H263;
 762         avctx->delay       = 0;
 763         s->low_delay       = 1;
 764         s->modified_quant  = 1;
 765         s->h263_aic        = 1;
 766         s->h263_plus       = 1;
 767         s->loop_filter     = 1;
 768         s->unrestricted_mv = 0;
 769         break;
 770     case AV_CODEC_ID_MPEG4:
 771         s->out_format      = FMT_H263;
 772         s->h263_pred       = 1;
 773         s->unrestricted_mv = 1;
 774         s->low_delay       = s->max_b_frames ? 0 : 1;
 775         avctx->delay       = s->low_delay ? 0 : (s->max_b_frames + 1);
 776         break;
 777     case AV_CODEC_ID_MSMPEG4V2:
 778         s->out_format      = FMT_H263;
 779         s->h263_pred       = 1;
 780         s->unrestricted_mv = 1;
 781         s->msmpeg4_version = 2;
 782         avctx->delay       = 0;
 783         s->low_delay       = 1;
 784         break;
 785     case AV_CODEC_ID_MSMPEG4V3:
 786         s->out_format        = FMT_H263;
 787         s->h263_pred         = 1;
 788         s->unrestricted_mv   = 1;
 789         s->msmpeg4_version   = 3;
 790         s->flipflop_rounding = 1;
 791         avctx->delay         = 0;
 792         s->low_delay         = 1;
 793         break;
 794     case AV_CODEC_ID_WMV1:
 795         s->out_format        = FMT_H263;
 796         s->h263_pred         = 1;
 797         s->unrestricted_mv   = 1;
 798         s->msmpeg4_version   = 4;
 799         s->flipflop_rounding = 1;
 800         avctx->delay         = 0;
 801         s->low_delay         = 1;
 802         break;
 803     case AV_CODEC_ID_WMV2:
 804         s->out_format        = FMT_H263;
 805         s->h263_pred         = 1;
 806         s->unrestricted_mv   = 1;
 807         s->msmpeg4_version   = 5;
 808         s->flipflop_rounding = 1;
 809         avctx->delay         = 0;
 810         s->low_delay         = 1;
 811         break;
 812     default:
 813         return -1;
 814     }
 815
 816     avctx->has_b_frames = !s->low_delay;
 817
 818     s->encoding = 1;
 819
 820     s->progressive_frame    =
 821     s->progressive_sequence = !(avctx->flags & (CODEC_FLAG_INTERLACED_DCT |
 822                                                 CODEC_FLAG_INTERLACED_ME) ||
 823                                 s->alternate_scan);
 824
 825     /* init */
 826     if (ff_MPV_common_init(s) < 0)
 827         return -1;
 828
 829     ff_dct_encode_init(s);
 830
 831     if ((CONFIG_H263P_ENCODER || CONFIG_RV20_ENCODER) && s->modified_quant)
 832         s->chroma_qscale_table = ff_h263_chroma_qscale_table;
 833
 834     s->quant_precision = 5;
 835
 836     ff_set_cmp(&s->dsp, s->dsp.ildct_cmp, s->avctx->ildct_cmp);
 837     ff_set_cmp(&s->dsp, s->dsp.frame_skip_cmp, s->avctx->frame_skip_cmp);
 838
 839     if (CONFIG_H261_ENCODER && s->out_format == FMT_H261)
 840         ff_h261_encode_init(s);
 841     if (CONFIG_H263_ENCODER && s->out_format == FMT_H263)
 842         ff_h263_encode_init(s);
 843     if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
 844         ff_msmpeg4_encode_init(s);
 845     if ((CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
 846         && s->out_format == FMT_MPEG1)
 847         ff_mpeg1_encode_init(s);
 848
 849     /* init q matrix */
 850     for (i = 0; i < 64; i++) {
 851         int j = s->dsp.idct_permutation[i];
 852         if (CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4 &&
 853             s->mpeg_quant) {
 854             s->intra_matrix[j] = ff_mpeg4_default_intra_matrix[i];
 855             s->inter_matrix[j] = ff_mpeg4_default_non_intra_matrix[i];
 856         } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
 857             s->intra_matrix[j] =
 858             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
 859         } else {
 860             /* mpeg1/2 */
 861             s->intra_matrix[j] = ff_mpeg1_default_intra_matrix[i];
 862             s->inter_matrix[j] = ff_mpeg1_default_non_intra_matrix[i];
 863         }
 864         if (s->avctx->intra_matrix)
 865             s->intra_matrix[j] = s->avctx->intra_matrix[i];
 866         if (s->avctx->inter_matrix)
 867             s->inter_matrix[j] = s->avctx->inter_matrix[i];
 868     }
 869
 870     /* precompute matrix */
 871     /* for mjpeg, we do include qscale in the matrix */
 872     if (s->out_format != FMT_MJPEG) {
 873         ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
 874                           s->intra_matrix, s->intra_quant_bias, avctx->qmin,
 875                           31, 1);
 876         ff_convert_matrix(&s->dsp, s->q_inter_matrix, s->q_inter_matrix16,
 877                           s->inter_matrix, s->inter_quant_bias, avctx->qmin,
 878                           31, 0);
 879     }
 880
 881     if (ff_rate_control_init(s) < 0)
 882         return -1;
 883
 884     return 0;
 885 }
 886
 887 av_cold int ff_MPV_encode_end(AVCodecContext *avctx)
 888 {
 889     MpegEncContext *s = avctx->priv_data;
 890
 891     ff_rate_control_uninit(s);
 892
 893     ff_MPV_common_end(s);
 894     if ((CONFIG_MJPEG_ENCODER || CONFIG_LJPEG_ENCODER) &&
 895         s->out_format == FMT_MJPEG)
 896         ff_mjpeg_encode_close(s);
 897
 898     av_freep(&avctx->extradata);
 899
 900     return 0;
 901 }
 902
 903 static int get_sae(uint8_t *src, int ref, int stride)
 904 {
 905     int x,y;
 906     int acc = 0;
 907
 908     for (y = 0; y < 16; y++) {
 909         for (x = 0; x < 16; x++) {
 910             acc += FFABS(src[x + y * stride] - ref);
 911         }
 912     }
 913
 914     return acc;
 915 }
 916
 917 static int get_intra_count(MpegEncContext *s, uint8_t *src,
 918                            uint8_t *ref, int stride)
 919 {
 920     int x, y, w, h;
 921     int acc = 0;
 922
 923     w = s->width  & ~15;
 924     h = s->height & ~15;
 925
 926     for (y = 0; y < h; y += 16) {
 927         for (x = 0; x < w; x += 16) {
 928             int offset = x + y * stride;
 929             int sad  = s->dsp.sad[0](NULL, src + offset, ref + offset, stride,
 930                                      16);
 931             int mean = (s->dsp.pix_sum(src + offset, stride) + 128) >> 8;
 932             int sae  = get_sae(src + offset, mean, stride);
 933
 934             acc += sae + 500 < sad;
 935         }
 936     }
 937     return acc;
 938 }
 939
 940
 941 static int load_input_picture(MpegEncContext *s, const AVFrame *pic_arg)
 942 {
 943     Picture *pic = NULL;
 944     int64_t pts;
 945     int i, display_picture_number = 0, ret;
 946     const int encoding_delay = s->max_b_frames ? s->max_b_frames :
 947                                                  (s->low_delay ? 0 : 1);
 948     int direct = 1;
 949
 950     if (pic_arg) {
 951         pts = pic_arg->pts;
 952         display_picture_number = s->input_picture_number++;
 953
 954         if (pts != AV_NOPTS_VALUE) {
 955             if (s->user_specified_pts != AV_NOPTS_VALUE) {
 956                 int64_t last = s->user_specified_pts;
 957
 958                 if (pts <= last) {
 959                     av_log(s->avctx, AV_LOG_ERROR,
 960                            "Invalid pts (%"PRId64") <= last (%"PRId64")\n",
 961                            pts, last);
 962                     return AVERROR(EINVAL);
 963                 }
 964
 965                 if (!s->low_delay && display_picture_number == 1)
 966                     s->dts_delta = pts - last;
 967             }
 968             s->user_specified_pts = pts;
 969         } else {
 970             if (s->user_specified_pts != AV_NOPTS_VALUE) {
 971                 s->user_specified_pts =
 972                 pts = s->user_specified_pts + 1;
 973                 av_log(s->avctx, AV_LOG_INFO,
 974                        "Warning: AVFrame.pts=? trying to guess (%"PRId64")\n",
 975                        pts);
 976             } else {
 977                 pts = display_picture_number;
 978             }
 979         }
 980     }
 981
 982     if (pic_arg) {
 983         if (!pic_arg->buf[0])
 984             direct = 0;
 985         if (pic_arg->linesize[0] != s->linesize)
 986             direct = 0;
 987         if (pic_arg->linesize[1] != s->uvlinesize)
 988             direct = 0;
 989         if (pic_arg->linesize[2] != s->uvlinesize)
 990             direct = 0;
 991
 992         av_dlog(s->avctx, "%d %d %td %td\n", pic_arg->linesize[0],
 993                 pic_arg->linesize[1], s->linesize, s->uvlinesize);
 994
 995         if (direct) {
 996             i = ff_find_unused_picture(s, 1);
 997             if (i < 0)
 998                 return i;
 999
1000             pic = &s->picture[i];
1001             pic->reference = 3;
1002
1003             if ((ret = av_frame_ref(&pic->f, pic_arg)) < 0)
1004                 return ret;
1005             if (ff_alloc_picture(s, pic, 1) < 0) {
1006                 return -1;
1007             }
1008         } else {
1009             i = ff_find_unused_picture(s, 0);
1010             if (i < 0)
1011                 return i;
1012
1013             pic = &s->picture[i];
1014             pic->reference = 3;
1015
1016             if (ff_alloc_picture(s, pic, 0) < 0) {
1017                 return -1;
1018             }
1019
1020             if (pic->f.data[0] + INPLACE_OFFSET == pic_arg->data[0] &&
1021                 pic->f.data[1] + INPLACE_OFFSET == pic_arg->data[1] &&
1022                 pic->f.data[2] + INPLACE_OFFSET == pic_arg->data[2]) {
1023                 // empty
1024             } else {
1025                 int h_chroma_shift, v_chroma_shift;
1026                 av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1027                                                  &h_chroma_shift,
1028                                                  &v_chroma_shift);
1029
1030                 for (i = 0; i < 3; i++) {
1031                     int src_stride = pic_arg->linesize[i];
1032                     int dst_stride = i ? s->uvlinesize : s->linesize;
1033                     int h_shift = i ? h_chroma_shift : 0;
1034                     int v_shift = i ? v_chroma_shift : 0;
1035                     int w = s->width  >> h_shift;
1036                     int h = s->height >> v_shift;
1037                     uint8_t *src = pic_arg->data[i];
1038                     uint8_t *dst = pic->f.data[i];
1039
1040                     if (s->codec_id == AV_CODEC_ID_AMV && !(s->avctx->flags & CODEC_FLAG_EMU_EDGE)) {
1041                         h = ((s->height + 15)/16*16) >> v_shift;
1042                     }
1043
1044                     if (!s->avctx->rc_buffer_size)
1045                         dst += INPLACE_OFFSET;
1046
1047                     if (src_stride == dst_stride)
1048                         memcpy(dst, src, src_stride * h);
1049                     else {
1050                         int h2 = h;
1051                         uint8_t *dst2 = dst;
1052                         while (h2--) {
1053                             memcpy(dst2, src, w);
1054                             dst2 += dst_stride;
1055                             src += src_stride;
1056                         }
1057                     }
1058                     if ((s->width & 15) || (s->height & 15)) {
1059                         s->dsp.draw_edges(dst, dst_stride,
1060                                           w, h,
1061                                           16>>h_shift,
1062                                           16>>v_shift,
1063                                           EDGE_BOTTOM);
1064                     }
1065                 }
1066             }
1067         }
1068         ret = av_frame_copy_props(&pic->f, pic_arg);
1069         if (ret < 0)
1070             return ret;
1071
1072         pic->f.display_picture_number = display_picture_number;
1073         pic->f.pts = pts; // we set this here to avoid modifiying pic_arg
1074     }
1075
1076     /* shift buffer entries */
1077     for (i = 1; i < MAX_PICTURE_COUNT /*s->encoding_delay + 1*/; i++)
1078         s->input_picture[i - 1] = s->input_picture[i];
1079
1080     s->input_picture[encoding_delay] = (Picture*) pic;
1081
1082     return 0;
1083 }
1084
1085 static int skip_check(MpegEncContext *s, Picture *p, Picture *ref)
1086 {
1087     int x, y, plane;
1088     int score = 0;
1089     int64_t score64 = 0;
1090
1091     for (plane = 0; plane < 3; plane++) {
1092         const int stride = p->f.linesize[plane];
1093         const int bw = plane ? 1 : 2;
1094         for (y = 0; y < s->mb_height * bw; y++) {
1095             for (x = 0; x < s->mb_width * bw; x++) {
1096                 int off = p->shared ? 0 : 16;
1097                 uint8_t *dptr = p->f.data[plane] + 8 * (x + y * stride) + off;
1098                 uint8_t *rptr = ref->f.data[plane] + 8 * (x + y * stride);
1099                 int v   = s->dsp.frame_skip_cmp[1](s, dptr, rptr, stride, 8);
1100
1101                 switch (s->avctx->frame_skip_exp) {
1102                 case 0: score    =  FFMAX(score, v);          break;
1103                 case 1: score   += FFABS(v);                  break;
1104                 case 2: score   += v * v;                     break;
1105                 case 3: score64 += FFABS(v * v * (int64_t)v); break;
1106                 case 4: score64 += v * v * (int64_t)(v * v);  break;
1107                 }
1108             }
1109         }
1110     }
1111
1112     if (score)
1113         score64 = score;
1114
1115     if (score64 < s->avctx->frame_skip_threshold)
1116         return 1;
1117     if (score64 < ((s->avctx->frame_skip_factor * (int64_t)s->lambda) >> 8))
1118         return 1;
1119     return 0;
1120 }
1121
1122 static int encode_frame(AVCodecContext *c, AVFrame *frame)
1123 {
1124     AVPacket pkt = { 0 };
1125     int ret, got_output;
1126
1127     av_init_packet(&pkt);
1128     ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
1129     if (ret < 0)
1130         return ret;
1131
1132     ret = pkt.size;
1133     av_free_packet(&pkt);
1134     return ret;
1135 }
1136
1137 static int estimate_best_b_count(MpegEncContext *s)
1138 {
1139     AVCodec *codec    = avcodec_find_encoder(s->avctx->codec_id);
1140     AVCodecContext *c = avcodec_alloc_context3(NULL);
1141     AVFrame input[FF_MAX_B_FRAMES + 2];
1142     const int scale = s->avctx->brd_scale;
1143     int i, j, out_size, p_lambda, b_lambda, lambda2;
1144     int64_t best_rd  = INT64_MAX;
1145     int best_b_count = -1;
1146
1147     av_assert0(scale >= 0 && scale <= 3);
1148
1149     //emms_c();
1150     //s->next_picture_ptr->quality;
1151     p_lambda = s->last_lambda_for[AV_PICTURE_TYPE_P];
1152     //p_lambda * FFABS(s->avctx->b_quant_factor) + s->avctx->b_quant_offset;
1153     b_lambda = s->last_lambda_for[AV_PICTURE_TYPE_B];
1154     if (!b_lambda) // FIXME we should do this somewhere else
1155         b_lambda = p_lambda;
1156     lambda2  = (b_lambda * b_lambda + (1 << FF_LAMBDA_SHIFT) / 2) >>
1157                FF_LAMBDA_SHIFT;
1158
1159     c->width        = s->width  >> scale;
1160     c->height       = s->height >> scale;
1161     c->flags        = CODEC_FLAG_QSCALE | CODEC_FLAG_PSNR |
1162                       CODEC_FLAG_INPUT_PRESERVED /*| CODEC_FLAG_EMU_EDGE*/;
1163     c->flags       |= s->avctx->flags & CODEC_FLAG_QPEL;
1164     c->mb_decision  = s->avctx->mb_decision;
1165     c->me_cmp       = s->avctx->me_cmp;
1166     c->mb_cmp       = s->avctx->mb_cmp;
1167     c->me_sub_cmp   = s->avctx->me_sub_cmp;
1168     c->pix_fmt      = AV_PIX_FMT_YUV420P;
1169     c->time_base    = s->avctx->time_base;
1170     c->max_b_frames = s->max_b_frames;
1171
1172     if (avcodec_open2(c, codec, NULL) < 0)
1173         return -1;
1174
1175     for (i = 0; i < s->max_b_frames + 2; i++) {
1176         int ysize = c->width * c->height;
1177         int csize = (c->width / 2) * (c->height / 2);
1178         Picture pre_input, *pre_input_ptr = i ? s->input_picture[i - 1] :
1179                                                 s->next_picture_ptr;
1180
1181         avcodec_get_frame_defaults(&input[i]);
1182         input[i].data[0]     = av_malloc(ysize + 2 * csize);
1183         input[i].data[1]     = input[i].data[0] + ysize;
1184         input[i].data[2]     = input[i].data[1] + csize;
1185         input[i].linesize[0] = c->width;
1186         input[i].linesize[1] =
1187         input[i].linesize[2] = c->width / 2;
1188
1189         if (pre_input_ptr && (!i || s->input_picture[i - 1])) {
1190             pre_input = *pre_input_ptr;
1191
1192             if (!pre_input.shared && i) {
1193                 pre_input.f.data[0] += INPLACE_OFFSET;
1194                 pre_input.f.data[1] += INPLACE_OFFSET;
1195                 pre_input.f.data[2] += INPLACE_OFFSET;
1196             }
1197
1198             s->dsp.shrink[scale](input[i].data[0], input[i].linesize[0],
1199                                  pre_input.f.data[0], pre_input.f.linesize[0],
1200                                  c->width,      c->height);
1201             s->dsp.shrink[scale](input[i].data[1], input[i].linesize[1],
1202                                  pre_input.f.data[1], pre_input.f.linesize[1],
1203                                  c->width >> 1, c->height >> 1);
1204             s->dsp.shrink[scale](input[i].data[2], input[i].linesize[2],
1205                                  pre_input.f.data[2], pre_input.f.linesize[2],
1206                                  c->width >> 1, c->height >> 1);
1207         }
1208     }
1209
1210     for (j = 0; j < s->max_b_frames + 1; j++) {
1211         int64_t rd = 0;
1212
1213         if (!s->input_picture[j])
1214             break;
1215
1216         c->error[0] = c->error[1] = c->error[2] = 0;
1217
1218         input[0].pict_type = AV_PICTURE_TYPE_I;
1219         input[0].quality   = 1 * FF_QP2LAMBDA;
1220
1221         out_size = encode_frame(c, &input[0]);
1222
1223         //rd += (out_size * lambda2) >> FF_LAMBDA_SHIFT;
1224
1225         for (i = 0; i < s->max_b_frames + 1; i++) {
1226             int is_p = i % (j + 1) == j || i == s->max_b_frames;
1227
1228             input[i + 1].pict_type = is_p ?
1229                                      AV_PICTURE_TYPE_P : AV_PICTURE_TYPE_B;
1230             input[i + 1].quality   = is_p ? p_lambda : b_lambda;
1231
1232             out_size = encode_frame(c, &input[i + 1]);
1233
1234             rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1235         }
1236
1237         /* get the delayed frames */
1238         while (out_size) {
1239             out_size = encode_frame(c, NULL);
1240             rd += (out_size * lambda2) >> (FF_LAMBDA_SHIFT - 3);
1241         }
1242
1243         rd += c->error[0] + c->error[1] + c->error[2];
1244
1245         if (rd < best_rd) {
1246             best_rd = rd;
1247             best_b_count = j;
1248         }
1249     }
1250
1251     avcodec_close(c);
1252     av_freep(&c);
1253
1254     for (i = 0; i < s->max_b_frames + 2; i++) {
1255         av_freep(&input[i].data[0]);
1256     }
1257
1258     return best_b_count;
1259 }
1260
1261 static int select_input_picture(MpegEncContext *s)
1262 {
1263     int i, ret;
1264
1265     for (i = 1; i < MAX_PICTURE_COUNT; i++)
1266         s->reordered_input_picture[i - 1] = s->reordered_input_picture[i];
1267     s->reordered_input_picture[MAX_PICTURE_COUNT - 1] = NULL;
1268
1269     /* set next picture type & ordering */
1270     if (s->reordered_input_picture[0] == NULL && s->input_picture[0]) {
1271         if (/*s->picture_in_gop_number >= s->gop_size ||*/
1272             s->next_picture_ptr == NULL || s->intra_only) {
1273             s->reordered_input_picture[0] = s->input_picture[0];
1274             s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_I;
1275             s->reordered_input_picture[0]->f.coded_picture_number =
1276                 s->coded_picture_number++;
1277         } else {
1278             int b_frames;
1279
1280             if (s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor) {
1281                 if (s->picture_in_gop_number < s->gop_size &&
1282                     skip_check(s, s->input_picture[0], s->next_picture_ptr)) {
1283                     // FIXME check that te gop check above is +-1 correct
1284                     av_frame_unref(&s->input_picture[0]->f);
1285
1286                     emms_c();
1287                     ff_vbv_update(s, 0);
1288
1289                     goto no_output_pic;
1290                 }
1291             }
1292
1293             if (s->flags & CODEC_FLAG_PASS2) {
1294                 for (i = 0; i < s->max_b_frames + 1; i++) {
1295                     int pict_num = s->input_picture[0]->f.display_picture_number + i;
1296
1297                     if (pict_num >= s->rc_context.num_entries)
1298                         break;
1299                     if (!s->input_picture[i]) {
1300                         s->rc_context.entry[pict_num - 1].new_pict_type = AV_PICTURE_TYPE_P;
1301                         break;
1302                     }
1303
1304                     s->input_picture[i]->f.pict_type =
1305                         s->rc_context.entry[pict_num].new_pict_type;
1306                 }
1307             }
1308
1309             if (s->avctx->b_frame_strategy == 0) {
1310                 b_frames = s->max_b_frames;
1311                 while (b_frames && !s->input_picture[b_frames])
1312                     b_frames--;
1313             } else if (s->avctx->b_frame_strategy == 1) {
1314                 for (i = 1; i < s->max_b_frames + 1; i++) {
1315                     if (s->input_picture[i] &&
1316                         s->input_picture[i]->b_frame_score == 0) {
1317                         s->input_picture[i]->b_frame_score =
1318                             get_intra_count(s,
1319                                             s->input_picture[i    ]->f.data[0],
1320                                             s->input_picture[i - 1]->f.data[0],
1321                                             s->linesize) + 1;
1322                     }
1323                 }
1324                 for (i = 0; i < s->max_b_frames + 1; i++) {
1325                     if (s->input_picture[i] == NULL ||
1326                         s->input_picture[i]->b_frame_score - 1 >
1327                             s->mb_num / s->avctx->b_sensitivity)
1328                         break;
1329                 }
1330
1331                 b_frames = FFMAX(0, i - 1);
1332
1333                 /* reset scores */
1334                 for (i = 0; i < b_frames + 1; i++) {
1335                     s->input_picture[i]->b_frame_score = 0;
1336                 }
1337             } else if (s->avctx->b_frame_strategy == 2) {
1338                 b_frames = estimate_best_b_count(s);
1339             } else {
1340                 av_log(s->avctx, AV_LOG_ERROR, "illegal b frame strategy\n");
1341                 b_frames = 0;
1342             }
1343
1344             emms_c();
1345
1346             for (i = b_frames - 1; i >= 0; i--) {
1347                 int type = s->input_picture[i]->f.pict_type;
1348                 if (type && type != AV_PICTURE_TYPE_B)
1349                     b_frames = i;
1350             }
1351             if (s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_B &&
1352                 b_frames == s->max_b_frames) {
1353                 av_log(s->avctx, AV_LOG_ERROR,
1354                        "warning, too many b frames in a row\n");
1355             }
1356
1357             if (s->picture_in_gop_number + b_frames >= s->gop_size) {
1358                 if ((s->mpv_flags & FF_MPV_FLAG_STRICT_GOP) &&
1359                     s->gop_size > s->picture_in_gop_number) {
1360                     b_frames = s->gop_size - s->picture_in_gop_number - 1;
1361                 } else {
1362                     if (s->flags & CODEC_FLAG_CLOSED_GOP)
1363                         b_frames = 0;
1364                     s->input_picture[b_frames]->f.pict_type = AV_PICTURE_TYPE_I;
1365                 }
1366             }
1367
1368             if ((s->flags & CODEC_FLAG_CLOSED_GOP) && b_frames &&
1369                 s->input_picture[b_frames]->f.pict_type == AV_PICTURE_TYPE_I)
1370                 b_frames--;
1371
1372             s->reordered_input_picture[0] = s->input_picture[b_frames];
1373             if (s->reordered_input_picture[0]->f.pict_type != AV_PICTURE_TYPE_I)
1374                 s->reordered_input_picture[0]->f.pict_type = AV_PICTURE_TYPE_P;
1375             s->reordered_input_picture[0]->f.coded_picture_number =
1376                 s->coded_picture_number++;
1377             for (i = 0; i < b_frames; i++) {
1378                 s->reordered_input_picture[i + 1] = s->input_picture[i];
1379                 s->reordered_input_picture[i + 1]->f.pict_type =
1380                     AV_PICTURE_TYPE_B;
1381                 s->reordered_input_picture[i + 1]->f.coded_picture_number =
1382                     s->coded_picture_number++;
1383             }
1384         }
1385     }
1386 no_output_pic:
1387     if (s->reordered_input_picture[0]) {
1388         s->reordered_input_picture[0]->reference =
1389            s->reordered_input_picture[0]->f.pict_type !=
1390                AV_PICTURE_TYPE_B ? 3 : 0;
1391
1392         ff_mpeg_unref_picture(s, &s->new_picture);
1393         if ((ret = ff_mpeg_ref_picture(s, &s->new_picture, s->reordered_input_picture[0])))
1394             return ret;
1395
1396         if (s->reordered_input_picture[0]->shared || s->avctx->rc_buffer_size) {
1397             // input is a shared pix, so we can't modifiy it -> alloc a new
1398             // one & ensure that the shared one is reuseable
1399
1400             Picture *pic;
1401             int i = ff_find_unused_picture(s, 0);
1402             if (i < 0)
1403                 return i;
1404             pic = &s->picture[i];
1405
1406             pic->reference = s->reordered_input_picture[0]->reference;
1407             if (ff_alloc_picture(s, pic, 0) < 0) {
1408                 return -1;
1409             }
1410
1411             ret = av_frame_copy_props(&pic->f, &s->reordered_input_picture[0]->f);
1412             if (ret < 0)
1413                 return ret;
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     ptrdiff_t 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, wrap_y, 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, wrap_c, 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, wrap_c, 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
2576                         if(CONFIG_MPEG4_ENCODER && s->codec_id==AV_CODEC_ID_MPEG4 && s->partitioned_frame){
2577                             ff_mpeg4_init_partitions(s);
2578                         }
2579                     }
2580
2581                     av_assert2((put_bits_count(&s->pb)&7) == 0);
2582                     current_packet_size= put_bits_ptr(&s->pb) - s->ptr_lastgob;
2583
2584                     if(s->avctx->error_rate && s->resync_mb_x + s->resync_mb_y > 0){
2585                         int r= put_bits_count(&s->pb)/8 + s->picture_number + 16 + s->mb_x + s->mb_y;
2586                         int d= 100 / s->avctx->error_rate;
2587                         if(r % d == 0){
2588                             current_packet_size=0;
2589                             s->pb.buf_ptr= s->ptr_lastgob;
2590                             assert(put_bits_ptr(&s->pb) == s->ptr_lastgob);
2591                         }
2592                     }
2593
2594                     if (s->avctx->rtp_callback){
2595                         int number_mb = (mb_y - s->resync_mb_y)*s->mb_width + mb_x - s->resync_mb_x;
2596                         s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, current_packet_size, number_mb);
2597                     }
2598                     update_mb_info(s, 1);
2599
2600                     switch(s->codec_id){
2601                     case AV_CODEC_ID_MPEG4:
2602                         if (CONFIG_MPEG4_ENCODER) {
2603                             ff_mpeg4_encode_video_packet_header(s);
2604                             ff_mpeg4_clean_buffers(s);
2605                         }
2606                     break;
2607                     case AV_CODEC_ID_MPEG1VIDEO:
2608                     case AV_CODEC_ID_MPEG2VIDEO:
2609                         if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER) {
2610                             ff_mpeg1_encode_slice_header(s);
2611                             ff_mpeg1_clean_buffers(s);
2612                         }
2613                     break;
2614                     case AV_CODEC_ID_H263:
2615                     case AV_CODEC_ID_H263P:
2616                         if (CONFIG_H263_ENCODER)
2617                             ff_h263_encode_gob_header(s, mb_y);
2618                     break;
2619                     }
2620
2621                     if(s->flags&CODEC_FLAG_PASS1){
2622                         int bits= put_bits_count(&s->pb);
2623                         s->misc_bits+= bits - s->last_bits;
2624                         s->last_bits= bits;
2625                     }
2626
2627                     s->ptr_lastgob += current_packet_size;
2628                     s->first_slice_line=1;
2629                     s->resync_mb_x=mb_x;
2630                     s->resync_mb_y=mb_y;
2631                 }
2632             }
2633
2634             if(  (s->resync_mb_x   == s->mb_x)
2635                && s->resync_mb_y+1 == s->mb_y){
2636                 s->first_slice_line=0;
2637             }
2638
2639             s->mb_skipped=0;
2640             s->dquant=0; //only for QP_RD
2641
2642             update_mb_info(s, 0);
2643
2644             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
2645                 int next_block=0;
2646                 int pb_bits_count, pb2_bits_count, tex_pb_bits_count;
2647
2648                 copy_context_before_encode(&backup_s, s, -1);
2649                 backup_s.pb= s->pb;
2650                 best_s.data_partitioning= s->data_partitioning;
2651                 best_s.partitioned_frame= s->partitioned_frame;
2652                 if(s->data_partitioning){
2653                     backup_s.pb2= s->pb2;
2654                     backup_s.tex_pb= s->tex_pb;
2655                 }
2656
2657                 if(mb_type&CANDIDATE_MB_TYPE_INTER){
2658                     s->mv_dir = MV_DIR_FORWARD;
2659                     s->mv_type = MV_TYPE_16X16;
2660                     s->mb_intra= 0;
2661                     s->mv[0][0][0] = s->p_mv_table[xy][0];
2662                     s->mv[0][0][1] = s->p_mv_table[xy][1];
2663                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER, pb, pb2, tex_pb,
2664                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2665                 }
2666                 if(mb_type&CANDIDATE_MB_TYPE_INTER_I){
2667                     s->mv_dir = MV_DIR_FORWARD;
2668                     s->mv_type = MV_TYPE_FIELD;
2669                     s->mb_intra= 0;
2670                     for(i=0; i<2; i++){
2671                         j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2672                         s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2673                         s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2674                     }
2675                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER_I, pb, pb2, tex_pb,
2676                                  &dmin, &next_block, 0, 0);
2677                 }
2678                 if(mb_type&CANDIDATE_MB_TYPE_SKIPPED){
2679                     s->mv_dir = MV_DIR_FORWARD;
2680                     s->mv_type = MV_TYPE_16X16;
2681                     s->mb_intra= 0;
2682                     s->mv[0][0][0] = 0;
2683                     s->mv[0][0][1] = 0;
2684                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_SKIPPED, pb, pb2, tex_pb,
2685                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2686                 }
2687                 if(mb_type&CANDIDATE_MB_TYPE_INTER4V){
2688                     s->mv_dir = MV_DIR_FORWARD;
2689                     s->mv_type = MV_TYPE_8X8;
2690                     s->mb_intra= 0;
2691                     for(i=0; i<4; i++){
2692                         s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2693                         s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
2694                     }
2695                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER4V, pb, pb2, tex_pb,
2696                                  &dmin, &next_block, 0, 0);
2697                 }
2698                 if(mb_type&CANDIDATE_MB_TYPE_FORWARD){
2699                     s->mv_dir = MV_DIR_FORWARD;
2700                     s->mv_type = MV_TYPE_16X16;
2701                     s->mb_intra= 0;
2702                     s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2703                     s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2704                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD, pb, pb2, tex_pb,
2705                                  &dmin, &next_block, s->mv[0][0][0], s->mv[0][0][1]);
2706                 }
2707                 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD){
2708                     s->mv_dir = MV_DIR_BACKWARD;
2709                     s->mv_type = MV_TYPE_16X16;
2710                     s->mb_intra= 0;
2711                     s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2712                     s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2713                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD, pb, pb2, tex_pb,
2714                                  &dmin, &next_block, s->mv[1][0][0], s->mv[1][0][1]);
2715                 }
2716                 if(mb_type&CANDIDATE_MB_TYPE_BIDIR){
2717                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2718                     s->mv_type = MV_TYPE_16X16;
2719                     s->mb_intra= 0;
2720                     s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2721                     s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2722                     s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2723                     s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2724                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR, pb, pb2, tex_pb,
2725                                  &dmin, &next_block, 0, 0);
2726                 }
2727                 if(mb_type&CANDIDATE_MB_TYPE_FORWARD_I){
2728                     s->mv_dir = MV_DIR_FORWARD;
2729                     s->mv_type = MV_TYPE_FIELD;
2730                     s->mb_intra= 0;
2731                     for(i=0; i<2; i++){
2732                         j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2733                         s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2734                         s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2735                     }
2736                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_FORWARD_I, pb, pb2, tex_pb,
2737                                  &dmin, &next_block, 0, 0);
2738                 }
2739                 if(mb_type&CANDIDATE_MB_TYPE_BACKWARD_I){
2740                     s->mv_dir = MV_DIR_BACKWARD;
2741                     s->mv_type = MV_TYPE_FIELD;
2742                     s->mb_intra= 0;
2743                     for(i=0; i<2; i++){
2744                         j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
2745                         s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
2746                         s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
2747                     }
2748                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BACKWARD_I, pb, pb2, tex_pb,
2749                                  &dmin, &next_block, 0, 0);
2750                 }
2751                 if(mb_type&CANDIDATE_MB_TYPE_BIDIR_I){
2752                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2753                     s->mv_type = MV_TYPE_FIELD;
2754                     s->mb_intra= 0;
2755                     for(dir=0; dir<2; dir++){
2756                         for(i=0; i<2; i++){
2757                             j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
2758                             s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
2759                             s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
2760                         }
2761                     }
2762                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_BIDIR_I, pb, pb2, tex_pb,
2763                                  &dmin, &next_block, 0, 0);
2764                 }
2765                 if(mb_type&CANDIDATE_MB_TYPE_INTRA){
2766                     s->mv_dir = 0;
2767                     s->mv_type = MV_TYPE_16X16;
2768                     s->mb_intra= 1;
2769                     s->mv[0][0][0] = 0;
2770                     s->mv[0][0][1] = 0;
2771                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTRA, pb, pb2, tex_pb,
2772                                  &dmin, &next_block, 0, 0);
2773                     if(s->h263_pred || s->h263_aic){
2774                         if(best_s.mb_intra)
2775                             s->mbintra_table[mb_x + mb_y*s->mb_stride]=1;
2776                         else
2777                             ff_clean_intra_table_entries(s); //old mode?
2778                     }
2779                 }
2780
2781                 if ((s->mpv_flags & FF_MPV_FLAG_QP_RD) && dmin < INT_MAX) {
2782                     if(best_s.mv_type==MV_TYPE_16X16){ //FIXME move 4mv after QPRD
2783                         const int last_qp= backup_s.qscale;
2784                         int qpi, qp, dc[6];
2785                         int16_t ac[6][16];
2786                         const int mvdir= (best_s.mv_dir&MV_DIR_BACKWARD) ? 1 : 0;
2787                         static const int dquant_tab[4]={-1,1,-2,2};
2788                         int storecoefs = s->mb_intra && s->dc_val[0];
2789
2790                         av_assert2(backup_s.dquant == 0);
2791
2792                         //FIXME intra
2793                         s->mv_dir= best_s.mv_dir;
2794                         s->mv_type = MV_TYPE_16X16;
2795                         s->mb_intra= best_s.mb_intra;
2796                         s->mv[0][0][0] = best_s.mv[0][0][0];
2797                         s->mv[0][0][1] = best_s.mv[0][0][1];
2798                         s->mv[1][0][0] = best_s.mv[1][0][0];
2799                         s->mv[1][0][1] = best_s.mv[1][0][1];
2800
2801                         qpi = s->pict_type == AV_PICTURE_TYPE_B ? 2 : 0;
2802                         for(; qpi<4; qpi++){
2803                             int dquant= dquant_tab[qpi];
2804                             qp= last_qp + dquant;
2805                             if(qp < s->avctx->qmin || qp > s->avctx->qmax)
2806                                 continue;
2807                             backup_s.dquant= dquant;
2808                             if(storecoefs){
2809                                 for(i=0; i<6; i++){
2810                                     dc[i]= s->dc_val[0][ s->block_index[i] ];
2811                                     memcpy(ac[i], s->ac_val[0][s->block_index[i]], sizeof(int16_t)*16);
2812                                 }
2813                             }
2814
2815                             encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2816                                          &dmin, &next_block, s->mv[mvdir][0][0], s->mv[mvdir][0][1]);
2817                             if(best_s.qscale != qp){
2818                                 if(storecoefs){
2819                                     for(i=0; i<6; i++){
2820                                         s->dc_val[0][ s->block_index[i] ]= dc[i];
2821                                         memcpy(s->ac_val[0][s->block_index[i]], ac[i], sizeof(int16_t)*16);
2822                                     }
2823                                 }
2824                             }
2825                         }
2826                     }
2827                 }
2828                 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT){
2829                     int mx= s->b_direct_mv_table[xy][0];
2830                     int my= s->b_direct_mv_table[xy][1];
2831
2832                     backup_s.dquant = 0;
2833                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2834                     s->mb_intra= 0;
2835                     ff_mpeg4_set_direct_mv(s, mx, my);
2836                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2837                                  &dmin, &next_block, mx, my);
2838                 }
2839                 if(CONFIG_MPEG4_ENCODER && mb_type&CANDIDATE_MB_TYPE_DIRECT0){
2840                     backup_s.dquant = 0;
2841                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2842                     s->mb_intra= 0;
2843                     ff_mpeg4_set_direct_mv(s, 0, 0);
2844                     encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_DIRECT, pb, pb2, tex_pb,
2845                                  &dmin, &next_block, 0, 0);
2846                 }
2847                 if (!best_s.mb_intra && s->mpv_flags & FF_MPV_FLAG_SKIP_RD) {
2848                     int coded=0;
2849                     for(i=0; i<6; i++)
2850                         coded |= s->block_last_index[i];
2851                     if(coded){
2852                         int mx,my;
2853                         memcpy(s->mv, best_s.mv, sizeof(s->mv));
2854                         if(CONFIG_MPEG4_ENCODER && best_s.mv_dir & MV_DIRECT){
2855                             mx=my=0; //FIXME find the one we actually used
2856                             ff_mpeg4_set_direct_mv(s, mx, my);
2857                         }else if(best_s.mv_dir&MV_DIR_BACKWARD){
2858                             mx= s->mv[1][0][0];
2859                             my= s->mv[1][0][1];
2860                         }else{
2861                             mx= s->mv[0][0][0];
2862                             my= s->mv[0][0][1];
2863                         }
2864
2865                         s->mv_dir= best_s.mv_dir;
2866                         s->mv_type = best_s.mv_type;
2867                         s->mb_intra= 0;
2868 /*                        s->mv[0][0][0] = best_s.mv[0][0][0];
2869                         s->mv[0][0][1] = best_s.mv[0][0][1];
2870                         s->mv[1][0][0] = best_s.mv[1][0][0];
2871                         s->mv[1][0][1] = best_s.mv[1][0][1];*/
2872                         backup_s.dquant= 0;
2873                         s->skipdct=1;
2874                         encode_mb_hq(s, &backup_s, &best_s, CANDIDATE_MB_TYPE_INTER /* wrong but unused */, pb, pb2, tex_pb,
2875                                         &dmin, &next_block, mx, my);
2876                         s->skipdct=0;
2877                     }
2878                 }
2879
2880                 s->current_picture.qscale_table[xy] = best_s.qscale;
2881
2882                 copy_context_after_encode(s, &best_s, -1);
2883
2884                 pb_bits_count= put_bits_count(&s->pb);
2885                 flush_put_bits(&s->pb);
2886                 avpriv_copy_bits(&backup_s.pb, bit_buf[next_block^1], pb_bits_count);
2887                 s->pb= backup_s.pb;
2888
2889                 if(s->data_partitioning){
2890                     pb2_bits_count= put_bits_count(&s->pb2);
2891                     flush_put_bits(&s->pb2);
2892                     avpriv_copy_bits(&backup_s.pb2, bit_buf2[next_block^1], pb2_bits_count);
2893                     s->pb2= backup_s.pb2;
2894
2895                     tex_pb_bits_count= put_bits_count(&s->tex_pb);
2896                     flush_put_bits(&s->tex_pb);
2897                     avpriv_copy_bits(&backup_s.tex_pb, bit_buf_tex[next_block^1], tex_pb_bits_count);
2898                     s->tex_pb= backup_s.tex_pb;
2899                 }
2900                 s->last_bits= put_bits_count(&s->pb);
2901
2902                 if (CONFIG_H263_ENCODER &&
2903                     s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
2904                     ff_h263_update_motion_val(s);
2905
2906                 if(next_block==0){ //FIXME 16 vs linesize16
2907                     s->hdsp.put_pixels_tab[0][0](s->dest[0], s->rd_scratchpad                     , s->linesize  ,16);
2908                     s->hdsp.put_pixels_tab[1][0](s->dest[1], s->rd_scratchpad + 16*s->linesize    , s->uvlinesize, 8);
2909                     s->hdsp.put_pixels_tab[1][0](s->dest[2], s->rd_scratchpad + 16*s->linesize + 8, s->uvlinesize, 8);
2910                 }
2911
2912                 if(s->avctx->mb_decision == FF_MB_DECISION_BITS)
2913                     ff_MPV_decode_mb(s, s->block);
2914             } else {
2915                 int motion_x = 0, motion_y = 0;
2916                 s->mv_type=MV_TYPE_16X16;
2917                 // only one MB-Type possible
2918
2919                 switch(mb_type){
2920                 case CANDIDATE_MB_TYPE_INTRA:
2921                     s->mv_dir = 0;
2922                     s->mb_intra= 1;
2923                     motion_x= s->mv[0][0][0] = 0;
2924                     motion_y= s->mv[0][0][1] = 0;
2925                     break;
2926                 case CANDIDATE_MB_TYPE_INTER:
2927                     s->mv_dir = MV_DIR_FORWARD;
2928                     s->mb_intra= 0;
2929                     motion_x= s->mv[0][0][0] = s->p_mv_table[xy][0];
2930                     motion_y= s->mv[0][0][1] = s->p_mv_table[xy][1];
2931                     break;
2932                 case CANDIDATE_MB_TYPE_INTER_I:
2933                     s->mv_dir = MV_DIR_FORWARD;
2934                     s->mv_type = MV_TYPE_FIELD;
2935                     s->mb_intra= 0;
2936                     for(i=0; i<2; i++){
2937                         j= s->field_select[0][i] = s->p_field_select_table[i][xy];
2938                         s->mv[0][i][0] = s->p_field_mv_table[i][j][xy][0];
2939                         s->mv[0][i][1] = s->p_field_mv_table[i][j][xy][1];
2940                     }
2941                     break;
2942                 case CANDIDATE_MB_TYPE_INTER4V:
2943                     s->mv_dir = MV_DIR_FORWARD;
2944                     s->mv_type = MV_TYPE_8X8;
2945                     s->mb_intra= 0;
2946                     for(i=0; i<4; i++){
2947                         s->mv[0][i][0] = s->current_picture.motion_val[0][s->block_index[i]][0];
2948                         s->mv[0][i][1] = s->current_picture.motion_val[0][s->block_index[i]][1];
2949                     }
2950                     break;
2951                 case CANDIDATE_MB_TYPE_DIRECT:
2952                     if (CONFIG_MPEG4_ENCODER) {
2953                         s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2954                         s->mb_intra= 0;
2955                         motion_x=s->b_direct_mv_table[xy][0];
2956                         motion_y=s->b_direct_mv_table[xy][1];
2957                         ff_mpeg4_set_direct_mv(s, motion_x, motion_y);
2958                     }
2959                     break;
2960                 case CANDIDATE_MB_TYPE_DIRECT0:
2961                     if (CONFIG_MPEG4_ENCODER) {
2962                         s->mv_dir = MV_DIR_FORWARD|MV_DIR_BACKWARD|MV_DIRECT;
2963                         s->mb_intra= 0;
2964                         ff_mpeg4_set_direct_mv(s, 0, 0);
2965                     }
2966                     break;
2967                 case CANDIDATE_MB_TYPE_BIDIR:
2968                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2969                     s->mb_intra= 0;
2970                     s->mv[0][0][0] = s->b_bidir_forw_mv_table[xy][0];
2971                     s->mv[0][0][1] = s->b_bidir_forw_mv_table[xy][1];
2972                     s->mv[1][0][0] = s->b_bidir_back_mv_table[xy][0];
2973                     s->mv[1][0][1] = s->b_bidir_back_mv_table[xy][1];
2974                     break;
2975                 case CANDIDATE_MB_TYPE_BACKWARD:
2976                     s->mv_dir = MV_DIR_BACKWARD;
2977                     s->mb_intra= 0;
2978                     motion_x= s->mv[1][0][0] = s->b_back_mv_table[xy][0];
2979                     motion_y= s->mv[1][0][1] = s->b_back_mv_table[xy][1];
2980                     break;
2981                 case CANDIDATE_MB_TYPE_FORWARD:
2982                     s->mv_dir = MV_DIR_FORWARD;
2983                     s->mb_intra= 0;
2984                     motion_x= s->mv[0][0][0] = s->b_forw_mv_table[xy][0];
2985                     motion_y= s->mv[0][0][1] = s->b_forw_mv_table[xy][1];
2986                     break;
2987                 case CANDIDATE_MB_TYPE_FORWARD_I:
2988                     s->mv_dir = MV_DIR_FORWARD;
2989                     s->mv_type = MV_TYPE_FIELD;
2990                     s->mb_intra= 0;
2991                     for(i=0; i<2; i++){
2992                         j= s->field_select[0][i] = s->b_field_select_table[0][i][xy];
2993                         s->mv[0][i][0] = s->b_field_mv_table[0][i][j][xy][0];
2994                         s->mv[0][i][1] = s->b_field_mv_table[0][i][j][xy][1];
2995                     }
2996                     break;
2997                 case CANDIDATE_MB_TYPE_BACKWARD_I:
2998                     s->mv_dir = MV_DIR_BACKWARD;
2999                     s->mv_type = MV_TYPE_FIELD;
3000                     s->mb_intra= 0;
3001                     for(i=0; i<2; i++){
3002                         j= s->field_select[1][i] = s->b_field_select_table[1][i][xy];
3003                         s->mv[1][i][0] = s->b_field_mv_table[1][i][j][xy][0];
3004                         s->mv[1][i][1] = s->b_field_mv_table[1][i][j][xy][1];
3005                     }
3006                     break;
3007                 case CANDIDATE_MB_TYPE_BIDIR_I:
3008                     s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
3009                     s->mv_type = MV_TYPE_FIELD;
3010                     s->mb_intra= 0;
3011                     for(dir=0; dir<2; dir++){
3012                         for(i=0; i<2; i++){
3013                             j= s->field_select[dir][i] = s->b_field_select_table[dir][i][xy];
3014                             s->mv[dir][i][0] = s->b_field_mv_table[dir][i][j][xy][0];
3015                             s->mv[dir][i][1] = s->b_field_mv_table[dir][i][j][xy][1];
3016                         }
3017                     }
3018                     break;
3019                 default:
3020                     av_log(s->avctx, AV_LOG_ERROR, "illegal MB type\n");
3021                 }
3022
3023                 encode_mb(s, motion_x, motion_y);
3024
3025                 // RAL: Update last macroblock type
3026                 s->last_mv_dir = s->mv_dir;
3027
3028                 if (CONFIG_H263_ENCODER &&
3029                     s->out_format == FMT_H263 && s->pict_type!=AV_PICTURE_TYPE_B)
3030                     ff_h263_update_motion_val(s);
3031
3032                 ff_MPV_decode_mb(s, s->block);
3033             }
3034
3035             /* clean the MV table in IPS frames for direct mode in B frames */
3036             if(s->mb_intra /* && I,P,S_TYPE */){
3037                 s->p_mv_table[xy][0]=0;
3038                 s->p_mv_table[xy][1]=0;
3039             }
3040
3041             if(s->flags&CODEC_FLAG_PSNR){
3042                 int w= 16;
3043                 int h= 16;
3044
3045                 if(s->mb_x*16 + 16 > s->width ) w= s->width - s->mb_x*16;
3046                 if(s->mb_y*16 + 16 > s->height) h= s->height- s->mb_y*16;
3047
3048                 s->current_picture.f.error[0] += sse(
3049                     s, s->new_picture.f.data[0] + s->mb_x*16 + s->mb_y*s->linesize*16,
3050                     s->dest[0], w, h, s->linesize);
3051                 s->current_picture.f.error[1] += sse(
3052                     s, s->new_picture.f.data[1] + s->mb_x*8  + s->mb_y*s->uvlinesize*chr_h,
3053                     s->dest[1], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3054                 s->current_picture.f.error[2] += sse(
3055                     s, s->new_picture.f.data[2] + s->mb_x*8  + s->mb_y*s->uvlinesize*chr_h,
3056                     s->dest[2], w>>1, h>>s->chroma_y_shift, s->uvlinesize);
3057             }
3058             if(s->loop_filter){
3059                 if(CONFIG_H263_ENCODER && s->out_format == FMT_H263)
3060                     ff_h263_loop_filter(s);
3061             }
3062             av_dlog(s->avctx, "MB %d %d bits\n",
3063                     s->mb_x + s->mb_y * s->mb_stride, put_bits_count(&s->pb));
3064         }
3065     }
3066
3067     //not beautiful here but we must write it before flushing so it has to be here
3068     if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version && s->msmpeg4_version<4 && s->pict_type == AV_PICTURE_TYPE_I)
3069         ff_msmpeg4_encode_ext_header(s);
3070
3071     write_slice_end(s);
3072
3073     /* Send the last GOB if RTP */
3074     if (s->avctx->rtp_callback) {
3075         int number_mb = (mb_y - s->resync_mb_y)*s->mb_width - s->resync_mb_x;
3076         pdif = put_bits_ptr(&s->pb) - s->ptr_lastgob;
3077         /* Call the RTP callback to send the last GOB */
3078         emms_c();
3079         s->avctx->rtp_callback(s->avctx, s->ptr_lastgob, pdif, number_mb);
3080     }
3081
3082     return 0;
3083 }
3084
3085 #define MERGE(field) dst->field += src->field; src->field=0
3086 static void merge_context_after_me(MpegEncContext *dst, MpegEncContext *src){
3087     MERGE(me.scene_change_score);
3088     MERGE(me.mc_mb_var_sum_temp);
3089     MERGE(me.mb_var_sum_temp);
3090 }
3091
3092 static void merge_context_after_encode(MpegEncContext *dst, MpegEncContext *src){
3093     int i;
3094
3095     MERGE(dct_count[0]); //note, the other dct vars are not part of the context
3096     MERGE(dct_count[1]);
3097     MERGE(mv_bits);
3098     MERGE(i_tex_bits);
3099     MERGE(p_tex_bits);
3100     MERGE(i_count);
3101     MERGE(f_count);
3102     MERGE(b_count);
3103     MERGE(skip_count);
3104     MERGE(misc_bits);
3105     MERGE(er.error_count);
3106     MERGE(padding_bug_score);
3107     MERGE(current_picture.f.error[0]);
3108     MERGE(current_picture.f.error[1]);
3109     MERGE(current_picture.f.error[2]);
3110
3111     if(dst->avctx->noise_reduction){
3112         for(i=0; i<64; i++){
3113             MERGE(dct_error_sum[0][i]);
3114             MERGE(dct_error_sum[1][i]);
3115         }
3116     }
3117
3118     assert(put_bits_count(&src->pb) % 8 ==0);
3119     assert(put_bits_count(&dst->pb) % 8 ==0);
3120     avpriv_copy_bits(&dst->pb, src->pb.buf, put_bits_count(&src->pb));
3121     flush_put_bits(&dst->pb);
3122 }
3123
3124 static int estimate_qp(MpegEncContext *s, int dry_run){
3125     if (s->next_lambda){
3126         s->current_picture_ptr->f.quality =
3127         s->current_picture.f.quality = s->next_lambda;
3128         if(!dry_run) s->next_lambda= 0;
3129     } else if (!s->fixed_qscale) {
3130         s->current_picture_ptr->f.quality =
3131         s->current_picture.f.quality = ff_rate_estimate_qscale(s, dry_run);
3132         if (s->current_picture.f.quality < 0)
3133             return -1;
3134     }
3135
3136     if(s->adaptive_quant){
3137         switch(s->codec_id){
3138         case AV_CODEC_ID_MPEG4:
3139             if (CONFIG_MPEG4_ENCODER)
3140                 ff_clean_mpeg4_qscales(s);
3141             break;
3142         case AV_CODEC_ID_H263:
3143         case AV_CODEC_ID_H263P:
3144         case AV_CODEC_ID_FLV1:
3145             if (CONFIG_H263_ENCODER)
3146                 ff_clean_h263_qscales(s);
3147             break;
3148         default:
3149             ff_init_qscale_tab(s);
3150         }
3151
3152         s->lambda= s->lambda_table[0];
3153         //FIXME broken
3154     }else
3155         s->lambda = s->current_picture.f.quality;
3156     update_qscale(s);
3157     return 0;
3158 }
3159
3160 /* must be called before writing the header */
3161 static void set_frame_distances(MpegEncContext * s){
3162     assert(s->current_picture_ptr->f.pts != AV_NOPTS_VALUE);
3163     s->time = s->current_picture_ptr->f.pts * s->avctx->time_base.num;
3164
3165     if(s->pict_type==AV_PICTURE_TYPE_B){
3166         s->pb_time= s->pp_time - (s->last_non_b_time - s->time);
3167         assert(s->pb_time > 0 && s->pb_time < s->pp_time);
3168     }else{
3169         s->pp_time= s->time - s->last_non_b_time;
3170         s->last_non_b_time= s->time;
3171         assert(s->picture_number==0 || s->pp_time > 0);
3172     }
3173 }
3174
3175 static int encode_picture(MpegEncContext *s, int picture_number)
3176 {
3177     int i, ret;
3178     int bits;
3179     int context_count = s->slice_context_count;
3180
3181     s->picture_number = picture_number;
3182
3183     /* Reset the average MB variance */
3184     s->me.mb_var_sum_temp    =
3185     s->me.mc_mb_var_sum_temp = 0;
3186
3187     /* we need to initialize some time vars before we can encode b-frames */
3188     // RAL: Condition added for MPEG1VIDEO
3189     if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO || s->codec_id == AV_CODEC_ID_MPEG2VIDEO || (s->h263_pred && !s->msmpeg4_version))
3190         set_frame_distances(s);
3191     if(CONFIG_MPEG4_ENCODER && s->codec_id == AV_CODEC_ID_MPEG4)
3192         ff_set_mpeg4_time(s);
3193
3194     s->me.scene_change_score=0;
3195
3196 //    s->lambda= s->current_picture_ptr->quality; //FIXME qscale / ... stuff for ME rate distortion
3197
3198     if(s->pict_type==AV_PICTURE_TYPE_I){
3199         if(s->msmpeg4_version >= 3) s->no_rounding=1;
3200         else                        s->no_rounding=0;
3201     }else if(s->pict_type!=AV_PICTURE_TYPE_B){
3202         if(s->flipflop_rounding || s->codec_id == AV_CODEC_ID_H263P || s->codec_id == AV_CODEC_ID_MPEG4)
3203             s->no_rounding ^= 1;
3204     }
3205
3206     if(s->flags & CODEC_FLAG_PASS2){
3207         if (estimate_qp(s,1) < 0)
3208             return -1;
3209         ff_get_2pass_fcode(s);
3210     }else if(!(s->flags & CODEC_FLAG_QSCALE)){
3211         if(s->pict_type==AV_PICTURE_TYPE_B)
3212             s->lambda= s->last_lambda_for[s->pict_type];
3213         else
3214             s->lambda= s->last_lambda_for[s->last_non_b_pict_type];
3215         update_qscale(s);
3216     }
3217
3218     if(s->codec_id != AV_CODEC_ID_AMV){
3219         if(s->q_chroma_intra_matrix   != s->q_intra_matrix  ) av_freep(&s->q_chroma_intra_matrix);
3220         if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
3221         s->q_chroma_intra_matrix   = s->q_intra_matrix;
3222         s->q_chroma_intra_matrix16 = s->q_intra_matrix16;
3223     }
3224
3225     s->mb_intra=0; //for the rate distortion & bit compare functions
3226     for(i=1; i<context_count; i++){
3227         ret = ff_update_duplicate_context(s->thread_context[i], s);
3228         if (ret < 0)
3229             return ret;
3230     }
3231
3232     if(ff_init_me(s)<0)
3233         return -1;
3234
3235     /* Estimate motion for every MB */
3236     if(s->pict_type != AV_PICTURE_TYPE_I){
3237         s->lambda = (s->lambda * s->avctx->me_penalty_compensation + 128)>>8;
3238         s->lambda2= (s->lambda2* (int64_t)s->avctx->me_penalty_compensation + 128)>>8;
3239         if (s->pict_type != AV_PICTURE_TYPE_B) {
3240             if((s->avctx->pre_me && s->last_non_b_pict_type==AV_PICTURE_TYPE_I) || s->avctx->pre_me==2){
3241                 s->avctx->execute(s->avctx, pre_estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3242             }
3243         }
3244
3245         s->avctx->execute(s->avctx, estimate_motion_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3246     }else /* if(s->pict_type == AV_PICTURE_TYPE_I) */{
3247         /* I-Frame */
3248         for(i=0; i<s->mb_stride*s->mb_height; i++)
3249             s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3250
3251         if(!s->fixed_qscale){
3252             /* finding spatial complexity for I-frame rate control */
3253             s->avctx->execute(s->avctx, mb_var_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3254         }
3255     }
3256     for(i=1; i<context_count; i++){
3257         merge_context_after_me(s, s->thread_context[i]);
3258     }
3259     s->current_picture.mc_mb_var_sum= s->current_picture_ptr->mc_mb_var_sum= s->me.mc_mb_var_sum_temp;
3260     s->current_picture.   mb_var_sum= s->current_picture_ptr->   mb_var_sum= s->me.   mb_var_sum_temp;
3261     emms_c();
3262
3263     if(s->me.scene_change_score > s->avctx->scenechange_threshold && s->pict_type == AV_PICTURE_TYPE_P){
3264         s->pict_type= AV_PICTURE_TYPE_I;
3265         for(i=0; i<s->mb_stride*s->mb_height; i++)
3266             s->mb_type[i]= CANDIDATE_MB_TYPE_INTRA;
3267         if(s->msmpeg4_version >= 3)
3268             s->no_rounding=1;
3269         av_dlog(s, "Scene change detected, encoding as I Frame %d %d\n",
3270                 s->current_picture.mb_var_sum, s->current_picture.mc_mb_var_sum);
3271     }
3272
3273     if(!s->umvplus){
3274         if(s->pict_type==AV_PICTURE_TYPE_P || s->pict_type==AV_PICTURE_TYPE_S) {
3275             s->f_code= ff_get_best_fcode(s, s->p_mv_table, CANDIDATE_MB_TYPE_INTER);
3276
3277             if(s->flags & CODEC_FLAG_INTERLACED_ME){
3278                 int a,b;
3279                 a= ff_get_best_fcode(s, s->p_field_mv_table[0][0], CANDIDATE_MB_TYPE_INTER_I); //FIXME field_select
3280                 b= ff_get_best_fcode(s, s->p_field_mv_table[1][1], CANDIDATE_MB_TYPE_INTER_I);
3281                 s->f_code= FFMAX3(s->f_code, a, b);
3282             }
3283
3284             ff_fix_long_p_mvs(s);
3285             ff_fix_long_mvs(s, NULL, 0, s->p_mv_table, s->f_code, CANDIDATE_MB_TYPE_INTER, 0);
3286             if(s->flags & CODEC_FLAG_INTERLACED_ME){
3287                 int j;
3288                 for(i=0; i<2; i++){
3289                     for(j=0; j<2; j++)
3290                         ff_fix_long_mvs(s, s->p_field_select_table[i], j,
3291                                         s->p_field_mv_table[i][j], s->f_code, CANDIDATE_MB_TYPE_INTER_I, 0);
3292                 }
3293             }
3294         }
3295
3296         if(s->pict_type==AV_PICTURE_TYPE_B){
3297             int a, b;
3298
3299             a = ff_get_best_fcode(s, s->b_forw_mv_table, CANDIDATE_MB_TYPE_FORWARD);
3300             b = ff_get_best_fcode(s, s->b_bidir_forw_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3301             s->f_code = FFMAX(a, b);
3302
3303             a = ff_get_best_fcode(s, s->b_back_mv_table, CANDIDATE_MB_TYPE_BACKWARD);
3304             b = ff_get_best_fcode(s, s->b_bidir_back_mv_table, CANDIDATE_MB_TYPE_BIDIR);
3305             s->b_code = FFMAX(a, b);
3306
3307             ff_fix_long_mvs(s, NULL, 0, s->b_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_FORWARD, 1);
3308             ff_fix_long_mvs(s, NULL, 0, s->b_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BACKWARD, 1);
3309             ff_fix_long_mvs(s, NULL, 0, s->b_bidir_forw_mv_table, s->f_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3310             ff_fix_long_mvs(s, NULL, 0, s->b_bidir_back_mv_table, s->b_code, CANDIDATE_MB_TYPE_BIDIR, 1);
3311             if(s->flags & CODEC_FLAG_INTERLACED_ME){
3312                 int dir, j;
3313                 for(dir=0; dir<2; dir++){
3314                     for(i=0; i<2; i++){
3315                         for(j=0; j<2; j++){
3316                             int type= dir ? (CANDIDATE_MB_TYPE_BACKWARD_I|CANDIDATE_MB_TYPE_BIDIR_I)
3317                                           : (CANDIDATE_MB_TYPE_FORWARD_I |CANDIDATE_MB_TYPE_BIDIR_I);
3318                             ff_fix_long_mvs(s, s->b_field_select_table[dir][i], j,
3319                                             s->b_field_mv_table[dir][i][j], dir ? s->b_code : s->f_code, type, 1);
3320                         }
3321                     }
3322                 }
3323             }
3324         }
3325     }
3326
3327     if (estimate_qp(s, 0) < 0)
3328         return -1;
3329
3330     if(s->qscale < 3 && s->max_qcoeff<=128 && s->pict_type==AV_PICTURE_TYPE_I && !(s->flags & CODEC_FLAG_QSCALE))
3331         s->qscale= 3; //reduce clipping problems
3332
3333     if (s->out_format == FMT_MJPEG) {
3334         /* for mjpeg, we do include qscale in the matrix */
3335         for(i=1;i<64;i++){
3336             int j= s->dsp.idct_permutation[i];
3337
3338             s->intra_matrix[j] = av_clip_uint8((ff_mpeg1_default_intra_matrix[i] * s->qscale) >> 3);
3339         }
3340         s->y_dc_scale_table=
3341         s->c_dc_scale_table= ff_mpeg2_dc_scale_table[s->intra_dc_precision];
3342         s->intra_matrix[0] = ff_mpeg2_dc_scale_table[s->intra_dc_precision][8];
3343         ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3344                        s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3345         s->qscale= 8;
3346     }
3347     if(s->codec_id == AV_CODEC_ID_AMV){
3348         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};
3349         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};
3350         for(i=1;i<64;i++){
3351             int j= s->dsp.idct_permutation[ff_zigzag_direct[i]];
3352
3353             s->intra_matrix[j] = sp5x_quant_table[5*2+0][i];
3354             s->chroma_intra_matrix[j] = sp5x_quant_table[5*2+1][i];
3355         }
3356         s->y_dc_scale_table= y;
3357         s->c_dc_scale_table= c;
3358         s->intra_matrix[0] = 13;
3359         s->chroma_intra_matrix[0] = 14;
3360         ff_convert_matrix(&s->dsp, s->q_intra_matrix, s->q_intra_matrix16,
3361                        s->intra_matrix, s->intra_quant_bias, 8, 8, 1);
3362         ff_convert_matrix(&s->dsp, s->q_chroma_intra_matrix, s->q_chroma_intra_matrix16,
3363                        s->chroma_intra_matrix, s->intra_quant_bias, 8, 8, 1);
3364         s->qscale= 8;
3365     }
3366
3367     //FIXME var duplication
3368     s->current_picture_ptr->f.key_frame =
3369     s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I; //FIXME pic_ptr
3370     s->current_picture_ptr->f.pict_type =
3371     s->current_picture.f.pict_type = s->pict_type;
3372
3373     if (s->current_picture.f.key_frame)
3374         s->picture_in_gop_number=0;
3375
3376     s->mb_x = s->mb_y = 0;
3377     s->last_bits= put_bits_count(&s->pb);
3378     switch(s->out_format) {
3379     case FMT_MJPEG:
3380         if (CONFIG_MJPEG_ENCODER)
3381             ff_mjpeg_encode_picture_header(s);
3382         break;
3383     case FMT_H261:
3384         if (CONFIG_H261_ENCODER)
3385             ff_h261_encode_picture_header(s, picture_number);
3386         break;
3387     case FMT_H263:
3388         if (CONFIG_WMV2_ENCODER && s->codec_id == AV_CODEC_ID_WMV2)
3389             ff_wmv2_encode_picture_header(s, picture_number);
3390         else if (CONFIG_MSMPEG4_ENCODER && s->msmpeg4_version)
3391             ff_msmpeg4_encode_picture_header(s, picture_number);
3392         else if (CONFIG_MPEG4_ENCODER && s->h263_pred)
3393             ff_mpeg4_encode_picture_header(s, picture_number);
3394         else if (CONFIG_RV10_ENCODER && s->codec_id == AV_CODEC_ID_RV10)
3395             ff_rv10_encode_picture_header(s, picture_number);
3396         else if (CONFIG_RV20_ENCODER && s->codec_id == AV_CODEC_ID_RV20)
3397             ff_rv20_encode_picture_header(s, picture_number);
3398         else if (CONFIG_FLV_ENCODER && s->codec_id == AV_CODEC_ID_FLV1)
3399             ff_flv_encode_picture_header(s, picture_number);
3400         else if (CONFIG_H263_ENCODER)
3401             ff_h263_encode_picture_header(s, picture_number);
3402         break;
3403     case FMT_MPEG1:
3404         if (CONFIG_MPEG1VIDEO_ENCODER || CONFIG_MPEG2VIDEO_ENCODER)
3405             ff_mpeg1_encode_picture_header(s, picture_number);
3406         break;
3407     default:
3408         av_assert0(0);
3409     }
3410     bits= put_bits_count(&s->pb);
3411     s->header_bits= bits - s->last_bits;
3412
3413     for(i=1; i<context_count; i++){
3414         update_duplicate_context_after_me(s->thread_context[i], s);
3415     }
3416     s->avctx->execute(s->avctx, encode_thread, &s->thread_context[0], NULL, context_count, sizeof(void*));
3417     for(i=1; i<context_count; i++){
3418         merge_context_after_encode(s, s->thread_context[i]);
3419     }
3420     emms_c();
3421     return 0;
3422 }
3423
3424 static void denoise_dct_c(MpegEncContext *s, int16_t *block){
3425     const int intra= s->mb_intra;
3426     int i;
3427
3428     s->dct_count[intra]++;
3429
3430     for(i=0; i<64; i++){
3431         int level= block[i];
3432
3433         if(level){
3434             if(level>0){
3435                 s->dct_error_sum[intra][i] += level;
3436                 level -= s->dct_offset[intra][i];
3437                 if(level<0) level=0;
3438             }else{
3439                 s->dct_error_sum[intra][i] -= level;
3440                 level += s->dct_offset[intra][i];
3441                 if(level>0) level=0;
3442             }
3443             block[i]= level;
3444         }
3445     }
3446 }
3447
3448 static int dct_quantize_trellis_c(MpegEncContext *s,
3449                                   int16_t *block, int n,
3450                                   int qscale, int *overflow){
3451     const int *qmat;
3452     const uint8_t *scantable= s->intra_scantable.scantable;
3453     const uint8_t *perm_scantable= s->intra_scantable.permutated;
3454     int max=0;
3455     unsigned int threshold1, threshold2;
3456     int bias=0;
3457     int run_tab[65];
3458     int level_tab[65];
3459     int score_tab[65];
3460     int survivor[65];
3461     int survivor_count;
3462     int last_run=0;
3463     int last_level=0;
3464     int last_score= 0;
3465     int last_i;
3466     int coeff[2][64];
3467     int coeff_count[64];
3468     int qmul, qadd, start_i, last_non_zero, i, dc;
3469     const int esc_length= s->ac_esc_length;
3470     uint8_t * length;
3471     uint8_t * last_length;
3472     const int lambda= s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
3473
3474     s->dsp.fdct (block);
3475
3476     if(s->dct_error_sum)
3477         s->denoise_dct(s, block);
3478     qmul= qscale*16;
3479     qadd= ((qscale-1)|1)*8;
3480
3481     if (s->mb_intra) {
3482         int q;
3483         if (!s->h263_aic) {
3484             if (n < 4)
3485                 q = s->y_dc_scale;
3486             else
3487                 q = s->c_dc_scale;
3488             q = q << 3;
3489         } else{
3490             /* For AIC we skip quant/dequant of INTRADC */
3491             q = 1 << 3;
3492             qadd=0;
3493         }
3494
3495         /* note: block[0] is assumed to be positive */
3496         block[0] = (block[0] + (q >> 1)) / q;
3497         start_i = 1;
3498         last_non_zero = 0;
3499         qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
3500         if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3501             bias= 1<<(QMAT_SHIFT-1);
3502         length     = s->intra_ac_vlc_length;
3503         last_length= s->intra_ac_vlc_last_length;
3504     } else {
3505         start_i = 0;
3506         last_non_zero = -1;
3507         qmat = s->q_inter_matrix[qscale];
3508         length     = s->inter_ac_vlc_length;
3509         last_length= s->inter_ac_vlc_last_length;
3510     }
3511     last_i= start_i;
3512
3513     threshold1= (1<<QMAT_SHIFT) - bias - 1;
3514     threshold2= (threshold1<<1);
3515
3516     for(i=63; i>=start_i; i--) {
3517         const int j = scantable[i];
3518         int level = block[j] * qmat[j];
3519
3520         if(((unsigned)(level+threshold1))>threshold2){
3521             last_non_zero = i;
3522             break;
3523         }
3524     }
3525
3526     for(i=start_i; i<=last_non_zero; i++) {
3527         const int j = scantable[i];
3528         int level = block[j] * qmat[j];
3529
3530 //        if(   bias+level >= (1<<(QMAT_SHIFT - 3))
3531 //           || bias-level >= (1<<(QMAT_SHIFT - 3))){
3532         if(((unsigned)(level+threshold1))>threshold2){
3533             if(level>0){
3534                 level= (bias + level)>>QMAT_SHIFT;
3535                 coeff[0][i]= level;
3536                 coeff[1][i]= level-1;
3537 //                coeff[2][k]= level-2;
3538             }else{
3539                 level= (bias - level)>>QMAT_SHIFT;
3540                 coeff[0][i]= -level;
3541                 coeff[1][i]= -level+1;
3542 //                coeff[2][k]= -level+2;
3543             }
3544             coeff_count[i]= FFMIN(level, 2);
3545             av_assert2(coeff_count[i]);
3546             max |=level;
3547         }else{
3548             coeff[0][i]= (level>>31)|1;
3549             coeff_count[i]= 1;
3550         }
3551     }
3552
3553     *overflow= s->max_qcoeff < max; //overflow might have happened
3554
3555     if(last_non_zero < start_i){
3556         memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3557         return last_non_zero;
3558     }
3559
3560     score_tab[start_i]= 0;
3561     survivor[0]= start_i;
3562     survivor_count= 1;
3563
3564     for(i=start_i; i<=last_non_zero; i++){
3565         int level_index, j, zero_distortion;
3566         int dct_coeff= FFABS(block[ scantable[i] ]);
3567         int best_score=256*256*256*120;
3568
3569         if (s->dsp.fdct == ff_fdct_ifast)
3570             dct_coeff= (dct_coeff*ff_inv_aanscales[ scantable[i] ]) >> 12;
3571         zero_distortion= dct_coeff*dct_coeff;
3572
3573         for(level_index=0; level_index < coeff_count[i]; level_index++){
3574             int distortion;
3575             int level= coeff[level_index][i];
3576             const int alevel= FFABS(level);
3577             int unquant_coeff;
3578
3579             av_assert2(level);
3580
3581             if(s->out_format == FMT_H263){
3582                 unquant_coeff= alevel*qmul + qadd;
3583             }else{ //MPEG1
3584                 j= s->dsp.idct_permutation[ scantable[i] ]; //FIXME optimize
3585                 if(s->mb_intra){
3586                         unquant_coeff = (int)(  alevel  * qscale * s->intra_matrix[j]) >> 3;
3587                         unquant_coeff =   (unquant_coeff - 1) | 1;
3588                 }else{
3589                         unquant_coeff = (((  alevel  << 1) + 1) * qscale * ((int) s->inter_matrix[j])) >> 4;
3590                         unquant_coeff =   (unquant_coeff - 1) | 1;
3591                 }
3592                 unquant_coeff<<= 3;
3593             }
3594
3595             distortion= (unquant_coeff - dct_coeff) * (unquant_coeff - dct_coeff) - zero_distortion;
3596             level+=64;
3597             if((level&(~127)) == 0){
3598                 for(j=survivor_count-1; j>=0; j--){
3599                     int run= i - survivor[j];
3600                     int score= distortion + length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3601                     score += score_tab[i-run];
3602
3603                     if(score < best_score){
3604                         best_score= score;
3605                         run_tab[i+1]= run;
3606                         level_tab[i+1]= level-64;
3607                     }
3608                 }
3609
3610                 if(s->out_format == FMT_H263){
3611                     for(j=survivor_count-1; j>=0; j--){
3612                         int run= i - survivor[j];
3613                         int score= distortion + last_length[UNI_AC_ENC_INDEX(run, level)]*lambda;
3614                         score += score_tab[i-run];
3615                         if(score < last_score){
3616                             last_score= score;
3617                             last_run= run;
3618                             last_level= level-64;
3619                             last_i= i+1;
3620                         }
3621                     }
3622                 }
3623             }else{
3624                 distortion += esc_length*lambda;
3625                 for(j=survivor_count-1; j>=0; j--){
3626                     int run= i - survivor[j];
3627                     int score= distortion + score_tab[i-run];
3628
3629                     if(score < best_score){
3630                         best_score= score;
3631                         run_tab[i+1]= run;
3632                         level_tab[i+1]= level-64;
3633                     }
3634                 }
3635
3636                 if(s->out_format == FMT_H263){
3637                   for(j=survivor_count-1; j>=0; j--){
3638                         int run= i - survivor[j];
3639                         int score= distortion + score_tab[i-run];
3640                         if(score < last_score){
3641                             last_score= score;
3642                             last_run= run;
3643                             last_level= level-64;
3644                             last_i= i+1;
3645                         }
3646                     }
3647                 }
3648             }
3649         }
3650
3651         score_tab[i+1]= best_score;
3652
3653         //Note: there is a vlc code in mpeg4 which is 1 bit shorter then another one with a shorter run and the same level
3654         if(last_non_zero <= 27){
3655             for(; survivor_count; survivor_count--){
3656                 if(score_tab[ survivor[survivor_count-1] ] <= best_score)
3657                     break;
3658             }
3659         }else{
3660             for(; survivor_count; survivor_count--){
3661                 if(score_tab[ survivor[survivor_count-1] ] <= best_score + lambda)
3662                     break;
3663             }
3664         }
3665
3666         survivor[ survivor_count++ ]= i+1;
3667     }
3668
3669     if(s->out_format != FMT_H263){
3670         last_score= 256*256*256*120;
3671         for(i= survivor[0]; i<=last_non_zero + 1; i++){
3672             int score= score_tab[i];
3673             if(i) score += lambda*2; //FIXME exacter?
3674
3675             if(score < last_score){
3676                 last_score= score;
3677                 last_i= i;
3678                 last_level= level_tab[i];
3679                 last_run= run_tab[i];
3680             }
3681         }
3682     }
3683
3684     s->coded_score[n] = last_score;
3685
3686     dc= FFABS(block[0]);
3687     last_non_zero= last_i - 1;
3688     memset(block + start_i, 0, (64-start_i)*sizeof(int16_t));
3689
3690     if(last_non_zero < start_i)
3691         return last_non_zero;
3692
3693     if(last_non_zero == 0 && start_i == 0){
3694         int best_level= 0;
3695         int best_score= dc * dc;
3696
3697         for(i=0; i<coeff_count[0]; i++){
3698             int level= coeff[i][0];
3699             int alevel= FFABS(level);
3700             int unquant_coeff, score, distortion;
3701
3702             if(s->out_format == FMT_H263){
3703                     unquant_coeff= (alevel*qmul + qadd)>>3;
3704             }else{ //MPEG1
3705                     unquant_coeff = (((  alevel  << 1) + 1) * qscale * ((int) s->inter_matrix[0])) >> 4;
3706                     unquant_coeff =   (unquant_coeff - 1) | 1;
3707             }
3708             unquant_coeff = (unquant_coeff + 4) >> 3;
3709             unquant_coeff<<= 3 + 3;
3710
3711             distortion= (unquant_coeff - dc) * (unquant_coeff - dc);
3712             level+=64;
3713             if((level&(~127)) == 0) score= distortion + last_length[UNI_AC_ENC_INDEX(0, level)]*lambda;
3714             else                    score= distortion + esc_length*lambda;
3715
3716             if(score < best_score){
3717                 best_score= score;
3718                 best_level= level - 64;
3719             }
3720         }
3721         block[0]= best_level;
3722         s->coded_score[n] = best_score - dc*dc;
3723         if(best_level == 0) return -1;
3724         else                return last_non_zero;
3725     }
3726
3727     i= last_i;
3728     av_assert2(last_level);
3729
3730     block[ perm_scantable[last_non_zero] ]= last_level;
3731     i -= last_run + 1;
3732
3733     for(; i>start_i; i -= run_tab[i] + 1){
3734         block[ perm_scantable[i-1] ]= level_tab[i];
3735     }
3736
3737     return last_non_zero;
3738 }
3739
3740 //#define REFINE_STATS 1
3741 static int16_t basis[64][64];
3742
3743 static void build_basis(uint8_t *perm){
3744     int i, j, x, y;
3745     emms_c();
3746     for(i=0; i<8; i++){
3747         for(j=0; j<8; j++){
3748             for(y=0; y<8; y++){
3749                 for(x=0; x<8; x++){
3750                     double s= 0.25*(1<<BASIS_SHIFT);
3751                     int index= 8*i + j;
3752                     int perm_index= perm[index];
3753                     if(i==0) s*= sqrt(0.5);
3754                     if(j==0) s*= sqrt(0.5);
3755                     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)));
3756                 }
3757             }
3758         }
3759     }
3760 }
3761
3762 static int dct_quantize_refine(MpegEncContext *s, //FIXME breaks denoise?
3763                         int16_t *block, int16_t *weight, int16_t *orig,
3764                         int n, int qscale){
3765     int16_t rem[64];
3766     LOCAL_ALIGNED_16(int16_t, d1, [64]);
3767     const uint8_t *scantable= s->intra_scantable.scantable;
3768     const uint8_t *perm_scantable= s->intra_scantable.permutated;
3769 //    unsigned int threshold1, threshold2;
3770 //    int bias=0;
3771     int run_tab[65];
3772     int prev_run=0;
3773     int prev_level=0;
3774     int qmul, qadd, start_i, last_non_zero, i, dc;
3775     uint8_t * length;
3776     uint8_t * last_length;
3777     int lambda;
3778     int rle_index, run, q = 1, sum; //q is only used when s->mb_intra is true
3779 #ifdef REFINE_STATS
3780 static int count=0;
3781 static int after_last=0;
3782 static int to_zero=0;
3783 static int from_zero=0;
3784 static int raise=0;
3785 static int lower=0;
3786 static int messed_sign=0;
3787 #endif
3788
3789     if(basis[0][0] == 0)
3790         build_basis(s->dsp.idct_permutation);
3791
3792     qmul= qscale*2;
3793     qadd= (qscale-1)|1;
3794     if (s->mb_intra) {
3795         if (!s->h263_aic) {
3796             if (n < 4)
3797                 q = s->y_dc_scale;
3798             else
3799                 q = s->c_dc_scale;
3800         } else{
3801             /* For AIC we skip quant/dequant of INTRADC */
3802             q = 1;
3803             qadd=0;
3804         }
3805         q <<= RECON_SHIFT-3;
3806         /* note: block[0] is assumed to be positive */
3807         dc= block[0]*q;
3808 //        block[0] = (block[0] + (q >> 1)) / q;
3809         start_i = 1;
3810 //        if(s->mpeg_quant || s->out_format == FMT_MPEG1)
3811 //            bias= 1<<(QMAT_SHIFT-1);
3812         length     = s->intra_ac_vlc_length;
3813         last_length= s->intra_ac_vlc_last_length;
3814     } else {
3815         dc= 0;
3816         start_i = 0;
3817         length     = s->inter_ac_vlc_length;
3818         last_length= s->inter_ac_vlc_last_length;
3819     }
3820     last_non_zero = s->block_last_index[n];
3821
3822 #ifdef REFINE_STATS
3823 {START_TIMER
3824 #endif
3825     dc += (1<<(RECON_SHIFT-1));
3826     for(i=0; i<64; i++){
3827         rem[i]= dc - (orig[i]<<RECON_SHIFT); //FIXME  use orig dirrectly instead of copying to rem[]
3828     }
3829 #ifdef REFINE_STATS
3830 STOP_TIMER("memset rem[]")}
3831 #endif
3832     sum=0;
3833     for(i=0; i<64; i++){
3834         int one= 36;
3835         int qns=4;
3836         int w;
3837
3838         w= FFABS(weight[i]) + qns*one;
3839         w= 15 + (48*qns*one + w/2)/w; // 16 .. 63
3840
3841         weight[i] = w;
3842 //        w=weight[i] = (63*qns + (w/2)) / w;
3843
3844         av_assert2(w>0);
3845         av_assert2(w<(1<<6));
3846         sum += w*w;
3847     }
3848     lambda= sum*(uint64_t)s->lambda2 >> (FF_LAMBDA_SHIFT - 6 + 6 + 6 + 6);
3849 #ifdef REFINE_STATS
3850 {START_TIMER
3851 #endif
3852     run=0;
3853     rle_index=0;
3854     for(i=start_i; i<=last_non_zero; i++){
3855         int j= perm_scantable[i];
3856         const int level= block[j];
3857         int coeff;
3858
3859         if(level){
3860             if(level<0) coeff= qmul*level - qadd;
3861             else        coeff= qmul*level + qadd;
3862             run_tab[rle_index++]=run;
3863             run=0;
3864
3865             s->dsp.add_8x8basis(rem, basis[j], coeff);
3866         }else{
3867             run++;
3868         }
3869     }
3870 #ifdef REFINE_STATS
3871 if(last_non_zero>0){
3872 STOP_TIMER("init rem[]")
3873 }
3874 }
3875
3876 {START_TIMER
3877 #endif
3878     for(;;){
3879         int best_score=s->dsp.try_8x8basis(rem, weight, basis[0], 0);
3880         int best_coeff=0;
3881         int best_change=0;
3882         int run2, best_unquant_change=0, analyze_gradient;
3883 #ifdef REFINE_STATS
3884 {START_TIMER
3885 #endif
3886         analyze_gradient = last_non_zero > 2 || s->quantizer_noise_shaping >= 3;
3887
3888         if(analyze_gradient){
3889 #ifdef REFINE_STATS
3890 {START_TIMER
3891 #endif
3892             for(i=0; i<64; i++){
3893                 int w= weight[i];
3894
3895                 d1[i] = (rem[i]*w*w + (1<<(RECON_SHIFT+12-1)))>>(RECON_SHIFT+12);
3896             }
3897 #ifdef REFINE_STATS
3898 STOP_TIMER("rem*w*w")}
3899 {START_TIMER
3900 #endif
3901             s->dsp.fdct(d1);
3902 #ifdef REFINE_STATS
3903 STOP_TIMER("dct")}
3904 #endif
3905         }
3906
3907         if(start_i){
3908             const int level= block[0];
3909             int change, old_coeff;
3910
3911             av_assert2(s->mb_intra);
3912
3913             old_coeff= q*level;
3914
3915             for(change=-1; change<=1; change+=2){
3916                 int new_level= level + change;
3917                 int score, new_coeff;
3918
3919                 new_coeff= q*new_level;
3920                 if(new_coeff >= 2048 || new_coeff < 0)
3921                     continue;
3922
3923                 score= s->dsp.try_8x8basis(rem, weight, basis[0], new_coeff - old_coeff);
3924                 if(score<best_score){
3925                     best_score= score;
3926                     best_coeff= 0;
3927                     best_change= change;
3928                     best_unquant_change= new_coeff - old_coeff;
3929                 }
3930             }
3931         }
3932
3933         run=0;
3934         rle_index=0;
3935         run2= run_tab[rle_index++];
3936         prev_level=0;
3937         prev_run=0;
3938
3939         for(i=start_i; i<64; i++){
3940             int j= perm_scantable[i];
3941             const int level= block[j];
3942             int change, old_coeff;
3943
3944             if(s->quantizer_noise_shaping < 3 && i > last_non_zero + 1)
3945                 break;
3946
3947             if(level){
3948                 if(level<0) old_coeff= qmul*level - qadd;
3949                 else        old_coeff= qmul*level + qadd;
3950                 run2= run_tab[rle_index++]; //FIXME ! maybe after last
3951             }else{
3952                 old_coeff=0;
3953                 run2--;
3954                 av_assert2(run2>=0 || i >= last_non_zero );
3955             }
3956
3957             for(change=-1; change<=1; change+=2){
3958                 int new_level= level + change;
3959                 int score, new_coeff, unquant_change;
3960
3961                 score=0;
3962                 if(s->quantizer_noise_shaping < 2 && FFABS(new_level) > FFABS(level))
3963                    continue;
3964
3965                 if(new_level){
3966                     if(new_level<0) new_coeff= qmul*new_level - qadd;
3967                     else            new_coeff= qmul*new_level + qadd;
3968                     if(new_coeff >= 2048 || new_coeff <= -2048)
3969                         continue;
3970                     //FIXME check for overflow
3971
3972                     if(level){
3973                         if(level < 63 && level > -63){
3974                             if(i < last_non_zero)
3975                                 score +=   length[UNI_AC_ENC_INDEX(run, new_level+64)]
3976                                          - length[UNI_AC_ENC_INDEX(run, level+64)];
3977                             else
3978                                 score +=   last_length[UNI_AC_ENC_INDEX(run, new_level+64)]
3979                                          - last_length[UNI_AC_ENC_INDEX(run, level+64)];
3980                         }
3981                     }else{
3982                         av_assert2(FFABS(new_level)==1);
3983
3984                         if(analyze_gradient){
3985                             int g= d1[ scantable[i] ];
3986                             if(g && (g^new_level) >= 0)
3987                                 continue;
3988                         }
3989
3990                         if(i < last_non_zero){
3991                             int next_i= i + run2 + 1;
3992                             int next_level= block[ perm_scantable[next_i] ] + 64;
3993
3994                             if(next_level&(~127))
3995                                 next_level= 0;
3996
3997                             if(next_i < last_non_zero)
3998                                 score +=   length[UNI_AC_ENC_INDEX(run, 65)]
3999                                          + length[UNI_AC_ENC_INDEX(run2, next_level)]
4000                                          - length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4001                             else
4002                                 score +=  length[UNI_AC_ENC_INDEX(run, 65)]
4003                                         + last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4004                                         - last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)];
4005                         }else{
4006                             score += last_length[UNI_AC_ENC_INDEX(run, 65)];
4007                             if(prev_level){
4008                                 score +=  length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4009                                         - last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4010                             }
4011                         }
4012                     }
4013                 }else{
4014                     new_coeff=0;
4015                     av_assert2(FFABS(level)==1);
4016
4017                     if(i < last_non_zero){
4018                         int next_i= i + run2 + 1;
4019                         int next_level= block[ perm_scantable[next_i] ] + 64;
4020
4021                         if(next_level&(~127))
4022                             next_level= 0;
4023
4024                         if(next_i < last_non_zero)
4025                             score +=   length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4026                                      - length[UNI_AC_ENC_INDEX(run2, next_level)]
4027                                      - length[UNI_AC_ENC_INDEX(run, 65)];
4028                         else
4029                             score +=   last_length[UNI_AC_ENC_INDEX(run + run2 + 1, next_level)]
4030                                      - last_length[UNI_AC_ENC_INDEX(run2, next_level)]
4031                                      - length[UNI_AC_ENC_INDEX(run, 65)];
4032                     }else{
4033                         score += -last_length[UNI_AC_ENC_INDEX(run, 65)];
4034                         if(prev_level){
4035                             score +=  last_length[UNI_AC_ENC_INDEX(prev_run, prev_level)]
4036                                     - length[UNI_AC_ENC_INDEX(prev_run, prev_level)];
4037                         }
4038                     }
4039                 }
4040
4041                 score *= lambda;
4042
4043                 unquant_change= new_coeff - old_coeff;
4044                 av_assert2((score < 100*lambda && score > -100*lambda) || lambda==0);
4045
4046                 score+= s->dsp.try_8x8basis(rem, weight, basis[j], unquant_change);
4047                 if(score<best_score){
4048                     best_score= score;
4049                     best_coeff= i;
4050                     best_change= change;
4051                     best_unquant_change= unquant_change;
4052                 }
4053             }
4054             if(level){
4055                 prev_level= level + 64;
4056                 if(prev_level&(~127))
4057                     prev_level= 0;
4058                 prev_run= run;
4059                 run=0;
4060             }else{
4061                 run++;
4062             }
4063         }
4064 #ifdef REFINE_STATS
4065 STOP_TIMER("iterative step")}
4066 #endif
4067
4068         if(best_change){
4069             int j= perm_scantable[ best_coeff ];
4070
4071             block[j] += best_change;
4072
4073             if(best_coeff > last_non_zero){
4074                 last_non_zero= best_coeff;
4075                 av_assert2(block[j]);
4076 #ifdef REFINE_STATS
4077 after_last++;
4078 #endif
4079             }else{
4080 #ifdef REFINE_STATS
4081 if(block[j]){
4082     if(block[j] - best_change){
4083         if(FFABS(block[j]) > FFABS(block[j] - best_change)){
4084             raise++;
4085         }else{
4086             lower++;
4087         }
4088     }else{
4089         from_zero++;
4090     }
4091 }else{
4092     to_zero++;
4093 }
4094 #endif
4095                 for(; last_non_zero>=start_i; last_non_zero--){
4096                     if(block[perm_scantable[last_non_zero]])
4097                         break;
4098                 }
4099             }
4100 #ifdef REFINE_STATS
4101 count++;
4102 if(256*256*256*64 % count == 0){
4103     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);
4104 }
4105 #endif
4106             run=0;
4107             rle_index=0;
4108             for(i=start_i; i<=last_non_zero; i++){
4109                 int j= perm_scantable[i];
4110                 const int level= block[j];
4111
4112                  if(level){
4113                      run_tab[rle_index++]=run;
4114                      run=0;
4115                  }else{
4116                      run++;
4117                  }
4118             }
4119
4120             s->dsp.add_8x8basis(rem, basis[j], best_unquant_change);
4121         }else{
4122             break;
4123         }
4124     }
4125 #ifdef REFINE_STATS
4126 if(last_non_zero>0){
4127 STOP_TIMER("iterative search")
4128 }
4129 }
4130 #endif
4131
4132     return last_non_zero;
4133 }
4134
4135 int ff_dct_quantize_c(MpegEncContext *s,
4136                         int16_t *block, int n,
4137                         int qscale, int *overflow)
4138 {
4139     int i, j, level, last_non_zero, q, start_i;
4140     const int *qmat;
4141     const uint8_t *scantable= s->intra_scantable.scantable;
4142     int bias;
4143     int max=0;
4144     unsigned int threshold1, threshold2;
4145
4146     s->dsp.fdct (block);
4147
4148     if(s->dct_error_sum)
4149         s->denoise_dct(s, block);
4150
4151     if (s->mb_intra) {
4152         if (!s->h263_aic) {
4153             if (n < 4)
4154                 q = s->y_dc_scale;
4155             else
4156                 q = s->c_dc_scale;
4157             q = q << 3;
4158         } else
4159             /* For AIC we skip quant/dequant of INTRADC */
4160             q = 1 << 3;
4161
4162         /* note: block[0] is assumed to be positive */
4163         block[0] = (block[0] + (q >> 1)) / q;
4164         start_i = 1;
4165         last_non_zero = 0;
4166         qmat = n < 4 ? s->q_intra_matrix[qscale] : s->q_chroma_intra_matrix[qscale];
4167         bias= s->intra_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4168     } else {
4169         start_i = 0;
4170         last_non_zero = -1;
4171         qmat = s->q_inter_matrix[qscale];
4172         bias= s->inter_quant_bias<<(QMAT_SHIFT - QUANT_BIAS_SHIFT);
4173     }
4174     threshold1= (1<<QMAT_SHIFT) - bias - 1;
4175     threshold2= (threshold1<<1);
4176     for(i=63;i>=start_i;i--) {
4177         j = scantable[i];
4178         level = block[j] * qmat[j];
4179
4180         if(((unsigned)(level+threshold1))>threshold2){
4181             last_non_zero = i;
4182             break;
4183         }else{
4184             block[j]=0;
4185         }
4186     }
4187     for(i=start_i; i<=last_non_zero; i++) {
4188         j = scantable[i];
4189         level = block[j] * qmat[j];
4190
4191 //        if(   bias+level >= (1<<QMAT_SHIFT)
4192 //           || bias-level >= (1<<QMAT_SHIFT)){
4193         if(((unsigned)(level+threshold1))>threshold2){
4194             if(level>0){
4195                 level= (bias + level)>>QMAT_SHIFT;
4196                 block[j]= level;
4197             }else{
4198                 level= (bias - level)>>QMAT_SHIFT;
4199                 block[j]= -level;
4200             }
4201             max |=level;
4202         }else{
4203             block[j]=0;
4204         }
4205     }
4206     *overflow= s->max_qcoeff < max; //overflow might have happened
4207
4208     /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */
4209     if (s->dsp.idct_permutation_type != FF_NO_IDCT_PERM)
4210         ff_block_permute(block, s->dsp.idct_permutation, scantable, last_non_zero);
4211
4212     return last_non_zero;
4213 }
4214
4215 #define OFFSET(x) offsetof(MpegEncContext, x)
4216 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
4217 static const AVOption h263_options[] = {
4218     { "obmc",         "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4219     { "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},
4220     { "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 },
4221     FF_MPV_COMMON_OPTS
4222     { NULL },
4223 };
4224
4225 static const AVClass h263_class = {
4226     .class_name = "H.263 encoder",
4227     .item_name  = av_default_item_name,
4228     .option     = h263_options,
4229     .version    = LIBAVUTIL_VERSION_INT,
4230 };
4231
4232 AVCodec ff_h263_encoder = {
4233     .name           = "h263",
4234     .long_name      = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
4235     .type           = AVMEDIA_TYPE_VIDEO,
4236     .id             = AV_CODEC_ID_H263,
4237     .priv_data_size = sizeof(MpegEncContext),
4238     .init           = ff_MPV_encode_init,
4239     .encode2        = ff_MPV_encode_picture,
4240     .close          = ff_MPV_encode_end,
4241     .pix_fmts= (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},
4242     .priv_class     = &h263_class,
4243 };
4244
4245 static const AVOption h263p_options[] = {
4246     { "umv",        "Use unlimited motion vectors.",    OFFSET(umvplus), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4247     { "aiv",        "Use alternative inter VLC.",       OFFSET(alt_inter_vlc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4248     { "obmc",       "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
4249     { "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},
4250     FF_MPV_COMMON_OPTS
4251     { NULL },
4252 };
4253 static const AVClass h263p_class = {
4254     .class_name = "H.263p encoder",
4255     .item_name  = av_default_item_name,
4256     .option     = h263p_options,
4257     .version    = LIBAVUTIL_VERSION_INT,
4258 };
4259
4260 AVCodec ff_h263p_encoder = {
4261     .name           = "h263p",
4262     .long_name      = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
4263     .type           = AVMEDIA_TYPE_VIDEO,
4264     .id             = AV_CODEC_ID_H263P,
4265     .priv_data_size = sizeof(MpegEncContext),
4266     .init           = ff_MPV_encode_init,
4267     .encode2        = ff_MPV_encode_picture,
4268     .close          = ff_MPV_encode_end,
4269     .capabilities   = CODEC_CAP_SLICE_THREADS,
4270     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4271     .priv_class     = &h263p_class,
4272 };
4273
4274 FF_MPV_GENERIC_CLASS(msmpeg4v2)
4275
4276 AVCodec ff_msmpeg4v2_encoder = {
4277     .name           = "msmpeg4v2",
4278     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"),
4279     .type           = AVMEDIA_TYPE_VIDEO,
4280     .id             = AV_CODEC_ID_MSMPEG4V2,
4281     .priv_data_size = sizeof(MpegEncContext),
4282     .init           = ff_MPV_encode_init,
4283     .encode2        = ff_MPV_encode_picture,
4284     .close          = ff_MPV_encode_end,
4285     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4286     .priv_class     = &msmpeg4v2_class,
4287 };
4288
4289 FF_MPV_GENERIC_CLASS(msmpeg4v3)
4290
4291 AVCodec ff_msmpeg4v3_encoder = {
4292     .name           = "msmpeg4",
4293     .long_name      = NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"),
4294     .type           = AVMEDIA_TYPE_VIDEO,
4295     .id             = AV_CODEC_ID_MSMPEG4V3,
4296     .priv_data_size = sizeof(MpegEncContext),
4297     .init           = ff_MPV_encode_init,
4298     .encode2        = ff_MPV_encode_picture,
4299     .close          = ff_MPV_encode_end,
4300     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4301     .priv_class     = &msmpeg4v3_class,
4302 };
4303
4304 FF_MPV_GENERIC_CLASS(wmv1)
4305
4306 AVCodec ff_wmv1_encoder = {
4307     .name           = "wmv1",
4308     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 7"),
4309     .type           = AVMEDIA_TYPE_VIDEO,
4310     .id             = AV_CODEC_ID_WMV1,
4311     .priv_data_size = sizeof(MpegEncContext),
4312     .init           = ff_MPV_encode_init,
4313     .encode2        = ff_MPV_encode_picture,
4314     .close          = ff_MPV_encode_end,
4315     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
4316     .priv_class     = &wmv1_class,
4317 };