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

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