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