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

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