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;
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 4095x4095 !\n");
201 "Input dimensions too small, input must be at least 16x16 !\n");
248 #ifndef FLASHSV2_DUMB 264 for (i = 0; i < s->
rows * s->
cols; i++) {
299 buf[buf_pos++] = s->
flags;
322 if (buf_size < block_size + 2)
325 buf[buf_pos++] = block_size >> 8;
326 buf[buf_pos++] = block_size;
331 buf[buf_pos++] = b->
flags;
334 buf[buf_pos++] = (b->
start);
335 buf[buf_pos++] = (b->
len);
340 buf[buf_pos++] = (b->
col);
341 buf[buf_pos++] = (b->
row);
354 return res == Z_OK ? 0 : -1;
358 int *buf_size,
int comp)
365 res = deflateInit(&s, comp);
369 s.next_in = prime->
enc;
371 while (s.avail_in > 0) {
373 s.avail_out = *buf_size;
374 res =
deflate(&s, Z_SYNC_FLUSH);
382 s.avail_out = *buf_size;
385 *buf_size -= s.avail_out;
386 if (res != Z_STREAM_END)
395 for (i = 0; i < b->
start; i++)
396 memcpy(ptr + i * b->
width * 3, src + i * stride, b->
width * 3);
399 memcpy(ptr + i * b->
width * 3, src + i * stride, b->
width * 3);
401 for (; i < b->
height; i++)
402 memcpy(ptr + i * b->
width * 3, src + i * stride, b->
width * 3);
409 return (src[0] >> 3) | ((src[1] & 0xf8) << 2) | ((src[2] & 0xf8) << 7);
414 #define ABSDIFF(a,b) (abs((int)(a)-(int)(b))) 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 ABSDIFF(t1, t2) +
ABSDIFF(c1 & 0x000000ff, c2 & 0x000000ff) +
420 ABSDIFF((c1 & 0x0000ff00) >> 8 , (c2 & 0x0000ff00) >> 8) +
421 ABSDIFF((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)
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 673 for (row = 0; row < s->
rows; row++) {
674 for (col = 0; col < s->
cols; col++) {
687 uint8_t * buf,
int buf_size,
int keyframe)
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) {
736 #ifndef FLASHSV2_DUMB 737 static const double block_size_fraction = 1.0 / 300;
738 static const double use15_7_threshold = 8192;
739 static const double color15_7_factor = 100;
743 #ifndef FLASHSV2_DUMB 744 double save = (1-pow(s->diff_lines/s->diff_blocks/s->
block_height, 0.5)) * s->comp_size/s->tot_blocks;
747 return FFCLIP(pwidth & ~15, 256, 16);
755 #ifndef FLASHSV2_DUMB 756 double save = (1-pow(s->diff_lines/s->diff_blocks/s->
block_height, 0.5)) * s->comp_size/s->tot_blocks;
759 return FFCLIP(pheight & ~15, 256, 16);
767 #ifndef FLASHSV2_DUMB 770 if (ideal + use15_7_threshold < s->total_bits) {
782 #ifndef FLASHSV2_DUMB 786 int dist = pow((s->total_bits / ideal) * color15_7_factor, 3);
798 int update_palette = 0;
852 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...
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