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!=AV_PICTURE_TYPE_B){
 531             s->last_non_b_pict_type= s1->pict_type;
 532         }
 533     }
 534
 535     return 0;
 536 }
 537
 538 /**
 539  * sets the given MpegEncContext to common defaults (same for encoding and decoding).
 540  * the changed fields will not depend upon the prior state of the MpegEncContext.
 541  */
 542 void MPV_common_defaults(MpegEncContext *s){
 543     s->y_dc_scale_table=
 544     s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
 545     s->chroma_qscale_table= ff_default_chroma_qscale_table;
 546     s->progressive_frame= 1;
 547     s->progressive_sequence= 1;
 548     s->picture_structure= PICT_FRAME;
 549
 550     s->coded_picture_number = 0;
 551     s->picture_number = 0;
 552     s->input_picture_number = 0;
 553
 554     s->picture_in_gop_number = 0;
 555
 556     s->f_code = 1;
 557     s->b_code = 1;
 558
 559     s->picture_range_start = 0;
 560     s->picture_range_end = MAX_PICTURE_COUNT;
 561 }
 562
 563 /**
 564  * sets the given MpegEncContext to defaults for decoding.
 565  * the changed fields will not depend upon the prior state of the MpegEncContext.
 566  */
 567 void MPV_decode_defaults(MpegEncContext *s){
 568     MPV_common_defaults(s);
 569 }
 570
 571 /**
 572  * init common structure for both encoder and decoder.
 573  * this assumes that some variables like width/height are already set
 574  */
 575 av_cold int MPV_common_init(MpegEncContext *s)
 576 {
 577     int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y, threads;
 578
 579     if(s->codec_id == CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
 580         s->mb_height = (s->height + 31) / 32 * 2;
 581     else if (s->codec_id != CODEC_ID_H264)
 582         s->mb_height = (s->height + 15) / 16;
 583
 584     if(s->avctx->pix_fmt == PIX_FMT_NONE){
 585         av_log(s->avctx, AV_LOG_ERROR, "decoding to PIX_FMT_NONE is not supported.\n");
 586         return -1;
 587     }
 588
 589     if(s->avctx->active_thread_type&FF_THREAD_SLICE &&
 590        (s->avctx->thread_count > MAX_THREADS || (s->avctx->thread_count > s->mb_height && s->mb_height))){
 591         av_log(s->avctx, AV_LOG_ERROR, "too many threads\n");
 592         return -1;
 593     }
 594
 595     if((s->width || s->height) && av_image_check_size(s->width, s->height, 0, s->avctx))
 596         return -1;
 597
 598     dsputil_init(&s->dsp, s->avctx);
 599     ff_dct_common_init(s);
 600
 601     s->flags= s->avctx->flags;
 602     s->flags2= s->avctx->flags2;
 603
 604     s->mb_width  = (s->width  + 15) / 16;
 605     s->mb_stride = s->mb_width + 1;
 606     s->b8_stride = s->mb_width*2 + 1;
 607     s->b4_stride = s->mb_width*4 + 1;
 608     mb_array_size= s->mb_height * s->mb_stride;
 609     mv_table_size= (s->mb_height+2) * s->mb_stride + 1;
 610
 611     /* set chroma shifts */
 612     avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,&(s->chroma_x_shift),
 613                                                     &(s->chroma_y_shift) );
 614
 615     /* set default edge pos, will be overriden in decode_header if needed */
 616     s->h_edge_pos= s->mb_width*16;
 617     s->v_edge_pos= s->mb_height*16;
 618
 619     s->mb_num = s->mb_width * s->mb_height;
 620
 621     s->block_wrap[0]=
 622     s->block_wrap[1]=
 623     s->block_wrap[2]=
 624     s->block_wrap[3]= s->b8_stride;
 625     s->block_wrap[4]=
 626     s->block_wrap[5]= s->mb_stride;
 627
 628     y_size = s->b8_stride * (2 * s->mb_height + 1);
 629     c_size = s->mb_stride * (s->mb_height + 1);
 630     yc_size = y_size + 2 * c_size;
 631
 632     /* convert fourcc to upper case */
 633     s->codec_tag = ff_toupper4(s->avctx->codec_tag);
 634
 635     s->stream_codec_tag = ff_toupper4(s->avctx->stream_codec_tag);
 636
 637     s->avctx->coded_frame= (AVFrame*)&s->current_picture;
 638
 639     FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num+1)*sizeof(int), fail) //error ressilience code looks cleaner with this
 640     for(y=0; y<s->mb_height; y++){
 641         for(x=0; x<s->mb_width; x++){
 642             s->mb_index2xy[ x + y*s->mb_width ] = x + y*s->mb_stride;
 643         }
 644     }
 645     s->mb_index2xy[ s->mb_height*s->mb_width ] = (s->mb_height-1)*s->mb_stride + s->mb_width; //FIXME really needed?
 646
 647     if (s->encoding) {
 648         /* Allocate MV tables */
 649         FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base            , mv_table_size * 2 * sizeof(int16_t), fail)
 650         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base       , mv_table_size * 2 * sizeof(int16_t), fail)
 651         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base       , mv_table_size * 2 * sizeof(int16_t), fail)
 652         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
 653         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof(int16_t), fail)
 654         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base     , mv_table_size * 2 * sizeof(int16_t), fail)
 655         s->p_mv_table           = s->p_mv_table_base            + s->mb_stride + 1;
 656         s->b_forw_mv_table      = s->b_forw_mv_table_base       + s->mb_stride + 1;
 657         s->b_back_mv_table      = s->b_back_mv_table_base       + s->mb_stride + 1;
 658         s->b_bidir_forw_mv_table= s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
 659         s->b_bidir_back_mv_table= s->b_bidir_back_mv_table_base + s->mb_stride + 1;
 660         s->b_direct_mv_table    = s->b_direct_mv_table_base     + s->mb_stride + 1;
 661
 662         if(s->msmpeg4_version){
 663             FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats, 2*2*(MAX_LEVEL+1)*(MAX_RUN+1)*2*sizeof(int), fail);
 664         }
 665         FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
 666
 667         /* Allocate MB type table */
 668         FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type  , mb_array_size * sizeof(uint16_t), fail) //needed for encoding
 669
 670         FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
 671
 672         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix  , 64*32   * sizeof(int), fail)
 673         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix  , 64*32   * sizeof(int), fail)
 674         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16, 64*32*2 * sizeof(uint16_t), fail)
 675         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16, 64*32*2 * sizeof(uint16_t), fail)
 676         FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
 677         FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture*), fail)
 678
 679         if(s->avctx->noise_reduction){
 680             FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail)
 681         }
 682     }
 683
 684     s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
 685     FF_ALLOCZ_OR_GOTO(s->avctx, s->picture, s->picture_count * sizeof(Picture), fail)
 686     for(i = 0; i < s->picture_count; i++) {
 687         avcodec_get_frame_defaults((AVFrame *)&s->picture[i]);
 688     }
 689
 690     FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table, mb_array_size*sizeof(uint8_t), fail)
 691
 692     if(s->codec_id==CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)){
 693         /* interlaced direct mode decoding tables */
 694             for(i=0; i<2; i++){
 695                 int j, k;
 696                 for(j=0; j<2; j++){
 697                     for(k=0; k<2; k++){
 698                         FF_ALLOCZ_OR_GOTO(s->avctx,    s->b_field_mv_table_base[i][j][k], mv_table_size * 2 * sizeof(int16_t), fail)
 699                         s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] + s->mb_stride + 1;
 700                     }
 701                     FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
 702                     FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
 703                     s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j]+ s->mb_stride + 1;
 704                 }
 705                 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
 706             }
 707     }
 708     if (s->out_format == FMT_H263) {
 709         /* cbp values */
 710         FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
 711         s->coded_block= s->coded_block_base + s->b8_stride + 1;
 712
 713         /* cbp, ac_pred, pred_dir */
 714         FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table     , mb_array_size * sizeof(uint8_t), fail)
 715         FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail)
 716     }
 717
 718     if (s->h263_pred || s->h263_plus || !s->encoding) {
 719         /* dc values */
 720         //MN: we need these for error resilience of intra-frames
 721         FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
 722         s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
 723         s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
 724         s->dc_val[2] = s->dc_val[1] + c_size;
 725         for(i=0;i<yc_size;i++)
 726             s->dc_val_base[i] = 1024;
 727     }
 728
 729     /* which mb is a intra block */
 730     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
 731     memset(s->mbintra_table, 1, mb_array_size);
 732
 733     /* init macroblock skip table */
 734     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size+2, fail);
 735     //Note the +1 is for a quicker mpeg4 slice_end detection
 736     FF_ALLOCZ_OR_GOTO(s->avctx, s->prev_pict_types, PREV_PICT_TYPES_BUFFER_SIZE, fail);
 737
 738     s->parse_context.state= -1;
 739     if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
 740        s->visualization_buffer[0] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
 741        s->visualization_buffer[1] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
 742        s->visualization_buffer[2] = av_malloc((s->mb_width*16 + 2*EDGE_WIDTH) * s->mb_height*16 + 2*EDGE_WIDTH);
 743     }
 744
 745     s->context_initialized = 1;
 746     s->thread_context[0]= s;
 747
 748     if (HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_SLICE) {
 749         threads = s->avctx->thread_count;
 750
 751         for(i=1; i<threads; i++){
 752             s->thread_context[i]= av_malloc(sizeof(MpegEncContext));
 753             memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
 754         }
 755
 756         for(i=0; i<threads; i++){
 757             if(init_duplicate_context(s->thread_context[i], s) < 0)
 758                 goto fail;
 759             s->thread_context[i]->start_mb_y= (s->mb_height*(i  ) + s->avctx->thread_count/2) / s->avctx->thread_count;
 760             s->thread_context[i]->end_mb_y  = (s->mb_height*(i+1) + s->avctx->thread_count/2) / s->avctx->thread_count;
 761         }
 762     } else {
 763         if(init_duplicate_context(s, s) < 0) goto fail;
 764         s->start_mb_y = 0;
 765         s->end_mb_y   = s->mb_height;
 766     }
 767
 768     return 0;
 769  fail:
 770     MPV_common_end(s);
 771     return -1;
 772 }
 773
 774 /* init common structure for both encoder and decoder */
 775 void MPV_common_end(MpegEncContext *s)
 776 {
 777     int i, j, k;
 778
 779     if (HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_SLICE) {
 780         for(i=0; i<s->avctx->thread_count; i++){
 781             free_duplicate_context(s->thread_context[i]);
 782         }
 783         for(i=1; i<s->avctx->thread_count; i++){
 784             av_freep(&s->thread_context[i]);
 785         }
 786     } else free_duplicate_context(s);
 787
 788     av_freep(&s->parse_context.buffer);
 789     s->parse_context.buffer_size=0;
 790
 791     av_freep(&s->mb_type);
 792     av_freep(&s->p_mv_table_base);
 793     av_freep(&s->b_forw_mv_table_base);
 794     av_freep(&s->b_back_mv_table_base);
 795     av_freep(&s->b_bidir_forw_mv_table_base);
 796     av_freep(&s->b_bidir_back_mv_table_base);
 797     av_freep(&s->b_direct_mv_table_base);
 798     s->p_mv_table= NULL;
 799     s->b_forw_mv_table= NULL;
 800     s->b_back_mv_table= NULL;
 801     s->b_bidir_forw_mv_table= NULL;
 802     s->b_bidir_back_mv_table= NULL;
 803     s->b_direct_mv_table= NULL;
 804     for(i=0; i<2; i++){
 805         for(j=0; j<2; j++){
 806             for(k=0; k<2; k++){
 807                 av_freep(&s->b_field_mv_table_base[i][j][k]);
 808                 s->b_field_mv_table[i][j][k]=NULL;
 809             }
 810             av_freep(&s->b_field_select_table[i][j]);
 811             av_freep(&s->p_field_mv_table_base[i][j]);
 812             s->p_field_mv_table[i][j]=NULL;
 813         }
 814         av_freep(&s->p_field_select_table[i]);
 815     }
 816
 817     av_freep(&s->dc_val_base);
 818     av_freep(&s->coded_block_base);
 819     av_freep(&s->mbintra_table);
 820     av_freep(&s->cbp_table);
 821     av_freep(&s->pred_dir_table);
 822
 823     av_freep(&s->mbskip_table);
 824     av_freep(&s->prev_pict_types);
 825     av_freep(&s->bitstream_buffer);
 826     s->allocated_bitstream_buffer_size=0;
 827
 828     av_freep(&s->avctx->stats_out);
 829     av_freep(&s->ac_stats);
 830     av_freep(&s->error_status_table);
 831     av_freep(&s->mb_index2xy);
 832     av_freep(&s->lambda_table);
 833     av_freep(&s->q_intra_matrix);
 834     av_freep(&s->q_inter_matrix);
 835     av_freep(&s->q_intra_matrix16);
 836     av_freep(&s->q_inter_matrix16);
 837     av_freep(&s->input_picture);
 838     av_freep(&s->reordered_input_picture);
 839     av_freep(&s->dct_offset);
 840
 841     if(s->picture && !s->avctx->is_copy){
 842         for(i=0; i<s->picture_count; i++){
 843             free_picture(s, &s->picture[i]);
 844         }
 845     }
 846     av_freep(&s->picture);
 847     s->context_initialized = 0;
 848     s->last_picture_ptr=
 849     s->next_picture_ptr=
 850     s->current_picture_ptr= NULL;
 851     s->linesize= s->uvlinesize= 0;
 852
 853     for(i=0; i<3; i++)
 854         av_freep(&s->visualization_buffer[i]);
 855
 856     if(!(s->avctx->active_thread_type&FF_THREAD_FRAME))
 857         avcodec_default_free_buffers(s->avctx);
 858 }
 859
 860 void init_rl(RLTable *rl, uint8_t static_store[2][2*MAX_RUN + MAX_LEVEL + 3])
 861 {
 862     int8_t max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
 863     uint8_t index_run[MAX_RUN+1];
 864     int last, run, level, start, end, i;
 865
 866     /* If table is static, we can quit if rl->max_level[0] is not NULL */
 867     if(static_store && rl->max_level[0])
 868         return;
 869
 870     /* compute max_level[], max_run[] and index_run[] */
 871     for(last=0;last<2;last++) {
 872         if (last == 0) {
 873             start = 0;
 874             end = rl->last;
 875         } else {
 876             start = rl->last;
 877             end = rl->n;
 878         }
 879
 880         memset(max_level, 0, MAX_RUN + 1);
 881         memset(max_run, 0, MAX_LEVEL + 1);
 882         memset(index_run, rl->n, MAX_RUN + 1);
 883         for(i=start;i<end;i++) {
 884             run = rl->table_run[i];
 885             level = rl->table_level[i];
 886             if (index_run[run] == rl->n)
 887                 index_run[run] = i;
 888             if (level > max_level[run])
 889                 max_level[run] = level;
 890             if (run > max_run[level])
 891                 max_run[level] = run;
 892         }
 893         if(static_store)
 894             rl->max_level[last] = static_store[last];
 895         else
 896             rl->max_level[last] = av_malloc(MAX_RUN + 1);
 897         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
 898         if(static_store)
 899             rl->max_run[last] = static_store[last] + MAX_RUN + 1;
 900         else
 901             rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
 902         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
 903         if(static_store)
 904             rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
 905         else
 906             rl->index_run[last] = av_malloc(MAX_RUN + 1);
 907         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
 908     }
 909 }
 910
 911 void init_vlc_rl(RLTable *rl)
 912 {
 913     int i, q;
 914
 915     for(q=0; q<32; q++){
 916         int qmul= q*2;
 917         int qadd= (q-1)|1;
 918
 919         if(q==0){
 920             qmul=1;
 921             qadd=0;
 922         }
 923         for(i=0; i<rl->vlc.table_size; i++){
 924             int code= rl->vlc.table[i][0];
 925             int len = rl->vlc.table[i][1];
 926             int level, run;
 927
 928             if(len==0){ // illegal code
 929                 run= 66;
 930                 level= MAX_LEVEL;
 931             }else if(len<0){ //more bits needed
 932                 run= 0;
 933                 level= code;
 934             }else{
 935                 if(code==rl->n){ //esc
 936                     run= 66;
 937                     level= 0;
 938                 }else{
 939                     run=   rl->table_run  [code] + 1;
 940                     level= rl->table_level[code] * qmul + qadd;
 941                     if(code >= rl->last) run+=192;
 942                 }
 943             }
 944             rl->rl_vlc[q][i].len= len;
 945             rl->rl_vlc[q][i].level= level;
 946             rl->rl_vlc[q][i].run= run;
 947         }
 948     }
 949 }
 950
 951 void ff_release_unused_pictures(MpegEncContext *s, int remove_current)
 952 {
 953     int i;
 954
 955     /* release non reference frames */
 956     for(i=0; i<s->picture_count; i++){
 957         if(s->picture[i].data[0] && !s->picture[i].reference
 958            && (!s->picture[i].owner2 || s->picture[i].owner2 == s)
 959            && (remove_current || &s->picture[i] != s->current_picture_ptr)
 960            /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
 961             free_frame_buffer(s, &s->picture[i]);
 962         }
 963     }
 964 }
 965
 966 int ff_find_unused_picture(MpegEncContext *s, int shared){
 967     int i;
 968
 969     if(shared){
 970         for(i=s->picture_range_start; i<s->picture_range_end; i++){
 971             if(s->picture[i].data[0]==NULL && s->picture[i].type==0) return i;
 972         }
 973     }else{
 974         for(i=s->picture_range_start; i<s->picture_range_end; i++){
 975             if(s->picture[i].data[0]==NULL && s->picture[i].type!=0) return i; //FIXME
 976         }
 977         for(i=s->picture_range_start; i<s->picture_range_end; i++){
 978             if(s->picture[i].data[0]==NULL) return i;
 979         }
 980     }
 981
 982     av_log(s->avctx, AV_LOG_FATAL, "Internal error, picture buffer overflow\n");
 983     /* We could return -1, but the codec would crash trying to draw into a
 984      * non-existing frame anyway. This is safer than waiting for a random crash.
 985      * Also the return of this is never useful, an encoder must only allocate
 986      * as much as allowed in the specification. This has no relationship to how
 987      * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
 988      * enough for such valid streams).
 989      * Plus, a decoder has to check stream validity and remove frames if too
 990      * many reference frames are around. Waiting for "OOM" is not correct at
 991      * all. Similarly, missing reference frames have to be replaced by
 992      * interpolated/MC frames, anything else is a bug in the codec ...
 993      */
 994     abort();
 995     return -1;
 996 }
 997
 998 static void update_noise_reduction(MpegEncContext *s){
 999     int intra, i;
1000
1001     for(intra=0; intra<2; intra++){
1002         if(s->dct_count[intra] > (1<<16)){
1003             for(i=0; i<64; i++){
1004                 s->dct_error_sum[intra][i] >>=1;
1005             }
1006             s->dct_count[intra] >>= 1;
1007         }
1008
1009         for(i=0; i<64; i++){
1010             s->dct_offset[intra][i]= (s->avctx->noise_reduction * s->dct_count[intra] + s->dct_error_sum[intra][i]/2) / (s->dct_error_sum[intra][i]+1);
1011         }
1012     }
1013 }
1014
1015 /**
1016  * generic function for encode/decode called after coding/decoding the header and before a frame is coded/decoded
1017  */
1018 int MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1019 {
1020     int i;
1021     Picture *pic;
1022     s->mb_skipped = 0;
1023
1024     assert(s->last_picture_ptr==NULL || s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3);
1025
1026     /* mark&release old frames */
1027     if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr && s->last_picture_ptr != s->next_picture_ptr && s->last_picture_ptr->data[0]) {
1028       if(s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3){
1029           free_frame_buffer(s, s->last_picture_ptr);
1030
1031         /* release forgotten pictures */
1032         /* if(mpeg124/h263) */
1033         if(!s->encoding){
1034             for(i=0; i<s->picture_count; i++){
1035                 if(s->picture[i].data[0] && &s->picture[i] != s->next_picture_ptr && s->picture[i].reference){
1036                     av_log(avctx, AV_LOG_ERROR, "releasing zombie picture\n");
1037                     free_frame_buffer(s, &s->picture[i]);
1038                 }
1039             }
1040         }
1041       }
1042     }
1043
1044     if(!s->encoding){
1045         ff_release_unused_pictures(s, 1);
1046
1047         if(s->current_picture_ptr && s->current_picture_ptr->data[0]==NULL)
1048             pic= s->current_picture_ptr; //we already have a unused image (maybe it was set before reading the header)
1049         else{
1050             i= ff_find_unused_picture(s, 0);
1051             pic= &s->picture[i];
1052         }
1053
1054         pic->reference= 0;
1055         if (!s->dropable){
1056             if (s->codec_id == CODEC_ID_H264)
1057                 pic->reference = s->picture_structure;
1058             else if (s->pict_type != AV_PICTURE_TYPE_B)
1059                 pic->reference = 3;
1060         }
1061
1062         pic->coded_picture_number= s->coded_picture_number++;
1063
1064         if(ff_alloc_picture(s, pic, 0) < 0)
1065             return -1;
1066
1067         s->current_picture_ptr= pic;
1068         //FIXME use only the vars from current_pic
1069         s->current_picture_ptr->top_field_first= s->top_field_first;
1070         if(s->codec_id == CODEC_ID_MPEG1VIDEO || s->codec_id == CODEC_ID_MPEG2VIDEO) {
1071             if(s->picture_structure != PICT_FRAME)
1072                 s->current_picture_ptr->top_field_first= (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1073         }
1074         s->current_picture_ptr->interlaced_frame= !s->progressive_frame && !s->progressive_sequence;
1075         s->current_picture_ptr->field_picture= s->picture_structure != PICT_FRAME;
1076     }
1077
1078     s->current_picture_ptr->pict_type= s->pict_type;
1079 //    if(s->flags && CODEC_FLAG_QSCALE)
1080   //      s->current_picture_ptr->quality= s->new_picture_ptr->quality;
1081     s->current_picture_ptr->key_frame= s->pict_type == AV_PICTURE_TYPE_I;
1082
1083     ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1084
1085     if (s->pict_type != AV_PICTURE_TYPE_B) {
1086         s->last_picture_ptr= s->next_picture_ptr;
1087         if(!s->dropable)
1088             s->next_picture_ptr= s->current_picture_ptr;
1089     }
1090 /*    av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n", s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1091         s->last_picture_ptr    ? s->last_picture_ptr->data[0] : NULL,
1092         s->next_picture_ptr    ? s->next_picture_ptr->data[0] : NULL,
1093         s->current_picture_ptr ? s->current_picture_ptr->data[0] : NULL,
1094         s->pict_type, s->dropable);*/
1095
1096     if(s->codec_id != CODEC_ID_H264){
1097         if((s->last_picture_ptr==NULL || s->last_picture_ptr->data[0]==NULL) &&
1098            (s->pict_type!=AV_PICTURE_TYPE_I || s->picture_structure != PICT_FRAME)){
1099             if (s->pict_type != AV_PICTURE_TYPE_I)
1100                 av_log(avctx, AV_LOG_ERROR, "warning: first frame is no keyframe\n");
1101             else if (s->picture_structure != PICT_FRAME)
1102                 av_log(avctx, AV_LOG_INFO, "allocate dummy last picture for field based first keyframe\n");
1103
1104             /* Allocate a dummy frame */
1105             i= ff_find_unused_picture(s, 0);
1106             s->last_picture_ptr= &s->picture[i];
1107             if(ff_alloc_picture(s, s->last_picture_ptr, 0) < 0)
1108                 return -1;
1109             ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 0);
1110             ff_thread_report_progress((AVFrame*)s->last_picture_ptr, INT_MAX, 1);
1111         }
1112         if((s->next_picture_ptr==NULL || s->next_picture_ptr->data[0]==NULL) && s->pict_type==AV_PICTURE_TYPE_B){
1113             /* Allocate a dummy frame */
1114             i= ff_find_unused_picture(s, 0);
1115             s->next_picture_ptr= &s->picture[i];
1116             if(ff_alloc_picture(s, s->next_picture_ptr, 0) < 0)
1117                 return -1;
1118             ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 0);
1119             ff_thread_report_progress((AVFrame*)s->next_picture_ptr, INT_MAX, 1);
1120         }
1121     }
1122
1123     if(s->last_picture_ptr) ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1124     if(s->next_picture_ptr) ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1125
1126     assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr && s->last_picture_ptr->data[0]));
1127
1128     if(s->picture_structure!=PICT_FRAME && s->out_format != FMT_H264){
1129         int i;
1130         for(i=0; i<4; i++){
1131             if(s->picture_structure == PICT_BOTTOM_FIELD){
1132                  s->current_picture.data[i] += s->current_picture.linesize[i];
1133             }
1134             s->current_picture.linesize[i] *= 2;
1135             s->last_picture.linesize[i] *=2;
1136             s->next_picture.linesize[i] *=2;
1137         }
1138     }
1139
1140     s->error_recognition= avctx->error_recognition;
1141
1142     /* set dequantizer, we can't do it during init as it might change for mpeg4
1143        and we can't do it in the header decode as init is not called for mpeg4 there yet */
1144     if(s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO){
1145         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1146         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1147     }else if(s->out_format == FMT_H263 || s->out_format == FMT_H261){
1148         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1149         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1150     }else{
1151         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1152         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1153     }
1154
1155     if(s->dct_error_sum){
1156         assert(s->avctx->noise_reduction && s->encoding);
1157
1158         update_noise_reduction(s);
1159     }
1160
1161     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1162         return ff_xvmc_field_start(s, avctx);
1163
1164     return 0;
1165 }
1166
1167 /* generic function for encode/decode called after a frame has been coded/decoded */
1168 void MPV_frame_end(MpegEncContext *s)
1169 {
1170     int i;
1171     /* redraw edges for the frame if decoding didn't complete */
1172     //just to make sure that all data is rendered.
1173     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
1174         ff_xvmc_field_end(s);
1175    }else if((s->error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND))
1176        && !s->avctx->hwaccel
1177        && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
1178        && s->unrestricted_mv
1179        && s->current_picture.reference
1180        && !s->intra_only
1181        && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
1182         int edges = EDGE_BOTTOM | EDGE_TOP, h = s->v_edge_pos;
1183
1184             s->dsp.draw_edges(s->current_picture.data[0], s->linesize  , s->h_edge_pos   , h   , EDGE_WIDTH  , edges);
1185             s->dsp.draw_edges(s->current_picture.data[1], s->uvlinesize, s->h_edge_pos>>1, h>>1, EDGE_WIDTH/2, edges);
1186             s->dsp.draw_edges(s->current_picture.data[2], s->uvlinesize, s->h_edge_pos>>1, h>>1, EDGE_WIDTH/2, edges);
1187
1188     }
1189
1190     emms_c();
1191
1192     s->last_pict_type    = s->pict_type;
1193     s->last_lambda_for[s->pict_type]= s->current_picture_ptr->quality;
1194     if(s->pict_type!=AV_PICTURE_TYPE_B){
1195         s->last_non_b_pict_type= s->pict_type;
1196     }
1197 #if 0
1198         /* copy back current_picture variables */
1199     for(i=0; i<MAX_PICTURE_COUNT; i++){
1200         if(s->picture[i].data[0] == s->current_picture.data[0]){
1201             s->picture[i]= s->current_picture;
1202             break;
1203         }
1204     }
1205     assert(i<MAX_PICTURE_COUNT);
1206 #endif
1207
1208     if(s->encoding){
1209         /* release non-reference frames */
1210         for(i=0; i<s->picture_count; i++){
1211             if(s->picture[i].data[0] && !s->picture[i].reference /*&& s->picture[i].type!=FF_BUFFER_TYPE_SHARED*/){
1212                 free_frame_buffer(s, &s->picture[i]);
1213             }
1214         }
1215     }
1216     // clear copies, to avoid confusion
1217 #if 0
1218     memset(&s->last_picture, 0, sizeof(Picture));
1219     memset(&s->next_picture, 0, sizeof(Picture));
1220     memset(&s->current_picture, 0, sizeof(Picture));
1221 #endif
1222     s->avctx->coded_frame= (AVFrame*)s->current_picture_ptr;
1223
1224     if (s->codec_id != CODEC_ID_H264 && s->current_picture.reference) {
1225         ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_height-1, 0);
1226     }
1227 }
1228
1229 /**
1230  * draws an line from (ex, ey) -> (sx, sy).
1231  * @param w width of the image
1232  * @param h height of the image
1233  * @param stride stride/linesize of the image
1234  * @param color color of the arrow
1235  */
1236 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1237     int x, y, fr, f;
1238
1239     sx= av_clip(sx, 0, w-1);
1240     sy= av_clip(sy, 0, h-1);
1241     ex= av_clip(ex, 0, w-1);
1242     ey= av_clip(ey, 0, h-1);
1243
1244     buf[sy*stride + sx]+= color;
1245
1246     if(FFABS(ex - sx) > FFABS(ey - sy)){
1247         if(sx > ex){
1248             FFSWAP(int, sx, ex);
1249             FFSWAP(int, sy, ey);
1250         }
1251         buf+= sx + sy*stride;
1252         ex-= sx;
1253         f= ((ey-sy)<<16)/ex;
1254         for(x= 0; x <= ex; x++){
1255             y = (x*f)>>16;
1256             fr= (x*f)&0xFFFF;
1257             buf[ y   *stride + x]+= (color*(0x10000-fr))>>16;
1258             buf[(y+1)*stride + x]+= (color*         fr )>>16;
1259         }
1260     }else{
1261         if(sy > ey){
1262             FFSWAP(int, sx, ex);
1263             FFSWAP(int, sy, ey);
1264         }
1265         buf+= sx + sy*stride;
1266         ey-= sy;
1267         if(ey) f= ((ex-sx)<<16)/ey;
1268         else   f= 0;
1269         for(y= 0; y <= ey; y++){
1270             x = (y*f)>>16;
1271             fr= (y*f)&0xFFFF;
1272             buf[y*stride + x  ]+= (color*(0x10000-fr))>>16;
1273             buf[y*stride + x+1]+= (color*         fr )>>16;
1274         }
1275     }
1276 }
1277
1278 /**
1279  * draws an arrow from (ex, ey) -> (sx, sy).
1280  * @param w width of the image
1281  * @param h height of the image
1282  * @param stride stride/linesize of the image
1283  * @param color color of the arrow
1284  */
1285 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex, int ey, int w, int h, int stride, int color){
1286     int dx,dy;
1287
1288     sx= av_clip(sx, -100, w+100);
1289     sy= av_clip(sy, -100, h+100);
1290     ex= av_clip(ex, -100, w+100);
1291     ey= av_clip(ey, -100, h+100);
1292
1293     dx= ex - sx;
1294     dy= ey - sy;
1295
1296     if(dx*dx + dy*dy > 3*3){
1297         int rx=  dx + dy;
1298         int ry= -dx + dy;
1299         int length= ff_sqrt((rx*rx + ry*ry)<<8);
1300
1301         //FIXME subpixel accuracy
1302         rx= ROUNDED_DIV(rx*3<<4, length);
1303         ry= ROUNDED_DIV(ry*3<<4, length);
1304
1305         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1306         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1307     }
1308     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1309 }
1310
1311 /**
1312  * prints debuging info for the given picture.
1313  */
1314 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict){
1315
1316     if(s->avctx->hwaccel || !pict || !pict->mb_type) return;
1317
1318     if(s->avctx->debug&(FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)){
1319         int x,y;
1320
1321         av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1322         switch (pict->pict_type) {
1323             case AV_PICTURE_TYPE_I: av_log(s->avctx,AV_LOG_DEBUG,"I\n"); break;
1324             case AV_PICTURE_TYPE_P: av_log(s->avctx,AV_LOG_DEBUG,"P\n"); break;
1325             case AV_PICTURE_TYPE_B: av_log(s->avctx,AV_LOG_DEBUG,"B\n"); break;
1326             case AV_PICTURE_TYPE_S: av_log(s->avctx,AV_LOG_DEBUG,"S\n"); break;
1327             case AV_PICTURE_TYPE_SI: av_log(s->avctx,AV_LOG_DEBUG,"SI\n"); break;
1328             case AV_PICTURE_TYPE_SP: av_log(s->avctx,AV_LOG_DEBUG,"SP\n"); break;
1329         }
1330         for(y=0; y<s->mb_height; y++){
1331             for(x=0; x<s->mb_width; x++){
1332                 if(s->avctx->debug&FF_DEBUG_SKIP){
1333                     int count= s->mbskip_table[x + y*s->mb_stride];
1334                     if(count>9) count=9;
1335                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1336                 }
1337                 if(s->avctx->debug&FF_DEBUG_QP){
1338                     av_log(s->avctx, AV_LOG_DEBUG, "%2d", pict->qscale_table[x + y*s->mb_stride]);
1339                 }
1340                 if(s->avctx->debug&FF_DEBUG_MB_TYPE){
1341                     int mb_type= pict->mb_type[x + y*s->mb_stride];
1342                     //Type & MV direction
1343                     if(IS_PCM(mb_type))
1344                         av_log(s->avctx, AV_LOG_DEBUG, "P");
1345                     else if(IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1346                         av_log(s->avctx, AV_LOG_DEBUG, "A");
1347                     else if(IS_INTRA4x4(mb_type))
1348                         av_log(s->avctx, AV_LOG_DEBUG, "i");
1349                     else if(IS_INTRA16x16(mb_type))
1350                         av_log(s->avctx, AV_LOG_DEBUG, "I");
1351                     else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1352                         av_log(s->avctx, AV_LOG_DEBUG, "d");
1353                     else if(IS_DIRECT(mb_type))
1354                         av_log(s->avctx, AV_LOG_DEBUG, "D");
1355                     else if(IS_GMC(mb_type) && IS_SKIP(mb_type))
1356                         av_log(s->avctx, AV_LOG_DEBUG, "g");
1357                     else if(IS_GMC(mb_type))
1358                         av_log(s->avctx, AV_LOG_DEBUG, "G");
1359                     else if(IS_SKIP(mb_type))
1360                         av_log(s->avctx, AV_LOG_DEBUG, "S");
1361                     else if(!USES_LIST(mb_type, 1))
1362                         av_log(s->avctx, AV_LOG_DEBUG, ">");
1363                     else if(!USES_LIST(mb_type, 0))
1364                         av_log(s->avctx, AV_LOG_DEBUG, "<");
1365                     else{
1366                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1367                         av_log(s->avctx, AV_LOG_DEBUG, "X");
1368                     }
1369
1370                     //segmentation
1371                     if(IS_8X8(mb_type))
1372                         av_log(s->avctx, AV_LOG_DEBUG, "+");
1373                     else if(IS_16X8(mb_type))
1374                         av_log(s->avctx, AV_LOG_DEBUG, "-");
1375                     else if(IS_8X16(mb_type))
1376                         av_log(s->avctx, AV_LOG_DEBUG, "|");
1377                     else if(IS_INTRA(mb_type) || IS_16X16(mb_type))
1378                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1379                     else
1380                         av_log(s->avctx, AV_LOG_DEBUG, "?");
1381
1382
1383                     if(IS_INTERLACED(mb_type))
1384                         av_log(s->avctx, AV_LOG_DEBUG, "=");
1385                     else
1386                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1387                 }
1388 //                av_log(s->avctx, AV_LOG_DEBUG, " ");
1389             }
1390             av_log(s->avctx, AV_LOG_DEBUG, "\n");
1391         }
1392     }
1393
1394     if((s->avctx->debug&(FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) || (s->avctx->debug_mv)){
1395         const int shift= 1 + s->quarter_sample;
1396         int mb_y;
1397         uint8_t *ptr;
1398         int i;
1399         int h_chroma_shift, v_chroma_shift, block_height;
1400         const int width = s->avctx->width;
1401         const int height= s->avctx->height;
1402         const int mv_sample_log2= 4 - pict->motion_subsample_log2;
1403         const int mv_stride= (s->mb_width << mv_sample_log2) + (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1404         s->low_delay=0; //needed to see the vectors without trashing the buffers
1405
1406         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1407         for(i=0; i<3; i++){
1408             memcpy(s->visualization_buffer[i], pict->data[i], (i==0) ? pict->linesize[i]*height:pict->linesize[i]*height >> v_chroma_shift);
1409             pict->data[i]= s->visualization_buffer[i];
1410         }
1411         pict->type= FF_BUFFER_TYPE_COPY;
1412         ptr= pict->data[0];
1413         block_height = 16>>v_chroma_shift;
1414
1415         for(mb_y=0; mb_y<s->mb_height; mb_y++){
1416             int mb_x;
1417             for(mb_x=0; mb_x<s->mb_width; mb_x++){
1418                 const int mb_index= mb_x + mb_y*s->mb_stride;
1419                 if((s->avctx->debug_mv) && pict->motion_val){
1420                   int type;
1421                   for(type=0; type<3; type++){
1422                     int direction = 0;
1423                     switch (type) {
1424                       case 0: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_P_FOR)) || (pict->pict_type!=AV_PICTURE_TYPE_P))
1425                                 continue;
1426                               direction = 0;
1427                               break;
1428                       case 1: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_FOR)) || (pict->pict_type!=AV_PICTURE_TYPE_B))
1429                                 continue;
1430                               direction = 0;
1431                               break;
1432                       case 2: if ((!(s->avctx->debug_mv&FF_DEBUG_VIS_MV_B_BACK)) || (pict->pict_type!=AV_PICTURE_TYPE_B))
1433                                 continue;
1434                               direction = 1;
1435                               break;
1436                     }
1437                     if(!USES_LIST(pict->mb_type[mb_index], direction))
1438                         continue;
1439
1440                     if(IS_8X8(pict->mb_type[mb_index])){
1441                       int i;
1442                       for(i=0; i<4; i++){
1443                         int sx= mb_x*16 + 4 + 8*(i&1);
1444                         int sy= mb_y*16 + 4 + 8*(i>>1);
1445                         int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1446                         int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1447                         int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1448                         draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1449                       }
1450                     }else if(IS_16X8(pict->mb_type[mb_index])){
1451                       int i;
1452                       for(i=0; i<2; i++){
1453                         int sx=mb_x*16 + 8;
1454                         int sy=mb_y*16 + 4 + 8*i;
1455                         int xy= (mb_x*2 + (mb_y*2 + i)*mv_stride) << (mv_sample_log2-1);
1456                         int mx=(pict->motion_val[direction][xy][0]>>shift);
1457                         int my=(pict->motion_val[direction][xy][1]>>shift);
1458
1459                         if(IS_INTERLACED(pict->mb_type[mb_index]))
1460                             my*=2;
1461
1462                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1463                       }
1464                     }else if(IS_8X16(pict->mb_type[mb_index])){
1465                       int i;
1466                       for(i=0; i<2; i++){
1467                         int sx=mb_x*16 + 4 + 8*i;
1468                         int sy=mb_y*16 + 8;
1469                         int xy= (mb_x*2 + i + mb_y*2*mv_stride) << (mv_sample_log2-1);
1470                         int mx=(pict->motion_val[direction][xy][0]>>shift);
1471                         int my=(pict->motion_val[direction][xy][1]>>shift);
1472
1473                         if(IS_INTERLACED(pict->mb_type[mb_index]))
1474                             my*=2;
1475
1476                         draw_arrow(ptr, sx, sy, mx+sx, my+sy, width, height, s->linesize, 100);
1477                       }
1478                     }else{
1479                       int sx= mb_x*16 + 8;
1480                       int sy= mb_y*16 + 8;
1481                       int xy= (mb_x + mb_y*mv_stride) << mv_sample_log2;
1482                       int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1483                       int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1484                       draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1485                     }
1486                   }
1487                 }
1488                 if((s->avctx->debug&FF_DEBUG_VIS_QP) && pict->motion_val){
1489                     uint64_t c= (pict->qscale_table[mb_index]*128/31) * 0x0101010101010101ULL;
1490                     int y;
1491                     for(y=0; y<block_height; y++){
1492                         *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= c;
1493                         *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= c;
1494                     }
1495                 }
1496                 if((s->avctx->debug&FF_DEBUG_VIS_MB_TYPE) && pict->motion_val){
1497                     int mb_type= pict->mb_type[mb_index];
1498                     uint64_t u,v;
1499                     int y;
1500 #define COLOR(theta, r)\
1501 u= (int)(128 + r*cos(theta*3.141592/180));\
1502 v= (int)(128 + r*sin(theta*3.141592/180));
1503
1504
1505                     u=v=128;
1506                     if(IS_PCM(mb_type)){
1507                         COLOR(120,48)
1508                     }else if((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) || IS_INTRA16x16(mb_type)){
1509                         COLOR(30,48)
1510                     }else if(IS_INTRA4x4(mb_type)){
1511                         COLOR(90,48)
1512                     }else if(IS_DIRECT(mb_type) && IS_SKIP(mb_type)){
1513 //                        COLOR(120,48)
1514                     }else if(IS_DIRECT(mb_type)){
1515                         COLOR(150,48)
1516                     }else if(IS_GMC(mb_type) && IS_SKIP(mb_type)){
1517                         COLOR(170,48)
1518                     }else if(IS_GMC(mb_type)){
1519                         COLOR(190,48)
1520                     }else if(IS_SKIP(mb_type)){
1521 //                        COLOR(180,48)
1522                     }else if(!USES_LIST(mb_type, 1)){
1523                         COLOR(240,48)
1524                     }else if(!USES_LIST(mb_type, 0)){
1525                         COLOR(0,48)
1526                     }else{
1527                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1528                         COLOR(300,48)
1529                     }
1530
1531                     u*= 0x0101010101010101ULL;
1532                     v*= 0x0101010101010101ULL;
1533                     for(y=0; y<block_height; y++){
1534                         *(uint64_t*)(pict->data[1] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[1])= u;
1535                         *(uint64_t*)(pict->data[2] + 8*mb_x + (block_height*mb_y + y)*pict->linesize[2])= v;
1536                     }
1537
1538                     //segmentation
1539                     if(IS_8X8(mb_type) || IS_16X8(mb_type)){
1540                         *(uint64_t*)(pict->data[0] + 16*mb_x + 0 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1541                         *(uint64_t*)(pict->data[0] + 16*mb_x + 8 + (16*mb_y + 8)*pict->linesize[0])^= 0x8080808080808080ULL;
1542                     }
1543                     if(IS_8X8(mb_type) || IS_8X16(mb_type)){
1544                         for(y=0; y<16; y++)
1545                             pict->data[0][16*mb_x + 8 + (16*mb_y + y)*pict->linesize[0]]^= 0x80;
1546                     }
1547                     if(IS_8X8(mb_type) && mv_sample_log2 >= 2){
1548                         int dm= 1 << (mv_sample_log2-2);
1549                         for(i=0; i<4; i++){
1550                             int sx= mb_x*16 + 8*(i&1);
1551                             int sy= mb_y*16 + 8*(i>>1);
1552                             int xy= (mb_x*2 + (i&1) + (mb_y*2 + (i>>1))*mv_stride) << (mv_sample_log2-1);
1553                             //FIXME bidir
1554                             int32_t *mv = (int32_t*)&pict->motion_val[0][xy];
1555                             if(mv[0] != mv[dm] || mv[dm*mv_stride] != mv[dm*(mv_stride+1)])
1556                                 for(y=0; y<8; y++)
1557                                     pict->data[0][sx + 4 + (sy + y)*pict->linesize[0]]^= 0x80;
1558                             if(mv[0] != mv[dm*mv_stride] || mv[dm] != mv[dm*(mv_stride+1)])
1559                                 *(uint64_t*)(pict->data[0] + sx + (sy + 4)*pict->linesize[0])^= 0x8080808080808080ULL;
1560                         }
1561                     }
1562
1563                     if(IS_INTERLACED(mb_type) && s->codec_id == CODEC_ID_H264){
1564                         // hmm
1565                     }
1566                 }
1567                 s->mbskip_table[mb_index]=0;
1568             }
1569         }
1570     }
1571 }
1572
1573 static inline int hpel_motion_lowres(MpegEncContext *s,
1574                                   uint8_t *dest, uint8_t *src,
1575                                   int field_based, int field_select,
1576                                   int src_x, int src_y,
1577                                   int width, int height, int stride,
1578                                   int h_edge_pos, int v_edge_pos,
1579                                   int w, int h, h264_chroma_mc_func *pix_op,
1580                                   int motion_x, int motion_y)
1581 {
1582     const int lowres= s->avctx->lowres;
1583     const int op_index= FFMIN(lowres, 2);
1584     const int s_mask= (2<<lowres)-1;
1585     int emu=0;
1586     int sx, sy;
1587
1588     if(s->quarter_sample){
1589         motion_x/=2;
1590         motion_y/=2;
1591     }
1592
1593     sx= motion_x & s_mask;
1594     sy= motion_y & s_mask;
1595     src_x += motion_x >> (lowres+1);
1596     src_y += motion_y >> (lowres+1);
1597
1598     src += src_y * stride + src_x;
1599
1600     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - w
1601        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1602         s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w+1, (h+1)<<field_based,
1603                             src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1604         src= s->edge_emu_buffer;
1605         emu=1;
1606     }
1607
1608     sx= (sx << 2) >> lowres;
1609     sy= (sy << 2) >> lowres;
1610     if(field_select)
1611         src += s->linesize;
1612     pix_op[op_index](dest, src, stride, h, sx, sy);
1613     return emu;
1614 }
1615
1616 /* apply one mpeg motion vector to the three components */
1617 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1618                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
1619                                int field_based, int bottom_field, int field_select,
1620                                uint8_t **ref_picture, h264_chroma_mc_func *pix_op,
1621                                int motion_x, int motion_y, int h, int mb_y)
1622 {
1623     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1624     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy, uvsx, uvsy;
1625     const int lowres= s->avctx->lowres;
1626     const int op_index= FFMIN(lowres-1+s->chroma_x_shift, 2);
1627     const int block_s= 8>>lowres;
1628     const int s_mask= (2<<lowres)-1;
1629     const int h_edge_pos = s->h_edge_pos >> lowres;
1630     const int v_edge_pos = s->v_edge_pos >> lowres;
1631     linesize   = s->current_picture.linesize[0] << field_based;
1632     uvlinesize = s->current_picture.linesize[1] << field_based;
1633
1634     if(s->quarter_sample){ //FIXME obviously not perfect but qpel will not work in lowres anyway
1635         motion_x/=2;
1636         motion_y/=2;
1637     }
1638
1639     if(field_based){
1640         motion_y += (bottom_field - field_select)*((1<<lowres)-1);
1641     }
1642
1643     sx= motion_x & s_mask;
1644     sy= motion_y & s_mask;
1645     src_x = s->mb_x*2*block_s               + (motion_x >> (lowres+1));
1646     src_y =(   mb_y*2*block_s>>field_based) + (motion_y >> (lowres+1));
1647
1648     if (s->out_format == FMT_H263) {
1649         uvsx = ((motion_x>>1) & s_mask) | (sx&1);
1650         uvsy = ((motion_y>>1) & s_mask) | (sy&1);
1651         uvsrc_x = src_x>>1;
1652         uvsrc_y = src_y>>1;
1653     }else if(s->out_format == FMT_H261){//even chroma mv's are full pel in H261
1654         mx = motion_x / 4;
1655         my = motion_y / 4;
1656         uvsx = (2*mx) & s_mask;
1657         uvsy = (2*my) & s_mask;
1658         uvsrc_x = s->mb_x*block_s               + (mx >> lowres);
1659         uvsrc_y =    mb_y*block_s               + (my >> lowres);
1660     } else {
1661         if(s->chroma_y_shift){
1662             mx = motion_x / 2;
1663             my = motion_y / 2;
1664             uvsx = mx & s_mask;
1665             uvsy = my & s_mask;
1666             uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
1667             uvsrc_y =(   mb_y*block_s>>field_based) + (my >> (lowres+1));
1668         } else {
1669             if(s->chroma_x_shift){
1670             //Chroma422
1671                 mx = motion_x / 2;
1672                 uvsx = mx & s_mask;
1673                 uvsy = motion_y & s_mask;
1674                 uvsrc_y = src_y;
1675                 uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
1676             } else {
1677             //Chroma444
1678                 uvsx = motion_x & s_mask;
1679                 uvsy = motion_y & s_mask;
1680                 uvsrc_x = src_x;
1681                 uvsrc_y = src_y;
1682             }
1683         }
1684     }
1685
1686     ptr_y  = ref_picture[0] + src_y * linesize + src_x;
1687     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1688     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1689
1690     if(   (unsigned)src_x > h_edge_pos                 - (!!sx) - 2*block_s
1691        || (unsigned)src_y >(v_edge_pos >> field_based) - (!!sy) - h){
1692             s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y, s->linesize, 17, 17+field_based,
1693                              src_x, src_y<<field_based, h_edge_pos, v_edge_pos);
1694             ptr_y = s->edge_emu_buffer;
1695             if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1696                 uint8_t *uvbuf= s->edge_emu_buffer+18*s->linesize;
1697                 s->dsp.emulated_edge_mc(uvbuf  , ptr_cb, s->uvlinesize, 9, 9+field_based,
1698                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1699                 s->dsp.emulated_edge_mc(uvbuf+16, ptr_cr, s->uvlinesize, 9, 9+field_based,
1700                                  uvsrc_x, uvsrc_y<<field_based, h_edge_pos>>1, v_edge_pos>>1);
1701                 ptr_cb= uvbuf;
1702                 ptr_cr= uvbuf+16;
1703             }
1704     }
1705
1706     if(bottom_field){ //FIXME use this for field pix too instead of the obnoxious hack which changes picture.data
1707         dest_y += s->linesize;
1708         dest_cb+= s->uvlinesize;
1709         dest_cr+= s->uvlinesize;
1710     }
1711
1712     if(field_select){
1713         ptr_y += s->linesize;
1714         ptr_cb+= s->uvlinesize;
1715         ptr_cr+= s->uvlinesize;
1716     }
1717
1718     sx= (sx << 2) >> lowres;
1719     sy= (sy << 2) >> lowres;
1720     pix_op[lowres-1](dest_y, ptr_y, linesize, h, sx, sy);
1721
1722     if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
1723         uvsx= (uvsx << 2) >> lowres;
1724         uvsy= (uvsy << 2) >> lowres;
1725         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         if (y==0) sides |= EDGE_TOP;
2298         if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2299
2300         edge_h= FFMIN(h, s->v_edge_pos - y);
2301
2302         s->dsp.draw_edges(s->current_picture_ptr->data[0] +  y    *s->linesize  , s->linesize  , s->h_edge_pos   , edge_h   , EDGE_WIDTH  , sides);
2303         s->dsp.draw_edges(s->current_picture_ptr->data[1] + (y>>1)*s->uvlinesize, s->uvlinesize, s->h_edge_pos>>1, edge_h>>1, EDGE_WIDTH/2, sides);
2304         s->dsp.draw_edges(s->current_picture_ptr->data[2] + (y>>1)*s->uvlinesize, s->uvlinesize, s->h_edge_pos>>1, edge_h>>1, EDGE_WIDTH/2, sides);
2305     }
2306
2307     h= FFMIN(h, s->avctx->height - y);
2308
2309     if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2310
2311     if (s->avctx->draw_horiz_band) {
2312         AVFrame *src;
2313         int offset[4];
2314
2315         if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2316             src= (AVFrame*)s->current_picture_ptr;
2317         else if(s->last_picture_ptr)
2318             src= (AVFrame*)s->last_picture_ptr;
2319         else
2320             return;
2321
2322         if(s->pict_type==AV_PICTURE_TYPE_B && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2323             offset[0]=
2324             offset[1]=
2325             offset[2]=
2326             offset[3]= 0;
2327         }else{
2328             offset[0]= y * s->linesize;
2329             offset[1]=
2330             offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2331             offset[3]= 0;
2332         }
2333
2334         emms_c();
2335
2336         s->avctx->draw_horiz_band(s->avctx, src, offset,
2337                                   y, s->picture_structure, h);
2338     }
2339 }
2340
2341 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2342     const int linesize= s->current_picture.linesize[0]; //not s->linesize as this would be wrong for field pics
2343     const int uvlinesize= s->current_picture.linesize[1];
2344     const int mb_size= 4 - s->avctx->lowres;
2345
2346     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2347     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2348     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2349     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2350     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2351     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;
2352     //block_index is not used by mpeg2, so it is not affected by chroma_format
2353
2354     s->dest[0] = s->current_picture.data[0] + ((s->mb_x - 1) << mb_size);
2355     s->dest[1] = s->current_picture.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2356     s->dest[2] = s->current_picture.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2357
2358     if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2359     {
2360         if(s->picture_structure==PICT_FRAME){
2361         s->dest[0] += s->mb_y *   linesize << mb_size;
2362         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2363         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2364         }else{
2365             s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
2366             s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2367             s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2368             assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2369         }
2370     }
2371 }
2372
2373 void ff_mpeg_flush(AVCodecContext *avctx){
2374     int i;
2375     MpegEncContext *s = avctx->priv_data;
2376
2377     if(s==NULL || s->picture==NULL)
2378         return;
2379
2380     for(i=0; i<s->picture_count; i++){
2381        if(s->picture[i].data[0] && (   s->picture[i].type == FF_BUFFER_TYPE_INTERNAL
2382                                     || s->picture[i].type == FF_BUFFER_TYPE_USER))
2383         free_frame_buffer(s, &s->picture[i]);
2384     }
2385     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2386
2387     s->mb_x= s->mb_y= 0;
2388     s->closed_gop= 0;
2389
2390     s->parse_context.state= -1;
2391     s->parse_context.frame_start_found= 0;
2392     s->parse_context.overread= 0;
2393     s->parse_context.overread_index= 0;
2394     s->parse_context.index= 0;
2395     s->parse_context.last_index= 0;
2396     s->bitstream_buffer_size=0;
2397     s->pp_time=0;
2398 }
2399
2400 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2401                                    DCTELEM *block, int n, int qscale)
2402 {
2403     int i, level, nCoeffs;
2404     const uint16_t *quant_matrix;
2405
2406     nCoeffs= s->block_last_index[n];
2407
2408     if (n < 4)
2409         block[0] = block[0] * s->y_dc_scale;
2410     else
2411         block[0] = block[0] * s->c_dc_scale;
2412     /* XXX: only mpeg1 */
2413     quant_matrix = s->intra_matrix;
2414     for(i=1;i<=nCoeffs;i++) {
2415         int j= s->intra_scantable.permutated[i];
2416         level = block[j];
2417         if (level) {
2418             if (level < 0) {
2419                 level = -level;
2420                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2421                 level = (level - 1) | 1;
2422                 level = -level;
2423             } else {
2424                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2425                 level = (level - 1) | 1;
2426             }
2427             block[j] = level;
2428         }
2429     }
2430 }
2431
2432 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2433                                    DCTELEM *block, int n, int qscale)
2434 {
2435     int i, level, nCoeffs;
2436     const uint16_t *quant_matrix;
2437
2438     nCoeffs= s->block_last_index[n];
2439
2440     quant_matrix = s->inter_matrix;
2441     for(i=0; i<=nCoeffs; i++) {
2442         int j= s->intra_scantable.permutated[i];
2443         level = block[j];
2444         if (level) {
2445             if (level < 0) {
2446                 level = -level;
2447                 level = (((level << 1) + 1) * qscale *
2448                          ((int) (quant_matrix[j]))) >> 4;
2449                 level = (level - 1) | 1;
2450                 level = -level;
2451             } else {
2452                 level = (((level << 1) + 1) * qscale *
2453                          ((int) (quant_matrix[j]))) >> 4;
2454                 level = (level - 1) | 1;
2455             }
2456             block[j] = level;
2457         }
2458     }
2459 }
2460
2461 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2462                                    DCTELEM *block, int n, int qscale)
2463 {
2464     int i, level, nCoeffs;
2465     const uint16_t *quant_matrix;
2466
2467     if(s->alternate_scan) nCoeffs= 63;
2468     else nCoeffs= s->block_last_index[n];
2469
2470     if (n < 4)
2471         block[0] = block[0] * s->y_dc_scale;
2472     else
2473         block[0] = block[0] * s->c_dc_scale;
2474     quant_matrix = s->intra_matrix;
2475     for(i=1;i<=nCoeffs;i++) {
2476         int j= s->intra_scantable.permutated[i];
2477         level = block[j];
2478         if (level) {
2479             if (level < 0) {
2480                 level = -level;
2481                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2482                 level = -level;
2483             } else {
2484                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2485             }
2486             block[j] = level;
2487         }
2488     }
2489 }
2490
2491 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2492                                    DCTELEM *block, int n, int qscale)
2493 {
2494     int i, level, nCoeffs;
2495     const uint16_t *quant_matrix;
2496     int sum=-1;
2497
2498     if(s->alternate_scan) nCoeffs= 63;
2499     else nCoeffs= s->block_last_index[n];
2500
2501     if (n < 4)
2502         block[0] = block[0] * s->y_dc_scale;
2503     else
2504         block[0] = block[0] * s->c_dc_scale;
2505     quant_matrix = s->intra_matrix;
2506     for(i=1;i<=nCoeffs;i++) {
2507         int j= s->intra_scantable.permutated[i];
2508         level = block[j];
2509         if (level) {
2510             if (level < 0) {
2511                 level = -level;
2512                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2513                 level = -level;
2514             } else {
2515                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2516             }
2517             block[j] = level;
2518             sum+=level;
2519         }
2520     }
2521     block[63]^=sum&1;
2522 }
2523
2524 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2525                                    DCTELEM *block, int n, int qscale)
2526 {
2527     int i, level, nCoeffs;
2528     const uint16_t *quant_matrix;
2529     int sum=-1;
2530
2531     if(s->alternate_scan) nCoeffs= 63;
2532     else nCoeffs= s->block_last_index[n];
2533
2534     quant_matrix = s->inter_matrix;
2535     for(i=0; i<=nCoeffs; i++) {
2536         int j= s->intra_scantable.permutated[i];
2537         level = block[j];
2538         if (level) {
2539             if (level < 0) {
2540                 level = -level;
2541                 level = (((level << 1) + 1) * qscale *
2542                          ((int) (quant_matrix[j]))) >> 4;
2543                 level = -level;
2544             } else {
2545                 level = (((level << 1) + 1) * qscale *
2546                          ((int) (quant_matrix[j]))) >> 4;
2547             }
2548             block[j] = level;
2549             sum+=level;
2550         }
2551     }
2552     block[63]^=sum&1;
2553 }
2554
2555 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2556                                   DCTELEM *block, int n, int qscale)
2557 {
2558     int i, level, qmul, qadd;
2559     int nCoeffs;
2560
2561     assert(s->block_last_index[n]>=0);
2562
2563     qmul = qscale << 1;
2564
2565     if (!s->h263_aic) {
2566         if (n < 4)
2567             block[0] = block[0] * s->y_dc_scale;
2568         else
2569             block[0] = block[0] * s->c_dc_scale;
2570         qadd = (qscale - 1) | 1;
2571     }else{
2572         qadd = 0;
2573     }
2574     if(s->ac_pred)
2575         nCoeffs=63;
2576     else
2577         nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2578
2579     for(i=1; i<=nCoeffs; i++) {
2580         level = block[i];
2581         if (level) {
2582             if (level < 0) {
2583                 level = level * qmul - qadd;
2584             } else {
2585                 level = level * qmul + qadd;
2586             }
2587             block[i] = level;
2588         }
2589     }
2590 }
2591
2592 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2593                                   DCTELEM *block, int n, int qscale)
2594 {
2595     int i, level, qmul, qadd;
2596     int nCoeffs;
2597
2598     assert(s->block_last_index[n]>=0);
2599
2600     qadd = (qscale - 1) | 1;
2601     qmul = qscale << 1;
2602
2603     nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2604
2605     for(i=0; i<=nCoeffs; i++) {
2606         level = block[i];
2607         if (level) {
2608             if (level < 0) {
2609                 level = level * qmul - qadd;
2610             } else {
2611                 level = level * qmul + qadd;
2612             }
2613             block[i] = level;
2614         }
2615     }
2616 }
2617
2618 /**
2619  * set qscale and update qscale dependent variables.
2620  */
2621 void ff_set_qscale(MpegEncContext * s, int qscale)
2622 {
2623     if (qscale < 1)
2624         qscale = 1;
2625     else if (qscale > 31)
2626         qscale = 31;
2627
2628     s->qscale = qscale;
2629     s->chroma_qscale= s->chroma_qscale_table[qscale];
2630
2631     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2632     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2633 }
2634
2635 void MPV_report_decode_progress(MpegEncContext *s)
2636 {
2637     if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame)
2638         ff_thread_report_progress((AVFrame*)s->current_picture_ptr, s->mb_y, 0);
2639 }