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

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