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 Libav.
   9  *
  10  * Libav 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  * Libav 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 Libav; 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/attributes.h"
  31 #include "libavutil/avassert.h"
  32 #include "libavutil/imgutils.h"
  33 #include "libavutil/internal.h"
  34 #include "libavutil/timer.h"
  35 #include "avcodec.h"
  36 #include "blockdsp.h"
  37 #include "idctdsp.h"
  38 #include "internal.h"
  39 #include "mathops.h"
  40 #include "mpegutils.h"
  41 #include "mpegvideo.h"
  42 #include "mjpegenc.h"
  43 #include "msmpeg4.h"
  44 #include "qpeldsp.h"
  45 #include "xvmc_internal.h"
  46 #include "thread.h"
  47 #include <limits.h>
  48
  49 static const uint8_t ff_default_chroma_qscale_table[32] = {
  50 //   0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15
  51      0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15,
  52     16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31
  53 };
  54
  55 const uint8_t ff_mpeg1_dc_scale_table[128] = {
  56 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
  57     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  58     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  59     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  60     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  61     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  62     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  63     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  64     8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
  65 };
  66
  67 static const uint8_t mpeg2_dc_scale_table1[128] = {
  68 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
  69     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  70     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  71     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  72     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  73     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  74     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  75     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  76     4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
  77 };
  78
  79 static const uint8_t mpeg2_dc_scale_table2[128] = {
  80 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
  81     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  82     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  83     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  84     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  85     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  86     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  87     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  88     2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
  89 };
  90
  91 static const uint8_t mpeg2_dc_scale_table3[128] = {
  92 //  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
  93     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  94     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  95     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  96     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  97     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  98     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
  99     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 100     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
 101 };
 102
 103 const uint8_t *const ff_mpeg2_dc_scale_table[4] = {
 104     ff_mpeg1_dc_scale_table,
 105     mpeg2_dc_scale_table1,
 106     mpeg2_dc_scale_table2,
 107     mpeg2_dc_scale_table3,
 108 };
 109
 110 const uint8_t ff_alternate_horizontal_scan[64] = {
 111      0,  1,  2,  3,  8,  9, 16, 17,
 112     10, 11,  4,  5,  6,  7, 15, 14,
 113     13, 12, 19, 18, 24, 25, 32, 33,
 114     26, 27, 20, 21, 22, 23, 28, 29,
 115     30, 31, 34, 35, 40, 41, 48, 49,
 116     42, 43, 36, 37, 38, 39, 44, 45,
 117     46, 47, 50, 51, 56, 57, 58, 59,
 118     52, 53, 54, 55, 60, 61, 62, 63,
 119 };
 120
 121 const uint8_t ff_alternate_vertical_scan[64] = {
 122      0,  8, 16, 24,  1,  9,  2, 10,
 123     17, 25, 32, 40, 48, 56, 57, 49,
 124     41, 33, 26, 18,  3, 11,  4, 12,
 125     19, 27, 34, 42, 50, 58, 35, 43,
 126     51, 59, 20, 28,  5, 13,  6, 14,
 127     21, 29, 36, 44, 52, 60, 37, 45,
 128     53, 61, 22, 30,  7, 15, 23, 31,
 129     38, 46, 54, 62, 39, 47, 55, 63,
 130 };
 131
 132 static void dct_unquantize_mpeg1_intra_c(MpegEncContext *s,
 133                                    int16_t *block, int n, int qscale)
 134 {
 135     int i, level, nCoeffs;
 136     const uint16_t *quant_matrix;
 137
 138     nCoeffs= s->block_last_index[n];
 139
 140     if (n < 4)
 141         block[0] = block[0] * s->y_dc_scale;
 142     else
 143         block[0] = block[0] * s->c_dc_scale;
 144     /* XXX: only mpeg1 */
 145     quant_matrix = s->intra_matrix;
 146     for(i=1;i<=nCoeffs;i++) {
 147         int j= s->intra_scantable.permutated[i];
 148         level = block[j];
 149         if (level) {
 150             if (level < 0) {
 151                 level = -level;
 152                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
 153                 level = (level - 1) | 1;
 154                 level = -level;
 155             } else {
 156                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
 157                 level = (level - 1) | 1;
 158             }
 159             block[j] = level;
 160         }
 161     }
 162 }
 163
 164 static void dct_unquantize_mpeg1_inter_c(MpegEncContext *s,
 165                                    int16_t *block, int n, int qscale)
 166 {
 167     int i, level, nCoeffs;
 168     const uint16_t *quant_matrix;
 169
 170     nCoeffs= s->block_last_index[n];
 171
 172     quant_matrix = s->inter_matrix;
 173     for(i=0; i<=nCoeffs; i++) {
 174         int j= s->intra_scantable.permutated[i];
 175         level = block[j];
 176         if (level) {
 177             if (level < 0) {
 178                 level = -level;
 179                 level = (((level << 1) + 1) * qscale *
 180                          ((int) (quant_matrix[j]))) >> 4;
 181                 level = (level - 1) | 1;
 182                 level = -level;
 183             } else {
 184                 level = (((level << 1) + 1) * qscale *
 185                          ((int) (quant_matrix[j]))) >> 4;
 186                 level = (level - 1) | 1;
 187             }
 188             block[j] = level;
 189         }
 190     }
 191 }
 192
 193 static void dct_unquantize_mpeg2_intra_c(MpegEncContext *s,
 194                                    int16_t *block, int n, int qscale)
 195 {
 196     int i, level, nCoeffs;
 197     const uint16_t *quant_matrix;
 198
 199     if(s->alternate_scan) nCoeffs= 63;
 200     else nCoeffs= s->block_last_index[n];
 201
 202     if (n < 4)
 203         block[0] = block[0] * s->y_dc_scale;
 204     else
 205         block[0] = block[0] * s->c_dc_scale;
 206     quant_matrix = s->intra_matrix;
 207     for(i=1;i<=nCoeffs;i++) {
 208         int j= s->intra_scantable.permutated[i];
 209         level = block[j];
 210         if (level) {
 211             if (level < 0) {
 212                 level = -level;
 213                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
 214                 level = -level;
 215             } else {
 216                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
 217             }
 218             block[j] = level;
 219         }
 220     }
 221 }
 222
 223 static void dct_unquantize_mpeg2_intra_bitexact(MpegEncContext *s,
 224                                    int16_t *block, int n, int qscale)
 225 {
 226     int i, level, nCoeffs;
 227     const uint16_t *quant_matrix;
 228     int sum=-1;
 229
 230     if(s->alternate_scan) nCoeffs= 63;
 231     else nCoeffs= s->block_last_index[n];
 232
 233     if (n < 4)
 234         block[0] = block[0] * s->y_dc_scale;
 235     else
 236         block[0] = block[0] * s->c_dc_scale;
 237     quant_matrix = s->intra_matrix;
 238     for(i=1;i<=nCoeffs;i++) {
 239         int j= s->intra_scantable.permutated[i];
 240         level = block[j];
 241         if (level) {
 242             if (level < 0) {
 243                 level = -level;
 244                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
 245                 level = -level;
 246             } else {
 247                 level = (int)(level * qscale * quant_matrix[j]) >> 3;
 248             }
 249             block[j] = level;
 250             sum+=level;
 251         }
 252     }
 253     block[63]^=sum&1;
 254 }
 255
 256 static void dct_unquantize_mpeg2_inter_c(MpegEncContext *s,
 257                                    int16_t *block, int n, int qscale)
 258 {
 259     int i, level, nCoeffs;
 260     const uint16_t *quant_matrix;
 261     int sum=-1;
 262
 263     if(s->alternate_scan) nCoeffs= 63;
 264     else nCoeffs= s->block_last_index[n];
 265
 266     quant_matrix = s->inter_matrix;
 267     for(i=0; i<=nCoeffs; i++) {
 268         int j= s->intra_scantable.permutated[i];
 269         level = block[j];
 270         if (level) {
 271             if (level < 0) {
 272                 level = -level;
 273                 level = (((level << 1) + 1) * qscale *
 274                          ((int) (quant_matrix[j]))) >> 4;
 275                 level = -level;
 276             } else {
 277                 level = (((level << 1) + 1) * qscale *
 278                          ((int) (quant_matrix[j]))) >> 4;
 279             }
 280             block[j] = level;
 281             sum+=level;
 282         }
 283     }
 284     block[63]^=sum&1;
 285 }
 286
 287 static void dct_unquantize_h263_intra_c(MpegEncContext *s,
 288                                   int16_t *block, int n, int qscale)
 289 {
 290     int i, level, qmul, qadd;
 291     int nCoeffs;
 292
 293     assert(s->block_last_index[n]>=0);
 294
 295     qmul = qscale << 1;
 296
 297     if (!s->h263_aic) {
 298         if (n < 4)
 299             block[0] = block[0] * s->y_dc_scale;
 300         else
 301             block[0] = block[0] * s->c_dc_scale;
 302         qadd = (qscale - 1) | 1;
 303     }else{
 304         qadd = 0;
 305     }
 306     if(s->ac_pred)
 307         nCoeffs=63;
 308     else
 309         nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
 310
 311     for(i=1; i<=nCoeffs; i++) {
 312         level = block[i];
 313         if (level) {
 314             if (level < 0) {
 315                 level = level * qmul - qadd;
 316             } else {
 317                 level = level * qmul + qadd;
 318             }
 319             block[i] = level;
 320         }
 321     }
 322 }
 323
 324 static void dct_unquantize_h263_inter_c(MpegEncContext *s,
 325                                   int16_t *block, int n, int qscale)
 326 {
 327     int i, level, qmul, qadd;
 328     int nCoeffs;
 329
 330     assert(s->block_last_index[n]>=0);
 331
 332     qadd = (qscale - 1) | 1;
 333     qmul = qscale << 1;
 334
 335     nCoeffs= s->inter_scantable.raster_end[ s->block_last_index[n] ];
 336
 337     for(i=0; i<=nCoeffs; i++) {
 338         level = block[i];
 339         if (level) {
 340             if (level < 0) {
 341                 level = level * qmul - qadd;
 342             } else {
 343                 level = level * qmul + qadd;
 344             }
 345             block[i] = level;
 346         }
 347     }
 348 }
 349
 350 static void mpeg_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type,
 351                               int (*mv)[2][4][2],
 352                               int mb_x, int mb_y, int mb_intra, int mb_skipped)
 353 {
 354     MpegEncContext *s = opaque;
 355
 356     s->mv_dir     = mv_dir;
 357     s->mv_type    = mv_type;
 358     s->mb_intra   = mb_intra;
 359     s->mb_skipped = mb_skipped;
 360     s->mb_x       = mb_x;
 361     s->mb_y       = mb_y;
 362     memcpy(s->mv, mv, sizeof(*mv));
 363
 364     ff_init_block_index(s);
 365     ff_update_block_index(s);
 366
 367     s->bdsp.clear_blocks(s->block[0]);
 368
 369     s->dest[0] = s->current_picture.f->data[0] + (s->mb_y *  16                       * s->linesize)   + s->mb_x *  16;
 370     s->dest[1] = s->current_picture.f->data[1] + (s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16 >> s->chroma_x_shift);
 371     s->dest[2] = s->current_picture.f->data[2] + (s->mb_y * (16 >> s->chroma_y_shift) * s->uvlinesize) + s->mb_x * (16 >> s->chroma_x_shift);
 372
 373     assert(ref == 0);
 374     ff_mpv_decode_mb(s, s->block);
 375 }
 376
 377 /* init common dct for both encoder and decoder */
 378 static av_cold int dct_init(MpegEncContext *s)
 379 {
 380     ff_blockdsp_init(&s->bdsp, s->avctx);
 381     ff_hpeldsp_init(&s->hdsp, s->avctx->flags);
 382     ff_me_cmp_init(&s->mecc, s->avctx);
 383     ff_mpegvideodsp_init(&s->mdsp);
 384     ff_videodsp_init(&s->vdsp, s->avctx->bits_per_raw_sample);
 385
 386     s->dct_unquantize_h263_intra = dct_unquantize_h263_intra_c;
 387     s->dct_unquantize_h263_inter = dct_unquantize_h263_inter_c;
 388     s->dct_unquantize_mpeg1_intra = dct_unquantize_mpeg1_intra_c;
 389     s->dct_unquantize_mpeg1_inter = dct_unquantize_mpeg1_inter_c;
 390     s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_c;
 391     if (s->flags & CODEC_FLAG_BITEXACT)
 392         s->dct_unquantize_mpeg2_intra = dct_unquantize_mpeg2_intra_bitexact;
 393     s->dct_unquantize_mpeg2_inter = dct_unquantize_mpeg2_inter_c;
 394
 395     if (HAVE_INTRINSICS_NEON)
 396         ff_mpv_common_init_neon(s);
 397
 398     if (ARCH_ARM)
 399         ff_mpv_common_init_arm(s);
 400     if (ARCH_PPC)
 401         ff_mpv_common_init_ppc(s);
 402     if (ARCH_X86)
 403         ff_mpv_common_init_x86(s);
 404
 405     return 0;
 406 }
 407
 408 av_cold void ff_mpv_idct_init(MpegEncContext *s)
 409 {
 410     ff_idctdsp_init(&s->idsp, s->avctx);
 411
 412     /* load & permutate scantables
 413      * note: only wmv uses different ones
 414      */
 415     if (s->alternate_scan) {
 416         ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_alternate_vertical_scan);
 417         ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_alternate_vertical_scan);
 418     } else {
 419         ff_init_scantable(s->idsp.idct_permutation, &s->inter_scantable, ff_zigzag_direct);
 420         ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, ff_zigzag_direct);
 421     }
 422     ff_init_scantable(s->idsp.idct_permutation, &s->intra_h_scantable, ff_alternate_horizontal_scan);
 423     ff_init_scantable(s->idsp.idct_permutation, &s->intra_v_scantable, ff_alternate_vertical_scan);
 424 }
 425
 426 static int frame_size_alloc(MpegEncContext *s, int linesize)
 427 {
 428     int alloc_size = FFALIGN(FFABS(linesize) + 32, 32);
 429
 430     // edge emu needs blocksize + filter length - 1
 431     // (= 17x17 for  halfpel / 21x21 for  h264)
 432     // VC1 computes luma and chroma simultaneously and needs 19X19 + 9x9
 433     // at uvlinesize. It supports only YUV420 so 24x24 is enough
 434     // linesize * interlaced * MBsize
 435     FF_ALLOCZ_OR_GOTO(s->avctx, s->edge_emu_buffer, alloc_size * 2 * 24,
 436                       fail);
 437
 438     FF_ALLOCZ_OR_GOTO(s->avctx, s->me.scratchpad, alloc_size * 2 * 16 * 3,
 439                       fail)
 440     s->me.temp         = s->me.scratchpad;
 441     s->rd_scratchpad   = s->me.scratchpad;
 442     s->b_scratchpad    = s->me.scratchpad;
 443     s->obmc_scratchpad = s->me.scratchpad + 16;
 444
 445     return 0;
 446 fail:
 447     av_freep(&s->edge_emu_buffer);
 448     return AVERROR(ENOMEM);
 449 }
 450
 451 /**
 452  * Allocate a frame buffer
 453  */
 454 static int alloc_frame_buffer(MpegEncContext *s, Picture *pic)
 455 {
 456     int edges_needed = av_codec_is_encoder(s->avctx->codec);
 457     int r, ret;
 458
 459     pic->tf.f = pic->f;
 460     if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
 461         s->codec_id != AV_CODEC_ID_VC1IMAGE  &&
 462         s->codec_id != AV_CODEC_ID_MSS2) {
 463         if (edges_needed) {
 464             pic->f->width  = s->avctx->width  + 2 * EDGE_WIDTH;
 465             pic->f->height = s->avctx->height + 2 * EDGE_WIDTH;
 466         }
 467
 468         r = ff_thread_get_buffer(s->avctx, &pic->tf,
 469                                  pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
 470     } else {
 471         pic->f->width  = s->avctx->width;
 472         pic->f->height = s->avctx->height;
 473         pic->f->format = s->avctx->pix_fmt;
 474         r = avcodec_default_get_buffer2(s->avctx, pic->f, 0);
 475     }
 476
 477     if (r < 0 || !pic->f->buf[0]) {
 478         av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed (%d %p)\n",
 479                r, pic->f->data[0]);
 480         return -1;
 481     }
 482
 483     if (edges_needed) {
 484         int i;
 485         for (i = 0; pic->f->data[i]; i++) {
 486             int offset = (EDGE_WIDTH >> (i ? s->chroma_y_shift : 0)) *
 487                          pic->f->linesize[i] +
 488                          (EDGE_WIDTH >> (i ? s->chroma_x_shift : 0));
 489             pic->f->data[i] += offset;
 490         }
 491         pic->f->width  = s->avctx->width;
 492         pic->f->height = s->avctx->height;
 493     }
 494
 495     if (s->avctx->hwaccel) {
 496         assert(!pic->hwaccel_picture_private);
 497         if (s->avctx->hwaccel->frame_priv_data_size) {
 498             pic->hwaccel_priv_buf = av_buffer_allocz(s->avctx->hwaccel->frame_priv_data_size);
 499             if (!pic->hwaccel_priv_buf) {
 500                 av_log(s->avctx, AV_LOG_ERROR, "alloc_frame_buffer() failed (hwaccel private data allocation)\n");
 501                 return -1;
 502             }
 503             pic->hwaccel_picture_private = pic->hwaccel_priv_buf->data;
 504         }
 505     }
 506
 507     if (s->linesize && (s->linesize   != pic->f->linesize[0] ||
 508                         s->uvlinesize != pic->f->linesize[1])) {
 509         av_log(s->avctx, AV_LOG_ERROR,
 510                "get_buffer() failed (stride changed)\n");
 511         ff_mpeg_unref_picture(s, pic);
 512         return -1;
 513     }
 514
 515     if (pic->f->linesize[1] != pic->f->linesize[2]) {
 516         av_log(s->avctx, AV_LOG_ERROR,
 517                "get_buffer() failed (uv stride mismatch)\n");
 518         ff_mpeg_unref_picture(s, pic);
 519         return -1;
 520     }
 521
 522     if (!s->edge_emu_buffer &&
 523         (ret = frame_size_alloc(s, pic->f->linesize[0])) < 0) {
 524         av_log(s->avctx, AV_LOG_ERROR,
 525                "get_buffer() failed to allocate context scratch buffers.\n");
 526         ff_mpeg_unref_picture(s, pic);
 527         return ret;
 528     }
 529
 530     return 0;
 531 }
 532
 533 void ff_free_picture_tables(Picture *pic)
 534 {
 535     int i;
 536
 537     av_buffer_unref(&pic->mb_var_buf);
 538     av_buffer_unref(&pic->mc_mb_var_buf);
 539     av_buffer_unref(&pic->mb_mean_buf);
 540     av_buffer_unref(&pic->mbskip_table_buf);
 541     av_buffer_unref(&pic->qscale_table_buf);
 542     av_buffer_unref(&pic->mb_type_buf);
 543
 544     for (i = 0; i < 2; i++) {
 545         av_buffer_unref(&pic->motion_val_buf[i]);
 546         av_buffer_unref(&pic->ref_index_buf[i]);
 547     }
 548 }
 549
 550 static int alloc_picture_tables(MpegEncContext *s, Picture *pic)
 551 {
 552     const int big_mb_num    = s->mb_stride * (s->mb_height + 1) + 1;
 553     const int mb_array_size = s->mb_stride * s->mb_height;
 554     const int b8_array_size = s->b8_stride * s->mb_height * 2;
 555     int i;
 556
 557
 558     pic->mbskip_table_buf = av_buffer_allocz(mb_array_size + 2);
 559     pic->qscale_table_buf = av_buffer_allocz(big_mb_num + s->mb_stride);
 560     pic->mb_type_buf      = av_buffer_allocz((big_mb_num + s->mb_stride) *
 561                                              sizeof(uint32_t));
 562     if (!pic->mbskip_table_buf || !pic->qscale_table_buf || !pic->mb_type_buf)
 563         return AVERROR(ENOMEM);
 564
 565     if (s->encoding) {
 566         pic->mb_var_buf    = av_buffer_allocz(mb_array_size * sizeof(int16_t));
 567         pic->mc_mb_var_buf = av_buffer_allocz(mb_array_size * sizeof(int16_t));
 568         pic->mb_mean_buf   = av_buffer_allocz(mb_array_size);
 569         if (!pic->mb_var_buf || !pic->mc_mb_var_buf || !pic->mb_mean_buf)
 570             return AVERROR(ENOMEM);
 571     }
 572
 573     if (s->out_format == FMT_H263 || s->encoding) {
 574         int mv_size        = 2 * (b8_array_size + 4) * sizeof(int16_t);
 575         int ref_index_size = 4 * mb_array_size;
 576
 577         for (i = 0; mv_size && i < 2; i++) {
 578             pic->motion_val_buf[i] = av_buffer_allocz(mv_size);
 579             pic->ref_index_buf[i]  = av_buffer_allocz(ref_index_size);
 580             if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i])
 581                 return AVERROR(ENOMEM);
 582         }
 583     }
 584
 585     return 0;
 586 }
 587
 588 static int make_tables_writable(Picture *pic)
 589 {
 590     int ret, i;
 591 #define MAKE_WRITABLE(table) \
 592 do {\
 593     if (pic->table &&\
 594        (ret = av_buffer_make_writable(&pic->table)) < 0)\
 595     return ret;\
 596 } while (0)
 597
 598     MAKE_WRITABLE(mb_var_buf);
 599     MAKE_WRITABLE(mc_mb_var_buf);
 600     MAKE_WRITABLE(mb_mean_buf);
 601     MAKE_WRITABLE(mbskip_table_buf);
 602     MAKE_WRITABLE(qscale_table_buf);
 603     MAKE_WRITABLE(mb_type_buf);
 604
 605     for (i = 0; i < 2; i++) {
 606         MAKE_WRITABLE(motion_val_buf[i]);
 607         MAKE_WRITABLE(ref_index_buf[i]);
 608     }
 609
 610     return 0;
 611 }
 612
 613 /**
 614  * Allocate a Picture.
 615  * The pixels are allocated/set by calling get_buffer() if shared = 0
 616  */
 617 int ff_alloc_picture(MpegEncContext *s, Picture *pic, int shared)
 618 {
 619     int i, ret;
 620
 621     if (shared) {
 622         assert(pic->f->data[0]);
 623         pic->shared = 1;
 624     } else {
 625         assert(!pic->f->buf[0]);
 626
 627         if (alloc_frame_buffer(s, pic) < 0)
 628             return -1;
 629
 630         s->linesize   = pic->f->linesize[0];
 631         s->uvlinesize = pic->f->linesize[1];
 632     }
 633
 634     if (!pic->qscale_table_buf)
 635         ret = alloc_picture_tables(s, pic);
 636     else
 637         ret = make_tables_writable(pic);
 638     if (ret < 0)
 639         goto fail;
 640
 641     if (s->encoding) {
 642         pic->mb_var    = (uint16_t*)pic->mb_var_buf->data;
 643         pic->mc_mb_var = (uint16_t*)pic->mc_mb_var_buf->data;
 644         pic->mb_mean   = pic->mb_mean_buf->data;
 645     }
 646
 647     pic->mbskip_table = pic->mbskip_table_buf->data;
 648     pic->qscale_table = pic->qscale_table_buf->data + 2 * s->mb_stride + 1;
 649     pic->mb_type      = (uint32_t*)pic->mb_type_buf->data + 2 * s->mb_stride + 1;
 650
 651     if (pic->motion_val_buf[0]) {
 652         for (i = 0; i < 2; i++) {
 653             pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
 654             pic->ref_index[i]  = pic->ref_index_buf[i]->data;
 655         }
 656     }
 657
 658     return 0;
 659 fail:
 660     av_log(s->avctx, AV_LOG_ERROR, "Error allocating a picture.\n");
 661     ff_mpeg_unref_picture(s, pic);
 662     ff_free_picture_tables(pic);
 663     return AVERROR(ENOMEM);
 664 }
 665
 666 /**
 667  * Deallocate a picture.
 668  */
 669 void ff_mpeg_unref_picture(MpegEncContext *s, Picture *pic)
 670 {
 671     int off = offsetof(Picture, mb_mean) + sizeof(pic->mb_mean);
 672
 673     pic->tf.f = pic->f;
 674     /* WM Image / Screen codecs allocate internal buffers with different
 675      * dimensions / colorspaces; ignore user-defined callbacks for these. */
 676     if (s->codec_id != AV_CODEC_ID_WMV3IMAGE &&
 677         s->codec_id != AV_CODEC_ID_VC1IMAGE  &&
 678         s->codec_id != AV_CODEC_ID_MSS2)
 679         ff_thread_release_buffer(s->avctx, &pic->tf);
 680     else if (pic->f)
 681         av_frame_unref(pic->f);
 682
 683     av_buffer_unref(&pic->hwaccel_priv_buf);
 684
 685     if (pic->needs_realloc)
 686         ff_free_picture_tables(pic);
 687
 688     memset((uint8_t*)pic + off, 0, sizeof(*pic) - off);
 689 }
 690
 691 static int update_picture_tables(Picture *dst, Picture *src)
 692 {
 693      int i;
 694
 695 #define UPDATE_TABLE(table)\
 696 do {\
 697     if (src->table &&\
 698         (!dst->table || dst->table->buffer != src->table->buffer)) {\
 699         av_buffer_unref(&dst->table);\
 700         dst->table = av_buffer_ref(src->table);\
 701         if (!dst->table) {\
 702             ff_free_picture_tables(dst);\
 703             return AVERROR(ENOMEM);\
 704         }\
 705     }\
 706 } while (0)
 707
 708     UPDATE_TABLE(mb_var_buf);
 709     UPDATE_TABLE(mc_mb_var_buf);
 710     UPDATE_TABLE(mb_mean_buf);
 711     UPDATE_TABLE(mbskip_table_buf);
 712     UPDATE_TABLE(qscale_table_buf);
 713     UPDATE_TABLE(mb_type_buf);
 714     for (i = 0; i < 2; i++) {
 715         UPDATE_TABLE(motion_val_buf[i]);
 716         UPDATE_TABLE(ref_index_buf[i]);
 717     }
 718
 719     dst->mb_var        = src->mb_var;
 720     dst->mc_mb_var     = src->mc_mb_var;
 721     dst->mb_mean       = src->mb_mean;
 722     dst->mbskip_table  = src->mbskip_table;
 723     dst->qscale_table  = src->qscale_table;
 724     dst->mb_type       = src->mb_type;
 725     for (i = 0; i < 2; i++) {
 726         dst->motion_val[i] = src->motion_val[i];
 727         dst->ref_index[i]  = src->ref_index[i];
 728     }
 729
 730     return 0;
 731 }
 732
 733 int ff_mpeg_ref_picture(MpegEncContext *s, Picture *dst, Picture *src)
 734 {
 735     int ret;
 736
 737     av_assert0(!dst->f->buf[0]);
 738     av_assert0(src->f->buf[0]);
 739
 740     src->tf.f = src->f;
 741     dst->tf.f = dst->f;
 742     ret = ff_thread_ref_frame(&dst->tf, &src->tf);
 743     if (ret < 0)
 744         goto fail;
 745
 746     ret = update_picture_tables(dst, src);
 747     if (ret < 0)
 748         goto fail;
 749
 750     if (src->hwaccel_picture_private) {
 751         dst->hwaccel_priv_buf = av_buffer_ref(src->hwaccel_priv_buf);
 752         if (!dst->hwaccel_priv_buf)
 753             goto fail;
 754         dst->hwaccel_picture_private = dst->hwaccel_priv_buf->data;
 755     }
 756
 757     dst->field_picture           = src->field_picture;
 758     dst->mb_var_sum              = src->mb_var_sum;
 759     dst->mc_mb_var_sum           = src->mc_mb_var_sum;
 760     dst->b_frame_score           = src->b_frame_score;
 761     dst->needs_realloc           = src->needs_realloc;
 762     dst->reference               = src->reference;
 763     dst->shared                  = src->shared;
 764
 765     return 0;
 766 fail:
 767     ff_mpeg_unref_picture(s, dst);
 768     return ret;
 769 }
 770
 771 static void exchange_uv(MpegEncContext *s)
 772 {
 773     int16_t (*tmp)[64];
 774
 775     tmp           = s->pblocks[4];
 776     s->pblocks[4] = s->pblocks[5];
 777     s->pblocks[5] = tmp;
 778 }
 779
 780 static int init_duplicate_context(MpegEncContext *s)
 781 {
 782     int y_size = s->b8_stride * (2 * s->mb_height + 1);
 783     int c_size = s->mb_stride * (s->mb_height + 1);
 784     int yc_size = y_size + 2 * c_size;
 785     int i;
 786
 787     s->edge_emu_buffer =
 788     s->me.scratchpad   =
 789     s->me.temp         =
 790     s->rd_scratchpad   =
 791     s->b_scratchpad    =
 792     s->obmc_scratchpad = NULL;
 793
 794     if (s->encoding) {
 795         FF_ALLOCZ_OR_GOTO(s->avctx, s->me.map,
 796                           ME_MAP_SIZE * sizeof(uint32_t), fail)
 797         FF_ALLOCZ_OR_GOTO(s->avctx, s->me.score_map,
 798                           ME_MAP_SIZE * sizeof(uint32_t), fail)
 799         if (s->avctx->noise_reduction) {
 800             FF_ALLOCZ_OR_GOTO(s->avctx, s->dct_error_sum,
 801                               2 * 64 * sizeof(int), fail)
 802         }
 803     }
 804     FF_ALLOCZ_OR_GOTO(s->avctx, s->blocks, 64 * 12 * 2 * sizeof(int16_t), fail)
 805     s->block = s->blocks[0];
 806
 807     for (i = 0; i < 12; i++) {
 808         s->pblocks[i] = &s->block[i];
 809     }
 810     if (s->avctx->codec_tag == AV_RL32("VCR2"))
 811         exchange_uv(s);
 812
 813     if (s->out_format == FMT_H263) {
 814         /* ac values */
 815         FF_ALLOCZ_OR_GOTO(s->avctx, s->ac_val_base,
 816                           yc_size * sizeof(int16_t) * 16, fail);
 817         s->ac_val[0] = s->ac_val_base + s->b8_stride + 1;
 818         s->ac_val[1] = s->ac_val_base + y_size + s->mb_stride + 1;
 819         s->ac_val[2] = s->ac_val[1] + c_size;
 820     }
 821
 822     return 0;
 823 fail:
 824     return -1; // free() through ff_mpv_common_end()
 825 }
 826
 827 static void free_duplicate_context(MpegEncContext *s)
 828 {
 829     if (!s)
 830         return;
 831
 832     av_freep(&s->edge_emu_buffer);
 833     av_freep(&s->me.scratchpad);
 834     s->me.temp =
 835     s->rd_scratchpad =
 836     s->b_scratchpad =
 837     s->obmc_scratchpad = NULL;
 838
 839     av_freep(&s->dct_error_sum);
 840     av_freep(&s->me.map);
 841     av_freep(&s->me.score_map);
 842     av_freep(&s->blocks);
 843     av_freep(&s->ac_val_base);
 844     s->block = NULL;
 845 }
 846
 847 static void backup_duplicate_context(MpegEncContext *bak, MpegEncContext *src)
 848 {
 849 #define COPY(a) bak->a = src->a
 850     COPY(edge_emu_buffer);
 851     COPY(me.scratchpad);
 852     COPY(me.temp);
 853     COPY(rd_scratchpad);
 854     COPY(b_scratchpad);
 855     COPY(obmc_scratchpad);
 856     COPY(me.map);
 857     COPY(me.score_map);
 858     COPY(blocks);
 859     COPY(block);
 860     COPY(start_mb_y);
 861     COPY(end_mb_y);
 862     COPY(me.map_generation);
 863     COPY(pb);
 864     COPY(dct_error_sum);
 865     COPY(dct_count[0]);
 866     COPY(dct_count[1]);
 867     COPY(ac_val_base);
 868     COPY(ac_val[0]);
 869     COPY(ac_val[1]);
 870     COPY(ac_val[2]);
 871 #undef COPY
 872 }
 873
 874 int ff_update_duplicate_context(MpegEncContext *dst, MpegEncContext *src)
 875 {
 876     MpegEncContext bak;
 877     int i, ret;
 878     // FIXME copy only needed parts
 879     // START_TIMER
 880     backup_duplicate_context(&bak, dst);
 881     memcpy(dst, src, sizeof(MpegEncContext));
 882     backup_duplicate_context(dst, &bak);
 883     for (i = 0; i < 12; i++) {
 884         dst->pblocks[i] = &dst->block[i];
 885     }
 886     if (dst->avctx->codec_tag == AV_RL32("VCR2"))
 887         exchange_uv(dst);
 888     if (!dst->edge_emu_buffer &&
 889         (ret = frame_size_alloc(dst, dst->linesize)) < 0) {
 890         av_log(dst->avctx, AV_LOG_ERROR, "failed to allocate context "
 891                "scratch buffers.\n");
 892         return ret;
 893     }
 894     // STOP_TIMER("update_duplicate_context")
 895     // about 10k cycles / 0.01 sec for  1000frames on 1ghz with 2 threads
 896     return 0;
 897 }
 898
 899 int ff_mpeg_update_thread_context(AVCodecContext *dst,
 900                                   const AVCodecContext *src)
 901 {
 902     int i, ret;
 903     MpegEncContext *s = dst->priv_data, *s1 = src->priv_data;
 904
 905     if (dst == src || !s1->context_initialized)
 906         return 0;
 907
 908     // FIXME can parameters change on I-frames?
 909     // in that case dst may need a reinit
 910     if (!s->context_initialized) {
 911         memcpy(s, s1, sizeof(MpegEncContext));
 912
 913         s->avctx                 = dst;
 914         s->bitstream_buffer      = NULL;
 915         s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
 916
 917         ff_mpv_idct_init(s);
 918         ff_mpv_common_init(s);
 919     }
 920
 921     if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
 922         int err;
 923         s->context_reinit = 0;
 924         s->height = s1->height;
 925         s->width  = s1->width;
 926         if ((err = ff_mpv_common_frame_size_change(s)) < 0)
 927             return err;
 928     }
 929
 930     s->avctx->coded_height  = s1->avctx->coded_height;
 931     s->avctx->coded_width   = s1->avctx->coded_width;
 932     s->avctx->width         = s1->avctx->width;
 933     s->avctx->height        = s1->avctx->height;
 934
 935     s->coded_picture_number = s1->coded_picture_number;
 936     s->picture_number       = s1->picture_number;
 937
 938     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
 939         ff_mpeg_unref_picture(s, &s->picture[i]);
 940         if (s1->picture[i].f->buf[0] &&
 941             (ret = ff_mpeg_ref_picture(s, &s->picture[i], &s1->picture[i])) < 0)
 942             return ret;
 943     }
 944
 945 #define UPDATE_PICTURE(pic)\
 946 do {\
 947     ff_mpeg_unref_picture(s, &s->pic);\
 948     if (s1->pic.f->buf[0])\
 949         ret = ff_mpeg_ref_picture(s, &s->pic, &s1->pic);\
 950     else\
 951         ret = update_picture_tables(&s->pic, &s1->pic);\
 952     if (ret < 0)\
 953         return ret;\
 954 } while (0)
 955
 956     UPDATE_PICTURE(current_picture);
 957     UPDATE_PICTURE(last_picture);
 958     UPDATE_PICTURE(next_picture);
 959
 960     s->last_picture_ptr    = REBASE_PICTURE(s1->last_picture_ptr,    s, s1);
 961     s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
 962     s->next_picture_ptr    = REBASE_PICTURE(s1->next_picture_ptr,    s, s1);
 963
 964     // Error/bug resilience
 965     s->next_p_frame_damaged = s1->next_p_frame_damaged;
 966     s->workaround_bugs      = s1->workaround_bugs;
 967
 968     // MPEG4 timing info
 969     memcpy(&s->last_time_base, &s1->last_time_base,
 970            (char *) &s1->pb_field_time + sizeof(s1->pb_field_time) -
 971            (char *) &s1->last_time_base);
 972
 973     // B-frame info
 974     s->max_b_frames = s1->max_b_frames;
 975     s->low_delay    = s1->low_delay;
 976     s->droppable    = s1->droppable;
 977
 978     // DivX handling (doesn't work)
 979     s->divx_packed  = s1->divx_packed;
 980
 981     if (s1->bitstream_buffer) {
 982         if (s1->bitstream_buffer_size +
 983             FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
 984             av_fast_malloc(&s->bitstream_buffer,
 985                            &s->allocated_bitstream_buffer_size,
 986                            s1->allocated_bitstream_buffer_size);
 987             s->bitstream_buffer_size = s1->bitstream_buffer_size;
 988         memcpy(s->bitstream_buffer, s1->bitstream_buffer,
 989                s1->bitstream_buffer_size);
 990         memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
 991                FF_INPUT_BUFFER_PADDING_SIZE);
 992     }
 993
 994     // linesize dependend scratch buffer allocation
 995     if (!s->edge_emu_buffer)
 996         if (s1->linesize) {
 997             if (frame_size_alloc(s, s1->linesize) < 0) {
 998                 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate context "
 999                        "scratch buffers.\n");
1000                 return AVERROR(ENOMEM);
1001             }
1002         } else {
1003             av_log(s->avctx, AV_LOG_ERROR, "Context scratch buffers could not "
1004                    "be allocated due to unknown size.\n");
1005             return AVERROR_BUG;
1006         }
1007
1008     // MPEG2/interlacing info
1009     memcpy(&s->progressive_sequence, &s1->progressive_sequence,
1010            (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
1011
1012     if (!s1->first_field) {
1013         s->last_pict_type = s1->pict_type;
1014         if (s1->current_picture_ptr)
1015             s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f->quality;
1016     }
1017
1018     return 0;
1019 }
1020
1021 /**
1022  * Set the given MpegEncContext to common defaults
1023  * (same for encoding and decoding).
1024  * The changed fields will not depend upon the
1025  * prior state of the MpegEncContext.
1026  */
1027 void ff_mpv_common_defaults(MpegEncContext *s)
1028 {
1029     s->y_dc_scale_table      =
1030     s->c_dc_scale_table      = ff_mpeg1_dc_scale_table;
1031     s->chroma_qscale_table   = ff_default_chroma_qscale_table;
1032     s->progressive_frame     = 1;
1033     s->progressive_sequence  = 1;
1034     s->picture_structure     = PICT_FRAME;
1035
1036     s->coded_picture_number  = 0;
1037     s->picture_number        = 0;
1038
1039     s->f_code                = 1;
1040     s->b_code                = 1;
1041
1042     s->slice_context_count   = 1;
1043 }
1044
1045 /**
1046  * Set the given MpegEncContext to defaults for decoding.
1047  * the changed fields will not depend upon
1048  * the prior state of the MpegEncContext.
1049  */
1050 void ff_mpv_decode_defaults(MpegEncContext *s)
1051 {
1052     ff_mpv_common_defaults(s);
1053 }
1054
1055 static int init_er(MpegEncContext *s)
1056 {
1057     ERContext *er = &s->er;
1058     int mb_array_size = s->mb_height * s->mb_stride;
1059     int i;
1060
1061     er->avctx       = s->avctx;
1062     er->mecc        = &s->mecc;
1063
1064     er->mb_index2xy = s->mb_index2xy;
1065     er->mb_num      = s->mb_num;
1066     er->mb_width    = s->mb_width;
1067     er->mb_height   = s->mb_height;
1068     er->mb_stride   = s->mb_stride;
1069     er->b8_stride   = s->b8_stride;
1070
1071     er->er_temp_buffer     = av_malloc(s->mb_height * s->mb_stride);
1072     er->error_status_table = av_mallocz(mb_array_size);
1073     if (!er->er_temp_buffer || !er->error_status_table)
1074         goto fail;
1075
1076     er->mbskip_table  = s->mbskip_table;
1077     er->mbintra_table = s->mbintra_table;
1078
1079     for (i = 0; i < FF_ARRAY_ELEMS(s->dc_val); i++)
1080         er->dc_val[i] = s->dc_val[i];
1081
1082     er->decode_mb = mpeg_er_decode_mb;
1083     er->opaque    = s;
1084
1085     return 0;
1086 fail:
1087     av_freep(&er->er_temp_buffer);
1088     av_freep(&er->error_status_table);
1089     return AVERROR(ENOMEM);
1090 }
1091
1092 /**
1093  * Initialize and allocates MpegEncContext fields dependent on the resolution.
1094  */
1095 static int init_context_frame(MpegEncContext *s)
1096 {
1097     int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
1098
1099     s->mb_width   = (s->width + 15) / 16;
1100     s->mb_stride  = s->mb_width + 1;
1101     s->b8_stride  = s->mb_width * 2 + 1;
1102     mb_array_size = s->mb_height * s->mb_stride;
1103     mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
1104
1105     /* set default edge pos, will be overriden
1106      * in decode_header if needed */
1107     s->h_edge_pos = s->mb_width * 16;
1108     s->v_edge_pos = s->mb_height * 16;
1109
1110     s->mb_num     = s->mb_width * s->mb_height;
1111
1112     s->block_wrap[0] =
1113     s->block_wrap[1] =
1114     s->block_wrap[2] =
1115     s->block_wrap[3] = s->b8_stride;
1116     s->block_wrap[4] =
1117     s->block_wrap[5] = s->mb_stride;
1118
1119     y_size  = s->b8_stride * (2 * s->mb_height + 1);
1120     c_size  = s->mb_stride * (s->mb_height + 1);
1121     yc_size = y_size + 2   * c_size;
1122
1123     FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int),
1124                       fail); // error ressilience code looks cleaner with this
1125     for (y = 0; y < s->mb_height; y++)
1126         for (x = 0; x < s->mb_width; x++)
1127             s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
1128
1129     s->mb_index2xy[s->mb_height * s->mb_width] =
1130         (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
1131
1132     if (s->encoding) {
1133         /* Allocate MV tables */
1134         FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base,
1135                           mv_table_size * 2 * sizeof(int16_t), fail);
1136         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base,
1137                           mv_table_size * 2 * sizeof(int16_t), fail);
1138         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base,
1139                           mv_table_size * 2 * sizeof(int16_t), fail);
1140         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base,
1141                           mv_table_size * 2 * sizeof(int16_t), fail);
1142         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base,
1143                           mv_table_size * 2 * sizeof(int16_t), fail);
1144         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base,
1145                           mv_table_size * 2 * sizeof(int16_t), fail);
1146         s->p_mv_table            = s->p_mv_table_base + s->mb_stride + 1;
1147         s->b_forw_mv_table       = s->b_forw_mv_table_base + s->mb_stride + 1;
1148         s->b_back_mv_table       = s->b_back_mv_table_base + s->mb_stride + 1;
1149         s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base +
1150                                    s->mb_stride + 1;
1151         s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base +
1152                                    s->mb_stride + 1;
1153         s->b_direct_mv_table     = s->b_direct_mv_table_base + s->mb_stride + 1;
1154
1155         /* Allocate MB type table */
1156         FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size *
1157                           sizeof(uint16_t), fail); // needed for encoding
1158
1159         FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size *
1160                           sizeof(int), fail);
1161
1162         FF_ALLOC_OR_GOTO(s->avctx, s->cplx_tab,
1163                          mb_array_size * sizeof(float), fail);
1164         FF_ALLOC_OR_GOTO(s->avctx, s->bits_tab,
1165                          mb_array_size * sizeof(float), fail);
1166
1167     }
1168
1169     if (s->codec_id == AV_CODEC_ID_MPEG4 ||
1170         (s->flags & CODEC_FLAG_INTERLACED_ME)) {
1171         /* interlaced direct mode decoding tables */
1172         for (i = 0; i < 2; i++) {
1173             int j, k;
1174             for (j = 0; j < 2; j++) {
1175                 for (k = 0; k < 2; k++) {
1176                     FF_ALLOCZ_OR_GOTO(s->avctx,
1177                                       s->b_field_mv_table_base[i][j][k],
1178                                       mv_table_size * 2 * sizeof(int16_t),
1179                                       fail);
1180                     s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
1181                                                    s->mb_stride + 1;
1182                 }
1183                 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j],
1184                                   mb_array_size * 2 * sizeof(uint8_t), fail);
1185                 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j],
1186                                   mv_table_size * 2 * sizeof(int16_t), fail);
1187                 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j]
1188                                             + s->mb_stride + 1;
1189             }
1190             FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i],
1191                               mb_array_size * 2 * sizeof(uint8_t), fail);
1192         }
1193     }
1194     if (s->out_format == FMT_H263) {
1195         /* cbp values */
1196         FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size, fail);
1197         s->coded_block = s->coded_block_base + s->b8_stride + 1;
1198
1199         /* cbp, ac_pred, pred_dir */
1200         FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table,
1201                           mb_array_size * sizeof(uint8_t), fail);
1202         FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table,
1203                           mb_array_size * sizeof(uint8_t), fail);
1204     }
1205
1206     if (s->h263_pred || s->h263_plus || !s->encoding) {
1207         /* dc values */
1208         // MN: we need these for  error resilience of intra-frames
1209         FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base,
1210                           yc_size * sizeof(int16_t), fail);
1211         s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
1212         s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
1213         s->dc_val[2] = s->dc_val[1] + c_size;
1214         for (i = 0; i < yc_size; i++)
1215             s->dc_val_base[i] = 1024;
1216     }
1217
1218     /* which mb is a intra block */
1219     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
1220     memset(s->mbintra_table, 1, mb_array_size);
1221
1222     /* init macroblock skip table */
1223     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
1224     // Note the + 1 is for  a quicker mpeg4 slice_end detection
1225
1226     return init_er(s);
1227 fail:
1228     return AVERROR(ENOMEM);
1229 }
1230
1231 /**
1232  * init common structure for both encoder and decoder.
1233  * this assumes that some variables like width/height are already set
1234  */
1235 av_cold int ff_mpv_common_init(MpegEncContext *s)
1236 {
1237     int i;
1238     int nb_slices = (HAVE_THREADS &&
1239                      s->avctx->active_thread_type & FF_THREAD_SLICE) ?
1240                     s->avctx->thread_count : 1;
1241
1242     if (s->encoding && s->avctx->slices)
1243         nb_slices = s->avctx->slices;
1244
1245     if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1246         s->mb_height = (s->height + 31) / 32 * 2;
1247     else
1248         s->mb_height = (s->height + 15) / 16;
1249
1250     if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
1251         av_log(s->avctx, AV_LOG_ERROR,
1252                "decoding to AV_PIX_FMT_NONE is not supported.\n");
1253         return -1;
1254     }
1255
1256     if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
1257         int max_slices;
1258         if (s->mb_height)
1259             max_slices = FFMIN(MAX_THREADS, s->mb_height);
1260         else
1261             max_slices = MAX_THREADS;
1262         av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
1263                " reducing to %d\n", nb_slices, max_slices);
1264         nb_slices = max_slices;
1265     }
1266
1267     if ((s->width || s->height) &&
1268         av_image_check_size(s->width, s->height, 0, s->avctx))
1269         return -1;
1270
1271     dct_init(s);
1272
1273     s->flags  = s->avctx->flags;
1274     s->flags2 = s->avctx->flags2;
1275
1276     /* set chroma shifts */
1277     av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1278                                      &s->chroma_x_shift,
1279                                      &s->chroma_y_shift);
1280
1281     /* convert fourcc to upper case */
1282     s->codec_tag          = avpriv_toupper4(s->avctx->codec_tag);
1283
1284     s->stream_codec_tag   = avpriv_toupper4(s->avctx->stream_codec_tag);
1285
1286     FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
1287                       MAX_PICTURE_COUNT * sizeof(Picture), fail);
1288     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1289         s->picture[i].f = av_frame_alloc();
1290         if (!s->picture[i].f)
1291             goto fail;
1292     }
1293     memset(&s->next_picture, 0, sizeof(s->next_picture));
1294     memset(&s->last_picture, 0, sizeof(s->last_picture));
1295     memset(&s->current_picture, 0, sizeof(s->current_picture));
1296     memset(&s->new_picture, 0, sizeof(s->new_picture));
1297     s->next_picture.f = av_frame_alloc();
1298     if (!s->next_picture.f)
1299         goto fail;
1300     s->last_picture.f = av_frame_alloc();
1301     if (!s->last_picture.f)
1302         goto fail;
1303     s->current_picture.f = av_frame_alloc();
1304     if (!s->current_picture.f)
1305         goto fail;
1306     s->new_picture.f = av_frame_alloc();
1307     if (!s->new_picture.f)
1308         goto fail;
1309
1310     if (s->width && s->height) {
1311         if (init_context_frame(s))
1312             goto fail;
1313
1314         s->parse_context.state = -1;
1315     }
1316
1317     s->context_initialized = 1;
1318     s->thread_context[0]   = s;
1319
1320     if (s->width && s->height) {
1321         if (nb_slices > 1) {
1322             for (i = 1; i < nb_slices; i++) {
1323                 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1324                 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1325             }
1326
1327             for (i = 0; i < nb_slices; i++) {
1328                 if (init_duplicate_context(s->thread_context[i]) < 0)
1329                     goto fail;
1330                     s->thread_context[i]->start_mb_y =
1331                         (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1332                     s->thread_context[i]->end_mb_y   =
1333                         (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1334             }
1335         } else {
1336             if (init_duplicate_context(s) < 0)
1337                 goto fail;
1338             s->start_mb_y = 0;
1339             s->end_mb_y   = s->mb_height;
1340         }
1341         s->slice_context_count = nb_slices;
1342     }
1343
1344     return 0;
1345  fail:
1346     ff_mpv_common_end(s);
1347     return -1;
1348 }
1349
1350 /**
1351  * Frees and resets MpegEncContext fields depending on the resolution.
1352  * Is used during resolution changes to avoid a full reinitialization of the
1353  * codec.
1354  */
1355 static int free_context_frame(MpegEncContext *s)
1356 {
1357     int i, j, k;
1358
1359     av_freep(&s->mb_type);
1360     av_freep(&s->p_mv_table_base);
1361     av_freep(&s->b_forw_mv_table_base);
1362     av_freep(&s->b_back_mv_table_base);
1363     av_freep(&s->b_bidir_forw_mv_table_base);
1364     av_freep(&s->b_bidir_back_mv_table_base);
1365     av_freep(&s->b_direct_mv_table_base);
1366     s->p_mv_table            = NULL;
1367     s->b_forw_mv_table       = NULL;
1368     s->b_back_mv_table       = NULL;
1369     s->b_bidir_forw_mv_table = NULL;
1370     s->b_bidir_back_mv_table = NULL;
1371     s->b_direct_mv_table     = NULL;
1372     for (i = 0; i < 2; i++) {
1373         for (j = 0; j < 2; j++) {
1374             for (k = 0; k < 2; k++) {
1375                 av_freep(&s->b_field_mv_table_base[i][j][k]);
1376                 s->b_field_mv_table[i][j][k] = NULL;
1377             }
1378             av_freep(&s->b_field_select_table[i][j]);
1379             av_freep(&s->p_field_mv_table_base[i][j]);
1380             s->p_field_mv_table[i][j] = NULL;
1381         }
1382         av_freep(&s->p_field_select_table[i]);
1383     }
1384
1385     av_freep(&s->dc_val_base);
1386     av_freep(&s->coded_block_base);
1387     av_freep(&s->mbintra_table);
1388     av_freep(&s->cbp_table);
1389     av_freep(&s->pred_dir_table);
1390
1391     av_freep(&s->mbskip_table);
1392
1393     av_freep(&s->er.error_status_table);
1394     av_freep(&s->er.er_temp_buffer);
1395     av_freep(&s->mb_index2xy);
1396     av_freep(&s->lambda_table);
1397     av_freep(&s->cplx_tab);
1398     av_freep(&s->bits_tab);
1399
1400     s->linesize = s->uvlinesize = 0;
1401
1402     return 0;
1403 }
1404
1405 int ff_mpv_common_frame_size_change(MpegEncContext *s)
1406 {
1407     int i, err = 0;
1408
1409     if (s->slice_context_count > 1) {
1410         for (i = 0; i < s->slice_context_count; i++) {
1411             free_duplicate_context(s->thread_context[i]);
1412         }
1413         for (i = 1; i < s->slice_context_count; i++) {
1414             av_freep(&s->thread_context[i]);
1415         }
1416     } else
1417         free_duplicate_context(s);
1418
1419     if ((err = free_context_frame(s)) < 0)
1420         return err;
1421
1422     if (s->picture)
1423         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1424                 s->picture[i].needs_realloc = 1;
1425         }
1426
1427     s->last_picture_ptr         =
1428     s->next_picture_ptr         =
1429     s->current_picture_ptr      = NULL;
1430
1431     // init
1432     if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1433         s->mb_height = (s->height + 31) / 32 * 2;
1434     else
1435         s->mb_height = (s->height + 15) / 16;
1436
1437     if ((s->width || s->height) &&
1438         av_image_check_size(s->width, s->height, 0, s->avctx))
1439         return AVERROR_INVALIDDATA;
1440
1441     if ((err = init_context_frame(s)))
1442         goto fail;
1443
1444     s->thread_context[0]   = s;
1445
1446     if (s->width && s->height) {
1447         int nb_slices = s->slice_context_count;
1448         if (nb_slices > 1) {
1449             for (i = 1; i < nb_slices; i++) {
1450                 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1451                 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1452             }
1453
1454             for (i = 0; i < nb_slices; i++) {
1455                 if (init_duplicate_context(s->thread_context[i]) < 0)
1456                     goto fail;
1457                     s->thread_context[i]->start_mb_y =
1458                         (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1459                     s->thread_context[i]->end_mb_y   =
1460                         (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1461             }
1462         } else {
1463             if (init_duplicate_context(s) < 0)
1464                 goto fail;
1465             s->start_mb_y = 0;
1466             s->end_mb_y   = s->mb_height;
1467         }
1468         s->slice_context_count = nb_slices;
1469     }
1470
1471     return 0;
1472  fail:
1473     ff_mpv_common_end(s);
1474     return err;
1475 }
1476
1477 /* init common structure for both encoder and decoder */
1478 void ff_mpv_common_end(MpegEncContext *s)
1479 {
1480     int i;
1481
1482     if (s->slice_context_count > 1) {
1483         for (i = 0; i < s->slice_context_count; i++) {
1484             free_duplicate_context(s->thread_context[i]);
1485         }
1486         for (i = 1; i < s->slice_context_count; i++) {
1487             av_freep(&s->thread_context[i]);
1488         }
1489         s->slice_context_count = 1;
1490     } else free_duplicate_context(s);
1491
1492     av_freep(&s->parse_context.buffer);
1493     s->parse_context.buffer_size = 0;
1494
1495     av_freep(&s->bitstream_buffer);
1496     s->allocated_bitstream_buffer_size = 0;
1497
1498     if (s->picture) {
1499         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1500             ff_free_picture_tables(&s->picture[i]);
1501             ff_mpeg_unref_picture(s, &s->picture[i]);
1502             av_frame_free(&s->picture[i].f);
1503         }
1504     }
1505     av_freep(&s->picture);
1506     ff_free_picture_tables(&s->last_picture);
1507     ff_mpeg_unref_picture(s, &s->last_picture);
1508     av_frame_free(&s->last_picture.f);
1509     ff_free_picture_tables(&s->current_picture);
1510     ff_mpeg_unref_picture(s, &s->current_picture);
1511     av_frame_free(&s->current_picture.f);
1512     ff_free_picture_tables(&s->next_picture);
1513     ff_mpeg_unref_picture(s, &s->next_picture);
1514     av_frame_free(&s->next_picture.f);
1515     ff_free_picture_tables(&s->new_picture);
1516     ff_mpeg_unref_picture(s, &s->new_picture);
1517     av_frame_free(&s->new_picture.f);
1518
1519     free_context_frame(s);
1520
1521     s->context_initialized      = 0;
1522     s->last_picture_ptr         =
1523     s->next_picture_ptr         =
1524     s->current_picture_ptr      = NULL;
1525     s->linesize = s->uvlinesize = 0;
1526 }
1527
1528 av_cold void ff_init_rl(RLTable *rl,
1529                         uint8_t static_store[2][2 * MAX_RUN + MAX_LEVEL + 3])
1530 {
1531     int8_t  max_level[MAX_RUN + 1], max_run[MAX_LEVEL + 1];
1532     uint8_t index_run[MAX_RUN + 1];
1533     int last, run, level, start, end, i;
1534
1535     /* If table is static, we can quit if rl->max_level[0] is not NULL */
1536     if (static_store && rl->max_level[0])
1537         return;
1538
1539     /* compute max_level[], max_run[] and index_run[] */
1540     for (last = 0; last < 2; last++) {
1541         if (last == 0) {
1542             start = 0;
1543             end = rl->last;
1544         } else {
1545             start = rl->last;
1546             end = rl->n;
1547         }
1548
1549         memset(max_level, 0, MAX_RUN + 1);
1550         memset(max_run, 0, MAX_LEVEL + 1);
1551         memset(index_run, rl->n, MAX_RUN + 1);
1552         for (i = start; i < end; i++) {
1553             run   = rl->table_run[i];
1554             level = rl->table_level[i];
1555             if (index_run[run] == rl->n)
1556                 index_run[run] = i;
1557             if (level > max_level[run])
1558                 max_level[run] = level;
1559             if (run > max_run[level])
1560                 max_run[level] = run;
1561         }
1562         if (static_store)
1563             rl->max_level[last] = static_store[last];
1564         else
1565             rl->max_level[last] = av_malloc(MAX_RUN + 1);
1566         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1567         if (static_store)
1568             rl->max_run[last]   = static_store[last] + MAX_RUN + 1;
1569         else
1570             rl->max_run[last]   = av_malloc(MAX_LEVEL + 1);
1571         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1572         if (static_store)
1573             rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
1574         else
1575             rl->index_run[last] = av_malloc(MAX_RUN + 1);
1576         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1577     }
1578 }
1579
1580 av_cold void ff_init_vlc_rl(RLTable *rl)
1581 {
1582     int i, q;
1583
1584     for (q = 0; q < 32; q++) {
1585         int qmul = q * 2;
1586         int qadd = (q - 1) | 1;
1587
1588         if (q == 0) {
1589             qmul = 1;
1590             qadd = 0;
1591         }
1592         for (i = 0; i < rl->vlc.table_size; i++) {
1593             int code = rl->vlc.table[i][0];
1594             int len  = rl->vlc.table[i][1];
1595             int level, run;
1596
1597             if (len == 0) { // illegal code
1598                 run   = 66;
1599                 level = MAX_LEVEL;
1600             } else if (len < 0) { // more bits needed
1601                 run   = 0;
1602                 level = code;
1603             } else {
1604                 if (code == rl->n) { // esc
1605                     run   = 66;
1606                     level =  0;
1607                 } else {
1608                     run   = rl->table_run[code] + 1;
1609                     level = rl->table_level[code] * qmul + qadd;
1610                     if (code >= rl->last) run += 192;
1611                 }
1612             }
1613             rl->rl_vlc[q][i].len   = len;
1614             rl->rl_vlc[q][i].level = level;
1615             rl->rl_vlc[q][i].run   = run;
1616         }
1617     }
1618 }
1619
1620 static void release_unused_pictures(MpegEncContext *s)
1621 {
1622     int i;
1623
1624     /* release non reference frames */
1625     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1626         if (!s->picture[i].reference)
1627             ff_mpeg_unref_picture(s, &s->picture[i]);
1628     }
1629 }
1630
1631 static inline int pic_is_unused(MpegEncContext *s, Picture *pic)
1632 {
1633     if (!pic->f->buf[0])
1634         return 1;
1635     if (pic->needs_realloc && !(pic->reference & DELAYED_PIC_REF))
1636         return 1;
1637     return 0;
1638 }
1639
1640 static int find_unused_picture(MpegEncContext *s, int shared)
1641 {
1642     int i;
1643
1644     if (shared) {
1645         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1646             if (!s->picture[i].f->buf[0])
1647                 return i;
1648         }
1649     } else {
1650         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1651             if (pic_is_unused(s, &s->picture[i]))
1652                 return i;
1653         }
1654     }
1655
1656     return AVERROR_INVALIDDATA;
1657 }
1658
1659 int ff_find_unused_picture(MpegEncContext *s, int shared)
1660 {
1661     int ret = find_unused_picture(s, shared);
1662
1663     if (ret >= 0 && ret < MAX_PICTURE_COUNT) {
1664         if (s->picture[ret].needs_realloc) {
1665             s->picture[ret].needs_realloc = 0;
1666             ff_free_picture_tables(&s->picture[ret]);
1667             ff_mpeg_unref_picture(s, &s->picture[ret]);
1668         }
1669     }
1670     return ret;
1671 }
1672
1673 /**
1674  * generic function called after decoding
1675  * the header and before a frame is decoded.
1676  */
1677 int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1678 {
1679     int i, ret;
1680     Picture *pic;
1681     s->mb_skipped = 0;
1682
1683     /* mark & release old frames */
1684     if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1685         s->last_picture_ptr != s->next_picture_ptr &&
1686         s->last_picture_ptr->f->buf[0]) {
1687         ff_mpeg_unref_picture(s, s->last_picture_ptr);
1688     }
1689
1690     /* release forgotten pictures */
1691     /* if (mpeg124/h263) */
1692     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1693         if (&s->picture[i] != s->last_picture_ptr &&
1694             &s->picture[i] != s->next_picture_ptr &&
1695             s->picture[i].reference && !s->picture[i].needs_realloc) {
1696             if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1697                 av_log(avctx, AV_LOG_ERROR,
1698                        "releasing zombie picture\n");
1699             ff_mpeg_unref_picture(s, &s->picture[i]);
1700         }
1701     }
1702
1703     ff_mpeg_unref_picture(s, &s->current_picture);
1704
1705     release_unused_pictures(s);
1706
1707     if (s->current_picture_ptr && !s->current_picture_ptr->f->buf[0]) {
1708         // we already have a unused image
1709         // (maybe it was set before reading the header)
1710         pic = s->current_picture_ptr;
1711     } else {
1712         i   = ff_find_unused_picture(s, 0);
1713         if (i < 0) {
1714             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1715             return i;
1716         }
1717         pic = &s->picture[i];
1718     }
1719
1720     pic->reference = 0;
1721     if (!s->droppable) {
1722         if (s->pict_type != AV_PICTURE_TYPE_B)
1723             pic->reference = 3;
1724     }
1725
1726     pic->f->coded_picture_number = s->coded_picture_number++;
1727
1728     if (ff_alloc_picture(s, pic, 0) < 0)
1729         return -1;
1730
1731     s->current_picture_ptr = pic;
1732     // FIXME use only the vars from current_pic
1733     s->current_picture_ptr->f->top_field_first = s->top_field_first;
1734     if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1735         s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1736         if (s->picture_structure != PICT_FRAME)
1737             s->current_picture_ptr->f->top_field_first =
1738                 (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1739     }
1740     s->current_picture_ptr->f->interlaced_frame = !s->progressive_frame &&
1741                                                  !s->progressive_sequence;
1742     s->current_picture_ptr->field_picture      =  s->picture_structure != PICT_FRAME;
1743
1744     s->current_picture_ptr->f->pict_type = s->pict_type;
1745     // if (s->flags && CODEC_FLAG_QSCALE)
1746     //     s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1747     s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1748
1749     if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1750                                    s->current_picture_ptr)) < 0)
1751         return ret;
1752
1753     if (s->pict_type != AV_PICTURE_TYPE_B) {
1754         s->last_picture_ptr = s->next_picture_ptr;
1755         if (!s->droppable)
1756             s->next_picture_ptr = s->current_picture_ptr;
1757     }
1758     av_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1759             s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1760             s->last_picture_ptr    ? s->last_picture_ptr->f->data[0]    : NULL,
1761             s->next_picture_ptr    ? s->next_picture_ptr->f->data[0]    : NULL,
1762             s->current_picture_ptr ? s->current_picture_ptr->f->data[0] : NULL,
1763             s->pict_type, s->droppable);
1764
1765     if ((!s->last_picture_ptr || !s->last_picture_ptr->f->buf[0]) &&
1766         (s->pict_type != AV_PICTURE_TYPE_I ||
1767          s->picture_structure != PICT_FRAME)) {
1768         int h_chroma_shift, v_chroma_shift;
1769         av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1770                                          &h_chroma_shift, &v_chroma_shift);
1771         if (s->pict_type != AV_PICTURE_TYPE_I)
1772             av_log(avctx, AV_LOG_ERROR,
1773                    "warning: first frame is no keyframe\n");
1774         else if (s->picture_structure != PICT_FRAME)
1775             av_log(avctx, AV_LOG_INFO,
1776                    "allocate dummy last picture for field based first keyframe\n");
1777
1778         /* Allocate a dummy frame */
1779         i = ff_find_unused_picture(s, 0);
1780         if (i < 0) {
1781             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1782             return i;
1783         }
1784         s->last_picture_ptr = &s->picture[i];
1785
1786         s->last_picture_ptr->reference   = 3;
1787         s->last_picture_ptr->f->pict_type = AV_PICTURE_TYPE_I;
1788
1789         if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1790             s->last_picture_ptr = NULL;
1791             return -1;
1792         }
1793
1794         memset(s->last_picture_ptr->f->data[0], 0,
1795                avctx->height * s->last_picture_ptr->f->linesize[0]);
1796         memset(s->last_picture_ptr->f->data[1], 0x80,
1797                (avctx->height >> v_chroma_shift) *
1798                s->last_picture_ptr->f->linesize[1]);
1799         memset(s->last_picture_ptr->f->data[2], 0x80,
1800                (avctx->height >> v_chroma_shift) *
1801                s->last_picture_ptr->f->linesize[2]);
1802
1803         ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 0);
1804         ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 1);
1805     }
1806     if ((!s->next_picture_ptr || !s->next_picture_ptr->f->buf[0]) &&
1807         s->pict_type == AV_PICTURE_TYPE_B) {
1808         /* Allocate a dummy frame */
1809         i = ff_find_unused_picture(s, 0);
1810         if (i < 0) {
1811             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1812             return i;
1813         }
1814         s->next_picture_ptr = &s->picture[i];
1815
1816         s->next_picture_ptr->reference   = 3;
1817         s->next_picture_ptr->f->pict_type = AV_PICTURE_TYPE_I;
1818
1819         if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1820             s->next_picture_ptr = NULL;
1821             return -1;
1822         }
1823         ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 0);
1824         ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 1);
1825     }
1826
1827     if (s->last_picture_ptr) {
1828         ff_mpeg_unref_picture(s, &s->last_picture);
1829         if (s->last_picture_ptr->f->buf[0] &&
1830             (ret = ff_mpeg_ref_picture(s, &s->last_picture,
1831                                        s->last_picture_ptr)) < 0)
1832             return ret;
1833     }
1834     if (s->next_picture_ptr) {
1835         ff_mpeg_unref_picture(s, &s->next_picture);
1836         if (s->next_picture_ptr->f->buf[0] &&
1837             (ret = ff_mpeg_ref_picture(s, &s->next_picture,
1838                                        s->next_picture_ptr)) < 0)
1839             return ret;
1840     }
1841
1842     if (s->pict_type != AV_PICTURE_TYPE_I &&
1843         !(s->last_picture_ptr && s->last_picture_ptr->f->buf[0])) {
1844         av_log(s, AV_LOG_ERROR,
1845                "Non-reference picture received and no reference available\n");
1846         return AVERROR_INVALIDDATA;
1847     }
1848
1849     if (s->picture_structure!= PICT_FRAME) {
1850         int i;
1851         for (i = 0; i < 4; i++) {
1852             if (s->picture_structure == PICT_BOTTOM_FIELD) {
1853                 s->current_picture.f->data[i] +=
1854                     s->current_picture.f->linesize[i];
1855             }
1856             s->current_picture.f->linesize[i] *= 2;
1857             s->last_picture.f->linesize[i]    *= 2;
1858             s->next_picture.f->linesize[i]    *= 2;
1859         }
1860     }
1861
1862     s->err_recognition = avctx->err_recognition;
1863
1864     /* set dequantizer, we can't do it during init as
1865      * it might change for mpeg4 and we can't do it in the header
1866      * decode as init is not called for mpeg4 there yet */
1867     if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1868         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1869         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1870     } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1871         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1872         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1873     } else {
1874         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1875         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1876     }
1877
1878 #if FF_API_XVMC
1879 FF_DISABLE_DEPRECATION_WARNINGS
1880     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration)
1881         return ff_xvmc_field_start(s, avctx);
1882 FF_ENABLE_DEPRECATION_WARNINGS
1883 #endif /* FF_API_XVMC */
1884
1885     return 0;
1886 }
1887
1888 /* called after a frame has been decoded. */
1889 void ff_mpv_frame_end(MpegEncContext *s)
1890 {
1891 #if FF_API_XVMC
1892 FF_DISABLE_DEPRECATION_WARNINGS
1893     /* redraw edges for the frame if decoding didn't complete */
1894     // just to make sure that all data is rendered.
1895     if (CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration) {
1896         ff_xvmc_field_end(s);
1897     } else
1898 FF_ENABLE_DEPRECATION_WARNINGS
1899 #endif /* FF_API_XVMC */
1900
1901     emms_c();
1902
1903     if (s->current_picture.reference)
1904         ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);
1905 }
1906
1907 /**
1908  * Print debugging info for the given picture.
1909  */
1910 void ff_print_debug_info(MpegEncContext *s, Picture *p)
1911 {
1912     AVFrame *pict;
1913     if (s->avctx->hwaccel || !p || !p->mb_type)
1914         return;
1915     pict = p->f;
1916
1917     if (s->avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
1918         int x,y;
1919
1920         av_log(s->avctx,AV_LOG_DEBUG,"New frame, type: ");
1921         switch (pict->pict_type) {
1922         case AV_PICTURE_TYPE_I:
1923             av_log(s->avctx,AV_LOG_DEBUG,"I\n");
1924             break;
1925         case AV_PICTURE_TYPE_P:
1926             av_log(s->avctx,AV_LOG_DEBUG,"P\n");
1927             break;
1928         case AV_PICTURE_TYPE_B:
1929             av_log(s->avctx,AV_LOG_DEBUG,"B\n");
1930             break;
1931         case AV_PICTURE_TYPE_S:
1932             av_log(s->avctx,AV_LOG_DEBUG,"S\n");
1933             break;
1934         case AV_PICTURE_TYPE_SI:
1935             av_log(s->avctx,AV_LOG_DEBUG,"SI\n");
1936             break;
1937         case AV_PICTURE_TYPE_SP:
1938             av_log(s->avctx,AV_LOG_DEBUG,"SP\n");
1939             break;
1940         }
1941         for (y = 0; y < s->mb_height; y++) {
1942             for (x = 0; x < s->mb_width; x++) {
1943                 if (s->avctx->debug & FF_DEBUG_SKIP) {
1944                     int count = s->mbskip_table[x + y * s->mb_stride];
1945                     if (count > 9)
1946                         count = 9;
1947                     av_log(s->avctx, AV_LOG_DEBUG, "%1d", count);
1948                 }
1949                 if (s->avctx->debug & FF_DEBUG_QP) {
1950                     av_log(s->avctx, AV_LOG_DEBUG, "%2d",
1951                            p->qscale_table[x + y * s->mb_stride]);
1952                 }
1953                 if (s->avctx->debug & FF_DEBUG_MB_TYPE) {
1954                     int mb_type = p->mb_type[x + y * s->mb_stride];
1955                     // Type & MV direction
1956                     if (IS_PCM(mb_type))
1957                         av_log(s->avctx, AV_LOG_DEBUG, "P");
1958                     else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
1959                         av_log(s->avctx, AV_LOG_DEBUG, "A");
1960                     else if (IS_INTRA4x4(mb_type))
1961                         av_log(s->avctx, AV_LOG_DEBUG, "i");
1962                     else if (IS_INTRA16x16(mb_type))
1963                         av_log(s->avctx, AV_LOG_DEBUG, "I");
1964                     else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
1965                         av_log(s->avctx, AV_LOG_DEBUG, "d");
1966                     else if (IS_DIRECT(mb_type))
1967                         av_log(s->avctx, AV_LOG_DEBUG, "D");
1968                     else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
1969                         av_log(s->avctx, AV_LOG_DEBUG, "g");
1970                     else if (IS_GMC(mb_type))
1971                         av_log(s->avctx, AV_LOG_DEBUG, "G");
1972                     else if (IS_SKIP(mb_type))
1973                         av_log(s->avctx, AV_LOG_DEBUG, "S");
1974                     else if (!USES_LIST(mb_type, 1))
1975                         av_log(s->avctx, AV_LOG_DEBUG, ">");
1976                     else if (!USES_LIST(mb_type, 0))
1977                         av_log(s->avctx, AV_LOG_DEBUG, "<");
1978                     else {
1979                         assert(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
1980                         av_log(s->avctx, AV_LOG_DEBUG, "X");
1981                     }
1982
1983                     // segmentation
1984                     if (IS_8X8(mb_type))
1985                         av_log(s->avctx, AV_LOG_DEBUG, "+");
1986                     else if (IS_16X8(mb_type))
1987                         av_log(s->avctx, AV_LOG_DEBUG, "-");
1988                     else if (IS_8X16(mb_type))
1989                         av_log(s->avctx, AV_LOG_DEBUG, "|");
1990                     else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
1991                         av_log(s->avctx, AV_LOG_DEBUG, " ");
1992                     else
1993                         av_log(s->avctx, AV_LOG_DEBUG, "?");
1994
1995
1996                     if (IS_INTERLACED(mb_type))
1997                         av_log(s->avctx, AV_LOG_DEBUG, "=");
1998                     else
1999                         av_log(s->avctx, AV_LOG_DEBUG, " ");
2000                 }
2001             }
2002             av_log(s->avctx, AV_LOG_DEBUG, "\n");
2003         }
2004     }
2005 }
2006
2007 /**
2008  * find the lowest MB row referenced in the MVs
2009  */
2010 int ff_mpv_lowest_referenced_row(MpegEncContext *s, int dir)
2011 {
2012     int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2013     int my, off, i, mvs;
2014
2015     if (s->picture_structure != PICT_FRAME || s->mcsel)
2016         goto unhandled;
2017
2018     switch (s->mv_type) {
2019         case MV_TYPE_16X16:
2020             mvs = 1;
2021             break;
2022         case MV_TYPE_16X8:
2023             mvs = 2;
2024             break;
2025         case MV_TYPE_8X8:
2026             mvs = 4;
2027             break;
2028         default:
2029             goto unhandled;
2030     }
2031
2032     for (i = 0; i < mvs; i++) {
2033         my = s->mv[dir][i][1]<<qpel_shift;
2034         my_max = FFMAX(my_max, my);
2035         my_min = FFMIN(my_min, my);
2036     }
2037
2038     off = (FFMAX(-my_min, my_max) + 63) >> 6;
2039
2040     return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
2041 unhandled:
2042     return s->mb_height-1;
2043 }
2044
2045 /* put block[] to dest[] */
2046 static inline void put_dct(MpegEncContext *s,
2047                            int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2048 {
2049     s->dct_unquantize_intra(s, block, i, qscale);
2050     s->idsp.idct_put(dest, line_size, block);
2051 }
2052
2053 /* add block[] to dest[] */
2054 static inline void add_dct(MpegEncContext *s,
2055                            int16_t *block, int i, uint8_t *dest, int line_size)
2056 {
2057     if (s->block_last_index[i] >= 0) {
2058         s->idsp.idct_add(dest, line_size, block);
2059     }
2060 }
2061
2062 static inline void add_dequant_dct(MpegEncContext *s,
2063                            int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2064 {
2065     if (s->block_last_index[i] >= 0) {
2066         s->dct_unquantize_inter(s, block, i, qscale);
2067
2068         s->idsp.idct_add(dest, line_size, block);
2069     }
2070 }
2071
2072 /**
2073  * Clean dc, ac, coded_block for the current non-intra MB.
2074  */
2075 void ff_clean_intra_table_entries(MpegEncContext *s)
2076 {
2077     int wrap = s->b8_stride;
2078     int xy = s->block_index[0];
2079
2080     s->dc_val[0][xy           ] =
2081     s->dc_val[0][xy + 1       ] =
2082     s->dc_val[0][xy     + wrap] =
2083     s->dc_val[0][xy + 1 + wrap] = 1024;
2084     /* ac pred */
2085     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
2086     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
2087     if (s->msmpeg4_version>=3) {
2088         s->coded_block[xy           ] =
2089         s->coded_block[xy + 1       ] =
2090         s->coded_block[xy     + wrap] =
2091         s->coded_block[xy + 1 + wrap] = 0;
2092     }
2093     /* chroma */
2094     wrap = s->mb_stride;
2095     xy = s->mb_x + s->mb_y * wrap;
2096     s->dc_val[1][xy] =
2097     s->dc_val[2][xy] = 1024;
2098     /* ac pred */
2099     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
2100     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
2101
2102     s->mbintra_table[xy]= 0;
2103 }
2104
2105 /* generic function called after a macroblock has been parsed by the
2106    decoder or after it has been encoded by the encoder.
2107
2108    Important variables used:
2109    s->mb_intra : true if intra macroblock
2110    s->mv_dir   : motion vector direction
2111    s->mv_type  : motion vector type
2112    s->mv       : motion vector
2113    s->interlaced_dct : true if interlaced dct used (mpeg2)
2114  */
2115 static av_always_inline
2116 void mpv_decode_mb_internal(MpegEncContext *s, int16_t block[12][64],
2117                             int is_mpeg12)
2118 {
2119     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
2120
2121 #if FF_API_XVMC
2122 FF_DISABLE_DEPRECATION_WARNINGS
2123     if(CONFIG_MPEG_XVMC_DECODER && s->avctx->xvmc_acceleration){
2124         ff_xvmc_decode_mb(s);//xvmc uses pblocks
2125         return;
2126     }
2127 FF_ENABLE_DEPRECATION_WARNINGS
2128 #endif /* FF_API_XVMC */
2129
2130     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
2131        /* print DCT coefficients */
2132        int i,j;
2133        av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
2134        for(i=0; i<6; i++){
2135            for(j=0; j<64; j++){
2136                av_log(s->avctx, AV_LOG_DEBUG, "%5d",
2137                       block[i][s->idsp.idct_permutation[j]]);
2138            }
2139            av_log(s->avctx, AV_LOG_DEBUG, "\n");
2140        }
2141     }
2142
2143     s->current_picture.qscale_table[mb_xy] = s->qscale;
2144
2145     /* update DC predictors for P macroblocks */
2146     if (!s->mb_intra) {
2147         if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
2148             if(s->mbintra_table[mb_xy])
2149                 ff_clean_intra_table_entries(s);
2150         } else {
2151             s->last_dc[0] =
2152             s->last_dc[1] =
2153             s->last_dc[2] = 128 << s->intra_dc_precision;
2154         }
2155     }
2156     else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
2157         s->mbintra_table[mb_xy]=1;
2158
2159     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
2160         uint8_t *dest_y, *dest_cb, *dest_cr;
2161         int dct_linesize, dct_offset;
2162         op_pixels_func (*op_pix)[4];
2163         qpel_mc_func (*op_qpix)[16];
2164         const int linesize   = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
2165         const int uvlinesize = s->current_picture.f->linesize[1];
2166         const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band;
2167         const int block_size = 8;
2168
2169         /* avoid copy if macroblock skipped in last frame too */
2170         /* skip only during decoding as we might trash the buffers during encoding a bit */
2171         if(!s->encoding){
2172             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
2173
2174             if (s->mb_skipped) {
2175                 s->mb_skipped= 0;
2176                 assert(s->pict_type!=AV_PICTURE_TYPE_I);
2177                 *mbskip_ptr = 1;
2178             } else if(!s->current_picture.reference) {
2179                 *mbskip_ptr = 1;
2180             } else{
2181                 *mbskip_ptr = 0; /* not skipped */
2182             }
2183         }
2184
2185         dct_linesize = linesize << s->interlaced_dct;
2186         dct_offset   = s->interlaced_dct ? linesize : linesize * block_size;
2187
2188         if(readable){
2189             dest_y=  s->dest[0];
2190             dest_cb= s->dest[1];
2191             dest_cr= s->dest[2];
2192         }else{
2193             dest_y = s->b_scratchpad;
2194             dest_cb= s->b_scratchpad+16*linesize;
2195             dest_cr= s->b_scratchpad+32*linesize;
2196         }
2197
2198         if (!s->mb_intra) {
2199             /* motion handling */
2200             /* decoding or more than one mb_type (MC was already done otherwise) */
2201             if(!s->encoding){
2202
2203                 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
2204                     if (s->mv_dir & MV_DIR_FORWARD) {
2205                         ff_thread_await_progress(&s->last_picture_ptr->tf,
2206                                                  ff_mpv_lowest_referenced_row(s, 0),
2207                                                  0);
2208                     }
2209                     if (s->mv_dir & MV_DIR_BACKWARD) {
2210                         ff_thread_await_progress(&s->next_picture_ptr->tf,
2211                                                  ff_mpv_lowest_referenced_row(s, 1),
2212                                                  0);
2213                     }
2214                 }
2215
2216                 op_qpix= s->me.qpel_put;
2217                 if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
2218                     op_pix = s->hdsp.put_pixels_tab;
2219                 }else{
2220                     op_pix = s->hdsp.put_no_rnd_pixels_tab;
2221                 }
2222                 if (s->mv_dir & MV_DIR_FORWARD) {
2223                     ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix, op_qpix);
2224                     op_pix = s->hdsp.avg_pixels_tab;
2225                     op_qpix= s->me.qpel_avg;
2226                 }
2227                 if (s->mv_dir & MV_DIR_BACKWARD) {
2228                     ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix, op_qpix);
2229                 }
2230             }
2231
2232             /* skip dequant / idct if we are really late ;) */
2233             if(s->avctx->skip_idct){
2234                 if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
2235                    ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
2236                    || s->avctx->skip_idct >= AVDISCARD_ALL)
2237                     goto skip_idct;
2238             }
2239
2240             /* add dct residue */
2241             if(s->encoding || !(   s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
2242                                 || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
2243                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2244                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2245                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2246                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2247
2248                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2249                     if (s->chroma_y_shift){
2250                         add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2251                         add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2252                     }else{
2253                         dct_linesize >>= 1;
2254                         dct_offset >>=1;
2255                         add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2256                         add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2257                         add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2258                         add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2259                     }
2260                 }
2261             } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
2262                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
2263                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
2264                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
2265                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
2266
2267                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2268                     if(s->chroma_y_shift){//Chroma420
2269                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
2270                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
2271                     }else{
2272                         //chroma422
2273                         dct_linesize = uvlinesize << s->interlaced_dct;
2274                         dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize * 8;
2275
2276                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
2277                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
2278                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
2279                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
2280                         if(!s->chroma_x_shift){//Chroma444
2281                             add_dct(s, block[8], 8, dest_cb+8, dct_linesize);
2282                             add_dct(s, block[9], 9, dest_cr+8, dct_linesize);
2283                             add_dct(s, block[10], 10, dest_cb+8+dct_offset, dct_linesize);
2284                             add_dct(s, block[11], 11, dest_cr+8+dct_offset, dct_linesize);
2285                         }
2286                     }
2287                 }//fi gray
2288             }
2289             else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
2290                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
2291             }
2292         } else {
2293             /* dct only in intra block */
2294             if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
2295                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
2296                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
2297                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
2298                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
2299
2300                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2301                     if(s->chroma_y_shift){
2302                         put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
2303                         put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
2304                     }else{
2305                         dct_offset >>=1;
2306                         dct_linesize >>=1;
2307                         put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
2308                         put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
2309                         put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
2310                         put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
2311                     }
2312                 }
2313             }else{
2314                 s->idsp.idct_put(dest_y,                           dct_linesize, block[0]);
2315                 s->idsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
2316                 s->idsp.idct_put(dest_y + dct_offset,              dct_linesize, block[2]);
2317                 s->idsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
2318
2319                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
2320                     if(s->chroma_y_shift){
2321                         s->idsp.idct_put(dest_cb, uvlinesize, block[4]);
2322                         s->idsp.idct_put(dest_cr, uvlinesize, block[5]);
2323                     }else{
2324
2325                         dct_linesize = uvlinesize << s->interlaced_dct;
2326                         dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize * 8;
2327
2328                         s->idsp.idct_put(dest_cb,              dct_linesize, block[4]);
2329                         s->idsp.idct_put(dest_cr,              dct_linesize, block[5]);
2330                         s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
2331                         s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
2332                         if(!s->chroma_x_shift){//Chroma444
2333                             s->idsp.idct_put(dest_cb + 8,              dct_linesize, block[8]);
2334                             s->idsp.idct_put(dest_cr + 8,              dct_linesize, block[9]);
2335                             s->idsp.idct_put(dest_cb + 8 + dct_offset, dct_linesize, block[10]);
2336                             s->idsp.idct_put(dest_cr + 8 + dct_offset, dct_linesize, block[11]);
2337                         }
2338                     }
2339                 }//gray
2340             }
2341         }
2342 skip_idct:
2343         if(!readable){
2344             s->hdsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
2345             s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
2346             s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
2347         }
2348     }
2349 }
2350
2351 void ff_mpv_decode_mb(MpegEncContext *s, int16_t block[12][64])
2352 {
2353 #if !CONFIG_SMALL
2354     if(s->out_format == FMT_MPEG1) {
2355         mpv_decode_mb_internal(s, block, 1);
2356     } else
2357 #endif
2358         mpv_decode_mb_internal(s, block, 0);
2359 }
2360
2361 void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
2362 {
2363     ff_draw_horiz_band(s->avctx, s->current_picture.f,
2364                        s->last_picture.f, y, h, s->picture_structure,
2365                        s->first_field, s->low_delay);
2366 }
2367
2368 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
2369     const int linesize   = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
2370     const int uvlinesize = s->current_picture.f->linesize[1];
2371     const int mb_size= 4;
2372
2373     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
2374     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
2375     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
2376     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
2377     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
2378     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;
2379     //block_index is not used by mpeg2, so it is not affected by chroma_format
2380
2381     s->dest[0] = s->current_picture.f->data[0] + ((s->mb_x - 1) <<  mb_size);
2382     s->dest[1] = s->current_picture.f->data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2383     s->dest[2] = s->current_picture.f->data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
2384
2385     if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
2386     {
2387         if(s->picture_structure==PICT_FRAME){
2388         s->dest[0] += s->mb_y *   linesize << mb_size;
2389         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2390         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
2391         }else{
2392             s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
2393             s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2394             s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
2395             assert((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
2396         }
2397     }
2398 }
2399
2400 /**
2401  * Permute an 8x8 block.
2402  * @param block the block which will be permuted according to the given permutation vector
2403  * @param permutation the permutation vector
2404  * @param last the last non zero coefficient in scantable order, used to speed the permutation up
2405  * @param scantable the used scantable, this is only used to speed the permutation up, the block is not
2406  *                  (inverse) permutated to scantable order!
2407  */
2408 void ff_block_permute(int16_t *block, uint8_t *permutation, const uint8_t *scantable, int last)
2409 {
2410     int i;
2411     int16_t temp[64];
2412
2413     if(last<=0) return;
2414     //if(permutation[1]==1) return; //FIXME it is ok but not clean and might fail for some permutations
2415
2416     for(i=0; i<=last; i++){
2417         const int j= scantable[i];
2418         temp[j]= block[j];
2419         block[j]=0;
2420     }
2421
2422     for(i=0; i<=last; i++){
2423         const int j= scantable[i];
2424         const int perm_j= permutation[j];
2425         block[perm_j]= temp[j];
2426     }
2427 }
2428
2429 void ff_mpeg_flush(AVCodecContext *avctx){
2430     int i;
2431     MpegEncContext *s = avctx->priv_data;
2432
2433     if (!s || !s->picture)
2434         return;
2435
2436     for (i = 0; i < MAX_PICTURE_COUNT; i++)
2437         ff_mpeg_unref_picture(s, &s->picture[i]);
2438     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
2439
2440     ff_mpeg_unref_picture(s, &s->current_picture);
2441     ff_mpeg_unref_picture(s, &s->last_picture);
2442     ff_mpeg_unref_picture(s, &s->next_picture);
2443
2444     s->mb_x= s->mb_y= 0;
2445
2446     s->parse_context.state= -1;
2447     s->parse_context.frame_start_found= 0;
2448     s->parse_context.overread= 0;
2449     s->parse_context.overread_index= 0;
2450     s->parse_context.index= 0;
2451     s->parse_context.last_index= 0;
2452     s->bitstream_buffer_size=0;
2453     s->pp_time=0;
2454 }
2455
2456 /**
2457  * set qscale and update qscale dependent variables.
2458  */
2459 void ff_set_qscale(MpegEncContext * s, int qscale)
2460 {
2461     if (qscale < 1)
2462         qscale = 1;
2463     else if (qscale > 31)
2464         qscale = 31;
2465
2466     s->qscale = qscale;
2467     s->chroma_qscale= s->chroma_qscale_table[qscale];
2468
2469     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
2470     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
2471 }
2472
2473 void ff_mpv_report_decode_progress(MpegEncContext *s)
2474 {
2475     if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->er.error_occurred)
2476         ff_thread_report_progress(&s->current_picture_ptr->tf, s->mb_y, 0);
2477 }