LCOV - code coverage report
Current view: top level - libavcodec - mpegvideo_enc.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 2012 2901 69.4 %
Date: 2018-05-20 11:54:08 Functions: 38 50 76.0 %

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

Generated by: LCOV version 1.13