FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
flashsv.c
Go to the documentation of this file.
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 {
48  int size;
49 } BlockInfo;
50 
51 typedef struct FlashSVContext {
58  z_stream zstream;
59  int ver;
60  const uint32_t *pal;
71 
72 
73 static int decode_hybrid(const uint8_t *sptr, uint8_t *dptr, int dx, int dy,
74  int h, int w, int stride, const uint32_t *pal)
75 {
76  int x, y;
77  const uint8_t *orig_src = sptr;
78 
79  for (y = dx+h; y > dx; y--) {
80  uint8_t *dst = dptr + (y * stride) + dy * 3;
81  for (x = 0; x < w; x++) {
82  if (*sptr & 0x80) {
83  /* 15-bit color */
84  unsigned c = AV_RB16(sptr) & ~0x8000;
85  unsigned b = c & 0x1F;
86  unsigned g = (c >> 5) & 0x1F;
87  unsigned r = c >> 10;
88  /* 000aaabb -> aaabbaaa */
89  *dst++ = (b << 3) | (b >> 2);
90  *dst++ = (g << 3) | (g >> 2);
91  *dst++ = (r << 3) | (r >> 2);
92  sptr += 2;
93  } else {
94  /* palette index */
95  uint32_t c = pal[*sptr++];
96  bytestream_put_le24(&dst, c);
97  }
98  }
99  }
100  return sptr - orig_src;
101 }
102 
104 {
105  FlashSVContext *s = avctx->priv_data;
106  inflateEnd(&s->zstream);
107  /* release the frame if needed */
108  av_frame_free(&s->frame);
109 
110  /* free the tmpblock */
111  av_freep(&s->tmpblock);
112 
113  return 0;
114 }
115 
117 {
118  FlashSVContext *s = avctx->priv_data;
119  int zret; // Zlib return code
120 
121  s->avctx = avctx;
122  s->zstream.zalloc = Z_NULL;
123  s->zstream.zfree = Z_NULL;
124  s->zstream.opaque = Z_NULL;
125  zret = inflateInit(&s->zstream);
126  if (zret != Z_OK) {
127  av_log(avctx, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
128  return 1;
129  }
130  avctx->pix_fmt = AV_PIX_FMT_BGR24;
131 
132  s->frame = av_frame_alloc();
133  if (!s->frame) {
134  flashsv_decode_end(avctx);
135  return AVERROR(ENOMEM);
136  }
137 
138  return 0;
139 }
140 
141 
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  if (!s->color_depth) {
223  /* Flash Screen Video stores the image upside down, so copy
224  * lines to destination in reverse order. */
225  for (k = 1; k <= s->diff_height; k++) {
226  memcpy(s->frame->data[0] + x_pos * 3 +
227  (s->image_height - y_pos - s->diff_start - k) * s->frame->linesize[0],
228  line, width * 3);
229  /* advance source pointer to next line */
230  line += width * 3;
231  }
232  } else {
233  /* hybrid 15-bit/palette mode */
234  decode_hybrid(s->tmpblock, s->frame->data[0],
235  s->image_height - (y_pos + 1 + s->diff_start + s->diff_height),
236  x_pos, s->diff_height, width,
237  s->frame->linesize[0], s->pal);
238  }
239  skip_bits_long(gb, 8 * block_size); /* skip the consumed bits */
240  return 0;
241 }
242 
243 static int calc_deflate_block_size(int tmpblock_size)
244 {
245  z_stream zstream;
246  int size;
247 
248  zstream.zalloc = Z_NULL;
249  zstream.zfree = Z_NULL;
250  zstream.opaque = Z_NULL;
251  if (deflateInit(&zstream, 0) != Z_OK)
252  return -1;
253  size = deflateBound(&zstream, tmpblock_size);
254  deflateEnd(&zstream);
255 
256  return size;
257 }
258 
260  int *got_frame, AVPacket *avpkt)
261 {
262  int buf_size = avpkt->size;
263  FlashSVContext *s = avctx->priv_data;
264  int h_blocks, v_blocks, h_part, v_part, i, j, ret;
265  GetBitContext gb;
266  int last_blockwidth = s->block_width;
267  int last_blockheight= s->block_height;
268 
269  /* no supplementary picture */
270  if (buf_size == 0)
271  return 0;
272  if (buf_size < 4)
273  return -1;
274 
275  init_get_bits(&gb, avpkt->data, buf_size * 8);
276 
277  /* start to parse the bitstream */
278  s->block_width = 16 * (get_bits(&gb, 4) + 1);
279  s->image_width = get_bits(&gb, 12);
280  s->block_height = 16 * (get_bits(&gb, 4) + 1);
281  s->image_height = get_bits(&gb, 12);
282 
283  if ( last_blockwidth != s->block_width
284  || last_blockheight!= s->block_height)
285  av_freep(&s->blocks);
286 
287  if (s->ver == 2) {
288  skip_bits(&gb, 6);
289  if (get_bits1(&gb)) {
290  avpriv_request_sample(avctx, "iframe");
291  return AVERROR_PATCHWELCOME;
292  }
293  if (get_bits1(&gb)) {
294  avpriv_request_sample(avctx, "Custom palette");
295  return AVERROR_PATCHWELCOME;
296  }
297  }
298 
299  /* calculate number of blocks and size of border (partial) blocks */
300  h_blocks = s->image_width / s->block_width;
301  h_part = s->image_width % s->block_width;
302  v_blocks = s->image_height / s->block_height;
303  v_part = s->image_height % s->block_height;
304 
305  /* the block size could change between frames, make sure the buffer
306  * is large enough, if not, get a larger one */
307  if (s->block_size < s->block_width * s->block_height) {
308  int tmpblock_size = 3 * s->block_width * s->block_height;
309 
310  s->tmpblock = av_realloc(s->tmpblock, tmpblock_size);
311  if (!s->tmpblock) {
312  av_log(avctx, AV_LOG_ERROR, "Can't allocate decompression buffer.\n");
313  return AVERROR(ENOMEM);
314  }
315  if (s->ver == 2) {
316  s->deflate_block_size = calc_deflate_block_size(tmpblock_size);
317  if (s->deflate_block_size <= 0) {
318  av_log(avctx, AV_LOG_ERROR, "Can't determine deflate buffer size.\n");
319  return -1;
320  }
322  if (!s->deflate_block) {
323  av_log(avctx, AV_LOG_ERROR, "Can't allocate deflate buffer.\n");
324  return AVERROR(ENOMEM);
325  }
326  }
327  }
328  s->block_size = s->block_width * s->block_height;
329 
330  /* initialize the image size once */
331  if (avctx->width == 0 && avctx->height == 0) {
333  }
334 
335  /* check for changes of image width and image height */
336  if (avctx->width != s->image_width || avctx->height != s->image_height) {
337  av_log(avctx, AV_LOG_ERROR,
338  "Frame width or height differs from first frame!\n");
339  av_log(avctx, AV_LOG_ERROR, "fh = %d, fv %d vs ch = %d, cv = %d\n",
340  avctx->height, avctx->width, s->image_height, s->image_width);
341  return AVERROR_INVALIDDATA;
342  }
343 
344  /* we care for keyframes only in Screen Video v2 */
345  s->is_keyframe = (avpkt->flags & AV_PKT_FLAG_KEY) && (s->ver == 2);
346  if (s->is_keyframe) {
347  s->keyframedata = av_realloc(s->keyframedata, avpkt->size);
348  memcpy(s->keyframedata, avpkt->data, avpkt->size);
349  }
350  if(s->ver == 2 && !s->blocks)
351  s->blocks = av_mallocz((v_blocks + !!v_part) * (h_blocks + !!h_part)
352  * sizeof(s->blocks[0]));
353 
354  av_dlog(avctx, "image: %dx%d block: %dx%d num: %dx%d part: %dx%d\n",
356  h_blocks, v_blocks, h_part, v_part);
357 
358  if ((ret = ff_reget_buffer(avctx, s->frame)) < 0)
359  return ret;
360 
361  /* loop over all block columns */
362  for (j = 0; j < v_blocks + (v_part ? 1 : 0); j++) {
363 
364  int y_pos = j * s->block_height; // vertical position in frame
365  int cur_blk_height = (j < v_blocks) ? s->block_height : v_part;
366 
367  /* loop over all block rows */
368  for (i = 0; i < h_blocks + (h_part ? 1 : 0); i++) {
369  int x_pos = i * s->block_width; // horizontal position in frame
370  int cur_blk_width = (i < h_blocks) ? s->block_width : h_part;
371  int has_diff = 0;
372 
373  /* get the size of the compressed zlib chunk */
374  int size = get_bits(&gb, 16);
375 
376  s->color_depth = 0;
377  s->zlibprime_curr = 0;
378  s->zlibprime_prev = 0;
379  s->diff_start = 0;
380  s->diff_height = cur_blk_height;
381 
382  if (8 * size > get_bits_left(&gb)) {
383  av_frame_unref(s->frame);
384  return AVERROR_INVALIDDATA;
385  }
386 
387  if (s->ver == 2 && size) {
388  skip_bits(&gb, 3);
389  s->color_depth = get_bits(&gb, 2);
390  has_diff = get_bits1(&gb);
391  s->zlibprime_curr = get_bits1(&gb);
392  s->zlibprime_prev = get_bits1(&gb);
393 
394  if (s->color_depth != 0 && s->color_depth != 2) {
395  av_log(avctx, AV_LOG_ERROR,
396  "%dx%d invalid color depth %d\n", i, j, s->color_depth);
397  return AVERROR_INVALIDDATA;
398  }
399 
400  if (has_diff) {
401  if (!s->keyframe) {
402  av_log(avctx, AV_LOG_ERROR,
403  "inter frame without keyframe\n");
404  return AVERROR_INVALIDDATA;
405  }
406  s->diff_start = get_bits(&gb, 8);
407  s->diff_height = get_bits(&gb, 8);
408  if (s->diff_start + s->diff_height > cur_blk_height) {
409  av_log(avctx, AV_LOG_ERROR, "Block parameters invalid\n");
410  return AVERROR_INVALIDDATA;
411  }
412  av_log(avctx, AV_LOG_DEBUG,
413  "%dx%d diff start %d height %d\n",
414  i, j, s->diff_start, s->diff_height);
415  size -= 2;
416  }
417 
418  if (s->zlibprime_prev)
419  av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_prev\n", i, j);
420 
421  if (s->zlibprime_curr) {
422  int col = get_bits(&gb, 8);
423  int row = get_bits(&gb, 8);
424  av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_curr %dx%d\n", i, j, col, row);
425  size -= 2;
426  avpriv_request_sample(avctx, "zlibprime_curr");
427  return AVERROR_PATCHWELCOME;
428  }
429  if (!s->blocks && (s->zlibprime_curr || s->zlibprime_prev)) {
430  av_log(avctx, AV_LOG_ERROR, "no data available for zlib "
431  "priming\n");
432  return AVERROR_INVALIDDATA;
433  }
434  size--; // account for flags byte
435  }
436 
437  if (has_diff) {
438  int k;
439  int off = (s->image_height - y_pos - 1) * s->frame->linesize[0];
440 
441  for (k = 0; k < cur_blk_height; k++)
442  memcpy(s->frame->data[0] + off - k*s->frame->linesize[0] + x_pos*3,
443  s->keyframe + off - k*s->frame->linesize[0] + x_pos*3,
444  cur_blk_width * 3);
445  }
446 
447  /* skip unchanged blocks, which have size 0 */
448  if (size) {
449  if (flashsv_decode_block(avctx, avpkt, &gb, size,
450  cur_blk_width, cur_blk_height,
451  x_pos, y_pos,
452  i + j * (h_blocks + !!h_part)))
453  av_log(avctx, AV_LOG_ERROR,
454  "error in decompression of block %dx%d\n", i, j);
455  }
456  }
457  }
458  if (s->is_keyframe && s->ver == 2) {
459  if (!s->keyframe) {
460  s->keyframe = av_malloc(s->frame->linesize[0] * avctx->height);
461  if (!s->keyframe) {
462  av_log(avctx, AV_LOG_ERROR, "Cannot allocate image data\n");
463  return AVERROR(ENOMEM);
464  }
465  }
466  memcpy(s->keyframe, s->frame->data[0], s->frame->linesize[0] * avctx->height);
467  }
468 
469  if ((ret = av_frame_ref(data, s->frame)) < 0)
470  return ret;
471 
472  *got_frame = 1;
473 
474  if ((get_bits_count(&gb) / 8) != buf_size)
475  av_log(avctx, AV_LOG_ERROR, "buffer not fully consumed (%d != %d)\n",
476  buf_size, (get_bits_count(&gb) / 8));
477 
478  /* report that the buffer was completely consumed */
479  return buf_size;
480 }
481 
482 #if CONFIG_FLASHSV_DECODER
483 AVCodec ff_flashsv_decoder = {
484  .name = "flashsv",
485  .long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video v1"),
486  .type = AVMEDIA_TYPE_VIDEO,
487  .id = AV_CODEC_ID_FLASHSV,
488  .priv_data_size = sizeof(FlashSVContext),
492  .capabilities = CODEC_CAP_DR1,
493  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE },
494 };
495 #endif /* CONFIG_FLASHSV_DECODER */
496 
497 #if CONFIG_FLASHSV2_DECODER
498 static const uint32_t ff_flashsv2_default_palette[128] = {
499  0x000000, 0x333333, 0x666666, 0x999999, 0xCCCCCC, 0xFFFFFF,
500  0x330000, 0x660000, 0x990000, 0xCC0000, 0xFF0000, 0x003300,
501  0x006600, 0x009900, 0x00CC00, 0x00FF00, 0x000033, 0x000066,
502  0x000099, 0x0000CC, 0x0000FF, 0x333300, 0x666600, 0x999900,
503  0xCCCC00, 0xFFFF00, 0x003333, 0x006666, 0x009999, 0x00CCCC,
504  0x00FFFF, 0x330033, 0x660066, 0x990099, 0xCC00CC, 0xFF00FF,
505  0xFFFF33, 0xFFFF66, 0xFFFF99, 0xFFFFCC, 0xFF33FF, 0xFF66FF,
506  0xFF99FF, 0xFFCCFF, 0x33FFFF, 0x66FFFF, 0x99FFFF, 0xCCFFFF,
507  0xCCCC33, 0xCCCC66, 0xCCCC99, 0xCCCCFF, 0xCC33CC, 0xCC66CC,
508  0xCC99CC, 0xCCFFCC, 0x33CCCC, 0x66CCCC, 0x99CCCC, 0xFFCCCC,
509  0x999933, 0x999966, 0x9999CC, 0x9999FF, 0x993399, 0x996699,
510  0x99CC99, 0x99FF99, 0x339999, 0x669999, 0xCC9999, 0xFF9999,
511  0x666633, 0x666699, 0x6666CC, 0x6666FF, 0x663366, 0x669966,
512  0x66CC66, 0x66FF66, 0x336666, 0x996666, 0xCC6666, 0xFF6666,
513  0x333366, 0x333399, 0x3333CC, 0x3333FF, 0x336633, 0x339933,
514  0x33CC33, 0x33FF33, 0x663333, 0x993333, 0xCC3333, 0xFF3333,
515  0x003366, 0x336600, 0x660033, 0x006633, 0x330066, 0x663300,
516  0x336699, 0x669933, 0x993366, 0x339966, 0x663399, 0x996633,
517  0x6699CC, 0x99CC66, 0xCC6699, 0x66CC99, 0x9966CC, 0xCC9966,
518  0x99CCFF, 0xCCFF99, 0xFF99CC, 0x99FFCC, 0xCC99FF, 0xFFCC99,
519  0x111111, 0x222222, 0x444444, 0x555555, 0xAAAAAA, 0xBBBBBB,
520  0xDDDDDD, 0xEEEEEE
521 };
522 
523 static av_cold int flashsv2_decode_init(AVCodecContext *avctx)
524 {
525  FlashSVContext *s = avctx->priv_data;
526  flashsv_decode_init(avctx);
527  s->pal = ff_flashsv2_default_palette;
528  s->ver = 2;
529 
530  return 0;
531 }
532 
533 static av_cold int flashsv2_decode_end(AVCodecContext *avctx)
534 {
535  FlashSVContext *s = avctx->priv_data;
536 
537  av_freep(&s->keyframedata);
538  av_freep(&s->blocks);
539  av_freep(&s->keyframe);
540  av_freep(&s->deflate_block);
541  flashsv_decode_end(avctx);
542 
543  return 0;
544 }
545 
546 AVCodec ff_flashsv2_decoder = {
547  .name = "flashsv2",
548  .long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video v2"),
549  .type = AVMEDIA_TYPE_VIDEO,
550  .id = AV_CODEC_ID_FLASHSV2,
551  .priv_data_size = sizeof(FlashSVContext),
552  .init = flashsv2_decode_init,
553  .close = flashsv2_decode_end,
555  .capabilities = CODEC_CAP_DR1,
556  .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE },
557 };
558 #endif /* CONFIG_FLASHSV2_DECODER */