git.sesse.net Git - ffmpeg/blob - libavcodec/mpegvideo.c

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