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

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