git.sesse.net Git - ffmpeg/blob - libavcodec/mpegvideo_enc.c

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