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 FFmpeg.
   9  *
  10  * FFmpeg is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * FFmpeg is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with FFmpeg; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  23  */
  24
  25 /**
  26  * @file
  27  * The simplest mpeg encoder (well, it was the simplest!).
  28  */
  29
  30 #include "libavutil/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 ? FF_B_TYPE : s->pict_type;
 317     if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == FF_B_TYPE)
 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 = s;
 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->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     s->mb_width  = (s->width  + 15) / 16;
 605     s->mb_stride = s->mb_width + 1;
 606     s->b8_stride = s->mb_width*2 + 1;
 607     s->b4_stride = s->mb_width*4 + 1;
 608     mb_array_size= s->mb_height * s->mb_stride;
 609     mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
 610
 611     /* set chroma shifts */
 612     avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
 613                                                     &(s->chroma_y_shift) );
 614
 615     /* set default edge pos, will be overriden in decode_header if needed */
 616     s->h_edge_pos= s->mb_width*16;
 617     s->v_edge_pos= s->mb_height*16;
 618
 619     s->mb_num = s->mb_width * s->mb_height;
 620
 621     s->block_wrap[0]=
 622     s->block_wrap[1]=
 623     s->block_wrap[2]=
 624     s->block_wrap[3]= s->b8_stride;
 625     s->block_wrap[4]=
 626     s->block_wrap[5]= s->mb_stride;
 627
 628     y_size = s->b8_stride * (2 * s->mb_height + 1);
 629     c_size = s->mb_stride * (s->mb_height + 1);
 630     yc_size = y_size + 2 * c_size;
 631
 632     /* convert fourcc to upper case */
 633     s->codec_tag = ff_toupper4(s->avctx->codec_tag);
 634
 635     s->stream_codec_tag = ff_toupper4(s->avctx->stream_codec_tag);
 636
 637     s->avctx->coded_frame= (AVFrame*)&s->current_picture;
 638
 639     FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num+1)*sizeof(int), fail) //error ressilience code looks cleaner with this
 640     for(y=0; y<s->mb_height; y++){
 641         for(x=0; x<s->mb_width; x++){
 642             s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
 643         }
 644     }
 645     s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
 646
 647     if (s->encoding) {
 648         /* Allocate MV tables */
 649         FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t), fail)
 650         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t), fail)
 651         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t), fail)
 652         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
 653         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
 654         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t), fail)
 655         s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
 656         s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
 657         s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
 658         s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
 659         s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
 660         s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
 661
 662         if(s->msmpeg4_version){
 663             FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int), fail);
 664         }
 665         FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
 666
 667         /* Allocate MB type table */
 668         FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type  , mb_array_size * sizeof(uint16_t), fail) //needed for encoding
 669
 670         FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
 671
 672         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix  , 64*32   * sizeof(int), fail)
 673         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix  , 64*32   * sizeof(int), fail)
 674         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t), fail)
 675         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t), fail)
 676         FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
 677         FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
 678
 679         if(s->avctx->noise_reduction){
 680             FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail)
 681         }
 682     }
 683     s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
 684     FF_ALLOCZ_OR_GOTO(s->avctx, s->picture, s->picture_count * sizeof(Picture), fail)
 685     for(i = 0; i < s->picture_count; i++) {
 686         avcodec_get_frame_defaults((AVFrame *)&s->picture[i]);
 687     }
 688
 689     FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table, mb_array_size*sizeof(uint8_t), fail)
 690
 691     if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
 692         /* interlaced direct mode decoding tables */
 693             for(i=0; i<2; i++){
 694                 int j, k;
 695                 for(j=0; j<2; j++){
 696                     for(k=0; k<2; k++){
 697                         FF_ALLOCZ_OR_GOTO(s->avctx,    s->b_field_mv_table_base[i][j][k], mv_table_size * 2 * sizeof(int16_t), fail)
 698                         s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
 699                     }
 700                     FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
 701                     FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
 702                     s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j]+ s->mb_stride + 1;
 703                 }
 704                 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
 705             }
 706     }
 707     if (s->out_format == FMT_H263) {
 708         /* cbp values */
 709         FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
 710         s->coded_block= s->coded_block_base + s->b8_stride + 1;
 711
 712         /* cbp, ac_pred, pred_dir */
 713         FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table     , mb_array_size * sizeof(uint8_t), fail)
 714         FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail)
 715     }
 716
 717     if (s->h263_pred || s->h263_plus || !s->encoding) {
 718         /* dc values */
 719         //MN: we need these for error resilience of intra-frames
 720         FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
 721         s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
 722         s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
 723         s->dc_val[2] = s->dc_val[1] + c_size;
 724         for(i=0;i<yc_size;i++)
 725             s->dc_val_base[i] = 1024;
 726     }
 727
 728     /* which mb is a intra block */
 729     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
 730     memset(s->mbintra_table, 1, mb_array_size);
 731
 732     /* init macroblock skip table */
 733     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size+2, fail);
 734     //Note the +1 is for a quicker mpeg4 slice_end detection
 735     FF_ALLOCZ_OR_GOTO(s->avctx, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE, fail);
 736
 737     s->parse_context.state= -1;
 738     if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
 739        s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
 740        s->visualization_buffer[1] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
 741        s->visualization_buffer[2] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
 742     }
 743
 744     s->context_initialized = 1;
 745     s->thread_context[0]= s;
 746
 747     if (HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_SLICE) {
 748         threads = s->avctx->thread_count;
 749
 750         for(i=1; i<threads; i++){
 751             s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
 752             memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
 753         }
 754
 755         for(i=0; i<threads; i++){
 756             if(init_duplicate_context(s->thread_context[i], s) < 0)
 757                goto fail;
 758             s->thread_context[i]->start_mb_y= (s->mb_height*(i  ) + s->avctx->thread_count/2) / s->avctx->thread_count;
 759             s->thread_context[i]->end_mb_y  = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
 760         }
 761     } else {
 762         if(init_duplicate_context(s, s) < 0) goto fail;
 763         s->start_mb_y = 0;
 764         s->end_mb_y   = s->mb_height;
 765     }
 766
 767     return 0;
 768  fail:
 769     MPV_common_end(s);
 770     return -1;
 771 }
 772
 773 /* init common structure for both encoder and decoder */
 774 void MPV_common_end(MpegEncContext *s)
 775 {
 776     int i, j, k;
 777
 778     if (HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_SLICE) {
 779         for(i=0; i<s->avctx->thread_count; i++){
 780             free_duplicate_context(s->thread_context[i]);
 781         }
 782         for(i=1; i<s->avctx->thread_count; i++){
 783             av_freep(&s->thread_context[i]);
 784         }
 785     } else free_duplicate_context(s);
 786
 787     av_freep(&s->parse_context.buffer);
 788     s->parse_context.buffer_size=0;
 789
 790     av_freep(&s->mb_type);
 791     av_freep(&s->p_mv_table_base);
 792     av_freep(&s->b_forw_mv_table_base);
 793     av_freep(&s->b_back_mv_table_base);
 794     av_freep(&s->b_bidir_forw_mv_table_base);
 795     av_freep(&s->b_bidir_back_mv_table_base);
 796     av_freep(&s->b_direct_mv_table_base);
 797     s->p_mv_table= NULL;
 798     s->b_forw_mv_table= NULL;
 799     s->b_back_mv_table= NULL;
 800     s->b_bidir_forw_mv_table= NULL;
 801     s->b_bidir_back_mv_table= NULL;
 802     s->b_direct_mv_table= NULL;
 803     for(i=0; i<2; i++){
 804         for(j=0; j<2; j++){
 805             for(k=0; k<2; k++){
 806                 av_freep(&s->b_field_mv_table_base[i][j][k]);
 807                 s->b_field_mv_table[i][j][k]=NULL;
 808             }
 809             av_freep(&s->b_field_select_table[i][j]);
 810             av_freep(&s->p_field_mv_table_base[i][j]);
 811             s->p_field_mv_table[i][j]=NULL;
 812         }
 813         av_freep(&s->p_field_select_table[i]);
 814     }
 815
 816     av_freep(&s->dc_val_base);
 817     av_freep(&s->coded_block_base);
 818     av_freep(&s->mbintra_table);
 819     av_freep(&s->cbp_table);
 820     av_freep(&s->pred_dir_table);
 821
 822     av_freep(&s->mbskip_table);
 823     av_freep(&s->prev_pict_types);
 824     av_freep(&s->bitstream_buffer);
 825     s->allocated_bitstream_buffer_size=0;
 826
 827     av_freep(&s->avctx->stats_out);
 828     av_freep(&s->ac_stats);
 829     av_freep(&s->error_status_table);
 830     av_freep(&s->mb_index2xy);
 831     av_freep(&s->lambda_table);
 832     av_freep(&s->q_intra_matrix);
 833     av_freep(&s->q_inter_matrix);
 834     av_freep(&s->q_intra_matrix16);
 835     av_freep(&s->q_inter_matrix16);
 836     av_freep(&s->input_picture);
 837     av_freep(&s->reordered_input_picture);
 838     av_freep(&s->dct_offset);
 839
 840     if(s->picture && !s->avctx->is_copy){
 841         for(i=0; i<s->picture_count; i++){
 842             free_picture(s, &s->picture[i]);
 843         }
 844     }
 845     av_freep(&s->picture);
 846     s->context_initialized = 0;
 847     s->last_picture_ptr=
 848     s->next_picture_ptr=
 849     s->current_picture_ptr= NULL;
 850     s->linesize= s->uvlinesize= 0;
 851
 852     for(i=0; i<3; i++)
 853         av_freep(&s->visualization_buffer[i]);
 854
 855     if(!(s->avctx->active_thread_type&FF_THREAD_FRAME))
 856         avcodec_default_free_buffers(s->avctx);
 857 }
 858
 859 void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
 860 {
 861     int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
 862     uint8_t index_run[MAX_RUN+1];
 863     int last, run, level, start, end, i;
 864
 865     /* If table is static, we can quit if rl->max_level[0] is not NULL */
 866     if(static_store && rl->max_level[0])
 867         return;
 868
 869     /* compute max_level[], max_run[] and index_run[] */
 870     for(last=0;last<2;last++) {
 871         if (last == 0) {
 872             start = 0;
 873             end = rl->last;
 874         } else {
 875             start = rl->last;
 876             end = rl->n;
 877         }
 878
 879         memset(max_level, 0, MAX_RUN + 1);
 880         memset(max_run, 0, MAX_LEVEL + 1);
 881         memset(index_run, rl->n, MAX_RUN + 1);
 882         for(i=start;i<end;i++) {
 883             run = rl->table_run[i];
 884             level = rl->table_level[i];
 885             if (index_run[run] == rl->n)
 886                 index_run[run] = i;
 887             if (level > max_level[run])
 888                 max_level[run] = level;
 889             if (run > max_run[level])
 890                 max_run[level] = run;
 891         }
 892         if(static_store)
 893             rl->max_level[last] = static_store[last];
 894         else
 895             rl->max_level[last] = av_malloc(MAX_RUN + 1);
 896         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
 897         if(static_store)
 898             rl->max_run[last] = static_store[last] + MAX_RUN + 1;
 899         else
 900             rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
 901         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
 902         if(static_store)
 903             rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
 904         else
 905             rl->index_run[last] = av_malloc(MAX_RUN + 1);
 906         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
 907     }
 908 }
 909
 910 void init_vlc_rl(RLTable *rl)
 911 {
 912     int i, q;
 913
 914     for(q=0; q<32; q++){
 915         int qmul= q*2;
 916         int qadd= (q-1)|1;
 917
 918         if(q==0){
 919             qmul=1;
 920             qadd=0;
 921         }
 922         for(i=0; i<rl->vlc.table_size; i++){
 923             int code= rl->vlc.table[i][0];
 924             int len = rl->vlc.table[i][1];
 925             int level, run;
 926
 927             if(len==0){ // illegal code
 928                 run= 66;
 929                 level= MAX_LEVEL;
 930             }else if(len<0){ //more bits needed
 931                 run= 0;
 932                 level= code;
 933             }else{
 934                 if(code==rl->n){ //esc
 935                     run= 66;
 936                     level= 0;
 937                 }else{
 938                     run=   rl->table_run  [code] + 1;
 939                     level= rl->table_level[code] * qmul + qadd;
 940                     if(code >= rl->last) run+=192;
 941                 }
 942             }
 943             rl->rl_vlc[q][i].len= len;
 944             rl->rl_vlc[q][i].level= level;
 945             rl->rl_vlc[q][i].run= run;
 946         }
 947     }
 948 }
 949
 950 void ff_release_unused_pictures(MpegEncContext *s, int remove_current)
 951 {
 952     int i;
 953
 954     /* release non reference frames */
 955     for(i=0; i<s->picture_count; i++){
 956         if(s->picture[i].data[0] && !s->picture[i].reference
 957            && s->picture[i].owner2 == s
 958            && (remove_current || &s->picture[i] != s->current_picture_ptr)
 959            /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
 960             free_frame_buffer(s, &s->picture[i]);
 961         }
 962     }
 963 }
 964
 965 int ff_find_unused_picture(MpegEncContext *s, int shared){
 966     int i;
 967
 968     if(shared){
 969         for(i=s->picture_range_start; i<s->picture_range_end; i++){
 970             if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
 971         }
 972     }else{
 973         for(i=s->picture_range_start; i<s->picture_range_end; i++){
 974             if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
 975         }
 976         for(i=s->picture_range_start; i<s->picture_range_end; i++){
 977             if(s->picture[i].data[0]==NULL) return i;
 978         }
 979     }
 980
 981     av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflow\n");
 982     /* We could return -1, but the codec would crash trying to draw into a
 983      * non-existing frame anyway. This is safer than waiting for a random crash.
 984      * Also the return of this is never useful, an encoder must only allocate
 985      * as much as allowed in the specification. This has no relationship to how
 986      * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
 987      * enough for such valid streams).
 988      * Plus, a decoder has to check stream validity and remove frames if too
 989      * many reference frames are around. Waiting for "OOM" is not correct at
 990      * all. Similarly, missing reference frames have to be replaced by
 991      * interpolated/MC frames, anything else is a bug in the codec ...
 992      */
 993     abort();
 994     return -1;
 995 }
 996
 997 static void update_noise_reduction(MpegEncContext *s){
 998     int intra, i;
 999
1000     for(intra=0; intra<2; intra++){
1001         if(s->dct_count[intra] > (1<<16)){
1002             for(i=0; i<64; i++){
1003                 s->dct_error_sum[intra][i] >>=1;
1004             }
1005             s->dct_count[intra] >>= 1;
1006         }
1007
1008         for(i=0; i<64; i++){
1009             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);
1010         }
1011     }
1012 }
1013
1014 /**
1015  * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1016  */
1017 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1018 {
1019     int i;
1020     Picture *pic;
1021     s->mb_skipped = 0;
1022
1023     assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1024
1025     /* mark&release old frames */
1026     if (s->pict_type != FF_B_TYPE && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1027       if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1028           free_frame_buffer(s, s->last_picture_ptr);
1029
1030         /* release forgotten pictures */
1031         /* if(mpeg124/h263) */
1032         if(!s->encoding){
1033             for(i=0; i<s->picture_count; i++){
1034                 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1035                     av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1036                     free_frame_buffer(s, &s->picture[i]);
1037                 }
1038             }
1039         }
1040       }
1041     }
1042
1043     if(!s->encoding){
1044         ff_release_unused_pictures(s, 1);
1045
1046         if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1047             pic= s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
1048         else{
1049             i= ff_find_unused_picture(s, 0);
1050             pic= &s->picture[i];
1051         }
1052
1053         pic->reference= 0;
1054         if (!s->dropable){
1055             if (s->codec_id == CODEC_ID_H264)
1056                 pic->reference = s->picture_structure;
1057             else if (s->pict_type != FF_B_TYPE)
1058                 pic->reference = 3;
1059         }
1060
1061         pic->coded_picture_number= s->coded_picture_number++;
1062
1063         if(ff_alloc_picture(s, pic, 0) < 0)
1064             return -1;
1065
1066         s->current_picture_ptr= pic;
1067         //FIXME use only the vars from current_pic
1068         s->current_picture_ptr->top_field_first= s->top_field_first;
1069         if(s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO) {
1070             if(s->picture_structure != PICT_FRAME)
1071                 s->current_picture_ptr->top_field_first= (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1072         }
1073         s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1074         s->current_picture_ptr->field_picture= s->picture_structure != PICT_FRAME;
1075     }
1076
1077     s->current_picture_ptr->pict_type= s->pict_type;
1078 //    if(s->flags && CODEC_FLAG_QSCALE)
1079   //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1080     s->current_picture_ptr->key_frame= s->pict_type == FF_I_TYPE;
1081
1082     ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1083
1084     if (s->pict_type != FF_B_TYPE) {
1085         s->last_picture_ptr= s->next_picture_ptr;
1086         if(!s->dropable)
1087             s->next_picture_ptr= s->current_picture_ptr;
1088     }
1089 /*    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,
1090         s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
1091         s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
1092         s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1093         s->pict_type, s->dropable);*/
1094
1095     if(s->codec_id != CODEC_ID_H264){
1096         if((s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && s->pict_type!=FF_I_TYPE){
1097             av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1098             /* Allocate a dummy frame */
1099             i= ff_find_unused_picture(s, 0);
1100             s->last_picture_ptr= &s->picture[i];
1101             if(ff_alloc_picture(s, s->last_picture_ptr, 0) < 0)
1102                 return -1;
1103             ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 0);
1104             ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 1);
1105         }
1106         if((s->next_picture_ptr==NULL || s->next_picture_ptr->data[0]==NULL) && s->pict_type==FF_B_TYPE){
1107             /* Allocate a dummy frame */
1108             i= ff_find_unused_picture(s, 0);
1109             s->next_picture_ptr= &s->picture[i];
1110             if(ff_alloc_picture(s, s->next_picture_ptr, 0) < 0)
1111                 return -1;
1112             ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 0);
1113             ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 1);
1114         }
1115     }
1116
1117     if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1118     if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1119
1120     assert(s->pict_type == FF_I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1121
1122     if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
1123         int i;
1124         for(i=0; i<4; i++){
1125             if(s->picture_structure == PICT_BOTTOM_FIELD){
1126                  s->current_picture.data[i] += s->current_picture.linesize[i];
1127             }
1128             s->current_picture.linesize[i] *= 2;
1129             s->last_picture.linesize[i] *=2;
1130             s->next_picture.linesize[i] *=2;
1131         }
1132     }
1133
1134 #if FF_API_HURRY_UP
1135     s->hurry_up= s->avctx->hurry_up;
1136 #endif
1137     s->error_recognition= avctx->error_recognition;
1138
1139     /* set dequantizer, we can't do it during init as it might change for mpeg4
1140        and we can't do it in the header decode as init is not called for mpeg4 there yet */
1141     if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1142         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1143         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1144     }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1145         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1146         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1147     }else{
1148         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1149         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1150     }
1151
1152     if(s->dct_error_sum){
1153         assert(s->avctx->noise_reduction && s->encoding);
1154
1155         update_noise_reduction(s);
1156     }
1157
1158     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1159         return ff_xvmc_field_start(s, avctx);
1160
1161     return 0;
1162 }
1163
1164 /* generic function for encode/decode called after a frame has been coded/decoded */
1165 void MPV_frame_end(MpegEncContext *s)
1166 {
1167     int i;
1168     /* redraw edges for the frame if decoding didn't complete */
1169     //just to make sure that all data is rendered.
1170     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1171         ff_xvmc_field_end(s);
1172    }else if((s->error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND))
1173        && !s->avctx->hwaccel
1174        && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
1175        && s->unrestricted_mv
1176        && s->current_picture.reference
1177        && !s->intra_only
1178        && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1179         int edges = EDGE_BOTTOM | EDGE_TOP, h = s->v_edge_pos;
1180
1181             s->dsp.draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , h   , EDGE_WIDTH  , edges);
1182             s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, h>>1, EDGE_WIDTH/2, edges);
1183             s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, h>>1, EDGE_WIDTH/2, edges);
1184
1185     }
1186
1187     emms_c();
1188
1189     s->last_pict_type    = s->pict_type;
1190     s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1191     if(s->pict_type!=FF_B_TYPE){
1192         s->last_non_b_pict_type= s->pict_type;
1193     }
1194 #if 0
1195         /* copy back current_picture variables */
1196     for(i=0; i<MAX_PICTURE_COUNT; i++){
1197         if(s->picture[i].data[0] == s->current_picture.data[0]){
1198             s->picture[i]= s->current_picture;
1199             break;
1200         }
1201     }
1202     assert(i<MAX_PICTURE_COUNT);
1203 #endif
1204
1205     if(s->encoding){
1206         /* release non-reference frames */
1207         for(i=0; i<s->picture_count; i++){
1208             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1209                 free_frame_buffer(s, &s->picture[i]);
1210             }
1211         }
1212     }
1213     // clear copies, to avoid confusion
1214 #if 0
1215     memset(&s->last_picture, 0, sizeof(Picture));
1216     memset(&s->next_picture, 0, sizeof(Picture));
1217     memset(&s->current_picture, 0, sizeof(Picture));
1218 #endif
1219     s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1220
1221     if (s->codec_id != CODEC_ID_H264 && s->current_picture.reference) {
1222         ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_height-1, 0);
1223     }
1224 }
1225
1226 /**
1227  * draws an line from (ex, ey) -> (sx, sy).
1228  * @param w width of the image
1229  * @param h height of the image
1230  * @param stride stride/linesize of the image
1231  * @param color color of the arrow
1232  */
1233 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1234     int x, y, fr, f;
1235
1236     sx= av_clip(sx, 0, w-1);
1237     sy= av_clip(sy, 0, h-1);
1238     ex= av_clip(ex, 0, w-1);
1239     ey= av_clip(ey, 0, h-1);
1240
1241     buf[sy*stride + sx]+= color;
1242
1243     if(FFABS(ex - sx) > FFABS(ey - sy)){
1244         if(sx > ex){
1245             FFSWAP(int, sx, ex);
1246             FFSWAP(int, sy, ey);
1247         }
1248         buf+= sx + sy*stride;
1249         ex-= sx;
1250         f= ((ey-sy)<<16)/ex;
1251         for(x= 0; x <= ex; x++){
1252             y = (x*f)>>16;
1253             fr= (x*f)&0xFFFF;
1254             buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1255             buf[(y+1)*stride + x]+= (color*         fr )>>16;
1256         }
1257     }else{
1258         if(sy > ey){
1259             FFSWAP(int, sx, ex);
1260             FFSWAP(int, sy, ey);
1261         }
1262         buf+= sx + sy*stride;
1263         ey-= sy;
1264         if(ey) f= ((ex-sx)<<16)/ey;
1265         else   f= 0;
1266         for(y= 0; y <= ey; y++){
1267             x = (y*f)>>16;
1268             fr= (y*f)&0xFFFF;
1269             buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;
1270             buf[y*stride + x+1]+= (color*         fr )>>16;
1271         }
1272     }
1273 }
1274
1275 /**
1276  * draws an arrow from (ex, ey) -> (sx, sy).
1277  * @param w width of the image
1278  * @param h height of the image
1279  * @param stride stride/linesize of the image
1280  * @param color color of the arrow
1281  */
1282 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1283     int dx,dy;
1284
1285     sx= av_clip(sx, -100, w+100);
1286     sy= av_clip(sy, -100, h+100);
1287     ex= av_clip(ex, -100, w+100);
1288     ey= av_clip(ey, -100, h+100);
1289
1290     dx= ex - sx;
1291     dy= ey - sy;
1292
1293     if(dx*dx + dy*dy > 3*3){
1294         int rx=  dx + dy;
1295         int ry= -dx + dy;
1296         int length= ff_sqrt((rx*rx + ry*ry)<<8);
1297
1298         //FIXME subpixel accuracy
1299         rx= ROUNDED_DIV(rx*3<<4, length);
1300         ry= ROUNDED_DIV(ry*3<<4, length);
1301
1302         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1303         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1304     }
1305     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1306 }
1307
1308 /**
1309  * prints debuging info for the given picture.
1310  */
1311 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1312
1313     if(s->avctx->hwaccel || !pict || !pict->mb_type) return;
1314
1315     if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1316         int x,y;
1317
1318         av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1319         switch (pict->pict_type) {
1320             case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1321             case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1322             case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1323             case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1324             case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1325             case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1326         }
1327         for(y=0; y<s->mb_height; y++){
1328             for(x=0; x<s->mb_width; x++){
1329                 if(s->avctx->debug&FF_DEBUG_SKIP){
1330                     int count= s->mbskip_table[x + y*s->mb_stride];
1331                     if(count>9) count=9;
1332                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1333                 }
1334                 if(s->avctx->debug&FF_DEBUG_QP){
1335                     av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1336                 }
1337                 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1338                     int mb_type= pict->mb_type[x + y*s->mb_stride];
1339                     //Type & MV direction
1340                     if(IS_PCM(mb_type))
1341                         av_log(s->avctx, AV_LOG_DEBUG, "P");
1342                     else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1343                         av_log(s->avctx, AV_LOG_DEBUG, "A");
1344                     else if(IS_INTRA4x4(mb_type))
1345                         av_log(s->avctx, AV_LOG_DEBUG, "i");
1346                     else if(IS_INTRA16x16(mb_type))
1347                         av_log(s->avctx, AV_LOG_DEBUG, "I");
1348                     else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1349                         av_log(s->avctx, AV_LOG_DEBUG, "d");
1350                     else if(IS_DIRECT(mb_type))
1351                         av_log(s->avctx, AV_LOG_DEBUG, "D");
1352                     else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1353                         av_log(s->avctx, AV_LOG_DEBUG, "g");
1354                     else if(IS_GMC(mb_type))
1355                         av_log(s->avctx, AV_LOG_DEBUG, "G");
1356                     else if(IS_SKIP(mb_type))
1357                         av_log(s->avctx, AV_LOG_DEBUG, "S");
1358                     else if(!USES_LIST(mb_type, 1))
1359                         av_log(s->avctx, AV_LOG_DEBUG, ">");
1360                     else if(!USES_LIST(mb_type, 0))
1361                         av_log(s->avctx, AV_LOG_DEBUG, "<");
1362                     else{
1363                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1364                         av_log(s->avctx, AV_LOG_DEBUG, "X");
1365                     }
1366
1367                     //segmentation
1368                     if(IS_8X8(mb_type))
1369                         av_log(s->avctx, AV_LOG_DEBUG, "+");
1370                     else if(IS_16X8(mb_type))
1371                         av_log(s->avctx, AV_LOG_DEBUG, "-");
1372                     else if(IS_8X16(mb_type))
1373                         av_log(s->avctx, AV_LOG_DEBUG, "|");
1374                     else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1375                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1376                     else
1377                         av_log(s->avctx, AV_LOG_DEBUG, "?");
1378
1379
1380                     if(IS_INTERLACED(mb_type))
1381                         av_log(s->avctx, AV_LOG_DEBUG, "=");
1382                     else
1383                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1384                 }
1385 //                av_log(s->avctx, AV_LOG_DEBUG, " ");
1386             }
1387             av_log(s->avctx, AV_LOG_DEBUG, "\n");
1388         }
1389     }
1390
1391     if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1392         const int shift= 1 + s->quarter_sample;
1393         int mb_y;
1394         uint8_t *ptr;
1395         int i;
1396         int h_chroma_shift, v_chroma_shift, block_height;
1397         const int width = s->avctx->width;
1398         const int height= s->avctx->height;
1399         const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1400         const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1401         s->low_delay=0; //needed to see the vectors without trashing the buffers
1402
1403         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1404         for(i=0; i<3; i++){
1405             memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1406             pict->data[i]= s->visualization_buffer[i];
1407         }
1408         pict->type= FF_BUFFER_TYPE_COPY;
1409         ptr= pict->data[0];
1410         block_height = 16>>v_chroma_shift;
1411
1412         for(mb_y=0; mb_y<s->mb_height; mb_y++){
1413             int mb_x;
1414             for(mb_x=0; mb_x<s->mb_width; mb_x++){
1415                 const int mb_index= mb_x + mb_y*s->mb_stride;
1416                 if((s->avctx->debug_mv) && pict->motion_val){
1417                   int type;
1418                   for(type=0; type<3; type++){
1419                     int direction = 0;
1420                     switch (type) {
1421                       case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1422                                 continue;
1423                               direction = 0;
1424                               break;
1425                       case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1426                                 continue;
1427                               direction = 0;
1428                               break;
1429                       case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1430                                 continue;
1431                               direction = 1;
1432                               break;
1433                     }
1434                     if(!USES_LIST(pict->mb_type[mb_index], direction))
1435                         continue;
1436
1437                     if(IS_8X8(pict->mb_type[mb_index])){
1438                       int i;
1439                       for(i=0; i<4; i++){
1440                         int sx= mb_x*16 + 4 + 8*(i&1);
1441                         int sy= mb_y*16 + 4 + 8*(i>>1);
1442                         int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1443                         int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1444                         int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1445                         draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1446                       }
1447                     }else if(IS_16X8(pict->mb_type[mb_index])){
1448                       int i;
1449                       for(i=0; i<2; i++){
1450                         int sx=mb_x*16 + 8;
1451                         int sy=mb_y*16 + 4 + 8*i;
1452                         int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1453                         int mx=(pict->motion_val[direction][xy][0]>>shift);
1454                         int my=(pict->motion_val[direction][xy][1]>>shift);
1455
1456                         if(IS_INTERLACED(pict->mb_type[mb_index]))
1457                             my*=2;
1458
1459                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1460                       }
1461                     }else if(IS_8X16(pict->mb_type[mb_index])){
1462                       int i;
1463                       for(i=0; i<2; i++){
1464                         int sx=mb_x*16 + 4 + 8*i;
1465                         int sy=mb_y*16 + 8;
1466                         int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1467                         int mx=(pict->motion_val[direction][xy][0]>>shift);
1468                         int my=(pict->motion_val[direction][xy][1]>>shift);
1469
1470                         if(IS_INTERLACED(pict->mb_type[mb_index]))
1471                             my*=2;
1472
1473                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1474                       }
1475                     }else{
1476                       int sx= mb_x*16 + 8;
1477                       int sy= mb_y*16 + 8;
1478                       int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1479                       int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1480                       int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1481                       draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1482                     }
1483                   }
1484                 }
1485                 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1486                     uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1487                     int y;
1488                     for(y=0; y<block_height; y++){
1489                         *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1490                         *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1491                     }
1492                 }
1493                 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1494                     int mb_type= pict->mb_type[mb_index];
1495                     uint64_t u,v;
1496                     int y;
1497 #define COLOR(theta, r)\
1498 u= (int)(128 + r*cos(theta*3.141592/180));\
1499 v= (int)(128 + r*sin(theta*3.141592/180));
1500
1501
1502                     u=v=128;
1503                     if(IS_PCM(mb_type)){
1504                         COLOR(120,48)
1505                     }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1506                         COLOR(30,48)
1507                     }else if(IS_INTRA4x4(mb_type)){
1508                         COLOR(90,48)
1509                     }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1510 //                        COLOR(120,48)
1511                     }else if(IS_DIRECT(mb_type)){
1512                         COLOR(150,48)
1513                     }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1514                         COLOR(170,48)
1515                     }else if(IS_GMC(mb_type)){
1516                         COLOR(190,48)
1517                     }else if(IS_SKIP(mb_type)){
1518 //                        COLOR(180,48)
1519                     }else if(!USES_LIST(mb_type, 1)){
1520                         COLOR(240,48)
1521                     }else if(!USES_LIST(mb_type, 0)){
1522                         COLOR(0,48)
1523                     }else{
1524                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1525                         COLOR(300,48)
1526                     }
1527
1528                     u*= 0x0101010101010101ULL;
1529                     v*= 0x0101010101010101ULL;
1530                     for(y=0; y<block_height; y++){
1531                         *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1532                         *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1533                     }
1534
1535                     //segmentation
1536                     if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1537                         *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1538                         *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1539                     }
1540                     if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1541                         for(y=0; y<16; y++)
1542                             pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1543                     }
1544                     if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1545                         int dm= 1 << (mv_sample_log2-2);
1546                         for(i=0; i<4; i++){
1547                             int sx= mb_x*16 + 8*(i&1);
1548                             int sy= mb_y*16 + 8*(i>>1);
1549                             int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1550                             //FIXME bidir
1551                             int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1552                             if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1553                                 for(y=0; y<8; y++)
1554                                     pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1555                             if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1556                                 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1557                         }
1558                     }
1559
1560                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1561                         // hmm
1562                     }
1563                 }
1564                 s->mbskip_table[mb_index]=0;
1565             }
1566         }
1567     }
1568 }
1569
1570 static inline int hpel_motion_lowres(MpegEncContext *s,
1571                                   uint8_t *dest, uint8_t *src,
1572                                   int field_based, int field_select,
1573                                   int src_x, int src_y,
1574                                   int width, int height, int stride,
1575                                   int h_edge_pos, int v_edge_pos,
1576                                   int w, int h, h264_chroma_mc_func *pix_op,
1577                                   int motion_x, int motion_y)
1578 {
1579     const int lowres= s->avctx->lowres;
1580     const int op_index= FFMIN(lowres, 2);
1581     const int s_mask= (2<<lowres)-1;
1582     int emu=0;
1583     int sx, sy;
1584
1585     if(s->quarter_sample){
1586         motion_x/=2;
1587         motion_y/=2;
1588     }
1589
1590     sx= motion_x & s_mask;
1591     sy= motion_y & s_mask;
1592     src_x += motion_x >> (lowres+1);
1593     src_y += motion_y >> (lowres+1);
1594
1595     src += src_y * stride + src_x;
1596
1597     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
1598        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1599         s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1600                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1601         src= s->edge_emu_buffer;
1602         emu=1;
1603     }
1604
1605     sx= (sx << 2) >> lowres;
1606     sy= (sy << 2) >> lowres;
1607     if(field_select)
1608         src += s->linesize;
1609     pix_op[op_index](dest, src, stride, h, sx, sy);
1610     return emu;
1611 }
1612
1613 /* apply one mpeg motion vector to the three components */
1614 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1615                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1616                                int field_based, int bottom_field, int field_select,
1617                                uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1618                                int motion_x, int motion_y, int h, int mb_y)
1619 {
1620     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1621     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1622     const int lowres= s->avctx->lowres;
1623     const int op_index= FFMIN(lowres, 2);
1624     const int block_s= 8>>lowres;
1625     const int s_mask= (2<<lowres)-1;
1626     const int h_edge_pos = s->h_edge_pos >> lowres;
1627     const int v_edge_pos = s->v_edge_pos >> lowres;
1628     linesize   = s->current_picture.linesize[0] << field_based;
1629     uvlinesize = s->current_picture.linesize[1] << field_based;
1630
1631     if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1632         motion_x/=2;
1633         motion_y/=2;
1634     }
1635
1636     if(field_based){
1637         motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1638     }
1639
1640     sx= motion_x & s_mask;
1641     sy= motion_y & s_mask;
1642     src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
1643     src_y =(   mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1644
1645     if (s->out_format == FMT_H263) {
1646         uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1647         uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1648         uvsrc_x = src_x>>1;
1649         uvsrc_y = src_y>>1;
1650     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1651         mx = motion_x / 4;
1652         my = motion_y / 4;
1653         uvsx = (2*mx) & s_mask;
1654         uvsy = (2*my) & s_mask;
1655         uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
1656         uvsrc_y =    mb_y*block_s               + (my >> lowres);
1657     } else {
1658         mx = motion_x / 2;
1659         my = motion_y / 2;
1660         uvsx = mx & s_mask;
1661         uvsy = my & s_mask;
1662         uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
1663         uvsrc_y =(   mb_y*block_s>>field_based) + (my >> (lowres+1));
1664     }
1665
1666     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
1667     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1668     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1669
1670     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
1671        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1672             s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1673                              src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1674             ptr_y = s->edge_emu_buffer;
1675             if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1676                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1677                 s->dsp.emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
1678                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1679                 s->dsp.emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1680                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1681                 ptr_cb= uvbuf;
1682                 ptr_cr= uvbuf+16;
1683             }
1684     }
1685
1686     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1687         dest_y += s->linesize;
1688         dest_cb+= s->uvlinesize;
1689         dest_cr+= s->uvlinesize;
1690     }
1691
1692     if(field_select){
1693         ptr_y += s->linesize;
1694         ptr_cb+= s->uvlinesize;
1695         ptr_cr+= s->uvlinesize;
1696     }
1697
1698     sx= (sx << 2) >> lowres;
1699     sy= (sy << 2) >> lowres;
1700     pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1701
1702     if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1703         uvsx= (uvsx << 2) >> lowres;
1704         uvsy= (uvsy << 2) >> lowres;
1705         pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1706         pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1707     }
1708     //FIXME h261 lowres loop filter
1709 }
1710
1711 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1712                                      uint8_t *dest_cb, uint8_t *dest_cr,
1713                                      uint8_t **ref_picture,
1714                                      h264_chroma_mc_func *pix_op,
1715                                      int mx, int my){
1716     const int lowres= s->avctx->lowres;
1717     const int op_index= FFMIN(lowres, 2);
1718     const int block_s= 8>>lowres;
1719     const int s_mask= (2<<lowres)-1;
1720     const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1721     const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1722     int emu=0, src_x, src_y, offset, sx, sy;
1723     uint8_t *ptr;
1724
1725     if(s->quarter_sample){
1726         mx/=2;
1727         my/=2;
1728     }
1729
1730     /* In case of 8X8, we construct a single chroma motion vector
1731        with a special rounding */
1732     mx= ff_h263_round_chroma(mx);
1733     my= ff_h263_round_chroma(my);
1734
1735     sx= mx & s_mask;
1736     sy= my & s_mask;
1737     src_x = s->mb_x*block_s + (mx >> (lowres+1));
1738     src_y = s->mb_y*block_s + (my >> (lowres+1));
1739
1740     offset = src_y * s->uvlinesize + src_x;
1741     ptr = ref_picture[1] + offset;
1742     if(s->flags&CODEC_FLAG_EMU_EDGE){
1743         if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1744            || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1745             s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1746             ptr= s->edge_emu_buffer;
1747             emu=1;
1748         }
1749     }
1750     sx= (sx << 2) >> lowres;
1751     sy= (sy << 2) >> lowres;
1752     pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1753
1754     ptr = ref_picture[2] + offset;
1755     if(emu){
1756         s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1757         ptr= s->edge_emu_buffer;
1758     }
1759     pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1760 }
1761
1762 /**
1763  * motion compensation of a single macroblock
1764  * @param s context
1765  * @param dest_y luma destination pointer
1766  * @param dest_cb chroma cb/u destination pointer
1767  * @param dest_cr chroma cr/v destination pointer
1768  * @param dir direction (0->forward, 1->backward)
1769  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1770  * @param pix_op halfpel motion compensation function (average or put normally)
1771  * the motion vectors are taken from s->mv and the MV type from s->mv_type
1772  */
1773 static inline void MPV_motion_lowres(MpegEncContext *s,
1774                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1775                               int dir, uint8_t **ref_picture,
1776                               h264_chroma_mc_func *pix_op)
1777 {
1778     int mx, my;
1779     int mb_x, mb_y, i;
1780     const int lowres= s->avctx->lowres;
1781     const int block_s= 8>>lowres;
1782
1783     mb_x = s->mb_x;
1784     mb_y = s->mb_y;
1785
1786     switch(s->mv_type) {
1787     case MV_TYPE_16X16:
1788         mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1789                     0, 0, 0,
1790                     ref_picture, pix_op,
1791                     s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y);
1792         break;
1793     case MV_TYPE_8X8:
1794         mx = 0;
1795         my = 0;
1796             for(i=0;i<4;i++) {
1797                 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1798                             ref_picture[0], 0, 0,
1799                             (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1800                             s->width, s->height, s->linesize,
1801                             s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1802                             block_s, block_s, pix_op,
1803                             s->mv[dir][i][0], s->mv[dir][i][1]);
1804
1805                 mx += s->mv[dir][i][0];
1806                 my += s->mv[dir][i][1];
1807             }
1808
1809         if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1810             chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1811         break;
1812     case MV_TYPE_FIELD:
1813         if (s->picture_structure == PICT_FRAME) {
1814             /* top field */
1815             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1816                         1, 0, s->field_select[dir][0],
1817                         ref_picture, pix_op,
1818                         s->mv[dir][0][0], s->mv[dir][0][1], block_s, mb_y);
1819             /* bottom field */
1820             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1821                         1, 1, s->field_select[dir][1],
1822                         ref_picture, pix_op,
1823                         s->mv[dir][1][0], s->mv[dir][1][1], block_s, mb_y);
1824         } else {
1825             if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != FF_B_TYPE && !s->first_field){
1826                 ref_picture= s->current_picture_ptr->data;
1827             }
1828
1829             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1830                         0, 0, s->field_select[dir][0],
1831                         ref_picture, pix_op,
1832                         s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y>>1);
1833         }
1834         break;
1835     case MV_TYPE_16X8:
1836         for(i=0; i<2; i++){
1837             uint8_t ** ref2picture;
1838
1839             if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == FF_B_TYPE || s->first_field){
1840                 ref2picture= ref_picture;
1841             }else{
1842                 ref2picture= s->current_picture_ptr->data;
1843             }
1844
1845             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1846                         0, 0, s->field_select[dir][i],
1847                         ref2picture, pix_op,
1848                         s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s, mb_y>>1);
1849
1850             dest_y += 2*block_s*s->linesize;
1851             dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1852             dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1853         }
1854         break;
1855     case MV_TYPE_DMV:
1856         if(s->picture_structure == PICT_FRAME){
1857             for(i=0; i<2; i++){
1858                 int j;
1859                 for(j=0; j<2; j++){
1860                     mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1861                                 1, j, j^i,
1862                                 ref_picture, pix_op,
1863                                 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s, mb_y);
1864                 }
1865                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1866             }
1867         }else{
1868             for(i=0; i<2; i++){
1869                 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1870                             0, 0, s->picture_structure != i+1,
1871                             ref_picture, pix_op,
1872                             s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s, mb_y>>1);
1873
1874                 // after put we make avg of the same block
1875                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1876
1877                 //opposite parity is always in the same frame if this is second field
1878                 if(!s->first_field){
1879                     ref_picture = s->current_picture_ptr->data;
1880                 }
1881             }
1882         }
1883     break;
1884     default: assert(0);
1885     }
1886 }
1887
1888 /**
1889  * find the lowest MB row referenced in the MVs
1890  */
1891 int MPV_lowest_referenced_row(MpegEncContext *s, int dir)
1892 {
1893     int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
1894     int my, off, i, mvs;
1895
1896     if (s->picture_structure != PICT_FRAME) goto unhandled;
1897
1898     switch (s->mv_type) {
1899         case MV_TYPE_16X16:
1900             mvs = 1;
1901             break;
1902         case MV_TYPE_16X8:
1903             mvs = 2;
1904             break;
1905         case MV_TYPE_8X8:
1906             mvs = 4;
1907             break;
1908         default:
1909             goto unhandled;
1910     }
1911
1912     for (i = 0; i < mvs; i++) {
1913         my = s->mv[dir][i][1]<<qpel_shift;
1914         my_max = FFMAX(my_max, my);
1915         my_min = FFMIN(my_min, my);
1916     }
1917
1918     off = (FFMAX(-my_min, my_max) + 63) >> 6;
1919
1920     return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
1921 unhandled:
1922     return s->mb_height-1;
1923 }
1924
1925 /* put block[] to dest[] */
1926 static inline void put_dct(MpegEncContext *s,
1927                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1928 {
1929     s->dct_unquantize_intra(s, block, i, qscale);
1930     s->dsp.idct_put (dest, line_size, block);
1931 }
1932
1933 /* add block[] to dest[] */
1934 static inline void add_dct(MpegEncContext *s,
1935                            DCTELEM *block, int i, uint8_t *dest, int line_size)
1936 {
1937     if (s->block_last_index[i] >= 0) {
1938         s->dsp.idct_add (dest, line_size, block);
1939     }
1940 }
1941
1942 static inline void add_dequant_dct(MpegEncContext *s,
1943                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1944 {
1945     if (s->block_last_index[i] >= 0) {
1946         s->dct_unquantize_inter(s, block, i, qscale);
1947
1948         s->dsp.idct_add (dest, line_size, block);
1949     }
1950 }
1951
1952 /**
1953  * cleans dc, ac, coded_block for the current non intra MB
1954  */
1955 void ff_clean_intra_table_entries(MpegEncContext *s)
1956 {
1957     int wrap = s->b8_stride;
1958     int xy = s->block_index[0];
1959
1960     s->dc_val[0][xy           ] =
1961     s->dc_val[0][xy + 1       ] =
1962     s->dc_val[0][xy     + wrap] =
1963     s->dc_val[0][xy + 1 + wrap] = 1024;
1964     /* ac pred */
1965     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
1966     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1967     if (s->msmpeg4_version>=3) {
1968         s->coded_block[xy           ] =
1969         s->coded_block[xy + 1       ] =
1970         s->coded_block[xy     + wrap] =
1971         s->coded_block[xy + 1 + wrap] = 0;
1972     }
1973     /* chroma */
1974     wrap = s->mb_stride;
1975     xy = s->mb_x + s->mb_y * wrap;
1976     s->dc_val[1][xy] =
1977     s->dc_val[2][xy] = 1024;
1978     /* ac pred */
1979     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1980     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1981
1982     s->mbintra_table[xy]= 0;
1983 }
1984
1985 /* generic function called after a macroblock has been parsed by the
1986    decoder or after it has been encoded by the encoder.
1987
1988    Important variables used:
1989    s->mb_intra : true if intra macroblock
1990    s->mv_dir   : motion vector direction
1991    s->mv_type  : motion vector type
1992    s->mv       : motion vector
1993    s->interlaced_dct : true if interlaced dct used (mpeg2)
1994  */
1995 static av_always_inline
1996 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
1997                             int lowres_flag, int is_mpeg12)
1998 {
1999     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2000     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2001         ff_xvmc_decode_mb(s);//xvmc uses pblocks
2002         return;
2003     }
2004
2005     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2006        /* save DCT coefficients */
2007        int i,j;
2008        DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
2009        av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2010        for(i=0; i<6; i++){
2011            for(j=0; j<64; j++){
2012                *dct++ = block[i][s->dsp.idct_permutation[j]];
2013                av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
2014            }
2015            av_log(s->avctx, AV_LOG_DEBUG, "\n");
2016        }
2017     }
2018
2019     s->current_picture.qscale_table[mb_xy]= s->qscale;
2020
2021     /* update DC predictors for P macroblocks */
2022     if (!s->mb_intra) {
2023         if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2024             if(s->mbintra_table[mb_xy])
2025                 ff_clean_intra_table_entries(s);
2026         } else {
2027             s->last_dc[0] =
2028             s->last_dc[1] =
2029             s->last_dc[2] = 128 << s->intra_dc_precision;
2030         }
2031     }
2032     else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2033         s->mbintra_table[mb_xy]=1;
2034
2035     if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==FF_B_TYPE) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
2036         uint8_t *dest_y, *dest_cb, *dest_cr;
2037         int dct_linesize, dct_offset;
2038         op_pixels_func (*op_pix)[4];
2039         qpel_mc_func (*op_qpix)[16];
2040         const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2041         const int uvlinesize= s->current_picture.linesize[1];
2042         const int readable= s->pict_type != FF_B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2043         const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2044
2045         /* avoid copy if macroblock skipped in last frame too */
2046         /* skip only during decoding as we might trash the buffers during encoding a bit */
2047         if(!s->encoding){
2048             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2049             const int age= s->current_picture.age;
2050
2051             assert(age);
2052
2053             if (s->mb_skipped) {
2054                 s->mb_skipped= 0;
2055                 assert(s->pict_type!=FF_I_TYPE);
2056
2057                 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
2058                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2059
2060                 /* if previous was skipped too, then nothing to do !  */
2061                 if (*mbskip_ptr >= age && s->current_picture.reference){
2062                     return;
2063                 }
2064             } else if(!s->current_picture.reference){
2065                 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2066                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2067             } else{
2068                 *mbskip_ptr = 0; /* not skipped */
2069             }
2070         }
2071
2072         dct_linesize = linesize << s->interlaced_dct;
2073         dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
2074
2075         if(readable){
2076             dest_y=  s->dest[0];
2077             dest_cb= s->dest[1];
2078             dest_cr= s->dest[2];
2079         }else{
2080             dest_y = s->b_scratchpad;
2081             dest_cb= s->b_scratchpad+16*linesize;
2082             dest_cr= s->b_scratchpad+32*linesize;
2083         }
2084
2085         if (!s->mb_intra) {
2086             /* motion handling */
2087             /* decoding or more than one mb_type (MC was already done otherwise) */
2088             if(!s->encoding){
2089
2090                 if(HAVE_PTHREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2091                     if (s->mv_dir & MV_DIR_FORWARD) {
2092                         ff_thread_await_progress((AVFrame*)s->last_picture_ptr, MPV_lowest_referenced_row(s, 0), 0);
2093                     }
2094                     if (s->mv_dir & MV_DIR_BACKWARD) {
2095                         ff_thread_await_progress((AVFrame*)s->next_picture_ptr, MPV_lowest_referenced_row(s, 1), 0);
2096                     }
2097                 }
2098
2099                 if(lowres_flag){
2100                     h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
2101
2102                     if (s->mv_dir & MV_DIR_FORWARD) {
2103                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
2104                         op_pix = s->dsp.avg_h264_chroma_pixels_tab;
2105                     }
2106                     if (s->mv_dir & MV_DIR_BACKWARD) {
2107                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
2108                     }
2109                 }else{
2110                     op_qpix= s->me.qpel_put;
2111                     if ((!s->no_rounding) || s->pict_type==FF_B_TYPE){
2112                         op_pix = s->dsp.put_pixels_tab;
2113                     }else{
2114                         op_pix = s->dsp.put_no_rnd_pixels_tab;
2115                     }
2116                     if (s->mv_dir & MV_DIR_FORWARD) {
2117                         MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2118                         op_pix = s->dsp.avg_pixels_tab;
2119                         op_qpix= s->me.qpel_avg;
2120                     }
2121                     if (s->mv_dir & MV_DIR_BACKWARD) {
2122                         MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2123                     }
2124                 }
2125             }
2126
2127             /* skip dequant / idct if we are really late ;) */
2128 #if FF_API_HURRY_UP
2129             if(s->hurry_up>1) goto skip_idct;
2130 #endif
2131             if(s->avctx->skip_idct){
2132                 if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
2133                    ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
2134                    || s->avctx->skip_idct >= AVDISCARD_ALL)
2135                     goto skip_idct;
2136             }
2137
2138             /* add dct residue */
2139             if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
2140                                 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2141                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2142                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2143                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2144                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2145
2146                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2147                     if (s->chroma_y_shift){
2148                         add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2149                         add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2150                     }else{
2151                         dct_linesize >>= 1;
2152                         dct_offset >>=1;
2153                         add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2154                         add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2155                         add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2156                         add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2157                     }
2158                 }
2159             } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
2160                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
2161                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
2162                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
2163                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2164
2165                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2166                     if(s->chroma_y_shift){//Chroma420
2167                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
2168                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
2169                     }else{
2170                         //chroma422
2171                         dct_linesize = uvlinesize << s->interlaced_dct;
2172                         dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2173
2174                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
2175                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
2176                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2177                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2178                         if(!s->chroma_x_shift){//Chroma444
2179                             add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
2180                             add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
2181                             add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
2182                             add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
2183                         }
2184                     }
2185                 }//fi gray
2186             }
2187             else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2188                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2189             }
2190         } else {
2191             /* dct only in intra block */
2192             if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
2193                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2194                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2195                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2196                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2197
2198                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2199                     if(s->chroma_y_shift){
2200                         put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2201                         put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2202                     }else{
2203                         dct_offset >>=1;
2204                         dct_linesize >>=1;
2205                         put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2206                         put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2207                         put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2208                         put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2209                     }
2210                 }
2211             }else{
2212                 s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
2213                 s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
2214                 s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
2215                 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2216
2217                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2218                     if(s->chroma_y_shift){
2219                         s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2220                         s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2221                     }else{
2222
2223                         dct_linesize = uvlinesize << s->interlaced_dct;
2224                         dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2225
2226                         s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
2227                         s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
2228                         s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2229                         s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2230                         if(!s->chroma_x_shift){//Chroma444
2231                             s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
2232                             s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
2233                             s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2234                             s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2235                         }
2236                     }
2237                 }//gray
2238             }
2239         }
2240 skip_idct:
2241         if(!readable){
2242             s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
2243             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2244             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2245         }
2246     }
2247 }
2248
2249 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2250 #if !CONFIG_SMALL
2251     if(s->out_format == FMT_MPEG1) {
2252         if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2253         else                 MPV_decode_mb_internal(s, block, 0, 1);
2254     } else
2255 #endif
2256     if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2257     else                  MPV_decode_mb_internal(s, block, 0, 0);
2258 }
2259
2260 /**
2261  *
2262  * @param h is the normal height, this will be reduced automatically if needed for the last row
2263  */
2264 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2265     const int field_pic= s->picture_structure != PICT_FRAME;
2266     if(field_pic){
2267         h <<= 1;
2268         y <<= 1;
2269     }
2270
2271     if (!s->avctx->hwaccel
2272        && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2273        && s->unrestricted_mv
2274        && s->current_picture.reference
2275        && !s->intra_only
2276        && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
2277         int sides = 0, edge_h;
2278         if (y==0) sides |= EDGE_TOP;
2279         if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2280
2281         edge_h= FFMIN(h, s->v_edge_pos - y);
2282
2283         s->dsp.draw_edges(s->current_picture_ptr->data[0] +  y    *s->linesize  , s->linesize  , s->h_edge_pos   , edge_h   , EDGE_WIDTH  , sides);
2284         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);
2285         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);
2286     }
2287
2288     h= FFMIN(h, s->avctx->height - y);
2289
2290     if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2291
2292     if (s->avctx->draw_horiz_band) {
2293         AVFrame *src;
2294         int offset[4];
2295
2296         if(s->pict_type==FF_B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2297             src= (AVFrame*)s->current_picture_ptr;
2298         else if(s->last_picture_ptr)
2299             src= (AVFrame*)s->last_picture_ptr;
2300         else
2301             return;
2302
2303         if(s->pict_type==FF_B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2304             offset[0]=
2305             offset[1]=
2306             offset[2]=
2307             offset[3]= 0;
2308         }else{
2309             offset[0]= y * s->linesize;
2310             offset[1]=
2311             offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2312             offset[3]= 0;
2313         }
2314
2315         emms_c();
2316
2317         s->avctx->draw_horiz_band(s->avctx, src, offset,
2318                                   y, s->picture_structure, h);
2319     }
2320 }
2321
2322 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2323     const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2324     const int uvlinesize= s->current_picture.linesize[1];
2325     const int mb_size= 4 - s->avctx->lowres;
2326
2327     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2328     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2329     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2330     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2331     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2332     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;
2333     //block_index is not used by mpeg2, so it is not affected by chroma_format
2334
2335     s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2336     s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2337     s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2338
2339     if(!(s->pict_type==FF_B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2340     {
2341         if(s->picture_structure==PICT_FRAME){
2342         s->dest[0] += s->mb_y *   linesize << mb_size;
2343         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2344         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2345         }else{
2346             s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
2347             s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2348             s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2349             assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2350         }
2351     }
2352 }
2353
2354 void ff_mpeg_flush(AVCodecContext *avctx){
2355     int i;
2356     MpegEncContext *s = avctx->priv_data;
2357
2358     if(s==NULL || s->picture==NULL)
2359         return;
2360
2361     for(i=0; i<s->picture_count; i++){
2362        if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2363                                     || s->picture[i].type == FF_BUFFER_TYPE_USER))
2364         free_frame_buffer(s, &s->picture[i]);
2365     }
2366     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2367
2368     s->mb_x= s->mb_y= 0;
2369     s->closed_gop= 0;
2370
2371     s->parse_context.state= -1;
2372     s->parse_context.frame_start_found= 0;
2373     s->parse_context.overread= 0;
2374     s->parse_context.overread_index= 0;
2375     s->parse_context.index= 0;
2376     s->parse_context.last_index= 0;
2377     s->bitstream_buffer_size=0;
2378     s->pp_time=0;
2379 }
2380
2381 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2382                                    DCTELEM *block, int n, int qscale)
2383 {
2384     int i, level, nCoeffs;
2385     const uint16_t *quant_matrix;
2386
2387     nCoeffs= s->block_last_index[n];
2388
2389     if (n < 4)
2390         block[0] = block[0] * s->y_dc_scale;
2391     else
2392         block[0] = block[0] * s->c_dc_scale;
2393     /* XXX: only mpeg1 */
2394     quant_matrix = s->intra_matrix;
2395     for(i=1;i<=nCoeffs;i++) {
2396         int j= s->intra_scantable.permutated[i];
2397         level = block[j];
2398         if (level) {
2399             if (level < 0) {
2400                 level = -level;
2401                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2402                 level = (level - 1) | 1;
2403                 level = -level;
2404             } else {
2405                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2406                 level = (level - 1) | 1;
2407             }
2408             block[j] = level;
2409         }
2410     }
2411 }
2412
2413 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2414                                    DCTELEM *block, int n, int qscale)
2415 {
2416     int i, level, nCoeffs;
2417     const uint16_t *quant_matrix;
2418
2419     nCoeffs= s->block_last_index[n];
2420
2421     quant_matrix = s->inter_matrix;
2422     for(i=0; i<=nCoeffs; i++) {
2423         int j= s->intra_scantable.permutated[i];
2424         level = block[j];
2425         if (level) {
2426             if (level < 0) {
2427                 level = -level;
2428                 level = (((level << 1) + 1) * qscale *
2429                          ((int) (quant_matrix[j]))) >> 4;
2430                 level = (level - 1) | 1;
2431                 level = -level;
2432             } else {
2433                 level = (((level << 1) + 1) * qscale *
2434                          ((int) (quant_matrix[j]))) >> 4;
2435                 level = (level - 1) | 1;
2436             }
2437             block[j] = level;
2438         }
2439     }
2440 }
2441
2442 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2443                                    DCTELEM *block, int n, int qscale)
2444 {
2445     int i, level, nCoeffs;
2446     const uint16_t *quant_matrix;
2447
2448     if(s->alternate_scan) nCoeffs= 63;
2449     else nCoeffs= s->block_last_index[n];
2450
2451     if (n < 4)
2452         block[0] = block[0] * s->y_dc_scale;
2453     else
2454         block[0] = block[0] * s->c_dc_scale;
2455     quant_matrix = s->intra_matrix;
2456     for(i=1;i<=nCoeffs;i++) {
2457         int j= s->intra_scantable.permutated[i];
2458         level = block[j];
2459         if (level) {
2460             if (level < 0) {
2461                 level = -level;
2462                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2463                 level = -level;
2464             } else {
2465                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2466             }
2467             block[j] = level;
2468         }
2469     }
2470 }
2471
2472 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2473                                    DCTELEM *block, int n, int qscale)
2474 {
2475     int i, level, nCoeffs;
2476     const uint16_t *quant_matrix;
2477     int sum=-1;
2478
2479     if(s->alternate_scan) nCoeffs= 63;
2480     else nCoeffs= s->block_last_index[n];
2481
2482     if (n < 4)
2483         block[0] = block[0] * s->y_dc_scale;
2484     else
2485         block[0] = block[0] * s->c_dc_scale;
2486     quant_matrix = s->intra_matrix;
2487     for(i=1;i<=nCoeffs;i++) {
2488         int j= s->intra_scantable.permutated[i];
2489         level = block[j];
2490         if (level) {
2491             if (level < 0) {
2492                 level = -level;
2493                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2494                 level = -level;
2495             } else {
2496                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2497             }
2498             block[j] = level;
2499             sum+=level;
2500         }
2501     }
2502     block[63]^=sum&1;
2503 }
2504
2505 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2506                                    DCTELEM *block, int n, int qscale)
2507 {
2508     int i, level, nCoeffs;
2509     const uint16_t *quant_matrix;
2510     int sum=-1;
2511
2512     if(s->alternate_scan) nCoeffs= 63;
2513     else nCoeffs= s->block_last_index[n];
2514
2515     quant_matrix = s->inter_matrix;
2516     for(i=0; i<=nCoeffs; i++) {
2517         int j= s->intra_scantable.permutated[i];
2518         level = block[j];
2519         if (level) {
2520             if (level < 0) {
2521                 level = -level;
2522                 level = (((level << 1) + 1) * qscale *
2523                          ((int) (quant_matrix[j]))) >> 4;
2524                 level = -level;
2525             } else {
2526                 level = (((level << 1) + 1) * qscale *
2527                          ((int) (quant_matrix[j]))) >> 4;
2528             }
2529             block[j] = level;
2530             sum+=level;
2531         }
2532     }
2533     block[63]^=sum&1;
2534 }
2535
2536 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2537                                   DCTELEM *block, int n, int qscale)
2538 {
2539     int i, level, qmul, qadd;
2540     int nCoeffs;
2541
2542     assert(s->block_last_index[n]>=0);
2543
2544     qmul = qscale << 1;
2545
2546     if (!s->h263_aic) {
2547         if (n < 4)
2548             block[0] = block[0] * s->y_dc_scale;
2549         else
2550             block[0] = block[0] * s->c_dc_scale;
2551         qadd = (qscale - 1) | 1;
2552     }else{
2553         qadd = 0;
2554     }
2555     if(s->ac_pred)
2556         nCoeffs=63;
2557     else
2558         nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2559
2560     for(i=1; i<=nCoeffs; i++) {
2561         level = block[i];
2562         if (level) {
2563             if (level < 0) {
2564                 level = level * qmul - qadd;
2565             } else {
2566                 level = level * qmul + qadd;
2567             }
2568             block[i] = level;
2569         }
2570     }
2571 }
2572
2573 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2574                                   DCTELEM *block, int n, int qscale)
2575 {
2576     int i, level, qmul, qadd;
2577     int nCoeffs;
2578
2579     assert(s->block_last_index[n]>=0);
2580
2581     qadd = (qscale - 1) | 1;
2582     qmul = qscale << 1;
2583
2584     nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2585
2586     for(i=0; i<=nCoeffs; i++) {
2587         level = block[i];
2588         if (level) {
2589             if (level < 0) {
2590                 level = level * qmul - qadd;
2591             } else {
2592                 level = level * qmul + qadd;
2593             }
2594             block[i] = level;
2595         }
2596     }
2597 }
2598
2599 /**
2600  * set qscale and update qscale dependent variables.
2601  */
2602 void ff_set_qscale(MpegEncContext * s, int qscale)
2603 {
2604     if (qscale < 1)
2605         qscale = 1;
2606     else if (qscale > 31)
2607         qscale = 31;
2608
2609     s->qscale = qscale;
2610     s->chroma_qscale= s->chroma_qscale_table[qscale];
2611
2612     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2613     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2614 }
2615
2616 void MPV_report_decode_progress(MpegEncContext *s)
2617 {
2618     if (s->pict_type != FF_B_TYPE && !s->partitioned_frame)
2619         ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_y, 0);
2620 }