blob: 90e1d43cdad6c02a4b56a60341634af370827da7
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 | flashsv_decode_end(avctx); |
136 | return AVERROR(ENOMEM); |
137 | } |
138 | |
139 | return 0; |
140 | } |
141 | |
142 | static int flashsv2_prime(FlashSVContext *s, uint8_t *src, int size) |
143 | { |
144 | z_stream zs; |
145 | int zret; // Zlib return code |
146 | |
147 | if (!src) |
148 | return AVERROR_INVALIDDATA; |
149 | |
150 | zs.zalloc = NULL; |
151 | zs.zfree = NULL; |
152 | zs.opaque = NULL; |
153 | |
154 | s->zstream.next_in = src; |
155 | s->zstream.avail_in = size; |
156 | s->zstream.next_out = s->tmpblock; |
157 | s->zstream.avail_out = s->block_size * 3; |
158 | inflate(&s->zstream, Z_SYNC_FLUSH); |
159 | |
160 | if (deflateInit(&zs, 0) != Z_OK) |
161 | return -1; |
162 | zs.next_in = s->tmpblock; |
163 | zs.avail_in = s->block_size * 3 - s->zstream.avail_out; |
164 | zs.next_out = s->deflate_block; |
165 | zs.avail_out = s->deflate_block_size; |
166 | deflate(&zs, Z_SYNC_FLUSH); |
167 | deflateEnd(&zs); |
168 | |
169 | if ((zret = inflateReset(&s->zstream)) != Z_OK) { |
170 | av_log(s->avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret); |
171 | return AVERROR_UNKNOWN; |
172 | } |
173 | |
174 | s->zstream.next_in = s->deflate_block; |
175 | s->zstream.avail_in = s->deflate_block_size - zs.avail_out; |
176 | s->zstream.next_out = s->tmpblock; |
177 | s->zstream.avail_out = s->block_size * 3; |
178 | inflate(&s->zstream, Z_SYNC_FLUSH); |
179 | |
180 | return 0; |
181 | } |
182 | |
183 | static int flashsv_decode_block(AVCodecContext *avctx, AVPacket *avpkt, |
184 | GetBitContext *gb, int block_size, |
185 | int width, int height, int x_pos, int y_pos, |
186 | int blk_idx) |
187 | { |
188 | struct FlashSVContext *s = avctx->priv_data; |
189 | uint8_t *line = s->tmpblock; |
190 | int k; |
191 | int ret = inflateReset(&s->zstream); |
192 | if (ret != Z_OK) { |
193 | av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", ret); |
194 | return AVERROR_UNKNOWN; |
195 | } |
196 | if (s->zlibprime_curr || s->zlibprime_prev) { |
197 | ret = flashsv2_prime(s, |
198 | s->blocks[blk_idx].pos, |
199 | s->blocks[blk_idx].size); |
200 | if (ret < 0) |
201 | return ret; |
202 | } |
203 | s->zstream.next_in = avpkt->data + get_bits_count(gb) / 8; |
204 | s->zstream.avail_in = block_size; |
205 | s->zstream.next_out = s->tmpblock; |
206 | s->zstream.avail_out = s->block_size * 3; |
207 | ret = inflate(&s->zstream, Z_FINISH); |
208 | if (ret == Z_DATA_ERROR) { |
209 | av_log(avctx, AV_LOG_ERROR, "Zlib resync occurred\n"); |
210 | inflateSync(&s->zstream); |
211 | ret = inflate(&s->zstream, Z_FINISH); |
212 | } |
213 | |
214 | if (ret != Z_OK && ret != Z_STREAM_END) { |
215 | //return -1; |
216 | } |
217 | |
218 | if (s->is_keyframe) { |
219 | s->blocks[blk_idx].pos = s->keyframedata + (get_bits_count(gb) / 8); |
220 | s->blocks[blk_idx].size = block_size; |
221 | } |
222 | |
223 | y_pos += s->diff_start; |
224 | |
225 | if (!s->color_depth) { |
226 | /* Flash Screen Video stores the image upside down, so copy |
227 | * lines to destination in reverse order. */ |
228 | for (k = 1; k <= s->diff_height; k++) { |
229 | memcpy(s->frame->data[0] + x_pos * 3 + |
230 | (s->image_height - y_pos - k) * s->frame->linesize[0], |
231 | line, width * 3); |
232 | /* advance source pointer to next line */ |
233 | line += width * 3; |
234 | } |
235 | } else { |
236 | /* hybrid 15-bit/palette mode */ |
237 | ret = decode_hybrid(s->tmpblock, s->zstream.next_out, |
238 | s->frame->data[0], |
239 | s->image_height - (y_pos + 1 + s->diff_height), |
240 | x_pos, s->diff_height, width, |
241 | s->frame->linesize[0], s->pal); |
242 | if (ret < 0) { |
243 | av_log(avctx, AV_LOG_ERROR, "decode_hybrid failed\n"); |
244 | return ret; |
245 | } |
246 | } |
247 | skip_bits_long(gb, 8 * block_size); /* skip the consumed bits */ |
248 | return 0; |
249 | } |
250 | |
251 | static int calc_deflate_block_size(int tmpblock_size) |
252 | { |
253 | z_stream zstream; |
254 | int size; |
255 | |
256 | zstream.zalloc = Z_NULL; |
257 | zstream.zfree = Z_NULL; |
258 | zstream.opaque = Z_NULL; |
259 | if (deflateInit(&zstream, 0) != Z_OK) |
260 | return -1; |
261 | size = deflateBound(&zstream, tmpblock_size); |
262 | deflateEnd(&zstream); |
263 | |
264 | return size; |
265 | } |
266 | |
267 | static int flashsv_decode_frame(AVCodecContext *avctx, void *data, |
268 | int *got_frame, AVPacket *avpkt) |
269 | { |
270 | int buf_size = avpkt->size; |
271 | FlashSVContext *s = avctx->priv_data; |
272 | int h_blocks, v_blocks, h_part, v_part, i, j, ret; |
273 | GetBitContext gb; |
274 | int last_blockwidth = s->block_width; |
275 | int last_blockheight= s->block_height; |
276 | |
277 | /* no supplementary picture */ |
278 | if (buf_size == 0) |
279 | return 0; |
280 | if (buf_size < 4) |
281 | return -1; |
282 | |
283 | if ((ret = init_get_bits8(&gb, avpkt->data, buf_size)) < 0) |
284 | return ret; |
285 | |
286 | /* start to parse the bitstream */ |
287 | s->block_width = 16 * (get_bits(&gb, 4) + 1); |
288 | s->image_width = get_bits(&gb, 12); |
289 | s->block_height = 16 * (get_bits(&gb, 4) + 1); |
290 | s->image_height = get_bits(&gb, 12); |
291 | |
292 | if ( last_blockwidth != s->block_width |
293 | || last_blockheight!= s->block_height) |
294 | av_freep(&s->blocks); |
295 | |
296 | if (s->ver == 2) { |
297 | skip_bits(&gb, 6); |
298 | if (get_bits1(&gb)) { |
299 | avpriv_request_sample(avctx, "iframe"); |
300 | return AVERROR_PATCHWELCOME; |
301 | } |
302 | if (get_bits1(&gb)) { |
303 | avpriv_request_sample(avctx, "Custom palette"); |
304 | return AVERROR_PATCHWELCOME; |
305 | } |
306 | } |
307 | |
308 | /* calculate number of blocks and size of border (partial) blocks */ |
309 | h_blocks = s->image_width / s->block_width; |
310 | h_part = s->image_width % s->block_width; |
311 | v_blocks = s->image_height / s->block_height; |
312 | v_part = s->image_height % s->block_height; |
313 | |
314 | /* the block size could change between frames, make sure the buffer |
315 | * is large enough, if not, get a larger one */ |
316 | if (s->block_size < s->block_width * s->block_height) { |
317 | int tmpblock_size = 3 * s->block_width * s->block_height, err; |
318 | |
319 | if ((err = av_reallocp(&s->tmpblock, tmpblock_size)) < 0) { |
320 | s->block_size = 0; |
321 | av_log(avctx, AV_LOG_ERROR, |
322 | "Cannot allocate decompression buffer.\n"); |
323 | return err; |
324 | } |
325 | if (s->ver == 2) { |
326 | s->deflate_block_size = calc_deflate_block_size(tmpblock_size); |
327 | if (s->deflate_block_size <= 0) { |
328 | av_log(avctx, AV_LOG_ERROR, |
329 | "Cannot determine deflate buffer size.\n"); |
330 | return -1; |
331 | } |
332 | if ((err = av_reallocp(&s->deflate_block, s->deflate_block_size)) < 0) { |
333 | s->block_size = 0; |
334 | av_log(avctx, AV_LOG_ERROR, "Cannot allocate deflate buffer.\n"); |
335 | return err; |
336 | } |
337 | } |
338 | } |
339 | s->block_size = s->block_width * s->block_height; |
340 | |
341 | /* initialize the image size once */ |
342 | if (avctx->width == 0 && avctx->height == 0) { |
343 | if ((ret = ff_set_dimensions(avctx, s->image_width, s->image_height)) < 0) |
344 | return ret; |
345 | } |
346 | |
347 | /* check for changes of image width and image height */ |
348 | if (avctx->width != s->image_width || avctx->height != s->image_height) { |
349 | av_log(avctx, AV_LOG_ERROR, |
350 | "Frame width or height differs from first frame!\n"); |
351 | av_log(avctx, AV_LOG_ERROR, "fh = %d, fv %d vs ch = %d, cv = %d\n", |
352 | avctx->height, avctx->width, s->image_height, s->image_width); |
353 | return AVERROR_INVALIDDATA; |
354 | } |
355 | |
356 | /* we care for keyframes only in Screen Video v2 */ |
357 | s->is_keyframe = (avpkt->flags & AV_PKT_FLAG_KEY) && (s->ver == 2); |
358 | if (s->is_keyframe) { |
359 | int err; |
360 | if ((err = av_reallocp(&s->keyframedata, avpkt->size)) < 0) |
361 | return err; |
362 | memcpy(s->keyframedata, avpkt->data, avpkt->size); |
363 | } |
364 | if(s->ver == 2 && !s->blocks) |
365 | s->blocks = av_mallocz((v_blocks + !!v_part) * (h_blocks + !!h_part) * |
366 | sizeof(s->blocks[0])); |
367 | |
368 | ff_dlog(avctx, "image: %dx%d block: %dx%d num: %dx%d part: %dx%d\n", |
369 | s->image_width, s->image_height, s->block_width, s->block_height, |
370 | h_blocks, v_blocks, h_part, v_part); |
371 | |
372 | if ((ret = ff_reget_buffer(avctx, s->frame)) < 0) |
373 | return ret; |
374 | |
375 | /* loop over all block columns */ |
376 | for (j = 0; j < v_blocks + (v_part ? 1 : 0); j++) { |
377 | |
378 | int y_pos = j * s->block_height; // vertical position in frame |
379 | int cur_blk_height = (j < v_blocks) ? s->block_height : v_part; |
380 | |
381 | /* loop over all block rows */ |
382 | for (i = 0; i < h_blocks + (h_part ? 1 : 0); i++) { |
383 | int x_pos = i * s->block_width; // horizontal position in frame |
384 | int cur_blk_width = (i < h_blocks) ? s->block_width : h_part; |
385 | int has_diff = 0; |
386 | |
387 | /* get the size of the compressed zlib chunk */ |
388 | int size = get_bits(&gb, 16); |
389 | |
390 | s->color_depth = 0; |
391 | s->zlibprime_curr = 0; |
392 | s->zlibprime_prev = 0; |
393 | s->diff_start = 0; |
394 | s->diff_height = cur_blk_height; |
395 | |
396 | if (8 * size > get_bits_left(&gb)) { |
397 | av_frame_unref(s->frame); |
398 | return AVERROR_INVALIDDATA; |
399 | } |
400 | |
401 | if (s->ver == 2 && size) { |
402 | skip_bits(&gb, 3); |
403 | s->color_depth = get_bits(&gb, 2); |
404 | has_diff = get_bits1(&gb); |
405 | s->zlibprime_curr = get_bits1(&gb); |
406 | s->zlibprime_prev = get_bits1(&gb); |
407 | |
408 | if (s->color_depth != 0 && s->color_depth != 2) { |
409 | av_log(avctx, AV_LOG_ERROR, |
410 | "%dx%d invalid color depth %d\n", |
411 | i, j, s->color_depth); |
412 | return AVERROR_INVALIDDATA; |
413 | } |
414 | |
415 | if (has_diff) { |
416 | if (size < 3) { |
417 | av_log(avctx, AV_LOG_ERROR, "size too small for diff\n"); |
418 | return AVERROR_INVALIDDATA; |
419 | } |
420 | if (!s->keyframe) { |
421 | av_log(avctx, AV_LOG_ERROR, |
422 | "Inter frame without keyframe\n"); |
423 | return AVERROR_INVALIDDATA; |
424 | } |
425 | s->diff_start = get_bits(&gb, 8); |
426 | s->diff_height = get_bits(&gb, 8); |
427 | if (s->diff_start + s->diff_height > cur_blk_height) { |
428 | av_log(avctx, AV_LOG_ERROR, |
429 | "Block parameters invalid: %d + %d > %d\n", |
430 | s->diff_start, s->diff_height, cur_blk_height); |
431 | return AVERROR_INVALIDDATA; |
432 | } |
433 | av_log(avctx, AV_LOG_DEBUG, |
434 | "%dx%d diff start %d height %d\n", |
435 | i, j, s->diff_start, s->diff_height); |
436 | size -= 2; |
437 | } |
438 | |
439 | if (s->zlibprime_prev) |
440 | av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_prev\n", i, j); |
441 | |
442 | if (s->zlibprime_curr) { |
443 | int col = get_bits(&gb, 8); |
444 | int row = get_bits(&gb, 8); |
445 | av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_curr %dx%d\n", |
446 | i, j, col, row); |
447 | if (size < 3) { |
448 | av_log(avctx, AV_LOG_ERROR, "size too small for zlibprime_curr\n"); |
449 | return AVERROR_INVALIDDATA; |
450 | } |
451 | size -= 2; |
452 | avpriv_request_sample(avctx, "zlibprime_curr"); |
453 | return AVERROR_PATCHWELCOME; |
454 | } |
455 | if (!s->blocks && (s->zlibprime_curr || s->zlibprime_prev)) { |
456 | av_log(avctx, AV_LOG_ERROR, |
457 | "no data available for zlib priming\n"); |
458 | return AVERROR_INVALIDDATA; |
459 | } |
460 | size--; // account for flags byte |
461 | } |
462 | |
463 | if (has_diff) { |
464 | int k; |
465 | int off = (s->image_height - y_pos - 1) * s->frame->linesize[0]; |
466 | |
467 | for (k = 0; k < cur_blk_height; k++) { |
468 | int x = off - k * s->frame->linesize[0] + x_pos * 3; |
469 | memcpy(s->frame->data[0] + x, s->keyframe + x, |
470 | cur_blk_width * 3); |
471 | } |
472 | } |
473 | |
474 | /* skip unchanged blocks, which have size 0 */ |
475 | if (size) { |
476 | if (flashsv_decode_block(avctx, avpkt, &gb, size, |
477 | cur_blk_width, cur_blk_height, |
478 | x_pos, y_pos, |
479 | i + j * (h_blocks + !!h_part))) |
480 | av_log(avctx, AV_LOG_ERROR, |
481 | "error in decompression of block %dx%d\n", i, j); |
482 | } |
483 | } |
484 | } |
485 | if (s->is_keyframe && s->ver == 2) { |
486 | if (!s->keyframe) { |
487 | s->keyframe = av_malloc(s->frame->linesize[0] * avctx->height); |
488 | if (!s->keyframe) { |
489 | av_log(avctx, AV_LOG_ERROR, "Cannot allocate image data\n"); |
490 | return AVERROR(ENOMEM); |
491 | } |
492 | } |
493 | memcpy(s->keyframe, s->frame->data[0], |
494 | s->frame->linesize[0] * avctx->height); |
495 | } |
496 | |
497 | if ((ret = av_frame_ref(data, s->frame)) < 0) |
498 | return ret; |
499 | |
500 | *got_frame = 1; |
501 | |
502 | if ((get_bits_count(&gb) / 8) != buf_size) |
503 | av_log(avctx, AV_LOG_ERROR, "buffer not fully consumed (%d != %d)\n", |
504 | buf_size, (get_bits_count(&gb) / 8)); |
505 | |
506 | /* report that the buffer was completely consumed */ |
507 | return buf_size; |
508 | } |
509 | |
510 | #if CONFIG_FLASHSV_DECODER |
511 | AVCodec ff_flashsv_decoder = { |
512 | .name = "flashsv", |
513 | .long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video v1"), |
514 | .type = AVMEDIA_TYPE_VIDEO, |
515 | .id = AV_CODEC_ID_FLASHSV, |
516 | .priv_data_size = sizeof(FlashSVContext), |
517 | .init = flashsv_decode_init, |
518 | .close = flashsv_decode_end, |
519 | .decode = flashsv_decode_frame, |
520 | .capabilities = AV_CODEC_CAP_DR1, |
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 | flashsv_decode_init(avctx); |
555 | s->pal = ff_flashsv2_default_palette; |
556 | s->ver = 2; |
557 | |
558 | return 0; |
559 | } |
560 | |
561 | static av_cold int flashsv2_decode_end(AVCodecContext *avctx) |
562 | { |
563 | FlashSVContext *s = avctx->priv_data; |
564 | |
565 | av_freep(&s->keyframedata); |
566 | av_freep(&s->blocks); |
567 | av_freep(&s->keyframe); |
568 | av_freep(&s->deflate_block); |
569 | flashsv_decode_end(avctx); |
570 | |
571 | return 0; |
572 | } |
573 | |
574 | AVCodec ff_flashsv2_decoder = { |
575 | .name = "flashsv2", |
576 | .long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video v2"), |
577 | .type = AVMEDIA_TYPE_VIDEO, |
578 | .id = AV_CODEC_ID_FLASHSV2, |
579 | .priv_data_size = sizeof(FlashSVContext), |
580 | .init = flashsv2_decode_init, |
581 | .close = flashsv2_decode_end, |
582 | .decode = flashsv_decode_frame, |
583 | .capabilities = AV_CODEC_CAP_DR1, |
584 | .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE }, |
585 | }; |
586 | #endif /* CONFIG_FLASHSV2_DECODER */ |
587 |