git.sesse.net Git - ffmpeg/blob - libavcodec/mpegvideo.c

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