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     memset(s->last_picture.f.data, 0, sizeof(s->last_picture.f.data));
1500     memset(s->next_picture.f.data, 0, sizeof(s->next_picture.f.data));
1501     if (s->last_picture_ptr)
1502         ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1503     if (s->next_picture_ptr)
1504         ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1505
1506     if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME)) {
1507         if (s->next_picture_ptr)
1508             s->next_picture_ptr->owner2 = s;
1509         if (s->last_picture_ptr)
1510             s->last_picture_ptr->owner2 = s;
1511     }
1512
1513     assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1514                                                  s->last_picture_ptr->f.data[0]));
1515
1516     if (s->picture_structure!= PICT_FRAME && s->out_format != FMT_H264) {
1517         int i;
1518         for (i = 0; i < 4; i++) {
1519             if (s->picture_structure == PICT_BOTTOM_FIELD) {
1520                 s->current_picture.f.data[i] +=
1521                     s->current_picture.f.linesize[i];
1522             }
1523             s->current_picture.f.linesize[i] *= 2;
1524             s->last_picture.f.linesize[i]    *= 2;
1525             s->next_picture.f.linesize[i]    *= 2;
1526         }
1527     }
1528
1529     s->err_recognition = avctx->err_recognition;
1530
1531     /* set dequantizer, we can't do it during init as
1532      * it might change for mpeg4 and we can't do it in the header
1533      * decode as init is not called for mpeg4 there yet */
1534     if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1535         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1536         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1537     } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1538         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1539         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1540     } else {
1541         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1542         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1543     }
1544
1545     if (s->dct_error_sum) {
1546         assert(s->avctx->noise_reduction && s->encoding);
1547         update_noise_reduction(s);
1548     }
1549
1550     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1551         return ff_xvmc_field_start(s, avctx);
1552
1553     return 0;
1554 }
1555
1556 /* generic function for encode/decode called after a
1557  * frame has been coded/decoded. */
1558 void ff_MPV_frame_end(MpegEncContext *s)
1559 {
1560     int i;
1561     /* redraw edges for the frame if decoding didn't complete */
1562     // just to make sure that all data is rendered.
1563     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
1564         ff_xvmc_field_end(s);
1565    } else if((s->error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND)) &&
1566               !s->avctx->hwaccel &&
1567               !(s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
1568               s->unrestricted_mv &&
1569               s->current_picture.f.reference &&
1570               !s->intra_only &&
1571               !(s->flags & CODEC_FLAG_EMU_EDGE) &&
1572               !s->avctx->lowres
1573             ) {
1574         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1575         int hshift = desc->log2_chroma_w;
1576         int vshift = desc->log2_chroma_h;
1577         s->dsp.draw_edges(s->current_picture.f.data[0], s->current_picture.f.linesize[0],
1578                           s->h_edge_pos, s->v_edge_pos,
1579                           EDGE_WIDTH, EDGE_WIDTH,
1580                           EDGE_TOP | EDGE_BOTTOM);
1581         s->dsp.draw_edges(s->current_picture.f.data[1], s->current_picture.f.linesize[1],
1582                           s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1583                           EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1584                           EDGE_TOP | EDGE_BOTTOM);
1585         s->dsp.draw_edges(s->current_picture.f.data[2], s->current_picture.f.linesize[2],
1586                           s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1587                           EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1588                           EDGE_TOP | EDGE_BOTTOM);
1589     }
1590
1591     emms_c();
1592
1593     s->last_pict_type                 = s->pict_type;
1594     s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f.quality;
1595     if (s->pict_type!= AV_PICTURE_TYPE_B) {
1596         s->last_non_b_pict_type = s->pict_type;
1597     }
1598 #if 0
1599     /* copy back current_picture variables */
1600     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1601         if (s->picture[i].f.data[0] == s->current_picture.f.data[0]) {
1602             s->picture[i] = s->current_picture;
1603             break;
1604         }
1605     }
1606     assert(i < MAX_PICTURE_COUNT);
1607 #endif
1608
1609     if (s->encoding) {
1610         /* release non-reference frames */
1611         for (i = 0; i < s->picture_count; i++) {
1612             if (s->picture[i].f.data[0] && !s->picture[i].f.reference
1613                 /* && s->picture[i].type != FF_BUFFER_TYPE_SHARED */) {
1614                 free_frame_buffer(s, &s->picture[i]);
1615             }
1616         }
1617     }
1618     // clear copies, to avoid confusion
1619 #if 0
1620     memset(&s->last_picture,    0, sizeof(Picture));
1621     memset(&s->next_picture,    0, sizeof(Picture));
1622     memset(&s->current_picture, 0, sizeof(Picture));
1623 #endif
1624     s->avctx->coded_frame = &s->current_picture_ptr->f;
1625
1626     if (s->codec_id != AV_CODEC_ID_H264 && s->current_picture.f.reference) {
1627         ff_thread_report_progress(&s->current_picture_ptr->f, INT_MAX, 0);
1628     }
1629 }
1630
1631 /**
1632  * Draw a line from (ex, ey) -> (sx, sy).
1633  * @param w width of the image
1634  * @param h height of the image
1635  * @param stride stride/linesize of the image
1636  * @param color color of the arrow
1637  */
1638 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
1639                       int w, int h, int stride, int color)
1640 {
1641     int x, y, fr, f;
1642
1643     sx = av_clip(sx, 0, w - 1);
1644     sy = av_clip(sy, 0, h - 1);
1645     ex = av_clip(ex, 0, w - 1);
1646     ey = av_clip(ey, 0, h - 1);
1647
1648     buf[sy * stride + sx] += color;
1649
1650     if (FFABS(ex - sx) > FFABS(ey - sy)) {
1651         if (sx > ex) {
1652             FFSWAP(int, sx, ex);
1653             FFSWAP(int, sy, ey);
1654         }
1655         buf += sx + sy * stride;
1656         ex  -= sx;
1657         f    = ((ey - sy) << 16) / ex;
1658         for(x= 0; x <= ex; x++){
1659             y  = (x * f) >> 16;
1660             fr = (x * f) & 0xFFFF;
1661             buf[y * stride + x]       += (color * (0x10000 - fr)) >> 16;
1662             if(fr) buf[(y + 1) * stride + x] += (color *            fr ) >> 16;
1663         }
1664     } else {
1665         if (sy > ey) {
1666             FFSWAP(int, sx, ex);
1667             FFSWAP(int, sy, ey);
1668         }
1669         buf += sx + sy * stride;
1670         ey  -= sy;
1671         if (ey)
1672             f = ((ex - sx) << 16) / ey;
1673         else
1674             f = 0;
1675         for(y= 0; y <= ey; y++){
1676             x  = (y*f) >> 16;
1677             fr = (y*f) & 0xFFFF;
1678             buf[y * stride + x]     += (color * (0x10000 - fr)) >> 16;
1679             if(fr) buf[y * stride + x + 1] += (color *            fr ) >> 16;
1680         }
1681     }
1682 }
1683
1684 /**
1685  * Draw an arrow from (ex, ey) -> (sx, sy).
1686  * @param w width of the image
1687  * @param h height of the image
1688  * @param stride stride/linesize of the image
1689  * @param color color of the arrow
1690  */
1691 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
1692                        int ey, int w, int h, int stride, int color)
1693 {
1694     int dx,dy;
1695
1696     sx = av_clip(sx, -100, w + 100);
1697     sy = av_clip(sy, -100, h + 100);
1698     ex = av_clip(ex, -100, w + 100);
1699     ey = av_clip(ey, -100, h + 100);
1700
1701     dx = ex - sx;
1702     dy = ey - sy;
1703
1704     if (dx * dx + dy * dy > 3 * 3) {
1705         int rx =  dx + dy;
1706         int ry = -dx + dy;
1707         int length = ff_sqrt((rx * rx + ry * ry) << 8);
1708
1709         // FIXME subpixel accuracy
1710         rx = ROUNDED_DIV(rx * 3 << 4, length);
1711         ry = ROUNDED_DIV(ry * 3 << 4, length);
1712
1713         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1714         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1715     }
1716     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1717 }
1718
1719 /**
1720  * Print debugging info for the given picture.
1721  */
1722 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict)
1723 {
1724     if (   s->avctx->hwaccel || !pict || !pict->mb_type
1725         || (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU))
1726         return;
1727
1728
1729     if (s->avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
1730         int x,y;
1731
1732         av_log(s->avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
1733                av_get_picture_type_char(pict->pict_type));
1734         for (y = 0; y < s->mb_height; y++) {
1735             for (x = 0; x < s->mb_width; x++) {
1736                 if (s->avctx->debug & FF_DEBUG_SKIP) {
1737                     int count = s->mbskip_table[x + y * s->mb_stride];
1738                     if (count > 9)
1739                         count = 9;
1740                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1741                 }
1742                 if (s->avctx->debug & FF_DEBUG_QP) {
1743                     av_log(s->avctx, AV_LOG_DEBUG, "%2d",
1744                            pict->qscale_table[x + y * s->mb_stride]);
1745                 }
1746                 if (s->avctx->debug & FF_DEBUG_MB_TYPE) {
1747                     int mb_type = pict->mb_type[x + y * s->mb_stride];
1748                     // Type & MV direction
1749                     if (IS_PCM(mb_type))
1750                         av_log(s->avctx, AV_LOG_DEBUG, "P");
1751                     else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1752                         av_log(s->avctx, AV_LOG_DEBUG, "A");
1753                     else if (IS_INTRA4x4(mb_type))
1754                         av_log(s->avctx, AV_LOG_DEBUG, "i");
1755                     else if (IS_INTRA16x16(mb_type))
1756                         av_log(s->avctx, AV_LOG_DEBUG, "I");
1757                     else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1758                         av_log(s->avctx, AV_LOG_DEBUG, "d");
1759                     else if (IS_DIRECT(mb_type))
1760                         av_log(s->avctx, AV_LOG_DEBUG, "D");
1761                     else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
1762                         av_log(s->avctx, AV_LOG_DEBUG, "g");
1763                     else if (IS_GMC(mb_type))
1764                         av_log(s->avctx, AV_LOG_DEBUG, "G");
1765                     else if (IS_SKIP(mb_type))
1766                         av_log(s->avctx, AV_LOG_DEBUG, "S");
1767                     else if (!USES_LIST(mb_type, 1))
1768                         av_log(s->avctx, AV_LOG_DEBUG, ">");
1769                     else if (!USES_LIST(mb_type, 0))
1770                         av_log(s->avctx, AV_LOG_DEBUG, "<");
1771                     else {
1772                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1773                         av_log(s->avctx, AV_LOG_DEBUG, "X");
1774                     }
1775
1776                     // segmentation
1777                     if (IS_8X8(mb_type))
1778                         av_log(s->avctx, AV_LOG_DEBUG, "+");
1779                     else if (IS_16X8(mb_type))
1780                         av_log(s->avctx, AV_LOG_DEBUG, "-");
1781                     else if (IS_8X16(mb_type))
1782                         av_log(s->avctx, AV_LOG_DEBUG, "|");
1783                     else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
1784                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1785                     else
1786                         av_log(s->avctx, AV_LOG_DEBUG, "?");
1787
1788
1789                     if (IS_INTERLACED(mb_type))
1790                         av_log(s->avctx, AV_LOG_DEBUG, "=");
1791                     else
1792                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1793                 }
1794             }
1795             av_log(s->avctx, AV_LOG_DEBUG, "\n");
1796         }
1797     }
1798
1799     if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
1800         (s->avctx->debug_mv)) {
1801         const int shift = 1 + s->quarter_sample;
1802         int mb_y;
1803         uint8_t *ptr;
1804         int i;
1805         int h_chroma_shift, v_chroma_shift, block_height;
1806         const int width          = s->avctx->width;
1807         const int height         = s->avctx->height;
1808         const int mv_sample_log2 = 4 - pict->motion_subsample_log2;
1809         const int mv_stride      = (s->mb_width << mv_sample_log2) +
1810                                    (s->codec_id == AV_CODEC_ID_H264 ? 0 : 1);
1811         s->low_delay = 0; // needed to see the vectors without trashing the buffers
1812
1813         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
1814
1815         for (i = 0; i < 3; i++) {
1816             size_t size= (i == 0) ? pict->linesize[i] * FFALIGN(height, 16):
1817                          pict->linesize[i] * FFALIGN(height, 16) >> v_chroma_shift;
1818             s->visualization_buffer[i]= av_realloc(s->visualization_buffer[i], size);
1819             memcpy(s->visualization_buffer[i], pict->data[i], size);
1820             pict->data[i] = s->visualization_buffer[i];
1821         }
1822         pict->type   = FF_BUFFER_TYPE_COPY;
1823         pict->opaque= NULL;
1824         ptr          = pict->data[0];
1825         block_height = 16 >> v_chroma_shift;
1826
1827         for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1828             int mb_x;
1829             for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1830                 const int mb_index = mb_x + mb_y * s->mb_stride;
1831                 if ((s->avctx->debug_mv) && pict->motion_val[0]) {
1832                     int type;
1833                     for (type = 0; type < 3; type++) {
1834                         int direction = 0;
1835                         switch (type) {
1836                         case 0:
1837                             if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
1838                                 (pict->pict_type!= AV_PICTURE_TYPE_P))
1839                                 continue;
1840                             direction = 0;
1841                             break;
1842                         case 1:
1843                             if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
1844                                 (pict->pict_type!= AV_PICTURE_TYPE_B))
1845                                 continue;
1846                             direction = 0;
1847                             break;
1848                         case 2:
1849                             if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
1850                                 (pict->pict_type!= AV_PICTURE_TYPE_B))
1851                                 continue;
1852                             direction = 1;
1853                             break;
1854                         }
1855                         if (!USES_LIST(pict->mb_type[mb_index], direction))
1856                             continue;
1857
1858                         if (IS_8X8(pict->mb_type[mb_index])) {
1859                             int i;
1860                             for (i = 0; i < 4; i++) {
1861                                 int sx = mb_x * 16 + 4 + 8 * (i & 1);
1862                                 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
1863                                 int xy = (mb_x * 2 + (i & 1) +
1864                                           (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1865                                 int mx = (pict->motion_val[direction][xy][0] >> shift) + sx;
1866                                 int my = (pict->motion_val[direction][xy][1] >> shift) + sy;
1867                                 draw_arrow(ptr, sx, sy, mx, my, width,
1868                                            height, s->linesize, 100);
1869                             }
1870                         } else if (IS_16X8(pict->mb_type[mb_index])) {
1871                             int i;
1872                             for (i = 0; i < 2; i++) {
1873                                 int sx = mb_x * 16 + 8;
1874                                 int sy = mb_y * 16 + 4 + 8 * i;
1875                                 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
1876                                 int mx = (pict->motion_val[direction][xy][0] >> shift);
1877                                 int my = (pict->motion_val[direction][xy][1] >> shift);
1878
1879                                 if (IS_INTERLACED(pict->mb_type[mb_index]))
1880                                     my *= 2;
1881
1882                             draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1883                                        height, s->linesize, 100);
1884                             }
1885                         } else if (IS_8X16(pict->mb_type[mb_index])) {
1886                             int i;
1887                             for (i = 0; i < 2; i++) {
1888                                 int sx = mb_x * 16 + 4 + 8 * i;
1889                                 int sy = mb_y * 16 + 8;
1890                                 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
1891                                 int mx = pict->motion_val[direction][xy][0] >> shift;
1892                                 int my = pict->motion_val[direction][xy][1] >> shift;
1893
1894                                 if (IS_INTERLACED(pict->mb_type[mb_index]))
1895                                     my *= 2;
1896
1897                                 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1898                                            height, s->linesize, 100);
1899                             }
1900                         } else {
1901                               int sx= mb_x * 16 + 8;
1902                               int sy= mb_y * 16 + 8;
1903                               int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
1904                               int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1905                               int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1906                               draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1907                         }
1908                     }
1909                 }
1910                 if ((s->avctx->debug & FF_DEBUG_VIS_QP)) {
1911                     uint64_t c = (pict->qscale_table[mb_index] * 128 / 31) *
1912                                  0x0101010101010101ULL;
1913                     int y;
1914                     for (y = 0; y < block_height; y++) {
1915                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
1916                                       (block_height * mb_y + y) *
1917                                       pict->linesize[1]) = c;
1918                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
1919                                       (block_height * mb_y + y) *
1920                                       pict->linesize[2]) = c;
1921                     }
1922                 }
1923                 if ((s->avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
1924                     pict->motion_val[0]) {
1925                     int mb_type = pict->mb_type[mb_index];
1926                     uint64_t u,v;
1927                     int y;
1928 #define COLOR(theta, r) \
1929     u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
1930     v = (int)(128 + r * sin(theta * 3.141592 / 180));
1931
1932
1933                     u = v = 128;
1934                     if (IS_PCM(mb_type)) {
1935                         COLOR(120, 48)
1936                     } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
1937                                IS_INTRA16x16(mb_type)) {
1938                         COLOR(30, 48)
1939                     } else if (IS_INTRA4x4(mb_type)) {
1940                         COLOR(90, 48)
1941                     } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
1942                         // COLOR(120, 48)
1943                     } else if (IS_DIRECT(mb_type)) {
1944                         COLOR(150, 48)
1945                     } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
1946                         COLOR(170, 48)
1947                     } else if (IS_GMC(mb_type)) {
1948                         COLOR(190, 48)
1949                     } else if (IS_SKIP(mb_type)) {
1950                         // COLOR(180, 48)
1951                     } else if (!USES_LIST(mb_type, 1)) {
1952                         COLOR(240, 48)
1953                     } else if (!USES_LIST(mb_type, 0)) {
1954                         COLOR(0, 48)
1955                     } else {
1956                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1957                         COLOR(300,48)
1958                     }
1959
1960                     u *= 0x0101010101010101ULL;
1961                     v *= 0x0101010101010101ULL;
1962                     for (y = 0; y < block_height; y++) {
1963                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
1964                                       (block_height * mb_y + y) * pict->linesize[1]) = u;
1965                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
1966                                       (block_height * mb_y + y) * pict->linesize[2]) = v;
1967                     }
1968
1969                     // segmentation
1970                     if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
1971                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
1972                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1973                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
1974                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1975                     }
1976                     if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
1977                         for (y = 0; y < 16; y++)
1978                             pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
1979                                           pict->linesize[0]] ^= 0x80;
1980                     }
1981                     if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
1982                         int dm = 1 << (mv_sample_log2 - 2);
1983                         for (i = 0; i < 4; i++) {
1984                             int sx = mb_x * 16 + 8 * (i & 1);
1985                             int sy = mb_y * 16 + 8 * (i >> 1);
1986                             int xy = (mb_x * 2 + (i & 1) +
1987                                      (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1988                             // FIXME bidir
1989                             int32_t *mv = (int32_t *) &pict->motion_val[0][xy];
1990                             if (mv[0] != mv[dm] ||
1991                                 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
1992                                 for (y = 0; y < 8; y++)
1993                                     pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
1994                             if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
1995                                 *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
1996                                               pict->linesize[0]) ^= 0x8080808080808080ULL;
1997                         }
1998                     }
1999
2000                     if (IS_INTERLACED(mb_type) &&
2001                         s->codec_id == AV_CODEC_ID_H264) {
2002                         // hmm
2003                     }
2004                 }
2005                 s->mbskip_table[mb_index] = 0;
2006             }
2007         }
2008     }
2009 }
2010
2011 static inline int hpel_motion_lowres(MpegEncContext *s,
2012                                      uint8_t *dest, uint8_t *src,
2013                                      int field_based, int field_select,
2014                                      int src_x, int src_y,
2015                                      int width, int height, int stride,
2016                                      int h_edge_pos, int v_edge_pos,
2017                                      int w, int h, h264_chroma_mc_func *pix_op,
2018                                      int motion_x, int motion_y)
2019 {
2020     const int lowres   = s->avctx->lowres;
2021     const int op_index = FFMIN(lowres, 2);
2022     const int s_mask   = (2 << lowres) - 1;
2023     int emu = 0;
2024     int sx, sy;
2025
2026     if (s->quarter_sample) {
2027         motion_x /= 2;
2028         motion_y /= 2;
2029     }
2030
2031     sx = motion_x & s_mask;
2032     sy = motion_y & s_mask;
2033     src_x += motion_x >> lowres + 1;
2034     src_y += motion_y >> lowres + 1;
2035
2036     src   += src_y * stride + src_x;
2037
2038     if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w,                 0) ||
2039         (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2040         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w + 1,
2041                                 (h + 1) << field_based, src_x,
2042                                 src_y   << field_based,
2043                                 h_edge_pos,
2044                                 v_edge_pos);
2045         src = s->edge_emu_buffer;
2046         emu = 1;
2047     }
2048
2049     sx = (sx << 2) >> lowres;
2050     sy = (sy << 2) >> lowres;
2051     if (field_select)
2052         src += s->linesize;
2053     pix_op[op_index](dest, src, stride, h, sx, sy);
2054     return emu;
2055 }
2056
2057 /* apply one mpeg motion vector to the three components */
2058 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
2059                                                 uint8_t *dest_y,
2060                                                 uint8_t *dest_cb,
2061                                                 uint8_t *dest_cr,
2062                                                 int field_based,
2063                                                 int bottom_field,
2064                                                 int field_select,
2065                                                 uint8_t **ref_picture,
2066                                                 h264_chroma_mc_func *pix_op,
2067                                                 int motion_x, int motion_y,
2068                                                 int h, int mb_y)
2069 {
2070     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2071     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy,
2072         uvsx, uvsy;
2073     const int lowres     = s->avctx->lowres;
2074     const int op_index   = FFMIN(lowres-1+s->chroma_x_shift, 2);
2075     const int block_s    = 8>>lowres;
2076     const int s_mask     = (2 << lowres) - 1;
2077     const int h_edge_pos = s->h_edge_pos >> lowres;
2078     const int v_edge_pos = s->v_edge_pos >> lowres;
2079     linesize   = s->current_picture.f.linesize[0] << field_based;
2080     uvlinesize = s->current_picture.f.linesize[1] << field_based;
2081
2082     // FIXME obviously not perfect but qpel will not work in lowres anyway
2083     if (s->quarter_sample) {
2084         motion_x /= 2;
2085         motion_y /= 2;
2086     }
2087
2088     if(field_based){
2089         motion_y += (bottom_field - field_select)*((1 << lowres)-1);
2090     }
2091
2092     sx = motion_x & s_mask;
2093     sy = motion_y & s_mask;
2094     src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
2095     src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
2096
2097     if (s->out_format == FMT_H263) {
2098         uvsx    = ((motion_x >> 1) & s_mask) | (sx & 1);
2099         uvsy    = ((motion_y >> 1) & s_mask) | (sy & 1);
2100         uvsrc_x = src_x >> 1;
2101         uvsrc_y = src_y >> 1;
2102     } else if (s->out_format == FMT_H261) {
2103         // even chroma mv's are full pel in H261
2104         mx      = motion_x / 4;
2105         my      = motion_y / 4;
2106         uvsx    = (2 * mx) & s_mask;
2107         uvsy    = (2 * my) & s_mask;
2108         uvsrc_x = s->mb_x * block_s + (mx >> lowres);
2109         uvsrc_y =    mb_y * block_s + (my >> lowres);
2110     } else {
2111         if(s->chroma_y_shift){
2112             mx      = motion_x / 2;
2113             my      = motion_y / 2;
2114             uvsx    = mx & s_mask;
2115             uvsy    = my & s_mask;
2116             uvsrc_x = s->mb_x * block_s                 + (mx >> lowres + 1);
2117             uvsrc_y =   (mb_y * block_s >> field_based) + (my >> lowres + 1);
2118         } else {
2119             if(s->chroma_x_shift){
2120             //Chroma422
2121                 mx = motion_x / 2;
2122                 uvsx = mx & s_mask;
2123                 uvsy = motion_y & s_mask;
2124                 uvsrc_y = src_y;
2125                 uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
2126             } else {
2127             //Chroma444
2128                 uvsx = motion_x & s_mask;
2129                 uvsy = motion_y & s_mask;
2130                 uvsrc_x = src_x;
2131                 uvsrc_y = src_y;
2132             }
2133         }
2134     }
2135
2136     ptr_y  = ref_picture[0] + src_y   * linesize   + src_x;
2137     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2138     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2139
2140     if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s,       0) ||
2141         (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2142         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
2143                                 linesize >> field_based, 17, 17 + field_based,
2144                                 src_x, src_y << field_based, h_edge_pos,
2145                                 v_edge_pos);
2146         ptr_y = s->edge_emu_buffer;
2147         if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2148             uint8_t *uvbuf = s->edge_emu_buffer + 18 * s->linesize;
2149             s->vdsp.emulated_edge_mc(uvbuf , ptr_cb, uvlinesize >> field_based, 9,
2150                                     9 + field_based,
2151                                     uvsrc_x, uvsrc_y << field_based,
2152                                     h_edge_pos >> 1, v_edge_pos >> 1);
2153             s->vdsp.emulated_edge_mc(uvbuf + 16, ptr_cr, uvlinesize >> field_based, 9,
2154                                     9 + field_based,
2155                                     uvsrc_x, uvsrc_y << field_based,
2156                                     h_edge_pos >> 1, v_edge_pos >> 1);
2157             ptr_cb = uvbuf;
2158             ptr_cr = uvbuf + 16;
2159         }
2160     }
2161
2162     // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data
2163     if (bottom_field) {
2164         dest_y  += s->linesize;
2165         dest_cb += s->uvlinesize;
2166         dest_cr += s->uvlinesize;
2167     }
2168
2169     if (field_select) {
2170         ptr_y   += s->linesize;
2171         ptr_cb  += s->uvlinesize;
2172         ptr_cr  += s->uvlinesize;
2173     }
2174
2175     sx = (sx << 2) >> lowres;
2176     sy = (sy << 2) >> lowres;
2177     pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
2178
2179     if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2180         uvsx = (uvsx << 2) >> lowres;
2181         uvsy = (uvsy << 2) >> lowres;
2182         if (h >> s->chroma_y_shift) {
2183             pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2184             pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2185         }
2186     }
2187     // FIXME h261 lowres loop filter
2188 }
2189
2190 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
2191                                             uint8_t *dest_cb, uint8_t *dest_cr,
2192                                             uint8_t **ref_picture,
2193                                             h264_chroma_mc_func * pix_op,
2194                                             int mx, int my)
2195 {
2196     const int lowres     = s->avctx->lowres;
2197     const int op_index   = FFMIN(lowres, 2);
2198     const int block_s    = 8 >> lowres;
2199     const int s_mask     = (2 << lowres) - 1;
2200     const int h_edge_pos = s->h_edge_pos >> lowres + 1;
2201     const int v_edge_pos = s->v_edge_pos >> lowres + 1;
2202     int emu = 0, src_x, src_y, offset, sx, sy;
2203     uint8_t *ptr;
2204
2205     if (s->quarter_sample) {
2206         mx /= 2;
2207         my /= 2;
2208     }
2209
2210     /* In case of 8X8, we construct a single chroma motion vector
2211        with a special rounding */
2212     mx = ff_h263_round_chroma(mx);
2213     my = ff_h263_round_chroma(my);
2214
2215     sx = mx & s_mask;
2216     sy = my & s_mask;
2217     src_x = s->mb_x * block_s + (mx >> lowres + 1);
2218     src_y = s->mb_y * block_s + (my >> lowres + 1);
2219
2220     offset = src_y * s->uvlinesize + src_x;
2221     ptr = ref_picture[1] + offset;
2222     if (s->flags & CODEC_FLAG_EMU_EDGE) {
2223         if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2224             (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2225             s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize,
2226                                     9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
2227             ptr = s->edge_emu_buffer;
2228             emu = 1;
2229         }
2230     }
2231     sx = (sx << 2) >> lowres;
2232     sy = (sy << 2) >> lowres;
2233     pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
2234
2235     ptr = ref_picture[2] + offset;
2236     if (emu) {
2237         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9,
2238                                 src_x, src_y, h_edge_pos, v_edge_pos);
2239         ptr = s->edge_emu_buffer;
2240     }
2241     pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
2242 }
2243
2244 /**
2245  * motion compensation of a single macroblock
2246  * @param s context
2247  * @param dest_y luma destination pointer
2248  * @param dest_cb chroma cb/u destination pointer
2249  * @param dest_cr chroma cr/v destination pointer
2250  * @param dir direction (0->forward, 1->backward)
2251  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2252  * @param pix_op halfpel motion compensation function (average or put normally)
2253  * the motion vectors are taken from s->mv and the MV type from s->mv_type
2254  */
2255 static inline void MPV_motion_lowres(MpegEncContext *s,
2256                                      uint8_t *dest_y, uint8_t *dest_cb,
2257                                      uint8_t *dest_cr,
2258                                      int dir, uint8_t **ref_picture,
2259                                      h264_chroma_mc_func *pix_op)
2260 {
2261     int mx, my;
2262     int mb_x, mb_y, i;
2263     const int lowres  = s->avctx->lowres;
2264     const int block_s = 8 >>lowres;
2265
2266     mb_x = s->mb_x;
2267     mb_y = s->mb_y;
2268
2269     switch (s->mv_type) {
2270     case MV_TYPE_16X16:
2271         mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2272                            0, 0, 0,
2273                            ref_picture, pix_op,
2274                            s->mv[dir][0][0], s->mv[dir][0][1],
2275                            2 * block_s, mb_y);
2276         break;
2277     case MV_TYPE_8X8:
2278         mx = 0;
2279         my = 0;
2280         for (i = 0; i < 4; i++) {
2281             hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
2282                                s->linesize) * block_s,
2283                                ref_picture[0], 0, 0,
2284                                (2 * mb_x + (i & 1)) * block_s,
2285                                (2 * mb_y + (i >> 1)) * block_s,
2286                                s->width, s->height, s->linesize,
2287                                s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
2288                                block_s, block_s, pix_op,
2289                                s->mv[dir][i][0], s->mv[dir][i][1]);
2290
2291             mx += s->mv[dir][i][0];
2292             my += s->mv[dir][i][1];
2293         }
2294
2295         if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY))
2296             chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
2297                                      pix_op, mx, my);
2298         break;
2299     case MV_TYPE_FIELD:
2300         if (s->picture_structure == PICT_FRAME) {
2301             /* top field */
2302             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2303                                1, 0, s->field_select[dir][0],
2304                                ref_picture, pix_op,
2305                                s->mv[dir][0][0], s->mv[dir][0][1],
2306                                block_s, mb_y);
2307             /* bottom field */
2308             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2309                                1, 1, s->field_select[dir][1],
2310                                ref_picture, pix_op,
2311                                s->mv[dir][1][0], s->mv[dir][1][1],
2312                                block_s, mb_y);
2313         } else {
2314             if (s->picture_structure != s->field_select[dir][0] + 1 &&
2315                 s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
2316                 ref_picture = s->current_picture_ptr->f.data;
2317
2318             }
2319             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2320                                0, 0, s->field_select[dir][0],
2321                                ref_picture, pix_op,
2322                                s->mv[dir][0][0],
2323                                s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
2324             }
2325         break;
2326     case MV_TYPE_16X8:
2327         for (i = 0; i < 2; i++) {
2328             uint8_t **ref2picture;
2329
2330             if (s->picture_structure == s->field_select[dir][i] + 1 ||
2331                 s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
2332                 ref2picture = ref_picture;
2333             } else {
2334                 ref2picture = s->current_picture_ptr->f.data;
2335             }
2336
2337             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2338                                0, 0, s->field_select[dir][i],
2339                                ref2picture, pix_op,
2340                                s->mv[dir][i][0], s->mv[dir][i][1] +
2341                                2 * block_s * i, block_s, mb_y >> 1);
2342
2343             dest_y  +=  2 * block_s *  s->linesize;
2344             dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2345             dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2346         }
2347         break;
2348     case MV_TYPE_DMV:
2349         if (s->picture_structure == PICT_FRAME) {
2350             for (i = 0; i < 2; i++) {
2351                 int j;
2352                 for (j = 0; j < 2; j++) {
2353                     mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2354                                        1, j, j ^ i,
2355                                        ref_picture, pix_op,
2356                                        s->mv[dir][2 * i + j][0],
2357                                        s->mv[dir][2 * i + j][1],
2358                                        block_s, mb_y);
2359                 }
2360                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2361             }
2362         } else {
2363             for (i = 0; i < 2; i++) {
2364                 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2365                                    0, 0, s->picture_structure != i + 1,
2366                                    ref_picture, pix_op,
2367                                    s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
2368                                    2 * block_s, mb_y >> 1);
2369
2370                 // after put we make avg of the same block
2371                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2372
2373                 // opposite parity is always in the same
2374                 // frame if this is second field
2375                 if (!s->first_field) {
2376                     ref_picture = s->current_picture_ptr->f.data;
2377                 }
2378             }
2379         }
2380         break;
2381     default:
2382         av_assert2(0);
2383     }
2384 }
2385
2386 /**
2387  * find the lowest MB row referenced in the MVs
2388  */
2389 int ff_MPV_lowest_referenced_row(MpegEncContext *s, int dir)
2390 {
2391     int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2392     int my, off, i, mvs;
2393
2394     if (s->picture_structure != PICT_FRAME || s->mcsel)
2395         goto unhandled;
2396
2397     switch (s->mv_type) {
2398         case MV_TYPE_16X16:
2399             mvs = 1;
2400             break;
2401         case MV_TYPE_16X8:
2402             mvs = 2;
2403             break;
2404         case MV_TYPE_8X8:
2405             mvs = 4;
2406             break;
2407         default:
2408             goto unhandled;
2409     }
2410
2411     for (i = 0; i < mvs; i++) {
2412         my = s->mv[dir][i][1]<<qpel_shift;
2413         my_max = FFMAX(my_max, my);
2414         my_min = FFMIN(my_min, my);
2415     }
2416
2417     off = (FFMAX(-my_min, my_max) + 63) >> 6;
2418
2419     return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
2420 unhandled:
2421     return s->mb_height-1;
2422 }
2423
2424 /* put block[] to dest[] */
2425 static inline void put_dct(MpegEncContext *s,
2426                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2427 {
2428     s->dct_unquantize_intra(s, block, i, qscale);
2429     s->dsp.idct_put (dest, line_size, block);
2430 }
2431
2432 /* add block[] to dest[] */
2433 static inline void add_dct(MpegEncContext *s,
2434                            DCTELEM *block, int i, uint8_t *dest, int line_size)
2435 {
2436     if (s->block_last_index[i] >= 0) {
2437         s->dsp.idct_add (dest, line_size, block);
2438     }
2439 }
2440
2441 static inline void add_dequant_dct(MpegEncContext *s,
2442                            DCTELEM *block, int i, uint8_t *dest, int line_size, int qscale)
2443 {
2444     if (s->block_last_index[i] >= 0) {
2445         s->dct_unquantize_inter(s, block, i, qscale);
2446
2447         s->dsp.idct_add (dest, line_size, block);
2448     }
2449 }
2450
2451 /**
2452  * Clean dc, ac, coded_block for the current non-intra MB.
2453  */
2454 void ff_clean_intra_table_entries(MpegEncContext *s)
2455 {
2456     int wrap = s->b8_stride;
2457     int xy = s->block_index[0];
2458
2459     s->dc_val[0][xy           ] =
2460     s->dc_val[0][xy + 1       ] =
2461     s->dc_val[0][xy     + wrap] =
2462     s->dc_val[0][xy + 1 + wrap] = 1024;
2463     /* ac pred */
2464     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
2465     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2466     if (s->msmpeg4_version>=3) {
2467         s->coded_block[xy           ] =
2468         s->coded_block[xy + 1       ] =
2469         s->coded_block[xy     + wrap] =
2470         s->coded_block[xy + 1 + wrap] = 0;
2471     }
2472     /* chroma */
2473     wrap = s->mb_stride;
2474     xy = s->mb_x + s->mb_y * wrap;
2475     s->dc_val[1][xy] =
2476     s->dc_val[2][xy] = 1024;
2477     /* ac pred */
2478     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2479     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2480
2481     s->mbintra_table[xy]= 0;
2482 }
2483
2484 /* generic function called after a macroblock has been parsed by the
2485    decoder or after it has been encoded by the encoder.
2486
2487    Important variables used:
2488    s->mb_intra : true if intra macroblock
2489    s->mv_dir   : motion vector direction
2490    s->mv_type  : motion vector type
2491    s->mv       : motion vector
2492    s->interlaced_dct : true if interlaced dct used (mpeg2)
2493  */
2494 static av_always_inline
2495 void MPV_decode_mb_internal(MpegEncContext *s, DCTELEM block[12][64],
2496                             int lowres_flag, int is_mpeg12)
2497 {
2498     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2499     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2500         ff_xvmc_decode_mb(s);//xvmc uses pblocks
2501         return;
2502     }
2503
2504     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2505        /* save DCT coefficients */
2506        int i,j;
2507        DCTELEM *dct = &s->current_picture.f.dct_coeff[mb_xy * 64 * 6];
2508        av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2509        for(i=0; i<6; i++){
2510            for(j=0; j<64; j++){
2511                *dct++ = block[i][s->dsp.idct_permutation[j]];
2512                av_log(s->avctx, AV_LOG_DEBUG, "%5d", dct[-1]);
2513            }
2514            av_log(s->avctx, AV_LOG_DEBUG, "\n");
2515        }
2516     }
2517
2518     s->current_picture.f.qscale_table[mb_xy] = s->qscale;
2519
2520     /* update DC predictors for P macroblocks */
2521     if (!s->mb_intra) {
2522         if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2523             if(s->mbintra_table[mb_xy])
2524                 ff_clean_intra_table_entries(s);
2525         } else {
2526             s->last_dc[0] =
2527             s->last_dc[1] =
2528             s->last_dc[2] = 128 << s->intra_dc_precision;
2529         }
2530     }
2531     else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2532         s->mbintra_table[mb_xy]=1;
2533
2534     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
2535         uint8_t *dest_y, *dest_cb, *dest_cr;
2536         int dct_linesize, dct_offset;
2537         op_pixels_func (*op_pix)[4];
2538         qpel_mc_func (*op_qpix)[16];
2539         const int linesize   = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2540         const int uvlinesize = s->current_picture.f.linesize[1];
2541         const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
2542         const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
2543
2544         /* avoid copy if macroblock skipped in last frame too */
2545         /* skip only during decoding as we might trash the buffers during encoding a bit */
2546         if(!s->encoding){
2547             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2548
2549             if (s->mb_skipped) {
2550                 s->mb_skipped= 0;
2551                 av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
2552                 *mbskip_ptr = 1;
2553             } else if(!s->current_picture.f.reference) {
2554                 *mbskip_ptr = 1;
2555             } else{
2556                 *mbskip_ptr = 0; /* not skipped */
2557             }
2558         }
2559
2560         dct_linesize = linesize << s->interlaced_dct;
2561         dct_offset   = s->interlaced_dct ? linesize : linesize * block_size;
2562
2563         if(readable){
2564             dest_y=  s->dest[0];
2565             dest_cb= s->dest[1];
2566             dest_cr= s->dest[2];
2567         }else{
2568             dest_y = s->b_scratchpad;
2569             dest_cb= s->b_scratchpad+16*linesize;
2570             dest_cr= s->b_scratchpad+32*linesize;
2571         }
2572
2573         if (!s->mb_intra) {
2574             /* motion handling */
2575             /* decoding or more than one mb_type (MC was already done otherwise) */
2576             if(!s->encoding){
2577
2578                 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2579                     if (s->mv_dir & MV_DIR_FORWARD) {
2580                         ff_thread_await_progress(&s->last_picture_ptr->f,
2581                                                  ff_MPV_lowest_referenced_row(s, 0),
2582                                                  0);
2583                     }
2584                     if (s->mv_dir & MV_DIR_BACKWARD) {
2585                         ff_thread_await_progress(&s->next_picture_ptr->f,
2586                                                  ff_MPV_lowest_referenced_row(s, 1),
2587                                                  0);
2588                     }
2589                 }
2590
2591                 if(lowres_flag){
2592                     h264_chroma_mc_func *op_pix = s->dsp.put_h264_chroma_pixels_tab;
2593
2594                     if (s->mv_dir & MV_DIR_FORWARD) {
2595                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix);
2596                         op_pix = s->dsp.avg_h264_chroma_pixels_tab;
2597                     }
2598                     if (s->mv_dir & MV_DIR_BACKWARD) {
2599                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix);
2600                     }
2601                 }else{
2602                     op_qpix= s->me.qpel_put;
2603                     if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2604                         op_pix = s->dsp.put_pixels_tab;
2605                     }else{
2606                         op_pix = s->dsp.put_no_rnd_pixels_tab;
2607                     }
2608                     if (s->mv_dir & MV_DIR_FORWARD) {
2609                         ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f.data, op_pix, op_qpix);
2610                         op_pix = s->dsp.avg_pixels_tab;
2611                         op_qpix= s->me.qpel_avg;
2612                     }
2613                     if (s->mv_dir & MV_DIR_BACKWARD) {
2614                         ff_MPV_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f.data, op_pix, op_qpix);
2615                     }
2616                 }
2617             }
2618
2619             /* skip dequant / idct if we are really late ;) */
2620             if(s->avctx->skip_idct){
2621                 if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2622                    ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2623                    || s->avctx->skip_idct >= AVDISCARD_ALL)
2624                     goto skip_idct;
2625             }
2626
2627             /* add dct residue */
2628             if(s->encoding || !(   s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
2629                                 || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
2630                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2631                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2632                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2633                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2634
2635                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2636                     if (s->chroma_y_shift){
2637                         add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2638                         add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2639                     }else{
2640                         dct_linesize >>= 1;
2641                         dct_offset >>=1;
2642                         add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2643                         add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2644                         add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2645                         add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2646                     }
2647                 }
2648             } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
2649                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
2650                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
2651                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
2652                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2653
2654                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2655                     if(s->chroma_y_shift){//Chroma420
2656                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
2657                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
2658                     }else{
2659                         //chroma422
2660                         dct_linesize = uvlinesize << s->interlaced_dct;
2661                         dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
2662
2663                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
2664                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
2665                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2666                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2667                         if(!s->chroma_x_shift){//Chroma444
2668                             add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
2669                             add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
2670                             add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
2671                             add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
2672                         }
2673                     }
2674                 }//fi gray
2675             }
2676             else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2677                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2678             }
2679         } else {
2680             /* dct only in intra block */
2681             if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
2682                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2683                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2684                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2685                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2686
2687                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2688                     if(s->chroma_y_shift){
2689                         put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2690                         put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2691                     }else{
2692                         dct_offset >>=1;
2693                         dct_linesize >>=1;
2694                         put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2695                         put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2696                         put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2697                         put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2698                     }
2699                 }
2700             }else{
2701                 s->dsp.idct_put(dest_y                          , dct_linesize, block[0]);
2702                 s->dsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
2703                 s->dsp.idct_put(dest_y + dct_offset             , dct_linesize, block[2]);
2704                 s->dsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2705
2706                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2707                     if(s->chroma_y_shift){
2708                         s->dsp.idct_put(dest_cb, uvlinesize, block[4]);
2709                         s->dsp.idct_put(dest_cr, uvlinesize, block[5]);
2710                     }else{
2711
2712                         dct_linesize = uvlinesize << s->interlaced_dct;
2713                         dct_offset   = s->interlaced_dct? uvlinesize : uvlinesize*block_size;
2714
2715                         s->dsp.idct_put(dest_cb,              dct_linesize, block[4]);
2716                         s->dsp.idct_put(dest_cr,              dct_linesize, block[5]);
2717                         s->dsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2718                         s->dsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2719                         if(!s->chroma_x_shift){//Chroma444
2720                             s->dsp.idct_put(dest_cb + block_size,              dct_linesize, block[8]);
2721                             s->dsp.idct_put(dest_cr + block_size,              dct_linesize, block[9]);
2722                             s->dsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
2723                             s->dsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
2724                         }
2725                     }
2726                 }//gray
2727             }
2728         }
2729 skip_idct:
2730         if(!readable){
2731             s->dsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
2732             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2733             s->dsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2734         }
2735     }
2736 }
2737
2738 void ff_MPV_decode_mb(MpegEncContext *s, DCTELEM block[12][64]){
2739 #if !CONFIG_SMALL
2740     if(s->out_format == FMT_MPEG1) {
2741         if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 1);
2742         else                 MPV_decode_mb_internal(s, block, 0, 1);
2743     } else
2744 #endif
2745     if(s->avctx->lowres) MPV_decode_mb_internal(s, block, 1, 0);
2746     else                  MPV_decode_mb_internal(s, block, 0, 0);
2747 }
2748
2749 /**
2750  * @param h is the normal height, this will be reduced automatically if needed for the last row
2751  */
2752 void ff_draw_horiz_band(MpegEncContext *s, int y, int h){
2753     const int field_pic= s->picture_structure != PICT_FRAME;
2754     if(field_pic){
2755         h <<= 1;
2756         y <<= 1;
2757     }
2758
2759     if (!s->avctx->hwaccel
2760        && !(s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)
2761        && s->unrestricted_mv
2762        && s->current_picture.f.reference
2763        && !s->intra_only
2764        && !(s->flags&CODEC_FLAG_EMU_EDGE)) {
2765         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
2766         int sides = 0, edge_h;
2767         int hshift = desc->log2_chroma_w;
2768         int vshift = desc->log2_chroma_h;
2769         if (y==0) sides |= EDGE_TOP;
2770         if (y + h >= s->v_edge_pos) sides |= EDGE_BOTTOM;
2771
2772         edge_h= FFMIN(h, s->v_edge_pos - y);
2773
2774         s->dsp.draw_edges(s->current_picture_ptr->f.data[0] +  y         *s->linesize,
2775                           s->linesize,           s->h_edge_pos,         edge_h,
2776                           EDGE_WIDTH,            EDGE_WIDTH,            sides);
2777         s->dsp.draw_edges(s->current_picture_ptr->f.data[1] + (y>>vshift)*s->uvlinesize,
2778                           s->uvlinesize,         s->h_edge_pos>>hshift, edge_h>>vshift,
2779                           EDGE_WIDTH>>hshift,    EDGE_WIDTH>>vshift,    sides);
2780         s->dsp.draw_edges(s->current_picture_ptr->f.data[2] + (y>>vshift)*s->uvlinesize,
2781                           s->uvlinesize,         s->h_edge_pos>>hshift, edge_h>>vshift,
2782                           EDGE_WIDTH>>hshift,    EDGE_WIDTH>>vshift,    sides);
2783     }
2784
2785     h= FFMIN(h, s->avctx->height - y);
2786
2787     if(field_pic && s->first_field && !(s->avctx->slice_flags&SLICE_FLAG_ALLOW_FIELD)) return;
2788
2789     if (s->avctx->draw_horiz_band) {
2790         AVFrame *src;
2791         int offset[AV_NUM_DATA_POINTERS];
2792         int i;
2793
2794         if(s->pict_type==AV_PICTURE_TYPE_B || s->low_delay || (s->avctx->slice_flags&SLICE_FLAG_CODED_ORDER))
2795             src = &s->current_picture_ptr->f;
2796         else if(s->last_picture_ptr)
2797             src = &s->last_picture_ptr->f;
2798         else
2799             return;
2800
2801         if(s->pict_type==AV_PICTURE_TYPE_B && s->picture_structure == PICT_FRAME && s->out_format != FMT_H264){
2802             for (i = 0; i < AV_NUM_DATA_POINTERS; i++)
2803                 offset[i] = 0;
2804         }else{
2805             offset[0]= y * s->linesize;
2806             offset[1]=
2807             offset[2]= (y >> s->chroma_y_shift) * s->uvlinesize;
2808             for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
2809                 offset[i] = 0;
2810         }
2811
2812         emms_c();
2813
2814         s->avctx->draw_horiz_band(s->avctx, src, offset,
2815                                   y, s->picture_structure, h);
2816     }
2817 }
2818
2819 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2820     const int linesize   = s->current_picture.f.linesize[0]; //not s->linesize as this would be wrong for field pics
2821     const int uvlinesize = s->current_picture.f.linesize[1];
2822     const int mb_size= 4 - s->avctx->lowres;
2823
2824     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2825     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2826     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2827     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2828     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2829     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;
2830     //block_index is not used by mpeg2, so it is not affected by chroma_format
2831
2832     s->dest[0] = s->current_picture.f.data[0] + ((s->mb_x - 1) <<  mb_size);
2833     s->dest[1] = s->current_picture.f.data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2834     s->dest[2] = s->current_picture.f.data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2835
2836     if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2837     {
2838         if(s->picture_structure==PICT_FRAME){
2839         s->dest[0] += s->mb_y *   linesize << mb_size;
2840         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2841         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2842         }else{
2843             s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
2844             s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2845             s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2846             av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2847         }
2848     }
2849 }
2850
2851 void ff_mpeg_flush(AVCodecContext *avctx){
2852     int i;
2853     MpegEncContext *s = avctx->priv_data;
2854
2855     if(s==NULL || s->picture==NULL)
2856         return;
2857
2858     for(i=0; i<s->picture_count; i++){
2859        if (s->picture[i].f.data[0] &&
2860            (s->picture[i].f.type == FF_BUFFER_TYPE_INTERNAL ||
2861             s->picture[i].f.type == FF_BUFFER_TYPE_USER))
2862         free_frame_buffer(s, &s->picture[i]);
2863     }
2864     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2865
2866     s->mb_x= s->mb_y= 0;
2867     s->closed_gop= 0;
2868
2869     s->parse_context.state= -1;
2870     s->parse_context.frame_start_found= 0;
2871     s->parse_context.overread= 0;
2872     s->parse_context.overread_index= 0;
2873     s->parse_context.index= 0;
2874     s->parse_context.last_index= 0;
2875     s->bitstream_buffer_size=0;
2876     s->pp_time=0;
2877 }
2878
2879 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
2880                                    DCTELEM *block, int n, int qscale)
2881 {
2882     int i, level, nCoeffs;
2883     const uint16_t *quant_matrix;
2884
2885     nCoeffs= s->block_last_index[n];
2886
2887     block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2888     /* XXX: only mpeg1 */
2889     quant_matrix = s->intra_matrix;
2890     for(i=1;i<=nCoeffs;i++) {
2891         int j= s->intra_scantable.permutated[i];
2892         level = block[j];
2893         if (level) {
2894             if (level < 0) {
2895                 level = -level;
2896                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2897                 level = (level - 1) | 1;
2898                 level = -level;
2899             } else {
2900                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2901                 level = (level - 1) | 1;
2902             }
2903             block[j] = level;
2904         }
2905     }
2906 }
2907
2908 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
2909                                    DCTELEM *block, int n, int qscale)
2910 {
2911     int i, level, nCoeffs;
2912     const uint16_t *quant_matrix;
2913
2914     nCoeffs= s->block_last_index[n];
2915
2916     quant_matrix = s->inter_matrix;
2917     for(i=0; i<=nCoeffs; i++) {
2918         int j= s->intra_scantable.permutated[i];
2919         level = block[j];
2920         if (level) {
2921             if (level < 0) {
2922                 level = -level;
2923                 level = (((level << 1) + 1) * qscale *
2924                          ((int) (quant_matrix[j]))) >> 4;
2925                 level = (level - 1) | 1;
2926                 level = -level;
2927             } else {
2928                 level = (((level << 1) + 1) * qscale *
2929                          ((int) (quant_matrix[j]))) >> 4;
2930                 level = (level - 1) | 1;
2931             }
2932             block[j] = level;
2933         }
2934     }
2935 }
2936
2937 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
2938                                    DCTELEM *block, int n, int qscale)
2939 {
2940     int i, level, nCoeffs;
2941     const uint16_t *quant_matrix;
2942
2943     if(s->alternate_scan) nCoeffs= 63;
2944     else nCoeffs= s->block_last_index[n];
2945
2946     block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2947     quant_matrix = s->intra_matrix;
2948     for(i=1;i<=nCoeffs;i++) {
2949         int j= s->intra_scantable.permutated[i];
2950         level = block[j];
2951         if (level) {
2952             if (level < 0) {
2953                 level = -level;
2954                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2955                 level = -level;
2956             } else {
2957                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2958             }
2959             block[j] = level;
2960         }
2961     }
2962 }
2963
2964 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
2965                                    DCTELEM *block, int n, int qscale)
2966 {
2967     int i, level, nCoeffs;
2968     const uint16_t *quant_matrix;
2969     int sum=-1;
2970
2971     if(s->alternate_scan) nCoeffs= 63;
2972     else nCoeffs= s->block_last_index[n];
2973
2974     block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
2975     sum += block[0];
2976     quant_matrix = s->intra_matrix;
2977     for(i=1;i<=nCoeffs;i++) {
2978         int j= s->intra_scantable.permutated[i];
2979         level = block[j];
2980         if (level) {
2981             if (level < 0) {
2982                 level = -level;
2983                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2984                 level = -level;
2985             } else {
2986                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
2987             }
2988             block[j] = level;
2989             sum+=level;
2990         }
2991     }
2992     block[63]^=sum&1;
2993 }
2994
2995 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
2996                                    DCTELEM *block, int n, int qscale)
2997 {
2998     int i, level, nCoeffs;
2999     const uint16_t *quant_matrix;
3000     int sum=-1;
3001
3002     if(s->alternate_scan) nCoeffs= 63;
3003     else nCoeffs= s->block_last_index[n];
3004
3005     quant_matrix = s->inter_matrix;
3006     for(i=0; i<=nCoeffs; i++) {
3007         int j= s->intra_scantable.permutated[i];
3008         level = block[j];
3009         if (level) {
3010             if (level < 0) {
3011                 level = -level;
3012                 level = (((level << 1) + 1) * qscale *
3013                          ((int) (quant_matrix[j]))) >> 4;
3014                 level = -level;
3015             } else {
3016                 level = (((level << 1) + 1) * qscale *
3017                          ((int) (quant_matrix[j]))) >> 4;
3018             }
3019             block[j] = level;
3020             sum+=level;
3021         }
3022     }
3023     block[63]^=sum&1;
3024 }
3025
3026 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
3027                                   DCTELEM *block, int n, int qscale)
3028 {
3029     int i, level, qmul, qadd;
3030     int nCoeffs;
3031
3032     assert(s->block_last_index[n]>=0);
3033
3034     qmul = qscale << 1;
3035
3036     if (!s->h263_aic) {
3037         block[0] *= n < 4 ? s->y_dc_scale : s->c_dc_scale;
3038         qadd = (qscale - 1) | 1;
3039     }else{
3040         qadd = 0;
3041     }
3042     if(s->ac_pred)
3043         nCoeffs=63;
3044     else
3045         nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
3046
3047     for(i=1; i<=nCoeffs; i++) {
3048         level = block[i];
3049         if (level) {
3050             if (level < 0) {
3051                 level = level * qmul - qadd;
3052             } else {
3053                 level = level * qmul + qadd;
3054             }
3055             block[i] = level;
3056         }
3057     }
3058 }
3059
3060 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
3061                                   DCTELEM *block, int n, int qscale)
3062 {
3063     int i, level, qmul, qadd;
3064     int nCoeffs;
3065
3066     assert(s->block_last_index[n]>=0);
3067
3068     qadd = (qscale - 1) | 1;
3069     qmul = qscale << 1;
3070
3071     nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
3072
3073     for(i=0; i<=nCoeffs; i++) {
3074         level = block[i];
3075         if (level) {
3076             if (level < 0) {
3077                 level = level * qmul - qadd;
3078             } else {
3079                 level = level * qmul + qadd;
3080             }
3081             block[i] = level;
3082         }
3083     }
3084 }
3085
3086 /**
3087  * set qscale and update qscale dependent variables.
3088  */
3089 void ff_set_qscale(MpegEncContext * s, int qscale)
3090 {
3091     if (qscale < 1)
3092         qscale = 1;
3093     else if (qscale > 31)
3094         qscale = 31;
3095
3096     s->qscale = qscale;
3097     s->chroma_qscale= s->chroma_qscale_table[qscale];
3098
3099     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
3100     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
3101 }
3102
3103 void ff_MPV_report_decode_progress(MpegEncContext *s)
3104 {
3105     if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->error_occurred)
3106         ff_thread_report_progress(&s->current_picture_ptr->f, s->mb_y, 0);
3107 }