57 #define HAS_IFRAME_IMAGE 0x02
58 #define HAS_PALLET_INFO 0x01
60 #define COLORSPACE_BGR 0x00
61 #define COLORSPACE_15_7 0x10
62 #define HAS_DIFF_BLOCKS 0x04
63 #define ZLIB_PRIME_COMPRESS_CURRENT 0x02
64 #define ZLIB_PRIME_COMPRESS_PREVIOUS 0x01
117 #ifndef FLASHSV2_DUMB
145 uint8_t * encbuf, uint8_t * databuf)
149 memset(blocks, 0,
s->cols *
s->rows *
sizeof(*blocks));
150 for (col = 0; col <
s->cols; col++) {
151 for (row = 0; row <
s->rows; row++) {
152 b = blocks + (col + row *
s->cols);
153 b->width = (col <
s->cols - 1) ?
155 s->image_width - col *
s->block_width;
157 b->height = (row < s->rows - 1) ?
159 s->image_height - row *
s->block_height;
165 encbuf +=
b->width *
b->height * 3;
166 databuf = databuf ? databuf +
b->width *
b->height * 6 :
NULL;
173 #ifndef FLASHSV2_DUMB
174 s->diff_blocks = 0.1;
178 s->raw_size =
s->comp_size =
s->uncomp_size = 10;
184 s->block_width = block_width;
185 s->block_height = block_height;
186 s->rows = (
s->image_height +
s->block_height - 1) /
s->block_height;
187 s->cols = (
s->image_width +
s->block_width - 1) /
s->block_width;
188 if (
s->rows *
s->cols >
s->blocks_size /
sizeof(
Block)) {
191 if (!
s->frame_blocks || !
s->key_blocks) {
195 s->blocks_size =
s->rows *
s->cols *
sizeof(
Block);
200 av_fast_malloc(&
s->blockbuffer, &
s->blockbuffer_size, block_width * block_height * 6);
201 if (!
s->blockbuffer) {
219 if (
s->comp < 0 ||
s->comp > 9) {
221 "Compression level should be 0-9, not %d\n",
s->comp);
226 if ((avctx->
width > 4095) || (avctx->
height > 4095)) {
228 "Input dimensions too large, input must be max 4095x4095 !\n");
233 "Input dimensions too small, input must be at least 16x16 !\n");
243 s->last_key_frame = 0;
245 s->image_width = avctx->
width;
246 s->image_height = avctx->
height;
248 s->frame_size =
s->image_width *
s->image_height * 3;
255 if (!
s->encbuffer || !
s->keybuffer || !
s->databuffer
256 || !
s->current_frame || !
s->key_frame) {
262 #ifndef FLASHSV2_DUMB
266 s->use_custom_palette = 0;
267 s->palette_type = -1;
275 memcpy(
s->key_blocks,
s->frame_blocks,
s->blocks_size);
276 memcpy(
s->key_frame,
s->current_frame,
s->frame_size);
278 for (
i = 0;
i <
s->rows *
s->cols;
i++) {
279 s->key_blocks[
i].enc += (
s->keybuffer -
s->encbuffer);
280 s->key_blocks[
i].sl_begin = 0;
281 s->key_blocks[
i].sl_end = 0;
282 s->key_blocks[
i].data = 0;
284 memcpy(
s->keybuffer,
s->encbuffer,
s->frame_size);
305 put_bits(&pb, 4, (
s->block_width >> 4) - 1);
307 put_bits(&pb, 4, (
s->block_height >> 4) - 1);
313 buf[buf_pos++] =
s->flags;
328 unsigned block_size =
b->data_size;
336 if (buf_size < block_size + 2)
339 buf[buf_pos++] = block_size >> 8;
340 buf[buf_pos++] = block_size;
345 buf[buf_pos++] =
b->flags;
348 buf[buf_pos++] = (
b->start);
349 buf[buf_pos++] = (
b->len);
354 buf[buf_pos++] = (
b->col);
355 buf[buf_pos++] = (
b->row);
358 memcpy(buf + buf_pos,
b->data,
b->data_size);
360 buf_pos +=
b->data_size;
370 if (deflateReset(zstream) != Z_OK)
372 zstream->next_out = buf;
373 zstream->avail_out = *buf_size;
374 zstream->next_in =
b->sl_begin;
375 zstream->avail_in =
b->sl_end -
b->sl_begin;
376 res =
deflate(zstream, Z_FINISH);
377 if (res != Z_STREAM_END)
379 *buf_size -= zstream->avail_out;
384 int *buf_size, z_stream *zstream)
388 if (deflateReset(zstream) != Z_OK)
390 zstream->next_in = prime->
enc;
391 zstream->avail_in = prime->
enc_size;
392 while (zstream->avail_in > 0) {
393 zstream->next_out = buf;
394 zstream->avail_out = *buf_size;
395 res =
deflate(zstream, Z_SYNC_FLUSH);
400 zstream->next_in =
b->sl_begin;
401 zstream->avail_in =
b->sl_end -
b->sl_begin;
402 zstream->next_out = buf;
403 zstream->avail_out = *buf_size;
404 res =
deflate(zstream, Z_FINISH);
405 *buf_size -= zstream->avail_out;
406 if (res != Z_STREAM_END)
414 uint8_t *ptr =
b->enc;
415 for (
i = 0;
i <
b->start;
i++)
416 memcpy(ptr +
i *
b->width * 3,
src +
i *
stride,
b->width * 3);
417 b->sl_begin = ptr +
i *
b->width * 3;
418 for (;
i <
b->start +
b->len;
i++)
419 memcpy(ptr +
i *
b->width * 3,
src +
i *
stride,
b->width * 3);
420 b->sl_end = ptr +
i *
b->width * 3;
421 for (;
i <
b->height;
i++)
422 memcpy(ptr +
i *
b->width * 3,
src +
i *
stride,
b->width * 3);
423 b->enc_size = ptr +
i *
b->width * 3 -
b->enc;
429 return (
src[0] >> 3) | ((
src[1] & 0xf8) << 2) | ((
src[2] & 0xf8) << 7);
434 #define ABSDIFF(a,b) (abs((int)(a)-(int)(b)))
436 unsigned int t1 = (
c1 & 0x000000ff) + ((
c1 & 0x0000ff00) >> 8) + ((
c1 & 0x00ff0000) >> 16);
437 unsigned int t2 = (
c2 & 0x000000ff) + ((
c2 & 0x0000ff00) >> 8) + ((
c2 & 0x00ff0000) >> 16);
440 ABSDIFF((
c1 & 0x0000ff00) >> 8 , (
c2 & 0x0000ff00) >> 8) +
441 ABSDIFF((
c1 & 0x00ff0000) >> 16, (
c2 & 0x00ff0000) >> 16);
446 return palette->
index[c15];
451 int i,
min = 0x7fffffff;
453 for (
i = 0;
i < 128;
i++) {
466 return (
src[0]) | (
src[1] << 8) | (
src[2] << 16);
477 if (dist + d15 >= d7) {
481 dest[0] = 0x80 | (c15 >> 8);
482 dest[1] = c15 & 0xff;
490 unsigned int bgr, c15,
index;
491 for (
r = 4;
r < 256;
r += 8) {
492 for (
g = 4;
g < 256;
g += 8) {
493 for (
b = 4;
b < 256;
b += 8) {
494 bgr =
b | (
g << 8) | (
r << 16);
495 c15 = (
b >> 3) | ((
g & 0xf8) << 2) | ((
r & 0xf8) << 7);
506 0x00000000, 0x00333333, 0x00666666, 0x00999999, 0x00CCCCCC, 0x00FFFFFF,
507 0x00330000, 0x00660000, 0x00990000, 0x00CC0000, 0x00FF0000, 0x00003300,
508 0x00006600, 0x00009900, 0x0000CC00, 0x0000FF00, 0x00000033, 0x00000066,
509 0x00000099, 0x000000CC, 0x000000FF, 0x00333300, 0x00666600, 0x00999900,
510 0x00CCCC00, 0x00FFFF00, 0x00003333, 0x00006666, 0x00009999, 0x0000CCCC,
511 0x0000FFFF, 0x00330033, 0x00660066, 0x00990099, 0x00CC00CC, 0x00FF00FF,
512 0x00FFFF33, 0x00FFFF66, 0x00FFFF99, 0x00FFFFCC, 0x00FF33FF, 0x00FF66FF,
513 0x00FF99FF, 0x00FFCCFF, 0x0033FFFF, 0x0066FFFF, 0x0099FFFF, 0x00CCFFFF,
514 0x00CCCC33, 0x00CCCC66, 0x00CCCC99, 0x00CCCCFF, 0x00CC33CC, 0x00CC66CC,
515 0x00CC99CC, 0x00CCFFCC, 0x0033CCCC, 0x0066CCCC, 0x0099CCCC, 0x00FFCCCC,
516 0x00999933, 0x00999966, 0x009999CC, 0x009999FF, 0x00993399, 0x00996699,
517 0x0099CC99, 0x0099FF99, 0x00339999, 0x00669999, 0x00CC9999, 0x00FF9999,
518 0x00666633, 0x00666699, 0x006666CC, 0x006666FF, 0x00663366, 0x00669966,
519 0x0066CC66, 0x0066FF66, 0x00336666, 0x00996666, 0x00CC6666, 0x00FF6666,
520 0x00333366, 0x00333399, 0x003333CC, 0x003333FF, 0x00336633, 0x00339933,
521 0x0033CC33, 0x0033FF33, 0x00663333, 0x00993333, 0x00CC3333, 0x00FF3333,
522 0x00003366, 0x00336600, 0x00660033, 0x00006633, 0x00330066, 0x00663300,
523 0x00336699, 0x00669933, 0x00993366, 0x00339966, 0x00663399, 0x00996633,
524 0x006699CC, 0x0099CC66, 0x00CC6699, 0x0066CC99, 0x009966CC, 0x00CC9966,
525 0x0099CCFF, 0x00CCFF99, 0x00FF99CC, 0x0099FFCC, 0x00CC99FF, 0x00FFCC99,
526 0x00111111, 0x00222222, 0x00444444, 0x00555555, 0x00AAAAAA, 0x00BBBBBB,
527 0x00DDDDDD, 0x00EEEEEE
546 const uint8_t *
src,
int width,
int dist)
549 for (x = 0; x <
width; x++) {
559 uint8_t *ptr =
b->enc;
560 for (
i = 0;
i <
b->start;
i++)
563 for (;
i <
b->start +
b->len;
i++)
566 for (;
i <
b->height;
i++)
568 b->enc_size = ptr -
b->enc;
574 int dist,
int keyframe)
576 unsigned buf_size =
b->width *
b->height * 6;
577 uint8_t *buf =
s->blockbuffer;
587 b->data_size = buf_size;
597 if (buf_size < b->data_size) {
598 b->data_size = buf_size;
599 memcpy(
b->data, buf, buf_size);
610 uint8_t *
frame, uint8_t *
key,
int y,
int keyframe)
612 if (memcmp(
src,
frame,
b->width * 3) != 0) {
615 #ifndef FLASHSV2_DUMB
619 if (memcmp(
src,
key,
b->width * 3) != 0) {
622 b->len = y + 1 -
b->start;
630 int sl, rsl, col,
pos, possl;
632 for (sl =
s->image_height - 1; sl >= 0; sl--) {
633 for (col = 0; col <
s->cols; col++) {
634 rsl =
s->image_height - sl - 1;
635 b =
s->frame_blocks + col + rsl /
s->block_height *
s->cols;
636 possl =
stride * sl + col *
s->block_width * 3;
637 pos =
s->image_width * rsl * 3 + col *
s->block_width * 3;
639 s->key_frame +
pos, rsl %
s->block_height, keyframe);
642 #ifndef FLASHSV2_DUMB
643 s->tot_lines +=
s->image_height *
s->cols;
653 for (row = 0; row <
s->rows; row++) {
654 for (col = 0; col <
s->cols; col++) {
655 b =
s->frame_blocks + (row *
s->cols + col);
656 prev =
s->key_blocks + (row *
s->cols + col);
661 }
else if (!
b->dirty) {
666 }
else if (
b->start != 0 ||
b->len !=
b->height) {
669 data =
s->current_frame +
s->image_width * 3 *
s->block_height * row +
s->block_width * col * 3;
671 s->image_width * 3,
s->dist, keyframe);
672 #ifndef FLASHSV2_DUMB
675 s->comp_size +=
b->data_size;
676 s->uncomp_size +=
b->enc_size;
682 #ifndef FLASHSV2_DUMB
683 s->raw_size +=
s->image_width *
s->image_height * 3;
684 s->tot_blocks +=
s->rows *
s->cols;
692 int row, col, buf_pos = 0,
len;
694 for (row = 0; row <
s->rows; row++) {
695 for (col = 0; col <
s->cols; col++) {
696 b =
s->frame_blocks + row *
s->cols + col;
698 b->start =
b->len =
b->dirty = 0;
708 uint8_t * buf,
int buf_size,
int keyframe)
729 #ifndef FLASHSV2_DUMB
730 s->total_bits += ((
double) buf_pos) * 8.0;
738 #ifndef FLASHSV2_DUMB
739 double block_ratio, line_ratio, enc_ratio, comp_ratio, data_ratio;
740 if (
s->avctx->gop_size > 0) {
741 block_ratio =
s->diff_blocks /
s->tot_blocks;
742 line_ratio =
s->diff_lines /
s->tot_lines;
743 enc_ratio =
s->uncomp_size /
s->raw_size;
744 comp_ratio =
s->comp_size /
s->uncomp_size;
745 data_ratio =
s->comp_size /
s->raw_size;
747 if ((block_ratio >= 0.5 && line_ratio / block_ratio <= 0.5) || line_ratio >= 0.95) {
757 #ifndef FLASHSV2_DUMB
758 static const double block_size_fraction = 1.0 / 300;
759 static const double use15_7_threshold = 8192;
760 static const double color15_7_factor = 100;
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 width = block_size_fraction * sqrt(0.5 * save *
s->rows *
s->cols) *
s->image_width;
768 return FFCLIP(pwidth & ~15, 256, 16);
776 #ifndef FLASHSV2_DUMB
777 double save = (1-pow(
s->diff_lines/
s->diff_blocks/
s->block_height, 0.5)) *
s->comp_size/
s->tot_blocks;
778 double height = block_size_fraction * sqrt(0.5 * save *
s->rows *
s->cols) *
s->image_height;
780 return FFCLIP(pheight & ~15, 256, 16);
788 #ifndef FLASHSV2_DUMB
789 double ideal = ((
double)(
s->avctx->bit_rate *
s->avctx->time_base.den *
s->avctx->ticks_per_frame)) /
790 ((
double)
s->avctx->time_base.num) *
s->avctx->frame_number;
791 if (ideal + use15_7_threshold < s->total_bits) {
797 return s->avctx->global_quality == 0;
803 #ifndef FLASHSV2_DUMB
805 s->avctx->bit_rate *
s->avctx->time_base.den *
806 s->avctx->ticks_per_frame;
807 int dist = pow((
s->total_bits / ideal) * color15_7_factor, 3);
824 if (block_width !=
s->block_width || block_height !=
s->block_height) {
838 }
else if (!
s->use_custom_palette &&
s->palette_type != 0) {
854 const AVFrame *p,
int *got_packet)
914 .
p.
name =
"flashsv2",