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