2 * Flash Screen Video decoder
3 * Copyright (C) 2004 Alex Beregszaszi
4 * Copyright (C) 2006 Benjamin Larsson
6 * This file is part of FFmpeg.
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.
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.
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
25 * Flash Screen Video decoder
26 * @author Alex Beregszaszi
27 * @author Benjamin Larsson
28 * @author Daniel Verkamp
29 * @author Konstantin Shishkov
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.
40 #include "libavutil/intreadwrite.h"
42 #include "bytestream.h"
46 typedef struct BlockInfo {
51 typedef struct FlashSVContext {
52 AVCodecContext *avctx;
54 int image_width, image_height;
55 int block_width, block_height;
62 uint8_t *keyframedata;
65 uint8_t *deflate_block;
66 int deflate_block_size;
68 int zlibprime_curr, zlibprime_prev;
69 int diff_start, diff_height;
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)
76 const uint8_t *orig_src = sptr;
78 for (y = dx + h; y > dx; y--) {
79 uint8_t *dst = dptr + (y * stride) + dy * 3;
80 for (x = 0; x < w; x++) {
83 unsigned c = AV_RB16(sptr) & ~0x8000;
84 unsigned b = c & 0x1F;
85 unsigned g = (c >> 5) & 0x1F;
87 /* 000aaabb -> aaabbaaa */
88 *dst++ = (b << 3) | (b >> 2);
89 *dst++ = (g << 3) | (g >> 2);
90 *dst++ = (r << 3) | (r >> 2);
94 uint32_t c = pal[*sptr++];
95 bytestream_put_le24(&dst, c);
99 return sptr - orig_src;
102 static av_cold int flashsv_decode_end(AVCodecContext *avctx)
104 FlashSVContext *s = avctx->priv_data;
105 inflateEnd(&s->zstream);
106 /* release the frame if needed */
107 av_frame_free(&s->frame);
109 /* free the tmpblock */
110 av_freep(&s->tmpblock);
115 static av_cold int flashsv_decode_init(AVCodecContext *avctx)
117 FlashSVContext *s = avctx->priv_data;
118 int zret; // Zlib return code
121 s->zstream.zalloc = Z_NULL;
122 s->zstream.zfree = Z_NULL;
123 s->zstream.opaque = Z_NULL;
124 zret = inflateInit(&s->zstream);
126 av_log(avctx, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
129 avctx->pix_fmt = AV_PIX_FMT_BGR24;
131 s->frame = av_frame_alloc();
133 flashsv_decode_end(avctx);
134 return AVERROR(ENOMEM);
140 static int flashsv2_prime(FlashSVContext *s, uint8_t *src, int size)
143 int zret; // Zlib return code
146 return AVERROR_INVALIDDATA;
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);
158 if (deflateInit(&zs, 0) != Z_OK)
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);
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;
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);
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,
186 struct FlashSVContext *s = avctx->priv_data;
187 uint8_t *line = s->tmpblock;
189 int ret = inflateReset(&s->zstream);
191 av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", ret);
192 return AVERROR_UNKNOWN;
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);
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);
212 if (ret != Z_OK && ret != Z_STREAM_END) {
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;
221 y_pos += s->diff_start;
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],
230 /* advance source pointer to next line */
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);
240 skip_bits_long(gb, 8 * block_size); /* skip the consumed bits */
244 static int calc_deflate_block_size(int tmpblock_size)
249 zstream.zalloc = Z_NULL;
250 zstream.zfree = Z_NULL;
251 zstream.opaque = Z_NULL;
252 if (deflateInit(&zstream, 0) != Z_OK)
254 size = deflateBound(&zstream, tmpblock_size);
255 deflateEnd(&zstream);
260 static int flashsv_decode_frame(AVCodecContext *avctx, void *data,
261 int *got_frame, AVPacket *avpkt)
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;
267 int last_blockwidth = s->block_width;
268 int last_blockheight= s->block_height;
270 /* no supplementary picture */
276 if ((ret = init_get_bits8(&gb, avpkt->data, buf_size)) < 0)
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);
285 if ( last_blockwidth != s->block_width
286 || last_blockheight!= s->block_height)
287 av_freep(&s->blocks);
291 if (get_bits1(&gb)) {
292 avpriv_request_sample(avctx, "iframe");
293 return AVERROR_PATCHWELCOME;
295 if (get_bits1(&gb)) {
296 avpriv_request_sample(avctx, "Custom palette");
297 return AVERROR_PATCHWELCOME;
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;
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;
312 s->tmpblock = av_realloc(s->tmpblock, tmpblock_size);
314 av_log(avctx, AV_LOG_ERROR,
315 "Cannot allocate decompression buffer.\n");
316 return AVERROR(ENOMEM);
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");
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);
334 s->block_size = s->block_width * s->block_height;
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)
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;
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);
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]));
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);
365 if ((ret = ff_reget_buffer(avctx, s->frame)) < 0)
368 /* loop over all block columns */
369 for (j = 0; j < v_blocks + (v_part ? 1 : 0); j++) {
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;
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;
380 /* get the size of the compressed zlib chunk */
381 int size = get_bits(&gb, 16);
384 s->zlibprime_curr = 0;
385 s->zlibprime_prev = 0;
387 s->diff_height = cur_blk_height;
389 if (8 * size > get_bits_left(&gb)) {
390 av_frame_unref(s->frame);
391 return AVERROR_INVALIDDATA;
394 if (s->ver == 2 && size) {
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);
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;
410 av_log(avctx, AV_LOG_ERROR,
411 "Inter frame without keyframe\n");
412 return AVERROR_INVALIDDATA;
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;
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);
428 if (s->zlibprime_prev)
429 av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_prev\n", i, j);
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",
437 avpriv_request_sample(avctx, "zlibprime_curr");
438 return AVERROR_PATCHWELCOME;
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;
445 size--; // account for flags byte
450 int off = (s->image_height - y_pos - 1) * s->frame->linesize[0];
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,
459 /* skip unchanged blocks, which have size 0 */
461 if (flashsv_decode_block(avctx, avpkt, &gb, size,
462 cur_blk_width, cur_blk_height,
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);
470 if (s->is_keyframe && s->ver == 2) {
472 s->keyframe = av_malloc(s->frame->linesize[0] * avctx->height);
474 av_log(avctx, AV_LOG_ERROR, "Cannot allocate image data\n");
475 return AVERROR(ENOMEM);
478 memcpy(s->keyframe, s->frame->data[0],
479 s->frame->linesize[0] * avctx->height);
482 if ((ret = av_frame_ref(data, s->frame)) < 0)
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));
491 /* report that the buffer was completely consumed */
495 #if CONFIG_FLASHSV_DECODER
496 AVCodec ff_flashsv_decoder = {
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 },
508 #endif /* CONFIG_FLASHSV_DECODER */
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,
536 static av_cold int flashsv2_decode_init(AVCodecContext *avctx)
538 FlashSVContext *s = avctx->priv_data;
539 flashsv_decode_init(avctx);
540 s->pal = ff_flashsv2_default_palette;
546 static av_cold int flashsv2_decode_end(AVCodecContext *avctx)
548 FlashSVContext *s = avctx->priv_data;
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);
559 AVCodec ff_flashsv2_decoder = {
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 },
571 #endif /* CONFIG_FLASHSV2_DECODER */