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