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