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