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 114 #ifndef FLASHSV2_DUMB 145 for (col = 0; col < s->
cols; col++) {
146 for (row = 0; row < s->
rows; row++) {
147 b = blocks + (col + row * s->
cols);
152 b->
height = (row < s->rows - 1) ?
161 databuf += !databuf ? 0 : b->
width * b->
height * 6;
168 #ifndef FLASHSV2_DUMB 169 s->diff_blocks = 0.1;
173 s->raw_size = s->comp_size = s->uncomp_size = 10;
216 "Compression level should be 0-9, not %d\n", s->
comp);
221 if ((avctx->
width > 4095) || (avctx->
height > 4095)) {
223 "Input dimensions too large, input must be max 4095x4095 !\n");
228 "Input dimensions too small, input must be at least 16x16 !\n");
255 #ifndef FLASHSV2_DUMB 271 for (i = 0; i < s->
rows * s->
cols; i++) {
306 buf[buf_pos++] = s->
flags;
329 if (buf_size < block_size + 2)
332 buf[buf_pos++] = block_size >> 8;
333 buf[buf_pos++] = block_size;
338 buf[buf_pos++] = b->
flags;
341 buf[buf_pos++] = (b->
start);
342 buf[buf_pos++] = (b->
len);
347 buf[buf_pos++] = (b->
col);
348 buf[buf_pos++] = (b->
row);
361 return res == Z_OK ? 0 : -1;
365 int *buf_size,
int comp)
372 res = deflateInit(&s, comp);
376 s.next_in = prime->
enc;
378 while (s.avail_in > 0) {
380 s.avail_out = *buf_size;
381 res =
deflate(&s, Z_SYNC_FLUSH);
389 s.avail_out = *buf_size;
392 *buf_size -= s.avail_out;
393 if (res != Z_STREAM_END)
402 for (i = 0; i < b->
start; i++)
403 memcpy(ptr + i * b->
width * 3, src + i * stride, b->
width * 3);
406 memcpy(ptr + i * b->
width * 3, src + i * stride, b->
width * 3);
408 for (; i < b->
height; i++)
409 memcpy(ptr + i * b->
width * 3, src + i * stride, b->
width * 3);
416 return (src[0] >> 3) | ((src[1] & 0xf8) << 2) | ((src[2] & 0xf8) << 7);
421 #define ABSDIFF(a,b) (abs((int)(a)-(int)(b))) 423 unsigned int t1 = (c1 & 0x000000ff) + ((c1 & 0x0000ff00) >> 8) + ((c1 & 0x00ff0000) >> 16);
424 unsigned int t2 = (c2 & 0x000000ff) + ((c2 & 0x0000ff00) >> 8) + ((c2 & 0x00ff0000) >> 16);
426 return ABSDIFF(t1, t2) +
ABSDIFF(c1 & 0x000000ff, c2 & 0x000000ff) +
427 ABSDIFF((c1 & 0x0000ff00) >> 8 , (c2 & 0x0000ff00) >> 8) +
428 ABSDIFF((c1 & 0x00ff0000) >> 16, (c2 & 0x00ff0000) >> 16);
433 return palette->
index[c15];
438 int i,
min = 0x7fffffff;
440 for (i = 0; i < 128; i++) {
453 return (src[0]) | (src[1] << 8) | (src[2] << 16);
464 if (dist + d15 >= d7) {
468 dest[0] = 0x80 | (c15 >> 8);
469 dest[1] = c15 & 0xff;
477 unsigned int bgr, c15,
index;
478 for (r = 4; r < 256; r += 8) {
479 for (g = 4; g < 256; g += 8) {
480 for (b = 4; b < 256; b += 8) {
481 bgr = b | (g << 8) | (r << 16);
482 c15 = (b >> 3) | ((g & 0xf8) << 2) | ((r & 0xf8) << 7);
493 0x00000000, 0x00333333, 0x00666666, 0x00999999, 0x00CCCCCC, 0x00FFFFFF,
494 0x00330000, 0x00660000, 0x00990000, 0x00CC0000, 0x00FF0000, 0x00003300,
495 0x00006600, 0x00009900, 0x0000CC00, 0x0000FF00, 0x00000033, 0x00000066,
496 0x00000099, 0x000000CC, 0x000000FF, 0x00333300, 0x00666600, 0x00999900,
497 0x00CCCC00, 0x00FFFF00, 0x00003333, 0x00006666, 0x00009999, 0x0000CCCC,
498 0x0000FFFF, 0x00330033, 0x00660066, 0x00990099, 0x00CC00CC, 0x00FF00FF,
499 0x00FFFF33, 0x00FFFF66, 0x00FFFF99, 0x00FFFFCC, 0x00FF33FF, 0x00FF66FF,
500 0x00FF99FF, 0x00FFCCFF, 0x0033FFFF, 0x0066FFFF, 0x0099FFFF, 0x00CCFFFF,
501 0x00CCCC33, 0x00CCCC66, 0x00CCCC99, 0x00CCCCFF, 0x00CC33CC, 0x00CC66CC,
502 0x00CC99CC, 0x00CCFFCC, 0x0033CCCC, 0x0066CCCC, 0x0099CCCC, 0x00FFCCCC,
503 0x00999933, 0x00999966, 0x009999CC, 0x009999FF, 0x00993399, 0x00996699,
504 0x0099CC99, 0x0099FF99, 0x00339999, 0x00669999, 0x00CC9999, 0x00FF9999,
505 0x00666633, 0x00666699, 0x006666CC, 0x006666FF, 0x00663366, 0x00669966,
506 0x0066CC66, 0x0066FF66, 0x00336666, 0x00996666, 0x00CC6666, 0x00FF6666,
507 0x00333366, 0x00333399, 0x003333CC, 0x003333FF, 0x00336633, 0x00339933,
508 0x0033CC33, 0x0033FF33, 0x00663333, 0x00993333, 0x00CC3333, 0x00FF3333,
509 0x00003366, 0x00336600, 0x00660033, 0x00006633, 0x00330066, 0x00663300,
510 0x00336699, 0x00669933, 0x00993366, 0x00339966, 0x00663399, 0x00996633,
511 0x006699CC, 0x0099CC66, 0x00CC6699, 0x0066CC99, 0x009966CC, 0x00CC9966,
512 0x0099CCFF, 0x00CCFF99, 0x00FF99CC, 0x0099FFCC, 0x00CC99FF, 0x00FFCC99,
513 0x00111111, 0x00222222, 0x00444444, 0x00555555, 0x00AAAAAA, 0x00BBBBBB,
514 0x00DDDDDD, 0x00EEEEEE
536 for (x = 0; x <
width; x++) {
547 for (i = 0; i < b->
start; i++)
553 for (; i < b->
height; i++)
561 int dist,
int keyframe)
586 memcpy(b->
data, buf, buf_size);
599 if (memcmp(src, frame, b->
width * 3) != 0) {
601 memcpy(frame, src, b->
width * 3);
602 #ifndef FLASHSV2_DUMB 606 if (memcmp(src, key, b->
width * 3) != 0) {
617 int sl, rsl,
col,
pos, possl;
620 for (col = 0; col < s->
cols; col++) {
629 #ifndef FLASHSV2_DUMB 640 for (row = 0; row < s->
rows; row++) {
641 for (col = 0; col < s->
cols; col++) {
648 }
else if (!b->
dirty) {
658 #ifndef FLASHSV2_DUMB 668 #ifndef FLASHSV2_DUMB 680 for (row = 0; row < s->
rows; row++) {
681 for (col = 0; col < s->
cols; col++) {
694 uint8_t * buf,
int buf_size,
int keyframe)
715 #ifndef FLASHSV2_DUMB 716 s->total_bits += ((double) buf_pos) * 8.0;
724 #ifndef FLASHSV2_DUMB 725 double block_ratio, line_ratio, enc_ratio, comp_ratio, data_ratio;
727 block_ratio = s->diff_blocks / s->tot_blocks;
728 line_ratio = s->diff_lines / s->tot_lines;
729 enc_ratio = s->uncomp_size / s->raw_size;
730 comp_ratio = s->comp_size / s->uncomp_size;
731 data_ratio = s->comp_size / s->raw_size;
733 if ((block_ratio >= 0.5 && line_ratio / block_ratio <= 0.5) || line_ratio >= 0.95) {
743 #ifndef FLASHSV2_DUMB 744 static const double block_size_fraction = 1.0 / 300;
745 static const double use15_7_threshold = 8192;
746 static const double color15_7_factor = 100;
750 #ifndef FLASHSV2_DUMB 751 double save = (1-pow(s->diff_lines/s->diff_blocks/s->
block_height, 0.5)) * s->comp_size/s->tot_blocks;
754 return FFCLIP(pwidth & ~15, 256, 16);
762 #ifndef FLASHSV2_DUMB 763 double save = (1-pow(s->diff_lines/s->diff_blocks/s->
block_height, 0.5)) * s->comp_size/s->tot_blocks;
766 return FFCLIP(pheight & ~15, 256, 16);
774 #ifndef FLASHSV2_DUMB 777 if (ideal + use15_7_threshold < s->total_bits) {
789 #ifndef FLASHSV2_DUMB 793 int dist = pow((s->total_bits / ideal) * color15_7_factor, 3);
805 int update_palette = 0;
840 const AVFrame *p,
int *got_packet)
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
uint8_t use_custom_palette
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 void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
int64_t bit_rate
the average bitrate
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)
static int optimum_dist(FlashSV2Context *s)
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
static int update_block_dimensions(FlashSV2Context *s, int block_width, int block_height)
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
static av_cold int flashsv2_encode_end(AVCodecContext *avctx)
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
static int generate_default_palette(Palette *palette)
static int flashsv2_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *p, int *got_packet)
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)
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
#define AV_INPUT_BUFFER_MIN_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
#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.
const char * name
Name of the codec implementation.
int flags
A combination of AV_PKT_FLAG values.
AVCodec ff_flashsv2_encoder
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
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 width
picture width / height.
static int pixel_color7_slow(Palette *palette, unsigned color)
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
static int write_block(Block *b, uint8_t *buf, int buf_size)
packed RGB 8:8:8, 24bpp, BGRBGR...
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 void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
static int write_palette(FlashSV2Context *s, uint8_t *buf, int buf_size)
static int update_palette_index(Palette *palette)
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
main external API structure.
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)
static int mark_all_blocks(FlashSV2Context *s, const uint8_t *src, int stride, int keyframe)
static int pixel_color7_fast(Palette *palette, unsigned c15)
static void init_blocks(FlashSV2Context *s, Block *blocks, uint8_t *encbuf, uint8_t *databuf)
static enum AVPixelFormat pix_fmts[]
int global_quality
Global quality for codecs which cannot change it per frame.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
GLint GLenum GLboolean GLsizei stride
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 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 void deflate(uint8_t *dst, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord, int maxc)
static av_always_inline int diff(const uint32_t a, const uint32_t b)
static int encode_all_blocks(FlashSV2Context *s, int keyframe)
int frame_number
Frame counter, set by libavcodec.
static int optimum_block_height(FlashSV2Context *s)
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
AVPixelFormat
Pixel format.
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)
static int write_pixel_15_7(Palette *palette, uint8_t *dest, const uint8_t *src, int dist)
static void reset_stats(FlashSV2Context *s)
static av_cold void cleanup(FlashSV2Context *s)
int keyint_min
minimum GOP size