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