LCOV - code coverage report
Current view: top level - libavcodec - vc1dec.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 324 703 46.1 %
Date: 2017-12-18 20:14:19 Functions: 5 11 45.5 %

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

Generated by: LCOV version 1.13