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