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

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