git.sesse.net Git - ffmpeg/blob - libavcodec/flashsv.c

   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 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     const uint8_t *orig_src = sptr;
  77
  78     for (y = dx + h; y > dx; y--) {
  79         uint8_t *dst = dptr + (y * stride) + dy * 3;
  80         for (x = 0; x < w; x++) {
  81             if (sptr >= sptr_end)
  82                 return AVERROR_INVALIDDATA;
  83             if (*sptr & 0x80) {
  84                 /* 15-bit color */
  85                 unsigned c = AV_RB16(sptr) & ~0x8000;
  86                 unsigned b =  c        & 0x1F;
  87                 unsigned g = (c >>  5) & 0x1F;
  88                 unsigned r =  c >> 10;
  89                 /* 000aaabb -> aaabbaaa  */
  90                 *dst++ = (b << 3) | (b >> 2);
  91                 *dst++ = (g << 3) | (g >> 2);
  92                 *dst++ = (r << 3) | (r >> 2);
  93                 sptr += 2;
  94             } else {
  95                 /* palette index */
  96                 uint32_t c = pal[*sptr++];
  97                 bytestream_put_le24(&dst, c);
  98             }
  99         }
 100     }
 101     return sptr - orig_src;
 102 }
 103
 104 static av_cold int flashsv_decode_end(AVCodecContext *avctx)
 105 {
 106     FlashSVContext *s = avctx->priv_data;
 107     inflateEnd(&s->zstream);
 108     /* release the frame if needed */
 109     av_frame_free(&s->frame);
 110
 111     /* free the tmpblock */
 112     av_freep(&s->tmpblock);
 113
 114     return 0;
 115 }
 116
 117 static av_cold int flashsv_decode_init(AVCodecContext *avctx)
 118 {
 119     FlashSVContext *s = avctx->priv_data;
 120     int zret; // Zlib return code
 121
 122     s->avctx          = avctx;
 123     s->zstream.zalloc = Z_NULL;
 124     s->zstream.zfree  = Z_NULL;
 125     s->zstream.opaque = Z_NULL;
 126     zret = inflateInit(&s->zstream);
 127     if (zret != Z_OK) {
 128         av_log(avctx, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
 129         return 1;
 130     }
 131     avctx->pix_fmt = AV_PIX_FMT_BGR24;
 132
 133     s->frame = av_frame_alloc();
 134     if (!s->frame) {
 135         flashsv_decode_end(avctx);
 136         return AVERROR(ENOMEM);
 137     }
 138
 139     return 0;
 140 }
 141
 142 static int flashsv2_prime(FlashSVContext *s, uint8_t *src, int size)
 143 {
 144     z_stream zs;
 145     int zret; // Zlib return code
 146
 147     if (!src)
 148         return AVERROR_INVALIDDATA;
 149
 150     zs.zalloc = NULL;
 151     zs.zfree  = NULL;
 152     zs.opaque = NULL;
 153
 154     s->zstream.next_in   = src;
 155     s->zstream.avail_in  = size;
 156     s->zstream.next_out  = s->tmpblock;
 157     s->zstream.avail_out = s->block_size * 3;
 158     inflate(&s->zstream, Z_SYNC_FLUSH);
 159
 160     if (deflateInit(&zs, 0) != Z_OK)
 161         return -1;
 162     zs.next_in   = s->tmpblock;
 163     zs.avail_in  = s->block_size * 3 - s->zstream.avail_out;
 164     zs.next_out  = s->deflate_block;
 165     zs.avail_out = s->deflate_block_size;
 166     deflate(&zs, Z_SYNC_FLUSH);
 167     deflateEnd(&zs);
 168
 169     if ((zret = inflateReset(&s->zstream)) != Z_OK) {
 170         av_log(s->avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);
 171         return AVERROR_UNKNOWN;
 172     }
 173
 174     s->zstream.next_in   = s->deflate_block;
 175     s->zstream.avail_in  = s->deflate_block_size - zs.avail_out;
 176     s->zstream.next_out  = s->tmpblock;
 177     s->zstream.avail_out = s->block_size * 3;
 178     inflate(&s->zstream, Z_SYNC_FLUSH);
 179
 180     return 0;
 181 }
 182
 183 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     struct FlashSVContext *s = avctx->priv_data;
 189     uint8_t *line = s->tmpblock;
 190     int k;
 191     int ret = inflateReset(&s->zstream);
 192     if (ret != Z_OK) {
 193         av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", ret);
 194         return AVERROR_UNKNOWN;
 195     }
 196     if (s->zlibprime_curr || s->zlibprime_prev) {
 197         ret = flashsv2_prime(s,
 198                              s->blocks[blk_idx].pos,
 199                              s->blocks[blk_idx].size);
 200         if (ret < 0)
 201             return ret;
 202     }
 203     s->zstream.next_in   = avpkt->data + get_bits_count(gb) / 8;
 204     s->zstream.avail_in  = block_size;
 205     s->zstream.next_out  = s->tmpblock;
 206     s->zstream.avail_out = s->block_size * 3;
 207     ret = inflate(&s->zstream, Z_FINISH);
 208     if (ret == Z_DATA_ERROR) {
 209         av_log(avctx, AV_LOG_ERROR, "Zlib resync occurred\n");
 210         inflateSync(&s->zstream);
 211         ret = inflate(&s->zstream, Z_FINISH);
 212     }
 213
 214     if (ret != Z_OK && ret != Z_STREAM_END) {
 215         //return -1;
 216     }
 217
 218     if (s->is_keyframe) {
 219         s->blocks[blk_idx].pos  = s->keyframedata + (get_bits_count(gb) / 8);
 220         s->blocks[blk_idx].size = block_size;
 221     }
 222
 223     y_pos += s->diff_start;
 224
 225     if (!s->color_depth) {
 226         /* Flash Screen Video stores the image upside down, so copy
 227          * lines to destination in reverse order. */
 228         for (k = 1; k <= s->diff_height; k++) {
 229             memcpy(s->frame->data[0] + x_pos * 3 +
 230                    (s->image_height - y_pos - k) * s->frame->linesize[0],
 231                    line, width * 3);
 232             /* advance source pointer to next line */
 233             line += width * 3;
 234         }
 235     } else {
 236         /* hybrid 15-bit/palette mode */
 237         ret = decode_hybrid(s->tmpblock, s->zstream.next_out,
 238                       s->frame->data[0],
 239                       s->image_height - (y_pos + 1 + s->diff_height),
 240                       x_pos, s->diff_height, width,
 241                       s->frame->linesize[0], s->pal);
 242         if (ret < 0) {
 243             av_log(avctx, AV_LOG_ERROR, "decode_hybrid failed\n");
 244             return ret;
 245         }
 246     }
 247     skip_bits_long(gb, 8 * block_size); /* skip the consumed bits */
 248     return 0;
 249 }
 250
 251 static int calc_deflate_block_size(int tmpblock_size)
 252 {
 253     z_stream zstream;
 254     int size;
 255
 256     zstream.zalloc = Z_NULL;
 257     zstream.zfree  = Z_NULL;
 258     zstream.opaque = Z_NULL;
 259     if (deflateInit(&zstream, 0) != Z_OK)
 260         return -1;
 261     size = deflateBound(&zstream, tmpblock_size);
 262     deflateEnd(&zstream);
 263
 264     return size;
 265 }
 266
 267 static int flashsv_decode_frame(AVCodecContext *avctx, void *data,
 268                                 int *got_frame, AVPacket *avpkt)
 269 {
 270     int buf_size = avpkt->size;
 271     FlashSVContext *s = avctx->priv_data;
 272     int h_blocks, v_blocks, h_part, v_part, i, j, ret;
 273     GetBitContext gb;
 274     int last_blockwidth = s->block_width;
 275     int last_blockheight= s->block_height;
 276
 277     /* no supplementary picture */
 278     if (buf_size == 0)
 279         return 0;
 280     if (buf_size < 4)
 281         return -1;
 282
 283     if ((ret = init_get_bits8(&gb, avpkt->data, buf_size)) < 0)
 284         return ret;
 285
 286     /* start to parse the bitstream */
 287     s->block_width  = 16 * (get_bits(&gb, 4) + 1);
 288     s->image_width  = get_bits(&gb, 12);
 289     s->block_height = 16 * (get_bits(&gb, 4) + 1);
 290     s->image_height = get_bits(&gb, 12);
 291
 292     if (   last_blockwidth != s->block_width
 293         || last_blockheight!= s->block_height)
 294         av_freep(&s->blocks);
 295
 296     if (s->ver == 2) {
 297         skip_bits(&gb, 6);
 298         if (get_bits1(&gb)) {
 299             avpriv_request_sample(avctx, "iframe");
 300             return AVERROR_PATCHWELCOME;
 301         }
 302         if (get_bits1(&gb)) {
 303             avpriv_request_sample(avctx, "Custom palette");
 304             return AVERROR_PATCHWELCOME;
 305         }
 306     }
 307
 308     /* calculate number of blocks and size of border (partial) blocks */
 309     h_blocks = s->image_width  / s->block_width;
 310     h_part   = s->image_width  % s->block_width;
 311     v_blocks = s->image_height / s->block_height;
 312     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     if (s->block_size < s->block_width * s->block_height) {
 317         int tmpblock_size = 3 * s->block_width * s->block_height, err;
 318
 319         if ((err = av_reallocp(&s->tmpblock, tmpblock_size)) < 0) {
 320             s->block_size = 0;
 321             av_log(avctx, AV_LOG_ERROR,
 322                    "Cannot allocate decompression buffer.\n");
 323             return err;
 324         }
 325         if (s->ver == 2) {
 326             s->deflate_block_size = calc_deflate_block_size(tmpblock_size);
 327             if (s->deflate_block_size <= 0) {
 328                 av_log(avctx, AV_LOG_ERROR,
 329                        "Cannot determine deflate buffer size.\n");
 330                 return -1;
 331             }
 332             if ((err = av_reallocp(&s->deflate_block, s->deflate_block_size)) < 0) {
 333                 s->block_size = 0;
 334                 av_log(avctx, AV_LOG_ERROR, "Cannot allocate deflate buffer.\n");
 335                 return err;
 336             }
 337         }
 338     }
 339     s->block_size = s->block_width * s->block_height;
 340
 341     /* initialize the image size once */
 342     if (avctx->width == 0 && avctx->height == 0) {
 343         if ((ret = ff_set_dimensions(avctx, s->image_width, s->image_height)) < 0)
 344             return ret;
 345     }
 346
 347     /* check for changes of image width and image height */
 348     if (avctx->width != s->image_width || avctx->height != s->image_height) {
 349         av_log(avctx, AV_LOG_ERROR,
 350                "Frame width or height differs from first frame!\n");
 351         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         return AVERROR_INVALIDDATA;
 354     }
 355
 356     /* we care for keyframes only in Screen Video v2 */
 357     s->is_keyframe = (avpkt->flags & AV_PKT_FLAG_KEY) && (s->ver == 2);
 358     if (s->is_keyframe) {
 359         int err;
 360         if ((err = av_reallocp(&s->keyframedata, avpkt->size)) < 0)
 361             return err;
 362         memcpy(s->keyframedata, avpkt->data, avpkt->size);
 363     }
 364     if(s->ver == 2 && !s->blocks)
 365         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     if ((ret = ff_reget_buffer(avctx, s->frame)) < 0)
 373         return ret;
 374
 375     /* loop over all block columns */
 376     for (j = 0; j < v_blocks + (v_part ? 1 : 0); j++) {
 377
 378         int y_pos  = j * s->block_height; // vertical position in frame
 379         int cur_blk_height = (j < v_blocks) ? s->block_height : v_part;
 380
 381         /* loop over all block rows */
 382         for (i = 0; i < h_blocks + (h_part ? 1 : 0); i++) {
 383             int x_pos = i * s->block_width; // horizontal position in frame
 384             int cur_blk_width = (i < h_blocks) ? s->block_width : h_part;
 385             int has_diff = 0;
 386
 387             /* get the size of the compressed zlib chunk */
 388             int size = get_bits(&gb, 16);
 389
 390             s->color_depth    = 0;
 391             s->zlibprime_curr = 0;
 392             s->zlibprime_prev = 0;
 393             s->diff_start     = 0;
 394             s->diff_height    = cur_blk_height;
 395
 396             if (8 * size > get_bits_left(&gb)) {
 397                 av_frame_unref(s->frame);
 398                 return AVERROR_INVALIDDATA;
 399             }
 400
 401             if (s->ver == 2 && size) {
 402                 skip_bits(&gb, 3);
 403                 s->color_depth    = get_bits(&gb, 2);
 404                 has_diff          = get_bits1(&gb);
 405                 s->zlibprime_curr = get_bits1(&gb);
 406                 s->zlibprime_prev = get_bits1(&gb);
 407
 408                 if (s->color_depth != 0 && s->color_depth != 2) {
 409                     av_log(avctx, AV_LOG_ERROR,
 410                            "%dx%d invalid color depth %d\n",
 411                            i, j, s->color_depth);
 412                     return AVERROR_INVALIDDATA;
 413                 }
 414
 415                 if (has_diff) {
 416                     if (size < 3) {
 417                         av_log(avctx, AV_LOG_ERROR, "size too small for diff\n");
 418                         return AVERROR_INVALIDDATA;
 419                     }
 420                     if (!s->keyframe) {
 421                         av_log(avctx, AV_LOG_ERROR,
 422                                "Inter frame without keyframe\n");
 423                         return AVERROR_INVALIDDATA;
 424                     }
 425                     s->diff_start  = get_bits(&gb, 8);
 426                     s->diff_height = get_bits(&gb, 8);
 427                     if (s->diff_start + s->diff_height > cur_blk_height) {
 428                         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                         return AVERROR_INVALIDDATA;
 432                     }
 433                     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                     size -= 2;
 437                 }
 438
 439                 if (s->zlibprime_prev)
 440                     av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_prev\n", i, j);
 441
 442                 if (s->zlibprime_curr) {
 443                     int col = get_bits(&gb, 8);
 444                     int row = get_bits(&gb, 8);
 445                     av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_curr %dx%d\n",
 446                            i, j, col, row);
 447                     if (size < 3) {
 448                         av_log(avctx, AV_LOG_ERROR, "size too small for zlibprime_curr\n");
 449                         return AVERROR_INVALIDDATA;
 450                     }
 451                     size -= 2;
 452                     avpriv_request_sample(avctx, "zlibprime_curr");
 453                     return AVERROR_PATCHWELCOME;
 454                 }
 455                 if (!s->blocks && (s->zlibprime_curr || s->zlibprime_prev)) {
 456                     av_log(avctx, AV_LOG_ERROR,
 457                            "no data available for zlib priming\n");
 458                     return AVERROR_INVALIDDATA;
 459                 }
 460                 size--; // account for flags byte
 461             }
 462
 463             if (has_diff) {
 464                 int k;
 465                 int off = (s->image_height - y_pos - 1) * s->frame->linesize[0];
 466
 467                 for (k = 0; k < cur_blk_height; k++) {
 468                     int x = off - k * s->frame->linesize[0] + x_pos * 3;
 469                     memcpy(s->frame->data[0] + x, s->keyframe + x,
 470                            cur_blk_width * 3);
 471                 }
 472             }
 473
 474             /* skip unchanged blocks, which have size 0 */
 475             if (size) {
 476                 if (flashsv_decode_block(avctx, avpkt, &gb, size,
 477                                          cur_blk_width, cur_blk_height,
 478                                          x_pos, y_pos,
 479                                          i + j * (h_blocks + !!h_part)))
 480                     av_log(avctx, AV_LOG_ERROR,
 481                            "error in decompression of block %dx%d\n", i, j);
 482             }
 483         }
 484     }
 485     if (s->is_keyframe && s->ver == 2) {
 486         if (!s->keyframe) {
 487             s->keyframe = av_malloc(s->frame->linesize[0] * avctx->height);
 488             if (!s->keyframe) {
 489                 av_log(avctx, AV_LOG_ERROR, "Cannot allocate image data\n");
 490                 return AVERROR(ENOMEM);
 491             }
 492         }
 493         memcpy(s->keyframe, s->frame->data[0],
 494                s->frame->linesize[0] * avctx->height);
 495     }
 496
 497     if ((ret = av_frame_ref(data, s->frame)) < 0)
 498         return ret;
 499
 500     *got_frame = 1;
 501
 502     if ((get_bits_count(&gb) / 8) != buf_size)
 503         av_log(avctx, AV_LOG_ERROR, "buffer not fully consumed (%d != %d)\n",
 504                buf_size, (get_bits_count(&gb) / 8));
 505
 506     /* report that the buffer was completely consumed */
 507     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 static av_cold int flashsv2_decode_init(AVCodecContext *avctx)
 552 {
 553     FlashSVContext *s = avctx->priv_data;
 554     int ret;
 555
 556     ret = flashsv_decode_init(avctx);
 557     if (ret < 0)
 558         return ret;
 559     s->pal = ff_flashsv2_default_palette;
 560     s->ver = 2;
 561
 562     return 0;
 563 }
 564
 565 static av_cold int flashsv2_decode_end(AVCodecContext *avctx)
 566 {
 567     FlashSVContext *s = avctx->priv_data;
 568
 569     av_freep(&s->keyframedata);
 570     av_freep(&s->blocks);
 571     av_freep(&s->keyframe);
 572     av_freep(&s->deflate_block);
 573     flashsv_decode_end(avctx);
 574
 575     return 0;
 576 }
 577
 578 AVCodec ff_flashsv2_decoder = {
 579     .name           = "flashsv2",
 580     .long_name      = NULL_IF_CONFIG_SMALL("Flash Screen Video v2"),
 581     .type           = AVMEDIA_TYPE_VIDEO,
 582     .id             = AV_CODEC_ID_FLASHSV2,
 583     .priv_data_size = sizeof(FlashSVContext),
 584     .init           = flashsv2_decode_init,
 585     .close          = flashsv2_decode_end,
 586     .decode         = flashsv_decode_frame,
 587     .capabilities   = AV_CODEC_CAP_DR1,
 588     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE },
 589 };
 590 #endif /* CONFIG_FLASHSV2_DECODER */