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