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