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