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

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