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

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