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