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