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