Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * VC-1 and WMV3 decoder
  3.  * Copyright (c) 2011 Mashiat Sarker Shakkhar
  4.  * Copyright (c) 2006-2007 Konstantin Shishkov
  5.  * Partly based on vc9.c (c) 2005 Anonymous, Alex Beregszaszi, Michael Niedermayer
  6.  *
  7.  * This file is part of FFmpeg.
  8.  *
  9.  * FFmpeg is free software; you can redistribute it and/or
  10.  * modify it under the terms of the GNU Lesser General Public
  11.  * License as published by the Free Software Foundation; either
  12.  * version 2.1 of the License, or (at your option) any later version.
  13.  *
  14.  * FFmpeg is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17.  * Lesser General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU Lesser General Public
  20.  * License along with FFmpeg; if not, write to the Free Software
  21.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  22.  */
  23.  
  24. /**
  25.  * @file
  26.  * VC-1 and WMV3 decoder
  27.  */
  28.  
  29. #include "avcodec.h"
  30. #include "blockdsp.h"
  31. #include "get_bits.h"
  32. #include "internal.h"
  33. #include "mpeg_er.h"
  34. #include "mpegvideo.h"
  35. #include "msmpeg4.h"
  36. #include "msmpeg4data.h"
  37. #include "vc1.h"
  38. #include "vc1data.h"
  39. #include "vdpau_compat.h"
  40. #include "libavutil/avassert.h"
  41.  
  42.  
  43. #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
  44.  
  45. typedef struct SpriteData {
  46.     /**
  47.      * Transform coefficients for both sprites in 16.16 fixed point format,
  48.      * in the order they appear in the bitstream:
  49.      *  x scale
  50.      *  rotation 1 (unused)
  51.      *  x offset
  52.      *  rotation 2 (unused)
  53.      *  y scale
  54.      *  y offset
  55.      *  alpha
  56.      */
  57.     int coefs[2][7];
  58.  
  59.     int effect_type, effect_flag;
  60.     int effect_pcount1, effect_pcount2;   ///< amount of effect parameters stored in effect_params
  61.     int effect_params1[15], effect_params2[10]; ///< effect parameters in 16.16 fixed point format
  62. } SpriteData;
  63.  
  64. static inline int get_fp_val(GetBitContext* gb)
  65. {
  66.     return (get_bits_long(gb, 30) - (1 << 29)) << 1;
  67. }
  68.  
  69. static void vc1_sprite_parse_transform(GetBitContext* gb, int c[7])
  70. {
  71.     c[1] = c[3] = 0;
  72.  
  73.     switch (get_bits(gb, 2)) {
  74.     case 0:
  75.         c[0] = 1 << 16;
  76.         c[2] = get_fp_val(gb);
  77.         c[4] = 1 << 16;
  78.         break;
  79.     case 1:
  80.         c[0] = c[4] = get_fp_val(gb);
  81.         c[2] = get_fp_val(gb);
  82.         break;
  83.     case 2:
  84.         c[0] = get_fp_val(gb);
  85.         c[2] = get_fp_val(gb);
  86.         c[4] = get_fp_val(gb);
  87.         break;
  88.     case 3:
  89.         c[0] = get_fp_val(gb);
  90.         c[1] = get_fp_val(gb);
  91.         c[2] = get_fp_val(gb);
  92.         c[3] = get_fp_val(gb);
  93.         c[4] = get_fp_val(gb);
  94.         break;
  95.     }
  96.     c[5] = get_fp_val(gb);
  97.     if (get_bits1(gb))
  98.         c[6] = get_fp_val(gb);
  99.     else
  100.         c[6] = 1 << 16;
  101. }
  102.  
  103. static int vc1_parse_sprites(VC1Context *v, GetBitContext* gb, SpriteData* sd)
  104. {
  105.     AVCodecContext *avctx = v->s.avctx;
  106.     int sprite, i;
  107.  
  108.     for (sprite = 0; sprite <= v->two_sprites; sprite++) {
  109.         vc1_sprite_parse_transform(gb, sd->coefs[sprite]);
  110.         if (sd->coefs[sprite][1] || sd->coefs[sprite][3])
  111.             avpriv_request_sample(avctx, "Non-zero rotation coefficients");
  112.         av_log(avctx, AV_LOG_DEBUG, sprite ? "S2:" : "S1:");
  113.         for (i = 0; i < 7; i++)
  114.             av_log(avctx, AV_LOG_DEBUG, " %d.%.3d",
  115.                    sd->coefs[sprite][i] / (1<<16),
  116.                    (abs(sd->coefs[sprite][i]) & 0xFFFF) * 1000 / (1 << 16));
  117.         av_log(avctx, AV_LOG_DEBUG, "\n");
  118.     }
  119.  
  120.     skip_bits(gb, 2);
  121.     if (sd->effect_type = get_bits_long(gb, 30)) {
  122.         switch (sd->effect_pcount1 = get_bits(gb, 4)) {
  123.         case 7:
  124.             vc1_sprite_parse_transform(gb, sd->effect_params1);
  125.             break;
  126.         case 14:
  127.             vc1_sprite_parse_transform(gb, sd->effect_params1);
  128.             vc1_sprite_parse_transform(gb, sd->effect_params1 + 7);
  129.             break;
  130.         default:
  131.             for (i = 0; i < sd->effect_pcount1; i++)
  132.                 sd->effect_params1[i] = get_fp_val(gb);
  133.         }
  134.         if (sd->effect_type != 13 || sd->effect_params1[0] != sd->coefs[0][6]) {
  135.             // effect 13 is simple alpha blending and matches the opacity above
  136.             av_log(avctx, AV_LOG_DEBUG, "Effect: %d; params: ", sd->effect_type);
  137.             for (i = 0; i < sd->effect_pcount1; i++)
  138.                 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
  139.                        sd->effect_params1[i] / (1 << 16),
  140.                        (abs(sd->effect_params1[i]) & 0xFFFF) * 1000 / (1 << 16));
  141.             av_log(avctx, AV_LOG_DEBUG, "\n");
  142.         }
  143.  
  144.         sd->effect_pcount2 = get_bits(gb, 16);
  145.         if (sd->effect_pcount2 > 10) {
  146.             av_log(avctx, AV_LOG_ERROR, "Too many effect parameters\n");
  147.             return AVERROR_INVALIDDATA;
  148.         } else if (sd->effect_pcount2) {
  149.             i = -1;
  150.             av_log(avctx, AV_LOG_DEBUG, "Effect params 2: ");
  151.             while (++i < sd->effect_pcount2) {
  152.                 sd->effect_params2[i] = get_fp_val(gb);
  153.                 av_log(avctx, AV_LOG_DEBUG, " %d.%.2d",
  154.                        sd->effect_params2[i] / (1 << 16),
  155.                        (abs(sd->effect_params2[i]) & 0xFFFF) * 1000 / (1 << 16));
  156.             }
  157.             av_log(avctx, AV_LOG_DEBUG, "\n");
  158.         }
  159.     }
  160.     if (sd->effect_flag = get_bits1(gb))
  161.         av_log(avctx, AV_LOG_DEBUG, "Effect flag set\n");
  162.  
  163.     if (get_bits_count(gb) >= gb->size_in_bits +
  164.        (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE ? 64 : 0)) {
  165.         av_log(avctx, AV_LOG_ERROR, "Buffer overrun\n");
  166.         return AVERROR_INVALIDDATA;
  167.     }
  168.     if (get_bits_count(gb) < gb->size_in_bits - 8)
  169.         av_log(avctx, AV_LOG_WARNING, "Buffer not fully read\n");
  170.  
  171.     return 0;
  172. }
  173.  
  174. static void vc1_draw_sprites(VC1Context *v, SpriteData* sd)
  175. {
  176.     int i, plane, row, sprite;
  177.     int sr_cache[2][2] = { { -1, -1 }, { -1, -1 } };
  178.     uint8_t* src_h[2][2];
  179.     int xoff[2], xadv[2], yoff[2], yadv[2], alpha;
  180.     int ysub[2];
  181.     MpegEncContext *s = &v->s;
  182.  
  183.     for (i = 0; i <= v->two_sprites; i++) {
  184.         xoff[i] = av_clip(sd->coefs[i][2], 0, v->sprite_width-1 << 16);
  185.         xadv[i] = sd->coefs[i][0];
  186.         if (xadv[i] != 1<<16 || (v->sprite_width << 16) - (v->output_width << 16) - xoff[i])
  187.             xadv[i] = av_clip(xadv[i], 0, ((v->sprite_width<<16) - xoff[i] - 1) / v->output_width);
  188.  
  189.         yoff[i] = av_clip(sd->coefs[i][5], 0, v->sprite_height-1 << 16);
  190.         yadv[i] = av_clip(sd->coefs[i][4], 0, ((v->sprite_height << 16) - yoff[i]) / v->output_height);
  191.     }
  192.     alpha = av_clip_uint16(sd->coefs[1][6]);
  193.  
  194.     for (plane = 0; plane < (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY ? 1 : 3); plane++) {
  195.         int width = v->output_width>>!!plane;
  196.  
  197.         for (row = 0; row < v->output_height>>!!plane; row++) {
  198.             uint8_t *dst = v->sprite_output_frame->data[plane] +
  199.                            v->sprite_output_frame->linesize[plane] * row;
  200.  
  201.             for (sprite = 0; sprite <= v->two_sprites; sprite++) {
  202.                 uint8_t *iplane = s->current_picture.f->data[plane];
  203.                 int      iline  = s->current_picture.f->linesize[plane];
  204.                 int      ycoord = yoff[sprite] + yadv[sprite] * row;
  205.                 int      yline  = ycoord >> 16;
  206.                 int      next_line;
  207.                 ysub[sprite] = ycoord & 0xFFFF;
  208.                 if (sprite) {
  209.                     iplane = s->last_picture.f->data[plane];
  210.                     iline  = s->last_picture.f->linesize[plane];
  211.                 }
  212.                 next_line = FFMIN(yline + 1, (v->sprite_height >> !!plane) - 1) * iline;
  213.                 if (!(xoff[sprite] & 0xFFFF) && xadv[sprite] == 1 << 16) {
  214.                         src_h[sprite][0] = iplane + (xoff[sprite] >> 16) +  yline      * iline;
  215.                     if (ysub[sprite])
  216.                         src_h[sprite][1] = iplane + (xoff[sprite] >> 16) + next_line;
  217.                 } else {
  218.                     if (sr_cache[sprite][0] != yline) {
  219.                         if (sr_cache[sprite][1] == yline) {
  220.                             FFSWAP(uint8_t*, v->sr_rows[sprite][0], v->sr_rows[sprite][1]);
  221.                             FFSWAP(int,        sr_cache[sprite][0],   sr_cache[sprite][1]);
  222.                         } else {
  223.                             v->vc1dsp.sprite_h(v->sr_rows[sprite][0], iplane + yline * iline, xoff[sprite], xadv[sprite], width);
  224.                             sr_cache[sprite][0] = yline;
  225.                         }
  226.                     }
  227.                     if (ysub[sprite] && sr_cache[sprite][1] != yline + 1) {
  228.                         v->vc1dsp.sprite_h(v->sr_rows[sprite][1],
  229.                                            iplane + next_line, xoff[sprite],
  230.                                            xadv[sprite], width);
  231.                         sr_cache[sprite][1] = yline + 1;
  232.                     }
  233.                     src_h[sprite][0] = v->sr_rows[sprite][0];
  234.                     src_h[sprite][1] = v->sr_rows[sprite][1];
  235.                 }
  236.             }
  237.  
  238.             if (!v->two_sprites) {
  239.                 if (ysub[0]) {
  240.                     v->vc1dsp.sprite_v_single(dst, src_h[0][0], src_h[0][1], ysub[0], width);
  241.                 } else {
  242.                     memcpy(dst, src_h[0][0], width);
  243.                 }
  244.             } else {
  245.                 if (ysub[0] && ysub[1]) {
  246.                     v->vc1dsp.sprite_v_double_twoscale(dst, src_h[0][0], src_h[0][1], ysub[0],
  247.                                                        src_h[1][0], src_h[1][1], ysub[1], alpha, width);
  248.                 } else if (ysub[0]) {
  249.                     v->vc1dsp.sprite_v_double_onescale(dst, src_h[0][0], src_h[0][1], ysub[0],
  250.                                                        src_h[1][0], alpha, width);
  251.                 } else if (ysub[1]) {
  252.                     v->vc1dsp.sprite_v_double_onescale(dst, src_h[1][0], src_h[1][1], ysub[1],
  253.                                                        src_h[0][0], (1<<16)-1-alpha, width);
  254.                 } else {
  255.                     v->vc1dsp.sprite_v_double_noscale(dst, src_h[0][0], src_h[1][0], alpha, width);
  256.                 }
  257.             }
  258.         }
  259.  
  260.         if (!plane) {
  261.             for (i = 0; i <= v->two_sprites; i++) {
  262.                 xoff[i] >>= 1;
  263.                 yoff[i] >>= 1;
  264.             }
  265.         }
  266.  
  267.     }
  268. }
  269.  
  270.  
  271. static int vc1_decode_sprites(VC1Context *v, GetBitContext* gb)
  272. {
  273.     int ret;
  274.     MpegEncContext *s     = &v->s;
  275.     AVCodecContext *avctx = s->avctx;
  276.     SpriteData sd;
  277.  
  278.     memset(&sd, 0, sizeof(sd));
  279.  
  280.     ret = vc1_parse_sprites(v, gb, &sd);
  281.     if (ret < 0)
  282.         return ret;
  283.  
  284.     if (!s->current_picture.f || !s->current_picture.f->data[0]) {
  285.         av_log(avctx, AV_LOG_ERROR, "Got no sprites\n");
  286.         return AVERROR_UNKNOWN;
  287.     }
  288.  
  289.     if (v->two_sprites && (!s->last_picture_ptr || !s->last_picture.f->data[0])) {
  290.         av_log(avctx, AV_LOG_WARNING, "Need two sprites, only got one\n");
  291.         v->two_sprites = 0;
  292.     }
  293.  
  294.     av_frame_unref(v->sprite_output_frame);
  295.     if ((ret = ff_get_buffer(avctx, v->sprite_output_frame, 0)) < 0)
  296.         return ret;
  297.  
  298.     vc1_draw_sprites(v, &sd);
  299.  
  300.     return 0;
  301. }
  302.  
  303. static void vc1_sprite_flush(AVCodecContext *avctx)
  304. {
  305.     VC1Context *v     = avctx->priv_data;
  306.     MpegEncContext *s = &v->s;
  307.     AVFrame *f = s->current_picture.f;
  308.     int plane, i;
  309.  
  310.     /* Windows Media Image codecs have a convergence interval of two keyframes.
  311.        Since we can't enforce it, clear to black the missing sprite. This is
  312.        wrong but it looks better than doing nothing. */
  313.  
  314.     if (f && f->data[0])
  315.         for (plane = 0; plane < (CONFIG_GRAY && s->avctx->flags & AV_CODEC_FLAG_GRAY ? 1 : 3); plane++)
  316.             for (i = 0; i < v->sprite_height>>!!plane; i++)
  317.                 memset(f->data[plane] + i * f->linesize[plane],
  318.                        plane ? 128 : 0, f->linesize[plane]);
  319. }
  320.  
  321. #endif
  322.  
  323. av_cold int ff_vc1_decode_init_alloc_tables(VC1Context *v)
  324. {
  325.     MpegEncContext *s = &v->s;
  326.     int i;
  327.     int mb_height = FFALIGN(s->mb_height, 2);
  328.  
  329.     /* Allocate mb bitplanes */
  330.     v->mv_type_mb_plane = av_malloc (s->mb_stride * mb_height);
  331.     v->direct_mb_plane  = av_malloc (s->mb_stride * mb_height);
  332.     v->forward_mb_plane = av_malloc (s->mb_stride * mb_height);
  333.     v->fieldtx_plane    = av_mallocz(s->mb_stride * mb_height);
  334.     v->acpred_plane     = av_malloc (s->mb_stride * mb_height);
  335.     v->over_flags_plane = av_malloc (s->mb_stride * mb_height);
  336.  
  337.     v->n_allocated_blks = s->mb_width + 2;
  338.     v->block            = av_malloc(sizeof(*v->block) * v->n_allocated_blks);
  339.     v->cbp_base         = av_malloc(sizeof(v->cbp_base[0]) * 2 * s->mb_stride);
  340.     v->cbp              = v->cbp_base + s->mb_stride;
  341.     v->ttblk_base       = av_malloc(sizeof(v->ttblk_base[0]) * 2 * s->mb_stride);
  342.     v->ttblk            = v->ttblk_base + s->mb_stride;
  343.     v->is_intra_base    = av_mallocz(sizeof(v->is_intra_base[0]) * 2 * s->mb_stride);
  344.     v->is_intra         = v->is_intra_base + s->mb_stride;
  345.     v->luma_mv_base     = av_mallocz(sizeof(v->luma_mv_base[0]) * 2 * s->mb_stride);
  346.     v->luma_mv          = v->luma_mv_base + s->mb_stride;
  347.  
  348.     /* allocate block type info in that way so it could be used with s->block_index[] */
  349.     v->mb_type_base = av_malloc(s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
  350.     v->mb_type[0]   = v->mb_type_base + s->b8_stride + 1;
  351.     v->mb_type[1]   = v->mb_type_base + s->b8_stride * (mb_height * 2 + 1) + s->mb_stride + 1;
  352.     v->mb_type[2]   = v->mb_type[1] + s->mb_stride * (mb_height + 1);
  353.  
  354.     /* allocate memory to store block level MV info */
  355.     v->blk_mv_type_base = av_mallocz(     s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
  356.     v->blk_mv_type      = v->blk_mv_type_base + s->b8_stride + 1;
  357.     v->mv_f_base        = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
  358.     v->mv_f[0]          = v->mv_f_base + s->b8_stride + 1;
  359.     v->mv_f[1]          = v->mv_f[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
  360.     v->mv_f_next_base   = av_mallocz(2 * (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2));
  361.     v->mv_f_next[0]     = v->mv_f_next_base + s->b8_stride + 1;
  362.     v->mv_f_next[1]     = v->mv_f_next[0] + (s->b8_stride * (mb_height * 2 + 1) + s->mb_stride * (mb_height + 1) * 2);
  363.  
  364.     /* Init coded blocks info */
  365.     if (v->profile == PROFILE_ADVANCED) {
  366. //        if (alloc_bitplane(&v->over_flags_plane, s->mb_width, s->mb_height) < 0)
  367. //            return -1;
  368. //        if (alloc_bitplane(&v->ac_pred_plane, s->mb_width, s->mb_height) < 0)
  369. //            return -1;
  370.     }
  371.  
  372.     ff_intrax8_common_init(&v->x8,s);
  373.  
  374.     if (s->avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || s->avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
  375.         for (i = 0; i < 4; i++)
  376.             if (!(v->sr_rows[i >> 1][i & 1] = av_malloc(v->output_width)))
  377.                 return AVERROR(ENOMEM);
  378.     }
  379.  
  380.     if (!v->mv_type_mb_plane || !v->direct_mb_plane || !v->acpred_plane || !v->over_flags_plane ||
  381.         !v->block || !v->cbp_base || !v->ttblk_base || !v->is_intra_base || !v->luma_mv_base ||
  382.         !v->mb_type_base) {
  383.         av_freep(&v->mv_type_mb_plane);
  384.         av_freep(&v->direct_mb_plane);
  385.         av_freep(&v->acpred_plane);
  386.         av_freep(&v->over_flags_plane);
  387.         av_freep(&v->block);
  388.         av_freep(&v->cbp_base);
  389.         av_freep(&v->ttblk_base);
  390.         av_freep(&v->is_intra_base);
  391.         av_freep(&v->luma_mv_base);
  392.         av_freep(&v->mb_type_base);
  393.         return AVERROR(ENOMEM);
  394.     }
  395.  
  396.     return 0;
  397. }
  398.  
  399. av_cold void ff_vc1_init_transposed_scantables(VC1Context *v)
  400. {
  401.     int i;
  402.     for (i = 0; i < 64; i++) {
  403. #define transpose(x) (((x) >> 3) | (((x) & 7) << 3))
  404.         v->zz_8x8[0][i] = transpose(ff_wmv1_scantable[0][i]);
  405.         v->zz_8x8[1][i] = transpose(ff_wmv1_scantable[1][i]);
  406.         v->zz_8x8[2][i] = transpose(ff_wmv1_scantable[2][i]);
  407.         v->zz_8x8[3][i] = transpose(ff_wmv1_scantable[3][i]);
  408.         v->zzi_8x8[i]   = transpose(ff_vc1_adv_interlaced_8x8_zz[i]);
  409.     }
  410.     v->left_blk_sh = 0;
  411.     v->top_blk_sh  = 3;
  412. }
  413.  
  414. /** Initialize a VC1/WMV3 decoder
  415.  * @todo TODO: Handle VC-1 IDUs (Transport level?)
  416.  * @todo TODO: Decypher remaining bits in extra_data
  417.  */
  418. static av_cold int vc1_decode_init(AVCodecContext *avctx)
  419. {
  420.     VC1Context *v = avctx->priv_data;
  421.     MpegEncContext *s = &v->s;
  422.     GetBitContext gb;
  423.     int ret;
  424.  
  425.     /* save the container output size for WMImage */
  426.     v->output_width  = avctx->width;
  427.     v->output_height = avctx->height;
  428.  
  429.     if (!avctx->extradata_size || !avctx->extradata)
  430.         return -1;
  431.     v->s.avctx = avctx;
  432.  
  433.     if ((ret = ff_vc1_init_common(v)) < 0)
  434.         return ret;
  435.  
  436.     if (avctx->codec_id == AV_CODEC_ID_WMV3 || avctx->codec_id == AV_CODEC_ID_WMV3IMAGE) {
  437.         int count = 0;
  438.  
  439.         // looks like WMV3 has a sequence header stored in the extradata
  440.         // advanced sequence header may be before the first frame
  441.         // the last byte of the extradata is a version number, 1 for the
  442.         // samples we can decode
  443.  
  444.         init_get_bits(&gb, avctx->extradata, avctx->extradata_size*8);
  445.  
  446.         if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0)
  447.           return ret;
  448.  
  449.         count = avctx->extradata_size*8 - get_bits_count(&gb);
  450.         if (count > 0) {
  451.             av_log(avctx, AV_LOG_INFO, "Extra data: %i bits left, value: %X\n",
  452.                    count, get_bits_long(&gb, FFMIN(count, 32)));
  453.         } else if (count < 0) {
  454.             av_log(avctx, AV_LOG_INFO, "Read %i bits in overflow\n", -count);
  455.         }
  456.     } else { // VC1/WVC1/WVP2
  457.         const uint8_t *start = avctx->extradata;
  458.         uint8_t *end = avctx->extradata + avctx->extradata_size;
  459.         const uint8_t *next;
  460.         int size, buf2_size;
  461.         uint8_t *buf2 = NULL;
  462.         int seq_initialized = 0, ep_initialized = 0;
  463.  
  464.         if (avctx->extradata_size < 16) {
  465.             av_log(avctx, AV_LOG_ERROR, "Extradata size too small: %i\n", avctx->extradata_size);
  466.             return -1;
  467.         }
  468.  
  469.         buf2  = av_mallocz(avctx->extradata_size + AV_INPUT_BUFFER_PADDING_SIZE);
  470.         if (!buf2)
  471.             return AVERROR(ENOMEM);
  472.  
  473.         start = find_next_marker(start, end); // in WVC1 extradata first byte is its size, but can be 0 in mkv
  474.         next  = start;
  475.         for (; next < end; start = next) {
  476.             next = find_next_marker(start + 4, end);
  477.             size = next - start - 4;
  478.             if (size <= 0)
  479.                 continue;
  480.             buf2_size = vc1_unescape_buffer(start + 4, size, buf2);
  481.             init_get_bits(&gb, buf2, buf2_size * 8);
  482.             switch (AV_RB32(start)) {
  483.             case VC1_CODE_SEQHDR:
  484.                 if ((ret = ff_vc1_decode_sequence_header(avctx, v, &gb)) < 0) {
  485.                     av_free(buf2);
  486.                     return ret;
  487.                 }
  488.                 seq_initialized = 1;
  489.                 break;
  490.             case VC1_CODE_ENTRYPOINT:
  491.                 if ((ret = ff_vc1_decode_entry_point(avctx, v, &gb)) < 0) {
  492.                     av_free(buf2);
  493.                     return ret;
  494.                 }
  495.                 ep_initialized = 1;
  496.                 break;
  497.             }
  498.         }
  499.         av_free(buf2);
  500.         if (!seq_initialized || !ep_initialized) {
  501.             av_log(avctx, AV_LOG_ERROR, "Incomplete extradata\n");
  502.             return -1;
  503.         }
  504.         v->res_sprite = (avctx->codec_id == AV_CODEC_ID_VC1IMAGE);
  505.     }
  506.  
  507.     avctx->profile = v->profile;
  508.     if (v->profile == PROFILE_ADVANCED)
  509.         avctx->level = v->level;
  510.  
  511.     if (!CONFIG_GRAY || !(avctx->flags & AV_CODEC_FLAG_GRAY))
  512.         avctx->pix_fmt = ff_get_format(avctx, avctx->codec->pix_fmts);
  513.     else {
  514.         avctx->pix_fmt = AV_PIX_FMT_GRAY8;
  515.         if (avctx->color_range == AVCOL_RANGE_UNSPECIFIED)
  516.             avctx->color_range = AVCOL_RANGE_MPEG;
  517.     }
  518.  
  519.     // ensure static VLC tables are initialized
  520.     if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
  521.         return ret;
  522.     if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0)
  523.         return ret;
  524.     // Hack to ensure the above functions will be called
  525.     // again once we know all necessary settings.
  526.     // That this is necessary might indicate a bug.
  527.     ff_vc1_decode_end(avctx);
  528.  
  529.     ff_blockdsp_init(&s->bdsp, avctx);
  530.     ff_h264chroma_init(&v->h264chroma, 8);
  531.     ff_qpeldsp_init(&s->qdsp);
  532.  
  533.     // Must happen after calling ff_vc1_decode_end
  534.     // to avoid de-allocating the sprite_output_frame
  535.     v->sprite_output_frame = av_frame_alloc();
  536.     if (!v->sprite_output_frame)
  537.         return AVERROR(ENOMEM);
  538.  
  539.     avctx->has_b_frames = !!avctx->max_b_frames;
  540.  
  541.     if (v->color_prim == 1 || v->color_prim == 5 || v->color_prim == 6)
  542.         avctx->color_primaries = v->color_prim;
  543.     if (v->transfer_char == 1 || v->transfer_char == 7)
  544.         avctx->color_trc = v->transfer_char;
  545.     if (v->matrix_coef == 1 || v->matrix_coef == 6 || v->matrix_coef == 7)
  546.         avctx->colorspace = v->matrix_coef;
  547.  
  548.     s->mb_width  = (avctx->coded_width  + 15) >> 4;
  549.     s->mb_height = (avctx->coded_height + 15) >> 4;
  550.  
  551.     if (v->profile == PROFILE_ADVANCED || v->res_fasttx) {
  552.         ff_vc1_init_transposed_scantables(v);
  553.     } else {
  554.         memcpy(v->zz_8x8, ff_wmv1_scantable, 4*64);
  555.         v->left_blk_sh = 3;
  556.         v->top_blk_sh  = 0;
  557.     }
  558.  
  559.     if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
  560.         v->sprite_width  = avctx->coded_width;
  561.         v->sprite_height = avctx->coded_height;
  562.  
  563.         avctx->coded_width  = avctx->width  = v->output_width;
  564.         avctx->coded_height = avctx->height = v->output_height;
  565.  
  566.         // prevent 16.16 overflows
  567.         if (v->sprite_width  > 1 << 14 ||
  568.             v->sprite_height > 1 << 14 ||
  569.             v->output_width  > 1 << 14 ||
  570.             v->output_height > 1 << 14) return -1;
  571.  
  572.         if ((v->sprite_width&1) || (v->sprite_height&1)) {
  573.             avpriv_request_sample(avctx, "odd sprites support");
  574.             return AVERROR_PATCHWELCOME;
  575.         }
  576.     }
  577.     return 0;
  578. }
  579.  
  580. /** Close a VC1/WMV3 decoder
  581.  * @warning Initial try at using MpegEncContext stuff
  582.  */
  583. av_cold int ff_vc1_decode_end(AVCodecContext *avctx)
  584. {
  585.     VC1Context *v = avctx->priv_data;
  586.     int i;
  587.  
  588.     av_frame_free(&v->sprite_output_frame);
  589.  
  590.     for (i = 0; i < 4; i++)
  591.         av_freep(&v->sr_rows[i >> 1][i & 1]);
  592.     av_freep(&v->hrd_rate);
  593.     av_freep(&v->hrd_buffer);
  594.     ff_mpv_common_end(&v->s);
  595.     av_freep(&v->mv_type_mb_plane);
  596.     av_freep(&v->direct_mb_plane);
  597.     av_freep(&v->forward_mb_plane);
  598.     av_freep(&v->fieldtx_plane);
  599.     av_freep(&v->acpred_plane);
  600.     av_freep(&v->over_flags_plane);
  601.     av_freep(&v->mb_type_base);
  602.     av_freep(&v->blk_mv_type_base);
  603.     av_freep(&v->mv_f_base);
  604.     av_freep(&v->mv_f_next_base);
  605.     av_freep(&v->block);
  606.     av_freep(&v->cbp_base);
  607.     av_freep(&v->ttblk_base);
  608.     av_freep(&v->is_intra_base); // FIXME use v->mb_type[]
  609.     av_freep(&v->luma_mv_base);
  610.     ff_intrax8_common_end(&v->x8);
  611.     return 0;
  612. }
  613.  
  614.  
  615. /** Decode a VC1/WMV3 frame
  616.  * @todo TODO: Handle VC-1 IDUs (Transport level?)
  617.  */
  618. static int vc1_decode_frame(AVCodecContext *avctx, void *data,
  619.                             int *got_frame, AVPacket *avpkt)
  620. {
  621.     const uint8_t *buf = avpkt->data;
  622.     int buf_size = avpkt->size, n_slices = 0, i, ret;
  623.     VC1Context *v = avctx->priv_data;
  624.     MpegEncContext *s = &v->s;
  625.     AVFrame *pict = data;
  626.     uint8_t *buf2 = NULL;
  627.     const uint8_t *buf_start = buf, *buf_start_second_field = NULL;
  628.     int mb_height, n_slices1=-1;
  629.     struct {
  630.         uint8_t *buf;
  631.         GetBitContext gb;
  632.         int mby_start;
  633.     } *slices = NULL, *tmp;
  634.  
  635.     v->second_field = 0;
  636.  
  637.     if(s->avctx->flags & AV_CODEC_FLAG_LOW_DELAY)
  638.         s->low_delay = 1;
  639.  
  640.     /* no supplementary picture */
  641.     if (buf_size == 0 || (buf_size == 4 && AV_RB32(buf) == VC1_CODE_ENDOFSEQ)) {
  642.         /* special case for last picture */
  643.         if (s->low_delay == 0 && s->next_picture_ptr) {
  644.             if ((ret = av_frame_ref(pict, s->next_picture_ptr->f)) < 0)
  645.                 return ret;
  646.             s->next_picture_ptr = NULL;
  647.  
  648.             *got_frame = 1;
  649.         }
  650.  
  651.         return buf_size;
  652.     }
  653.  
  654. #if FF_API_CAP_VDPAU
  655.     if (s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU) {
  656.         if (v->profile < PROFILE_ADVANCED)
  657.             avctx->pix_fmt = AV_PIX_FMT_VDPAU_WMV3;
  658.         else
  659.             avctx->pix_fmt = AV_PIX_FMT_VDPAU_VC1;
  660.     }
  661. #endif
  662.  
  663.     //for advanced profile we may need to parse and unescape data
  664.     if (avctx->codec_id == AV_CODEC_ID_VC1 || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
  665.         int buf_size2 = 0;
  666.         buf2 = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
  667.         if (!buf2)
  668.             return AVERROR(ENOMEM);
  669.  
  670.         if (IS_MARKER(AV_RB32(buf))) { /* frame starts with marker and needs to be parsed */
  671.             const uint8_t *start, *end, *next;
  672.             int size;
  673.  
  674.             next = buf;
  675.             for (start = buf, end = buf + buf_size; next < end; start = next) {
  676.                 next = find_next_marker(start + 4, end);
  677.                 size = next - start - 4;
  678.                 if (size <= 0) continue;
  679.                 switch (AV_RB32(start)) {
  680.                 case VC1_CODE_FRAME:
  681.                     if (avctx->hwaccel
  682. #if FF_API_CAP_VDPAU
  683.                         || s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU
  684. #endif
  685.                         )
  686.                         buf_start = start;
  687.                     buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
  688.                     break;
  689.                 case VC1_CODE_FIELD: {
  690.                     int buf_size3;
  691.                     if (avctx->hwaccel
  692. #if FF_API_CAP_VDPAU
  693.                         || s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU
  694. #endif
  695.                         )
  696.                         buf_start_second_field = start;
  697.                     tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
  698.                     if (!tmp) {
  699.                         ret = AVERROR(ENOMEM);
  700.                         goto err;
  701.                     }
  702.                     slices = tmp;
  703.                     slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
  704.                     if (!slices[n_slices].buf) {
  705.                         ret = AVERROR(ENOMEM);
  706.                         goto err;
  707.                     }
  708.                     buf_size3 = vc1_unescape_buffer(start + 4, size,
  709.                                                     slices[n_slices].buf);
  710.                     init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
  711.                                   buf_size3 << 3);
  712.                     /* assuming that the field marker is at the exact middle,
  713.                        hope it's correct */
  714.                     slices[n_slices].mby_start = s->mb_height + 1 >> 1;
  715.                     n_slices1 = n_slices - 1; // index of the last slice of the first field
  716.                     n_slices++;
  717.                     break;
  718.                 }
  719.                 case VC1_CODE_ENTRYPOINT: /* it should be before frame data */
  720.                     buf_size2 = vc1_unescape_buffer(start + 4, size, buf2);
  721.                     init_get_bits(&s->gb, buf2, buf_size2 * 8);
  722.                     ff_vc1_decode_entry_point(avctx, v, &s->gb);
  723.                     break;
  724.                 case VC1_CODE_SLICE: {
  725.                     int buf_size3;
  726.                     tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
  727.                     if (!tmp) {
  728.                         ret = AVERROR(ENOMEM);
  729.                         goto err;
  730.                     }
  731.                     slices = tmp;
  732.                     slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
  733.                     if (!slices[n_slices].buf) {
  734.                         ret = AVERROR(ENOMEM);
  735.                         goto err;
  736.                     }
  737.                     buf_size3 = vc1_unescape_buffer(start + 4, size,
  738.                                                     slices[n_slices].buf);
  739.                     init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
  740.                                   buf_size3 << 3);
  741.                     slices[n_slices].mby_start = get_bits(&slices[n_slices].gb, 9);
  742.                     n_slices++;
  743.                     break;
  744.                 }
  745.                 }
  746.             }
  747.         } else if (v->interlace && ((buf[0] & 0xC0) == 0xC0)) { /* WVC1 interlaced stores both fields divided by marker */
  748.             const uint8_t *divider;
  749.             int buf_size3;
  750.  
  751.             divider = find_next_marker(buf, buf + buf_size);
  752.             if ((divider == (buf + buf_size)) || AV_RB32(divider) != VC1_CODE_FIELD) {
  753.                 av_log(avctx, AV_LOG_ERROR, "Error in WVC1 interlaced frame\n");
  754.                 ret = AVERROR_INVALIDDATA;
  755.                 goto err;
  756.             } else { // found field marker, unescape second field
  757.                 if (avctx->hwaccel
  758. #if FF_API_CAP_VDPAU
  759.                     || s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU
  760. #endif
  761.                     )
  762.                     buf_start_second_field = divider;
  763.                 tmp = av_realloc_array(slices, sizeof(*slices), (n_slices+1));
  764.                 if (!tmp) {
  765.                     ret = AVERROR(ENOMEM);
  766.                     goto err;
  767.                 }
  768.                 slices = tmp;
  769.                 slices[n_slices].buf = av_mallocz(buf_size + AV_INPUT_BUFFER_PADDING_SIZE);
  770.                 if (!slices[n_slices].buf) {
  771.                     ret = AVERROR(ENOMEM);
  772.                     goto err;
  773.                 }
  774.                 buf_size3 = vc1_unescape_buffer(divider + 4, buf + buf_size - divider - 4, slices[n_slices].buf);
  775.                 init_get_bits(&slices[n_slices].gb, slices[n_slices].buf,
  776.                               buf_size3 << 3);
  777.                 slices[n_slices].mby_start = s->mb_height + 1 >> 1;
  778.                 n_slices1 = n_slices - 1;
  779.                 n_slices++;
  780.             }
  781.             buf_size2 = vc1_unescape_buffer(buf, divider - buf, buf2);
  782.         } else {
  783.             buf_size2 = vc1_unescape_buffer(buf, buf_size, buf2);
  784.         }
  785.         init_get_bits(&s->gb, buf2, buf_size2*8);
  786.     } else
  787.         init_get_bits(&s->gb, buf, buf_size*8);
  788.  
  789.     if (v->res_sprite) {
  790.         v->new_sprite  = !get_bits1(&s->gb);
  791.         v->two_sprites =  get_bits1(&s->gb);
  792.         /* res_sprite means a Windows Media Image stream, AV_CODEC_ID_*IMAGE means
  793.            we're using the sprite compositor. These are intentionally kept separate
  794.            so you can get the raw sprites by using the wmv3 decoder for WMVP or
  795.            the vc1 one for WVP2 */
  796.         if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
  797.             if (v->new_sprite) {
  798.                 // switch AVCodecContext parameters to those of the sprites
  799.                 avctx->width  = avctx->coded_width  = v->sprite_width;
  800.                 avctx->height = avctx->coded_height = v->sprite_height;
  801.             } else {
  802.                 goto image;
  803.             }
  804.         }
  805.     }
  806.  
  807.     if (s->context_initialized &&
  808.         (s->width  != avctx->coded_width ||
  809.          s->height != avctx->coded_height)) {
  810.         ff_vc1_decode_end(avctx);
  811.     }
  812.  
  813.     if (!s->context_initialized) {
  814.         if ((ret = ff_msmpeg4_decode_init(avctx)) < 0)
  815.             goto err;
  816.         if ((ret = ff_vc1_decode_init_alloc_tables(v)) < 0) {
  817.             ff_mpv_common_end(s);
  818.             goto err;
  819.         }
  820.  
  821.         s->low_delay = !avctx->has_b_frames || v->res_sprite;
  822.  
  823.         if (v->profile == PROFILE_ADVANCED) {
  824.             if(avctx->coded_width<=1 || avctx->coded_height<=1) {
  825.                 ret = AVERROR_INVALIDDATA;
  826.                 goto err;
  827.             }
  828.             s->h_edge_pos = avctx->coded_width;
  829.             s->v_edge_pos = avctx->coded_height;
  830.         }
  831.     }
  832.  
  833.     // do parse frame header
  834.     v->pic_header_flag = 0;
  835.     v->first_pic_header_flag = 1;
  836.     if (v->profile < PROFILE_ADVANCED) {
  837.         if ((ret = ff_vc1_parse_frame_header(v, &s->gb)) < 0) {
  838.             goto err;
  839.         }
  840.     } else {
  841.         if ((ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
  842.             goto err;
  843.         }
  844.     }
  845.     v->first_pic_header_flag = 0;
  846.  
  847.     if (avctx->debug & FF_DEBUG_PICT_INFO)
  848.         av_log(v->s.avctx, AV_LOG_DEBUG, "pict_type: %c\n", av_get_picture_type_char(s->pict_type));
  849.  
  850.     if ((avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE)
  851.         && s->pict_type != AV_PICTURE_TYPE_I) {
  852.         av_log(v->s.avctx, AV_LOG_ERROR, "Sprite decoder: expected I-frame\n");
  853.         ret = AVERROR_INVALIDDATA;
  854.         goto err;
  855.     }
  856.  
  857.     if ((s->mb_height >> v->field_mode) == 0) {
  858.         av_log(v->s.avctx, AV_LOG_ERROR, "image too short\n");
  859.         ret = AVERROR_INVALIDDATA;
  860.         goto err;
  861.     }
  862.  
  863.     // for skipping the frame
  864.     s->current_picture.f->pict_type = s->pict_type;
  865.     s->current_picture.f->key_frame = s->pict_type == AV_PICTURE_TYPE_I;
  866.  
  867.     /* skip B-frames if we don't have reference frames */
  868.     if (!s->last_picture_ptr && (s->pict_type == AV_PICTURE_TYPE_B || s->droppable)) {
  869.         av_log(v->s.avctx, AV_LOG_DEBUG, "Skipping B frame without reference frames\n");
  870.         goto end;
  871.     }
  872.     if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
  873.         (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
  874.          avctx->skip_frame >= AVDISCARD_ALL) {
  875.         goto end;
  876.     }
  877.  
  878.     if (s->next_p_frame_damaged) {
  879.         if (s->pict_type == AV_PICTURE_TYPE_B)
  880.             goto end;
  881.         else
  882.             s->next_p_frame_damaged = 0;
  883.     }
  884.  
  885.     if ((ret = ff_mpv_frame_start(s, avctx)) < 0) {
  886.         goto err;
  887.     }
  888.  
  889.     v->s.current_picture_ptr->field_picture = v->field_mode;
  890.     v->s.current_picture_ptr->f->interlaced_frame = (v->fcm != PROGRESSIVE);
  891.     v->s.current_picture_ptr->f->top_field_first  = v->tff;
  892.  
  893.     // process pulldown flags
  894.     s->current_picture_ptr->f->repeat_pict = 0;
  895.     // Pulldown flags are only valid when 'broadcast' has been set.
  896.     // So ticks_per_frame will be 2
  897.     if (v->rff) {
  898.         // repeat field
  899.         s->current_picture_ptr->f->repeat_pict = 1;
  900.     } else if (v->rptfrm) {
  901.         // repeat frames
  902.         s->current_picture_ptr->f->repeat_pict = v->rptfrm * 2;
  903.     }
  904.  
  905.     s->me.qpel_put = s->qdsp.put_qpel_pixels_tab;
  906.     s->me.qpel_avg = s->qdsp.avg_qpel_pixels_tab;
  907.  
  908. #if FF_API_CAP_VDPAU
  909.     if ((CONFIG_VC1_VDPAU_DECODER)
  910.         &&s->avctx->codec->capabilities&AV_CODEC_CAP_HWACCEL_VDPAU) {
  911.         if (v->field_mode && buf_start_second_field) {
  912.             ff_vdpau_vc1_decode_picture(s, buf_start, buf_start_second_field - buf_start);
  913.             ff_vdpau_vc1_decode_picture(s, buf_start_second_field, (buf + buf_size) - buf_start_second_field);
  914.         } else {
  915.             ff_vdpau_vc1_decode_picture(s, buf_start, (buf + buf_size) - buf_start);
  916.         }
  917.     } else
  918. #endif
  919.     if (avctx->hwaccel) {
  920.         if (v->field_mode && buf_start_second_field) {
  921.             // decode first field
  922.             s->picture_structure = PICT_BOTTOM_FIELD - v->tff;
  923.             if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
  924.                 goto err;
  925.             if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, buf_start_second_field - buf_start)) < 0)
  926.                 goto err;
  927.             if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
  928.                 goto err;
  929.  
  930.             // decode second field
  931.             s->gb = slices[n_slices1 + 1].gb;
  932.             s->picture_structure = PICT_TOP_FIELD + v->tff;
  933.             v->second_field = 1;
  934.             v->pic_header_flag = 0;
  935.             if (ff_vc1_parse_frame_header_adv(v, &s->gb) < 0) {
  936.                 av_log(avctx, AV_LOG_ERROR, "parsing header for second field failed");
  937.                 ret = AVERROR_INVALIDDATA;
  938.                 goto err;
  939.             }
  940.             v->s.current_picture_ptr->f->pict_type = v->s.pict_type;
  941.  
  942.             if ((ret = avctx->hwaccel->start_frame(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
  943.                 goto err;
  944.             if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start_second_field, (buf + buf_size) - buf_start_second_field)) < 0)
  945.                 goto err;
  946.             if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
  947.                 goto err;
  948.         } else {
  949.             s->picture_structure = PICT_FRAME;
  950.             if ((ret = avctx->hwaccel->start_frame(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
  951.                 goto err;
  952.             if ((ret = avctx->hwaccel->decode_slice(avctx, buf_start, (buf + buf_size) - buf_start)) < 0)
  953.                 goto err;
  954.             if ((ret = avctx->hwaccel->end_frame(avctx)) < 0)
  955.                 goto err;
  956.         }
  957.     } else {
  958.         int header_ret = 0;
  959.  
  960.         ff_mpeg_er_frame_start(s);
  961.  
  962.         v->bits = buf_size * 8;
  963.         v->end_mb_x = s->mb_width;
  964.         if (v->field_mode) {
  965.             s->current_picture.f->linesize[0] <<= 1;
  966.             s->current_picture.f->linesize[1] <<= 1;
  967.             s->current_picture.f->linesize[2] <<= 1;
  968.             s->linesize                      <<= 1;
  969.             s->uvlinesize                    <<= 1;
  970.         }
  971.         mb_height = s->mb_height >> v->field_mode;
  972.  
  973.         av_assert0 (mb_height > 0);
  974.  
  975.         for (i = 0; i <= n_slices; i++) {
  976.             if (i > 0 &&  slices[i - 1].mby_start >= mb_height) {
  977.                 if (v->field_mode <= 0) {
  978.                     av_log(v->s.avctx, AV_LOG_ERROR, "Slice %d starts beyond "
  979.                            "picture boundary (%d >= %d)\n", i,
  980.                            slices[i - 1].mby_start, mb_height);
  981.                     continue;
  982.                 }
  983.                 v->second_field = 1;
  984.                 av_assert0((s->mb_height & 1) == 0);
  985.                 v->blocks_off   = s->b8_stride * (s->mb_height&~1);
  986.                 v->mb_off       = s->mb_stride * s->mb_height >> 1;
  987.             } else {
  988.                 v->second_field = 0;
  989.                 v->blocks_off   = 0;
  990.                 v->mb_off       = 0;
  991.             }
  992.             if (i) {
  993.                 v->pic_header_flag = 0;
  994.                 if (v->field_mode && i == n_slices1 + 2) {
  995.                     if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
  996.                         av_log(v->s.avctx, AV_LOG_ERROR, "Field header damaged\n");
  997.                         ret = AVERROR_INVALIDDATA;
  998.                         if (avctx->err_recognition & AV_EF_EXPLODE)
  999.                             goto err;
  1000.                         continue;
  1001.                     }
  1002.                 } else if (get_bits1(&s->gb)) {
  1003.                     v->pic_header_flag = 1;
  1004.                     if ((header_ret = ff_vc1_parse_frame_header_adv(v, &s->gb)) < 0) {
  1005.                         av_log(v->s.avctx, AV_LOG_ERROR, "Slice header damaged\n");
  1006.                         ret = AVERROR_INVALIDDATA;
  1007.                         if (avctx->err_recognition & AV_EF_EXPLODE)
  1008.                             goto err;
  1009.                         continue;
  1010.                     }
  1011.                 }
  1012.             }
  1013.             if (header_ret < 0)
  1014.                 continue;
  1015.             s->start_mb_y = (i == 0) ? 0 : FFMAX(0, slices[i-1].mby_start % mb_height);
  1016.             if (!v->field_mode || v->second_field)
  1017.                 s->end_mb_y = (i == n_slices     ) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
  1018.             else {
  1019.                 if (i >= n_slices) {
  1020.                     av_log(v->s.avctx, AV_LOG_ERROR, "first field slice count too large\n");
  1021.                     continue;
  1022.                 }
  1023.                 s->end_mb_y = (i <= n_slices1 + 1) ? mb_height : FFMIN(mb_height, slices[i].mby_start % mb_height);
  1024.             }
  1025.             if (s->end_mb_y <= s->start_mb_y) {
  1026.                 av_log(v->s.avctx, AV_LOG_ERROR, "end mb y %d %d invalid\n", s->end_mb_y, s->start_mb_y);
  1027.                 continue;
  1028.             }
  1029.             if (!v->p_frame_skipped && s->pict_type != AV_PICTURE_TYPE_I && !v->cbpcy_vlc) {
  1030.                 av_log(v->s.avctx, AV_LOG_ERROR, "missing cbpcy_vlc\n");
  1031.                 continue;
  1032.             }
  1033.             ff_vc1_decode_blocks(v);
  1034.             if (i != n_slices)
  1035.                 s->gb = slices[i].gb;
  1036.         }
  1037.         if (v->field_mode) {
  1038.             v->second_field = 0;
  1039.             s->current_picture.f->linesize[0] >>= 1;
  1040.             s->current_picture.f->linesize[1] >>= 1;
  1041.             s->current_picture.f->linesize[2] >>= 1;
  1042.             s->linesize                      >>= 1;
  1043.             s->uvlinesize                    >>= 1;
  1044.             if (v->s.pict_type != AV_PICTURE_TYPE_BI && v->s.pict_type != AV_PICTURE_TYPE_B) {
  1045.                 FFSWAP(uint8_t *, v->mv_f_next[0], v->mv_f[0]);
  1046.                 FFSWAP(uint8_t *, v->mv_f_next[1], v->mv_f[1]);
  1047.             }
  1048.         }
  1049.         ff_dlog(s->avctx, "Consumed %i/%i bits\n",
  1050.                 get_bits_count(&s->gb), s->gb.size_in_bits);
  1051. //  if (get_bits_count(&s->gb) > buf_size * 8)
  1052. //      return -1;
  1053.         if(s->er.error_occurred && s->pict_type == AV_PICTURE_TYPE_B) {
  1054.             ret = AVERROR_INVALIDDATA;
  1055.             goto err;
  1056.         }
  1057.         if (!v->field_mode)
  1058.             ff_er_frame_end(&s->er);
  1059.     }
  1060.  
  1061.     ff_mpv_frame_end(s);
  1062.  
  1063.     if (avctx->codec_id == AV_CODEC_ID_WMV3IMAGE || avctx->codec_id == AV_CODEC_ID_VC1IMAGE) {
  1064. image:
  1065.         avctx->width  = avctx->coded_width  = v->output_width;
  1066.         avctx->height = avctx->coded_height = v->output_height;
  1067.         if (avctx->skip_frame >= AVDISCARD_NONREF)
  1068.             goto end;
  1069. #if CONFIG_WMV3IMAGE_DECODER || CONFIG_VC1IMAGE_DECODER
  1070.         if ((ret = vc1_decode_sprites(v, &s->gb)) < 0)
  1071.             goto err;
  1072. #endif
  1073.         if ((ret = av_frame_ref(pict, v->sprite_output_frame)) < 0)
  1074.             goto err;
  1075.         *got_frame = 1;
  1076.     } else {
  1077.         if (s->pict_type == AV_PICTURE_TYPE_B || s->low_delay) {
  1078.             if ((ret = av_frame_ref(pict, s->current_picture_ptr->f)) < 0)
  1079.                 goto err;
  1080.             ff_print_debug_info(s, s->current_picture_ptr, pict);
  1081.             *got_frame = 1;
  1082.         } else if (s->last_picture_ptr) {
  1083.             if ((ret = av_frame_ref(pict, s->last_picture_ptr->f)) < 0)
  1084.                 goto err;
  1085.             ff_print_debug_info(s, s->last_picture_ptr, pict);
  1086.             *got_frame = 1;
  1087.         }
  1088.     }
  1089.  
  1090. end:
  1091.     av_free(buf2);
  1092.     for (i = 0; i < n_slices; i++)
  1093.         av_free(slices[i].buf);
  1094.     av_free(slices);
  1095.     return buf_size;
  1096.  
  1097. err:
  1098.     av_free(buf2);
  1099.     for (i = 0; i < n_slices; i++)
  1100.         av_free(slices[i].buf);
  1101.     av_free(slices);
  1102.     return ret;
  1103. }
  1104.  
  1105.  
  1106. static const AVProfile profiles[] = {
  1107.     { FF_PROFILE_VC1_SIMPLE,   "Simple"   },
  1108.     { FF_PROFILE_VC1_MAIN,     "Main"     },
  1109.     { FF_PROFILE_VC1_COMPLEX,  "Complex"  },
  1110.     { FF_PROFILE_VC1_ADVANCED, "Advanced" },
  1111.     { FF_PROFILE_UNKNOWN },
  1112. };
  1113.  
  1114. static const enum AVPixelFormat vc1_hwaccel_pixfmt_list_420[] = {
  1115. #if CONFIG_VC1_DXVA2_HWACCEL
  1116.     AV_PIX_FMT_DXVA2_VLD,
  1117. #endif
  1118. #if CONFIG_VC1_D3D11VA_HWACCEL
  1119.     AV_PIX_FMT_D3D11VA_VLD,
  1120. #endif
  1121. #if CONFIG_VC1_VAAPI_HWACCEL
  1122.     AV_PIX_FMT_VAAPI,
  1123. #endif
  1124. #if CONFIG_VC1_VDPAU_HWACCEL
  1125.     AV_PIX_FMT_VDPAU,
  1126. #endif
  1127.     AV_PIX_FMT_YUV420P,
  1128.     AV_PIX_FMT_NONE
  1129. };
  1130.  
  1131. AVCodec ff_vc1_decoder = {
  1132.     .name           = "vc1",
  1133.     .long_name      = NULL_IF_CONFIG_SMALL("SMPTE VC-1"),
  1134.     .type           = AVMEDIA_TYPE_VIDEO,
  1135.     .id             = AV_CODEC_ID_VC1,
  1136.     .priv_data_size = sizeof(VC1Context),
  1137.     .init           = vc1_decode_init,
  1138.     .close          = ff_vc1_decode_end,
  1139.     .decode         = vc1_decode_frame,
  1140.     .flush          = ff_mpeg_flush,
  1141.     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
  1142.     .pix_fmts       = vc1_hwaccel_pixfmt_list_420,
  1143.     .profiles       = NULL_IF_CONFIG_SMALL(profiles)
  1144. };
  1145.  
  1146. #if CONFIG_WMV3_DECODER
  1147. AVCodec ff_wmv3_decoder = {
  1148.     .name           = "wmv3",
  1149.     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9"),
  1150.     .type           = AVMEDIA_TYPE_VIDEO,
  1151.     .id             = AV_CODEC_ID_WMV3,
  1152.     .priv_data_size = sizeof(VC1Context),
  1153.     .init           = vc1_decode_init,
  1154.     .close          = ff_vc1_decode_end,
  1155.     .decode         = vc1_decode_frame,
  1156.     .flush          = ff_mpeg_flush,
  1157.     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY,
  1158.     .pix_fmts       = vc1_hwaccel_pixfmt_list_420,
  1159.     .profiles       = NULL_IF_CONFIG_SMALL(profiles)
  1160. };
  1161. #endif
  1162.  
  1163. #if CONFIG_WMV3_VDPAU_DECODER && FF_API_VDPAU
  1164. AVCodec ff_wmv3_vdpau_decoder = {
  1165.     .name           = "wmv3_vdpau",
  1166.     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 VDPAU"),
  1167.     .type           = AVMEDIA_TYPE_VIDEO,
  1168.     .id             = AV_CODEC_ID_WMV3,
  1169.     .priv_data_size = sizeof(VC1Context),
  1170.     .init           = vc1_decode_init,
  1171.     .close          = ff_vc1_decode_end,
  1172.     .decode         = vc1_decode_frame,
  1173.     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HWACCEL_VDPAU,
  1174.     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_WMV3, AV_PIX_FMT_NONE },
  1175.     .profiles       = NULL_IF_CONFIG_SMALL(profiles)
  1176. };
  1177. #endif
  1178.  
  1179. #if CONFIG_VC1_VDPAU_DECODER && FF_API_VDPAU
  1180. AVCodec ff_vc1_vdpau_decoder = {
  1181.     .name           = "vc1_vdpau",
  1182.     .long_name      = NULL_IF_CONFIG_SMALL("SMPTE VC-1 VDPAU"),
  1183.     .type           = AVMEDIA_TYPE_VIDEO,
  1184.     .id             = AV_CODEC_ID_VC1,
  1185.     .priv_data_size = sizeof(VC1Context),
  1186.     .init           = vc1_decode_init,
  1187.     .close          = ff_vc1_decode_end,
  1188.     .decode         = vc1_decode_frame,
  1189.     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_HWACCEL_VDPAU,
  1190.     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_VDPAU_VC1, AV_PIX_FMT_NONE },
  1191.     .profiles       = NULL_IF_CONFIG_SMALL(profiles)
  1192. };
  1193. #endif
  1194.  
  1195. #if CONFIG_WMV3IMAGE_DECODER
  1196. AVCodec ff_wmv3image_decoder = {
  1197.     .name           = "wmv3image",
  1198.     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image"),
  1199.     .type           = AVMEDIA_TYPE_VIDEO,
  1200.     .id             = AV_CODEC_ID_WMV3IMAGE,
  1201.     .priv_data_size = sizeof(VC1Context),
  1202.     .init           = vc1_decode_init,
  1203.     .close          = ff_vc1_decode_end,
  1204.     .decode         = vc1_decode_frame,
  1205.     .capabilities   = AV_CODEC_CAP_DR1,
  1206.     .flush          = vc1_sprite_flush,
  1207.     .pix_fmts       = (const enum AVPixelFormat[]) {
  1208.         AV_PIX_FMT_YUV420P,
  1209.         AV_PIX_FMT_NONE
  1210.     },
  1211. };
  1212. #endif
  1213.  
  1214. #if CONFIG_VC1IMAGE_DECODER
  1215. AVCodec ff_vc1image_decoder = {
  1216.     .name           = "vc1image",
  1217.     .long_name      = NULL_IF_CONFIG_SMALL("Windows Media Video 9 Image v2"),
  1218.     .type           = AVMEDIA_TYPE_VIDEO,
  1219.     .id             = AV_CODEC_ID_VC1IMAGE,
  1220.     .priv_data_size = sizeof(VC1Context),
  1221.     .init           = vc1_decode_init,
  1222.     .close          = ff_vc1_decode_end,
  1223.     .decode         = vc1_decode_frame,
  1224.     .capabilities   = AV_CODEC_CAP_DR1,
  1225.     .flush          = vc1_sprite_flush,
  1226.     .pix_fmts       = (const enum AVPixelFormat[]) {
  1227.         AV_PIX_FMT_YUV420P,
  1228.         AV_PIX_FMT_NONE
  1229.     },
  1230. };
  1231. #endif
  1232.