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, 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 & 0x80) {
  82                 /* 15-bit color */
  83                 unsigned c = AV_RB16(sptr) & ~0x8000;
  84                 unsigned b =  c        & 0x1F;
  85                 unsigned g = (c >>  5) & 0x1F;
  86                 unsigned r =  c >> 10;
  87                 /* 000aaabb -> aaabbaaa  */
  88                 *dst++ = (b << 3) | (b >> 2);
  89                 *dst++ = (g << 3) | (g >> 2);
  90                 *dst++ = (r << 3) | (r >> 2);
  91                 sptr += 2;
  92             } else {
  93                 /* palette index */
  94                 uint32_t c = pal[*sptr++];
  95                 bytestream_put_le24(&dst, c);
  96             }
  97         }
  98     }
  99     return sptr - orig_src;
 100 }
 101
 102 static av_cold int flashsv_decode_init(AVCodecContext *avctx)
 103 {
 104     FlashSVContext *s = avctx->priv_data;
 105     int zret; // Zlib return code
 106
 107     s->avctx          = avctx;
 108     s->zstream.zalloc = Z_NULL;
 109     s->zstream.zfree  = Z_NULL;
 110     s->zstream.opaque = Z_NULL;
 111     zret = inflateInit(&s->zstream);
 112     if (zret != Z_OK) {
 113         av_log(avctx, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
 114         return 1;
 115     }
 116     avctx->pix_fmt = AV_PIX_FMT_BGR24;
 117     avcodec_get_frame_defaults(&s->frame);
 118
 119     return 0;
 120 }
 121
 122 static int flashsv2_prime(FlashSVContext *s, uint8_t *src, int size)
 123 {
 124     z_stream zs;
 125     int zret; // Zlib return code
 126
 127     if (!src)
 128         return AVERROR_INVALIDDATA;
 129
 130     zs.zalloc = NULL;
 131     zs.zfree  = NULL;
 132     zs.opaque = NULL;
 133
 134     s->zstream.next_in   = src;
 135     s->zstream.avail_in  = size;
 136     s->zstream.next_out  = s->tmpblock;
 137     s->zstream.avail_out = s->block_size * 3;
 138     inflate(&s->zstream, Z_SYNC_FLUSH);
 139
 140     if (deflateInit(&zs, 0) != Z_OK)
 141         return -1;
 142     zs.next_in   = s->tmpblock;
 143     zs.avail_in  = s->block_size * 3 - s->zstream.avail_out;
 144     zs.next_out  = s->deflate_block;
 145     zs.avail_out = s->deflate_block_size;
 146     deflate(&zs, Z_SYNC_FLUSH);
 147     deflateEnd(&zs);
 148
 149     if ((zret = inflateReset(&s->zstream)) != Z_OK) {
 150         av_log(s->avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);
 151         return AVERROR_UNKNOWN;
 152     }
 153
 154     s->zstream.next_in   = s->deflate_block;
 155     s->zstream.avail_in  = s->deflate_block_size - zs.avail_out;
 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     return 0;
 161 }
 162
 163 static int flashsv_decode_block(AVCodecContext *avctx, AVPacket *avpkt,
 164                                 GetBitContext *gb, int block_size,
 165                                 int width, int height, int x_pos, int y_pos,
 166                                 int blk_idx)
 167 {
 168     struct FlashSVContext *s = avctx->priv_data;
 169     uint8_t *line = s->tmpblock;
 170     int k;
 171     int ret = inflateReset(&s->zstream);
 172     if (ret != Z_OK) {
 173         av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", ret);
 174         return AVERROR_UNKNOWN;
 175     }
 176     if (s->zlibprime_curr || s->zlibprime_prev) {
 177         ret = flashsv2_prime(s,
 178                              s->blocks[blk_idx].pos,
 179                              s->blocks[blk_idx].size);
 180         if (ret < 0)
 181             return ret;
 182     }
 183     s->zstream.next_in   = avpkt->data + get_bits_count(gb) / 8;
 184     s->zstream.avail_in  = block_size;
 185     s->zstream.next_out  = s->tmpblock;
 186     s->zstream.avail_out = s->block_size * 3;
 187     ret = inflate(&s->zstream, Z_FINISH);
 188     if (ret == Z_DATA_ERROR) {
 189         av_log(avctx, AV_LOG_ERROR, "Zlib resync occurred\n");
 190         inflateSync(&s->zstream);
 191         ret = inflate(&s->zstream, Z_FINISH);
 192     }
 193
 194     if (ret != Z_OK && ret != Z_STREAM_END) {
 195         //return -1;
 196     }
 197
 198     if (s->is_keyframe) {
 199         s->blocks[blk_idx].pos  = s->keyframedata + (get_bits_count(gb) / 8);
 200         s->blocks[blk_idx].size = block_size;
 201     }
 202
 203     y_pos += s->diff_start;
 204
 205     if (!s->color_depth) {
 206         /* Flash Screen Video stores the image upside down, so copy
 207          * lines to destination in reverse order. */
 208         for (k = 1; k <= s->diff_height; k++) {
 209             memcpy(s->frame.data[0] + x_pos * 3 +
 210                    (s->image_height - y_pos - k) * s->frame.linesize[0],
 211                    line, width * 3);
 212             /* advance source pointer to next line */
 213             line += width * 3;
 214         }
 215     } else {
 216         /* hybrid 15-bit/palette mode */
 217         decode_hybrid(s->tmpblock, s->frame.data[0],
 218                       s->image_height - (y_pos + 1 + s->diff_height),
 219                       x_pos, s->diff_height, width,
 220                       s->frame.linesize[0], s->pal);
 221     }
 222     skip_bits_long(gb, 8 * block_size); /* skip the consumed bits */
 223     return 0;
 224 }
 225
 226 static int calc_deflate_block_size(int tmpblock_size)
 227 {
 228     z_stream zstream;
 229     int size;
 230
 231     zstream.zalloc = Z_NULL;
 232     zstream.zfree  = Z_NULL;
 233     zstream.opaque = Z_NULL;
 234     if (deflateInit(&zstream, 0) != Z_OK)
 235         return -1;
 236     size = deflateBound(&zstream, tmpblock_size);
 237     deflateEnd(&zstream);
 238
 239     return size;
 240 }
 241
 242 static int flashsv_decode_frame(AVCodecContext *avctx, void *data,
 243                                 int *got_frame, AVPacket *avpkt)
 244 {
 245     int buf_size = avpkt->size;
 246     FlashSVContext *s = avctx->priv_data;
 247     int h_blocks, v_blocks, h_part, v_part, i, j, ret;
 248     GetBitContext gb;
 249     int last_blockwidth = s->block_width;
 250     int last_blockheight= s->block_height;
 251
 252     /* no supplementary picture */
 253     if (buf_size == 0)
 254         return 0;
 255     if (buf_size < 4)
 256         return -1;
 257
 258     if ((ret = init_get_bits8(&gb, avpkt->data, buf_size)) < 0)
 259         return ret;
 260
 261     /* start to parse the bitstream */
 262     s->block_width  = 16 * (get_bits(&gb, 4) + 1);
 263     s->image_width  = get_bits(&gb, 12);
 264     s->block_height = 16 * (get_bits(&gb, 4) + 1);
 265     s->image_height = get_bits(&gb, 12);
 266
 267     if (   last_blockwidth != s->block_width
 268         || last_blockheight!= s->block_height)
 269         av_freep(&s->blocks);
 270
 271     if (s->ver == 2) {
 272         skip_bits(&gb, 6);
 273         if (get_bits1(&gb)) {
 274             avpriv_request_sample(avctx, "iframe");
 275             return AVERROR_PATCHWELCOME;
 276         }
 277         if (get_bits1(&gb)) {
 278             avpriv_request_sample(avctx, "Custom palette");
 279             return AVERROR_PATCHWELCOME;
 280         }
 281     }
 282
 283     /* calculate number of blocks and size of border (partial) blocks */
 284     h_blocks = s->image_width  / s->block_width;
 285     h_part   = s->image_width  % s->block_width;
 286     v_blocks = s->image_height / s->block_height;
 287     v_part   = s->image_height % s->block_height;
 288
 289     /* the block size could change between frames, make sure the buffer
 290      * is large enough, if not, get a larger one */
 291     if (s->block_size < s->block_width * s->block_height) {
 292         int tmpblock_size = 3 * s->block_width * s->block_height;
 293
 294         s->tmpblock = av_realloc(s->tmpblock, tmpblock_size);
 295         if (!s->tmpblock) {
 296             av_log(avctx, AV_LOG_ERROR,
 297                    "Cannot allocate decompression buffer.\n");
 298             return AVERROR(ENOMEM);
 299         }
 300         if (s->ver == 2) {
 301             s->deflate_block_size = calc_deflate_block_size(tmpblock_size);
 302             if (s->deflate_block_size <= 0) {
 303                 av_log(avctx, AV_LOG_ERROR,
 304                        "Cannot determine deflate buffer size.\n");
 305                 return -1;
 306             }
 307             s->deflate_block = av_realloc(s->deflate_block,
 308                                           s->deflate_block_size);
 309             if (!s->deflate_block) {
 310                 av_log(avctx, AV_LOG_ERROR,
 311                        "Cannot allocate deflate buffer.\n");
 312                 return AVERROR(ENOMEM);
 313             }
 314         }
 315     }
 316     s->block_size = s->block_width * s->block_height;
 317
 318     /* initialize the image size once */
 319     if (avctx->width == 0 && avctx->height == 0) {
 320         if ((ret = ff_set_dimensions(avctx, s->image_width, s->image_height)) < 0)
 321             return ret;
 322     }
 323
 324     /* check for changes of image width and image height */
 325     if (avctx->width != s->image_width || avctx->height != s->image_height) {
 326         av_log(avctx, AV_LOG_ERROR,
 327                "Frame width or height differs from first frame!\n");
 328         av_log(avctx, AV_LOG_ERROR, "fh = %d, fv %d  vs  ch = %d, cv = %d\n",
 329                avctx->height, avctx->width, s->image_height, s->image_width);
 330         return AVERROR_INVALIDDATA;
 331     }
 332
 333     /* we care for keyframes only in Screen Video v2 */
 334     s->is_keyframe = (avpkt->flags & AV_PKT_FLAG_KEY) && (s->ver == 2);
 335     if (s->is_keyframe) {
 336         s->keyframedata = av_realloc(s->keyframedata, avpkt->size);
 337         memcpy(s->keyframedata, avpkt->data, avpkt->size);
 338     }
 339     if(s->ver == 2 && !s->blocks)
 340         s->blocks = av_mallocz((v_blocks + !!v_part) * (h_blocks + !!h_part) *
 341                                sizeof(s->blocks[0]));
 342
 343     av_dlog(avctx, "image: %dx%d block: %dx%d num: %dx%d part: %dx%d\n",
 344             s->image_width, s->image_height, s->block_width, s->block_height,
 345             h_blocks, v_blocks, h_part, v_part);
 346
 347     if ((ret = ff_reget_buffer(avctx, &s->frame)) < 0)
 348         return ret;
 349
 350     /* loop over all block columns */
 351     for (j = 0; j < v_blocks + (v_part ? 1 : 0); j++) {
 352
 353         int y_pos  = j * s->block_height; // vertical position in frame
 354         int cur_blk_height = (j < v_blocks) ? s->block_height : v_part;
 355
 356         /* loop over all block rows */
 357         for (i = 0; i < h_blocks + (h_part ? 1 : 0); i++) {
 358             int x_pos = i * s->block_width; // horizontal position in frame
 359             int cur_blk_width = (i < h_blocks) ? s->block_width : h_part;
 360             int has_diff = 0;
 361
 362             /* get the size of the compressed zlib chunk */
 363             int size = get_bits(&gb, 16);
 364
 365             s->color_depth    = 0;
 366             s->zlibprime_curr = 0;
 367             s->zlibprime_prev = 0;
 368             s->diff_start     = 0;
 369             s->diff_height    = cur_blk_height;
 370
 371             if (8 * size > get_bits_left(&gb)) {
 372                 av_frame_unref(&s->frame);
 373                 return AVERROR_INVALIDDATA;
 374             }
 375
 376             if (s->ver == 2 && size) {
 377                 skip_bits(&gb, 3);
 378                 s->color_depth    = get_bits(&gb, 2);
 379                 has_diff          = get_bits1(&gb);
 380                 s->zlibprime_curr = get_bits1(&gb);
 381                 s->zlibprime_prev = get_bits1(&gb);
 382
 383                 if (s->color_depth != 0 && s->color_depth != 2) {
 384                     av_log(avctx, AV_LOG_ERROR,
 385                            "%dx%d invalid color depth %d\n",
 386                            i, j, s->color_depth);
 387                     return AVERROR_INVALIDDATA;
 388                 }
 389
 390                 if (has_diff) {
 391                     if (!s->keyframe) {
 392                         av_log(avctx, AV_LOG_ERROR,
 393                                "Inter frame without keyframe\n");
 394                         return AVERROR_INVALIDDATA;
 395                     }
 396                     s->diff_start  = get_bits(&gb, 8);
 397                     s->diff_height = get_bits(&gb, 8);
 398                     if (s->diff_start + s->diff_height > cur_blk_height) {
 399                         av_log(avctx, AV_LOG_ERROR,
 400                                "Block parameters invalid: %d + %d > %d\n",
 401                                s->diff_start, s->diff_height, cur_blk_height);
 402                         return AVERROR_INVALIDDATA;
 403                     }
 404                     av_log(avctx, AV_LOG_DEBUG,
 405                            "%dx%d diff start %d height %d\n",
 406                            i, j, s->diff_start, s->diff_height);
 407                     size -= 2;
 408                 }
 409
 410                 if (s->zlibprime_prev)
 411                     av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_prev\n", i, j);
 412
 413                 if (s->zlibprime_curr) {
 414                     int col = get_bits(&gb, 8);
 415                     int row = get_bits(&gb, 8);
 416                     av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_curr %dx%d\n",
 417                            i, j, col, row);
 418                     size -= 2;
 419                     avpriv_request_sample(avctx, "zlibprime_curr");
 420                     return AVERROR_PATCHWELCOME;
 421                 }
 422                 if (!s->blocks && (s->zlibprime_curr || s->zlibprime_prev)) {
 423                     av_log(avctx, AV_LOG_ERROR,
 424                            "no data available for zlib priming\n");
 425                     return AVERROR_INVALIDDATA;
 426                 }
 427                 size--; // account for flags byte
 428             }
 429
 430             if (has_diff) {
 431                 int k;
 432                 int off = (s->image_height - y_pos - 1) * s->frame.linesize[0];
 433
 434                 for (k = 0; k < cur_blk_height; k++) {
 435                     int x = off - k * s->frame.linesize[0] + x_pos * 3;
 436                     memcpy(s->frame.data[0] + x, s->keyframe + x,
 437                            cur_blk_width * 3);
 438                 }
 439             }
 440
 441             /* skip unchanged blocks, which have size 0 */
 442             if (size) {
 443                 if (flashsv_decode_block(avctx, avpkt, &gb, size,
 444                                          cur_blk_width, cur_blk_height,
 445                                          x_pos, y_pos,
 446                                          i + j * (h_blocks + !!h_part)))
 447                     av_log(avctx, AV_LOG_ERROR,
 448                            "error in decompression of block %dx%d\n", i, j);
 449             }
 450         }
 451     }
 452     if (s->is_keyframe && s->ver == 2) {
 453         if (!s->keyframe) {
 454             s->keyframe = av_malloc(s->frame.linesize[0] * avctx->height);
 455             if (!s->keyframe) {
 456                 av_log(avctx, AV_LOG_ERROR, "Cannot allocate image data\n");
 457                 return AVERROR(ENOMEM);
 458             }
 459         }
 460         memcpy(s->keyframe, s->frame.data[0],
 461                s->frame.linesize[0] * avctx->height);
 462     }
 463
 464     if ((ret = av_frame_ref(data, &s->frame)) < 0)
 465         return ret;
 466
 467     *got_frame = 1;
 468
 469     if ((get_bits_count(&gb) / 8) != buf_size)
 470         av_log(avctx, AV_LOG_ERROR, "buffer not fully consumed (%d != %d)\n",
 471                buf_size, (get_bits_count(&gb) / 8));
 472
 473     /* report that the buffer was completely consumed */
 474     return buf_size;
 475 }
 476
 477 static av_cold int flashsv_decode_end(AVCodecContext *avctx)
 478 {
 479     FlashSVContext *s = avctx->priv_data;
 480     inflateEnd(&s->zstream);
 481     /* release the frame if needed */
 482     av_frame_unref(&s->frame);
 483
 484     /* free the tmpblock */
 485     av_freep(&s->tmpblock);
 486
 487     return 0;
 488 }
 489
 490 #if CONFIG_FLASHSV_DECODER
 491 AVCodec ff_flashsv_decoder = {
 492     .name           = "flashsv",
 493     .long_name      = NULL_IF_CONFIG_SMALL("Flash Screen Video v1"),
 494     .type           = AVMEDIA_TYPE_VIDEO,
 495     .id             = AV_CODEC_ID_FLASHSV,
 496     .priv_data_size = sizeof(FlashSVContext),
 497     .init           = flashsv_decode_init,
 498     .close          = flashsv_decode_end,
 499     .decode         = flashsv_decode_frame,
 500     .capabilities   = CODEC_CAP_DR1,
 501     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE },
 502 };
 503 #endif /* CONFIG_FLASHSV_DECODER */
 504
 505 #if CONFIG_FLASHSV2_DECODER
 506 static const uint32_t ff_flashsv2_default_palette[128] = {
 507     0x000000, 0x333333, 0x666666, 0x999999, 0xCCCCCC, 0xFFFFFF,
 508     0x330000, 0x660000, 0x990000, 0xCC0000, 0xFF0000, 0x003300,
 509     0x006600, 0x009900, 0x00CC00, 0x00FF00, 0x000033, 0x000066,
 510     0x000099, 0x0000CC, 0x0000FF, 0x333300, 0x666600, 0x999900,
 511     0xCCCC00, 0xFFFF00, 0x003333, 0x006666, 0x009999, 0x00CCCC,
 512     0x00FFFF, 0x330033, 0x660066, 0x990099, 0xCC00CC, 0xFF00FF,
 513     0xFFFF33, 0xFFFF66, 0xFFFF99, 0xFFFFCC, 0xFF33FF, 0xFF66FF,
 514     0xFF99FF, 0xFFCCFF, 0x33FFFF, 0x66FFFF, 0x99FFFF, 0xCCFFFF,
 515     0xCCCC33, 0xCCCC66, 0xCCCC99, 0xCCCCFF, 0xCC33CC, 0xCC66CC,
 516     0xCC99CC, 0xCCFFCC, 0x33CCCC, 0x66CCCC, 0x99CCCC, 0xFFCCCC,
 517     0x999933, 0x999966, 0x9999CC, 0x9999FF, 0x993399, 0x996699,
 518     0x99CC99, 0x99FF99, 0x339999, 0x669999, 0xCC9999, 0xFF9999,
 519     0x666633, 0x666699, 0x6666CC, 0x6666FF, 0x663366, 0x669966,
 520     0x66CC66, 0x66FF66, 0x336666, 0x996666, 0xCC6666, 0xFF6666,
 521     0x333366, 0x333399, 0x3333CC, 0x3333FF, 0x336633, 0x339933,
 522     0x33CC33, 0x33FF33, 0x663333, 0x993333, 0xCC3333, 0xFF3333,
 523     0x003366, 0x336600, 0x660033, 0x006633, 0x330066, 0x663300,
 524     0x336699, 0x669933, 0x993366, 0x339966, 0x663399, 0x996633,
 525     0x6699CC, 0x99CC66, 0xCC6699, 0x66CC99, 0x9966CC, 0xCC9966,
 526     0x99CCFF, 0xCCFF99, 0xFF99CC, 0x99FFCC, 0xCC99FF, 0xFFCC99,
 527     0x111111, 0x222222, 0x444444, 0x555555, 0xAAAAAA, 0xBBBBBB,
 528     0xDDDDDD, 0xEEEEEE
 529 };
 530
 531 static av_cold int flashsv2_decode_init(AVCodecContext *avctx)
 532 {
 533     FlashSVContext *s = avctx->priv_data;
 534     flashsv_decode_init(avctx);
 535     s->pal = ff_flashsv2_default_palette;
 536     s->ver = 2;
 537
 538     return 0;
 539 }
 540
 541 static av_cold int flashsv2_decode_end(AVCodecContext *avctx)
 542 {
 543     FlashSVContext *s = avctx->priv_data;
 544
 545     av_freep(&s->keyframedata);
 546     av_freep(&s->blocks);
 547     av_freep(&s->keyframe);
 548     av_freep(&s->deflate_block);
 549     flashsv_decode_end(avctx);
 550
 551     return 0;
 552 }
 553
 554 AVCodec ff_flashsv2_decoder = {
 555     .name           = "flashsv2",
 556     .long_name      = NULL_IF_CONFIG_SMALL("Flash Screen Video v2"),
 557     .type           = AVMEDIA_TYPE_VIDEO,
 558     .id             = AV_CODEC_ID_FLASHSV2,
 559     .priv_data_size = sizeof(FlashSVContext),
 560     .init           = flashsv2_decode_init,
 561     .close          = flashsv2_decode_end,
 562     .decode         = flashsv_decode_frame,
 563     .capabilities   = CODEC_CAP_DR1,
 564     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE },
 565 };
 566 #endif /* CONFIG_FLASHSV2_DECODER */