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