LCOV - code coverage report
Current view: top level - libavcodec - flashsv.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 197 275 71.6 %
Date: 2017-12-16 01:21:47 Functions: 9 9 100.0 %

          Line data    Source code
       1             : /*
       2             :  * Flash Screen Video decoder
       3             :  * Copyright (C) 2004 Alex Beregszaszi
       4             :  * Copyright (C) 2006 Benjamin Larsson
       5             :  *
       6             :  * This file is part of FFmpeg.
       7             :  *
       8             :  * FFmpeg is free software; you can redistribute it and/or
       9             :  * modify it under the terms of the GNU Lesser General Public
      10             :  * License as published by the Free Software Foundation; either
      11             :  * version 2.1 of the License, or (at your option) any later version.
      12             :  *
      13             :  * FFmpeg is distributed in the hope that it will be useful,
      14             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      15             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      16             :  * Lesser General Public License for more details.
      17             :  *
      18             :  * You should have received a copy of the GNU Lesser General Public
      19             :  * License along with FFmpeg; if not, write to the Free Software
      20             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      21             :  */
      22             : 
      23             : /**
      24             :  * @file
      25             :  * Flash Screen Video decoder
      26             :  * @author Alex Beregszaszi
      27             :  * @author Benjamin Larsson
      28             :  * @author Daniel Verkamp
      29             :  * @author Konstantin Shishkov
      30             :  *
      31             :  * A description of the bitstream format for Flash Screen Video version 1/2
      32             :  * is part of the SWF File Format Specification (version 10), which can be
      33             :  * downloaded from http://www.adobe.com/devnet/swf.html.
      34             :  */
      35             : 
      36             : #include <stdio.h>
      37             : #include <stdlib.h>
      38             : #include <zlib.h>
      39             : 
      40             : #include "libavutil/intreadwrite.h"
      41             : #include "avcodec.h"
      42             : #include "bytestream.h"
      43             : #include "get_bits.h"
      44             : #include "internal.h"
      45             : 
      46             : typedef struct BlockInfo {
      47             :     uint8_t *pos;
      48             :     int      size;
      49             : } BlockInfo;
      50             : 
      51             : typedef struct FlashSVContext {
      52             :     AVCodecContext *avctx;
      53             :     AVFrame        *frame;
      54             :     int             image_width, image_height;
      55             :     int             block_width, block_height;
      56             :     uint8_t        *tmpblock;
      57             :     int             block_size;
      58             :     z_stream        zstream;
      59             :     int             ver;
      60             :     const uint32_t *pal;
      61             :     int             is_keyframe;
      62             :     uint8_t        *keyframedata;
      63             :     uint8_t        *keyframe;
      64             :     BlockInfo      *blocks;
      65             :     uint8_t        *deflate_block;
      66             :     int             deflate_block_size;
      67             :     int             color_depth;
      68             :     int             zlibprime_curr, zlibprime_prev;
      69             :     int             diff_start, diff_height;
      70             : } FlashSVContext;
      71             : 
      72        4641 : static int decode_hybrid(const uint8_t *sptr, const uint8_t *sptr_end, uint8_t *dptr, int dx, int dy,
      73             :                          int h, int w, int stride, const uint32_t *pal)
      74             : {
      75             :     int x, y;
      76        4641 :     const uint8_t *orig_src = sptr;
      77             : 
      78      270759 :     for (y = dx + h; y > dx; y--) {
      79      266118 :         uint8_t *dst = dptr + (y * stride) + dy * 3;
      80    15835602 :         for (x = 0; x < w; x++) {
      81    15569484 :             if (sptr >= sptr_end)
      82           0 :                 return AVERROR_INVALIDDATA;
      83    15569484 :             if (*sptr & 0x80) {
      84             :                 /* 15-bit color */
      85    12342661 :                 unsigned c = AV_RB16(sptr) & ~0x8000;
      86    12342661 :                 unsigned b =  c        & 0x1F;
      87    12342661 :                 unsigned g = (c >>  5) & 0x1F;
      88    12342661 :                 unsigned r =  c >> 10;
      89             :                 /* 000aaabb -> aaabbaaa  */
      90    12342661 :                 *dst++ = (b << 3) | (b >> 2);
      91    12342661 :                 *dst++ = (g << 3) | (g >> 2);
      92    12342661 :                 *dst++ = (r << 3) | (r >> 2);
      93    12342661 :                 sptr += 2;
      94             :             } else {
      95             :                 /* palette index */
      96     3226823 :                 uint32_t c = pal[*sptr++];
      97     3226823 :                 bytestream_put_le24(&dst, c);
      98             :             }
      99             :         }
     100             :     }
     101        4641 :     return sptr - orig_src;
     102             : }
     103             : 
     104          17 : static av_cold int flashsv_decode_end(AVCodecContext *avctx)
     105             : {
     106          17 :     FlashSVContext *s = avctx->priv_data;
     107          17 :     inflateEnd(&s->zstream);
     108             :     /* release the frame if needed */
     109          17 :     av_frame_free(&s->frame);
     110             : 
     111             :     /* free the tmpblock */
     112          17 :     av_freep(&s->tmpblock);
     113             : 
     114          17 :     return 0;
     115             : }
     116             : 
     117          17 : static av_cold int flashsv_decode_init(AVCodecContext *avctx)
     118             : {
     119          17 :     FlashSVContext *s = avctx->priv_data;
     120             :     int zret; // Zlib return code
     121             : 
     122          17 :     s->avctx          = avctx;
     123          17 :     s->zstream.zalloc = Z_NULL;
     124          17 :     s->zstream.zfree  = Z_NULL;
     125          17 :     s->zstream.opaque = Z_NULL;
     126          17 :     zret = inflateInit(&s->zstream);
     127          17 :     if (zret != Z_OK) {
     128           0 :         av_log(avctx, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
     129           0 :         return 1;
     130             :     }
     131          17 :     avctx->pix_fmt = AV_PIX_FMT_BGR24;
     132             : 
     133          17 :     s->frame = av_frame_alloc();
     134          17 :     if (!s->frame) {
     135           0 :         flashsv_decode_end(avctx);
     136           0 :         return AVERROR(ENOMEM);
     137             :     }
     138             : 
     139          17 :     return 0;
     140             : }
     141             : 
     142        4095 : static int flashsv2_prime(FlashSVContext *s, uint8_t *src, int size)
     143             : {
     144             :     z_stream zs;
     145             :     int zret; // Zlib return code
     146             : 
     147        4095 :     if (!src)
     148           0 :         return AVERROR_INVALIDDATA;
     149             : 
     150        4095 :     zs.zalloc = NULL;
     151        4095 :     zs.zfree  = NULL;
     152        4095 :     zs.opaque = NULL;
     153             : 
     154        4095 :     s->zstream.next_in   = src;
     155        4095 :     s->zstream.avail_in  = size;
     156        4095 :     s->zstream.next_out  = s->tmpblock;
     157        4095 :     s->zstream.avail_out = s->block_size * 3;
     158        4095 :     inflate(&s->zstream, Z_SYNC_FLUSH);
     159             : 
     160        4095 :     if (deflateInit(&zs, 0) != Z_OK)
     161           0 :         return -1;
     162        4095 :     zs.next_in   = s->tmpblock;
     163        4095 :     zs.avail_in  = s->block_size * 3 - s->zstream.avail_out;
     164        4095 :     zs.next_out  = s->deflate_block;
     165        4095 :     zs.avail_out = s->deflate_block_size;
     166        4095 :     deflate(&zs, Z_SYNC_FLUSH);
     167        4095 :     deflateEnd(&zs);
     168             : 
     169        4095 :     if ((zret = inflateReset(&s->zstream)) != Z_OK) {
     170           0 :         av_log(s->avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);
     171           0 :         return AVERROR_UNKNOWN;
     172             :     }
     173             : 
     174        4095 :     s->zstream.next_in   = s->deflate_block;
     175        4095 :     s->zstream.avail_in  = s->deflate_block_size - zs.avail_out;
     176        4095 :     s->zstream.next_out  = s->tmpblock;
     177        4095 :     s->zstream.avail_out = s->block_size * 3;
     178        4095 :     inflate(&s->zstream, Z_SYNC_FLUSH);
     179             : 
     180        4095 :     return 0;
     181             : }
     182             : 
     183        9312 : static int flashsv_decode_block(AVCodecContext *avctx, AVPacket *avpkt,
     184             :                                 GetBitContext *gb, int block_size,
     185             :                                 int width, int height, int x_pos, int y_pos,
     186             :                                 int blk_idx)
     187             : {
     188        9312 :     struct FlashSVContext *s = avctx->priv_data;
     189        9312 :     uint8_t *line = s->tmpblock;
     190             :     int k;
     191        9312 :     int ret = inflateReset(&s->zstream);
     192        9312 :     if (ret != Z_OK) {
     193           0 :         av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", ret);
     194           0 :         return AVERROR_UNKNOWN;
     195             :     }
     196        9312 :     if (s->zlibprime_curr || s->zlibprime_prev) {
     197        8190 :         ret = flashsv2_prime(s,
     198        4095 :                              s->blocks[blk_idx].pos,
     199        4095 :                              s->blocks[blk_idx].size);
     200        4095 :         if (ret < 0)
     201           0 :             return ret;
     202             :     }
     203        9312 :     s->zstream.next_in   = avpkt->data + get_bits_count(gb) / 8;
     204        9312 :     s->zstream.avail_in  = block_size;
     205        9312 :     s->zstream.next_out  = s->tmpblock;
     206        9312 :     s->zstream.avail_out = s->block_size * 3;
     207        9312 :     ret = inflate(&s->zstream, Z_FINISH);
     208        9312 :     if (ret == Z_DATA_ERROR) {
     209           0 :         av_log(avctx, AV_LOG_ERROR, "Zlib resync occurred\n");
     210           0 :         inflateSync(&s->zstream);
     211           0 :         ret = inflate(&s->zstream, Z_FINISH);
     212             :     }
     213             : 
     214             :     if (ret != Z_OK && ret != Z_STREAM_END) {
     215             :         //return -1;
     216             :     }
     217             : 
     218        9312 :     if (s->is_keyframe) {
     219         546 :         s->blocks[blk_idx].pos  = s->keyframedata + (get_bits_count(gb) / 8);
     220         546 :         s->blocks[blk_idx].size = block_size;
     221             :     }
     222             : 
     223        9312 :     y_pos += s->diff_start;
     224             : 
     225        9312 :     if (!s->color_depth) {
     226             :         /* Flash Screen Video stores the image upside down, so copy
     227             :          * lines to destination in reverse order. */
     228      272517 :         for (k = 1; k <= s->diff_height; k++) {
     229      535692 :             memcpy(s->frame->data[0] + x_pos * 3 +
     230      267846 :                    (s->image_height - y_pos - k) * s->frame->linesize[0],
     231      267846 :                    line, width * 3);
     232             :             /* advance source pointer to next line */
     233      267846 :             line += width * 3;
     234             :         }
     235             :     } else {
     236             :         /* hybrid 15-bit/palette mode */
     237       18564 :         ret = decode_hybrid(s->tmpblock, s->zstream.next_out,
     238        4641 :                       s->frame->data[0],
     239        4641 :                       s->image_height - (y_pos + 1 + s->diff_height),
     240             :                       x_pos, s->diff_height, width,
     241        4641 :                       s->frame->linesize[0], s->pal);
     242        4641 :         if (ret < 0) {
     243           0 :             av_log(avctx, AV_LOG_ERROR, "decode_hybrid failed\n");
     244           0 :             return ret;
     245             :         }
     246             :     }
     247        9312 :     skip_bits_long(gb, 8 * block_size); /* skip the consumed bits */
     248        9312 :     return 0;
     249             : }
     250             : 
     251           8 : static int calc_deflate_block_size(int tmpblock_size)
     252             : {
     253             :     z_stream zstream;
     254             :     int size;
     255             : 
     256           8 :     zstream.zalloc = Z_NULL;
     257           8 :     zstream.zfree  = Z_NULL;
     258           8 :     zstream.opaque = Z_NULL;
     259           8 :     if (deflateInit(&zstream, 0) != Z_OK)
     260           0 :         return -1;
     261           8 :     size = deflateBound(&zstream, tmpblock_size);
     262           8 :     deflateEnd(&zstream);
     263             : 
     264           8 :     return size;
     265             : }
     266             : 
     267         409 : static int flashsv_decode_frame(AVCodecContext *avctx, void *data,
     268             :                                 int *got_frame, AVPacket *avpkt)
     269             : {
     270         409 :     int buf_size = avpkt->size;
     271         409 :     FlashSVContext *s = avctx->priv_data;
     272             :     int h_blocks, v_blocks, h_part, v_part, i, j, ret;
     273             :     GetBitContext gb;
     274         409 :     int last_blockwidth = s->block_width;
     275         409 :     int last_blockheight= s->block_height;
     276             : 
     277             :     /* no supplementary picture */
     278         409 :     if (buf_size == 0)
     279           0 :         return 0;
     280         409 :     if (buf_size < 4)
     281           0 :         return -1;
     282             : 
     283         409 :     if ((ret = init_get_bits8(&gb, avpkt->data, buf_size)) < 0)
     284           0 :         return ret;
     285             : 
     286             :     /* start to parse the bitstream */
     287         409 :     s->block_width  = 16 * (get_bits(&gb, 4) + 1);
     288         409 :     s->image_width  = get_bits(&gb, 12);
     289         409 :     s->block_height = 16 * (get_bits(&gb, 4) + 1);
     290         409 :     s->image_height = get_bits(&gb, 12);
     291             : 
     292         409 :     if (   last_blockwidth != s->block_width
     293         392 :         || last_blockheight!= s->block_height)
     294          17 :         av_freep(&s->blocks);
     295             : 
     296         409 :     if (s->ver == 2) {
     297         204 :         skip_bits(&gb, 6);
     298         204 :         if (get_bits1(&gb)) {
     299           0 :             avpriv_request_sample(avctx, "iframe");
     300           0 :             return AVERROR_PATCHWELCOME;
     301             :         }
     302         204 :         if (get_bits1(&gb)) {
     303           0 :             avpriv_request_sample(avctx, "Custom palette");
     304           0 :             return AVERROR_PATCHWELCOME;
     305             :         }
     306             :     }
     307             : 
     308             :     /* calculate number of blocks and size of border (partial) blocks */
     309         409 :     h_blocks = s->image_width  / s->block_width;
     310         409 :     h_part   = s->image_width  % s->block_width;
     311         409 :     v_blocks = s->image_height / s->block_height;
     312         409 :     v_part   = s->image_height % s->block_height;
     313             : 
     314             :     /* the block size could change between frames, make sure the buffer
     315             :      * is large enough, if not, get a larger one */
     316         409 :     if (s->block_size < s->block_width * s->block_height) {
     317          17 :         int tmpblock_size = 3 * s->block_width * s->block_height, err;
     318             : 
     319          17 :         if ((err = av_reallocp(&s->tmpblock, tmpblock_size)) < 0) {
     320           0 :             s->block_size = 0;
     321           0 :             av_log(avctx, AV_LOG_ERROR,
     322             :                    "Cannot allocate decompression buffer.\n");
     323           0 :             return err;
     324             :         }
     325          17 :         if (s->ver == 2) {
     326           8 :             s->deflate_block_size = calc_deflate_block_size(tmpblock_size);
     327           8 :             if (s->deflate_block_size <= 0) {
     328           0 :                 av_log(avctx, AV_LOG_ERROR,
     329             :                        "Cannot determine deflate buffer size.\n");
     330           0 :                 return -1;
     331             :             }
     332           8 :             if ((err = av_reallocp(&s->deflate_block, s->deflate_block_size)) < 0) {
     333           0 :                 s->block_size = 0;
     334           0 :                 av_log(avctx, AV_LOG_ERROR, "Cannot allocate deflate buffer.\n");
     335           0 :                 return err;
     336             :             }
     337             :         }
     338             :     }
     339         409 :     s->block_size = s->block_width * s->block_height;
     340             : 
     341             :     /* initialize the image size once */
     342         409 :     if (avctx->width == 0 && avctx->height == 0) {
     343           9 :         if ((ret = ff_set_dimensions(avctx, s->image_width, s->image_height)) < 0)
     344           0 :             return ret;
     345             :     }
     346             : 
     347             :     /* check for changes of image width and image height */
     348         409 :     if (avctx->width != s->image_width || avctx->height != s->image_height) {
     349           0 :         av_log(avctx, AV_LOG_ERROR,
     350             :                "Frame width or height differs from first frame!\n");
     351           0 :         av_log(avctx, AV_LOG_ERROR, "fh = %d, fv %d  vs  ch = %d, cv = %d\n",
     352             :                avctx->height, avctx->width, s->image_height, s->image_width);
     353           0 :         return AVERROR_INVALIDDATA;
     354             :     }
     355             : 
     356             :     /* we care for keyframes only in Screen Video v2 */
     357         409 :     s->is_keyframe = (avpkt->flags & AV_PKT_FLAG_KEY) && (s->ver == 2);
     358         409 :     if (s->is_keyframe) {
     359             :         int err;
     360          24 :         if ((err = av_reallocp(&s->keyframedata, avpkt->size)) < 0)
     361           0 :             return err;
     362          24 :         memcpy(s->keyframedata, avpkt->data, avpkt->size);
     363             :     }
     364         409 :     if(s->ver == 2 && !s->blocks)
     365           8 :         s->blocks = av_mallocz((v_blocks + !!v_part) * (h_blocks + !!h_part) *
     366             :                                sizeof(s->blocks[0]));
     367             : 
     368             :     ff_dlog(avctx, "image: %dx%d block: %dx%d num: %dx%d part: %dx%d\n",
     369             :             s->image_width, s->image_height, s->block_width, s->block_height,
     370             :             h_blocks, v_blocks, h_part, v_part);
     371             : 
     372         409 :     if ((ret = ff_reget_buffer(avctx, s->frame)) < 0)
     373           0 :         return ret;
     374             : 
     375             :     /* loop over all block columns */
     376        2046 :     for (j = 0; j < v_blocks + (v_part ? 1 : 0); j++) {
     377             : 
     378        1637 :         int y_pos  = j * s->block_height; // vertical position in frame
     379        1637 :         int cur_blk_height = (j < v_blocks) ? s->block_height : v_part;
     380             : 
     381             :         /* loop over all block rows */
     382       10949 :         for (i = 0; i < h_blocks + (h_part ? 1 : 0); i++) {
     383        9312 :             int x_pos = i * s->block_width; // horizontal position in frame
     384        9312 :             int cur_blk_width = (i < h_blocks) ? s->block_width : h_part;
     385        9312 :             int has_diff = 0;
     386             : 
     387             :             /* get the size of the compressed zlib chunk */
     388        9312 :             int size = get_bits(&gb, 16);
     389             : 
     390        9312 :             s->color_depth    = 0;
     391        9312 :             s->zlibprime_curr = 0;
     392        9312 :             s->zlibprime_prev = 0;
     393        9312 :             s->diff_start     = 0;
     394        9312 :             s->diff_height    = cur_blk_height;
     395             : 
     396        9312 :             if (8 * size > get_bits_left(&gb)) {
     397           0 :                 av_frame_unref(s->frame);
     398           0 :                 return AVERROR_INVALIDDATA;
     399             :             }
     400             : 
     401        9312 :             if (s->ver == 2 && size) {
     402        4641 :                 skip_bits(&gb, 3);
     403        4641 :                 s->color_depth    = get_bits(&gb, 2);
     404        4641 :                 has_diff          = get_bits1(&gb);
     405        4641 :                 s->zlibprime_curr = get_bits1(&gb);
     406        4641 :                 s->zlibprime_prev = get_bits1(&gb);
     407             : 
     408        4641 :                 if (s->color_depth != 0 && s->color_depth != 2) {
     409           0 :                     av_log(avctx, AV_LOG_ERROR,
     410             :                            "%dx%d invalid color depth %d\n",
     411             :                            i, j, s->color_depth);
     412           0 :                     return AVERROR_INVALIDDATA;
     413             :                 }
     414             : 
     415        4641 :                 if (has_diff) {
     416           0 :                     if (size < 3) {
     417           0 :                         av_log(avctx, AV_LOG_ERROR, "size too small for diff\n");
     418           0 :                         return AVERROR_INVALIDDATA;
     419             :                     }
     420           0 :                     if (!s->keyframe) {
     421           0 :                         av_log(avctx, AV_LOG_ERROR,
     422             :                                "Inter frame without keyframe\n");
     423           0 :                         return AVERROR_INVALIDDATA;
     424             :                     }
     425           0 :                     s->diff_start  = get_bits(&gb, 8);
     426           0 :                     s->diff_height = get_bits(&gb, 8);
     427           0 :                     if (s->diff_start + s->diff_height > cur_blk_height) {
     428           0 :                         av_log(avctx, AV_LOG_ERROR,
     429             :                                "Block parameters invalid: %d + %d > %d\n",
     430             :                                s->diff_start, s->diff_height, cur_blk_height);
     431           0 :                         return AVERROR_INVALIDDATA;
     432             :                     }
     433           0 :                     av_log(avctx, AV_LOG_DEBUG,
     434             :                            "%dx%d diff start %d height %d\n",
     435             :                            i, j, s->diff_start, s->diff_height);
     436           0 :                     size -= 2;
     437             :                 }
     438             : 
     439        4641 :                 if (s->zlibprime_prev)
     440        4095 :                     av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_prev\n", i, j);
     441             : 
     442        4641 :                 if (s->zlibprime_curr) {
     443           0 :                     int col = get_bits(&gb, 8);
     444           0 :                     int row = get_bits(&gb, 8);
     445           0 :                     av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_curr %dx%d\n",
     446             :                            i, j, col, row);
     447           0 :                     if (size < 3) {
     448           0 :                         av_log(avctx, AV_LOG_ERROR, "size too small for zlibprime_curr\n");
     449           0 :                         return AVERROR_INVALIDDATA;
     450             :                     }
     451           0 :                     size -= 2;
     452           0 :                     avpriv_request_sample(avctx, "zlibprime_curr");
     453           0 :                     return AVERROR_PATCHWELCOME;
     454             :                 }
     455        4641 :                 if (!s->blocks && (s->zlibprime_curr || s->zlibprime_prev)) {
     456           0 :                     av_log(avctx, AV_LOG_ERROR,
     457             :                            "no data available for zlib priming\n");
     458           0 :                     return AVERROR_INVALIDDATA;
     459             :                 }
     460        4641 :                 size--; // account for flags byte
     461             :             }
     462             : 
     463        9312 :             if (has_diff) {
     464             :                 int k;
     465           0 :                 int off = (s->image_height - y_pos - 1) * s->frame->linesize[0];
     466             : 
     467           0 :                 for (k = 0; k < cur_blk_height; k++) {
     468           0 :                     int x = off - k * s->frame->linesize[0] + x_pos * 3;
     469           0 :                     memcpy(s->frame->data[0] + x, s->keyframe + x,
     470           0 :                            cur_blk_width * 3);
     471             :                 }
     472             :             }
     473             : 
     474             :             /* skip unchanged blocks, which have size 0 */
     475        9312 :             if (size) {
     476        9312 :                 if (flashsv_decode_block(avctx, avpkt, &gb, size,
     477             :                                          cur_blk_width, cur_blk_height,
     478             :                                          x_pos, y_pos,
     479        9312 :                                          i + j * (h_blocks + !!h_part)))
     480           0 :                     av_log(avctx, AV_LOG_ERROR,
     481             :                            "error in decompression of block %dx%d\n", i, j);
     482             :             }
     483             :         }
     484             :     }
     485         409 :     if (s->is_keyframe && s->ver == 2) {
     486          24 :         if (!s->keyframe) {
     487           8 :             s->keyframe = av_malloc(s->frame->linesize[0] * avctx->height);
     488           8 :             if (!s->keyframe) {
     489           0 :                 av_log(avctx, AV_LOG_ERROR, "Cannot allocate image data\n");
     490           0 :                 return AVERROR(ENOMEM);
     491             :             }
     492             :         }
     493          24 :         memcpy(s->keyframe, s->frame->data[0],
     494          24 :                s->frame->linesize[0] * avctx->height);
     495             :     }
     496             : 
     497         409 :     if ((ret = av_frame_ref(data, s->frame)) < 0)
     498           0 :         return ret;
     499             : 
     500         409 :     *got_frame = 1;
     501             : 
     502         409 :     if ((get_bits_count(&gb) / 8) != buf_size)
     503           0 :         av_log(avctx, AV_LOG_ERROR, "buffer not fully consumed (%d != %d)\n",
     504           0 :                buf_size, (get_bits_count(&gb) / 8));
     505             : 
     506             :     /* report that the buffer was completely consumed */
     507         409 :     return buf_size;
     508             : }
     509             : 
     510             : #if CONFIG_FLASHSV_DECODER
     511             : AVCodec ff_flashsv_decoder = {
     512             :     .name           = "flashsv",
     513             :     .long_name      = NULL_IF_CONFIG_SMALL("Flash Screen Video v1"),
     514             :     .type           = AVMEDIA_TYPE_VIDEO,
     515             :     .id             = AV_CODEC_ID_FLASHSV,
     516             :     .priv_data_size = sizeof(FlashSVContext),
     517             :     .init           = flashsv_decode_init,
     518             :     .close          = flashsv_decode_end,
     519             :     .decode         = flashsv_decode_frame,
     520             :     .capabilities   = AV_CODEC_CAP_DR1,
     521             :     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE },
     522             : };
     523             : #endif /* CONFIG_FLASHSV_DECODER */
     524             : 
     525             : #if CONFIG_FLASHSV2_DECODER
     526             : static const uint32_t ff_flashsv2_default_palette[128] = {
     527             :     0x000000, 0x333333, 0x666666, 0x999999, 0xCCCCCC, 0xFFFFFF,
     528             :     0x330000, 0x660000, 0x990000, 0xCC0000, 0xFF0000, 0x003300,
     529             :     0x006600, 0x009900, 0x00CC00, 0x00FF00, 0x000033, 0x000066,
     530             :     0x000099, 0x0000CC, 0x0000FF, 0x333300, 0x666600, 0x999900,
     531             :     0xCCCC00, 0xFFFF00, 0x003333, 0x006666, 0x009999, 0x00CCCC,
     532             :     0x00FFFF, 0x330033, 0x660066, 0x990099, 0xCC00CC, 0xFF00FF,
     533             :     0xFFFF33, 0xFFFF66, 0xFFFF99, 0xFFFFCC, 0xFF33FF, 0xFF66FF,
     534             :     0xFF99FF, 0xFFCCFF, 0x33FFFF, 0x66FFFF, 0x99FFFF, 0xCCFFFF,
     535             :     0xCCCC33, 0xCCCC66, 0xCCCC99, 0xCCCCFF, 0xCC33CC, 0xCC66CC,
     536             :     0xCC99CC, 0xCCFFCC, 0x33CCCC, 0x66CCCC, 0x99CCCC, 0xFFCCCC,
     537             :     0x999933, 0x999966, 0x9999CC, 0x9999FF, 0x993399, 0x996699,
     538             :     0x99CC99, 0x99FF99, 0x339999, 0x669999, 0xCC9999, 0xFF9999,
     539             :     0x666633, 0x666699, 0x6666CC, 0x6666FF, 0x663366, 0x669966,
     540             :     0x66CC66, 0x66FF66, 0x336666, 0x996666, 0xCC6666, 0xFF6666,
     541             :     0x333366, 0x333399, 0x3333CC, 0x3333FF, 0x336633, 0x339933,
     542             :     0x33CC33, 0x33FF33, 0x663333, 0x993333, 0xCC3333, 0xFF3333,
     543             :     0x003366, 0x336600, 0x660033, 0x006633, 0x330066, 0x663300,
     544             :     0x336699, 0x669933, 0x993366, 0x339966, 0x663399, 0x996633,
     545             :     0x6699CC, 0x99CC66, 0xCC6699, 0x66CC99, 0x9966CC, 0xCC9966,
     546             :     0x99CCFF, 0xCCFF99, 0xFF99CC, 0x99FFCC, 0xCC99FF, 0xFFCC99,
     547             :     0x111111, 0x222222, 0x444444, 0x555555, 0xAAAAAA, 0xBBBBBB,
     548             :     0xDDDDDD, 0xEEEEEE
     549             : };
     550             : 
     551           8 : static av_cold int flashsv2_decode_init(AVCodecContext *avctx)
     552             : {
     553           8 :     FlashSVContext *s = avctx->priv_data;
     554           8 :     flashsv_decode_init(avctx);
     555           8 :     s->pal = ff_flashsv2_default_palette;
     556           8 :     s->ver = 2;
     557             : 
     558           8 :     return 0;
     559             : }
     560             : 
     561           8 : static av_cold int flashsv2_decode_end(AVCodecContext *avctx)
     562             : {
     563           8 :     FlashSVContext *s = avctx->priv_data;
     564             : 
     565           8 :     av_freep(&s->keyframedata);
     566           8 :     av_freep(&s->blocks);
     567           8 :     av_freep(&s->keyframe);
     568           8 :     av_freep(&s->deflate_block);
     569           8 :     flashsv_decode_end(avctx);
     570             : 
     571           8 :     return 0;
     572             : }
     573             : 
     574             : AVCodec ff_flashsv2_decoder = {
     575             :     .name           = "flashsv2",
     576             :     .long_name      = NULL_IF_CONFIG_SMALL("Flash Screen Video v2"),
     577             :     .type           = AVMEDIA_TYPE_VIDEO,
     578             :     .id             = AV_CODEC_ID_FLASHSV2,
     579             :     .priv_data_size = sizeof(FlashSVContext),
     580             :     .init           = flashsv2_decode_init,
     581             :     .close          = flashsv2_decode_end,
     582             :     .decode         = flashsv_decode_frame,
     583             :     .capabilities   = AV_CODEC_CAP_DR1,
     584             :     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE },
     585             : };
     586             : #endif /* CONFIG_FLASHSV2_DECODER */

Generated by: LCOV version 1.13