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