Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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