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