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