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

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