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