56 #define HAS_IFRAME_IMAGE 0x02
57 #define HAS_PALLET_INFO 0x01
59 #define COLORSPACE_BGR 0x00
60 #define COLORSPACE_15_7 0x10
61 #define HAS_DIFF_BLOCKS 0x04
62 #define ZLIB_PRIME_COMPRESS_CURRENT 0x02
63 #define ZLIB_PRIME_COMPRESS_PREVIOUS 0x01
115 #ifndef FLASHSV2_DUMB
142 uint8_t * encbuf, uint8_t * databuf)
146 memset(blocks, 0,
s->cols *
s->rows *
sizeof(*blocks));
147 for (col = 0; col <
s->cols; col++) {
148 for (row = 0; row <
s->rows; row++) {
149 b = blocks + (col + row *
s->cols);
150 b->width = (col <
s->cols - 1) ?
152 s->image_width - col *
s->block_width;
154 b->height = (row < s->rows - 1) ?
156 s->image_height - row *
s->block_height;
162 encbuf +=
b->width *
b->height * 3;
163 databuf = databuf ? databuf +
b->width *
b->height * 6 :
NULL;
170 #ifndef FLASHSV2_DUMB
171 s->diff_blocks = 0.1;
175 s->raw_size =
s->comp_size =
s->uncomp_size = 10;
181 s->block_width = block_width;
182 s->block_height = block_height;
183 s->rows = (
s->image_height +
s->block_height - 1) /
s->block_height;
184 s->cols = (
s->image_width +
s->block_width - 1) /
s->block_width;
185 if (
s->rows *
s->cols >
s->blocks_size /
sizeof(
Block)) {
188 if (!
s->frame_blocks || !
s->key_blocks) {
192 s->blocks_size =
s->rows *
s->cols *
sizeof(
Block);
197 av_fast_malloc(&
s->blockbuffer, &
s->blockbuffer_size, block_width * block_height * 6);
198 if (!
s->blockbuffer) {
216 if (
s->comp < 0 ||
s->comp > 9) {
218 "Compression level should be 0-9, not %d\n",
s->comp);
223 if ((avctx->
width > 4095) || (avctx->
height > 4095)) {
225 "Input dimensions too large, input must be max 4095x4095 !\n");
230 "Input dimensions too small, input must be at least 16x16 !\n");
238 s->last_key_frame = 0;
240 s->image_width = avctx->
width;
241 s->image_height = avctx->
height;
243 s->frame_size =
s->image_width *
s->image_height * 3;
250 if (!
s->encbuffer || !
s->keybuffer || !
s->databuffer
251 || !
s->current_frame || !
s->key_frame) {
257 #ifndef FLASHSV2_DUMB
261 s->use_custom_palette = 0;
262 s->palette_type = -1;
270 memcpy(
s->key_blocks,
s->frame_blocks,
s->blocks_size);
271 memcpy(
s->key_frame,
s->current_frame,
s->frame_size);
273 for (
i = 0;
i <
s->rows *
s->cols;
i++) {
274 s->key_blocks[
i].enc += (
s->keybuffer -
s->encbuffer);
275 s->key_blocks[
i].sl_begin = 0;
276 s->key_blocks[
i].sl_end = 0;
277 s->key_blocks[
i].data = 0;
279 memcpy(
s->keybuffer,
s->encbuffer,
s->frame_size);
300 put_bits(&pb, 4, (
s->block_width >> 4) - 1);
302 put_bits(&pb, 4, (
s->block_height >> 4) - 1);
308 buf[buf_pos++] =
s->flags;
323 unsigned block_size =
b->data_size;
331 if (buf_size < block_size + 2)
334 buf[buf_pos++] = block_size >> 8;
335 buf[buf_pos++] = block_size;
340 buf[buf_pos++] =
b->flags;
343 buf[buf_pos++] = (
b->start);
344 buf[buf_pos++] = (
b->len);
349 buf[buf_pos++] = (
b->col);
350 buf[buf_pos++] = (
b->row);
353 memcpy(buf + buf_pos,
b->data,
b->data_size);
355 buf_pos +=
b->data_size;
362 int res = compress2(buf, buf_size,
b->sl_begin,
b->sl_end -
b->sl_begin,
comp);
363 return res == Z_OK ? 0 : -1;
367 int *buf_size,
int comp)
374 res = deflateInit(&
s,
comp);
378 s.next_in = prime->
enc;
380 while (
s.avail_in > 0) {
382 s.avail_out = *buf_size;
388 s.next_in =
b->sl_begin;
389 s.avail_in =
b->sl_end -
b->sl_begin;
391 s.avail_out = *buf_size;
394 *buf_size -=
s.avail_out;
395 if (res != Z_STREAM_END)
403 uint8_t *ptr =
b->enc;
404 for (
i = 0;
i <
b->start;
i++)
405 memcpy(ptr +
i *
b->width * 3,
src +
i *
stride,
b->width * 3);
406 b->sl_begin = ptr +
i *
b->width * 3;
407 for (;
i <
b->start +
b->len;
i++)
408 memcpy(ptr +
i *
b->width * 3,
src +
i *
stride,
b->width * 3);
409 b->sl_end = ptr +
i *
b->width * 3;
410 for (;
i <
b->height;
i++)
411 memcpy(ptr +
i *
b->width * 3,
src +
i *
stride,
b->width * 3);
412 b->enc_size = ptr +
i *
b->width * 3 -
b->enc;
418 return (
src[0] >> 3) | ((
src[1] & 0xf8) << 2) | ((
src[2] & 0xf8) << 7);
423 #define ABSDIFF(a,b) (abs((int)(a)-(int)(b)))
425 unsigned int t1 = (
c1 & 0x000000ff) + ((
c1 & 0x0000ff00) >> 8) + ((
c1 & 0x00ff0000) >> 16);
426 unsigned int t2 = (
c2 & 0x000000ff) + ((
c2 & 0x0000ff00) >> 8) + ((
c2 & 0x00ff0000) >> 16);
429 ABSDIFF((
c1 & 0x0000ff00) >> 8 , (
c2 & 0x0000ff00) >> 8) +
430 ABSDIFF((
c1 & 0x00ff0000) >> 16, (
c2 & 0x00ff0000) >> 16);
435 return palette->
index[c15];
440 int i,
min = 0x7fffffff;
442 for (
i = 0;
i < 128;
i++) {
455 return (
src[0]) | (
src[1] << 8) | (
src[2] << 16);
466 if (dist + d15 >= d7) {
470 dest[0] = 0x80 | (c15 >> 8);
471 dest[1] = c15 & 0xff;
479 unsigned int bgr, c15,
index;
480 for (
r = 4;
r < 256;
r += 8) {
481 for (
g = 4;
g < 256;
g += 8) {
482 for (
b = 4;
b < 256;
b += 8) {
483 bgr =
b | (
g << 8) | (
r << 16);
484 c15 = (
b >> 3) | ((
g & 0xf8) << 2) | ((
r & 0xf8) << 7);
495 0x00000000, 0x00333333, 0x00666666, 0x00999999, 0x00CCCCCC, 0x00FFFFFF,
496 0x00330000, 0x00660000, 0x00990000, 0x00CC0000, 0x00FF0000, 0x00003300,
497 0x00006600, 0x00009900, 0x0000CC00, 0x0000FF00, 0x00000033, 0x00000066,
498 0x00000099, 0x000000CC, 0x000000FF, 0x00333300, 0x00666600, 0x00999900,
499 0x00CCCC00, 0x00FFFF00, 0x00003333, 0x00006666, 0x00009999, 0x0000CCCC,
500 0x0000FFFF, 0x00330033, 0x00660066, 0x00990099, 0x00CC00CC, 0x00FF00FF,
501 0x00FFFF33, 0x00FFFF66, 0x00FFFF99, 0x00FFFFCC, 0x00FF33FF, 0x00FF66FF,
502 0x00FF99FF, 0x00FFCCFF, 0x0033FFFF, 0x0066FFFF, 0x0099FFFF, 0x00CCFFFF,
503 0x00CCCC33, 0x00CCCC66, 0x00CCCC99, 0x00CCCCFF, 0x00CC33CC, 0x00CC66CC,
504 0x00CC99CC, 0x00CCFFCC, 0x0033CCCC, 0x0066CCCC, 0x0099CCCC, 0x00FFCCCC,
505 0x00999933, 0x00999966, 0x009999CC, 0x009999FF, 0x00993399, 0x00996699,
506 0x0099CC99, 0x0099FF99, 0x00339999, 0x00669999, 0x00CC9999, 0x00FF9999,
507 0x00666633, 0x00666699, 0x006666CC, 0x006666FF, 0x00663366, 0x00669966,
508 0x0066CC66, 0x0066FF66, 0x00336666, 0x00996666, 0x00CC6666, 0x00FF6666,
509 0x00333366, 0x00333399, 0x003333CC, 0x003333FF, 0x00336633, 0x00339933,
510 0x0033CC33, 0x0033FF33, 0x00663333, 0x00993333, 0x00CC3333, 0x00FF3333,
511 0x00003366, 0x00336600, 0x00660033, 0x00006633, 0x00330066, 0x00663300,
512 0x00336699, 0x00669933, 0x00993366, 0x00339966, 0x00663399, 0x00996633,
513 0x006699CC, 0x0099CC66, 0x00CC6699, 0x0066CC99, 0x009966CC, 0x00CC9966,
514 0x0099CCFF, 0x00CCFF99, 0x00FF99CC, 0x0099FFCC, 0x00CC99FF, 0x00FFCC99,
515 0x00111111, 0x00222222, 0x00444444, 0x00555555, 0x00AAAAAA, 0x00BBBBBB,
516 0x00DDDDDD, 0x00EEEEEE
535 const uint8_t *
src,
int width,
int dist)
538 for (x = 0; x <
width; x++) {
548 uint8_t *ptr =
b->enc;
549 for (
i = 0;
i <
b->start;
i++)
552 for (;
i <
b->start +
b->len;
i++)
555 for (;
i <
b->height;
i++)
557 b->enc_size = ptr -
b->enc;
563 int dist,
int keyframe)
565 unsigned buf_size =
b->width *
b->height * 6;
566 uint8_t *buf =
s->blockbuffer;
576 b->data_size = buf_size;
586 if (buf_size < b->data_size) {
587 b->data_size = buf_size;
588 memcpy(
b->data, buf, buf_size);
599 uint8_t *
frame, uint8_t *
key,
int y,
int keyframe)
601 if (memcmp(
src,
frame,
b->width * 3) != 0) {
604 #ifndef FLASHSV2_DUMB
608 if (memcmp(
src,
key,
b->width * 3) != 0) {
611 b->len = y + 1 -
b->start;
619 int sl, rsl, col,
pos, possl;
621 for (sl =
s->image_height - 1; sl >= 0; sl--) {
622 for (col = 0; col <
s->cols; col++) {
623 rsl =
s->image_height - sl - 1;
624 b =
s->frame_blocks + col + rsl /
s->block_height *
s->cols;
625 possl =
stride * sl + col *
s->block_width * 3;
626 pos =
s->image_width * rsl * 3 + col *
s->block_width * 3;
628 s->key_frame +
pos, rsl %
s->block_height, keyframe);
631 #ifndef FLASHSV2_DUMB
632 s->tot_lines +=
s->image_height *
s->cols;
642 for (row = 0; row <
s->rows; row++) {
643 for (col = 0; col <
s->cols; col++) {
644 b =
s->frame_blocks + (row *
s->cols + col);
645 prev =
s->key_blocks + (row *
s->cols + col);
650 }
else if (!
b->dirty) {
655 }
else if (
b->start != 0 ||
b->len !=
b->height) {
658 data =
s->current_frame +
s->image_width * 3 *
s->block_height * row +
s->block_width * col * 3;
660 #ifndef FLASHSV2_DUMB
663 s->comp_size +=
b->data_size;
664 s->uncomp_size +=
b->enc_size;
670 #ifndef FLASHSV2_DUMB
671 s->raw_size +=
s->image_width *
s->image_height * 3;
672 s->tot_blocks +=
s->rows *
s->cols;
680 int row, col, buf_pos = 0,
len;
682 for (row = 0; row <
s->rows; row++) {
683 for (col = 0; col <
s->cols; col++) {
684 b =
s->frame_blocks + row *
s->cols + col;
686 b->start =
b->len =
b->dirty = 0;
696 uint8_t * buf,
int buf_size,
int keyframe)
717 #ifndef FLASHSV2_DUMB
718 s->total_bits += ((double) buf_pos) * 8.0;
726 #ifndef FLASHSV2_DUMB
727 double block_ratio, line_ratio, enc_ratio, comp_ratio, data_ratio;
728 if (
s->avctx->gop_size > 0) {
729 block_ratio =
s->diff_blocks /
s->tot_blocks;
730 line_ratio =
s->diff_lines /
s->tot_lines;
731 enc_ratio =
s->uncomp_size /
s->raw_size;
732 comp_ratio =
s->comp_size /
s->uncomp_size;
733 data_ratio =
s->comp_size /
s->raw_size;
735 if ((block_ratio >= 0.5 && line_ratio / block_ratio <= 0.5) || line_ratio >= 0.95) {
745 #ifndef FLASHSV2_DUMB
746 static const double block_size_fraction = 1.0 / 300;
747 static const double use15_7_threshold = 8192;
748 static const double color15_7_factor = 100;
752 #ifndef FLASHSV2_DUMB
753 double save = (1-pow(
s->diff_lines/
s->diff_blocks/
s->block_height, 0.5)) *
s->comp_size/
s->tot_blocks;
754 double width = block_size_fraction * sqrt(0.5 * save *
s->rows *
s->cols) *
s->image_width;
756 return FFCLIP(pwidth & ~15, 256, 16);
764 #ifndef FLASHSV2_DUMB
765 double save = (1-pow(
s->diff_lines/
s->diff_blocks/
s->block_height, 0.5)) *
s->comp_size/
s->tot_blocks;
766 double height = block_size_fraction * sqrt(0.5 * save *
s->rows *
s->cols) *
s->image_height;
768 return FFCLIP(pheight & ~15, 256, 16);
776 #ifndef FLASHSV2_DUMB
777 double ideal = ((double)(
s->avctx->bit_rate *
s->avctx->time_base.den *
s->avctx->ticks_per_frame)) /
778 ((
double)
s->avctx->time_base.num) *
s->avctx->frame_number;
779 if (ideal + use15_7_threshold < s->total_bits) {
785 return s->avctx->global_quality == 0;
791 #ifndef FLASHSV2_DUMB
793 s->avctx->bit_rate *
s->avctx->time_base.den *
794 s->avctx->ticks_per_frame;
795 int dist = pow((
s->total_bits / ideal) * color15_7_factor, 3);
812 if (block_width !=
s->block_width || block_height !=
s->block_height) {
826 }
else if (!
s->use_custom_palette &&
s->palette_type != 0) {
842 const AVFrame *p,
int *got_packet)