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