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