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