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