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