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 /* enable all paranoid tests for rounding, overflows, etc... */
  62 //#define PARANOID
  63
  64 //#define DEBUG
  65
  66
  67 static const uint8_t ff_default_chroma_qscale_table[32] = {
  68 //   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15
  69      0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
  70     16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
  71 };
  72
  73 const uint8_t ff_mpeg1_dc_scale_table[128] = {
  74 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
  75     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  76     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  77     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  78     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  79     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  80     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  81     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  82     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  83 };
  84
  85 static const uint8_t mpeg2_dc_scale_table1[128] = {
  86 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
  87     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  88     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  89     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  90     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  91     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  92     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  93     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  94     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  95 };
  96
  97 static const uint8_t mpeg2_dc_scale_table2[128] = {
  98 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
  99     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 100     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 101     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 102     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 103     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 104     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 105     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 106     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 107 };
 108
 109 static const uint8_t mpeg2_dc_scale_table3[128] = {
 110 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
 111     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 112     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 113     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 114     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 115     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 116     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 117     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 118     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 119 };
 120
 121 const uint8_t *const ff_mpeg2_dc_scale_table[4] = {
 122     ff_mpeg1_dc_scale_table,
 123     mpeg2_dc_scale_table1,
 124     mpeg2_dc_scale_table2,
 125     mpeg2_dc_scale_table3,
 126 };
 127
 128 const enum AVPixelFormat ff_pixfmt_list_420[] = {
 129     AV_PIX_FMT_YUV420P,
 130     AV_PIX_FMT_NONE
 131 };
 132
 133 const enum AVPixelFormat ff_hwaccel_pixfmt_list_420[] = {
 134     AV_PIX_FMT_DXVA2_VLD,
 135     AV_PIX_FMT_VAAPI_VLD,
 136     AV_PIX_FMT_VDA_VLD,
 137     AV_PIX_FMT_YUV420P,
 138     AV_PIX_FMT_NONE
 139 };
 140
 141 const uint8_t *avpriv_mpv_find_start_code(const uint8_t *av_restrict p,
 142                                           const uint8_t *end,
 143                                           uint32_t *av_restrict state)
 144 {
 145     int i;
 146
 147     assert(p <= end);
 148     if (p >= end)
 149         return end;
 150
 151     for (i = 0; i < 3; i++) {
 152         uint32_t tmp = *state << 8;
 153         *state = tmp + *(p++);
 154         if (tmp == 0x100 || p == end)
 155             return p;
 156     }
 157
 158     while (p < end) {
 159         if      (p[-1] > 1      ) p += 3;
 160         else if (p[-2]          ) p += 2;
 161         else if (p[-3]|(p[-1]-1)) p++;
 162         else {
 163             p++;
 164             break;
 165         }
 166     }
 167
 168     p = FFMIN(p, end) - 4;
 169     *state = AV_RB32(p);
 170
 171     return p + 4;
 172 }
 173
 174 /* init common dct for both encoder and decoder */
 175 av_cold int ff_dct_common_init(MpegEncContext *s)
 176 {
 177     ff_dsputil_init(&s->dsp, s->avctx);
 178
 179     s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
 180     s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
 181     s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
 182     s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
 183     s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
 184     if (s->flags & CODEC_FLAG_BITEXACT)
 185         s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
 186     s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
 187
 188 #if ARCH_X86
 189     ff_MPV_common_init_x86(s);
 190 #elif ARCH_ALPHA
 191     ff_MPV_common_init_axp(s);
 192 #elif ARCH_ARM
 193     ff_MPV_common_init_arm(s);
 194 #elif HAVE_ALTIVEC
 195     ff_MPV_common_init_altivec(s);
 196 #elif ARCH_BFIN
 197     ff_MPV_common_init_bfin(s);
 198 #endif
 199
 200     /* load & permutate scantables
 201      * note: only wmv uses different ones
 202      */
 203     if (s->alternate_scan) {
 204         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
 205         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
 206     } else {
 207         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
 208         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
 209     }
 210     ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
 211     ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
 212
 213     return 0;
 214 }
 215
 216 void ff_copy_picture(Picture *dst, Picture *src)
 217 {
 218     *dst = *src;
 219     dst->f.type = FF_BUFFER_TYPE_COPY;
 220 }
 221
 222 /**
 223  * Release a frame buffer
 224  */
 225 static void free_frame_buffer(MpegEncContext *s, Picture *pic)
 226 {
 227     /* WM Image / Screen codecs allocate internal buffers with different
 228      * dimensions / colorspaces; ignore user-defined callbacks for these. */
 229     if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
 230         s->codec_id != AV_CODEC_ID_VC1IMAGE  &&
 231         s->codec_id != AV_CODEC_ID_MSS2)
 232         ff_thread_release_buffer(s->avctx, &pic->f);
 233     else
 234         avcodec_default_release_buffer(s->avctx, &pic->f);
 235     av_freep(&pic->f.hwaccel_picture_private);
 236 }
 237
 238 /**
 239  * Allocate a frame buffer
 240  */
 241 static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
 242 {
 243     int r;
 244
 245     if (s->avctx->hwaccel) {
 246         assert(!pic->f.hwaccel_picture_private);
 247         if (s->avctx->hwaccel->priv_data_size) {
 248             pic->f.hwaccel_picture_private = av_mallocz(s->avctx->hwaccel->priv_data_size);
 249             if (!pic->f.hwaccel_picture_private) {
 250                 av_log(s->avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
 251                 return -1;
 252             }
 253         }
 254     }
 255
 256     if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
 257         s->codec_id != AV_CODEC_ID_VC1IMAGE  &&
 258         s->codec_id != AV_CODEC_ID_MSS2)
 259         r = ff_thread_get_buffer(s->avctx, &pic->f);
 260     else
 261         r = avcodec_default_get_buffer(s->avctx, &pic->f);
 262
 263     if (r < 0 || !pic->f.type || !pic->f.data[0]) {
 264         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %p)\n",
 265                r, pic->f.type, pic->f.data[0]);
 266         av_freep(&pic->f.hwaccel_picture_private);
 267         return -1;
 268     }
 269
 270     if (s->linesize && (s->linesize   != pic->f.linesize[0] ||
 271                         s->uvlinesize != pic->f.linesize[1])) {
 272         av_log(s->avctx, AV_LOG_ERROR,
 273                "get_buffer() failed (stride changed)\n");
 274         free_frame_buffer(s, pic);
 275         return -1;
 276     }
 277
 278     if (pic->f.linesize[1] != pic->f.linesize[2]) {
 279         av_log(s->avctx, AV_LOG_ERROR,
 280                "get_buffer() failed (uv stride mismatch)\n");
 281         free_frame_buffer(s, pic);
 282         return -1;
 283     }
 284
 285     return 0;
 286 }
 287
 288 /**
 289  * Allocate a Picture.
 290  * The pixels are allocated/set by calling get_buffer() if shared = 0
 291  */
 292 int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared)
 293 {
 294     const int big_mb_num = s->mb_stride * (s->mb_height + 1) + 1;
 295
 296     // the + 1 is needed so memset(,,stride*height) does not sig11
 297
 298     const int mb_array_size = s->mb_stride * s->mb_height;
 299     const int b8_array_size = s->b8_stride * s->mb_height * 2;
 300     const int b4_array_size = s->b4_stride * s->mb_height * 4;
 301     int i;
 302     int r = -1;
 303
 304     if (shared) {
 305         assert(pic->f.data[0]);
 306         assert(pic->f.type == 0 || pic->f.type == FF_BUFFER_TYPE_SHARED);
 307         pic->f.type = FF_BUFFER_TYPE_SHARED;
 308     } else {
 309         assert(!pic->f.data[0]);
 310
 311         if (alloc_frame_buffer(s, pic) < 0)
 312             return -1;
 313
 314         s->linesize   = pic->f.linesize[0];
 315         s->uvlinesize = pic->f.linesize[1];
 316     }
 317
 318     if (pic->f.qscale_table == NULL) {
 319         if (s->encoding) {
 320             FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_var,
 321                               mb_array_size * sizeof(int16_t), fail)
 322             FF_ALLOCZ_OR_GOTO(s->avctx, pic->mc_mb_var,
 323                               mb_array_size * sizeof(int16_t), fail)
 324             FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_mean,
 325                               mb_array_size * sizeof(int8_t ), fail)
 326         }
 327
 328         FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.mbskip_table,
 329                           mb_array_size * sizeof(uint8_t) + 2, fail)// the + 2 is for the slice end check
 330         FF_ALLOCZ_OR_GOTO(s->avctx, pic->qscale_table_base,
 331                           (big_mb_num + s->mb_stride) * sizeof(uint8_t),
 332                           fail)
 333         FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_type_base,
 334                           (big_mb_num + s->mb_stride) * sizeof(uint32_t),
 335                           fail)
 336         pic->f.mb_type = pic->mb_type_base + 2 * s->mb_stride + 1;
 337         pic->f.qscale_table = pic->qscale_table_base + 2 * s->mb_stride + 1;
 338         if (s->out_format == FMT_H264) {
 339             for (i = 0; i < 2; i++) {
 340                 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i],
 341                                   2 * (b4_array_size + 4) * sizeof(int16_t),
 342                                   fail)
 343                 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
 344                 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i],
 345                                   4 * mb_array_size * sizeof(uint8_t), fail)
 346             }
 347             pic->f.motion_subsample_log2 = 2;
 348         } else if (s->out_format == FMT_H263 || s->encoding ||
 349                    (s->avctx->debug & FF_DEBUG_MV) || s->avctx->debug_mv) {
 350             for (i = 0; i < 2; i++) {
 351                 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i],
 352                                   2 * (b8_array_size + 4) * sizeof(int16_t),
 353                                   fail)
 354                 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
 355                 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i],
 356                                   4 * mb_array_size * sizeof(uint8_t), fail)
 357             }
 358             pic->f.motion_subsample_log2 = 3;
 359         }
 360         if (s->avctx->debug&FF_DEBUG_DCT_COEFF) {
 361             FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.dct_coeff,
 362                               64 * mb_array_size * sizeof(DCTELEM) * 6, fail)
 363         }
 364         pic->f.qstride = s->mb_stride;
 365         FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.pan_scan,
 366                           1 * sizeof(AVPanScan), fail)
 367     }
 368
 369     pic->owner2 = s;
 370
 371     return 0;
 372 fail: // for  the FF_ALLOCZ_OR_GOTO macro
 373     if (r >= 0)
 374         free_frame_buffer(s, pic);
 375     return -1;
 376 }
 377
 378 /**
 379  * Deallocate a picture.
 380  */
 381 static void free_picture(MpegEncContext *s, Picture *pic)
 382 {
 383     int i;
 384
 385     if (pic->f.data[0] && pic->f.type != FF_BUFFER_TYPE_SHARED) {
 386         free_frame_buffer(s, pic);
 387     }
 388
 389     av_freep(&pic->mb_var);
 390     av_freep(&pic->mc_mb_var);
 391     av_freep(&pic->mb_mean);
 392     av_freep(&pic->f.mbskip_table);
 393     av_freep(&pic->qscale_table_base);
 394     pic->f.qscale_table = NULL;
 395     av_freep(&pic->mb_type_base);
 396     pic->f.mb_type = NULL;
 397     av_freep(&pic->f.dct_coeff);
 398     av_freep(&pic->f.pan_scan);
 399     pic->f.mb_type = NULL;
 400     for (i = 0; i < 2; i++) {
 401         av_freep(&pic->motion_val_base[i]);
 402         av_freep(&pic->f.ref_index[i]);
 403         pic->f.motion_val[i] = NULL;
 404     }
 405
 406     if (pic->f.type == FF_BUFFER_TYPE_SHARED) {
 407         for (i = 0; i < 4; i++) {
 408             pic->f.base[i] =
 409             pic->f.data[i] = NULL;
 410         }
 411         pic->f.type = 0;
 412     }
 413 }
 414
 415 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base)
 416 {
 417     int y_size = s->b8_stride * (2 * s->mb_height + 1);
 418     int c_size = s->mb_stride * (s->mb_height + 1);
 419     int yc_size = y_size + 2 * c_size;
 420     int i;
 421
 422     // edge emu needs blocksize + filter length - 1
 423     // (= 17x17 for  halfpel / 21x21 for  h264)
 424     FF_ALLOCZ_OR_GOTO(s->avctx, s->edge_emu_buffer,
 425                       (s->width + 95) * 2 * 21 * 4, fail);    // (width + edge + align)*interlaced*MBsize*tolerance
 426
 427     // FIXME should be linesize instead of s->width * 2
 428     // but that is not known before get_buffer()
 429     FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad,
 430                       (s->width + 95) * 4 * 16 * 2 * sizeof(uint8_t), fail)
 431     s->me.temp         = s->me.scratchpad;
 432     s->rd_scratchpad   = s->me.scratchpad;
 433     s->b_scratchpad    = s->me.scratchpad;
 434     s->obmc_scratchpad = s->me.scratchpad + 16;
 435     if (s->encoding) {
 436         FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map,
 437                           ME_MAP_SIZE * sizeof(uint32_t), fail)
 438         FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map,
 439                           ME_MAP_SIZE * sizeof(uint32_t), fail)
 440         if (s->avctx->noise_reduction) {
 441             FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum,
 442                               2 * 64 * sizeof(int), fail)
 443         }
 444     }
 445     FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64 * 12 * 2 * sizeof(DCTELEM), fail)
 446     s->block = s->blocks[0];
 447
 448     for (i = 0; i < 12; i++) {
 449         s->pblocks[i] = &s->block[i];
 450     }
 451
 452     if (s->out_format == FMT_H263) {
 453         /* ac values */
 454         FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base,
 455                           yc_size * sizeof(int16_t) * 16, fail);
 456         s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
 457         s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
 458         s->ac_val[2] = s->ac_val[1] + c_size;
 459     }
 460
 461     return 0;
 462 fail:
 463     return -1; // free() through ff_MPV_common_end()
 464 }
 465
 466 static void free_duplicate_context(MpegEncContext *s)
 467 {
 468     if (s == NULL)
 469         return;
 470
 471     av_freep(&s->edge_emu_buffer);
 472     av_freep(&s->me.scratchpad);
 473     s->me.temp =
 474     s->rd_scratchpad =
 475     s->b_scratchpad =
 476     s->obmc_scratchpad = NULL;
 477
 478     av_freep(&s->dct_error_sum);
 479     av_freep(&s->me.map);
 480     av_freep(&s->me.score_map);
 481     av_freep(&s->blocks);
 482     av_freep(&s->ac_val_base);
 483     s->block = NULL;
 484 }
 485
 486 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
 487 {
 488 #define COPY(a) bak->a = src->a
 489     COPY(edge_emu_buffer);
 490     COPY(me.scratchpad);
 491     COPY(me.temp);
 492     COPY(rd_scratchpad);
 493     COPY(b_scratchpad);
 494     COPY(obmc_scratchpad);
 495     COPY(me.map);
 496     COPY(me.score_map);
 497     COPY(blocks);
 498     COPY(block);
 499     COPY(start_mb_y);
 500     COPY(end_mb_y);
 501     COPY(me.map_generation);
 502     COPY(pb);
 503     COPY(dct_error_sum);
 504     COPY(dct_count[0]);
 505     COPY(dct_count[1]);
 506     COPY(ac_val_base);
 507     COPY(ac_val[0]);
 508     COPY(ac_val[1]);
 509     COPY(ac_val[2]);
 510 #undef COPY
 511 }
 512
 513 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
 514 {
 515     MpegEncContext bak;
 516     int i;
 517     // FIXME copy only needed parts
 518     // START_TIMER
 519     backup_duplicate_context(&bak, dst);
 520     memcpy(dst, src, sizeof(MpegEncContext));
 521     backup_duplicate_context(dst, &bak);
 522     for (i = 0; i < 12; i++) {
 523         dst->pblocks[i] = &dst->block[i];
 524     }
 525     // STOP_TIMER("update_duplicate_context")
 526     // about 10k cycles / 0.01 sec for  1000frames on 1ghz with 2 threads
 527 }
 528
 529 int ff_mpeg_update_thread_context(AVCodecContext *dst,
 530                                   const AVCodecContext *src)
 531 {
 532     int i;
 533     MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
 534
 535     if (dst == src)
 536         return 0;
 537
 538     // FIXME can parameters change on I-frames?
 539     // in that case dst may need a reinit
 540     if (!s->context_initialized) {
 541         memcpy(s, s1, sizeof(MpegEncContext));
 542
 543         s->avctx                 = dst;
 544         s->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             ff_MPV_common_init(s);
 551         }
 552     }
 553
 554     if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
 555         int err;
 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     memcpy(s->picture, s1->picture, s1->picture_count * sizeof(Picture));
 573     memcpy(&s->last_picture, &s1->last_picture,
 574            (char *) &s1->last_picture_ptr - (char *) &s1->last_picture);
 575
 576     // reset s->picture[].f.extended_data to s->picture[].f.data
 577     for (i = 0; i < s->picture_count; i++)
 578         s->picture[i].f.extended_data = s->picture[i].f.data;
 579
 580     s->last_picture_ptr    = REBASE_PICTURE(s1->last_picture_ptr,    s, s1);
 581     s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
 582     s->next_picture_ptr    = REBASE_PICTURE(s1->next_picture_ptr,    s, s1);
 583
 584     // Error/bug resilience
 585     s->next_p_frame_damaged = s1->next_p_frame_damaged;
 586     s->workaround_bugs      = s1->workaround_bugs;
 587     s->padding_bug_score    = s1->padding_bug_score;
 588
 589     // MPEG4 timing info
 590     memcpy(&s->time_increment_bits, &s1->time_increment_bits,
 591            (char *) &s1->shape - (char *) &s1->time_increment_bits);
 592
 593     // B-frame info
 594     s->max_b_frames = s1->max_b_frames;
 595     s->low_delay    = s1->low_delay;
 596     s->dropable     = s1->dropable;
 597
 598     // DivX handling (doesn't work)
 599     s->divx_packed  = s1->divx_packed;
 600
 601     if (s1->bitstream_buffer) {
 602         if (s1->bitstream_buffer_size +
 603             FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
 604             av_fast_malloc(&s->bitstream_buffer,
 605                            &s->allocated_bitstream_buffer_size,
 606                            s1->allocated_bitstream_buffer_size);
 607             s->bitstream_buffer_size = s1->bitstream_buffer_size;
 608         memcpy(s->bitstream_buffer, s1->bitstream_buffer,
 609                s1->bitstream_buffer_size);
 610         memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
 611                FF_INPUT_BUFFER_PADDING_SIZE);
 612     }
 613
 614     // MPEG2/interlacing info
 615     memcpy(&s->progressive_sequence, &s1->progressive_sequence,
 616            (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
 617
 618     if (!s1->first_field) {
 619         s->last_pict_type = s1->pict_type;
 620         if (s1->current_picture_ptr)
 621             s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f.quality;
 622
 623         if (s1->pict_type != AV_PICTURE_TYPE_B) {
 624             s->last_non_b_pict_type = s1->pict_type;
 625         }
 626     }
 627
 628     return 0;
 629 }
 630
 631 /**
 632  * Set the given MpegEncContext to common defaults
 633  * (same for encoding and decoding).
 634  * The changed fields will not depend upon the
 635  * prior state of the MpegEncContext.
 636  */
 637 void ff_MPV_common_defaults(MpegEncContext *s)
 638 {
 639     s->y_dc_scale_table      =
 640     s->c_dc_scale_table      = ff_mpeg1_dc_scale_table;
 641     s->chroma_qscale_table   = ff_default_chroma_qscale_table;
 642     s->progressive_frame     = 1;
 643     s->progressive_sequence  = 1;
 644     s->picture_structure     = PICT_FRAME;
 645
 646     s->coded_picture_number  = 0;
 647     s->picture_number        = 0;
 648     s->input_picture_number  = 0;
 649
 650     s->picture_in_gop_number = 0;
 651
 652     s->f_code                = 1;
 653     s->b_code                = 1;
 654
 655     s->picture_range_start   = 0;
 656     s->picture_range_end     = MAX_PICTURE_COUNT;
 657
 658     s->slice_context_count   = 1;
 659 }
 660
 661 /**
 662  * Set the given MpegEncContext to defaults for decoding.
 663  * the changed fields will not depend upon
 664  * the prior state of the MpegEncContext.
 665  */
 666 void ff_MPV_decode_defaults(MpegEncContext *s)
 667 {
 668     ff_MPV_common_defaults(s);
 669 }
 670
 671 /**
 672  * Initialize and allocates MpegEncContext fields dependent on the resolution.
 673  */
 674 static int init_context_frame(MpegEncContext *s)
 675 {
 676     int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
 677
 678     s->mb_width   = (s->width + 15) / 16;
 679     s->mb_stride  = s->mb_width + 1;
 680     s->b8_stride  = s->mb_width * 2 + 1;
 681     s->b4_stride  = s->mb_width * 4 + 1;
 682     mb_array_size = s->mb_height * s->mb_stride;
 683     mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
 684
 685     /* set default edge pos, will be overriden
 686      * in decode_header if needed */
 687     s->h_edge_pos = s->mb_width * 16;
 688     s->v_edge_pos = s->mb_height * 16;
 689
 690     s->mb_num     = s->mb_width * s->mb_height;
 691
 692     s->block_wrap[0] =
 693     s->block_wrap[1] =
 694     s->block_wrap[2] =
 695     s->block_wrap[3] = s->b8_stride;
 696     s->block_wrap[4] =
 697     s->block_wrap[5] = s->mb_stride;
 698
 699     y_size  = s->b8_stride * (2 * s->mb_height + 1);
 700     c_size  = s->mb_stride * (s->mb_height + 1);
 701     yc_size = y_size + 2   * c_size;
 702
 703     FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int), fail); // error ressilience code looks cleaner with this
 704     for (y = 0; y < s->mb_height; y++)
 705         for (x = 0; x < s->mb_width; x++)
 706             s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
 707
 708     s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
 709
 710     if (s->encoding) {
 711         /* Allocate MV tables */
 712         FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base,                 mv_table_size * 2 * sizeof(int16_t), fail)
 713         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base,            mv_table_size * 2 * sizeof(int16_t), fail)
 714         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base,            mv_table_size * 2 * sizeof(int16_t), fail)
 715         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base,      mv_table_size * 2 * sizeof(int16_t), fail)
 716         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base,      mv_table_size * 2 * sizeof(int16_t), fail)
 717         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base,          mv_table_size * 2 * sizeof(int16_t), fail)
 718         s->p_mv_table            = s->p_mv_table_base + s->mb_stride + 1;
 719         s->b_forw_mv_table       = s->b_forw_mv_table_base + s->mb_stride + 1;
 720         s->b_back_mv_table       = s->b_back_mv_table_base + s->mb_stride + 1;
 721         s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
 722         s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base + s->mb_stride + 1;
 723         s->b_direct_mv_table     = s->b_direct_mv_table_base + s->mb_stride + 1;
 724
 725         /* Allocate MB type table */
 726         FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size * sizeof(uint16_t), fail) // needed for encoding
 727
 728         FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
 729
 730         FF_ALLOC_OR_GOTO(s->avctx, s->cplx_tab,
 731                          mb_array_size * sizeof(float), fail);
 732         FF_ALLOC_OR_GOTO(s->avctx, s->bits_tab,
 733                          mb_array_size * sizeof(float), fail);
 734
 735     }
 736
 737     FF_ALLOC_OR_GOTO(s->avctx, s->er_temp_buffer,
 738                      mb_array_size * sizeof(uint8_t), fail);
 739     FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table,
 740                       mb_array_size * sizeof(uint8_t), fail);
 741
 742     if (s->codec_id == AV_CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)) {
 743         /* interlaced direct mode decoding tables */
 744         for (i = 0; i < 2; i++) {
 745             int j, k;
 746             for (j = 0; j < 2; j++) {
 747                 for (k = 0; k < 2; k++) {
 748                     FF_ALLOCZ_OR_GOTO(s->avctx,
 749                                       s->b_field_mv_table_base[i][j][k],
 750                                       mv_table_size * 2 * sizeof(int16_t),
 751                                       fail);
 752                     s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
 753                                                    s->mb_stride + 1;
 754                 }
 755                 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
 756                 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
 757                 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
 758             }
 759             FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
 760         }
 761     }
 762     if (s->out_format == FMT_H263) {
 763         /* cbp values */
 764         FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
 765         s->coded_block = s->coded_block_base + s->b8_stride + 1;
 766
 767         /* cbp, ac_pred, pred_dir */
 768         FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table     , mb_array_size * sizeof(uint8_t), fail);
 769         FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail);
 770     }
 771
 772     if (s->h263_pred || s->h263_plus || !s->encoding) {
 773         /* dc values */
 774         // MN: we need these for  error resilience of intra-frames
 775         FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
 776         s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
 777         s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
 778         s->dc_val[2] = s->dc_val[1] + c_size;
 779         for (i = 0; i < yc_size; i++)
 780             s->dc_val_base[i] = 1024;
 781     }
 782
 783     /* which mb is a intra block */
 784     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
 785     memset(s->mbintra_table, 1, mb_array_size);
 786
 787     /* init macroblock skip table */
 788     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
 789     // Note the + 1 is for  a quicker mpeg4 slice_end detection
 790
 791     return 0;
 792 fail:
 793     return AVERROR(ENOMEM);
 794 }
 795
 796 /**
 797  * init common structure for both encoder and decoder.
 798  * this assumes that some variables like width/height are already set
 799  */
 800 av_cold int ff_MPV_common_init(MpegEncContext *s)
 801 {
 802     int i;
 803     int nb_slices = (HAVE_THREADS &&
 804                      s->avctx->active_thread_type & FF_THREAD_SLICE) ?
 805                     s->avctx->thread_count : 1;
 806
 807     if (s->encoding && s->avctx->slices)
 808         nb_slices = s->avctx->slices;
 809
 810     if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
 811         s->mb_height = (s->height + 31) / 32 * 2;
 812     else if (s->codec_id != AV_CODEC_ID_H264)
 813         s->mb_height = (s->height + 15) / 16;
 814
 815     if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
 816         av_log(s->avctx, AV_LOG_ERROR,
 817                "decoding to AV_PIX_FMT_NONE is not supported.\n");
 818         return -1;
 819     }
 820
 821     if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
 822         int max_slices;
 823         if (s->mb_height)
 824             max_slices = FFMIN(MAX_THREADS, s->mb_height);
 825         else
 826             max_slices = MAX_THREADS;
 827         av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
 828                " reducing to %d\n", nb_slices, max_slices);
 829         nb_slices = max_slices;
 830     }
 831
 832     if ((s->width || s->height) &&
 833         av_image_check_size(s->width, s->height, 0, s->avctx))
 834         return -1;
 835
 836     ff_dct_common_init(s);
 837
 838     s->flags  = s->avctx->flags;
 839     s->flags2 = s->avctx->flags2;
 840
 841         /* set chroma shifts */
 842         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &s->chroma_x_shift,
 843                                       &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         (s->out_format != FMT_H264 || s->codec_id == AV_CODEC_ID_SVQ3)) {
1458         if (s->next_picture_ptr)
1459             s->next_picture_ptr->owner2 = s;
1460         if (s->last_picture_ptr)
1461             s->last_picture_ptr->owner2 = s;
1462     }
1463
1464     assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1465                                                  s->last_picture_ptr->f.data[0]));
1466
1467     if (s->picture_structure!= PICT_FRAME && s->out_format != FMT_H264) {
1468         int i;
1469         for (i = 0; i < 4; i++) {
1470             if (s->picture_structure == PICT_BOTTOM_FIELD) {
1471                 s->current_picture.f.data[i] +=
1472                     s->current_picture.f.linesize[i];
1473             }
1474             s->current_picture.f.linesize[i] *= 2;
1475             s->last_picture.f.linesize[i]    *= 2;
1476             s->next_picture.f.linesize[i]    *= 2;
1477         }
1478     }
1479
1480     s->err_recognition = avctx->err_recognition;
1481
1482     /* set dequantizer, we can't do it during init as
1483      * it might change for mpeg4 and we can't do it in the header
1484      * decode as init is not called for mpeg4 there yet */
1485     if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1486         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1487         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1488     } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1489         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1490         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1491     } else {
1492         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1493         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1494     }
1495
1496     if (s->dct_error_sum) {
1497         assert(s->avctx->noise_reduction && s->encoding);
1498         update_noise_reduction(s);
1499     }
1500
1501     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1502         return ff_xvmc_field_start(s, avctx);
1503
1504     return 0;
1505 }
1506
1507 /* generic function for encode/decode called after a
1508  * frame has been coded/decoded. */
1509 void ff_MPV_frame_end(MpegEncContext *s)
1510 {
1511     int i;
1512     /* redraw edges for the frame if decoding didn't complete */
1513     // just to make sure that all data is rendered.
1514     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
1515         ff_xvmc_field_end(s);
1516    } else if((s->error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND)) &&
1517               !s->avctx->hwaccel &&
1518               !(s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
1519               s->unrestricted_mv &&
1520               s->current_picture.f.reference &&
1521               !s->intra_only &&
1522               !(s->flags & CODEC_FLAG_EMU_EDGE) &&
1523               !s->avctx->lowres
1524             ) {
1525         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1526         int hshift = desc->log2_chroma_w;
1527         int vshift = desc->log2_chroma_h;
1528         s->dsp.draw_edges(s->current_picture.f.data[0], s->current_picture.f.linesize[0],
1529                           s->h_edge_pos, s->v_edge_pos,
1530                           EDGE_WIDTH, EDGE_WIDTH,
1531                           EDGE_TOP | EDGE_BOTTOM);
1532         s->dsp.draw_edges(s->current_picture.f.data[1], s->current_picture.f.linesize[1],
1533                           s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1534                           EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1535                           EDGE_TOP | EDGE_BOTTOM);
1536         s->dsp.draw_edges(s->current_picture.f.data[2], s->current_picture.f.linesize[2],
1537                           s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1538                           EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1539                           EDGE_TOP | EDGE_BOTTOM);
1540     }
1541
1542     emms_c();
1543
1544     s->last_pict_type                 = s->pict_type;
1545     s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f.quality;
1546     if (s->pict_type!= AV_PICTURE_TYPE_B) {
1547         s->last_non_b_pict_type = s->pict_type;
1548     }
1549 #if 0
1550     /* copy back current_picture variables */
1551     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1552         if (s->picture[i].f.data[0] == s->current_picture.f.data[0]) {
1553             s->picture[i] = s->current_picture;
1554             break;
1555         }
1556     }
1557     assert(i < MAX_PICTURE_COUNT);
1558 #endif
1559
1560     if (s->encoding) {
1561         /* release non-reference frames */
1562         for (i = 0; i < s->picture_count; i++) {
1563             if (s->picture[i].f.data[0] && !s->picture[i].f.reference
1564                 /* && s->picture[i].type != FF_BUFFER_TYPE_SHARED */) {
1565                 free_frame_buffer(s, &s->picture[i]);
1566             }
1567         }
1568     }
1569     // clear copies, to avoid confusion
1570 #if 0
1571     memset(&s->last_picture,    0, sizeof(Picture));
1572     memset(&s->next_picture,    0, sizeof(Picture));
1573     memset(&s->current_picture, 0, sizeof(Picture));
1574 #endif
1575     s->avctx->coded_frame = &s->current_picture_ptr->f;
1576
1577     if (s->codec_id != AV_CODEC_ID_H264 && s->current_picture.f.reference) {
1578         ff_thread_report_progress(&s->current_picture_ptr->f, INT_MAX, 0);
1579     }
1580 }
1581
1582 /**
1583  * Draw a line from (ex, ey) -> (sx, sy).
1584  * @param w width of the image
1585  * @param h height of the image
1586  * @param stride stride/linesize of the image
1587  * @param color color of the arrow
1588  */
1589 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
1590                       int w, int h, int stride, int color)
1591 {
1592     int x, y, fr, f;
1593
1594     sx = av_clip(sx, 0, w - 1);
1595     sy = av_clip(sy, 0, h - 1);
1596     ex = av_clip(ex, 0, w - 1);
1597     ey = av_clip(ey, 0, h - 1);
1598
1599     buf[sy * stride + sx] += color;
1600
1601     if (FFABS(ex - sx) > FFABS(ey - sy)) {
1602         if (sx > ex) {
1603             FFSWAP(int, sx, ex);
1604             FFSWAP(int, sy, ey);
1605         }
1606         buf += sx + sy * stride;
1607         ex  -= sx;
1608         f    = ((ey - sy) << 16) / ex;
1609         for(x= 0; x <= ex; x++){
1610             y  = (x * f) >> 16;
1611             fr = (x * f) & 0xFFFF;
1612             buf[y * stride + x]       += (color * (0x10000 - fr)) >> 16;
1613             if(fr) buf[(y + 1) * stride + x] += (color *            fr ) >> 16;
1614         }
1615     } else {
1616         if (sy > ey) {
1617             FFSWAP(int, sx, ex);
1618             FFSWAP(int, sy, ey);
1619         }
1620         buf += sx + sy * stride;
1621         ey  -= sy;
1622         if (ey)
1623             f = ((ex - sx) << 16) / ey;
1624         else
1625             f = 0;
1626         for(y= 0; y <= ey; y++){
1627             x  = (y*f) >> 16;
1628             fr = (y*f) & 0xFFFF;
1629             buf[y * stride + x]     += (color * (0x10000 - fr)) >> 16;
1630             if(fr) buf[y * stride + x + 1] += (color *            fr ) >> 16;
1631         }
1632     }
1633 }
1634
1635 /**
1636  * Draw an arrow from (ex, ey) -> (sx, sy).
1637  * @param w width of the image
1638  * @param h height of the image
1639  * @param stride stride/linesize of the image
1640  * @param color color of the arrow
1641  */
1642 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
1643                        int ey, int w, int h, int stride, int color)
1644 {
1645     int dx,dy;
1646
1647     sx = av_clip(sx, -100, w + 100);
1648     sy = av_clip(sy, -100, h + 100);
1649     ex = av_clip(ex, -100, w + 100);
1650     ey = av_clip(ey, -100, h + 100);
1651
1652     dx = ex - sx;
1653     dy = ey - sy;
1654
1655     if (dx * dx + dy * dy > 3 * 3) {
1656         int rx =  dx + dy;
1657         int ry = -dx + dy;
1658         int length = ff_sqrt((rx * rx + ry * ry) << 8);
1659
1660         // FIXME subpixel accuracy
1661         rx = ROUNDED_DIV(rx * 3 << 4, length);
1662         ry = ROUNDED_DIV(ry * 3 << 4, length);
1663
1664         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1665         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1666     }
1667     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1668 }
1669
1670 /**
1671  * Print debugging info for the given picture.
1672  */
1673 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict)
1674 {
1675     if (   s->avctx->hwaccel || !pict || !pict->mb_type
1676         || (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU))
1677         return;
1678
1679
1680     if (s->avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
1681         int x,y;
1682
1683         av_log(s->avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
1684                av_get_picture_type_char(pict->pict_type));
1685         for (y = 0; y < s->mb_height; y++) {
1686             for (x = 0; x < s->mb_width; x++) {
1687                 if (s->avctx->debug & FF_DEBUG_SKIP) {
1688                     int count = s->mbskip_table[x + y * s->mb_stride];
1689                     if (count > 9)
1690                         count = 9;
1691                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1692                 }
1693                 if (s->avctx->debug & FF_DEBUG_QP) {
1694                     av_log(s->avctx, AV_LOG_DEBUG, "%2d",
1695                            pict->qscale_table[x + y * s->mb_stride]);
1696                 }
1697                 if (s->avctx->debug & FF_DEBUG_MB_TYPE) {
1698                     int mb_type = pict->mb_type[x + y * s->mb_stride];
1699                     // Type & MV direction
1700                     if (IS_PCM(mb_type))
1701                         av_log(s->avctx, AV_LOG_DEBUG, "P");
1702                     else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1703                         av_log(s->avctx, AV_LOG_DEBUG, "A");
1704                     else if (IS_INTRA4x4(mb_type))
1705                         av_log(s->avctx, AV_LOG_DEBUG, "i");
1706                     else if (IS_INTRA16x16(mb_type))
1707                         av_log(s->avctx, AV_LOG_DEBUG, "I");
1708                     else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1709                         av_log(s->avctx, AV_LOG_DEBUG, "d");
1710                     else if (IS_DIRECT(mb_type))
1711                         av_log(s->avctx, AV_LOG_DEBUG, "D");
1712                     else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
1713                         av_log(s->avctx, AV_LOG_DEBUG, "g");
1714                     else if (IS_GMC(mb_type))
1715                         av_log(s->avctx, AV_LOG_DEBUG, "G");
1716                     else if (IS_SKIP(mb_type))
1717                         av_log(s->avctx, AV_LOG_DEBUG, "S");
1718                     else if (!USES_LIST(mb_type, 1))
1719                         av_log(s->avctx, AV_LOG_DEBUG, ">");
1720                     else if (!USES_LIST(mb_type, 0))
1721                         av_log(s->avctx, AV_LOG_DEBUG, "<");
1722                     else {
1723                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1724                         av_log(s->avctx, AV_LOG_DEBUG, "X");
1725                     }
1726
1727                     // segmentation
1728                     if (IS_8X8(mb_type))
1729                         av_log(s->avctx, AV_LOG_DEBUG, "+");
1730                     else if (IS_16X8(mb_type))
1731                         av_log(s->avctx, AV_LOG_DEBUG, "-");
1732                     else if (IS_8X16(mb_type))
1733                         av_log(s->avctx, AV_LOG_DEBUG, "|");
1734                     else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
1735                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1736                     else
1737                         av_log(s->avctx, AV_LOG_DEBUG, "?");
1738
1739
1740                     if (IS_INTERLACED(mb_type))
1741                         av_log(s->avctx, AV_LOG_DEBUG, "=");
1742                     else
1743                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1744                 }
1745             }
1746             av_log(s->avctx, AV_LOG_DEBUG, "\n");
1747         }
1748     }
1749
1750     if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
1751         (s->avctx->debug_mv)) {
1752         const int shift = 1 + s->quarter_sample;
1753         int mb_y;
1754         uint8_t *ptr;
1755         int i;
1756         int h_chroma_shift, v_chroma_shift, block_height;
1757         const int width          = s->avctx->width;
1758         const int height         = s->avctx->height;
1759         const int mv_sample_log2 = 4 - pict->motion_subsample_log2;
1760         const int mv_stride      = (s->mb_width << mv_sample_log2) +
1761                                    (s->codec_id == AV_CODEC_ID_H264 ? 0 : 1);
1762         s->low_delay = 0; // needed to see the vectors without trashing the buffers
1763
1764         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,
1765                                       &h_chroma_shift, &v_chroma_shift);
1766         for (i = 0; i < 3; i++) {
1767             size_t size= (i == 0) ? pict->linesize[i] * FFALIGN(height, 16):
1768                          pict->linesize[i] * FFALIGN(height, 16) >> v_chroma_shift;
1769             s->visualization_buffer[i]= av_realloc(s->visualization_buffer[i], size);
1770             memcpy(s->visualization_buffer[i], pict->data[i], size);
1771             pict->data[i] = s->visualization_buffer[i];
1772         }
1773         pict->type   = FF_BUFFER_TYPE_COPY;
1774         pict->opaque= NULL;
1775         ptr          = pict->data[0];
1776         block_height = 16 >> v_chroma_shift;
1777
1778         for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1779             int mb_x;
1780             for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1781                 const int mb_index = mb_x + mb_y * s->mb_stride;
1782                 if ((s->avctx->debug_mv) && pict->motion_val) {
1783                     int type;
1784                     for (type = 0; type < 3; type++) {
1785                         int direction = 0;
1786                         switch (type) {
1787                         case 0:
1788                             if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
1789                                 (pict->pict_type!= AV_PICTURE_TYPE_P))
1790                                 continue;
1791                             direction = 0;
1792                             break;
1793                         case 1:
1794                             if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
1795                                 (pict->pict_type!= AV_PICTURE_TYPE_B))
1796                                 continue;
1797                             direction = 0;
1798                             break;
1799                         case 2:
1800                             if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
1801                                 (pict->pict_type!= AV_PICTURE_TYPE_B))
1802                                 continue;
1803                             direction = 1;
1804                             break;
1805                         }
1806                         if (!USES_LIST(pict->mb_type[mb_index], direction))
1807                             continue;
1808
1809                         if (IS_8X8(pict->mb_type[mb_index])) {
1810                             int i;
1811                             for (i = 0; i < 4; i++) {
1812                                 int sx = mb_x * 16 + 4 + 8 * (i & 1);
1813                                 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
1814                                 int xy = (mb_x * 2 + (i & 1) +
1815                                           (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1816                                 int mx = (pict->motion_val[direction][xy][0] >> shift) + sx;
1817                                 int my = (pict->motion_val[direction][xy][1] >> shift) + sy;
1818                                 draw_arrow(ptr, sx, sy, mx, my, width,
1819                                            height, s->linesize, 100);
1820                             }
1821                         } else if (IS_16X8(pict->mb_type[mb_index])) {
1822                             int i;
1823                             for (i = 0; i < 2; i++) {
1824                                 int sx = mb_x * 16 + 8;
1825                                 int sy = mb_y * 16 + 4 + 8 * i;
1826                                 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
1827                                 int mx = (pict->motion_val[direction][xy][0] >> shift);
1828                                 int my = (pict->motion_val[direction][xy][1] >> shift);
1829
1830                                 if (IS_INTERLACED(pict->mb_type[mb_index]))
1831                                     my *= 2;
1832
1833                             draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1834                                        height, s->linesize, 100);
1835                             }
1836                         } else if (IS_8X16(pict->mb_type[mb_index])) {
1837                             int i;
1838                             for (i = 0; i < 2; i++) {
1839                                 int sx = mb_x * 16 + 4 + 8 * i;
1840                                 int sy = mb_y * 16 + 8;
1841                                 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
1842                                 int mx = pict->motion_val[direction][xy][0] >> shift;
1843                                 int my = pict->motion_val[direction][xy][1] >> shift;
1844
1845                                 if (IS_INTERLACED(pict->mb_type[mb_index]))
1846                                     my *= 2;
1847
1848                                 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1849                                            height, s->linesize, 100);
1850                             }
1851                         } else {
1852                               int sx= mb_x * 16 + 8;
1853                               int sy= mb_y * 16 + 8;
1854                               int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
1855                               int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1856                               int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1857                               draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1858                         }
1859                     }
1860                 }
1861                 if ((s->avctx->debug & FF_DEBUG_VIS_QP) && pict->motion_val) {
1862                     uint64_t c = (pict->qscale_table[mb_index] * 128 / 31) *
1863                                  0x0101010101010101ULL;
1864                     int y;
1865                     for (y = 0; y < block_height; y++) {
1866                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
1867                                       (block_height * mb_y + y) *
1868                                       pict->linesize[1]) = c;
1869                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
1870                                       (block_height * mb_y + y) *
1871                                       pict->linesize[2]) = c;
1872                     }
1873                 }
1874                 if ((s->avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
1875                     pict->motion_val) {
1876                     int mb_type = pict->mb_type[mb_index];
1877                     uint64_t u,v;
1878                     int y;
1879 #define COLOR(theta, r) \
1880     u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
1881     v = (int)(128 + r * sin(theta * 3.141592 / 180));
1882
1883
1884                     u = v = 128;
1885                     if (IS_PCM(mb_type)) {
1886                         COLOR(120, 48)
1887                     } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
1888                                IS_INTRA16x16(mb_type)) {
1889                         COLOR(30, 48)
1890                     } else if (IS_INTRA4x4(mb_type)) {
1891                         COLOR(90, 48)
1892                     } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
1893                         // COLOR(120, 48)
1894                     } else if (IS_DIRECT(mb_type)) {
1895                         COLOR(150, 48)
1896                     } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
1897                         COLOR(170, 48)
1898                     } else if (IS_GMC(mb_type)) {
1899                         COLOR(190, 48)
1900                     } else if (IS_SKIP(mb_type)) {
1901                         // COLOR(180, 48)
1902                     } else if (!USES_LIST(mb_type, 1)) {
1903                         COLOR(240, 48)
1904                     } else if (!USES_LIST(mb_type, 0)) {
1905                         COLOR(0, 48)
1906                     } else {
1907                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1908                         COLOR(300,48)
1909                     }
1910
1911                     u *= 0x0101010101010101ULL;
1912                     v *= 0x0101010101010101ULL;
1913                     for (y = 0; y < block_height; y++) {
1914                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
1915                                       (block_height * mb_y + y) * pict->linesize[1]) = u;
1916                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
1917                                       (block_height * mb_y + y) * pict->linesize[2]) = v;
1918                     }
1919
1920                     // segmentation
1921                     if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
1922                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
1923                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1924                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
1925                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1926                     }
1927                     if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
1928                         for (y = 0; y < 16; y++)
1929                             pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
1930                                           pict->linesize[0]] ^= 0x80;
1931                     }
1932                     if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
1933                         int dm = 1 << (mv_sample_log2 - 2);
1934                         for (i = 0; i < 4; i++) {
1935                             int sx = mb_x * 16 + 8 * (i & 1);
1936                             int sy = mb_y * 16 + 8 * (i >> 1);
1937                             int xy = (mb_x * 2 + (i & 1) +
1938                                      (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1939                             // FIXME bidir
1940                             int32_t *mv = (int32_t *) &pict->motion_val[0][xy];
1941                             if (mv[0] != mv[dm] ||
1942                                 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
1943                                 for (y = 0; y < 8; y++)
1944                                     pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
1945                             if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
1946                                 *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
1947                                               pict->linesize[0]) ^= 0x8080808080808080ULL;
1948                         }
1949                     }
1950
1951                     if (IS_INTERLACED(mb_type) &&
1952                         s->codec_id == AV_CODEC_ID_H264) {
1953                         // hmm
1954                     }
1955                 }
1956                 s->mbskip_table[mb_index] = 0;
1957             }
1958         }
1959     }
1960 }
1961
1962 static inline int hpel_motion_lowres(MpegEncContext *s,
1963                                      uint8_t *dest, uint8_t *src,
1964                                      int field_based, int field_select,
1965                                      int src_x, int src_y,
1966                                      int width, int height, int stride,
1967                                      int h_edge_pos, int v_edge_pos,
1968                                      int w, int h, h264_chroma_mc_func *pix_op,
1969                                      int motion_x, int motion_y)
1970 {
1971     const int lowres   = s->avctx->lowres;
1972     const int op_index = FFMIN(lowres, 2);
1973     const int s_mask   = (2 << lowres) - 1;
1974     int emu = 0;
1975     int sx, sy;
1976
1977     if (s->quarter_sample) {
1978         motion_x /= 2;
1979         motion_y /= 2;
1980     }
1981
1982     sx = motion_x & s_mask;
1983     sy = motion_y & s_mask;
1984     src_x += motion_x >> lowres + 1;
1985     src_y += motion_y >> lowres + 1;
1986
1987     src   += src_y * stride + src_x;
1988
1989     if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w,                 0) ||
1990         (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1991         s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w + 1,
1992                                 (h + 1) << field_based, src_x,
1993                                 src_y   << field_based,
1994                                 h_edge_pos,
1995                                 v_edge_pos);
1996         src = s->edge_emu_buffer;
1997         emu = 1;
1998     }
1999
2000     sx = (sx << 2) >> lowres;
2001     sy = (sy << 2) >> lowres;
2002     if (field_select)
2003         src += s->linesize;
2004     pix_op[op_index](dest, src, stride, h, sx, sy);
2005     return emu;
2006 }
2007
2008 /* apply one mpeg motion vector to the three components */
2009 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
2010                                                 uint8_t *dest_y,
2011                                                 uint8_t *dest_cb,
2012                                                 uint8_t *dest_cr,
2013                                                 int field_based,
2014                                                 int bottom_field,
2015                                                 int field_select,
2016                                                 uint8_t **ref_picture,
2017                                                 h264_chroma_mc_func *pix_op,
2018                                                 int motion_x, int motion_y,
2019                                                 int h, int mb_y)
2020 {
2021     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2022     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy,
2023         uvsx, uvsy;
2024     const int lowres     = s->avctx->lowres;
2025     const int op_index   = FFMIN(lowres-1+s->chroma_x_shift, 2);
2026     const int block_s    = 8>>lowres;
2027     const int s_mask     = (2 << lowres) - 1;
2028     const int h_edge_pos = s->h_edge_pos >> lowres;
2029     const int v_edge_pos = s->v_edge_pos >> lowres;
2030     linesize   = s->current_picture.f.linesize[0] << field_based;
2031     uvlinesize = s->current_picture.f.linesize[1] << field_based;
2032
2033     // FIXME obviously not perfect but qpel will not work in lowres anyway
2034     if (s->quarter_sample) {
2035         motion_x /= 2;
2036         motion_y /= 2;
2037     }
2038
2039     if(field_based){
2040         motion_y += (bottom_field - field_select)*((1 << lowres)-1);
2041     }
2042
2043     sx = motion_x & s_mask;
2044     sy = motion_y & s_mask;
2045     src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
2046     src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
2047
2048     if (s->out_format == FMT_H263) {
2049         uvsx    = ((motion_x >> 1) & s_mask) | (sx & 1);
2050         uvsy    = ((motion_y >> 1) & s_mask) | (sy & 1);
2051         uvsrc_x = src_x >> 1;
2052         uvsrc_y = src_y >> 1;
2053     } else if (s->out_format == FMT_H261) {
2054         // even chroma mv's are full pel in H261
2055         mx      = motion_x / 4;
2056         my      = motion_y / 4;
2057         uvsx    = (2 * mx) & s_mask;
2058         uvsy    = (2 * my) & s_mask;
2059         uvsrc_x = s->mb_x * block_s + (mx >> lowres);
2060         uvsrc_y =    mb_y * block_s + (my >> lowres);
2061     } else {
2062         if(s->chroma_y_shift){
2063             mx      = motion_x / 2;
2064             my      = motion_y / 2;
2065             uvsx    = mx & s_mask;
2066             uvsy    = my & s_mask;
2067             uvsrc_x = s->mb_x * block_s                 + (mx >> lowres + 1);
2068             uvsrc_y =   (mb_y * block_s >> field_based) + (my >> lowres + 1);
2069         } else {
2070             if(s->chroma_x_shift){
2071             //Chroma422
2072                 mx = motion_x / 2;
2073                 uvsx = mx & s_mask;
2074                 uvsy = motion_y & s_mask;
2075                 uvsrc_y = src_y;
2076                 uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
2077             } else {
2078             //Chroma444
2079                 uvsx = motion_x & s_mask;
2080                 uvsy = motion_y & s_mask;
2081                 uvsrc_x = src_x;
2082                 uvsrc_y = src_y;
2083             }
2084         }
2085     }
2086
2087     ptr_y  = ref_picture[0] + src_y   * linesize   + src_x;
2088     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2089     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2090
2091     if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s,       0) ||
2092         (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2093         s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
2094                                 s->linesize, 17, 17 + field_based,
2095                                 src_x, src_y << field_based, h_edge_pos,
2096                                 v_edge_pos);
2097         ptr_y = s->edge_emu_buffer;
2098         if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2099             uint8_t *uvbuf = s->edge_emu_buffer + 18 * s->linesize;
2100             s->dsp.emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9,
2101                                     9 + field_based,
2102                                     uvsrc_x, uvsrc_y << field_based,
2103                                     h_edge_pos >> 1, v_edge_pos >> 1);
2104             s->dsp.emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9,
2105                                     9 + field_based,
2106                                     uvsrc_x, uvsrc_y << field_based,
2107                                     h_edge_pos >> 1, v_edge_pos >> 1);
2108             ptr_cb = uvbuf;
2109             ptr_cr = uvbuf + 16;
2110         }
2111     }
2112
2113     // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data
2114     if (bottom_field) {
2115         dest_y  += s->linesize;
2116         dest_cb += s->uvlinesize;
2117         dest_cr += s->uvlinesize;
2118     }
2119
2120     if (field_select) {
2121         ptr_y   += s->linesize;
2122         ptr_cb  += s->uvlinesize;
2123         ptr_cr  += s->uvlinesize;
2124     }
2125
2126     sx = (sx << 2) >> lowres;
2127     sy = (sy << 2) >> lowres;
2128     pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
2129
2130     if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2131         uvsx = (uvsx << 2) >> lowres;
2132         uvsy = (uvsy << 2) >> lowres;
2133         if (h >> s->chroma_y_shift) {
2134             pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2135             pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2136         }
2137     }
2138     // FIXME h261 lowres loop filter
2139 }
2140
2141 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
2142                                             uint8_t *dest_cb, uint8_t *dest_cr,
2143                                             uint8_t **ref_picture,
2144                                             h264_chroma_mc_func * pix_op,
2145                                             int mx, int my)
2146 {
2147     const int lowres     = s->avctx->lowres;
2148     const int op_index   = FFMIN(lowres, 2);
2149     const int block_s    = 8 >> lowres;
2150     const int s_mask     = (2 << lowres) - 1;
2151     const int h_edge_pos = s->h_edge_pos >> lowres + 1;
2152     const int v_edge_pos = s->v_edge_pos >> lowres + 1;
2153     int emu = 0, src_x, src_y, offset, sx, sy;
2154     uint8_t *ptr;
2155
2156     if (s->quarter_sample) {
2157         mx /= 2;
2158         my /= 2;
2159     }
2160
2161     /* In case of 8X8, we construct a single chroma motion vector
2162        with a special rounding */
2163     mx = ff_h263_round_chroma(mx);
2164     my = ff_h263_round_chroma(my);
2165
2166     sx = mx & s_mask;
2167     sy = my & s_mask;
2168     src_x = s->mb_x * block_s + (mx >> lowres + 1);
2169     src_y = s->mb_y * block_s + (my >> lowres + 1);
2170
2171     offset = src_y * s->uvlinesize + src_x;
2172     ptr = ref_picture[1] + offset;
2173     if (s->flags & CODEC_FLAG_EMU_EDGE) {
2174         if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2175             (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2176             s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize,
2177                                     9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
2178             ptr = s->edge_emu_buffer;
2179             emu = 1;
2180         }
2181     }
2182     sx = (sx << 2) >> lowres;
2183     sy = (sy << 2) >> lowres;
2184     pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
2185
2186     ptr = ref_picture[2] + offset;
2187     if (emu) {
2188         s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9,
2189                                 src_x, src_y, h_edge_pos, v_edge_pos);
2190         ptr = s->edge_emu_buffer;
2191     }
2192     pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
2193 }
2194
2195 /**
2196  * motion compensation of a single macroblock
2197  * @param s context
2198  * @param dest_y luma destination pointer
2199  * @param dest_cb chroma cb/u destination pointer
2200  * @param dest_cr chroma cr/v destination pointer
2201  * @param dir direction (0->forward, 1->backward)
2202  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2203  * @param pix_op halfpel motion compensation function (average or put normally)
2204  * the motion vectors are taken from s->mv and the MV type from s->mv_type
2205  */
2206 static inline void MPV_motion_lowres(MpegEncContext *s,
2207                                      uint8_t *dest_y, uint8_t *dest_cb,
2208                                      uint8_t *dest_cr,
2209                                      int dir, uint8_t **ref_picture,
2210                                      h264_chroma_mc_func *pix_op)
2211 {
2212     int mx, my;
2213     int mb_x, mb_y, i;
2214     const int lowres  = s->avctx->lowres;
2215     const int block_s = 8 >>lowres;
2216
2217     mb_x = s->mb_x;
2218     mb_y = s->mb_y;
2219
2220     switch (s->mv_type) {
2221     case MV_TYPE_16X16:
2222         mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2223                            0, 0, 0,
2224                            ref_picture, pix_op,
2225                            s->mv[dir][0][0], s->mv[dir][0][1],
2226                            2 * block_s, mb_y);
2227         break;
2228     case MV_TYPE_8X8:
2229         mx = 0;
2230         my = 0;
2231         for (i = 0; i < 4; i++) {
2232             hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
2233                                s->linesize) * block_s,
2234                                ref_picture[0], 0, 0,
2235                                (2 * mb_x + (i & 1)) * block_s,
2236                                (2 * mb_y + (i >> 1)) * block_s,
2237                                s->width, s->height, s->linesize,
2238                                s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
2239                                block_s, block_s, pix_op,
2240                                s->mv[dir][i][0], s->mv[dir][i][1]);
2241
2242             mx += s->mv[dir][i][0];
2243             my += s->mv[dir][i][1];
2244         }
2245
2246         if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY))
2247             chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
2248                                      pix_op, mx, my);
2249         break;
2250     case MV_TYPE_FIELD:
2251         if (s->picture_structure == PICT_FRAME) {
2252             /* top field */
2253             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2254                                1, 0, s->field_select[dir][0],
2255                                ref_picture, pix_op,
2256                                s->mv[dir][0][0], s->mv[dir][0][1],
2257                                block_s, mb_y);
2258             /* bottom field */
2259             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2260                                1, 1, s->field_select[dir][1],
2261                                ref_picture, pix_op,
2262                                s->mv[dir][1][0], s->mv[dir][1][1],
2263                                block_s, mb_y);
2264         } else {
2265             if (s->picture_structure != s->field_select[dir][0] + 1 &&
2266                 s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
2267                 ref_picture = s->current_picture_ptr->f.data;
2268
2269             }
2270             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2271                                0, 0, s->field_select[dir][0],
2272                                ref_picture, pix_op,
2273                                s->mv[dir][0][0],
2274                                s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
2275             }
2276         break;
2277     case MV_TYPE_16X8:
2278         for (i = 0; i < 2; i++) {
2279             uint8_t **ref2picture;
2280
2281             if (s->picture_structure == s->field_select[dir][i] + 1 ||
2282                 s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
2283                 ref2picture = ref_picture;
2284             } else {
2285                 ref2picture = s->current_picture_ptr->f.data;
2286             }
2287
2288             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2289                                0, 0, s->field_select[dir][i],
2290                                ref2picture, pix_op,
2291                                s->mv[dir][i][0], s->mv[dir][i][1] +
2292                                2 * block_s * i, block_s, mb_y >> 1);
2293
2294             dest_y  +=  2 * block_s *  s->linesize;
2295             dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2296             dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2297         }
2298         break;
2299     case MV_TYPE_DMV:
2300         if (s->picture_structure == PICT_FRAME) {
2301             for (i = 0; i < 2; i++) {
2302                 int j;
2303                 for (j = 0; j < 2; j++) {
2304                     mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2305                                        1, j, j ^ i,
2306                                        ref_picture, pix_op,
2307                                        s->mv[dir][2 * i + j][0],
2308                                        s->mv[dir][2 * i + j][1],
2309                                        block_s, mb_y);
2310                 }
2311                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2312             }
2313         } else {
2314             for (i = 0; i < 2; i++) {
2315                 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2316                                    0, 0, s->picture_structure != i + 1,
2317                                    ref_picture, pix_op,
2318                                    s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
2319                                    2 * block_s, mb_y >> 1);
2320
2321                 // after put we make avg of the same block
2322                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2323
2324                 // opposite parity is always in the same
2325                 // frame if this is second field
2326                 if (!s->first_field) {
2327                     ref_picture = s->current_picture_ptr->f.data;
2328                 }
2329             }
2330         }
2331         break;
2332     default:
2333         av_assert2(0);
2334     }
2335 }
2336
2337 /**
2338  * find the lowest MB row referenced in the MVs
2339  */
2340 int ff_MPV_lowest_referenced_row(MpegEncContext *s, int dir)
2341 {
2342     int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2343     int my, off, i, mvs;
2344
2345     if (s->picture_structure != PICT_FRAME || s->mcsel) 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 }