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     if (ref)
 150         av_log(s->avctx, AV_LOG_DEBUG, "Interlaced error concealment is not fully implemented\n");
 151     ff_MPV_decode_mb(s, s->block);
 152 }
 153
 154 /* init common dct for both encoder and decoder */
 155 av_cold int ff_dct_common_init(MpegEncContext *s)
 156 {
 157     ff_dsputil_init(&s->dsp, s->avctx);
 158     ff_h264chroma_init(&s->h264chroma, 8); //for lowres
 159     ff_hpeldsp_init(&s->hdsp, s->avctx->flags);
 160     ff_videodsp_init(&s->vdsp, s->avctx->bits_per_raw_sample);
 161
 162     s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
 163     s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
 164     s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
 165     s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
 166     s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
 167     if (s->flags & CODEC_FLAG_BITEXACT)
 168         s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
 169     s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
 170
 171     if (ARCH_ALPHA)
 172         ff_MPV_common_init_axp(s);
 173     if (ARCH_ARM)
 174         ff_MPV_common_init_arm(s);
 175     if (ARCH_BFIN)
 176         ff_MPV_common_init_bfin(s);
 177     if (ARCH_PPC)
 178         ff_MPV_common_init_ppc(s);
 179     if (ARCH_X86)
 180         ff_MPV_common_init_x86(s);
 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         av_assert0(pic->f.data[0]);
 389         pic->shared = 1;
 390     } else {
 391         av_assert0(!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             err = init_duplicate_context(s);
1227             if (err < 0)
1228                 goto fail;
1229             s->start_mb_y = 0;
1230             s->end_mb_y   = s->mb_height;
1231         }
1232         s->slice_context_count = nb_slices;
1233     }
1234
1235     return 0;
1236  fail:
1237     ff_MPV_common_end(s);
1238     return err;
1239 }
1240
1241 /* init common structure for both encoder and decoder */
1242 void ff_MPV_common_end(MpegEncContext *s)
1243 {
1244     int i;
1245
1246     if (s->slice_context_count > 1) {
1247         for (i = 0; i < s->slice_context_count; i++) {
1248             free_duplicate_context(s->thread_context[i]);
1249         }
1250         for (i = 1; i < s->slice_context_count; i++) {
1251             av_freep(&s->thread_context[i]);
1252         }
1253         s->slice_context_count = 1;
1254     } else free_duplicate_context(s);
1255
1256     av_freep(&s->parse_context.buffer);
1257     s->parse_context.buffer_size = 0;
1258
1259     av_freep(&s->bitstream_buffer);
1260     s->allocated_bitstream_buffer_size = 0;
1261
1262     av_freep(&s->avctx->stats_out);
1263     av_freep(&s->ac_stats);
1264
1265     if(s->q_chroma_intra_matrix   != s->q_intra_matrix  ) av_freep(&s->q_chroma_intra_matrix);
1266     if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
1267     s->q_chroma_intra_matrix=   NULL;
1268     s->q_chroma_intra_matrix16= NULL;
1269     av_freep(&s->q_intra_matrix);
1270     av_freep(&s->q_inter_matrix);
1271     av_freep(&s->q_intra_matrix16);
1272     av_freep(&s->q_inter_matrix16);
1273     av_freep(&s->input_picture);
1274     av_freep(&s->reordered_input_picture);
1275     av_freep(&s->dct_offset);
1276
1277     if (s->picture) {
1278         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1279             free_picture_tables(&s->picture[i]);
1280             ff_mpeg_unref_picture(s, &s->picture[i]);
1281         }
1282     }
1283     av_freep(&s->picture);
1284     free_picture_tables(&s->last_picture);
1285     ff_mpeg_unref_picture(s, &s->last_picture);
1286     free_picture_tables(&s->current_picture);
1287     ff_mpeg_unref_picture(s, &s->current_picture);
1288     free_picture_tables(&s->next_picture);
1289     ff_mpeg_unref_picture(s, &s->next_picture);
1290     free_picture_tables(&s->new_picture);
1291     ff_mpeg_unref_picture(s, &s->new_picture);
1292
1293     free_context_frame(s);
1294
1295     s->context_initialized      = 0;
1296     s->last_picture_ptr         =
1297     s->next_picture_ptr         =
1298     s->current_picture_ptr      = NULL;
1299     s->linesize = s->uvlinesize = 0;
1300 }
1301
1302 av_cold void ff_init_rl(RLTable *rl,
1303                         uint8_t static_store[2][2 * MAX_RUN + MAX_LEVEL + 3])
1304 {
1305     int8_t  max_level[MAX_RUN + 1], max_run[MAX_LEVEL + 1];
1306     uint8_t index_run[MAX_RUN + 1];
1307     int last, run, level, start, end, i;
1308
1309     /* If table is static, we can quit if rl->max_level[0] is not NULL */
1310     if (static_store && rl->max_level[0])
1311         return;
1312
1313     /* compute max_level[], max_run[] and index_run[] */
1314     for (last = 0; last < 2; last++) {
1315         if (last == 0) {
1316             start = 0;
1317             end = rl->last;
1318         } else {
1319             start = rl->last;
1320             end = rl->n;
1321         }
1322
1323         memset(max_level, 0, MAX_RUN + 1);
1324         memset(max_run, 0, MAX_LEVEL + 1);
1325         memset(index_run, rl->n, MAX_RUN + 1);
1326         for (i = start; i < end; i++) {
1327             run   = rl->table_run[i];
1328             level = rl->table_level[i];
1329             if (index_run[run] == rl->n)
1330                 index_run[run] = i;
1331             if (level > max_level[run])
1332                 max_level[run] = level;
1333             if (run > max_run[level])
1334                 max_run[level] = run;
1335         }
1336         if (static_store)
1337             rl->max_level[last] = static_store[last];
1338         else
1339             rl->max_level[last] = av_malloc(MAX_RUN + 1);
1340         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1341         if (static_store)
1342             rl->max_run[last]   = static_store[last] + MAX_RUN + 1;
1343         else
1344             rl->max_run[last]   = av_malloc(MAX_LEVEL + 1);
1345         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1346         if (static_store)
1347             rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
1348         else
1349             rl->index_run[last] = av_malloc(MAX_RUN + 1);
1350         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1351     }
1352 }
1353
1354 av_cold void ff_init_vlc_rl(RLTable *rl)
1355 {
1356     int i, q;
1357
1358     for (q = 0; q < 32; q++) {
1359         int qmul = q * 2;
1360         int qadd = (q - 1) | 1;
1361
1362         if (q == 0) {
1363             qmul = 1;
1364             qadd = 0;
1365         }
1366         for (i = 0; i < rl->vlc.table_size; i++) {
1367             int code = rl->vlc.table[i][0];
1368             int len  = rl->vlc.table[i][1];
1369             int level, run;
1370
1371             if (len == 0) { // illegal code
1372                 run   = 66;
1373                 level = MAX_LEVEL;
1374             } else if (len < 0) { // more bits needed
1375                 run   = 0;
1376                 level = code;
1377             } else {
1378                 if (code == rl->n) { // esc
1379                     run   = 66;
1380                     level =  0;
1381                 } else {
1382                     run   = rl->table_run[code] + 1;
1383                     level = rl->table_level[code] * qmul + qadd;
1384                     if (code >= rl->last) run += 192;
1385                 }
1386             }
1387             rl->rl_vlc[q][i].len   = len;
1388             rl->rl_vlc[q][i].level = level;
1389             rl->rl_vlc[q][i].run   = run;
1390         }
1391     }
1392 }
1393
1394 void ff_release_unused_pictures(MpegEncContext*s, int remove_current)
1395 {
1396     int i;
1397
1398     /* release non reference frames */
1399     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1400         if (!s->picture[i].reference &&
1401             (remove_current || &s->picture[i] !=  s->current_picture_ptr)) {
1402             ff_mpeg_unref_picture(s, &s->picture[i]);
1403         }
1404     }
1405 }
1406
1407 static inline int pic_is_unused(MpegEncContext *s, Picture *pic)
1408 {
1409     if (pic == s->last_picture_ptr)
1410         return 0;
1411     if (pic->f.data[0] == NULL)
1412         return 1;
1413     if (pic->needs_realloc && !(pic->reference & DELAYED_PIC_REF))
1414         return 1;
1415     return 0;
1416 }
1417
1418 static int find_unused_picture(MpegEncContext *s, int shared)
1419 {
1420     int i;
1421
1422     if (shared) {
1423         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1424             if (s->picture[i].f.data[0] == NULL && &s->picture[i] != s->last_picture_ptr)
1425                 return i;
1426         }
1427     } else {
1428         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1429             if (pic_is_unused(s, &s->picture[i]))
1430                 return i;
1431         }
1432     }
1433
1434     av_log(s->avctx, AV_LOG_FATAL,
1435            "Internal error, picture buffer overflow\n");
1436     /* We could return -1, but the codec would crash trying to draw into a
1437      * non-existing frame anyway. This is safer than waiting for a random crash.
1438      * Also the return of this is never useful, an encoder must only allocate
1439      * as much as allowed in the specification. This has no relationship to how
1440      * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
1441      * enough for such valid streams).
1442      * Plus, a decoder has to check stream validity and remove frames if too
1443      * many reference frames are around. Waiting for "OOM" is not correct at
1444      * all. Similarly, missing reference frames have to be replaced by
1445      * interpolated/MC frames, anything else is a bug in the codec ...
1446      */
1447     abort();
1448     return -1;
1449 }
1450
1451 int ff_find_unused_picture(MpegEncContext *s, int shared)
1452 {
1453     int ret = find_unused_picture(s, shared);
1454
1455     if (ret >= 0 && ret < MAX_PICTURE_COUNT) {
1456         if (s->picture[ret].needs_realloc) {
1457             s->picture[ret].needs_realloc = 0;
1458             free_picture_tables(&s->picture[ret]);
1459             ff_mpeg_unref_picture(s, &s->picture[ret]);
1460             avcodec_get_frame_defaults(&s->picture[ret].f);
1461         }
1462     }
1463     return ret;
1464 }
1465
1466 static void update_noise_reduction(MpegEncContext *s)
1467 {
1468     int intra, i;
1469
1470     for (intra = 0; intra < 2; intra++) {
1471         if (s->dct_count[intra] > (1 << 16)) {
1472             for (i = 0; i < 64; i++) {
1473                 s->dct_error_sum[intra][i] >>= 1;
1474             }
1475             s->dct_count[intra] >>= 1;
1476         }
1477
1478         for (i = 0; i < 64; i++) {
1479             s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1480                                        s->dct_count[intra] +
1481                                        s->dct_error_sum[intra][i] / 2) /
1482                                       (s->dct_error_sum[intra][i] + 1);
1483         }
1484     }
1485 }
1486
1487 /**
1488  * generic function for encode/decode called after coding/decoding
1489  * the header and before a frame is coded/decoded.
1490  */
1491 int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1492 {
1493     int i, ret;
1494     Picture *pic;
1495     s->mb_skipped = 0;
1496
1497     if (!ff_thread_can_start_frame(avctx)) {
1498         av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
1499         return -1;
1500     }
1501
1502     /* mark & release old frames */
1503     if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1504         s->last_picture_ptr != s->next_picture_ptr &&
1505         s->last_picture_ptr->f.data[0]) {
1506         ff_mpeg_unref_picture(s, s->last_picture_ptr);
1507     }
1508
1509     /* release forgotten pictures */
1510     /* if (mpeg124/h263) */
1511     if (!s->encoding) {
1512         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1513             if (&s->picture[i] != s->last_picture_ptr &&
1514                 &s->picture[i] != s->next_picture_ptr &&
1515                 s->picture[i].reference && !s->picture[i].needs_realloc) {
1516                 if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1517                     av_log(avctx, AV_LOG_ERROR,
1518                            "releasing zombie picture\n");
1519                 ff_mpeg_unref_picture(s, &s->picture[i]);
1520             }
1521         }
1522     }
1523
1524     ff_mpeg_unref_picture(s, &s->current_picture);
1525
1526     if (!s->encoding) {
1527         ff_release_unused_pictures(s, 1);
1528
1529         if (s->current_picture_ptr &&
1530             s->current_picture_ptr->f.data[0] == NULL) {
1531             // we already have a unused image
1532             // (maybe it was set before reading the header)
1533             pic = s->current_picture_ptr;
1534         } else {
1535             i   = ff_find_unused_picture(s, 0);
1536             if (i < 0) {
1537                 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1538                 return i;
1539             }
1540             pic = &s->picture[i];
1541         }
1542
1543         pic->reference = 0;
1544         if (!s->droppable) {
1545             if (s->pict_type != AV_PICTURE_TYPE_B)
1546                 pic->reference = 3;
1547         }
1548
1549         pic->f.coded_picture_number = s->coded_picture_number++;
1550
1551         if (ff_alloc_picture(s, pic, 0) < 0)
1552             return -1;
1553
1554         s->current_picture_ptr = pic;
1555         // FIXME use only the vars from current_pic
1556         s->current_picture_ptr->f.top_field_first = s->top_field_first;
1557         if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1558             s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1559             if (s->picture_structure != PICT_FRAME)
1560                 s->current_picture_ptr->f.top_field_first =
1561                     (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1562         }
1563         s->current_picture_ptr->f.interlaced_frame = !s->progressive_frame &&
1564                                                      !s->progressive_sequence;
1565         s->current_picture_ptr->field_picture      =  s->picture_structure != PICT_FRAME;
1566     }
1567
1568     s->current_picture_ptr->f.pict_type = s->pict_type;
1569     // if (s->flags && CODEC_FLAG_QSCALE)
1570     //     s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1571     s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1572
1573     if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1574                                    s->current_picture_ptr)) < 0)
1575         return ret;
1576
1577     if (s->pict_type != AV_PICTURE_TYPE_B) {
1578         s->last_picture_ptr = s->next_picture_ptr;
1579         if (!s->droppable)
1580             s->next_picture_ptr = s->current_picture_ptr;
1581     }
1582     av_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1583             s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1584             s->last_picture_ptr    ? s->last_picture_ptr->f.data[0]    : NULL,
1585             s->next_picture_ptr    ? s->next_picture_ptr->f.data[0]    : NULL,
1586             s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL,
1587             s->pict_type, s->droppable);
1588
1589     if ((s->last_picture_ptr == NULL ||
1590          s->last_picture_ptr->f.data[0] == NULL) &&
1591         (s->pict_type != AV_PICTURE_TYPE_I ||
1592          s->picture_structure != PICT_FRAME)) {
1593         int h_chroma_shift, v_chroma_shift;
1594         av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1595                                          &h_chroma_shift, &v_chroma_shift);
1596         if (s->pict_type == AV_PICTURE_TYPE_B && s->next_picture_ptr && s->next_picture_ptr->f.data[0])
1597             av_log(avctx, AV_LOG_DEBUG,
1598                    "allocating dummy last picture for B frame\n");
1599         else if (s->pict_type != AV_PICTURE_TYPE_I)
1600             av_log(avctx, AV_LOG_ERROR,
1601                    "warning: first frame is no keyframe\n");
1602         else if (s->picture_structure != PICT_FRAME)
1603             av_log(avctx, AV_LOG_DEBUG,
1604                    "allocate dummy last picture for field based first keyframe\n");
1605
1606         /* Allocate a dummy frame */
1607         i = ff_find_unused_picture(s, 0);
1608         if (i < 0) {
1609             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1610             return i;
1611         }
1612         s->last_picture_ptr = &s->picture[i];
1613         s->last_picture_ptr->f.key_frame = 0;
1614         if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1615             s->last_picture_ptr = NULL;
1616             return -1;
1617         }
1618
1619         memset(s->last_picture_ptr->f.data[0], 0x80,
1620                avctx->height * s->last_picture_ptr->f.linesize[0]);
1621         memset(s->last_picture_ptr->f.data[1], 0x80,
1622                (avctx->height >> v_chroma_shift) *
1623                s->last_picture_ptr->f.linesize[1]);
1624         memset(s->last_picture_ptr->f.data[2], 0x80,
1625                (avctx->height >> v_chroma_shift) *
1626                s->last_picture_ptr->f.linesize[2]);
1627
1628         if(s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263){
1629             for(i=0; i<avctx->height; i++)
1630             memset(s->last_picture_ptr->f.data[0] + s->last_picture_ptr->f.linesize[0]*i, 16, avctx->width);
1631         }
1632
1633         ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 0);
1634         ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 1);
1635     }
1636     if ((s->next_picture_ptr == NULL ||
1637          s->next_picture_ptr->f.data[0] == NULL) &&
1638         s->pict_type == AV_PICTURE_TYPE_B) {
1639         /* Allocate a dummy frame */
1640         i = ff_find_unused_picture(s, 0);
1641         if (i < 0) {
1642             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1643             return i;
1644         }
1645         s->next_picture_ptr = &s->picture[i];
1646         s->next_picture_ptr->f.key_frame = 0;
1647         if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1648             s->next_picture_ptr = NULL;
1649             return -1;
1650         }
1651         ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 0);
1652         ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 1);
1653     }
1654
1655 #if 0 // BUFREF-FIXME
1656     memset(s->last_picture.f.data, 0, sizeof(s->last_picture.f.data));
1657     memset(s->next_picture.f.data, 0, sizeof(s->next_picture.f.data));
1658 #endif
1659     if (s->last_picture_ptr) {
1660         ff_mpeg_unref_picture(s, &s->last_picture);
1661         if (s->last_picture_ptr->f.data[0] &&
1662             (ret = ff_mpeg_ref_picture(s, &s->last_picture,
1663                                        s->last_picture_ptr)) < 0)
1664             return ret;
1665     }
1666     if (s->next_picture_ptr) {
1667         ff_mpeg_unref_picture(s, &s->next_picture);
1668         if (s->next_picture_ptr->f.data[0] &&
1669             (ret = ff_mpeg_ref_picture(s, &s->next_picture,
1670                                        s->next_picture_ptr)) < 0)
1671             return ret;
1672     }
1673
1674     av_assert0(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1675                                                  s->last_picture_ptr->f.data[0]));
1676
1677     if (s->picture_structure!= PICT_FRAME) {
1678         int i;
1679         for (i = 0; i < 4; i++) {
1680             if (s->picture_structure == PICT_BOTTOM_FIELD) {
1681                 s->current_picture.f.data[i] +=
1682                     s->current_picture.f.linesize[i];
1683             }
1684             s->current_picture.f.linesize[i] *= 2;
1685             s->last_picture.f.linesize[i]    *= 2;
1686             s->next_picture.f.linesize[i]    *= 2;
1687         }
1688     }
1689
1690     s->err_recognition = avctx->err_recognition;
1691
1692     /* set dequantizer, we can't do it during init as
1693      * it might change for mpeg4 and we can't do it in the header
1694      * decode as init is not called for mpeg4 there yet */
1695     if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1696         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1697         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1698     } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1699         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1700         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1701     } else {
1702         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1703         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1704     }
1705
1706     if (s->dct_error_sum) {
1707         av_assert2(s->avctx->noise_reduction && s->encoding);
1708         update_noise_reduction(s);
1709     }
1710
1711     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1712         return ff_xvmc_field_start(s, avctx);
1713
1714     return 0;
1715 }
1716
1717 /* generic function for encode/decode called after a
1718  * frame has been coded/decoded. */
1719 void ff_MPV_frame_end(MpegEncContext *s)
1720 {
1721     /* redraw edges for the frame if decoding didn't complete */
1722     // just to make sure that all data is rendered.
1723     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
1724         ff_xvmc_field_end(s);
1725    } else if ((s->er.error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND)) &&
1726               !s->avctx->hwaccel &&
1727               !(s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
1728               s->unrestricted_mv &&
1729               s->current_picture.reference &&
1730               !s->intra_only &&
1731               !(s->flags & CODEC_FLAG_EMU_EDGE) &&
1732               !s->avctx->lowres
1733             ) {
1734         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1735         int hshift = desc->log2_chroma_w;
1736         int vshift = desc->log2_chroma_h;
1737         s->dsp.draw_edges(s->current_picture.f.data[0], s->current_picture.f.linesize[0],
1738                           s->h_edge_pos, s->v_edge_pos,
1739                           EDGE_WIDTH, EDGE_WIDTH,
1740                           EDGE_TOP | EDGE_BOTTOM);
1741         s->dsp.draw_edges(s->current_picture.f.data[1], s->current_picture.f.linesize[1],
1742                           s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1743                           EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1744                           EDGE_TOP | EDGE_BOTTOM);
1745         s->dsp.draw_edges(s->current_picture.f.data[2], s->current_picture.f.linesize[2],
1746                           s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1747                           EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1748                           EDGE_TOP | EDGE_BOTTOM);
1749     }
1750
1751     emms_c();
1752
1753     s->last_pict_type                 = s->pict_type;
1754     s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f.quality;
1755     if (s->pict_type!= AV_PICTURE_TYPE_B) {
1756         s->last_non_b_pict_type = s->pict_type;
1757     }
1758 #if 0
1759     /* copy back current_picture variables */
1760     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1761         if (s->picture[i].f.data[0] == s->current_picture.f.data[0]) {
1762             s->picture[i] = s->current_picture;
1763             break;
1764         }
1765     }
1766     av_assert0(i < MAX_PICTURE_COUNT);
1767 #endif
1768
1769     // clear copies, to avoid confusion
1770 #if 0
1771     memset(&s->last_picture,    0, sizeof(Picture));
1772     memset(&s->next_picture,    0, sizeof(Picture));
1773     memset(&s->current_picture, 0, sizeof(Picture));
1774 #endif
1775     s->avctx->coded_frame = &s->current_picture_ptr->f;
1776
1777     if (s->current_picture.reference)
1778         ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);
1779 }
1780
1781 /**
1782  * Draw a line from (ex, ey) -> (sx, sy).
1783  * @param w width of the image
1784  * @param h height of the image
1785  * @param stride stride/linesize of the image
1786  * @param color color of the arrow
1787  */
1788 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
1789                       int w, int h, int stride, int color)
1790 {
1791     int x, y, fr, f;
1792
1793     sx = av_clip(sx, 0, w - 1);
1794     sy = av_clip(sy, 0, h - 1);
1795     ex = av_clip(ex, 0, w - 1);
1796     ey = av_clip(ey, 0, h - 1);
1797
1798     buf[sy * stride + sx] += color;
1799
1800     if (FFABS(ex - sx) > FFABS(ey - sy)) {
1801         if (sx > ex) {
1802             FFSWAP(int, sx, ex);
1803             FFSWAP(int, sy, ey);
1804         }
1805         buf += sx + sy * stride;
1806         ex  -= sx;
1807         f    = ((ey - sy) << 16) / ex;
1808         for (x = 0; x <= ex; x++) {
1809             y  = (x * f) >> 16;
1810             fr = (x * f) & 0xFFFF;
1811             buf[y * stride + x]       += (color * (0x10000 - fr)) >> 16;
1812             if(fr) buf[(y + 1) * stride + x] += (color *            fr ) >> 16;
1813         }
1814     } else {
1815         if (sy > ey) {
1816             FFSWAP(int, sx, ex);
1817             FFSWAP(int, sy, ey);
1818         }
1819         buf += sx + sy * stride;
1820         ey  -= sy;
1821         if (ey)
1822             f = ((ex - sx) << 16) / ey;
1823         else
1824             f = 0;
1825         for(y= 0; y <= ey; y++){
1826             x  = (y*f) >> 16;
1827             fr = (y*f) & 0xFFFF;
1828             buf[y * stride + x]     += (color * (0x10000 - fr)) >> 16;
1829             if(fr) buf[y * stride + x + 1] += (color *            fr ) >> 16;
1830         }
1831     }
1832 }
1833
1834 /**
1835  * Draw an arrow from (ex, ey) -> (sx, sy).
1836  * @param w width of the image
1837  * @param h height of the image
1838  * @param stride stride/linesize of the image
1839  * @param color color of the arrow
1840  */
1841 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
1842                        int ey, int w, int h, int stride, int color)
1843 {
1844     int dx,dy;
1845
1846     sx = av_clip(sx, -100, w + 100);
1847     sy = av_clip(sy, -100, h + 100);
1848     ex = av_clip(ex, -100, w + 100);
1849     ey = av_clip(ey, -100, h + 100);
1850
1851     dx = ex - sx;
1852     dy = ey - sy;
1853
1854     if (dx * dx + dy * dy > 3 * 3) {
1855         int rx =  dx + dy;
1856         int ry = -dx + dy;
1857         int length = ff_sqrt((rx * rx + ry * ry) << 8);
1858
1859         // FIXME subpixel accuracy
1860         rx = ROUNDED_DIV(rx * 3 << 4, length);
1861         ry = ROUNDED_DIV(ry * 3 << 4, length);
1862
1863         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1864         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1865     }
1866     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1867 }
1868
1869 /**
1870  * Print debugging info for the given picture.
1871  */
1872 void ff_print_debug_info2(AVCodecContext *avctx, Picture *p, AVFrame *pict, uint8_t *mbskip_table,
1873                          int *low_delay,
1874                          int mb_width, int mb_height, int mb_stride, int quarter_sample)
1875 {
1876     if (avctx->hwaccel || !p || !p->mb_type
1877         || (avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU))
1878         return;
1879
1880
1881     if (avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
1882         int x,y;
1883
1884         av_log(avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
1885                av_get_picture_type_char(pict->pict_type));
1886         for (y = 0; y < mb_height; y++) {
1887             for (x = 0; x < mb_width; x++) {
1888                 if (avctx->debug & FF_DEBUG_SKIP) {
1889                     int count = mbskip_table[x + y * mb_stride];
1890                     if (count > 9)
1891                         count = 9;
1892                     av_log(avctx, AV_LOG_DEBUG, "%1d", count);
1893                 }
1894                 if (avctx->debug & FF_DEBUG_QP) {
1895                     av_log(avctx, AV_LOG_DEBUG, "%2d",
1896                            p->qscale_table[x + y * mb_stride]);
1897                 }
1898                 if (avctx->debug & FF_DEBUG_MB_TYPE) {
1899                     int mb_type = p->mb_type[x + y * mb_stride];
1900                     // Type & MV direction
1901                     if (IS_PCM(mb_type))
1902                         av_log(avctx, AV_LOG_DEBUG, "P");
1903                     else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1904                         av_log(avctx, AV_LOG_DEBUG, "A");
1905                     else if (IS_INTRA4x4(mb_type))
1906                         av_log(avctx, AV_LOG_DEBUG, "i");
1907                     else if (IS_INTRA16x16(mb_type))
1908                         av_log(avctx, AV_LOG_DEBUG, "I");
1909                     else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1910                         av_log(avctx, AV_LOG_DEBUG, "d");
1911                     else if (IS_DIRECT(mb_type))
1912                         av_log(avctx, AV_LOG_DEBUG, "D");
1913                     else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
1914                         av_log(avctx, AV_LOG_DEBUG, "g");
1915                     else if (IS_GMC(mb_type))
1916                         av_log(avctx, AV_LOG_DEBUG, "G");
1917                     else if (IS_SKIP(mb_type))
1918                         av_log(avctx, AV_LOG_DEBUG, "S");
1919                     else if (!USES_LIST(mb_type, 1))
1920                         av_log(avctx, AV_LOG_DEBUG, ">");
1921                     else if (!USES_LIST(mb_type, 0))
1922                         av_log(avctx, AV_LOG_DEBUG, "<");
1923                     else {
1924                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1925                         av_log(avctx, AV_LOG_DEBUG, "X");
1926                     }
1927
1928                     // segmentation
1929                     if (IS_8X8(mb_type))
1930                         av_log(avctx, AV_LOG_DEBUG, "+");
1931                     else if (IS_16X8(mb_type))
1932                         av_log(avctx, AV_LOG_DEBUG, "-");
1933                     else if (IS_8X16(mb_type))
1934                         av_log(avctx, AV_LOG_DEBUG, "|");
1935                     else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
1936                         av_log(avctx, AV_LOG_DEBUG, " ");
1937                     else
1938                         av_log(avctx, AV_LOG_DEBUG, "?");
1939
1940
1941                     if (IS_INTERLACED(mb_type))
1942                         av_log(avctx, AV_LOG_DEBUG, "=");
1943                     else
1944                         av_log(avctx, AV_LOG_DEBUG, " ");
1945                 }
1946             }
1947             av_log(avctx, AV_LOG_DEBUG, "\n");
1948         }
1949     }
1950
1951     if ((avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
1952         (avctx->debug_mv)) {
1953         const int shift = 1 + quarter_sample;
1954         int mb_y;
1955         uint8_t *ptr;
1956         int i;
1957         int h_chroma_shift, v_chroma_shift, block_height;
1958         const int width          = avctx->width;
1959         const int height         = avctx->height;
1960         const int mv_sample_log2 = avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_SVQ3 ? 2 : 1;
1961         const int mv_stride      = (mb_width << mv_sample_log2) +
1962                                    (avctx->codec->id == AV_CODEC_ID_H264 ? 0 : 1);
1963
1964         *low_delay = 0; // needed to see the vectors without trashing the buffers
1965
1966         avcodec_get_chroma_sub_sample(avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1967
1968         av_frame_make_writable(pict);
1969
1970         pict->opaque = NULL;
1971         ptr          = pict->data[0];
1972         block_height = 16 >> v_chroma_shift;
1973
1974         for (mb_y = 0; mb_y < mb_height; mb_y++) {
1975             int mb_x;
1976             for (mb_x = 0; mb_x < mb_width; mb_x++) {
1977                 const int mb_index = mb_x + mb_y * mb_stride;
1978                 if ((avctx->debug_mv) && p->motion_val[0]) {
1979                     int type;
1980                     for (type = 0; type < 3; type++) {
1981                         int direction = 0;
1982                         switch (type) {
1983                         case 0:
1984                             if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
1985                                 (pict->pict_type!= AV_PICTURE_TYPE_P))
1986                                 continue;
1987                             direction = 0;
1988                             break;
1989                         case 1:
1990                             if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
1991                                 (pict->pict_type!= AV_PICTURE_TYPE_B))
1992                                 continue;
1993                             direction = 0;
1994                             break;
1995                         case 2:
1996                             if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
1997                                 (pict->pict_type!= AV_PICTURE_TYPE_B))
1998                                 continue;
1999                             direction = 1;
2000                             break;
2001                         }
2002                         if (!USES_LIST(p->mb_type[mb_index], direction))
2003                             continue;
2004
2005                         if (IS_8X8(p->mb_type[mb_index])) {
2006                             int i;
2007                             for (i = 0; i < 4; i++) {
2008                                 int sx = mb_x * 16 + 4 + 8 * (i & 1);
2009                                 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
2010                                 int xy = (mb_x * 2 + (i & 1) +
2011                                           (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2012                                 int mx = (p->motion_val[direction][xy][0] >> shift) + sx;
2013                                 int my = (p->motion_val[direction][xy][1] >> shift) + sy;
2014                                 draw_arrow(ptr, sx, sy, mx, my, width,
2015                                            height, pict->linesize[0], 100);
2016                             }
2017                         } else if (IS_16X8(p->mb_type[mb_index])) {
2018                             int i;
2019                             for (i = 0; i < 2; i++) {
2020                                 int sx = mb_x * 16 + 8;
2021                                 int sy = mb_y * 16 + 4 + 8 * i;
2022                                 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
2023                                 int mx = (p->motion_val[direction][xy][0] >> shift);
2024                                 int my = (p->motion_val[direction][xy][1] >> shift);
2025
2026                                 if (IS_INTERLACED(p->mb_type[mb_index]))
2027                                     my *= 2;
2028
2029                             draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
2030                                        height, pict->linesize[0], 100);
2031                             }
2032                         } else if (IS_8X16(p->mb_type[mb_index])) {
2033                             int i;
2034                             for (i = 0; i < 2; i++) {
2035                                 int sx = mb_x * 16 + 4 + 8 * i;
2036                                 int sy = mb_y * 16 + 8;
2037                                 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
2038                                 int mx = p->motion_val[direction][xy][0] >> shift;
2039                                 int my = p->motion_val[direction][xy][1] >> shift;
2040
2041                                 if (IS_INTERLACED(p->mb_type[mb_index]))
2042                                     my *= 2;
2043
2044                                 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
2045                                            height, pict->linesize[0], 100);
2046                             }
2047                         } else {
2048                               int sx= mb_x * 16 + 8;
2049                               int sy= mb_y * 16 + 8;
2050                               int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
2051                               int mx= (p->motion_val[direction][xy][0]>>shift) + sx;
2052                               int my= (p->motion_val[direction][xy][1]>>shift) + sy;
2053                               draw_arrow(ptr, sx, sy, mx, my, width, height, pict->linesize[0], 100);
2054                         }
2055                     }
2056                 }
2057                 if ((avctx->debug & FF_DEBUG_VIS_QP)) {
2058                     uint64_t c = (p->qscale_table[mb_index] * 128 / 31) *
2059                                  0x0101010101010101ULL;
2060                     int y;
2061                     for (y = 0; y < block_height; y++) {
2062                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
2063                                       (block_height * mb_y + y) *
2064                                       pict->linesize[1]) = c;
2065                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
2066                                       (block_height * mb_y + y) *
2067                                       pict->linesize[2]) = c;
2068                     }
2069                 }
2070                 if ((avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
2071                     p->motion_val[0]) {
2072                     int mb_type = p->mb_type[mb_index];
2073                     uint64_t u,v;
2074                     int y;
2075 #define COLOR(theta, r) \
2076     u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
2077     v = (int)(128 + r * sin(theta * 3.141592 / 180));
2078
2079
2080                     u = v = 128;
2081                     if (IS_PCM(mb_type)) {
2082                         COLOR(120, 48)
2083                     } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
2084                                IS_INTRA16x16(mb_type)) {
2085                         COLOR(30, 48)
2086                     } else if (IS_INTRA4x4(mb_type)) {
2087                         COLOR(90, 48)
2088                     } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
2089                         // COLOR(120, 48)
2090                     } else if (IS_DIRECT(mb_type)) {
2091                         COLOR(150, 48)
2092                     } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
2093                         COLOR(170, 48)
2094                     } else if (IS_GMC(mb_type)) {
2095                         COLOR(190, 48)
2096                     } else if (IS_SKIP(mb_type)) {
2097                         // COLOR(180, 48)
2098                     } else if (!USES_LIST(mb_type, 1)) {
2099                         COLOR(240, 48)
2100                     } else if (!USES_LIST(mb_type, 0)) {
2101                         COLOR(0, 48)
2102                     } else {
2103                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
2104                         COLOR(300,48)
2105                     }
2106
2107                     u *= 0x0101010101010101ULL;
2108                     v *= 0x0101010101010101ULL;
2109                     for (y = 0; y < block_height; y++) {
2110                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
2111                                       (block_height * mb_y + y) * pict->linesize[1]) = u;
2112                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
2113                                       (block_height * mb_y + y) * pict->linesize[2]) = v;
2114                     }
2115
2116                     // segmentation
2117                     if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
2118                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
2119                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
2120                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
2121                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
2122                     }
2123                     if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
2124                         for (y = 0; y < 16; y++)
2125                             pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
2126                                           pict->linesize[0]] ^= 0x80;
2127                     }
2128                     if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
2129                         int dm = 1 << (mv_sample_log2 - 2);
2130                         for (i = 0; i < 4; i++) {
2131                             int sx = mb_x * 16 + 8 * (i & 1);
2132                             int sy = mb_y * 16 + 8 * (i >> 1);
2133                             int xy = (mb_x * 2 + (i & 1) +
2134                                      (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2135                             // FIXME bidir
2136                             int32_t *mv = (int32_t *) &p->motion_val[0][xy];
2137                             if (mv[0] != mv[dm] ||
2138                                 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
2139                                 for (y = 0; y < 8; y++)
2140                                     pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
2141                             if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
2142                                 *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
2143                                               pict->linesize[0]) ^= 0x8080808080808080ULL;
2144                         }
2145                     }
2146
2147                     if (IS_INTERLACED(mb_type) &&
2148                         avctx->codec->id == AV_CODEC_ID_H264) {
2149                         // hmm
2150                     }
2151                 }
2152                 mbskip_table[mb_index] = 0;
2153             }
2154         }
2155     }
2156 }
2157
2158 void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
2159 {
2160     ff_print_debug_info2(s->avctx, p, pict, s->mbskip_table, &s->low_delay,
2161                          s->mb_width, s->mb_height, s->mb_stride, s->quarter_sample);
2162 }
2163
2164 int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type)
2165 {
2166     AVBufferRef *ref = av_buffer_ref(p->qscale_table_buf);
2167     int offset = 2*s->mb_stride + 1;
2168     if(!ref)
2169         return AVERROR(ENOMEM);
2170     av_assert0(ref->size >= offset + s->mb_stride * ((f->height+15)/16));
2171     ref->size -= offset;
2172     ref->data += offset;
2173     return av_frame_set_qp_table(f, ref, s->mb_stride, qp_type);
2174 }
2175
2176 static inline int hpel_motion_lowres(MpegEncContext *s,
2177                                      uint8_t *dest, uint8_t *src,
2178                                      int field_based, int field_select,
2179                                      int src_x, int src_y,
2180                                      int width, int height, int stride,
2181                                      int h_edge_pos, int v_edge_pos,
2182                                      int w, int h, h264_chroma_mc_func *pix_op,
2183                                      int motion_x, int motion_y)
2184 {
2185     const int lowres   = s->avctx->lowres;
2186     const int op_index = FFMIN(lowres, 3);
2187     const int s_mask   = (2 << lowres) - 1;
2188     int emu = 0;
2189     int sx, sy;
2190
2191     if (s->quarter_sample) {
2192         motion_x /= 2;
2193         motion_y /= 2;
2194     }
2195
2196     sx = motion_x & s_mask;
2197     sy = motion_y & s_mask;
2198     src_x += motion_x >> lowres + 1;
2199     src_y += motion_y >> lowres + 1;
2200
2201     src   += src_y * stride + src_x;
2202
2203     if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w,                 0) ||
2204         (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2205         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w + 1,
2206                                 (h + 1) << field_based, src_x,
2207                                 src_y   << field_based,
2208                                 h_edge_pos,
2209                                 v_edge_pos);
2210         src = s->edge_emu_buffer;
2211         emu = 1;
2212     }
2213
2214     sx = (sx << 2) >> lowres;
2215     sy = (sy << 2) >> lowres;
2216     if (field_select)
2217         src += s->linesize;
2218     pix_op[op_index](dest, src, stride, h, sx, sy);
2219     return emu;
2220 }
2221
2222 /* apply one mpeg motion vector to the three components */
2223 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
2224                                                 uint8_t *dest_y,
2225                                                 uint8_t *dest_cb,
2226                                                 uint8_t *dest_cr,
2227                                                 int field_based,
2228                                                 int bottom_field,
2229                                                 int field_select,
2230                                                 uint8_t **ref_picture,
2231                                                 h264_chroma_mc_func *pix_op,
2232                                                 int motion_x, int motion_y,
2233                                                 int h, int mb_y)
2234 {
2235     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2236     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy,
2237         uvsx, uvsy;
2238     const int lowres     = s->avctx->lowres;
2239     const int op_index   = FFMIN(lowres-1+s->chroma_x_shift, 3);
2240     const int block_s    = 8>>lowres;
2241     const int s_mask     = (2 << lowres) - 1;
2242     const int h_edge_pos = s->h_edge_pos >> lowres;
2243     const int v_edge_pos = s->v_edge_pos >> lowres;
2244     linesize   = s->current_picture.f.linesize[0] << field_based;
2245     uvlinesize = s->current_picture.f.linesize[1] << field_based;
2246
2247     // FIXME obviously not perfect but qpel will not work in lowres anyway
2248     if (s->quarter_sample) {
2249         motion_x /= 2;
2250         motion_y /= 2;
2251     }
2252
2253     if(field_based){
2254         motion_y += (bottom_field - field_select)*((1 << lowres)-1);
2255     }
2256
2257     sx = motion_x & s_mask;
2258     sy = motion_y & s_mask;
2259     src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
2260     src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
2261
2262     if (s->out_format == FMT_H263) {
2263         uvsx    = ((motion_x >> 1) & s_mask) | (sx & 1);
2264         uvsy    = ((motion_y >> 1) & s_mask) | (sy & 1);
2265         uvsrc_x = src_x >> 1;
2266         uvsrc_y = src_y >> 1;
2267     } else if (s->out_format == FMT_H261) {
2268         // even chroma mv's are full pel in H261
2269         mx      = motion_x / 4;
2270         my      = motion_y / 4;
2271         uvsx    = (2 * mx) & s_mask;
2272         uvsy    = (2 * my) & s_mask;
2273         uvsrc_x = s->mb_x * block_s + (mx >> lowres);
2274         uvsrc_y =    mb_y * block_s + (my >> lowres);
2275     } else {
2276         if(s->chroma_y_shift){
2277             mx      = motion_x / 2;
2278             my      = motion_y / 2;
2279             uvsx    = mx & s_mask;
2280             uvsy    = my & s_mask;
2281             uvsrc_x = s->mb_x * block_s                 + (mx >> lowres + 1);
2282             uvsrc_y =   (mb_y * block_s >> field_based) + (my >> lowres + 1);
2283         } else {
2284             if(s->chroma_x_shift){
2285             //Chroma422
2286                 mx = motion_x / 2;
2287                 uvsx = mx & s_mask;
2288                 uvsy = motion_y & s_mask;
2289                 uvsrc_y = src_y;
2290                 uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
2291             } else {
2292             //Chroma444
2293                 uvsx = motion_x & s_mask;
2294                 uvsy = motion_y & s_mask;
2295                 uvsrc_x = src_x;
2296                 uvsrc_y = src_y;
2297             }
2298         }
2299     }
2300
2301     ptr_y  = ref_picture[0] + src_y   * linesize   + src_x;
2302     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2303     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2304
2305     if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s,       0) || uvsrc_y<0 ||
2306         (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2307         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
2308                                 linesize >> field_based, 17, 17 + field_based,
2309                                 src_x, src_y << field_based, h_edge_pos,
2310                                 v_edge_pos);
2311         ptr_y = s->edge_emu_buffer;
2312         if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2313             uint8_t *uvbuf = s->edge_emu_buffer + 18 * s->linesize;
2314             s->vdsp.emulated_edge_mc(uvbuf , ptr_cb, uvlinesize >> field_based, 9,
2315                                     9 + field_based,
2316                                     uvsrc_x, uvsrc_y << field_based,
2317                                     h_edge_pos >> 1, v_edge_pos >> 1);
2318             s->vdsp.emulated_edge_mc(uvbuf + 16, ptr_cr, 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             ptr_cb = uvbuf;
2323             ptr_cr = uvbuf + 16;
2324         }
2325     }
2326
2327     // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data
2328     if (bottom_field) {
2329         dest_y  += s->linesize;
2330         dest_cb += s->uvlinesize;
2331         dest_cr += s->uvlinesize;
2332     }
2333
2334     if (field_select) {
2335         ptr_y   += s->linesize;
2336         ptr_cb  += s->uvlinesize;
2337         ptr_cr  += s->uvlinesize;
2338     }
2339
2340     sx = (sx << 2) >> lowres;
2341     sy = (sy << 2) >> lowres;
2342     pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
2343
2344     if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2345         int hc = s->chroma_y_shift ? (h+1-bottom_field)>>1 : h;
2346         uvsx = (uvsx << 2) >> lowres;
2347         uvsy = (uvsy << 2) >> lowres;
2348         if (hc) {
2349             pix_op[op_index](dest_cb, ptr_cb, uvlinesize, hc, uvsx, uvsy);
2350             pix_op[op_index](dest_cr, ptr_cr, uvlinesize, hc, uvsx, uvsy);
2351         }
2352     }
2353     // FIXME h261 lowres loop filter
2354 }
2355
2356 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
2357                                             uint8_t *dest_cb, uint8_t *dest_cr,
2358                                             uint8_t **ref_picture,
2359                                             h264_chroma_mc_func * pix_op,
2360                                             int mx, int my)
2361 {
2362     const int lowres     = s->avctx->lowres;
2363     const int op_index   = FFMIN(lowres, 3);
2364     const int block_s    = 8 >> lowres;
2365     const int s_mask     = (2 << lowres) - 1;
2366     const int h_edge_pos = s->h_edge_pos >> lowres + 1;
2367     const int v_edge_pos = s->v_edge_pos >> lowres + 1;
2368     int emu = 0, src_x, src_y, offset, sx, sy;
2369     uint8_t *ptr;
2370
2371     if (s->quarter_sample) {
2372         mx /= 2;
2373         my /= 2;
2374     }
2375
2376     /* In case of 8X8, we construct a single chroma motion vector
2377        with a special rounding */
2378     mx = ff_h263_round_chroma(mx);
2379     my = ff_h263_round_chroma(my);
2380
2381     sx = mx & s_mask;
2382     sy = my & s_mask;
2383     src_x = s->mb_x * block_s + (mx >> lowres + 1);
2384     src_y = s->mb_y * block_s + (my >> lowres + 1);
2385
2386     offset = src_y * s->uvlinesize + src_x;
2387     ptr = ref_picture[1] + offset;
2388     if (s->flags & CODEC_FLAG_EMU_EDGE) {
2389         if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2390             (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2391             s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize,
2392                                     9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
2393             ptr = s->edge_emu_buffer;
2394             emu = 1;
2395         }
2396     }
2397     sx = (sx << 2) >> lowres;
2398     sy = (sy << 2) >> lowres;
2399     pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
2400
2401     ptr = ref_picture[2] + offset;
2402     if (emu) {
2403         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9,
2404                                 src_x, src_y, h_edge_pos, v_edge_pos);
2405         ptr = s->edge_emu_buffer;
2406     }
2407     pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
2408 }
2409
2410 /**
2411  * motion compensation of a single macroblock
2412  * @param s context
2413  * @param dest_y luma destination pointer
2414  * @param dest_cb chroma cb/u destination pointer
2415  * @param dest_cr chroma cr/v destination pointer
2416  * @param dir direction (0->forward, 1->backward)
2417  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2418  * @param pix_op halfpel motion compensation function (average or put normally)
2419  * the motion vectors are taken from s->mv and the MV type from s->mv_type
2420  */
2421 static inline void MPV_motion_lowres(MpegEncContext *s,
2422                                      uint8_t *dest_y, uint8_t *dest_cb,
2423                                      uint8_t *dest_cr,
2424                                      int dir, uint8_t **ref_picture,
2425                                      h264_chroma_mc_func *pix_op)
2426 {
2427     int mx, my;
2428     int mb_x, mb_y, i;
2429     const int lowres  = s->avctx->lowres;
2430     const int block_s = 8 >>lowres;
2431
2432     mb_x = s->mb_x;
2433     mb_y = s->mb_y;
2434
2435     switch (s->mv_type) {
2436     case MV_TYPE_16X16:
2437         mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2438                            0, 0, 0,
2439                            ref_picture, pix_op,
2440                            s->mv[dir][0][0], s->mv[dir][0][1],
2441                            2 * block_s, mb_y);
2442         break;
2443     case MV_TYPE_8X8:
2444         mx = 0;
2445         my = 0;
2446         for (i = 0; i < 4; i++) {
2447             hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
2448                                s->linesize) * block_s,
2449                                ref_picture[0], 0, 0,
2450                                (2 * mb_x + (i & 1)) * block_s,
2451                                (2 * mb_y + (i >> 1)) * block_s,
2452                                s->width, s->height, s->linesize,
2453                                s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
2454                                block_s, block_s, pix_op,
2455                                s->mv[dir][i][0], s->mv[dir][i][1]);
2456
2457             mx += s->mv[dir][i][0];
2458             my += s->mv[dir][i][1];
2459         }
2460
2461         if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY))
2462             chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
2463                                      pix_op, mx, my);
2464         break;
2465     case MV_TYPE_FIELD:
2466         if (s->picture_structure == PICT_FRAME) {
2467             /* top field */
2468             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2469                                1, 0, s->field_select[dir][0],
2470                                ref_picture, pix_op,
2471                                s->mv[dir][0][0], s->mv[dir][0][1],
2472                                block_s, mb_y);
2473             /* bottom field */
2474             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2475                                1, 1, s->field_select[dir][1],
2476                                ref_picture, pix_op,
2477                                s->mv[dir][1][0], s->mv[dir][1][1],
2478                                block_s, mb_y);
2479         } else {
2480             if (s->picture_structure != s->field_select[dir][0] + 1 &&
2481                 s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
2482                 ref_picture = s->current_picture_ptr->f.data;
2483
2484             }
2485             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2486                                0, 0, s->field_select[dir][0],
2487                                ref_picture, pix_op,
2488                                s->mv[dir][0][0],
2489                                s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
2490             }
2491         break;
2492     case MV_TYPE_16X8:
2493         for (i = 0; i < 2; i++) {
2494             uint8_t **ref2picture;
2495
2496             if (s->picture_structure == s->field_select[dir][i] + 1 ||
2497                 s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
2498                 ref2picture = ref_picture;
2499             } else {
2500                 ref2picture = s->current_picture_ptr->f.data;
2501             }
2502
2503             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2504                                0, 0, s->field_select[dir][i],
2505                                ref2picture, pix_op,
2506                                s->mv[dir][i][0], s->mv[dir][i][1] +
2507                                2 * block_s * i, block_s, mb_y >> 1);
2508
2509             dest_y  +=  2 * block_s *  s->linesize;
2510             dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2511             dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2512         }
2513         break;
2514     case MV_TYPE_DMV:
2515         if (s->picture_structure == PICT_FRAME) {
2516             for (i = 0; i < 2; i++) {
2517                 int j;
2518                 for (j = 0; j < 2; j++) {
2519                     mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2520                                        1, j, j ^ i,
2521                                        ref_picture, pix_op,
2522                                        s->mv[dir][2 * i + j][0],
2523                                        s->mv[dir][2 * i + j][1],
2524                                        block_s, mb_y);
2525                 }
2526                 pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
2527             }
2528         } else {
2529             for (i = 0; i < 2; i++) {
2530                 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2531                                    0, 0, s->picture_structure != i + 1,
2532                                    ref_picture, pix_op,
2533                                    s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
2534                                    2 * block_s, mb_y >> 1);
2535
2536                 // after put we make avg of the same block
2537                 pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
2538
2539                 // opposite parity is always in the same
2540                 // frame if this is second field
2541                 if (!s->first_field) {
2542                     ref_picture = s->current_picture_ptr->f.data;
2543                 }
2544             }
2545         }
2546         break;
2547     default:
2548         av_assert2(0);
2549     }
2550 }
2551
2552 /**
2553  * find the lowest MB row referenced in the MVs
2554  */
2555 int ff_MPV_lowest_referenced_row(MpegEncContext *s, int dir)
2556 {
2557     int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2558     int my, off, i, mvs;
2559
2560     if (s->picture_structure != PICT_FRAME || s->mcsel)
2561         goto unhandled;
2562
2563     switch (s->mv_type) {
2564         case MV_TYPE_16X16:
2565             mvs = 1;
2566             break;
2567         case MV_TYPE_16X8:
2568             mvs = 2;
2569             break;
2570         case MV_TYPE_8X8:
2571             mvs = 4;
2572             break;
2573         default:
2574             goto unhandled;
2575     }
2576
2577     for (i = 0; i < mvs; i++) {
2578         my = s->mv[dir][i][1]<<qpel_shift;
2579         my_max = FFMAX(my_max, my);
2580         my_min = FFMIN(my_min, my);
2581     }
2582
2583     off = (FFMAX(-my_min, my_max) + 63) >> 6;
2584
2585     return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
2586 unhandled:
2587     return s->mb_height-1;
2588 }
2589
2590 /* put block[] to dest[] */
2591 static inline void put_dct(MpegEncContext *s,
2592                            int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2593 {
2594     s->dct_unquantize_intra(s, block, i, qscale);
2595     s->dsp.idct_put (dest, line_size, block);
2596 }
2597
2598 /* add block[] to dest[] */
2599 static inline void add_dct(MpegEncContext *s,
2600                            int16_t *block, int i, uint8_t *dest, int line_size)
2601 {
2602     if (s->block_last_index[i] >= 0) {
2603         s->dsp.idct_add (dest, line_size, block);
2604     }
2605 }
2606
2607 static inline void add_dequant_dct(MpegEncContext *s,
2608                            int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2609 {
2610     if (s->block_last_index[i] >= 0) {
2611         s->dct_unquantize_inter(s, block, i, qscale);
2612
2613         s->dsp.idct_add (dest, line_size, block);
2614     }
2615 }
2616
2617 /**
2618  * Clean dc, ac, coded_block for the current non-intra MB.
2619  */
2620 void ff_clean_intra_table_entries(MpegEncContext *s)
2621 {
2622     int wrap = s->b8_stride;
2623     int xy = s->block_index[0];
2624
2625     s->dc_val[0][xy           ] =
2626     s->dc_val[0][xy + 1       ] =
2627     s->dc_val[0][xy     + wrap] =
2628     s->dc_val[0][xy + 1 + wrap] = 1024;
2629     /* ac pred */
2630     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
2631     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2632     if (s->msmpeg4_version>=3) {
2633         s->coded_block[xy           ] =
2634         s->coded_block[xy + 1       ] =
2635         s->coded_block[xy     + wrap] =
2636         s->coded_block[xy + 1 + wrap] = 0;
2637     }
2638     /* chroma */
2639     wrap = s->mb_stride;
2640     xy = s->mb_x + s->mb_y * wrap;
2641     s->dc_val[1][xy] =
2642     s->dc_val[2][xy] = 1024;
2643     /* ac pred */
2644     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2645     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2646
2647     s->mbintra_table[xy]= 0;
2648 }
2649
2650 /* generic function called after a macroblock has been parsed by the
2651    decoder or after it has been encoded by the encoder.
2652
2653    Important variables used:
2654    s->mb_intra : true if intra macroblock
2655    s->mv_dir   : motion vector direction
2656    s->mv_type  : motion vector type
2657    s->mv       : motion vector
2658    s->interlaced_dct : true if interlaced dct used (mpeg2)
2659  */
2660 static av_always_inline
2661 void MPV_decode_mb_internal(MpegEncContext *s, int16_t block[12][64],
2662                             int lowres_flag, int is_mpeg12)
2663 {
2664     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2665     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2666         ff_xvmc_decode_mb(s);//xvmc uses pblocks
2667         return;
2668     }
2669
2670     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2671        /* print DCT coefficients */
2672        int i,j;
2673        av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2674        for(i=0; i<6; i++){
2675            for(j=0; j<64; j++){
2676                av_log(s->avctx, AV_LOG_DEBUG, "%5d", block[i][s->dsp.idct_permutation[j]]);
2677            }
2678            av_log(s->avctx, AV_LOG_DEBUG, "\n");
2679        }
2680     }
2681
2682     s->current_picture.qscale_table[mb_xy] = s->qscale;
2683
2684     /* update DC predictors for P macroblocks */
2685     if (!s->mb_intra) {
2686         if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2687             if(s->mbintra_table[mb_xy])
2688                 ff_clean_intra_table_entries(s);
2689         } else {
2690             s->last_dc[0] =
2691             s->last_dc[1] =
2692             s->last_dc[2] = 128 << s->intra_dc_precision;
2693         }
2694     }
2695     else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2696         s->mbintra_table[mb_xy]=1;
2697
2698     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
2699         uint8_t *dest_y, *dest_cb, *dest_cr;
2700         int dct_linesize, dct_offset;
2701         op_pixels_func (*op_pix)[4];
2702         qpel_mc_func (*op_qpix)[16];
2703         const int linesize   = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2704         const int uvlinesize = s->current_picture.f.linesize[1];
2705         const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2706         const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2707
2708         /* avoid copy if macroblock skipped in last frame too */
2709         /* skip only during decoding as we might trash the buffers during encoding a bit */
2710         if(!s->encoding){
2711             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2712
2713             if (s->mb_skipped) {
2714                 s->mb_skipped= 0;
2715                 av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
2716                 *mbskip_ptr = 1;
2717             } else if(!s->current_picture.reference) {
2718                 *mbskip_ptr = 1;
2719             } else{
2720                 *mbskip_ptr = 0; /* not skipped */
2721             }
2722         }
2723
2724         dct_linesize = linesize << s->interlaced_dct;
2725         dct_offset   = s->interlaced_dct ? linesize : linesize * block_size;
2726
2727         if(readable){
2728             dest_y=  s->dest[0];
2729             dest_cb= s->dest[1];
2730             dest_cr= s->dest[2];
2731         }else{
2732             dest_y = s->b_scratchpad;
2733             dest_cb= s->b_scratchpad+16*linesize;
2734             dest_cr= s->b_scratchpad+32*linesize;
2735         }
2736
2737         if (!s->mb_intra) {
2738             /* motion handling */
2739             /* decoding or more than one mb_type (MC was already done otherwise) */
2740             if(!s->encoding){
2741
2742                 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2743                     if (s->mv_dir & MV_DIR_FORWARD) {
2744                         ff_thread_await_progress(&s->last_picture_ptr->tf,
2745                                                  ff_MPV_lowest_referenced_row(s, 0),
2746                                                  0);
2747                     }
2748                     if (s->mv_dir & MV_DIR_BACKWARD) {
2749                         ff_thread_await_progress(&s->next_picture_ptr->tf,
2750                                                  ff_MPV_lowest_referenced_row(s, 1),
2751                                                  0);
2752                     }
2753                 }
2754
2755                 if(lowres_flag){
2756                     h264_chroma_mc_func *op_pix = s->h264chroma.put_h264_chroma_pixels_tab;
2757
2758                     if (s->mv_dir & MV_DIR_FORWARD) {
2759                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix);
2760                         op_pix = s->h264chroma.avg_h264_chroma_pixels_tab;
2761                     }
2762                     if (s->mv_dir & MV_DIR_BACKWARD) {
2763                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix);
2764                     }
2765                 }else{
2766                     op_qpix= s->me.qpel_put;
2767                     if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2768                         op_pix = s->hdsp.put_pixels_tab;
2769                     }else{
2770                         op_pix = s->hdsp.put_no_rnd_pixels_tab;
2771                     }
2772                     if (s->mv_dir & MV_DIR_FORWARD) {
2773                         ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
2774                         op_pix = s->hdsp.avg_pixels_tab;
2775                         op_qpix= s->me.qpel_avg;
2776                     }
2777                     if (s->mv_dir & MV_DIR_BACKWARD) {
2778                         ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
2779                     }
2780                 }
2781             }
2782
2783             /* skip dequant / idct if we are really late ;) */
2784             if(s->avctx->skip_idct){
2785                 if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2786                    ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2787                    || s->avctx->skip_idct >= AVDISCARD_ALL)
2788                     goto skip_idct;
2789             }
2790
2791             /* add dct residue */
2792             if(s->encoding || !(   s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
2793                                 || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
2794                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2795                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2796                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2797                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2798
2799                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2800                     if (s->chroma_y_shift){
2801                         add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2802                         add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2803                     }else{
2804                         dct_linesize >>= 1;
2805                         dct_offset >>=1;
2806                         add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2807                         add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2808                         add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2809                         add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2810                     }
2811                 }
2812             } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
2813                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
2814                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
2815                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
2816                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2817
2818                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2819                     if(s->chroma_y_shift){//Chroma420
2820                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
2821                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
2822                     }else{
2823                         //chroma422
2824                         dct_linesize = uvlinesize << s->interlaced_dct;
2825                         dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2826
2827                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
2828                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
2829                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2830                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2831                         if(!s->chroma_x_shift){//Chroma444
2832                             add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2833                             add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2834                             add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2835                             add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2836                         }
2837                     }
2838                 }//fi gray
2839             }
2840             else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2841                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2842             }
2843         } else {
2844             /* dct only in intra block */
2845             if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
2846                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2847                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2848                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2849                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2850
2851                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2852                     if(s->chroma_y_shift){
2853                         put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2854                         put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2855                     }else{
2856                         dct_offset >>=1;
2857                         dct_linesize >>=1;
2858                         put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2859                         put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2860                         put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2861                         put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2862                     }
2863                 }
2864             }else{
2865                 s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
2866                 s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
2867                 s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
2868                 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2869
2870                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2871                     if(s->chroma_y_shift){
2872                         s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2873                         s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2874                     }else{
2875
2876                         dct_linesize = uvlinesize << s->interlaced_dct;
2877                         dct_offset   = s->interlaced_dct? uvlinesize : uvlinesize*block_size;
2878
2879                         s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
2880                         s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
2881                         s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2882                         s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2883                         if(!s->chroma_x_shift){//Chroma444
2884                             s->dsp.idct_put(dest_cb + block_size,              dct_linesize, block[8]);
2885                             s->dsp.idct_put(dest_cr + block_size,              dct_linesize, block[9]);
2886                             s->dsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2887                             s->dsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2888                         }
2889                     }
2890                 }//gray
2891             }
2892         }
2893 skip_idct:
2894         if(!readable){
2895             s->hdsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
2896             s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2897             s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2898         }
2899     }
2900 }
2901
2902 void ff_MPV_decode_mb(MpegEncContext *s, int16_t block[12][64]){
2903 #if !CONFIG_SMALL
2904     if(s->out_format == FMT_MPEG1) {
2905         if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2906         else                 MPV_decode_mb_internal(s, block, 0, 1);
2907     } else
2908 #endif
2909     if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2910     else                  MPV_decode_mb_internal(s, block, 0, 0);
2911 }
2912
2913 /**
2914  * @param h is the normal height, this will be reduced automatically if needed for the last row
2915  */
2916 void ff_draw_horiz_band(AVCodecContext *avctx, DSPContext *dsp, Picture *cur,
2917                         Picture *last, int y, int h, int picture_structure,
2918                         int first_field, int draw_edges, int low_delay,
2919                         int v_edge_pos, int h_edge_pos)
2920 {
2921     const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
2922     int hshift = desc->log2_chroma_w;
2923     int vshift = desc->log2_chroma_h;
2924     const int field_pic = picture_structure != PICT_FRAME;
2925     if(field_pic){
2926         h <<= 1;
2927         y <<= 1;
2928     }
2929
2930     if (!avctx->hwaccel &&
2931         !(avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
2932         draw_edges &&
2933         cur->reference &&
2934         !(avctx->flags & CODEC_FLAG_EMU_EDGE)) {
2935         int *linesize = cur->f.linesize;
2936         int sides = 0, edge_h;
2937         if (y==0) sides |= EDGE_TOP;
2938         if (y + h >= v_edge_pos)
2939             sides |= EDGE_BOTTOM;
2940
2941         edge_h= FFMIN(h, v_edge_pos - y);
2942
2943         dsp->draw_edges(cur->f.data[0] + y * linesize[0],
2944                         linesize[0], h_edge_pos, edge_h,
2945                         EDGE_WIDTH, EDGE_WIDTH, sides);
2946         dsp->draw_edges(cur->f.data[1] + (y >> vshift) * linesize[1],
2947                         linesize[1], h_edge_pos >> hshift, edge_h >> vshift,
2948                         EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift, sides);
2949         dsp->draw_edges(cur->f.data[2] + (y >> vshift) * linesize[2],
2950                         linesize[2], h_edge_pos >> hshift, edge_h >> vshift,
2951                         EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift, sides);
2952     }
2953
2954     h = FFMIN(h, avctx->height - y);
2955
2956     if(field_pic && first_field && !(avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2957
2958     if (avctx->draw_horiz_band) {
2959         AVFrame *src;
2960         int offset[AV_NUM_DATA_POINTERS];
2961         int i;
2962
2963         if(cur->f.pict_type == AV_PICTURE_TYPE_B || low_delay ||
2964            (avctx->slice_flags & SLICE_FLAG_CODED_ORDER))
2965             src = &cur->f;
2966         else if (last)
2967             src = &last->f;
2968         else
2969             return;
2970
2971         if (cur->f.pict_type == AV_PICTURE_TYPE_B &&
2972             picture_structure == PICT_FRAME &&
2973             avctx->codec_id != AV_CODEC_ID_SVQ3) {
2974             for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
2975                 offset[i] = 0;
2976         }else{
2977             offset[0]= y * src->linesize[0];
2978             offset[1]=
2979             offset[2]= (y >> vshift) * src->linesize[1];
2980             for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
2981                 offset[i] = 0;
2982         }
2983
2984         emms_c();
2985
2986         avctx->draw_horiz_band(avctx, src, offset,
2987                                y, picture_structure, h);
2988     }
2989 }
2990
2991 void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
2992 {
2993     int draw_edges = s->unrestricted_mv && !s->intra_only;
2994     ff_draw_horiz_band(s->avctx, &s->dsp, s->current_picture_ptr,
2995                        s->last_picture_ptr, y, h, s->picture_structure,
2996                        s->first_field, draw_edges, s->low_delay,
2997                        s->v_edge_pos, s->h_edge_pos);
2998 }
2999
3000 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3001     const int linesize   = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
3002     const int uvlinesize = s->current_picture.f.linesize[1];
3003     const int mb_size= 4 - s->avctx->lowres;
3004
3005     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
3006     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
3007     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
3008     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3009     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
3010     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;
3011     //block_index is not used by mpeg2, so it is not affected by chroma_format
3012
3013     s->dest[0] = s->current_picture.f.data[0] + ((s->mb_x - 1) <<  mb_size);
3014     s->dest[1] = s->current_picture.f.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3015     s->dest[2] = s->current_picture.f.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3016
3017     if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
3018     {
3019         if(s->picture_structure==PICT_FRAME){
3020         s->dest[0] += s->mb_y *   linesize << mb_size;
3021         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3022         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3023         }else{
3024             s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
3025             s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
3026             s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
3027             av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
3028         }
3029     }
3030 }
3031
3032 /**
3033  * Permute an 8x8 block.
3034  * @param block the block which will be permuted according to the given permutation vector
3035  * @param permutation the permutation vector
3036  * @param last the last non zero coefficient in scantable order, used to speed the permutation up
3037  * @param scantable the used scantable, this is only used to speed the permutation up, the block is not
3038  *                  (inverse) permutated to scantable order!
3039  */
3040 void ff_block_permute(int16_t *block, uint8_t *permutation, const uint8_t *scantable, int last)
3041 {
3042     int i;
3043     int16_t temp[64];
3044
3045     if(last<=0) return;
3046     //if(permutation[1]==1) return; //FIXME it is ok but not clean and might fail for some permutations
3047
3048     for(i=0; i<=last; i++){
3049         const int j= scantable[i];
3050         temp[j]= block[j];
3051         block[j]=0;
3052     }
3053
3054     for(i=0; i<=last; i++){
3055         const int j= scantable[i];
3056         const int perm_j= permutation[j];
3057         block[perm_j]= temp[j];
3058     }
3059 }
3060
3061 void ff_mpeg_flush(AVCodecContext *avctx){
3062     int i;
3063     MpegEncContext *s = avctx->priv_data;
3064
3065     if(s==NULL || s->picture==NULL)
3066         return;
3067
3068     for (i = 0; i < MAX_PICTURE_COUNT; i++)
3069         ff_mpeg_unref_picture(s, &s->picture[i]);
3070     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
3071
3072     ff_mpeg_unref_picture(s, &s->current_picture);
3073     ff_mpeg_unref_picture(s, &s->last_picture);
3074     ff_mpeg_unref_picture(s, &s->next_picture);
3075
3076     s->mb_x= s->mb_y= 0;
3077     s->closed_gop= 0;
3078
3079     s->parse_context.state= -1;
3080     s->parse_context.frame_start_found= 0;
3081     s->parse_context.overread= 0;
3082     s->parse_context.overread_index= 0;
3083     s->parse_context.index= 0;
3084     s->parse_context.last_index= 0;
3085     s->bitstream_buffer_size=0;
3086     s->pp_time=0;
3087 }
3088
3089 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
3090                                    int16_t *block, int n, int qscale)
3091 {
3092     int i, level, nCoeffs;
3093     const uint16_t *quant_matrix;
3094
3095     nCoeffs= s->block_last_index[n];
3096
3097     block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
3098     /* XXX: only mpeg1 */
3099     quant_matrix = s->intra_matrix;
3100     for(i=1;i<=nCoeffs;i++) {
3101         int j= s->intra_scantable.permutated[i];
3102         level = block[j];
3103         if (level) {
3104             if (level < 0) {
3105                 level = -level;
3106                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3107                 level = (level - 1) | 1;
3108                 level = -level;
3109             } else {
3110                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3111                 level = (level - 1) | 1;
3112             }
3113             block[j] = level;
3114         }
3115     }
3116 }
3117
3118 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
3119                                    int16_t *block, int n, int qscale)
3120 {
3121     int i, level, nCoeffs;
3122     const uint16_t *quant_matrix;
3123
3124     nCoeffs= s->block_last_index[n];
3125
3126     quant_matrix = s->inter_matrix;
3127     for(i=0; i<=nCoeffs; i++) {
3128         int j= s->intra_scantable.permutated[i];
3129         level = block[j];
3130         if (level) {
3131             if (level < 0) {
3132                 level = -level;
3133                 level = (((level << 1) + 1) * qscale *
3134                          ((int) (quant_matrix[j]))) >> 4;
3135                 level = (level - 1) | 1;
3136                 level = -level;
3137             } else {
3138                 level = (((level << 1) + 1) * qscale *
3139                          ((int) (quant_matrix[j]))) >> 4;
3140                 level = (level - 1) | 1;
3141             }
3142             block[j] = level;
3143         }
3144     }
3145 }
3146
3147 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
3148                                    int16_t *block, int n, int qscale)
3149 {
3150     int i, level, nCoeffs;
3151     const uint16_t *quant_matrix;
3152
3153     if(s->alternate_scan) nCoeffs= 63;
3154     else nCoeffs= s->block_last_index[n];
3155
3156     block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
3157     quant_matrix = s->intra_matrix;
3158     for(i=1;i<=nCoeffs;i++) {
3159         int j= s->intra_scantable.permutated[i];
3160         level = block[j];
3161         if (level) {
3162             if (level < 0) {
3163                 level = -level;
3164                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3165                 level = -level;
3166             } else {
3167                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3168             }
3169             block[j] = level;
3170         }
3171     }
3172 }
3173
3174 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
3175                                    int16_t *block, int n, int qscale)
3176 {
3177     int i, level, nCoeffs;
3178     const uint16_t *quant_matrix;
3179     int sum=-1;
3180
3181     if(s->alternate_scan) nCoeffs= 63;
3182     else nCoeffs= s->block_last_index[n];
3183
3184     block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
3185     sum += block[0];
3186     quant_matrix = s->intra_matrix;
3187     for(i=1;i<=nCoeffs;i++) {
3188         int j= s->intra_scantable.permutated[i];
3189         level = block[j];
3190         if (level) {
3191             if (level < 0) {
3192                 level = -level;
3193                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3194                 level = -level;
3195             } else {
3196                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
3197             }
3198             block[j] = level;
3199             sum+=level;
3200         }
3201     }
3202     block[63]^=sum&1;
3203 }
3204
3205 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
3206                                    int16_t *block, int n, int qscale)
3207 {
3208     int i, level, nCoeffs;
3209     const uint16_t *quant_matrix;
3210     int sum=-1;
3211
3212     if(s->alternate_scan) nCoeffs= 63;
3213     else nCoeffs= s->block_last_index[n];
3214
3215     quant_matrix = s->inter_matrix;
3216     for(i=0; i<=nCoeffs; i++) {
3217         int j= s->intra_scantable.permutated[i];
3218         level = block[j];
3219         if (level) {
3220             if (level < 0) {
3221                 level = -level;
3222                 level = (((level << 1) + 1) * qscale *
3223                          ((int) (quant_matrix[j]))) >> 4;
3224                 level = -level;
3225             } else {
3226                 level = (((level << 1) + 1) * qscale *
3227                          ((int) (quant_matrix[j]))) >> 4;
3228             }
3229             block[j] = level;
3230             sum+=level;
3231         }
3232     }
3233     block[63]^=sum&1;
3234 }
3235
3236 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
3237                                   int16_t *block, int n, int qscale)
3238 {
3239     int i, level, qmul, qadd;
3240     int nCoeffs;
3241
3242     av_assert2(s->block_last_index[n]>=0 || s->h263_aic);
3243
3244     qmul = qscale << 1;
3245
3246     if (!s->h263_aic) {
3247         block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
3248         qadd = (qscale - 1) | 1;
3249     }else{
3250         qadd = 0;
3251     }
3252     if(s->ac_pred)
3253         nCoeffs=63;
3254     else
3255         nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
3256
3257     for(i=1; i<=nCoeffs; i++) {
3258         level = block[i];
3259         if (level) {
3260             if (level < 0) {
3261                 level = level * qmul - qadd;
3262             } else {
3263                 level = level * qmul + qadd;
3264             }
3265             block[i] = level;
3266         }
3267     }
3268 }
3269
3270 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
3271                                   int16_t *block, int n, int qscale)
3272 {
3273     int i, level, qmul, qadd;
3274     int nCoeffs;
3275
3276     av_assert2(s->block_last_index[n]>=0);
3277
3278     qadd = (qscale - 1) | 1;
3279     qmul = qscale << 1;
3280
3281     nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
3282
3283     for(i=0; i<=nCoeffs; i++) {
3284         level = block[i];
3285         if (level) {
3286             if (level < 0) {
3287                 level = level * qmul - qadd;
3288             } else {
3289                 level = level * qmul + qadd;
3290             }
3291             block[i] = level;
3292         }
3293     }
3294 }
3295
3296 /**
3297  * set qscale and update qscale dependent variables.
3298  */
3299 void ff_set_qscale(MpegEncContext * s, int qscale)
3300 {
3301     if (qscale < 1)
3302         qscale = 1;
3303     else if (qscale > 31)
3304         qscale = 31;
3305
3306     s->qscale = qscale;
3307     s->chroma_qscale= s->chroma_qscale_table[qscale];
3308
3309     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
3310     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
3311 }
3312
3313 void ff_MPV_report_decode_progress(MpegEncContext *s)
3314 {
3315     if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->er.error_occurred)
3316         ff_thread_report_progress(&s->current_picture_ptr->tf, s->mb_y, 0);
3317 }
3318
3319 #if CONFIG_ERROR_RESILIENCE
3320 void ff_mpeg_er_frame_start(MpegEncContext *s)
3321 {
3322     ERContext *er = &s->er;
3323
3324     er->cur_pic  = s->current_picture_ptr;
3325     er->last_pic = s->last_picture_ptr;
3326     er->next_pic = s->next_picture_ptr;
3327
3328     er->pp_time           = s->pp_time;
3329     er->pb_time           = s->pb_time;
3330     er->quarter_sample    = s->quarter_sample;
3331     er->partitioned_frame = s->partitioned_frame;
3332
3333     ff_er_frame_start(er);
3334 }
3335 #endif /* CONFIG_ERROR_RESILIENCE */