Commit | Line | Data |
---|---|---|
2ba45a60 DM |
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 | av_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 (!s->keyframe) { | |
417 | av_log(avctx, AV_LOG_ERROR, | |
418 | "Inter frame without keyframe\n"); | |
419 | return AVERROR_INVALIDDATA; | |
420 | } | |
421 | s->diff_start = get_bits(&gb, 8); | |
422 | s->diff_height = get_bits(&gb, 8); | |
423 | if (s->diff_start + s->diff_height > cur_blk_height) { | |
424 | av_log(avctx, AV_LOG_ERROR, | |
425 | "Block parameters invalid: %d + %d > %d\n", | |
426 | s->diff_start, s->diff_height, cur_blk_height); | |
427 | return AVERROR_INVALIDDATA; | |
428 | } | |
429 | av_log(avctx, AV_LOG_DEBUG, | |
430 | "%dx%d diff start %d height %d\n", | |
431 | i, j, s->diff_start, s->diff_height); | |
432 | size -= 2; | |
433 | } | |
434 | ||
435 | if (s->zlibprime_prev) | |
436 | av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_prev\n", i, j); | |
437 | ||
438 | if (s->zlibprime_curr) { | |
439 | int col = get_bits(&gb, 8); | |
440 | int row = get_bits(&gb, 8); | |
441 | av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_curr %dx%d\n", | |
442 | i, j, col, row); | |
443 | size -= 2; | |
444 | avpriv_request_sample(avctx, "zlibprime_curr"); | |
445 | return AVERROR_PATCHWELCOME; | |
446 | } | |
447 | if (!s->blocks && (s->zlibprime_curr || s->zlibprime_prev)) { | |
448 | av_log(avctx, AV_LOG_ERROR, | |
449 | "no data available for zlib priming\n"); | |
450 | return AVERROR_INVALIDDATA; | |
451 | } | |
452 | size--; // account for flags byte | |
453 | } | |
454 | ||
455 | if (has_diff) { | |
456 | int k; | |
457 | int off = (s->image_height - y_pos - 1) * s->frame->linesize[0]; | |
458 | ||
459 | for (k = 0; k < cur_blk_height; k++) { | |
460 | int x = off - k * s->frame->linesize[0] + x_pos * 3; | |
461 | memcpy(s->frame->data[0] + x, s->keyframe + x, | |
462 | cur_blk_width * 3); | |
463 | } | |
464 | } | |
465 | ||
466 | /* skip unchanged blocks, which have size 0 */ | |
467 | if (size) { | |
468 | if (flashsv_decode_block(avctx, avpkt, &gb, size, | |
469 | cur_blk_width, cur_blk_height, | |
470 | x_pos, y_pos, | |
471 | i + j * (h_blocks + !!h_part))) | |
472 | av_log(avctx, AV_LOG_ERROR, | |
473 | "error in decompression of block %dx%d\n", i, j); | |
474 | } | |
475 | } | |
476 | } | |
477 | if (s->is_keyframe && s->ver == 2) { | |
478 | if (!s->keyframe) { | |
479 | s->keyframe = av_malloc(s->frame->linesize[0] * avctx->height); | |
480 | if (!s->keyframe) { | |
481 | av_log(avctx, AV_LOG_ERROR, "Cannot allocate image data\n"); | |
482 | return AVERROR(ENOMEM); | |
483 | } | |
484 | } | |
485 | memcpy(s->keyframe, s->frame->data[0], | |
486 | s->frame->linesize[0] * avctx->height); | |
487 | } | |
488 | ||
489 | if ((ret = av_frame_ref(data, s->frame)) < 0) | |
490 | return ret; | |
491 | ||
492 | *got_frame = 1; | |
493 | ||
494 | if ((get_bits_count(&gb) / 8) != buf_size) | |
495 | av_log(avctx, AV_LOG_ERROR, "buffer not fully consumed (%d != %d)\n", | |
496 | buf_size, (get_bits_count(&gb) / 8)); | |
497 | ||
498 | /* report that the buffer was completely consumed */ | |
499 | return buf_size; | |
500 | } | |
501 | ||
502 | #if CONFIG_FLASHSV_DECODER | |
503 | AVCodec ff_flashsv_decoder = { | |
504 | .name = "flashsv", | |
505 | .long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video v1"), | |
506 | .type = AVMEDIA_TYPE_VIDEO, | |
507 | .id = AV_CODEC_ID_FLASHSV, | |
508 | .priv_data_size = sizeof(FlashSVContext), | |
509 | .init = flashsv_decode_init, | |
510 | .close = flashsv_decode_end, | |
511 | .decode = flashsv_decode_frame, | |
512 | .capabilities = CODEC_CAP_DR1, | |
513 | .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE }, | |
514 | }; | |
515 | #endif /* CONFIG_FLASHSV_DECODER */ | |
516 | ||
517 | #if CONFIG_FLASHSV2_DECODER | |
518 | static const uint32_t ff_flashsv2_default_palette[128] = { | |
519 | 0x000000, 0x333333, 0x666666, 0x999999, 0xCCCCCC, 0xFFFFFF, | |
520 | 0x330000, 0x660000, 0x990000, 0xCC0000, 0xFF0000, 0x003300, | |
521 | 0x006600, 0x009900, 0x00CC00, 0x00FF00, 0x000033, 0x000066, | |
522 | 0x000099, 0x0000CC, 0x0000FF, 0x333300, 0x666600, 0x999900, | |
523 | 0xCCCC00, 0xFFFF00, 0x003333, 0x006666, 0x009999, 0x00CCCC, | |
524 | 0x00FFFF, 0x330033, 0x660066, 0x990099, 0xCC00CC, 0xFF00FF, | |
525 | 0xFFFF33, 0xFFFF66, 0xFFFF99, 0xFFFFCC, 0xFF33FF, 0xFF66FF, | |
526 | 0xFF99FF, 0xFFCCFF, 0x33FFFF, 0x66FFFF, 0x99FFFF, 0xCCFFFF, | |
527 | 0xCCCC33, 0xCCCC66, 0xCCCC99, 0xCCCCFF, 0xCC33CC, 0xCC66CC, | |
528 | 0xCC99CC, 0xCCFFCC, 0x33CCCC, 0x66CCCC, 0x99CCCC, 0xFFCCCC, | |
529 | 0x999933, 0x999966, 0x9999CC, 0x9999FF, 0x993399, 0x996699, | |
530 | 0x99CC99, 0x99FF99, 0x339999, 0x669999, 0xCC9999, 0xFF9999, | |
531 | 0x666633, 0x666699, 0x6666CC, 0x6666FF, 0x663366, 0x669966, | |
532 | 0x66CC66, 0x66FF66, 0x336666, 0x996666, 0xCC6666, 0xFF6666, | |
533 | 0x333366, 0x333399, 0x3333CC, 0x3333FF, 0x336633, 0x339933, | |
534 | 0x33CC33, 0x33FF33, 0x663333, 0x993333, 0xCC3333, 0xFF3333, | |
535 | 0x003366, 0x336600, 0x660033, 0x006633, 0x330066, 0x663300, | |
536 | 0x336699, 0x669933, 0x993366, 0x339966, 0x663399, 0x996633, | |
537 | 0x6699CC, 0x99CC66, 0xCC6699, 0x66CC99, 0x9966CC, 0xCC9966, | |
538 | 0x99CCFF, 0xCCFF99, 0xFF99CC, 0x99FFCC, 0xCC99FF, 0xFFCC99, | |
539 | 0x111111, 0x222222, 0x444444, 0x555555, 0xAAAAAA, 0xBBBBBB, | |
540 | 0xDDDDDD, 0xEEEEEE | |
541 | }; | |
542 | ||
543 | static av_cold int flashsv2_decode_init(AVCodecContext *avctx) | |
544 | { | |
545 | FlashSVContext *s = avctx->priv_data; | |
546 | flashsv_decode_init(avctx); | |
547 | s->pal = ff_flashsv2_default_palette; | |
548 | s->ver = 2; | |
549 | ||
550 | return 0; | |
551 | } | |
552 | ||
553 | static av_cold int flashsv2_decode_end(AVCodecContext *avctx) | |
554 | { | |
555 | FlashSVContext *s = avctx->priv_data; | |
556 | ||
557 | av_freep(&s->keyframedata); | |
558 | av_freep(&s->blocks); | |
559 | av_freep(&s->keyframe); | |
560 | av_freep(&s->deflate_block); | |
561 | flashsv_decode_end(avctx); | |
562 | ||
563 | return 0; | |
564 | } | |
565 | ||
566 | AVCodec ff_flashsv2_decoder = { | |
567 | .name = "flashsv2", | |
568 | .long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video v2"), | |
569 | .type = AVMEDIA_TYPE_VIDEO, | |
570 | .id = AV_CODEC_ID_FLASHSV2, | |
571 | .priv_data_size = sizeof(FlashSVContext), | |
572 | .init = flashsv2_decode_init, | |
573 | .close = flashsv2_decode_end, | |
574 | .decode = flashsv_decode_frame, | |
575 | .capabilities = CODEC_CAP_DR1, | |
576 | .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE }, | |
577 | }; | |
578 | #endif /* CONFIG_FLASHSV2_DECODER */ |