Libav
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 Libav.
7  *
8  * Libav 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  * Libav 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 Libav; 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 #include "internal.h"
45 
46 typedef struct BlockInfo {
48  int size;
49 } BlockInfo;
50 
51 typedef struct FlashSVContext {
54  int image_width, image_height;
55  int block_width, block_height;
58  z_stream zstream;
59  int ver;
60  const uint32_t *pal;
68  int zlibprime_curr, zlibprime_prev;
69  int diff_start, diff_height;
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  inflateEnd(&s->zstream);
106  /* release the frame if needed */
107  av_frame_free(&s->frame);
108 
109  /* free the tmpblock */
110  av_free(s->tmpblock);
111 
112  return 0;
113 }
114 
116 {
117  FlashSVContext *s = avctx->priv_data;
118  int zret; // Zlib return code
119 
120  s->avctx = avctx;
121  s->zstream.zalloc = Z_NULL;
122  s->zstream.zfree = Z_NULL;
123  s->zstream.opaque = Z_NULL;
124  zret = inflateInit(&s->zstream);
125  if (zret != Z_OK) {
126  av_log(avctx, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
127  return 1;
128  }
129  avctx->pix_fmt = AV_PIX_FMT_BGR24;
130 
131  s->frame = av_frame_alloc();
132  if (!s->frame) {
133  flashsv_decode_end(avctx);
134  return AVERROR(ENOMEM);
135  }
136 
137  return 0;
138 }
139 
140 static int flashsv2_prime(FlashSVContext *s, uint8_t *src, int size)
141 {
142  z_stream zs;
143  int zret; // Zlib return code
144 
145  zs.zalloc = NULL;
146  zs.zfree = NULL;
147  zs.opaque = NULL;
148 
149  s->zstream.next_in = src;
150  s->zstream.avail_in = size;
151  s->zstream.next_out = s->tmpblock;
152  s->zstream.avail_out = s->block_size * 3;
153  inflate(&s->zstream, Z_SYNC_FLUSH);
154 
155  deflateInit(&zs, 0);
156  zs.next_in = s->tmpblock;
157  zs.avail_in = s->block_size * 3 - s->zstream.avail_out;
158  zs.next_out = s->deflate_block;
159  zs.avail_out = s->deflate_block_size;
160  deflate(&zs, Z_SYNC_FLUSH);
161  deflateEnd(&zs);
162 
163  if ((zret = inflateReset(&s->zstream)) != Z_OK) {
164  av_log(s->avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);
165  return AVERROR_UNKNOWN;
166  }
167 
168  s->zstream.next_in = s->deflate_block;
169  s->zstream.avail_in = s->deflate_block_size - zs.avail_out;
170  s->zstream.next_out = s->tmpblock;
171  s->zstream.avail_out = s->block_size * 3;
172  inflate(&s->zstream, Z_SYNC_FLUSH);
173 
174  return 0;
175 }
176 
177 static int flashsv_decode_block(AVCodecContext *avctx, AVPacket *avpkt,
178  GetBitContext *gb, int block_size,
179  int width, int height, int x_pos, int y_pos,
180  int blk_idx)
181 {
182  struct FlashSVContext *s = avctx->priv_data;
183  uint8_t *line = s->tmpblock;
184  int k;
185  int ret = inflateReset(&s->zstream);
186  if (ret != Z_OK) {
187  av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", ret);
188  return AVERROR_UNKNOWN;
189  }
190  if (s->zlibprime_curr || s->zlibprime_prev) {
191  ret = flashsv2_prime(s,
192  s->blocks[blk_idx].pos,
193  s->blocks[blk_idx].size);
194  if (ret < 0)
195  return ret;
196  }
197  s->zstream.next_in = avpkt->data + get_bits_count(gb) / 8;
198  s->zstream.avail_in = block_size;
199  s->zstream.next_out = s->tmpblock;
200  s->zstream.avail_out = s->block_size * 3;
201  ret = inflate(&s->zstream, Z_FINISH);
202  if (ret == Z_DATA_ERROR) {
203  av_log(avctx, AV_LOG_ERROR, "Zlib resync occurred\n");
204  inflateSync(&s->zstream);
205  ret = inflate(&s->zstream, Z_FINISH);
206  }
207 
208  if (ret != Z_OK && ret != Z_STREAM_END) {
209  //return -1;
210  }
211 
212  if (s->is_keyframe) {
213  s->blocks[blk_idx].pos = s->keyframedata + (get_bits_count(gb) / 8);
214  s->blocks[blk_idx].size = block_size;
215  }
216 
217  y_pos += s->diff_start;
218 
219  if (!s->color_depth) {
220  /* Flash Screen Video stores the image upside down, so copy
221  * lines to destination in reverse order. */
222  for (k = 1; k <= s->diff_height; k++) {
223  memcpy(s->frame->data[0] + x_pos * 3 +
224  (s->image_height - y_pos - k) * s->frame->linesize[0],
225  line, width * 3);
226  /* advance source pointer to next line */
227  line += width * 3;
228  }
229  } else {
230  /* hybrid 15-bit/palette mode */
231  decode_hybrid(s->tmpblock, s->frame->data[0],
232  s->image_height - (y_pos + 1 + s->diff_height),
233  x_pos, s->diff_height, width,
234  s->frame->linesize[0], s->pal);
235  }
236  skip_bits_long(gb, 8 * block_size); /* skip the consumed bits */
237  return 0;
238 }
239 
240 static int calc_deflate_block_size(int tmpblock_size)
241 {
242  z_stream zstream;
243  int size;
244 
245  zstream.zalloc = Z_NULL;
246  zstream.zfree = Z_NULL;
247  zstream.opaque = Z_NULL;
248  if (deflateInit(&zstream, 0) != Z_OK)
249  return -1;
250  size = deflateBound(&zstream, tmpblock_size);
251  deflateEnd(&zstream);
252 
253  return size;
254 }
255 
257  int *got_frame, AVPacket *avpkt)
258 {
259  int buf_size = avpkt->size;
260  FlashSVContext *s = avctx->priv_data;
261  int h_blocks, v_blocks, h_part, v_part, i, j, ret;
262  GetBitContext gb;
263 
264  /* no supplementary picture */
265  if (buf_size == 0)
266  return 0;
267  if (buf_size < 4)
268  return -1;
269 
270  init_get_bits(&gb, avpkt->data, buf_size * 8);
271 
272  /* start to parse the bitstream */
273  s->block_width = 16 * (get_bits(&gb, 4) + 1);
274  s->image_width = get_bits(&gb, 12);
275  s->block_height = 16 * (get_bits(&gb, 4) + 1);
276  s->image_height = get_bits(&gb, 12);
277 
278  if (s->ver == 2) {
279  skip_bits(&gb, 6);
280  if (get_bits1(&gb)) {
281  avpriv_request_sample(avctx, "iframe");
282  return AVERROR_PATCHWELCOME;
283  }
284  if (get_bits1(&gb)) {
285  avpriv_request_sample(avctx, "Custom palette");
286  return AVERROR_PATCHWELCOME;
287  }
288  }
289 
290  /* calculate number of blocks and size of border (partial) blocks */
291  h_blocks = s->image_width / s->block_width;
292  h_part = s->image_width % s->block_width;
293  v_blocks = s->image_height / s->block_height;
294  v_part = s->image_height % s->block_height;
295 
296  /* the block size could change between frames, make sure the buffer
297  * is large enough, if not, get a larger one */
298  if (s->block_size < s->block_width * s->block_height) {
299  int tmpblock_size = 3 * s->block_width * s->block_height, err;
300 
301  if ((err = av_reallocp(&s->tmpblock, tmpblock_size)) < 0) {
302  s->block_size = 0;
303  av_log(avctx, AV_LOG_ERROR,
304  "Cannot allocate decompression buffer.\n");
305  return err;
306  }
307  if (s->ver == 2) {
308  s->deflate_block_size = calc_deflate_block_size(tmpblock_size);
309  if (s->deflate_block_size <= 0) {
310  av_log(avctx, AV_LOG_ERROR,
311  "Cannot determine deflate buffer size.\n");
312  return -1;
313  }
314  if ((err = av_reallocp(&s->deflate_block, s->deflate_block_size)) < 0) {
315  s->block_size = 0;
316  av_log(avctx, AV_LOG_ERROR, "Cannot allocate deflate buffer.\n");
317  return err;
318  }
319  }
320  }
321  s->block_size = s->block_width * s->block_height;
322 
323  /* initialize the image size once */
324  if (avctx->width == 0 && avctx->height == 0) {
325  avctx->width = s->image_width;
326  avctx->height = s->image_height;
327  }
328 
329  /* check for changes of image width and image height */
330  if (avctx->width != s->image_width || avctx->height != s->image_height) {
331  av_log(avctx, AV_LOG_ERROR,
332  "Frame width or height differs from first frame!\n");
333  av_log(avctx, AV_LOG_ERROR, "fh = %d, fv %d vs ch = %d, cv = %d\n",
334  avctx->height, avctx->width, s->image_height, s->image_width);
335  return AVERROR_INVALIDDATA;
336  }
337 
338  /* we care for keyframes only in Screen Video v2 */
339  s->is_keyframe = (avpkt->flags & AV_PKT_FLAG_KEY) && (s->ver == 2);
340  if (s->is_keyframe) {
341  int err;
342  int nb_blocks = (v_blocks + !!v_part) *
343  (h_blocks + !!h_part) * sizeof(s->blocks[0]);
344  if ((err = av_reallocp(&s->keyframedata, avpkt->size)) < 0)
345  return err;
346  memcpy(s->keyframedata, avpkt->data, avpkt->size);
347  if ((err = av_reallocp(&s->blocks, nb_blocks)) < 0)
348  return err;
349  memset(s->blocks, 0, nb_blocks);
350  }
351 
352  av_dlog(avctx, "image: %dx%d block: %dx%d num: %dx%d part: %dx%d\n",
354  h_blocks, v_blocks, h_part, v_part);
355 
356  if ((ret = ff_reget_buffer(avctx, s->frame)) < 0) {
357  av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
358  return ret;
359  }
360 
361  /* loop over all block columns */
362  for (j = 0; j < v_blocks + (v_part ? 1 : 0); j++) {
363 
364  int y_pos = j * s->block_height; // vertical position in frame
365  int cur_blk_height = (j < v_blocks) ? s->block_height : v_part;
366 
367  /* loop over all block rows */
368  for (i = 0; i < h_blocks + (h_part ? 1 : 0); i++) {
369  int x_pos = i * s->block_width; // horizontal position in frame
370  int cur_blk_width = (i < h_blocks) ? s->block_width : h_part;
371  int has_diff = 0;
372 
373  /* get the size of the compressed zlib chunk */
374  int size = get_bits(&gb, 16);
375 
376  s->color_depth = 0;
377  s->zlibprime_curr = 0;
378  s->zlibprime_prev = 0;
379  s->diff_start = 0;
380  s->diff_height = cur_blk_height;
381 
382  if (8 * size > get_bits_left(&gb)) {
383  av_frame_unref(s->frame);
384  return AVERROR_INVALIDDATA;
385  }
386 
387  if (s->ver == 2 && size) {
388  skip_bits(&gb, 3);
389  s->color_depth = get_bits(&gb, 2);
390  has_diff = get_bits1(&gb);
391  s->zlibprime_curr = get_bits1(&gb);
392  s->zlibprime_prev = get_bits1(&gb);
393 
394  if (s->color_depth != 0 && s->color_depth != 2) {
395  av_log(avctx, AV_LOG_ERROR,
396  "%dx%d invalid color depth %d\n",
397  i, j, s->color_depth);
398  return AVERROR_INVALIDDATA;
399  }
400 
401  if (has_diff) {
402  if (!s->keyframe) {
403  av_log(avctx, AV_LOG_ERROR,
404  "Inter frame without keyframe\n");
405  return AVERROR_INVALIDDATA;
406  }
407  s->diff_start = get_bits(&gb, 8);
408  s->diff_height = get_bits(&gb, 8);
409  if (s->diff_start + s->diff_height > cur_blk_height) {
410  av_log(avctx, AV_LOG_ERROR,
411  "Block parameters invalid: %d + %d > %d\n",
412  s->diff_start, s->diff_height, cur_blk_height);
413  return AVERROR_INVALIDDATA;
414  }
415  av_log(avctx, AV_LOG_DEBUG,
416  "%dx%d diff start %d height %d\n",
417  i, j, s->diff_start, s->diff_height);
418  size -= 2;
419  }
420 
421  if (s->zlibprime_prev)
422  av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_prev\n", i, j);
423 
424  if (s->zlibprime_curr) {
425  int col = get_bits(&gb, 8);
426  int row = get_bits(&gb, 8);
427  av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_curr %dx%d\n",
428  i, j, col, row);
429  size -= 2;
430  avpriv_request_sample(avctx, "zlibprime_curr");
431  return AVERROR_PATCHWELCOME;
432  }
433  if (!s->blocks && (s->zlibprime_curr || s->zlibprime_prev)) {
434  av_log(avctx, AV_LOG_ERROR,
435  "no data available for zlib priming\n");
436  return AVERROR_INVALIDDATA;
437  }
438  size--; // account for flags byte
439  }
440 
441  if (has_diff) {
442  int k;
443  int off = (s->image_height - y_pos - 1) * s->frame->linesize[0];
444 
445  for (k = 0; k < cur_blk_height; k++) {
446  int x = off - k * s->frame->linesize[0] + x_pos * 3;
447  memcpy(s->frame->data[0] + x, s->keyframe + x,
448  cur_blk_width * 3);
449  }
450  }
451 
452  /* skip unchanged blocks, which have size 0 */
453  if (size) {
454  if (flashsv_decode_block(avctx, avpkt, &gb, size,
455  cur_blk_width, cur_blk_height,
456  x_pos, y_pos,
457  i + j * (h_blocks + !!h_part)))
458  av_log(avctx, AV_LOG_ERROR,
459  "error in decompression of block %dx%d\n", i, j);
460  }
461  }
462  }
463  if (s->is_keyframe && s->ver == 2) {
464  if (!s->keyframe) {
465  s->keyframe = av_malloc(s->frame->linesize[0] * avctx->height);
466  if (!s->keyframe) {
467  av_log(avctx, AV_LOG_ERROR, "Cannot allocate image data\n");
468  return AVERROR(ENOMEM);
469  }
470  }
471  memcpy(s->keyframe, s->frame->data[0],
472  s->frame->linesize[0] * avctx->height);
473  }
474 
475  if ((ret = av_frame_ref(data, s->frame)) < 0)
476  return ret;
477 
478  *got_frame = 1;
479 
480  if ((get_bits_count(&gb) / 8) != buf_size)
481  av_log(avctx, AV_LOG_ERROR, "buffer not fully consumed (%d != %d)\n",
482  buf_size, (get_bits_count(&gb) / 8));
483 
484  /* report that the buffer was completely consumed */
485  return buf_size;
486 }
487 
488 #if CONFIG_FLASHSV_DECODER
489 AVCodec ff_flashsv_decoder = {
490  .name = "flashsv",
491  .long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video v1"),
492  .type = AVMEDIA_TYPE_VIDEO,
493  .id = AV_CODEC_ID_FLASHSV,
494  .priv_data_size = sizeof(FlashSVContext),
498  .capabilities = CODEC_CAP_DR1,
499  .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE },
500 };
501 #endif /* CONFIG_FLASHSV_DECODER */
502 
503 #if CONFIG_FLASHSV2_DECODER
504 static const uint32_t ff_flashsv2_default_palette[128] = {
505  0x000000, 0x333333, 0x666666, 0x999999, 0xCCCCCC, 0xFFFFFF,
506  0x330000, 0x660000, 0x990000, 0xCC0000, 0xFF0000, 0x003300,
507  0x006600, 0x009900, 0x00CC00, 0x00FF00, 0x000033, 0x000066,
508  0x000099, 0x0000CC, 0x0000FF, 0x333300, 0x666600, 0x999900,
509  0xCCCC00, 0xFFFF00, 0x003333, 0x006666, 0x009999, 0x00CCCC,
510  0x00FFFF, 0x330033, 0x660066, 0x990099, 0xCC00CC, 0xFF00FF,
511  0xFFFF33, 0xFFFF66, 0xFFFF99, 0xFFFFCC, 0xFF33FF, 0xFF66FF,
512  0xFF99FF, 0xFFCCFF, 0x33FFFF, 0x66FFFF, 0x99FFFF, 0xCCFFFF,
513  0xCCCC33, 0xCCCC66, 0xCCCC99, 0xCCCCFF, 0xCC33CC, 0xCC66CC,
514  0xCC99CC, 0xCCFFCC, 0x33CCCC, 0x66CCCC, 0x99CCCC, 0xFFCCCC,
515  0x999933, 0x999966, 0x9999CC, 0x9999FF, 0x993399, 0x996699,
516  0x99CC99, 0x99FF99, 0x339999, 0x669999, 0xCC9999, 0xFF9999,
517  0x666633, 0x666699, 0x6666CC, 0x6666FF, 0x663366, 0x669966,
518  0x66CC66, 0x66FF66, 0x336666, 0x996666, 0xCC6666, 0xFF6666,
519  0x333366, 0x333399, 0x3333CC, 0x3333FF, 0x336633, 0x339933,
520  0x33CC33, 0x33FF33, 0x663333, 0x993333, 0xCC3333, 0xFF3333,
521  0x003366, 0x336600, 0x660033, 0x006633, 0x330066, 0x663300,
522  0x336699, 0x669933, 0x993366, 0x339966, 0x663399, 0x996633,
523  0x6699CC, 0x99CC66, 0xCC6699, 0x66CC99, 0x9966CC, 0xCC9966,
524  0x99CCFF, 0xCCFF99, 0xFF99CC, 0x99FFCC, 0xCC99FF, 0xFFCC99,
525  0x111111, 0x222222, 0x444444, 0x555555, 0xAAAAAA, 0xBBBBBB,
526  0xDDDDDD, 0xEEEEEE
527 };
528 
529 static av_cold int flashsv2_decode_init(AVCodecContext *avctx)
530 {
531  FlashSVContext *s = avctx->priv_data;
532  flashsv_decode_init(avctx);
533  s->pal = ff_flashsv2_default_palette;
534  s->ver = 2;
535 
536  return 0;
537 }
538 
539 static av_cold int flashsv2_decode_end(AVCodecContext *avctx)
540 {
541  FlashSVContext *s = avctx->priv_data;
542 
543  av_freep(&s->keyframedata);
544  av_freep(&s->blocks);
545  av_freep(&s->keyframe);
546  av_freep(&s->deflate_block);
547  flashsv_decode_end(avctx);
548 
549  return 0;
550 }
551 
552 AVCodec ff_flashsv2_decoder = {
553  .name = "flashsv2",
554  .long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video v2"),
555  .type = AVMEDIA_TYPE_VIDEO,
556  .id = AV_CODEC_ID_FLASHSV2,
557  .priv_data_size = sizeof(FlashSVContext),
558  .init = flashsv2_decode_init,
559  .close = flashsv2_decode_end,
561  .capabilities = CODEC_CAP_DR1,
562  .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE },
563 };
564 #endif /* CONFIG_FLASHSV2_DECODER */
int zlibprime_prev
Definition: flashsv.c:68
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:62
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
This structure describes decoded (raw) audio or video data.
Definition: frame.h:135
int size
Definition: flashsv.c:48
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:240
uint8_t * keyframe
Definition: flashsv.c:63
static void skip_bits_long(GetBitContext *s, int n)
Definition: get_bits.h:199
int size
Definition: avcodec.h:974
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1270
AVFrame * frame
Definition: flashsv.c:53
int stride
Definition: mace.c:144
AVCodec.
Definition: avcodec.h:2812
const uint32_t * pal
Definition: flashsv.c:60
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:198
static av_cold int flashsv_decode_end(AVCodecContext *avctx)
Definition: flashsv.c:102
av_dlog(ac->avr, "%d samples - audio_convert: %s to %s (%s)\, len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic ? ac->func_descr_generic :ac->func_descr)
AVCodecContext * avctx
Definition: flashsv.c:52
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:275
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:66
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:57
#define b
Definition: input.c:52
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:188
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:684
const char data[16]
Definition: mxf.c:70
uint8_t * data
Definition: avcodec.h:973
int av_reallocp(void *ptr, size_t size)
Allocate or reallocate a block of memory.
Definition: mem.c:140
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:194
bitstream reader API header.
int image_width
Definition: flashsv.c:54
int diff_start
Definition: flashsv.c:69
#define r
Definition: input.c:51
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1019
static int decode_hybrid(const uint8_t *sptr, uint8_t *dptr, int dx, int dy, int h, int w, int stride, const uint32_t *pal)
Definition: flashsv.c:72
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:555
static av_cold int flashsv_decode_init(AVCodecContext *avctx)
Definition: flashsv.c:115
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:123
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:186
int block_width
Definition: flashsv.c:55
#define AV_RB16
Definition: intreadwrite.h:53
#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:69
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:145
g
Definition: yuv2rgb.c:535
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:144
Definition: graph2dot.c:49
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:169
const char * name
Name of the codec implementation.
Definition: avcodec.h:2819
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:979
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:808
int width
picture width / height.
Definition: avcodec.h:1229
static int flashsv2_prime(FlashSVContext *s, uint8_t *src, int size)
Definition: flashsv.c:140
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:68
static int flashsv_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: flashsv.c:256
#define AVERROR_PATCHWELCOME
Not yet implemented in Libav, patches welcome.
Definition: error.h:57
NULL
Definition: eval.c:55
static int width
Definition: utils.c:156
int block_size
Definition: flashsv.c:57
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:153
uint8_t pos
Definition: dvdec.c:53
main external API structure.
Definition: avcodec.h:1050
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:490
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:271
static int calc_deflate_block_size(int tmpblock_size)
Definition: flashsv.c:240
int zlibprime_curr
Definition: flashsv.c:68
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:263
int is_keyframe
Definition: flashsv.c:61
z_stream zstream
Definition: flashsv.c:58
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:375
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:283
int color_depth
Definition: flashsv.c:67
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:141
int height
Definition: gxfenc.c:72
int deflate_block_size
Definition: flashsv.c:66
uint8_t * pos
Definition: flashsv.c:47
common internal api header.
uint8_t * deflate_block
Definition: flashsv.c:65
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
Definition: error.h:61
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:499
BlockInfo * blocks
Definition: flashsv.c:64
void * priv_data
Definition: avcodec.h:1092
uint8_t * tmpblock
Definition: flashsv.c:56
uint8_t * keyframedata
Definition: flashsv.c:62
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:177
int block_height
Definition: flashsv.c:55
AVPixelFormat
Pixel format.
Definition: pixfmt.h:63
This structure stores compressed data.
Definition: avcodec.h:950
int diff_height
Definition: flashsv.c:69
for(j=16;j >0;--j)
int image_height
Definition: flashsv.c:54