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 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 1;
130  }
131  avctx->pix_fmt = AV_PIX_FMT_BGR24;
132 
133  s->frame = av_frame_alloc();
134  if (!s->frame) {
135  flashsv_decode_end(avctx);
136  return AVERROR(ENOMEM);
137  }
138 
139  return 0;
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 
223  y_pos += s->diff_start;
224 
225  if (!s->color_depth) {
226  /* Flash Screen Video stores the image upside down, so copy
227  * lines to destination in reverse order. */
228  for (k = 1; k <= s->diff_height; k++) {
229  memcpy(s->frame->data[0] + x_pos * 3 +
230  (s->image_height - y_pos - k) * s->frame->linesize[0],
231  line, width * 3);
232  /* advance source pointer to next line */
233  line += width * 3;
234  }
235  } else {
236  /* hybrid 15-bit/palette mode */
237  ret = decode_hybrid(s->tmpblock, s->zstream.next_out,
238  s->frame->data[0],
239  s->image_height - (y_pos + 1 + s->diff_height),
240  x_pos, s->diff_height, width,
241  s->frame->linesize[0], s->pal);
242  if (ret < 0) {
243  av_log(avctx, AV_LOG_ERROR, "decode_hybrid failed\n");
244  return ret;
245  }
246  }
247  skip_bits_long(gb, 8 * block_size); /* skip the consumed bits */
248  return 0;
249 }
250 
251 static int calc_deflate_block_size(int tmpblock_size)
252 {
253  z_stream zstream;
254  int size;
255 
256  zstream.zalloc = Z_NULL;
257  zstream.zfree = Z_NULL;
258  zstream.opaque = Z_NULL;
259  if (deflateInit(&zstream, 0) != Z_OK)
260  return -1;
261  size = deflateBound(&zstream, tmpblock_size);
262  deflateEnd(&zstream);
263 
264  return size;
265 }
266 
268  int *got_frame, AVPacket *avpkt)
269 {
270  int buf_size = avpkt->size;
271  FlashSVContext *s = avctx->priv_data;
272  int h_blocks, v_blocks, h_part, v_part, i, j, ret;
273  GetBitContext gb;
274  int last_blockwidth = s->block_width;
275  int last_blockheight= s->block_height;
276 
277  /* no supplementary picture */
278  if (buf_size == 0)
279  return 0;
280  if (buf_size < 4)
281  return -1;
282 
283  if ((ret = init_get_bits8(&gb, avpkt->data, buf_size)) < 0)
284  return ret;
285 
286  /* start to parse the bitstream */
287  s->block_width = 16 * (get_bits(&gb, 4) + 1);
288  s->image_width = get_bits(&gb, 12);
289  s->block_height = 16 * (get_bits(&gb, 4) + 1);
290  s->image_height = get_bits(&gb, 12);
291 
292  if ( last_blockwidth != s->block_width
293  || last_blockheight!= s->block_height)
294  av_freep(&s->blocks);
295 
296  if (s->ver == 2) {
297  skip_bits(&gb, 6);
298  if (get_bits1(&gb)) {
299  avpriv_request_sample(avctx, "iframe");
300  return AVERROR_PATCHWELCOME;
301  }
302  if (get_bits1(&gb)) {
303  avpriv_request_sample(avctx, "Custom palette");
304  return AVERROR_PATCHWELCOME;
305  }
306  }
307 
308  /* calculate number of blocks and size of border (partial) blocks */
309  h_blocks = s->image_width / s->block_width;
310  h_part = s->image_width % s->block_width;
311  v_blocks = s->image_height / s->block_height;
312  v_part = s->image_height % s->block_height;
313 
314  /* the block size could change between frames, make sure the buffer
315  * is large enough, if not, get a larger one */
316  if (s->block_size < s->block_width * s->block_height) {
317  int tmpblock_size = 3 * s->block_width * s->block_height, err;
318 
319  if ((err = av_reallocp(&s->tmpblock, tmpblock_size)) < 0) {
320  s->block_size = 0;
321  av_log(avctx, AV_LOG_ERROR,
322  "Cannot allocate decompression buffer.\n");
323  return err;
324  }
325  if (s->ver == 2) {
326  s->deflate_block_size = calc_deflate_block_size(tmpblock_size);
327  if (s->deflate_block_size <= 0) {
328  av_log(avctx, AV_LOG_ERROR,
329  "Cannot determine deflate buffer size.\n");
330  return -1;
331  }
332  if ((err = av_reallocp(&s->deflate_block, s->deflate_block_size)) < 0) {
333  s->block_size = 0;
334  av_log(avctx, AV_LOG_ERROR, "Cannot allocate deflate buffer.\n");
335  return err;
336  }
337  }
338  }
339  s->block_size = s->block_width * s->block_height;
340 
341  /* initialize the image size once */
342  if (avctx->width == 0 && avctx->height == 0) {
343  if ((ret = ff_set_dimensions(avctx, s->image_width, s->image_height)) < 0)
344  return ret;
345  }
346 
347  /* check for changes of image width and image height */
348  if (avctx->width != s->image_width || avctx->height != s->image_height) {
349  av_log(avctx, AV_LOG_ERROR,
350  "Frame width or height differs from first frame!\n");
351  av_log(avctx, AV_LOG_ERROR, "fh = %d, fv %d vs ch = %d, cv = %d\n",
352  avctx->height, avctx->width, s->image_height, s->image_width);
353  return AVERROR_INVALIDDATA;
354  }
355 
356  /* we care for keyframes only in Screen Video v2 */
357  s->is_keyframe = (avpkt->flags & AV_PKT_FLAG_KEY) && (s->ver == 2);
358  if (s->is_keyframe) {
359  int err;
360  if ((err = av_reallocp(&s->keyframedata, avpkt->size)) < 0)
361  return err;
362  memcpy(s->keyframedata, avpkt->data, avpkt->size);
363  }
364  if(s->ver == 2 && !s->blocks)
365  s->blocks = av_mallocz((v_blocks + !!v_part) * (h_blocks + !!h_part) *
366  sizeof(s->blocks[0]));
367 
368  ff_dlog(avctx, "image: %dx%d block: %dx%d num: %dx%d part: %dx%d\n",
370  h_blocks, v_blocks, h_part, v_part);
371 
372  if ((ret = ff_reget_buffer(avctx, s->frame)) < 0)
373  return ret;
374 
375  /* loop over all block columns */
376  for (j = 0; j < v_blocks + (v_part ? 1 : 0); j++) {
377 
378  int y_pos = j * s->block_height; // vertical position in frame
379  int cur_blk_height = (j < v_blocks) ? s->block_height : v_part;
380 
381  /* loop over all block rows */
382  for (i = 0; i < h_blocks + (h_part ? 1 : 0); i++) {
383  int x_pos = i * s->block_width; // horizontal position in frame
384  int cur_blk_width = (i < h_blocks) ? s->block_width : h_part;
385  int has_diff = 0;
386 
387  /* get the size of the compressed zlib chunk */
388  int size = get_bits(&gb, 16);
389 
390  s->color_depth = 0;
391  s->zlibprime_curr = 0;
392  s->zlibprime_prev = 0;
393  s->diff_start = 0;
394  s->diff_height = cur_blk_height;
395 
396  if (8 * size > get_bits_left(&gb)) {
397  av_frame_unref(s->frame);
398  return AVERROR_INVALIDDATA;
399  }
400 
401  if (s->ver == 2 && size) {
402  skip_bits(&gb, 3);
403  s->color_depth = get_bits(&gb, 2);
404  has_diff = get_bits1(&gb);
405  s->zlibprime_curr = get_bits1(&gb);
406  s->zlibprime_prev = get_bits1(&gb);
407 
408  if (s->color_depth != 0 && s->color_depth != 2) {
409  av_log(avctx, AV_LOG_ERROR,
410  "%dx%d invalid color depth %d\n",
411  i, j, s->color_depth);
412  return AVERROR_INVALIDDATA;
413  }
414 
415  if (has_diff) {
416  if (size < 3) {
417  av_log(avctx, AV_LOG_ERROR, "size too small for diff\n");
418  return AVERROR_INVALIDDATA;
419  }
420  if (!s->keyframe) {
421  av_log(avctx, AV_LOG_ERROR,
422  "Inter frame without keyframe\n");
423  return AVERROR_INVALIDDATA;
424  }
425  s->diff_start = get_bits(&gb, 8);
426  s->diff_height = get_bits(&gb, 8);
427  if (s->diff_start + s->diff_height > cur_blk_height) {
428  av_log(avctx, AV_LOG_ERROR,
429  "Block parameters invalid: %d + %d > %d\n",
430  s->diff_start, s->diff_height, cur_blk_height);
431  return AVERROR_INVALIDDATA;
432  }
433  av_log(avctx, AV_LOG_DEBUG,
434  "%dx%d diff start %d height %d\n",
435  i, j, s->diff_start, s->diff_height);
436  size -= 2;
437  }
438 
439  if (s->zlibprime_prev)
440  av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_prev\n", i, j);
441 
442  if (s->zlibprime_curr) {
443  int col = get_bits(&gb, 8);
444  int row = get_bits(&gb, 8);
445  av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_curr %dx%d\n",
446  i, j, col, row);
447  if (size < 3) {
448  av_log(avctx, AV_LOG_ERROR, "size too small for zlibprime_curr\n");
449  return AVERROR_INVALIDDATA;
450  }
451  size -= 2;
452  avpriv_request_sample(avctx, "zlibprime_curr");
453  return AVERROR_PATCHWELCOME;
454  }
455  if (!s->blocks && (s->zlibprime_curr || s->zlibprime_prev)) {
456  av_log(avctx, AV_LOG_ERROR,
457  "no data available for zlib priming\n");
458  return AVERROR_INVALIDDATA;
459  }
460  size--; // account for flags byte
461  }
462 
463  if (has_diff) {
464  int k;
465  int off = (s->image_height - y_pos - 1) * s->frame->linesize[0];
466 
467  for (k = 0; k < cur_blk_height; k++) {
468  int x = off - k * s->frame->linesize[0] + x_pos * 3;
469  memcpy(s->frame->data[0] + x, s->keyframe + x,
470  cur_blk_width * 3);
471  }
472  }
473 
474  /* skip unchanged blocks, which have size 0 */
475  if (size) {
476  if (flashsv_decode_block(avctx, avpkt, &gb, size,
477  cur_blk_width, cur_blk_height,
478  x_pos, y_pos,
479  i + j * (h_blocks + !!h_part)))
480  av_log(avctx, AV_LOG_ERROR,
481  "error in decompression of block %dx%d\n", i, j);
482  }
483  }
484  }
485  if (s->is_keyframe && s->ver == 2) {
486  if (!s->keyframe) {
487  s->keyframe = av_malloc(s->frame->linesize[0] * avctx->height);
488  if (!s->keyframe) {
489  av_log(avctx, AV_LOG_ERROR, "Cannot allocate image data\n");
490  return AVERROR(ENOMEM);
491  }
492  }
493  memcpy(s->keyframe, s->frame->data[0],
494  s->frame->linesize[0] * avctx->height);
495  }
496 
497  if ((ret = av_frame_ref(data, s->frame)) < 0)
498  return ret;
499 
500  *got_frame = 1;
501 
502  if ((get_bits_count(&gb) / 8) != buf_size)
503  av_log(avctx, AV_LOG_ERROR, "buffer not fully consumed (%d != %d)\n",
504  buf_size, (get_bits_count(&gb) / 8));
505 
506  /* report that the buffer was completely consumed */
507  return buf_size;
508 }
509 
510 #if CONFIG_FLASHSV_DECODER
511 AVCodec ff_flashsv_decoder = {
512  .name = "flashsv",
513  .long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video v1"),
514  .type = AVMEDIA_TYPE_VIDEO,
515  .id = AV_CODEC_ID_FLASHSV,
516  .priv_data_size = sizeof(FlashSVContext),
518  .close = flashsv_decode_end,
520  .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 {
553  FlashSVContext *s = avctx->priv_data;
554  flashsv_decode_init(avctx);
555  s->pal = ff_flashsv2_default_palette;
556  s->ver = 2;
557 
558  return 0;
559 }
560 
561 static av_cold int flashsv2_decode_end(AVCodecContext *avctx)
562 {
563  FlashSVContext *s = avctx->priv_data;
564 
565  av_freep(&s->keyframedata);
566  av_freep(&s->blocks);
567  av_freep(&s->keyframe);
568  av_freep(&s->deflate_block);
569  flashsv_decode_end(avctx);
570 
571  return 0;
572 }
573 
574 AVCodec ff_flashsv2_decoder = {
575  .name = "flashsv2",
576  .long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video v2"),
577  .type = AVMEDIA_TYPE_VIDEO,
578  .id = AV_CODEC_ID_FLASHSV2,
579  .priv_data_size = sizeof(FlashSVContext),
580  .init = flashsv2_decode_init,
581  .close = flashsv2_decode_end,
583  .capabilities = AV_CODEC_CAP_DR1,
585 };
586 #endif /* CONFIG_FLASHSV2_DECODER */
int zlibprime_prev
Definition: flashsv.c:68
#define NULL
Definition: coverity.c:32
const char * s
Definition: avisynth_c.h:768
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:184
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
int size
Definition: flashsv.c:48
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:247
uint8_t * keyframe
Definition: flashsv.c:63
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:210
static void skip_bits_long(GetBitContext *s, int n)
Definition: get_bits.h:204
const char * g
Definition: vf_curves.c:112
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int size
Definition: avcodec.h:1591
const char * b
Definition: vf_curves.c:113
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1887
AVFrame * frame
Definition: flashsv.c:53
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:252
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:87
AVCodec.
Definition: avcodec.h:3573
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
const uint32_t * pal
Definition: flashsv.c:60
static av_cold int flashsv_decode_end(AVCodecContext *avctx)
Definition: flashsv.c:104
AVCodecContext * avctx
Definition: flashsv.c:52
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
uint8_t
#define av_cold
Definition: attributes.h:82
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:140
static void deflate(uint8_t *dst, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord)
Definition: vf_neighbor.c:114
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:374
#define height
uint8_t * data
Definition: avcodec.h:1590
static void inflate(uint8_t *dst, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord)
Definition: vf_neighbor.c:129
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:199
#define ff_dlog(a,...)
bitstream reader API header.
int image_width
Definition: flashsv.c:54
ptrdiff_t size
Definition: opengl_enc.c:101
int diff_start
Definition: flashsv.c:69
#define av_log(a,...)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1622
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:568
static av_cold int flashsv_decode_init(AVCodecContext *avctx)
Definition: flashsv.c:117
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int block_width
Definition: flashsv.c:55
#define AVERROR(e)
Definition: error.h:43
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:153
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:176
const char * r
Definition: vf_curves.c:111
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
Definition: graph2dot.c:48
const char * name
Name of the codec implementation.
Definition: avcodec.h:3580
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1596
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame)
Identical in function to av_frame_make_writable(), except it uses ff_get_buffer() to allocate the buf...
Definition: utils.c:977
#define width
int width
picture width / height.
Definition: avcodec.h:1846
static int flashsv2_prime(FlashSVContext *s, uint8_t *src, int size)
Definition: flashsv.c:142
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:65
static int flashsv_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: flashsv.c:267
#define src
Definition: vp9dsp.c:530
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int block_size
Definition: flashsv.c:57
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:187
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:215
uint8_t pos
Definition: dvdec.c:56
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:437
main external API structure.
Definition: avcodec.h:1659
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:299
static int calc_deflate_block_size(int tmpblock_size)
Definition: flashsv.c:251
int zlibprime_curr
Definition: flashsv.c:68
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:292
int is_keyframe
Definition: flashsv.c:61
z_stream zstream
Definition: flashsv.c:58
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:262
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:484
int color_depth
Definition: flashsv.c:67
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:198
int deflate_block_size
Definition: flashsv.c:66
static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)
Definition: ccaption_dec.c:752
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:105
uint8_t * pos
Definition: flashsv.c:47
common internal api header.
static double c[64]
uint8_t * deflate_block
Definition: flashsv.c:65
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:71
BlockInfo * blocks
Definition: flashsv.c:64
void * priv_data
Definition: avcodec.h:1701
uint8_t * tmpblock
Definition: flashsv.c:56
uint8_t * keyframedata
Definition: flashsv.c:62
#define av_freep(p)
static int flashsv_decode_block(AVCodecContext *avctx, AVPacket *avpkt, GetBitContext *gb, int block_size, int width, int height, int x_pos, int y_pos, int blk_idx)
Definition: flashsv.c:183
int block_height
Definition: flashsv.c:55
#define stride
AVPixelFormat
Pixel format.
Definition: pixfmt.h:60
This structure stores compressed data.
Definition: avcodec.h:1567
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:958
int diff_height
Definition: flashsv.c:69
for(j=16;j >0;--j)
int image_height
Definition: flashsv.c:54