LCOV - code coverage report
Current view: top level - libavcodec - mpegvideo.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 979 1310 74.7 %
Date: 2017-12-18 06:23:41 Functions: 41 47 87.2 %

          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             :  * @file
      27             :  * The simplest mpeg encoder (well, it was the simplest!).
      28             :  */
      29             : 
      30             : #include "libavutil/attributes.h"
      31             : #include "libavutil/avassert.h"
      32             : #include "libavutil/imgutils.h"
      33             : #include "libavutil/internal.h"
      34             : #include "libavutil/motion_vector.h"
      35             : #include "libavutil/timer.h"
      36             : #include "avcodec.h"
      37             : #include "blockdsp.h"
      38             : #include "h264chroma.h"
      39             : #include "idctdsp.h"
      40             : #include "internal.h"
      41             : #include "mathops.h"
      42             : #include "mpeg_er.h"
      43             : #include "mpegutils.h"
      44             : #include "mpegvideo.h"
      45             : #include "mpegvideodata.h"
      46             : #include "mjpegenc.h"
      47             : #include "msmpeg4.h"
      48             : #include "qpeldsp.h"
      49             : #include "thread.h"
      50             : #include "wmv2.h"
      51             : #include <limits.h>
      52             : 
      53      138102 : static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
      54             :                                    int16_t *block, int n, int qscale)
      55             : {
      56             :     int i, level, nCoeffs;
      57             :     const uint16_t *quant_matrix;
      58             : 
      59      138102 :     nCoeffs= s->block_last_index[n];
      60             : 
      61      138102 :     block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
      62             :     /* XXX: only MPEG-1 */
      63      138102 :     quant_matrix = s->intra_matrix;
      64     3397416 :     for(i=1;i<=nCoeffs;i++) {
      65     3259314 :         int j= s->intra_scantable.permutated[i];
      66     3259314 :         level = block[j];
      67     3259314 :         if (level) {
      68     1351372 :             if (level < 0) {
      69      671553 :                 level = -level;
      70      671553 :                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
      71      671553 :                 level = (level - 1) | 1;
      72      671553 :                 level = -level;
      73             :             } else {
      74      679819 :                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
      75      679819 :                 level = (level - 1) | 1;
      76             :             }
      77     1351372 :             block[j] = level;
      78             :         }
      79             :     }
      80      138102 : }
      81             : 
      82      318146 : static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
      83             :                                    int16_t *block, int n, int qscale)
      84             : {
      85             :     int i, level, nCoeffs;
      86             :     const uint16_t *quant_matrix;
      87             : 
      88      318146 :     nCoeffs= s->block_last_index[n];
      89             : 
      90      318146 :     quant_matrix = s->inter_matrix;
      91    10740276 :     for(i=0; i<=nCoeffs; i++) {
      92    10422130 :         int j= s->intra_scantable.permutated[i];
      93    10422130 :         level = block[j];
      94    10422130 :         if (level) {
      95     2378635 :             if (level < 0) {
      96     1190849 :                 level = -level;
      97     2381698 :                 level = (((level << 1) + 1) * qscale *
      98     1190849 :                          ((int) (quant_matrix[j]))) >> 4;
      99     1190849 :                 level = (level - 1) | 1;
     100     1190849 :                 level = -level;
     101             :             } else {
     102     2375572 :                 level = (((level << 1) + 1) * qscale *
     103     1187786 :                          ((int) (quant_matrix[j]))) >> 4;
     104     1187786 :                 level = (level - 1) | 1;
     105             :             }
     106     2378635 :             block[j] = level;
     107             :         }
     108             :     }
     109      318146 : }
     110             : 
     111           0 : static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
     112             :                                    int16_t *block, int n, int qscale)
     113             : {
     114             :     int i, level, nCoeffs;
     115             :     const uint16_t *quant_matrix;
     116             : 
     117           0 :     if (s->q_scale_type) qscale = ff_mpeg2_non_linear_qscale[qscale];
     118           0 :     else                 qscale <<= 1;
     119             : 
     120           0 :     if(s->alternate_scan) nCoeffs= 63;
     121           0 :     else nCoeffs= s->block_last_index[n];
     122             : 
     123           0 :     block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
     124           0 :     quant_matrix = s->intra_matrix;
     125           0 :     for(i=1;i<=nCoeffs;i++) {
     126           0 :         int j= s->intra_scantable.permutated[i];
     127           0 :         level = block[j];
     128           0 :         if (level) {
     129           0 :             if (level < 0) {
     130           0 :                 level = -level;
     131           0 :                 level = (int)(level * qscale * quant_matrix[j]) >> 4;
     132           0 :                 level = -level;
     133             :             } else {
     134           0 :                 level = (int)(level * qscale * quant_matrix[j]) >> 4;
     135             :             }
     136           0 :             block[j] = level;
     137             :         }
     138             :     }
     139           0 : }
     140             : 
     141     1004864 : static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
     142             :                                    int16_t *block, int n, int qscale)
     143             : {
     144             :     int i, level, nCoeffs;
     145             :     const uint16_t *quant_matrix;
     146     1004864 :     int sum=-1;
     147             : 
     148     1004864 :     if (s->q_scale_type) qscale = ff_mpeg2_non_linear_qscale[qscale];
     149     1004864 :     else                 qscale <<= 1;
     150             : 
     151     1004864 :     if(s->alternate_scan) nCoeffs= 63;
     152     1004864 :     else nCoeffs= s->block_last_index[n];
     153             : 
     154     1004864 :     block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
     155     1004864 :     sum += block[0];
     156     1004864 :     quant_matrix = s->intra_matrix;
     157    19033337 :     for(i=1;i<=nCoeffs;i++) {
     158    18028473 :         int j= s->intra_scantable.permutated[i];
     159    18028473 :         level = block[j];
     160    18028473 :         if (level) {
     161     8890498 :             if (level < 0) {
     162     4472731 :                 level = -level;
     163     4472731 :                 level = (int)(level * qscale * quant_matrix[j]) >> 4;
     164     4472731 :                 level = -level;
     165             :             } else {
     166     4417767 :                 level = (int)(level * qscale * quant_matrix[j]) >> 4;
     167             :             }
     168     8890498 :             block[j] = level;
     169     8890498 :             sum+=level;
     170             :         }
     171             :     }
     172     1004864 :     block[63]^=sum&1;
     173     1004864 : }
     174             : 
     175     2577120 : static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
     176             :                                    int16_t *block, int n, int qscale)
     177             : {
     178             :     int i, level, nCoeffs;
     179             :     const uint16_t *quant_matrix;
     180     2577120 :     int sum=-1;
     181             : 
     182     2577120 :     if (s->q_scale_type) qscale = ff_mpeg2_non_linear_qscale[qscale];
     183     2577120 :     else                 qscale <<= 1;
     184             : 
     185     2577120 :     if(s->alternate_scan) nCoeffs= 63;
     186     2577120 :     else nCoeffs= s->block_last_index[n];
     187             : 
     188     2577120 :     quant_matrix = s->inter_matrix;
     189    65294556 :     for(i=0; i<=nCoeffs; i++) {
     190    62717436 :         int j= s->intra_scantable.permutated[i];
     191    62717436 :         level = block[j];
     192    62717436 :         if (level) {
     193    22179210 :             if (level < 0) {
     194    11115371 :                 level = -level;
     195    22230742 :                 level = (((level << 1) + 1) * qscale *
     196    11115371 :                          ((int) (quant_matrix[j]))) >> 5;
     197    11115371 :                 level = -level;
     198             :             } else {
     199    22127678 :                 level = (((level << 1) + 1) * qscale *
     200    11063839 :                          ((int) (quant_matrix[j]))) >> 5;
     201             :             }
     202    22179210 :             block[j] = level;
     203    22179210 :             sum+=level;
     204             :         }
     205             :     }
     206     2577120 :     block[63]^=sum&1;
     207     2577120 : }
     208             : 
     209     3363228 : static void dct_unquantize_h263_intra_c(MpegEncContext *s,
     210             :                                   int16_t *block, int n, int qscale)
     211             : {
     212             :     int i, level, qmul, qadd;
     213             :     int nCoeffs;
     214             : 
     215             :     av_assert2(s->block_last_index[n]>=0 || s->h263_aic);
     216             : 
     217     3363228 :     qmul = qscale << 1;
     218             : 
     219     3363228 :     if (!s->h263_aic) {
     220     3190032 :         block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
     221     3190032 :         qadd = (qscale - 1) | 1;
     222             :     }else{
     223      173196 :         qadd = 0;
     224             :     }
     225     3363228 :     if(s->ac_pred)
     226       68304 :         nCoeffs=63;
     227             :     else
     228     3294924 :         nCoeffs= s->intra_scantable.raster_end[ s->block_last_index[n] ];
     229             : 
     230   120195275 :     for(i=1; i<=nCoeffs; i++) {
     231   116832047 :         level = block[i];
     232   116832047 :         if (level) {
     233    35700964 :             if (level < 0) {
     234    17877171 :                 level = level * qmul - qadd;
     235             :             } else {
     236    17823793 :                 level = level * qmul + qadd;
     237             :             }
     238    35700964 :             block[i] = level;
     239             :         }
     240             :     }
     241     3363228 : }
     242             : 
     243     6014662 : static void dct_unquantize_h263_inter_c(MpegEncContext *s,
     244             :                                   int16_t *block, int n, int qscale)
     245             : {
     246             :     int i, level, qmul, qadd;
     247             :     int nCoeffs;
     248             : 
     249             :     av_assert2(s->block_last_index[n]>=0);
     250             : 
     251     6014662 :     qadd = (qscale - 1) | 1;
     252     6014662 :     qmul = qscale << 1;
     253             : 
     254     6014662 :     nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
     255             : 
     256   235641304 :     for(i=0; i<=nCoeffs; i++) {
     257   229626642 :         level = block[i];
     258   229626642 :         if (level) {
     259    48213622 :             if (level < 0) {
     260    24027915 :                 level = level * qmul - qadd;
     261             :             } else {
     262    24185707 :                 level = level * qmul + qadd;
     263             :             }
     264    48213622 :             block[i] = level;
     265             :         }
     266             :     }
     267     6014662 : }
     268             : 
     269             : 
     270           0 : static void gray16(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
     271             : {
     272           0 :     while(h--)
     273           0 :         memset(dst + h*linesize, 128, 16);
     274           0 : }
     275             : 
     276           0 : static void gray8(uint8_t *dst, const uint8_t *src, ptrdiff_t linesize, int h)
     277             : {
     278           0 :     while(h--)
     279           0 :         memset(dst + h*linesize, 128, 8);
     280           0 : }
     281             : 
     282             : /* init common dct for both encoder and decoder */
     283         737 : static av_cold int dct_init(MpegEncContext *s)
     284             : {
     285         737 :     ff_blockdsp_init(&s->bdsp, s->avctx);
     286         737 :     ff_h264chroma_init(&s->h264chroma, 8); //for lowres
     287         737 :     ff_hpeldsp_init(&s->hdsp, s->avctx->flags);
     288         737 :     ff_mpegvideodsp_init(&s->mdsp);
     289         737 :     ff_videodsp_init(&s->vdsp, s->avctx->bits_per_raw_sample);
     290             : 
     291         737 :     if (s->avctx->debug & FF_DEBUG_NOMC) {
     292             :         int i;
     293           0 :         for (i=0; i<4; i++) {
     294           0 :             s->hdsp.avg_pixels_tab[0][i] = gray16;
     295           0 :             s->hdsp.put_pixels_tab[0][i] = gray16;
     296           0 :             s->hdsp.put_no_rnd_pixels_tab[0][i] = gray16;
     297             : 
     298           0 :             s->hdsp.avg_pixels_tab[1][i] = gray8;
     299           0 :             s->hdsp.put_pixels_tab[1][i] = gray8;
     300           0 :             s->hdsp.put_no_rnd_pixels_tab[1][i] = gray8;
     301             :         }
     302             :     }
     303             : 
     304         737 :     s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
     305         737 :     s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
     306         737 :     s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
     307         737 :     s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
     308         737 :     s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
     309         737 :     if (s->avctx->flags & AV_CODEC_FLAG_BITEXACT)
     310         539 :         s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
     311         737 :     s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
     312             : 
     313             :     if (HAVE_INTRINSICS_NEON)
     314             :         ff_mpv_common_init_neon(s);
     315             : 
     316             :     if (ARCH_ALPHA)
     317             :         ff_mpv_common_init_axp(s);
     318             :     if (ARCH_ARM)
     319             :         ff_mpv_common_init_arm(s);
     320             :     if (ARCH_PPC)
     321             :         ff_mpv_common_init_ppc(s);
     322             :     if (ARCH_X86)
     323         737 :         ff_mpv_common_init_x86(s);
     324             :     if (ARCH_MIPS)
     325             :         ff_mpv_common_init_mips(s);
     326             : 
     327         737 :     return 0;
     328             : }
     329             : 
     330        1062 : av_cold void ff_mpv_idct_init(MpegEncContext *s)
     331             : {
     332        1062 :     ff_idctdsp_init(&s->idsp, s->avctx);
     333             : 
     334             :     /* load & permutate scantables
     335             :      * note: only wmv uses different ones
     336             :      */
     337        1062 :     if (s->alternate_scan) {
     338           0 :         ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
     339           0 :         ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
     340             :     } else {
     341        1062 :         ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
     342        1062 :         ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
     343             :     }
     344        1062 :     ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
     345        1062 :     ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
     346        1062 : }
     347             : 
     348       10808 : static int alloc_picture(MpegEncContext *s, Picture *pic, int shared)
     349             : {
     350       21616 :     return ff_alloc_picture(s->avctx, pic, &s->me, &s->sc, shared, 0,
     351       10808 :                             s->chroma_x_shift, s->chroma_y_shift, s->out_format,
     352             :                             s->mb_stride, s->mb_width, s->mb_height, s->b8_stride,
     353             :                             &s->linesize, &s->uvlinesize);
     354             : }
     355             : 
     356         787 : static int init_duplicate_context(MpegEncContext *s)
     357             : {
     358         787 :     int y_size = s->b8_stride * (2 * s->mb_height + 1);
     359         787 :     int c_size = s->mb_stride * (s->mb_height + 1);
     360         787 :     int yc_size = y_size + 2 * c_size;
     361             :     int i;
     362             : 
     363         787 :     if (s->mb_height & 1)
     364         144 :         yc_size += 2*s->b8_stride + 2*s->mb_stride;
     365             : 
     366         787 :     s->sc.edge_emu_buffer =
     367         787 :     s->me.scratchpad   =
     368         787 :     s->me.temp         =
     369         787 :     s->sc.rd_scratchpad   =
     370         787 :     s->sc.b_scratchpad    =
     371         787 :     s->sc.obmc_scratchpad = NULL;
     372             : 
     373         787 :     if (s->encoding) {
     374         195 :         FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map,
     375             :                           ME_MAP_SIZE * sizeof(uint32_t), fail)
     376         195 :         FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map,
     377             :                           ME_MAP_SIZE * sizeof(uint32_t), fail)
     378         195 :         if (s->noise_reduction) {
     379           4 :             FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum,
     380             :                               2 * 64 * sizeof(int), fail)
     381             :         }
     382             :     }
     383         787 :     FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64 * 12 * 2 * sizeof(int16_t), fail)
     384         787 :     s->block = s->blocks[0];
     385             : 
     386       10231 :     for (i = 0; i < 12; i++) {
     387        9444 :         s->pblocks[i] = &s->block[i];
     388             :     }
     389         787 :     if (s->avctx->codec_tag == AV_RL32("VCR2")) {
     390             :         // exchange uv
     391           4 :         FFSWAP(void *, s->pblocks[4], s->pblocks[5]);
     392             :     }
     393             : 
     394         787 :     if (s->out_format == FMT_H263) {
     395             :         /* ac values */
     396         445 :         FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base,
     397             :                           yc_size * sizeof(int16_t) * 16, fail);
     398         445 :         s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
     399         445 :         s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
     400         445 :         s->ac_val[2] = s->ac_val[1] + c_size;
     401             :     }
     402             : 
     403         787 :     return 0;
     404           0 : fail:
     405           0 :     return -1; // free() through ff_mpv_common_end()
     406             : }
     407             : 
     408         804 : static void free_duplicate_context(MpegEncContext *s)
     409             : {
     410         804 :     if (!s)
     411           0 :         return;
     412             : 
     413         804 :     av_freep(&s->sc.edge_emu_buffer);
     414         804 :     av_freep(&s->me.scratchpad);
     415         804 :     s->me.temp =
     416         804 :     s->sc.rd_scratchpad =
     417         804 :     s->sc.b_scratchpad =
     418         804 :     s->sc.obmc_scratchpad = NULL;
     419             : 
     420         804 :     av_freep(&s->dct_error_sum);
     421         804 :     av_freep(&s->me.map);
     422         804 :     av_freep(&s->me.score_map);
     423         804 :     av_freep(&s->blocks);
     424         804 :     av_freep(&s->ac_val_base);
     425         804 :     s->block = NULL;
     426             : }
     427             : 
     428        1200 : static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
     429             : {
     430             : #define COPY(a) bak->a = src->a
     431        1200 :     COPY(sc.edge_emu_buffer);
     432        1200 :     COPY(me.scratchpad);
     433        1200 :     COPY(me.temp);
     434        1200 :     COPY(sc.rd_scratchpad);
     435        1200 :     COPY(sc.b_scratchpad);
     436        1200 :     COPY(sc.obmc_scratchpad);
     437        1200 :     COPY(me.map);
     438        1200 :     COPY(me.score_map);
     439        1200 :     COPY(blocks);
     440        1200 :     COPY(block);
     441        1200 :     COPY(start_mb_y);
     442        1200 :     COPY(end_mb_y);
     443        1200 :     COPY(me.map_generation);
     444        1200 :     COPY(pb);
     445        1200 :     COPY(dct_error_sum);
     446        1200 :     COPY(dct_count[0]);
     447        1200 :     COPY(dct_count[1]);
     448        1200 :     COPY(ac_val_base);
     449        1200 :     COPY(ac_val[0]);
     450        1200 :     COPY(ac_val[1]);
     451        1200 :     COPY(ac_val[2]);
     452             : #undef COPY
     453        1200 : }
     454             : 
     455         600 : int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
     456             : {
     457             :     MpegEncContext bak;
     458             :     int i, ret;
     459             :     // FIXME copy only needed parts
     460             :     // START_TIMER
     461         600 :     backup_duplicate_context(&bak, dst);
     462         600 :     memcpy(dst, src, sizeof(MpegEncContext));
     463         600 :     backup_duplicate_context(dst, &bak);
     464        7800 :     for (i = 0; i < 12; i++) {
     465        7200 :         dst->pblocks[i] = &dst->block[i];
     466             :     }
     467         600 :     if (dst->avctx->codec_tag == AV_RL32("VCR2")) {
     468             :         // exchange uv
     469           0 :         FFSWAP(void *, dst->pblocks[4], dst->pblocks[5]);
     470             :     }
     471         612 :     if (!dst->sc.edge_emu_buffer &&
     472          12 :         (ret = ff_mpeg_framesize_alloc(dst->avctx, &dst->me,
     473          12 :                                        &dst->sc, dst->linesize)) < 0) {
     474           0 :         av_log(dst->avctx, AV_LOG_ERROR, "failed to allocate context "
     475             :                "scratch buffers.\n");
     476           0 :         return ret;
     477             :     }
     478             :     // STOP_TIMER("update_duplicate_context")
     479             :     // about 10k cycles / 0.01 sec for  1000frames on 1ghz with 2 threads
     480         600 :     return 0;
     481             : }
     482             : 
     483           0 : int ff_mpeg_update_thread_context(AVCodecContext *dst,
     484             :                                   const AVCodecContext *src)
     485             : {
     486             :     int i, ret;
     487           0 :     MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
     488             : 
     489           0 :     if (dst == src)
     490           0 :         return 0;
     491             : 
     492           0 :     av_assert0(s != s1);
     493             : 
     494             :     // FIXME can parameters change on I-frames?
     495             :     // in that case dst may need a reinit
     496           0 :     if (!s->context_initialized) {
     497             :         int err;
     498           0 :         memcpy(s, s1, sizeof(MpegEncContext));
     499             : 
     500           0 :         s->avctx                 = dst;
     501           0 :         s->bitstream_buffer      = NULL;
     502           0 :         s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
     503             : 
     504           0 :         if (s1->context_initialized){
     505             : //             s->picture_range_start  += MAX_PICTURE_COUNT;
     506             : //             s->picture_range_end    += MAX_PICTURE_COUNT;
     507           0 :             ff_mpv_idct_init(s);
     508           0 :             if((err = ff_mpv_common_init(s)) < 0){
     509           0 :                 memset(s, 0, sizeof(MpegEncContext));
     510           0 :                 s->avctx = dst;
     511           0 :                 return err;
     512             :             }
     513             :         }
     514             :     }
     515             : 
     516           0 :     if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
     517           0 :         s->context_reinit = 0;
     518           0 :         s->height = s1->height;
     519           0 :         s->width  = s1->width;
     520           0 :         if ((ret = ff_mpv_common_frame_size_change(s)) < 0)
     521           0 :             return ret;
     522             :     }
     523             : 
     524           0 :     s->avctx->coded_height  = s1->avctx->coded_height;
     525           0 :     s->avctx->coded_width   = s1->avctx->coded_width;
     526           0 :     s->avctx->width         = s1->avctx->width;
     527           0 :     s->avctx->height        = s1->avctx->height;
     528             : 
     529           0 :     s->coded_picture_number = s1->coded_picture_number;
     530           0 :     s->picture_number       = s1->picture_number;
     531             : 
     532           0 :     av_assert0(!s->picture || s->picture != s1->picture);
     533           0 :     if(s->picture)
     534           0 :     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
     535           0 :         ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
     536           0 :         if (s1->picture && s1->picture[i].f->buf[0] &&
     537           0 :             (ret = ff_mpeg_ref_picture(s->avctx, &s->picture[i], &s1->picture[i])) < 0)
     538           0 :             return ret;
     539             :     }
     540             : 
     541             : #define UPDATE_PICTURE(pic)\
     542             : do {\
     543             :     ff_mpeg_unref_picture(s->avctx, &s->pic);\
     544             :     if (s1->pic.f && s1->pic.f->buf[0])\
     545             :         ret = ff_mpeg_ref_picture(s->avctx, &s->pic, &s1->pic);\
     546             :     else\
     547             :         ret = ff_update_picture_tables(&s->pic, &s1->pic);\
     548             :     if (ret < 0)\
     549             :         return ret;\
     550             : } while (0)
     551             : 
     552           0 :     UPDATE_PICTURE(current_picture);
     553           0 :     UPDATE_PICTURE(last_picture);
     554           0 :     UPDATE_PICTURE(next_picture);
     555             : 
     556             : #define REBASE_PICTURE(pic, new_ctx, old_ctx)                                 \
     557             :     ((pic && pic >= old_ctx->picture &&                                       \
     558             :       pic < old_ctx->picture + MAX_PICTURE_COUNT) ?                           \
     559             :         &new_ctx->picture[pic - old_ctx->picture] : NULL)
     560             : 
     561           0 :     s->last_picture_ptr    = REBASE_PICTURE(s1->last_picture_ptr,    s, s1);
     562           0 :     s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
     563           0 :     s->next_picture_ptr    = REBASE_PICTURE(s1->next_picture_ptr,    s, s1);
     564             : 
     565             :     // Error/bug resilience
     566           0 :     s->next_p_frame_damaged = s1->next_p_frame_damaged;
     567           0 :     s->workaround_bugs      = s1->workaround_bugs;
     568           0 :     s->padding_bug_score    = s1->padding_bug_score;
     569             : 
     570             :     // MPEG-4 timing info
     571           0 :     memcpy(&s->last_time_base, &s1->last_time_base,
     572           0 :            (char *) &s1->pb_field_time + sizeof(s1->pb_field_time) -
     573           0 :            (char *) &s1->last_time_base);
     574             : 
     575             :     // B-frame info
     576           0 :     s->max_b_frames = s1->max_b_frames;
     577           0 :     s->low_delay    = s1->low_delay;
     578           0 :     s->droppable    = s1->droppable;
     579             : 
     580             :     // DivX handling (doesn't work)
     581           0 :     s->divx_packed  = s1->divx_packed;
     582             : 
     583           0 :     if (s1->bitstream_buffer) {
     584           0 :         if (s1->bitstream_buffer_size +
     585           0 :             AV_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size) {
     586           0 :             av_fast_malloc(&s->bitstream_buffer,
     587             :                            &s->allocated_bitstream_buffer_size,
     588           0 :                            s1->allocated_bitstream_buffer_size);
     589           0 :             if (!s->bitstream_buffer) {
     590           0 :                 s->bitstream_buffer_size = 0;
     591           0 :                 return AVERROR(ENOMEM);
     592             :             }
     593             :         }
     594           0 :         s->bitstream_buffer_size = s1->bitstream_buffer_size;
     595           0 :         memcpy(s->bitstream_buffer, s1->bitstream_buffer,
     596           0 :                s1->bitstream_buffer_size);
     597           0 :         memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
     598             :                AV_INPUT_BUFFER_PADDING_SIZE);
     599             :     }
     600             : 
     601             :     // linesize-dependent scratch buffer allocation
     602           0 :     if (!s->sc.edge_emu_buffer)
     603           0 :         if (s1->linesize) {
     604           0 :             if (ff_mpeg_framesize_alloc(s->avctx, &s->me,
     605           0 :                                         &s->sc, s1->linesize) < 0) {
     606           0 :                 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate context "
     607             :                        "scratch buffers.\n");
     608           0 :                 return AVERROR(ENOMEM);
     609             :             }
     610             :         } else {
     611           0 :             av_log(s->avctx, AV_LOG_ERROR, "Context scratch buffers could not "
     612             :                    "be allocated due to unknown size.\n");
     613             :         }
     614             : 
     615             :     // MPEG-2/interlacing info
     616           0 :     memcpy(&s->progressive_sequence, &s1->progressive_sequence,
     617             :            (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
     618             : 
     619           0 :     if (!s1->first_field) {
     620           0 :         s->last_pict_type = s1->pict_type;
     621           0 :         if (s1->current_picture_ptr)
     622           0 :             s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f->quality;
     623             :     }
     624             : 
     625           0 :     return 0;
     626             : }
     627             : 
     628             : /**
     629             :  * Set the given MpegEncContext to common defaults
     630             :  * (same for encoding and decoding).
     631             :  * The changed fields will not depend upon the
     632             :  * prior state of the MpegEncContext.
     633             :  */
     634         753 : void ff_mpv_common_defaults(MpegEncContext *s)
     635             : {
     636         753 :     s->y_dc_scale_table      =
     637         753 :     s->c_dc_scale_table      = ff_mpeg1_dc_scale_table;
     638         753 :     s->chroma_qscale_table   = ff_default_chroma_qscale_table;
     639         753 :     s->progressive_frame     = 1;
     640         753 :     s->progressive_sequence  = 1;
     641         753 :     s->picture_structure     = PICT_FRAME;
     642             : 
     643         753 :     s->coded_picture_number  = 0;
     644         753 :     s->picture_number        = 0;
     645             : 
     646         753 :     s->f_code                = 1;
     647         753 :     s->b_code                = 1;
     648             : 
     649         753 :     s->slice_context_count   = 1;
     650         753 : }
     651             : 
     652             : /**
     653             :  * Set the given MpegEncContext to defaults for decoding.
     654             :  * the changed fields will not depend upon
     655             :  * the prior state of the MpegEncContext.
     656             :  */
     657         570 : void ff_mpv_decode_defaults(MpegEncContext *s)
     658             : {
     659         570 :     ff_mpv_common_defaults(s);
     660         570 : }
     661             : 
     662         570 : void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
     663             : {
     664         570 :     s->avctx           = avctx;
     665         570 :     s->width           = avctx->coded_width;
     666         570 :     s->height          = avctx->coded_height;
     667         570 :     s->codec_id        = avctx->codec->id;
     668         570 :     s->workaround_bugs = avctx->workaround_bugs;
     669             : 
     670             :     /* convert fourcc to upper case */
     671         570 :     s->codec_tag          = avpriv_toupper4(avctx->codec_tag);
     672         570 : }
     673             : 
     674             : /**
     675             :  * Initialize and allocates MpegEncContext fields dependent on the resolution.
     676             :  */
     677         775 : static int init_context_frame(MpegEncContext *s)
     678             : {
     679             :     int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
     680             : 
     681         775 :     s->mb_width   = (s->width + 15) / 16;
     682         775 :     s->mb_stride  = s->mb_width + 1;
     683         775 :     s->b8_stride  = s->mb_width * 2 + 1;
     684         775 :     mb_array_size = s->mb_height * s->mb_stride;
     685         775 :     mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
     686             : 
     687             :     /* set default edge pos, will be overridden
     688             :      * in decode_header if needed */
     689         775 :     s->h_edge_pos = s->mb_width * 16;
     690         775 :     s->v_edge_pos = s->mb_height * 16;
     691             : 
     692         775 :     s->mb_num     = s->mb_width * s->mb_height;
     693             : 
     694         775 :     s->block_wrap[0] =
     695         775 :     s->block_wrap[1] =
     696         775 :     s->block_wrap[2] =
     697         775 :     s->block_wrap[3] = s->b8_stride;
     698         775 :     s->block_wrap[4] =
     699         775 :     s->block_wrap[5] = s->mb_stride;
     700             : 
     701         775 :     y_size  = s->b8_stride * (2 * s->mb_height + 1);
     702         775 :     c_size  = s->mb_stride * (s->mb_height + 1);
     703         775 :     yc_size = y_size + 2   * c_size;
     704             : 
     705         775 :     if (s->mb_height & 1)
     706         143 :         yc_size += 2*s->b8_stride + 2*s->mb_stride;
     707             : 
     708         775 :     FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int),
     709             :                       fail); // error resilience code looks cleaner with this
     710       14900 :     for (y = 0; y < s->mb_height; y++)
     711      433644 :         for (x = 0; x < s->mb_width; x++)
     712      419519 :             s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
     713             : 
     714         775 :     s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
     715             : 
     716         775 :     if (s->encoding) {
     717             :         /* Allocate MV tables */
     718         183 :         FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base,                 mv_table_size * 2 * sizeof(int16_t), fail)
     719         183 :         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base,            mv_table_size * 2 * sizeof(int16_t), fail)
     720         183 :         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base,            mv_table_size * 2 * sizeof(int16_t), fail)
     721         183 :         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base,      mv_table_size * 2 * sizeof(int16_t), fail)
     722         183 :         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base,      mv_table_size * 2 * sizeof(int16_t), fail)
     723         183 :         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base,          mv_table_size * 2 * sizeof(int16_t), fail)
     724         183 :         s->p_mv_table            = s->p_mv_table_base + s->mb_stride + 1;
     725         183 :         s->b_forw_mv_table       = s->b_forw_mv_table_base + s->mb_stride + 1;
     726         183 :         s->b_back_mv_table       = s->b_back_mv_table_base + s->mb_stride + 1;
     727         183 :         s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
     728         183 :         s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base + s->mb_stride + 1;
     729         183 :         s->b_direct_mv_table     = s->b_direct_mv_table_base + s->mb_stride + 1;
     730             : 
     731             :         /* Allocate MB type table */
     732         183 :         FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size * sizeof(uint16_t), fail) // needed for encoding
     733             : 
     734         183 :         FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
     735             : 
     736         183 :         FF_ALLOC_OR_GOTO(s->avctx, s->cplx_tab,
     737             :                          mb_array_size * sizeof(float), fail);
     738         183 :         FF_ALLOC_OR_GOTO(s->avctx, s->bits_tab,
     739             :                          mb_array_size * sizeof(float), fail);
     740             : 
     741             :     }
     742             : 
     743        1308 :     if (s->codec_id == AV_CODEC_ID_MPEG4 ||
     744         533 :         (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_ME)) {
     745             :         /* interlaced direct mode decoding tables */
     746         774 :         for (i = 0; i < 2; i++) {
     747             :             int j, k;
     748        1548 :             for (j = 0; j < 2; j++) {
     749        3096 :                 for (k = 0; k < 2; k++) {
     750        2064 :                     FF_ALLOCZ_OR_GOTO(s->avctx,
     751             :                                       s->b_field_mv_table_base[i][j][k],
     752             :                                       mv_table_size * 2 * sizeof(int16_t),
     753             :                                       fail);
     754        4128 :                     s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
     755        2064 :                                                    s->mb_stride + 1;
     756             :                 }
     757        1032 :                 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
     758        1032 :                 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
     759        1032 :                 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
     760             :             }
     761         516 :             FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
     762             :         }
     763             :     }
     764         775 :     if (s->out_format == FMT_H263) {
     765             :         /* cbp values */
     766         441 :         FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size + (s->mb_height&1)*2*s->b8_stride, fail);
     767         441 :         s->coded_block = s->coded_block_base + s->b8_stride + 1;
     768             : 
     769             :         /* cbp, ac_pred, pred_dir */
     770         441 :         FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table     , mb_array_size * sizeof(uint8_t), fail);
     771         441 :         FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail);
     772             :     }
     773             : 
     774         775 :     if (s->h263_pred || s->h263_plus || !s->encoding) {
     775             :         /* dc values */
     776             :         // MN: we need these for error resilience of intra-frames
     777         673 :         FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
     778         673 :         s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
     779         673 :         s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
     780         673 :         s->dc_val[2] = s->dc_val[1] + c_size;
     781     2415704 :         for (i = 0; i < yc_size; i++)
     782     2415031 :             s->dc_val_base[i] = 1024;
     783             :     }
     784             : 
     785             :     /* which mb is an intra block */
     786         775 :     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
     787         775 :     memset(s->mbintra_table, 1, mb_array_size);
     788             : 
     789             :     /* init macroblock skip table */
     790         775 :     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
     791             :     // Note the + 1 is for a quicker MPEG-4 slice_end detection
     792             : 
     793         775 :     return ff_mpeg_er_init(s);
     794           0 : fail:
     795           0 :     return AVERROR(ENOMEM);
     796             : }
     797             : 
     798         737 : static void clear_context(MpegEncContext *s)
     799             : {
     800             :     int i, j, k;
     801             : 
     802         737 :     memset(&s->next_picture, 0, sizeof(s->next_picture));
     803         737 :     memset(&s->last_picture, 0, sizeof(s->last_picture));
     804         737 :     memset(&s->current_picture, 0, sizeof(s->current_picture));
     805         737 :     memset(&s->new_picture, 0, sizeof(s->new_picture));
     806             : 
     807         737 :     memset(s->thread_context, 0, sizeof(s->thread_context));
     808             : 
     809         737 :     s->me.map = NULL;
     810         737 :     s->me.score_map = NULL;
     811         737 :     s->dct_error_sum = NULL;
     812         737 :     s->block = NULL;
     813         737 :     s->blocks = NULL;
     814         737 :     memset(s->pblocks, 0, sizeof(s->pblocks));
     815         737 :     s->ac_val_base = NULL;
     816         737 :     s->ac_val[0] =
     817         737 :     s->ac_val[1] =
     818         737 :     s->ac_val[2] =NULL;
     819         737 :     s->sc.edge_emu_buffer = NULL;
     820         737 :     s->me.scratchpad = NULL;
     821         737 :     s->me.temp =
     822         737 :     s->sc.rd_scratchpad =
     823         737 :     s->sc.b_scratchpad =
     824         737 :     s->sc.obmc_scratchpad = NULL;
     825             : 
     826             : 
     827         737 :     s->bitstream_buffer = NULL;
     828         737 :     s->allocated_bitstream_buffer_size = 0;
     829         737 :     s->picture          = NULL;
     830         737 :     s->mb_type          = NULL;
     831         737 :     s->p_mv_table_base  = NULL;
     832         737 :     s->b_forw_mv_table_base = NULL;
     833         737 :     s->b_back_mv_table_base = NULL;
     834         737 :     s->b_bidir_forw_mv_table_base = NULL;
     835         737 :     s->b_bidir_back_mv_table_base = NULL;
     836         737 :     s->b_direct_mv_table_base = NULL;
     837         737 :     s->p_mv_table            = NULL;
     838         737 :     s->b_forw_mv_table       = NULL;
     839         737 :     s->b_back_mv_table       = NULL;
     840         737 :     s->b_bidir_forw_mv_table = NULL;
     841         737 :     s->b_bidir_back_mv_table = NULL;
     842         737 :     s->b_direct_mv_table     = NULL;
     843        2211 :     for (i = 0; i < 2; i++) {
     844        4422 :         for (j = 0; j < 2; j++) {
     845        8844 :             for (k = 0; k < 2; k++) {
     846        5896 :                 s->b_field_mv_table_base[i][j][k] = NULL;
     847        5896 :                 s->b_field_mv_table[i][j][k] = NULL;
     848             :             }
     849        2948 :             s->b_field_select_table[i][j] = NULL;
     850        2948 :             s->p_field_mv_table_base[i][j] = NULL;
     851        2948 :             s->p_field_mv_table[i][j] = NULL;
     852             :         }
     853        1474 :         s->p_field_select_table[i] = NULL;
     854             :     }
     855             : 
     856         737 :     s->dc_val_base = NULL;
     857         737 :     s->coded_block_base = NULL;
     858         737 :     s->mbintra_table = NULL;
     859         737 :     s->cbp_table = NULL;
     860         737 :     s->pred_dir_table = NULL;
     861             : 
     862         737 :     s->mbskip_table = NULL;
     863             : 
     864         737 :     s->er.error_status_table = NULL;
     865         737 :     s->er.er_temp_buffer = NULL;
     866         737 :     s->mb_index2xy = NULL;
     867         737 :     s->lambda_table = NULL;
     868             : 
     869         737 :     s->cplx_tab = NULL;
     870         737 :     s->bits_tab = NULL;
     871         737 : }
     872             : 
     873             : /**
     874             :  * init common structure for both encoder and decoder.
     875             :  * this assumes that some variables like width/height are already set
     876             :  */
     877         737 : av_cold int ff_mpv_common_init(MpegEncContext *s)
     878             : {
     879             :     int i, ret;
     880         737 :     int nb_slices = (HAVE_THREADS &&
     881         737 :                      s->avctx->active_thread_type & FF_THREAD_SLICE) ?
     882         737 :                     s->avctx->thread_count : 1;
     883             : 
     884         737 :     clear_context(s);
     885             : 
     886         737 :     if (s->encoding && s->avctx->slices)
     887          12 :         nb_slices = s->avctx->slices;
     888             : 
     889         737 :     if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
     890         126 :         s->mb_height = (s->height + 31) / 32 * 2;
     891             :     else
     892         611 :         s->mb_height = (s->height + 15) / 16;
     893             : 
     894         737 :     if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
     895           0 :         av_log(s->avctx, AV_LOG_ERROR,
     896             :                "decoding to AV_PIX_FMT_NONE is not supported.\n");
     897           0 :         return -1;
     898             :     }
     899             : 
     900         737 :     if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
     901             :         int max_slices;
     902           0 :         if (s->mb_height)
     903           0 :             max_slices = FFMIN(MAX_THREADS, s->mb_height);
     904             :         else
     905           0 :             max_slices = MAX_THREADS;
     906           0 :         av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
     907             :                " reducing to %d\n", nb_slices, max_slices);
     908           0 :         nb_slices = max_slices;
     909             :     }
     910             : 
     911        1459 :     if ((s->width || s->height) &&
     912         722 :         av_image_check_size(s->width, s->height, 0, s->avctx))
     913           0 :         return -1;
     914             : 
     915         737 :     dct_init(s);
     916             : 
     917             :     /* set chroma shifts */
     918         737 :     ret = av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
     919             :                                            &s->chroma_x_shift,
     920             :                                            &s->chroma_y_shift);
     921         737 :     if (ret)
     922           0 :         return ret;
     923             : 
     924         737 :     FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
     925             :                       MAX_PICTURE_COUNT * sizeof(Picture), fail);
     926       27269 :     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
     927       26532 :         s->picture[i].f = av_frame_alloc();
     928       26532 :         if (!s->picture[i].f)
     929           0 :             goto fail;
     930             :     }
     931         737 :     s->next_picture.f = av_frame_alloc();
     932         737 :     if (!s->next_picture.f)
     933           0 :         goto fail;
     934         737 :     s->last_picture.f = av_frame_alloc();
     935         737 :     if (!s->last_picture.f)
     936           0 :         goto fail;
     937         737 :     s->current_picture.f = av_frame_alloc();
     938         737 :     if (!s->current_picture.f)
     939           0 :         goto fail;
     940         737 :     s->new_picture.f = av_frame_alloc();
     941         737 :     if (!s->new_picture.f)
     942           0 :         goto fail;
     943             : 
     944         737 :     if (init_context_frame(s))
     945           0 :         goto fail;
     946             : 
     947         737 :     s->parse_context.state = -1;
     948             : 
     949         737 :     s->context_initialized = 1;
     950         737 :     memset(s->thread_context, 0, sizeof(s->thread_context));
     951         737 :     s->thread_context[0]   = s;
     952             : 
     953             : //     if (s->width && s->height) {
     954         737 :     if (nb_slices > 1) {
     955          36 :         for (i = 0; i < nb_slices; i++) {
     956          24 :             if (i) {
     957          12 :                 s->thread_context[i] = av_memdup(s, sizeof(MpegEncContext));
     958          12 :                 if (!s->thread_context[i])
     959           0 :                     goto fail;
     960             :             }
     961          24 :             if (init_duplicate_context(s->thread_context[i]) < 0)
     962           0 :                 goto fail;
     963          48 :             s->thread_context[i]->start_mb_y =
     964          48 :                 (s->mb_height * (i) + nb_slices / 2) / nb_slices;
     965          48 :             s->thread_context[i]->end_mb_y   =
     966          48 :                 (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
     967             :         }
     968             :     } else {
     969         725 :         if (init_duplicate_context(s) < 0)
     970           0 :             goto fail;
     971         725 :         s->start_mb_y = 0;
     972         725 :         s->end_mb_y   = s->mb_height;
     973             :     }
     974         737 :     s->slice_context_count = nb_slices;
     975             : //     }
     976             : 
     977         737 :     return 0;
     978           0 :  fail:
     979           0 :     ff_mpv_common_end(s);
     980           0 :     return -1;
     981             : }
     982             : 
     983             : /**
     984             :  * Frees and resets MpegEncContext fields depending on the resolution.
     985             :  * Is used during resolution changes to avoid a full reinitialization of the
     986             :  * codec.
     987             :  */
     988         792 : static void free_context_frame(MpegEncContext *s)
     989             : {
     990             :     int i, j, k;
     991             : 
     992         792 :     av_freep(&s->mb_type);
     993         792 :     av_freep(&s->p_mv_table_base);
     994         792 :     av_freep(&s->b_forw_mv_table_base);
     995         792 :     av_freep(&s->b_back_mv_table_base);
     996         792 :     av_freep(&s->b_bidir_forw_mv_table_base);
     997         792 :     av_freep(&s->b_bidir_back_mv_table_base);
     998         792 :     av_freep(&s->b_direct_mv_table_base);
     999         792 :     s->p_mv_table            = NULL;
    1000         792 :     s->b_forw_mv_table       = NULL;
    1001         792 :     s->b_back_mv_table       = NULL;
    1002         792 :     s->b_bidir_forw_mv_table = NULL;
    1003         792 :     s->b_bidir_back_mv_table = NULL;
    1004         792 :     s->b_direct_mv_table     = NULL;
    1005        2376 :     for (i = 0; i < 2; i++) {
    1006        4752 :         for (j = 0; j < 2; j++) {
    1007        9504 :             for (k = 0; k < 2; k++) {
    1008        6336 :                 av_freep(&s->b_field_mv_table_base[i][j][k]);
    1009        6336 :                 s->b_field_mv_table[i][j][k] = NULL;
    1010             :             }
    1011        3168 :             av_freep(&s->b_field_select_table[i][j]);
    1012        3168 :             av_freep(&s->p_field_mv_table_base[i][j]);
    1013        3168 :             s->p_field_mv_table[i][j] = NULL;
    1014             :         }
    1015        1584 :         av_freep(&s->p_field_select_table[i]);
    1016             :     }
    1017             : 
    1018         792 :     av_freep(&s->dc_val_base);
    1019         792 :     av_freep(&s->coded_block_base);
    1020         792 :     av_freep(&s->mbintra_table);
    1021         792 :     av_freep(&s->cbp_table);
    1022         792 :     av_freep(&s->pred_dir_table);
    1023             : 
    1024         792 :     av_freep(&s->mbskip_table);
    1025             : 
    1026         792 :     av_freep(&s->er.error_status_table);
    1027         792 :     av_freep(&s->er.er_temp_buffer);
    1028         792 :     av_freep(&s->mb_index2xy);
    1029         792 :     av_freep(&s->lambda_table);
    1030             : 
    1031         792 :     av_freep(&s->cplx_tab);
    1032         792 :     av_freep(&s->bits_tab);
    1033             : 
    1034         792 :     s->linesize = s->uvlinesize = 0;
    1035         792 : }
    1036             : 
    1037          38 : int ff_mpv_common_frame_size_change(MpegEncContext *s)
    1038             : {
    1039          38 :     int i, err = 0;
    1040             : 
    1041          38 :     if (!s->context_initialized)
    1042           0 :         return AVERROR(EINVAL);
    1043             : 
    1044          38 :     if (s->slice_context_count > 1) {
    1045           0 :         for (i = 0; i < s->slice_context_count; i++) {
    1046           0 :             free_duplicate_context(s->thread_context[i]);
    1047             :         }
    1048           0 :         for (i = 1; i < s->slice_context_count; i++) {
    1049           0 :             av_freep(&s->thread_context[i]);
    1050             :         }
    1051             :     } else
    1052          38 :         free_duplicate_context(s);
    1053             : 
    1054          38 :     free_context_frame(s);
    1055             : 
    1056          38 :     if (s->picture)
    1057        1406 :         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
    1058        1368 :                 s->picture[i].needs_realloc = 1;
    1059             :         }
    1060             : 
    1061          38 :     s->last_picture_ptr         =
    1062          38 :     s->next_picture_ptr         =
    1063          38 :     s->current_picture_ptr      = NULL;
    1064             : 
    1065             :     // init
    1066          38 :     if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
    1067           0 :         s->mb_height = (s->height + 31) / 32 * 2;
    1068             :     else
    1069          38 :         s->mb_height = (s->height + 15) / 16;
    1070             : 
    1071          76 :     if ((s->width || s->height) &&
    1072          38 :         (err = av_image_check_size(s->width, s->height, 0, s->avctx)) < 0)
    1073           0 :         goto fail;
    1074             : 
    1075          38 :     if ((err = init_context_frame(s)))
    1076           0 :         goto fail;
    1077             : 
    1078          38 :     memset(s->thread_context, 0, sizeof(s->thread_context));
    1079          38 :     s->thread_context[0]   = s;
    1080             : 
    1081          38 :     if (s->width && s->height) {
    1082          38 :         int nb_slices = s->slice_context_count;
    1083          38 :         if (nb_slices > 1) {
    1084           0 :             for (i = 0; i < nb_slices; i++) {
    1085           0 :                 if (i) {
    1086           0 :                     s->thread_context[i] = av_memdup(s, sizeof(MpegEncContext));
    1087           0 :                     if (!s->thread_context[i]) {
    1088           0 :                         err = AVERROR(ENOMEM);
    1089           0 :                         goto fail;
    1090             :                     }
    1091             :                 }
    1092           0 :                 if ((err = init_duplicate_context(s->thread_context[i])) < 0)
    1093           0 :                     goto fail;
    1094           0 :                 s->thread_context[i]->start_mb_y =
    1095           0 :                     (s->mb_height * (i) + nb_slices / 2) / nb_slices;
    1096           0 :                 s->thread_context[i]->end_mb_y   =
    1097           0 :                     (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
    1098             :             }
    1099             :         } else {
    1100          38 :             err = init_duplicate_context(s);
    1101          38 :             if (err < 0)
    1102           0 :                 goto fail;
    1103          38 :             s->start_mb_y = 0;
    1104          38 :             s->end_mb_y   = s->mb_height;
    1105             :         }
    1106          38 :         s->slice_context_count = nb_slices;
    1107             :     }
    1108             : 
    1109          38 :     return 0;
    1110           0 :  fail:
    1111           0 :     ff_mpv_common_end(s);
    1112           0 :     return err;
    1113             : }
    1114             : 
    1115             : /* init common structure for both encoder and decoder */
    1116         754 : void ff_mpv_common_end(MpegEncContext *s)
    1117             : {
    1118             :     int i;
    1119             : 
    1120         754 :     if (!s)
    1121           0 :         return ;
    1122             : 
    1123         754 :     if (s->slice_context_count > 1) {
    1124          36 :         for (i = 0; i < s->slice_context_count; i++) {
    1125          24 :             free_duplicate_context(s->thread_context[i]);
    1126             :         }
    1127          24 :         for (i = 1; i < s->slice_context_count; i++) {
    1128          12 :             av_freep(&s->thread_context[i]);
    1129             :         }
    1130          12 :         s->slice_context_count = 1;
    1131         742 :     } else free_duplicate_context(s);
    1132             : 
    1133         754 :     av_freep(&s->parse_context.buffer);
    1134         754 :     s->parse_context.buffer_size = 0;
    1135             : 
    1136         754 :     av_freep(&s->bitstream_buffer);
    1137         754 :     s->allocated_bitstream_buffer_size = 0;
    1138             : 
    1139         754 :     if (s->picture) {
    1140       27269 :         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
    1141       26532 :             ff_free_picture_tables(&s->picture[i]);
    1142       26532 :             ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
    1143       26532 :             av_frame_free(&s->picture[i].f);
    1144             :         }
    1145             :     }
    1146         754 :     av_freep(&s->picture);
    1147         754 :     ff_free_picture_tables(&s->last_picture);
    1148         754 :     ff_mpeg_unref_picture(s->avctx, &s->last_picture);
    1149         754 :     av_frame_free(&s->last_picture.f);
    1150         754 :     ff_free_picture_tables(&s->current_picture);
    1151         754 :     ff_mpeg_unref_picture(s->avctx, &s->current_picture);
    1152         754 :     av_frame_free(&s->current_picture.f);
    1153         754 :     ff_free_picture_tables(&s->next_picture);
    1154         754 :     ff_mpeg_unref_picture(s->avctx, &s->next_picture);
    1155         754 :     av_frame_free(&s->next_picture.f);
    1156         754 :     ff_free_picture_tables(&s->new_picture);
    1157         754 :     ff_mpeg_unref_picture(s->avctx, &s->new_picture);
    1158         754 :     av_frame_free(&s->new_picture.f);
    1159             : 
    1160         754 :     free_context_frame(s);
    1161             : 
    1162         754 :     s->context_initialized      = 0;
    1163         754 :     s->last_picture_ptr         =
    1164         754 :     s->next_picture_ptr         =
    1165         754 :     s->current_picture_ptr      = NULL;
    1166         754 :     s->linesize = s->uvlinesize = 0;
    1167             : }
    1168             : 
    1169             : 
    1170           0 : static void gray_frame(AVFrame *frame)
    1171             : {
    1172             :     int i, h_chroma_shift, v_chroma_shift;
    1173             : 
    1174           0 :     av_pix_fmt_get_chroma_sub_sample(frame->format, &h_chroma_shift, &v_chroma_shift);
    1175             : 
    1176           0 :     for(i=0; i<frame->height; i++)
    1177           0 :         memset(frame->data[0] + frame->linesize[0]*i, 0x80, frame->width);
    1178           0 :     for(i=0; i<AV_CEIL_RSHIFT(frame->height, v_chroma_shift); i++) {
    1179           0 :         memset(frame->data[1] + frame->linesize[1]*i,
    1180           0 :                0x80, AV_CEIL_RSHIFT(frame->width, h_chroma_shift));
    1181           0 :         memset(frame->data[2] + frame->linesize[2]*i,
    1182           0 :                0x80, AV_CEIL_RSHIFT(frame->width, h_chroma_shift));
    1183             :     }
    1184           0 : }
    1185             : 
    1186             : /**
    1187             :  * generic function called after decoding
    1188             :  * the header and before a frame is decoded.
    1189             :  */
    1190       10802 : int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
    1191             : {
    1192             :     int i, ret;
    1193             :     Picture *pic;
    1194       10802 :     s->mb_skipped = 0;
    1195             : 
    1196       10802 :     if (!ff_thread_can_start_frame(avctx)) {
    1197           0 :         av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
    1198           0 :         return -1;
    1199             :     }
    1200             : 
    1201             :     /* mark & release old frames */
    1202       18652 :     if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
    1203       15700 :         s->last_picture_ptr != s->next_picture_ptr &&
    1204        7850 :         s->last_picture_ptr->f->buf[0]) {
    1205        7850 :         ff_mpeg_unref_picture(s->avctx, s->last_picture_ptr);
    1206             :     }
    1207             : 
    1208             :     /* release forgotten pictures */
    1209             :     /* if (MPEG-124 / H.263) */
    1210      399674 :     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
    1211      767436 :         if (&s->picture[i] != s->last_picture_ptr &&
    1212      746618 :             &s->picture[i] != s->next_picture_ptr &&
    1213      368074 :             s->picture[i].reference && !s->picture[i].needs_realloc) {
    1214           0 :             ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
    1215             :         }
    1216             :     }
    1217             : 
    1218       10802 :     ff_mpeg_unref_picture(s->avctx, &s->current_picture);
    1219       10802 :     ff_mpeg_unref_picture(s->avctx, &s->last_picture);
    1220       10802 :     ff_mpeg_unref_picture(s->avctx, &s->next_picture);
    1221             : 
    1222             :     /* release non reference frames */
    1223      399674 :     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
    1224      388872 :         if (!s->picture[i].reference)
    1225      375884 :             ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
    1226             :     }
    1227             : 
    1228       10802 :     if (s->current_picture_ptr && !s->current_picture_ptr->f->buf[0]) {
    1229             :         // we already have an unused image
    1230             :         // (maybe it was set before reading the header)
    1231        5966 :         pic = s->current_picture_ptr;
    1232             :     } else {
    1233        4836 :         i   = ff_find_unused_picture(s->avctx, s->picture, 0);
    1234        4836 :         if (i < 0) {
    1235           0 :             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
    1236           0 :             return i;
    1237             :         }
    1238        4836 :         pic = &s->picture[i];
    1239             :     }
    1240             : 
    1241       10802 :     pic->reference = 0;
    1242       10802 :     if (!s->droppable) {
    1243       10802 :         if (s->pict_type != AV_PICTURE_TYPE_B)
    1244        8344 :             pic->reference = 3;
    1245             :     }
    1246             : 
    1247       10802 :     pic->f->coded_picture_number = s->coded_picture_number++;
    1248             : 
    1249       10802 :     if (alloc_picture(s, pic, 0) < 0)
    1250           0 :         return -1;
    1251             : 
    1252       10802 :     s->current_picture_ptr = pic;
    1253             :     // FIXME use only the vars from current_pic
    1254       10802 :     s->current_picture_ptr->f->top_field_first = s->top_field_first;
    1255       21099 :     if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
    1256       10297 :         s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
    1257        3512 :         if (s->picture_structure != PICT_FRAME)
    1258        1204 :             s->current_picture_ptr->f->top_field_first =
    1259        1204 :                 (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
    1260             :     }
    1261       12704 :     s->current_picture_ptr->f->interlaced_frame = !s->progressive_frame &&
    1262        1902 :                                                  !s->progressive_sequence;
    1263       10802 :     s->current_picture_ptr->field_picture      =  s->picture_structure != PICT_FRAME;
    1264             : 
    1265       10802 :     s->current_picture_ptr->f->pict_type = s->pict_type;
    1266             :     // if (s->avctx->flags && AV_CODEC_FLAG_QSCALE)
    1267             :     //     s->current_picture_ptr->quality = s->new_picture_ptr->quality;
    1268       10802 :     s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
    1269             : 
    1270       10802 :     if ((ret = ff_mpeg_ref_picture(s->avctx, &s->current_picture,
    1271             :                                    s->current_picture_ptr)) < 0)
    1272           0 :         return ret;
    1273             : 
    1274       10802 :     if (s->pict_type != AV_PICTURE_TYPE_B) {
    1275        8344 :         s->last_picture_ptr = s->next_picture_ptr;
    1276        8344 :         if (!s->droppable)
    1277        8344 :             s->next_picture_ptr = s->current_picture_ptr;
    1278             :     }
    1279             :     ff_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
    1280             :             s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
    1281             :             s->last_picture_ptr    ? s->last_picture_ptr->f->data[0]    : NULL,
    1282             :             s->next_picture_ptr    ? s->next_picture_ptr->f->data[0]    : NULL,
    1283             :             s->current_picture_ptr ? s->current_picture_ptr->f->data[0] : NULL,
    1284             :             s->pict_type, s->droppable);
    1285             : 
    1286       11094 :     if ((!s->last_picture_ptr || !s->last_picture_ptr->f->buf[0]) &&
    1287         292 :         (s->pict_type != AV_PICTURE_TYPE_I)) {
    1288             :         int h_chroma_shift, v_chroma_shift;
    1289           6 :         av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
    1290             :                                          &h_chroma_shift, &v_chroma_shift);
    1291           6 :         if (s->pict_type == AV_PICTURE_TYPE_B && s->next_picture_ptr && s->next_picture_ptr->f->buf[0])
    1292           0 :             av_log(avctx, AV_LOG_DEBUG,
    1293             :                    "allocating dummy last picture for B frame\n");
    1294           6 :         else if (s->pict_type != AV_PICTURE_TYPE_I)
    1295           6 :             av_log(avctx, AV_LOG_ERROR,
    1296             :                    "warning: first frame is no keyframe\n");
    1297             : 
    1298             :         /* Allocate a dummy frame */
    1299           6 :         i = ff_find_unused_picture(s->avctx, s->picture, 0);
    1300           6 :         if (i < 0) {
    1301           0 :             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
    1302           0 :             return i;
    1303             :         }
    1304           6 :         s->last_picture_ptr = &s->picture[i];
    1305             : 
    1306           6 :         s->last_picture_ptr->reference   = 3;
    1307           6 :         s->last_picture_ptr->f->key_frame = 0;
    1308           6 :         s->last_picture_ptr->f->pict_type = AV_PICTURE_TYPE_P;
    1309             : 
    1310           6 :         if (alloc_picture(s, s->last_picture_ptr, 0) < 0) {
    1311           0 :             s->last_picture_ptr = NULL;
    1312           0 :             return -1;
    1313             :         }
    1314             : 
    1315           6 :         if (!avctx->hwaccel) {
    1316        1734 :             for(i=0; i<avctx->height; i++)
    1317        1728 :                 memset(s->last_picture_ptr->f->data[0] + s->last_picture_ptr->f->linesize[0]*i,
    1318        1728 :                        0x80, avctx->width);
    1319           6 :             if (s->last_picture_ptr->f->data[2]) {
    1320         870 :                 for(i=0; i<AV_CEIL_RSHIFT(avctx->height, v_chroma_shift); i++) {
    1321         864 :                     memset(s->last_picture_ptr->f->data[1] + s->last_picture_ptr->f->linesize[1]*i,
    1322         864 :                         0x80, AV_CEIL_RSHIFT(avctx->width, h_chroma_shift));
    1323         864 :                     memset(s->last_picture_ptr->f->data[2] + s->last_picture_ptr->f->linesize[2]*i,
    1324         864 :                         0x80, AV_CEIL_RSHIFT(avctx->width, h_chroma_shift));
    1325             :                 }
    1326             :             }
    1327             : 
    1328           6 :             if(s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263){
    1329           0 :                 for(i=0; i<avctx->height; i++)
    1330           0 :                 memset(s->last_picture_ptr->f->data[0] + s->last_picture_ptr->f->linesize[0]*i, 16, avctx->width);
    1331             :             }
    1332             :         }
    1333             : 
    1334           6 :         ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 0);
    1335           6 :         ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 1);
    1336             :     }
    1337       10802 :     if ((!s->next_picture_ptr || !s->next_picture_ptr->f->buf[0]) &&
    1338           0 :         s->pict_type == AV_PICTURE_TYPE_B) {
    1339             :         /* Allocate a dummy frame */
    1340           0 :         i = ff_find_unused_picture(s->avctx, s->picture, 0);
    1341           0 :         if (i < 0) {
    1342           0 :             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
    1343           0 :             return i;
    1344             :         }
    1345           0 :         s->next_picture_ptr = &s->picture[i];
    1346             : 
    1347           0 :         s->next_picture_ptr->reference   = 3;
    1348           0 :         s->next_picture_ptr->f->key_frame = 0;
    1349           0 :         s->next_picture_ptr->f->pict_type = AV_PICTURE_TYPE_P;
    1350             : 
    1351           0 :         if (alloc_picture(s, s->next_picture_ptr, 0) < 0) {
    1352           0 :             s->next_picture_ptr = NULL;
    1353           0 :             return -1;
    1354             :         }
    1355           0 :         ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 0);
    1356           0 :         ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 1);
    1357             :     }
    1358             : 
    1359             : #if 0 // BUFREF-FIXME
    1360             :     memset(s->last_picture.f->data, 0, sizeof(s->last_picture.f->data));
    1361             :     memset(s->next_picture.f->data, 0, sizeof(s->next_picture.f->data));
    1362             : #endif
    1363       10802 :     if (s->last_picture_ptr) {
    1364       21032 :         if (s->last_picture_ptr->f->buf[0] &&
    1365       10516 :             (ret = ff_mpeg_ref_picture(s->avctx, &s->last_picture,
    1366             :                                        s->last_picture_ptr)) < 0)
    1367           0 :             return ret;
    1368             :     }
    1369       10802 :     if (s->next_picture_ptr) {
    1370       21604 :         if (s->next_picture_ptr->f->buf[0] &&
    1371       10802 :             (ret = ff_mpeg_ref_picture(s->avctx, &s->next_picture,
    1372             :                                        s->next_picture_ptr)) < 0)
    1373           0 :             return ret;
    1374             :     }
    1375             : 
    1376       10802 :     av_assert0(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
    1377             :                                                  s->last_picture_ptr->f->buf[0]));
    1378             : 
    1379       10802 :     if (s->picture_structure!= PICT_FRAME) {
    1380             :         int i;
    1381        3010 :         for (i = 0; i < 4; i++) {
    1382        2408 :             if (s->picture_structure == PICT_BOTTOM_FIELD) {
    1383        4808 :                 s->current_picture.f->data[i] +=
    1384        2404 :                     s->current_picture.f->linesize[i];
    1385             :             }
    1386        2408 :             s->current_picture.f->linesize[i] *= 2;
    1387        2408 :             s->last_picture.f->linesize[i]    *= 2;
    1388        2408 :             s->next_picture.f->linesize[i]    *= 2;
    1389             :         }
    1390             :     }
    1391             : 
    1392             :     /* set dequantizer, we can't do it during init as
    1393             :      * it might change for MPEG-4 and we can't do it in the header
    1394             :      * decode as init is not called for MPEG-4 there yet */
    1395       10802 :     if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
    1396        3047 :         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
    1397        3047 :         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
    1398        7755 :     } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
    1399        7250 :         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
    1400        7250 :         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
    1401             :     } else {
    1402         505 :         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
    1403         505 :         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
    1404             :     }
    1405             : 
    1406       10802 :     if (s->avctx->debug & FF_DEBUG_NOMC) {
    1407           0 :         gray_frame(s->current_picture_ptr->f);
    1408             :     }
    1409             : 
    1410       10802 :     return 0;
    1411             : }
    1412             : 
    1413             : /* called after a frame has been decoded. */
    1414       10802 : void ff_mpv_frame_end(MpegEncContext *s)
    1415             : {
    1416       10802 :     emms_c();
    1417             : 
    1418       10802 :     if (s->current_picture.reference)
    1419        8344 :         ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);
    1420       10802 : }
    1421             : 
    1422       10622 : void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
    1423             : {
    1424       21244 :     ff_print_debug_info2(s->avctx, pict, s->mbskip_table, p->mb_type,
    1425       10622 :                          p->qscale_table, p->motion_val, &s->low_delay,
    1426             :                          s->mb_width, s->mb_height, s->mb_stride, s->quarter_sample);
    1427       10622 : }
    1428             : 
    1429        9902 : int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type)
    1430             : {
    1431        9902 :     AVBufferRef *ref = av_buffer_ref(p->qscale_table_buf);
    1432        9902 :     int offset = 2*s->mb_stride + 1;
    1433        9902 :     if(!ref)
    1434           0 :         return AVERROR(ENOMEM);
    1435        9902 :     av_assert0(ref->size >= offset + s->mb_stride * ((f->height+15)/16));
    1436        9902 :     ref->size -= offset;
    1437        9902 :     ref->data += offset;
    1438        9902 :     return av_frame_set_qp_table(f, ref, s->mb_stride, qp_type);
    1439             : }
    1440             : 
    1441      126300 : static inline int hpel_motion_lowres(MpegEncContext *s,
    1442             :                                      uint8_t *dest, uint8_t *src,
    1443             :                                      int field_based, int field_select,
    1444             :                                      int src_x, int src_y,
    1445             :                                      int width, int height, ptrdiff_t stride,
    1446             :                                      int h_edge_pos, int v_edge_pos,
    1447             :                                      int w, int h, h264_chroma_mc_func *pix_op,
    1448             :                                      int motion_x, int motion_y)
    1449             : {
    1450      126300 :     const int lowres   = s->avctx->lowres;
    1451      126300 :     const int op_index = FFMIN(lowres, 3);
    1452      126300 :     const int s_mask   = (2 << lowres) - 1;
    1453      126300 :     int emu = 0;
    1454             :     int sx, sy;
    1455             : 
    1456      126300 :     if (s->quarter_sample) {
    1457           0 :         motion_x /= 2;
    1458           0 :         motion_y /= 2;
    1459             :     }
    1460             : 
    1461      126300 :     sx = motion_x & s_mask;
    1462      126300 :     sy = motion_y & s_mask;
    1463      126300 :     src_x += motion_x >> lowres + 1;
    1464      126300 :     src_y += motion_y >> lowres + 1;
    1465             : 
    1466      126300 :     src   += src_y * stride + src_x;
    1467             : 
    1468      252600 :     if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w,                 0) ||
    1469      126300 :         (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
    1470         596 :         s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, src,
    1471             :                                  s->linesize, s->linesize,
    1472         298 :                                  w + 1, (h + 1) << field_based,
    1473             :                                  src_x, src_y   << field_based,
    1474             :                                  h_edge_pos, v_edge_pos);
    1475         298 :         src = s->sc.edge_emu_buffer;
    1476         298 :         emu = 1;
    1477             :     }
    1478             : 
    1479      126300 :     sx = (sx << 2) >> lowres;
    1480      126300 :     sy = (sy << 2) >> lowres;
    1481      126300 :     if (field_select)
    1482           0 :         src += s->linesize;
    1483      126300 :     pix_op[op_index](dest, src, stride, h, sx, sy);
    1484      126300 :     return emu;
    1485             : }
    1486             : 
    1487             : /* apply one mpeg motion vector to the three components */
    1488       24814 : static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
    1489             :                                                 uint8_t *dest_y,
    1490             :                                                 uint8_t *dest_cb,
    1491             :                                                 uint8_t *dest_cr,
    1492             :                                                 int field_based,
    1493             :                                                 int bottom_field,
    1494             :                                                 int field_select,
    1495             :                                                 uint8_t **ref_picture,
    1496             :                                                 h264_chroma_mc_func *pix_op,
    1497             :                                                 int motion_x, int motion_y,
    1498             :                                                 int h, int mb_y)
    1499             : {
    1500             :     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
    1501             :     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, sx, sy, uvsx, uvsy;
    1502             :     ptrdiff_t uvlinesize, linesize;
    1503       24814 :     const int lowres     = s->avctx->lowres;
    1504       24814 :     const int op_index   = FFMIN(lowres-1+s->chroma_x_shift, 3);
    1505       24814 :     const int block_s    = 8>>lowres;
    1506       24814 :     const int s_mask     = (2 << lowres) - 1;
    1507       24814 :     const int h_edge_pos = s->h_edge_pos >> lowres;
    1508       24814 :     const int v_edge_pos = s->v_edge_pos >> lowres;
    1509       24814 :     linesize   = s->current_picture.f->linesize[0] << field_based;
    1510       24814 :     uvlinesize = s->current_picture.f->linesize[1] << field_based;
    1511             : 
    1512             :     // FIXME obviously not perfect but qpel will not work in lowres anyway
    1513       24814 :     if (s->quarter_sample) {
    1514           0 :         motion_x /= 2;
    1515           0 :         motion_y /= 2;
    1516             :     }
    1517             : 
    1518       24814 :     if(field_based){
    1519           0 :         motion_y += (bottom_field - field_select)*((1 << lowres)-1);
    1520             :     }
    1521             : 
    1522       24814 :     sx = motion_x & s_mask;
    1523       24814 :     sy = motion_y & s_mask;
    1524       24814 :     src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
    1525       24814 :     src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
    1526             : 
    1527       24814 :     if (s->out_format == FMT_H263) {
    1528       24814 :         uvsx    = ((motion_x >> 1) & s_mask) | (sx & 1);
    1529       24814 :         uvsy    = ((motion_y >> 1) & s_mask) | (sy & 1);
    1530       24814 :         uvsrc_x = src_x >> 1;
    1531       24814 :         uvsrc_y = src_y >> 1;
    1532           0 :     } else if (s->out_format == FMT_H261) {
    1533             :         // even chroma mv's are full pel in H261
    1534           0 :         mx      = motion_x / 4;
    1535           0 :         my      = motion_y / 4;
    1536           0 :         uvsx    = (2 * mx) & s_mask;
    1537           0 :         uvsy    = (2 * my) & s_mask;
    1538           0 :         uvsrc_x = s->mb_x * block_s + (mx >> lowres);
    1539           0 :         uvsrc_y =    mb_y * block_s + (my >> lowres);
    1540             :     } else {
    1541           0 :         if(s->chroma_y_shift){
    1542           0 :             mx      = motion_x / 2;
    1543           0 :             my      = motion_y / 2;
    1544           0 :             uvsx    = mx & s_mask;
    1545           0 :             uvsy    = my & s_mask;
    1546           0 :             uvsrc_x = s->mb_x * block_s                 + (mx >> lowres + 1);
    1547           0 :             uvsrc_y =   (mb_y * block_s >> field_based) + (my >> lowres + 1);
    1548             :         } else {
    1549           0 :             if(s->chroma_x_shift){
    1550             :             //Chroma422
    1551           0 :                 mx = motion_x / 2;
    1552           0 :                 uvsx = mx & s_mask;
    1553           0 :                 uvsy = motion_y & s_mask;
    1554           0 :                 uvsrc_y = src_y;
    1555           0 :                 uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
    1556             :             } else {
    1557             :             //Chroma444
    1558           0 :                 uvsx = motion_x & s_mask;
    1559           0 :                 uvsy = motion_y & s_mask;
    1560           0 :                 uvsrc_x = src_x;
    1561           0 :                 uvsrc_y = src_y;
    1562             :             }
    1563             :         }
    1564             :     }
    1565             : 
    1566       24814 :     ptr_y  = ref_picture[0] + src_y   * linesize   + src_x;
    1567       24814 :     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
    1568       24814 :     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
    1569             : 
    1570       49526 :     if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s,       0) || uvsrc_y<0 ||
    1571       24712 :         (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
    1572         197 :         s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr_y,
    1573             :                                  linesize >> field_based, linesize >> field_based,
    1574             :                                  17, 17 + field_based,
    1575             :                                 src_x, src_y << field_based, h_edge_pos,
    1576             :                                 v_edge_pos);
    1577         197 :         ptr_y = s->sc.edge_emu_buffer;
    1578             :         if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
    1579         197 :             uint8_t *ubuf = s->sc.edge_emu_buffer + 18 * s->linesize;
    1580         197 :             uint8_t *vbuf =ubuf + 10 * s->uvlinesize;
    1581         197 :             if (s->workaround_bugs & FF_BUG_IEDGE)
    1582           0 :                 vbuf -= s->uvlinesize;
    1583         197 :             s->vdsp.emulated_edge_mc(ubuf,  ptr_cb,
    1584             :                                      uvlinesize >> field_based, uvlinesize >> field_based,
    1585             :                                      9, 9 + field_based,
    1586             :                                     uvsrc_x, uvsrc_y << field_based,
    1587             :                                     h_edge_pos >> 1, v_edge_pos >> 1);
    1588         197 :             s->vdsp.emulated_edge_mc(vbuf,  ptr_cr,
    1589             :                                      uvlinesize >> field_based,uvlinesize >> field_based,
    1590             :                                      9, 9 + field_based,
    1591             :                                     uvsrc_x, uvsrc_y << field_based,
    1592             :                                     h_edge_pos >> 1, v_edge_pos >> 1);
    1593         197 :             ptr_cb = ubuf;
    1594         197 :             ptr_cr = vbuf;
    1595             :         }
    1596             :     }
    1597             : 
    1598             :     // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f->data
    1599       24814 :     if (bottom_field) {
    1600           0 :         dest_y  += s->linesize;
    1601           0 :         dest_cb += s->uvlinesize;
    1602           0 :         dest_cr += s->uvlinesize;
    1603             :     }
    1604             : 
    1605       24814 :     if (field_select) {
    1606           0 :         ptr_y   += s->linesize;
    1607           0 :         ptr_cb  += s->uvlinesize;
    1608           0 :         ptr_cr  += s->uvlinesize;
    1609             :     }
    1610             : 
    1611       24814 :     sx = (sx << 2) >> lowres;
    1612       24814 :     sy = (sy << 2) >> lowres;
    1613       24814 :     pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
    1614             : 
    1615             :     if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
    1616       24814 :         int hc = s->chroma_y_shift ? (h+1-bottom_field)>>1 : h;
    1617       24814 :         uvsx = (uvsx << 2) >> lowres;
    1618       24814 :         uvsy = (uvsy << 2) >> lowres;
    1619       24814 :         if (hc) {
    1620       24814 :             pix_op[op_index](dest_cb, ptr_cb, uvlinesize, hc, uvsx, uvsy);
    1621       24814 :             pix_op[op_index](dest_cr, ptr_cr, uvlinesize, hc, uvsx, uvsy);
    1622             :         }
    1623             :     }
    1624             :     // FIXME h261 lowres loop filter
    1625       24814 : }
    1626             : 
    1627       31575 : static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
    1628             :                                             uint8_t *dest_cb, uint8_t *dest_cr,
    1629             :                                             uint8_t **ref_picture,
    1630             :                                             h264_chroma_mc_func * pix_op,
    1631             :                                             int mx, int my)
    1632             : {
    1633       31575 :     const int lowres     = s->avctx->lowres;
    1634       31575 :     const int op_index   = FFMIN(lowres, 3);
    1635       31575 :     const int block_s    = 8 >> lowres;
    1636       31575 :     const int s_mask     = (2 << lowres) - 1;
    1637       31575 :     const int h_edge_pos = s->h_edge_pos >> lowres + 1;
    1638       31575 :     const int v_edge_pos = s->v_edge_pos >> lowres + 1;
    1639       31575 :     int emu = 0, src_x, src_y, sx, sy;
    1640             :     ptrdiff_t offset;
    1641             :     uint8_t *ptr;
    1642             : 
    1643       31575 :     if (s->quarter_sample) {
    1644           0 :         mx /= 2;
    1645           0 :         my /= 2;
    1646             :     }
    1647             : 
    1648             :     /* In case of 8X8, we construct a single chroma motion vector
    1649             :        with a special rounding */
    1650       31575 :     mx = ff_h263_round_chroma(mx);
    1651       31575 :     my = ff_h263_round_chroma(my);
    1652             : 
    1653       31575 :     sx = mx & s_mask;
    1654       31575 :     sy = my & s_mask;
    1655       31575 :     src_x = s->mb_x * block_s + (mx >> lowres + 1);
    1656       31575 :     src_y = s->mb_y * block_s + (my >> lowres + 1);
    1657             : 
    1658       31575 :     offset = src_y * s->uvlinesize + src_x;
    1659       31575 :     ptr = ref_picture[1] + offset;
    1660       63150 :     if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
    1661       31575 :         (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
    1662         144 :         s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr,
    1663             :                                  s->uvlinesize, s->uvlinesize,
    1664             :                                  9, 9,
    1665             :                                  src_x, src_y, h_edge_pos, v_edge_pos);
    1666         144 :         ptr = s->sc.edge_emu_buffer;
    1667         144 :         emu = 1;
    1668             :     }
    1669       31575 :     sx = (sx << 2) >> lowres;
    1670       31575 :     sy = (sy << 2) >> lowres;
    1671       31575 :     pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
    1672             : 
    1673       31575 :     ptr = ref_picture[2] + offset;
    1674       31575 :     if (emu) {
    1675         144 :         s->vdsp.emulated_edge_mc(s->sc.edge_emu_buffer, ptr,
    1676             :                                  s->uvlinesize, s->uvlinesize,
    1677             :                                  9, 9,
    1678             :                                  src_x, src_y, h_edge_pos, v_edge_pos);
    1679         144 :         ptr = s->sc.edge_emu_buffer;
    1680             :     }
    1681       31575 :     pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
    1682       31575 : }
    1683             : 
    1684             : /**
    1685             :  * motion compensation of a single macroblock
    1686             :  * @param s context
    1687             :  * @param dest_y luma destination pointer
    1688             :  * @param dest_cb chroma cb/u destination pointer
    1689             :  * @param dest_cr chroma cr/v destination pointer
    1690             :  * @param dir direction (0->forward, 1->backward)
    1691             :  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
    1692             :  * @param pix_op halfpel motion compensation function (average or put normally)
    1693             :  * the motion vectors are taken from s->mv and the MV type from s->mv_type
    1694             :  */
    1695       56389 : static inline void MPV_motion_lowres(MpegEncContext *s,
    1696             :                                      uint8_t *dest_y, uint8_t *dest_cb,
    1697             :                                      uint8_t *dest_cr,
    1698             :                                      int dir, uint8_t **ref_picture,
    1699             :                                      h264_chroma_mc_func *pix_op)
    1700             : {
    1701             :     int mx, my;
    1702             :     int mb_x, mb_y, i;
    1703       56389 :     const int lowres  = s->avctx->lowres;
    1704       56389 :     const int block_s = 8 >>lowres;
    1705             : 
    1706       56389 :     mb_x = s->mb_x;
    1707       56389 :     mb_y = s->mb_y;
    1708             : 
    1709       56389 :     switch (s->mv_type) {
    1710       24814 :     case MV_TYPE_16X16:
    1711       24814 :         mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
    1712             :                            0, 0, 0,
    1713             :                            ref_picture, pix_op,
    1714             :                            s->mv[dir][0][0], s->mv[dir][0][1],
    1715             :                            2 * block_s, mb_y);
    1716       24814 :         break;
    1717       31575 :     case MV_TYPE_8X8:
    1718       31575 :         mx = 0;
    1719       31575 :         my = 0;
    1720      157875 :         for (i = 0; i < 4; i++) {
    1721      884100 :             hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
    1722      252600 :                                s->linesize) * block_s,
    1723             :                                ref_picture[0], 0, 0,
    1724      126300 :                                (2 * mb_x + (i & 1)) * block_s,
    1725      126300 :                                (2 * mb_y + (i >> 1)) * block_s,
    1726             :                                s->width, s->height, s->linesize,
    1727      252600 :                                s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
    1728             :                                block_s, block_s, pix_op,
    1729             :                                s->mv[dir][i][0], s->mv[dir][i][1]);
    1730             : 
    1731      126300 :             mx += s->mv[dir][i][0];
    1732      126300 :             my += s->mv[dir][i][1];
    1733             :         }
    1734             : 
    1735             :         if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY))
    1736       31575 :             chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
    1737             :                                      pix_op, mx, my);
    1738       31575 :         break;
    1739           0 :     case MV_TYPE_FIELD:
    1740           0 :         if (s->picture_structure == PICT_FRAME) {
    1741             :             /* top field */
    1742           0 :             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
    1743             :                                1, 0, s->field_select[dir][0],
    1744             :                                ref_picture, pix_op,
    1745             :                                s->mv[dir][0][0], s->mv[dir][0][1],
    1746             :                                block_s, mb_y);
    1747             :             /* bottom field */
    1748           0 :             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
    1749             :                                1, 1, s->field_select[dir][1],
    1750             :                                ref_picture, pix_op,
    1751             :                                s->mv[dir][1][0], s->mv[dir][1][1],
    1752             :                                block_s, mb_y);
    1753             :         } else {
    1754           0 :             if (s->picture_structure != s->field_select[dir][0] + 1 &&
    1755           0 :                 s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
    1756           0 :                 ref_picture = s->current_picture_ptr->f->data;
    1757             : 
    1758             :             }
    1759           0 :             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
    1760             :                                0, 0, s->field_select[dir][0],
    1761             :                                ref_picture, pix_op,
    1762             :                                s->mv[dir][0][0],
    1763             :                                s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
    1764             :             }
    1765           0 :         break;
    1766           0 :     case MV_TYPE_16X8:
    1767           0 :         for (i = 0; i < 2; i++) {
    1768             :             uint8_t **ref2picture;
    1769             : 
    1770           0 :             if (s->picture_structure == s->field_select[dir][i] + 1 ||
    1771           0 :                 s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
    1772           0 :                 ref2picture = ref_picture;
    1773             :             } else {
    1774           0 :                 ref2picture = s->current_picture_ptr->f->data;
    1775             :             }
    1776             : 
    1777           0 :             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
    1778             :                                0, 0, s->field_select[dir][i],
    1779             :                                ref2picture, pix_op,
    1780           0 :                                s->mv[dir][i][0], s->mv[dir][i][1] +
    1781           0 :                                2 * block_s * i, block_s, mb_y >> 1);
    1782             : 
    1783           0 :             dest_y  +=  2 * block_s *  s->linesize;
    1784           0 :             dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
    1785           0 :             dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
    1786             :         }
    1787           0 :         break;
    1788           0 :     case MV_TYPE_DMV:
    1789           0 :         if (s->picture_structure == PICT_FRAME) {
    1790           0 :             for (i = 0; i < 2; i++) {
    1791             :                 int j;
    1792           0 :                 for (j = 0; j < 2; j++) {
    1793           0 :                     mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
    1794             :                                        1, j, j ^ i,
    1795             :                                        ref_picture, pix_op,
    1796           0 :                                        s->mv[dir][2 * i + j][0],
    1797           0 :                                        s->mv[dir][2 * i + j][1],
    1798             :                                        block_s, mb_y);
    1799             :                 }
    1800           0 :                 pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
    1801             :             }
    1802             :         } else {
    1803           0 :             for (i = 0; i < 2; i++) {
    1804           0 :                 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
    1805           0 :                                    0, 0, s->picture_structure != i + 1,
    1806             :                                    ref_picture, pix_op,
    1807           0 :                                    s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
    1808             :                                    2 * block_s, mb_y >> 1);
    1809             : 
    1810             :                 // after put we make avg of the same block
    1811           0 :                 pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
    1812             : 
    1813             :                 // opposite parity is always in the same
    1814             :                 // frame if this is second field
    1815           0 :                 if (!s->first_field) {
    1816           0 :                     ref_picture = s->current_picture_ptr->f->data;
    1817             :                 }
    1818             :             }
    1819             :         }
    1820           0 :         break;
    1821       56389 :     default:
    1822             :         av_assert2(0);
    1823             :     }
    1824       56389 : }
    1825             : 
    1826             : /**
    1827             :  * find the lowest MB row referenced in the MVs
    1828             :  */
    1829           0 : static int lowest_referenced_row(MpegEncContext *s, int dir)
    1830             : {
    1831           0 :     int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
    1832             :     int my, off, i, mvs;
    1833             : 
    1834           0 :     if (s->picture_structure != PICT_FRAME || s->mcsel)
    1835             :         goto unhandled;
    1836             : 
    1837           0 :     switch (s->mv_type) {
    1838           0 :         case MV_TYPE_16X16:
    1839           0 :             mvs = 1;
    1840           0 :             break;
    1841           0 :         case MV_TYPE_16X8:
    1842           0 :             mvs = 2;
    1843           0 :             break;
    1844           0 :         case MV_TYPE_8X8:
    1845           0 :             mvs = 4;
    1846           0 :             break;
    1847           0 :         default:
    1848           0 :             goto unhandled;
    1849             :     }
    1850             : 
    1851           0 :     for (i = 0; i < mvs; i++) {
    1852           0 :         my = s->mv[dir][i][1];
    1853           0 :         my_max = FFMAX(my_max, my);
    1854           0 :         my_min = FFMIN(my_min, my);
    1855             :     }
    1856             : 
    1857           0 :     off = ((FFMAX(-my_min, my_max)<<qpel_shift) + 63) >> 6;
    1858             : 
    1859           0 :     return av_clip(s->mb_y + off, 0, s->mb_height - 1);
    1860           0 : unhandled:
    1861           0 :     return s->mb_height-1;
    1862             : }
    1863             : 
    1864             : /* put block[] to dest[] */
    1865     4710854 : static inline void put_dct(MpegEncContext *s,
    1866             :                            int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
    1867             : {
    1868     4710854 :     s->dct_unquantize_intra(s, block, i, qscale);
    1869     4710854 :     s->idsp.idct_put(dest, line_size, block);
    1870     4710854 : }
    1871             : 
    1872             : /* add block[] to dest[] */
    1873    19413506 : static inline void add_dct(MpegEncContext *s,
    1874             :                            int16_t *block, int i, uint8_t *dest, int line_size)
    1875             : {
    1876    19413506 :     if (s->block_last_index[i] >= 0) {
    1877     7079053 :         s->idsp.idct_add(dest, line_size, block);
    1878             :     }
    1879    19413506 : }
    1880             : 
    1881    21901814 : static inline void add_dequant_dct(MpegEncContext *s,
    1882             :                            int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
    1883             : {
    1884    21901814 :     if (s->block_last_index[i] >= 0) {
    1885     9084572 :         s->dct_unquantize_inter(s, block, i, qscale);
    1886             : 
    1887     9084572 :         s->idsp.idct_add(dest, line_size, block);
    1888             :     }
    1889    21901814 : }
    1890             : 
    1891             : /**
    1892             :  * Clean dc, ac, coded_block for the current non-intra MB.
    1893             :  */
    1894      383901 : void ff_clean_intra_table_entries(MpegEncContext *s)
    1895             : {
    1896      383901 :     int wrap = s->b8_stride;
    1897      383901 :     int xy = s->block_index[0];
    1898             : 
    1899      767802 :     s->dc_val[0][xy           ] =
    1900     1151703 :     s->dc_val[0][xy + 1       ] =
    1901     1151703 :     s->dc_val[0][xy     + wrap] =
    1902      767802 :     s->dc_val[0][xy + 1 + wrap] = 1024;
    1903             :     /* ac pred */
    1904      383901 :     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
    1905      383901 :     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
    1906      383901 :     if (s->msmpeg4_version>=3) {
    1907       91402 :         s->coded_block[xy           ] =
    1908      137103 :         s->coded_block[xy + 1       ] =
    1909      137103 :         s->coded_block[xy     + wrap] =
    1910       91402 :         s->coded_block[xy + 1 + wrap] = 0;
    1911             :     }
    1912             :     /* chroma */
    1913      383901 :     wrap = s->mb_stride;
    1914      383901 :     xy = s->mb_x + s->mb_y * wrap;
    1915      767802 :     s->dc_val[1][xy] =
    1916      767802 :     s->dc_val[2][xy] = 1024;
    1917             :     /* ac pred */
    1918      383901 :     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
    1919      383901 :     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
    1920             : 
    1921      383901 :     s->mbintra_table[xy]= 0;
    1922      383901 : }
    1923             : 
    1924             : /* generic function called after a macroblock has been parsed by the
    1925             :    decoder or after it has been encoded by the encoder.
    1926             : 
    1927             :    Important variables used:
    1928             :    s->mb_intra : true if intra macroblock
    1929             :    s->mv_dir   : motion vector direction
    1930             :    s->mv_type  : motion vector type
    1931             :    s->mv       : motion vector
    1932             :    s->interlaced_dct : true if interlaced dct used (mpeg2)
    1933             :  */
    1934             : static av_always_inline
    1935     8892967 : void mpv_reconstruct_mb_internal(MpegEncContext *s, int16_t block[12][64],
    1936             :                             int lowres_flag, int is_mpeg12)
    1937             : {
    1938     8892967 :     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
    1939             : 
    1940             :     if (CONFIG_XVMC &&
    1941             :         s->avctx->hwaccel && s->avctx->hwaccel->decode_mb) {
    1942             :         s->avctx->hwaccel->decode_mb(s);//xvmc uses pblocks
    1943             :         return;
    1944             :     }
    1945             : 
    1946     8892967 :     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
    1947             :        /* print DCT coefficients */
    1948             :        int i,j;
    1949           0 :        av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
    1950           0 :        for(i=0; i<6; i++){
    1951           0 :            for(j=0; j<64; j++){
    1952           0 :                av_log(s->avctx, AV_LOG_DEBUG, "%5d",
    1953           0 :                       block[i][s->idsp.idct_permutation[j]]);
    1954             :            }
    1955           0 :            av_log(s->avctx, AV_LOG_DEBUG, "\n");
    1956             :        }
    1957             :     }
    1958             : 
    1959     8892967 :     s->current_picture.qscale_table[mb_xy] = s->qscale;
    1960             : 
    1961             :     /* update DC predictors for P macroblocks */
    1962     8892967 :     if (!s->mb_intra) {
    1963     7154430 :         if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
    1964     6659948 :             if(s->mbintra_table[mb_xy])
    1965      306277 :                 ff_clean_intra_table_entries(s);
    1966             :         } else {
    1967     3824456 :             s->last_dc[0] =
    1968     3824456 :             s->last_dc[1] =
    1969     3824456 :             s->last_dc[2] = 128 << s->intra_dc_precision;
    1970             :         }
    1971             :     }
    1972     1738537 :     else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
    1973      452318 :         s->mbintra_table[mb_xy]=1;
    1974             : 
    1975    17785934 :     if ((s->avctx->flags & AV_CODEC_FLAG_PSNR) || s->frame_skip_threshold || s->frame_skip_factor ||
    1976    15157957 :         !(s->encoding && (s->intra_only || s->pict_type == AV_PICTURE_TYPE_B) &&
    1977     1926989 :           s->avctx->mb_decision != FF_MB_DECISION_RD)) { // FIXME precalc
    1978             :         uint8_t *dest_y, *dest_cb, *dest_cr;
    1979             :         int dct_linesize, dct_offset;
    1980             :         op_pixels_func (*op_pix)[4];
    1981             :         qpel_mc_func (*op_qpix)[16];
    1982     7985773 :         const int linesize   = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
    1983     7985773 :         const int uvlinesize = s->current_picture.f->linesize[1];
    1984     7985773 :         const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
    1985     7985773 :         const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
    1986             : 
    1987             :         /* avoid copy if macroblock skipped in last frame too */
    1988             :         /* skip only during decoding as we might trash the buffers during encoding a bit */
    1989     7985773 :         if(!s->encoding){
    1990     4554966 :             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
    1991             : 
    1992     4554966 :             if (s->mb_skipped) {
    1993      322950 :                 s->mb_skipped= 0;
    1994             :                 av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
    1995      322950 :                 *mbskip_ptr = 1;
    1996     4232016 :             } else if(!s->current_picture.reference) {
    1997      886263 :                 *mbskip_ptr = 1;
    1998             :             } else{
    1999     3345753 :                 *mbskip_ptr = 0; /* not skipped */
    2000             :             }
    2001             :         }
    2002             : 
    2003     7985773 :         dct_linesize = linesize << s->interlaced_dct;
    2004     7985773 :         dct_offset   = s->interlaced_dct ? linesize : linesize * block_size;
    2005             : 
    2006     7985773 :         if(readable){
    2007     7014846 :             dest_y=  s->dest[0];
    2008     7014846 :             dest_cb= s->dest[1];
    2009     7014846 :             dest_cr= s->dest[2];
    2010             :         }else{
    2011      970927 :             dest_y = s->sc.b_scratchpad;
    2012      970927 :             dest_cb= s->sc.b_scratchpad+16*linesize;
    2013      970927 :             dest_cr= s->sc.b_scratchpad+32*linesize;
    2014             :         }
    2015             : 
    2016     7985773 :         if (!s->mb_intra) {
    2017             :             /* motion handling */
    2018             :             /* decoding or more than one mb_type (MC was already done otherwise) */
    2019     6937734 :             if(!s->encoding){
    2020             : 
    2021     3976864 :                 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
    2022           0 :                     if (s->mv_dir & MV_DIR_FORWARD) {
    2023           0 :                         ff_thread_await_progress(&s->last_picture_ptr->tf,
    2024             :                                                  lowest_referenced_row(s, 0),
    2025             :                                                  0);
    2026             :                     }
    2027           0 :                     if (s->mv_dir & MV_DIR_BACKWARD) {
    2028           0 :                         ff_thread_await_progress(&s->next_picture_ptr->tf,
    2029             :                                                  lowest_referenced_row(s, 1),
    2030             :                                                  0);
    2031             :                     }
    2032             :                 }
    2033             : 
    2034     3976864 :                 if(lowres_flag){
    2035       41123 :                     h264_chroma_mc_func *op_pix = s->h264chroma.put_h264_chroma_pixels_tab;
    2036             : 
    2037       41123 :                     if (s->mv_dir & MV_DIR_FORWARD) {
    2038       37429 :                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix);
    2039       37429 :                         op_pix = s->h264chroma.avg_h264_chroma_pixels_tab;
    2040             :                     }
    2041       41123 :                     if (s->mv_dir & MV_DIR_BACKWARD) {
    2042       18960 :                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix);
    2043             :                     }
    2044             :                 }else{
    2045     3935741 :                     op_qpix = s->me.qpel_put;
    2046     3935741 :                     if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
    2047     3176802 :                         op_pix = s->hdsp.put_pixels_tab;
    2048             :                     }else{
    2049      758939 :                         op_pix = s->hdsp.put_no_rnd_pixels_tab;
    2050             :                     }
    2051     3935741 :                     if (s->mv_dir & MV_DIR_FORWARD) {
    2052     3705148 :                         ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix, op_qpix);
    2053     3705148 :                         op_pix = s->hdsp.avg_pixels_tab;
    2054     3705148 :                         op_qpix= s->me.qpel_avg;
    2055             :                     }
    2056     3935741 :                     if (s->mv_dir & MV_DIR_BACKWARD) {
    2057      754504 :                         ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix, op_qpix);
    2058             :                     }
    2059             :                 }
    2060             :             }
    2061             : 
    2062             :             /* skip dequant / idct if we are really late ;) */
    2063     6937734 :             if(s->avctx->skip_idct){
    2064           0 :                 if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
    2065           0 :                    ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
    2066           0 :                    || s->avctx->skip_idct >= AVDISCARD_ALL)
    2067             :                     goto skip_idct;
    2068             :             }
    2069             : 
    2070             :             /* add dct residue */
    2071     8752576 :             if(s->encoding || !(   s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
    2072     3117654 :                                 || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
    2073     3534434 :                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
    2074     3534434 :                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
    2075     3534434 :                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
    2076     3534434 :                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
    2077             : 
    2078     3534434 :                 if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
    2079     3534434 :                     if (s->chroma_y_shift){
    2080     3186829 :                         add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
    2081     3186829 :                         add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
    2082             :                     }else{
    2083      347605 :                         dct_linesize >>= 1;
    2084      347605 :                         dct_offset >>=1;
    2085      347605 :                         add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
    2086      347605 :                         add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
    2087      347605 :                         add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
    2088      347605 :                         add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
    2089             :                     }
    2090             :                 }
    2091     3403300 :             } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
    2092     3213151 :                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
    2093     3213151 :                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
    2094     3213151 :                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
    2095     3213151 :                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
    2096             : 
    2097     3213151 :                 if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
    2098     3213151 :                     if(s->chroma_y_shift){//Chroma420
    2099     3145851 :                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
    2100     3145851 :                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
    2101             :                     }else{
    2102             :                         //chroma422
    2103       67300 :                         dct_linesize = uvlinesize << s->interlaced_dct;
    2104       67300 :                         dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
    2105             : 
    2106       67300 :                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
    2107       67300 :                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
    2108       67300 :                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
    2109       67300 :                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
    2110       67300 :                         if(!s->chroma_x_shift){//Chroma444
    2111           0 :                             add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
    2112           0 :                             add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
    2113           0 :                             add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
    2114           0 :                             add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
    2115             :                         }
    2116             :                     }
    2117             :                 }//fi gray
    2118             :             }
    2119             :             else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
    2120      190149 :                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
    2121             :             }
    2122             :         } else {
    2123             :             /* dct only in intra block */
    2124     1048039 :             if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
    2125      772139 :                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
    2126      772139 :                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
    2127      772139 :                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
    2128      772139 :                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
    2129             : 
    2130      772139 :                 if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
    2131      772139 :                     if(s->chroma_y_shift){
    2132      733129 :                         put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
    2133      733129 :                         put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
    2134             :                     }else{
    2135       39010 :                         dct_offset >>=1;
    2136       39010 :                         dct_linesize >>=1;
    2137       39010 :                         put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
    2138       39010 :                         put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
    2139       39010 :                         put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
    2140       39010 :                         put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
    2141             :                     }
    2142             :                 }
    2143             :             }else{
    2144      275900 :                 s->idsp.idct_put(dest_y,                           dct_linesize, block[0]);
    2145      275900 :                 s->idsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
    2146      275900 :                 s->idsp.idct_put(dest_y + dct_offset,              dct_linesize, block[2]);
    2147      275900 :                 s->idsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
    2148             : 
    2149             :                 if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
    2150      275900 :                     if(s->chroma_y_shift){
    2151      222090 :                         s->idsp.idct_put(dest_cb, uvlinesize, block[4]);
    2152      222090 :                         s->idsp.idct_put(dest_cr, uvlinesize, block[5]);
    2153             :                     }else{
    2154             : 
    2155       53810 :                         dct_linesize = uvlinesize << s->interlaced_dct;
    2156       53810 :                         dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
    2157             : 
    2158       53810 :                         s->idsp.idct_put(dest_cb,              dct_linesize, block[4]);
    2159       53810 :                         s->idsp.idct_put(dest_cr,              dct_linesize, block[5]);
    2160       53810 :                         s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
    2161       53810 :                         s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
    2162       53810 :                         if(!s->chroma_x_shift){//Chroma444
    2163           0 :                             s->idsp.idct_put(dest_cb + block_size,              dct_linesize, block[8]);
    2164           0 :                             s->idsp.idct_put(dest_cr + block_size,              dct_linesize, block[9]);
    2165           0 :                             s->idsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
    2166           0 :                             s->idsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
    2167             :                         }
    2168             :                     }
    2169             :                 }//gray
    2170             :             }
    2171             :         }
    2172     8039583 : skip_idct:
    2173     7985773 :         if(!readable){
    2174      970927 :             s->hdsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
    2175             :             if (!CONFIG_GRAY || !(s->avctx->flags & AV_CODEC_FLAG_GRAY)) {
    2176      970927 :                 s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
    2177      970927 :                 s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
    2178             :             }
    2179             :         }
    2180             :     }
    2181             : }
    2182             : 
    2183     8892967 : void ff_mpv_reconstruct_mb(MpegEncContext *s, int16_t block[12][64])
    2184             : {
    2185             : #if !CONFIG_SMALL
    2186     8892967 :     if(s->out_format == FMT_MPEG1) {
    2187     3647091 :         if(s->avctx->lowres) mpv_reconstruct_mb_internal(s, block, 1, 1);
    2188     3647091 :         else                 mpv_reconstruct_mb_internal(s, block, 0, 1);
    2189             :     } else
    2190             : #endif
    2191     5245876 :     if(s->avctx->lowres) mpv_reconstruct_mb_internal(s, block, 1, 0);
    2192     5202376 :     else                  mpv_reconstruct_mb_internal(s, block, 0, 0);
    2193     8892967 : }
    2194             : 
    2195      165590 : void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
    2196             : {
    2197      492442 :     ff_draw_horiz_band(s->avctx, s->current_picture_ptr->f,
    2198      326852 :                        s->last_picture_ptr ? s->last_picture_ptr->f : NULL, y, h, s->picture_structure,
    2199             :                        s->first_field, s->low_delay);
    2200      165590 : }
    2201             : 
    2202      837350 : void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
    2203      837350 :     const int linesize   = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
    2204      837350 :     const int uvlinesize = s->current_picture.f->linesize[1];
    2205      837350 :     const int mb_size= 4 - s->avctx->lowres;
    2206             : 
    2207      837350 :     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
    2208      837350 :     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
    2209      837350 :     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
    2210      837350 :     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
    2211      837350 :     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
    2212      837350 :     s->block_index[5]= s->mb_stride*(s->mb_y + s->mb_height + 2) + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
    2213             :     //block_index is not used by mpeg2, so it is not affected by chroma_format
    2214             : 
    2215      837350 :     s->dest[0] = s->current_picture.f->data[0] + (int)((s->mb_x - 1U) <<  mb_size);
    2216      837350 :     s->dest[1] = s->current_picture.f->data[1] + (int)((s->mb_x - 1U) << (mb_size - s->chroma_x_shift));
    2217      837350 :     s->dest[2] = s->current_picture.f->data[2] + (int)((s->mb_x - 1U) << (mb_size - s->chroma_x_shift));
    2218             : 
    2219      837350 :     if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
    2220             :     {
    2221      837350 :         if(s->picture_structure==PICT_FRAME){
    2222      806570 :         s->dest[0] += s->mb_y *   linesize << mb_size;
    2223      806570 :         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
    2224      806570 :         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
    2225             :         }else{
    2226       30780 :             s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
    2227       30780 :             s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
    2228       30780 :             s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
    2229             :             av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
    2230             :         }
    2231             :     }
    2232      837350 : }
    2233             : 
    2234          79 : void ff_mpeg_flush(AVCodecContext *avctx){
    2235             :     int i;
    2236          79 :     MpegEncContext *s = avctx->priv_data;
    2237             : 
    2238          79 :     if (!s || !s->picture)
    2239           0 :         return;
    2240             : 
    2241        2923 :     for (i = 0; i < MAX_PICTURE_COUNT; i++)
    2242        2844 :         ff_mpeg_unref_picture(s->avctx, &s->picture[i]);
    2243          79 :     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
    2244             : 
    2245          79 :     ff_mpeg_unref_picture(s->avctx, &s->current_picture);
    2246          79 :     ff_mpeg_unref_picture(s->avctx, &s->last_picture);
    2247          79 :     ff_mpeg_unref_picture(s->avctx, &s->next_picture);
    2248             : 
    2249          79 :     s->mb_x= s->mb_y= 0;
    2250          79 :     s->closed_gop= 0;
    2251             : 
    2252          79 :     s->parse_context.state= -1;
    2253          79 :     s->parse_context.frame_start_found= 0;
    2254          79 :     s->parse_context.overread= 0;
    2255          79 :     s->parse_context.overread_index= 0;
    2256          79 :     s->parse_context.index= 0;
    2257          79 :     s->parse_context.last_index= 0;
    2258          79 :     s->bitstream_buffer_size=0;
    2259          79 :     s->pp_time=0;
    2260             : }
    2261             : 
    2262             : /**
    2263             :  * set qscale and update qscale dependent variables.
    2264             :  */
    2265     1444630 : void ff_set_qscale(MpegEncContext * s, int qscale)
    2266             : {
    2267     1444630 :     if (qscale < 1)
    2268           0 :         qscale = 1;
    2269     1444630 :     else if (qscale > 31)
    2270           0 :         qscale = 31;
    2271             : 
    2272     1444630 :     s->qscale = qscale;
    2273     1444630 :     s->chroma_qscale= s->chroma_qscale_table[qscale];
    2274             : 
    2275     1444630 :     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
    2276     1444630 :     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
    2277     1444630 : }
    2278             : 
    2279      157442 : void ff_mpv_report_decode_progress(MpegEncContext *s)
    2280             : {
    2281      157442 :     if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->er.error_occurred)
    2282      116982 :         ff_thread_report_progress(&s->current_picture_ptr->tf, s->mb_y, 0);
    2283      157442 : }

Generated by: LCOV version 1.13