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

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