49 #include "libavutil/imgutils.h"
55 #define HAS_IFRAME_IMAGE 0x02
56 #define HAS_PALLET_INFO 0x01
58 #define COLORSPACE_BGR 0x00
59 #define COLORSPACE_15_7 0x10
60 #define HAS_DIFF_BLOCKS 0x04
61 #define ZLIB_PRIME_COMPRESS_CURRENT 0x02
62 #define ZLIB_PRIME_COMPRESS_PREVIOUS 0x01
115 #ifndef FLASHSV2_DUMB
146 for (col = 0; col < s->
cols; col++) {
147 for (row = 0; row < s->
rows; row++) {
148 b = blocks + (col + row * s->
cols);
153 b->
height = (row < s->rows - 1) ?
162 databuf += !databuf ? 0 : b->
width * b->
height * 6;
169 #ifndef FLASHSV2_DUMB
170 s->diff_blocks = 0.1;
174 s->raw_size = s->comp_size = s->uncomp_size = 10;
189 "Compression level should be 0-9, not %d\n", s->
comp);
194 if ((avctx->
width > 4095) || (avctx->
height > 4095)) {
196 "Input dimensions too large, input must be max 4096x4096 !\n");
201 "Input dimensions too small, input must be at least 16x16 !\n");
242 #ifndef FLASHSV2_DUMB
266 for (i = 0; i < s->
rows * s->
cols; i++) {
301 buf[buf_pos++] = s->
flags;
324 if (buf_size < block_size + 2)
327 buf[buf_pos++] = block_size >> 8;
328 buf[buf_pos++] = block_size;
333 buf[buf_pos++] = b->
flags;
336 buf[buf_pos++] = (b->
start);
337 buf[buf_pos++] = (b->
len);
342 buf[buf_pos++] = (b->
col);
343 buf[buf_pos++] = (b->
row);
356 return res == Z_OK ? 0 : -1;
360 int *buf_size,
int comp)
367 res = deflateInit(&s, comp);
371 s.next_in = prime->
enc;
373 while (s.avail_in > 0) {
375 s.avail_out = *buf_size;
376 res = deflate(&s, Z_SYNC_FLUSH);
384 s.avail_out = *buf_size;
385 res = deflate(&s, Z_FINISH);
387 *buf_size -= s.avail_out;
388 if (res != Z_STREAM_END)
397 for (i = 0; i < b->
start; i++)
398 memcpy(ptr + i * b->
width * 3, src + i * stride, b->
width * 3);
401 memcpy(ptr + i * b->
width * 3, src + i * stride, b->
width * 3);
403 for (; i < b->
height; i++)
404 memcpy(ptr + i * b->
width * 3, src + i * stride, b->
width * 3);
411 return (src[0] >> 3) | ((src[1] & 0xf8) << 2) | ((src[2] & 0xf8) << 7);
416 unsigned int t1 = (c1 & 0x000000ff) + ((c1 & 0x0000ff00) >> 8) + ((c1 & 0x00ff0000) >> 16);
417 unsigned int t2 = (c2 & 0x000000ff) + ((c2 & 0x0000ff00) >> 8) + ((c2 & 0x00ff0000) >> 16);
419 return abs(t1 - t2) + abs((c1 & 0x000000ff) - (c2 & 0x000000ff)) +
420 abs(((c1 & 0x0000ff00) >> 8) - ((c2 & 0x0000ff00) >> 8)) +
421 abs(((c1 & 0x00ff0000) >> 16) - ((c2 & 0x00ff0000) >> 16));
426 return palette->
index[c15];
431 int i,
min = 0x7fffffff;
433 for (i = 0; i < 128; i++) {
446 return (src[0]) | (src[1] << 8) | (src[2] << 16);
457 if (dist + d15 >= d7) {
461 dest[0] = 0x80 | (c15 >> 8);
462 dest[1] = c15 & 0xff;
470 unsigned int bgr, c15,
index;
471 for (r = 4; r < 256; r += 8) {
472 for (g = 4; g < 256; g += 8) {
473 for (b = 4; b < 256; b += 8) {
474 bgr = b | (g << 8) | (r << 16);
475 c15 = (b >> 3) | ((g & 0xf8) << 2) | ((r & 0xf8) << 7);
486 0x00000000, 0x00333333, 0x00666666, 0x00999999, 0x00CCCCCC, 0x00FFFFFF,
487 0x00330000, 0x00660000, 0x00990000, 0x00CC0000, 0x00FF0000, 0x00003300,
488 0x00006600, 0x00009900, 0x0000CC00, 0x0000FF00, 0x00000033, 0x00000066,
489 0x00000099, 0x000000CC, 0x000000FF, 0x00333300, 0x00666600, 0x00999900,
490 0x00CCCC00, 0x00FFFF00, 0x00003333, 0x00006666, 0x00009999, 0x0000CCCC,
491 0x0000FFFF, 0x00330033, 0x00660066, 0x00990099, 0x00CC00CC, 0x00FF00FF,
492 0x00FFFF33, 0x00FFFF66, 0x00FFFF99, 0x00FFFFCC, 0x00FF33FF, 0x00FF66FF,
493 0x00FF99FF, 0x00FFCCFF, 0x0033FFFF, 0x0066FFFF, 0x0099FFFF, 0x00CCFFFF,
494 0x00CCCC33, 0x00CCCC66, 0x00CCCC99, 0x00CCCCFF, 0x00CC33CC, 0x00CC66CC,
495 0x00CC99CC, 0x00CCFFCC, 0x0033CCCC, 0x0066CCCC, 0x0099CCCC, 0x00FFCCCC,
496 0x00999933, 0x00999966, 0x009999CC, 0x009999FF, 0x00993399, 0x00996699,
497 0x0099CC99, 0x0099FF99, 0x00339999, 0x00669999, 0x00CC9999, 0x00FF9999,
498 0x00666633, 0x00666699, 0x006666CC, 0x006666FF, 0x00663366, 0x00669966,
499 0x0066CC66, 0x0066FF66, 0x00336666, 0x00996666, 0x00CC6666, 0x00FF6666,
500 0x00333366, 0x00333399, 0x003333CC, 0x003333FF, 0x00336633, 0x00339933,
501 0x0033CC33, 0x0033FF33, 0x00663333, 0x00993333, 0x00CC3333, 0x00FF3333,
502 0x00003366, 0x00336600, 0x00660033, 0x00006633, 0x00330066, 0x00663300,
503 0x00336699, 0x00669933, 0x00993366, 0x00339966, 0x00663399, 0x00996633,
504 0x006699CC, 0x0099CC66, 0x00CC6699, 0x0066CC99, 0x009966CC, 0x00CC9966,
505 0x0099CCFF, 0x00CCFF99, 0x00FF99CC, 0x0099FFCC, 0x00CC99FF, 0x00FFCC99,
506 0x00111111, 0x00222222, 0x00444444, 0x00555555, 0x00AAAAAA, 0x00BBBBBB,
507 0x00DDDDDD, 0x00EEEEEE
529 for (x = 0; x <
width; x++) {
540 for (i = 0; i < b->
start; i++)
546 for (; i < b->
height; i++)
554 int dist,
int keyframe)
577 if (buf_size < b->data_size) {
579 memcpy(b->
data, buf, buf_size);
592 if (memcmp(src, frame, b->
width * 3) != 0) {
594 memcpy(frame, src, b->
width * 3);
595 #ifndef FLASHSV2_DUMB
599 if (memcmp(src, key, b->
width * 3) != 0) {
610 int sl, rsl, col, pos, possl;
613 for (col = 0; col < s->
cols; col++) {
622 #ifndef FLASHSV2_DUMB
633 for (row = 0; row < s->
rows; row++) {
634 for (col = 0; col < s->
cols; col++) {
641 }
else if (!b->
dirty) {
651 #ifndef FLASHSV2_DUMB
661 #ifndef FLASHSV2_DUMB
671 int row, col, buf_pos = 0,
len;
673 for (row = 0; row < s->
rows; row++) {
674 for (col = 0; col < s->
cols; col++) {
708 #ifndef FLASHSV2_DUMB
709 s->total_bits += ((double) buf_pos) * 8.0;
717 #ifndef FLASHSV2_DUMB
718 double block_ratio, line_ratio, enc_ratio, comp_ratio, data_ratio;
720 block_ratio = s->diff_blocks / s->tot_blocks;
721 line_ratio = s->diff_lines / s->tot_lines;
722 enc_ratio = s->uncomp_size / s->raw_size;
723 comp_ratio = s->comp_size / s->uncomp_size;
724 data_ratio = s->comp_size / s->raw_size;
726 if ((block_ratio >= 0.5 && line_ratio / block_ratio <= 0.5) || line_ratio >= 0.95) {
739 #ifndef FLASHSV2_DUMB
740 double save = (1-pow(s->diff_lines/s->diff_blocks/s->
block_height, 0.5)) * s->comp_size/s->tot_blocks;
742 int pwidth = ((int)
width);
743 return FFCLIP(pwidth & ~15, 256, 16);
751 #ifndef FLASHSV2_DUMB
752 double save = (1-pow(s->diff_lines/s->diff_blocks/s->
block_height, 0.5)) * s->comp_size/s->tot_blocks;
754 int pheight = ((int)
height);
755 return FFCLIP(pheight & ~15, 256, 16);
765 #ifndef FLASHSV2_DUMB
768 if (ideal + use15_7_threshold < s->total_bits) {
782 #ifndef FLASHSV2_DUMB
798 int update_palette = 0;
852 const AVFrame *pict,
int *got_packet)
uint8_t use_custom_palette
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and/or allocate data.
static int compare_sl(FlashSV2Context *s, Block *b, const uint8_t *src, uint8_t *frame, uint8_t *key, int y, int keyframe)
static int optimum_block_width(FlashSV2Context *s)
static void recommend_keyframe(FlashSV2Context *s, int *keyframe)
This structure describes decoded (raw) audio or video data.
static int new_key_frame(FlashSV2Context *s)
static unsigned pixel_color15(const uint8_t *src)
static int optimum_use15_7(FlashSV2Context *s)
static const double block_size_fraction
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
static int encode_zlibprime(Block *b, Block *prime, uint8_t *buf, int *buf_size, int comp)
static av_cold int init(AVCodecContext *avctx)
static const unsigned int default_screen_video_v2_palette[128]
static int generate_optimum_palette(Palette *palette, const uint8_t *image, int width, int height, int stride)
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
static int optimum_dist(FlashSV2Context *s)
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
void av_freep(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
if((e=av_dict_get(options,"", NULL, AV_DICT_IGNORE_SUFFIX)))
static av_cold int flashsv2_encode_end(AVCodecContext *avctx)
packed RGB 8:8:8, 24bpp, BGRBGR...
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
static int generate_default_palette(Palette *palette)
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
const char * name
Name of the codec implementation.
static int encode_block(FlashSV2Context *s, Palette *palette, Block *b, Block *prev, const uint8_t *src, int stride, int comp, int dist, int keyframe)
#define ZLIB_PRIME_COMPRESS_CURRENT
static unsigned int chroma_diff(unsigned int c1, unsigned int c2)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
static av_cold int flashsv2_encode_init(AVCodecContext *avctx)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define ZLIB_PRIME_COMPRESS_PREVIOUS
static int encode_zlib(Block *b, uint8_t *buf, unsigned long *buf_size, int comp)
static int encode_15_7(Palette *palette, Block *b, const uint8_t *src, int stride, int dist)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Libavcodec external API header.
AVPixelFormat
Pixel format.
int flags
A combination of AV_PKT_FLAG values.
AVCodec ff_flashsv2_encoder
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
int bit_rate
the average bitrate
enum AVPictureType pict_type
Picture type of the frame.
void * av_realloc(void *ptr, size_t size) 1(2)
Allocate or reallocate a block of memory.
#define FF_MIN_BUFFER_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
int width
picture width / height.
static int pixel_color7_slow(Palette *palette, unsigned color)
static int write_block(Block *b, uint8_t *buf, int buf_size)
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
static int encode_bgr(Block *b, const uint8_t *src, int stride)
static int reconfigure_at_keyframe(FlashSV2Context *s, const uint8_t *image, int stride)
static int write_palette(FlashSV2Context *s, uint8_t *buf, int buf_size)
static int update_palette_index(Palette *palette)
static int flashsv2_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
main external API structure.
static void close(AVCodecParserContext *s)
static int write_header(FlashSV2Context *s, uint8_t *buf, int buf_size)
static int encode_15_7_sl(Palette *palette, uint8_t *dest, const uint8_t *src, int width, int dist)
BYTE int const BYTE int int int height
static int mark_all_blocks(FlashSV2Context *s, const uint8_t *src, int stride, int keyframe)
AVFrame * coded_frame
the picture in the bitstream
static int pixel_color7_fast(Palette *palette, unsigned c15)
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
static void init_blocks(FlashSV2Context *s, Block *blocks, uint8_t *encbuf, uint8_t *databuf)
int global_quality
Global quality for codecs which cannot change it per frame.
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
static unsigned pixel_bgr(const uint8_t *src)
uint8_t palette_type
0=>default, 1=>custom - changed when palette regenerated.
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
static const double use15_7_threshold
static int write_all_blocks(FlashSV2Context *s, uint8_t *buf, int buf_size)
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
static const double color15_7_factor
int key_frame
1 -> keyframe, 0-> not
static int encode_all_blocks(FlashSV2Context *s, int keyframe)
int frame_number
Frame counter, set by libavcodec.
static void comp(unsigned char *dst, int dst_stride, unsigned char *src, int src_stride, int add)
static int optimum_block_height(FlashSV2Context *s)
This structure stores compressed data.
static int write_bitstream(FlashSV2Context *s, const uint8_t *src, int stride, uint8_t *buf, int buf_size, int keyframe)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static int write_pixel_15_7(Palette *palette, uint8_t *dest, const uint8_t *src, int dist)
static void reset_stats(FlashSV2Context *s)
void * av_mallocz(size_t size) av_malloc_attrib 1(1)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
static av_cold void cleanup(FlashSV2Context *s)
int keyint_min
minimum GOP size