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     av_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 (!s->keyframe) {
 417                         av_log(avctx, AV_LOG_ERROR,
 418                                "Inter frame without keyframe\n");
 419                         return AVERROR_INVALIDDATA;
 420                     }
 421                     s->diff_start  = get_bits(&gb, 8);
 422                     s->diff_height = get_bits(&gb, 8);
 423                     if (s->diff_start + s->diff_height > cur_blk_height) {
 424                         av_log(avctx, AV_LOG_ERROR,
 425                                "Block parameters invalid: %d + %d > %d\n",
 426                                s->diff_start, s->diff_height, cur_blk_height);
 427                         return AVERROR_INVALIDDATA;
 428                     }
 429                     av_log(avctx, AV_LOG_DEBUG,
 430                            "%dx%d diff start %d height %d\n",
 431                            i, j, s->diff_start, s->diff_height);
 432                     size -= 2;
 433                 }
 434
 435                 if (s->zlibprime_prev)
 436                     av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_prev\n", i, j);
 437
 438                 if (s->zlibprime_curr) {
 439                     int col = get_bits(&gb, 8);
 440                     int row = get_bits(&gb, 8);
 441                     av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_curr %dx%d\n",
 442                            i, j, col, row);
 443                     size -= 2;
 444                     avpriv_request_sample(avctx, "zlibprime_curr");
 445                     return AVERROR_PATCHWELCOME;
 446                 }
 447                 if (!s->blocks && (s->zlibprime_curr || s->zlibprime_prev)) {
 448                     av_log(avctx, AV_LOG_ERROR,
 449                            "no data available for zlib priming\n");
 450                     return AVERROR_INVALIDDATA;
 451                 }
 452                 size--; // account for flags byte
 453             }
 454
 455             if (has_diff) {
 456                 int k;
 457                 int off = (s->image_height - y_pos - 1) * s->frame->linesize[0];
 458
 459                 for (k = 0; k < cur_blk_height; k++) {
 460                     int x = off - k * s->frame->linesize[0] + x_pos * 3;
 461                     memcpy(s->frame->data[0] + x, s->keyframe + x,
 462                            cur_blk_width * 3);
 463                 }
 464             }
 465
 466             /* skip unchanged blocks, which have size 0 */
 467             if (size) {
 468                 if (flashsv_decode_block(avctx, avpkt, &gb, size,
 469                                          cur_blk_width, cur_blk_height,
 470                                          x_pos, y_pos,
 471                                          i + j * (h_blocks + !!h_part)))
 472                     av_log(avctx, AV_LOG_ERROR,
 473                            "error in decompression of block %dx%d\n", i, j);
 474             }
 475         }
 476     }
 477     if (s->is_keyframe && s->ver == 2) {
 478         if (!s->keyframe) {
 479             s->keyframe = av_malloc(s->frame->linesize[0] * avctx->height);
 480             if (!s->keyframe) {
 481                 av_log(avctx, AV_LOG_ERROR, "Cannot allocate image data\n");
 482                 return AVERROR(ENOMEM);
 483             }
 484         }
 485         memcpy(s->keyframe, s->frame->data[0],
 486                s->frame->linesize[0] * avctx->height);
 487     }
 488
 489     if ((ret = av_frame_ref(data, s->frame)) < 0)
 490         return ret;
 491
 492     *got_frame = 1;
 493
 494     if ((get_bits_count(&gb) / 8) != buf_size)
 495         av_log(avctx, AV_LOG_ERROR, "buffer not fully consumed (%d != %d)\n",
 496                buf_size, (get_bits_count(&gb) / 8));
 497
 498     /* report that the buffer was completely consumed */
 499     return buf_size;
 500 }
 501
 502 #if CONFIG_FLASHSV_DECODER
 503 AVCodec ff_flashsv_decoder = {
 504     .name           = "flashsv",
 505     .long_name      = NULL_IF_CONFIG_SMALL("Flash Screen Video v1"),
 506     .type           = AVMEDIA_TYPE_VIDEO,
 507     .id             = AV_CODEC_ID_FLASHSV,
 508     .priv_data_size = sizeof(FlashSVContext),
 509     .init           = flashsv_decode_init,
 510     .close          = flashsv_decode_end,
 511     .decode         = flashsv_decode_frame,
 512     .capabilities   = CODEC_CAP_DR1,
 513     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE },
 514 };
 515 #endif /* CONFIG_FLASHSV_DECODER */
 516
 517 #if CONFIG_FLASHSV2_DECODER
 518 static const uint32_t ff_flashsv2_default_palette[128] = {
 519     0x000000, 0x333333, 0x666666, 0x999999, 0xCCCCCC, 0xFFFFFF,
 520     0x330000, 0x660000, 0x990000, 0xCC0000, 0xFF0000, 0x003300,
 521     0x006600, 0x009900, 0x00CC00, 0x00FF00, 0x000033, 0x000066,
 522     0x000099, 0x0000CC, 0x0000FF, 0x333300, 0x666600, 0x999900,
 523     0xCCCC00, 0xFFFF00, 0x003333, 0x006666, 0x009999, 0x00CCCC,
 524     0x00FFFF, 0x330033, 0x660066, 0x990099, 0xCC00CC, 0xFF00FF,
 525     0xFFFF33, 0xFFFF66, 0xFFFF99, 0xFFFFCC, 0xFF33FF, 0xFF66FF,
 526     0xFF99FF, 0xFFCCFF, 0x33FFFF, 0x66FFFF, 0x99FFFF, 0xCCFFFF,
 527     0xCCCC33, 0xCCCC66, 0xCCCC99, 0xCCCCFF, 0xCC33CC, 0xCC66CC,
 528     0xCC99CC, 0xCCFFCC, 0x33CCCC, 0x66CCCC, 0x99CCCC, 0xFFCCCC,
 529     0x999933, 0x999966, 0x9999CC, 0x9999FF, 0x993399, 0x996699,
 530     0x99CC99, 0x99FF99, 0x339999, 0x669999, 0xCC9999, 0xFF9999,
 531     0x666633, 0x666699, 0x6666CC, 0x6666FF, 0x663366, 0x669966,
 532     0x66CC66, 0x66FF66, 0x336666, 0x996666, 0xCC6666, 0xFF6666,
 533     0x333366, 0x333399, 0x3333CC, 0x3333FF, 0x336633, 0x339933,
 534     0x33CC33, 0x33FF33, 0x663333, 0x993333, 0xCC3333, 0xFF3333,
 535     0x003366, 0x336600, 0x660033, 0x006633, 0x330066, 0x663300,
 536     0x336699, 0x669933, 0x993366, 0x339966, 0x663399, 0x996633,
 537     0x6699CC, 0x99CC66, 0xCC6699, 0x66CC99, 0x9966CC, 0xCC9966,
 538     0x99CCFF, 0xCCFF99, 0xFF99CC, 0x99FFCC, 0xCC99FF, 0xFFCC99,
 539     0x111111, 0x222222, 0x444444, 0x555555, 0xAAAAAA, 0xBBBBBB,
 540     0xDDDDDD, 0xEEEEEE
 541 };
 542
 543 static av_cold int flashsv2_decode_init(AVCodecContext *avctx)
 544 {
 545     FlashSVContext *s = avctx->priv_data;
 546     flashsv_decode_init(avctx);
 547     s->pal = ff_flashsv2_default_palette;
 548     s->ver = 2;
 549
 550     return 0;
 551 }
 552
 553 static av_cold int flashsv2_decode_end(AVCodecContext *avctx)
 554 {
 555     FlashSVContext *s = avctx->priv_data;
 556
 557     av_freep(&s->keyframedata);
 558     av_freep(&s->blocks);
 559     av_freep(&s->keyframe);
 560     av_freep(&s->deflate_block);
 561     flashsv_decode_end(avctx);
 562
 563     return 0;
 564 }
 565
 566 AVCodec ff_flashsv2_decoder = {
 567     .name           = "flashsv2",
 568     .long_name      = NULL_IF_CONFIG_SMALL("Flash Screen Video v2"),
 569     .type           = AVMEDIA_TYPE_VIDEO,
 570     .id             = AV_CODEC_ID_FLASHSV2,
 571     .priv_data_size = sizeof(FlashSVContext),
 572     .init           = flashsv2_decode_init,
 573     .close          = flashsv2_decode_end,
 574     .decode         = flashsv_decode_frame,
 575     .capabilities   = CODEC_CAP_DR1,
 576     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE },
 577 };
 578 #endif /* CONFIG_FLASHSV2_DECODER */