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 <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 {
56  uint8_t *tmpblock;
58  z_stream zstream;
59  int ver;
60  const uint32_t *pal;
62  uint8_t *keyframedata;
63  uint8_t *keyframe;
65  uint8_t *deflate_block;
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 
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 
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 AVERROR_EXTERNAL;
130  }
131  avctx->pix_fmt = AV_PIX_FMT_BGR24;
132 
133  s->frame = av_frame_alloc();
134  if (!s->frame) {
135  return AVERROR(ENOMEM);
136  }
137 
138  return 0;
139 }
140 
141 static int flashsv2_prime(FlashSVContext *s, uint8_t *src, int size)
142 {
143  z_stream zs;
144  int zret; // Zlib return code
145 
146  if (!src)
147  return AVERROR_INVALIDDATA;
148 
149  zs.zalloc = NULL;
150  zs.zfree = NULL;
151  zs.opaque = NULL;
152 
153  s->zstream.next_in = src;
154  s->zstream.avail_in = size;
155  s->zstream.next_out = s->tmpblock;
156  s->zstream.avail_out = s->block_size * 3;
157  inflate(&s->zstream, Z_SYNC_FLUSH);
158 
159  if (deflateInit(&zs, 0) != Z_OK)
160  return -1;
161  zs.next_in = s->tmpblock;
162  zs.avail_in = s->block_size * 3 - s->zstream.avail_out;
163  zs.next_out = s->deflate_block;
164  zs.avail_out = s->deflate_block_size;
165  deflate(&zs, Z_SYNC_FLUSH);
166  deflateEnd(&zs);
167 
168  if ((zret = inflateReset(&s->zstream)) != Z_OK) {
169  av_log(s->avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);
170  return AVERROR_UNKNOWN;
171  }
172 
173  s->zstream.next_in = s->deflate_block;
174  s->zstream.avail_in = s->deflate_block_size - zs.avail_out;
175  s->zstream.next_out = s->tmpblock;
176  s->zstream.avail_out = s->block_size * 3;
177  inflate(&s->zstream, Z_SYNC_FLUSH);
178 
179  return 0;
180 }
181 
182 static int flashsv_decode_block(AVCodecContext *avctx, const AVPacket *avpkt,
183  GetBitContext *gb, int block_size,
184  int width, int height, int x_pos, int y_pos,
185  int blk_idx)
186 {
187  struct FlashSVContext *s = avctx->priv_data;
188  uint8_t *line = s->tmpblock;
189  int k;
190  int ret = inflateReset(&s->zstream);
191  if (ret != Z_OK) {
192  av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", ret);
193  return AVERROR_UNKNOWN;
194  }
195  if (s->zlibprime_curr || s->zlibprime_prev) {
196  ret = flashsv2_prime(s,
197  s->blocks[blk_idx].pos,
198  s->blocks[blk_idx].size);
199  if (ret < 0)
200  return ret;
201  }
202  s->zstream.next_in = avpkt->data + get_bits_count(gb) / 8;
203  s->zstream.avail_in = block_size;
204  s->zstream.next_out = s->tmpblock;
205  s->zstream.avail_out = s->block_size * 3;
206  ret = inflate(&s->zstream, Z_FINISH);
207  if (ret == Z_DATA_ERROR) {
208  av_log(avctx, AV_LOG_ERROR, "Zlib resync occurred\n");
209  inflateSync(&s->zstream);
210  ret = inflate(&s->zstream, Z_FINISH);
211  }
212 
213  if (ret != Z_OK && ret != Z_STREAM_END) {
214  //return -1;
215  }
216 
217  if (s->is_keyframe) {
218  s->blocks[blk_idx].pos = s->keyframedata + (get_bits_count(gb) / 8);
219  s->blocks[blk_idx].size = block_size;
220  }
221 
222  y_pos += s->diff_start;
223 
224  if (!s->color_depth) {
225  /* Flash Screen Video stores the image upside down, so copy
226  * lines to destination in reverse order. */
227  for (k = 1; k <= s->diff_height; k++) {
228  memcpy(s->frame->data[0] + x_pos * 3 +
229  (s->image_height - y_pos - k) * s->frame->linesize[0],
230  line, width * 3);
231  /* advance source pointer to next line */
232  line += width * 3;
233  }
234  } else {
235  /* hybrid 15-bit/palette mode */
236  ret = decode_hybrid(s->tmpblock, s->zstream.next_out,
237  s->frame->data[0],
238  s->image_height - (y_pos + 1 + s->diff_height),
239  x_pos, s->diff_height, width,
240  s->frame->linesize[0], s->pal);
241  if (ret < 0) {
242  av_log(avctx, AV_LOG_ERROR, "decode_hybrid failed\n");
243  return ret;
244  }
245  }
246  skip_bits_long(gb, 8 * block_size); /* skip the consumed bits */
247  return 0;
248 }
249 
250 static int calc_deflate_block_size(int tmpblock_size)
251 {
252  z_stream zstream;
253  int size;
254 
255  zstream.zalloc = Z_NULL;
256  zstream.zfree = Z_NULL;
257  zstream.opaque = Z_NULL;
258  if (deflateInit(&zstream, 0) != Z_OK)
259  return -1;
260  size = deflateBound(&zstream, tmpblock_size);
261  deflateEnd(&zstream);
262 
263  return size;
264 }
265 
267  int *got_frame, AVPacket *avpkt)
268 {
269  int buf_size = avpkt->size;
271  int h_blocks, v_blocks, h_part, v_part, i, j, ret;
272  GetBitContext gb;
273  int last_blockwidth = s->block_width;
274  int last_blockheight= s->block_height;
275 
276  /* no supplementary picture */
277  if (buf_size == 0)
278  return 0;
279  if (buf_size < 4)
280  return -1;
281 
282  if ((ret = init_get_bits8(&gb, avpkt->data, buf_size)) < 0)
283  return ret;
284 
285  /* start to parse the bitstream */
286  s->block_width = 16 * (get_bits(&gb, 4) + 1);
287  s->image_width = get_bits(&gb, 12);
288  s->block_height = 16 * (get_bits(&gb, 4) + 1);
289  s->image_height = get_bits(&gb, 12);
290 
291  if ( last_blockwidth != s->block_width
292  || last_blockheight!= s->block_height)
293  av_freep(&s->blocks);
294 
295  if (s->ver == 2) {
296  skip_bits(&gb, 6);
297  if (get_bits1(&gb)) {
298  avpriv_request_sample(avctx, "iframe");
299  return AVERROR_PATCHWELCOME;
300  }
301  if (get_bits1(&gb)) {
302  avpriv_request_sample(avctx, "Custom palette");
303  return AVERROR_PATCHWELCOME;
304  }
305  }
306 
307  /* calculate number of blocks and size of border (partial) blocks */
308  h_blocks = s->image_width / s->block_width;
309  h_part = s->image_width % s->block_width;
310  v_blocks = s->image_height / s->block_height;
311  v_part = s->image_height % s->block_height;
312 
313  /* the block size could change between frames, make sure the buffer
314  * is large enough, if not, get a larger one */
315  if (s->block_size < s->block_width * s->block_height) {
316  int tmpblock_size = 3 * s->block_width * s->block_height, err;
317 
318  if ((err = av_reallocp(&s->tmpblock, tmpblock_size)) < 0) {
319  s->block_size = 0;
321  "Cannot allocate decompression buffer.\n");
322  return err;
323  }
324  if (s->ver == 2) {
325  s->deflate_block_size = calc_deflate_block_size(tmpblock_size);
326  if (s->deflate_block_size <= 0) {
328  "Cannot determine deflate buffer size.\n");
329  return -1;
330  }
331  if ((err = av_reallocp(&s->deflate_block, s->deflate_block_size)) < 0) {
332  s->block_size = 0;
333  av_log(avctx, AV_LOG_ERROR, "Cannot allocate deflate buffer.\n");
334  return err;
335  }
336  }
337  }
338  s->block_size = s->block_width * s->block_height;
339 
340  /* initialize the image size once */
341  if (avctx->width == 0 && avctx->height == 0) {
342  if ((ret = ff_set_dimensions(avctx, s->image_width, s->image_height)) < 0)
343  return ret;
344  }
345 
346  /* check for changes of image width and image height */
347  if (avctx->width != s->image_width || avctx->height != s->image_height) {
349  "Frame width or height differs from first frame!\n");
350  av_log(avctx, AV_LOG_ERROR, "fh = %d, fv %d vs ch = %d, cv = %d\n",
351  avctx->height, avctx->width, s->image_height, s->image_width);
352  return AVERROR_INVALIDDATA;
353  }
354 
355  /* we care for keyframes only in Screen Video v2 */
356  s->is_keyframe = (avpkt->flags & AV_PKT_FLAG_KEY) && (s->ver == 2);
357  if (s->is_keyframe) {
358  int err;
359  if ((err = av_reallocp(&s->keyframedata, avpkt->size)) < 0)
360  return err;
361  memcpy(s->keyframedata, avpkt->data, avpkt->size);
362  }
363  if(s->ver == 2 && !s->blocks)
364  s->blocks = av_mallocz((v_blocks + !!v_part) * (h_blocks + !!h_part) *
365  sizeof(s->blocks[0]));
366 
367  ff_dlog(avctx, "image: %dx%d block: %dx%d num: %dx%d part: %dx%d\n",
368  s->image_width, s->image_height, s->block_width, s->block_height,
369  h_blocks, v_blocks, h_part, v_part);
370 
371  if ((ret = ff_reget_buffer(avctx, s->frame, 0)) < 0)
372  return ret;
373 
374  /* loop over all block columns */
375  for (j = 0; j < v_blocks + (v_part ? 1 : 0); j++) {
376 
377  int y_pos = j * s->block_height; // vertical position in frame
378  int cur_blk_height = (j < v_blocks) ? s->block_height : v_part;
379 
380  /* loop over all block rows */
381  for (i = 0; i < h_blocks + (h_part ? 1 : 0); i++) {
382  int x_pos = i * s->block_width; // horizontal position in frame
383  int cur_blk_width = (i < h_blocks) ? s->block_width : h_part;
384  int has_diff = 0;
385 
386  /* get the size of the compressed zlib chunk */
387  int size = get_bits(&gb, 16);
388 
389  s->color_depth = 0;
390  s->zlibprime_curr = 0;
391  s->zlibprime_prev = 0;
392  s->diff_start = 0;
393  s->diff_height = cur_blk_height;
394 
395  if (8 * size > get_bits_left(&gb)) {
396  av_frame_unref(s->frame);
397  return AVERROR_INVALIDDATA;
398  }
399 
400  if (s->ver == 2 && size) {
401  skip_bits(&gb, 3);
402  s->color_depth = get_bits(&gb, 2);
403  has_diff = get_bits1(&gb);
404  s->zlibprime_curr = get_bits1(&gb);
405  s->zlibprime_prev = get_bits1(&gb);
406 
407  if (s->color_depth != 0 && s->color_depth != 2) {
409  "%dx%d invalid color depth %d\n",
410  i, j, s->color_depth);
411  return AVERROR_INVALIDDATA;
412  }
413 
414  if (has_diff) {
415  if (size < 3) {
416  av_log(avctx, AV_LOG_ERROR, "size too small for diff\n");
417  return AVERROR_INVALIDDATA;
418  }
419  if (!s->keyframe) {
421  "Inter frame without keyframe\n");
422  return AVERROR_INVALIDDATA;
423  }
424  s->diff_start = get_bits(&gb, 8);
425  s->diff_height = get_bits(&gb, 8);
426  if (s->diff_start + s->diff_height > cur_blk_height) {
428  "Block parameters invalid: %d + %d > %d\n",
429  s->diff_start, s->diff_height, cur_blk_height);
430  return AVERROR_INVALIDDATA;
431  }
433  "%dx%d diff start %d height %d\n",
434  i, j, s->diff_start, s->diff_height);
435  size -= 2;
436  }
437 
438  if (s->zlibprime_prev)
439  av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_prev\n", i, j);
440 
441  if (s->zlibprime_curr) {
442  int col = get_bits(&gb, 8);
443  int row = get_bits(&gb, 8);
444  av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_curr %dx%d\n",
445  i, j, col, row);
446  if (size < 3) {
447  av_log(avctx, AV_LOG_ERROR, "size too small for zlibprime_curr\n");
448  return AVERROR_INVALIDDATA;
449  }
450  size -= 2;
451  avpriv_request_sample(avctx, "zlibprime_curr");
452  return AVERROR_PATCHWELCOME;
453  }
454  if (!s->blocks && (s->zlibprime_curr || s->zlibprime_prev)) {
456  "no data available for zlib priming\n");
457  return AVERROR_INVALIDDATA;
458  }
459  size--; // account for flags byte
460  }
461 
462  if (has_diff) {
463  int k;
464  int off = (s->image_height - y_pos - 1) * s->frame->linesize[0];
465 
466  for (k = 0; k < cur_blk_height; k++) {
467  int x = off - k * s->frame->linesize[0] + x_pos * 3;
468  memcpy(s->frame->data[0] + x, s->keyframe + x,
469  cur_blk_width * 3);
470  }
471  }
472 
473  /* skip unchanged blocks, which have size 0 */
474  if (size) {
475  if (flashsv_decode_block(avctx, avpkt, &gb, size,
476  cur_blk_width, cur_blk_height,
477  x_pos, y_pos,
478  i + j * (h_blocks + !!h_part)))
480  "error in decompression of block %dx%d\n", i, j);
481  }
482  }
483  }
484  if (s->is_keyframe && s->ver == 2) {
485  if (!s->keyframe) {
486  s->keyframe = av_malloc(s->frame->linesize[0] * avctx->height);
487  if (!s->keyframe) {
488  av_log(avctx, AV_LOG_ERROR, "Cannot allocate image data\n");
489  return AVERROR(ENOMEM);
490  }
491  }
492  memcpy(s->keyframe, s->frame->data[0],
493  s->frame->linesize[0] * avctx->height);
494  }
495 
496  if ((ret = av_frame_ref(data, s->frame)) < 0)
497  return ret;
498 
499  *got_frame = 1;
500 
501  if ((get_bits_count(&gb) / 8) != buf_size)
502  av_log(avctx, AV_LOG_ERROR, "buffer not fully consumed (%d != %d)\n",
503  buf_size, (get_bits_count(&gb) / 8));
504 
505  /* report that the buffer was completely consumed */
506  return buf_size;
507 }
508 
509 #if CONFIG_FLASHSV_DECODER
510 const AVCodec ff_flashsv_decoder = {
511  .name = "flashsv",
512  .long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video v1"),
513  .type = AVMEDIA_TYPE_VIDEO,
514  .id = AV_CODEC_ID_FLASHSV,
515  .priv_data_size = sizeof(FlashSVContext),
517  .close = flashsv_decode_end,
519  .capabilities = AV_CODEC_CAP_DR1,
522 };
523 #endif /* CONFIG_FLASHSV_DECODER */
524 
525 #if CONFIG_FLASHSV2_DECODER
526 static const uint32_t ff_flashsv2_default_palette[128] = {
527  0x000000, 0x333333, 0x666666, 0x999999, 0xCCCCCC, 0xFFFFFF,
528  0x330000, 0x660000, 0x990000, 0xCC0000, 0xFF0000, 0x003300,
529  0x006600, 0x009900, 0x00CC00, 0x00FF00, 0x000033, 0x000066,
530  0x000099, 0x0000CC, 0x0000FF, 0x333300, 0x666600, 0x999900,
531  0xCCCC00, 0xFFFF00, 0x003333, 0x006666, 0x009999, 0x00CCCC,
532  0x00FFFF, 0x330033, 0x660066, 0x990099, 0xCC00CC, 0xFF00FF,
533  0xFFFF33, 0xFFFF66, 0xFFFF99, 0xFFFFCC, 0xFF33FF, 0xFF66FF,
534  0xFF99FF, 0xFFCCFF, 0x33FFFF, 0x66FFFF, 0x99FFFF, 0xCCFFFF,
535  0xCCCC33, 0xCCCC66, 0xCCCC99, 0xCCCCFF, 0xCC33CC, 0xCC66CC,
536  0xCC99CC, 0xCCFFCC, 0x33CCCC, 0x66CCCC, 0x99CCCC, 0xFFCCCC,
537  0x999933, 0x999966, 0x9999CC, 0x9999FF, 0x993399, 0x996699,
538  0x99CC99, 0x99FF99, 0x339999, 0x669999, 0xCC9999, 0xFF9999,
539  0x666633, 0x666699, 0x6666CC, 0x6666FF, 0x663366, 0x669966,
540  0x66CC66, 0x66FF66, 0x336666, 0x996666, 0xCC6666, 0xFF6666,
541  0x333366, 0x333399, 0x3333CC, 0x3333FF, 0x336633, 0x339933,
542  0x33CC33, 0x33FF33, 0x663333, 0x993333, 0xCC3333, 0xFF3333,
543  0x003366, 0x336600, 0x660033, 0x006633, 0x330066, 0x663300,
544  0x336699, 0x669933, 0x993366, 0x339966, 0x663399, 0x996633,
545  0x6699CC, 0x99CC66, 0xCC6699, 0x66CC99, 0x9966CC, 0xCC9966,
546  0x99CCFF, 0xCCFF99, 0xFF99CC, 0x99FFCC, 0xCC99FF, 0xFFCC99,
547  0x111111, 0x222222, 0x444444, 0x555555, 0xAAAAAA, 0xBBBBBB,
548  0xDDDDDD, 0xEEEEEE
549 };
550 
551 static av_cold int flashsv2_decode_init(AVCodecContext *avctx)
552 {
554  int ret;
555 
557  if (ret < 0)
558  return ret;
559  s->pal = ff_flashsv2_default_palette;
560  s->ver = 2;
561 
562  return 0;
563 }
564 
565 static av_cold int flashsv2_decode_end(AVCodecContext *avctx)
566 {
568 
569  av_freep(&s->keyframedata);
570  av_freep(&s->blocks);
571  av_freep(&s->keyframe);
572  av_freep(&s->deflate_block);
574 
575  return 0;
576 }
577 
579  .name = "flashsv2",
580  .long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video v2"),
581  .type = AVMEDIA_TYPE_VIDEO,
582  .id = AV_CODEC_ID_FLASHSV2,
583  .priv_data_size = sizeof(FlashSVContext),
584  .init = flashsv2_decode_init,
585  .close = flashsv2_decode_end,
587  .capabilities = AV_CODEC_CAP_DR1,
590 };
591 #endif /* CONFIG_FLASHSV2_DECODER */
AVCodec
AVCodec.
Definition: codec.h:202
stride
int stride
Definition: mace.c:144
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:292
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:42
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:850
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:54
flashsv_decode_end
static av_cold int flashsv_decode_end(AVCodecContext *avctx)
Definition: flashsv.c:104
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:220
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:109
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:317
FlashSVContext::pal
const uint32_t * pal
Definition: flashsv.c:60
w
uint8_t w
Definition: llviddspenc.c:38
FlashSVContext::ver
int ver
Definition: flashsv.c:59
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
b
#define b
Definition: input.c:40
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:72
data
const char data[16]
Definition: mxf.c:143
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:428
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
init
static int init
Definition: av_tx.c:47
flashsv_decode_init
static av_cold int flashsv_decode_init(AVCodecContext *avctx)
Definition: flashsv.c:117
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:468
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:380
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:182
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:193
GetBitContext
Definition: get_bits.h:62
FlashSVContext::deflate_block_size
int deflate_block_size
Definition: flashsv.c:66
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:97
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
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:678
FlashSVContext::tmpblock
uint8_t * tmpblock
Definition: flashsv.c:56
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
width
#define width
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
BlockInfo::pos
uint8_t * pos
Definition: flashsv.c:47
g
const char * g
Definition: vf_curves.c:117
FlashSVContext::keyframedata
uint8_t * keyframedata
Definition: flashsv.c:62
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:296
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:61
FlashSVContext::zlibprime_curr
int zlibprime_curr
Definition: flashsv.c:68
AV_CODEC_ID_FLASHSV2
@ AV_CODEC_ID_FLASHSV2
Definition: codec_id.h:181
NULL
#define NULL
Definition: coverity.c:32
FlashSVContext::frame
AVFrame * frame
Definition: flashsv.c:53
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
FlashSVContext::color_depth
int color_depth
Definition: flashsv.c:67
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:499
src
#define src
Definition: vp8dsp.c:255
deflate
static void deflate(uint8_t *dst, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord, int maxc)
Definition: vf_neighbor.c:160
FlashSVContext
Definition: flashsv.c:51
FlashSVContext::zlibprime_prev
int zlibprime_prev
Definition: flashsv.c:68
AV_CODEC_ID_FLASHSV
@ AV_CODEC_ID_FLASHSV
Definition: codec_id.h:136
BlockInfo::size
int size
Definition: flashsv.c:48
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
BlockInfo
Definition: dvdec.c:55
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
FlashSVContext::blocks
BlockInfo * blocks
Definition: flashsv.c:64
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:374
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:325
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:185
height
#define height
flashsv_decode_frame
static int flashsv_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: flashsv.c:266
FlashSVContext::block_height
int block_height
Definition: flashsv.c:55
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
line
Definition: graph2dot.c:48
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:379
FlashSVContext::block_width
int block_width
Definition: flashsv.c:55
FlashSVContext::diff_height
int diff_height
Definition: flashsv.c:69
flashsv2_prime
static int flashsv2_prime(FlashSVContext *s, uint8_t *src, int size)
Definition: flashsv.c:141
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
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: internal.h:50
FlashSVContext::block_size
int block_size
Definition: flashsv.c:57
ff_flashsv2_decoder
const AVCodec ff_flashsv2_decoder
FlashSVContext::image_height
int image_height
Definition: flashsv.c:54
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:435
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:263
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
AVCodecContext::height
int height
Definition: avcodec.h:556
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:593
avcodec.h
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:1759
ret
ret
Definition: filter_design.txt:187
AVCodecContext
main external API structure.
Definition: avcodec.h:383
FlashSVContext::keyframe
uint8_t * keyframe
Definition: flashsv.c:63
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
FlashSVContext::diff_start
int diff_start
Definition: flashsv.c:69
calc_deflate_block_size
static int calc_deflate_block_size(int tmpblock_size)
Definition: flashsv.c:250
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
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:86
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:37
ff_flashsv_decoder
const AVCodec ff_flashsv_decoder
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
FlashSVContext::deflate_block
uint8_t * deflate_block
Definition: flashsv.c:65
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:556
bytestream.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
h
h
Definition: vp9dsp_template.c:2038
FlashSVContext::avctx
AVCodecContext * avctx
Definition: flashsv.c:52
FlashSVContext::zstream
z_stream zstream
Definition: flashsv.c:58
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