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