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

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