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