git.sesse.net Git - ffmpeg/blob - libavcodec/mpegvideo.c

   1 /*
   2  * The simplest mpeg encoder (well, it was the simplest!)
   3  * Copyright (c) 2000,2001 Fabrice Bellard
   4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   5  *
   6  * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
   7  *
   8  * This file is part of Libav.
   9  *
  10  * Libav is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * Libav is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with Libav; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  23  */
  24
  25 /**
  26  * @file
  27  * The simplest mpeg encoder (well, it was the simplest!).
  28  */
  29
  30 #include "libavutil/intmath.h"
  31 #include "libavutil/imgutils.h"
  32 #include "avcodec.h"
  33 #include "dsputil.h"
  34 #include "internal.h"
  35 #include "mpegvideo.h"
  36 #include "mpegvideo_common.h"
  37 #include "mjpegenc.h"
  38 #include "msmpeg4.h"
  39 #include "faandct.h"
  40 #include "xvmc_internal.h"
  41 #include "thread.h"
  42 #include <limits.h>
  43
  44 //#undef NDEBUG
  45 //#include <assert.h>
  46
  47 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
  48                                    DCTELEM *block, int n, int qscale);
  49 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
  50                                    DCTELEM *block, int n, int qscale);
  51 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
  52                                    DCTELEM *block, int n, int qscale);
  53 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
  54                                    DCTELEM *block, int n, int qscale);
  55 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
  56                                    DCTELEM *block, int n, int qscale);
  57 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
  58                                   DCTELEM *block, int n, int qscale);
  59 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
  60                                   DCTELEM *block, int n, int qscale);
  61
  62
  63 /* enable all paranoid tests for rounding, overflows, etc... */
  64 //#define PARANOID
  65
  66 //#define DEBUG
  67
  68
  69 static const uint8_t ff_default_chroma_qscale_table[32]={
  70 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
  71     0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
  72 };
  73
  74 const uint8_t ff_mpeg1_dc_scale_table[128]={
  75 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
  76     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  77     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  78     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  79     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  80 };
  81
  82 static const uint8_t mpeg2_dc_scale_table1[128]={
  83 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
  84     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  85     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  86     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  87     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  88 };
  89
  90 static const uint8_t mpeg2_dc_scale_table2[128]={
  91 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
  92     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  93     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  94     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  95     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  96 };
  97
  98 static const uint8_t mpeg2_dc_scale_table3[128]={
  99 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
 100     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 101     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 102     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 103     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 104 };
 105
 106 const uint8_t * const ff_mpeg2_dc_scale_table[4]={
 107     ff_mpeg1_dc_scale_table,
 108     mpeg2_dc_scale_table1,
 109     mpeg2_dc_scale_table2,
 110     mpeg2_dc_scale_table3,
 111 };
 112
 113 const enum PixelFormat ff_pixfmt_list_420[] = {
 114     PIX_FMT_YUV420P,
 115     PIX_FMT_NONE
 116 };
 117
 118 const enum PixelFormat ff_hwaccel_pixfmt_list_420[] = {
 119     PIX_FMT_DXVA2_VLD,
 120     PIX_FMT_VAAPI_VLD,
 121     PIX_FMT_YUV420P,
 122     PIX_FMT_NONE
 123 };
 124
 125 const uint8_t *ff_find_start_code(const uint8_t * restrict p, const uint8_t *end, uint32_t * restrict state){
 126     int i;
 127
 128     assert(p<=end);
 129     if(p>=end)
 130         return end;
 131
 132     for(i=0; i<3; i++){
 133         uint32_t tmp= *state << 8;
 134         *state= tmp + *(p++);
 135         if(tmp == 0x100 || p==end)
 136             return p;
 137     }
 138
 139     while(p<end){
 140         if     (p[-1] > 1      ) p+= 3;
 141         else if(p[-2]          ) p+= 2;
 142         else if(p[-3]|(p[-1]-1)) p++;
 143         else{
 144             p++;
 145             break;
 146         }
 147     }
 148
 149     p= FFMIN(p, end)-4;
 150     *state= AV_RB32(p);
 151
 152     return p+4;
 153 }
 154
 155 /* init common dct for both encoder and decoder */
 156 av_cold int ff_dct_common_init(MpegEncContext *s)
 157 {
 158     s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
 159     s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
 160     s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
 161     s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
 162     s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
 163     if(s->flags & CODEC_FLAG_BITEXACT)
 164         s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
 165     s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
 166
 167 #if   HAVE_MMX
 168     MPV_common_init_mmx(s);
 169 #elif ARCH_ALPHA
 170     MPV_common_init_axp(s);
 171 #elif CONFIG_MLIB
 172     MPV_common_init_mlib(s);
 173 #elif HAVE_MMI
 174     MPV_common_init_mmi(s);
 175 #elif ARCH_ARM
 176     MPV_common_init_arm(s);
 177 #elif HAVE_ALTIVEC
 178     MPV_common_init_altivec(s);
 179 #elif ARCH_BFIN
 180     MPV_common_init_bfin(s);
 181 #endif
 182
 183     /* load & permutate scantables
 184        note: only wmv uses different ones
 185     */
 186     if(s->alternate_scan){
 187         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
 188         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
 189     }else{
 190         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
 191         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
 192     }
 193     ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
 194     ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
 195
 196     return 0;
 197 }
 198
 199 void ff_copy_picture(Picture *dst, Picture *src){
 200     *dst = *src;
 201     dst->type= FF_BUFFER_TYPE_COPY;
 202 }
 203
 204 /**
 205  * Release a frame buffer
 206  */
 207 static void free_frame_buffer(MpegEncContext *s, Picture *pic)
 208 {
 209     ff_thread_release_buffer(s->avctx, (AVFrame*)pic);
 210     av_freep(&pic->hwaccel_picture_private);
 211 }
 212
 213 /**
 214  * Allocate a frame buffer
 215  */
 216 static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
 217 {
 218     int r;
 219
 220     if (s->avctx->hwaccel) {
 221         assert(!pic->hwaccel_picture_private);
 222         if (s->avctx->hwaccel->priv_data_size) {
 223             pic->hwaccel_picture_private = av_mallocz(s->avctx->hwaccel->priv_data_size);
 224             if (!pic->hwaccel_picture_private) {
 225                 av_log(s->avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
 226                 return -1;
 227             }
 228         }
 229     }
 230
 231     r = ff_thread_get_buffer(s->avctx, (AVFrame*)pic);
 232
 233     if (r<0 || !pic->age || !pic->type || !pic->data[0]) {
 234         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %d %p)\n", r, pic->age, pic->type, pic->data[0]);
 235         av_freep(&pic->hwaccel_picture_private);
 236         return -1;
 237     }
 238
 239     if (s->linesize && (s->linesize != pic->linesize[0] || s->uvlinesize != pic->linesize[1])) {
 240         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (stride changed)\n");
 241         free_frame_buffer(s, pic);
 242         return -1;
 243     }
 244
 245     if (pic->linesize[1] != pic->linesize[2]) {
 246         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (uv stride mismatch)\n");
 247         free_frame_buffer(s, pic);
 248         return -1;
 249     }
 250
 251     return 0;
 252 }
 253
 254 /**
 255  * allocates a Picture
 256  * The pixels are allocated/set by calling get_buffer() if shared=0
 257  */
 258 int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared){
 259     const int big_mb_num= s->mb_stride*(s->mb_height+1) + 1; //the +1 is needed so memset(,,stride*height) does not sig11
 260     const int mb_array_size= s->mb_stride*s->mb_height;
 261     const int b8_array_size= s->b8_stride*s->mb_height*2;
 262     const int b4_array_size= s->b4_stride*s->mb_height*4;
 263     int i;
 264     int r= -1;
 265
 266     if(shared){
 267         assert(pic->data[0]);
 268         assert(pic->type == 0 || pic->type == FF_BUFFER_TYPE_SHARED);
 269         pic->type= FF_BUFFER_TYPE_SHARED;
 270     }else{
 271         assert(!pic->data[0]);
 272
 273         if (alloc_frame_buffer(s, pic) < 0)
 274             return -1;
 275
 276         s->linesize  = pic->linesize[0];
 277         s->uvlinesize= pic->linesize[1];
 278     }
 279
 280     if(pic->qscale_table==NULL){
 281         if (s->encoding) {
 282             FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_var   , mb_array_size * sizeof(int16_t)  , fail)
 283             FF_ALLOCZ_OR_GOTO(s->avctx, pic->mc_mb_var, mb_array_size * sizeof(int16_t)  , fail)
 284             FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_mean  , mb_array_size * sizeof(int8_t )  , fail)
 285         }
 286
 287         FF_ALLOCZ_OR_GOTO(s->avctx, pic->mbskip_table , mb_array_size * sizeof(uint8_t)+2, fail) //the +2 is for the slice end check
 288         FF_ALLOCZ_OR_GOTO(s->avctx, pic->qscale_table , mb_array_size * sizeof(uint8_t)  , fail)
 289         FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_type_base , (big_mb_num + s->mb_stride) * sizeof(uint32_t), fail)
 290         pic->mb_type= pic->mb_type_base + 2*s->mb_stride+1;
 291         if(s->out_format == FMT_H264){
 292             for(i=0; i<2; i++){
 293                 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i], 2 * (b4_array_size+4)  * sizeof(int16_t), fail)
 294                 pic->motion_val[i]= pic->motion_val_base[i]+4;
 295                 FF_ALLOCZ_OR_GOTO(s->avctx, pic->ref_index[i], 4*mb_array_size * sizeof(uint8_t), fail)
 296             }
 297             pic->motion_subsample_log2= 2;
 298         }else if(s->out_format == FMT_H263 || s->encoding || (s->avctx->debug&FF_DEBUG_MV) || (s->avctx->debug_mv)){
 299             for(i=0; i<2; i++){
 300                 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i], 2 * (b8_array_size+4) * sizeof(int16_t), fail)
 301                 pic->motion_val[i]= pic->motion_val_base[i]+4;
 302                 FF_ALLOCZ_OR_GOTO(s->avctx, pic->ref_index[i], 4*mb_array_size * sizeof(uint8_t), fail)
 303             }
 304             pic->motion_subsample_log2= 3;
 305         }
 306         if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
 307             FF_ALLOCZ_OR_GOTO(s->avctx, pic->dct_coeff, 64 * mb_array_size * sizeof(DCTELEM)*6, fail)
 308         }
 309         pic->qstride= s->mb_stride;
 310         FF_ALLOCZ_OR_GOTO(s->avctx, pic->pan_scan , 1 * sizeof(AVPanScan), fail)
 311     }
 312
 313     /* It might be nicer if the application would keep track of these
 314      * but it would require an API change. */
 315     memmove(s->prev_pict_types+1, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE-1);
 316     s->prev_pict_types[0]= s->dropable ? AV_PICTURE_TYPE_B : s->pict_type;
 317     if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == AV_PICTURE_TYPE_B)
 318         pic->age= INT_MAX; // Skipped MBs in B-frames are quite rare in MPEG-1/2 and it is a bit tricky to skip them anyway.
 319     pic->owner2 = NULL;
 320
 321     return 0;
 322 fail: //for the FF_ALLOCZ_OR_GOTO macro
 323     if(r>=0)
 324         free_frame_buffer(s, pic);
 325     return -1;
 326 }
 327
 328 /**
 329  * deallocates a picture
 330  */
 331 static void free_picture(MpegEncContext *s, Picture *pic){
 332     int i;
 333
 334     if(pic->data[0] && pic->type!=FF_BUFFER_TYPE_SHARED){
 335         free_frame_buffer(s, pic);
 336     }
 337
 338     av_freep(&pic->mb_var);
 339     av_freep(&pic->mc_mb_var);
 340     av_freep(&pic->mb_mean);
 341     av_freep(&pic->mbskip_table);
 342     av_freep(&pic->qscale_table);
 343     av_freep(&pic->mb_type_base);
 344     av_freep(&pic->dct_coeff);
 345     av_freep(&pic->pan_scan);
 346     pic->mb_type= NULL;
 347     for(i=0; i<2; i++){
 348         av_freep(&pic->motion_val_base[i]);
 349         av_freep(&pic->ref_index[i]);
 350     }
 351
 352     if(pic->type == FF_BUFFER_TYPE_SHARED){
 353         for(i=0; i<4; i++){
 354             pic->base[i]=
 355             pic->data[i]= NULL;
 356         }
 357         pic->type= 0;
 358     }
 359 }
 360
 361 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base){
 362     int y_size = s->b8_stride * (2 * s->mb_height + 1);
 363     int c_size = s->mb_stride * (s->mb_height + 1);
 364     int yc_size = y_size + 2 * c_size;
 365     int i;
 366
 367     // edge emu needs blocksize + filter length - 1 (=17x17 for halfpel / 21x21 for h264)
 368     FF_ALLOCZ_OR_GOTO(s->avctx, s->allocated_edge_emu_buffer, (s->width+64)*2*21*2, fail); //(width + edge + align)*interlaced*MBsize*tolerance
 369     s->edge_emu_buffer= s->allocated_edge_emu_buffer + (s->width+64)*2*21;
 370
 371      //FIXME should be linesize instead of s->width*2 but that is not known before get_buffer()
 372     FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad,  (s->width+64)*4*16*2*sizeof(uint8_t), fail)
 373     s->me.temp=         s->me.scratchpad;
 374     s->rd_scratchpad=   s->me.scratchpad;
 375     s->b_scratchpad=    s->me.scratchpad;
 376     s->obmc_scratchpad= s->me.scratchpad + 16;
 377     if (s->encoding) {
 378         FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map      , ME_MAP_SIZE*sizeof(uint32_t), fail)
 379         FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map, ME_MAP_SIZE*sizeof(uint32_t), fail)
 380         if(s->avctx->noise_reduction){
 381             FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum, 2 * 64 * sizeof(int), fail)
 382         }
 383     }
 384     FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64*12*2 * sizeof(DCTELEM), fail)
 385     s->block= s->blocks[0];
 386
 387     for(i=0;i<12;i++){
 388         s->pblocks[i] = &s->block[i];
 389     }
 390
 391     if (s->out_format == FMT_H263) {
 392         /* ac values */
 393         FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base, yc_size * sizeof(int16_t) * 16, fail);
 394         s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
 395         s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
 396         s->ac_val[2] = s->ac_val[1] + c_size;
 397     }
 398
 399     return 0;
 400 fail:
 401     return -1; //free() through MPV_common_end()
 402 }
 403
 404 static void free_duplicate_context(MpegEncContext *s){
 405     if(s==NULL) return;
 406
 407     av_freep(&s->allocated_edge_emu_buffer); s->edge_emu_buffer= NULL;
 408     av_freep(&s->me.scratchpad);
 409     s->me.temp=
 410     s->rd_scratchpad=
 411     s->b_scratchpad=
 412     s->obmc_scratchpad= NULL;
 413
 414     av_freep(&s->dct_error_sum);
 415     av_freep(&s->me.map);
 416     av_freep(&s->me.score_map);
 417     av_freep(&s->blocks);
 418     av_freep(&s->ac_val_base);
 419     s->block= NULL;
 420 }
 421
 422 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src){
 423 #define COPY(a) bak->a= src->a
 424     COPY(allocated_edge_emu_buffer);
 425     COPY(edge_emu_buffer);
 426     COPY(me.scratchpad);
 427     COPY(me.temp);
 428     COPY(rd_scratchpad);
 429     COPY(b_scratchpad);
 430     COPY(obmc_scratchpad);
 431     COPY(me.map);
 432     COPY(me.score_map);
 433     COPY(blocks);
 434     COPY(block);
 435     COPY(start_mb_y);
 436     COPY(end_mb_y);
 437     COPY(me.map_generation);
 438     COPY(pb);
 439     COPY(dct_error_sum);
 440     COPY(dct_count[0]);
 441     COPY(dct_count[1]);
 442     COPY(ac_val_base);
 443     COPY(ac_val[0]);
 444     COPY(ac_val[1]);
 445     COPY(ac_val[2]);
 446 #undef COPY
 447 }
 448
 449 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src){
 450     MpegEncContext bak;
 451     int i;
 452     //FIXME copy only needed parts
 453 //START_TIMER
 454     backup_duplicate_context(&bak, dst);
 455     memcpy(dst, src, sizeof(MpegEncContext));
 456     backup_duplicate_context(dst, &bak);
 457     for(i=0;i<12;i++){
 458         dst->pblocks[i] = &dst->block[i];
 459     }
 460 //STOP_TIMER("update_duplicate_context") //about 10k cycles / 0.01 sec for 1000frames on 1ghz with 2 threads
 461 }
 462
 463 int ff_mpeg_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
 464 {
 465     MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
 466
 467     if(dst == src || !s1->context_initialized) return 0;
 468
 469     //FIXME can parameters change on I-frames? in that case dst may need a reinit
 470     if(!s->context_initialized){
 471         memcpy(s, s1, sizeof(MpegEncContext));
 472
 473         s->avctx                 = dst;
 474         s->picture_range_start  += MAX_PICTURE_COUNT;
 475         s->picture_range_end    += MAX_PICTURE_COUNT;
 476         s->bitstream_buffer      = NULL;
 477         s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
 478
 479         MPV_common_init(s);
 480     }
 481
 482     s->avctx->coded_height  = s1->avctx->coded_height;
 483     s->avctx->coded_width   = s1->avctx->coded_width;
 484     s->avctx->width         = s1->avctx->width;
 485     s->avctx->height        = s1->avctx->height;
 486
 487     s->coded_picture_number = s1->coded_picture_number;
 488     s->picture_number       = s1->picture_number;
 489     s->input_picture_number = s1->input_picture_number;
 490
 491     memcpy(s->picture, s1->picture, s1->picture_count * sizeof(Picture));
 492     memcpy(&s->last_picture, &s1->last_picture, (char*)&s1->last_picture_ptr - (char*)&s1->last_picture);
 493
 494     s->last_picture_ptr     = REBASE_PICTURE(s1->last_picture_ptr,    s, s1);
 495     s->current_picture_ptr  = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
 496     s->next_picture_ptr     = REBASE_PICTURE(s1->next_picture_ptr,    s, s1);
 497
 498     memcpy(s->prev_pict_types, s1->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE);
 499
 500     //Error/bug resilience
 501     s->next_p_frame_damaged = s1->next_p_frame_damaged;
 502     s->workaround_bugs      = s1->workaround_bugs;
 503
 504     //MPEG4 timing info
 505     memcpy(&s->time_increment_bits, &s1->time_increment_bits, (char*)&s1->shape - (char*)&s1->time_increment_bits);
 506
 507     //B-frame info
 508     s->max_b_frames         = s1->max_b_frames;
 509     s->low_delay            = s1->low_delay;
 510     s->dropable             = s1->dropable;
 511
 512     //DivX handling (doesn't work)
 513     s->divx_packed          = s1->divx_packed;
 514
 515     if(s1->bitstream_buffer){
 516         if (s1->bitstream_buffer_size + FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
 517             av_fast_malloc(&s->bitstream_buffer, &s->allocated_bitstream_buffer_size, s1->allocated_bitstream_buffer_size);
 518         s->bitstream_buffer_size  = s1->bitstream_buffer_size;
 519         memcpy(s->bitstream_buffer, s1->bitstream_buffer, s1->bitstream_buffer_size);
 520         memset(s->bitstream_buffer+s->bitstream_buffer_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
 521     }
 522
 523     //MPEG2/interlacing info
 524     memcpy(&s->progressive_sequence, &s1->progressive_sequence, (char*)&s1->rtp_mode - (char*)&s1->progressive_sequence);
 525
 526     if(!s1->first_field){
 527         s->last_pict_type= s1->pict_type;
 528         if (s1->current_picture_ptr) s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->quality;
 529
 530         if(s1->pict_type!=FF_B_TYPE){
 531             s->last_non_b_pict_type= s1->pict_type;
 532         }
 533     }
 534
 535     return 0;
 536 }
 537
 538 /**
 539  * sets the given MpegEncContext to common defaults (same for encoding and decoding).
 540  * the changed fields will not depend upon the prior state of the MpegEncContext.
 541  */
 542 void MPV_common_defaults(MpegEncContext *s){
 543     s->y_dc_scale_table=
 544     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 545     s->chroma_qscale_table= ff_default_chroma_qscale_table;
 546     s->progressive_frame= 1;
 547     s->progressive_sequence= 1;
 548     s->picture_structure= PICT_FRAME;
 549
 550     s->coded_picture_number = 0;
 551     s->picture_number = 0;
 552     s->input_picture_number = 0;
 553
 554     s->picture_in_gop_number = 0;
 555
 556     s->f_code = 1;
 557     s->b_code = 1;
 558
 559     s->picture_range_start = 0;
 560     s->picture_range_end = MAX_PICTURE_COUNT;
 561 }
 562
 563 /**
 564  * sets the given MpegEncContext to defaults for decoding.
 565  * the changed fields will not depend upon the prior state of the MpegEncContext.
 566  */
 567 void MPV_decode_defaults(MpegEncContext *s){
 568     MPV_common_defaults(s);
 569 }
 570
 571 /**
 572  * init common structure for both encoder and decoder.
 573  * this assumes that some variables like width/height are already set
 574  */
 575 av_cold int MPV_common_init(MpegEncContext *s)
 576 {
 577     int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y, threads;
 578
 579     if(s->codec_id == CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
 580         s->mb_height = (s->height + 31) / 32 * 2;
 581     else if (s->codec_id != CODEC_ID_H264)
 582         s->mb_height = (s->height + 15) / 16;
 583
 584     if(s->avctx->pix_fmt == PIX_FMT_NONE){
 585         av_log(s->avctx, AV_LOG_ERROR, "decoding to PIX_FMT_NONE is not supported.\n");
 586         return -1;
 587     }
 588
 589     if((s->encoding || (s->avctx->active_thread_type & FF_THREAD_SLICE)) &&
 590        (s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height))){
 591         av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
 592         return -1;
 593     }
 594
 595     if((s->width || s->height) && av_image_check_size(s->width, s->height, 0, s->avctx))
 596         return -1;
 597
 598     dsputil_init(&s->dsp, s->avctx);
 599     ff_dct_common_init(s);
 600
 601     s->flags= s->avctx->flags;
 602     s->flags2= s->avctx->flags2;
 603
 604     if (s->width && s->height) {
 605         s->mb_width  = (s->width  + 15) / 16;
 606         s->mb_stride = s->mb_width + 1;
 607         s->b8_stride = s->mb_width*2 + 1;
 608         s->b4_stride = s->mb_width*4 + 1;
 609         mb_array_size= s->mb_height * s->mb_stride;
 610         mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
 611
 612         /* set chroma shifts */
 613         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
 614                                       &(s->chroma_y_shift) );
 615
 616         /* set default edge pos, will be overriden in decode_header if needed */
 617         s->h_edge_pos= s->mb_width*16;
 618         s->v_edge_pos= s->mb_height*16;
 619
 620         s->mb_num = s->mb_width * s->mb_height;
 621
 622         s->block_wrap[0]=
 623         s->block_wrap[1]=
 624         s->block_wrap[2]=
 625         s->block_wrap[3]= s->b8_stride;
 626         s->block_wrap[4]=
 627         s->block_wrap[5]= s->mb_stride;
 628
 629         y_size = s->b8_stride * (2 * s->mb_height + 1);
 630         c_size = s->mb_stride * (s->mb_height + 1);
 631         yc_size = y_size + 2 * c_size;
 632
 633         /* convert fourcc to upper case */
 634         s->codec_tag = ff_toupper4(s->avctx->codec_tag);
 635
 636         s->stream_codec_tag = ff_toupper4(s->avctx->stream_codec_tag);
 637
 638         s->avctx->coded_frame= (AVFrame*)&s->current_picture;
 639
 640         FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num+1)*sizeof(int), fail) //error ressilience code looks cleaner with this
 641         for(y=0; y<s->mb_height; y++){
 642             for(x=0; x<s->mb_width; x++){
 643                 s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
 644             }
 645         }
 646         s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
 647
 648         if (s->encoding) {
 649             /* Allocate MV tables */
 650             FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t), fail)
 651             FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t), fail)
 652             FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t), fail)
 653             FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
 654             FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
 655             FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t), fail)
 656             s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
 657             s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
 658             s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
 659             s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
 660             s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
 661             s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
 662
 663             if(s->msmpeg4_version){
 664                 FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int), fail);
 665             }
 666             FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
 667
 668             /* Allocate MB type table */
 669             FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type  , mb_array_size * sizeof(uint16_t), fail) //needed for encoding
 670
 671             FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
 672
 673             FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix  , 64*32   * sizeof(int), fail)
 674             FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix  , 64*32   * sizeof(int), fail)
 675             FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t), fail)
 676             FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t), fail)
 677             FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
 678             FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
 679
 680             if(s->avctx->noise_reduction){
 681                 FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail)
 682             }
 683         }
 684     }
 685
 686     s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
 687     FF_ALLOCZ_OR_GOTO(s->avctx, s->picture, s->picture_count * sizeof(Picture), fail)
 688     for(i = 0; i < s->picture_count; i++) {
 689         avcodec_get_frame_defaults((AVFrame *)&s->picture[i]);
 690     }
 691
 692     if (s->width && s->height) {
 693         FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table, mb_array_size*sizeof(uint8_t), fail)
 694
 695         if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
 696             /* interlaced direct mode decoding tables */
 697             for(i=0; i<2; i++){
 698                 int j, k;
 699                 for(j=0; j<2; j++){
 700                     for(k=0; k<2; k++){
 701                         FF_ALLOCZ_OR_GOTO(s->avctx,    s->b_field_mv_table_base[i][j][k], mv_table_size * 2 * sizeof(int16_t), fail)
 702                         s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
 703                     }
 704                     FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
 705                     FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
 706                     s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j]+ s->mb_stride + 1;
 707                 }
 708                 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
 709             }
 710         }
 711         if (s->out_format == FMT_H263) {
 712             /* cbp values */
 713             FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
 714             s->coded_block= s->coded_block_base + s->b8_stride + 1;
 715
 716             /* cbp, ac_pred, pred_dir */
 717             FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table     , mb_array_size * sizeof(uint8_t), fail)
 718             FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail)
 719         }
 720
 721         if (s->h263_pred || s->h263_plus || !s->encoding) {
 722             /* dc values */
 723             //MN: we need these for error resilience of intra-frames
 724             FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
 725             s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
 726             s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
 727             s->dc_val[2] = s->dc_val[1] + c_size;
 728             for(i=0;i<yc_size;i++)
 729                 s->dc_val_base[i] = 1024;
 730         }
 731
 732         /* which mb is a intra block */
 733         FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
 734         memset(s->mbintra_table, 1, mb_array_size);
 735
 736         /* init macroblock skip table */
 737         FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size+2, fail);
 738         //Note the +1 is for a quicker mpeg4 slice_end detection
 739         FF_ALLOCZ_OR_GOTO(s->avctx, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE, fail);
 740
 741         s->parse_context.state= -1;
 742         if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
 743             s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
 744             s->visualization_buffer[1] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
 745             s->visualization_buffer[2] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
 746         }
 747     }
 748
 749     s->context_initialized = 1;
 750     s->thread_context[0]= s;
 751
 752     if (s->width && s->height) {
 753     if (s->encoding || (HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_SLICE)) {
 754         threads = s->avctx->thread_count;
 755
 756         for(i=1; i<threads; i++){
 757             s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
 758             memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
 759         }
 760
 761         for(i=0; i<threads; i++){
 762             if(init_duplicate_context(s->thread_context[i], s) < 0)
 763                 goto fail;
 764             s->thread_context[i]->start_mb_y= (s->mb_height*(i  ) + s->avctx->thread_count/2) / s->avctx->thread_count;
 765             s->thread_context[i]->end_mb_y  = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
 766         }
 767     } else {
 768         if(init_duplicate_context(s, s) < 0) goto fail;
 769         s->start_mb_y = 0;
 770         s->end_mb_y   = s->mb_height;
 771     }
 772     }
 773
 774     return 0;
 775  fail:
 776     MPV_common_end(s);
 777     return -1;
 778 }
 779
 780 /* init common structure for both encoder and decoder */
 781 void MPV_common_end(MpegEncContext *s)
 782 {
 783     int i, j, k;
 784
 785     if (s->encoding || (HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_SLICE)) {
 786         for(i=0; i<s->avctx->thread_count; i++){
 787             free_duplicate_context(s->thread_context[i]);
 788         }
 789         for(i=1; i<s->avctx->thread_count; i++){
 790             av_freep(&s->thread_context[i]);
 791         }
 792     } else free_duplicate_context(s);
 793
 794     av_freep(&s->parse_context.buffer);
 795     s->parse_context.buffer_size=0;
 796
 797     av_freep(&s->mb_type);
 798     av_freep(&s->p_mv_table_base);
 799     av_freep(&s->b_forw_mv_table_base);
 800     av_freep(&s->b_back_mv_table_base);
 801     av_freep(&s->b_bidir_forw_mv_table_base);
 802     av_freep(&s->b_bidir_back_mv_table_base);
 803     av_freep(&s->b_direct_mv_table_base);
 804     s->p_mv_table= NULL;
 805     s->b_forw_mv_table= NULL;
 806     s->b_back_mv_table= NULL;
 807     s->b_bidir_forw_mv_table= NULL;
 808     s->b_bidir_back_mv_table= NULL;
 809     s->b_direct_mv_table= NULL;
 810     for(i=0; i<2; i++){
 811         for(j=0; j<2; j++){
 812             for(k=0; k<2; k++){
 813                 av_freep(&s->b_field_mv_table_base[i][j][k]);
 814                 s->b_field_mv_table[i][j][k]=NULL;
 815             }
 816             av_freep(&s->b_field_select_table[i][j]);
 817             av_freep(&s->p_field_mv_table_base[i][j]);
 818             s->p_field_mv_table[i][j]=NULL;
 819         }
 820         av_freep(&s->p_field_select_table[i]);
 821     }
 822
 823     av_freep(&s->dc_val_base);
 824     av_freep(&s->coded_block_base);
 825     av_freep(&s->mbintra_table);
 826     av_freep(&s->cbp_table);
 827     av_freep(&s->pred_dir_table);
 828
 829     av_freep(&s->mbskip_table);
 830     av_freep(&s->prev_pict_types);
 831     av_freep(&s->bitstream_buffer);
 832     s->allocated_bitstream_buffer_size=0;
 833
 834     av_freep(&s->avctx->stats_out);
 835     av_freep(&s->ac_stats);
 836     av_freep(&s->error_status_table);
 837     av_freep(&s->mb_index2xy);
 838     av_freep(&s->lambda_table);
 839     av_freep(&s->q_intra_matrix);
 840     av_freep(&s->q_inter_matrix);
 841     av_freep(&s->q_intra_matrix16);
 842     av_freep(&s->q_inter_matrix16);
 843     av_freep(&s->input_picture);
 844     av_freep(&s->reordered_input_picture);
 845     av_freep(&s->dct_offset);
 846
 847     if(s->picture && !s->avctx->is_copy){
 848         for(i=0; i<s->picture_count; i++){
 849             free_picture(s, &s->picture[i]);
 850         }
 851     }
 852     av_freep(&s->picture);
 853     s->context_initialized = 0;
 854     s->last_picture_ptr=
 855     s->next_picture_ptr=
 856     s->current_picture_ptr= NULL;
 857     s->linesize= s->uvlinesize= 0;
 858
 859     for(i=0; i<3; i++)
 860         av_freep(&s->visualization_buffer[i]);
 861
 862     if(!(s->avctx->active_thread_type&FF_THREAD_FRAME))
 863         avcodec_default_free_buffers(s->avctx);
 864 }
 865
 866 void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
 867 {
 868     int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
 869     uint8_t index_run[MAX_RUN+1];
 870     int last, run, level, start, end, i;
 871
 872     /* If table is static, we can quit if rl->max_level[0] is not NULL */
 873     if(static_store && rl->max_level[0])
 874         return;
 875
 876     /* compute max_level[], max_run[] and index_run[] */
 877     for(last=0;last<2;last++) {
 878         if (last == 0) {
 879             start = 0;
 880             end = rl->last;
 881         } else {
 882             start = rl->last;
 883             end = rl->n;
 884         }
 885
 886         memset(max_level, 0, MAX_RUN + 1);
 887         memset(max_run, 0, MAX_LEVEL + 1);
 888         memset(index_run, rl->n, MAX_RUN + 1);
 889         for(i=start;i<end;i++) {
 890             run = rl->table_run[i];
 891             level = rl->table_level[i];
 892             if (index_run[run] == rl->n)
 893                 index_run[run] = i;
 894             if (level > max_level[run])
 895                 max_level[run] = level;
 896             if (run > max_run[level])
 897                 max_run[level] = run;
 898         }
 899         if(static_store)
 900             rl->max_level[last] = static_store[last];
 901         else
 902             rl->max_level[last] = av_malloc(MAX_RUN + 1);
 903         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
 904         if(static_store)
 905             rl->max_run[last] = static_store[last] + MAX_RUN + 1;
 906         else
 907             rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
 908         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
 909         if(static_store)
 910             rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
 911         else
 912             rl->index_run[last] = av_malloc(MAX_RUN + 1);
 913         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
 914     }
 915 }
 916
 917 void init_vlc_rl(RLTable *rl)
 918 {
 919     int i, q;
 920
 921     for(q=0; q<32; q++){
 922         int qmul= q*2;
 923         int qadd= (q-1)|1;
 924
 925         if(q==0){
 926             qmul=1;
 927             qadd=0;
 928         }
 929         for(i=0; i<rl->vlc.table_size; i++){
 930             int code= rl->vlc.table[i][0];
 931             int len = rl->vlc.table[i][1];
 932             int level, run;
 933
 934             if(len==0){ // illegal code
 935                 run= 66;
 936                 level= MAX_LEVEL;
 937             }else if(len<0){ //more bits needed
 938                 run= 0;
 939                 level= code;
 940             }else{
 941                 if(code==rl->n){ //esc
 942                     run= 66;
 943                     level= 0;
 944                 }else{
 945                     run=   rl->table_run  [code] + 1;
 946                     level= rl->table_level[code] * qmul + qadd;
 947                     if(code >= rl->last) run+=192;
 948                 }
 949             }
 950             rl->rl_vlc[q][i].len= len;
 951             rl->rl_vlc[q][i].level= level;
 952             rl->rl_vlc[q][i].run= run;
 953         }
 954     }
 955 }
 956
 957 void ff_release_unused_pictures(MpegEncContext *s, int remove_current)
 958 {
 959     int i;
 960
 961     /* release non reference frames */
 962     for(i=0; i<s->picture_count; i++){
 963         if(s->picture[i].data[0] && !s->picture[i].reference
 964            && (!s->picture[i].owner2 || s->picture[i].owner2 == s)
 965            && (remove_current || &s->picture[i] != s->current_picture_ptr)
 966            /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
 967             free_frame_buffer(s, &s->picture[i]);
 968         }
 969     }
 970 }
 971
 972 int ff_find_unused_picture(MpegEncContext *s, int shared){
 973     int i;
 974
 975     if(shared){
 976         for(i=s->picture_range_start; i<s->picture_range_end; i++){
 977             if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
 978         }
 979     }else{
 980         for(i=s->picture_range_start; i<s->picture_range_end; i++){
 981             if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
 982         }
 983         for(i=s->picture_range_start; i<s->picture_range_end; i++){
 984             if(s->picture[i].data[0]==NULL) return i;
 985         }
 986     }
 987
 988     av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflow\n");
 989     /* We could return -1, but the codec would crash trying to draw into a
 990      * non-existing frame anyway. This is safer than waiting for a random crash.
 991      * Also the return of this is never useful, an encoder must only allocate
 992      * as much as allowed in the specification. This has no relationship to how
 993      * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
 994      * enough for such valid streams).
 995      * Plus, a decoder has to check stream validity and remove frames if too
 996      * many reference frames are around. Waiting for "OOM" is not correct at
 997      * all. Similarly, missing reference frames have to be replaced by
 998      * interpolated/MC frames, anything else is a bug in the codec ...
 999      */
1000     abort();
1001     return -1;
1002 }
1003
1004 static void update_noise_reduction(MpegEncContext *s){
1005     int intra, i;
1006
1007     for(intra=0; intra<2; intra++){
1008         if(s->dct_count[intra] > (1<<16)){
1009             for(i=0; i<64; i++){
1010                 s->dct_error_sum[intra][i] >>=1;
1011             }
1012             s->dct_count[intra] >>= 1;
1013         }
1014
1015         for(i=0; i<64; i++){
1016             s->dct_offset[intra][i]= (s->avctx->noise_reduction * s->dct_count[intra] + s->dct_error_sum[intra][i]/2) / (s->dct_error_sum[intra][i]+1);
1017         }
1018     }
1019 }
1020
1021 /**
1022  * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1023  */
1024 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1025 {
1026     int i;
1027     Picture *pic;
1028     s->mb_skipped = 0;
1029
1030     assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1031
1032     /* mark&release old frames */
1033     if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1034       if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1035           free_frame_buffer(s, s->last_picture_ptr);
1036
1037         /* release forgotten pictures */
1038         /* if(mpeg124/h263) */
1039         if(!s->encoding){
1040             for(i=0; i<s->picture_count; i++){
1041                 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1042                     av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1043                     free_frame_buffer(s, &s->picture[i]);
1044                 }
1045             }
1046         }
1047       }
1048     }
1049
1050     if(!s->encoding){
1051         ff_release_unused_pictures(s, 1);
1052
1053         if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1054             pic= s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
1055         else{
1056             i= ff_find_unused_picture(s, 0);
1057             pic= &s->picture[i];
1058         }
1059
1060         pic->reference= 0;
1061         if (!s->dropable){
1062             if (s->codec_id == CODEC_ID_H264)
1063                 pic->reference = s->picture_structure;
1064             else if (s->pict_type != AV_PICTURE_TYPE_B)
1065                 pic->reference = 3;
1066         }
1067
1068         pic->coded_picture_number= s->coded_picture_number++;
1069
1070         if(ff_alloc_picture(s, pic, 0) < 0)
1071             return -1;
1072
1073         s->current_picture_ptr= pic;
1074         //FIXME use only the vars from current_pic
1075         s->current_picture_ptr->top_field_first= s->top_field_first;
1076         if(s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO) {
1077             if(s->picture_structure != PICT_FRAME)
1078                 s->current_picture_ptr->top_field_first= (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1079         }
1080         s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1081         s->current_picture_ptr->field_picture= s->picture_structure != PICT_FRAME;
1082     }
1083
1084     s->current_picture_ptr->pict_type= s->pict_type;
1085 //    if(s->flags && CODEC_FLAG_QSCALE)
1086   //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1087     s->current_picture_ptr->key_frame= s->pict_type == AV_PICTURE_TYPE_I;
1088
1089     ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1090
1091     if (s->pict_type != AV_PICTURE_TYPE_B) {
1092         s->last_picture_ptr= s->next_picture_ptr;
1093         if(!s->dropable)
1094             s->next_picture_ptr= s->current_picture_ptr;
1095     }
1096 /*    av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n", s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1097         s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
1098         s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
1099         s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1100         s->pict_type, s->dropable);*/
1101
1102     if(s->codec_id != CODEC_ID_H264){
1103         if((s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) &&
1104            (s->pict_type!=AV_PICTURE_TYPE_I || s->picture_structure != PICT_FRAME)){
1105             if (s->pict_type != AV_PICTURE_TYPE_I)
1106                 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1107             else if (s->picture_structure != PICT_FRAME)
1108                 av_log(avctx, AV_LOG_INFO, "allocate dummy last picture for field based first keyframe\n");
1109
1110             /* Allocate a dummy frame */
1111             i= ff_find_unused_picture(s, 0);
1112             s->last_picture_ptr= &s->picture[i];
1113             if(ff_alloc_picture(s, s->last_picture_ptr, 0) < 0)
1114                 return -1;
1115             ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 0);
1116             ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 1);
1117         }
1118         if((s->next_picture_ptr==NULL || s->next_picture_ptr->data[0]==NULL) && s->pict_type==AV_PICTURE_TYPE_B){
1119             /* Allocate a dummy frame */
1120             i= ff_find_unused_picture(s, 0);
1121             s->next_picture_ptr= &s->picture[i];
1122             if(ff_alloc_picture(s, s->next_picture_ptr, 0) < 0)
1123                 return -1;
1124             ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 0);
1125             ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 1);
1126         }
1127     }
1128
1129     if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1130     if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1131
1132     assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1133
1134     if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
1135         int i;
1136         for(i=0; i<4; i++){
1137             if(s->picture_structure == PICT_BOTTOM_FIELD){
1138                  s->current_picture.data[i] += s->current_picture.linesize[i];
1139             }
1140             s->current_picture.linesize[i] *= 2;
1141             s->last_picture.linesize[i] *=2;
1142             s->next_picture.linesize[i] *=2;
1143         }
1144     }
1145
1146     s->error_recognition= avctx->error_recognition;
1147
1148     /* set dequantizer, we can't do it during init as it might change for mpeg4
1149        and we can't do it in the header decode as init is not called for mpeg4 there yet */
1150     if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1151         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1152         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1153     }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1154         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1155         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1156     }else{
1157         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1158         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1159     }
1160
1161     if(s->dct_error_sum){
1162         assert(s->avctx->noise_reduction && s->encoding);
1163
1164         update_noise_reduction(s);
1165     }
1166
1167     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1168         return ff_xvmc_field_start(s, avctx);
1169
1170     return 0;
1171 }
1172
1173 /* generic function for encode/decode called after a frame has been coded/decoded */
1174 void MPV_frame_end(MpegEncContext *s)
1175 {
1176     int i;
1177     /* redraw edges for the frame if decoding didn't complete */
1178     //just to make sure that all data is rendered.
1179     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1180         ff_xvmc_field_end(s);
1181    }else if((s->error_count || s->encoding)
1182        && !s->avctx->hwaccel
1183        && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
1184        && s->unrestricted_mv
1185        && s->current_picture.reference
1186        && !s->intra_only
1187        && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1188             s->dsp.draw_edges(s->current_picture.data[0], s->linesize  ,
1189                               s->h_edge_pos   , s->v_edge_pos   ,
1190                               EDGE_WIDTH  , EDGE_TOP | EDGE_BOTTOM);
1191             s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize,
1192                               s->h_edge_pos>>1, s->v_edge_pos>>1,
1193                               EDGE_WIDTH/2, EDGE_TOP | EDGE_BOTTOM);
1194             s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize,
1195                               s->h_edge_pos>>1, s->v_edge_pos>>1,
1196                               EDGE_WIDTH/2, EDGE_TOP | EDGE_BOTTOM);
1197     }
1198
1199     emms_c();
1200
1201     s->last_pict_type    = s->pict_type;
1202     s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1203     if(s->pict_type!=AV_PICTURE_TYPE_B){
1204         s->last_non_b_pict_type= s->pict_type;
1205     }
1206 #if 0
1207         /* copy back current_picture variables */
1208     for(i=0; i<MAX_PICTURE_COUNT; i++){
1209         if(s->picture[i].data[0] == s->current_picture.data[0]){
1210             s->picture[i]= s->current_picture;
1211             break;
1212         }
1213     }
1214     assert(i<MAX_PICTURE_COUNT);
1215 #endif
1216
1217     if(s->encoding){
1218         /* release non-reference frames */
1219         for(i=0; i<s->picture_count; i++){
1220             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1221                 free_frame_buffer(s, &s->picture[i]);
1222             }
1223         }
1224     }
1225     // clear copies, to avoid confusion
1226 #if 0
1227     memset(&s->last_picture, 0, sizeof(Picture));
1228     memset(&s->next_picture, 0, sizeof(Picture));
1229     memset(&s->current_picture, 0, sizeof(Picture));
1230 #endif
1231     s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1232
1233     if (s->codec_id != CODEC_ID_H264 && s->current_picture.reference) {
1234         ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_height-1, 0);
1235     }
1236 }
1237
1238 /**
1239  * draws an line from (ex, ey) -> (sx, sy).
1240  * @param w width of the image
1241  * @param h height of the image
1242  * @param stride stride/linesize of the image
1243  * @param color color of the arrow
1244  */
1245 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1246     int x, y, fr, f;
1247
1248     sx= av_clip(sx, 0, w-1);
1249     sy= av_clip(sy, 0, h-1);
1250     ex= av_clip(ex, 0, w-1);
1251     ey= av_clip(ey, 0, h-1);
1252
1253     buf[sy*stride + sx]+= color;
1254
1255     if(FFABS(ex - sx) > FFABS(ey - sy)){
1256         if(sx > ex){
1257             FFSWAP(int, sx, ex);
1258             FFSWAP(int, sy, ey);
1259         }
1260         buf+= sx + sy*stride;
1261         ex-= sx;
1262         f= ((ey-sy)<<16)/ex;
1263         for(x= 0; x <= ex; x++){
1264             y = (x*f)>>16;
1265             fr= (x*f)&0xFFFF;
1266             buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1267             buf[(y+1)*stride + x]+= (color*         fr )>>16;
1268         }
1269     }else{
1270         if(sy > ey){
1271             FFSWAP(int, sx, ex);
1272             FFSWAP(int, sy, ey);
1273         }
1274         buf+= sx + sy*stride;
1275         ey-= sy;
1276         if(ey) f= ((ex-sx)<<16)/ey;
1277         else   f= 0;
1278         for(y= 0; y <= ey; y++){
1279             x = (y*f)>>16;
1280             fr= (y*f)&0xFFFF;
1281             buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;
1282             buf[y*stride + x+1]+= (color*         fr )>>16;
1283         }
1284     }
1285 }
1286
1287 /**
1288  * draws an arrow from (ex, ey) -> (sx, sy).
1289  * @param w width of the image
1290  * @param h height of the image
1291  * @param stride stride/linesize of the image
1292  * @param color color of the arrow
1293  */
1294 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1295     int dx,dy;
1296
1297     sx= av_clip(sx, -100, w+100);
1298     sy= av_clip(sy, -100, h+100);
1299     ex= av_clip(ex, -100, w+100);
1300     ey= av_clip(ey, -100, h+100);
1301
1302     dx= ex - sx;
1303     dy= ey - sy;
1304
1305     if(dx*dx + dy*dy > 3*3){
1306         int rx=  dx + dy;
1307         int ry= -dx + dy;
1308         int length= ff_sqrt((rx*rx + ry*ry)<<8);
1309
1310         //FIXME subpixel accuracy
1311         rx= ROUNDED_DIV(rx*3<<4, length);
1312         ry= ROUNDED_DIV(ry*3<<4, length);
1313
1314         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1315         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1316     }
1317     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1318 }
1319
1320 /**
1321  * prints debuging info for the given picture.
1322  */
1323 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1324
1325     if(s->avctx->hwaccel || !pict || !pict->mb_type) return;
1326
1327     if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1328         int x,y;
1329
1330         av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1331         switch (pict->pict_type) {
1332             case AV_PICTURE_TYPE_I: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1333             case AV_PICTURE_TYPE_P: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1334             case AV_PICTURE_TYPE_B: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1335             case AV_PICTURE_TYPE_S: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1336             case AV_PICTURE_TYPE_SI: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1337             case AV_PICTURE_TYPE_SP: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1338         }
1339         for(y=0; y<s->mb_height; y++){
1340             for(x=0; x<s->mb_width; x++){
1341                 if(s->avctx->debug&FF_DEBUG_SKIP){
1342                     int count= s->mbskip_table[x + y*s->mb_stride];
1343                     if(count>9) count=9;
1344                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1345                 }
1346                 if(s->avctx->debug&FF_DEBUG_QP){
1347                     av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1348                 }
1349                 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1350                     int mb_type= pict->mb_type[x + y*s->mb_stride];
1351                     //Type & MV direction
1352                     if(IS_PCM(mb_type))
1353                         av_log(s->avctx, AV_LOG_DEBUG, "P");
1354                     else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1355                         av_log(s->avctx, AV_LOG_DEBUG, "A");
1356                     else if(IS_INTRA4x4(mb_type))
1357                         av_log(s->avctx, AV_LOG_DEBUG, "i");
1358                     else if(IS_INTRA16x16(mb_type))
1359                         av_log(s->avctx, AV_LOG_DEBUG, "I");
1360                     else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1361                         av_log(s->avctx, AV_LOG_DEBUG, "d");
1362                     else if(IS_DIRECT(mb_type))
1363                         av_log(s->avctx, AV_LOG_DEBUG, "D");
1364                     else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1365                         av_log(s->avctx, AV_LOG_DEBUG, "g");
1366                     else if(IS_GMC(mb_type))
1367                         av_log(s->avctx, AV_LOG_DEBUG, "G");
1368                     else if(IS_SKIP(mb_type))
1369                         av_log(s->avctx, AV_LOG_DEBUG, "S");
1370                     else if(!USES_LIST(mb_type, 1))
1371                         av_log(s->avctx, AV_LOG_DEBUG, ">");
1372                     else if(!USES_LIST(mb_type, 0))
1373                         av_log(s->avctx, AV_LOG_DEBUG, "<");
1374                     else{
1375                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1376                         av_log(s->avctx, AV_LOG_DEBUG, "X");
1377                     }
1378
1379                     //segmentation
1380                     if(IS_8X8(mb_type))
1381                         av_log(s->avctx, AV_LOG_DEBUG, "+");
1382                     else if(IS_16X8(mb_type))
1383                         av_log(s->avctx, AV_LOG_DEBUG, "-");
1384                     else if(IS_8X16(mb_type))
1385                         av_log(s->avctx, AV_LOG_DEBUG, "|");
1386                     else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1387                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1388                     else
1389                         av_log(s->avctx, AV_LOG_DEBUG, "?");
1390
1391
1392                     if(IS_INTERLACED(mb_type))
1393                         av_log(s->avctx, AV_LOG_DEBUG, "=");
1394                     else
1395                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1396                 }
1397 //                av_log(s->avctx, AV_LOG_DEBUG, " ");
1398             }
1399             av_log(s->avctx, AV_LOG_DEBUG, "\n");
1400         }
1401     }
1402
1403     if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1404         const int shift= 1 + s->quarter_sample;
1405         int mb_y;
1406         uint8_t *ptr;
1407         int i;
1408         int h_chroma_shift, v_chroma_shift, block_height;
1409         const int width = s->avctx->width;
1410         const int height= s->avctx->height;
1411         const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1412         const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1413         s->low_delay=0; //needed to see the vectors without trashing the buffers
1414
1415         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1416         for(i=0; i<3; i++){
1417             memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1418             pict->data[i]= s->visualization_buffer[i];
1419         }
1420         pict->type= FF_BUFFER_TYPE_COPY;
1421         ptr= pict->data[0];
1422         block_height = 16>>v_chroma_shift;
1423
1424         for(mb_y=0; mb_y<s->mb_height; mb_y++){
1425             int mb_x;
1426             for(mb_x=0; mb_x<s->mb_width; mb_x++){
1427                 const int mb_index= mb_x + mb_y*s->mb_stride;
1428                 if((s->avctx->debug_mv) && pict->motion_val){
1429                   int type;
1430                   for(type=0; type<3; type++){
1431                     int direction = 0;
1432                     switch (type) {
1433                       case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=AV_PICTURE_TYPE_P))
1434                                 continue;
1435                               direction = 0;
1436                               break;
1437                       case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=AV_PICTURE_TYPE_B))
1438                                 continue;
1439                               direction = 0;
1440                               break;
1441                       case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=AV_PICTURE_TYPE_B))
1442                                 continue;
1443                               direction = 1;
1444                               break;
1445                     }
1446                     if(!USES_LIST(pict->mb_type[mb_index], direction))
1447                         continue;
1448
1449                     if(IS_8X8(pict->mb_type[mb_index])){
1450                       int i;
1451                       for(i=0; i<4; i++){
1452                         int sx= mb_x*16 + 4 + 8*(i&1);
1453                         int sy= mb_y*16 + 4 + 8*(i>>1);
1454                         int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1455                         int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1456                         int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1457                         draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1458                       }
1459                     }else if(IS_16X8(pict->mb_type[mb_index])){
1460                       int i;
1461                       for(i=0; i<2; i++){
1462                         int sx=mb_x*16 + 8;
1463                         int sy=mb_y*16 + 4 + 8*i;
1464                         int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1465                         int mx=(pict->motion_val[direction][xy][0]>>shift);
1466                         int my=(pict->motion_val[direction][xy][1]>>shift);
1467
1468                         if(IS_INTERLACED(pict->mb_type[mb_index]))
1469                             my*=2;
1470
1471                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1472                       }
1473                     }else if(IS_8X16(pict->mb_type[mb_index])){
1474                       int i;
1475                       for(i=0; i<2; i++){
1476                         int sx=mb_x*16 + 4 + 8*i;
1477                         int sy=mb_y*16 + 8;
1478                         int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1479                         int mx=(pict->motion_val[direction][xy][0]>>shift);
1480                         int my=(pict->motion_val[direction][xy][1]>>shift);
1481
1482                         if(IS_INTERLACED(pict->mb_type[mb_index]))
1483                             my*=2;
1484
1485                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1486                       }
1487                     }else{
1488                       int sx= mb_x*16 + 8;
1489                       int sy= mb_y*16 + 8;
1490                       int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1491                       int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1492                       int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1493                       draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1494                     }
1495                   }
1496                 }
1497                 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1498                     uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1499                     int y;
1500                     for(y=0; y<block_height; y++){
1501                         *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1502                         *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1503                     }
1504                 }
1505                 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1506                     int mb_type= pict->mb_type[mb_index];
1507                     uint64_t u,v;
1508                     int y;
1509 #define COLOR(theta, r)\
1510 u= (int)(128 + r*cos(theta*3.141592/180));\
1511 v= (int)(128 + r*sin(theta*3.141592/180));
1512
1513
1514                     u=v=128;
1515                     if(IS_PCM(mb_type)){
1516                         COLOR(120,48)
1517                     }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1518                         COLOR(30,48)
1519                     }else if(IS_INTRA4x4(mb_type)){
1520                         COLOR(90,48)
1521                     }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1522 //                        COLOR(120,48)
1523                     }else if(IS_DIRECT(mb_type)){
1524                         COLOR(150,48)
1525                     }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1526                         COLOR(170,48)
1527                     }else if(IS_GMC(mb_type)){
1528                         COLOR(190,48)
1529                     }else if(IS_SKIP(mb_type)){
1530 //                        COLOR(180,48)
1531                     }else if(!USES_LIST(mb_type, 1)){
1532                         COLOR(240,48)
1533                     }else if(!USES_LIST(mb_type, 0)){
1534                         COLOR(0,48)
1535                     }else{
1536                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1537                         COLOR(300,48)
1538                     }
1539
1540                     u*= 0x0101010101010101ULL;
1541                     v*= 0x0101010101010101ULL;
1542                     for(y=0; y<block_height; y++){
1543                         *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1544                         *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1545                     }
1546
1547                     //segmentation
1548                     if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1549                         *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1550                         *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1551                     }
1552                     if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1553                         for(y=0; y<16; y++)
1554                             pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1555                     }
1556                     if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1557                         int dm= 1 << (mv_sample_log2-2);
1558                         for(i=0; i<4; i++){
1559                             int sx= mb_x*16 + 8*(i&1);
1560                             int sy= mb_y*16 + 8*(i>>1);
1561                             int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1562                             //FIXME bidir
1563                             int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1564                             if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1565                                 for(y=0; y<8; y++)
1566                                     pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1567                             if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1568                                 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1569                         }
1570                     }
1571
1572                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1573                         // hmm
1574                     }
1575                 }
1576                 s->mbskip_table[mb_index]=0;
1577             }
1578         }
1579     }
1580 }
1581
1582 static inline int hpel_motion_lowres(MpegEncContext *s,
1583                                   uint8_t *dest, uint8_t *src,
1584                                   int field_based, int field_select,
1585                                   int src_x, int src_y,
1586                                   int width, int height, int stride,
1587                                   int h_edge_pos, int v_edge_pos,
1588                                   int w, int h, h264_chroma_mc_func *pix_op,
1589                                   int motion_x, int motion_y)
1590 {
1591     const int lowres= s->avctx->lowres;
1592     const int op_index= FFMIN(lowres, 2);
1593     const int s_mask= (2<<lowres)-1;
1594     int emu=0;
1595     int sx, sy;
1596
1597     if(s->quarter_sample){
1598         motion_x/=2;
1599         motion_y/=2;
1600     }
1601
1602     sx= motion_x & s_mask;
1603     sy= motion_y & s_mask;
1604     src_x += motion_x >> (lowres+1);
1605     src_y += motion_y >> (lowres+1);
1606
1607     src += src_y * stride + src_x;
1608
1609     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
1610        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1611         s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1612                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1613         src= s->edge_emu_buffer;
1614         emu=1;
1615     }
1616
1617     sx= (sx << 2) >> lowres;
1618     sy= (sy << 2) >> lowres;
1619     if(field_select)
1620         src += s->linesize;
1621     pix_op[op_index](dest, src, stride, h, sx, sy);
1622     return emu;
1623 }
1624
1625 /* apply one mpeg motion vector to the three components */
1626 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1627                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1628                                int field_based, int bottom_field, int field_select,
1629                                uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1630                                int motion_x, int motion_y, int h, int mb_y)
1631 {
1632     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1633     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1634     const int lowres= s->avctx->lowres;
1635     const int op_index= FFMIN(lowres, 2);
1636     const int block_s= 8>>lowres;
1637     const int s_mask= (2<<lowres)-1;
1638     const int h_edge_pos = s->h_edge_pos >> lowres;
1639     const int v_edge_pos = s->v_edge_pos >> lowres;
1640     linesize   = s->current_picture.linesize[0] << field_based;
1641     uvlinesize = s->current_picture.linesize[1] << field_based;
1642
1643     if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1644         motion_x/=2;
1645         motion_y/=2;
1646     }
1647
1648     if(field_based){
1649         motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1650     }
1651
1652     sx= motion_x & s_mask;
1653     sy= motion_y & s_mask;
1654     src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
1655     src_y =(   mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1656
1657     if (s->out_format == FMT_H263) {
1658         uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1659         uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1660         uvsrc_x = src_x>>1;
1661         uvsrc_y = src_y>>1;
1662     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1663         mx = motion_x / 4;
1664         my = motion_y / 4;
1665         uvsx = (2*mx) & s_mask;
1666         uvsy = (2*my) & s_mask;
1667         uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
1668         uvsrc_y =    mb_y*block_s               + (my >> lowres);
1669     } else {
1670         mx = motion_x / 2;
1671         my = motion_y / 2;
1672         uvsx = mx & s_mask;
1673         uvsy = my & s_mask;
1674         uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
1675         uvsrc_y =(   mb_y*block_s>>field_based) + (my >> (lowres+1));
1676     }
1677
1678     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
1679     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1680     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1681
1682     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
1683        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1684             s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1685                              src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1686             ptr_y = s->edge_emu_buffer;
1687             if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1688                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1689                 s->dsp.emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
1690                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1691                 s->dsp.emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1692                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1693                 ptr_cb= uvbuf;
1694                 ptr_cr= uvbuf+16;
1695             }
1696     }
1697
1698     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1699         dest_y += s->linesize;
1700         dest_cb+= s->uvlinesize;
1701         dest_cr+= s->uvlinesize;
1702     }
1703
1704     if(field_select){
1705         ptr_y += s->linesize;
1706         ptr_cb+= s->uvlinesize;
1707         ptr_cr+= s->uvlinesize;
1708     }
1709
1710     sx= (sx << 2) >> lowres;
1711     sy= (sy << 2) >> lowres;
1712     pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1713
1714     if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1715         uvsx= (uvsx << 2) >> lowres;
1716         uvsy= (uvsy << 2) >> lowres;
1717         pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1718         pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1719     }
1720     //FIXME h261 lowres loop filter
1721 }
1722
1723 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1724                                      uint8_t *dest_cb, uint8_t *dest_cr,
1725                                      uint8_t **ref_picture,
1726                                      h264_chroma_mc_func *pix_op,
1727                                      int mx, int my){
1728     const int lowres= s->avctx->lowres;
1729     const int op_index= FFMIN(lowres, 2);
1730     const int block_s= 8>>lowres;
1731     const int s_mask= (2<<lowres)-1;
1732     const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1733     const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1734     int emu=0, src_x, src_y, offset, sx, sy;
1735     uint8_t *ptr;
1736
1737     if(s->quarter_sample){
1738         mx/=2;
1739         my/=2;
1740     }
1741
1742     /* In case of 8X8, we construct a single chroma motion vector
1743        with a special rounding */
1744     mx= ff_h263_round_chroma(mx);
1745     my= ff_h263_round_chroma(my);
1746
1747     sx= mx & s_mask;
1748     sy= my & s_mask;
1749     src_x = s->mb_x*block_s + (mx >> (lowres+1));
1750     src_y = s->mb_y*block_s + (my >> (lowres+1));
1751
1752     offset = src_y * s->uvlinesize + src_x;
1753     ptr = ref_picture[1] + offset;
1754     if(s->flags&CODEC_FLAG_EMU_EDGE){
1755         if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1756            || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1757             s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1758             ptr= s->edge_emu_buffer;
1759             emu=1;
1760         }
1761     }
1762     sx= (sx << 2) >> lowres;
1763     sy= (sy << 2) >> lowres;
1764     pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1765
1766     ptr = ref_picture[2] + offset;
1767     if(emu){
1768         s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1769         ptr= s->edge_emu_buffer;
1770     }
1771     pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1772 }
1773
1774 /**
1775  * motion compensation of a single macroblock
1776  * @param s context
1777  * @param dest_y luma destination pointer
1778  * @param dest_cb chroma cb/u destination pointer
1779  * @param dest_cr chroma cr/v destination pointer
1780  * @param dir direction (0->forward, 1->backward)
1781  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1782  * @param pix_op halfpel motion compensation function (average or put normally)
1783  * the motion vectors are taken from s->mv and the MV type from s->mv_type
1784  */
1785 static inline void MPV_motion_lowres(MpegEncContext *s,
1786                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1787                               int dir, uint8_t **ref_picture,
1788                               h264_chroma_mc_func *pix_op)
1789 {
1790     int mx, my;
1791     int mb_x, mb_y, i;
1792     const int lowres= s->avctx->lowres;
1793     const int block_s= 8>>lowres;
1794
1795     mb_x = s->mb_x;
1796     mb_y = s->mb_y;
1797
1798     switch(s->mv_type) {
1799     case MV_TYPE_16X16:
1800         mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1801                     0, 0, 0,
1802                     ref_picture, pix_op,
1803                     s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y);
1804         break;
1805     case MV_TYPE_8X8:
1806         mx = 0;
1807         my = 0;
1808             for(i=0;i<4;i++) {
1809                 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1810                             ref_picture[0], 0, 0,
1811                             (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1812                             s->width, s->height, s->linesize,
1813                             s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1814                             block_s, block_s, pix_op,
1815                             s->mv[dir][i][0], s->mv[dir][i][1]);
1816
1817                 mx += s->mv[dir][i][0];
1818                 my += s->mv[dir][i][1];
1819             }
1820
1821         if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1822             chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1823         break;
1824     case MV_TYPE_FIELD:
1825         if (s->picture_structure == PICT_FRAME) {
1826             /* top field */
1827             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1828                         1, 0, s->field_select[dir][0],
1829                         ref_picture, pix_op,
1830                         s->mv[dir][0][0], s->mv[dir][0][1], block_s, mb_y);
1831             /* bottom field */
1832             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1833                         1, 1, s->field_select[dir][1],
1834                         ref_picture, pix_op,
1835                         s->mv[dir][1][0], s->mv[dir][1][1], block_s, mb_y);
1836         } else {
1837             if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != AV_PICTURE_TYPE_B && !s->first_field){
1838                 ref_picture= s->current_picture_ptr->data;
1839             }
1840
1841             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1842                         0, 0, s->field_select[dir][0],
1843                         ref_picture, pix_op,
1844                         s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y>>1);
1845         }
1846         break;
1847     case MV_TYPE_16X8:
1848         for(i=0; i<2; i++){
1849             uint8_t ** ref2picture;
1850
1851             if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == AV_PICTURE_TYPE_B || s->first_field){
1852                 ref2picture= ref_picture;
1853             }else{
1854                 ref2picture= s->current_picture_ptr->data;
1855             }
1856
1857             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1858                         0, 0, s->field_select[dir][i],
1859                         ref2picture, pix_op,
1860                         s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s, mb_y>>1);
1861
1862             dest_y += 2*block_s*s->linesize;
1863             dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1864             dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1865         }
1866         break;
1867     case MV_TYPE_DMV:
1868         if(s->picture_structure == PICT_FRAME){
1869             for(i=0; i<2; i++){
1870                 int j;
1871                 for(j=0; j<2; j++){
1872                     mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1873                                 1, j, j^i,
1874                                 ref_picture, pix_op,
1875                                 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s, mb_y);
1876                 }
1877                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1878             }
1879         }else{
1880             for(i=0; i<2; i++){
1881                 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1882                             0, 0, s->picture_structure != i+1,
1883                             ref_picture, pix_op,
1884                             s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s, mb_y>>1);
1885
1886                 // after put we make avg of the same block
1887                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1888
1889                 //opposite parity is always in the same frame if this is second field
1890                 if(!s->first_field){
1891                     ref_picture = s->current_picture_ptr->data;
1892                 }
1893             }
1894         }
1895     break;
1896     default: assert(0);
1897     }
1898 }
1899
1900 /**
1901  * find the lowest MB row referenced in the MVs
1902  */
1903 int MPV_lowest_referenced_row(MpegEncContext *s, int dir)
1904 {
1905     int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
1906     int my, off, i, mvs;
1907
1908     if (s->picture_structure != PICT_FRAME) goto unhandled;
1909
1910     switch (s->mv_type) {
1911         case MV_TYPE_16X16:
1912             mvs = 1;
1913             break;
1914         case MV_TYPE_16X8:
1915             mvs = 2;
1916             break;
1917         case MV_TYPE_8X8:
1918             mvs = 4;
1919             break;
1920         default:
1921             goto unhandled;
1922     }
1923
1924     for (i = 0; i < mvs; i++) {
1925         my = s->mv[dir][i][1]<<qpel_shift;
1926         my_max = FFMAX(my_max, my);
1927         my_min = FFMIN(my_min, my);
1928     }
1929
1930     off = (FFMAX(-my_min, my_max) + 63) >> 6;
1931
1932     return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
1933 unhandled:
1934     return s->mb_height-1;
1935 }
1936
1937 /* put block[] to dest[] */
1938 static inline void put_dct(MpegEncContext *s,
1939                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1940 {
1941     s->dct_unquantize_intra(s, block, i, qscale);
1942     s->dsp.idct_put (dest, line_size, block);
1943 }
1944
1945 /* add block[] to dest[] */
1946 static inline void add_dct(MpegEncContext *s,
1947                            DCTELEM *block, int i, uint8_t *dest, int line_size)
1948 {
1949     if (s->block_last_index[i] >= 0) {
1950         s->dsp.idct_add (dest, line_size, block);
1951     }
1952 }
1953
1954 static inline void add_dequant_dct(MpegEncContext *s,
1955                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1956 {
1957     if (s->block_last_index[i] >= 0) {
1958         s->dct_unquantize_inter(s, block, i, qscale);
1959
1960         s->dsp.idct_add (dest, line_size, block);
1961     }
1962 }
1963
1964 /**
1965  * cleans dc, ac, coded_block for the current non intra MB
1966  */
1967 void ff_clean_intra_table_entries(MpegEncContext *s)
1968 {
1969     int wrap = s->b8_stride;
1970     int xy = s->block_index[0];
1971
1972     s->dc_val[0][xy           ] =
1973     s->dc_val[0][xy + 1       ] =
1974     s->dc_val[0][xy     + wrap] =
1975     s->dc_val[0][xy + 1 + wrap] = 1024;
1976     /* ac pred */
1977     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
1978     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1979     if (s->msmpeg4_version>=3) {
1980         s->coded_block[xy           ] =
1981         s->coded_block[xy + 1       ] =
1982         s->coded_block[xy     + wrap] =
1983         s->coded_block[xy + 1 + wrap] = 0;
1984     }
1985     /* chroma */
1986     wrap = s->mb_stride;
1987     xy = s->mb_x + s->mb_y * wrap;
1988     s->dc_val[1][xy] =
1989     s->dc_val[2][xy] = 1024;
1990     /* ac pred */
1991     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1992     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1993
1994     s->mbintra_table[xy]= 0;
1995 }
1996
1997 /* generic function called after a macroblock has been parsed by the
1998    decoder or after it has been encoded by the encoder.
1999
2000    Important variables used:
2001    s->mb_intra : true if intra macroblock
2002    s->mv_dir   : motion vector direction
2003    s->mv_type  : motion vector type
2004    s->mv       : motion vector
2005    s->interlaced_dct : true if interlaced dct used (mpeg2)
2006  */
2007 static av_always_inline
2008 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
2009                             int lowres_flag, int is_mpeg12)
2010 {
2011     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2012     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2013         ff_xvmc_decode_mb(s);//xvmc uses pblocks
2014         return;
2015     }
2016
2017     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2018        /* save DCT coefficients */
2019        int i,j;
2020        DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
2021        av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2022        for(i=0; i<6; i++){
2023            for(j=0; j<64; j++){
2024                *dct++ = block[i][s->dsp.idct_permutation[j]];
2025                av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
2026            }
2027            av_log(s->avctx, AV_LOG_DEBUG, "\n");
2028        }
2029     }
2030
2031     s->current_picture.qscale_table[mb_xy]= s->qscale;
2032
2033     /* update DC predictors for P macroblocks */
2034     if (!s->mb_intra) {
2035         if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2036             if(s->mbintra_table[mb_xy])
2037                 ff_clean_intra_table_entries(s);
2038         } else {
2039             s->last_dc[0] =
2040             s->last_dc[1] =
2041             s->last_dc[2] = 128 << s->intra_dc_precision;
2042         }
2043     }
2044     else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2045         s->mbintra_table[mb_xy]=1;
2046
2047     if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==AV_PICTURE_TYPE_B) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
2048         uint8_t *dest_y, *dest_cb, *dest_cr;
2049         int dct_linesize, dct_offset;
2050         op_pixels_func (*op_pix)[4];
2051         qpel_mc_func (*op_qpix)[16];
2052         const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2053         const int uvlinesize= s->current_picture.linesize[1];
2054         const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2055         const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2056
2057         /* avoid copy if macroblock skipped in last frame too */
2058         /* skip only during decoding as we might trash the buffers during encoding a bit */
2059         if(!s->encoding){
2060             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2061             const int age= s->current_picture.age;
2062
2063             assert(age);
2064
2065             if (s->mb_skipped) {
2066                 s->mb_skipped= 0;
2067                 assert(s->pict_type!=AV_PICTURE_TYPE_I);
2068
2069                 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
2070                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2071
2072                 /* if previous was skipped too, then nothing to do !  */
2073                 if (*mbskip_ptr >= age && s->current_picture.reference){
2074                     return;
2075                 }
2076             } else if(!s->current_picture.reference){
2077                 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2078                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2079             } else{
2080                 *mbskip_ptr = 0; /* not skipped */
2081             }
2082         }
2083
2084         dct_linesize = linesize << s->interlaced_dct;
2085         dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
2086
2087         if(readable){
2088             dest_y=  s->dest[0];
2089             dest_cb= s->dest[1];
2090             dest_cr= s->dest[2];
2091         }else{
2092             dest_y = s->b_scratchpad;
2093             dest_cb= s->b_scratchpad+16*linesize;
2094             dest_cr= s->b_scratchpad+32*linesize;
2095         }
2096
2097         if (!s->mb_intra) {
2098             /* motion handling */
2099             /* decoding or more than one mb_type (MC was already done otherwise) */
2100             if(!s->encoding){
2101
2102                 if(HAVE_PTHREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2103                     if (s->mv_dir & MV_DIR_FORWARD) {
2104                         ff_thread_await_progress((AVFrame*)s->last_picture_ptr, MPV_lowest_referenced_row(s, 0), 0);
2105                     }
2106                     if (s->mv_dir & MV_DIR_BACKWARD) {
2107                         ff_thread_await_progress((AVFrame*)s->next_picture_ptr, MPV_lowest_referenced_row(s, 1), 0);
2108                     }
2109                 }
2110
2111                 if(lowres_flag){
2112                     h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
2113
2114                     if (s->mv_dir & MV_DIR_FORWARD) {
2115                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
2116                         op_pix = s->dsp.avg_h264_chroma_pixels_tab;
2117                     }
2118                     if (s->mv_dir & MV_DIR_BACKWARD) {
2119                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
2120                     }
2121                 }else{
2122                     op_qpix= s->me.qpel_put;
2123                     if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2124                         op_pix = s->dsp.put_pixels_tab;
2125                     }else{
2126                         op_pix = s->dsp.put_no_rnd_pixels_tab;
2127                     }
2128                     if (s->mv_dir & MV_DIR_FORWARD) {
2129                         MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2130                         op_pix = s->dsp.avg_pixels_tab;
2131                         op_qpix= s->me.qpel_avg;
2132                     }
2133                     if (s->mv_dir & MV_DIR_BACKWARD) {
2134                         MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2135                     }
2136                 }
2137             }
2138
2139             /* skip dequant / idct if we are really late ;) */
2140             if(s->avctx->skip_idct){
2141                 if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2142                    ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2143                    || s->avctx->skip_idct >= AVDISCARD_ALL)
2144                     goto skip_idct;
2145             }
2146
2147             /* add dct residue */
2148             if(s->encoding || !(   s->msmpeg4_version || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
2149                                 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2150                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2151                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2152                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2153                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2154
2155                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2156                     if (s->chroma_y_shift){
2157                         add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2158                         add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2159                     }else{
2160                         dct_linesize >>= 1;
2161                         dct_offset >>=1;
2162                         add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2163                         add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2164                         add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2165                         add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2166                     }
2167                 }
2168             } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
2169                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
2170                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
2171                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
2172                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2173
2174                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2175                     if(s->chroma_y_shift){//Chroma420
2176                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
2177                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
2178                     }else{
2179                         //chroma422
2180                         dct_linesize = uvlinesize << s->interlaced_dct;
2181                         dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2182
2183                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
2184                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
2185                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2186                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2187                         if(!s->chroma_x_shift){//Chroma444
2188                             add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
2189                             add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
2190                             add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
2191                             add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
2192                         }
2193                     }
2194                 }//fi gray
2195             }
2196             else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2197                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2198             }
2199         } else {
2200             /* dct only in intra block */
2201             if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
2202                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2203                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2204                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2205                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2206
2207                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2208                     if(s->chroma_y_shift){
2209                         put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2210                         put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2211                     }else{
2212                         dct_offset >>=1;
2213                         dct_linesize >>=1;
2214                         put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2215                         put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2216                         put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2217                         put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2218                     }
2219                 }
2220             }else{
2221                 s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
2222                 s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
2223                 s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
2224                 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2225
2226                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2227                     if(s->chroma_y_shift){
2228                         s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2229                         s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2230                     }else{
2231
2232                         dct_linesize = uvlinesize << s->interlaced_dct;
2233                         dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2234
2235                         s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
2236                         s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
2237                         s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2238                         s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2239                         if(!s->chroma_x_shift){//Chroma444
2240                             s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
2241                             s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
2242                             s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2243                             s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2244                         }
2245                     }
2246                 }//gray
2247             }
2248         }
2249 skip_idct:
2250         if(!readable){
2251             s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
2252             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2253             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2254         }
2255     }
2256 }
2257
2258 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2259 #if !CONFIG_SMALL
2260     if(s->out_format == FMT_MPEG1) {
2261         if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2262         else                 MPV_decode_mb_internal(s, block, 0, 1);
2263     } else
2264 #endif
2265     if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2266     else                  MPV_decode_mb_internal(s, block, 0, 0);
2267 }
2268
2269 /**
2270  *
2271  * @param h is the normal height, this will be reduced automatically if needed for the last row
2272  */
2273 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2274     const int field_pic= s->picture_structure != PICT_FRAME;
2275     if(field_pic){
2276         h <<= 1;
2277         y <<= 1;
2278     }
2279
2280     if (!s->avctx->hwaccel
2281        && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2282        && s->unrestricted_mv
2283        && s->current_picture.reference
2284        && !s->intra_only
2285        && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
2286         int sides = 0, edge_h;
2287         if (y==0) sides |= EDGE_TOP;
2288         if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2289
2290         edge_h= FFMIN(h, s->v_edge_pos - y);
2291
2292         s->dsp.draw_edges(s->current_picture_ptr->data[0] +  y    *s->linesize  , s->linesize  , s->h_edge_pos   , edge_h   , EDGE_WIDTH  , sides);
2293         s->dsp.draw_edges(s->current_picture_ptr->data[1] + (y>>1)*s->uvlinesize, s->uvlinesize, s->h_edge_pos>>1, edge_h>>1, EDGE_WIDTH/2, sides);
2294         s->dsp.draw_edges(s->current_picture_ptr->data[2] + (y>>1)*s->uvlinesize, s->uvlinesize, s->h_edge_pos>>1, edge_h>>1, EDGE_WIDTH/2, sides);
2295     }
2296
2297     h= FFMIN(h, s->avctx->height - y);
2298
2299     if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2300
2301     if (s->avctx->draw_horiz_band) {
2302         AVFrame *src;
2303         int offset[4];
2304
2305         if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2306             src= (AVFrame*)s->current_picture_ptr;
2307         else if(s->last_picture_ptr)
2308             src= (AVFrame*)s->last_picture_ptr;
2309         else
2310             return;
2311
2312         if(s->pict_type==AV_PICTURE_TYPE_B && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2313             offset[0]=
2314             offset[1]=
2315             offset[2]=
2316             offset[3]= 0;
2317         }else{
2318             offset[0]= y * s->linesize;
2319             offset[1]=
2320             offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2321             offset[3]= 0;
2322         }
2323
2324         emms_c();
2325
2326         s->avctx->draw_horiz_band(s->avctx, src, offset,
2327                                   y, s->picture_structure, h);
2328     }
2329 }
2330
2331 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2332     const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2333     const int uvlinesize= s->current_picture.linesize[1];
2334     const int mb_size= 4 - s->avctx->lowres;
2335
2336     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2337     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2338     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2339     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2340     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2341     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;
2342     //block_index is not used by mpeg2, so it is not affected by chroma_format
2343
2344     s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2345     s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2346     s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2347
2348     if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2349     {
2350         if(s->picture_structure==PICT_FRAME){
2351         s->dest[0] += s->mb_y *   linesize << mb_size;
2352         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2353         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2354         }else{
2355             s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
2356             s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2357             s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2358             assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2359         }
2360     }
2361 }
2362
2363 void ff_mpeg_flush(AVCodecContext *avctx){
2364     int i;
2365     MpegEncContext *s = avctx->priv_data;
2366
2367     if(s==NULL || s->picture==NULL)
2368         return;
2369
2370     for(i=0; i<s->picture_count; i++){
2371        if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2372                                     || s->picture[i].type == FF_BUFFER_TYPE_USER))
2373         free_frame_buffer(s, &s->picture[i]);
2374     }
2375     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2376
2377     s->mb_x= s->mb_y= 0;
2378     s->closed_gop= 0;
2379
2380     s->parse_context.state= -1;
2381     s->parse_context.frame_start_found= 0;
2382     s->parse_context.overread= 0;
2383     s->parse_context.overread_index= 0;
2384     s->parse_context.index= 0;
2385     s->parse_context.last_index= 0;
2386     s->bitstream_buffer_size=0;
2387     s->pp_time=0;
2388 }
2389
2390 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2391                                    DCTELEM *block, int n, int qscale)
2392 {
2393     int i, level, nCoeffs;
2394     const uint16_t *quant_matrix;
2395
2396     nCoeffs= s->block_last_index[n];
2397
2398     if (n < 4)
2399         block[0] = block[0] * s->y_dc_scale;
2400     else
2401         block[0] = block[0] * s->c_dc_scale;
2402     /* XXX: only mpeg1 */
2403     quant_matrix = s->intra_matrix;
2404     for(i=1;i<=nCoeffs;i++) {
2405         int j= s->intra_scantable.permutated[i];
2406         level = block[j];
2407         if (level) {
2408             if (level < 0) {
2409                 level = -level;
2410                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2411                 level = (level - 1) | 1;
2412                 level = -level;
2413             } else {
2414                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2415                 level = (level - 1) | 1;
2416             }
2417             block[j] = level;
2418         }
2419     }
2420 }
2421
2422 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2423                                    DCTELEM *block, int n, int qscale)
2424 {
2425     int i, level, nCoeffs;
2426     const uint16_t *quant_matrix;
2427
2428     nCoeffs= s->block_last_index[n];
2429
2430     quant_matrix = s->inter_matrix;
2431     for(i=0; i<=nCoeffs; i++) {
2432         int j= s->intra_scantable.permutated[i];
2433         level = block[j];
2434         if (level) {
2435             if (level < 0) {
2436                 level = -level;
2437                 level = (((level << 1) + 1) * qscale *
2438                          ((int) (quant_matrix[j]))) >> 4;
2439                 level = (level - 1) | 1;
2440                 level = -level;
2441             } else {
2442                 level = (((level << 1) + 1) * qscale *
2443                          ((int) (quant_matrix[j]))) >> 4;
2444                 level = (level - 1) | 1;
2445             }
2446             block[j] = level;
2447         }
2448     }
2449 }
2450
2451 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2452                                    DCTELEM *block, int n, int qscale)
2453 {
2454     int i, level, nCoeffs;
2455     const uint16_t *quant_matrix;
2456
2457     if(s->alternate_scan) nCoeffs= 63;
2458     else nCoeffs= s->block_last_index[n];
2459
2460     if (n < 4)
2461         block[0] = block[0] * s->y_dc_scale;
2462     else
2463         block[0] = block[0] * s->c_dc_scale;
2464     quant_matrix = s->intra_matrix;
2465     for(i=1;i<=nCoeffs;i++) {
2466         int j= s->intra_scantable.permutated[i];
2467         level = block[j];
2468         if (level) {
2469             if (level < 0) {
2470                 level = -level;
2471                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2472                 level = -level;
2473             } else {
2474                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2475             }
2476             block[j] = level;
2477         }
2478     }
2479 }
2480
2481 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2482                                    DCTELEM *block, int n, int qscale)
2483 {
2484     int i, level, nCoeffs;
2485     const uint16_t *quant_matrix;
2486     int sum=-1;
2487
2488     if(s->alternate_scan) nCoeffs= 63;
2489     else nCoeffs= s->block_last_index[n];
2490
2491     if (n < 4)
2492         block[0] = block[0] * s->y_dc_scale;
2493     else
2494         block[0] = block[0] * s->c_dc_scale;
2495     quant_matrix = s->intra_matrix;
2496     for(i=1;i<=nCoeffs;i++) {
2497         int j= s->intra_scantable.permutated[i];
2498         level = block[j];
2499         if (level) {
2500             if (level < 0) {
2501                 level = -level;
2502                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2503                 level = -level;
2504             } else {
2505                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2506             }
2507             block[j] = level;
2508             sum+=level;
2509         }
2510     }
2511     block[63]^=sum&1;
2512 }
2513
2514 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2515                                    DCTELEM *block, int n, int qscale)
2516 {
2517     int i, level, nCoeffs;
2518     const uint16_t *quant_matrix;
2519     int sum=-1;
2520
2521     if(s->alternate_scan) nCoeffs= 63;
2522     else nCoeffs= s->block_last_index[n];
2523
2524     quant_matrix = s->inter_matrix;
2525     for(i=0; i<=nCoeffs; i++) {
2526         int j= s->intra_scantable.permutated[i];
2527         level = block[j];
2528         if (level) {
2529             if (level < 0) {
2530                 level = -level;
2531                 level = (((level << 1) + 1) * qscale *
2532                          ((int) (quant_matrix[j]))) >> 4;
2533                 level = -level;
2534             } else {
2535                 level = (((level << 1) + 1) * qscale *
2536                          ((int) (quant_matrix[j]))) >> 4;
2537             }
2538             block[j] = level;
2539             sum+=level;
2540         }
2541     }
2542     block[63]^=sum&1;
2543 }
2544
2545 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2546                                   DCTELEM *block, int n, int qscale)
2547 {
2548     int i, level, qmul, qadd;
2549     int nCoeffs;
2550
2551     assert(s->block_last_index[n]>=0);
2552
2553     qmul = qscale << 1;
2554
2555     if (!s->h263_aic) {
2556         if (n < 4)
2557             block[0] = block[0] * s->y_dc_scale;
2558         else
2559             block[0] = block[0] * s->c_dc_scale;
2560         qadd = (qscale - 1) | 1;
2561     }else{
2562         qadd = 0;
2563     }
2564     if(s->ac_pred)
2565         nCoeffs=63;
2566     else
2567         nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2568
2569     for(i=1; i<=nCoeffs; i++) {
2570         level = block[i];
2571         if (level) {
2572             if (level < 0) {
2573                 level = level * qmul - qadd;
2574             } else {
2575                 level = level * qmul + qadd;
2576             }
2577             block[i] = level;
2578         }
2579     }
2580 }
2581
2582 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2583                                   DCTELEM *block, int n, int qscale)
2584 {
2585     int i, level, qmul, qadd;
2586     int nCoeffs;
2587
2588     assert(s->block_last_index[n]>=0);
2589
2590     qadd = (qscale - 1) | 1;
2591     qmul = qscale << 1;
2592
2593     nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2594
2595     for(i=0; i<=nCoeffs; i++) {
2596         level = block[i];
2597         if (level) {
2598             if (level < 0) {
2599                 level = level * qmul - qadd;
2600             } else {
2601                 level = level * qmul + qadd;
2602             }
2603             block[i] = level;
2604         }
2605     }
2606 }
2607
2608 /**
2609  * set qscale and update qscale dependent variables.
2610  */
2611 void ff_set_qscale(MpegEncContext * s, int qscale)
2612 {
2613     if (qscale < 1)
2614         qscale = 1;
2615     else if (qscale > 31)
2616         qscale = 31;
2617
2618     s->qscale = qscale;
2619     s->chroma_qscale= s->chroma_qscale_table[qscale];
2620
2621     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2622     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2623 }
2624
2625 void MPV_report_decode_progress(MpegEncContext *s)
2626 {
2627     if (s->pict_type != FF_B_TYPE && !s->partitioned_frame && !s->error_occurred)
2628         ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_y, 0);
2629 }