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