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