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

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