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

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