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