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

   1 /*
   2  * The simplest mpeg encoder (well, it was the simplest!)
   3  * Copyright (c) 2000,2001 Fabrice Bellard
   4  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
   5  *
   6  * 4MV & hq & B-frame encoding stuff by Michael Niedermayer <michaelni@gmx.at>
   7  *
   8  * This file is part of FFmpeg.
   9  *
  10  * FFmpeg is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * FFmpeg is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with FFmpeg; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  23  */
  24
  25 /**
  26  * @file
  27  * The simplest mpeg encoder (well, it was the simplest!).
  28  */
  29
  30 #include "libavutil/avassert.h"
  31 #include "libavutil/imgutils.h"
  32 #include "avcodec.h"
  33 #include "dsputil.h"
  34 #include "h264chroma.h"
  35 #include "internal.h"
  36 #include "mathops.h"
  37 #include "mpegvideo.h"
  38 #include "mjpegenc.h"
  39 #include "msmpeg4.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                                    int16_t *block, int n, int qscale);
  49 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
  50                                    int16_t *block, int n, int qscale);
  51 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
  52                                    int16_t *block, int n, int qscale);
  53 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
  54                                    int16_t *block, int n, int qscale);
  55 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
  56                                    int16_t *block, int n, int qscale);
  57 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
  58                                   int16_t *block, int n, int qscale);
  59 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
  60                                   int16_t *block, int n, int qscale);
  61
  62
  63 //#define DEBUG
  64
  65
  66 static const uint8_t ff_default_chroma_qscale_table[32] = {
  67 //   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15
  68      0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
  69     16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
  70 };
  71
  72 const uint8_t ff_mpeg1_dc_scale_table[128] = {
  73 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
  74     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  75     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  76     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  77     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  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 };
  83
  84 static const uint8_t mpeg2_dc_scale_table1[128] = {
  85 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
  86     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  87     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  88     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  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 };
  95
  96 static const uint8_t mpeg2_dc_scale_table2[128] = {
  97 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
  98     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  99     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 100     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 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 };
 107
 108 static const uint8_t mpeg2_dc_scale_table3[128] = {
 109 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
 110     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 111     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 112     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 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 };
 119
 120 const uint8_t *const ff_mpeg2_dc_scale_table[4] = {
 121     ff_mpeg1_dc_scale_table,
 122     mpeg2_dc_scale_table1,
 123     mpeg2_dc_scale_table2,
 124     mpeg2_dc_scale_table3,
 125 };
 126
 127 const enum AVPixelFormat ff_pixfmt_list_420[] = {
 128     AV_PIX_FMT_YUV420P,
 129     AV_PIX_FMT_NONE
 130 };
 131
 132 static void mpeg_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type,
 133                               int (*mv)[2][4][2],
 134                               int mb_x, int mb_y, int mb_intra, int mb_skipped)
 135 {
 136     MpegEncContext *s = opaque;
 137
 138     s->mv_dir     = mv_dir;
 139     s->mv_type    = mv_type;
 140     s->mb_intra   = mb_intra;
 141     s->mb_skipped = mb_skipped;
 142     s->mb_x       = mb_x;
 143     s->mb_y       = mb_y;
 144     memcpy(s->mv, mv, sizeof(*mv));
 145
 146     ff_init_block_index(s);
 147     ff_update_block_index(s);
 148
 149     s->dsp.clear_blocks(s->block[0]);
 150
 151     s->dest[0] = s->current_picture.f.data[0] + (s->mb_y *  16                       * s->linesize)   + s->mb_x *  16;
 152     s->dest[1] = s->current_picture.f.data[1] + (s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16 >> s->chroma_x_shift);
 153     s->dest[2] = s->current_picture.f.data[2] + (s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16 >> s->chroma_x_shift);
 154
 155     assert(ref == 0);
 156     ff_MPV_decode_mb(s, s->block);
 157 }
 158
 159 /* init common dct for both encoder and decoder */
 160 av_cold int ff_dct_common_init(MpegEncContext *s)
 161 {
 162     ff_dsputil_init(&s->dsp, s->avctx);
 163     ff_h264chroma_init(&s->h264chroma, 8); //for lowres
 164     ff_hpeldsp_init(&s->hdsp, s->avctx->flags);
 165     ff_videodsp_init(&s->vdsp, s->avctx->bits_per_raw_sample);
 166
 167     s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
 168     s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
 169     s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
 170     s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
 171     s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
 172     if (s->flags & CODEC_FLAG_BITEXACT)
 173         s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
 174     s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
 175
 176 #if ARCH_X86
 177     ff_MPV_common_init_x86(s);
 178 #elif ARCH_ALPHA
 179     ff_MPV_common_init_axp(s);
 180 #elif ARCH_ARM
 181     ff_MPV_common_init_arm(s);
 182 #elif ARCH_BFIN
 183     ff_MPV_common_init_bfin(s);
 184 #elif ARCH_PPC
 185     ff_MPV_common_init_ppc(s);
 186 #endif
 187
 188     /* load & permutate scantables
 189      * note: only wmv uses different ones
 190      */
 191     if (s->alternate_scan) {
 192         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
 193         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
 194     } else {
 195         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
 196         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
 197     }
 198     ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
 199     ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
 200
 201     return 0;
 202 }
 203
 204 int ff_mpv_frame_size_alloc(MpegEncContext *s, int linesize)
 205 {
 206     int alloc_size = FFALIGN(FFABS(linesize) + 64, 32);
 207
 208     // edge emu needs blocksize + filter length - 1
 209     // (= 17x17 for  halfpel / 21x21 for  h264)
 210     // VC1 computes luma and chroma simultaneously and needs 19X19 + 9x9
 211     // at uvlinesize. It supports only YUV420 so 24x24 is enough
 212     // linesize * interlaced * MBsize
 213     FF_ALLOCZ_OR_GOTO(s->avctx, s->edge_emu_buffer, alloc_size * 4 * 24,
 214                       fail);
 215
 216     FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad, alloc_size * 4 * 16 * 2,
 217                       fail)
 218     s->me.temp         = s->me.scratchpad;
 219     s->rd_scratchpad   = s->me.scratchpad;
 220     s->b_scratchpad    = s->me.scratchpad;
 221     s->obmc_scratchpad = s->me.scratchpad + 16;
 222
 223     return 0;
 224 fail:
 225     av_freep(&s->edge_emu_buffer);
 226     return AVERROR(ENOMEM);
 227 }
 228
 229 /**
 230  * Allocate a frame buffer
 231  */
 232 static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
 233 {
 234     int r, ret;
 235
 236     pic->tf.f = &pic->f;
 237     if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
 238         s->codec_id != AV_CODEC_ID_VC1IMAGE  &&
 239         s->codec_id != AV_CODEC_ID_MSS2)
 240         r = ff_thread_get_buffer(s->avctx, &pic->tf,
 241                                  pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
 242     else {
 243         pic->f.width  = s->avctx->width;
 244         pic->f.height = s->avctx->height;
 245         pic->f.format = s->avctx->pix_fmt;
 246         r = avcodec_default_get_buffer2(s->avctx, &pic->f, 0);
 247     }
 248
 249     if (r < 0 || !pic->f.data[0]) {
 250         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %p)\n",
 251                r, pic->f.data[0]);
 252         return -1;
 253     }
 254
 255     if (s->avctx->hwaccel) {
 256         assert(!pic->hwaccel_picture_private);
 257         if (s->avctx->hwaccel->priv_data_size) {
 258             pic->hwaccel_priv_buf = av_buffer_allocz(s->avctx->hwaccel->priv_data_size);
 259             if (!pic->hwaccel_priv_buf) {
 260                 av_log(s->avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
 261                 return -1;
 262             }
 263             pic->hwaccel_picture_private = pic->hwaccel_priv_buf->data;
 264         }
 265     }
 266
 267     if (s->linesize && (s->linesize   != pic->f.linesize[0] ||
 268                         s->uvlinesize != pic->f.linesize[1])) {
 269         av_log(s->avctx, AV_LOG_ERROR,
 270                "get_buffer() failed (stride changed)\n");
 271         ff_mpeg_unref_picture(s, pic);
 272         return -1;
 273     }
 274
 275     if (pic->f.linesize[1] != pic->f.linesize[2]) {
 276         av_log(s->avctx, AV_LOG_ERROR,
 277                "get_buffer() failed (uv stride mismatch)\n");
 278         ff_mpeg_unref_picture(s, pic);
 279         return -1;
 280     }
 281
 282     if (!s->edge_emu_buffer &&
 283         (ret = ff_mpv_frame_size_alloc(s, pic->f.linesize[0])) < 0) {
 284         av_log(s->avctx, AV_LOG_ERROR,
 285                "get_buffer() failed to allocate context scratch buffers.\n");
 286         ff_mpeg_unref_picture(s, pic);
 287         return ret;
 288     }
 289
 290     return 0;
 291 }
 292
 293 static void free_picture_tables(Picture *pic)
 294 {
 295     int i;
 296
 297     pic->alloc_mb_width  =
 298     pic->alloc_mb_height = 0;
 299
 300     av_buffer_unref(&pic->mb_var_buf);
 301     av_buffer_unref(&pic->mc_mb_var_buf);
 302     av_buffer_unref(&pic->mb_mean_buf);
 303     av_buffer_unref(&pic->mbskip_table_buf);
 304     av_buffer_unref(&pic->qscale_table_buf);
 305     av_buffer_unref(&pic->mb_type_buf);
 306
 307     for (i = 0; i < 2; i++) {
 308         av_buffer_unref(&pic->motion_val_buf[i]);
 309         av_buffer_unref(&pic->ref_index_buf[i]);
 310     }
 311 }
 312
 313 static int alloc_picture_tables(MpegEncContext *s, Picture *pic)
 314 {
 315     const int big_mb_num    = s->mb_stride * (s->mb_height + 1) + 1;
 316     const int mb_array_size = s->mb_stride * s->mb_height;
 317     const int b8_array_size = s->b8_stride * s->mb_height * 2;
 318     int i;
 319
 320
 321     pic->mbskip_table_buf = av_buffer_allocz(mb_array_size + 2);
 322     pic->qscale_table_buf = av_buffer_allocz(big_mb_num + s->mb_stride);
 323     pic->mb_type_buf      = av_buffer_allocz((big_mb_num + s->mb_stride) *
 324                                              sizeof(uint32_t));
 325     if (!pic->mbskip_table_buf || !pic->qscale_table_buf || !pic->mb_type_buf)
 326         return AVERROR(ENOMEM);
 327
 328     if (s->encoding) {
 329         pic->mb_var_buf    = av_buffer_allocz(mb_array_size * sizeof(int16_t));
 330         pic->mc_mb_var_buf = av_buffer_allocz(mb_array_size * sizeof(int16_t));
 331         pic->mb_mean_buf   = av_buffer_allocz(mb_array_size);
 332         if (!pic->mb_var_buf || !pic->mc_mb_var_buf || !pic->mb_mean_buf)
 333             return AVERROR(ENOMEM);
 334     }
 335
 336     if (s->out_format == FMT_H263 || s->encoding ||
 337                (s->avctx->debug & FF_DEBUG_MV) || s->avctx->debug_mv) {
 338         int mv_size        = 2 * (b8_array_size + 4) * sizeof(int16_t);
 339         int ref_index_size = 4 * mb_array_size;
 340
 341         for (i = 0; mv_size && i < 2; i++) {
 342             pic->motion_val_buf[i] = av_buffer_allocz(mv_size);
 343             pic->ref_index_buf[i]  = av_buffer_allocz(ref_index_size);
 344             if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i])
 345                 return AVERROR(ENOMEM);
 346         }
 347     }
 348
 349     pic->alloc_mb_width  = s->mb_width;
 350     pic->alloc_mb_height = s->mb_height;
 351
 352     return 0;
 353 }
 354
 355 static int make_tables_writable(Picture *pic)
 356 {
 357     int ret, i;
 358 #define MAKE_WRITABLE(table) \
 359 do {\
 360     if (pic->table &&\
 361        (ret = av_buffer_make_writable(&pic->table)) < 0)\
 362     return ret;\
 363 } while (0)
 364
 365     MAKE_WRITABLE(mb_var_buf);
 366     MAKE_WRITABLE(mc_mb_var_buf);
 367     MAKE_WRITABLE(mb_mean_buf);
 368     MAKE_WRITABLE(mbskip_table_buf);
 369     MAKE_WRITABLE(qscale_table_buf);
 370     MAKE_WRITABLE(mb_type_buf);
 371
 372     for (i = 0; i < 2; i++) {
 373         MAKE_WRITABLE(motion_val_buf[i]);
 374         MAKE_WRITABLE(ref_index_buf[i]);
 375     }
 376
 377     return 0;
 378 }
 379
 380 /**
 381  * Allocate a Picture.
 382  * The pixels are allocated/set by calling get_buffer() if shared = 0
 383  */
 384 int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared)
 385 {
 386     int i, ret;
 387
 388     if (pic->qscale_table_buf)
 389         if (   pic->alloc_mb_width  != s->mb_width
 390             || pic->alloc_mb_height != s->mb_height)
 391             free_picture_tables(pic);
 392
 393     if (shared) {
 394         assert(pic->f.data[0]);
 395         pic->shared = 1;
 396     } else {
 397         assert(!pic->f.data[0]);
 398
 399         if (alloc_frame_buffer(s, pic) < 0)
 400             return -1;
 401
 402         s->linesize   = pic->f.linesize[0];
 403         s->uvlinesize = pic->f.linesize[1];
 404     }
 405
 406     if (!pic->qscale_table_buf)
 407         ret = alloc_picture_tables(s, pic);
 408     else
 409         ret = make_tables_writable(pic);
 410     if (ret < 0)
 411         goto fail;
 412
 413     if (s->encoding) {
 414         pic->mb_var    = (uint16_t*)pic->mb_var_buf->data;
 415         pic->mc_mb_var = (uint16_t*)pic->mc_mb_var_buf->data;
 416         pic->mb_mean   = pic->mb_mean_buf->data;
 417     }
 418
 419     pic->mbskip_table = pic->mbskip_table_buf->data;
 420     pic->qscale_table = pic->qscale_table_buf->data + 2 * s->mb_stride + 1;
 421     pic->mb_type      = (uint32_t*)pic->mb_type_buf->data + 2 * s->mb_stride + 1;
 422
 423     if (pic->motion_val_buf[0]) {
 424         for (i = 0; i < 2; i++) {
 425             pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
 426             pic->ref_index[i]  = pic->ref_index_buf[i]->data;
 427         }
 428     }
 429
 430     return 0;
 431 fail:
 432     av_log(s->avctx, AV_LOG_ERROR, "Error allocating a picture.\n");
 433     ff_mpeg_unref_picture(s, pic);
 434     free_picture_tables(pic);
 435     return AVERROR(ENOMEM);
 436 }
 437
 438 /**
 439  * Deallocate a picture.
 440  */
 441 void ff_mpeg_unref_picture(MpegEncContext *s, Picture *pic)
 442 {
 443     int off = offsetof(Picture, mb_mean) + sizeof(pic->mb_mean);
 444
 445     pic->tf.f = &pic->f;
 446     /* WM Image / Screen codecs allocate internal buffers with different
 447      * dimensions / colorspaces; ignore user-defined callbacks for these. */
 448     if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
 449         s->codec_id != AV_CODEC_ID_VC1IMAGE  &&
 450         s->codec_id != AV_CODEC_ID_MSS2)
 451         ff_thread_release_buffer(s->avctx, &pic->tf);
 452     else
 453         av_frame_unref(&pic->f);
 454
 455     av_buffer_unref(&pic->hwaccel_priv_buf);
 456
 457     memset((uint8_t*)pic + off, 0, sizeof(*pic) - off);
 458 }
 459
 460 static int update_picture_tables(Picture *dst, Picture *src)
 461 {
 462      int i;
 463
 464 #define UPDATE_TABLE(table)\
 465 do {\
 466     if (src->table &&\
 467         (!dst->table || dst->table->buffer != src->table->buffer)) {\
 468         av_buffer_unref(&dst->table);\
 469         dst->table = av_buffer_ref(src->table);\
 470         if (!dst->table) {\
 471             free_picture_tables(dst);\
 472             return AVERROR(ENOMEM);\
 473         }\
 474     }\
 475 } while (0)
 476
 477     UPDATE_TABLE(mb_var_buf);
 478     UPDATE_TABLE(mc_mb_var_buf);
 479     UPDATE_TABLE(mb_mean_buf);
 480     UPDATE_TABLE(mbskip_table_buf);
 481     UPDATE_TABLE(qscale_table_buf);
 482     UPDATE_TABLE(mb_type_buf);
 483     for (i = 0; i < 2; i++) {
 484         UPDATE_TABLE(motion_val_buf[i]);
 485         UPDATE_TABLE(ref_index_buf[i]);
 486     }
 487
 488     dst->mb_var        = src->mb_var;
 489     dst->mc_mb_var     = src->mc_mb_var;
 490     dst->mb_mean       = src->mb_mean;
 491     dst->mbskip_table  = src->mbskip_table;
 492     dst->qscale_table  = src->qscale_table;
 493     dst->mb_type       = src->mb_type;
 494     for (i = 0; i < 2; i++) {
 495         dst->motion_val[i] = src->motion_val[i];
 496         dst->ref_index[i]  = src->ref_index[i];
 497     }
 498
 499     dst->alloc_mb_width  = src->alloc_mb_width;
 500     dst->alloc_mb_height = src->alloc_mb_height;
 501
 502     return 0;
 503 }
 504
 505 int ff_mpeg_ref_picture(MpegEncContext *s, Picture *dst, Picture *src)
 506 {
 507     int ret;
 508
 509     av_assert0(!dst->f.buf[0]);
 510     av_assert0(src->f.buf[0]);
 511
 512     src->tf.f = &src->f;
 513     dst->tf.f = &dst->f;
 514     ret = ff_thread_ref_frame(&dst->tf, &src->tf);
 515     if (ret < 0)
 516         goto fail;
 517
 518     ret = update_picture_tables(dst, src);
 519     if (ret < 0)
 520         goto fail;
 521
 522     if (src->hwaccel_picture_private) {
 523         dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
 524         if (!dst->hwaccel_priv_buf)
 525             goto fail;
 526         dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
 527     }
 528
 529     dst->field_picture           = src->field_picture;
 530     dst->mb_var_sum              = src->mb_var_sum;
 531     dst->mc_mb_var_sum           = src->mc_mb_var_sum;
 532     dst->b_frame_score           = src->b_frame_score;
 533     dst->needs_realloc           = src->needs_realloc;
 534     dst->reference               = src->reference;
 535     dst->shared                  = src->shared;
 536
 537     return 0;
 538 fail:
 539     ff_mpeg_unref_picture(s, dst);
 540     return ret;
 541 }
 542
 543 static int init_duplicate_context(MpegEncContext *s)
 544 {
 545     int y_size = s->b8_stride * (2 * s->mb_height + 1);
 546     int c_size = s->mb_stride * (s->mb_height + 1);
 547     int yc_size = y_size + 2 * c_size;
 548     int i;
 549
 550     s->edge_emu_buffer =
 551     s->me.scratchpad   =
 552     s->me.temp         =
 553     s->rd_scratchpad   =
 554     s->b_scratchpad    =
 555     s->obmc_scratchpad = NULL;
 556
 557     if (s->encoding) {
 558         FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map,
 559                           ME_MAP_SIZE * sizeof(uint32_t), fail)
 560         FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map,
 561                           ME_MAP_SIZE * sizeof(uint32_t), fail)
 562         if (s->avctx->noise_reduction) {
 563             FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum,
 564                               2 * 64 * sizeof(int), fail)
 565         }
 566     }
 567     FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64 * 12 * 2 * sizeof(int16_t), fail)
 568     s->block = s->blocks[0];
 569
 570     for (i = 0; i < 12; i++) {
 571         s->pblocks[i] = &s->block[i];
 572     }
 573
 574     if (s->out_format == FMT_H263) {
 575         /* ac values */
 576         FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base,
 577                           yc_size * sizeof(int16_t) * 16, fail);
 578         s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
 579         s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
 580         s->ac_val[2] = s->ac_val[1] + c_size;
 581     }
 582
 583     return 0;
 584 fail:
 585     return -1; // free() through ff_MPV_common_end()
 586 }
 587
 588 static void free_duplicate_context(MpegEncContext *s)
 589 {
 590     if (s == NULL)
 591         return;
 592
 593     av_freep(&s->edge_emu_buffer);
 594     av_freep(&s->me.scratchpad);
 595     s->me.temp =
 596     s->rd_scratchpad =
 597     s->b_scratchpad =
 598     s->obmc_scratchpad = NULL;
 599
 600     av_freep(&s->dct_error_sum);
 601     av_freep(&s->me.map);
 602     av_freep(&s->me.score_map);
 603     av_freep(&s->blocks);
 604     av_freep(&s->ac_val_base);
 605     s->block = NULL;
 606 }
 607
 608 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
 609 {
 610 #define COPY(a) bak->a = src->a
 611     COPY(edge_emu_buffer);
 612     COPY(me.scratchpad);
 613     COPY(me.temp);
 614     COPY(rd_scratchpad);
 615     COPY(b_scratchpad);
 616     COPY(obmc_scratchpad);
 617     COPY(me.map);
 618     COPY(me.score_map);
 619     COPY(blocks);
 620     COPY(block);
 621     COPY(start_mb_y);
 622     COPY(end_mb_y);
 623     COPY(me.map_generation);
 624     COPY(pb);
 625     COPY(dct_error_sum);
 626     COPY(dct_count[0]);
 627     COPY(dct_count[1]);
 628     COPY(ac_val_base);
 629     COPY(ac_val[0]);
 630     COPY(ac_val[1]);
 631     COPY(ac_val[2]);
 632 #undef COPY
 633 }
 634
 635 int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
 636 {
 637     MpegEncContext bak;
 638     int i, ret;
 639     // FIXME copy only needed parts
 640     // START_TIMER
 641     backup_duplicate_context(&bak, dst);
 642     memcpy(dst, src, sizeof(MpegEncContext));
 643     backup_duplicate_context(dst, &bak);
 644     for (i = 0; i < 12; i++) {
 645         dst->pblocks[i] = &dst->block[i];
 646     }
 647     if (!dst->edge_emu_buffer &&
 648         (ret = ff_mpv_frame_size_alloc(dst, dst->linesize)) < 0) {
 649         av_log(dst->avctx, AV_LOG_ERROR, "failed to allocate context "
 650                "scratch buffers.\n");
 651         return ret;
 652     }
 653     // STOP_TIMER("update_duplicate_context")
 654     // about 10k cycles / 0.01 sec for  1000frames on 1ghz with 2 threads
 655     return 0;
 656 }
 657
 658 int ff_mpeg_update_thread_context(AVCodecContext *dst,
 659                                   const AVCodecContext *src)
 660 {
 661     int i, ret;
 662     MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
 663
 664     if (dst == src)
 665         return 0;
 666
 667     av_assert0(s != s1);
 668
 669     // FIXME can parameters change on I-frames?
 670     // in that case dst may need a reinit
 671     if (!s->context_initialized) {
 672         memcpy(s, s1, sizeof(MpegEncContext));
 673
 674         s->avctx                 = dst;
 675         s->bitstream_buffer      = NULL;
 676         s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
 677
 678         if (s1->context_initialized){
 679 //             s->picture_range_start  += MAX_PICTURE_COUNT;
 680 //             s->picture_range_end    += MAX_PICTURE_COUNT;
 681             if((ret = ff_MPV_common_init(s)) < 0){
 682                 memset(s, 0, sizeof(MpegEncContext));
 683                 s->avctx = dst;
 684                 return ret;
 685             }
 686         }
 687     }
 688
 689     if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
 690         s->context_reinit = 0;
 691         s->height = s1->height;
 692         s->width  = s1->width;
 693         if ((ret = ff_MPV_common_frame_size_change(s)) < 0)
 694             return ret;
 695     }
 696
 697     s->avctx->coded_height  = s1->avctx->coded_height;
 698     s->avctx->coded_width   = s1->avctx->coded_width;
 699     s->avctx->width         = s1->avctx->width;
 700     s->avctx->height        = s1->avctx->height;
 701
 702     s->coded_picture_number = s1->coded_picture_number;
 703     s->picture_number       = s1->picture_number;
 704     s->input_picture_number = s1->input_picture_number;
 705
 706     av_assert0(!s->picture || s->picture != s1->picture);
 707     if(s->picture)
 708     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
 709         ff_mpeg_unref_picture(s, &s->picture[i]);
 710         if (s1->picture[i].f.data[0] &&
 711             (ret = ff_mpeg_ref_picture(s, &s->picture[i], &s1->picture[i])) < 0)
 712             return ret;
 713     }
 714
 715 #define UPDATE_PICTURE(pic)\
 716 do {\
 717     ff_mpeg_unref_picture(s, &s->pic);\
 718     if (s1->pic.f.data[0])\
 719         ret = ff_mpeg_ref_picture(s, &s->pic, &s1->pic);\
 720     else\
 721         ret = update_picture_tables(&s->pic, &s1->pic);\
 722     if (ret < 0)\
 723         return ret;\
 724 } while (0)
 725
 726     UPDATE_PICTURE(current_picture);
 727     UPDATE_PICTURE(last_picture);
 728     UPDATE_PICTURE(next_picture);
 729
 730     s->last_picture_ptr    = REBASE_PICTURE(s1->last_picture_ptr,    s, s1);
 731     s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
 732     s->next_picture_ptr    = REBASE_PICTURE(s1->next_picture_ptr,    s, s1);
 733
 734     // Error/bug resilience
 735     s->next_p_frame_damaged = s1->next_p_frame_damaged;
 736     s->workaround_bugs      = s1->workaround_bugs;
 737     s->padding_bug_score    = s1->padding_bug_score;
 738
 739     // MPEG4 timing info
 740     memcpy(&s->time_increment_bits, &s1->time_increment_bits,
 741            (char *) &s1->shape - (char *) &s1->time_increment_bits);
 742
 743     // B-frame info
 744     s->max_b_frames = s1->max_b_frames;
 745     s->low_delay    = s1->low_delay;
 746     s->droppable    = s1->droppable;
 747
 748     // DivX handling (doesn't work)
 749     s->divx_packed  = s1->divx_packed;
 750
 751     if (s1->bitstream_buffer) {
 752         if (s1->bitstream_buffer_size +
 753             FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
 754             av_fast_malloc(&s->bitstream_buffer,
 755                            &s->allocated_bitstream_buffer_size,
 756                            s1->allocated_bitstream_buffer_size);
 757             s->bitstream_buffer_size = s1->bitstream_buffer_size;
 758         memcpy(s->bitstream_buffer, s1->bitstream_buffer,
 759                s1->bitstream_buffer_size);
 760         memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
 761                FF_INPUT_BUFFER_PADDING_SIZE);
 762     }
 763
 764     // linesize dependend scratch buffer allocation
 765     if (!s->edge_emu_buffer)
 766         if (s1->linesize) {
 767             if (ff_mpv_frame_size_alloc(s, s1->linesize) < 0) {
 768                 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate context "
 769                        "scratch buffers.\n");
 770                 return AVERROR(ENOMEM);
 771             }
 772         } else {
 773             av_log(s->avctx, AV_LOG_ERROR, "Context scratch buffers could not "
 774                    "be allocated due to unknown size.\n");
 775         }
 776
 777     // MPEG2/interlacing info
 778     memcpy(&s->progressive_sequence, &s1->progressive_sequence,
 779            (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
 780
 781     if (!s1->first_field) {
 782         s->last_pict_type = s1->pict_type;
 783         if (s1->current_picture_ptr)
 784             s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f.quality;
 785
 786         if (s1->pict_type != AV_PICTURE_TYPE_B) {
 787             s->last_non_b_pict_type = s1->pict_type;
 788         }
 789     }
 790
 791     return 0;
 792 }
 793
 794 /**
 795  * Set the given MpegEncContext to common defaults
 796  * (same for encoding and decoding).
 797  * The changed fields will not depend upon the
 798  * prior state of the MpegEncContext.
 799  */
 800 void ff_MPV_common_defaults(MpegEncContext *s)
 801 {
 802     s->y_dc_scale_table      =
 803     s->c_dc_scale_table      = ff_mpeg1_dc_scale_table;
 804     s->chroma_qscale_table   = ff_default_chroma_qscale_table;
 805     s->progressive_frame     = 1;
 806     s->progressive_sequence  = 1;
 807     s->picture_structure     = PICT_FRAME;
 808
 809     s->coded_picture_number  = 0;
 810     s->picture_number        = 0;
 811     s->input_picture_number  = 0;
 812
 813     s->picture_in_gop_number = 0;
 814
 815     s->f_code                = 1;
 816     s->b_code                = 1;
 817
 818     s->slice_context_count   = 1;
 819 }
 820
 821 /**
 822  * Set the given MpegEncContext to defaults for decoding.
 823  * the changed fields will not depend upon
 824  * the prior state of the MpegEncContext.
 825  */
 826 void ff_MPV_decode_defaults(MpegEncContext *s)
 827 {
 828     ff_MPV_common_defaults(s);
 829 }
 830
 831 static int init_er(MpegEncContext *s)
 832 {
 833     ERContext *er = &s->er;
 834     int mb_array_size = s->mb_height * s->mb_stride;
 835     int i;
 836
 837     er->avctx       = s->avctx;
 838     er->dsp         = &s->dsp;
 839
 840     er->mb_index2xy = s->mb_index2xy;
 841     er->mb_num      = s->mb_num;
 842     er->mb_width    = s->mb_width;
 843     er->mb_height   = s->mb_height;
 844     er->mb_stride   = s->mb_stride;
 845     er->b8_stride   = s->b8_stride;
 846
 847     er->er_temp_buffer     = av_malloc(s->mb_height * s->mb_stride);
 848     er->error_status_table = av_mallocz(mb_array_size);
 849     if (!er->er_temp_buffer || !er->error_status_table)
 850         goto fail;
 851
 852     er->mbskip_table  = s->mbskip_table;
 853     er->mbintra_table = s->mbintra_table;
 854
 855     for (i = 0; i < FF_ARRAY_ELEMS(s->dc_val); i++)
 856         er->dc_val[i] = s->dc_val[i];
 857
 858     er->decode_mb = mpeg_er_decode_mb;
 859     er->opaque    = s;
 860
 861     return 0;
 862 fail:
 863     av_freep(&er->er_temp_buffer);
 864     av_freep(&er->error_status_table);
 865     return AVERROR(ENOMEM);
 866 }
 867
 868 /**
 869  * Initialize and allocates MpegEncContext fields dependent on the resolution.
 870  */
 871 static int init_context_frame(MpegEncContext *s)
 872 {
 873     int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
 874
 875     s->mb_width   = (s->width + 15) / 16;
 876     s->mb_stride  = s->mb_width + 1;
 877     s->b8_stride  = s->mb_width * 2 + 1;
 878     s->b4_stride  = s->mb_width * 4 + 1;
 879     mb_array_size = s->mb_height * s->mb_stride;
 880     mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
 881
 882     /* set default edge pos, will be overriden
 883      * in decode_header if needed */
 884     s->h_edge_pos = s->mb_width * 16;
 885     s->v_edge_pos = s->mb_height * 16;
 886
 887     s->mb_num     = s->mb_width * s->mb_height;
 888
 889     s->block_wrap[0] =
 890     s->block_wrap[1] =
 891     s->block_wrap[2] =
 892     s->block_wrap[3] = s->b8_stride;
 893     s->block_wrap[4] =
 894     s->block_wrap[5] = s->mb_stride;
 895
 896     y_size  = s->b8_stride * (2 * s->mb_height + 1);
 897     c_size  = s->mb_stride * (s->mb_height + 1);
 898     yc_size = y_size + 2   * c_size;
 899
 900     FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int), fail); // error ressilience code looks cleaner with this
 901     for (y = 0; y < s->mb_height; y++)
 902         for (x = 0; x < s->mb_width; x++)
 903             s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
 904
 905     s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
 906
 907     if (s->encoding) {
 908         /* Allocate MV tables */
 909         FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base,                 mv_table_size * 2 * sizeof(int16_t), fail)
 910         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base,            mv_table_size * 2 * sizeof(int16_t), fail)
 911         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base,            mv_table_size * 2 * sizeof(int16_t), fail)
 912         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base,      mv_table_size * 2 * sizeof(int16_t), fail)
 913         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base,      mv_table_size * 2 * sizeof(int16_t), fail)
 914         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base,          mv_table_size * 2 * sizeof(int16_t), fail)
 915         s->p_mv_table            = s->p_mv_table_base + s->mb_stride + 1;
 916         s->b_forw_mv_table       = s->b_forw_mv_table_base + s->mb_stride + 1;
 917         s->b_back_mv_table       = s->b_back_mv_table_base + s->mb_stride + 1;
 918         s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
 919         s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base + s->mb_stride + 1;
 920         s->b_direct_mv_table     = s->b_direct_mv_table_base + s->mb_stride + 1;
 921
 922         /* Allocate MB type table */
 923         FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size * sizeof(uint16_t), fail) // needed for encoding
 924
 925         FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
 926
 927         FF_ALLOC_OR_GOTO(s->avctx, s->cplx_tab,
 928                          mb_array_size * sizeof(float), fail);
 929         FF_ALLOC_OR_GOTO(s->avctx, s->bits_tab,
 930                          mb_array_size * sizeof(float), fail);
 931
 932     }
 933
 934     if (s->codec_id == AV_CODEC_ID_MPEG4 ||
 935         (s->flags & CODEC_FLAG_INTERLACED_ME)) {
 936         /* interlaced direct mode decoding tables */
 937         for (i = 0; i < 2; i++) {
 938             int j, k;
 939             for (j = 0; j < 2; j++) {
 940                 for (k = 0; k < 2; k++) {
 941                     FF_ALLOCZ_OR_GOTO(s->avctx,
 942                                       s->b_field_mv_table_base[i][j][k],
 943                                       mv_table_size * 2 * sizeof(int16_t),
 944                                       fail);
 945                     s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
 946                                                    s->mb_stride + 1;
 947                 }
 948                 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
 949                 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
 950                 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
 951             }
 952             FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
 953         }
 954     }
 955     if (s->out_format == FMT_H263) {
 956         /* cbp values */
 957         FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
 958         s->coded_block = s->coded_block_base + s->b8_stride + 1;
 959
 960         /* cbp, ac_pred, pred_dir */
 961         FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table     , mb_array_size * sizeof(uint8_t), fail);
 962         FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail);
 963     }
 964
 965     if (s->h263_pred || s->h263_plus || !s->encoding) {
 966         /* dc values */
 967         // MN: we need these for  error resilience of intra-frames
 968         FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
 969         s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
 970         s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
 971         s->dc_val[2] = s->dc_val[1] + c_size;
 972         for (i = 0; i < yc_size; i++)
 973             s->dc_val_base[i] = 1024;
 974     }
 975
 976     /* which mb is a intra block */
 977     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
 978     memset(s->mbintra_table, 1, mb_array_size);
 979
 980     /* init macroblock skip table */
 981     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
 982     // Note the + 1 is for  a quicker mpeg4 slice_end detection
 983
 984     return init_er(s);
 985 fail:
 986     return AVERROR(ENOMEM);
 987 }
 988
 989 /**
 990  * init common structure for both encoder and decoder.
 991  * this assumes that some variables like width/height are already set
 992  */
 993 av_cold int ff_MPV_common_init(MpegEncContext *s)
 994 {
 995     int i;
 996     int nb_slices = (HAVE_THREADS &&
 997                      s->avctx->active_thread_type & FF_THREAD_SLICE) ?
 998                     s->avctx->thread_count : 1;
 999
1000     if (s->encoding && s->avctx->slices)
1001         nb_slices = s->avctx->slices;
1002
1003     if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1004         s->mb_height = (s->height + 31) / 32 * 2;
1005     else
1006         s->mb_height = (s->height + 15) / 16;
1007
1008     if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
1009         av_log(s->avctx, AV_LOG_ERROR,
1010                "decoding to AV_PIX_FMT_NONE is not supported.\n");
1011         return -1;
1012     }
1013
1014     if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
1015         int max_slices;
1016         if (s->mb_height)
1017             max_slices = FFMIN(MAX_THREADS, s->mb_height);
1018         else
1019             max_slices = MAX_THREADS;
1020         av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
1021                " reducing to %d\n", nb_slices, max_slices);
1022         nb_slices = max_slices;
1023     }
1024
1025     if ((s->width || s->height) &&
1026         av_image_check_size(s->width, s->height, 0, s->avctx))
1027         return -1;
1028
1029     ff_dct_common_init(s);
1030
1031     s->flags  = s->avctx->flags;
1032     s->flags2 = s->avctx->flags2;
1033
1034     /* set chroma shifts */
1035     avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &s->chroma_x_shift, &s->chroma_y_shift);
1036
1037     /* convert fourcc to upper case */
1038     s->codec_tag        = avpriv_toupper4(s->avctx->codec_tag);
1039     s->stream_codec_tag = avpriv_toupper4(s->avctx->stream_codec_tag);
1040
1041     s->avctx->coded_frame = &s->current_picture.f;
1042
1043     if (s->encoding) {
1044         if (s->msmpeg4_version) {
1045             FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
1046                                 2 * 2 * (MAX_LEVEL + 1) *
1047                                 (MAX_RUN + 1) * 2 * sizeof(int), fail);
1048         }
1049         FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
1050
1051         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix,          64 * 32   * sizeof(int), fail)
1052         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix,   64 * 32   * sizeof(int), fail)
1053         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix,          64 * 32   * sizeof(int), fail)
1054         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16,        64 * 32 * 2 * sizeof(uint16_t), fail)
1055         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail)
1056         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16,        64 * 32 * 2 * sizeof(uint16_t), fail)
1057         FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture,           MAX_PICTURE_COUNT * sizeof(Picture *), fail)
1058         FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture *), fail)
1059
1060         if (s->avctx->noise_reduction) {
1061             FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail);
1062         }
1063     }
1064
1065     FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
1066                       MAX_PICTURE_COUNT * sizeof(Picture), fail);
1067     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1068         avcodec_get_frame_defaults(&s->picture[i].f);
1069     }
1070     memset(&s->next_picture, 0, sizeof(s->next_picture));
1071     memset(&s->last_picture, 0, sizeof(s->last_picture));
1072     memset(&s->current_picture, 0, sizeof(s->current_picture));
1073     avcodec_get_frame_defaults(&s->next_picture.f);
1074     avcodec_get_frame_defaults(&s->last_picture.f);
1075     avcodec_get_frame_defaults(&s->current_picture.f);
1076
1077         if (init_context_frame(s))
1078             goto fail;
1079
1080         s->parse_context.state = -1;
1081
1082         s->context_initialized = 1;
1083         s->thread_context[0]   = s;
1084
1085 //     if (s->width && s->height) {
1086         if (nb_slices > 1) {
1087             for (i = 1; i < nb_slices; i++) {
1088                 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1089                 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1090             }
1091
1092             for (i = 0; i < nb_slices; i++) {
1093                 if (init_duplicate_context(s->thread_context[i]) < 0)
1094                     goto fail;
1095                     s->thread_context[i]->start_mb_y =
1096                         (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1097                     s->thread_context[i]->end_mb_y   =
1098                         (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1099             }
1100         } else {
1101             if (init_duplicate_context(s) < 0)
1102                 goto fail;
1103             s->start_mb_y = 0;
1104             s->end_mb_y   = s->mb_height;
1105         }
1106         s->slice_context_count = nb_slices;
1107 //     }
1108
1109     return 0;
1110  fail:
1111     ff_MPV_common_end(s);
1112     return -1;
1113 }
1114
1115 /**
1116  * Frees and resets MpegEncContext fields depending on the resolution.
1117  * Is used during resolution changes to avoid a full reinitialization of the
1118  * codec.
1119  */
1120 static int free_context_frame(MpegEncContext *s)
1121 {
1122     int i, j, k;
1123
1124     av_freep(&s->mb_type);
1125     av_freep(&s->p_mv_table_base);
1126     av_freep(&s->b_forw_mv_table_base);
1127     av_freep(&s->b_back_mv_table_base);
1128     av_freep(&s->b_bidir_forw_mv_table_base);
1129     av_freep(&s->b_bidir_back_mv_table_base);
1130     av_freep(&s->b_direct_mv_table_base);
1131     s->p_mv_table            = NULL;
1132     s->b_forw_mv_table       = NULL;
1133     s->b_back_mv_table       = NULL;
1134     s->b_bidir_forw_mv_table = NULL;
1135     s->b_bidir_back_mv_table = NULL;
1136     s->b_direct_mv_table     = NULL;
1137     for (i = 0; i < 2; i++) {
1138         for (j = 0; j < 2; j++) {
1139             for (k = 0; k < 2; k++) {
1140                 av_freep(&s->b_field_mv_table_base[i][j][k]);
1141                 s->b_field_mv_table[i][j][k] = NULL;
1142             }
1143             av_freep(&s->b_field_select_table[i][j]);
1144             av_freep(&s->p_field_mv_table_base[i][j]);
1145             s->p_field_mv_table[i][j] = NULL;
1146         }
1147         av_freep(&s->p_field_select_table[i]);
1148     }
1149
1150     av_freep(&s->dc_val_base);
1151     av_freep(&s->coded_block_base);
1152     av_freep(&s->mbintra_table);
1153     av_freep(&s->cbp_table);
1154     av_freep(&s->pred_dir_table);
1155
1156     av_freep(&s->mbskip_table);
1157
1158     av_freep(&s->er.error_status_table);
1159     av_freep(&s->er.er_temp_buffer);
1160     av_freep(&s->mb_index2xy);
1161     av_freep(&s->lambda_table);
1162
1163     av_freep(&s->cplx_tab);
1164     av_freep(&s->bits_tab);
1165
1166     s->linesize = s->uvlinesize = 0;
1167
1168     return 0;
1169 }
1170
1171 int ff_MPV_common_frame_size_change(MpegEncContext *s)
1172 {
1173     int i, err = 0;
1174
1175     if (s->slice_context_count > 1) {
1176         for (i = 0; i < s->slice_context_count; i++) {
1177             free_duplicate_context(s->thread_context[i]);
1178         }
1179         for (i = 1; i < s->slice_context_count; i++) {
1180             av_freep(&s->thread_context[i]);
1181         }
1182     } else
1183         free_duplicate_context(s);
1184
1185     if ((err = free_context_frame(s)) < 0)
1186         return err;
1187
1188     if (s->picture)
1189         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1190                 s->picture[i].needs_realloc = 1;
1191         }
1192
1193     s->last_picture_ptr         =
1194     s->next_picture_ptr         =
1195     s->current_picture_ptr      = NULL;
1196
1197     // init
1198     if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1199         s->mb_height = (s->height + 31) / 32 * 2;
1200     else
1201         s->mb_height = (s->height + 15) / 16;
1202
1203     if ((s->width || s->height) &&
1204         av_image_check_size(s->width, s->height, 0, s->avctx))
1205         return AVERROR_INVALIDDATA;
1206
1207     if ((err = init_context_frame(s)))
1208         goto fail;
1209
1210     s->thread_context[0]   = s;
1211
1212     if (s->width && s->height) {
1213         int nb_slices = s->slice_context_count;
1214         if (nb_slices > 1) {
1215             for (i = 1; i < nb_slices; i++) {
1216                 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1217                 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1218             }
1219
1220             for (i = 0; i < nb_slices; i++) {
1221                 if (init_duplicate_context(s->thread_context[i]) < 0)
1222                     goto fail;
1223                     s->thread_context[i]->start_mb_y =
1224                         (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1225                     s->thread_context[i]->end_mb_y   =
1226                         (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1227             }
1228         } else {
1229             if (init_duplicate_context(s) < 0)
1230                 goto fail;
1231             s->start_mb_y = 0;
1232             s->end_mb_y   = s->mb_height;
1233         }
1234         s->slice_context_count = nb_slices;
1235     }
1236
1237     return 0;
1238  fail:
1239     ff_MPV_common_end(s);
1240     return err;
1241 }
1242
1243 /* init common structure for both encoder and decoder */
1244 void ff_MPV_common_end(MpegEncContext *s)
1245 {
1246     int i;
1247
1248     if (s->slice_context_count > 1) {
1249         for (i = 0; i < s->slice_context_count; i++) {
1250             free_duplicate_context(s->thread_context[i]);
1251         }
1252         for (i = 1; i < s->slice_context_count; i++) {
1253             av_freep(&s->thread_context[i]);
1254         }
1255         s->slice_context_count = 1;
1256     } else free_duplicate_context(s);
1257
1258     av_freep(&s->parse_context.buffer);
1259     s->parse_context.buffer_size = 0;
1260
1261     av_freep(&s->bitstream_buffer);
1262     s->allocated_bitstream_buffer_size = 0;
1263
1264     av_freep(&s->avctx->stats_out);
1265     av_freep(&s->ac_stats);
1266
1267     if(s->q_chroma_intra_matrix   != s->q_intra_matrix  ) av_freep(&s->q_chroma_intra_matrix);
1268     if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
1269     s->q_chroma_intra_matrix=   NULL;
1270     s->q_chroma_intra_matrix16= NULL;
1271     av_freep(&s->q_intra_matrix);
1272     av_freep(&s->q_inter_matrix);
1273     av_freep(&s->q_intra_matrix16);
1274     av_freep(&s->q_inter_matrix16);
1275     av_freep(&s->input_picture);
1276     av_freep(&s->reordered_input_picture);
1277     av_freep(&s->dct_offset);
1278
1279     if (s->picture) {
1280         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1281             free_picture_tables(&s->picture[i]);
1282             ff_mpeg_unref_picture(s, &s->picture[i]);
1283         }
1284     }
1285     av_freep(&s->picture);
1286     free_picture_tables(&s->last_picture);
1287     ff_mpeg_unref_picture(s, &s->last_picture);
1288     free_picture_tables(&s->current_picture);
1289     ff_mpeg_unref_picture(s, &s->current_picture);
1290     free_picture_tables(&s->next_picture);
1291     ff_mpeg_unref_picture(s, &s->next_picture);
1292     free_picture_tables(&s->new_picture);
1293     ff_mpeg_unref_picture(s, &s->new_picture);
1294
1295     free_context_frame(s);
1296
1297     s->context_initialized      = 0;
1298     s->last_picture_ptr         =
1299     s->next_picture_ptr         =
1300     s->current_picture_ptr      = NULL;
1301     s->linesize = s->uvlinesize = 0;
1302 }
1303
1304 void ff_init_rl(RLTable *rl,
1305                 uint8_t static_store[2][2 * MAX_RUN + MAX_LEVEL + 3])
1306 {
1307     int8_t  max_level[MAX_RUN + 1], max_run[MAX_LEVEL + 1];
1308     uint8_t index_run[MAX_RUN + 1];
1309     int last, run, level, start, end, i;
1310
1311     /* If table is static, we can quit if rl->max_level[0] is not NULL */
1312     if (static_store && rl->max_level[0])
1313         return;
1314
1315     /* compute max_level[], max_run[] and index_run[] */
1316     for (last = 0; last < 2; last++) {
1317         if (last == 0) {
1318             start = 0;
1319             end = rl->last;
1320         } else {
1321             start = rl->last;
1322             end = rl->n;
1323         }
1324
1325         memset(max_level, 0, MAX_RUN + 1);
1326         memset(max_run, 0, MAX_LEVEL + 1);
1327         memset(index_run, rl->n, MAX_RUN + 1);
1328         for (i = start; i < end; i++) {
1329             run   = rl->table_run[i];
1330             level = rl->table_level[i];
1331             if (index_run[run] == rl->n)
1332                 index_run[run] = i;
1333             if (level > max_level[run])
1334                 max_level[run] = level;
1335             if (run > max_run[level])
1336                 max_run[level] = run;
1337         }
1338         if (static_store)
1339             rl->max_level[last] = static_store[last];
1340         else
1341             rl->max_level[last] = av_malloc(MAX_RUN + 1);
1342         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1343         if (static_store)
1344             rl->max_run[last]   = static_store[last] + MAX_RUN + 1;
1345         else
1346             rl->max_run[last]   = av_malloc(MAX_LEVEL + 1);
1347         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1348         if (static_store)
1349             rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
1350         else
1351             rl->index_run[last] = av_malloc(MAX_RUN + 1);
1352         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1353     }
1354 }
1355
1356 void ff_init_vlc_rl(RLTable *rl)
1357 {
1358     int i, q;
1359
1360     for (q = 0; q < 32; q++) {
1361         int qmul = q * 2;
1362         int qadd = (q - 1) | 1;
1363
1364         if (q == 0) {
1365             qmul = 1;
1366             qadd = 0;
1367         }
1368         for (i = 0; i < rl->vlc.table_size; i++) {
1369             int code = rl->vlc.table[i][0];
1370             int len  = rl->vlc.table[i][1];
1371             int level, run;
1372
1373             if (len == 0) { // illegal code
1374                 run   = 66;
1375                 level = MAX_LEVEL;
1376             } else if (len < 0) { // more bits needed
1377                 run   = 0;
1378                 level = code;
1379             } else {
1380                 if (code == rl->n) { // esc
1381                     run   = 66;
1382                     level =  0;
1383                 } else {
1384                     run   = rl->table_run[code] + 1;
1385                     level = rl->table_level[code] * qmul + qadd;
1386                     if (code >= rl->last) run += 192;
1387                 }
1388             }
1389             rl->rl_vlc[q][i].len   = len;
1390             rl->rl_vlc[q][i].level = level;
1391             rl->rl_vlc[q][i].run   = run;
1392         }
1393     }
1394 }
1395
1396 void ff_release_unused_pictures(MpegEncContext*s, int remove_current)
1397 {
1398     int i;
1399
1400     /* release non reference frames */
1401     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1402         if (!s->picture[i].reference &&
1403             (remove_current || &s->picture[i] !=  s->current_picture_ptr)) {
1404             ff_mpeg_unref_picture(s, &s->picture[i]);
1405         }
1406     }
1407 }
1408
1409 static inline int pic_is_unused(MpegEncContext *s, Picture *pic)
1410 {
1411     if (pic == s->last_picture_ptr)
1412         return 0;
1413     if (pic->f.data[0] == NULL)
1414         return 1;
1415     if (pic->needs_realloc && !(pic->reference & DELAYED_PIC_REF))
1416         return 1;
1417     return 0;
1418 }
1419
1420 static int find_unused_picture(MpegEncContext *s, int shared)
1421 {
1422     int i;
1423
1424     if (shared) {
1425         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1426             if (s->picture[i].f.data[0] == NULL && &s->picture[i] != s->last_picture_ptr)
1427                 return i;
1428         }
1429     } else {
1430         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1431             if (pic_is_unused(s, &s->picture[i]))
1432                 return i;
1433         }
1434     }
1435
1436     av_log(s->avctx, AV_LOG_FATAL,
1437            "Internal error, picture buffer overflow\n");
1438     /* We could return -1, but the codec would crash trying to draw into a
1439      * non-existing frame anyway. This is safer than waiting for a random crash.
1440      * Also the return of this is never useful, an encoder must only allocate
1441      * as much as allowed in the specification. This has no relationship to how
1442      * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
1443      * enough for such valid streams).
1444      * Plus, a decoder has to check stream validity and remove frames if too
1445      * many reference frames are around. Waiting for "OOM" is not correct at
1446      * all. Similarly, missing reference frames have to be replaced by
1447      * interpolated/MC frames, anything else is a bug in the codec ...
1448      */
1449     abort();
1450     return -1;
1451 }
1452
1453 int ff_find_unused_picture(MpegEncContext *s, int shared)
1454 {
1455     int ret = find_unused_picture(s, shared);
1456
1457     if (ret >= 0 && ret < MAX_PICTURE_COUNT) {
1458         if (s->picture[ret].needs_realloc) {
1459             s->picture[ret].needs_realloc = 0;
1460             free_picture_tables(&s->picture[ret]);
1461             ff_mpeg_unref_picture(s, &s->picture[ret]);
1462             avcodec_get_frame_defaults(&s->picture[ret].f);
1463         }
1464     }
1465     return ret;
1466 }
1467
1468 static void update_noise_reduction(MpegEncContext *s)
1469 {
1470     int intra, i;
1471
1472     for (intra = 0; intra < 2; intra++) {
1473         if (s->dct_count[intra] > (1 << 16)) {
1474             for (i = 0; i < 64; i++) {
1475                 s->dct_error_sum[intra][i] >>= 1;
1476             }
1477             s->dct_count[intra] >>= 1;
1478         }
1479
1480         for (i = 0; i < 64; i++) {
1481             s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1482                                        s->dct_count[intra] +
1483                                        s->dct_error_sum[intra][i] / 2) /
1484                                       (s->dct_error_sum[intra][i] + 1);
1485         }
1486     }
1487 }
1488
1489 /**
1490  * generic function for encode/decode called after coding/decoding
1491  * the header and before a frame is coded/decoded.
1492  */
1493 int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1494 {
1495     int i, ret;
1496     Picture *pic;
1497     s->mb_skipped = 0;
1498
1499     if (!ff_thread_can_start_frame(avctx)) {
1500         av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
1501         return -1;
1502     }
1503
1504     /* mark & release old frames */
1505     if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1506         s->last_picture_ptr != s->next_picture_ptr &&
1507         s->last_picture_ptr->f.data[0]) {
1508         ff_mpeg_unref_picture(s, s->last_picture_ptr);
1509     }
1510
1511     /* release forgotten pictures */
1512     /* if (mpeg124/h263) */
1513     if (!s->encoding) {
1514         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1515             if (&s->picture[i] != s->last_picture_ptr &&
1516                 &s->picture[i] != s->next_picture_ptr &&
1517                 s->picture[i].reference && !s->picture[i].needs_realloc) {
1518                 if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1519                     av_log(avctx, AV_LOG_ERROR,
1520                            "releasing zombie picture\n");
1521                 ff_mpeg_unref_picture(s, &s->picture[i]);
1522             }
1523         }
1524     }
1525
1526     if (!s->encoding) {
1527         ff_release_unused_pictures(s, 1);
1528
1529         if (s->current_picture_ptr &&
1530             s->current_picture_ptr->f.data[0] == NULL) {
1531             // we already have a unused image
1532             // (maybe it was set before reading the header)
1533             pic = s->current_picture_ptr;
1534         } else {
1535             i   = ff_find_unused_picture(s, 0);
1536             if (i < 0) {
1537                 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1538                 return i;
1539             }
1540             pic = &s->picture[i];
1541         }
1542
1543         pic->reference = 0;
1544         if (!s->droppable) {
1545             if (s->pict_type != AV_PICTURE_TYPE_B)
1546                 pic->reference = 3;
1547         }
1548
1549         pic->f.coded_picture_number = s->coded_picture_number++;
1550
1551         if (ff_alloc_picture(s, pic, 0) < 0)
1552             return -1;
1553
1554         s->current_picture_ptr = pic;
1555         // FIXME use only the vars from current_pic
1556         s->current_picture_ptr->f.top_field_first = s->top_field_first;
1557         if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1558             s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1559             if (s->picture_structure != PICT_FRAME)
1560                 s->current_picture_ptr->f.top_field_first =
1561                     (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1562         }
1563         s->current_picture_ptr->f.interlaced_frame = !s->progressive_frame &&
1564                                                      !s->progressive_sequence;
1565         s->current_picture_ptr->field_picture      =  s->picture_structure != PICT_FRAME;
1566     }
1567
1568     s->current_picture_ptr->f.pict_type = s->pict_type;
1569     // if (s->flags && CODEC_FLAG_QSCALE)
1570     //     s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1571     s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1572
1573     ff_mpeg_unref_picture(s, &s->current_picture);
1574     if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1575                                    s->current_picture_ptr)) < 0)
1576         return ret;
1577
1578     if (s->pict_type != AV_PICTURE_TYPE_B) {
1579         s->last_picture_ptr = s->next_picture_ptr;
1580         if (!s->droppable)
1581             s->next_picture_ptr = s->current_picture_ptr;
1582     }
1583     av_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1584             s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1585             s->last_picture_ptr    ? s->last_picture_ptr->f.data[0]    : NULL,
1586             s->next_picture_ptr    ? s->next_picture_ptr->f.data[0]    : NULL,
1587             s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL,
1588             s->pict_type, s->droppable);
1589
1590     if ((s->last_picture_ptr == NULL ||
1591          s->last_picture_ptr->f.data[0] == NULL) &&
1592         (s->pict_type != AV_PICTURE_TYPE_I ||
1593          s->picture_structure != PICT_FRAME)) {
1594         int h_chroma_shift, v_chroma_shift;
1595         av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1596                                          &h_chroma_shift, &v_chroma_shift);
1597         if (s->pict_type != AV_PICTURE_TYPE_I)
1598             av_log(avctx, AV_LOG_ERROR,
1599                    "warning: first frame is no keyframe\n");
1600         else if (s->picture_structure != PICT_FRAME)
1601             av_log(avctx, AV_LOG_INFO,
1602                    "allocate dummy last picture for field based first keyframe\n");
1603
1604         /* Allocate a dummy frame */
1605         i = ff_find_unused_picture(s, 0);
1606         if (i < 0) {
1607             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1608             return i;
1609         }
1610         s->last_picture_ptr = &s->picture[i];
1611         s->last_picture_ptr->f.key_frame = 0;
1612         if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1613             s->last_picture_ptr = NULL;
1614             return -1;
1615         }
1616
1617         memset(s->last_picture_ptr->f.data[0], 0x80,
1618                avctx->height * s->last_picture_ptr->f.linesize[0]);
1619         memset(s->last_picture_ptr->f.data[1], 0x80,
1620                (avctx->height >> v_chroma_shift) *
1621                s->last_picture_ptr->f.linesize[1]);
1622         memset(s->last_picture_ptr->f.data[2], 0x80,
1623                (avctx->height >> v_chroma_shift) *
1624                s->last_picture_ptr->f.linesize[2]);
1625
1626         if(s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263){
1627             for(i=0; i<avctx->height; i++)
1628             memset(s->last_picture_ptr->f.data[0] + s->last_picture_ptr->f.linesize[0]*i, 16, avctx->width);
1629         }
1630
1631         ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 0);
1632         ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 1);
1633     }
1634     if ((s->next_picture_ptr == NULL ||
1635          s->next_picture_ptr->f.data[0] == NULL) &&
1636         s->pict_type == AV_PICTURE_TYPE_B) {
1637         /* Allocate a dummy frame */
1638         i = ff_find_unused_picture(s, 0);
1639         if (i < 0) {
1640             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1641             return i;
1642         }
1643         s->next_picture_ptr = &s->picture[i];
1644         s->next_picture_ptr->f.key_frame = 0;
1645         if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1646             s->next_picture_ptr = NULL;
1647             return -1;
1648         }
1649         ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 0);
1650         ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 1);
1651     }
1652
1653 #if 0 // BUFREF-FIXME
1654     memset(s->last_picture.f.data, 0, sizeof(s->last_picture.f.data));
1655     memset(s->next_picture.f.data, 0, sizeof(s->next_picture.f.data));
1656 #endif
1657     if (s->last_picture_ptr) {
1658         ff_mpeg_unref_picture(s, &s->last_picture);
1659         if (s->last_picture_ptr->f.data[0] &&
1660             (ret = ff_mpeg_ref_picture(s, &s->last_picture,
1661                                        s->last_picture_ptr)) < 0)
1662             return ret;
1663     }
1664     if (s->next_picture_ptr) {
1665         ff_mpeg_unref_picture(s, &s->next_picture);
1666         if (s->next_picture_ptr->f.data[0] &&
1667             (ret = ff_mpeg_ref_picture(s, &s->next_picture,
1668                                        s->next_picture_ptr)) < 0)
1669             return ret;
1670     }
1671
1672     assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1673                                                  s->last_picture_ptr->f.data[0]));
1674
1675     if (s->picture_structure!= PICT_FRAME) {
1676         int i;
1677         for (i = 0; i < 4; i++) {
1678             if (s->picture_structure == PICT_BOTTOM_FIELD) {
1679                 s->current_picture.f.data[i] +=
1680                     s->current_picture.f.linesize[i];
1681             }
1682             s->current_picture.f.linesize[i] *= 2;
1683             s->last_picture.f.linesize[i]    *= 2;
1684             s->next_picture.f.linesize[i]    *= 2;
1685         }
1686     }
1687
1688     s->err_recognition = avctx->err_recognition;
1689
1690     /* set dequantizer, we can't do it during init as
1691      * it might change for mpeg4 and we can't do it in the header
1692      * decode as init is not called for mpeg4 there yet */
1693     if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1694         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1695         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1696     } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1697         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1698         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1699     } else {
1700         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1701         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1702     }
1703
1704     if (s->dct_error_sum) {
1705         av_assert2(s->avctx->noise_reduction && s->encoding);
1706         update_noise_reduction(s);
1707     }
1708
1709     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1710         return ff_xvmc_field_start(s, avctx);
1711
1712     return 0;
1713 }
1714
1715 /* generic function for encode/decode called after a
1716  * frame has been coded/decoded. */
1717 void ff_MPV_frame_end(MpegEncContext *s)
1718 {
1719     int i;
1720     /* redraw edges for the frame if decoding didn't complete */
1721     // just to make sure that all data is rendered.
1722     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
1723         ff_xvmc_field_end(s);
1724    } else if ((s->er.error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND)) &&
1725               !s->avctx->hwaccel &&
1726               !(s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
1727               s->unrestricted_mv &&
1728               s->current_picture.reference &&
1729               !s->intra_only &&
1730               !(s->flags & CODEC_FLAG_EMU_EDGE) &&
1731               !s->avctx->lowres
1732             ) {
1733         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1734         int hshift = desc->log2_chroma_w;
1735         int vshift = desc->log2_chroma_h;
1736         s->dsp.draw_edges(s->current_picture.f.data[0], s->current_picture.f.linesize[0],
1737                           s->h_edge_pos, s->v_edge_pos,
1738                           EDGE_WIDTH, EDGE_WIDTH,
1739                           EDGE_TOP | EDGE_BOTTOM);
1740         s->dsp.draw_edges(s->current_picture.f.data[1], s->current_picture.f.linesize[1],
1741                           s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1742                           EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1743                           EDGE_TOP | EDGE_BOTTOM);
1744         s->dsp.draw_edges(s->current_picture.f.data[2], s->current_picture.f.linesize[2],
1745                           s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1746                           EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1747                           EDGE_TOP | EDGE_BOTTOM);
1748     }
1749
1750     emms_c();
1751
1752     s->last_pict_type                 = s->pict_type;
1753     s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f.quality;
1754     if (s->pict_type!= AV_PICTURE_TYPE_B) {
1755         s->last_non_b_pict_type = s->pict_type;
1756     }
1757 #if 0
1758     /* copy back current_picture variables */
1759     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1760         if (s->picture[i].f.data[0] == s->current_picture.f.data[0]) {
1761             s->picture[i] = s->current_picture;
1762             break;
1763         }
1764     }
1765     assert(i < MAX_PICTURE_COUNT);
1766 #endif
1767
1768     if (s->encoding) {
1769         /* release non-reference frames */
1770         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1771             if (!s->picture[i].reference)
1772                 ff_mpeg_unref_picture(s, &s->picture[i]);
1773         }
1774     }
1775     // clear copies, to avoid confusion
1776 #if 0
1777     memset(&s->last_picture,    0, sizeof(Picture));
1778     memset(&s->next_picture,    0, sizeof(Picture));
1779     memset(&s->current_picture, 0, sizeof(Picture));
1780 #endif
1781     s->avctx->coded_frame = &s->current_picture_ptr->f;
1782
1783     if (s->current_picture.reference)
1784         ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);
1785 }
1786
1787 /**
1788  * Draw a line from (ex, ey) -> (sx, sy).
1789  * @param w width of the image
1790  * @param h height of the image
1791  * @param stride stride/linesize of the image
1792  * @param color color of the arrow
1793  */
1794 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
1795                       int w, int h, int stride, int color)
1796 {
1797     int x, y, fr, f;
1798
1799     sx = av_clip(sx, 0, w - 1);
1800     sy = av_clip(sy, 0, h - 1);
1801     ex = av_clip(ex, 0, w - 1);
1802     ey = av_clip(ey, 0, h - 1);
1803
1804     buf[sy * stride + sx] += color;
1805
1806     if (FFABS(ex - sx) > FFABS(ey - sy)) {
1807         if (sx > ex) {
1808             FFSWAP(int, sx, ex);
1809             FFSWAP(int, sy, ey);
1810         }
1811         buf += sx + sy * stride;
1812         ex  -= sx;
1813         f    = ((ey - sy) << 16) / ex;
1814         for (x = 0; x <= ex; x++) {
1815             y  = (x * f) >> 16;
1816             fr = (x * f) & 0xFFFF;
1817             buf[y * stride + x]       += (color * (0x10000 - fr)) >> 16;
1818             if(fr) buf[(y + 1) * stride + x] += (color *            fr ) >> 16;
1819         }
1820     } else {
1821         if (sy > ey) {
1822             FFSWAP(int, sx, ex);
1823             FFSWAP(int, sy, ey);
1824         }
1825         buf += sx + sy * stride;
1826         ey  -= sy;
1827         if (ey)
1828             f = ((ex - sx) << 16) / ey;
1829         else
1830             f = 0;
1831         for(y= 0; y <= ey; y++){
1832             x  = (y*f) >> 16;
1833             fr = (y*f) & 0xFFFF;
1834             buf[y * stride + x]     += (color * (0x10000 - fr)) >> 16;
1835             if(fr) buf[y * stride + x + 1] += (color *            fr ) >> 16;
1836         }
1837     }
1838 }
1839
1840 /**
1841  * Draw an arrow from (ex, ey) -> (sx, sy).
1842  * @param w width of the image
1843  * @param h height of the image
1844  * @param stride stride/linesize of the image
1845  * @param color color of the arrow
1846  */
1847 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
1848                        int ey, int w, int h, int stride, int color)
1849 {
1850     int dx,dy;
1851
1852     sx = av_clip(sx, -100, w + 100);
1853     sy = av_clip(sy, -100, h + 100);
1854     ex = av_clip(ex, -100, w + 100);
1855     ey = av_clip(ey, -100, h + 100);
1856
1857     dx = ex - sx;
1858     dy = ey - sy;
1859
1860     if (dx * dx + dy * dy > 3 * 3) {
1861         int rx =  dx + dy;
1862         int ry = -dx + dy;
1863         int length = ff_sqrt((rx * rx + ry * ry) << 8);
1864
1865         // FIXME subpixel accuracy
1866         rx = ROUNDED_DIV(rx * 3 << 4, length);
1867         ry = ROUNDED_DIV(ry * 3 << 4, length);
1868
1869         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1870         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1871     }
1872     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1873 }
1874
1875 /**
1876  * Print debugging info for the given picture.
1877  */
1878 void ff_print_debug_info2(AVCodecContext *avctx, Picture *p, AVFrame *pict, uint8_t *mbskip_table,
1879                          int *low_delay,
1880                          int mb_width, int mb_height, int mb_stride, int quarter_sample)
1881 {
1882     if (avctx->hwaccel || !p || !p->mb_type
1883         || (avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU))
1884         return;
1885
1886
1887     if (avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
1888         int x,y;
1889
1890         av_log(avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
1891                av_get_picture_type_char(pict->pict_type));
1892         for (y = 0; y < mb_height; y++) {
1893             for (x = 0; x < mb_width; x++) {
1894                 if (avctx->debug & FF_DEBUG_SKIP) {
1895                     int count = mbskip_table[x + y * mb_stride];
1896                     if (count > 9)
1897                         count = 9;
1898                     av_log(avctx, AV_LOG_DEBUG, "%1d", count);
1899                 }
1900                 if (avctx->debug & FF_DEBUG_QP) {
1901                     av_log(avctx, AV_LOG_DEBUG, "%2d",
1902                            p->qscale_table[x + y * mb_stride]);
1903                 }
1904                 if (avctx->debug & FF_DEBUG_MB_TYPE) {
1905                     int mb_type = p->mb_type[x + y * mb_stride];
1906                     // Type & MV direction
1907                     if (IS_PCM(mb_type))
1908                         av_log(avctx, AV_LOG_DEBUG, "P");
1909                     else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1910                         av_log(avctx, AV_LOG_DEBUG, "A");
1911                     else if (IS_INTRA4x4(mb_type))
1912                         av_log(avctx, AV_LOG_DEBUG, "i");
1913                     else if (IS_INTRA16x16(mb_type))
1914                         av_log(avctx, AV_LOG_DEBUG, "I");
1915                     else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1916                         av_log(avctx, AV_LOG_DEBUG, "d");
1917                     else if (IS_DIRECT(mb_type))
1918                         av_log(avctx, AV_LOG_DEBUG, "D");
1919                     else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
1920                         av_log(avctx, AV_LOG_DEBUG, "g");
1921                     else if (IS_GMC(mb_type))
1922                         av_log(avctx, AV_LOG_DEBUG, "G");
1923                     else if (IS_SKIP(mb_type))
1924                         av_log(avctx, AV_LOG_DEBUG, "S");
1925                     else if (!USES_LIST(mb_type, 1))
1926                         av_log(avctx, AV_LOG_DEBUG, ">");
1927                     else if (!USES_LIST(mb_type, 0))
1928                         av_log(avctx, AV_LOG_DEBUG, "<");
1929                     else {
1930                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1931                         av_log(avctx, AV_LOG_DEBUG, "X");
1932                     }
1933
1934                     // segmentation
1935                     if (IS_8X8(mb_type))
1936                         av_log(avctx, AV_LOG_DEBUG, "+");
1937                     else if (IS_16X8(mb_type))
1938                         av_log(avctx, AV_LOG_DEBUG, "-");
1939                     else if (IS_8X16(mb_type))
1940                         av_log(avctx, AV_LOG_DEBUG, "|");
1941                     else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
1942                         av_log(avctx, AV_LOG_DEBUG, " ");
1943                     else
1944                         av_log(avctx, AV_LOG_DEBUG, "?");
1945
1946
1947                     if (IS_INTERLACED(mb_type))
1948                         av_log(avctx, AV_LOG_DEBUG, "=");
1949                     else
1950                         av_log(avctx, AV_LOG_DEBUG, " ");
1951                 }
1952             }
1953             av_log(avctx, AV_LOG_DEBUG, "\n");
1954         }
1955     }
1956
1957     if ((avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
1958         (avctx->debug_mv)) {
1959         const int shift = 1 + quarter_sample;
1960         int mb_y;
1961         uint8_t *ptr;
1962         int i;
1963         int h_chroma_shift, v_chroma_shift, block_height;
1964         const int width          = avctx->width;
1965         const int height         = avctx->height;
1966         const int mv_sample_log2 = avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_SVQ3 ? 2 : 1;
1967         const int mv_stride      = (mb_width << mv_sample_log2) +
1968                                    (avctx->codec->id == AV_CODEC_ID_H264 ? 0 : 1);
1969
1970         *low_delay = 0; // needed to see the vectors without trashing the buffers
1971
1972         avcodec_get_chroma_sub_sample(avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1973
1974         av_frame_make_writable(pict);
1975
1976         pict->opaque = NULL;
1977         ptr          = pict->data[0];
1978         block_height = 16 >> v_chroma_shift;
1979
1980         for (mb_y = 0; mb_y < mb_height; mb_y++) {
1981             int mb_x;
1982             for (mb_x = 0; mb_x < mb_width; mb_x++) {
1983                 const int mb_index = mb_x + mb_y * mb_stride;
1984                 if ((avctx->debug_mv) && p->motion_val[0]) {
1985                     int type;
1986                     for (type = 0; type < 3; type++) {
1987                         int direction = 0;
1988                         switch (type) {
1989                         case 0:
1990                             if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
1991                                 (pict->pict_type!= AV_PICTURE_TYPE_P))
1992                                 continue;
1993                             direction = 0;
1994                             break;
1995                         case 1:
1996                             if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
1997                                 (pict->pict_type!= AV_PICTURE_TYPE_B))
1998                                 continue;
1999                             direction = 0;
2000                             break;
2001                         case 2:
2002                             if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
2003                                 (pict->pict_type!= AV_PICTURE_TYPE_B))
2004                                 continue;
2005                             direction = 1;
2006                             break;
2007                         }
2008                         if (!USES_LIST(p->mb_type[mb_index], direction))
2009                             continue;
2010
2011                         if (IS_8X8(p->mb_type[mb_index])) {
2012                             int i;
2013                             for (i = 0; i < 4; i++) {
2014                                 int sx = mb_x * 16 + 4 + 8 * (i & 1);
2015                                 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
2016                                 int xy = (mb_x * 2 + (i & 1) +
2017                                           (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2018                                 int mx = (p->motion_val[direction][xy][0] >> shift) + sx;
2019                                 int my = (p->motion_val[direction][xy][1] >> shift) + sy;
2020                                 draw_arrow(ptr, sx, sy, mx, my, width,
2021                                            height, pict->linesize[0], 100);
2022                             }
2023                         } else if (IS_16X8(p->mb_type[mb_index])) {
2024                             int i;
2025                             for (i = 0; i < 2; i++) {
2026                                 int sx = mb_x * 16 + 8;
2027                                 int sy = mb_y * 16 + 4 + 8 * i;
2028                                 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
2029                                 int mx = (p->motion_val[direction][xy][0] >> shift);
2030                                 int my = (p->motion_val[direction][xy][1] >> shift);
2031
2032                                 if (IS_INTERLACED(p->mb_type[mb_index]))
2033                                     my *= 2;
2034
2035                             draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
2036                                        height, pict->linesize[0], 100);
2037                             }
2038                         } else if (IS_8X16(p->mb_type[mb_index])) {
2039                             int i;
2040                             for (i = 0; i < 2; i++) {
2041                                 int sx = mb_x * 16 + 4 + 8 * i;
2042                                 int sy = mb_y * 16 + 8;
2043                                 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
2044                                 int mx = p->motion_val[direction][xy][0] >> shift;
2045                                 int my = p->motion_val[direction][xy][1] >> shift;
2046
2047                                 if (IS_INTERLACED(p->mb_type[mb_index]))
2048                                     my *= 2;
2049
2050                                 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
2051                                            height, pict->linesize[0], 100);
2052                             }
2053                         } else {
2054                               int sx= mb_x * 16 + 8;
2055                               int sy= mb_y * 16 + 8;
2056                               int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
2057                               int mx= (p->motion_val[direction][xy][0]>>shift) + sx;
2058                               int my= (p->motion_val[direction][xy][1]>>shift) + sy;
2059                               draw_arrow(ptr, sx, sy, mx, my, width, height, pict->linesize[0], 100);
2060                         }
2061                     }
2062                 }
2063                 if ((avctx->debug & FF_DEBUG_VIS_QP)) {
2064                     uint64_t c = (p->qscale_table[mb_index] * 128 / 31) *
2065                                  0x0101010101010101ULL;
2066                     int y;
2067                     for (y = 0; y < block_height; y++) {
2068                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
2069                                       (block_height * mb_y + y) *
2070                                       pict->linesize[1]) = c;
2071                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
2072                                       (block_height * mb_y + y) *
2073                                       pict->linesize[2]) = c;
2074                     }
2075                 }
2076                 if ((avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
2077                     p->motion_val[0]) {
2078                     int mb_type = p->mb_type[mb_index];
2079                     uint64_t u,v;
2080                     int y;
2081 #define COLOR(theta, r) \
2082     u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
2083     v = (int)(128 + r * sin(theta * 3.141592 / 180));
2084
2085
2086                     u = v = 128;
2087                     if (IS_PCM(mb_type)) {
2088                         COLOR(120, 48)
2089                     } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
2090                                IS_INTRA16x16(mb_type)) {
2091                         COLOR(30, 48)
2092                     } else if (IS_INTRA4x4(mb_type)) {
2093                         COLOR(90, 48)
2094                     } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
2095                         // COLOR(120, 48)
2096                     } else if (IS_DIRECT(mb_type)) {
2097                         COLOR(150, 48)
2098                     } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
2099                         COLOR(170, 48)
2100                     } else if (IS_GMC(mb_type)) {
2101                         COLOR(190, 48)
2102                     } else if (IS_SKIP(mb_type)) {
2103                         // COLOR(180, 48)
2104                     } else if (!USES_LIST(mb_type, 1)) {
2105                         COLOR(240, 48)
2106                     } else if (!USES_LIST(mb_type, 0)) {
2107                         COLOR(0, 48)
2108                     } else {
2109                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
2110                         COLOR(300,48)
2111                     }
2112
2113                     u *= 0x0101010101010101ULL;
2114                     v *= 0x0101010101010101ULL;
2115                     for (y = 0; y < block_height; y++) {
2116                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
2117                                       (block_height * mb_y + y) * pict->linesize[1]) = u;
2118                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
2119                                       (block_height * mb_y + y) * pict->linesize[2]) = v;
2120                     }
2121
2122                     // segmentation
2123                     if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
2124                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
2125                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
2126                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
2127                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
2128                     }
2129                     if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
2130                         for (y = 0; y < 16; y++)
2131                             pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
2132                                           pict->linesize[0]] ^= 0x80;
2133                     }
2134                     if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
2135                         int dm = 1 << (mv_sample_log2 - 2);
2136                         for (i = 0; i < 4; i++) {
2137                             int sx = mb_x * 16 + 8 * (i & 1);
2138                             int sy = mb_y * 16 + 8 * (i >> 1);
2139                             int xy = (mb_x * 2 + (i & 1) +
2140                                      (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2141                             // FIXME bidir
2142                             int32_t *mv = (int32_t *) &p->motion_val[0][xy];
2143                             if (mv[0] != mv[dm] ||
2144                                 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
2145                                 for (y = 0; y < 8; y++)
2146                                     pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
2147                             if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
2148                                 *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
2149                                               pict->linesize[0]) ^= 0x8080808080808080ULL;
2150                         }
2151                     }
2152
2153                     if (IS_INTERLACED(mb_type) &&
2154                         avctx->codec->id == AV_CODEC_ID_H264) {
2155                         // hmm
2156                     }
2157                 }
2158                 mbskip_table[mb_index] = 0;
2159             }
2160         }
2161     }
2162 }
2163
2164 void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
2165 {
2166     ff_print_debug_info2(s->avctx, p, pict, s->mbskip_table, &s->low_delay,
2167                          s->mb_width, s->mb_height, s->mb_stride, s->quarter_sample);
2168 }
2169
2170 int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type)
2171 {
2172     AVBufferRef *ref = av_buffer_ref(p->qscale_table_buf);
2173     int offset = 2*s->mb_stride + 1;
2174     if(!ref)
2175         return AVERROR(ENOMEM);
2176     av_assert0(ref->size >= offset + s->mb_stride * ((f->height+15)/16));
2177     ref->size -= offset;
2178     ref->data += offset;
2179     return av_frame_set_qp_table(f, ref, s->mb_stride, qp_type);
2180 }
2181
2182 static inline int hpel_motion_lowres(MpegEncContext *s,
2183                                      uint8_t *dest, uint8_t *src,
2184                                      int field_based, int field_select,
2185                                      int src_x, int src_y,
2186                                      int width, int height, int stride,
2187                                      int h_edge_pos, int v_edge_pos,
2188                                      int w, int h, h264_chroma_mc_func *pix_op,
2189                                      int motion_x, int motion_y)
2190 {
2191     const int lowres   = s->avctx->lowres;
2192     const int op_index = FFMIN(lowres, 2);
2193     const int s_mask   = (2 << lowres) - 1;
2194     int emu = 0;
2195     int sx, sy;
2196
2197     if (s->quarter_sample) {
2198         motion_x /= 2;
2199         motion_y /= 2;
2200     }
2201
2202     sx = motion_x & s_mask;
2203     sy = motion_y & s_mask;
2204     src_x += motion_x >> lowres + 1;
2205     src_y += motion_y >> lowres + 1;
2206
2207     src   += src_y * stride + src_x;
2208
2209     if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w,                 0) ||
2210         (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2211         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w + 1,
2212                                 (h + 1) << field_based, src_x,
2213                                 src_y   << field_based,
2214                                 h_edge_pos,
2215                                 v_edge_pos);
2216         src = s->edge_emu_buffer;
2217         emu = 1;
2218     }
2219
2220     sx = (sx << 2) >> lowres;
2221     sy = (sy << 2) >> lowres;
2222     if (field_select)
2223         src += s->linesize;
2224     pix_op[op_index](dest, src, stride, h, sx, sy);
2225     return emu;
2226 }
2227
2228 /* apply one mpeg motion vector to the three components */
2229 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
2230                                                 uint8_t *dest_y,
2231                                                 uint8_t *dest_cb,
2232                                                 uint8_t *dest_cr,
2233                                                 int field_based,
2234                                                 int bottom_field,
2235                                                 int field_select,
2236                                                 uint8_t **ref_picture,
2237                                                 h264_chroma_mc_func *pix_op,
2238                                                 int motion_x, int motion_y,
2239                                                 int h, int mb_y)
2240 {
2241     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2242     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy,
2243         uvsx, uvsy;
2244     const int lowres     = s->avctx->lowres;
2245     const int op_index   = FFMIN(lowres-1+s->chroma_x_shift, 2);
2246     const int block_s    = 8>>lowres;
2247     const int s_mask     = (2 << lowres) - 1;
2248     const int h_edge_pos = s->h_edge_pos >> lowres;
2249     const int v_edge_pos = s->v_edge_pos >> lowres;
2250     linesize   = s->current_picture.f.linesize[0] << field_based;
2251     uvlinesize = s->current_picture.f.linesize[1] << field_based;
2252
2253     // FIXME obviously not perfect but qpel will not work in lowres anyway
2254     if (s->quarter_sample) {
2255         motion_x /= 2;
2256         motion_y /= 2;
2257     }
2258
2259     if(field_based){
2260         motion_y += (bottom_field - field_select)*((1 << lowres)-1);
2261     }
2262
2263     sx = motion_x & s_mask;
2264     sy = motion_y & s_mask;
2265     src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
2266     src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
2267
2268     if (s->out_format == FMT_H263) {
2269         uvsx    = ((motion_x >> 1) & s_mask) | (sx & 1);
2270         uvsy    = ((motion_y >> 1) & s_mask) | (sy & 1);
2271         uvsrc_x = src_x >> 1;
2272         uvsrc_y = src_y >> 1;
2273     } else if (s->out_format == FMT_H261) {
2274         // even chroma mv's are full pel in H261
2275         mx      = motion_x / 4;
2276         my      = motion_y / 4;
2277         uvsx    = (2 * mx) & s_mask;
2278         uvsy    = (2 * my) & s_mask;
2279         uvsrc_x = s->mb_x * block_s + (mx >> lowres);
2280         uvsrc_y =    mb_y * block_s + (my >> lowres);
2281     } else {
2282         if(s->chroma_y_shift){
2283             mx      = motion_x / 2;
2284             my      = motion_y / 2;
2285             uvsx    = mx & s_mask;
2286             uvsy    = my & s_mask;
2287             uvsrc_x = s->mb_x * block_s                 + (mx >> lowres + 1);
2288             uvsrc_y =   (mb_y * block_s >> field_based) + (my >> lowres + 1);
2289         } else {
2290             if(s->chroma_x_shift){
2291             //Chroma422
2292                 mx = motion_x / 2;
2293                 uvsx = mx & s_mask;
2294                 uvsy = motion_y & s_mask;
2295                 uvsrc_y = src_y;
2296                 uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
2297             } else {
2298             //Chroma444
2299                 uvsx = motion_x & s_mask;
2300                 uvsy = motion_y & s_mask;
2301                 uvsrc_x = src_x;
2302                 uvsrc_y = src_y;
2303             }
2304         }
2305     }
2306
2307     ptr_y  = ref_picture[0] + src_y   * linesize   + src_x;
2308     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2309     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2310
2311     if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s,       0) ||
2312         (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2313         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
2314                                 linesize >> field_based, 17, 17 + field_based,
2315                                 src_x, src_y << field_based, h_edge_pos,
2316                                 v_edge_pos);
2317         ptr_y = s->edge_emu_buffer;
2318         if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2319             uint8_t *uvbuf = s->edge_emu_buffer + 18 * s->linesize;
2320             s->vdsp.emulated_edge_mc(uvbuf , ptr_cb, uvlinesize >> field_based, 9,
2321                                     9 + field_based,
2322                                     uvsrc_x, uvsrc_y << field_based,
2323                                     h_edge_pos >> 1, v_edge_pos >> 1);
2324             s->vdsp.emulated_edge_mc(uvbuf + 16, ptr_cr, uvlinesize >> field_based, 9,
2325                                     9 + field_based,
2326                                     uvsrc_x, uvsrc_y << field_based,
2327                                     h_edge_pos >> 1, v_edge_pos >> 1);
2328             ptr_cb = uvbuf;
2329             ptr_cr = uvbuf + 16;
2330         }
2331     }
2332
2333     // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data
2334     if (bottom_field) {
2335         dest_y  += s->linesize;
2336         dest_cb += s->uvlinesize;
2337         dest_cr += s->uvlinesize;
2338     }
2339
2340     if (field_select) {
2341         ptr_y   += s->linesize;
2342         ptr_cb  += s->uvlinesize;
2343         ptr_cr  += s->uvlinesize;
2344     }
2345
2346     sx = (sx << 2) >> lowres;
2347     sy = (sy << 2) >> lowres;
2348     pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
2349
2350     if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2351         uvsx = (uvsx << 2) >> lowres;
2352         uvsy = (uvsy << 2) >> lowres;
2353         if (h >> s->chroma_y_shift) {
2354             pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2355             pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2356         }
2357     }
2358     // FIXME h261 lowres loop filter
2359 }
2360
2361 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
2362                                             uint8_t *dest_cb, uint8_t *dest_cr,
2363                                             uint8_t **ref_picture,
2364                                             h264_chroma_mc_func * pix_op,
2365                                             int mx, int my)
2366 {
2367     const int lowres     = s->avctx->lowres;
2368     const int op_index   = FFMIN(lowres, 2);
2369     const int block_s    = 8 >> lowres;
2370     const int s_mask     = (2 << lowres) - 1;
2371     const int h_edge_pos = s->h_edge_pos >> lowres + 1;
2372     const int v_edge_pos = s->v_edge_pos >> lowres + 1;
2373     int emu = 0, src_x, src_y, offset, sx, sy;
2374     uint8_t *ptr;
2375
2376     if (s->quarter_sample) {
2377         mx /= 2;
2378         my /= 2;
2379     }
2380
2381     /* In case of 8X8, we construct a single chroma motion vector
2382        with a special rounding */
2383     mx = ff_h263_round_chroma(mx);
2384     my = ff_h263_round_chroma(my);
2385
2386     sx = mx & s_mask;
2387     sy = my & s_mask;
2388     src_x = s->mb_x * block_s + (mx >> lowres + 1);
2389     src_y = s->mb_y * block_s + (my >> lowres + 1);
2390
2391     offset = src_y * s->uvlinesize + src_x;
2392     ptr = ref_picture[1] + offset;
2393     if (s->flags & CODEC_FLAG_EMU_EDGE) {
2394         if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2395             (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2396             s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize,
2397                                     9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
2398             ptr = s->edge_emu_buffer;
2399             emu = 1;
2400         }
2401     }
2402     sx = (sx << 2) >> lowres;
2403     sy = (sy << 2) >> lowres;
2404     pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
2405
2406     ptr = ref_picture[2] + offset;
2407     if (emu) {
2408         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9,
2409                                 src_x, src_y, h_edge_pos, v_edge_pos);
2410         ptr = s->edge_emu_buffer;
2411     }
2412     pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
2413 }
2414
2415 /**
2416  * motion compensation of a single macroblock
2417  * @param s context
2418  * @param dest_y luma destination pointer
2419  * @param dest_cb chroma cb/u destination pointer
2420  * @param dest_cr chroma cr/v destination pointer
2421  * @param dir direction (0->forward, 1->backward)
2422  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2423  * @param pix_op halfpel motion compensation function (average or put normally)
2424  * the motion vectors are taken from s->mv and the MV type from s->mv_type
2425  */
2426 static inline void MPV_motion_lowres(MpegEncContext *s,
2427                                      uint8_t *dest_y, uint8_t *dest_cb,
2428                                      uint8_t *dest_cr,
2429                                      int dir, uint8_t **ref_picture,
2430                                      h264_chroma_mc_func *pix_op)
2431 {
2432     int mx, my;
2433     int mb_x, mb_y, i;
2434     const int lowres  = s->avctx->lowres;
2435     const int block_s = 8 >>lowres;
2436
2437     mb_x = s->mb_x;
2438     mb_y = s->mb_y;
2439
2440     switch (s->mv_type) {
2441     case MV_TYPE_16X16:
2442         mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2443                            0, 0, 0,
2444                            ref_picture, pix_op,
2445                            s->mv[dir][0][0], s->mv[dir][0][1],
2446                            2 * block_s, mb_y);
2447         break;
2448     case MV_TYPE_8X8:
2449         mx = 0;
2450         my = 0;
2451         for (i = 0; i < 4; i++) {
2452             hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
2453                                s->linesize) * block_s,
2454                                ref_picture[0], 0, 0,
2455                                (2 * mb_x + (i & 1)) * block_s,
2456                                (2 * mb_y + (i >> 1)) * block_s,
2457                                s->width, s->height, s->linesize,
2458                                s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
2459                                block_s, block_s, pix_op,
2460                                s->mv[dir][i][0], s->mv[dir][i][1]);
2461
2462             mx += s->mv[dir][i][0];
2463             my += s->mv[dir][i][1];
2464         }
2465
2466         if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY))
2467             chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
2468                                      pix_op, mx, my);
2469         break;
2470     case MV_TYPE_FIELD:
2471         if (s->picture_structure == PICT_FRAME) {
2472             /* top field */
2473             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2474                                1, 0, s->field_select[dir][0],
2475                                ref_picture, pix_op,
2476                                s->mv[dir][0][0], s->mv[dir][0][1],
2477                                block_s, mb_y);
2478             /* bottom field */
2479             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2480                                1, 1, s->field_select[dir][1],
2481                                ref_picture, pix_op,
2482                                s->mv[dir][1][0], s->mv[dir][1][1],
2483                                block_s, mb_y);
2484         } else {
2485             if (s->picture_structure != s->field_select[dir][0] + 1 &&
2486                 s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
2487                 ref_picture = s->current_picture_ptr->f.data;
2488
2489             }
2490             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2491                                0, 0, s->field_select[dir][0],
2492                                ref_picture, pix_op,
2493                                s->mv[dir][0][0],
2494                                s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
2495             }
2496         break;
2497     case MV_TYPE_16X8:
2498         for (i = 0; i < 2; i++) {
2499             uint8_t **ref2picture;
2500
2501             if (s->picture_structure == s->field_select[dir][i] + 1 ||
2502                 s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
2503                 ref2picture = ref_picture;
2504             } else {
2505                 ref2picture = s->current_picture_ptr->f.data;
2506             }
2507
2508             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2509                                0, 0, s->field_select[dir][i],
2510                                ref2picture, pix_op,
2511                                s->mv[dir][i][0], s->mv[dir][i][1] +
2512                                2 * block_s * i, block_s, mb_y >> 1);
2513
2514             dest_y  +=  2 * block_s *  s->linesize;
2515             dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2516             dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2517         }
2518         break;
2519     case MV_TYPE_DMV:
2520         if (s->picture_structure == PICT_FRAME) {
2521             for (i = 0; i < 2; i++) {
2522                 int j;
2523                 for (j = 0; j < 2; j++) {
2524                     mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2525                                        1, j, j ^ i,
2526                                        ref_picture, pix_op,
2527                                        s->mv[dir][2 * i + j][0],
2528                                        s->mv[dir][2 * i + j][1],
2529                                        block_s, mb_y);
2530                 }
2531                 pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
2532             }
2533         } else {
2534             for (i = 0; i < 2; i++) {
2535                 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2536                                    0, 0, s->picture_structure != i + 1,
2537                                    ref_picture, pix_op,
2538                                    s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
2539                                    2 * block_s, mb_y >> 1);
2540
2541                 // after put we make avg of the same block
2542                 pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
2543
2544                 // opposite parity is always in the same
2545                 // frame if this is second field
2546                 if (!s->first_field) {
2547                     ref_picture = s->current_picture_ptr->f.data;
2548                 }
2549             }
2550         }
2551         break;
2552     default:
2553         av_assert2(0);
2554     }
2555 }
2556
2557 /**
2558  * find the lowest MB row referenced in the MVs
2559  */
2560 int ff_MPV_lowest_referenced_row(MpegEncContext *s, int dir)
2561 {
2562     int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2563     int my, off, i, mvs;
2564
2565     if (s->picture_structure != PICT_FRAME || s->mcsel)
2566         goto unhandled;
2567
2568     switch (s->mv_type) {
2569         case MV_TYPE_16X16:
2570             mvs = 1;
2571             break;
2572         case MV_TYPE_16X8:
2573             mvs = 2;
2574             break;
2575         case MV_TYPE_8X8:
2576             mvs = 4;
2577             break;
2578         default:
2579             goto unhandled;
2580     }
2581
2582     for (i = 0; i < mvs; i++) {
2583         my = s->mv[dir][i][1]<<qpel_shift;
2584         my_max = FFMAX(my_max, my);
2585         my_min = FFMIN(my_min, my);
2586     }
2587
2588     off = (FFMAX(-my_min, my_max) + 63) >> 6;
2589
2590     return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
2591 unhandled:
2592     return s->mb_height-1;
2593 }
2594
2595 /* put block[] to dest[] */
2596 static inline void put_dct(MpegEncContext *s,
2597                            int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2598 {
2599     s->dct_unquantize_intra(s, block, i, qscale);
2600     s->dsp.idct_put (dest, line_size, block);
2601 }
2602
2603 /* add block[] to dest[] */
2604 static inline void add_dct(MpegEncContext *s,
2605                            int16_t *block, int i, uint8_t *dest, int line_size)
2606 {
2607     if (s->block_last_index[i] >= 0) {
2608         s->dsp.idct_add (dest, line_size, block);
2609     }
2610 }
2611
2612 static inline void add_dequant_dct(MpegEncContext *s,
2613                            int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2614 {
2615     if (s->block_last_index[i] >= 0) {
2616         s->dct_unquantize_inter(s, block, i, qscale);
2617
2618         s->dsp.idct_add (dest, line_size, block);
2619     }
2620 }
2621
2622 /**
2623  * Clean dc, ac, coded_block for the current non-intra MB.
2624  */
2625 void ff_clean_intra_table_entries(MpegEncContext *s)
2626 {
2627     int wrap = s->b8_stride;
2628     int xy = s->block_index[0];
2629
2630     s->dc_val[0][xy           ] =
2631     s->dc_val[0][xy + 1       ] =
2632     s->dc_val[0][xy     + wrap] =
2633     s->dc_val[0][xy + 1 + wrap] = 1024;
2634     /* ac pred */
2635     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
2636     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2637     if (s->msmpeg4_version>=3) {
2638         s->coded_block[xy           ] =
2639         s->coded_block[xy + 1       ] =
2640         s->coded_block[xy     + wrap] =
2641         s->coded_block[xy + 1 + wrap] = 0;
2642     }
2643     /* chroma */
2644     wrap = s->mb_stride;
2645     xy = s->mb_x + s->mb_y * wrap;
2646     s->dc_val[1][xy] =
2647     s->dc_val[2][xy] = 1024;
2648     /* ac pred */
2649     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2650     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2651
2652     s->mbintra_table[xy]= 0;
2653 }
2654
2655 /* generic function called after a macroblock has been parsed by the
2656    decoder or after it has been encoded by the encoder.
2657
2658    Important variables used:
2659    s->mb_intra : true if intra macroblock
2660    s->mv_dir   : motion vector direction
2661    s->mv_type  : motion vector type
2662    s->mv       : motion vector
2663    s->interlaced_dct : true if interlaced dct used (mpeg2)
2664  */
2665 static av_always_inline
2666 void MPV_decode_mb_internal(MpegEncContext *s, int16_t block[12][64],
2667                             int lowres_flag, int is_mpeg12)
2668 {
2669     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2670     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2671         ff_xvmc_decode_mb(s);//xvmc uses pblocks
2672         return;
2673     }
2674
2675     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2676        /* print DCT coefficients */
2677        int i,j;
2678        av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2679        for(i=0; i<6; i++){
2680            for(j=0; j<64; j++){
2681                av_log(s->avctx, AV_LOG_DEBUG, "%5d", block[i][s->dsp.idct_permutation[j]]);
2682            }
2683            av_log(s->avctx, AV_LOG_DEBUG, "\n");
2684        }
2685     }
2686
2687     s->current_picture.qscale_table[mb_xy] = s->qscale;
2688
2689     /* update DC predictors for P macroblocks */
2690     if (!s->mb_intra) {
2691         if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2692             if(s->mbintra_table[mb_xy])
2693                 ff_clean_intra_table_entries(s);
2694         } else {
2695             s->last_dc[0] =
2696             s->last_dc[1] =
2697             s->last_dc[2] = 128 << s->intra_dc_precision;
2698         }
2699     }
2700     else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2701         s->mbintra_table[mb_xy]=1;
2702
2703     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
2704         uint8_t *dest_y, *dest_cb, *dest_cr;
2705         int dct_linesize, dct_offset;
2706         op_pixels_func (*op_pix)[4];
2707         qpel_mc_func (*op_qpix)[16];
2708         const int linesize   = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2709         const int uvlinesize = s->current_picture.f.linesize[1];
2710         const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2711         const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2712
2713         /* avoid copy if macroblock skipped in last frame too */
2714         /* skip only during decoding as we might trash the buffers during encoding a bit */
2715         if(!s->encoding){
2716             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2717
2718             if (s->mb_skipped) {
2719                 s->mb_skipped= 0;
2720                 av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
2721                 *mbskip_ptr = 1;
2722             } else if(!s->current_picture.reference) {
2723                 *mbskip_ptr = 1;
2724             } else{
2725                 *mbskip_ptr = 0; /* not skipped */
2726             }
2727         }
2728
2729         dct_linesize = linesize << s->interlaced_dct;
2730         dct_offset   = s->interlaced_dct ? linesize : linesize * block_size;
2731
2732         if(readable){
2733             dest_y=  s->dest[0];
2734             dest_cb= s->dest[1];
2735             dest_cr= s->dest[2];
2736         }else{
2737             dest_y = s->b_scratchpad;
2738             dest_cb= s->b_scratchpad+16*linesize;
2739             dest_cr= s->b_scratchpad+32*linesize;
2740         }
2741
2742         if (!s->mb_intra) {
2743             /* motion handling */
2744             /* decoding or more than one mb_type (MC was already done otherwise) */
2745             if(!s->encoding){
2746
2747                 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2748                     if (s->mv_dir & MV_DIR_FORWARD) {
2749                         ff_thread_await_progress(&s->last_picture_ptr->tf,
2750                                                  ff_MPV_lowest_referenced_row(s, 0),
2751                                                  0);
2752                     }
2753                     if (s->mv_dir & MV_DIR_BACKWARD) {
2754                         ff_thread_await_progress(&s->next_picture_ptr->tf,
2755                                                  ff_MPV_lowest_referenced_row(s, 1),
2756                                                  0);
2757                     }
2758                 }
2759
2760                 if(lowres_flag){
2761                     h264_chroma_mc_func *op_pix = s->h264chroma.put_h264_chroma_pixels_tab;
2762
2763                     if (s->mv_dir & MV_DIR_FORWARD) {
2764                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix);
2765                         op_pix = s->h264chroma.avg_h264_chroma_pixels_tab;
2766                     }
2767                     if (s->mv_dir & MV_DIR_BACKWARD) {
2768                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix);
2769                     }
2770                 }else{
2771                     op_qpix= s->me.qpel_put;
2772                     if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2773                         op_pix = s->hdsp.put_pixels_tab;
2774                     }else{
2775                         op_pix = s->hdsp.put_no_rnd_pixels_tab;
2776                     }
2777                     if (s->mv_dir & MV_DIR_FORWARD) {
2778                         ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
2779                         op_pix = s->hdsp.avg_pixels_tab;
2780                         op_qpix= s->me.qpel_avg;
2781                     }
2782                     if (s->mv_dir & MV_DIR_BACKWARD) {
2783                         ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
2784                     }
2785                 }
2786             }
2787
2788             /* skip dequant / idct if we are really late ;) */
2789             if(s->avctx->skip_idct){
2790                 if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2791                    ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2792                    || s->avctx->skip_idct >= AVDISCARD_ALL)
2793                     goto skip_idct;
2794             }
2795
2796             /* add dct residue */
2797             if(s->encoding || !(   s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
2798                                 || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
2799                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2800                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2801                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2802                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2803
2804                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2805                     if (s->chroma_y_shift){
2806                         add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2807                         add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2808                     }else{
2809                         dct_linesize >>= 1;
2810                         dct_offset >>=1;
2811                         add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2812                         add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2813                         add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2814                         add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2815                     }
2816                 }
2817             } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
2818                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
2819                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
2820                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
2821                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2822
2823                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2824                     if(s->chroma_y_shift){//Chroma420
2825                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
2826                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
2827                     }else{
2828                         //chroma422
2829                         dct_linesize = uvlinesize << s->interlaced_dct;
2830                         dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2831
2832                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
2833                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
2834                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2835                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2836                         if(!s->chroma_x_shift){//Chroma444
2837                             add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2838                             add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2839                             add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2840                             add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2841                         }
2842                     }
2843                 }//fi gray
2844             }
2845             else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2846                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2847             }
2848         } else {
2849             /* dct only in intra block */
2850             if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
2851                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2852                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2853                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2854                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2855
2856                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2857                     if(s->chroma_y_shift){
2858                         put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2859                         put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2860                     }else{
2861                         dct_offset >>=1;
2862                         dct_linesize >>=1;
2863                         put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2864                         put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2865                         put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2866                         put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2867                     }
2868                 }
2869             }else{
2870                 s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
2871                 s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
2872                 s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
2873                 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2874
2875                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2876                     if(s->chroma_y_shift){
2877                         s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2878                         s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2879                     }else{
2880
2881                         dct_linesize = uvlinesize << s->interlaced_dct;
2882                         dct_offset   = s->interlaced_dct? uvlinesize : uvlinesize*block_size;
2883
2884                         s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
2885                         s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
2886                         s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2887                         s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2888                         if(!s->chroma_x_shift){//Chroma444
2889                             s->dsp.idct_put(dest_cb + block_size,              dct_linesize, block[8]);
2890                             s->dsp.idct_put(dest_cr + block_size,              dct_linesize, block[9]);
2891                             s->dsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2892                             s->dsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2893                         }
2894                     }
2895                 }//gray
2896             }
2897         }
2898 skip_idct:
2899         if(!readable){
2900             s->hdsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
2901             s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2902             s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2903         }
2904     }
2905 }
2906
2907 void ff_MPV_decode_mb(MpegEncContext *s, int16_t block[12][64]){
2908 #if !CONFIG_SMALL
2909     if(s->out_format == FMT_MPEG1) {
2910         if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2911         else                 MPV_decode_mb_internal(s, block, 0, 1);
2912     } else
2913 #endif
2914     if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2915     else                  MPV_decode_mb_internal(s, block, 0, 0);
2916 }
2917
2918 /**
2919  * @param h is the normal height, this will be reduced automatically if needed for the last row
2920  */
2921 void ff_draw_horiz_band(AVCodecContext *avctx, DSPContext *dsp, Picture *cur,
2922                         Picture *last, int y, int h, int picture_structure,
2923                         int first_field, int draw_edges, int low_delay,
2924                         int v_edge_pos, int h_edge_pos)
2925 {
2926     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
2927     int hshift = desc->log2_chroma_w;
2928     int vshift = desc->log2_chroma_h;
2929     const int field_pic = picture_structure != PICT_FRAME;
2930     if(field_pic){
2931         h <<= 1;
2932         y <<= 1;
2933     }
2934
2935     if (!avctx->hwaccel &&
2936         !(avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
2937         draw_edges &&
2938         cur->reference &&
2939         !(avctx->flags & CODEC_FLAG_EMU_EDGE)) {
2940         int *linesize = cur->f.linesize;
2941         int sides = 0, edge_h;
2942         if (y==0) sides |= EDGE_TOP;
2943         if (y + h >= v_edge_pos)
2944             sides |= EDGE_BOTTOM;
2945
2946         edge_h= FFMIN(h, v_edge_pos - y);
2947
2948         dsp->draw_edges(cur->f.data[0] + y * linesize[0],
2949                         linesize[0], h_edge_pos, edge_h,
2950                         EDGE_WIDTH, EDGE_WIDTH, sides);
2951         dsp->draw_edges(cur->f.data[1] + (y >> vshift) * linesize[1],
2952                         linesize[1], h_edge_pos >> hshift, edge_h >> vshift,
2953                         EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift, sides);
2954         dsp->draw_edges(cur->f.data[2] + (y >> vshift) * linesize[2],
2955                         linesize[2], h_edge_pos >> hshift, edge_h >> vshift,
2956                         EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift, sides);
2957     }
2958
2959     h = FFMIN(h, avctx->height - y);
2960
2961     if(field_pic && first_field && !(avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2962
2963     if (avctx->draw_horiz_band) {
2964         AVFrame *src;
2965         int offset[AV_NUM_DATA_POINTERS];
2966         int i;
2967
2968         if(cur->f.pict_type == AV_PICTURE_TYPE_B || low_delay ||
2969            (avctx->slice_flags & SLICE_FLAG_CODED_ORDER))
2970             src = &cur->f;
2971         else if (last)
2972             src = &last->f;
2973         else
2974             return;
2975
2976         if (cur->f.pict_type == AV_PICTURE_TYPE_B &&
2977             picture_structure == PICT_FRAME &&
2978             avctx->codec_id != AV_CODEC_ID_SVQ3) {
2979             for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
2980                 offset[i] = 0;
2981         }else{
2982             offset[0]= y * src->linesize[0];
2983             offset[1]=
2984             offset[2]= (y >> vshift) * src->linesize[1];
2985             for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
2986                 offset[i] = 0;
2987         }
2988
2989         emms_c();
2990
2991         avctx->draw_horiz_band(avctx, src, offset,
2992                                y, picture_structure, h);
2993     }
2994 }
2995
2996 void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
2997 {
2998     int draw_edges = s->unrestricted_mv && !s->intra_only;
2999     ff_draw_horiz_band(s->avctx, &s->dsp, &s->current_picture,
3000                        &s->last_picture, y, h, s->picture_structure,
3001                        s->first_field, draw_edges, s->low_delay,
3002                        s->v_edge_pos, s->h_edge_pos);
3003 }
3004
3005 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3006     const int linesize   = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
3007     const int uvlinesize = s->current_picture.f.linesize[1];
3008     const int mb_size= 4 - s->avctx->lowres;
3009
3010     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
3011     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
3012     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
3013     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3014     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
3015     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;
3016     //block_index is not used by mpeg2, so it is not affected by chroma_format
3017
3018     s->dest[0] = s->current_picture.f.data[0] + ((s->mb_x - 1) <<  mb_size);
3019     s->dest[1] = s->current_picture.f.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3020     s->dest[2] = s->current_picture.f.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3021
3022     if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
3023     {
3024         if(s->picture_structure==PICT_FRAME){
3025         s->dest[0] += s->mb_y *   linesize << mb_size;
3026         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3027         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3028         }else{
3029             s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
3030             s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
3031             s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
3032             av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
3033         }
3034     }
3035 }
3036
3037 /**
3038  * Permute an 8x8 block.
3039  * @param block the block which will be permuted according to the given permutation vector
3040  * @param permutation the permutation vector
3041  * @param last the last non zero coefficient in scantable order, used to speed the permutation up
3042  * @param scantable the used scantable, this is only used to speed the permutation up, the block is not
3043  *                  (inverse) permutated to scantable order!
3044  */
3045 void ff_block_permute(int16_t *block, uint8_t *permutation, const uint8_t *scantable, int last)
3046 {
3047     int i;
3048     int16_t temp[64];
3049
3050     if(last<=0) return;
3051     //if(permutation[1]==1) return; //FIXME it is ok but not clean and might fail for some permutations
3052
3053     for(i=0; i<=last; i++){
3054         const int j= scantable[i];
3055         temp[j]= block[j];
3056         block[j]=0;
3057     }
3058
3059     for(i=0; i<=last; i++){
3060         const int j= scantable[i];
3061         const int perm_j= permutation[j];
3062         block[perm_j]= temp[j];
3063     }
3064 }
3065
3066 void ff_mpeg_flush(AVCodecContext *avctx){
3067     int i;
3068     MpegEncContext *s = avctx->priv_data;
3069
3070     if(s==NULL || s->picture==NULL)
3071         return;
3072
3073     for (i = 0; i < MAX_PICTURE_COUNT; i++)
3074         ff_mpeg_unref_picture(s, &s->picture[i]);
3075     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
3076
3077     ff_mpeg_unref_picture(s, &s->current_picture);
3078     ff_mpeg_unref_picture(s, &s->last_picture);
3079     ff_mpeg_unref_picture(s, &s->next_picture);
3080
3081     s->mb_x= s->mb_y= 0;
3082     s->closed_gop= 0;
3083
3084     s->parse_context.state= -1;
3085     s->parse_context.frame_start_found= 0;
3086     s->parse_context.overread= 0;
3087     s->parse_context.overread_index= 0;
3088     s->parse_context.index= 0;
3089     s->parse_context.last_index= 0;
3090     s->bitstream_buffer_size=0;
3091     s->pp_time=0;
3092 }
3093
3094 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
3095                                    int16_t *block, int n, int qscale)
3096 {
3097     int i, level, nCoeffs;
3098     const uint16_t *quant_matrix;
3099
3100     nCoeffs= s->block_last_index[n];
3101
3102     block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
3103     /* XXX: only mpeg1 */
3104     quant_matrix = s->intra_matrix;
3105     for(i=1;i<=nCoeffs;i++) {
3106         int j= s->intra_scantable.permutated[i];
3107         level = block[j];
3108         if (level) {
3109             if (level < 0) {
3110                 level = -level;
3111                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3112                 level = (level - 1) | 1;
3113                 level = -level;
3114             } else {
3115                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3116                 level = (level - 1) | 1;
3117             }
3118             block[j] = level;
3119         }
3120     }
3121 }
3122
3123 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
3124                                    int16_t *block, int n, int qscale)
3125 {
3126     int i, level, nCoeffs;
3127     const uint16_t *quant_matrix;
3128
3129     nCoeffs= s->block_last_index[n];
3130
3131     quant_matrix = s->inter_matrix;
3132     for(i=0; i<=nCoeffs; i++) {
3133         int j= s->intra_scantable.permutated[i];
3134         level = block[j];
3135         if (level) {
3136             if (level < 0) {
3137                 level = -level;
3138                 level = (((level << 1) + 1) * qscale *
3139                          ((int) (quant_matrix[j]))) >> 4;
3140                 level = (level - 1) | 1;
3141                 level = -level;
3142             } else {
3143                 level = (((level << 1) + 1) * qscale *
3144                          ((int) (quant_matrix[j]))) >> 4;
3145                 level = (level - 1) | 1;
3146             }
3147             block[j] = level;
3148         }
3149     }
3150 }
3151
3152 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
3153                                    int16_t *block, int n, int qscale)
3154 {
3155     int i, level, nCoeffs;
3156     const uint16_t *quant_matrix;
3157
3158     if(s->alternate_scan) nCoeffs= 63;
3159     else nCoeffs= s->block_last_index[n];
3160
3161     block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
3162     quant_matrix = s->intra_matrix;
3163     for(i=1;i<=nCoeffs;i++) {
3164         int j= s->intra_scantable.permutated[i];
3165         level = block[j];
3166         if (level) {
3167             if (level < 0) {
3168                 level = -level;
3169                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3170                 level = -level;
3171             } else {
3172                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3173             }
3174             block[j] = level;
3175         }
3176     }
3177 }
3178
3179 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
3180                                    int16_t *block, int n, int qscale)
3181 {
3182     int i, level, nCoeffs;
3183     const uint16_t *quant_matrix;
3184     int sum=-1;
3185
3186     if(s->alternate_scan) nCoeffs= 63;
3187     else nCoeffs= s->block_last_index[n];
3188
3189     block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
3190     sum += block[0];
3191     quant_matrix = s->intra_matrix;
3192     for(i=1;i<=nCoeffs;i++) {
3193         int j= s->intra_scantable.permutated[i];
3194         level = block[j];
3195         if (level) {
3196             if (level < 0) {
3197                 level = -level;
3198                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3199                 level = -level;
3200             } else {
3201                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3202             }
3203             block[j] = level;
3204             sum+=level;
3205         }
3206     }
3207     block[63]^=sum&1;
3208 }
3209
3210 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
3211                                    int16_t *block, int n, int qscale)
3212 {
3213     int i, level, nCoeffs;
3214     const uint16_t *quant_matrix;
3215     int sum=-1;
3216
3217     if(s->alternate_scan) nCoeffs= 63;
3218     else nCoeffs= s->block_last_index[n];
3219
3220     quant_matrix = s->inter_matrix;
3221     for(i=0; i<=nCoeffs; i++) {
3222         int j= s->intra_scantable.permutated[i];
3223         level = block[j];
3224         if (level) {
3225             if (level < 0) {
3226                 level = -level;
3227                 level = (((level << 1) + 1) * qscale *
3228                          ((int) (quant_matrix[j]))) >> 4;
3229                 level = -level;
3230             } else {
3231                 level = (((level << 1) + 1) * qscale *
3232                          ((int) (quant_matrix[j]))) >> 4;
3233             }
3234             block[j] = level;
3235             sum+=level;
3236         }
3237     }
3238     block[63]^=sum&1;
3239 }
3240
3241 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
3242                                   int16_t *block, int n, int qscale)
3243 {
3244     int i, level, qmul, qadd;
3245     int nCoeffs;
3246
3247     av_assert2(s->block_last_index[n]>=0);
3248
3249     qmul = qscale << 1;
3250
3251     if (!s->h263_aic) {
3252         block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
3253         qadd = (qscale - 1) | 1;
3254     }else{
3255         qadd = 0;
3256     }
3257     if(s->ac_pred)
3258         nCoeffs=63;
3259     else
3260         nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
3261
3262     for(i=1; i<=nCoeffs; i++) {
3263         level = block[i];
3264         if (level) {
3265             if (level < 0) {
3266                 level = level * qmul - qadd;
3267             } else {
3268                 level = level * qmul + qadd;
3269             }
3270             block[i] = level;
3271         }
3272     }
3273 }
3274
3275 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
3276                                   int16_t *block, int n, int qscale)
3277 {
3278     int i, level, qmul, qadd;
3279     int nCoeffs;
3280
3281     av_assert2(s->block_last_index[n]>=0);
3282
3283     qadd = (qscale - 1) | 1;
3284     qmul = qscale << 1;
3285
3286     nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
3287
3288     for(i=0; i<=nCoeffs; i++) {
3289         level = block[i];
3290         if (level) {
3291             if (level < 0) {
3292                 level = level * qmul - qadd;
3293             } else {
3294                 level = level * qmul + qadd;
3295             }
3296             block[i] = level;
3297         }
3298     }
3299 }
3300
3301 /**
3302  * set qscale and update qscale dependent variables.
3303  */
3304 void ff_set_qscale(MpegEncContext * s, int qscale)
3305 {
3306     if (qscale < 1)
3307         qscale = 1;
3308     else if (qscale > 31)
3309         qscale = 31;
3310
3311     s->qscale = qscale;
3312     s->chroma_qscale= s->chroma_qscale_table[qscale];
3313
3314     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
3315     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
3316 }
3317
3318 void ff_MPV_report_decode_progress(MpegEncContext *s)
3319 {
3320     if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->er.error_occurred)
3321         ff_thread_report_progress(&s->current_picture_ptr->tf, s->mb_y, 0);
3322 }
3323
3324 #if CONFIG_ERROR_RESILIENCE
3325 void ff_mpeg_er_frame_start(MpegEncContext *s)
3326 {
3327     ERContext *er = &s->er;
3328
3329     er->cur_pic  = s->current_picture_ptr;
3330     er->last_pic = s->last_picture_ptr;
3331     er->next_pic = s->next_picture_ptr;
3332
3333     er->pp_time           = s->pp_time;
3334     er->pb_time           = s->pb_time;
3335     er->quarter_sample    = s->quarter_sample;
3336     er->partitioned_frame = s->partitioned_frame;
3337
3338     ff_er_frame_start(er);
3339 }
3340 #endif /* CONFIG_ERROR_RESILIENCE */