libavcodec/mpegvideo.c

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