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_ARRAY_OR_GOTO(s->avctx, s->edge_emu_buffer, alloc_size, 4 * 68,
 464                       fail);
 465
 466     FF_ALLOCZ_ARRAY_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         int err;
 960         memcpy(s, s1, sizeof(MpegEncContext));
 961
 962         s->avctx                 = dst;
 963         s->bitstream_buffer      = NULL;
 964         s->bitstream_buffer_size = s->allocated_bitstream_buffer_size = 0;
 965
 966         if (s1->context_initialized){
 967 //             s->picture_range_start  += MAX_PICTURE_COUNT;
 968 //             s->picture_range_end    += MAX_PICTURE_COUNT;
 969             ff_mpv_idct_init(s);
 970             if((err = ff_mpv_common_init(s)) < 0){
 971                 memset(s, 0, sizeof(MpegEncContext));
 972                 s->avctx = dst;
 973                 return err;
 974             }
 975         }
 976     }
 977
 978     if (s->height != s1->height || s->width != s1->width || s->context_reinit) {
 979         s->context_reinit = 0;
 980         s->height = s1->height;
 981         s->width  = s1->width;
 982         if ((ret = ff_mpv_common_frame_size_change(s)) < 0)
 983             return ret;
 984     }
 985
 986     s->avctx->coded_height  = s1->avctx->coded_height;
 987     s->avctx->coded_width   = s1->avctx->coded_width;
 988     s->avctx->width         = s1->avctx->width;
 989     s->avctx->height        = s1->avctx->height;
 990
 991     s->coded_picture_number = s1->coded_picture_number;
 992     s->picture_number       = s1->picture_number;
 993
 994     av_assert0(!s->picture || s->picture != s1->picture);
 995     if(s->picture)
 996     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
 997         ff_mpeg_unref_picture(s, &s->picture[i]);
 998         if (s1->picture[i].f->buf[0] &&
 999             (ret = ff_mpeg_ref_picture(s, &s->picture[i], &s1->picture[i])) < 0)
1000             return ret;
1001     }
1002
1003 #define UPDATE_PICTURE(pic)\
1004 do {\
1005     ff_mpeg_unref_picture(s, &s->pic);\
1006     if (s1->pic.f && s1->pic.f->buf[0])\
1007         ret = ff_mpeg_ref_picture(s, &s->pic, &s1->pic);\
1008     else\
1009         ret = update_picture_tables(&s->pic, &s1->pic);\
1010     if (ret < 0)\
1011         return ret;\
1012 } while (0)
1013
1014     UPDATE_PICTURE(current_picture);
1015     UPDATE_PICTURE(last_picture);
1016     UPDATE_PICTURE(next_picture);
1017
1018     s->last_picture_ptr    = REBASE_PICTURE(s1->last_picture_ptr,    s, s1);
1019     s->current_picture_ptr = REBASE_PICTURE(s1->current_picture_ptr, s, s1);
1020     s->next_picture_ptr    = REBASE_PICTURE(s1->next_picture_ptr,    s, s1);
1021
1022     // Error/bug resilience
1023     s->next_p_frame_damaged = s1->next_p_frame_damaged;
1024     s->workaround_bugs      = s1->workaround_bugs;
1025     s->padding_bug_score    = s1->padding_bug_score;
1026
1027     // MPEG4 timing info
1028     memcpy(&s->last_time_base, &s1->last_time_base,
1029            (char *) &s1->pb_field_time + sizeof(s1->pb_field_time) -
1030            (char *) &s1->last_time_base);
1031
1032     // B-frame info
1033     s->max_b_frames = s1->max_b_frames;
1034     s->low_delay    = s1->low_delay;
1035     s->droppable    = s1->droppable;
1036
1037     // DivX handling (doesn't work)
1038     s->divx_packed  = s1->divx_packed;
1039
1040     if (s1->bitstream_buffer) {
1041         if (s1->bitstream_buffer_size +
1042             FF_INPUT_BUFFER_PADDING_SIZE > s->allocated_bitstream_buffer_size)
1043             av_fast_malloc(&s->bitstream_buffer,
1044                            &s->allocated_bitstream_buffer_size,
1045                            s1->allocated_bitstream_buffer_size);
1046             s->bitstream_buffer_size = s1->bitstream_buffer_size;
1047         memcpy(s->bitstream_buffer, s1->bitstream_buffer,
1048                s1->bitstream_buffer_size);
1049         memset(s->bitstream_buffer + s->bitstream_buffer_size, 0,
1050                FF_INPUT_BUFFER_PADDING_SIZE);
1051     }
1052
1053     // linesize dependend scratch buffer allocation
1054     if (!s->edge_emu_buffer)
1055         if (s1->linesize) {
1056             if (frame_size_alloc(s, s1->linesize) < 0) {
1057                 av_log(s->avctx, AV_LOG_ERROR, "Failed to allocate context "
1058                        "scratch buffers.\n");
1059                 return AVERROR(ENOMEM);
1060             }
1061         } else {
1062             av_log(s->avctx, AV_LOG_ERROR, "Context scratch buffers could not "
1063                    "be allocated due to unknown size.\n");
1064         }
1065
1066     // MPEG2/interlacing info
1067     memcpy(&s->progressive_sequence, &s1->progressive_sequence,
1068            (char *) &s1->rtp_mode - (char *) &s1->progressive_sequence);
1069
1070     if (!s1->first_field) {
1071         s->last_pict_type = s1->pict_type;
1072         if (s1->current_picture_ptr)
1073             s->last_lambda_for[s1->pict_type] = s1->current_picture_ptr->f->quality;
1074     }
1075
1076     return 0;
1077 }
1078
1079 /**
1080  * Set the given MpegEncContext to common defaults
1081  * (same for encoding and decoding).
1082  * The changed fields will not depend upon the
1083  * prior state of the MpegEncContext.
1084  */
1085 void ff_mpv_common_defaults(MpegEncContext *s)
1086 {
1087     s->y_dc_scale_table      =
1088     s->c_dc_scale_table      = ff_mpeg1_dc_scale_table;
1089     s->chroma_qscale_table   = ff_default_chroma_qscale_table;
1090     s->progressive_frame     = 1;
1091     s->progressive_sequence  = 1;
1092     s->picture_structure     = PICT_FRAME;
1093
1094     s->coded_picture_number  = 0;
1095     s->picture_number        = 0;
1096
1097     s->f_code                = 1;
1098     s->b_code                = 1;
1099
1100     s->slice_context_count   = 1;
1101 }
1102
1103 /**
1104  * Set the given MpegEncContext to defaults for decoding.
1105  * the changed fields will not depend upon
1106  * the prior state of the MpegEncContext.
1107  */
1108 void ff_mpv_decode_defaults(MpegEncContext *s)
1109 {
1110     ff_mpv_common_defaults(s);
1111 }
1112
1113 void ff_mpv_decode_init(MpegEncContext *s, AVCodecContext *avctx)
1114 {
1115     s->avctx           = avctx;
1116     s->width           = avctx->coded_width;
1117     s->height          = avctx->coded_height;
1118     s->codec_id        = avctx->codec->id;
1119     s->workaround_bugs = avctx->workaround_bugs;
1120     s->flags           = avctx->flags;
1121     s->flags2          = avctx->flags2;
1122
1123     /* convert fourcc to upper case */
1124     s->codec_tag          = avpriv_toupper4(avctx->codec_tag);
1125
1126     s->stream_codec_tag   = avpriv_toupper4(avctx->stream_codec_tag);
1127 }
1128
1129 static int init_er(MpegEncContext *s)
1130 {
1131     ERContext *er = &s->er;
1132     int mb_array_size = s->mb_height * s->mb_stride;
1133     int i;
1134
1135     er->avctx       = s->avctx;
1136     er->mecc        = &s->mecc;
1137
1138     er->mb_index2xy = s->mb_index2xy;
1139     er->mb_num      = s->mb_num;
1140     er->mb_width    = s->mb_width;
1141     er->mb_height   = s->mb_height;
1142     er->mb_stride   = s->mb_stride;
1143     er->b8_stride   = s->b8_stride;
1144
1145     er->er_temp_buffer     = av_malloc(s->mb_height * s->mb_stride);
1146     er->error_status_table = av_mallocz(mb_array_size);
1147     if (!er->er_temp_buffer || !er->error_status_table)
1148         goto fail;
1149
1150     er->mbskip_table  = s->mbskip_table;
1151     er->mbintra_table = s->mbintra_table;
1152
1153     for (i = 0; i < FF_ARRAY_ELEMS(s->dc_val); i++)
1154         er->dc_val[i] = s->dc_val[i];
1155
1156     er->decode_mb = mpeg_er_decode_mb;
1157     er->opaque    = s;
1158
1159     return 0;
1160 fail:
1161     av_freep(&er->er_temp_buffer);
1162     av_freep(&er->error_status_table);
1163     return AVERROR(ENOMEM);
1164 }
1165
1166 /**
1167  * Initialize and allocates MpegEncContext fields dependent on the resolution.
1168  */
1169 static int init_context_frame(MpegEncContext *s)
1170 {
1171     int y_size, c_size, yc_size, i, mb_array_size, mv_table_size, x, y;
1172
1173     s->mb_width   = (s->width + 15) / 16;
1174     s->mb_stride  = s->mb_width + 1;
1175     s->b8_stride  = s->mb_width * 2 + 1;
1176     mb_array_size = s->mb_height * s->mb_stride;
1177     mv_table_size = (s->mb_height + 2) * s->mb_stride + 1;
1178
1179     /* set default edge pos, will be overridden
1180      * in decode_header if needed */
1181     s->h_edge_pos = s->mb_width * 16;
1182     s->v_edge_pos = s->mb_height * 16;
1183
1184     s->mb_num     = s->mb_width * s->mb_height;
1185
1186     s->block_wrap[0] =
1187     s->block_wrap[1] =
1188     s->block_wrap[2] =
1189     s->block_wrap[3] = s->b8_stride;
1190     s->block_wrap[4] =
1191     s->block_wrap[5] = s->mb_stride;
1192
1193     y_size  = s->b8_stride * (2 * s->mb_height + 1);
1194     c_size  = s->mb_stride * (s->mb_height + 1);
1195     yc_size = y_size + 2   * c_size;
1196
1197     if (s->mb_height & 1)
1198         yc_size += 2*s->b8_stride + 2*s->mb_stride;
1199
1200     FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_index2xy, (s->mb_num + 1) * sizeof(int), fail); // error ressilience code looks cleaner with this
1201     for (y = 0; y < s->mb_height; y++)
1202         for (x = 0; x < s->mb_width; x++)
1203             s->mb_index2xy[x + y * s->mb_width] = x + y * s->mb_stride;
1204
1205     s->mb_index2xy[s->mb_height * s->mb_width] = (s->mb_height - 1) * s->mb_stride + s->mb_width; // FIXME really needed?
1206
1207     if (s->encoding) {
1208         /* Allocate MV tables */
1209         FF_ALLOCZ_OR_GOTO(s->avctx, s->p_mv_table_base,                 mv_table_size * 2 * sizeof(int16_t), fail)
1210         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_forw_mv_table_base,            mv_table_size * 2 * sizeof(int16_t), fail)
1211         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_back_mv_table_base,            mv_table_size * 2 * sizeof(int16_t), fail)
1212         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_forw_mv_table_base,      mv_table_size * 2 * sizeof(int16_t), fail)
1213         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_bidir_back_mv_table_base,      mv_table_size * 2 * sizeof(int16_t), fail)
1214         FF_ALLOCZ_OR_GOTO(s->avctx, s->b_direct_mv_table_base,          mv_table_size * 2 * sizeof(int16_t), fail)
1215         s->p_mv_table            = s->p_mv_table_base + s->mb_stride + 1;
1216         s->b_forw_mv_table       = s->b_forw_mv_table_base + s->mb_stride + 1;
1217         s->b_back_mv_table       = s->b_back_mv_table_base + s->mb_stride + 1;
1218         s->b_bidir_forw_mv_table = s->b_bidir_forw_mv_table_base + s->mb_stride + 1;
1219         s->b_bidir_back_mv_table = s->b_bidir_back_mv_table_base + s->mb_stride + 1;
1220         s->b_direct_mv_table     = s->b_direct_mv_table_base + s->mb_stride + 1;
1221
1222         /* Allocate MB type table */
1223         FF_ALLOCZ_OR_GOTO(s->avctx, s->mb_type, mb_array_size * sizeof(uint16_t), fail) // needed for encoding
1224
1225         FF_ALLOCZ_OR_GOTO(s->avctx, s->lambda_table, mb_array_size * sizeof(int), fail)
1226
1227         FF_ALLOC_OR_GOTO(s->avctx, s->cplx_tab,
1228                          mb_array_size * sizeof(float), fail);
1229         FF_ALLOC_OR_GOTO(s->avctx, s->bits_tab,
1230                          mb_array_size * sizeof(float), fail);
1231
1232     }
1233
1234     if (s->codec_id == AV_CODEC_ID_MPEG4 ||
1235         (s->flags & CODEC_FLAG_INTERLACED_ME)) {
1236         /* interlaced direct mode decoding tables */
1237         for (i = 0; i < 2; i++) {
1238             int j, k;
1239             for (j = 0; j < 2; j++) {
1240                 for (k = 0; k < 2; k++) {
1241                     FF_ALLOCZ_OR_GOTO(s->avctx,
1242                                       s->b_field_mv_table_base[i][j][k],
1243                                       mv_table_size * 2 * sizeof(int16_t),
1244                                       fail);
1245                     s->b_field_mv_table[i][j][k] = s->b_field_mv_table_base[i][j][k] +
1246                                                    s->mb_stride + 1;
1247                 }
1248                 FF_ALLOCZ_OR_GOTO(s->avctx, s->b_field_select_table [i][j], mb_array_size * 2 * sizeof(uint8_t), fail)
1249                 FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_mv_table_base[i][j], mv_table_size * 2 * sizeof(int16_t), fail)
1250                 s->p_field_mv_table[i][j] = s->p_field_mv_table_base[i][j] + s->mb_stride + 1;
1251             }
1252             FF_ALLOCZ_OR_GOTO(s->avctx, s->p_field_select_table[i], mb_array_size * 2 * sizeof(uint8_t), fail)
1253         }
1254     }
1255     if (s->out_format == FMT_H263) {
1256         /* cbp values */
1257         FF_ALLOCZ_OR_GOTO(s->avctx, s->coded_block_base, y_size + (s->mb_height&1)*2*s->b8_stride, fail);
1258         s->coded_block = s->coded_block_base + s->b8_stride + 1;
1259
1260         /* cbp, ac_pred, pred_dir */
1261         FF_ALLOCZ_OR_GOTO(s->avctx, s->cbp_table     , mb_array_size * sizeof(uint8_t), fail);
1262         FF_ALLOCZ_OR_GOTO(s->avctx, s->pred_dir_table, mb_array_size * sizeof(uint8_t), fail);
1263     }
1264
1265     if (s->h263_pred || s->h263_plus || !s->encoding) {
1266         /* dc values */
1267         // MN: we need these for  error resilience of intra-frames
1268         FF_ALLOCZ_OR_GOTO(s->avctx, s->dc_val_base, yc_size * sizeof(int16_t), fail);
1269         s->dc_val[0] = s->dc_val_base + s->b8_stride + 1;
1270         s->dc_val[1] = s->dc_val_base + y_size + s->mb_stride + 1;
1271         s->dc_val[2] = s->dc_val[1] + c_size;
1272         for (i = 0; i < yc_size; i++)
1273             s->dc_val_base[i] = 1024;
1274     }
1275
1276     /* which mb is a intra block */
1277     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbintra_table, mb_array_size, fail);
1278     memset(s->mbintra_table, 1, mb_array_size);
1279
1280     /* init macroblock skip table */
1281     FF_ALLOCZ_OR_GOTO(s->avctx, s->mbskip_table, mb_array_size + 2, fail);
1282     // Note the + 1 is for  a quicker mpeg4 slice_end detection
1283
1284     return init_er(s);
1285 fail:
1286     return AVERROR(ENOMEM);
1287 }
1288
1289 /**
1290  * init common structure for both encoder and decoder.
1291  * this assumes that some variables like width/height are already set
1292  */
1293 av_cold int ff_mpv_common_init(MpegEncContext *s)
1294 {
1295     int i;
1296     int nb_slices = (HAVE_THREADS &&
1297                      s->avctx->active_thread_type & FF_THREAD_SLICE) ?
1298                     s->avctx->thread_count : 1;
1299
1300     if (s->encoding && s->avctx->slices)
1301         nb_slices = s->avctx->slices;
1302
1303     if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1304         s->mb_height = (s->height + 31) / 32 * 2;
1305     else
1306         s->mb_height = (s->height + 15) / 16;
1307
1308     if (s->avctx->pix_fmt == AV_PIX_FMT_NONE) {
1309         av_log(s->avctx, AV_LOG_ERROR,
1310                "decoding to AV_PIX_FMT_NONE is not supported.\n");
1311         return -1;
1312     }
1313
1314     if (nb_slices > MAX_THREADS || (nb_slices > s->mb_height && s->mb_height)) {
1315         int max_slices;
1316         if (s->mb_height)
1317             max_slices = FFMIN(MAX_THREADS, s->mb_height);
1318         else
1319             max_slices = MAX_THREADS;
1320         av_log(s->avctx, AV_LOG_WARNING, "too many threads/slices (%d),"
1321                " reducing to %d\n", nb_slices, max_slices);
1322         nb_slices = max_slices;
1323     }
1324
1325     if ((s->width || s->height) &&
1326         av_image_check_size(s->width, s->height, 0, s->avctx))
1327         return -1;
1328
1329     dct_init(s);
1330
1331     s->flags  = s->avctx->flags;
1332     s->flags2 = s->avctx->flags2;
1333
1334     /* set chroma shifts */
1335     avcodec_get_chroma_sub_sample(s->avctx->pix_fmt,
1336                                   &s->chroma_x_shift,
1337                                   &s->chroma_y_shift);
1338
1339
1340     FF_ALLOCZ_OR_GOTO(s->avctx, s->picture,
1341                       MAX_PICTURE_COUNT * sizeof(Picture), fail);
1342     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1343         s->picture[i].f = av_frame_alloc();
1344         if (!s->picture[i].f)
1345             goto fail;
1346     }
1347     memset(&s->next_picture, 0, sizeof(s->next_picture));
1348     memset(&s->last_picture, 0, sizeof(s->last_picture));
1349     memset(&s->current_picture, 0, sizeof(s->current_picture));
1350     memset(&s->new_picture, 0, sizeof(s->new_picture));
1351     s->next_picture.f = av_frame_alloc();
1352     if (!s->next_picture.f)
1353         goto fail;
1354     s->last_picture.f = av_frame_alloc();
1355     if (!s->last_picture.f)
1356         goto fail;
1357     s->current_picture.f = av_frame_alloc();
1358     if (!s->current_picture.f)
1359         goto fail;
1360     s->new_picture.f = av_frame_alloc();
1361     if (!s->new_picture.f)
1362         goto fail;
1363
1364         if (init_context_frame(s))
1365             goto fail;
1366
1367         s->parse_context.state = -1;
1368
1369         s->context_initialized = 1;
1370         s->thread_context[0]   = s;
1371
1372 //     if (s->width && s->height) {
1373         if (nb_slices > 1) {
1374             for (i = 1; i < nb_slices; i++) {
1375                 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1376                 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1377             }
1378
1379             for (i = 0; i < nb_slices; i++) {
1380                 if (init_duplicate_context(s->thread_context[i]) < 0)
1381                     goto fail;
1382                     s->thread_context[i]->start_mb_y =
1383                         (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1384                     s->thread_context[i]->end_mb_y   =
1385                         (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1386             }
1387         } else {
1388             if (init_duplicate_context(s) < 0)
1389                 goto fail;
1390             s->start_mb_y = 0;
1391             s->end_mb_y   = s->mb_height;
1392         }
1393         s->slice_context_count = nb_slices;
1394 //     }
1395
1396     return 0;
1397  fail:
1398     ff_mpv_common_end(s);
1399     return -1;
1400 }
1401
1402 /**
1403  * Frees and resets MpegEncContext fields depending on the resolution.
1404  * Is used during resolution changes to avoid a full reinitialization of the
1405  * codec.
1406  */
1407 static void free_context_frame(MpegEncContext *s)
1408 {
1409     int i, j, k;
1410
1411     av_freep(&s->mb_type);
1412     av_freep(&s->p_mv_table_base);
1413     av_freep(&s->b_forw_mv_table_base);
1414     av_freep(&s->b_back_mv_table_base);
1415     av_freep(&s->b_bidir_forw_mv_table_base);
1416     av_freep(&s->b_bidir_back_mv_table_base);
1417     av_freep(&s->b_direct_mv_table_base);
1418     s->p_mv_table            = NULL;
1419     s->b_forw_mv_table       = NULL;
1420     s->b_back_mv_table       = NULL;
1421     s->b_bidir_forw_mv_table = NULL;
1422     s->b_bidir_back_mv_table = NULL;
1423     s->b_direct_mv_table     = NULL;
1424     for (i = 0; i < 2; i++) {
1425         for (j = 0; j < 2; j++) {
1426             for (k = 0; k < 2; k++) {
1427                 av_freep(&s->b_field_mv_table_base[i][j][k]);
1428                 s->b_field_mv_table[i][j][k] = NULL;
1429             }
1430             av_freep(&s->b_field_select_table[i][j]);
1431             av_freep(&s->p_field_mv_table_base[i][j]);
1432             s->p_field_mv_table[i][j] = NULL;
1433         }
1434         av_freep(&s->p_field_select_table[i]);
1435     }
1436
1437     av_freep(&s->dc_val_base);
1438     av_freep(&s->coded_block_base);
1439     av_freep(&s->mbintra_table);
1440     av_freep(&s->cbp_table);
1441     av_freep(&s->pred_dir_table);
1442
1443     av_freep(&s->mbskip_table);
1444
1445     av_freep(&s->er.error_status_table);
1446     av_freep(&s->er.er_temp_buffer);
1447     av_freep(&s->mb_index2xy);
1448     av_freep(&s->lambda_table);
1449
1450     av_freep(&s->cplx_tab);
1451     av_freep(&s->bits_tab);
1452
1453     s->linesize = s->uvlinesize = 0;
1454 }
1455
1456 int ff_mpv_common_frame_size_change(MpegEncContext *s)
1457 {
1458     int i, err = 0;
1459
1460     if (!s->context_initialized)
1461         return AVERROR(EINVAL);
1462
1463     if (s->slice_context_count > 1) {
1464         for (i = 0; i < s->slice_context_count; i++) {
1465             free_duplicate_context(s->thread_context[i]);
1466         }
1467         for (i = 1; i < s->slice_context_count; i++) {
1468             av_freep(&s->thread_context[i]);
1469         }
1470     } else
1471         free_duplicate_context(s);
1472
1473     free_context_frame(s);
1474
1475     if (s->picture)
1476         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1477                 s->picture[i].needs_realloc = 1;
1478         }
1479
1480     s->last_picture_ptr         =
1481     s->next_picture_ptr         =
1482     s->current_picture_ptr      = NULL;
1483
1484     // init
1485     if (s->codec_id == AV_CODEC_ID_MPEG2VIDEO && !s->progressive_sequence)
1486         s->mb_height = (s->height + 31) / 32 * 2;
1487     else
1488         s->mb_height = (s->height + 15) / 16;
1489
1490     if ((s->width || s->height) &&
1491         (err = av_image_check_size(s->width, s->height, 0, s->avctx)) < 0)
1492         goto fail;
1493
1494     if ((err = init_context_frame(s)))
1495         goto fail;
1496
1497     s->thread_context[0]   = s;
1498
1499     if (s->width && s->height) {
1500         int nb_slices = s->slice_context_count;
1501         if (nb_slices > 1) {
1502             for (i = 1; i < nb_slices; i++) {
1503                 s->thread_context[i] = av_malloc(sizeof(MpegEncContext));
1504                 memcpy(s->thread_context[i], s, sizeof(MpegEncContext));
1505             }
1506
1507             for (i = 0; i < nb_slices; i++) {
1508                 if ((err = init_duplicate_context(s->thread_context[i])) < 0)
1509                     goto fail;
1510                     s->thread_context[i]->start_mb_y =
1511                         (s->mb_height * (i) + nb_slices / 2) / nb_slices;
1512                     s->thread_context[i]->end_mb_y   =
1513                         (s->mb_height * (i + 1) + nb_slices / 2) / nb_slices;
1514             }
1515         } else {
1516             err = init_duplicate_context(s);
1517             if (err < 0)
1518                 goto fail;
1519             s->start_mb_y = 0;
1520             s->end_mb_y   = s->mb_height;
1521         }
1522         s->slice_context_count = nb_slices;
1523     }
1524
1525     return 0;
1526  fail:
1527     ff_mpv_common_end(s);
1528     return err;
1529 }
1530
1531 /* init common structure for both encoder and decoder */
1532 void ff_mpv_common_end(MpegEncContext *s)
1533 {
1534     int i;
1535
1536     if (s->slice_context_count > 1) {
1537         for (i = 0; i < s->slice_context_count; i++) {
1538             free_duplicate_context(s->thread_context[i]);
1539         }
1540         for (i = 1; i < s->slice_context_count; i++) {
1541             av_freep(&s->thread_context[i]);
1542         }
1543         s->slice_context_count = 1;
1544     } else free_duplicate_context(s);
1545
1546     av_freep(&s->parse_context.buffer);
1547     s->parse_context.buffer_size = 0;
1548
1549     av_freep(&s->bitstream_buffer);
1550     s->allocated_bitstream_buffer_size = 0;
1551
1552     if (s->picture) {
1553         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1554             ff_free_picture_tables(&s->picture[i]);
1555             ff_mpeg_unref_picture(s, &s->picture[i]);
1556             av_frame_free(&s->picture[i].f);
1557         }
1558     }
1559     av_freep(&s->picture);
1560     ff_free_picture_tables(&s->last_picture);
1561     ff_mpeg_unref_picture(s, &s->last_picture);
1562     av_frame_free(&s->last_picture.f);
1563     ff_free_picture_tables(&s->current_picture);
1564     ff_mpeg_unref_picture(s, &s->current_picture);
1565     av_frame_free(&s->current_picture.f);
1566     ff_free_picture_tables(&s->next_picture);
1567     ff_mpeg_unref_picture(s, &s->next_picture);
1568     av_frame_free(&s->next_picture.f);
1569     ff_free_picture_tables(&s->new_picture);
1570     ff_mpeg_unref_picture(s, &s->new_picture);
1571     av_frame_free(&s->new_picture.f);
1572
1573     free_context_frame(s);
1574
1575     s->context_initialized      = 0;
1576     s->last_picture_ptr         =
1577     s->next_picture_ptr         =
1578     s->current_picture_ptr      = NULL;
1579     s->linesize = s->uvlinesize = 0;
1580 }
1581
1582 av_cold void ff_init_rl(RLTable *rl,
1583                         uint8_t static_store[2][2 * MAX_RUN + MAX_LEVEL + 3])
1584 {
1585     int8_t  max_level[MAX_RUN + 1], max_run[MAX_LEVEL + 1];
1586     uint8_t index_run[MAX_RUN + 1];
1587     int last, run, level, start, end, i;
1588
1589     /* If table is static, we can quit if rl->max_level[0] is not NULL */
1590     if (static_store && rl->max_level[0])
1591         return;
1592
1593     /* compute max_level[], max_run[] and index_run[] */
1594     for (last = 0; last < 2; last++) {
1595         if (last == 0) {
1596             start = 0;
1597             end = rl->last;
1598         } else {
1599             start = rl->last;
1600             end = rl->n;
1601         }
1602
1603         memset(max_level, 0, MAX_RUN + 1);
1604         memset(max_run, 0, MAX_LEVEL + 1);
1605         memset(index_run, rl->n, MAX_RUN + 1);
1606         for (i = start; i < end; i++) {
1607             run   = rl->table_run[i];
1608             level = rl->table_level[i];
1609             if (index_run[run] == rl->n)
1610                 index_run[run] = i;
1611             if (level > max_level[run])
1612                 max_level[run] = level;
1613             if (run > max_run[level])
1614                 max_run[level] = run;
1615         }
1616         if (static_store)
1617             rl->max_level[last] = static_store[last];
1618         else
1619             rl->max_level[last] = av_malloc(MAX_RUN + 1);
1620         memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1621         if (static_store)
1622             rl->max_run[last]   = static_store[last] + MAX_RUN + 1;
1623         else
1624             rl->max_run[last]   = av_malloc(MAX_LEVEL + 1);
1625         memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1626         if (static_store)
1627             rl->index_run[last] = static_store[last] + MAX_RUN + MAX_LEVEL + 2;
1628         else
1629             rl->index_run[last] = av_malloc(MAX_RUN + 1);
1630         memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1631     }
1632 }
1633
1634 av_cold void ff_init_vlc_rl(RLTable *rl, unsigned static_size)
1635 {
1636     int i, q;
1637     VLC_TYPE table[1500][2] = {{0}};
1638     VLC vlc = { .table = table, .table_allocated = static_size };
1639     av_assert0(static_size <= FF_ARRAY_ELEMS(table));
1640     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);
1641
1642     for (q = 0; q < 32; q++) {
1643         int qmul = q * 2;
1644         int qadd = (q - 1) | 1;
1645
1646         if (q == 0) {
1647             qmul = 1;
1648             qadd = 0;
1649         }
1650         for (i = 0; i < vlc.table_size; i++) {
1651             int code = vlc.table[i][0];
1652             int len  = vlc.table[i][1];
1653             int level, run;
1654
1655             if (len == 0) { // illegal code
1656                 run   = 66;
1657                 level = MAX_LEVEL;
1658             } else if (len < 0) { // more bits needed
1659                 run   = 0;
1660                 level = code;
1661             } else {
1662                 if (code == rl->n) { // esc
1663                     run   = 66;
1664                     level =  0;
1665                 } else {
1666                     run   = rl->table_run[code] + 1;
1667                     level = rl->table_level[code] * qmul + qadd;
1668                     if (code >= rl->last) run += 192;
1669                 }
1670             }
1671             rl->rl_vlc[q][i].len   = len;
1672             rl->rl_vlc[q][i].level = level;
1673             rl->rl_vlc[q][i].run   = run;
1674         }
1675     }
1676 }
1677
1678 static void release_unused_pictures(MpegEncContext *s)
1679 {
1680     int i;
1681
1682     /* release non reference frames */
1683     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1684         if (!s->picture[i].reference)
1685             ff_mpeg_unref_picture(s, &s->picture[i]);
1686     }
1687 }
1688
1689 static inline int pic_is_unused(MpegEncContext *s, Picture *pic)
1690 {
1691     if (pic == s->last_picture_ptr)
1692         return 0;
1693     if (!pic->f->buf[0])
1694         return 1;
1695     if (pic->needs_realloc && !(pic->reference & DELAYED_PIC_REF))
1696         return 1;
1697     return 0;
1698 }
1699
1700 static int find_unused_picture(MpegEncContext *s, int shared)
1701 {
1702     int i;
1703
1704     if (shared) {
1705         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1706             if (!s->picture[i].f->buf[0] && &s->picture[i] != s->last_picture_ptr)
1707                 return i;
1708         }
1709     } else {
1710         for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1711             if (pic_is_unused(s, &s->picture[i]))
1712                 return i;
1713         }
1714     }
1715
1716     av_log(s->avctx, AV_LOG_FATAL,
1717            "Internal error, picture buffer overflow\n");
1718     /* We could return -1, but the codec would crash trying to draw into a
1719      * non-existing frame anyway. This is safer than waiting for a random crash.
1720      * Also the return of this is never useful, an encoder must only allocate
1721      * as much as allowed in the specification. This has no relationship to how
1722      * much libavcodec could allocate (and MAX_PICTURE_COUNT is always large
1723      * enough for such valid streams).
1724      * Plus, a decoder has to check stream validity and remove frames if too
1725      * many reference frames are around. Waiting for "OOM" is not correct at
1726      * all. Similarly, missing reference frames have to be replaced by
1727      * interpolated/MC frames, anything else is a bug in the codec ...
1728      */
1729     abort();
1730     return -1;
1731 }
1732
1733 int ff_find_unused_picture(MpegEncContext *s, int shared)
1734 {
1735     int ret = find_unused_picture(s, shared);
1736
1737     if (ret >= 0 && ret < MAX_PICTURE_COUNT) {
1738         if (s->picture[ret].needs_realloc) {
1739             s->picture[ret].needs_realloc = 0;
1740             ff_free_picture_tables(&s->picture[ret]);
1741             ff_mpeg_unref_picture(s, &s->picture[ret]);
1742         }
1743     }
1744     return ret;
1745 }
1746
1747 static void gray_frame(AVFrame *frame)
1748 {
1749     int i, h_chroma_shift, v_chroma_shift;
1750
1751     av_pix_fmt_get_chroma_sub_sample(frame->format, &h_chroma_shift, &v_chroma_shift);
1752
1753     for(i=0; i<frame->height; i++)
1754         memset(frame->data[0] + frame->linesize[0]*i, 0x80, frame->width);
1755     for(i=0; i<FF_CEIL_RSHIFT(frame->height, v_chroma_shift); i++) {
1756         memset(frame->data[1] + frame->linesize[1]*i,
1757                0x80, FF_CEIL_RSHIFT(frame->width, h_chroma_shift));
1758         memset(frame->data[2] + frame->linesize[2]*i,
1759                0x80, FF_CEIL_RSHIFT(frame->width, h_chroma_shift));
1760     }
1761 }
1762
1763 /**
1764  * generic function called after decoding
1765  * the header and before a frame is decoded.
1766  */
1767 int ff_mpv_frame_start(MpegEncContext *s, AVCodecContext *avctx)
1768 {
1769     int i, ret;
1770     Picture *pic;
1771     s->mb_skipped = 0;
1772
1773     if (!ff_thread_can_start_frame(avctx)) {
1774         av_log(avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
1775         return -1;
1776     }
1777
1778     /* mark & release old frames */
1779     if (s->pict_type != AV_PICTURE_TYPE_B && s->last_picture_ptr &&
1780         s->last_picture_ptr != s->next_picture_ptr &&
1781         s->last_picture_ptr->f->buf[0]) {
1782         ff_mpeg_unref_picture(s, s->last_picture_ptr);
1783     }
1784
1785     /* release forgotten pictures */
1786     /* if (mpeg124/h263) */
1787     for (i = 0; i < MAX_PICTURE_COUNT; i++) {
1788         if (&s->picture[i] != s->last_picture_ptr &&
1789             &s->picture[i] != s->next_picture_ptr &&
1790             s->picture[i].reference && !s->picture[i].needs_realloc) {
1791             if (!(avctx->active_thread_type & FF_THREAD_FRAME))
1792                 av_log(avctx, AV_LOG_ERROR,
1793                        "releasing zombie picture\n");
1794             ff_mpeg_unref_picture(s, &s->picture[i]);
1795         }
1796     }
1797
1798     ff_mpeg_unref_picture(s, &s->current_picture);
1799
1800     release_unused_pictures(s);
1801
1802     if (s->current_picture_ptr && !s->current_picture_ptr->f->buf[0]) {
1803         // we already have a unused image
1804         // (maybe it was set before reading the header)
1805         pic = s->current_picture_ptr;
1806     } else {
1807         i   = ff_find_unused_picture(s, 0);
1808         if (i < 0) {
1809             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1810             return i;
1811         }
1812         pic = &s->picture[i];
1813     }
1814
1815     pic->reference = 0;
1816     if (!s->droppable) {
1817         if (s->pict_type != AV_PICTURE_TYPE_B)
1818             pic->reference = 3;
1819     }
1820
1821     pic->f->coded_picture_number = s->coded_picture_number++;
1822
1823     if (ff_alloc_picture(s, pic, 0) < 0)
1824         return -1;
1825
1826     s->current_picture_ptr = pic;
1827     // FIXME use only the vars from current_pic
1828     s->current_picture_ptr->f->top_field_first = s->top_field_first;
1829     if (s->codec_id == AV_CODEC_ID_MPEG1VIDEO ||
1830         s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1831         if (s->picture_structure != PICT_FRAME)
1832             s->current_picture_ptr->f->top_field_first =
1833                 (s->picture_structure == PICT_TOP_FIELD) == s->first_field;
1834     }
1835     s->current_picture_ptr->f->interlaced_frame = !s->progressive_frame &&
1836                                                  !s->progressive_sequence;
1837     s->current_picture_ptr->field_picture      =  s->picture_structure != PICT_FRAME;
1838
1839     s->current_picture_ptr->f->pict_type = s->pict_type;
1840     // if (s->flags && CODEC_FLAG_QSCALE)
1841     //     s->current_picture_ptr->quality = s->new_picture_ptr->quality;
1842     s->current_picture_ptr->f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
1843
1844     if ((ret = ff_mpeg_ref_picture(s, &s->current_picture,
1845                                    s->current_picture_ptr)) < 0)
1846         return ret;
1847
1848     if (s->pict_type != AV_PICTURE_TYPE_B) {
1849         s->last_picture_ptr = s->next_picture_ptr;
1850         if (!s->droppable)
1851             s->next_picture_ptr = s->current_picture_ptr;
1852     }
1853     av_dlog(s->avctx, "L%p N%p C%p L%p N%p C%p type:%d drop:%d\n",
1854             s->last_picture_ptr, s->next_picture_ptr,s->current_picture_ptr,
1855             s->last_picture_ptr    ? s->last_picture_ptr->f->data[0]    : NULL,
1856             s->next_picture_ptr    ? s->next_picture_ptr->f->data[0]    : NULL,
1857             s->current_picture_ptr ? s->current_picture_ptr->f->data[0] : NULL,
1858             s->pict_type, s->droppable);
1859
1860     if ((!s->last_picture_ptr || !s->last_picture_ptr->f->buf[0]) &&
1861         (s->pict_type != AV_PICTURE_TYPE_I ||
1862          s->picture_structure != PICT_FRAME)) {
1863         int h_chroma_shift, v_chroma_shift;
1864         av_pix_fmt_get_chroma_sub_sample(s->avctx->pix_fmt,
1865                                          &h_chroma_shift, &v_chroma_shift);
1866         if (s->pict_type == AV_PICTURE_TYPE_B && s->next_picture_ptr && s->next_picture_ptr->f->buf[0])
1867             av_log(avctx, AV_LOG_DEBUG,
1868                    "allocating dummy last picture for B frame\n");
1869         else if (s->pict_type != AV_PICTURE_TYPE_I)
1870             av_log(avctx, AV_LOG_ERROR,
1871                    "warning: first frame is no keyframe\n");
1872         else if (s->picture_structure != PICT_FRAME)
1873             av_log(avctx, AV_LOG_DEBUG,
1874                    "allocate dummy last picture for field based first keyframe\n");
1875
1876         /* Allocate a dummy frame */
1877         i = ff_find_unused_picture(s, 0);
1878         if (i < 0) {
1879             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1880             return i;
1881         }
1882         s->last_picture_ptr = &s->picture[i];
1883
1884         s->last_picture_ptr->reference   = 3;
1885         s->last_picture_ptr->f->key_frame = 0;
1886         s->last_picture_ptr->f->pict_type = AV_PICTURE_TYPE_P;
1887
1888         if (ff_alloc_picture(s, s->last_picture_ptr, 0) < 0) {
1889             s->last_picture_ptr = NULL;
1890             return -1;
1891         }
1892
1893         if (!avctx->hwaccel && !(avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU)) {
1894             for(i=0; i<avctx->height; i++)
1895                 memset(s->last_picture_ptr->f->data[0] + s->last_picture_ptr->f->linesize[0]*i,
1896                        0x80, avctx->width);
1897             for(i=0; i<FF_CEIL_RSHIFT(avctx->height, v_chroma_shift); i++) {
1898                 memset(s->last_picture_ptr->f->data[1] + s->last_picture_ptr->f->linesize[1]*i,
1899                        0x80, FF_CEIL_RSHIFT(avctx->width, h_chroma_shift));
1900                 memset(s->last_picture_ptr->f->data[2] + s->last_picture_ptr->f->linesize[2]*i,
1901                        0x80, FF_CEIL_RSHIFT(avctx->width, h_chroma_shift));
1902             }
1903
1904             if(s->codec_id == AV_CODEC_ID_FLV1 || s->codec_id == AV_CODEC_ID_H263){
1905                 for(i=0; i<avctx->height; i++)
1906                 memset(s->last_picture_ptr->f->data[0] + s->last_picture_ptr->f->linesize[0]*i, 16, avctx->width);
1907             }
1908         }
1909
1910         ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 0);
1911         ff_thread_report_progress(&s->last_picture_ptr->tf, INT_MAX, 1);
1912     }
1913     if ((!s->next_picture_ptr || !s->next_picture_ptr->f->buf[0]) &&
1914         s->pict_type == AV_PICTURE_TYPE_B) {
1915         /* Allocate a dummy frame */
1916         i = ff_find_unused_picture(s, 0);
1917         if (i < 0) {
1918             av_log(s->avctx, AV_LOG_ERROR, "no frame buffer available\n");
1919             return i;
1920         }
1921         s->next_picture_ptr = &s->picture[i];
1922
1923         s->next_picture_ptr->reference   = 3;
1924         s->next_picture_ptr->f->key_frame = 0;
1925         s->next_picture_ptr->f->pict_type = AV_PICTURE_TYPE_P;
1926
1927         if (ff_alloc_picture(s, s->next_picture_ptr, 0) < 0) {
1928             s->next_picture_ptr = NULL;
1929             return -1;
1930         }
1931         ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 0);
1932         ff_thread_report_progress(&s->next_picture_ptr->tf, INT_MAX, 1);
1933     }
1934
1935 #if 0 // BUFREF-FIXME
1936     memset(s->last_picture.f->data, 0, sizeof(s->last_picture.f->data));
1937     memset(s->next_picture.f->data, 0, sizeof(s->next_picture.f->data));
1938 #endif
1939     if (s->last_picture_ptr) {
1940         ff_mpeg_unref_picture(s, &s->last_picture);
1941         if (s->last_picture_ptr->f->buf[0] &&
1942             (ret = ff_mpeg_ref_picture(s, &s->last_picture,
1943                                        s->last_picture_ptr)) < 0)
1944             return ret;
1945     }
1946     if (s->next_picture_ptr) {
1947         ff_mpeg_unref_picture(s, &s->next_picture);
1948         if (s->next_picture_ptr->f->buf[0] &&
1949             (ret = ff_mpeg_ref_picture(s, &s->next_picture,
1950                                        s->next_picture_ptr)) < 0)
1951             return ret;
1952     }
1953
1954     av_assert0(s->pict_type == AV_PICTURE_TYPE_I || (s->last_picture_ptr &&
1955                                                  s->last_picture_ptr->f->buf[0]));
1956
1957     if (s->picture_structure!= PICT_FRAME) {
1958         int i;
1959         for (i = 0; i < 4; i++) {
1960             if (s->picture_structure == PICT_BOTTOM_FIELD) {
1961                 s->current_picture.f->data[i] +=
1962                     s->current_picture.f->linesize[i];
1963             }
1964             s->current_picture.f->linesize[i] *= 2;
1965             s->last_picture.f->linesize[i]    *= 2;
1966             s->next_picture.f->linesize[i]    *= 2;
1967         }
1968     }
1969
1970     s->err_recognition = avctx->err_recognition;
1971
1972     /* set dequantizer, we can't do it during init as
1973      * it might change for mpeg4 and we can't do it in the header
1974      * decode as init is not called for mpeg4 there yet */
1975     if (s->mpeg_quant || s->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
1976         s->dct_unquantize_intra = s->dct_unquantize_mpeg2_intra;
1977         s->dct_unquantize_inter = s->dct_unquantize_mpeg2_inter;
1978     } else if (s->out_format == FMT_H263 || s->out_format == FMT_H261) {
1979         s->dct_unquantize_intra = s->dct_unquantize_h263_intra;
1980         s->dct_unquantize_inter = s->dct_unquantize_h263_inter;
1981     } else {
1982         s->dct_unquantize_intra = s->dct_unquantize_mpeg1_intra;
1983         s->dct_unquantize_inter = s->dct_unquantize_mpeg1_inter;
1984     }
1985
1986     if (s->avctx->debug & FF_DEBUG_NOMC) {
1987         gray_frame(s->current_picture_ptr->f);
1988     }
1989
1990     return 0;
1991 }
1992
1993 /* called after a frame has been decoded. */
1994 void ff_mpv_frame_end(MpegEncContext *s)
1995 {
1996     emms_c();
1997
1998     if (s->current_picture.reference)
1999         ff_thread_report_progress(&s->current_picture_ptr->tf, INT_MAX, 0);
2000 }
2001
2002
2003 #if FF_API_VISMV
2004 static int clip_line(int *sx, int *sy, int *ex, int *ey, int maxx)
2005 {
2006     if(*sx > *ex)
2007         return clip_line(ex, ey, sx, sy, maxx);
2008
2009     if (*sx < 0) {
2010         if (*ex < 0)
2011             return 1;
2012         *sy = *ey + (*sy - *ey) * (int64_t)*ex / (*ex - *sx);
2013         *sx = 0;
2014     }
2015
2016     if (*ex > maxx) {
2017         if (*sx > maxx)
2018             return 1;
2019         *ey = *sy + (*ey - *sy) * (int64_t)(maxx - *sx) / (*ex - *sx);
2020         *ex = maxx;
2021     }
2022     return 0;
2023 }
2024
2025
2026 /**
2027  * Draw a line from (ex, ey) -> (sx, sy).
2028  * @param w width of the image
2029  * @param h height of the image
2030  * @param stride stride/linesize of the image
2031  * @param color color of the arrow
2032  */
2033 static void draw_line(uint8_t *buf, int sx, int sy, int ex, int ey,
2034                       int w, int h, int stride, int color)
2035 {
2036     int x, y, fr, f;
2037
2038     if (clip_line(&sx, &sy, &ex, &ey, w - 1))
2039         return;
2040     if (clip_line(&sy, &sx, &ey, &ex, h - 1))
2041         return;
2042
2043     sx = av_clip(sx, 0, w - 1);
2044     sy = av_clip(sy, 0, h - 1);
2045     ex = av_clip(ex, 0, w - 1);
2046     ey = av_clip(ey, 0, h - 1);
2047
2048     buf[sy * stride + sx] += color;
2049
2050     if (FFABS(ex - sx) > FFABS(ey - sy)) {
2051         if (sx > ex) {
2052             FFSWAP(int, sx, ex);
2053             FFSWAP(int, sy, ey);
2054         }
2055         buf += sx + sy * stride;
2056         ex  -= sx;
2057         f    = ((ey - sy) << 16) / ex;
2058         for (x = 0; x <= ex; x++) {
2059             y  = (x * f) >> 16;
2060             fr = (x * f) & 0xFFFF;
2061             buf[y * stride + x]       += (color * (0x10000 - fr)) >> 16;
2062             if(fr) buf[(y + 1) * stride + x] += (color *            fr ) >> 16;
2063         }
2064     } else {
2065         if (sy > ey) {
2066             FFSWAP(int, sx, ex);
2067             FFSWAP(int, sy, ey);
2068         }
2069         buf += sx + sy * stride;
2070         ey  -= sy;
2071         if (ey)
2072             f = ((ex - sx) << 16) / ey;
2073         else
2074             f = 0;
2075         for(y= 0; y <= ey; y++){
2076             x  = (y*f) >> 16;
2077             fr = (y*f) & 0xFFFF;
2078             buf[y * stride + x]     += (color * (0x10000 - fr)) >> 16;
2079             if(fr) buf[y * stride + x + 1] += (color *            fr ) >> 16;
2080         }
2081     }
2082 }
2083
2084 /**
2085  * Draw an arrow from (ex, ey) -> (sx, sy).
2086  * @param w width of the image
2087  * @param h height of the image
2088  * @param stride stride/linesize of the image
2089  * @param color color of the arrow
2090  */
2091 static void draw_arrow(uint8_t *buf, int sx, int sy, int ex,
2092                        int ey, int w, int h, int stride, int color, int tail, int direction)
2093 {
2094     int dx,dy;
2095
2096     if (direction) {
2097         FFSWAP(int, sx, ex);
2098         FFSWAP(int, sy, ey);
2099     }
2100
2101     sx = av_clip(sx, -100, w + 100);
2102     sy = av_clip(sy, -100, h + 100);
2103     ex = av_clip(ex, -100, w + 100);
2104     ey = av_clip(ey, -100, h + 100);
2105
2106     dx = ex - sx;
2107     dy = ey - sy;
2108
2109     if (dx * dx + dy * dy > 3 * 3) {
2110         int rx =  dx + dy;
2111         int ry = -dx + dy;
2112         int length = ff_sqrt((rx * rx + ry * ry) << 8);
2113
2114         // FIXME subpixel accuracy
2115         rx = ROUNDED_DIV(rx * 3 << 4, length);
2116         ry = ROUNDED_DIV(ry * 3 << 4, length);
2117
2118         if (tail) {
2119             rx = -rx;
2120             ry = -ry;
2121         }
2122
2123         draw_line(buf, sx, sy, sx + rx, sy + ry, w, h, stride, color);
2124         draw_line(buf, sx, sy, sx - ry, sy + rx, w, h, stride, color);
2125     }
2126     draw_line(buf, sx, sy, ex, ey, w, h, stride, color);
2127 }
2128 #endif
2129
2130 static int add_mb(AVMotionVector *mb, uint32_t mb_type,
2131                   int dst_x, int dst_y,
2132                   int src_x, int src_y,
2133                   int direction)
2134 {
2135     if (dst_x == src_x && dst_y == src_y)
2136         return 0;
2137     mb->w = IS_8X8(mb_type) || IS_8X16(mb_type) ? 8 : 16;
2138     mb->h = IS_8X8(mb_type) || IS_16X8(mb_type) ? 8 : 16;
2139     mb->src_x = src_x;
2140     mb->src_y = src_y;
2141     mb->dst_x = dst_x;
2142     mb->dst_y = dst_y;
2143     mb->source = direction ? 1 : -1;
2144     mb->flags = 0; // XXX: does mb_type contain extra information that could be exported here?
2145     return 1;
2146 }
2147
2148 /**
2149  * Print debugging info for the given picture.
2150  */
2151 void ff_print_debug_info2(AVCodecContext *avctx, AVFrame *pict, uint8_t *mbskip_table,
2152                          uint32_t *mbtype_table, int8_t *qscale_table, int16_t (*motion_val[2])[2],
2153                          int *low_delay,
2154                          int mb_width, int mb_height, int mb_stride, int quarter_sample)
2155 {
2156     if ((avctx->flags2 & CODEC_FLAG2_EXPORT_MVS) && mbtype_table && motion_val[0]) {
2157         const int shift = 1 + quarter_sample;
2158         const int mv_sample_log2 = avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_SVQ3 ? 2 : 1;
2159         const int mv_stride      = (mb_width << mv_sample_log2) +
2160                                    (avctx->codec->id == AV_CODEC_ID_H264 ? 0 : 1);
2161         int mb_x, mb_y, mbcount = 0;
2162
2163         /* size is width * height * 2 * 4 where 2 is for directions and 4 is
2164          * for the maximum number of MB (4 MB in case of IS_8x8) */
2165         AVMotionVector *mvs = av_malloc_array(mb_width * mb_height, 2 * 4 * sizeof(AVMotionVector));
2166         if (!mvs)
2167             return;
2168
2169         for (mb_y = 0; mb_y < mb_height; mb_y++) {
2170             for (mb_x = 0; mb_x < mb_width; mb_x++) {
2171                 int i, direction, mb_type = mbtype_table[mb_x + mb_y * mb_stride];
2172                 for (direction = 0; direction < 2; direction++) {
2173                     if (!USES_LIST(mb_type, direction))
2174                         continue;
2175                     if (IS_8X8(mb_type)) {
2176                         for (i = 0; i < 4; i++) {
2177                             int sx = mb_x * 16 + 4 + 8 * (i & 1);
2178                             int sy = mb_y * 16 + 4 + 8 * (i >> 1);
2179                             int xy = (mb_x * 2 + (i & 1) +
2180                                       (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2181                             int mx = (motion_val[direction][xy][0] >> shift) + sx;
2182                             int my = (motion_val[direction][xy][1] >> shift) + sy;
2183                             mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, direction);
2184                         }
2185                     } else if (IS_16X8(mb_type)) {
2186                         for (i = 0; i < 2; i++) {
2187                             int sx = mb_x * 16 + 8;
2188                             int sy = mb_y * 16 + 4 + 8 * i;
2189                             int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
2190                             int mx = (motion_val[direction][xy][0] >> shift);
2191                             int my = (motion_val[direction][xy][1] >> shift);
2192
2193                             if (IS_INTERLACED(mb_type))
2194                                 my *= 2;
2195
2196                             mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx + sx, my + sy, direction);
2197                         }
2198                     } else if (IS_8X16(mb_type)) {
2199                         for (i = 0; i < 2; i++) {
2200                             int sx = mb_x * 16 + 4 + 8 * i;
2201                             int sy = mb_y * 16 + 8;
2202                             int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
2203                             int mx = motion_val[direction][xy][0] >> shift;
2204                             int my = motion_val[direction][xy][1] >> shift;
2205
2206                             if (IS_INTERLACED(mb_type))
2207                                 my *= 2;
2208
2209                             mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx + sx, my + sy, direction);
2210                         }
2211                     } else {
2212                           int sx = mb_x * 16 + 8;
2213                           int sy = mb_y * 16 + 8;
2214                           int xy = (mb_x + mb_y * mv_stride) << mv_sample_log2;
2215                           int mx = (motion_val[direction][xy][0]>>shift) + sx;
2216                           int my = (motion_val[direction][xy][1]>>shift) + sy;
2217                           mbcount += add_mb(mvs + mbcount, mb_type, sx, sy, mx, my, direction);
2218                     }
2219                 }
2220             }
2221         }
2222
2223         if (mbcount) {
2224             AVFrameSideData *sd;
2225
2226             av_log(avctx, AV_LOG_DEBUG, "Adding %d MVs info to frame %d\n", mbcount, avctx->frame_number);
2227             sd = av_frame_new_side_data(pict, AV_FRAME_DATA_MOTION_VECTORS, mbcount * sizeof(AVMotionVector));
2228             if (!sd)
2229                 return;
2230             memcpy(sd->data, mvs, mbcount * sizeof(AVMotionVector));
2231         }
2232
2233         av_freep(&mvs);
2234     }
2235
2236     /* TODO: export all the following to make them accessible for users (and filters) */
2237     if (avctx->hwaccel || !mbtype_table
2238         || (avctx->codec->capabilities&CODEC_CAP_HWACCEL_VDPAU))
2239         return;
2240
2241
2242     if (avctx->debug & (FF_DEBUG_SKIP | FF_DEBUG_QP | FF_DEBUG_MB_TYPE)) {
2243         int x,y;
2244
2245         av_log(avctx, AV_LOG_DEBUG, "New frame, type: %c\n",
2246                av_get_picture_type_char(pict->pict_type));
2247         for (y = 0; y < mb_height; y++) {
2248             for (x = 0; x < mb_width; x++) {
2249                 if (avctx->debug & FF_DEBUG_SKIP) {
2250                     int count = mbskip_table[x + y * mb_stride];
2251                     if (count > 9)
2252                         count = 9;
2253                     av_log(avctx, AV_LOG_DEBUG, "%1d", count);
2254                 }
2255                 if (avctx->debug & FF_DEBUG_QP) {
2256                     av_log(avctx, AV_LOG_DEBUG, "%2d",
2257                            qscale_table[x + y * mb_stride]);
2258                 }
2259                 if (avctx->debug & FF_DEBUG_MB_TYPE) {
2260                     int mb_type = mbtype_table[x + y * mb_stride];
2261                     // Type & MV direction
2262                     if (IS_PCM(mb_type))
2263                         av_log(avctx, AV_LOG_DEBUG, "P");
2264                     else if (IS_INTRA(mb_type) && IS_ACPRED(mb_type))
2265                         av_log(avctx, AV_LOG_DEBUG, "A");
2266                     else if (IS_INTRA4x4(mb_type))
2267                         av_log(avctx, AV_LOG_DEBUG, "i");
2268                     else if (IS_INTRA16x16(mb_type))
2269                         av_log(avctx, AV_LOG_DEBUG, "I");
2270                     else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type))
2271                         av_log(avctx, AV_LOG_DEBUG, "d");
2272                     else if (IS_DIRECT(mb_type))
2273                         av_log(avctx, AV_LOG_DEBUG, "D");
2274                     else if (IS_GMC(mb_type) && IS_SKIP(mb_type))
2275                         av_log(avctx, AV_LOG_DEBUG, "g");
2276                     else if (IS_GMC(mb_type))
2277                         av_log(avctx, AV_LOG_DEBUG, "G");
2278                     else if (IS_SKIP(mb_type))
2279                         av_log(avctx, AV_LOG_DEBUG, "S");
2280                     else if (!USES_LIST(mb_type, 1))
2281                         av_log(avctx, AV_LOG_DEBUG, ">");
2282                     else if (!USES_LIST(mb_type, 0))
2283                         av_log(avctx, AV_LOG_DEBUG, "<");
2284                     else {
2285                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
2286                         av_log(avctx, AV_LOG_DEBUG, "X");
2287                     }
2288
2289                     // segmentation
2290                     if (IS_8X8(mb_type))
2291                         av_log(avctx, AV_LOG_DEBUG, "+");
2292                     else if (IS_16X8(mb_type))
2293                         av_log(avctx, AV_LOG_DEBUG, "-");
2294                     else if (IS_8X16(mb_type))
2295                         av_log(avctx, AV_LOG_DEBUG, "|");
2296                     else if (IS_INTRA(mb_type) || IS_16X16(mb_type))
2297                         av_log(avctx, AV_LOG_DEBUG, " ");
2298                     else
2299                         av_log(avctx, AV_LOG_DEBUG, "?");
2300
2301
2302                     if (IS_INTERLACED(mb_type))
2303                         av_log(avctx, AV_LOG_DEBUG, "=");
2304                     else
2305                         av_log(avctx, AV_LOG_DEBUG, " ");
2306                 }
2307             }
2308             av_log(avctx, AV_LOG_DEBUG, "\n");
2309         }
2310     }
2311
2312     if ((avctx->debug & (FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE)) ||
2313         (avctx->debug_mv)) {
2314         int mb_y;
2315         int i;
2316         int h_chroma_shift, v_chroma_shift, block_height;
2317 #if FF_API_VISMV
2318         const int shift = 1 + quarter_sample;
2319         uint8_t *ptr;
2320         const int width          = avctx->width;
2321         const int height         = avctx->height;
2322 #endif
2323         const int mv_sample_log2 = avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_SVQ3 ? 2 : 1;
2324         const int mv_stride      = (mb_width << mv_sample_log2) +
2325                                    (avctx->codec->id == AV_CODEC_ID_H264 ? 0 : 1);
2326
2327         *low_delay = 0; // needed to see the vectors without trashing the buffers
2328
2329         avcodec_get_chroma_sub_sample(avctx->pix_fmt, &h_chroma_shift, &v_chroma_shift);
2330
2331         av_frame_make_writable(pict);
2332
2333         pict->opaque = NULL;
2334 #if FF_API_VISMV
2335         ptr          = pict->data[0];
2336 #endif
2337         block_height = 16 >> v_chroma_shift;
2338
2339         for (mb_y = 0; mb_y < mb_height; mb_y++) {
2340             int mb_x;
2341             for (mb_x = 0; mb_x < mb_width; mb_x++) {
2342                 const int mb_index = mb_x + mb_y * mb_stride;
2343 #if FF_API_VISMV
2344                 if ((avctx->debug_mv) && motion_val[0]) {
2345                     int type;
2346                     for (type = 0; type < 3; type++) {
2347                         int direction = 0;
2348                         switch (type) {
2349                         case 0:
2350                             if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_P_FOR)) ||
2351                                 (pict->pict_type!= AV_PICTURE_TYPE_P))
2352                                 continue;
2353                             direction = 0;
2354                             break;
2355                         case 1:
2356                             if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_B_FOR)) ||
2357                                 (pict->pict_type!= AV_PICTURE_TYPE_B))
2358                                 continue;
2359                             direction = 0;
2360                             break;
2361                         case 2:
2362                             if ((!(avctx->debug_mv & FF_DEBUG_VIS_MV_B_BACK)) ||
2363                                 (pict->pict_type!= AV_PICTURE_TYPE_B))
2364                                 continue;
2365                             direction = 1;
2366                             break;
2367                         }
2368                         if (!USES_LIST(mbtype_table[mb_index], direction))
2369                             continue;
2370
2371                         if (IS_8X8(mbtype_table[mb_index])) {
2372                             int i;
2373                             for (i = 0; i < 4; i++) {
2374                                 int sx = mb_x * 16 + 4 + 8 * (i & 1);
2375                                 int sy = mb_y * 16 + 4 + 8 * (i >> 1);
2376                                 int xy = (mb_x * 2 + (i & 1) +
2377                                           (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2378                                 int mx = (motion_val[direction][xy][0] >> shift) + sx;
2379                                 int my = (motion_val[direction][xy][1] >> shift) + sy;
2380                                 draw_arrow(ptr, sx, sy, mx, my, width,
2381                                            height, pict->linesize[0], 100, 0, direction);
2382                             }
2383                         } else if (IS_16X8(mbtype_table[mb_index])) {
2384                             int i;
2385                             for (i = 0; i < 2; i++) {
2386                                 int sx = mb_x * 16 + 8;
2387                                 int sy = mb_y * 16 + 4 + 8 * i;
2388                                 int xy = (mb_x * 2 + (mb_y * 2 + i) * mv_stride) << (mv_sample_log2 - 1);
2389                                 int mx = (motion_val[direction][xy][0] >> shift);
2390                                 int my = (motion_val[direction][xy][1] >> shift);
2391
2392                                 if (IS_INTERLACED(mbtype_table[mb_index]))
2393                                     my *= 2;
2394
2395                                 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
2396                                            height, pict->linesize[0], 100, 0, direction);
2397                             }
2398                         } else if (IS_8X16(mbtype_table[mb_index])) {
2399                             int i;
2400                             for (i = 0; i < 2; i++) {
2401                                 int sx = mb_x * 16 + 4 + 8 * i;
2402                                 int sy = mb_y * 16 + 8;
2403                                 int xy = (mb_x * 2 + i + mb_y * 2 * mv_stride) << (mv_sample_log2 - 1);
2404                                 int mx = motion_val[direction][xy][0] >> shift;
2405                                 int my = motion_val[direction][xy][1] >> shift;
2406
2407                                 if (IS_INTERLACED(mbtype_table[mb_index]))
2408                                     my *= 2;
2409
2410                                 draw_arrow(ptr, sx, sy, mx + sx, my + sy, width,
2411                                            height, pict->linesize[0], 100, 0, direction);
2412                             }
2413                         } else {
2414                               int sx= mb_x * 16 + 8;
2415                               int sy= mb_y * 16 + 8;
2416                               int xy= (mb_x + mb_y * mv_stride) << mv_sample_log2;
2417                               int mx= (motion_val[direction][xy][0]>>shift) + sx;
2418                               int my= (motion_val[direction][xy][1]>>shift) + sy;
2419                               draw_arrow(ptr, sx, sy, mx, my, width, height, pict->linesize[0], 100, 0, direction);
2420                         }
2421                     }
2422                 }
2423 #endif
2424                 if ((avctx->debug & FF_DEBUG_VIS_QP)) {
2425                     uint64_t c = (qscale_table[mb_index] * 128 / 31) *
2426                                  0x0101010101010101ULL;
2427                     int y;
2428                     for (y = 0; y < block_height; y++) {
2429                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
2430                                       (block_height * mb_y + y) *
2431                                       pict->linesize[1]) = c;
2432                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
2433                                       (block_height * mb_y + y) *
2434                                       pict->linesize[2]) = c;
2435                     }
2436                 }
2437                 if ((avctx->debug & FF_DEBUG_VIS_MB_TYPE) &&
2438                     motion_val[0]) {
2439                     int mb_type = mbtype_table[mb_index];
2440                     uint64_t u,v;
2441                     int y;
2442 #define COLOR(theta, r) \
2443     u = (int)(128 + r * cos(theta * 3.141592 / 180)); \
2444     v = (int)(128 + r * sin(theta * 3.141592 / 180));
2445
2446
2447                     u = v = 128;
2448                     if (IS_PCM(mb_type)) {
2449                         COLOR(120, 48)
2450                     } else if ((IS_INTRA(mb_type) && IS_ACPRED(mb_type)) ||
2451                                IS_INTRA16x16(mb_type)) {
2452                         COLOR(30, 48)
2453                     } else if (IS_INTRA4x4(mb_type)) {
2454                         COLOR(90, 48)
2455                     } else if (IS_DIRECT(mb_type) && IS_SKIP(mb_type)) {
2456                         // COLOR(120, 48)
2457                     } else if (IS_DIRECT(mb_type)) {
2458                         COLOR(150, 48)
2459                     } else if (IS_GMC(mb_type) && IS_SKIP(mb_type)) {
2460                         COLOR(170, 48)
2461                     } else if (IS_GMC(mb_type)) {
2462                         COLOR(190, 48)
2463                     } else if (IS_SKIP(mb_type)) {
2464                         // COLOR(180, 48)
2465                     } else if (!USES_LIST(mb_type, 1)) {
2466                         COLOR(240, 48)
2467                     } else if (!USES_LIST(mb_type, 0)) {
2468                         COLOR(0, 48)
2469                     } else {
2470                         av_assert2(USES_LIST(mb_type, 0) && USES_LIST(mb_type, 1));
2471                         COLOR(300,48)
2472                     }
2473
2474                     u *= 0x0101010101010101ULL;
2475                     v *= 0x0101010101010101ULL;
2476                     for (y = 0; y < block_height; y++) {
2477                         *(uint64_t *)(pict->data[1] + 8 * mb_x +
2478                                       (block_height * mb_y + y) * pict->linesize[1]) = u;
2479                         *(uint64_t *)(pict->data[2] + 8 * mb_x +
2480                                       (block_height * mb_y + y) * pict->linesize[2]) = v;
2481                     }
2482
2483                     // segmentation
2484                     if (IS_8X8(mb_type) || IS_16X8(mb_type)) {
2485                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 0 +
2486                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
2487                         *(uint64_t *)(pict->data[0] + 16 * mb_x + 8 +
2488                                       (16 * mb_y + 8) * pict->linesize[0]) ^= 0x8080808080808080ULL;
2489                     }
2490                     if (IS_8X8(mb_type) || IS_8X16(mb_type)) {
2491                         for (y = 0; y < 16; y++)
2492                             pict->data[0][16 * mb_x + 8 + (16 * mb_y + y) *
2493                                           pict->linesize[0]] ^= 0x80;
2494                     }
2495                     if (IS_8X8(mb_type) && mv_sample_log2 >= 2) {
2496                         int dm = 1 << (mv_sample_log2 - 2);
2497                         for (i = 0; i < 4; i++) {
2498                             int sx = mb_x * 16 + 8 * (i & 1);
2499                             int sy = mb_y * 16 + 8 * (i >> 1);
2500                             int xy = (mb_x * 2 + (i & 1) +
2501                                      (mb_y * 2 + (i >> 1)) * mv_stride) << (mv_sample_log2 - 1);
2502                             // FIXME bidir
2503                             int32_t *mv = (int32_t *) &motion_val[0][xy];
2504                             if (mv[0] != mv[dm] ||
2505                                 mv[dm * mv_stride] != mv[dm * (mv_stride + 1)])
2506                                 for (y = 0; y < 8; y++)
2507                                     pict->data[0][sx + 4 + (sy + y) * pict->linesize[0]] ^= 0x80;
2508                             if (mv[0] != mv[dm * mv_stride] || mv[dm] != mv[dm * (mv_stride + 1)])
2509                                 *(uint64_t *)(pict->data[0] + sx + (sy + 4) *
2510                                               pict->linesize[0]) ^= 0x8080808080808080ULL;
2511                         }
2512                     }
2513
2514                     if (IS_INTERLACED(mb_type) &&
2515                         avctx->codec->id == AV_CODEC_ID_H264) {
2516                         // hmm
2517                     }
2518                 }
2519                 mbskip_table[mb_index] = 0;
2520             }
2521         }
2522     }
2523 }
2524
2525 void ff_print_debug_info(MpegEncContext *s, Picture *p, AVFrame *pict)
2526 {
2527     ff_print_debug_info2(s->avctx, pict, s->mbskip_table, p->mb_type,
2528                          p->qscale_table, p->motion_val, &s->low_delay,
2529                          s->mb_width, s->mb_height, s->mb_stride, s->quarter_sample);
2530 }
2531
2532 int ff_mpv_export_qp_table(MpegEncContext *s, AVFrame *f, Picture *p, int qp_type)
2533 {
2534     AVBufferRef *ref = av_buffer_ref(p->qscale_table_buf);
2535     int offset = 2*s->mb_stride + 1;
2536     if(!ref)
2537         return AVERROR(ENOMEM);
2538     av_assert0(ref->size >= offset + s->mb_stride * ((f->height+15)/16));
2539     ref->size -= offset;
2540     ref->data += offset;
2541     return av_frame_set_qp_table(f, ref, s->mb_stride, qp_type);
2542 }
2543
2544 static inline int hpel_motion_lowres(MpegEncContext *s,
2545                                      uint8_t *dest, uint8_t *src,
2546                                      int field_based, int field_select,
2547                                      int src_x, int src_y,
2548                                      int width, int height, ptrdiff_t stride,
2549                                      int h_edge_pos, int v_edge_pos,
2550                                      int w, int h, h264_chroma_mc_func *pix_op,
2551                                      int motion_x, int motion_y)
2552 {
2553     const int lowres   = s->avctx->lowres;
2554     const int op_index = FFMIN(lowres, 3);
2555     const int s_mask   = (2 << lowres) - 1;
2556     int emu = 0;
2557     int sx, sy;
2558
2559     if (s->quarter_sample) {
2560         motion_x /= 2;
2561         motion_y /= 2;
2562     }
2563
2564     sx = motion_x & s_mask;
2565     sy = motion_y & s_mask;
2566     src_x += motion_x >> lowres + 1;
2567     src_y += motion_y >> lowres + 1;
2568
2569     src   += src_y * stride + src_x;
2570
2571     if ((unsigned)src_x > FFMAX( h_edge_pos - (!!sx) - w,                 0) ||
2572         (unsigned)src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2573         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, src,
2574                                  s->linesize, s->linesize,
2575                                  w + 1, (h + 1) << field_based,
2576                                  src_x, src_y   << field_based,
2577                                  h_edge_pos, v_edge_pos);
2578         src = s->edge_emu_buffer;
2579         emu = 1;
2580     }
2581
2582     sx = (sx << 2) >> lowres;
2583     sy = (sy << 2) >> lowres;
2584     if (field_select)
2585         src += s->linesize;
2586     pix_op[op_index](dest, src, stride, h, sx, sy);
2587     return emu;
2588 }
2589
2590 /* apply one mpeg motion vector to the three components */
2591 static av_always_inline void mpeg_motion_lowres(MpegEncContext *s,
2592                                                 uint8_t *dest_y,
2593                                                 uint8_t *dest_cb,
2594                                                 uint8_t *dest_cr,
2595                                                 int field_based,
2596                                                 int bottom_field,
2597                                                 int field_select,
2598                                                 uint8_t **ref_picture,
2599                                                 h264_chroma_mc_func *pix_op,
2600                                                 int motion_x, int motion_y,
2601                                                 int h, int mb_y)
2602 {
2603     uint8_t *ptr_y, *ptr_cb, *ptr_cr;
2604     int mx, my, src_x, src_y, uvsrc_x, uvsrc_y, sx, sy, uvsx, uvsy;
2605     ptrdiff_t uvlinesize, linesize;
2606     const int lowres     = s->avctx->lowres;
2607     const int op_index   = FFMIN(lowres-1+s->chroma_x_shift, 3);
2608     const int block_s    = 8>>lowres;
2609     const int s_mask     = (2 << lowres) - 1;
2610     const int h_edge_pos = s->h_edge_pos >> lowres;
2611     const int v_edge_pos = s->v_edge_pos >> lowres;
2612     linesize   = s->current_picture.f->linesize[0] << field_based;
2613     uvlinesize = s->current_picture.f->linesize[1] << field_based;
2614
2615     // FIXME obviously not perfect but qpel will not work in lowres anyway
2616     if (s->quarter_sample) {
2617         motion_x /= 2;
2618         motion_y /= 2;
2619     }
2620
2621     if(field_based){
2622         motion_y += (bottom_field - field_select)*((1 << lowres)-1);
2623     }
2624
2625     sx = motion_x & s_mask;
2626     sy = motion_y & s_mask;
2627     src_x = s->mb_x * 2 * block_s + (motion_x >> lowres + 1);
2628     src_y = (mb_y * 2 * block_s >> field_based) + (motion_y >> lowres + 1);
2629
2630     if (s->out_format == FMT_H263) {
2631         uvsx    = ((motion_x >> 1) & s_mask) | (sx & 1);
2632         uvsy    = ((motion_y >> 1) & s_mask) | (sy & 1);
2633         uvsrc_x = src_x >> 1;
2634         uvsrc_y = src_y >> 1;
2635     } else if (s->out_format == FMT_H261) {
2636         // even chroma mv's are full pel in H261
2637         mx      = motion_x / 4;
2638         my      = motion_y / 4;
2639         uvsx    = (2 * mx) & s_mask;
2640         uvsy    = (2 * my) & s_mask;
2641         uvsrc_x = s->mb_x * block_s + (mx >> lowres);
2642         uvsrc_y =    mb_y * block_s + (my >> lowres);
2643     } else {
2644         if(s->chroma_y_shift){
2645             mx      = motion_x / 2;
2646             my      = motion_y / 2;
2647             uvsx    = mx & s_mask;
2648             uvsy    = my & s_mask;
2649             uvsrc_x = s->mb_x * block_s                 + (mx >> lowres + 1);
2650             uvsrc_y =   (mb_y * block_s >> field_based) + (my >> lowres + 1);
2651         } else {
2652             if(s->chroma_x_shift){
2653             //Chroma422
2654                 mx = motion_x / 2;
2655                 uvsx = mx & s_mask;
2656                 uvsy = motion_y & s_mask;
2657                 uvsrc_y = src_y;
2658                 uvsrc_x = s->mb_x*block_s               + (mx >> (lowres+1));
2659             } else {
2660             //Chroma444
2661                 uvsx = motion_x & s_mask;
2662                 uvsy = motion_y & s_mask;
2663                 uvsrc_x = src_x;
2664                 uvsrc_y = src_y;
2665             }
2666         }
2667     }
2668
2669     ptr_y  = ref_picture[0] + src_y   * linesize   + src_x;
2670     ptr_cb = ref_picture[1] + uvsrc_y * uvlinesize + uvsrc_x;
2671     ptr_cr = ref_picture[2] + uvsrc_y * uvlinesize + uvsrc_x;
2672
2673     if ((unsigned) src_x > FFMAX( h_edge_pos - (!!sx) - 2 * block_s,       0) || uvsrc_y<0 ||
2674         (unsigned) src_y > FFMAX((v_edge_pos >> field_based) - (!!sy) - h, 0)) {
2675         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr_y,
2676                                  linesize >> field_based, linesize >> field_based,
2677                                  17, 17 + field_based,
2678                                 src_x, src_y << field_based, h_edge_pos,
2679                                 v_edge_pos);
2680         ptr_y = s->edge_emu_buffer;
2681         if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2682             uint8_t *ubuf = s->edge_emu_buffer + 18 * s->linesize;
2683             uint8_t *vbuf =ubuf + 9 * s->uvlinesize;
2684             s->vdsp.emulated_edge_mc(ubuf,  ptr_cb,
2685                                      uvlinesize >> field_based, uvlinesize >> field_based,
2686                                      9, 9 + field_based,
2687                                     uvsrc_x, uvsrc_y << field_based,
2688                                     h_edge_pos >> 1, v_edge_pos >> 1);
2689             s->vdsp.emulated_edge_mc(vbuf,  ptr_cr,
2690                                      uvlinesize >> field_based,uvlinesize >> field_based,
2691                                      9, 9 + field_based,
2692                                     uvsrc_x, uvsrc_y << field_based,
2693                                     h_edge_pos >> 1, v_edge_pos >> 1);
2694             ptr_cb = ubuf;
2695             ptr_cr = vbuf;
2696         }
2697     }
2698
2699     // FIXME use this for field pix too instead of the obnoxious hack which changes picture.f->data
2700     if (bottom_field) {
2701         dest_y  += s->linesize;
2702         dest_cb += s->uvlinesize;
2703         dest_cr += s->uvlinesize;
2704     }
2705
2706     if (field_select) {
2707         ptr_y   += s->linesize;
2708         ptr_cb  += s->uvlinesize;
2709         ptr_cr  += s->uvlinesize;
2710     }
2711
2712     sx = (sx << 2) >> lowres;
2713     sy = (sy << 2) >> lowres;
2714     pix_op[lowres - 1](dest_y, ptr_y, linesize, h, sx, sy);
2715
2716     if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY)) {
2717         int hc = s->chroma_y_shift ? (h+1-bottom_field)>>1 : h;
2718         uvsx = (uvsx << 2) >> lowres;
2719         uvsy = (uvsy << 2) >> lowres;
2720         if (hc) {
2721             pix_op[op_index](dest_cb, ptr_cb, uvlinesize, hc, uvsx, uvsy);
2722             pix_op[op_index](dest_cr, ptr_cr, uvlinesize, hc, uvsx, uvsy);
2723         }
2724     }
2725     // FIXME h261 lowres loop filter
2726 }
2727
2728 static inline void chroma_4mv_motion_lowres(MpegEncContext *s,
2729                                             uint8_t *dest_cb, uint8_t *dest_cr,
2730                                             uint8_t **ref_picture,
2731                                             h264_chroma_mc_func * pix_op,
2732                                             int mx, int my)
2733 {
2734     const int lowres     = s->avctx->lowres;
2735     const int op_index   = FFMIN(lowres, 3);
2736     const int block_s    = 8 >> lowres;
2737     const int s_mask     = (2 << lowres) - 1;
2738     const int h_edge_pos = s->h_edge_pos >> lowres + 1;
2739     const int v_edge_pos = s->v_edge_pos >> lowres + 1;
2740     int emu = 0, src_x, src_y, sx, sy;
2741     ptrdiff_t offset;
2742     uint8_t *ptr;
2743
2744     if (s->quarter_sample) {
2745         mx /= 2;
2746         my /= 2;
2747     }
2748
2749     /* In case of 8X8, we construct a single chroma motion vector
2750        with a special rounding */
2751     mx = ff_h263_round_chroma(mx);
2752     my = ff_h263_round_chroma(my);
2753
2754     sx = mx & s_mask;
2755     sy = my & s_mask;
2756     src_x = s->mb_x * block_s + (mx >> lowres + 1);
2757     src_y = s->mb_y * block_s + (my >> lowres + 1);
2758
2759     offset = src_y * s->uvlinesize + src_x;
2760     ptr = ref_picture[1] + offset;
2761     if ((unsigned) src_x > FFMAX(h_edge_pos - (!!sx) - block_s, 0) ||
2762         (unsigned) src_y > FFMAX(v_edge_pos - (!!sy) - block_s, 0)) {
2763         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr,
2764                                  s->uvlinesize, s->uvlinesize,
2765                                  9, 9,
2766                                  src_x, src_y, h_edge_pos, v_edge_pos);
2767         ptr = s->edge_emu_buffer;
2768         emu = 1;
2769     }
2770     sx = (sx << 2) >> lowres;
2771     sy = (sy << 2) >> lowres;
2772     pix_op[op_index](dest_cb, ptr, s->uvlinesize, block_s, sx, sy);
2773
2774     ptr = ref_picture[2] + offset;
2775     if (emu) {
2776         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr,
2777                                  s->uvlinesize, s->uvlinesize,
2778                                  9, 9,
2779                                  src_x, src_y, h_edge_pos, v_edge_pos);
2780         ptr = s->edge_emu_buffer;
2781     }
2782     pix_op[op_index](dest_cr, ptr, s->uvlinesize, block_s, sx, sy);
2783 }
2784
2785 /**
2786  * motion compensation of a single macroblock
2787  * @param s context
2788  * @param dest_y luma destination pointer
2789  * @param dest_cb chroma cb/u destination pointer
2790  * @param dest_cr chroma cr/v destination pointer
2791  * @param dir direction (0->forward, 1->backward)
2792  * @param ref_picture array[3] of pointers to the 3 planes of the reference picture
2793  * @param pix_op halfpel motion compensation function (average or put normally)
2794  * the motion vectors are taken from s->mv and the MV type from s->mv_type
2795  */
2796 static inline void MPV_motion_lowres(MpegEncContext *s,
2797                                      uint8_t *dest_y, uint8_t *dest_cb,
2798                                      uint8_t *dest_cr,
2799                                      int dir, uint8_t **ref_picture,
2800                                      h264_chroma_mc_func *pix_op)
2801 {
2802     int mx, my;
2803     int mb_x, mb_y, i;
2804     const int lowres  = s->avctx->lowres;
2805     const int block_s = 8 >>lowres;
2806
2807     mb_x = s->mb_x;
2808     mb_y = s->mb_y;
2809
2810     switch (s->mv_type) {
2811     case MV_TYPE_16X16:
2812         mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2813                            0, 0, 0,
2814                            ref_picture, pix_op,
2815                            s->mv[dir][0][0], s->mv[dir][0][1],
2816                            2 * block_s, mb_y);
2817         break;
2818     case MV_TYPE_8X8:
2819         mx = 0;
2820         my = 0;
2821         for (i = 0; i < 4; i++) {
2822             hpel_motion_lowres(s, dest_y + ((i & 1) + (i >> 1) *
2823                                s->linesize) * block_s,
2824                                ref_picture[0], 0, 0,
2825                                (2 * mb_x + (i & 1)) * block_s,
2826                                (2 * mb_y + (i >> 1)) * block_s,
2827                                s->width, s->height, s->linesize,
2828                                s->h_edge_pos >> lowres, s->v_edge_pos >> lowres,
2829                                block_s, block_s, pix_op,
2830                                s->mv[dir][i][0], s->mv[dir][i][1]);
2831
2832             mx += s->mv[dir][i][0];
2833             my += s->mv[dir][i][1];
2834         }
2835
2836         if (!CONFIG_GRAY || !(s->flags & CODEC_FLAG_GRAY))
2837             chroma_4mv_motion_lowres(s, dest_cb, dest_cr, ref_picture,
2838                                      pix_op, mx, my);
2839         break;
2840     case MV_TYPE_FIELD:
2841         if (s->picture_structure == PICT_FRAME) {
2842             /* top field */
2843             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2844                                1, 0, s->field_select[dir][0],
2845                                ref_picture, pix_op,
2846                                s->mv[dir][0][0], s->mv[dir][0][1],
2847                                block_s, mb_y);
2848             /* bottom field */
2849             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2850                                1, 1, s->field_select[dir][1],
2851                                ref_picture, pix_op,
2852                                s->mv[dir][1][0], s->mv[dir][1][1],
2853                                block_s, mb_y);
2854         } else {
2855             if (s->picture_structure != s->field_select[dir][0] + 1 &&
2856                 s->pict_type != AV_PICTURE_TYPE_B && !s->first_field) {
2857                 ref_picture = s->current_picture_ptr->f->data;
2858
2859             }
2860             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2861                                0, 0, s->field_select[dir][0],
2862                                ref_picture, pix_op,
2863                                s->mv[dir][0][0],
2864                                s->mv[dir][0][1], 2 * block_s, mb_y >> 1);
2865             }
2866         break;
2867     case MV_TYPE_16X8:
2868         for (i = 0; i < 2; i++) {
2869             uint8_t **ref2picture;
2870
2871             if (s->picture_structure == s->field_select[dir][i] + 1 ||
2872                 s->pict_type == AV_PICTURE_TYPE_B || s->first_field) {
2873                 ref2picture = ref_picture;
2874             } else {
2875                 ref2picture = s->current_picture_ptr->f->data;
2876             }
2877
2878             mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2879                                0, 0, s->field_select[dir][i],
2880                                ref2picture, pix_op,
2881                                s->mv[dir][i][0], s->mv[dir][i][1] +
2882                                2 * block_s * i, block_s, mb_y >> 1);
2883
2884             dest_y  +=  2 * block_s *  s->linesize;
2885             dest_cb += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2886             dest_cr += (2 * block_s >> s->chroma_y_shift) * s->uvlinesize;
2887         }
2888         break;
2889     case MV_TYPE_DMV:
2890         if (s->picture_structure == PICT_FRAME) {
2891             for (i = 0; i < 2; i++) {
2892                 int j;
2893                 for (j = 0; j < 2; j++) {
2894                     mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2895                                        1, j, j ^ i,
2896                                        ref_picture, pix_op,
2897                                        s->mv[dir][2 * i + j][0],
2898                                        s->mv[dir][2 * i + j][1],
2899                                        block_s, mb_y);
2900                 }
2901                 pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
2902             }
2903         } else {
2904             for (i = 0; i < 2; i++) {
2905                 mpeg_motion_lowres(s, dest_y, dest_cb, dest_cr,
2906                                    0, 0, s->picture_structure != i + 1,
2907                                    ref_picture, pix_op,
2908                                    s->mv[dir][2 * i][0],s->mv[dir][2 * i][1],
2909                                    2 * block_s, mb_y >> 1);
2910
2911                 // after put we make avg of the same block
2912                 pix_op = s->h264chroma.avg_h264_chroma_pixels_tab;
2913
2914                 // opposite parity is always in the same
2915                 // frame if this is second field
2916                 if (!s->first_field) {
2917                     ref_picture = s->current_picture_ptr->f->data;
2918                 }
2919             }
2920         }
2921         break;
2922     default:
2923         av_assert2(0);
2924     }
2925 }
2926
2927 /**
2928  * find the lowest MB row referenced in the MVs
2929  */
2930 int ff_mpv_lowest_referenced_row(MpegEncContext *s, int dir)
2931 {
2932     int my_max = INT_MIN, my_min = INT_MAX, qpel_shift = !s->quarter_sample;
2933     int my, off, i, mvs;
2934
2935     if (s->picture_structure != PICT_FRAME || s->mcsel)
2936         goto unhandled;
2937
2938     switch (s->mv_type) {
2939         case MV_TYPE_16X16:
2940             mvs = 1;
2941             break;
2942         case MV_TYPE_16X8:
2943             mvs = 2;
2944             break;
2945         case MV_TYPE_8X8:
2946             mvs = 4;
2947             break;
2948         default:
2949             goto unhandled;
2950     }
2951
2952     for (i = 0; i < mvs; i++) {
2953         my = s->mv[dir][i][1]<<qpel_shift;
2954         my_max = FFMAX(my_max, my);
2955         my_min = FFMIN(my_min, my);
2956     }
2957
2958     off = (FFMAX(-my_min, my_max) + 63) >> 6;
2959
2960     return FFMIN(FFMAX(s->mb_y + off, 0), s->mb_height-1);
2961 unhandled:
2962     return s->mb_height-1;
2963 }
2964
2965 /* put block[] to dest[] */
2966 static inline void put_dct(MpegEncContext *s,
2967                            int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2968 {
2969     s->dct_unquantize_intra(s, block, i, qscale);
2970     s->idsp.idct_put(dest, line_size, block);
2971 }
2972
2973 /* add block[] to dest[] */
2974 static inline void add_dct(MpegEncContext *s,
2975                            int16_t *block, int i, uint8_t *dest, int line_size)
2976 {
2977     if (s->block_last_index[i] >= 0) {
2978         s->idsp.idct_add(dest, line_size, block);
2979     }
2980 }
2981
2982 static inline void add_dequant_dct(MpegEncContext *s,
2983                            int16_t *block, int i, uint8_t *dest, int line_size, int qscale)
2984 {
2985     if (s->block_last_index[i] >= 0) {
2986         s->dct_unquantize_inter(s, block, i, qscale);
2987
2988         s->idsp.idct_add(dest, line_size, block);
2989     }
2990 }
2991
2992 /**
2993  * Clean dc, ac, coded_block for the current non-intra MB.
2994  */
2995 void ff_clean_intra_table_entries(MpegEncContext *s)
2996 {
2997     int wrap = s->b8_stride;
2998     int xy = s->block_index[0];
2999
3000     s->dc_val[0][xy           ] =
3001     s->dc_val[0][xy + 1       ] =
3002     s->dc_val[0][xy     + wrap] =
3003     s->dc_val[0][xy + 1 + wrap] = 1024;
3004     /* ac pred */
3005     memset(s->ac_val[0][xy       ], 0, 32 * sizeof(int16_t));
3006     memset(s->ac_val[0][xy + wrap], 0, 32 * sizeof(int16_t));
3007     if (s->msmpeg4_version>=3) {
3008         s->coded_block[xy           ] =
3009         s->coded_block[xy + 1       ] =
3010         s->coded_block[xy     + wrap] =
3011         s->coded_block[xy + 1 + wrap] = 0;
3012     }
3013     /* chroma */
3014     wrap = s->mb_stride;
3015     xy = s->mb_x + s->mb_y * wrap;
3016     s->dc_val[1][xy] =
3017     s->dc_val[2][xy] = 1024;
3018     /* ac pred */
3019     memset(s->ac_val[1][xy], 0, 16 * sizeof(int16_t));
3020     memset(s->ac_val[2][xy], 0, 16 * sizeof(int16_t));
3021
3022     s->mbintra_table[xy]= 0;
3023 }
3024
3025 /* generic function called after a macroblock has been parsed by the
3026    decoder or after it has been encoded by the encoder.
3027
3028    Important variables used:
3029    s->mb_intra : true if intra macroblock
3030    s->mv_dir   : motion vector direction
3031    s->mv_type  : motion vector type
3032    s->mv       : motion vector
3033    s->interlaced_dct : true if interlaced dct used (mpeg2)
3034  */
3035 static av_always_inline
3036 void mpv_decode_mb_internal(MpegEncContext *s, int16_t block[12][64],
3037                             int lowres_flag, int is_mpeg12)
3038 {
3039     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
3040
3041     if (CONFIG_XVMC &&
3042         s->avctx->hwaccel && s->avctx->hwaccel->decode_mb) {
3043         s->avctx->hwaccel->decode_mb(s);//xvmc uses pblocks
3044         return;
3045     }
3046
3047     if(s->avctx->debug&FF_DEBUG_DCT_COEFF) {
3048        /* print DCT coefficients */
3049        int i,j;
3050        av_log(s->avctx, AV_LOG_DEBUG, "DCT coeffs of MB at %dx%d:\n", s->mb_x, s->mb_y);
3051        for(i=0; i<6; i++){
3052            for(j=0; j<64; j++){
3053                av_log(s->avctx, AV_LOG_DEBUG, "%5d",
3054                       block[i][s->idsp.idct_permutation[j]]);
3055            }
3056            av_log(s->avctx, AV_LOG_DEBUG, "\n");
3057        }
3058     }
3059
3060     s->current_picture.qscale_table[mb_xy] = s->qscale;
3061
3062     /* update DC predictors for P macroblocks */
3063     if (!s->mb_intra) {
3064         if (!is_mpeg12 && (s->h263_pred || s->h263_aic)) {
3065             if(s->mbintra_table[mb_xy])
3066                 ff_clean_intra_table_entries(s);
3067         } else {
3068             s->last_dc[0] =
3069             s->last_dc[1] =
3070             s->last_dc[2] = 128 << s->intra_dc_precision;
3071         }
3072     }
3073     else if (!is_mpeg12 && (s->h263_pred || s->h263_aic))
3074         s->mbintra_table[mb_xy]=1;
3075
3076     if (   (s->flags&CODEC_FLAG_PSNR)
3077         || s->avctx->frame_skip_threshold || s->avctx->frame_skip_factor
3078         || !(s->encoding && (s->intra_only || s->pict_type==AV_PICTURE_TYPE_B) && s->avctx->mb_decision != FF_MB_DECISION_RD)) { //FIXME precalc
3079         uint8_t *dest_y, *dest_cb, *dest_cr;
3080         int dct_linesize, dct_offset;
3081         op_pixels_func (*op_pix)[4];
3082         qpel_mc_func (*op_qpix)[16];
3083         const int linesize   = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
3084         const int uvlinesize = s->current_picture.f->linesize[1];
3085         const int readable= s->pict_type != AV_PICTURE_TYPE_B || s->encoding || s->avctx->draw_horiz_band || lowres_flag;
3086         const int block_size= lowres_flag ? 8>>s->avctx->lowres : 8;
3087
3088         /* avoid copy if macroblock skipped in last frame too */
3089         /* skip only during decoding as we might trash the buffers during encoding a bit */
3090         if(!s->encoding){
3091             uint8_t *mbskip_ptr = &s->mbskip_table[mb_xy];
3092
3093             if (s->mb_skipped) {
3094                 s->mb_skipped= 0;
3095                 av_assert2(s->pict_type!=AV_PICTURE_TYPE_I);
3096                 *mbskip_ptr = 1;
3097             } else if(!s->current_picture.reference) {
3098                 *mbskip_ptr = 1;
3099             } else{
3100                 *mbskip_ptr = 0; /* not skipped */
3101             }
3102         }
3103
3104         dct_linesize = linesize << s->interlaced_dct;
3105         dct_offset   = s->interlaced_dct ? linesize : linesize * block_size;
3106
3107         if(readable){
3108             dest_y=  s->dest[0];
3109             dest_cb= s->dest[1];
3110             dest_cr= s->dest[2];
3111         }else{
3112             dest_y = s->b_scratchpad;
3113             dest_cb= s->b_scratchpad+16*linesize;
3114             dest_cr= s->b_scratchpad+32*linesize;
3115         }
3116
3117         if (!s->mb_intra) {
3118             /* motion handling */
3119             /* decoding or more than one mb_type (MC was already done otherwise) */
3120             if(!s->encoding){
3121
3122                 if(HAVE_THREADS && s->avctx->active_thread_type&FF_THREAD_FRAME) {
3123                     if (s->mv_dir & MV_DIR_FORWARD) {
3124                         ff_thread_await_progress(&s->last_picture_ptr->tf,
3125                                                  ff_mpv_lowest_referenced_row(s, 0),
3126                                                  0);
3127                     }
3128                     if (s->mv_dir & MV_DIR_BACKWARD) {
3129                         ff_thread_await_progress(&s->next_picture_ptr->tf,
3130                                                  ff_mpv_lowest_referenced_row(s, 1),
3131                                                  0);
3132                     }
3133                 }
3134
3135                 if(lowres_flag){
3136                     h264_chroma_mc_func *op_pix = s->h264chroma.put_h264_chroma_pixels_tab;
3137
3138                     if (s->mv_dir & MV_DIR_FORWARD) {
3139                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix);
3140                         op_pix = s->h264chroma.avg_h264_chroma_pixels_tab;
3141                     }
3142                     if (s->mv_dir & MV_DIR_BACKWARD) {
3143                         MPV_motion_lowres(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix);
3144                     }
3145                 }else{
3146                     op_qpix = s->me.qpel_put;
3147                     if ((!s->no_rounding) || s->pict_type==AV_PICTURE_TYPE_B){
3148                         op_pix = s->hdsp.put_pixels_tab;
3149                     }else{
3150                         op_pix = s->hdsp.put_no_rnd_pixels_tab;
3151                     }
3152                     if (s->mv_dir & MV_DIR_FORWARD) {
3153                         ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 0, s->last_picture.f->data, op_pix, op_qpix);
3154                         op_pix = s->hdsp.avg_pixels_tab;
3155                         op_qpix= s->me.qpel_avg;
3156                     }
3157                     if (s->mv_dir & MV_DIR_BACKWARD) {
3158                         ff_mpv_motion(s, dest_y, dest_cb, dest_cr, 1, s->next_picture.f->data, op_pix, op_qpix);
3159                     }
3160                 }
3161             }
3162
3163             /* skip dequant / idct if we are really late ;) */
3164             if(s->avctx->skip_idct){
3165                 if(  (s->avctx->skip_idct >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B)
3166                    ||(s->avctx->skip_idct >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I)
3167                    || s->avctx->skip_idct >= AVDISCARD_ALL)
3168                     goto skip_idct;
3169             }
3170
3171             /* add dct residue */
3172             if(s->encoding || !(   s->msmpeg4_version || s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO
3173                                 || (s->codec_id==AV_CODEC_ID_MPEG4 && !s->mpeg_quant))){
3174                 add_dequant_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3175                 add_dequant_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3176                 add_dequant_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3177                 add_dequant_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3178
3179                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
3180                     if (s->chroma_y_shift){
3181                         add_dequant_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3182                         add_dequant_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3183                     }else{
3184                         dct_linesize >>= 1;
3185                         dct_offset >>=1;
3186                         add_dequant_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
3187                         add_dequant_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
3188                         add_dequant_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
3189                         add_dequant_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
3190                     }
3191                 }
3192             } else if(is_mpeg12 || (s->codec_id != AV_CODEC_ID_WMV2)){
3193                 add_dct(s, block[0], 0, dest_y                          , dct_linesize);
3194                 add_dct(s, block[1], 1, dest_y              + block_size, dct_linesize);
3195                 add_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize);
3196                 add_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize);
3197
3198                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
3199                     if(s->chroma_y_shift){//Chroma420
3200                         add_dct(s, block[4], 4, dest_cb, uvlinesize);
3201                         add_dct(s, block[5], 5, dest_cr, uvlinesize);
3202                     }else{
3203                         //chroma422
3204                         dct_linesize = uvlinesize << s->interlaced_dct;
3205                         dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
3206
3207                         add_dct(s, block[4], 4, dest_cb, dct_linesize);
3208                         add_dct(s, block[5], 5, dest_cr, dct_linesize);
3209                         add_dct(s, block[6], 6, dest_cb+dct_offset, dct_linesize);
3210                         add_dct(s, block[7], 7, dest_cr+dct_offset, dct_linesize);
3211                         if(!s->chroma_x_shift){//Chroma444
3212                             add_dct(s, block[8], 8, dest_cb+block_size, dct_linesize);
3213                             add_dct(s, block[9], 9, dest_cr+block_size, dct_linesize);
3214                             add_dct(s, block[10], 10, dest_cb+block_size+dct_offset, dct_linesize);
3215                             add_dct(s, block[11], 11, dest_cr+block_size+dct_offset, dct_linesize);
3216                         }
3217                     }
3218                 }//fi gray
3219             }
3220             else if (CONFIG_WMV2_DECODER || CONFIG_WMV2_ENCODER) {
3221                 ff_wmv2_add_mb(s, block, dest_y, dest_cb, dest_cr);
3222             }
3223         } else {
3224             /* dct only in intra block */
3225             if(s->encoding || !(s->codec_id==AV_CODEC_ID_MPEG1VIDEO || s->codec_id==AV_CODEC_ID_MPEG2VIDEO)){
3226                 put_dct(s, block[0], 0, dest_y                          , dct_linesize, s->qscale);
3227                 put_dct(s, block[1], 1, dest_y              + block_size, dct_linesize, s->qscale);
3228                 put_dct(s, block[2], 2, dest_y + dct_offset             , dct_linesize, s->qscale);
3229                 put_dct(s, block[3], 3, dest_y + dct_offset + block_size, dct_linesize, s->qscale);
3230
3231                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
3232                     if(s->chroma_y_shift){
3233                         put_dct(s, block[4], 4, dest_cb, uvlinesize, s->chroma_qscale);
3234                         put_dct(s, block[5], 5, dest_cr, uvlinesize, s->chroma_qscale);
3235                     }else{
3236                         dct_offset >>=1;
3237                         dct_linesize >>=1;
3238                         put_dct(s, block[4], 4, dest_cb,              dct_linesize, s->chroma_qscale);
3239                         put_dct(s, block[5], 5, dest_cr,              dct_linesize, s->chroma_qscale);
3240                         put_dct(s, block[6], 6, dest_cb + dct_offset, dct_linesize, s->chroma_qscale);
3241                         put_dct(s, block[7], 7, dest_cr + dct_offset, dct_linesize, s->chroma_qscale);
3242                     }
3243                 }
3244             }else{
3245                 s->idsp.idct_put(dest_y,                           dct_linesize, block[0]);
3246                 s->idsp.idct_put(dest_y              + block_size, dct_linesize, block[1]);
3247                 s->idsp.idct_put(dest_y + dct_offset,              dct_linesize, block[2]);
3248                 s->idsp.idct_put(dest_y + dct_offset + block_size, dct_linesize, block[3]);
3249
3250                 if(!CONFIG_GRAY || !(s->flags&CODEC_FLAG_GRAY)){
3251                     if(s->chroma_y_shift){
3252                         s->idsp.idct_put(dest_cb, uvlinesize, block[4]);
3253                         s->idsp.idct_put(dest_cr, uvlinesize, block[5]);
3254                     }else{
3255
3256                         dct_linesize = uvlinesize << s->interlaced_dct;
3257                         dct_offset   = s->interlaced_dct ? uvlinesize : uvlinesize*block_size;
3258
3259                         s->idsp.idct_put(dest_cb,              dct_linesize, block[4]);
3260                         s->idsp.idct_put(dest_cr,              dct_linesize, block[5]);
3261                         s->idsp.idct_put(dest_cb + dct_offset, dct_linesize, block[6]);
3262                         s->idsp.idct_put(dest_cr + dct_offset, dct_linesize, block[7]);
3263                         if(!s->chroma_x_shift){//Chroma444
3264                             s->idsp.idct_put(dest_cb + block_size,              dct_linesize, block[8]);
3265                             s->idsp.idct_put(dest_cr + block_size,              dct_linesize, block[9]);
3266                             s->idsp.idct_put(dest_cb + block_size + dct_offset, dct_linesize, block[10]);
3267                             s->idsp.idct_put(dest_cr + block_size + dct_offset, dct_linesize, block[11]);
3268                         }
3269                     }
3270                 }//gray
3271             }
3272         }
3273 skip_idct:
3274         if(!readable){
3275             s->hdsp.put_pixels_tab[0][0](s->dest[0], dest_y ,   linesize,16);
3276             s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[1], dest_cb, uvlinesize,16 >> s->chroma_y_shift);
3277             s->hdsp.put_pixels_tab[s->chroma_x_shift][0](s->dest[2], dest_cr, uvlinesize,16 >> s->chroma_y_shift);
3278         }
3279     }
3280 }
3281
3282 void ff_mpv_decode_mb(MpegEncContext *s, int16_t block[12][64])
3283 {
3284 #if !CONFIG_SMALL
3285     if(s->out_format == FMT_MPEG1) {
3286         if(s->avctx->lowres) mpv_decode_mb_internal(s, block, 1, 1);
3287         else                 mpv_decode_mb_internal(s, block, 0, 1);
3288     } else
3289 #endif
3290     if(s->avctx->lowres) mpv_decode_mb_internal(s, block, 1, 0);
3291     else                  mpv_decode_mb_internal(s, block, 0, 0);
3292 }
3293
3294 void ff_mpeg_draw_horiz_band(MpegEncContext *s, int y, int h)
3295 {
3296     ff_draw_horiz_band(s->avctx, s->current_picture_ptr->f,
3297                        s->last_picture_ptr ? s->last_picture_ptr->f : NULL, y, h, s->picture_structure,
3298                        s->first_field, s->low_delay);
3299 }
3300
3301 void ff_init_block_index(MpegEncContext *s){ //FIXME maybe rename
3302     const int linesize   = s->current_picture.f->linesize[0]; //not s->linesize as this would be wrong for field pics
3303     const int uvlinesize = s->current_picture.f->linesize[1];
3304     const int mb_size= 4 - s->avctx->lowres;
3305
3306     s->block_index[0]= s->b8_stride*(s->mb_y*2    ) - 2 + s->mb_x*2;
3307     s->block_index[1]= s->b8_stride*(s->mb_y*2    ) - 1 + s->mb_x*2;
3308     s->block_index[2]= s->b8_stride*(s->mb_y*2 + 1) - 2 + s->mb_x*2;
3309     s->block_index[3]= s->b8_stride*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
3310     s->block_index[4]= s->mb_stride*(s->mb_y + 1)                + s->b8_stride*s->mb_height*2 + s->mb_x - 1;
3311     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;
3312     //block_index is not used by mpeg2, so it is not affected by chroma_format
3313
3314     s->dest[0] = s->current_picture.f->data[0] + ((s->mb_x - 1) <<  mb_size);
3315     s->dest[1] = s->current_picture.f->data[1] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3316     s->dest[2] = s->current_picture.f->data[2] + ((s->mb_x - 1) << (mb_size - s->chroma_x_shift));
3317
3318     if(!(s->pict_type==AV_PICTURE_TYPE_B && s->avctx->draw_horiz_band && s->picture_structure==PICT_FRAME))
3319     {
3320         if(s->picture_structure==PICT_FRAME){
3321         s->dest[0] += s->mb_y *   linesize << mb_size;
3322         s->dest[1] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3323         s->dest[2] += s->mb_y * uvlinesize << (mb_size - s->chroma_y_shift);
3324         }else{
3325             s->dest[0] += (s->mb_y>>1) *   linesize << mb_size;
3326             s->dest[1] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
3327             s->dest[2] += (s->mb_y>>1) * uvlinesize << (mb_size - s->chroma_y_shift);
3328             av_assert1((s->mb_y&1) == (s->picture_structure == PICT_BOTTOM_FIELD));
3329         }
3330     }
3331 }
3332
3333 /**
3334  * Permute an 8x8 block.
3335  * @param block the block which will be permuted according to the given permutation vector
3336  * @param permutation the permutation vector
3337  * @param last the last non zero coefficient in scantable order, used to speed the permutation up
3338  * @param scantable the used scantable, this is only used to speed the permutation up, the block is not
3339  *                  (inverse) permutated to scantable order!
3340  */
3341 void ff_block_permute(int16_t *block, uint8_t *permutation, const uint8_t *scantable, int last)
3342 {
3343     int i;
3344     int16_t temp[64];
3345
3346     if(last<=0) return;
3347     //if(permutation[1]==1) return; //FIXME it is ok but not clean and might fail for some permutations
3348
3349     for(i=0; i<=last; i++){
3350         const int j= scantable[i];
3351         temp[j]= block[j];
3352         block[j]=0;
3353     }
3354
3355     for(i=0; i<=last; i++){
3356         const int j= scantable[i];
3357         const int perm_j= permutation[j];
3358         block[perm_j]= temp[j];
3359     }
3360 }
3361
3362 void ff_mpeg_flush(AVCodecContext *avctx){
3363     int i;
3364     MpegEncContext *s = avctx->priv_data;
3365
3366     if (!s || !s->picture)
3367         return;
3368
3369     for (i = 0; i < MAX_PICTURE_COUNT; i++)
3370         ff_mpeg_unref_picture(s, &s->picture[i]);
3371     s->current_picture_ptr = s->last_picture_ptr = s->next_picture_ptr = NULL;
3372
3373     ff_mpeg_unref_picture(s, &s->current_picture);
3374     ff_mpeg_unref_picture(s, &s->last_picture);
3375     ff_mpeg_unref_picture(s, &s->next_picture);
3376
3377     s->mb_x= s->mb_y= 0;
3378     s->closed_gop= 0;
3379
3380     s->parse_context.state= -1;
3381     s->parse_context.frame_start_found= 0;
3382     s->parse_context.overread= 0;
3383     s->parse_context.overread_index= 0;
3384     s->parse_context.index= 0;
3385     s->parse_context.last_index= 0;
3386     s->bitstream_buffer_size=0;
3387     s->pp_time=0;
3388 }
3389
3390 /**
3391  * set qscale and update qscale dependent variables.
3392  */
3393 void ff_set_qscale(MpegEncContext * s, int qscale)
3394 {
3395     if (qscale < 1)
3396         qscale = 1;
3397     else if (qscale > 31)
3398         qscale = 31;
3399
3400     s->qscale = qscale;
3401     s->chroma_qscale= s->chroma_qscale_table[qscale];
3402
3403     s->y_dc_scale= s->y_dc_scale_table[ qscale ];
3404     s->c_dc_scale= s->c_dc_scale_table[ s->chroma_qscale ];
3405 }
3406
3407 void ff_mpv_report_decode_progress(MpegEncContext *s)
3408 {
3409     if (s->pict_type != AV_PICTURE_TYPE_B && !s->partitioned_frame && !s->er.error_occurred)
3410         ff_thread_report_progress(&s->current_picture_ptr->tf, s->mb_y, 0);
3411 }