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