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