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