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