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