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

   1 /*
   2  * The simplest mpeg encoder (well, it was the simplest!)
   3  * Copyright (c) 2000,2001 Fabrice Bellard
   4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   5  *
   6  * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
   7  *
   8  * This file is part of FFmpeg.
   9  *
  10  * FFmpeg is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * FFmpeg is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with FFmpeg; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  23  */
  24
  25 /**
  26  * @file libavcodec/mpegvideo.c
  27  * The simplest mpeg encoder (well, it was the simplest!).
  28  */
  29
  30 #include "avcodec.h"
  31 #include "dsputil.h"
  32 #include "mpegvideo.h"
  33 #include "mpegvideo_common.h"
  34 #include "mjpegenc.h"
  35 #include "msmpeg4.h"
  36 #include "faandct.h"
  37 #include "xvmc_internal.h"
  38 #include <limits.h>
  39
  40 //#undef NDEBUG
  41 //#include <assert.h>
  42
  43 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
  44                                    DCTELEM *block, int n, int qscale);
  45 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
  46                                    DCTELEM *block, int n, int qscale);
  47 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
  48                                    DCTELEM *block, int n, int qscale);
  49 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
  50                                    DCTELEM *block, int n, int qscale);
  51 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
  52                                    DCTELEM *block, int n, int qscale);
  53 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
  54                                   DCTELEM *block, int n, int qscale);
  55 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
  56                                   DCTELEM *block, int n, int qscale);
  57
  58
  59 /* enable all paranoid tests for rounding, overflows, etc... */
  60 //#define PARANOID
  61
  62 //#define DEBUG
  63
  64
  65 static const uint8_t ff_default_chroma_qscale_table[32]={
  66 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
  67     0, 1, 2, 3, 4, 5, 6, 7, 8, 9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31
  68 };
  69
  70 const uint8_t ff_mpeg1_dc_scale_table[128]={
  71 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
  72     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  73     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  74     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  75     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  76 };
  77
  78 const enum PixelFormat ff_pixfmt_list_420[] = {
  79     PIX_FMT_YUV420P,
  80     PIX_FMT_NONE
  81 };
  82
  83 const enum PixelFormat ff_hwaccel_pixfmt_list_420[] = {
  84     PIX_FMT_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
 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->codec_id != CODEC_ID_H264){
 950         if((s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) && s->pict_type!=FF_I_TYPE){
 951             av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
 952             /* Allocate a dummy frame */
 953             i= ff_find_unused_picture(s, 0);
 954             s->last_picture_ptr= &s->picture[i];
 955             if(ff_alloc_picture(s, s->last_picture_ptr, 0) < 0)
 956                 return -1;
 957         }
 958         if((s->next_picture_ptr==NULL || s->next_picture_ptr->data[0]==NULL) && s->pict_type==FF_B_TYPE){
 959             /* Allocate a dummy frame */
 960             i= ff_find_unused_picture(s, 0);
 961             s->next_picture_ptr= &s->picture[i];
 962             if(ff_alloc_picture(s, s->next_picture_ptr, 0) < 0)
 963                 return -1;
 964         }
 965     }
 966
 967     if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
 968     if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
 969
 970     assert(s->pict_type == FF_I_TYPE || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
 971
 972     if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
 973         int i;
 974         for(i=0; i<4; i++){
 975             if(s->picture_structure == PICT_BOTTOM_FIELD){
 976                  s->current_picture.data[i] += s->current_picture.linesize[i];
 977             }
 978             s->current_picture.linesize[i] *= 2;
 979             s->last_picture.linesize[i] *=2;
 980             s->next_picture.linesize[i] *=2;
 981         }
 982     }
 983
 984     s->hurry_up= s->avctx->hurry_up;
 985     s->error_recognition= avctx->error_recognition;
 986
 987     /* set dequantizer, we can't do it during init as it might change for mpeg4
 988        and we can't do it in the header decode as init is not called for mpeg4 there yet */
 989     if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
 990         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
 991         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
 992     }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
 993         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
 994         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
 995     }else{
 996         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
 997         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
 998     }
 999
1000     if(s->dct_error_sum){
1001         assert(s->avctx->noise_reduction && s->encoding);
1002
1003         update_noise_reduction(s);
1004     }
1005
1006     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1007         return ff_xvmc_field_start(s, avctx);
1008
1009     return 0;
1010 }
1011
1012 /* generic function for encode/decode called after a frame has been coded/decoded */
1013 void MPV_frame_end(MpegEncContext *s)
1014 {
1015     int i;
1016     /* draw edge for correct motion prediction if outside */
1017     //just to make sure that all data is rendered.
1018     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1019         ff_xvmc_field_end(s);
1020     }else if(!s->avctx->hwaccel
1021        && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
1022        && s->unrestricted_mv
1023        && s->current_picture.reference
1024        && !s->intra_only
1025        && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1026             s->dsp.draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , s->v_edge_pos   , EDGE_WIDTH  );
1027             s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1028             s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, s->v_edge_pos>>1, EDGE_WIDTH/2);
1029     }
1030     emms_c();
1031
1032     s->last_pict_type    = s->pict_type;
1033     s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1034     if(s->pict_type!=FF_B_TYPE){
1035         s->last_non_b_pict_type= s->pict_type;
1036     }
1037 #if 0
1038         /* copy back current_picture variables */
1039     for(i=0; i<MAX_PICTURE_COUNT; i++){
1040         if(s->picture[i].data[0] == s->current_picture.data[0]){
1041             s->picture[i]= s->current_picture;
1042             break;
1043         }
1044     }
1045     assert(i<MAX_PICTURE_COUNT);
1046 #endif
1047
1048     if(s->encoding){
1049         /* release non-reference frames */
1050         for(i=0; i<MAX_PICTURE_COUNT; i++){
1051             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1052                 free_frame_buffer(s, &s->picture[i]);
1053             }
1054         }
1055     }
1056     // clear copies, to avoid confusion
1057 #if 0
1058     memset(&s->last_picture, 0, sizeof(Picture));
1059     memset(&s->next_picture, 0, sizeof(Picture));
1060     memset(&s->current_picture, 0, sizeof(Picture));
1061 #endif
1062     s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1063 }
1064
1065 /**
1066  * draws an line from (ex, ey) -> (sx, sy).
1067  * @param w width of the image
1068  * @param h height of the image
1069  * @param stride stride/linesize of the image
1070  * @param color color of the arrow
1071  */
1072 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1073     int x, y, fr, f;
1074
1075     sx= av_clip(sx, 0, w-1);
1076     sy= av_clip(sy, 0, h-1);
1077     ex= av_clip(ex, 0, w-1);
1078     ey= av_clip(ey, 0, h-1);
1079
1080     buf[sy*stride + sx]+= color;
1081
1082     if(FFABS(ex - sx) > FFABS(ey - sy)){
1083         if(sx > ex){
1084             FFSWAP(int, sx, ex);
1085             FFSWAP(int, sy, ey);
1086         }
1087         buf+= sx + sy*stride;
1088         ex-= sx;
1089         f= ((ey-sy)<<16)/ex;
1090         for(x= 0; x <= ex; x++){
1091             y = (x*f)>>16;
1092             fr= (x*f)&0xFFFF;
1093             buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1094             buf[(y+1)*stride + x]+= (color*         fr )>>16;
1095         }
1096     }else{
1097         if(sy > ey){
1098             FFSWAP(int, sx, ex);
1099             FFSWAP(int, sy, ey);
1100         }
1101         buf+= sx + sy*stride;
1102         ey-= sy;
1103         if(ey) f= ((ex-sx)<<16)/ey;
1104         else   f= 0;
1105         for(y= 0; y <= ey; y++){
1106             x = (y*f)>>16;
1107             fr= (y*f)&0xFFFF;
1108             buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;
1109             buf[y*stride + x+1]+= (color*         fr )>>16;
1110         }
1111     }
1112 }
1113
1114 /**
1115  * draws an arrow from (ex, ey) -> (sx, sy).
1116  * @param w width of the image
1117  * @param h height of the image
1118  * @param stride stride/linesize of the image
1119  * @param color color of the arrow
1120  */
1121 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1122     int dx,dy;
1123
1124     sx= av_clip(sx, -100, w+100);
1125     sy= av_clip(sy, -100, h+100);
1126     ex= av_clip(ex, -100, w+100);
1127     ey= av_clip(ey, -100, h+100);
1128
1129     dx= ex - sx;
1130     dy= ey - sy;
1131
1132     if(dx*dx + dy*dy > 3*3){
1133         int rx=  dx + dy;
1134         int ry= -dx + dy;
1135         int length= ff_sqrt((rx*rx + ry*ry)<<8);
1136
1137         //FIXME subpixel accuracy
1138         rx= ROUNDED_DIV(rx*3<<4, length);
1139         ry= ROUNDED_DIV(ry*3<<4, length);
1140
1141         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1142         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1143     }
1144     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1145 }
1146
1147 /**
1148  * prints debuging info for the given picture.
1149  */
1150 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1151
1152     if(s->avctx->hwaccel || !pict || !pict->mb_type) return;
1153
1154     if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1155         int x,y;
1156
1157         av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1158         switch (pict->pict_type) {
1159             case FF_I_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1160             case FF_P_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1161             case FF_B_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1162             case FF_S_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1163             case FF_SI_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1164             case FF_SP_TYPE: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1165         }
1166         for(y=0; y<s->mb_height; y++){
1167             for(x=0; x<s->mb_width; x++){
1168                 if(s->avctx->debug&FF_DEBUG_SKIP){
1169                     int count= s->mbskip_table[x + y*s->mb_stride];
1170                     if(count>9) count=9;
1171                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1172                 }
1173                 if(s->avctx->debug&FF_DEBUG_QP){
1174                     av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1175                 }
1176                 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1177                     int mb_type= pict->mb_type[x + y*s->mb_stride];
1178                     //Type & MV direction
1179                     if(IS_PCM(mb_type))
1180                         av_log(s->avctx, AV_LOG_DEBUG, "P");
1181                     else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1182                         av_log(s->avctx, AV_LOG_DEBUG, "A");
1183                     else if(IS_INTRA4x4(mb_type))
1184                         av_log(s->avctx, AV_LOG_DEBUG, "i");
1185                     else if(IS_INTRA16x16(mb_type))
1186                         av_log(s->avctx, AV_LOG_DEBUG, "I");
1187                     else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1188                         av_log(s->avctx, AV_LOG_DEBUG, "d");
1189                     else if(IS_DIRECT(mb_type))
1190                         av_log(s->avctx, AV_LOG_DEBUG, "D");
1191                     else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1192                         av_log(s->avctx, AV_LOG_DEBUG, "g");
1193                     else if(IS_GMC(mb_type))
1194                         av_log(s->avctx, AV_LOG_DEBUG, "G");
1195                     else if(IS_SKIP(mb_type))
1196                         av_log(s->avctx, AV_LOG_DEBUG, "S");
1197                     else if(!USES_LIST(mb_type, 1))
1198                         av_log(s->avctx, AV_LOG_DEBUG, ">");
1199                     else if(!USES_LIST(mb_type, 0))
1200                         av_log(s->avctx, AV_LOG_DEBUG, "<");
1201                     else{
1202                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1203                         av_log(s->avctx, AV_LOG_DEBUG, "X");
1204                     }
1205
1206                     //segmentation
1207                     if(IS_8X8(mb_type))
1208                         av_log(s->avctx, AV_LOG_DEBUG, "+");
1209                     else if(IS_16X8(mb_type))
1210                         av_log(s->avctx, AV_LOG_DEBUG, "-");
1211                     else if(IS_8X16(mb_type))
1212                         av_log(s->avctx, AV_LOG_DEBUG, "|");
1213                     else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1214                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1215                     else
1216                         av_log(s->avctx, AV_LOG_DEBUG, "?");
1217
1218
1219                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264)
1220                         av_log(s->avctx, AV_LOG_DEBUG, "=");
1221                     else
1222                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1223                 }
1224 //                av_log(s->avctx, AV_LOG_DEBUG, " ");
1225             }
1226             av_log(s->avctx, AV_LOG_DEBUG, "\n");
1227         }
1228     }
1229
1230     if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1231         const int shift= 1 + s->quarter_sample;
1232         int mb_y;
1233         uint8_t *ptr;
1234         int i;
1235         int h_chroma_shift, v_chroma_shift, block_height;
1236         const int width = s->avctx->width;
1237         const int height= s->avctx->height;
1238         const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1239         const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1240         s->low_delay=0; //needed to see the vectors without trashing the buffers
1241
1242         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1243         for(i=0; i<3; i++){
1244             memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1245             pict->data[i]= s->visualization_buffer[i];
1246         }
1247         pict->type= FF_BUFFER_TYPE_COPY;
1248         ptr= pict->data[0];
1249         block_height = 16>>v_chroma_shift;
1250
1251         for(mb_y=0; mb_y<s->mb_height; mb_y++){
1252             int mb_x;
1253             for(mb_x=0; mb_x<s->mb_width; mb_x++){
1254                 const int mb_index= mb_x + mb_y*s->mb_stride;
1255                 if((s->avctx->debug_mv) && pict->motion_val){
1256                   int type;
1257                   for(type=0; type<3; type++){
1258                     int direction = 0;
1259                     switch (type) {
1260                       case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=FF_P_TYPE))
1261                                 continue;
1262                               direction = 0;
1263                               break;
1264                       case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=FF_B_TYPE))
1265                                 continue;
1266                               direction = 0;
1267                               break;
1268                       case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=FF_B_TYPE))
1269                                 continue;
1270                               direction = 1;
1271                               break;
1272                     }
1273                     if(!USES_LIST(pict->mb_type[mb_index], direction))
1274                         continue;
1275
1276                     if(IS_8X8(pict->mb_type[mb_index])){
1277                       int i;
1278                       for(i=0; i<4; i++){
1279                         int sx= mb_x*16 + 4 + 8*(i&1);
1280                         int sy= mb_y*16 + 4 + 8*(i>>1);
1281                         int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1282                         int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1283                         int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1284                         draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1285                       }
1286                     }else if(IS_16X8(pict->mb_type[mb_index])){
1287                       int i;
1288                       for(i=0; i<2; i++){
1289                         int sx=mb_x*16 + 8;
1290                         int sy=mb_y*16 + 4 + 8*i;
1291                         int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1292                         int mx=(pict->motion_val[direction][xy][0]>>shift);
1293                         int my=(pict->motion_val[direction][xy][1]>>shift);
1294
1295                         if(IS_INTERLACED(pict->mb_type[mb_index]))
1296                             my*=2;
1297
1298                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1299                       }
1300                     }else if(IS_8X16(pict->mb_type[mb_index])){
1301                       int i;
1302                       for(i=0; i<2; i++){
1303                         int sx=mb_x*16 + 4 + 8*i;
1304                         int sy=mb_y*16 + 8;
1305                         int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1306                         int mx=(pict->motion_val[direction][xy][0]>>shift);
1307                         int my=(pict->motion_val[direction][xy][1]>>shift);
1308
1309                         if(IS_INTERLACED(pict->mb_type[mb_index]))
1310                             my*=2;
1311
1312                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1313                       }
1314                     }else{
1315                       int sx= mb_x*16 + 8;
1316                       int sy= mb_y*16 + 8;
1317                       int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1318                       int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1319                       int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1320                       draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1321                     }
1322                   }
1323                 }
1324                 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1325                     uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1326                     int y;
1327                     for(y=0; y<block_height; y++){
1328                         *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1329                         *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1330                     }
1331                 }
1332                 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1333                     int mb_type= pict->mb_type[mb_index];
1334                     uint64_t u,v;
1335                     int y;
1336 #define COLOR(theta, r)\
1337 u= (int)(128 + r*cos(theta*3.141592/180));\
1338 v= (int)(128 + r*sin(theta*3.141592/180));
1339
1340
1341                     u=v=128;
1342                     if(IS_PCM(mb_type)){
1343                         COLOR(120,48)
1344                     }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1345                         COLOR(30,48)
1346                     }else if(IS_INTRA4x4(mb_type)){
1347                         COLOR(90,48)
1348                     }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1349 //                        COLOR(120,48)
1350                     }else if(IS_DIRECT(mb_type)){
1351                         COLOR(150,48)
1352                     }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1353                         COLOR(170,48)
1354                     }else if(IS_GMC(mb_type)){
1355                         COLOR(190,48)
1356                     }else if(IS_SKIP(mb_type)){
1357 //                        COLOR(180,48)
1358                     }else if(!USES_LIST(mb_type, 1)){
1359                         COLOR(240,48)
1360                     }else if(!USES_LIST(mb_type, 0)){
1361                         COLOR(0,48)
1362                     }else{
1363                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1364                         COLOR(300,48)
1365                     }
1366
1367                     u*= 0x0101010101010101ULL;
1368                     v*= 0x0101010101010101ULL;
1369                     for(y=0; y<block_height; y++){
1370                         *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1371                         *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1372                     }
1373
1374                     //segmentation
1375                     if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1376                         *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1377                         *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1378                     }
1379                     if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1380                         for(y=0; y<16; y++)
1381                             pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1382                     }
1383                     if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1384                         int dm= 1 << (mv_sample_log2-2);
1385                         for(i=0; i<4; i++){
1386                             int sx= mb_x*16 + 8*(i&1);
1387                             int sy= mb_y*16 + 8*(i>>1);
1388                             int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1389                             //FIXME bidir
1390                             int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1391                             if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1392                                 for(y=0; y<8; y++)
1393                                     pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1394                             if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1395                                 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1396                         }
1397                     }
1398
1399                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1400                         // hmm
1401                     }
1402                 }
1403                 s->mbskip_table[mb_index]=0;
1404             }
1405         }
1406     }
1407 }
1408
1409 static inline int hpel_motion_lowres(MpegEncContext *s,
1410                                   uint8_t *dest, uint8_t *src,
1411                                   int field_based, int field_select,
1412                                   int src_x, int src_y,
1413                                   int width, int height, int stride,
1414                                   int h_edge_pos, int v_edge_pos,
1415                                   int w, int h, h264_chroma_mc_func *pix_op,
1416                                   int motion_x, int motion_y)
1417 {
1418     const int lowres= s->avctx->lowres;
1419     const int s_mask= (2<<lowres)-1;
1420     int emu=0;
1421     int sx, sy;
1422
1423     if(s->quarter_sample){
1424         motion_x/=2;
1425         motion_y/=2;
1426     }
1427
1428     sx= motion_x & s_mask;
1429     sy= motion_y & s_mask;
1430     src_x += motion_x >> (lowres+1);
1431     src_y += motion_y >> (lowres+1);
1432
1433     src += src_y * stride + src_x;
1434
1435     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
1436        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1437         ff_emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1438                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1439         src= s->edge_emu_buffer;
1440         emu=1;
1441     }
1442
1443     sx <<= 2 - lowres;
1444     sy <<= 2 - lowres;
1445     if(field_select)
1446         src += s->linesize;
1447     pix_op[lowres](dest, src, stride, h, sx, sy);
1448     return emu;
1449 }
1450
1451 /* apply one mpeg motion vector to the three components */
1452 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1453                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1454                                int field_based, int bottom_field, int field_select,
1455                                uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1456                                int motion_x, int motion_y, int h, int mb_y)
1457 {
1458     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1459     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1460     const int lowres= s->avctx->lowres;
1461     const int block_s= 8>>lowres;
1462     const int s_mask= (2<<lowres)-1;
1463     const int h_edge_pos = s->h_edge_pos >> lowres;
1464     const int v_edge_pos = s->v_edge_pos >> lowres;
1465     linesize   = s->current_picture.linesize[0] << field_based;
1466     uvlinesize = s->current_picture.linesize[1] << field_based;
1467
1468     if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1469         motion_x/=2;
1470         motion_y/=2;
1471     }
1472
1473     if(field_based){
1474         motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1475     }
1476
1477     sx= motion_x & s_mask;
1478     sy= motion_y & s_mask;
1479     src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
1480     src_y =(   mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1481
1482     if (s->out_format == FMT_H263) {
1483         uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1484         uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1485         uvsrc_x = src_x>>1;
1486         uvsrc_y = src_y>>1;
1487     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1488         mx = motion_x / 4;
1489         my = motion_y / 4;
1490         uvsx = (2*mx) & s_mask;
1491         uvsy = (2*my) & s_mask;
1492         uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
1493         uvsrc_y =    mb_y*block_s               + (my >> lowres);
1494     } else {
1495         mx = motion_x / 2;
1496         my = motion_y / 2;
1497         uvsx = mx & s_mask;
1498         uvsy = my & s_mask;
1499         uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
1500         uvsrc_y =(   mb_y*block_s>>field_based) + (my >> (lowres+1));
1501     }
1502
1503     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
1504     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1505     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1506
1507     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
1508        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1509             ff_emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1510                              src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1511             ptr_y = s->edge_emu_buffer;
1512             if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1513                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1514                 ff_emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
1515                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1516                 ff_emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1517                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1518                 ptr_cb= uvbuf;
1519                 ptr_cr= uvbuf+16;
1520             }
1521     }
1522
1523     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1524         dest_y += s->linesize;
1525         dest_cb+= s->uvlinesize;
1526         dest_cr+= s->uvlinesize;
1527     }
1528
1529     if(field_select){
1530         ptr_y += s->linesize;
1531         ptr_cb+= s->uvlinesize;
1532         ptr_cr+= s->uvlinesize;
1533     }
1534
1535     sx <<= 2 - lowres;
1536     sy <<= 2 - lowres;
1537     pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1538
1539     if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1540         uvsx <<= 2 - lowres;
1541         uvsy <<= 2 - lowres;
1542         pix_op[lowres](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1543         pix_op[lowres](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1544     }
1545     //FIXME h261 lowres loop filter
1546 }
1547
1548 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1549                                      uint8_t *dest_cb, uint8_t *dest_cr,
1550                                      uint8_t **ref_picture,
1551                                      h264_chroma_mc_func *pix_op,
1552                                      int mx, int my){
1553     const int lowres= s->avctx->lowres;
1554     const int block_s= 8>>lowres;
1555     const int s_mask= (2<<lowres)-1;
1556     const int h_edge_pos = s->h_edge_pos >> (lowres+1);
1557     const int v_edge_pos = s->v_edge_pos >> (lowres+1);
1558     int emu=0, src_x, src_y, offset, sx, sy;
1559     uint8_t *ptr;
1560
1561     if(s->quarter_sample){
1562         mx/=2;
1563         my/=2;
1564     }
1565
1566     /* In case of 8X8, we construct a single chroma motion vector
1567        with a special rounding */
1568     mx= ff_h263_round_chroma(mx);
1569     my= ff_h263_round_chroma(my);
1570
1571     sx= mx & s_mask;
1572     sy= my & s_mask;
1573     src_x = s->mb_x*block_s + (mx >> (lowres+1));
1574     src_y = s->mb_y*block_s + (my >> (lowres+1));
1575
1576     offset = src_y * s->uvlinesize + src_x;
1577     ptr = ref_picture[1] + offset;
1578     if(s->flags&CODEC_FLAG_EMU_EDGE){
1579         if(   (unsigned)src_x > h_edge_pos - (!!sx) - block_s
1580            || (unsigned)src_y > v_edge_pos - (!!sy) - block_s){
1581             ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1582             ptr= s->edge_emu_buffer;
1583             emu=1;
1584         }
1585     }
1586     sx <<= 2 - lowres;
1587     sy <<= 2 - lowres;
1588     pix_op[lowres](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
1589
1590     ptr = ref_picture[2] + offset;
1591     if(emu){
1592         ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
1593         ptr= s->edge_emu_buffer;
1594     }
1595     pix_op[lowres](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
1596 }
1597
1598 /**
1599  * motion compensation of a single macroblock
1600  * @param s context
1601  * @param dest_y luma destination pointer
1602  * @param dest_cb chroma cb/u destination pointer
1603  * @param dest_cr chroma cr/v destination pointer
1604  * @param dir direction (0->forward, 1->backward)
1605  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
1606  * @param pic_op halfpel motion compensation function (average or put normally)
1607  * the motion vectors are taken from s->mv and the MV type from s->mv_type
1608  */
1609 static inline void MPV_motion_lowres(MpegEncContext *s,
1610                               uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1611                               int dir, uint8_t **ref_picture,
1612                               h264_chroma_mc_func *pix_op)
1613 {
1614     int mx, my;
1615     int mb_x, mb_y, i;
1616     const int lowres= s->avctx->lowres;
1617     const int block_s= 8>>lowres;
1618
1619     mb_x = s->mb_x;
1620     mb_y = s->mb_y;
1621
1622     switch(s->mv_type) {
1623     case MV_TYPE_16X16:
1624         mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1625                     0, 0, 0,
1626                     ref_picture, pix_op,
1627                     s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y);
1628         break;
1629     case MV_TYPE_8X8:
1630         mx = 0;
1631         my = 0;
1632             for(i=0;i<4;i++) {
1633                 hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) * s->linesize)*block_s,
1634                             ref_picture[0], 0, 0,
1635                             (2*mb_x + (i & 1))*block_s, (2*mb_y + (i >>1))*block_s,
1636                             s->width, s->height, s->linesize,
1637                             s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
1638                             block_s, block_s, pix_op,
1639                             s->mv[dir][i][0], s->mv[dir][i][1]);
1640
1641                 mx += s->mv[dir][i][0];
1642                 my += s->mv[dir][i][1];
1643             }
1644
1645         if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY))
1646             chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture, pix_op, mx, my);
1647         break;
1648     case MV_TYPE_FIELD:
1649         if (s->picture_structure == PICT_FRAME) {
1650             /* top field */
1651             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1652                         1, 0, s->field_select[dir][0],
1653                         ref_picture, pix_op,
1654                         s->mv[dir][0][0], s->mv[dir][0][1], block_s, mb_y);
1655             /* bottom field */
1656             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1657                         1, 1, s->field_select[dir][1],
1658                         ref_picture, pix_op,
1659                         s->mv[dir][1][0], s->mv[dir][1][1], block_s, mb_y);
1660         } else {
1661             if(s->picture_structure != s->field_select[dir][0] + 1 && s->pict_type != FF_B_TYPE && !s->first_field){
1662                 ref_picture= s->current_picture_ptr->data;
1663             }
1664
1665             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1666                         0, 0, s->field_select[dir][0],
1667                         ref_picture, pix_op,
1668                         s->mv[dir][0][0], s->mv[dir][0][1], 2*block_s, mb_y>>1);
1669         }
1670         break;
1671     case MV_TYPE_16X8:
1672         for(i=0; i<2; i++){
1673             uint8_t ** ref2picture;
1674
1675             if(s->picture_structure == s->field_select[dir][i] + 1 || s->pict_type == FF_B_TYPE || s->first_field){
1676                 ref2picture= ref_picture;
1677             }else{
1678                 ref2picture= s->current_picture_ptr->data;
1679             }
1680
1681             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1682                         0, 0, s->field_select[dir][i],
1683                         ref2picture, pix_op,
1684                         s->mv[dir][i][0], s->mv[dir][i][1] + 2*block_s*i, block_s, mb_y>>1);
1685
1686             dest_y += 2*block_s*s->linesize;
1687             dest_cb+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1688             dest_cr+= (2*block_s>>s->chroma_y_shift)*s->uvlinesize;
1689         }
1690         break;
1691     case MV_TYPE_DMV:
1692         if(s->picture_structure == PICT_FRAME){
1693             for(i=0; i<2; i++){
1694                 int j;
1695                 for(j=0; j<2; j++){
1696                     mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1697                                 1, j, j^i,
1698                                 ref_picture, pix_op,
1699                                 s->mv[dir][2*i + j][0], s->mv[dir][2*i + j][1], block_s, mb_y);
1700                 }
1701                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1702             }
1703         }else{
1704             for(i=0; i<2; i++){
1705                 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
1706                             0, 0, s->picture_structure != i+1,
1707                             ref_picture, pix_op,
1708                             s->mv[dir][2*i][0],s->mv[dir][2*i][1],2*block_s, mb_y>>1);
1709
1710                 // after put we make avg of the same block
1711                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
1712
1713                 //opposite parity is always in the same frame if this is second field
1714                 if(!s->first_field){
1715                     ref_picture = s->current_picture_ptr->data;
1716                 }
1717             }
1718         }
1719     break;
1720     default: assert(0);
1721     }
1722 }
1723
1724 /* put block[] to dest[] */
1725 static inline void put_dct(MpegEncContext *s,
1726                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1727 {
1728     s->dct_unquantize_intra(s, block, i, qscale);
1729     s->dsp.idct_put (dest, line_size, block);
1730 }
1731
1732 /* add block[] to dest[] */
1733 static inline void add_dct(MpegEncContext *s,
1734                            DCTELEM *block, int i, uint8_t *dest, int line_size)
1735 {
1736     if (s->block_last_index[i] >= 0) {
1737         s->dsp.idct_add (dest, line_size, block);
1738     }
1739 }
1740
1741 static inline void add_dequant_dct(MpegEncContext *s,
1742                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
1743 {
1744     if (s->block_last_index[i] >= 0) {
1745         s->dct_unquantize_inter(s, block, i, qscale);
1746
1747         s->dsp.idct_add (dest, line_size, block);
1748     }
1749 }
1750
1751 /**
1752  * cleans dc, ac, coded_block for the current non intra MB
1753  */
1754 void ff_clean_intra_table_entries(MpegEncContext *s)
1755 {
1756     int wrap = s->b8_stride;
1757     int xy = s->block_index[0];
1758
1759     s->dc_val[0][xy           ] =
1760     s->dc_val[0][xy + 1       ] =
1761     s->dc_val[0][xy     + wrap] =
1762     s->dc_val[0][xy + 1 + wrap] = 1024;
1763     /* ac pred */
1764     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
1765     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
1766     if (s->msmpeg4_version>=3) {
1767         s->coded_block[xy           ] =
1768         s->coded_block[xy + 1       ] =
1769         s->coded_block[xy     + wrap] =
1770         s->coded_block[xy + 1 + wrap] = 0;
1771     }
1772     /* chroma */
1773     wrap = s->mb_stride;
1774     xy = s->mb_x + s->mb_y * wrap;
1775     s->dc_val[1][xy] =
1776     s->dc_val[2][xy] = 1024;
1777     /* ac pred */
1778     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
1779     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
1780
1781     s->mbintra_table[xy]= 0;
1782 }
1783
1784 /* generic function called after a macroblock has been parsed by the
1785    decoder or after it has been encoded by the encoder.
1786
1787    Important variables used:
1788    s->mb_intra : true if intra macroblock
1789    s->mv_dir   : motion vector direction
1790    s->mv_type  : motion vector type
1791    s->mv       : motion vector
1792    s->interlaced_dct : true if interlaced dct used (mpeg2)
1793  */
1794 static av_always_inline
1795 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
1796                             int lowres_flag, int is_mpeg12)
1797 {
1798     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
1799     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1800         ff_xvmc_decode_mb(s);//xvmc uses pblocks
1801         return;
1802     }
1803
1804     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
1805        /* save DCT coefficients */
1806        int i,j;
1807        DCTELEM *dct = &s->current_picture.dct_coeff[mb_xy*64*6];
1808        for(i=0; i<6; i++)
1809            for(j=0; j<64; j++)
1810                *dct++ = block[i][s->dsp.idct_permutation[j]];
1811     }
1812
1813     s->current_picture.qscale_table[mb_xy]= s->qscale;
1814
1815     /* update DC predictors for P macroblocks */
1816     if (!s->mb_intra) {
1817         if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
1818             if(s->mbintra_table[mb_xy])
1819                 ff_clean_intra_table_entries(s);
1820         } else {
1821             s->last_dc[0] =
1822             s->last_dc[1] =
1823             s->last_dc[2] = 128 << s->intra_dc_precision;
1824         }
1825     }
1826     else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
1827         s->mbintra_table[mb_xy]=1;
1828
1829     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
1830         uint8_t *dest_y, *dest_cb, *dest_cr;
1831         int dct_linesize, dct_offset;
1832         op_pixels_func (*op_pix)[4];
1833         qpel_mc_func (*op_qpix)[16];
1834         const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
1835         const int uvlinesize= s->current_picture.linesize[1];
1836         const int readable= s->pict_type != FF_B_TYPE || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
1837         const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
1838
1839         /* avoid copy if macroblock skipped in last frame too */
1840         /* skip only during decoding as we might trash the buffers during encoding a bit */
1841         if(!s->encoding){
1842             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
1843             const int age= s->current_picture.age;
1844
1845             assert(age);
1846
1847             if (s->mb_skipped) {
1848                 s->mb_skipped= 0;
1849                 assert(s->pict_type!=FF_I_TYPE);
1850
1851                 (*mbskip_ptr) ++; /* indicate that this time we skipped it */
1852                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1853
1854                 /* if previous was skipped too, then nothing to do !  */
1855                 if (*mbskip_ptr >= age && s->current_picture.reference){
1856                     return;
1857                 }
1858             } else if(!s->current_picture.reference){
1859                 (*mbskip_ptr) ++; /* increase counter so the age can be compared cleanly */
1860                 if(*mbskip_ptr >99) *mbskip_ptr= 99;
1861             } else{
1862                 *mbskip_ptr = 0; /* not skipped */
1863             }
1864         }
1865
1866         dct_linesize = linesize << s->interlaced_dct;
1867         dct_offset =(s->interlaced_dct)? linesize : linesize*block_size;
1868
1869         if(readable){
1870             dest_y=  s->dest[0];
1871             dest_cb= s->dest[1];
1872             dest_cr= s->dest[2];
1873         }else{
1874             dest_y = s->b_scratchpad;
1875             dest_cb= s->b_scratchpad+16*linesize;
1876             dest_cr= s->b_scratchpad+32*linesize;
1877         }
1878
1879         if (!s->mb_intra) {
1880             /* motion handling */
1881             /* decoding or more than one mb_type (MC was already done otherwise) */
1882             if(!s->encoding){
1883                 if(lowres_flag){
1884                     h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
1885
1886                     if (s->mv_dir & MV_DIR_FORWARD) {
1887                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix);
1888                         op_pix = s->dsp.avg_h264_chroma_pixels_tab;
1889                     }
1890                     if (s->mv_dir & MV_DIR_BACKWARD) {
1891                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix);
1892                     }
1893                 }else{
1894                     op_qpix= s->me.qpel_put;
1895                     if ((!s->no_rounding) || s->pict_type==FF_B_TYPE){
1896                         op_pix = s->dsp.put_pixels_tab;
1897                     }else{
1898                         op_pix = s->dsp.put_no_rnd_pixels_tab;
1899                     }
1900                     if (s->mv_dir & MV_DIR_FORWARD) {
1901                         MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.data, op_pix, op_qpix);
1902                         op_pix = s->dsp.avg_pixels_tab;
1903                         op_qpix= s->me.qpel_avg;
1904                     }
1905                     if (s->mv_dir & MV_DIR_BACKWARD) {
1906                         MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.data, op_pix, op_qpix);
1907                     }
1908                 }
1909             }
1910
1911             /* skip dequant / idct if we are really late ;) */
1912             if(s->hurry_up>1) goto skip_idct;
1913             if(s->avctx->skip_idct){
1914                 if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == FF_B_TYPE)
1915                    ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != FF_I_TYPE)
1916                    || s->avctx->skip_idct >= AVDISCARD_ALL)
1917                     goto skip_idct;
1918             }
1919
1920             /* add dct residue */
1921             if(s->encoding || !(   s->h263_msmpeg4 || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
1922                                 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
1923                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
1924                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
1925                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
1926                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1927
1928                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1929                     if (s->chroma_y_shift){
1930                         add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1931                         add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1932                     }else{
1933                         dct_linesize >>= 1;
1934                         dct_offset >>=1;
1935                         add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
1936                         add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
1937                         add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1938                         add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1939                     }
1940                 }
1941             } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
1942                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
1943                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
1944                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
1945                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
1946
1947                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1948                     if(s->chroma_y_shift){//Chroma420
1949                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
1950                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
1951                     }else{
1952                         //chroma422
1953                         dct_linesize = uvlinesize << s->interlaced_dct;
1954                         dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
1955
1956                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
1957                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
1958                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
1959                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
1960                         if(!s->chroma_x_shift){//Chroma444
1961                             add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
1962                             add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
1963                             add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
1964                             add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
1965                         }
1966                     }
1967                 }//fi gray
1968             }
1969             else if (CONFIG_WMV2) {
1970                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
1971             }
1972         } else {
1973             /* dct only in intra block */
1974             if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
1975                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
1976                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
1977                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
1978                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
1979
1980                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1981                     if(s->chroma_y_shift){
1982                         put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
1983                         put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
1984                     }else{
1985                         dct_offset >>=1;
1986                         dct_linesize >>=1;
1987                         put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
1988                         put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
1989                         put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
1990                         put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
1991                     }
1992                 }
1993             }else{
1994                 s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
1995                 s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
1996                 s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
1997                 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
1998
1999                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2000                     if(s->chroma_y_shift){
2001                         s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2002                         s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2003                     }else{
2004
2005                         dct_linesize = uvlinesize << s->interlaced_dct;
2006                         dct_offset =(s->interlaced_dct)? uvlinesize : uvlinesize*8;
2007
2008                         s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
2009                         s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
2010                         s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2011                         s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2012                         if(!s->chroma_x_shift){//Chroma444
2013                             s->dsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
2014                             s->dsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
2015                             s->dsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2016                             s->dsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2017                         }
2018                     }
2019                 }//gray
2020             }
2021         }
2022 skip_idct:
2023         if(!readable){
2024             s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
2025             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2026             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2027         }
2028     }
2029 }
2030
2031 void MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2032 #if !CONFIG_SMALL
2033     if(s->out_format == FMT_MPEG1) {
2034         if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2035         else                 MPV_decode_mb_internal(s, block, 0, 1);
2036     } else
2037 #endif
2038     if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2039     else                  MPV_decode_mb_internal(s, block, 0, 0);
2040 }
2041
2042 /**
2043  *
2044  * @param h is the normal height, this will be reduced automatically if needed for the last row
2045  */
2046 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2047     if (s->avctx->draw_horiz_band) {
2048         AVFrame *src;
2049         const int field_pic= s->picture_structure != PICT_FRAME;
2050         int offset[4];
2051
2052         h= FFMIN(h, (s->avctx->height>>field_pic) - y);
2053
2054         if(field_pic && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)){
2055             h <<= 1;
2056             y <<= 1;
2057             if(s->first_field) return;
2058         }
2059
2060         if(s->pict_type==FF_B_TYPE || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2061             src= (AVFrame*)s->current_picture_ptr;
2062         else if(s->last_picture_ptr)
2063             src= (AVFrame*)s->last_picture_ptr;
2064         else
2065             return;
2066
2067         if(s->pict_type==FF_B_TYPE && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2068             offset[0]=
2069             offset[1]=
2070             offset[2]=
2071             offset[3]= 0;
2072         }else{
2073             offset[0]= y * s->linesize;
2074             offset[1]=
2075             offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2076             offset[3]= 0;
2077         }
2078
2079         emms_c();
2080
2081         s->avctx->draw_horiz_band(s->avctx, src, offset,
2082                                   y, s->picture_structure, h);
2083     }
2084 }
2085
2086 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2087     const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2088     const int uvlinesize= s->current_picture.linesize[1];
2089     const int mb_size= 4 - s->avctx->lowres;
2090
2091     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2092     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2093     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2094     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2095     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2096     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;
2097     //block_index is not used by mpeg2, so it is not affected by chroma_format
2098
2099     s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2100     s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2101     s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2102
2103     if(!(s->pict_type==FF_B_TYPE && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2104     {
2105         if(s->picture_structure==PICT_FRAME){
2106         s->dest[0] += s->mb_y *   linesize << mb_size;
2107         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2108         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2109         }else{
2110             s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
2111             s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2112             s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2113             assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2114         }
2115     }
2116 }
2117
2118 void ff_mpeg_flush(AVCodecContext *avctx){
2119     int i;
2120     MpegEncContext *s = avctx->priv_data;
2121
2122     if(s==NULL || s->picture==NULL)
2123         return;
2124
2125     for(i=0; i<MAX_PICTURE_COUNT; i++){
2126        if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2127                                     || s->picture[i].type == FF_BUFFER_TYPE_USER))
2128         free_frame_buffer(s, &s->picture[i]);
2129     }
2130     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2131
2132     s->mb_x= s->mb_y= 0;
2133     s->closed_gop= 0;
2134
2135     s->parse_context.state= -1;
2136     s->parse_context.frame_start_found= 0;
2137     s->parse_context.overread= 0;
2138     s->parse_context.overread_index= 0;
2139     s->parse_context.index= 0;
2140     s->parse_context.last_index= 0;
2141     s->bitstream_buffer_size=0;
2142     s->pp_time=0;
2143 }
2144
2145 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2146                                    DCTELEM *block, int n, int qscale)
2147 {
2148     int i, level, nCoeffs;
2149     const uint16_t *quant_matrix;
2150
2151     nCoeffs= s->block_last_index[n];
2152
2153     if (n < 4)
2154         block[0] = block[0] * s->y_dc_scale;
2155     else
2156         block[0] = block[0] * s->c_dc_scale;
2157     /* XXX: only mpeg1 */
2158     quant_matrix = s->intra_matrix;
2159     for(i=1;i<=nCoeffs;i++) {
2160         int j= s->intra_scantable.permutated[i];
2161         level = block[j];
2162         if (level) {
2163             if (level < 0) {
2164                 level = -level;
2165                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2166                 level = (level - 1) | 1;
2167                 level = -level;
2168             } else {
2169                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2170                 level = (level - 1) | 1;
2171             }
2172             block[j] = level;
2173         }
2174     }
2175 }
2176
2177 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2178                                    DCTELEM *block, int n, int qscale)
2179 {
2180     int i, level, nCoeffs;
2181     const uint16_t *quant_matrix;
2182
2183     nCoeffs= s->block_last_index[n];
2184
2185     quant_matrix = s->inter_matrix;
2186     for(i=0; i<=nCoeffs; i++) {
2187         int j= s->intra_scantable.permutated[i];
2188         level = block[j];
2189         if (level) {
2190             if (level < 0) {
2191                 level = -level;
2192                 level = (((level << 1) + 1) * qscale *
2193                          ((int) (quant_matrix[j]))) >> 4;
2194                 level = (level - 1) | 1;
2195                 level = -level;
2196             } else {
2197                 level = (((level << 1) + 1) * qscale *
2198                          ((int) (quant_matrix[j]))) >> 4;
2199                 level = (level - 1) | 1;
2200             }
2201             block[j] = level;
2202         }
2203     }
2204 }
2205
2206 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2207                                    DCTELEM *block, int n, int qscale)
2208 {
2209     int i, level, nCoeffs;
2210     const uint16_t *quant_matrix;
2211
2212     if(s->alternate_scan) nCoeffs= 63;
2213     else nCoeffs= s->block_last_index[n];
2214
2215     if (n < 4)
2216         block[0] = block[0] * s->y_dc_scale;
2217     else
2218         block[0] = block[0] * s->c_dc_scale;
2219     quant_matrix = s->intra_matrix;
2220     for(i=1;i<=nCoeffs;i++) {
2221         int j= s->intra_scantable.permutated[i];
2222         level = block[j];
2223         if (level) {
2224             if (level < 0) {
2225                 level = -level;
2226                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2227                 level = -level;
2228             } else {
2229                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2230             }
2231             block[j] = level;
2232         }
2233     }
2234 }
2235
2236 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2237                                    DCTELEM *block, int n, int qscale)
2238 {
2239     int i, level, nCoeffs;
2240     const uint16_t *quant_matrix;
2241     int sum=-1;
2242
2243     if(s->alternate_scan) nCoeffs= 63;
2244     else nCoeffs= s->block_last_index[n];
2245
2246     if (n < 4)
2247         block[0] = block[0] * s->y_dc_scale;
2248     else
2249         block[0] = block[0] * s->c_dc_scale;
2250     quant_matrix = s->intra_matrix;
2251     for(i=1;i<=nCoeffs;i++) {
2252         int j= s->intra_scantable.permutated[i];
2253         level = block[j];
2254         if (level) {
2255             if (level < 0) {
2256                 level = -level;
2257                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2258                 level = -level;
2259             } else {
2260                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2261             }
2262             block[j] = level;
2263             sum+=level;
2264         }
2265     }
2266     block[63]^=sum&1;
2267 }
2268
2269 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2270                                    DCTELEM *block, int n, int qscale)
2271 {
2272     int i, level, nCoeffs;
2273     const uint16_t *quant_matrix;
2274     int sum=-1;
2275
2276     if(s->alternate_scan) nCoeffs= 63;
2277     else nCoeffs= s->block_last_index[n];
2278
2279     quant_matrix = s->inter_matrix;
2280     for(i=0; i<=nCoeffs; i++) {
2281         int j= s->intra_scantable.permutated[i];
2282         level = block[j];
2283         if (level) {
2284             if (level < 0) {
2285                 level = -level;
2286                 level = (((level << 1) + 1) * qscale *
2287                          ((int) (quant_matrix[j]))) >> 4;
2288                 level = -level;
2289             } else {
2290                 level = (((level << 1) + 1) * qscale *
2291                          ((int) (quant_matrix[j]))) >> 4;
2292             }
2293             block[j] = level;
2294             sum+=level;
2295         }
2296     }
2297     block[63]^=sum&1;
2298 }
2299
2300 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2301                                   DCTELEM *block, int n, int qscale)
2302 {
2303     int i, level, qmul, qadd;
2304     int nCoeffs;
2305
2306     assert(s->block_last_index[n]>=0);
2307
2308     qmul = qscale << 1;
2309
2310     if (!s->h263_aic) {
2311         if (n < 4)
2312             block[0] = block[0] * s->y_dc_scale;
2313         else
2314             block[0] = block[0] * s->c_dc_scale;
2315         qadd = (qscale - 1) | 1;
2316     }else{
2317         qadd = 0;
2318     }
2319     if(s->ac_pred)
2320         nCoeffs=63;
2321     else
2322         nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2323
2324     for(i=1; i<=nCoeffs; i++) {
2325         level = block[i];
2326         if (level) {
2327             if (level < 0) {
2328                 level = level * qmul - qadd;
2329             } else {
2330                 level = level * qmul + qadd;
2331             }
2332             block[i] = level;
2333         }
2334     }
2335 }
2336
2337 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2338                                   DCTELEM *block, int n, int qscale)
2339 {
2340     int i, level, qmul, qadd;
2341     int nCoeffs;
2342
2343     assert(s->block_last_index[n]>=0);
2344
2345     qadd = (qscale - 1) | 1;
2346     qmul = qscale << 1;
2347
2348     nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2349
2350     for(i=0; i<=nCoeffs; i++) {
2351         level = block[i];
2352         if (level) {
2353             if (level < 0) {
2354                 level = level * qmul - qadd;
2355             } else {
2356                 level = level * qmul + qadd;
2357             }
2358             block[i] = level;
2359         }
2360     }
2361 }
2362
2363 /**
2364  * set qscale and update qscale dependent variables.
2365  */
2366 void ff_set_qscale(MpegEncContext * s, int qscale)
2367 {
2368     if (qscale < 1)
2369         qscale = 1;
2370     else if (qscale > 31)
2371         qscale = 31;
2372
2373     s->qscale = qscale;
2374     s->chroma_qscale= s->chroma_qscale_table[qscale];
2375
2376     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2377     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2378 }