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     if (!ff_thread_can_start_frame(avctx)) {
1145         av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
1146         return -1;
1147     }
1148
1149     /* mark & release old frames */
1150     if (s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3) {
1151         if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1152             s->last_picture_ptr != s->next_picture_ptr &&
1153             s->last_picture_ptr->f.data[0]) {
1154             if (s->last_picture_ptr->owner2 == s)
1155                 free_frame_buffer(s, s->last_picture_ptr);
1156         }
1157
1158         /* release forgotten pictures */
1159         /* if (mpeg124/h263) */
1160         if (!s->encoding) {
1161             for (i = 0; i < s->picture_count; i++) {
1162                 if (s->picture[i].owner2 == s && s->picture[i].f.data[0] &&
1163                     &s->picture[i] != s->last_picture_ptr &&
1164                     &s->picture[i] != s->next_picture_ptr &&
1165                     s->picture[i].f.reference) {
1166                     if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1167                         av_log(avctx, AV_LOG_ERROR,
1168                                "releasing zombie picture\n");
1169                     free_frame_buffer(s, &s->picture[i]);
1170                 }
1171             }
1172         }
1173     }
1174
1175     if (!s->encoding) {
1176         ff_release_unused_pictures(s, 1);
1177
1178         if (s->current_picture_ptr &&
1179             s->current_picture_ptr->f.data[0] == NULL) {
1180             // we already have a unused image
1181             // (maybe it was set before reading the header)
1182             pic = s->current_picture_ptr;
1183         } else {
1184             i   = ff_find_unused_picture(s, 0);
1185             if (i < 0)
1186                 return i;
1187             pic = &s->picture[i];
1188         }
1189
1190         pic->f.reference = 0;
1191         if (!s->dropable) {
1192             if (s->codec_id == CODEC_ID_H264)
1193                 pic->f.reference = s->picture_structure;
1194             else if (s->pict_type != AV_PICTURE_TYPE_B)
1195                 pic->f.reference = 3;
1196         }
1197
1198         pic->f.coded_picture_number = s->coded_picture_number++;
1199
1200         if (ff_alloc_picture(s, pic, 0) < 0)
1201             return -1;
1202
1203         s->current_picture_ptr = pic;
1204         // FIXME use only the vars from current_pic
1205         s->current_picture_ptr->f.top_field_first = s->top_field_first;
1206         if (s->codec_id == CODEC_ID_MPEG1VIDEO ||
1207             s->codec_id == CODEC_ID_MPEG2VIDEO) {
1208             if (s->picture_structure != PICT_FRAME)
1209                 s->current_picture_ptr->f.top_field_first =
1210                     (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1211         }
1212         s->current_picture_ptr->f.interlaced_frame = !s->progressive_frame &&
1213                                                      !s->progressive_sequence;
1214         s->current_picture_ptr->field_picture      =  s->picture_structure != PICT_FRAME;
1215     }
1216
1217     s->current_picture_ptr->f.pict_type = s->pict_type;
1218     // if (s->flags && CODEC_FLAG_QSCALE)
1219     //     s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1220     s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1221
1222     ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1223
1224     if (s->pict_type != AV_PICTURE_TYPE_B) {
1225         s->last_picture_ptr = s->next_picture_ptr;
1226         if (!s->dropable)
1227             s->next_picture_ptr = s->current_picture_ptr;
1228     }
1229     /* av_log(s->avctx, AV_LOG_DEBUG, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1230            s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1231            s->last_picture_ptr    ? s->last_picture_ptr->f.data[0]    : NULL,
1232            s->next_picture_ptr    ? s->next_picture_ptr->f.data[0]    : NULL,
1233            s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL,
1234            s->pict_type, s->dropable); */
1235
1236     if (s->codec_id != CODEC_ID_H264) {
1237         if ((s->last_picture_ptr == NULL ||
1238              s->last_picture_ptr->f.data[0] == NULL) &&
1239             (s->pict_type != AV_PICTURE_TYPE_I ||
1240              s->picture_structure != PICT_FRAME)) {
1241             if (s->pict_type != AV_PICTURE_TYPE_I)
1242                 av_log(avctx, AV_LOG_ERROR,
1243                        "warning: first frame is no keyframe\n");
1244             else if (s->picture_structure != PICT_FRAME)
1245                 av_log(avctx, AV_LOG_INFO,
1246                        "allocate dummy last picture for field based first keyframe\n");
1247
1248             /* Allocate a dummy frame */
1249             i = ff_find_unused_picture(s, 0);
1250             if (i < 0)
1251                 return i;
1252             s->last_picture_ptr = &s->picture[i];
1253             s->last_picture_ptr->f.key_frame = 0;
1254             if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1255                 s->last_picture_ptr = NULL;
1256                 return -1;
1257             }
1258
1259             if(s->codec_id == CODEC_ID_FLV1 || s->codec_id == CODEC_ID_H263){
1260                 for(i=0; i<avctx->height; i++)
1261                     memset(s->last_picture_ptr->f.data[0] + s->last_picture_ptr->f.linesize[0]*i, 16, avctx->width);
1262             }
1263
1264             ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 0);
1265             ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 1);
1266             s->last_picture_ptr->f.reference = 3;
1267         }
1268         if ((s->next_picture_ptr == NULL ||
1269              s->next_picture_ptr->f.data[0] == NULL) &&
1270             s->pict_type == AV_PICTURE_TYPE_B) {
1271             /* Allocate a dummy frame */
1272             i = ff_find_unused_picture(s, 0);
1273             if (i < 0)
1274                 return i;
1275             s->next_picture_ptr = &s->picture[i];
1276             s->next_picture_ptr->f.key_frame = 0;
1277             if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1278                 s->next_picture_ptr = NULL;
1279                 return -1;
1280             }
1281             ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 0);
1282             ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 1);
1283             s->next_picture_ptr->f.reference = 3;
1284         }
1285     }
1286
1287     if (s->last_picture_ptr)
1288         ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1289     if (s->next_picture_ptr)
1290         ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1291
1292     if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME) &&
1293         (s->out_format != FMT_H264 || s->codec_id == CODEC_ID_SVQ3)) {
1294         if (s->next_picture_ptr)
1295             s->next_picture_ptr->owner2 = s;
1296         if (s->last_picture_ptr)
1297             s->last_picture_ptr->owner2 = s;
1298     }
1299
1300     assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1301                                                  s->last_picture_ptr->f.data[0]));
1302
1303     if (s->picture_structure!= PICT_FRAME && s->out_format != FMT_H264) {
1304         int i;
1305         for (i = 0; i < 4; i++) {
1306             if (s->picture_structure == PICT_BOTTOM_FIELD) {
1307                 s->current_picture.f.data[i] +=
1308                     s->current_picture.f.linesize[i];
1309             }
1310             s->current_picture.f.linesize[i] *= 2;
1311             s->last_picture.f.linesize[i]    *= 2;
1312             s->next_picture.f.linesize[i]    *= 2;
1313         }
1314     }
1315
1316     s->err_recognition = avctx->err_recognition;
1317
1318     /* set dequantizer, we can't do it during init as
1319      * it might change for mpeg4 and we can't do it in the header
1320      * decode as init is not called for mpeg4 there yet */
1321     if (s->mpeg_quant || s->codec_id == CODEC_ID_MPEG2VIDEO) {
1322         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1323         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1324     } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1325         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1326         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1327     } else {
1328         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1329         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1330     }
1331
1332     if (s->dct_error_sum) {
1333         assert(s->avctx->noise_reduction && s->encoding);
1334         update_noise_reduction(s);
1335     }
1336
1337     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1338         return ff_xvmc_field_start(s, avctx);
1339
1340     return 0;
1341 }
1342
1343 /* generic function for encode/decode called after a
1344  * frame has been coded/decoded. */
1345 void ff_MPV_frame_end(MpegEncContext *s)
1346 {
1347     int i;
1348     /* redraw edges for the frame if decoding didn't complete */
1349     // just to make sure that all data is rendered.
1350     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
1351         ff_xvmc_field_end(s);
1352    } else if((s->error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND)) &&
1353               !s->avctx->hwaccel &&
1354               !(s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
1355               s->unrestricted_mv &&
1356               s->current_picture.f.reference &&
1357               !s->intra_only &&
1358               !(s->flags & CODEC_FLAG_EMU_EDGE)) {
1359         int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
1360         int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
1361         s->dsp.draw_edges(s->current_picture.f.data[0], s->current_picture.f.linesize[0],
1362                           s->h_edge_pos, s->v_edge_pos,
1363                           EDGE_WIDTH, EDGE_WIDTH,
1364                           EDGE_TOP | EDGE_BOTTOM);
1365         s->dsp.draw_edges(s->current_picture.f.data[1], s->current_picture.f.linesize[1],
1366                           s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1367                           EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1368                           EDGE_TOP | EDGE_BOTTOM);
1369         s->dsp.draw_edges(s->current_picture.f.data[2], s->current_picture.f.linesize[2],
1370                           s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1371                           EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1372                           EDGE_TOP | EDGE_BOTTOM);
1373     }
1374
1375     emms_c();
1376
1377     s->last_pict_type                 = s->pict_type;
1378     s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f.quality;
1379     if (s->pict_type!= AV_PICTURE_TYPE_B) {
1380         s->last_non_b_pict_type = s->pict_type;
1381     }
1382 #if 0
1383     /* copy back current_picture variables */
1384     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1385         if (s->picture[i].f.data[0] == s->current_picture.f.data[0]) {
1386             s->picture[i] = s->current_picture;
1387             break;
1388         }
1389     }
1390     assert(i < MAX_PICTURE_COUNT);
1391 #endif
1392
1393     if (s->encoding) {
1394         /* release non-reference frames */
1395         for (i = 0; i < s->picture_count; i++) {
1396             if (s->picture[i].f.data[0] && !s->picture[i].f.reference
1397                 /* && s->picture[i].type != FF_BUFFER_TYPE_SHARED */) {
1398                 free_frame_buffer(s, &s->picture[i]);
1399             }
1400         }
1401     }
1402     // clear copies, to avoid confusion
1403 #if 0
1404     memset(&s->last_picture,    0, sizeof(Picture));
1405     memset(&s->next_picture,    0, sizeof(Picture));
1406     memset(&s->current_picture, 0, sizeof(Picture));
1407 #endif
1408     s->avctx->coded_frame = &s->current_picture_ptr->f;
1409
1410     if (s->codec_id != CODEC_ID_H264 && s->current_picture.f.reference) {
1411         ff_thread_report_progress(&s->current_picture_ptr->f, INT_MAX, 0);
1412     }
1413 }
1414
1415 /**
1416  * Draw a line from (ex, ey) -> (sx, sy).
1417  * @param w width of the image
1418  * @param h height of the image
1419  * @param stride stride/linesize of the image
1420  * @param color color of the arrow
1421  */
1422 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
1423                       int w, int h, int stride, int color)
1424 {
1425     int x, y, fr, f;
1426
1427     sx = av_clip(sx, 0, w - 1);
1428     sy = av_clip(sy, 0, h - 1);
1429     ex = av_clip(ex, 0, w - 1);
1430     ey = av_clip(ey, 0, h - 1);
1431
1432     buf[sy * stride + sx] += color;
1433
1434     if (FFABS(ex - sx) > FFABS(ey - sy)) {
1435         if (sx > ex) {
1436             FFSWAP(int, sx, ex);
1437             FFSWAP(int, sy, ey);
1438         }
1439         buf += sx + sy * stride;
1440         ex  -= sx;
1441         f    = ((ey - sy) << 16) / ex;
1442         for(x= 0; x <= ex; x++){
1443             y  = (x * f) >> 16;
1444             fr = (x * f) & 0xFFFF;
1445             buf[y * stride + x]       += (color * (0x10000 - fr)) >> 16;
1446             if(fr) buf[(y + 1) * stride + x] += (color *            fr ) >> 16;
1447         }
1448     } else {
1449         if (sy > ey) {
1450             FFSWAP(int, sx, ex);
1451             FFSWAP(int, sy, ey);
1452         }
1453         buf += sx + sy * stride;
1454         ey  -= sy;
1455         if (ey)
1456             f = ((ex - sx) << 16) / ey;
1457         else
1458             f = 0;
1459         for(y= 0; y <= ey; y++){
1460             x  = (y*f) >> 16;
1461             fr = (y*f) & 0xFFFF;
1462             buf[y * stride + x]     += (color * (0x10000 - fr)) >> 16;
1463             if(fr) buf[y * stride + x + 1] += (color *            fr ) >> 16;
1464         }
1465     }
1466 }
1467
1468 /**
1469  * Draw an arrow from (ex, ey) -> (sx, sy).
1470  * @param w width of the image
1471  * @param h height of the image
1472  * @param stride stride/linesize of the image
1473  * @param color color of the arrow
1474  */
1475 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
1476                        int ey, int w, int h, int stride, int color)
1477 {
1478     int dx,dy;
1479
1480     sx = av_clip(sx, -100, w + 100);
1481     sy = av_clip(sy, -100, h + 100);
1482     ex = av_clip(ex, -100, w + 100);
1483     ey = av_clip(ey, -100, h + 100);
1484
1485     dx = ex - sx;
1486     dy = ey - sy;
1487
1488     if (dx * dx + dy * dy > 3 * 3) {
1489         int rx =  dx + dy;
1490         int ry = -dx + dy;
1491         int length = ff_sqrt((rx * rx + ry * ry) << 8);
1492
1493         // FIXME subpixel accuracy
1494         rx = ROUNDED_DIV(rx * 3 << 4, length);
1495         ry = ROUNDED_DIV(ry * 3 << 4, length);
1496
1497         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1498         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1499     }
1500     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1501 }
1502
1503 /**
1504  * Print debugging info for the given picture.
1505  */
1506 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict)
1507 {
1508     if (s->avctx->hwaccel || !pict || !pict->mb_type)
1509         return;
1510
1511     if (s->avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
1512         int x,y;
1513
1514         av_log(s->avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
1515                av_get_picture_type_char(pict->pict_type));
1516         for (y = 0; y < s->mb_height; y++) {
1517             for (x = 0; x < s->mb_width; x++) {
1518                 if (s->avctx->debug & FF_DEBUG_SKIP) {
1519                     int count = s->mbskip_table[x + y * s->mb_stride];
1520                     if (count > 9)
1521                         count = 9;
1522                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1523                 }
1524                 if (s->avctx->debug & FF_DEBUG_QP) {
1525                     av_log(s->avctx, AV_LOG_DEBUG, "%2d",
1526                            pict->qscale_table[x + y * s->mb_stride]);
1527                 }
1528                 if (s->avctx->debug & FF_DEBUG_MB_TYPE) {
1529                     int mb_type = pict->mb_type[x + y * s->mb_stride];
1530                     // Type & MV direction
1531                     if (IS_PCM(mb_type))
1532                         av_log(s->avctx, AV_LOG_DEBUG, "P");
1533                     else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1534                         av_log(s->avctx, AV_LOG_DEBUG, "A");
1535                     else if (IS_INTRA4x4(mb_type))
1536                         av_log(s->avctx, AV_LOG_DEBUG, "i");
1537                     else if (IS_INTRA16x16(mb_type))
1538                         av_log(s->avctx, AV_LOG_DEBUG, "I");
1539                     else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1540                         av_log(s->avctx, AV_LOG_DEBUG, "d");
1541                     else if (IS_DIRECT(mb_type))
1542                         av_log(s->avctx, AV_LOG_DEBUG, "D");
1543                     else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
1544                         av_log(s->avctx, AV_LOG_DEBUG, "g");
1545                     else if (IS_GMC(mb_type))
1546                         av_log(s->avctx, AV_LOG_DEBUG, "G");
1547                     else if (IS_SKIP(mb_type))
1548                         av_log(s->avctx, AV_LOG_DEBUG, "S");
1549                     else if (!USES_LIST(mb_type, 1))
1550                         av_log(s->avctx, AV_LOG_DEBUG, ">");
1551                     else if (!USES_LIST(mb_type, 0))
1552                         av_log(s->avctx, AV_LOG_DEBUG, "<");
1553                     else {
1554                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1555                         av_log(s->avctx, AV_LOG_DEBUG, "X");
1556                     }
1557
1558                     // segmentation
1559                     if (IS_8X8(mb_type))
1560                         av_log(s->avctx, AV_LOG_DEBUG, "+");
1561                     else if (IS_16X8(mb_type))
1562                         av_log(s->avctx, AV_LOG_DEBUG, "-");
1563                     else if (IS_8X16(mb_type))
1564                         av_log(s->avctx, AV_LOG_DEBUG, "|");
1565                     else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
1566                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1567                     else
1568                         av_log(s->avctx, AV_LOG_DEBUG, "?");
1569
1570
1571                     if (IS_INTERLACED(mb_type))
1572                         av_log(s->avctx, AV_LOG_DEBUG, "=");
1573                     else
1574                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1575                 }
1576                 // av_log(s->avctx, AV_LOG_DEBUG, " ");
1577             }
1578             av_log(s->avctx, AV_LOG_DEBUG, "\n");
1579         }
1580     }
1581
1582     if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
1583         (s->avctx->debug_mv)) {
1584         const int shift = 1 + s->quarter_sample;
1585         int mb_y;
1586         uint8_t *ptr;
1587         int i;
1588         int h_chroma_shift, v_chroma_shift, block_height;
1589         const int width          = s->avctx->width;
1590         const int height         = s->avctx->height;
1591         const int mv_sample_log2 = 4 - pict->motion_subsample_log2;
1592         const int mv_stride      = (s->mb_width << mv_sample_log2) +
1593                                    (s->codec_id == CODEC_ID_H264 ? 0 : 1);
1594         s->low_delay = 0; // needed to see the vectors without trashing the buffers
1595
1596         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,
1597                                       &h_chroma_shift, &v_chroma_shift);
1598         for (i = 0; i < 3; i++) {
1599             size_t size= (i == 0) ? pict->linesize[i] * height:
1600                          pict->linesize[i] * height >> v_chroma_shift;
1601             s->visualization_buffer[i]= av_realloc(s->visualization_buffer[i], size);
1602             memcpy(s->visualization_buffer[i], pict->data[i], size);
1603             pict->data[i] = s->visualization_buffer[i];
1604         }
1605         pict->type   = FF_BUFFER_TYPE_COPY;
1606         pict->opaque= NULL;
1607         ptr          = pict->data[0];
1608         block_height = 16 >> v_chroma_shift;
1609
1610         for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1611             int mb_x;
1612             for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1613                 const int mb_index = mb_x + mb_y * s->mb_stride;
1614                 if ((s->avctx->debug_mv) && pict->motion_val) {
1615                     int type;
1616                     for (type = 0; type < 3; type++) {
1617                         int direction = 0;
1618                         switch (type) {
1619                         case 0:
1620                             if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
1621                                 (pict->pict_type!= AV_PICTURE_TYPE_P))
1622                                 continue;
1623                             direction = 0;
1624                             break;
1625                         case 1:
1626                             if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
1627                                 (pict->pict_type!= AV_PICTURE_TYPE_B))
1628                                 continue;
1629                             direction = 0;
1630                             break;
1631                         case 2:
1632                             if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
1633                                 (pict->pict_type!= AV_PICTURE_TYPE_B))
1634                                 continue;
1635                             direction = 1;
1636                             break;
1637                         }
1638                         if (!USES_LIST(pict->mb_type[mb_index], direction))
1639                             continue;
1640
1641                         if (IS_8X8(pict->mb_type[mb_index])) {
1642                             int i;
1643                             for (i = 0; i < 4; i++) {
1644                                 int sx = mb_x * 16 + 4 + 8 * (i & 1);
1645                                 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
1646                                 int xy = (mb_x * 2 + (i & 1) +
1647                                           (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1648                                 int mx = (pict->motion_val[direction][xy][0] >> shift) + sx;
1649                                 int my = (pict->motion_val[direction][xy][1] >> shift) + sy;
1650                                 draw_arrow(ptr, sx, sy, mx, my, width,
1651                                            height, s->linesize, 100);
1652                             }
1653                         } else if (IS_16X8(pict->mb_type[mb_index])) {
1654                             int i;
1655                             for (i = 0; i < 2; i++) {
1656                                 int sx = mb_x * 16 + 8;
1657                                 int sy = mb_y * 16 + 4 + 8 * i;
1658                                 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
1659                                 int mx = (pict->motion_val[direction][xy][0] >> shift);
1660                                 int my = (pict->motion_val[direction][xy][1] >> shift);
1661
1662                                 if (IS_INTERLACED(pict->mb_type[mb_index]))
1663                                     my *= 2;
1664
1665                             draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1666                                        height, s->linesize, 100);
1667                             }
1668                         } else if (IS_8X16(pict->mb_type[mb_index])) {
1669                             int i;
1670                             for (i = 0; i < 2; i++) {
1671                                 int sx = mb_x * 16 + 4 + 8 * i;
1672                                 int sy = mb_y * 16 + 8;
1673                                 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
1674                                 int mx = pict->motion_val[direction][xy][0] >> shift;
1675                                 int my = pict->motion_val[direction][xy][1] >> shift;
1676
1677                                 if (IS_INTERLACED(pict->mb_type[mb_index]))
1678                                     my *= 2;
1679
1680                                 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1681                                            height, s->linesize, 100);
1682                             }
1683                         } else {
1684                               int sx= mb_x * 16 + 8;
1685                               int sy= mb_y * 16 + 8;
1686                               int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
1687                               int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1688                               int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1689                               draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1690                         }
1691                     }
1692                 }
1693                 if ((s->avctx->debug & FF_DEBUG_VIS_QP) && pict->motion_val) {
1694                     uint64_t c = (pict->qscale_table[mb_index] * 128 / 31) *
1695                                  0x0101010101010101ULL;
1696                     int y;
1697                     for (y = 0; y < block_height; y++) {
1698                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
1699                                       (block_height * mb_y + y) *
1700                                       pict->linesize[1]) = c;
1701                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
1702                                       (block_height * mb_y + y) *
1703                                       pict->linesize[2]) = c;
1704                     }
1705                 }
1706                 if ((s->avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
1707                     pict->motion_val) {
1708                     int mb_type = pict->mb_type[mb_index];
1709                     uint64_t u,v;
1710                     int y;
1711 #define COLOR(theta, r) \
1712     u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
1713     v = (int)(128 + r * sin(theta * 3.141592 / 180));
1714
1715
1716                     u = v = 128;
1717                     if (IS_PCM(mb_type)) {
1718                         COLOR(120, 48)
1719                     } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
1720                                IS_INTRA16x16(mb_type)) {
1721                         COLOR(30, 48)
1722                     } else if (IS_INTRA4x4(mb_type)) {
1723                         COLOR(90, 48)
1724                     } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
1725                         // COLOR(120, 48)
1726                     } else if (IS_DIRECT(mb_type)) {
1727                         COLOR(150, 48)
1728                     } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
1729                         COLOR(170, 48)
1730                     } else if (IS_GMC(mb_type)) {
1731                         COLOR(190, 48)
1732                     } else if (IS_SKIP(mb_type)) {
1733                         // COLOR(180, 48)
1734                     } else if (!USES_LIST(mb_type, 1)) {
1735                         COLOR(240, 48)
1736                     } else if (!USES_LIST(mb_type, 0)) {
1737                         COLOR(0, 48)
1738                     } else {
1739                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1740                         COLOR(300,48)
1741                     }
1742
1743                     u *= 0x0101010101010101ULL;
1744                     v *= 0x0101010101010101ULL;
1745                     for (y = 0; y < block_height; y++) {
1746                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
1747                                       (block_height * mb_y + y) * pict->linesize[1]) = u;
1748                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
1749                                       (block_height * mb_y + y) * pict->linesize[2]) = v;
1750                     }
1751
1752                     // segmentation
1753                     if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
1754                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
1755                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1756                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
1757                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1758                     }
1759                     if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
1760                         for (y = 0; y < 16; y++)
1761                             pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
1762                                           pict->linesize[0]] ^= 0x80;
1763                     }
1764                     if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
1765                         int dm = 1 << (mv_sample_log2 - 2);
1766                         for (i = 0; i < 4; i++) {
1767                             int sx = mb_x * 16 + 8 * (i & 1);
1768                             int sy = mb_y * 16 + 8 * (i >> 1);
1769                             int xy = (mb_x * 2 + (i & 1) +
1770                                      (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1771                             // FIXME bidir
1772                             int32_t *mv = (int32_t *) &pict->motion_val[0][xy];
1773                             if (mv[0] != mv[dm] ||
1774                                 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
1775                                 for (y = 0; y < 8; y++)
1776                                     pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
1777                             if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
1778                                 *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
1779                                               pict->linesize[0]) ^= 0x8080808080808080ULL;
1780                         }
1781                     }
1782
1783                     if (IS_INTERLACED(mb_type) &&
1784                         s->codec_id == CODEC_ID_H264) {
1785                         // hmm
1786                     }
1787                 }
1788                 s->mbskip_table[mb_index] = 0;
1789             }
1790         }
1791     }
1792 }
1793
1794 static inline int hpel_motion_lowres(MpegEncContext *s,
1795                                      uint8_t *dest, uint8_t *src,
1796                                      int field_based, int field_select,
1797                                      int src_x, int src_y,
1798                                      int width, int height, int stride,
1799                                      int h_edge_pos, int v_edge_pos,
1800                                      int w, int h, h264_chroma_mc_func *pix_op,
1801                                      int motion_x, int motion_y)
1802 {
1803     const int lowres   = s->avctx->lowres;
1804     const int op_index = FFMIN(lowres, 2);
1805     const int s_mask   = (2 << lowres) - 1;
1806     int emu = 0;
1807     int sx, sy;
1808
1809     if (s->quarter_sample) {
1810         motion_x /= 2;
1811         motion_y /= 2;
1812     }
1813
1814     sx = motion_x & s_mask;
1815     sy = motion_y & s_mask;
1816     src_x += motion_x >> lowres + 1;
1817     src_y += motion_y >> lowres + 1;
1818
1819     src   += src_y * stride + src_x;
1820
1821     if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w,                 0) ||
1822         (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1823         s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w + 1,
1824                                 (h + 1) << field_based, src_x,
1825                                 src_y   << field_based,
1826                                 h_edge_pos,
1827                                 v_edge_pos);
1828         src = s->edge_emu_buffer;
1829         emu = 1;
1830     }
1831
1832     sx = (sx << 2) >> lowres;
1833     sy = (sy << 2) >> lowres;
1834     if (field_select)
1835         src += s->linesize;
1836     pix_op[op_index](dest, src, stride, h, sx, sy);
1837     return emu;
1838 }
1839
1840 /* apply one mpeg motion vector to the three components */
1841 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
1842                                                 uint8_t *dest_y,
1843                                                 uint8_t *dest_cb,
1844                                                 uint8_t *dest_cr,
1845                                                 int field_based,
1846                                                 int bottom_field,
1847                                                 int field_select,
1848                                                 uint8_t **ref_picture,
1849                                                 h264_chroma_mc_func *pix_op,
1850                                                 int motion_x, int motion_y,
1851                                                 int h, int mb_y)
1852 {
1853     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
1854     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy,
1855         uvsx, uvsy;
1856     const int lowres     = s->avctx->lowres;
1857     const int op_index   = FFMIN(lowres-1+s->chroma_x_shift, 2);
1858     const int block_s    = 8>>lowres;
1859     const int s_mask     = (2 << lowres) - 1;
1860     const int h_edge_pos = s->h_edge_pos >> lowres;
1861     const int v_edge_pos = s->v_edge_pos >> lowres;
1862     linesize   = s->current_picture.f.linesize[0] << field_based;
1863     uvlinesize = s->current_picture.f.linesize[1] << field_based;
1864
1865     // FIXME obviously not perfect but qpel will not work in lowres anyway
1866     if (s->quarter_sample) {
1867         motion_x /= 2;
1868         motion_y /= 2;
1869     }
1870
1871     if(field_based){
1872         motion_y += (bottom_field - field_select)*((1 << lowres)-1);
1873     }
1874
1875     sx = motion_x & s_mask;
1876     sy = motion_y & s_mask;
1877     src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
1878     src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
1879
1880     if (s->out_format == FMT_H263) {
1881         uvsx    = ((motion_x >> 1) & s_mask) | (sx & 1);
1882         uvsy    = ((motion_y >> 1) & s_mask) | (sy & 1);
1883         uvsrc_x = src_x >> 1;
1884         uvsrc_y = src_y >> 1;
1885     } else if (s->out_format == FMT_H261) {
1886         // even chroma mv's are full pel in H261
1887         mx      = motion_x / 4;
1888         my      = motion_y / 4;
1889         uvsx    = (2 * mx) & s_mask;
1890         uvsy    = (2 * my) & s_mask;
1891         uvsrc_x = s->mb_x * block_s + (mx >> lowres);
1892         uvsrc_y =    mb_y * block_s + (my >> lowres);
1893     } else {
1894         if(s->chroma_y_shift){
1895             mx      = motion_x / 2;
1896             my      = motion_y / 2;
1897             uvsx    = mx & s_mask;
1898             uvsy    = my & s_mask;
1899             uvsrc_x = s->mb_x * block_s                 + (mx >> lowres + 1);
1900             uvsrc_y =   (mb_y * block_s >> field_based) + (my >> lowres + 1);
1901         } else {
1902             if(s->chroma_x_shift){
1903             //Chroma422
1904                 mx = motion_x / 2;
1905                 uvsx = mx & s_mask;
1906                 uvsy = motion_y & s_mask;
1907                 uvsrc_y = src_y;
1908                 uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
1909             } else {
1910             //Chroma444
1911                 uvsx = motion_x & s_mask;
1912                 uvsy = motion_y & s_mask;
1913                 uvsrc_x = src_x;
1914                 uvsrc_y = src_y;
1915             }
1916         }
1917     }
1918
1919     ptr_y  = ref_picture[0] + src_y   * linesize   + src_x;
1920     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
1921     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
1922
1923     if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s,       0) ||
1924         (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1925         s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
1926                                 s->linesize, 17, 17 + field_based,
1927                                 src_x, src_y << field_based, h_edge_pos,
1928                                 v_edge_pos);
1929         ptr_y = s->edge_emu_buffer;
1930         if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
1931             uint8_t *uvbuf = s->edge_emu_buffer + 18 * s->linesize;
1932             s->dsp.emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9,
1933                                     9 + field_based,
1934                                     uvsrc_x, uvsrc_y << field_based,
1935                                     h_edge_pos >> 1, v_edge_pos >> 1);
1936             s->dsp.emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9,
1937                                     9 + field_based,
1938                                     uvsrc_x, uvsrc_y << field_based,
1939                                     h_edge_pos >> 1, v_edge_pos >> 1);
1940             ptr_cb = uvbuf;
1941             ptr_cr = uvbuf + 16;
1942         }
1943     }
1944
1945     // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data
1946     if (bottom_field) {
1947         dest_y  += s->linesize;
1948         dest_cb += s->uvlinesize;
1949         dest_cr += s->uvlinesize;
1950     }
1951
1952     if (field_select) {
1953         ptr_y   += s->linesize;
1954         ptr_cb  += s->uvlinesize;
1955         ptr_cr  += s->uvlinesize;
1956     }
1957
1958     sx = (sx << 2) >> lowres;
1959     sy = (sy << 2) >> lowres;
1960     pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
1961
1962     if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
1963         uvsx = (uvsx << 2) >> lowres;
1964         uvsy = (uvsy << 2) >> lowres;
1965         if (h >> s->chroma_y_shift) {
1966             pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1967             pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
1968         }
1969     }
1970     // FIXME h261 lowres loop filter
1971 }
1972
1973 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
1974                                             uint8_t *dest_cb, uint8_t *dest_cr,
1975                                             uint8_t **ref_picture,
1976                                             h264_chroma_mc_func * pix_op,
1977                                             int mx, int my)
1978 {
1979     const int lowres     = s->avctx->lowres;
1980     const int op_index   = FFMIN(lowres, 2);
1981     const int block_s    = 8 >> lowres;
1982     const int s_mask     = (2 << lowres) - 1;
1983     const int h_edge_pos = s->h_edge_pos >> lowres + 1;
1984     const int v_edge_pos = s->v_edge_pos >> lowres + 1;
1985     int emu = 0, src_x, src_y, offset, sx, sy;
1986     uint8_t *ptr;
1987
1988     if (s->quarter_sample) {
1989         mx /= 2;
1990         my /= 2;
1991     }
1992
1993     /* In case of 8X8, we construct a single chroma motion vector
1994        with a special rounding */
1995     mx = ff_h263_round_chroma(mx);
1996     my = ff_h263_round_chroma(my);
1997
1998     sx = mx & s_mask;
1999     sy = my & s_mask;
2000     src_x = s->mb_x * block_s + (mx >> lowres + 1);
2001     src_y = s->mb_y * block_s + (my >> lowres + 1);
2002
2003     offset = src_y * s->uvlinesize + src_x;
2004     ptr = ref_picture[1] + offset;
2005     if (s->flags & CODEC_FLAG_EMU_EDGE) {
2006         if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2007             (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2008             s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize,
2009                                     9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
2010             ptr = s->edge_emu_buffer;
2011             emu = 1;
2012         }
2013     }
2014     sx = (sx << 2) >> lowres;
2015     sy = (sy << 2) >> lowres;
2016     pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
2017
2018     ptr = ref_picture[2] + offset;
2019     if (emu) {
2020         s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9,
2021                                 src_x, src_y, h_edge_pos, v_edge_pos);
2022         ptr = s->edge_emu_buffer;
2023     }
2024     pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
2025 }
2026
2027 /**
2028  * motion compensation of a single macroblock
2029  * @param s context
2030  * @param dest_y luma destination pointer
2031  * @param dest_cb chroma cb/u destination pointer
2032  * @param dest_cr chroma cr/v destination pointer
2033  * @param dir direction (0->forward, 1->backward)
2034  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2035  * @param pix_op halfpel motion compensation function (average or put normally)
2036  * the motion vectors are taken from s->mv and the MV type from s->mv_type
2037  */
2038 static inline void MPV_motion_lowres(MpegEncContext *s,
2039                                      uint8_t *dest_y, uint8_t *dest_cb,
2040                                      uint8_t *dest_cr,
2041                                      int dir, uint8_t **ref_picture,
2042                                      h264_chroma_mc_func *pix_op)
2043 {
2044     int mx, my;
2045     int mb_x, mb_y, i;
2046     const int lowres  = s->avctx->lowres;
2047     const int block_s = 8 >>lowres;
2048
2049     mb_x = s->mb_x;
2050     mb_y = s->mb_y;
2051
2052     switch (s->mv_type) {
2053     case MV_TYPE_16X16:
2054         mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2055                            0, 0, 0,
2056                            ref_picture, pix_op,
2057                            s->mv[dir][0][0], s->mv[dir][0][1],
2058                            2 * block_s, mb_y);
2059         break;
2060     case MV_TYPE_8X8:
2061         mx = 0;
2062         my = 0;
2063         for (i = 0; i < 4; i++) {
2064             hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
2065                                s->linesize) * block_s,
2066                                ref_picture[0], 0, 0,
2067                                (2 * mb_x + (i & 1)) * block_s,
2068                                (2 * mb_y + (i >> 1)) * block_s,
2069                                s->width, s->height, s->linesize,
2070                                s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
2071                                block_s, block_s, pix_op,
2072                                s->mv[dir][i][0], s->mv[dir][i][1]);
2073
2074             mx += s->mv[dir][i][0];
2075             my += s->mv[dir][i][1];
2076         }
2077
2078         if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY))
2079             chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
2080                                      pix_op, mx, my);
2081         break;
2082     case MV_TYPE_FIELD:
2083         if (s->picture_structure == PICT_FRAME) {
2084             /* top field */
2085             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2086                                1, 0, s->field_select[dir][0],
2087                                ref_picture, pix_op,
2088                                s->mv[dir][0][0], s->mv[dir][0][1],
2089                                block_s, mb_y);
2090             /* bottom field */
2091             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2092                                1, 1, s->field_select[dir][1],
2093                                ref_picture, pix_op,
2094                                s->mv[dir][1][0], s->mv[dir][1][1],
2095                                block_s, mb_y);
2096         } else {
2097             if (s->picture_structure != s->field_select[dir][0] + 1 &&
2098                 s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
2099                 ref_picture = s->current_picture_ptr->f.data;
2100
2101             }
2102             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2103                                0, 0, s->field_select[dir][0],
2104                                ref_picture, pix_op,
2105                                s->mv[dir][0][0],
2106                                s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
2107             }
2108         break;
2109     case MV_TYPE_16X8:
2110         for (i = 0; i < 2; i++) {
2111             uint8_t **ref2picture;
2112
2113             if (s->picture_structure == s->field_select[dir][i] + 1 ||
2114                 s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
2115                 ref2picture = ref_picture;
2116             } else {
2117                 ref2picture = s->current_picture_ptr->f.data;
2118             }
2119
2120             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2121                                0, 0, s->field_select[dir][i],
2122                                ref2picture, pix_op,
2123                                s->mv[dir][i][0], s->mv[dir][i][1] +
2124                                2 * block_s * i, block_s, mb_y >> 1);
2125
2126             dest_y  +=  2 * block_s *  s->linesize;
2127             dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2128             dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2129         }
2130         break;
2131     case MV_TYPE_DMV:
2132         if (s->picture_structure == PICT_FRAME) {
2133             for (i = 0; i < 2; i++) {
2134                 int j;
2135                 for (j = 0; j < 2; j++) {
2136                     mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2137                                        1, j, j ^ i,
2138                                        ref_picture, pix_op,
2139                                        s->mv[dir][2 * i + j][0],
2140                                        s->mv[dir][2 * i + j][1],
2141                                        block_s, mb_y);
2142                 }
2143                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2144             }
2145         } else {
2146             for (i = 0; i < 2; i++) {
2147                 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2148                                    0, 0, s->picture_structure != i + 1,
2149                                    ref_picture, pix_op,
2150                                    s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
2151                                    2 * block_s, mb_y >> 1);
2152
2153                 // after put we make avg of the same block
2154                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2155
2156                 // opposite parity is always in the same
2157                 // frame if this is second field
2158                 if (!s->first_field) {
2159                     ref_picture = s->current_picture_ptr->f.data;
2160                 }
2161             }
2162         }
2163         break;
2164     default:
2165         av_assert2(0);
2166     }
2167 }
2168
2169 /**
2170  * find the lowest MB row referenced in the MVs
2171  */
2172 int ff_MPV_lowest_referenced_row(MpegEncContext *s, int dir)
2173 {
2174     int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2175     int my, off, i, mvs;
2176
2177     if (s->picture_structure != PICT_FRAME) goto unhandled;
2178
2179     switch (s->mv_type) {
2180         case MV_TYPE_16X16:
2181             mvs = 1;
2182             break;
2183         case MV_TYPE_16X8:
2184             mvs = 2;
2185             break;
2186         case MV_TYPE_8X8:
2187             mvs = 4;
2188             break;
2189         default:
2190             goto unhandled;
2191     }
2192
2193     for (i = 0; i < mvs; i++) {
2194         my = s->mv[dir][i][1]<<qpel_shift;
2195         my_max = FFMAX(my_max, my);
2196         my_min = FFMIN(my_min, my);
2197     }
2198
2199     off = (FFMAX(-my_min, my_max) + 63) >> 6;
2200
2201     return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
2202 unhandled:
2203     return s->mb_height-1;
2204 }
2205
2206 /* put block[] to dest[] */
2207 static inline void put_dct(MpegEncContext *s,
2208                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2209 {
2210     s->dct_unquantize_intra(s, block, i, qscale);
2211     s->dsp.idct_put (dest, line_size, block);
2212 }
2213
2214 /* add block[] to dest[] */
2215 static inline void add_dct(MpegEncContext *s,
2216                            DCTELEM *block, int i, uint8_t *dest, int line_size)
2217 {
2218     if (s->block_last_index[i] >= 0) {
2219         s->dsp.idct_add (dest, line_size, block);
2220     }
2221 }
2222
2223 static inline void add_dequant_dct(MpegEncContext *s,
2224                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2225 {
2226     if (s->block_last_index[i] >= 0) {
2227         s->dct_unquantize_inter(s, block, i, qscale);
2228
2229         s->dsp.idct_add (dest, line_size, block);
2230     }
2231 }
2232
2233 /**
2234  * Clean dc, ac, coded_block for the current non-intra MB.
2235  */
2236 void ff_clean_intra_table_entries(MpegEncContext *s)
2237 {
2238     int wrap = s->b8_stride;
2239     int xy = s->block_index[0];
2240
2241     s->dc_val[0][xy           ] =
2242     s->dc_val[0][xy + 1       ] =
2243     s->dc_val[0][xy     + wrap] =
2244     s->dc_val[0][xy + 1 + wrap] = 1024;
2245     /* ac pred */
2246     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
2247     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2248     if (s->msmpeg4_version>=3) {
2249         s->coded_block[xy           ] =
2250         s->coded_block[xy + 1       ] =
2251         s->coded_block[xy     + wrap] =
2252         s->coded_block[xy + 1 + wrap] = 0;
2253     }
2254     /* chroma */
2255     wrap = s->mb_stride;
2256     xy = s->mb_x + s->mb_y * wrap;
2257     s->dc_val[1][xy] =
2258     s->dc_val[2][xy] = 1024;
2259     /* ac pred */
2260     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2261     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2262
2263     s->mbintra_table[xy]= 0;
2264 }
2265
2266 /* generic function called after a macroblock has been parsed by the
2267    decoder or after it has been encoded by the encoder.
2268
2269    Important variables used:
2270    s->mb_intra : true if intra macroblock
2271    s->mv_dir   : motion vector direction
2272    s->mv_type  : motion vector type
2273    s->mv       : motion vector
2274    s->interlaced_dct : true if interlaced dct used (mpeg2)
2275  */
2276 static av_always_inline
2277 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
2278                             int lowres_flag, int is_mpeg12)
2279 {
2280     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2281     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2282         ff_xvmc_decode_mb(s);//xvmc uses pblocks
2283         return;
2284     }
2285
2286     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2287        /* save DCT coefficients */
2288        int i,j;
2289        DCTELEM *dct = &s->current_picture.f.dct_coeff[mb_xy * 64 * 6];
2290        av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2291        for(i=0; i<6; i++){
2292            for(j=0; j<64; j++){
2293                *dct++ = block[i][s->dsp.idct_permutation[j]];
2294                av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
2295            }
2296            av_log(s->avctx, AV_LOG_DEBUG, "\n");
2297        }
2298     }
2299
2300     s->current_picture.f.qscale_table[mb_xy] = s->qscale;
2301
2302     /* update DC predictors for P macroblocks */
2303     if (!s->mb_intra) {
2304         if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2305             if(s->mbintra_table[mb_xy])
2306                 ff_clean_intra_table_entries(s);
2307         } else {
2308             s->last_dc[0] =
2309             s->last_dc[1] =
2310             s->last_dc[2] = 128 << s->intra_dc_precision;
2311         }
2312     }
2313     else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2314         s->mbintra_table[mb_xy]=1;
2315
2316     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
2317         uint8_t *dest_y, *dest_cb, *dest_cr;
2318         int dct_linesize, dct_offset;
2319         op_pixels_func (*op_pix)[4];
2320         qpel_mc_func (*op_qpix)[16];
2321         const int linesize   = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2322         const int uvlinesize = s->current_picture.f.linesize[1];
2323         const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2324         const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2325
2326         /* avoid copy if macroblock skipped in last frame too */
2327         /* skip only during decoding as we might trash the buffers during encoding a bit */
2328         if(!s->encoding){
2329             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2330
2331             if (s->mb_skipped) {
2332                 s->mb_skipped= 0;
2333                 av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
2334                 *mbskip_ptr = 1;
2335             } else if(!s->current_picture.f.reference) {
2336                 *mbskip_ptr = 1;
2337             } else{
2338                 *mbskip_ptr = 0; /* not skipped */
2339             }
2340         }
2341
2342         dct_linesize = linesize << s->interlaced_dct;
2343         dct_offset   = s->interlaced_dct ? linesize : linesize * block_size;
2344
2345         if(readable){
2346             dest_y=  s->dest[0];
2347             dest_cb= s->dest[1];
2348             dest_cr= s->dest[2];
2349         }else{
2350             dest_y = s->b_scratchpad;
2351             dest_cb= s->b_scratchpad+16*linesize;
2352             dest_cr= s->b_scratchpad+32*linesize;
2353         }
2354
2355         if (!s->mb_intra) {
2356             /* motion handling */
2357             /* decoding or more than one mb_type (MC was already done otherwise) */
2358             if(!s->encoding){
2359
2360                 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2361                     if (s->mv_dir & MV_DIR_FORWARD) {
2362                         ff_thread_await_progress(&s->last_picture_ptr->f,
2363                                                  ff_MPV_lowest_referenced_row(s, 0),
2364                                                  0);
2365                     }
2366                     if (s->mv_dir & MV_DIR_BACKWARD) {
2367                         ff_thread_await_progress(&s->next_picture_ptr->f,
2368                                                  ff_MPV_lowest_referenced_row(s, 1),
2369                                                  0);
2370                     }
2371                 }
2372
2373                 if(lowres_flag){
2374                     h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
2375
2376                     if (s->mv_dir & MV_DIR_FORWARD) {
2377                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix);
2378                         op_pix = s->dsp.avg_h264_chroma_pixels_tab;
2379                     }
2380                     if (s->mv_dir & MV_DIR_BACKWARD) {
2381                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix);
2382                     }
2383                 }else{
2384                     op_qpix= s->me.qpel_put;
2385                     if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2386                         op_pix = s->dsp.put_pixels_tab;
2387                     }else{
2388                         op_pix = s->dsp.put_no_rnd_pixels_tab;
2389                     }
2390                     if (s->mv_dir & MV_DIR_FORWARD) {
2391                         MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
2392                         op_pix = s->dsp.avg_pixels_tab;
2393                         op_qpix= s->me.qpel_avg;
2394                     }
2395                     if (s->mv_dir & MV_DIR_BACKWARD) {
2396                         MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
2397                     }
2398                 }
2399             }
2400
2401             /* skip dequant / idct if we are really late ;) */
2402             if(s->avctx->skip_idct){
2403                 if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2404                    ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2405                    || s->avctx->skip_idct >= AVDISCARD_ALL)
2406                     goto skip_idct;
2407             }
2408
2409             /* add dct residue */
2410             if(s->encoding || !(   s->msmpeg4_version || s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO
2411                                 || (s->codec_id==CODEC_ID_MPEG4 && !s->mpeg_quant))){
2412                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2413                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2414                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2415                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2416
2417                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2418                     if (s->chroma_y_shift){
2419                         add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2420                         add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2421                     }else{
2422                         dct_linesize >>= 1;
2423                         dct_offset >>=1;
2424                         add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2425                         add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2426                         add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2427                         add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2428                     }
2429                 }
2430             } else if(is_mpeg12 || (s->codec_id != CODEC_ID_WMV2)){
2431                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
2432                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
2433                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
2434                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2435
2436                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2437                     if(s->chroma_y_shift){//Chroma420
2438                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
2439                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
2440                     }else{
2441                         //chroma422
2442                         dct_linesize = uvlinesize << s->interlaced_dct;
2443                         dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2444
2445                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
2446                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
2447                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2448                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2449                         if(!s->chroma_x_shift){//Chroma444
2450                             add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2451                             add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2452                             add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2453                             add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2454                         }
2455                     }
2456                 }//fi gray
2457             }
2458             else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2459                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2460             }
2461         } else {
2462             /* dct only in intra block */
2463             if(s->encoding || !(s->codec_id==CODEC_ID_MPEG1VIDEO || s->codec_id==CODEC_ID_MPEG2VIDEO)){
2464                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2465                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2466                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2467                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2468
2469                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2470                     if(s->chroma_y_shift){
2471                         put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2472                         put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2473                     }else{
2474                         dct_offset >>=1;
2475                         dct_linesize >>=1;
2476                         put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2477                         put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2478                         put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2479                         put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2480                     }
2481                 }
2482             }else{
2483                 s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
2484                 s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
2485                 s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
2486                 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2487
2488                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2489                     if(s->chroma_y_shift){
2490                         s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2491                         s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2492                     }else{
2493
2494                         dct_linesize = uvlinesize << s->interlaced_dct;
2495                         dct_offset   = s->interlaced_dct? uvlinesize : uvlinesize*block_size;
2496
2497                         s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
2498                         s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
2499                         s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2500                         s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2501                         if(!s->chroma_x_shift){//Chroma444
2502                             s->dsp.idct_put(dest_cb + block_size,              dct_linesize, block[8]);
2503                             s->dsp.idct_put(dest_cr + block_size,              dct_linesize, block[9]);
2504                             s->dsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2505                             s->dsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2506                         }
2507                     }
2508                 }//gray
2509             }
2510         }
2511 skip_idct:
2512         if(!readable){
2513             s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
2514             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2515             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2516         }
2517     }
2518 }
2519
2520 void ff_MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2521 #if !CONFIG_SMALL
2522     if(s->out_format == FMT_MPEG1) {
2523         if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2524         else                 MPV_decode_mb_internal(s, block, 0, 1);
2525     } else
2526 #endif
2527     if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2528     else                  MPV_decode_mb_internal(s, block, 0, 0);
2529 }
2530
2531 /**
2532  * @param h is the normal height, this will be reduced automatically if needed for the last row
2533  */
2534 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2535     const int field_pic= s->picture_structure != PICT_FRAME;
2536     if(field_pic){
2537         h <<= 1;
2538         y <<= 1;
2539     }
2540
2541     if (!s->avctx->hwaccel
2542        && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2543        && s->unrestricted_mv
2544        && s->current_picture.f.reference
2545        && !s->intra_only
2546        && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
2547         int sides = 0, edge_h;
2548         int hshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_w;
2549         int vshift = av_pix_fmt_descriptors[s->avctx->pix_fmt].log2_chroma_h;
2550         if (y==0) sides |= EDGE_TOP;
2551         if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2552
2553         edge_h= FFMIN(h, s->v_edge_pos - y);
2554
2555         s->dsp.draw_edges(s->current_picture_ptr->f.data[0] +  y         *s->linesize,
2556                           s->linesize,           s->h_edge_pos,         edge_h,
2557                           EDGE_WIDTH,            EDGE_WIDTH,            sides);
2558         s->dsp.draw_edges(s->current_picture_ptr->f.data[1] + (y>>vshift)*s->uvlinesize,
2559                           s->uvlinesize,         s->h_edge_pos>>hshift, edge_h>>vshift,
2560                           EDGE_WIDTH>>hshift,    EDGE_WIDTH>>vshift,    sides);
2561         s->dsp.draw_edges(s->current_picture_ptr->f.data[2] + (y>>vshift)*s->uvlinesize,
2562                           s->uvlinesize,         s->h_edge_pos>>hshift, edge_h>>vshift,
2563                           EDGE_WIDTH>>hshift,    EDGE_WIDTH>>vshift,    sides);
2564     }
2565
2566     h= FFMIN(h, s->avctx->height - y);
2567
2568     if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2569
2570     if (s->avctx->draw_horiz_band) {
2571         AVFrame *src;
2572         int offset[AV_NUM_DATA_POINTERS];
2573         int i;
2574
2575         if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2576             src = &s->current_picture_ptr->f;
2577         else if(s->last_picture_ptr)
2578             src = &s->last_picture_ptr->f;
2579         else
2580             return;
2581
2582         if(s->pict_type==AV_PICTURE_TYPE_B && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2583             for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
2584                 offset[i] = 0;
2585         }else{
2586             offset[0]= y * s->linesize;
2587             offset[1]=
2588             offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2589             for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
2590                 offset[i] = 0;
2591         }
2592
2593         emms_c();
2594
2595         s->avctx->draw_horiz_band(s->avctx, src, offset,
2596                                   y, s->picture_structure, h);
2597     }
2598 }
2599
2600 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2601     const int linesize   = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2602     const int uvlinesize = s->current_picture.f.linesize[1];
2603     const int mb_size= 4 - s->avctx->lowres;
2604
2605     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2606     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2607     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2608     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2609     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2610     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;
2611     //block_index is not used by mpeg2, so it is not affected by chroma_format
2612
2613     s->dest[0] = s->current_picture.f.data[0] + ((s->mb_x - 1) <<  mb_size);
2614     s->dest[1] = s->current_picture.f.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2615     s->dest[2] = s->current_picture.f.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2616
2617     if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2618     {
2619         if(s->picture_structure==PICT_FRAME){
2620         s->dest[0] += s->mb_y *   linesize << mb_size;
2621         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2622         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2623         }else{
2624             s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
2625             s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2626             s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2627             av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2628         }
2629     }
2630 }
2631
2632 void ff_mpeg_flush(AVCodecContext *avctx){
2633     int i;
2634     MpegEncContext *s = avctx->priv_data;
2635
2636     if(s==NULL || s->picture==NULL)
2637         return;
2638
2639     for(i=0; i<s->picture_count; i++){
2640        if (s->picture[i].f.data[0] &&
2641            (s->picture[i].f.type == FF_BUFFER_TYPE_INTERNAL ||
2642             s->picture[i].f.type == FF_BUFFER_TYPE_USER))
2643         free_frame_buffer(s, &s->picture[i]);
2644     }
2645     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2646
2647     s->mb_x= s->mb_y= 0;
2648     s->closed_gop= 0;
2649
2650     s->parse_context.state= -1;
2651     s->parse_context.frame_start_found= 0;
2652     s->parse_context.overread= 0;
2653     s->parse_context.overread_index= 0;
2654     s->parse_context.index= 0;
2655     s->parse_context.last_index= 0;
2656     s->bitstream_buffer_size=0;
2657     s->pp_time=0;
2658 }
2659
2660 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2661                                    DCTELEM *block, int n, int qscale)
2662 {
2663     int i, level, nCoeffs;
2664     const uint16_t *quant_matrix;
2665
2666     nCoeffs= s->block_last_index[n];
2667
2668     block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2669     /* XXX: only mpeg1 */
2670     quant_matrix = s->intra_matrix;
2671     for(i=1;i<=nCoeffs;i++) {
2672         int j= s->intra_scantable.permutated[i];
2673         level = block[j];
2674         if (level) {
2675             if (level < 0) {
2676                 level = -level;
2677                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2678                 level = (level - 1) | 1;
2679                 level = -level;
2680             } else {
2681                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2682                 level = (level - 1) | 1;
2683             }
2684             block[j] = level;
2685         }
2686     }
2687 }
2688
2689 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2690                                    DCTELEM *block, int n, int qscale)
2691 {
2692     int i, level, nCoeffs;
2693     const uint16_t *quant_matrix;
2694
2695     nCoeffs= s->block_last_index[n];
2696
2697     quant_matrix = s->inter_matrix;
2698     for(i=0; i<=nCoeffs; i++) {
2699         int j= s->intra_scantable.permutated[i];
2700         level = block[j];
2701         if (level) {
2702             if (level < 0) {
2703                 level = -level;
2704                 level = (((level << 1) + 1) * qscale *
2705                          ((int) (quant_matrix[j]))) >> 4;
2706                 level = (level - 1) | 1;
2707                 level = -level;
2708             } else {
2709                 level = (((level << 1) + 1) * qscale *
2710                          ((int) (quant_matrix[j]))) >> 4;
2711                 level = (level - 1) | 1;
2712             }
2713             block[j] = level;
2714         }
2715     }
2716 }
2717
2718 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2719                                    DCTELEM *block, int n, int qscale)
2720 {
2721     int i, level, nCoeffs;
2722     const uint16_t *quant_matrix;
2723
2724     if(s->alternate_scan) nCoeffs= 63;
2725     else nCoeffs= s->block_last_index[n];
2726
2727     block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2728     quant_matrix = s->intra_matrix;
2729     for(i=1;i<=nCoeffs;i++) {
2730         int j= s->intra_scantable.permutated[i];
2731         level = block[j];
2732         if (level) {
2733             if (level < 0) {
2734                 level = -level;
2735                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2736                 level = -level;
2737             } else {
2738                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2739             }
2740             block[j] = level;
2741         }
2742     }
2743 }
2744
2745 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2746                                    DCTELEM *block, int n, int qscale)
2747 {
2748     int i, level, nCoeffs;
2749     const uint16_t *quant_matrix;
2750     int sum=-1;
2751
2752     if(s->alternate_scan) nCoeffs= 63;
2753     else nCoeffs= s->block_last_index[n];
2754
2755     block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2756     sum += block[0];
2757     quant_matrix = s->intra_matrix;
2758     for(i=1;i<=nCoeffs;i++) {
2759         int j= s->intra_scantable.permutated[i];
2760         level = block[j];
2761         if (level) {
2762             if (level < 0) {
2763                 level = -level;
2764                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2765                 level = -level;
2766             } else {
2767                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2768             }
2769             block[j] = level;
2770             sum+=level;
2771         }
2772     }
2773     block[63]^=sum&1;
2774 }
2775
2776 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2777                                    DCTELEM *block, int n, int qscale)
2778 {
2779     int i, level, nCoeffs;
2780     const uint16_t *quant_matrix;
2781     int sum=-1;
2782
2783     if(s->alternate_scan) nCoeffs= 63;
2784     else nCoeffs= s->block_last_index[n];
2785
2786     quant_matrix = s->inter_matrix;
2787     for(i=0; i<=nCoeffs; i++) {
2788         int j= s->intra_scantable.permutated[i];
2789         level = block[j];
2790         if (level) {
2791             if (level < 0) {
2792                 level = -level;
2793                 level = (((level << 1) + 1) * qscale *
2794                          ((int) (quant_matrix[j]))) >> 4;
2795                 level = -level;
2796             } else {
2797                 level = (((level << 1) + 1) * qscale *
2798                          ((int) (quant_matrix[j]))) >> 4;
2799             }
2800             block[j] = level;
2801             sum+=level;
2802         }
2803     }
2804     block[63]^=sum&1;
2805 }
2806
2807 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
2808                                   DCTELEM *block, int n, int qscale)
2809 {
2810     int i, level, qmul, qadd;
2811     int nCoeffs;
2812
2813     assert(s->block_last_index[n]>=0);
2814
2815     qmul = qscale << 1;
2816
2817     if (!s->h263_aic) {
2818         block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2819         qadd = (qscale - 1) | 1;
2820     }else{
2821         qadd = 0;
2822     }
2823     if(s->ac_pred)
2824         nCoeffs=63;
2825     else
2826         nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2827
2828     for(i=1; i<=nCoeffs; i++) {
2829         level = block[i];
2830         if (level) {
2831             if (level < 0) {
2832                 level = level * qmul - qadd;
2833             } else {
2834                 level = level * qmul + qadd;
2835             }
2836             block[i] = level;
2837         }
2838     }
2839 }
2840
2841 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
2842                                   DCTELEM *block, int n, int qscale)
2843 {
2844     int i, level, qmul, qadd;
2845     int nCoeffs;
2846
2847     assert(s->block_last_index[n]>=0);
2848
2849     qadd = (qscale - 1) | 1;
2850     qmul = qscale << 1;
2851
2852     nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
2853
2854     for(i=0; i<=nCoeffs; i++) {
2855         level = block[i];
2856         if (level) {
2857             if (level < 0) {
2858                 level = level * qmul - qadd;
2859             } else {
2860                 level = level * qmul + qadd;
2861             }
2862             block[i] = level;
2863         }
2864     }
2865 }
2866
2867 /**
2868  * set qscale and update qscale dependent variables.
2869  */
2870 void ff_set_qscale(MpegEncContext * s, int qscale)
2871 {
2872     if (qscale < 1)
2873         qscale = 1;
2874     else if (qscale > 31)
2875         qscale = 31;
2876
2877     s->qscale = qscale;
2878     s->chroma_qscale= s->chroma_qscale_table[qscale];
2879
2880     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2881     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2882 }
2883
2884 void ff_MPV_report_decode_progress(MpegEncContext *s)
2885 {
2886     if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->error_occurred)
2887         ff_thread_report_progress(&s->current_picture_ptr->f, s->mb_y, 0);
2888 }