73 int h,
int w,
int stride,
const uint32_t *pal)
78 for (y = dx +
h; y > dx; y--) {
80 for (x = 0; x <
w; x++) {
85 unsigned c =
AV_RB16(sptr) & ~0x8000;
86 unsigned b =
c & 0x1F;
87 unsigned g = (
c >> 5) & 0x1F;
90 *dst++ = (
b << 3) | (
b >> 2);
91 *dst++ = (
g << 3) | (
g >> 2);
92 *dst++ = (
r << 3) | (
r >> 2);
96 uint32_t
c = pal[*sptr++];
97 bytestream_put_le24(&dst,
c);
101 return sptr - orig_src;
107 inflateEnd(&
s->zstream);
123 s->zstream.zalloc = Z_NULL;
124 s->zstream.zfree = Z_NULL;
125 s->zstream.opaque = Z_NULL;
126 zret = inflateInit(&
s->zstream);
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;
159 if (deflateInit(&zs, 0) != Z_OK)
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;
168 if ((zret = inflateReset(&
s->zstream)) != Z_OK) {
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;
190 int ret = inflateReset(&
s->zstream);
195 if (
s->zlibprime_curr ||
s->zlibprime_prev) {
197 s->blocks[blk_idx].pos,
198 s->blocks[blk_idx].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) {
209 inflateSync(&
s->zstream);
210 ret =
inflate(&
s->zstream, Z_FINISH);
213 if (ret != Z_OK && ret != Z_STREAM_END) {
217 if (
s->is_keyframe) {
222 y_pos +=
s->diff_start;
224 if (!
s->color_depth) {
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],
238 s->image_height - (y_pos + 1 +
s->diff_height),
239 x_pos,
s->diff_height,
width,
240 s->frame->linesize[0],
s->pal);
258 if (deflateInit(&
zstream, 0) != Z_OK)
269 int buf_size = avpkt->
size;
271 int h_blocks, v_blocks, h_part, v_part,
i, j, ret;
273 int last_blockwidth =
s->block_width;
274 int last_blockheight=
s->block_height;
286 s->block_width = 16 * (
get_bits(&gb, 4) + 1);
288 s->block_height = 16 * (
get_bits(&gb, 4) + 1);
291 if ( last_blockwidth !=
s->block_width
292 || last_blockheight!=
s->block_height)
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;
315 if (
s->block_size <
s->block_width *
s->block_height) {
316 int tmpblock_size = 3 *
s->block_width *
s->block_height, err;
318 if ((err =
av_reallocp(&
s->tmpblock, tmpblock_size)) < 0) {
321 "Cannot allocate decompression buffer.\n");
326 if (
s->deflate_block_size <= 0) {
328 "Cannot determine deflate buffer size.\n");
331 if ((err =
av_reallocp(&
s->deflate_block,
s->deflate_block_size)) < 0) {
338 s->block_size =
s->block_width *
s->block_height;
349 "Frame width or height differs from first frame!\n");
357 if (
s->is_keyframe) {
361 memcpy(
s->keyframedata, avpkt->
data, avpkt->
size);
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]));
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);
375 for (j = 0; j < v_blocks + (v_part ? 1 : 0); j++) {
377 int y_pos = j *
s->block_height;
378 int cur_blk_height = (j < v_blocks) ?
s->block_height : v_part;
381 for (
i = 0;
i < h_blocks + (h_part ? 1 : 0);
i++) {
382 int x_pos =
i *
s->block_width;
383 int cur_blk_width = (
i < h_blocks) ?
s->block_width : h_part;
390 s->zlibprime_curr = 0;
391 s->zlibprime_prev = 0;
393 s->diff_height = cur_blk_height;
400 if (
s->ver == 2 &&
size) {
407 if (
s->color_depth != 0 &&
s->color_depth != 2) {
409 "%dx%d invalid color depth %d\n",
410 i, j,
s->color_depth);
421 "Inter frame without keyframe\n");
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);
433 "%dx%d diff start %d height %d\n",
434 i, j,
s->diff_start,
s->diff_height);
438 if (
s->zlibprime_prev)
441 if (
s->zlibprime_curr) {
454 if (!
s->blocks && (
s->zlibprime_curr ||
s->zlibprime_prev)) {
456 "no data available for zlib priming\n");
464 int off = (
s->image_height - y_pos - 1) *
s->frame->linesize[0];
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,
476 cur_blk_width, cur_blk_height,
478 i + j * (h_blocks + !!h_part)))
480 "error in decompression of block %dx%d\n",
i, j);
484 if (
s->is_keyframe &&
s->ver == 2) {
492 memcpy(
s->keyframe,
s->frame->data[0],
509 #if CONFIG_FLASHSV_DECODER
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,
559 s->pal = ff_flashsv2_default_palette;
584 .
init = flashsv2_decode_init,
585 .close = flashsv2_decode_end,
AVCodec ff_flashsv2_decoder
AVCodec ff_flashsv_decoder
Libavcodec external API header.
static av_cold int init(AVCodecContext *avctx)
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.
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
static int calc_deflate_block_size(int tmpblock_size)
static int flashsv_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
static av_cold int flashsv_decode_end(AVCodecContext *avctx)
static av_cold int flashsv_decode_init(AVCodecContext *avctx)
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)
static int flashsv2_prime(FlashSVContext *s, uint8_t *src, int size)
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)
bitstream reader API header.
static int get_bits_left(GetBitContext *gb)
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
static unsigned int get_bits1(GetBitContext *s)
static void skip_bits(GetBitContext *s, int n)
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
static int get_bits_count(const GetBitContext *s)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
int av_reallocp(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory through a pointer to a pointer.
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
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.
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
static enum AVPixelFormat pix_fmts[]
AVPixelFormat
Pixel format.
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
main external API structure.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
int width
picture width / height.
const char * name
Name of the codec implementation.
This structure describes decoded (raw) audio or video data.
This structure stores compressed data.
int flags
A combination of AV_PKT_FLAG values.
#define avpriv_request_sample(...)
static void deflate(uint8_t *dst, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord, int maxc)
static void inflate(uint8_t *dst, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord, int maxc)