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