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

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