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