git.sesse.net Git - ffmpeg/blob - libavcodec/mpegvideo.c

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