libavcodec/mpegvideo.c

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