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

Generated by: LCOV version 1.13