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 HAVE_MMI
 193     ff_MPV_common_init_mmi(s);
 194 #elif ARCH_ARM
 195     ff_MPV_common_init_arm(s);
 196 #elif HAVE_ALTIVEC
 197     ff_MPV_common_init_altivec(s);
 198 #elif ARCH_BFIN
 199     ff_MPV_common_init_bfin(s);
 200 #endif
 201
 202     /* load & permutate scantables
 203      * note: only wmv uses different ones
 204      */
 205     if (s->alternate_scan) {
 206         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_alternate_vertical_scan);
 207         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_alternate_vertical_scan);
 208     } else {
 209         ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable  , ff_zigzag_direct);
 210         ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable  , ff_zigzag_direct);
 211     }
 212     ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
 213     ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
 214
 215     return 0;
 216 }
 217
 218 void ff_copy_picture(Picture *dst, Picture *src)
 219 {
 220     *dst = *src;
 221     dst->f.type = FF_BUFFER_TYPE_COPY;
 222 }
 223
 224 /**
 225  * Release a frame buffer
 226  */
 227 static void free_frame_buffer(MpegEncContext *s, Picture *pic)
 228 {
 229     /* WM Image / Screen codecs allocate internal buffers with different
 230      * dimensions / colorspaces; ignore user-defined callbacks for these. */
 231     if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
 232         s->codec_id != AV_CODEC_ID_VC1IMAGE  &&
 233         s->codec_id != AV_CODEC_ID_MSS2)
 234         ff_thread_release_buffer(s->avctx, &pic->f);
 235     else
 236         avcodec_default_release_buffer(s->avctx, &pic->f);
 237     av_freep(&pic->f.hwaccel_picture_private);
 238 }
 239
 240 /**
 241  * Allocate a frame buffer
 242  */
 243 static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
 244 {
 245     int r;
 246
 247     if (s->avctx->hwaccel) {
 248         assert(!pic->f.hwaccel_picture_private);
 249         if (s->avctx->hwaccel->priv_data_size) {
 250             pic->f.hwaccel_picture_private = av_mallocz(s->avctx->hwaccel->priv_data_size);
 251             if (!pic->f.hwaccel_picture_private) {
 252                 av_log(s->avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
 253                 return -1;
 254             }
 255         }
 256     }
 257
 258     if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
 259         s->codec_id != AV_CODEC_ID_VC1IMAGE  &&
 260         s->codec_id != AV_CODEC_ID_MSS2)
 261         r = ff_thread_get_buffer(s->avctx, &pic->f);
 262     else
 263         r = avcodec_default_get_buffer(s->avctx, &pic->f);
 264
 265     if (r < 0 || !pic->f.type || !pic->f.data[0]) {
 266         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %d %p)\n",
 267                r, pic->f.type, pic->f.data[0]);
 268         av_freep(&pic->f.hwaccel_picture_private);
 269         return -1;
 270     }
 271
 272     if (s->linesize && (s->linesize   != pic->f.linesize[0] ||
 273                         s->uvlinesize != pic->f.linesize[1])) {
 274         av_log(s->avctx, AV_LOG_ERROR,
 275                "get_buffer() failed (stride changed)\n");
 276         free_frame_buffer(s, pic);
 277         return -1;
 278     }
 279
 280     if (pic->f.linesize[1] != pic->f.linesize[2]) {
 281         av_log(s->avctx, AV_LOG_ERROR,
 282                "get_buffer() failed (uv stride mismatch)\n");
 283         free_frame_buffer(s, pic);
 284         return -1;
 285     }
 286
 287     return 0;
 288 }
 289
 290 /**
 291  * Allocate a Picture.
 292  * The pixels are allocated/set by calling get_buffer() if shared = 0
 293  */
 294 int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared)
 295 {
 296     const int big_mb_num = s->mb_stride * (s->mb_height + 1) + 1;
 297
 298     // the + 1 is needed so memset(,,stride*height) does not sig11
 299
 300     const int mb_array_size = s->mb_stride * s->mb_height;
 301     const int b8_array_size = s->b8_stride * s->mb_height * 2;
 302     const int b4_array_size = s->b4_stride * s->mb_height * 4;
 303     int i;
 304     int r = -1;
 305
 306     if (shared) {
 307         assert(pic->f.data[0]);
 308         assert(pic->f.type == 0 || pic->f.type == FF_BUFFER_TYPE_SHARED);
 309         pic->f.type = FF_BUFFER_TYPE_SHARED;
 310     } else {
 311         assert(!pic->f.data[0]);
 312
 313         if (alloc_frame_buffer(s, pic) < 0)
 314             return -1;
 315
 316         s->linesize   = pic->f.linesize[0];
 317         s->uvlinesize = pic->f.linesize[1];
 318     }
 319
 320     if (pic->f.qscale_table == NULL) {
 321         if (s->encoding) {
 322             FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_var,
 323                               mb_array_size * sizeof(int16_t), fail)
 324             FF_ALLOCZ_OR_GOTO(s->avctx, pic->mc_mb_var,
 325                               mb_array_size * sizeof(int16_t), fail)
 326             FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_mean,
 327                               mb_array_size * sizeof(int8_t ), fail)
 328         }
 329
 330         FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.mbskip_table,
 331                           mb_array_size * sizeof(uint8_t) + 2, fail)// the + 2 is for the slice end check
 332         FF_ALLOCZ_OR_GOTO(s->avctx, pic->qscale_table_base,
 333                           (big_mb_num + s->mb_stride) * sizeof(uint8_t),
 334                           fail)
 335         FF_ALLOCZ_OR_GOTO(s->avctx, pic->mb_type_base,
 336                           (big_mb_num + s->mb_stride) * sizeof(uint32_t),
 337                           fail)
 338         pic->f.mb_type = pic->mb_type_base + 2 * s->mb_stride + 1;
 339         pic->f.qscale_table = pic->qscale_table_base + 2 * s->mb_stride + 1;
 340         if (s->out_format == FMT_H264) {
 341             for (i = 0; i < 2; i++) {
 342                 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i],
 343                                   2 * (b4_array_size + 4) * sizeof(int16_t),
 344                                   fail)
 345                 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
 346                 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i],
 347                                   4 * mb_array_size * sizeof(uint8_t), fail)
 348             }
 349             pic->f.motion_subsample_log2 = 2;
 350         } else if (s->out_format == FMT_H263 || s->encoding ||
 351                    (s->avctx->debug & FF_DEBUG_MV) || s->avctx->debug_mv) {
 352             for (i = 0; i < 2; i++) {
 353                 FF_ALLOCZ_OR_GOTO(s->avctx, pic->motion_val_base[i],
 354                                   2 * (b8_array_size + 4) * sizeof(int16_t),
 355                                   fail)
 356                 pic->f.motion_val[i] = pic->motion_val_base[i] + 4;
 357                 FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.ref_index[i],
 358                                   4 * mb_array_size * sizeof(uint8_t), fail)
 359             }
 360             pic->f.motion_subsample_log2 = 3;
 361         }
 362         if (s->avctx->debug&FF_DEBUG_DCT_COEFF) {
 363             FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.dct_coeff,
 364                               64 * mb_array_size * sizeof(DCTELEM) * 6, fail)
 365         }
 366         pic->f.qstride = s->mb_stride;
 367         FF_ALLOCZ_OR_GOTO(s->avctx, pic->f.pan_scan,
 368                           1 * sizeof(AVPanScan), fail)
 369     }
 370
 371     pic->owner2 = s;
 372
 373     return 0;
 374 fail: // for  the FF_ALLOCZ_OR_GOTO macro
 375     if (r >= 0)
 376         free_frame_buffer(s, pic);
 377     return -1;
 378 }
 379
 380 /**
 381  * Deallocate a picture.
 382  */
 383 static void free_picture(MpegEncContext *s, Picture *pic)
 384 {
 385     int i;
 386
 387     if (pic->f.data[0] && pic->f.type != FF_BUFFER_TYPE_SHARED) {
 388         free_frame_buffer(s, pic);
 389     }
 390
 391     av_freep(&pic->mb_var);
 392     av_freep(&pic->mc_mb_var);
 393     av_freep(&pic->mb_mean);
 394     av_freep(&pic->f.mbskip_table);
 395     av_freep(&pic->qscale_table_base);
 396     pic->f.qscale_table = NULL;
 397     av_freep(&pic->mb_type_base);
 398     pic->f.mb_type = NULL;
 399     av_freep(&pic->f.dct_coeff);
 400     av_freep(&pic->f.pan_scan);
 401     pic->f.mb_type = NULL;
 402     for (i = 0; i < 2; i++) {
 403         av_freep(&pic->motion_val_base[i]);
 404         av_freep(&pic->f.ref_index[i]);
 405         pic->f.motion_val[i] = NULL;
 406     }
 407
 408     if (pic->f.type == FF_BUFFER_TYPE_SHARED) {
 409         for (i = 0; i < 4; i++) {
 410             pic->f.base[i] =
 411             pic->f.data[i] = NULL;
 412         }
 413         pic->f.type = 0;
 414     }
 415 }
 416
 417 static int init_duplicate_context(MpegEncContext *s, MpegEncContext *base)
 418 {
 419     int y_size = s->b8_stride * (2 * s->mb_height + 1);
 420     int c_size = s->mb_stride * (s->mb_height + 1);
 421     int yc_size = y_size + 2 * c_size;
 422     int i;
 423
 424     // edge emu needs blocksize + filter length - 1
 425     // (= 17x17 for  halfpel / 21x21 for  h264)
 426     FF_ALLOCZ_OR_GOTO(s->avctx, s->edge_emu_buffer,
 427                       (s->width + 95) * 2 * 21 * 4, fail);    // (width + edge + align)*interlaced*MBsize*tolerance
 428
 429     // FIXME should be linesize instead of s->width * 2
 430     // but that is not known before get_buffer()
 431     FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad,
 432                       (s->width + 95) * 4 * 16 * 2 * sizeof(uint8_t), fail)
 433     s->me.temp         = s->me.scratchpad;
 434     s->rd_scratchpad   = s->me.scratchpad;
 435     s->b_scratchpad    = s->me.scratchpad;
 436     s->obmc_scratchpad = s->me.scratchpad + 16;
 437     if (s->encoding) {
 438         FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map,
 439                           ME_MAP_SIZE * sizeof(uint32_t), fail)
 440         FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map,
 441                           ME_MAP_SIZE * sizeof(uint32_t), fail)
 442         if (s->avctx->noise_reduction) {
 443             FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum,
 444                               2 * 64 * sizeof(int), fail)
 445         }
 446     }
 447     FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64 * 12 * 2 * sizeof(DCTELEM), fail)
 448     s->block = s->blocks[0];
 449
 450     for (i = 0; i < 12; i++) {
 451         s->pblocks[i] = &s->block[i];
 452     }
 453
 454     if (s->out_format == FMT_H263) {
 455         /* ac values */
 456         FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base,
 457                           yc_size * sizeof(int16_t) * 16, fail);
 458         s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
 459         s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
 460         s->ac_val[2] = s->ac_val[1] + c_size;
 461     }
 462
 463     return 0;
 464 fail:
 465     return -1; // free() through ff_MPV_common_end()
 466 }
 467
 468 static void free_duplicate_context(MpegEncContext *s)
 469 {
 470     if (s == NULL)
 471         return;
 472
 473     av_freep(&s->edge_emu_buffer);
 474     av_freep(&s->me.scratchpad);
 475     s->me.temp =
 476     s->rd_scratchpad =
 477     s->b_scratchpad =
 478     s->obmc_scratchpad = NULL;
 479
 480     av_freep(&s->dct_error_sum);
 481     av_freep(&s->me.map);
 482     av_freep(&s->me.score_map);
 483     av_freep(&s->blocks);
 484     av_freep(&s->ac_val_base);
 485     s->block = NULL;
 486 }
 487
 488 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
 489 {
 490 #define COPY(a) bak->a = src->a
 491     COPY(edge_emu_buffer);
 492     COPY(me.scratchpad);
 493     COPY(me.temp);
 494     COPY(rd_scratchpad);
 495     COPY(b_scratchpad);
 496     COPY(obmc_scratchpad);
 497     COPY(me.map);
 498     COPY(me.score_map);
 499     COPY(blocks);
 500     COPY(block);
 501     COPY(start_mb_y);
 502     COPY(end_mb_y);
 503     COPY(me.map_generation);
 504     COPY(pb);
 505     COPY(dct_error_sum);
 506     COPY(dct_count[0]);
 507     COPY(dct_count[1]);
 508     COPY(ac_val_base);
 509     COPY(ac_val[0]);
 510     COPY(ac_val[1]);
 511     COPY(ac_val[2]);
 512 #undef COPY
 513 }
 514
 515 void ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
 516 {
 517     MpegEncContext bak;
 518     int i;
 519     // FIXME copy only needed parts
 520     // START_TIMER
 521     backup_duplicate_context(&bak, dst);
 522     memcpy(dst, src, sizeof(MpegEncContext));
 523     backup_duplicate_context(dst, &bak);
 524     for (i = 0; i < 12; i++) {
 525         dst->pblocks[i] = &dst->block[i];
 526     }
 527     // STOP_TIMER("update_duplicate_context")
 528     // about 10k cycles / 0.01 sec for  1000frames on 1ghz with 2 threads
 529 }
 530
 531 int ff_mpeg_update_thread_context(AVCodecContext *dst,
 532                                   const AVCodecContext *src)
 533 {
 534     int i;
 535     MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
 536
 537     if (dst == src)
 538         return 0;
 539
 540     // FIXME can parameters change on I-frames?
 541     // in that case dst may need a reinit
 542     if (!s->context_initialized) {
 543         memcpy(s, s1, sizeof(MpegEncContext));
 544
 545         s->avctx                 = dst;
 546         s->bitstream_buffer      = NULL;
 547         s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
 548
 549         if (s1->context_initialized){
 550             s->picture_range_start  += MAX_PICTURE_COUNT;
 551             s->picture_range_end    += MAX_PICTURE_COUNT;
 552             ff_MPV_common_init(s);
 553         }
 554     }
 555
 556     if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
 557         int err;
 558         s->context_reinit = 0;
 559         s->height = s1->height;
 560         s->width  = s1->width;
 561         if ((err = ff_MPV_common_frame_size_change(s)) < 0)
 562             return err;
 563     }
 564
 565     s->avctx->coded_height  = s1->avctx->coded_height;
 566     s->avctx->coded_width   = s1->avctx->coded_width;
 567     s->avctx->width         = s1->avctx->width;
 568     s->avctx->height        = s1->avctx->height;
 569
 570     s->coded_picture_number = s1->coded_picture_number;
 571     s->picture_number       = s1->picture_number;
 572     s->input_picture_number = s1->input_picture_number;
 573
 574     memcpy(s->picture, s1->picture, s1->picture_count * sizeof(Picture));
 575     memcpy(&s->last_picture, &s1->last_picture,
 576            (char *) &s1->last_picture_ptr - (char *) &s1->last_picture);
 577
 578     // reset s->picture[].f.extended_data to s->picture[].f.data
 579     for (i = 0; i < s->picture_count; i++)
 580         s->picture[i].f.extended_data = s->picture[i].f.data;
 581
 582     s->last_picture_ptr    = REBASE_PICTURE(s1->last_picture_ptr,    s, s1);
 583     s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
 584     s->next_picture_ptr    = REBASE_PICTURE(s1->next_picture_ptr,    s, s1);
 585
 586     // Error/bug resilience
 587     s->next_p_frame_damaged = s1->next_p_frame_damaged;
 588     s->workaround_bugs      = s1->workaround_bugs;
 589     s->padding_bug_score    = s1->padding_bug_score;
 590
 591     // MPEG4 timing info
 592     memcpy(&s->time_increment_bits, &s1->time_increment_bits,
 593            (char *) &s1->shape - (char *) &s1->time_increment_bits);
 594
 595     // B-frame info
 596     s->max_b_frames = s1->max_b_frames;
 597     s->low_delay    = s1->low_delay;
 598     s->dropable     = s1->dropable;
 599
 600     // DivX handling (doesn't work)
 601     s->divx_packed  = s1->divx_packed;
 602
 603     if (s1->bitstream_buffer) {
 604         if (s1->bitstream_buffer_size +
 605             FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
 606             av_fast_malloc(&s->bitstream_buffer,
 607                            &s->allocated_bitstream_buffer_size,
 608                            s1->allocated_bitstream_buffer_size);
 609             s->bitstream_buffer_size = s1->bitstream_buffer_size;
 610         memcpy(s->bitstream_buffer, s1->bitstream_buffer,
 611                s1->bitstream_buffer_size);
 612         memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
 613                FF_INPUT_BUFFER_PADDING_SIZE);
 614     }
 615
 616     // MPEG2/interlacing info
 617     memcpy(&s->progressive_sequence, &s1->progressive_sequence,
 618            (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
 619
 620     if (!s1->first_field) {
 621         s->last_pict_type = s1->pict_type;
 622         if (s1->current_picture_ptr)
 623             s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f.quality;
 624
 625         if (s1->pict_type != AV_PICTURE_TYPE_B) {
 626             s->last_non_b_pict_type = s1->pict_type;
 627         }
 628     }
 629
 630     return 0;
 631 }
 632
 633 /**
 634  * Set the given MpegEncContext to common defaults
 635  * (same for encoding and decoding).
 636  * The changed fields will not depend upon the
 637  * prior state of the MpegEncContext.
 638  */
 639 void ff_MPV_common_defaults(MpegEncContext *s)
 640 {
 641     s->y_dc_scale_table      =
 642     s->c_dc_scale_table      = ff_mpeg1_dc_scale_table;
 643     s->chroma_qscale_table   = ff_default_chroma_qscale_table;
 644     s->progressive_frame     = 1;
 645     s->progressive_sequence  = 1;
 646     s->picture_structure     = PICT_FRAME;
 647
 648     s->coded_picture_number  = 0;
 649     s->picture_number        = 0;
 650     s->input_picture_number  = 0;
 651
 652     s->picture_in_gop_number = 0;
 653
 654     s->f_code                = 1;
 655     s->b_code                = 1;
 656
 657     s->picture_range_start   = 0;
 658     s->picture_range_end     = MAX_PICTURE_COUNT;
 659
 660     s->slice_context_count   = 1;
 661 }
 662
 663 /**
 664  * Set the given MpegEncContext to defaults for decoding.
 665  * the changed fields will not depend upon
 666  * the prior state of the MpegEncContext.
 667  */
 668 void ff_MPV_decode_defaults(MpegEncContext *s)
 669 {
 670     ff_MPV_common_defaults(s);
 671 }
 672
 673 /**
 674  * Initialize and allocates MpegEncContext fields dependent on the resolution.
 675  */
 676 static int init_context_frame(MpegEncContext *s)
 677 {
 678     int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
 679
 680     s->mb_width   = (s->width + 15) / 16;
 681     s->mb_stride  = s->mb_width + 1;
 682     s->b8_stride  = s->mb_width * 2 + 1;
 683     s->b4_stride  = s->mb_width * 4 + 1;
 684     mb_array_size = s->mb_height * s->mb_stride;
 685     mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
 686
 687     /* set default edge pos, will be overriden
 688      * in decode_header if needed */
 689     s->h_edge_pos = s->mb_width * 16;
 690     s->v_edge_pos = s->mb_height * 16;
 691
 692     s->mb_num     = s->mb_width * s->mb_height;
 693
 694     s->block_wrap[0] =
 695     s->block_wrap[1] =
 696     s->block_wrap[2] =
 697     s->block_wrap[3] = s->b8_stride;
 698     s->block_wrap[4] =
 699     s->block_wrap[5] = s->mb_stride;
 700
 701     y_size  = s->b8_stride * (2 * s->mb_height + 1);
 702     c_size  = s->mb_stride * (s->mb_height + 1);
 703     yc_size = y_size + 2   * c_size;
 704
 705     FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int), fail); // error ressilience code looks cleaner with this
 706     for (y = 0; y < s->mb_height; y++)
 707         for (x = 0; x < s->mb_width; x++)
 708             s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
 709
 710     s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
 711
 712     if (s->encoding) {
 713         /* Allocate MV tables */
 714         FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base,                 mv_table_size * 2 * sizeof(int16_t), fail)
 715         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base,            mv_table_size * 2 * sizeof(int16_t), fail)
 716         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base,            mv_table_size * 2 * sizeof(int16_t), fail)
 717         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base,      mv_table_size * 2 * sizeof(int16_t), fail)
 718         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base,      mv_table_size * 2 * sizeof(int16_t), fail)
 719         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base,          mv_table_size * 2 * sizeof(int16_t), fail)
 720         s->p_mv_table            = s->p_mv_table_base + s->mb_stride + 1;
 721         s->b_forw_mv_table       = s->b_forw_mv_table_base + s->mb_stride + 1;
 722         s->b_back_mv_table       = s->b_back_mv_table_base + s->mb_stride + 1;
 723         s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
 724         s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base + s->mb_stride + 1;
 725         s->b_direct_mv_table     = s->b_direct_mv_table_base + s->mb_stride + 1;
 726
 727         /* Allocate MB type table */
 728         FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size * sizeof(uint16_t), fail) // needed for encoding
 729
 730         FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
 731
 732         FF_ALLOC_OR_GOTO(s->avctx, s->cplx_tab,
 733                          mb_array_size * sizeof(float), fail);
 734         FF_ALLOC_OR_GOTO(s->avctx, s->bits_tab,
 735                          mb_array_size * sizeof(float), fail);
 736
 737     }
 738
 739     FF_ALLOC_OR_GOTO(s->avctx, s->er_temp_buffer,
 740                      mb_array_size * sizeof(uint8_t), fail);
 741     FF_ALLOCZ_OR_GOTO(s->avctx, s->error_status_table,
 742                       mb_array_size * sizeof(uint8_t), fail);
 743
 744     if (s->codec_id == AV_CODEC_ID_MPEG4 || (s->flags & CODEC_FLAG_INTERLACED_ME)) {
 745         /* interlaced direct mode decoding tables */
 746         for (i = 0; i < 2; i++) {
 747             int j, k;
 748             for (j = 0; j < 2; j++) {
 749                 for (k = 0; k < 2; k++) {
 750                     FF_ALLOCZ_OR_GOTO(s->avctx,
 751                                       s->b_field_mv_table_base[i][j][k],
 752                                       mv_table_size * 2 * sizeof(int16_t),
 753                                       fail);
 754                     s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
 755                                                    s->mb_stride + 1;
 756                 }
 757                 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
 758                 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
 759                 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
 760             }
 761             FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
 762         }
 763     }
 764     if (s->out_format == FMT_H263) {
 765         /* cbp values */
 766         FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
 767         s->coded_block = s->coded_block_base + s->b8_stride + 1;
 768
 769         /* cbp, ac_pred, pred_dir */
 770         FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table     , mb_array_size * sizeof(uint8_t), fail);
 771         FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail);
 772     }
 773
 774     if (s->h263_pred || s->h263_plus || !s->encoding) {
 775         /* dc values */
 776         // MN: we need these for  error resilience of intra-frames
 777         FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
 778         s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
 779         s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
 780         s->dc_val[2] = s->dc_val[1] + c_size;
 781         for (i = 0; i < yc_size; i++)
 782             s->dc_val_base[i] = 1024;
 783     }
 784
 785     /* which mb is a intra block */
 786     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
 787     memset(s->mbintra_table, 1, mb_array_size);
 788
 789     /* init macroblock skip table */
 790     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
 791     // Note the + 1 is for  a quicker mpeg4 slice_end detection
 792
 793     return 0;
 794 fail:
 795     return AVERROR(ENOMEM);
 796 }
 797
 798 /**
 799  * init common structure for both encoder and decoder.
 800  * this assumes that some variables like width/height are already set
 801  */
 802 av_cold int ff_MPV_common_init(MpegEncContext *s)
 803 {
 804     int i, err;
 805     int nb_slices = (HAVE_THREADS &&
 806                      s->avctx->active_thread_type & FF_THREAD_SLICE) ?
 807                     s->avctx->thread_count : 1;
 808
 809     if (s->encoding && s->avctx->slices)
 810         nb_slices = s->avctx->slices;
 811
 812     if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
 813         s->mb_height = (s->height + 31) / 32 * 2;
 814     else if (s->codec_id != AV_CODEC_ID_H264)
 815         s->mb_height = (s->height + 15) / 16;
 816
 817     if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
 818         av_log(s->avctx, AV_LOG_ERROR,
 819                "decoding to AV_PIX_FMT_NONE is not supported.\n");
 820         return -1;
 821     }
 822
 823     if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
 824         int max_slices;
 825         if (s->mb_height)
 826             max_slices = FFMIN(MAX_THREADS, s->mb_height);
 827         else
 828             max_slices = MAX_THREADS;
 829         av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
 830                " reducing to %d\n", nb_slices, max_slices);
 831         nb_slices = max_slices;
 832     }
 833
 834     if ((s->width || s->height) &&
 835         av_image_check_size(s->width, s->height, 0, s->avctx))
 836         return -1;
 837
 838     ff_dct_common_init(s);
 839
 840     s->flags  = s->avctx->flags;
 841     s->flags2 = s->avctx->flags2;
 842
 843         /* set chroma shifts */
 844         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt, &s->chroma_x_shift,
 845                                       &s->chroma_y_shift);
 846
 847     /* convert fourcc to upper case */
 848     s->codec_tag        = avpriv_toupper4(s->avctx->codec_tag);
 849     s->stream_codec_tag = avpriv_toupper4(s->avctx->stream_codec_tag);
 850
 851     s->avctx->coded_frame = &s->current_picture.f;
 852
 853     if (s->encoding) {
 854         if (s->msmpeg4_version) {
 855             FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_stats,
 856                                 2 * 2 * (MAX_LEVEL + 1) *
 857                                 (MAX_RUN + 1) * 2 * sizeof(int), fail);
 858         }
 859         FF_ALLOCZ_OR_GOTO(s->avctx, s->avctx->stats_out, 256, fail);
 860
 861         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix,          64 * 32   * sizeof(int), fail)
 862         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix,   64 * 32   * sizeof(int), fail)
 863         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix,          64 * 32   * sizeof(int), fail)
 864         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_intra_matrix16,        64 * 32 * 2 * sizeof(uint16_t), fail)
 865         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_chroma_intra_matrix16, 64 * 32 * 2 * sizeof(uint16_t), fail)
 866         FF_ALLOCZ_OR_GOTO(s->avctx, s->q_inter_matrix16,        64 * 32 * 2 * sizeof(uint16_t), fail)
 867         FF_ALLOCZ_OR_GOTO(s->avctx, s->input_picture,           MAX_PICTURE_COUNT * sizeof(Picture *), fail)
 868         FF_ALLOCZ_OR_GOTO(s->avctx, s->reordered_input_picture, MAX_PICTURE_COUNT * sizeof(Picture *), fail)
 869
 870         if (s->avctx->noise_reduction) {
 871             FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_offset, 2 * 64 * sizeof(uint16_t), fail);
 872         }
 873     }
 874
 875     s->picture_count = MAX_PICTURE_COUNT * FFMAX(1, s->avctx->thread_count);
 876     FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
 877                       s->picture_count * sizeof(Picture), fail);
 878     for (i = 0; i < s->picture_count; i++) {
 879         avcodec_get_frame_defaults(&s->picture[i].f);
 880     }
 881
 882         if ((err = init_context_frame(s)))
 883             goto fail;
 884
 885         s->parse_context.state = -1;
 886
 887         s->context_initialized = 1;
 888         s->thread_context[0]   = s;
 889
 890 //     if (s->width && s->height) {
 891         if (nb_slices > 1) {
 892             for (i = 1; i < nb_slices; i++) {
 893                 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
 894                 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
 895             }
 896
 897             for (i = 0; i < nb_slices; i++) {
 898                 if (init_duplicate_context(s->thread_context[i], s) < 0)
 899                     goto fail;
 900                     s->thread_context[i]->start_mb_y =
 901                         (s->mb_height * (i) + nb_slices / 2) / nb_slices;
 902                     s->thread_context[i]->end_mb_y   =
 903                         (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
 904             }
 905         } else {
 906             if (init_duplicate_context(s, s) < 0)
 907                 goto fail;
 908             s->start_mb_y = 0;
 909             s->end_mb_y   = s->mb_height;
 910         }
 911         s->slice_context_count = nb_slices;
 912 //     }
 913
 914     return 0;
 915  fail:
 916     ff_MPV_common_end(s);
 917     return -1;
 918 }
 919
 920 /**
 921  * Frees and resets MpegEncContext fields depending on the resolution.
 922  * Is used during resolution changes to avoid a full reinitialization of the
 923  * codec.
 924  */
 925 static int free_context_frame(MpegEncContext *s)
 926 {
 927     int i, j, k;
 928
 929     av_freep(&s->mb_type);
 930     av_freep(&s->p_mv_table_base);
 931     av_freep(&s->b_forw_mv_table_base);
 932     av_freep(&s->b_back_mv_table_base);
 933     av_freep(&s->b_bidir_forw_mv_table_base);
 934     av_freep(&s->b_bidir_back_mv_table_base);
 935     av_freep(&s->b_direct_mv_table_base);
 936     s->p_mv_table            = NULL;
 937     s->b_forw_mv_table       = NULL;
 938     s->b_back_mv_table       = NULL;
 939     s->b_bidir_forw_mv_table = NULL;
 940     s->b_bidir_back_mv_table = NULL;
 941     s->b_direct_mv_table     = NULL;
 942     for (i = 0; i < 2; i++) {
 943         for (j = 0; j < 2; j++) {
 944             for (k = 0; k < 2; k++) {
 945                 av_freep(&s->b_field_mv_table_base[i][j][k]);
 946                 s->b_field_mv_table[i][j][k] = NULL;
 947             }
 948             av_freep(&s->b_field_select_table[i][j]);
 949             av_freep(&s->p_field_mv_table_base[i][j]);
 950             s->p_field_mv_table[i][j] = NULL;
 951         }
 952         av_freep(&s->p_field_select_table[i]);
 953     }
 954
 955     av_freep(&s->dc_val_base);
 956     av_freep(&s->coded_block_base);
 957     av_freep(&s->mbintra_table);
 958     av_freep(&s->cbp_table);
 959     av_freep(&s->pred_dir_table);
 960
 961     av_freep(&s->mbskip_table);
 962
 963     av_freep(&s->error_status_table);
 964     av_freep(&s->er_temp_buffer);
 965     av_freep(&s->mb_index2xy);
 966     av_freep(&s->lambda_table);
 967
 968     av_freep(&s->cplx_tab);
 969     av_freep(&s->bits_tab);
 970
 971     s->linesize = s->uvlinesize = 0;
 972
 973     for (i = 0; i < 3; i++)
 974         av_freep(&s->visualization_buffer[i]);
 975
 976     if (!(s->avctx->active_thread_type & FF_THREAD_FRAME))
 977         avcodec_default_free_buffers(s->avctx);
 978
 979     return 0;
 980 }
 981
 982 int ff_MPV_common_frame_size_change(MpegEncContext *s)
 983 {
 984     int i, err = 0;
 985
 986     if (s->slice_context_count > 1) {
 987         for (i = 0; i < s->slice_context_count; i++) {
 988             free_duplicate_context(s->thread_context[i]);
 989         }
 990         for (i = 1; i < s->slice_context_count; i++) {
 991             av_freep(&s->thread_context[i]);
 992         }
 993     } else
 994         free_duplicate_context(s);
 995
 996     free_context_frame(s);
 997
 998     if (s->picture)
 999         for (i = 0; i < s->picture_count; i++) {
1000                 s->picture[i].needs_realloc = 1;
1001         }
1002
1003     s->last_picture_ptr         =
1004     s->next_picture_ptr         =
1005     s->current_picture_ptr      = NULL;
1006
1007     // init
1008     if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1009         s->mb_height = (s->height + 31) / 32 * 2;
1010     else if (s->codec_id != AV_CODEC_ID_H264)
1011         s->mb_height = (s->height + 15) / 16;
1012
1013     if ((s->width || s->height) &&
1014         av_image_check_size(s->width, s->height, 0, s->avctx))
1015         return AVERROR_INVALIDDATA;
1016
1017     if ((err = init_context_frame(s)))
1018         goto fail;
1019
1020     s->thread_context[0]   = s;
1021
1022     if (s->width && s->height) {
1023         int nb_slices = s->slice_context_count;
1024         if (nb_slices > 1) {
1025             for (i = 1; i < nb_slices; i++) {
1026                 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1027                 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1028             }
1029
1030             for (i = 0; i < nb_slices; i++) {
1031                 if (init_duplicate_context(s->thread_context[i], s) < 0)
1032                     goto fail;
1033                     s->thread_context[i]->start_mb_y =
1034                         (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1035                     s->thread_context[i]->end_mb_y   =
1036                         (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1037             }
1038         } else {
1039             if (init_duplicate_context(s, s) < 0)
1040                 goto fail;
1041             s->start_mb_y = 0;
1042             s->end_mb_y   = s->mb_height;
1043         }
1044         s->slice_context_count = nb_slices;
1045     }
1046
1047     return 0;
1048  fail:
1049     ff_MPV_common_end(s);
1050     return err;
1051 }
1052
1053 /* init common structure for both encoder and decoder */
1054 void ff_MPV_common_end(MpegEncContext *s)
1055 {
1056     int i;
1057
1058     if (s->slice_context_count > 1) {
1059         for (i = 0; i < s->slice_context_count; i++) {
1060             free_duplicate_context(s->thread_context[i]);
1061         }
1062         for (i = 1; i < s->slice_context_count; i++) {
1063             av_freep(&s->thread_context[i]);
1064         }
1065         s->slice_context_count = 1;
1066     } else free_duplicate_context(s);
1067
1068     av_freep(&s->parse_context.buffer);
1069     s->parse_context.buffer_size = 0;
1070
1071     av_freep(&s->bitstream_buffer);
1072     s->allocated_bitstream_buffer_size = 0;
1073
1074     av_freep(&s->avctx->stats_out);
1075     av_freep(&s->ac_stats);
1076
1077     if(s->q_chroma_intra_matrix   != s->q_intra_matrix  ) av_freep(&s->q_chroma_intra_matrix);
1078     if(s->q_chroma_intra_matrix16 != s->q_intra_matrix16) av_freep(&s->q_chroma_intra_matrix16);
1079     s->q_chroma_intra_matrix=   NULL;
1080     s->q_chroma_intra_matrix16= NULL;
1081     av_freep(&s->q_intra_matrix);
1082     av_freep(&s->q_inter_matrix);
1083     av_freep(&s->q_intra_matrix16);
1084     av_freep(&s->q_inter_matrix16);
1085     av_freep(&s->input_picture);
1086     av_freep(&s->reordered_input_picture);
1087     av_freep(&s->dct_offset);
1088
1089     if (s->picture && !s->avctx->internal->is_copy) {
1090         for (i = 0; i < s->picture_count; i++) {
1091             free_picture(s, &s->picture[i]);
1092         }
1093     }
1094     av_freep(&s->picture);
1095
1096     free_context_frame(s);
1097
1098     s->context_initialized      = 0;
1099     s->last_picture_ptr         =
1100     s->next_picture_ptr         =
1101     s->current_picture_ptr      = NULL;
1102     s->linesize = s->uvlinesize = 0;
1103 }
1104
1105 void ff_init_rl(RLTable *rl,
1106                 uint8_t static_store[2][2 * MAX_RUN + MAX_LEVEL + 3])
1107 {
1108     int8_t  max_level[MAX_RUN + 1], max_run[MAX_LEVEL + 1];
1109     uint8_t index_run[MAX_RUN + 1];
1110     int last, run, level, start, end, i;
1111
1112     /* If table is static, we can quit if rl->max_level[0] is not NULL */
1113     if (static_store && rl->max_level[0])
1114         return;
1115
1116     /* compute max_level[], max_run[] and index_run[] */
1117     for (last = 0; last < 2; last++) {
1118         if (last == 0) {
1119             start = 0;
1120             end = rl->last;
1121         } else {
1122             start = rl->last;
1123             end = rl->n;
1124         }
1125
1126         memset(max_level, 0, MAX_RUN + 1);
1127         memset(max_run, 0, MAX_LEVEL + 1);
1128         memset(index_run, rl->n, MAX_RUN + 1);
1129         for (i = start; i < end; i++) {
1130             run   = rl->table_run[i];
1131             level = rl->table_level[i];
1132             if (index_run[run] == rl->n)
1133                 index_run[run] = i;
1134             if (level > max_level[run])
1135                 max_level[run] = level;
1136             if (run > max_run[level])
1137                 max_run[level] = run;
1138         }
1139         if (static_store)
1140             rl->max_level[last] = static_store[last];
1141         else
1142             rl->max_level[last] = av_malloc(MAX_RUN + 1);
1143         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1144         if (static_store)
1145             rl->max_run[last]   = static_store[last] + MAX_RUN + 1;
1146         else
1147             rl->max_run[last]   = av_malloc(MAX_LEVEL + 1);
1148         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1149         if (static_store)
1150             rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
1151         else
1152             rl->index_run[last] = av_malloc(MAX_RUN + 1);
1153         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1154     }
1155 }
1156
1157 void ff_init_vlc_rl(RLTable *rl)
1158 {
1159     int i, q;
1160
1161     for (q = 0; q < 32; q++) {
1162         int qmul = q * 2;
1163         int qadd = (q - 1) | 1;
1164
1165         if (q == 0) {
1166             qmul = 1;
1167             qadd = 0;
1168         }
1169         for (i = 0; i < rl->vlc.table_size; i++) {
1170             int code = rl->vlc.table[i][0];
1171             int len  = rl->vlc.table[i][1];
1172             int level, run;
1173
1174             if (len == 0) { // illegal code
1175                 run   = 66;
1176                 level = MAX_LEVEL;
1177             } else if (len < 0) { // more bits needed
1178                 run   = 0;
1179                 level = code;
1180             } else {
1181                 if (code == rl->n) { // esc
1182                     run   = 66;
1183                     level =  0;
1184                 } else {
1185                     run   = rl->table_run[code] + 1;
1186                     level = rl->table_level[code] * qmul + qadd;
1187                     if (code >= rl->last) run += 192;
1188                 }
1189             }
1190             rl->rl_vlc[q][i].len   = len;
1191             rl->rl_vlc[q][i].level = level;
1192             rl->rl_vlc[q][i].run   = run;
1193         }
1194     }
1195 }
1196
1197 void ff_release_unused_pictures(MpegEncContext*s, int remove_current)
1198 {
1199     int i;
1200
1201     /* release non reference frames */
1202     for (i = 0; i < s->picture_count; i++) {
1203         if (s->picture[i].f.data[0] && !s->picture[i].f.reference &&
1204             (!s->picture[i].owner2 || s->picture[i].owner2 == s) &&
1205             (remove_current || &s->picture[i] !=  s->current_picture_ptr)
1206             /* && s->picture[i].type!= FF_BUFFER_TYPE_SHARED */) {
1207             free_frame_buffer(s, &s->picture[i]);
1208         }
1209     }
1210 }
1211
1212 static inline int pic_is_unused(MpegEncContext *s, Picture *pic)
1213 {
1214     if (pic->f.data[0] == NULL)
1215         return 1;
1216     if (pic->needs_realloc)
1217         if (!pic->owner2 || pic->owner2 == s)
1218             return 1;
1219     return 0;
1220 }
1221
1222 static int find_unused_picture(MpegEncContext *s, int shared)
1223 {
1224     int i;
1225
1226     if (shared) {
1227         for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1228             if (s->picture[i].f.data[0] == NULL && s->picture[i].f.type == 0)
1229                 return i;
1230         }
1231     } else {
1232         for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1233             if (pic_is_unused(s, &s->picture[i]) && s->picture[i].f.type != 0)
1234                 return i; // FIXME
1235         }
1236         for (i = s->picture_range_start; i < s->picture_range_end; i++) {
1237             if (pic_is_unused(s, &s->picture[i]))
1238                 return i;
1239         }
1240     }
1241
1242     av_log(s->avctx, AV_LOG_FATAL,
1243            "Internal error, picture buffer overflow\n");
1244     /* We could return -1, but the codec would crash trying to draw into a
1245      * non-existing frame anyway. This is safer than waiting for a random crash.
1246      * Also the return of this is never useful, an encoder must only allocate
1247      * as much as allowed in the specification. This has no relationship to how
1248      * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
1249      * enough for such valid streams).
1250      * Plus, a decoder has to check stream validity and remove frames if too
1251      * many reference frames are around. Waiting for "OOM" is not correct at
1252      * all. Similarly, missing reference frames have to be replaced by
1253      * interpolated/MC frames, anything else is a bug in the codec ...
1254      */
1255     abort();
1256     return -1;
1257 }
1258
1259 int ff_find_unused_picture(MpegEncContext *s, int shared)
1260 {
1261     int ret = find_unused_picture(s, shared);
1262
1263     if (ret >= 0 && ret < s->picture_range_end) {
1264         if (s->picture[ret].needs_realloc) {
1265             s->picture[ret].needs_realloc = 0;
1266             free_picture(s, &s->picture[ret]);
1267             avcodec_get_frame_defaults(&s->picture[ret].f);
1268         }
1269     }
1270     return ret;
1271 }
1272
1273 static void update_noise_reduction(MpegEncContext *s)
1274 {
1275     int intra, i;
1276
1277     for (intra = 0; intra < 2; intra++) {
1278         if (s->dct_count[intra] > (1 << 16)) {
1279             for (i = 0; i < 64; i++) {
1280                 s->dct_error_sum[intra][i] >>= 1;
1281             }
1282             s->dct_count[intra] >>= 1;
1283         }
1284
1285         for (i = 0; i < 64; i++) {
1286             s->dct_offset[intra][i] = (s->avctx->noise_reduction *
1287                                        s->dct_count[intra] +
1288                                        s->dct_error_sum[intra][i] / 2) /
1289                                       (s->dct_error_sum[intra][i] + 1);
1290         }
1291     }
1292 }
1293
1294 /**
1295  * generic function for encode/decode called after coding/decoding
1296  * the header and before a frame is coded/decoded.
1297  */
1298 int ff_MPV_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1299 {
1300     int i;
1301     Picture *pic;
1302     s->mb_skipped = 0;
1303
1304     if (!ff_thread_can_start_frame(avctx)) {
1305         av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
1306         return -1;
1307     }
1308
1309     /* mark & release old frames */
1310     if (s->out_format != FMT_H264 || s->codec_id == AV_CODEC_ID_SVQ3) {
1311         if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1312             s->last_picture_ptr != s->next_picture_ptr &&
1313             s->last_picture_ptr->f.data[0]) {
1314             if (s->last_picture_ptr->owner2 == s)
1315                 free_frame_buffer(s, s->last_picture_ptr);
1316         }
1317
1318         /* release forgotten pictures */
1319         /* if (mpeg124/h263) */
1320         if (!s->encoding) {
1321             for (i = 0; i < s->picture_count; i++) {
1322                 if (s->picture[i].owner2 == s && s->picture[i].f.data[0] &&
1323                     &s->picture[i] != s->last_picture_ptr &&
1324                     &s->picture[i] != s->next_picture_ptr &&
1325                     s->picture[i].f.reference && !s->picture[i].needs_realloc) {
1326                     if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1327                         av_log(avctx, AV_LOG_ERROR,
1328                                "releasing zombie picture\n");
1329                     free_frame_buffer(s, &s->picture[i]);
1330                 }
1331             }
1332         }
1333     }
1334
1335     if (!s->encoding) {
1336         ff_release_unused_pictures(s, 1);
1337
1338         if (s->current_picture_ptr &&
1339             s->current_picture_ptr->f.data[0] == NULL) {
1340             // we already have a unused image
1341             // (maybe it was set before reading the header)
1342             pic = s->current_picture_ptr;
1343         } else {
1344             i   = ff_find_unused_picture(s, 0);
1345             if (i < 0) {
1346                 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1347                 return i;
1348             }
1349             pic = &s->picture[i];
1350         }
1351
1352         pic->f.reference = 0;
1353         if (!s->dropable) {
1354             if (s->codec_id == AV_CODEC_ID_H264)
1355                 pic->f.reference = s->picture_structure;
1356             else if (s->pict_type != AV_PICTURE_TYPE_B)
1357                 pic->f.reference = 3;
1358         }
1359
1360         pic->f.coded_picture_number = s->coded_picture_number++;
1361
1362         if (ff_alloc_picture(s, pic, 0) < 0)
1363             return -1;
1364
1365         s->current_picture_ptr = pic;
1366         // FIXME use only the vars from current_pic
1367         s->current_picture_ptr->f.top_field_first = s->top_field_first;
1368         if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1369             s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1370             if (s->picture_structure != PICT_FRAME)
1371                 s->current_picture_ptr->f.top_field_first =
1372                     (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1373         }
1374         s->current_picture_ptr->f.interlaced_frame = !s->progressive_frame &&
1375                                                      !s->progressive_sequence;
1376         s->current_picture_ptr->field_picture      =  s->picture_structure != PICT_FRAME;
1377     }
1378
1379     s->current_picture_ptr->f.pict_type = s->pict_type;
1380     // if (s->flags && CODEC_FLAG_QSCALE)
1381     //     s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1382     s->current_picture_ptr->f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1383
1384     ff_copy_picture(&s->current_picture, s->current_picture_ptr);
1385
1386     if (s->pict_type != AV_PICTURE_TYPE_B) {
1387         s->last_picture_ptr = s->next_picture_ptr;
1388         if (!s->dropable)
1389             s->next_picture_ptr = s->current_picture_ptr;
1390     }
1391     av_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1392             s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1393             s->last_picture_ptr    ? s->last_picture_ptr->f.data[0]    : NULL,
1394             s->next_picture_ptr    ? s->next_picture_ptr->f.data[0]    : NULL,
1395             s->current_picture_ptr ? s->current_picture_ptr->f.data[0] : NULL,
1396             s->pict_type, s->dropable);
1397
1398     if (s->codec_id != AV_CODEC_ID_H264) {
1399         if ((s->last_picture_ptr == NULL ||
1400              s->last_picture_ptr->f.data[0] == NULL) &&
1401             (s->pict_type != AV_PICTURE_TYPE_I ||
1402              s->picture_structure != PICT_FRAME)) {
1403             if (s->pict_type != AV_PICTURE_TYPE_I)
1404                 av_log(avctx, AV_LOG_ERROR,
1405                        "warning: first frame is no keyframe\n");
1406             else if (s->picture_structure != PICT_FRAME)
1407                 av_log(avctx, AV_LOG_INFO,
1408                        "allocate dummy last picture for field based first keyframe\n");
1409
1410             /* Allocate a dummy frame */
1411             i = ff_find_unused_picture(s, 0);
1412             if (i < 0) {
1413                 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1414                 return i;
1415             }
1416             s->last_picture_ptr = &s->picture[i];
1417             s->last_picture_ptr->f.key_frame = 0;
1418             if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1419                 s->last_picture_ptr = NULL;
1420                 return -1;
1421             }
1422
1423             if(s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263){
1424                 for(i=0; i<avctx->height; i++)
1425                     memset(s->last_picture_ptr->f.data[0] + s->last_picture_ptr->f.linesize[0]*i, 16, avctx->width);
1426             }
1427
1428             ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 0);
1429             ff_thread_report_progress(&s->last_picture_ptr->f, INT_MAX, 1);
1430             s->last_picture_ptr->f.reference = 3;
1431         }
1432         if ((s->next_picture_ptr == NULL ||
1433              s->next_picture_ptr->f.data[0] == NULL) &&
1434             s->pict_type == AV_PICTURE_TYPE_B) {
1435             /* Allocate a dummy frame */
1436             i = ff_find_unused_picture(s, 0);
1437             if (i < 0) {
1438                 av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1439                 return i;
1440             }
1441             s->next_picture_ptr = &s->picture[i];
1442             s->next_picture_ptr->f.key_frame = 0;
1443             if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1444                 s->next_picture_ptr = NULL;
1445                 return -1;
1446             }
1447             ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 0);
1448             ff_thread_report_progress(&s->next_picture_ptr->f, INT_MAX, 1);
1449             s->next_picture_ptr->f.reference = 3;
1450         }
1451     }
1452
1453     if (s->last_picture_ptr)
1454         ff_copy_picture(&s->last_picture, s->last_picture_ptr);
1455     if (s->next_picture_ptr)
1456         ff_copy_picture(&s->next_picture, s->next_picture_ptr);
1457
1458     if (HAVE_THREADS && (avctx->active_thread_type & FF_THREAD_FRAME) &&
1459         (s->out_format != FMT_H264 || s->codec_id == AV_CODEC_ID_SVQ3)) {
1460         if (s->next_picture_ptr)
1461             s->next_picture_ptr->owner2 = s;
1462         if (s->last_picture_ptr)
1463             s->last_picture_ptr->owner2 = s;
1464     }
1465
1466     assert(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1467                                                  s->last_picture_ptr->f.data[0]));
1468
1469     if (s->picture_structure!= PICT_FRAME && s->out_format != FMT_H264) {
1470         int i;
1471         for (i = 0; i < 4; i++) {
1472             if (s->picture_structure == PICT_BOTTOM_FIELD) {
1473                 s->current_picture.f.data[i] +=
1474                     s->current_picture.f.linesize[i];
1475             }
1476             s->current_picture.f.linesize[i] *= 2;
1477             s->last_picture.f.linesize[i]    *= 2;
1478             s->next_picture.f.linesize[i]    *= 2;
1479         }
1480     }
1481
1482     s->err_recognition = avctx->err_recognition;
1483
1484     /* set dequantizer, we can't do it during init as
1485      * it might change for mpeg4 and we can't do it in the header
1486      * decode as init is not called for mpeg4 there yet */
1487     if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1488         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1489         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1490     } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1491         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1492         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1493     } else {
1494         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1495         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1496     }
1497
1498     if (s->dct_error_sum) {
1499         assert(s->avctx->noise_reduction && s->encoding);
1500         update_noise_reduction(s);
1501     }
1502
1503     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1504         return ff_xvmc_field_start(s, avctx);
1505
1506     return 0;
1507 }
1508
1509 /* generic function for encode/decode called after a
1510  * frame has been coded/decoded. */
1511 void ff_MPV_frame_end(MpegEncContext *s)
1512 {
1513     int i;
1514     /* redraw edges for the frame if decoding didn't complete */
1515     // just to make sure that all data is rendered.
1516     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
1517         ff_xvmc_field_end(s);
1518    } else if((s->error_count || s->encoding || !(s->avctx->codec->capabilities&CODEC_CAP_DRAW_HORIZ_BAND)) &&
1519               !s->avctx->hwaccel &&
1520               !(s->avctx->codec->capabilities & CODEC_CAP_HWACCEL_VDPAU) &&
1521               s->unrestricted_mv &&
1522               s->current_picture.f.reference &&
1523               !s->intra_only &&
1524               !(s->flags & CODEC_FLAG_EMU_EDGE) &&
1525               !s->avctx->lowres
1526             ) {
1527         const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(s->avctx->pix_fmt);
1528         int hshift = desc->log2_chroma_w;
1529         int vshift = desc->log2_chroma_h;
1530         s->dsp.draw_edges(s->current_picture.f.data[0], s->current_picture.f.linesize[0],
1531                           s->h_edge_pos, s->v_edge_pos,
1532                           EDGE_WIDTH, EDGE_WIDTH,
1533                           EDGE_TOP | EDGE_BOTTOM);
1534         s->dsp.draw_edges(s->current_picture.f.data[1], s->current_picture.f.linesize[1],
1535                           s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1536                           EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1537                           EDGE_TOP | EDGE_BOTTOM);
1538         s->dsp.draw_edges(s->current_picture.f.data[2], s->current_picture.f.linesize[2],
1539                           s->h_edge_pos >> hshift, s->v_edge_pos >> vshift,
1540                           EDGE_WIDTH >> hshift, EDGE_WIDTH >> vshift,
1541                           EDGE_TOP | EDGE_BOTTOM);
1542     }
1543
1544     emms_c();
1545
1546     s->last_pict_type                 = s->pict_type;
1547     s->last_lambda_for [s->pict_type] = s->current_picture_ptr->f.quality;
1548     if (s->pict_type!= AV_PICTURE_TYPE_B) {
1549         s->last_non_b_pict_type = s->pict_type;
1550     }
1551 #if 0
1552     /* copy back current_picture variables */
1553     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1554         if (s->picture[i].f.data[0] == s->current_picture.f.data[0]) {
1555             s->picture[i] = s->current_picture;
1556             break;
1557         }
1558     }
1559     assert(i < MAX_PICTURE_COUNT);
1560 #endif
1561
1562     if (s->encoding) {
1563         /* release non-reference frames */
1564         for (i = 0; i < s->picture_count; i++) {
1565             if (s->picture[i].f.data[0] && !s->picture[i].f.reference
1566                 /* && s->picture[i].type != FF_BUFFER_TYPE_SHARED */) {
1567                 free_frame_buffer(s, &s->picture[i]);
1568             }
1569         }
1570     }
1571     // clear copies, to avoid confusion
1572 #if 0
1573     memset(&s->last_picture,    0, sizeof(Picture));
1574     memset(&s->next_picture,    0, sizeof(Picture));
1575     memset(&s->current_picture, 0, sizeof(Picture));
1576 #endif
1577     s->avctx->coded_frame = &s->current_picture_ptr->f;
1578
1579     if (s->codec_id != AV_CODEC_ID_H264 && s->current_picture.f.reference) {
1580         ff_thread_report_progress(&s->current_picture_ptr->f, INT_MAX, 0);
1581     }
1582 }
1583
1584 /**
1585  * Draw a line from (ex, ey) -> (sx, sy).
1586  * @param w width of the image
1587  * @param h height of the image
1588  * @param stride stride/linesize of the image
1589  * @param color color of the arrow
1590  */
1591 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
1592                       int w, int h, int stride, int color)
1593 {
1594     int x, y, fr, f;
1595
1596     sx = av_clip(sx, 0, w - 1);
1597     sy = av_clip(sy, 0, h - 1);
1598     ex = av_clip(ex, 0, w - 1);
1599     ey = av_clip(ey, 0, h - 1);
1600
1601     buf[sy * stride + sx] += color;
1602
1603     if (FFABS(ex - sx) > FFABS(ey - sy)) {
1604         if (sx > ex) {
1605             FFSWAP(int, sx, ex);
1606             FFSWAP(int, sy, ey);
1607         }
1608         buf += sx + sy * stride;
1609         ex  -= sx;
1610         f    = ((ey - sy) << 16) / ex;
1611         for(x= 0; x <= ex; x++){
1612             y  = (x * f) >> 16;
1613             fr = (x * f) & 0xFFFF;
1614             buf[y * stride + x]       += (color * (0x10000 - fr)) >> 16;
1615             if(fr) buf[(y + 1) * stride + x] += (color *            fr ) >> 16;
1616         }
1617     } else {
1618         if (sy > ey) {
1619             FFSWAP(int, sx, ex);
1620             FFSWAP(int, sy, ey);
1621         }
1622         buf += sx + sy * stride;
1623         ey  -= sy;
1624         if (ey)
1625             f = ((ex - sx) << 16) / ey;
1626         else
1627             f = 0;
1628         for(y= 0; y <= ey; y++){
1629             x  = (y*f) >> 16;
1630             fr = (y*f) & 0xFFFF;
1631             buf[y * stride + x]     += (color * (0x10000 - fr)) >> 16;
1632             if(fr) buf[y * stride + x + 1] += (color *            fr ) >> 16;
1633         }
1634     }
1635 }
1636
1637 /**
1638  * Draw an arrow from (ex, ey) -> (sx, sy).
1639  * @param w width of the image
1640  * @param h height of the image
1641  * @param stride stride/linesize of the image
1642  * @param color color of the arrow
1643  */
1644 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
1645                        int ey, int w, int h, int stride, int color)
1646 {
1647     int dx,dy;
1648
1649     sx = av_clip(sx, -100, w + 100);
1650     sy = av_clip(sy, -100, h + 100);
1651     ex = av_clip(ex, -100, w + 100);
1652     ey = av_clip(ey, -100, h + 100);
1653
1654     dx = ex - sx;
1655     dy = ey - sy;
1656
1657     if (dx * dx + dy * dy > 3 * 3) {
1658         int rx =  dx + dy;
1659         int ry = -dx + dy;
1660         int length = ff_sqrt((rx * rx + ry * ry) << 8);
1661
1662         // FIXME subpixel accuracy
1663         rx = ROUNDED_DIV(rx * 3 << 4, length);
1664         ry = ROUNDED_DIV(ry * 3 << 4, length);
1665
1666         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
1667         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
1668     }
1669     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
1670 }
1671
1672 /**
1673  * Print debugging info for the given picture.
1674  */
1675 void ff_print_debug_info(MpegEncContext *s, AVFrame *pict)
1676 {
1677     if (   s->avctx->hwaccel || !pict || !pict->mb_type
1678         || (s->avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU))
1679         return;
1680
1681
1682     if (s->avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
1683         int x,y;
1684
1685         av_log(s->avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
1686                av_get_picture_type_char(pict->pict_type));
1687         for (y = 0; y < s->mb_height; y++) {
1688             for (x = 0; x < s->mb_width; x++) {
1689                 if (s->avctx->debug & FF_DEBUG_SKIP) {
1690                     int count = s->mbskip_table[x + y * s->mb_stride];
1691                     if (count > 9)
1692                         count = 9;
1693                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1694                 }
1695                 if (s->avctx->debug & FF_DEBUG_QP) {
1696                     av_log(s->avctx, AV_LOG_DEBUG, "%2d",
1697                            pict->qscale_table[x + y * s->mb_stride]);
1698                 }
1699                 if (s->avctx->debug & FF_DEBUG_MB_TYPE) {
1700                     int mb_type = pict->mb_type[x + y * s->mb_stride];
1701                     // Type & MV direction
1702                     if (IS_PCM(mb_type))
1703                         av_log(s->avctx, AV_LOG_DEBUG, "P");
1704                     else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1705                         av_log(s->avctx, AV_LOG_DEBUG, "A");
1706                     else if (IS_INTRA4x4(mb_type))
1707                         av_log(s->avctx, AV_LOG_DEBUG, "i");
1708                     else if (IS_INTRA16x16(mb_type))
1709                         av_log(s->avctx, AV_LOG_DEBUG, "I");
1710                     else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1711                         av_log(s->avctx, AV_LOG_DEBUG, "d");
1712                     else if (IS_DIRECT(mb_type))
1713                         av_log(s->avctx, AV_LOG_DEBUG, "D");
1714                     else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
1715                         av_log(s->avctx, AV_LOG_DEBUG, "g");
1716                     else if (IS_GMC(mb_type))
1717                         av_log(s->avctx, AV_LOG_DEBUG, "G");
1718                     else if (IS_SKIP(mb_type))
1719                         av_log(s->avctx, AV_LOG_DEBUG, "S");
1720                     else if (!USES_LIST(mb_type, 1))
1721                         av_log(s->avctx, AV_LOG_DEBUG, ">");
1722                     else if (!USES_LIST(mb_type, 0))
1723                         av_log(s->avctx, AV_LOG_DEBUG, "<");
1724                     else {
1725                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1726                         av_log(s->avctx, AV_LOG_DEBUG, "X");
1727                     }
1728
1729                     // segmentation
1730                     if (IS_8X8(mb_type))
1731                         av_log(s->avctx, AV_LOG_DEBUG, "+");
1732                     else if (IS_16X8(mb_type))
1733                         av_log(s->avctx, AV_LOG_DEBUG, "-");
1734                     else if (IS_8X16(mb_type))
1735                         av_log(s->avctx, AV_LOG_DEBUG, "|");
1736                     else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
1737                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1738                     else
1739                         av_log(s->avctx, AV_LOG_DEBUG, "?");
1740
1741
1742                     if (IS_INTERLACED(mb_type))
1743                         av_log(s->avctx, AV_LOG_DEBUG, "=");
1744                     else
1745                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1746                 }
1747             }
1748             av_log(s->avctx, AV_LOG_DEBUG, "\n");
1749         }
1750     }
1751
1752     if ((s->avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
1753         (s->avctx->debug_mv)) {
1754         const int shift = 1 + s->quarter_sample;
1755         int mb_y;
1756         uint8_t *ptr;
1757         int i;
1758         int h_chroma_shift, v_chroma_shift, block_height;
1759         const int width          = s->avctx->width;
1760         const int height         = s->avctx->height;
1761         const int mv_sample_log2 = 4 - pict->motion_subsample_log2;
1762         const int mv_stride      = (s->mb_width << mv_sample_log2) +
1763                                    (s->codec_id == AV_CODEC_ID_H264 ? 0 : 1);
1764         s->low_delay = 0; // needed to see the vectors without trashing the buffers
1765
1766         avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,
1767                                       &h_chroma_shift, &v_chroma_shift);
1768         for (i = 0; i < 3; i++) {
1769             size_t size= (i == 0) ? pict->linesize[i] * FFALIGN(height, 16):
1770                          pict->linesize[i] * FFALIGN(height, 16) >> v_chroma_shift;
1771             s->visualization_buffer[i]= av_realloc(s->visualization_buffer[i], size);
1772             memcpy(s->visualization_buffer[i], pict->data[i], size);
1773             pict->data[i] = s->visualization_buffer[i];
1774         }
1775         pict->type   = FF_BUFFER_TYPE_COPY;
1776         pict->opaque= NULL;
1777         ptr          = pict->data[0];
1778         block_height = 16 >> v_chroma_shift;
1779
1780         for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
1781             int mb_x;
1782             for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
1783                 const int mb_index = mb_x + mb_y * s->mb_stride;
1784                 if ((s->avctx->debug_mv) && pict->motion_val) {
1785                     int type;
1786                     for (type = 0; type < 3; type++) {
1787                         int direction = 0;
1788                         switch (type) {
1789                         case 0:
1790                             if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
1791                                 (pict->pict_type!= AV_PICTURE_TYPE_P))
1792                                 continue;
1793                             direction = 0;
1794                             break;
1795                         case 1:
1796                             if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
1797                                 (pict->pict_type!= AV_PICTURE_TYPE_B))
1798                                 continue;
1799                             direction = 0;
1800                             break;
1801                         case 2:
1802                             if ((!(s->avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
1803                                 (pict->pict_type!= AV_PICTURE_TYPE_B))
1804                                 continue;
1805                             direction = 1;
1806                             break;
1807                         }
1808                         if (!USES_LIST(pict->mb_type[mb_index], direction))
1809                             continue;
1810
1811                         if (IS_8X8(pict->mb_type[mb_index])) {
1812                             int i;
1813                             for (i = 0; i < 4; i++) {
1814                                 int sx = mb_x * 16 + 4 + 8 * (i & 1);
1815                                 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
1816                                 int xy = (mb_x * 2 + (i & 1) +
1817                                           (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1818                                 int mx = (pict->motion_val[direction][xy][0] >> shift) + sx;
1819                                 int my = (pict->motion_val[direction][xy][1] >> shift) + sy;
1820                                 draw_arrow(ptr, sx, sy, mx, my, width,
1821                                            height, s->linesize, 100);
1822                             }
1823                         } else if (IS_16X8(pict->mb_type[mb_index])) {
1824                             int i;
1825                             for (i = 0; i < 2; i++) {
1826                                 int sx = mb_x * 16 + 8;
1827                                 int sy = mb_y * 16 + 4 + 8 * i;
1828                                 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
1829                                 int mx = (pict->motion_val[direction][xy][0] >> shift);
1830                                 int my = (pict->motion_val[direction][xy][1] >> shift);
1831
1832                                 if (IS_INTERLACED(pict->mb_type[mb_index]))
1833                                     my *= 2;
1834
1835                             draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1836                                        height, s->linesize, 100);
1837                             }
1838                         } else if (IS_8X16(pict->mb_type[mb_index])) {
1839                             int i;
1840                             for (i = 0; i < 2; i++) {
1841                                 int sx = mb_x * 16 + 4 + 8 * i;
1842                                 int sy = mb_y * 16 + 8;
1843                                 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
1844                                 int mx = pict->motion_val[direction][xy][0] >> shift;
1845                                 int my = pict->motion_val[direction][xy][1] >> shift;
1846
1847                                 if (IS_INTERLACED(pict->mb_type[mb_index]))
1848                                     my *= 2;
1849
1850                                 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
1851                                            height, s->linesize, 100);
1852                             }
1853                         } else {
1854                               int sx= mb_x * 16 + 8;
1855                               int sy= mb_y * 16 + 8;
1856                               int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
1857                               int mx= (pict->motion_val[direction][xy][0]>>shift) + sx;
1858                               int my= (pict->motion_val[direction][xy][1]>>shift) + sy;
1859                               draw_arrow(ptr, sx, sy, mx, my, width, height, s->linesize, 100);
1860                         }
1861                     }
1862                 }
1863                 if ((s->avctx->debug & FF_DEBUG_VIS_QP) && pict->motion_val) {
1864                     uint64_t c = (pict->qscale_table[mb_index] * 128 / 31) *
1865                                  0x0101010101010101ULL;
1866                     int y;
1867                     for (y = 0; y < block_height; y++) {
1868                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
1869                                       (block_height * mb_y + y) *
1870                                       pict->linesize[1]) = c;
1871                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
1872                                       (block_height * mb_y + y) *
1873                                       pict->linesize[2]) = c;
1874                     }
1875                 }
1876                 if ((s->avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
1877                     pict->motion_val) {
1878                     int mb_type = pict->mb_type[mb_index];
1879                     uint64_t u,v;
1880                     int y;
1881 #define COLOR(theta, r) \
1882     u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
1883     v = (int)(128 + r * sin(theta * 3.141592 / 180));
1884
1885
1886                     u = v = 128;
1887                     if (IS_PCM(mb_type)) {
1888                         COLOR(120, 48)
1889                     } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
1890                                IS_INTRA16x16(mb_type)) {
1891                         COLOR(30, 48)
1892                     } else if (IS_INTRA4x4(mb_type)) {
1893                         COLOR(90, 48)
1894                     } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
1895                         // COLOR(120, 48)
1896                     } else if (IS_DIRECT(mb_type)) {
1897                         COLOR(150, 48)
1898                     } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
1899                         COLOR(170, 48)
1900                     } else if (IS_GMC(mb_type)) {
1901                         COLOR(190, 48)
1902                     } else if (IS_SKIP(mb_type)) {
1903                         // COLOR(180, 48)
1904                     } else if (!USES_LIST(mb_type, 1)) {
1905                         COLOR(240, 48)
1906                     } else if (!USES_LIST(mb_type, 0)) {
1907                         COLOR(0, 48)
1908                     } else {
1909                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1910                         COLOR(300,48)
1911                     }
1912
1913                     u *= 0x0101010101010101ULL;
1914                     v *= 0x0101010101010101ULL;
1915                     for (y = 0; y < block_height; y++) {
1916                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
1917                                       (block_height * mb_y + y) * pict->linesize[1]) = u;
1918                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
1919                                       (block_height * mb_y + y) * pict->linesize[2]) = v;
1920                     }
1921
1922                     // segmentation
1923                     if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
1924                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
1925                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1926                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
1927                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
1928                     }
1929                     if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
1930                         for (y = 0; y < 16; y++)
1931                             pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
1932                                           pict->linesize[0]] ^= 0x80;
1933                     }
1934                     if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
1935                         int dm = 1 << (mv_sample_log2 - 2);
1936                         for (i = 0; i < 4; i++) {
1937                             int sx = mb_x * 16 + 8 * (i & 1);
1938                             int sy = mb_y * 16 + 8 * (i >> 1);
1939                             int xy = (mb_x * 2 + (i & 1) +
1940                                      (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
1941                             // FIXME bidir
1942                             int32_t *mv = (int32_t *) &pict->motion_val[0][xy];
1943                             if (mv[0] != mv[dm] ||
1944                                 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
1945                                 for (y = 0; y < 8; y++)
1946                                     pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
1947                             if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
1948                                 *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
1949                                               pict->linesize[0]) ^= 0x8080808080808080ULL;
1950                         }
1951                     }
1952
1953                     if (IS_INTERLACED(mb_type) &&
1954                         s->codec_id == AV_CODEC_ID_H264) {
1955                         // hmm
1956                     }
1957                 }
1958                 s->mbskip_table[mb_index] = 0;
1959             }
1960         }
1961     }
1962 }
1963
1964 static inline int hpel_motion_lowres(MpegEncContext *s,
1965                                      uint8_t *dest, uint8_t *src,
1966                                      int field_based, int field_select,
1967                                      int src_x, int src_y,
1968                                      int width, int height, int stride,
1969                                      int h_edge_pos, int v_edge_pos,
1970                                      int w, int h, h264_chroma_mc_func *pix_op,
1971                                      int motion_x, int motion_y)
1972 {
1973     const int lowres   = s->avctx->lowres;
1974     const int op_index = FFMIN(lowres, 2);
1975     const int s_mask   = (2 << lowres) - 1;
1976     int emu = 0;
1977     int sx, sy;
1978
1979     if (s->quarter_sample) {
1980         motion_x /= 2;
1981         motion_y /= 2;
1982     }
1983
1984     sx = motion_x & s_mask;
1985     sy = motion_y & s_mask;
1986     src_x += motion_x >> lowres + 1;
1987     src_y += motion_y >> lowres + 1;
1988
1989     src   += src_y * stride + src_x;
1990
1991     if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w,                 0) ||
1992         (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
1993         s->dsp.emulated_edge_mc(s->edge_emu_buffer, src, s->linesize, w + 1,
1994                                 (h + 1) << field_based, src_x,
1995                                 src_y   << field_based,
1996                                 h_edge_pos,
1997                                 v_edge_pos);
1998         src = s->edge_emu_buffer;
1999         emu = 1;
2000     }
2001
2002     sx = (sx << 2) >> lowres;
2003     sy = (sy << 2) >> lowres;
2004     if (field_select)
2005         src += s->linesize;
2006     pix_op[op_index](dest, src, stride, h, sx, sy);
2007     return emu;
2008 }
2009
2010 /* apply one mpeg motion vector to the three components */
2011 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
2012                                                 uint8_t *dest_y,
2013                                                 uint8_t *dest_cb,
2014                                                 uint8_t *dest_cr,
2015                                                 int field_based,
2016                                                 int bottom_field,
2017                                                 int field_select,
2018                                                 uint8_t **ref_picture,
2019                                                 h264_chroma_mc_func *pix_op,
2020                                                 int motion_x, int motion_y,
2021                                                 int h, int mb_y)
2022 {
2023     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2024     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, uvlinesize, linesize, sx, sy,
2025         uvsx, uvsy;
2026     const int lowres     = s->avctx->lowres;
2027     const int op_index   = FFMIN(lowres-1+s->chroma_x_shift, 2);
2028     const int block_s    = 8>>lowres;
2029     const int s_mask     = (2 << lowres) - 1;
2030     const int h_edge_pos = s->h_edge_pos >> lowres;
2031     const int v_edge_pos = s->v_edge_pos >> lowres;
2032     linesize   = s->current_picture.f.linesize[0] << field_based;
2033     uvlinesize = s->current_picture.f.linesize[1] << field_based;
2034
2035     // FIXME obviously not perfect but qpel will not work in lowres anyway
2036     if (s->quarter_sample) {
2037         motion_x /= 2;
2038         motion_y /= 2;
2039     }
2040
2041     if(field_based){
2042         motion_y += (bottom_field - field_select)*((1 << lowres)-1);
2043     }
2044
2045     sx = motion_x & s_mask;
2046     sy = motion_y & s_mask;
2047     src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
2048     src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
2049
2050     if (s->out_format == FMT_H263) {
2051         uvsx    = ((motion_x >> 1) & s_mask) | (sx & 1);
2052         uvsy    = ((motion_y >> 1) & s_mask) | (sy & 1);
2053         uvsrc_x = src_x >> 1;
2054         uvsrc_y = src_y >> 1;
2055     } else if (s->out_format == FMT_H261) {
2056         // even chroma mv's are full pel in H261
2057         mx      = motion_x / 4;
2058         my      = motion_y / 4;
2059         uvsx    = (2 * mx) & s_mask;
2060         uvsy    = (2 * my) & s_mask;
2061         uvsrc_x = s->mb_x * block_s + (mx >> lowres);
2062         uvsrc_y =    mb_y * block_s + (my >> lowres);
2063     } else {
2064         if(s->chroma_y_shift){
2065             mx      = motion_x / 2;
2066             my      = motion_y / 2;
2067             uvsx    = mx & s_mask;
2068             uvsy    = my & s_mask;
2069             uvsrc_x = s->mb_x * block_s                 + (mx >> lowres + 1);
2070             uvsrc_y =   (mb_y * block_s >> field_based) + (my >> lowres + 1);
2071         } else {
2072             if(s->chroma_x_shift){
2073             //Chroma422
2074                 mx = motion_x / 2;
2075                 uvsx = mx & s_mask;
2076                 uvsy = motion_y & s_mask;
2077                 uvsrc_y = src_y;
2078                 uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
2079             } else {
2080             //Chroma444
2081                 uvsx = motion_x & s_mask;
2082                 uvsy = motion_y & s_mask;
2083                 uvsrc_x = src_x;
2084                 uvsrc_y = src_y;
2085             }
2086         }
2087     }
2088
2089     ptr_y  = ref_picture[0] + src_y   * linesize   + src_x;
2090     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2091     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2092
2093     if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s,       0) ||
2094         (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2095         s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
2096                                 s->linesize, 17, 17 + field_based,
2097                                 src_x, src_y << field_based, h_edge_pos,
2098                                 v_edge_pos);
2099         ptr_y = s->edge_emu_buffer;
2100         if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2101             uint8_t *uvbuf = s->edge_emu_buffer + 18 * s->linesize;
2102             s->dsp.emulated_edge_mc(uvbuf , ptr_cb, s->uvlinesize, 9,
2103                                     9 + field_based,
2104                                     uvsrc_x, uvsrc_y << field_based,
2105                                     h_edge_pos >> 1, v_edge_pos >> 1);
2106             s->dsp.emulated_edge_mc(uvbuf + 16, ptr_cr, s->uvlinesize, 9,
2107                                     9 + field_based,
2108                                     uvsrc_x, uvsrc_y << field_based,
2109                                     h_edge_pos >> 1, v_edge_pos >> 1);
2110             ptr_cb = uvbuf;
2111             ptr_cr = uvbuf + 16;
2112         }
2113     }
2114
2115     // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f.data
2116     if (bottom_field) {
2117         dest_y  += s->linesize;
2118         dest_cb += s->uvlinesize;
2119         dest_cr += s->uvlinesize;
2120     }
2121
2122     if (field_select) {
2123         ptr_y   += s->linesize;
2124         ptr_cb  += s->uvlinesize;
2125         ptr_cr  += s->uvlinesize;
2126     }
2127
2128     sx = (sx << 2) >> lowres;
2129     sy = (sy << 2) >> lowres;
2130     pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
2131
2132     if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2133         uvsx = (uvsx << 2) >> lowres;
2134         uvsy = (uvsy << 2) >> lowres;
2135         if (h >> s->chroma_y_shift) {
2136             pix_op[op_index](dest_cb, ptr_cb, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2137             pix_op[op_index](dest_cr, ptr_cr, uvlinesize, h >> s->chroma_y_shift, uvsx, uvsy);
2138         }
2139     }
2140     // FIXME h261 lowres loop filter
2141 }
2142
2143 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
2144                                             uint8_t *dest_cb, uint8_t *dest_cr,
2145                                             uint8_t **ref_picture,
2146                                             h264_chroma_mc_func * pix_op,
2147                                             int mx, int my)
2148 {
2149     const int lowres     = s->avctx->lowres;
2150     const int op_index   = FFMIN(lowres, 2);
2151     const int block_s    = 8 >> lowres;
2152     const int s_mask     = (2 << lowres) - 1;
2153     const int h_edge_pos = s->h_edge_pos >> lowres + 1;
2154     const int v_edge_pos = s->v_edge_pos >> lowres + 1;
2155     int emu = 0, src_x, src_y, offset, sx, sy;
2156     uint8_t *ptr;
2157
2158     if (s->quarter_sample) {
2159         mx /= 2;
2160         my /= 2;
2161     }
2162
2163     /* In case of 8X8, we construct a single chroma motion vector
2164        with a special rounding */
2165     mx = ff_h263_round_chroma(mx);
2166     my = ff_h263_round_chroma(my);
2167
2168     sx = mx & s_mask;
2169     sy = my & s_mask;
2170     src_x = s->mb_x * block_s + (mx >> lowres + 1);
2171     src_y = s->mb_y * block_s + (my >> lowres + 1);
2172
2173     offset = src_y * s->uvlinesize + src_x;
2174     ptr = ref_picture[1] + offset;
2175     if (s->flags & CODEC_FLAG_EMU_EDGE) {
2176         if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2177             (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2178             s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize,
2179                                     9, 9, src_x, src_y, h_edge_pos, v_edge_pos);
2180             ptr = s->edge_emu_buffer;
2181             emu = 1;
2182         }
2183     }
2184     sx = (sx << 2) >> lowres;
2185     sy = (sy << 2) >> lowres;
2186     pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
2187
2188     ptr = ref_picture[2] + offset;
2189     if (emu) {
2190         s->dsp.emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9,
2191                                 src_x, src_y, h_edge_pos, v_edge_pos);
2192         ptr = s->edge_emu_buffer;
2193     }
2194     pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
2195 }
2196
2197 /**
2198  * motion compensation of a single macroblock
2199  * @param s context
2200  * @param dest_y luma destination pointer
2201  * @param dest_cb chroma cb/u destination pointer
2202  * @param dest_cr chroma cr/v destination pointer
2203  * @param dir direction (0->forward, 1->backward)
2204  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2205  * @param pix_op halfpel motion compensation function (average or put normally)
2206  * the motion vectors are taken from s->mv and the MV type from s->mv_type
2207  */
2208 static inline void MPV_motion_lowres(MpegEncContext *s,
2209                                      uint8_t *dest_y, uint8_t *dest_cb,
2210                                      uint8_t *dest_cr,
2211                                      int dir, uint8_t **ref_picture,
2212                                      h264_chroma_mc_func *pix_op)
2213 {
2214     int mx, my;
2215     int mb_x, mb_y, i;
2216     const int lowres  = s->avctx->lowres;
2217     const int block_s = 8 >>lowres;
2218
2219     mb_x = s->mb_x;
2220     mb_y = s->mb_y;
2221
2222     switch (s->mv_type) {
2223     case MV_TYPE_16X16:
2224         mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2225                            0, 0, 0,
2226                            ref_picture, pix_op,
2227                            s->mv[dir][0][0], s->mv[dir][0][1],
2228                            2 * block_s, mb_y);
2229         break;
2230     case MV_TYPE_8X8:
2231         mx = 0;
2232         my = 0;
2233         for (i = 0; i < 4; i++) {
2234             hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
2235                                s->linesize) * block_s,
2236                                ref_picture[0], 0, 0,
2237                                (2 * mb_x + (i & 1)) * block_s,
2238                                (2 * mb_y + (i >> 1)) * block_s,
2239                                s->width, s->height, s->linesize,
2240                                s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
2241                                block_s, block_s, pix_op,
2242                                s->mv[dir][i][0], s->mv[dir][i][1]);
2243
2244             mx += s->mv[dir][i][0];
2245             my += s->mv[dir][i][1];
2246         }
2247
2248         if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY))
2249             chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
2250                                      pix_op, mx, my);
2251         break;
2252     case MV_TYPE_FIELD:
2253         if (s->picture_structure == PICT_FRAME) {
2254             /* top field */
2255             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2256                                1, 0, s->field_select[dir][0],
2257                                ref_picture, pix_op,
2258                                s->mv[dir][0][0], s->mv[dir][0][1],
2259                                block_s, mb_y);
2260             /* bottom field */
2261             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2262                                1, 1, s->field_select[dir][1],
2263                                ref_picture, pix_op,
2264                                s->mv[dir][1][0], s->mv[dir][1][1],
2265                                block_s, mb_y);
2266         } else {
2267             if (s->picture_structure != s->field_select[dir][0] + 1 &&
2268                 s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
2269                 ref_picture = s->current_picture_ptr->f.data;
2270
2271             }
2272             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2273                                0, 0, s->field_select[dir][0],
2274                                ref_picture, pix_op,
2275                                s->mv[dir][0][0],
2276                                s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
2277             }
2278         break;
2279     case MV_TYPE_16X8:
2280         for (i = 0; i < 2; i++) {
2281             uint8_t **ref2picture;
2282
2283             if (s->picture_structure == s->field_select[dir][i] + 1 ||
2284                 s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
2285                 ref2picture = ref_picture;
2286             } else {
2287                 ref2picture = s->current_picture_ptr->f.data;
2288             }
2289
2290             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2291                                0, 0, s->field_select[dir][i],
2292                                ref2picture, pix_op,
2293                                s->mv[dir][i][0], s->mv[dir][i][1] +
2294                                2 * block_s * i, block_s, mb_y >> 1);
2295
2296             dest_y  +=  2 * block_s *  s->linesize;
2297             dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2298             dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2299         }
2300         break;
2301     case MV_TYPE_DMV:
2302         if (s->picture_structure == PICT_FRAME) {
2303             for (i = 0; i < 2; i++) {
2304                 int j;
2305                 for (j = 0; j < 2; j++) {
2306                     mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2307                                        1, j, j ^ i,
2308                                        ref_picture, pix_op,
2309                                        s->mv[dir][2 * i + j][0],
2310                                        s->mv[dir][2 * i + j][1],
2311                                        block_s, mb_y);
2312                 }
2313                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2314             }
2315         } else {
2316             for (i = 0; i < 2; i++) {
2317                 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2318                                    0, 0, s->picture_structure != i + 1,
2319                                    ref_picture, pix_op,
2320                                    s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
2321                                    2 * block_s, mb_y >> 1);
2322
2323                 // after put we make avg of the same block
2324                 pix_op = s->dsp.avg_h264_chroma_pixels_tab;
2325
2326                 // opposite parity is always in the same
2327                 // frame if this is second field
2328                 if (!s->first_field) {
2329                     ref_picture = s->current_picture_ptr->f.data;
2330                 }
2331             }
2332         }
2333         break;
2334     default:
2335         av_assert2(0);
2336     }
2337 }
2338
2339 /**
2340  * find the lowest MB row referenced in the MVs
2341  */
2342 int ff_MPV_lowest_referenced_row(MpegEncContext *s, int dir)
2343 {
2344     int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2345     int my, off, i, mvs;
2346
2347     if (s->picture_structure != PICT_FRAME || s->mcsel) 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 }