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

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