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

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