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

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