FFmpeg
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 "config_components.h"
37 
38 #include <stdio.h>
39 #include <stdlib.h>
40 #include <zlib.h>
41 
42 #include "libavutil/intreadwrite.h"
43 #include "avcodec.h"
44 #include "bytestream.h"
45 #include "codec_internal.h"
46 #include "get_bits.h"
47 #include "internal.h"
48 #include "zlib_wrapper.h"
49 
50 typedef struct BlockInfo {
51  const uint8_t *pos;
52  int size;
53 } BlockInfo;
54 
55 typedef struct FlashSVContext {
60  uint8_t *tmpblock;
62  int ver;
63  const uint32_t *pal;
65  const uint8_t *keyframedata;
67  uint8_t *keyframe;
73  uint8_t tmp[UINT16_MAX];
75 
76 static int decode_hybrid(const uint8_t *sptr, const uint8_t *sptr_end, uint8_t *dptr, int dx, int dy,
77  int h, int w, int stride, const uint32_t *pal)
78 {
79  int x, y;
80  const uint8_t *orig_src = sptr;
81 
82  for (y = dx + h; y > dx; y--) {
83  uint8_t *dst = dptr + (y * stride) + dy * 3;
84  for (x = 0; x < w; x++) {
85  if (sptr >= sptr_end)
86  return AVERROR_INVALIDDATA;
87  if (*sptr & 0x80) {
88  /* 15-bit color */
89  unsigned c = AV_RB16(sptr) & ~0x8000;
90  unsigned b = c & 0x1F;
91  unsigned g = (c >> 5) & 0x1F;
92  unsigned r = c >> 10;
93  /* 000aaabb -> aaabbaaa */
94  *dst++ = (b << 3) | (b >> 2);
95  *dst++ = (g << 3) | (g >> 2);
96  *dst++ = (r << 3) | (r >> 2);
97  sptr += 2;
98  } else {
99  /* palette index */
100  uint32_t c = pal[*sptr++];
101  bytestream_put_le24(&dst, c);
102  }
103  }
104  }
105  return sptr - orig_src;
106 }
107 
109 {
110  FlashSVContext *s = avctx->priv_data;
111 
112  ff_inflate_end(&s->zstream);
113  /* release the frame if needed */
114  av_frame_free(&s->frame);
115 
116  /* free the tmpblock */
117  av_freep(&s->tmpblock);
118 
119  return 0;
120 }
121 
123 {
124  FlashSVContext *s = avctx->priv_data;
125 
126  s->avctx = avctx;
127  avctx->pix_fmt = AV_PIX_FMT_BGR24;
128 
129  s->frame = av_frame_alloc();
130  if (!s->frame) {
131  return AVERROR(ENOMEM);
132  }
133 
134  return ff_inflate_init(&s->zstream, avctx);
135 }
136 
137 static int flashsv2_prime(FlashSVContext *s, const uint8_t *src, int size)
138 {
139  int zret; // Zlib return code
140  static const uint8_t zlib_header[] = { 0x78, 0x01 };
141  z_stream *const zstream = &s->zstream.zstream;
142  uint8_t *data = s->tmpblock;
143  unsigned remaining;
144 
145  if (!src)
146  return AVERROR_INVALIDDATA;
147 
148  zstream->next_in = src;
149  zstream->avail_in = size;
150  zstream->next_out = data;
151  zstream->avail_out = s->block_size * 3;
152  zret = inflate(zstream, Z_SYNC_FLUSH);
153  if (zret != Z_OK && zret != Z_STREAM_END)
154  return AVERROR_UNKNOWN;
155  remaining = s->block_size * 3 - zstream->avail_out;
156 
157  if ((zret = inflateReset(zstream)) != Z_OK) {
158  av_log(s->avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);
159  return AVERROR_UNKNOWN;
160  }
161 
162  /* Create input for zlib that is equivalent to encoding the output
163  * from above and decoding it again (the net result of this is that
164  * the dictionary of past decoded data is correctly primed and
165  * the adler32 checksum is correctly initialized).
166  * This is accomplished by synthetizing blocks of uncompressed data
167  * out of the output from above. See section 3.2.4 of RFC 1951. */
168  zstream->next_in = zlib_header;
169  zstream->avail_in = sizeof(zlib_header);
170  zret = inflate(zstream, Z_SYNC_FLUSH);
171  if (zret != Z_OK)
172  return AVERROR_UNKNOWN;
173  while (remaining > 0) {
174  unsigned block_size = FFMIN(UINT16_MAX, remaining);
175  uint8_t header[5];
176  /* Bit 0: Non-last-block, bits 1-2: BTYPE for uncompressed block */
177  header[0] = 0;
178  /* Block size */
179  AV_WL16(header + 1, block_size);
180  /* Block size (one's complement) */
181  AV_WL16(header + 3, block_size ^ 0xFFFF);
182  zstream->next_in = header;
183  zstream->avail_in = sizeof(header);
184  zstream->next_out = s->tmp;
185  zstream->avail_out = sizeof(s->tmp);
186  zret = inflate(zstream, Z_SYNC_FLUSH);
187  if (zret != Z_OK)
188  return AVERROR_UNKNOWN;
189  zstream->next_in = data;
190  zstream->avail_in = block_size;
191  zret = inflate(zstream, Z_SYNC_FLUSH);
192  if (zret != Z_OK)
193  return AVERROR_UNKNOWN;
194  data += block_size;
195  remaining -= block_size;
196  }
197 
198  return 0;
199 }
200 
201 static int flashsv_decode_block(AVCodecContext *avctx, const AVPacket *avpkt,
202  GetBitContext *gb, int block_size,
203  int width, int height, int x_pos, int y_pos,
204  int blk_idx)
205 {
206  struct FlashSVContext *s = avctx->priv_data;
207  z_stream *const zstream = &s->zstream.zstream;
208  uint8_t *line = s->tmpblock;
209  int k;
210  int ret = inflateReset(zstream);
211  if (ret != Z_OK) {
212  av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", ret);
213  return AVERROR_UNKNOWN;
214  }
215  if (s->zlibprime_curr || s->zlibprime_prev) {
216  ret = flashsv2_prime(s,
217  s->blocks[blk_idx].pos,
218  s->blocks[blk_idx].size);
219  if (ret < 0)
220  return ret;
221  }
222  zstream->next_in = avpkt->data + get_bits_count(gb) / 8;
223  zstream->avail_in = block_size;
224  zstream->next_out = s->tmpblock;
225  zstream->avail_out = s->block_size * 3;
226  ret = inflate(zstream, Z_FINISH);
227  if (ret == Z_DATA_ERROR) {
228  av_log(avctx, AV_LOG_ERROR, "Zlib resync occurred\n");
229  inflateSync(zstream);
230  ret = inflate(zstream, Z_FINISH);
231  }
232 
233  if (ret != Z_OK && ret != Z_STREAM_END) {
234  //return -1;
235  }
236 
237  if (s->is_keyframe) {
238  s->blocks[blk_idx].pos = s->keyframedata + (get_bits_count(gb) / 8);
239  s->blocks[blk_idx].size = block_size;
240  }
241 
242  y_pos += s->diff_start;
243 
244  if (!s->color_depth) {
245  /* Flash Screen Video stores the image upside down, so copy
246  * lines to destination in reverse order. */
247  for (k = 1; k <= s->diff_height; k++) {
248  memcpy(s->frame->data[0] + x_pos * 3 +
249  (s->image_height - y_pos - k) * s->frame->linesize[0],
250  line, width * 3);
251  /* advance source pointer to next line */
252  line += width * 3;
253  }
254  } else {
255  /* hybrid 15-bit/palette mode */
256  ret = decode_hybrid(s->tmpblock, zstream->next_out,
257  s->frame->data[0],
258  s->image_height - (y_pos + 1 + s->diff_height),
259  x_pos, s->diff_height, width,
260  s->frame->linesize[0], s->pal);
261  if (ret < 0) {
262  av_log(avctx, AV_LOG_ERROR, "decode_hybrid failed\n");
263  return ret;
264  }
265  }
266  skip_bits_long(gb, 8 * block_size); /* skip the consumed bits */
267  return 0;
268 }
269 
271  int *got_frame, AVPacket *avpkt)
272 {
273  int buf_size = avpkt->size;
275  int h_blocks, v_blocks, h_part, v_part, i, j, ret;
276  GetBitContext gb;
277  int last_blockwidth = s->block_width;
278  int last_blockheight= s->block_height;
279 
280  /* no supplementary picture */
281  if (buf_size == 0)
282  return 0;
283  if (buf_size < 4)
284  return -1;
285 
286  if ((ret = init_get_bits8(&gb, avpkt->data, buf_size)) < 0)
287  return ret;
288 
289  /* start to parse the bitstream */
290  s->block_width = 16 * (get_bits(&gb, 4) + 1);
291  s->image_width = get_bits(&gb, 12);
292  s->block_height = 16 * (get_bits(&gb, 4) + 1);
293  s->image_height = get_bits(&gb, 12);
294 
295  if ( last_blockwidth != s->block_width
296  || last_blockheight!= s->block_height)
297  av_freep(&s->blocks);
298 
299  if (s->ver == 2) {
300  skip_bits(&gb, 6);
301  if (get_bits1(&gb)) {
302  avpriv_request_sample(avctx, "iframe");
303  return AVERROR_PATCHWELCOME;
304  }
305  if (get_bits1(&gb)) {
306  avpriv_request_sample(avctx, "Custom palette");
307  return AVERROR_PATCHWELCOME;
308  }
309  }
310 
311  /* calculate number of blocks and size of border (partial) blocks */
312  h_blocks = s->image_width / s->block_width;
313  h_part = s->image_width % s->block_width;
314  v_blocks = s->image_height / s->block_height;
315  v_part = s->image_height % s->block_height;
316 
317  /* the block size could change between frames, make sure the buffer
318  * is large enough, if not, get a larger one */
319  if (s->block_size < s->block_width * s->block_height) {
320  int tmpblock_size = 3 * s->block_width * s->block_height, err;
321 
322  if ((err = av_reallocp(&s->tmpblock, tmpblock_size)) < 0) {
323  s->block_size = 0;
325  "Cannot allocate decompression buffer.\n");
326  return err;
327  }
328  }
329  s->block_size = s->block_width * s->block_height;
330 
331  /* initialize the image size once */
332  if (avctx->width == 0 && avctx->height == 0) {
333  if ((ret = ff_set_dimensions(avctx, s->image_width, s->image_height)) < 0)
334  return ret;
335  }
336 
337  /* check for changes of image width and image height */
338  if (avctx->width != s->image_width || avctx->height != s->image_height) {
340  "Frame width or height differs from first frame!\n");
341  av_log(avctx, AV_LOG_ERROR, "fh = %d, fv %d vs ch = %d, cv = %d\n",
342  avctx->height, avctx->width, s->image_height, s->image_width);
343  return AVERROR_INVALIDDATA;
344  }
345 
346  /* we care for keyframes only in Screen Video v2 */
347  s->is_keyframe = (avpkt->flags & AV_PKT_FLAG_KEY) && (s->ver == 2);
348  if (s->is_keyframe) {
349  int err = av_buffer_replace(&s->keyframedata_buf, avpkt->buf);
350  if (err < 0)
351  return err;
352  s->keyframedata = avpkt->data;
353  if (s->blocks)
354  memset(s->blocks, 0, (v_blocks + !!v_part) * (h_blocks + !!h_part) *
355  sizeof(s->blocks[0]));
356  }
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]));
360 
361  ff_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);
364 
365  if ((ret = ff_reget_buffer(avctx, s->frame, 0)) < 0)
366  return ret;
367 
368  /* loop over all block columns */
369  for (j = 0; j < v_blocks + (v_part ? 1 : 0); j++) {
370 
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;
373 
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;
378  int has_diff = 0;
379 
380  /* get the size of the compressed zlib chunk */
381  int size = get_bits(&gb, 16);
382 
383  s->color_depth = 0;
384  s->zlibprime_curr = 0;
385  s->zlibprime_prev = 0;
386  s->diff_start = 0;
387  s->diff_height = cur_blk_height;
388 
389  if (8 * size > get_bits_left(&gb)) {
390  av_frame_unref(s->frame);
391  return AVERROR_INVALIDDATA;
392  }
393 
394  if (s->ver == 2 && size) {
395  skip_bits(&gb, 3);
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);
400 
401  if (s->color_depth != 0 && s->color_depth != 2) {
403  "%dx%d invalid color depth %d\n",
404  i, j, s->color_depth);
405  return AVERROR_INVALIDDATA;
406  }
407 
408  if (has_diff) {
409  if (size < 3) {
410  av_log(avctx, AV_LOG_ERROR, "size too small for diff\n");
411  return AVERROR_INVALIDDATA;
412  }
413  if (!s->keyframe) {
415  "Inter frame without keyframe\n");
416  return AVERROR_INVALIDDATA;
417  }
418  s->diff_start = get_bits(&gb, 8);
419  s->diff_height = get_bits(&gb, 8);
420  if (s->diff_start + s->diff_height > cur_blk_height) {
422  "Block parameters invalid: %d + %d > %d\n",
423  s->diff_start, s->diff_height, cur_blk_height);
424  return AVERROR_INVALIDDATA;
425  }
427  "%dx%d diff start %d height %d\n",
428  i, j, s->diff_start, s->diff_height);
429  size -= 2;
430  }
431 
432  if (s->zlibprime_prev)
433  av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_prev\n", i, j);
434 
435  if (s->zlibprime_curr) {
436  int col = get_bits(&gb, 8);
437  int row = get_bits(&gb, 8);
438  av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_curr %dx%d\n",
439  i, j, col, row);
440  if (size < 3) {
441  av_log(avctx, AV_LOG_ERROR, "size too small for zlibprime_curr\n");
442  return AVERROR_INVALIDDATA;
443  }
444  size -= 2;
445  avpriv_request_sample(avctx, "zlibprime_curr");
446  return AVERROR_PATCHWELCOME;
447  }
448  if (!s->blocks && (s->zlibprime_curr || s->zlibprime_prev)) {
450  "no data available for zlib priming\n");
451  return AVERROR_INVALIDDATA;
452  }
453  size--; // account for flags byte
454  }
455 
456  if (has_diff) {
457  int k;
458  int off = (s->image_height - y_pos - 1) * s->frame->linesize[0];
459 
460  for (k = 0; k < cur_blk_height; k++) {
461  int x = off - k * s->frame->linesize[0] + x_pos * 3;
462  memcpy(s->frame->data[0] + x, s->keyframe + x,
463  cur_blk_width * 3);
464  }
465  }
466 
467  /* skip unchanged blocks, which have size 0 */
468  if (size) {
469  if (flashsv_decode_block(avctx, avpkt, &gb, size,
470  cur_blk_width, cur_blk_height,
471  x_pos, y_pos,
472  i + j * (h_blocks + !!h_part)))
474  "error in decompression of block %dx%d\n", i, j);
475  }
476  }
477  }
478  if (s->is_keyframe && s->ver == 2) {
479  if (!s->keyframe) {
480  s->keyframe = av_malloc(s->frame->linesize[0] * avctx->height);
481  if (!s->keyframe) {
482  av_log(avctx, AV_LOG_ERROR, "Cannot allocate image data\n");
483  return AVERROR(ENOMEM);
484  }
485  }
486  memcpy(s->keyframe, s->frame->data[0],
487  s->frame->linesize[0] * avctx->height);
488  }
489 
490  if ((ret = av_frame_ref(rframe, s->frame)) < 0)
491  return ret;
492 
493  *got_frame = 1;
494 
495  if ((get_bits_count(&gb) / 8) != buf_size)
496  av_log(avctx, AV_LOG_ERROR, "buffer not fully consumed (%d != %d)\n",
497  buf_size, (get_bits_count(&gb) / 8));
498 
499  /* report that the buffer was completely consumed */
500  return buf_size;
501 }
502 
503 #if CONFIG_FLASHSV_DECODER
504 const FFCodec ff_flashsv_decoder = {
505  .p.name = "flashsv",
506  .p.long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video v1"),
507  .p.type = AVMEDIA_TYPE_VIDEO,
508  .p.id = AV_CODEC_ID_FLASHSV,
509  .priv_data_size = sizeof(FlashSVContext),
511  .close = flashsv_decode_end,
513  .p.capabilities = AV_CODEC_CAP_DR1,
514  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
515  .p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE },
516 };
517 #endif /* CONFIG_FLASHSV_DECODER */
518 
519 #if CONFIG_FLASHSV2_DECODER
520 static const uint32_t ff_flashsv2_default_palette[128] = {
521  0x000000, 0x333333, 0x666666, 0x999999, 0xCCCCCC, 0xFFFFFF,
522  0x330000, 0x660000, 0x990000, 0xCC0000, 0xFF0000, 0x003300,
523  0x006600, 0x009900, 0x00CC00, 0x00FF00, 0x000033, 0x000066,
524  0x000099, 0x0000CC, 0x0000FF, 0x333300, 0x666600, 0x999900,
525  0xCCCC00, 0xFFFF00, 0x003333, 0x006666, 0x009999, 0x00CCCC,
526  0x00FFFF, 0x330033, 0x660066, 0x990099, 0xCC00CC, 0xFF00FF,
527  0xFFFF33, 0xFFFF66, 0xFFFF99, 0xFFFFCC, 0xFF33FF, 0xFF66FF,
528  0xFF99FF, 0xFFCCFF, 0x33FFFF, 0x66FFFF, 0x99FFFF, 0xCCFFFF,
529  0xCCCC33, 0xCCCC66, 0xCCCC99, 0xCCCCFF, 0xCC33CC, 0xCC66CC,
530  0xCC99CC, 0xCCFFCC, 0x33CCCC, 0x66CCCC, 0x99CCCC, 0xFFCCCC,
531  0x999933, 0x999966, 0x9999CC, 0x9999FF, 0x993399, 0x996699,
532  0x99CC99, 0x99FF99, 0x339999, 0x669999, 0xCC9999, 0xFF9999,
533  0x666633, 0x666699, 0x6666CC, 0x6666FF, 0x663366, 0x669966,
534  0x66CC66, 0x66FF66, 0x336666, 0x996666, 0xCC6666, 0xFF6666,
535  0x333366, 0x333399, 0x3333CC, 0x3333FF, 0x336633, 0x339933,
536  0x33CC33, 0x33FF33, 0x663333, 0x993333, 0xCC3333, 0xFF3333,
537  0x003366, 0x336600, 0x660033, 0x006633, 0x330066, 0x663300,
538  0x336699, 0x669933, 0x993366, 0x339966, 0x663399, 0x996633,
539  0x6699CC, 0x99CC66, 0xCC6699, 0x66CC99, 0x9966CC, 0xCC9966,
540  0x99CCFF, 0xCCFF99, 0xFF99CC, 0x99FFCC, 0xCC99FF, 0xFFCC99,
541  0x111111, 0x222222, 0x444444, 0x555555, 0xAAAAAA, 0xBBBBBB,
542  0xDDDDDD, 0xEEEEEE
543 };
544 
545 static av_cold int flashsv2_decode_init(AVCodecContext *avctx)
546 {
548  int ret;
549 
551  if (ret < 0)
552  return ret;
553  s->pal = ff_flashsv2_default_palette;
554  s->ver = 2;
555 
556  return 0;
557 }
558 
559 static av_cold int flashsv2_decode_end(AVCodecContext *avctx)
560 {
562 
563  av_buffer_unref(&s->keyframedata_buf);
564  s->keyframedata = NULL;
565  av_freep(&s->blocks);
566  av_freep(&s->keyframe);
568 
569  return 0;
570 }
571 
573  .p.name = "flashsv2",
574  .p.long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video v2"),
575  .p.type = AVMEDIA_TYPE_VIDEO,
576  .p.id = AV_CODEC_ID_FLASHSV2,
577  .priv_data_size = sizeof(FlashSVContext),
578  .init = flashsv2_decode_init,
579  .close = flashsv2_decode_end,
581  .p.capabilities = AV_CODEC_CAP_DR1,
582  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
583  .p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE },
584 };
585 #endif /* CONFIG_FLASHSV2_DECODER */
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:41
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:839
r
const char * r
Definition: vf_curves.c:116
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
FlashSVContext::image_width
int image_width
Definition: flashsv.c:58
flashsv_decode_end
static av_cold int flashsv_decode_end(AVCodecContext *avctx)
Definition: flashsv.c:108
FlashSVContext::keyframedata
const uint8_t * keyframedata
Definition: flashsv.c:65
FlashSVContext::zstream
FFZStream zstream
Definition: flashsv.c:72
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:116
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
FlashSVContext::pal
const uint32_t * pal
Definition: flashsv.c:63
w
uint8_t w
Definition: llviddspenc.c:38
FlashSVContext::ver
int ver
Definition: flashsv.c:62
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
b
#define b
Definition: input.c:34
decode_hybrid
static int decode_hybrid(const uint8_t *sptr, const uint8_t *sptr_end, uint8_t *dptr, int dx, int dy, int h, int w, int stride, const uint32_t *pal)
Definition: flashsv.c:76
data
const char data[16]
Definition: mxf.c:146
FFCodec
Definition: codec_internal.h:118
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
AVERROR_UNKNOWN
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:73
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:429
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
init
static int init
Definition: av_tx.c:47
flashsv_decode_init
static av_cold int flashsv_decode_init(AVCodecContext *avctx)
Definition: flashsv.c:122
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
flashsv_decode_block
static int flashsv_decode_block(AVCodecContext *avctx, const AVPacket *avpkt, GetBitContext *gb, int block_size, int width, int height, int x_pos, int y_pos, int blk_idx)
Definition: flashsv.c:201
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:122
inflate
static void inflate(uint8_t *dst, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord, int maxc)
Definition: vf_neighbor.c:195
GetBitContext
Definition: get_bits.h:61
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:104
flashsv2_prime
static int flashsv2_prime(FlashSVContext *s, const uint8_t *src, int size)
Definition: flashsv.c:137
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
zlib_wrapper.h
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:667
FlashSVContext::tmpblock
uint8_t * tmpblock
Definition: flashsv.c:60
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:260
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:256
g
const char * g
Definition: vf_curves.c:117
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
get_bits.h
FlashSVContext::is_keyframe
int is_keyframe
Definition: flashsv.c:64
FlashSVContext::zlibprime_curr
int zlibprime_curr
Definition: flashsv.c:70
AV_CODEC_ID_FLASHSV2
@ AV_CODEC_ID_FLASHSV2
Definition: codec_id.h:181
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:357
NULL
#define NULL
Definition: coverity.c:32
FlashSVContext::frame
AVFrame * frame
Definition: flashsv.c:57
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
FlashSVContext::color_depth
int color_depth
Definition: flashsv.c:69
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
FlashSVContext
Definition: flashsv.c:55
FlashSVContext::zlibprime_prev
int zlibprime_prev
Definition: flashsv.c:70
AV_CODEC_ID_FLASHSV
@ AV_CODEC_ID_FLASHSV
Definition: codec_id.h:136
BlockInfo::size
int size
Definition: flashsv.c:52
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
FlashSVContext::keyframedata_buf
AVBufferRef * keyframedata_buf
Definition: flashsv.c:66
BlockInfo
Definition: dvdec.c:56
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
FlashSVContext::blocks
BlockInfo * blocks
Definition: flashsv.c:68
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:375
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:353
codec_internal.h
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
size
int size
Definition: twinvq_data.h:10344
av_reallocp
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
Definition: mem.c:186
ff_flashsv2_decoder
const FFCodec ff_flashsv2_decoder
header
static const uint8_t header[24]
Definition: sdr2.c:67
AV_WL16
#define AV_WL16(p, v)
Definition: intreadwrite.h:412
height
#define height
FlashSVContext::block_height
int block_height
Definition: flashsv.c:59
line
Definition: graph2dot.c:48
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:380
FlashSVContext::block_width
int block_width
Definition: flashsv.c:59
FlashSVContext::diff_height
int diff_height
Definition: flashsv.c:71
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
FlashSVContext::block_size
int block_size
Definition: flashsv.c:61
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
FlashSVContext::image_height
int image_height
Definition: flashsv.c:58
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:487
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:264
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
av_buffer_replace
int av_buffer_replace(AVBufferRef **pdst, const AVBufferRef *src)
Ensure dst refers to the same data as src.
Definition: buffer.c:233
ff_inflate_end
void ff_inflate_end(FFZStream *zstream)
Wrapper around inflateEnd().
AVCodecContext::height
int height
Definition: avcodec.h:571
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
ff_reget_buffer
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Identical in function to ff_get_buffer(), except it reuses the existing buffer if available.
Definition: decode.c:1580
ret
ret
Definition: filter_design.txt:187
AVCodecContext
main external API structure.
Definition: avcodec.h:398
FlashSVContext::keyframe
uint8_t * keyframe
Definition: flashsv.c:67
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
FlashSVContext::diff_start
int diff_start
Definition: flashsv.c:71
ff_flashsv_decoder
const FFCodec ff_flashsv_decoder
BlockInfo::pos
const uint8_t * pos
Definition: flashsv.c:51
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
FFZStream
Definition: zlib_wrapper.h:27
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:90
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
ff_inflate_init
int ff_inflate_init(FFZStream *zstream, void *logctx)
Wrapper around inflateInit().
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:571
bytestream.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
h
h
Definition: vp9dsp_template.c:2038
flashsv_decode_frame
static int flashsv_decode_frame(AVCodecContext *avctx, AVFrame *rframe, int *got_frame, AVPacket *avpkt)
Definition: flashsv.c:270
FlashSVContext::avctx
AVCodecContext * avctx
Definition: flashsv.c:56
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98
FlashSVContext::tmp
uint8_t tmp[UINT16_MAX]
Definition: flashsv.c:73