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(CONFIG_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 already 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
1739 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
1740                             int lowres_flag, int is_mpeg12)
1741 {
1742     int mb_x, mb_y;
1743     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1744 #ifdef HAVE_XVMC
1745     if(s->avctx->xvmc_acceleration){
1746         XVMC_decode_mb(s);//xvmc uses pblocks
1747         return;
1748     }
1749 #endif
1750
1751     mb_x = s->mb_x;
1752     mb_y = s->mb_y;
1753
1754     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1755        /* save DCT coefficients */
1756        int i,j;
1757        DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
1758        for(i=0; i<6; i++)
1759            for(j=0; j<64; j++)
1760                *dct++ = block[i][s->dsp.idct_permutation[j]];
1761     }
1762
1763     s->current_picture.qscale_table[mb_xy]= s->qscale;
1764
1765     /* update DC predictors for P macroblocks */
1766     if (!s->mb_intra) {
1767         if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
1768             if(s->mbintra_table[mb_xy])
1769                 ff_clean_intra_table_entries(s);
1770         } else {
1771             s->last_dc[0] =
1772             s->last_dc[1] =
1773             s->last_dc[2] = 128 << s->intra_dc_precision;
1774         }
1775     }
1776     else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
1777         s->mbintra_table[mb_xy]=1;
1778
1779     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
1780         uint8_t *dest_y, *dest_cb, *dest_cr;
1781         int dct_linesize, dct_offset;
1782         op_pixels_func (*op_pix)[4];
1783         qpel_mc_func (*op_qpix)[16];
1784         const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
1785         const int uvlinesize= s->current_picture.linesize[1];
1786         const int readable= s->pict_type != FF_B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1787         const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1788
1789         /* avoid copy if macroblock skipped in last frame too */
1790         /* skip only during decoding as we might trash the buffers during encoding a bit */
1791         if(!s->encoding){
1792             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1793             const int age= s->current_picture.age;
1794
1795             assert(age);
1796
1797             if (s->mb_skipped) {
1798                 s->mb_skipped= 0;
1799                 assert(s->pict_type!=FF_I_TYPE);
1800
1801                 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
1802                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1803
1804                 /* if previous was skipped too, then nothing to do !  */
1805                 if (*mbskip_ptr >= age && s->current_picture.reference){
1806                     return;
1807                 }
1808             } else if(!s->current_picture.reference){
1809                 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
1810                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1811             } else{
1812                 *mbskip_ptr = 0; /* not skipped */
1813             }
1814         }
1815
1816         dct_linesize = linesize << s->interlaced_dct;
1817         dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1818
1819         if(readable){
1820             dest_y=  s->dest[0];
1821             dest_cb= s->dest[1];
1822             dest_cr= s->dest[2];
1823         }else{
1824             dest_y = s->b_scratchpad;
1825             dest_cb= s->b_scratchpad+16*linesize;
1826             dest_cr= s->b_scratchpad+32*linesize;
1827         }
1828
1829         if (!s->mb_intra) {
1830             /* motion handling */
1831             /* decoding or more than one mb_type (MC was already done otherwise) */
1832             if(!s->encoding){
1833                 if(lowres_flag){
1834                     h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
1835
1836                     if (s->mv_dir & MV_DIR_FORWARD) {
1837                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
1838                         op_pix = s->dsp.avg_h264_chroma_pixels_tab;
1839                     }
1840                     if (s->mv_dir & MV_DIR_BACKWARD) {
1841                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
1842                     }
1843                 }else{
1844                     op_qpix= s->me.qpel_put;
1845                     if ((!s->no_rounding) || s->pict_type==FF_B_TYPE){
1846                         op_pix = s->dsp.put_pixels_tab;
1847                     }else{
1848                         op_pix = s->dsp.put_no_rnd_pixels_tab;
1849                     }
1850                     if (s->mv_dir & MV_DIR_FORWARD) {
1851                         MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
1852                         op_pix = s->dsp.avg_pixels_tab;
1853                         op_qpix= s->me.qpel_avg;
1854                     }
1855                     if (s->mv_dir & MV_DIR_BACKWARD) {
1856                         MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
1857                     }
1858                 }
1859             }
1860
1861             /* skip dequant / idct if we are really late ;) */
1862             if(s->hurry_up>1) goto skip_idct;
1863             if(s->avctx->skip_idct){
1864                 if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
1865                    ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
1866                    || s->avctx->skip_idct >= AVDISCARD_ALL)
1867                     goto skip_idct;
1868             }
1869
1870             /* add dct residue */
1871             if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
1872                                 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1873                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
1874                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
1875                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
1876                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1877
1878                 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1879                     if (s->chroma_y_shift){
1880                         add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1881                         add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1882                     }else{
1883                         dct_linesize >>= 1;
1884                         dct_offset >>=1;
1885                         add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
1886                         add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
1887                         add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1888                         add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1889                     }
1890                 }
1891             } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
1892                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
1893                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
1894                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
1895                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
1896
1897                 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1898                     if(s->chroma_y_shift){//Chroma420
1899                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
1900                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
1901                     }else{
1902                         //chroma422
1903                         dct_linesize = uvlinesize << s->interlaced_dct;
1904                         dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1905
1906                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
1907                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
1908                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
1909                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
1910                         if(!s->chroma_x_shift){//Chroma444
1911                             add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
1912                             add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
1913                             add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
1914                             add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
1915                         }
1916                     }
1917                 }//fi gray
1918             }
1919             else if (ENABLE_WMV2) {
1920                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
1921             }
1922         } else {
1923             /* dct only in intra block */
1924             if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
1925                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
1926                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
1927                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
1928                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1929
1930                 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1931                     if(s->chroma_y_shift){
1932                         put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1933                         put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1934                     }else{
1935                         dct_offset >>=1;
1936                         dct_linesize >>=1;
1937                         put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
1938                         put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
1939                         put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1940                         put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1941                     }
1942                 }
1943             }else{
1944                 s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
1945                 s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
1946                 s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
1947                 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
1948
1949                 if(!ENABLE_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1950                     if(s->chroma_y_shift){
1951                         s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
1952                         s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
1953                     }else{
1954
1955                         dct_linesize = uvlinesize << s->interlaced_dct;
1956                         dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1957
1958                         s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
1959                         s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
1960                         s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
1961                         s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
1962                         if(!s->chroma_x_shift){//Chroma444
1963                             s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
1964                             s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
1965                             s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
1966                             s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
1967                         }
1968                     }
1969                 }//gray
1970             }
1971         }
1972 skip_idct:
1973         if(!readable){
1974             s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
1975             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
1976             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
1977         }
1978     }
1979 }
1980
1981 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
1982 #ifndef CONFIG_SMALL
1983     if(s->out_format == FMT_MPEG1) {
1984         if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
1985         else                 MPV_decode_mb_internal(s, block, 0, 1);
1986     } else
1987 #endif
1988     if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
1989     else                  MPV_decode_mb_internal(s, block, 0, 0);
1990 }
1991
1992 /**
1993  *
1994  * @param h is the normal height, this will be reduced automatically if needed for the last row
1995  */
1996 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
1997     if (s->avctx->draw_horiz_band) {
1998         AVFrame *src;
1999         int offset[4];
2000
2001         if(s->picture_structure != PICT_FRAME){
2002             h <<= 1;
2003             y <<= 1;
2004             if(s->first_field  && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2005         }
2006
2007         h= FFMIN(h, s->avctx->height - y);
2008
2009         if(s->pict_type==FF_B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2010             src= (AVFrame*)s->current_picture_ptr;
2011         else if(s->last_picture_ptr)
2012             src= (AVFrame*)s->last_picture_ptr;
2013         else
2014             return;
2015
2016         if(s->pict_type==FF_B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2017             offset[0]=
2018             offset[1]=
2019             offset[2]=
2020             offset[3]= 0;
2021         }else{
2022             offset[0]= y * s->linesize;
2023             offset[1]=
2024             offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2025             offset[3]= 0;
2026         }
2027
2028         emms_c();
2029
2030         s->avctx->draw_horiz_band(s->avctx, src, offset,
2031                                   y, s->picture_structure, h);
2032     }
2033 }
2034
2035 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2036     const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2037     const int uvlinesize= s->current_picture.linesize[1];
2038     const int mb_size= 4 - s->avctx->lowres;
2039
2040     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2041     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2042     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2043     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2044     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2045     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;
2046     //block_index is not used by mpeg2, so it is not affected by chroma_format
2047
2048     s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2049     s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2050     s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2051
2052     if(!(s->pict_type==FF_B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2053     {
2054         s->dest[0] += s->mb_y *   linesize << mb_size;
2055         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2056         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2057     }
2058 }
2059
2060 void ff_mpeg_flush(AVCodecContext *avctx){
2061     int i;
2062     MpegEncContext *s = avctx->priv_data;
2063
2064     if(s==NULL || s->picture==NULL)
2065         return;
2066
2067     for(i=0; i<MAX_PICTURE_COUNT; i++){
2068        if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2069                                     || s->picture[i].type == FF_BUFFER_TYPE_USER))
2070         avctx->release_buffer(avctx, (AVFrame*)&s->picture[i]);
2071     }
2072     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2073
2074     s->mb_x= s->mb_y= 0;
2075
2076     s->parse_context.state= -1;
2077     s->parse_context.frame_start_found= 0;
2078     s->parse_context.overread= 0;
2079     s->parse_context.overread_index= 0;
2080     s->parse_context.index= 0;
2081     s->parse_context.last_index= 0;
2082     s->bitstream_buffer_size=0;
2083     s->pp_time=0;
2084 }
2085
2086 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2087                                    DCTELEM *block, int n, int qscale)
2088 {
2089     int i, level, nCoeffs;
2090     const uint16_t *quant_matrix;
2091
2092     nCoeffs= s->block_last_index[n];
2093
2094     if (n < 4)
2095         block[0] = block[0] * s->y_dc_scale;
2096     else
2097         block[0] = block[0] * s->c_dc_scale;
2098     /* XXX: only mpeg1 */
2099     quant_matrix = s->intra_matrix;
2100     for(i=1;i<=nCoeffs;i++) {
2101         int j= s->intra_scantable.permutated[i];
2102         level = block[j];
2103         if (level) {
2104             if (level < 0) {
2105                 level = -level;
2106                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2107                 level = (level - 1) | 1;
2108                 level = -level;
2109             } else {
2110                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2111                 level = (level - 1) | 1;
2112             }
2113             block[j] = level;
2114         }
2115     }
2116 }
2117
2118 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2119                                    DCTELEM *block, int n, int qscale)
2120 {
2121     int i, level, nCoeffs;
2122     const uint16_t *quant_matrix;
2123
2124     nCoeffs= s->block_last_index[n];
2125
2126     quant_matrix = s->inter_matrix;
2127     for(i=0; i<=nCoeffs; i++) {
2128         int j= s->intra_scantable.permutated[i];
2129         level = block[j];
2130         if (level) {
2131             if (level < 0) {
2132                 level = -level;
2133                 level = (((level << 1) + 1) * qscale *
2134                          ((int) (quant_matrix[j]))) >> 4;
2135                 level = (level - 1) | 1;
2136                 level = -level;
2137             } else {
2138                 level = (((level << 1) + 1) * qscale *
2139                          ((int) (quant_matrix[j]))) >> 4;
2140                 level = (level - 1) | 1;
2141             }
2142             block[j] = level;
2143         }
2144     }
2145 }
2146
2147 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2148                                    DCTELEM *block, int n, int qscale)
2149 {
2150     int i, level, nCoeffs;
2151     const uint16_t *quant_matrix;
2152
2153     if(s->alternate_scan) nCoeffs= 63;
2154     else nCoeffs= s->block_last_index[n];
2155
2156     if (n < 4)
2157         block[0] = block[0] * s->y_dc_scale;
2158     else
2159         block[0] = block[0] * s->c_dc_scale;
2160     quant_matrix = s->intra_matrix;
2161     for(i=1;i<=nCoeffs;i++) {
2162         int j= s->intra_scantable.permutated[i];
2163         level = block[j];
2164         if (level) {
2165             if (level < 0) {
2166                 level = -level;
2167                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2168                 level = -level;
2169             } else {
2170                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2171             }
2172             block[j] = level;
2173         }
2174     }
2175 }
2176
2177 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2178                                    DCTELEM *block, int n, int qscale)
2179 {
2180     int i, level, nCoeffs;
2181     const uint16_t *quant_matrix;
2182     int sum=-1;
2183
2184     if(s->alternate_scan) nCoeffs= 63;
2185     else nCoeffs= s->block_last_index[n];
2186
2187     if (n < 4)
2188         block[0] = block[0] * s->y_dc_scale;
2189     else
2190         block[0] = block[0] * s->c_dc_scale;
2191     quant_matrix = s->intra_matrix;
2192     for(i=1;i<=nCoeffs;i++) {
2193         int j= s->intra_scantable.permutated[i];
2194         level = block[j];
2195         if (level) {
2196             if (level < 0) {
2197                 level = -level;
2198                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2199                 level = -level;
2200             } else {
2201                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2202             }
2203             block[j] = level;
2204             sum+=level;
2205         }
2206     }
2207     block[63]^=sum&1;
2208 }
2209
2210 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2211                                    DCTELEM *block, int n, int qscale)
2212 {
2213     int i, level, nCoeffs;
2214     const uint16_t *quant_matrix;
2215     int sum=-1;
2216
2217     if(s->alternate_scan) nCoeffs= 63;
2218     else nCoeffs= s->block_last_index[n];
2219
2220     quant_matrix = s->inter_matrix;
2221     for(i=0; i<=nCoeffs; i++) {
2222         int j= s->intra_scantable.permutated[i];
2223         level = block[j];
2224         if (level) {
2225             if (level < 0) {
2226                 level = -level;
2227                 level = (((level << 1) + 1) * qscale *
2228                          ((int) (quant_matrix[j]))) >> 4;
2229                 level = -level;
2230             } else {
2231                 level = (((level << 1) + 1) * qscale *
2232                          ((int) (quant_matrix[j]))) >> 4;
2233             }
2234             block[j] = level;
2235             sum+=level;
2236         }
2237     }
2238     block[63]^=sum&1;
2239 }
2240
2241 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2242                                   DCTELEM *block, int n, int qscale)
2243 {
2244     int i, level, qmul, qadd;
2245     int nCoeffs;
2246
2247     assert(s->block_last_index[n]>=0);
2248
2249     qmul = qscale << 1;
2250
2251     if (!s->h263_aic) {
2252         if (n < 4)
2253             block[0] = block[0] * s->y_dc_scale;
2254         else
2255             block[0] = block[0] * s->c_dc_scale;
2256         qadd = (qscale - 1) | 1;
2257     }else{
2258         qadd = 0;
2259     }
2260     if(s->ac_pred)
2261         nCoeffs=63;
2262     else
2263         nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2264
2265     for(i=1; i<=nCoeffs; i++) {
2266         level = block[i];
2267         if (level) {
2268             if (level < 0) {
2269                 level = level * qmul - qadd;
2270             } else {
2271                 level = level * qmul + qadd;
2272             }
2273             block[i] = level;
2274         }
2275     }
2276 }
2277
2278 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2279                                   DCTELEM *block, int n, int qscale)
2280 {
2281     int i, level, qmul, qadd;
2282     int nCoeffs;
2283
2284     assert(s->block_last_index[n]>=0);
2285
2286     qadd = (qscale - 1) | 1;
2287     qmul = qscale << 1;
2288
2289     nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2290
2291     for(i=0; i<=nCoeffs; i++) {
2292         level = block[i];
2293         if (level) {
2294             if (level < 0) {
2295                 level = level * qmul - qadd;
2296             } else {
2297                 level = level * qmul + qadd;
2298             }
2299             block[i] = level;
2300         }
2301     }
2302 }
2303
2304 /**
2305  * set qscale and update qscale dependent variables.
2306  */
2307 void ff_set_qscale(MpegEncContext * s, int qscale)
2308 {
2309     if (qscale < 1)
2310         qscale = 1;
2311     else if (qscale > 31)
2312         qscale = 31;
2313
2314     s->qscale = qscale;
2315     s->chroma_qscale= s->chroma_qscale_table[qscale];
2316
2317     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2318     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2319 }