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

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