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