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 ? AV_PICTURE_TYPE_B : s->pict_type;
 317     if(pic->age < PREV_PICT_TYPES_BUFFER_SIZE && s->prev_pict_types[pic->age] == AV_PICTURE_TYPE_B)
 318         pic->age= INT_MAX; // Skipped MBs in B-frames are quite rare in MPEG-1/2 and it is a bit tricky to skip them anyway.
 319     pic->owner2 = 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!=AV_PICTURE_TYPE_B){
 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 != AV_PICTURE_TYPE_B && 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 != AV_PICTURE_TYPE_B)
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 == AV_PICTURE_TYPE_I;
1081
1082     ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1083
1084     if (s->pict_type != AV_PICTURE_TYPE_B) {
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!=AV_PICTURE_TYPE_I){
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==AV_PICTURE_TYPE_B){
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 == AV_PICTURE_TYPE_I || (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     s->error_recognition= avctx->error_recognition;
1135
1136     /* set dequantizer, we can't do it during init as it might change for mpeg4
1137        and we can't do it in the header decode as init is not called for mpeg4 there yet */
1138     if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1139         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1140         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1141     }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1142         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1143         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1144     }else{
1145         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1146         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1147     }
1148
1149     if(s->dct_error_sum){
1150         assert(s->avctx->noise_reduction && s->encoding);
1151
1152         update_noise_reduction(s);
1153     }
1154
1155     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1156         return ff_xvmc_field_start(s, avctx);
1157
1158     return 0;
1159 }
1160
1161 /* generic function for encode/decode called after a frame has been coded/decoded */
1162 void MPV_frame_end(MpegEncContext *s)
1163 {
1164     int i;
1165     /* redraw edges for the frame if decoding didn't complete */
1166     //just to make sure that all data is rendered.
1167     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1168         ff_xvmc_field_end(s);
1169    }else if((s->error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND))
1170        && !s->avctx->hwaccel
1171        && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
1172        && s->unrestricted_mv
1173        && s->current_picture.reference
1174        && !s->intra_only
1175        && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1176         int edges = EDGE_BOTTOM | EDGE_TOP, h = s->v_edge_pos;
1177
1178             s->dsp.draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , h   , EDGE_WIDTH  , edges);
1179             s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, h>>1, EDGE_WIDTH/2, edges);
1180             s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, h>>1, EDGE_WIDTH/2, edges);
1181
1182     }
1183
1184     emms_c();
1185
1186     s->last_pict_type    = s->pict_type;
1187     s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1188     if(s->pict_type!=AV_PICTURE_TYPE_B){
1189         s->last_non_b_pict_type= s->pict_type;
1190     }
1191 #if 0
1192         /* copy back current_picture variables */
1193     for(i=0; i<MAX_PICTURE_COUNT; i++){
1194         if(s->picture[i].data[0] == s->current_picture.data[0]){
1195             s->picture[i]= s->current_picture;
1196             break;
1197         }
1198     }
1199     assert(i<MAX_PICTURE_COUNT);
1200 #endif
1201
1202     if(s->encoding){
1203         /* release non-reference frames */
1204         for(i=0; i<s->picture_count; i++){
1205             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1206                 free_frame_buffer(s, &s->picture[i]);
1207             }
1208         }
1209     }
1210     // clear copies, to avoid confusion
1211 #if 0
1212     memset(&s->last_picture, 0, sizeof(Picture));
1213     memset(&s->next_picture, 0, sizeof(Picture));
1214     memset(&s->current_picture, 0, sizeof(Picture));
1215 #endif
1216     s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1217
1218     if (s->codec_id != CODEC_ID_H264 && s->current_picture.reference) {
1219         ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_height-1, 0);
1220     }
1221 }
1222
1223 /**
1224  * draws an line from (ex, ey) -> (sx, sy).
1225  * @param w width of the image
1226  * @param h height of the image
1227  * @param stride stride/linesize of the image
1228  * @param color color of the arrow
1229  */
1230 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1231     int x, y, fr, f;
1232
1233     sx= av_clip(sx, 0, w-1);
1234     sy= av_clip(sy, 0, h-1);
1235     ex= av_clip(ex, 0, w-1);
1236     ey= av_clip(ey, 0, h-1);
1237
1238     buf[sy*stride + sx]+= color;
1239
1240     if(FFABS(ex - sx) > FFABS(ey - sy)){
1241         if(sx > ex){
1242             FFSWAP(int, sx, ex);
1243             FFSWAP(int, sy, ey);
1244         }
1245         buf+= sx + sy*stride;
1246         ex-= sx;
1247         f= ((ey-sy)<<16)/ex;
1248         for(x= 0; x <= ex; x++){
1249             y = (x*f)>>16;
1250             fr= (x*f)&0xFFFF;
1251             buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1252             buf[(y+1)*stride + x]+= (color*         fr )>>16;
1253         }
1254     }else{
1255         if(sy > ey){
1256             FFSWAP(int, sx, ex);
1257             FFSWAP(int, sy, ey);
1258         }
1259         buf+= sx + sy*stride;
1260         ey-= sy;
1261         if(ey) f= ((ex-sx)<<16)/ey;
1262         else   f= 0;
1263         for(y= 0; y <= ey; y++){
1264             x = (y*f)>>16;
1265             fr= (y*f)&0xFFFF;
1266             buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;
1267             buf[y*stride + x+1]+= (color*         fr )>>16;
1268         }
1269     }
1270 }
1271
1272 /**
1273  * draws an arrow from (ex, ey) -> (sx, sy).
1274  * @param w width of the image
1275  * @param h height of the image
1276  * @param stride stride/linesize of the image
1277  * @param color color of the arrow
1278  */
1279 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1280     int dx,dy;
1281
1282     sx= av_clip(sx, -100, w+100);
1283     sy= av_clip(sy, -100, h+100);
1284     ex= av_clip(ex, -100, w+100);
1285     ey= av_clip(ey, -100, h+100);
1286
1287     dx= ex - sx;
1288     dy= ey - sy;
1289
1290     if(dx*dx + dy*dy > 3*3){
1291         int rx=  dx + dy;
1292         int ry= -dx + dy;
1293         int length= ff_sqrt((rx*rx + ry*ry)<<8);
1294
1295         //FIXME subpixel accuracy
1296         rx= ROUNDED_DIV(rx*3<<4, length);
1297         ry= ROUNDED_DIV(ry*3<<4, length);
1298
1299         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1300         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1301     }
1302     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1303 }
1304
1305 /**
1306  * prints debuging info for the given picture.
1307  */
1308 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1309
1310     if(s->avctx->hwaccel || !pict || !pict->mb_type) return;
1311
1312     if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1313         int x,y;
1314
1315         av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1316         switch (pict->pict_type) {
1317             case AV_PICTURE_TYPE_I: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1318             case AV_PICTURE_TYPE_P: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1319             case AV_PICTURE_TYPE_B: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1320             case AV_PICTURE_TYPE_S: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1321             case AV_PICTURE_TYPE_SI: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1322             case AV_PICTURE_TYPE_SP: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1323         }
1324         for(y=0; y<s->mb_height; y++){
1325             for(x=0; x<s->mb_width; x++){
1326                 if(s->avctx->debug&FF_DEBUG_SKIP){
1327                     int count= s->mbskip_table[x + y*s->mb_stride];
1328                     if(count>9) count=9;
1329                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1330                 }
1331                 if(s->avctx->debug&FF_DEBUG_QP){
1332                     av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1333                 }
1334                 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1335                     int mb_type= pict->mb_type[x + y*s->mb_stride];
1336                     //Type & MV direction
1337                     if(IS_PCM(mb_type))
1338                         av_log(s->avctx, AV_LOG_DEBUG, "P");
1339                     else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1340                         av_log(s->avctx, AV_LOG_DEBUG, "A");
1341                     else if(IS_INTRA4x4(mb_type))
1342                         av_log(s->avctx, AV_LOG_DEBUG, "i");
1343                     else if(IS_INTRA16x16(mb_type))
1344                         av_log(s->avctx, AV_LOG_DEBUG, "I");
1345                     else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1346                         av_log(s->avctx, AV_LOG_DEBUG, "d");
1347                     else if(IS_DIRECT(mb_type))
1348                         av_log(s->avctx, AV_LOG_DEBUG, "D");
1349                     else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1350                         av_log(s->avctx, AV_LOG_DEBUG, "g");
1351                     else if(IS_GMC(mb_type))
1352                         av_log(s->avctx, AV_LOG_DEBUG, "G");
1353                     else if(IS_SKIP(mb_type))
1354                         av_log(s->avctx, AV_LOG_DEBUG, "S");
1355                     else if(!USES_LIST(mb_type, 1))
1356                         av_log(s->avctx, AV_LOG_DEBUG, ">");
1357                     else if(!USES_LIST(mb_type, 0))
1358                         av_log(s->avctx, AV_LOG_DEBUG, "<");
1359                     else{
1360                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1361                         av_log(s->avctx, AV_LOG_DEBUG, "X");
1362                     }
1363
1364                     //segmentation
1365                     if(IS_8X8(mb_type))
1366                         av_log(s->avctx, AV_LOG_DEBUG, "+");
1367                     else if(IS_16X8(mb_type))
1368                         av_log(s->avctx, AV_LOG_DEBUG, "-");
1369                     else if(IS_8X16(mb_type))
1370                         av_log(s->avctx, AV_LOG_DEBUG, "|");
1371                     else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1372                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1373                     else
1374                         av_log(s->avctx, AV_LOG_DEBUG, "?");
1375
1376
1377                     if(IS_INTERLACED(mb_type))
1378                         av_log(s->avctx, AV_LOG_DEBUG, "=");
1379                     else
1380                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1381                 }
1382 //                av_log(s->avctx, AV_LOG_DEBUG, " ");
1383             }
1384             av_log(s->avctx, AV_LOG_DEBUG, "\n");
1385         }
1386     }
1387
1388     if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1389         const int shift= 1 + s->quarter_sample;
1390         int mb_y;
1391         uint8_t *ptr;
1392         int i;
1393         int h_chroma_shift, v_chroma_shift, block_height;
1394         const int width = s->avctx->width;
1395         const int height= s->avctx->height;
1396         const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1397         const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1398         s->low_delay=0; //needed to see the vectors without trashing the buffers
1399
1400         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1401         for(i=0; i<3; i++){
1402             memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1403             pict->data[i]= s->visualization_buffer[i];
1404         }
1405         pict->type= FF_BUFFER_TYPE_COPY;
1406         ptr= pict->data[0];
1407         block_height = 16>>v_chroma_shift;
1408
1409         for(mb_y=0; mb_y<s->mb_height; mb_y++){
1410             int mb_x;
1411             for(mb_x=0; mb_x<s->mb_width; mb_x++){
1412                 const int mb_index= mb_x + mb_y*s->mb_stride;
1413                 if((s->avctx->debug_mv) && pict->motion_val){
1414                   int type;
1415                   for(type=0; type<3; type++){
1416                     int direction = 0;
1417                     switch (type) {
1418                       case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=AV_PICTURE_TYPE_P))
1419                                 continue;
1420                               direction = 0;
1421                               break;
1422                       case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=AV_PICTURE_TYPE_B))
1423                                 continue;
1424                               direction = 0;
1425                               break;
1426                       case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=AV_PICTURE_TYPE_B))
1427                                 continue;
1428                               direction = 1;
1429                               break;
1430                     }
1431                     if(!USES_LIST(pict->mb_type[mb_index], direction))
1432                         continue;
1433
1434                     if(IS_8X8(pict->mb_type[mb_index])){
1435                       int i;
1436                       for(i=0; i<4; i++){
1437                         int sx= mb_x*16 + 4 + 8*(i&1);
1438                         int sy= mb_y*16 + 4 + 8*(i>>1);
1439                         int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1440                         int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1441                         int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1442                         draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1443                       }
1444                     }else if(IS_16X8(pict->mb_type[mb_index])){
1445                       int i;
1446                       for(i=0; i<2; i++){
1447                         int sx=mb_x*16 + 8;
1448                         int sy=mb_y*16 + 4 + 8*i;
1449                         int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1450                         int mx=(pict->motion_val[direction][xy][0]>>shift);
1451                         int my=(pict->motion_val[direction][xy][1]>>shift);
1452
1453                         if(IS_INTERLACED(pict->mb_type[mb_index]))
1454                             my*=2;
1455
1456                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1457                       }
1458                     }else if(IS_8X16(pict->mb_type[mb_index])){
1459                       int i;
1460                       for(i=0; i<2; i++){
1461                         int sx=mb_x*16 + 4 + 8*i;
1462                         int sy=mb_y*16 + 8;
1463                         int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1464                         int mx=(pict->motion_val[direction][xy][0]>>shift);
1465                         int my=(pict->motion_val[direction][xy][1]>>shift);
1466
1467                         if(IS_INTERLACED(pict->mb_type[mb_index]))
1468                             my*=2;
1469
1470                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1471                       }
1472                     }else{
1473                       int sx= mb_x*16 + 8;
1474                       int sy= mb_y*16 + 8;
1475                       int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1476                       int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1477                       int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1478                       draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1479                     }
1480                   }
1481                 }
1482                 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1483                     uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1484                     int y;
1485                     for(y=0; y<block_height; y++){
1486                         *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1487                         *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1488                     }
1489                 }
1490                 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1491                     int mb_type= pict->mb_type[mb_index];
1492                     uint64_t u,v;
1493                     int y;
1494 #define COLOR(theta, r)\
1495 u= (int)(128 + r*cos(theta*3.141592/180));\
1496 v= (int)(128 + r*sin(theta*3.141592/180));
1497
1498
1499                     u=v=128;
1500                     if(IS_PCM(mb_type)){
1501                         COLOR(120,48)
1502                     }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1503                         COLOR(30,48)
1504                     }else if(IS_INTRA4x4(mb_type)){
1505                         COLOR(90,48)
1506                     }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1507 //                        COLOR(120,48)
1508                     }else if(IS_DIRECT(mb_type)){
1509                         COLOR(150,48)
1510                     }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1511                         COLOR(170,48)
1512                     }else if(IS_GMC(mb_type)){
1513                         COLOR(190,48)
1514                     }else if(IS_SKIP(mb_type)){
1515 //                        COLOR(180,48)
1516                     }else if(!USES_LIST(mb_type, 1)){
1517                         COLOR(240,48)
1518                     }else if(!USES_LIST(mb_type, 0)){
1519                         COLOR(0,48)
1520                     }else{
1521                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1522                         COLOR(300,48)
1523                     }
1524
1525                     u*= 0x0101010101010101ULL;
1526                     v*= 0x0101010101010101ULL;
1527                     for(y=0; y<block_height; y++){
1528                         *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1529                         *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1530                     }
1531
1532                     //segmentation
1533                     if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1534                         *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1535                         *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1536                     }
1537                     if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1538                         for(y=0; y<16; y++)
1539                             pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1540                     }
1541                     if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1542                         int dm= 1 << (mv_sample_log2-2);
1543                         for(i=0; i<4; i++){
1544                             int sx= mb_x*16 + 8*(i&1);
1545                             int sy= mb_y*16 + 8*(i>>1);
1546                             int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1547                             //FIXME bidir
1548                             int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1549                             if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1550                                 for(y=0; y<8; y++)
1551                                     pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1552                             if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1553                                 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1554                         }
1555                     }
1556
1557                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1558                         // hmm
1559                     }
1560                 }
1561                 s->mbskip_table[mb_index]=0;
1562             }
1563         }
1564     }
1565 }
1566
1567 static inline int hpel_motion_lowres(MpegEncContext *s,
1568                                   uint8_t *dest, uint8_t *src,
1569                                   int field_based, int field_select,
1570                                   int src_x, int src_y,
1571                                   int width, int height, int stride,
1572                                   int h_edge_pos, int v_edge_pos,
1573                                   int w, int h, h264_chroma_mc_func *pix_op,
1574                                   int motion_x, int motion_y)
1575 {
1576     const int lowres= s->avctx->lowres;
1577     const int op_index= FFMIN(lowres, 2);
1578     const int s_mask= (2<<lowres)-1;
1579     int emu=0;
1580     int sx, sy;
1581
1582     if(s->quarter_sample){
1583         motion_x/=2;
1584         motion_y/=2;
1585     }
1586
1587     sx= motion_x & s_mask;
1588     sy= motion_y & s_mask;
1589     src_x += motion_x >> (lowres+1);
1590     src_y += motion_y >> (lowres+1);
1591
1592     src += src_y * stride + src_x;
1593
1594     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
1595        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1596         s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1597                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1598         src= s->edge_emu_buffer;
1599         emu=1;
1600     }
1601
1602     sx= (sx << 2) >> lowres;
1603     sy= (sy << 2) >> lowres;
1604     if(field_select)
1605         src += s->linesize;
1606     pix_op[op_index](dest, src, stride, h, sx, sy);
1607     return emu;
1608 }
1609
1610 /* apply one mpeg motion vector to the three components */
1611 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1612                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1613                                int field_based, int bottom_field, int field_select,
1614                                uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1615                                int motion_x, int motion_y, int h, int mb_y)
1616 {
1617     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1618     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1619     const int lowres= s->avctx->lowres;
1620     const int op_index= FFMIN(lowres, 2);
1621     const int block_s= 8>>lowres;
1622     const int s_mask= (2<<lowres)-1;
1623     const int h_edge_pos = s->h_edge_pos >> lowres;
1624     const int v_edge_pos = s->v_edge_pos >> lowres;
1625     linesize   = s->current_picture.linesize[0] << field_based;
1626     uvlinesize = s->current_picture.linesize[1] << field_based;
1627
1628     if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1629         motion_x/=2;
1630         motion_y/=2;
1631     }
1632
1633     if(field_based){
1634         motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1635     }
1636
1637     sx= motion_x & s_mask;
1638     sy= motion_y & s_mask;
1639     src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
1640     src_y =(   mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1641
1642     if (s->out_format == FMT_H263) {
1643         uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1644         uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1645         uvsrc_x = src_x>>1;
1646         uvsrc_y = src_y>>1;
1647     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1648         mx = motion_x / 4;
1649         my = motion_y / 4;
1650         uvsx = (2*mx) & s_mask;
1651         uvsy = (2*my) & s_mask;
1652         uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
1653         uvsrc_y =    mb_y*block_s               + (my >> lowres);
1654     } else {
1655         mx = motion_x / 2;
1656         my = motion_y / 2;
1657         uvsx = mx & s_mask;
1658         uvsy = my & s_mask;
1659         uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
1660         uvsrc_y =(   mb_y*block_s>>field_based) + (my >> (lowres+1));
1661     }
1662
1663     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
1664     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1665     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1666
1667     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
1668        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1669             s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1670                              src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1671             ptr_y = s->edge_emu_buffer;
1672             if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1673                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1674                 s->dsp.emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
1675                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1676                 s->dsp.emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1677                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1678                 ptr_cb= uvbuf;
1679                 ptr_cr= uvbuf+16;
1680             }
1681     }
1682
1683     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1684         dest_y += s->linesize;
1685         dest_cb+= s->uvlinesize;
1686         dest_cr+= s->uvlinesize;
1687     }
1688
1689     if(field_select){
1690         ptr_y += s->linesize;
1691         ptr_cb+= s->uvlinesize;
1692         ptr_cr+= s->uvlinesize;
1693     }
1694
1695     sx= (sx << 2) >> lowres;
1696     sy= (sy << 2) >> lowres;
1697     pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1698
1699     if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1700         uvsx= (uvsx << 2) >> lowres;
1701         uvsy= (uvsy << 2) >> lowres;
1702         pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1703         pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1704     }
1705     //FIXME h261 lowres loop filter
1706 }
1707
1708 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1709                                      uint8_t *dest_cb, uint8_t *dest_cr,
1710                                      uint8_t **ref_picture,
1711                                      h264_chroma_mc_func *pix_op,
1712                                      int mx, int my){
1713     const int lowres= s->avctx->lowres;
1714     const int op_index= FFMIN(lowres, 2);
1715     const int block_s= 8>>lowres;
1716     const int s_mask= (2<<lowres)-1;
1717     const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1718     const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1719     int emu=0, src_x, src_y, offset, sx, sy;
1720     uint8_t *ptr;
1721
1722     if(s->quarter_sample){
1723         mx/=2;
1724         my/=2;
1725     }
1726
1727     /* In case of 8X8, we construct a single chroma motion vector
1728        with a special rounding */
1729     mx= ff_h263_round_chroma(mx);
1730     my= ff_h263_round_chroma(my);
1731
1732     sx= mx & s_mask;
1733     sy= my & s_mask;
1734     src_x = s->mb_x*block_s + (mx >> (lowres+1));
1735     src_y = s->mb_y*block_s + (my >> (lowres+1));
1736
1737     offset = src_y * s->uvlinesize + src_x;
1738     ptr = ref_picture[1] + offset;
1739     if(s->flags&CODEC_FLAG_EMU_EDGE){
1740         if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1741            || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1742             s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1743             ptr= s->edge_emu_buffer;
1744             emu=1;
1745         }
1746     }
1747     sx= (sx << 2) >> lowres;
1748     sy= (sy << 2) >> lowres;
1749     pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1750
1751     ptr = ref_picture[2] + offset;
1752     if(emu){
1753         s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1754         ptr= s->edge_emu_buffer;
1755     }
1756     pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1757 }
1758
1759 /**
1760  * motion compensation of a single macroblock
1761  * @param s context
1762  * @param dest_y luma destination pointer
1763  * @param dest_cb chroma cb/u destination pointer
1764  * @param dest_cr chroma cr/v destination pointer
1765  * @param dir direction (0->forward, 1->backward)
1766  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1767  * @param pix_op halfpel motion compensation function (average or put normally)
1768  * the motion vectors are taken from s->mv and the MV type from s->mv_type
1769  */
1770 static inline void MPV_motion_lowres(MpegEncContext *s,
1771                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1772                               int dir, uint8_t **ref_picture,
1773                               h264_chroma_mc_func *pix_op)
1774 {
1775     int mx, my;
1776     int mb_x, mb_y, i;
1777     const int lowres= s->avctx->lowres;
1778     const int block_s= 8>>lowres;
1779
1780     mb_x = s->mb_x;
1781     mb_y = s->mb_y;
1782
1783     switch(s->mv_type) {
1784     case MV_TYPE_16X16:
1785         mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1786                     0, 0, 0,
1787                     ref_picture, pix_op,
1788                     s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y);
1789         break;
1790     case MV_TYPE_8X8:
1791         mx = 0;
1792         my = 0;
1793             for(i=0;i<4;i++) {
1794                 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1795                             ref_picture[0], 0, 0,
1796                             (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1797                             s->width, s->height, s->linesize,
1798                             s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1799                             block_s, block_s, pix_op,
1800                             s->mv[dir][i][0], s->mv[dir][i][1]);
1801
1802                 mx += s->mv[dir][i][0];
1803                 my += s->mv[dir][i][1];
1804             }
1805
1806         if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1807             chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1808         break;
1809     case MV_TYPE_FIELD:
1810         if (s->picture_structure == PICT_FRAME) {
1811             /* top field */
1812             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1813                         1, 0, s->field_select[dir][0],
1814                         ref_picture, pix_op,
1815                         s->mv[dir][0][0], s->mv[dir][0][1], block_s, mb_y);
1816             /* bottom field */
1817             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1818                         1, 1, s->field_select[dir][1],
1819                         ref_picture, pix_op,
1820                         s->mv[dir][1][0], s->mv[dir][1][1], block_s, mb_y);
1821         } else {
1822             if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != AV_PICTURE_TYPE_B && !s->first_field){
1823                 ref_picture= s->current_picture_ptr->data;
1824             }
1825
1826             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1827                         0, 0, s->field_select[dir][0],
1828                         ref_picture, pix_op,
1829                         s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y>>1);
1830         }
1831         break;
1832     case MV_TYPE_16X8:
1833         for(i=0; i<2; i++){
1834             uint8_t ** ref2picture;
1835
1836             if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == AV_PICTURE_TYPE_B || s->first_field){
1837                 ref2picture= ref_picture;
1838             }else{
1839                 ref2picture= s->current_picture_ptr->data;
1840             }
1841
1842             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1843                         0, 0, s->field_select[dir][i],
1844                         ref2picture, pix_op,
1845                         s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s, mb_y>>1);
1846
1847             dest_y += 2*block_s*s->linesize;
1848             dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1849             dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1850         }
1851         break;
1852     case MV_TYPE_DMV:
1853         if(s->picture_structure == PICT_FRAME){
1854             for(i=0; i<2; i++){
1855                 int j;
1856                 for(j=0; j<2; j++){
1857                     mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1858                                 1, j, j^i,
1859                                 ref_picture, pix_op,
1860                                 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s, mb_y);
1861                 }
1862                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1863             }
1864         }else{
1865             for(i=0; i<2; i++){
1866                 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1867                             0, 0, s->picture_structure != i+1,
1868                             ref_picture, pix_op,
1869                             s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s, mb_y>>1);
1870
1871                 // after put we make avg of the same block
1872                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1873
1874                 //opposite parity is always in the same frame if this is second field
1875                 if(!s->first_field){
1876                     ref_picture = s->current_picture_ptr->data;
1877                 }
1878             }
1879         }
1880     break;
1881     default: assert(0);
1882     }
1883 }
1884
1885 /**
1886  * find the lowest MB row referenced in the MVs
1887  */
1888 int MPV_lowest_referenced_row(MpegEncContext *s, int dir)
1889 {
1890     int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
1891     int my, off, i, mvs;
1892
1893     if (s->picture_structure != PICT_FRAME) goto unhandled;
1894
1895     switch (s->mv_type) {
1896         case MV_TYPE_16X16:
1897             mvs = 1;
1898             break;
1899         case MV_TYPE_16X8:
1900             mvs = 2;
1901             break;
1902         case MV_TYPE_8X8:
1903             mvs = 4;
1904             break;
1905         default:
1906             goto unhandled;
1907     }
1908
1909     for (i = 0; i < mvs; i++) {
1910         my = s->mv[dir][i][1]<<qpel_shift;
1911         my_max = FFMAX(my_max, my);
1912         my_min = FFMIN(my_min, my);
1913     }
1914
1915     off = (FFMAX(-my_min, my_max) + 63) >> 6;
1916
1917     return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
1918 unhandled:
1919     return s->mb_height-1;
1920 }
1921
1922 /* put block[] to dest[] */
1923 static inline void put_dct(MpegEncContext *s,
1924                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1925 {
1926     s->dct_unquantize_intra(s, block, i, qscale);
1927     s->dsp.idct_put (dest, line_size, block);
1928 }
1929
1930 /* add block[] to dest[] */
1931 static inline void add_dct(MpegEncContext *s,
1932                            DCTELEM *block, int i, uint8_t *dest, int line_size)
1933 {
1934     if (s->block_last_index[i] >= 0) {
1935         s->dsp.idct_add (dest, line_size, block);
1936     }
1937 }
1938
1939 static inline void add_dequant_dct(MpegEncContext *s,
1940                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1941 {
1942     if (s->block_last_index[i] >= 0) {
1943         s->dct_unquantize_inter(s, block, i, qscale);
1944
1945         s->dsp.idct_add (dest, line_size, block);
1946     }
1947 }
1948
1949 /**
1950  * cleans dc, ac, coded_block for the current non intra MB
1951  */
1952 void ff_clean_intra_table_entries(MpegEncContext *s)
1953 {
1954     int wrap = s->b8_stride;
1955     int xy = s->block_index[0];
1956
1957     s->dc_val[0][xy           ] =
1958     s->dc_val[0][xy + 1       ] =
1959     s->dc_val[0][xy     + wrap] =
1960     s->dc_val[0][xy + 1 + wrap] = 1024;
1961     /* ac pred */
1962     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
1963     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1964     if (s->msmpeg4_version>=3) {
1965         s->coded_block[xy           ] =
1966         s->coded_block[xy + 1       ] =
1967         s->coded_block[xy     + wrap] =
1968         s->coded_block[xy + 1 + wrap] = 0;
1969     }
1970     /* chroma */
1971     wrap = s->mb_stride;
1972     xy = s->mb_x + s->mb_y * wrap;
1973     s->dc_val[1][xy] =
1974     s->dc_val[2][xy] = 1024;
1975     /* ac pred */
1976     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1977     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1978
1979     s->mbintra_table[xy]= 0;
1980 }
1981
1982 /* generic function called after a macroblock has been parsed by the
1983    decoder or after it has been encoded by the encoder.
1984
1985    Important variables used:
1986    s->mb_intra : true if intra macroblock
1987    s->mv_dir   : motion vector direction
1988    s->mv_type  : motion vector type
1989    s->mv       : motion vector
1990    s->interlaced_dct : true if interlaced dct used (mpeg2)
1991  */
1992 static av_always_inline
1993 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
1994                             int lowres_flag, int is_mpeg12)
1995 {
1996     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1997     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1998         ff_xvmc_decode_mb(s);//xvmc uses pblocks
1999         return;
2000     }
2001
2002     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2003        /* save DCT coefficients */
2004        int i,j;
2005        DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
2006        av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2007        for(i=0; i<6; i++){
2008            for(j=0; j<64; j++){
2009                *dct++ = block[i][s->dsp.idct_permutation[j]];
2010                av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
2011            }
2012            av_log(s->avctx, AV_LOG_DEBUG, "\n");
2013        }
2014     }
2015
2016     s->current_picture.qscale_table[mb_xy]= s->qscale;
2017
2018     /* update DC predictors for P macroblocks */
2019     if (!s->mb_intra) {
2020         if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2021             if(s->mbintra_table[mb_xy])
2022                 ff_clean_intra_table_entries(s);
2023         } else {
2024             s->last_dc[0] =
2025             s->last_dc[1] =
2026             s->last_dc[2] = 128 << s->intra_dc_precision;
2027         }
2028     }
2029     else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2030         s->mbintra_table[mb_xy]=1;
2031
2032     if ((s->flags&CODEC_FLAG_PSNR) || !(s->encoding && (s->intra_only || s->pict_type==AV_PICTURE_TYPE_B) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
2033         uint8_t *dest_y, *dest_cb, *dest_cr;
2034         int dct_linesize, dct_offset;
2035         op_pixels_func (*op_pix)[4];
2036         qpel_mc_func (*op_qpix)[16];
2037         const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2038         const int uvlinesize= s->current_picture.linesize[1];
2039         const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2040         const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2041
2042         /* avoid copy if macroblock skipped in last frame too */
2043         /* skip only during decoding as we might trash the buffers during encoding a bit */
2044         if(!s->encoding){
2045             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2046             const int age= s->current_picture.age;
2047
2048             assert(age);
2049
2050             if (s->mb_skipped) {
2051                 s->mb_skipped= 0;
2052                 assert(s->pict_type!=AV_PICTURE_TYPE_I);
2053
2054                 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
2055                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2056
2057                 /* if previous was skipped too, then nothing to do !  */
2058                 if (*mbskip_ptr >= age && s->current_picture.reference){
2059                     return;
2060                 }
2061             } else if(!s->current_picture.reference){
2062                 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
2063                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
2064             } else{
2065                 *mbskip_ptr = 0; /* not skipped */
2066             }
2067         }
2068
2069         dct_linesize = linesize << s->interlaced_dct;
2070         dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
2071
2072         if(readable){
2073             dest_y=  s->dest[0];
2074             dest_cb= s->dest[1];
2075             dest_cr= s->dest[2];
2076         }else{
2077             dest_y = s->b_scratchpad;
2078             dest_cb= s->b_scratchpad+16*linesize;
2079             dest_cr= s->b_scratchpad+32*linesize;
2080         }
2081
2082         if (!s->mb_intra) {
2083             /* motion handling */
2084             /* decoding or more than one mb_type (MC was already done otherwise) */
2085             if(!s->encoding){
2086
2087                 if(HAVE_PTHREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2088                     if (s->mv_dir & MV_DIR_FORWARD) {
2089                         ff_thread_await_progress((AVFrame*)s->last_picture_ptr, MPV_lowest_referenced_row(s, 0), 0);
2090                     }
2091                     if (s->mv_dir & MV_DIR_BACKWARD) {
2092                         ff_thread_await_progress((AVFrame*)s->next_picture_ptr, MPV_lowest_referenced_row(s, 1), 0);
2093                     }
2094                 }
2095
2096                 if(lowres_flag){
2097                     h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
2098
2099                     if (s->mv_dir & MV_DIR_FORWARD) {
2100                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
2101                         op_pix = s->dsp.avg_h264_chroma_pixels_tab;
2102                     }
2103                     if (s->mv_dir & MV_DIR_BACKWARD) {
2104                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
2105                     }
2106                 }else{
2107                     op_qpix= s->me.qpel_put;
2108                     if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2109                         op_pix = s->dsp.put_pixels_tab;
2110                     }else{
2111                         op_pix = s->dsp.put_no_rnd_pixels_tab;
2112                     }
2113                     if (s->mv_dir & MV_DIR_FORWARD) {
2114                         MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
2115                         op_pix = s->dsp.avg_pixels_tab;
2116                         op_qpix= s->me.qpel_avg;
2117                     }
2118                     if (s->mv_dir & MV_DIR_BACKWARD) {
2119                         MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
2120                     }
2121                 }
2122             }
2123
2124             /* skip dequant / idct if we are really late ;) */
2125             if(s->avctx->skip_idct){
2126                 if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2127                    ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2128                    || s->avctx->skip_idct >= AVDISCARD_ALL)
2129                     goto skip_idct;
2130             }
2131
2132             /* add dct residue */
2133             if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
2134                                 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2135                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2136                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2137                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2138                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2139
2140                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2141                     if (s->chroma_y_shift){
2142                         add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2143                         add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2144                     }else{
2145                         dct_linesize >>= 1;
2146                         dct_offset >>=1;
2147                         add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2148                         add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2149                         add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2150                         add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2151                     }
2152                 }
2153             } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
2154                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
2155                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
2156                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
2157                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2158
2159                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2160                     if(s->chroma_y_shift){//Chroma420
2161                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
2162                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
2163                     }else{
2164                         //chroma422
2165                         dct_linesize = uvlinesize << s->interlaced_dct;
2166                         dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2167
2168                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
2169                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
2170                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2171                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2172                         if(!s->chroma_x_shift){//Chroma444
2173                             add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
2174                             add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
2175                             add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
2176                             add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
2177                         }
2178                     }
2179                 }//fi gray
2180             }
2181             else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2182                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2183             }
2184         } else {
2185             /* dct only in intra block */
2186             if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
2187                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2188                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2189                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2190                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2191
2192                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2193                     if(s->chroma_y_shift){
2194                         put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2195                         put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2196                     }else{
2197                         dct_offset >>=1;
2198                         dct_linesize >>=1;
2199                         put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2200                         put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2201                         put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2202                         put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2203                     }
2204                 }
2205             }else{
2206                 s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
2207                 s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
2208                 s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
2209                 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2210
2211                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2212                     if(s->chroma_y_shift){
2213                         s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2214                         s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2215                     }else{
2216
2217                         dct_linesize = uvlinesize << s->interlaced_dct;
2218                         dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2219
2220                         s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
2221                         s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
2222                         s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2223                         s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2224                         if(!s->chroma_x_shift){//Chroma444
2225                             s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
2226                             s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
2227                             s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2228                             s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2229                         }
2230                     }
2231                 }//gray
2232             }
2233         }
2234 skip_idct:
2235         if(!readable){
2236             s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
2237             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2238             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2239         }
2240     }
2241 }
2242
2243 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2244 #if !CONFIG_SMALL
2245     if(s->out_format == FMT_MPEG1) {
2246         if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2247         else                 MPV_decode_mb_internal(s, block, 0, 1);
2248     } else
2249 #endif
2250     if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2251     else                  MPV_decode_mb_internal(s, block, 0, 0);
2252 }
2253
2254 /**
2255  *
2256  * @param h is the normal height, this will be reduced automatically if needed for the last row
2257  */
2258 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2259     const int field_pic= s->picture_structure != PICT_FRAME;
2260     if(field_pic){
2261         h <<= 1;
2262         y <<= 1;
2263     }
2264
2265     if (!s->avctx->hwaccel
2266        && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2267        && s->unrestricted_mv
2268        && s->current_picture.reference
2269        && !s->intra_only
2270        && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
2271         int sides = 0, edge_h;
2272         if (y==0) sides |= EDGE_TOP;
2273         if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2274
2275         edge_h= FFMIN(h, s->v_edge_pos - y);
2276
2277         s->dsp.draw_edges(s->current_picture_ptr->data[0] +  y    *s->linesize  , s->linesize  , s->h_edge_pos   , edge_h   , EDGE_WIDTH  , sides);
2278         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);
2279         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);
2280     }
2281
2282     h= FFMIN(h, s->avctx->height - y);
2283
2284     if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2285
2286     if (s->avctx->draw_horiz_band) {
2287         AVFrame *src;
2288         int offset[4];
2289
2290         if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2291             src= (AVFrame*)s->current_picture_ptr;
2292         else if(s->last_picture_ptr)
2293             src= (AVFrame*)s->last_picture_ptr;
2294         else
2295             return;
2296
2297         if(s->pict_type==AV_PICTURE_TYPE_B && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2298             offset[0]=
2299             offset[1]=
2300             offset[2]=
2301             offset[3]= 0;
2302         }else{
2303             offset[0]= y * s->linesize;
2304             offset[1]=
2305             offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2306             offset[3]= 0;
2307         }
2308
2309         emms_c();
2310
2311         s->avctx->draw_horiz_band(s->avctx, src, offset,
2312                                   y, s->picture_structure, h);
2313     }
2314 }
2315
2316 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2317     const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2318     const int uvlinesize= s->current_picture.linesize[1];
2319     const int mb_size= 4 - s->avctx->lowres;
2320
2321     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2322     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2323     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2324     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2325     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2326     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;
2327     //block_index is not used by mpeg2, so it is not affected by chroma_format
2328
2329     s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2330     s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2331     s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2332
2333     if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2334     {
2335         if(s->picture_structure==PICT_FRAME){
2336         s->dest[0] += s->mb_y *   linesize << mb_size;
2337         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2338         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2339         }else{
2340             s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
2341             s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2342             s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2343             assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2344         }
2345     }
2346 }
2347
2348 void ff_mpeg_flush(AVCodecContext *avctx){
2349     int i;
2350     MpegEncContext *s = avctx->priv_data;
2351
2352     if(s==NULL || s->picture==NULL)
2353         return;
2354
2355     for(i=0; i<s->picture_count; i++){
2356        if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2357                                     || s->picture[i].type == FF_BUFFER_TYPE_USER))
2358         free_frame_buffer(s, &s->picture[i]);
2359     }
2360     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2361
2362     s->mb_x= s->mb_y= 0;
2363     s->closed_gop= 0;
2364
2365     s->parse_context.state= -1;
2366     s->parse_context.frame_start_found= 0;
2367     s->parse_context.overread= 0;
2368     s->parse_context.overread_index= 0;
2369     s->parse_context.index= 0;
2370     s->parse_context.last_index= 0;
2371     s->bitstream_buffer_size=0;
2372     s->pp_time=0;
2373 }
2374
2375 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2376                                    DCTELEM *block, int n, int qscale)
2377 {
2378     int i, level, nCoeffs;
2379     const uint16_t *quant_matrix;
2380
2381     nCoeffs= s->block_last_index[n];
2382
2383     if (n < 4)
2384         block[0] = block[0] * s->y_dc_scale;
2385     else
2386         block[0] = block[0] * s->c_dc_scale;
2387     /* XXX: only mpeg1 */
2388     quant_matrix = s->intra_matrix;
2389     for(i=1;i<=nCoeffs;i++) {
2390         int j= s->intra_scantable.permutated[i];
2391         level = block[j];
2392         if (level) {
2393             if (level < 0) {
2394                 level = -level;
2395                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2396                 level = (level - 1) | 1;
2397                 level = -level;
2398             } else {
2399                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2400                 level = (level - 1) | 1;
2401             }
2402             block[j] = level;
2403         }
2404     }
2405 }
2406
2407 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2408                                    DCTELEM *block, int n, int qscale)
2409 {
2410     int i, level, nCoeffs;
2411     const uint16_t *quant_matrix;
2412
2413     nCoeffs= s->block_last_index[n];
2414
2415     quant_matrix = s->inter_matrix;
2416     for(i=0; i<=nCoeffs; i++) {
2417         int j= s->intra_scantable.permutated[i];
2418         level = block[j];
2419         if (level) {
2420             if (level < 0) {
2421                 level = -level;
2422                 level = (((level << 1) + 1) * qscale *
2423                          ((int) (quant_matrix[j]))) >> 4;
2424                 level = (level - 1) | 1;
2425                 level = -level;
2426             } else {
2427                 level = (((level << 1) + 1) * qscale *
2428                          ((int) (quant_matrix[j]))) >> 4;
2429                 level = (level - 1) | 1;
2430             }
2431             block[j] = level;
2432         }
2433     }
2434 }
2435
2436 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2437                                    DCTELEM *block, int n, int qscale)
2438 {
2439     int i, level, nCoeffs;
2440     const uint16_t *quant_matrix;
2441
2442     if(s->alternate_scan) nCoeffs= 63;
2443     else nCoeffs= s->block_last_index[n];
2444
2445     if (n < 4)
2446         block[0] = block[0] * s->y_dc_scale;
2447     else
2448         block[0] = block[0] * s->c_dc_scale;
2449     quant_matrix = s->intra_matrix;
2450     for(i=1;i<=nCoeffs;i++) {
2451         int j= s->intra_scantable.permutated[i];
2452         level = block[j];
2453         if (level) {
2454             if (level < 0) {
2455                 level = -level;
2456                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2457                 level = -level;
2458             } else {
2459                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2460             }
2461             block[j] = level;
2462         }
2463     }
2464 }
2465
2466 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2467                                    DCTELEM *block, int n, int qscale)
2468 {
2469     int i, level, nCoeffs;
2470     const uint16_t *quant_matrix;
2471     int sum=-1;
2472
2473     if(s->alternate_scan) nCoeffs= 63;
2474     else nCoeffs= s->block_last_index[n];
2475
2476     if (n < 4)
2477         block[0] = block[0] * s->y_dc_scale;
2478     else
2479         block[0] = block[0] * s->c_dc_scale;
2480     quant_matrix = s->intra_matrix;
2481     for(i=1;i<=nCoeffs;i++) {
2482         int j= s->intra_scantable.permutated[i];
2483         level = block[j];
2484         if (level) {
2485             if (level < 0) {
2486                 level = -level;
2487                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2488                 level = -level;
2489             } else {
2490                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2491             }
2492             block[j] = level;
2493             sum+=level;
2494         }
2495     }
2496     block[63]^=sum&1;
2497 }
2498
2499 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2500                                    DCTELEM *block, int n, int qscale)
2501 {
2502     int i, level, nCoeffs;
2503     const uint16_t *quant_matrix;
2504     int sum=-1;
2505
2506     if(s->alternate_scan) nCoeffs= 63;
2507     else nCoeffs= s->block_last_index[n];
2508
2509     quant_matrix = s->inter_matrix;
2510     for(i=0; i<=nCoeffs; i++) {
2511         int j= s->intra_scantable.permutated[i];
2512         level = block[j];
2513         if (level) {
2514             if (level < 0) {
2515                 level = -level;
2516                 level = (((level << 1) + 1) * qscale *
2517                          ((int) (quant_matrix[j]))) >> 4;
2518                 level = -level;
2519             } else {
2520                 level = (((level << 1) + 1) * qscale *
2521                          ((int) (quant_matrix[j]))) >> 4;
2522             }
2523             block[j] = level;
2524             sum+=level;
2525         }
2526     }
2527     block[63]^=sum&1;
2528 }
2529
2530 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2531                                   DCTELEM *block, int n, int qscale)
2532 {
2533     int i, level, qmul, qadd;
2534     int nCoeffs;
2535
2536     assert(s->block_last_index[n]>=0);
2537
2538     qmul = qscale << 1;
2539
2540     if (!s->h263_aic) {
2541         if (n < 4)
2542             block[0] = block[0] * s->y_dc_scale;
2543         else
2544             block[0] = block[0] * s->c_dc_scale;
2545         qadd = (qscale - 1) | 1;
2546     }else{
2547         qadd = 0;
2548     }
2549     if(s->ac_pred)
2550         nCoeffs=63;
2551     else
2552         nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2553
2554     for(i=1; i<=nCoeffs; i++) {
2555         level = block[i];
2556         if (level) {
2557             if (level < 0) {
2558                 level = level * qmul - qadd;
2559             } else {
2560                 level = level * qmul + qadd;
2561             }
2562             block[i] = level;
2563         }
2564     }
2565 }
2566
2567 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2568                                   DCTELEM *block, int n, int qscale)
2569 {
2570     int i, level, qmul, qadd;
2571     int nCoeffs;
2572
2573     assert(s->block_last_index[n]>=0);
2574
2575     qadd = (qscale - 1) | 1;
2576     qmul = qscale << 1;
2577
2578     nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2579
2580     for(i=0; i<=nCoeffs; i++) {
2581         level = block[i];
2582         if (level) {
2583             if (level < 0) {
2584                 level = level * qmul - qadd;
2585             } else {
2586                 level = level * qmul + qadd;
2587             }
2588             block[i] = level;
2589         }
2590     }
2591 }
2592
2593 /**
2594  * set qscale and update qscale dependent variables.
2595  */
2596 void ff_set_qscale(MpegEncContext * s, int qscale)
2597 {
2598     if (qscale < 1)
2599         qscale = 1;
2600     else if (qscale > 31)
2601         qscale = 31;
2602
2603     s->qscale = qscale;
2604     s->chroma_qscale= s->chroma_qscale_table[qscale];
2605
2606     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2607     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2608 }
2609
2610 void MPV_report_decode_progress(MpegEncContext *s)
2611 {
2612     if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame)
2613         ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_y, 0);
2614 }