2 * Flash Screen Video Version 2 encoder
3 * Copyright (C) 2009 Joshua Warner
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 * Flash Screen Video Version 2 encoder
25 * @author Joshua Warner
28 /* Differences from version 1 stream:
29 * NOTE: Currently, the only player that supports version 2 streams is Adobe Flash Player itself.
30 * * Supports sending only a range of scanlines in a block,
31 * indicating a difference from the corresponding block in the last keyframe.
32 * * Supports initializing the zlib dictionary with data from the corresponding
33 * block in the last keyframe, to improve compression.
34 * * Supports a hybrid 15-bit rgb / 7-bit palette color space.
38 * Don't keep Block structures for both current frame and keyframe.
39 * Make better heuristics for deciding stream parameters (optimum_* functions). Currently these return constants.
40 * Figure out how to encode palette information in the stream, choose an optimum palette at each keyframe.
41 * Figure out how the zlibPrimeCompressCurrent flag works, implement support.
42 * Find other sample files (that weren't generated here), develop a decoder.
49 #include "libavutil/imgutils.h"
53 #include "bytestream.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
64 // Disables experimental "smart" parameter-choosing code, as well as the statistics that it depends on.
65 // At the moment, the "smart" code is a great example of how the parameters *shouldn't* be chosen.
68 typedef struct Block {
70 uint8_t *sl_begin, *sl_end;
73 unsigned long data_size;
77 uint8_t col, row, width, height;
81 typedef struct Palette {
83 uint8_t index[1 << 15];
86 typedef struct FlashSV2Context {
87 AVCodecContext *avctx;
88 uint8_t *current_frame;
102 int use15_7, dist, comp;
108 int image_width, image_height;
109 int block_width, block_height;
111 uint8_t use_custom_palette;
112 uint8_t palette_type; ///< 0=>default, 1=>custom - changed when palette regenerated.
114 #ifndef FLASHSV2_DUMB
115 double tot_blocks; ///< blocks encoded since last keyframe
116 double diff_blocks; ///< blocks that were different since last keyframe
117 double tot_lines; ///< total scanlines in image since last keyframe
118 double diff_lines; ///< scanlines that were different since last keyframe
119 double raw_size; ///< size of raw frames since last keyframe
120 double comp_size; ///< size of compressed data since last keyframe
121 double uncomp_size; ///< size of uncompressed data since last keyframe
123 double total_bits; ///< total bits written to stream so far
127 static av_cold void cleanup(FlashSV2Context * s)
129 av_freep(&s->encbuffer);
130 av_freep(&s->keybuffer);
131 av_freep(&s->databuffer);
132 av_freep(&s->blockbuffer);
133 av_freep(&s->current_frame);
134 av_freep(&s->key_frame);
136 av_freep(&s->frame_blocks);
137 av_freep(&s->key_blocks);
140 static void init_blocks(FlashSV2Context * s, Block * blocks,
141 uint8_t * encbuf, uint8_t * databuf)
145 memset(blocks, 0, s->cols * s->rows * sizeof(*blocks));
146 for (col = 0; col < s->cols; col++) {
147 for (row = 0; row < s->rows; row++) {
148 b = blocks + (col + row * s->cols);
149 b->width = (col < s->cols - 1) ?
151 s->image_width - col * s->block_width;
153 b->height = (row < s->rows - 1) ?
155 s->image_height - row * s->block_height;
161 encbuf += b->width * b->height * 3;
162 databuf = databuf ? databuf + b->width * b->height * 6 : NULL;
167 static void reset_stats(FlashSV2Context * s)
169 #ifndef FLASHSV2_DUMB
170 s->diff_blocks = 0.1;
174 s->raw_size = s->comp_size = s->uncomp_size = 10;
178 static int update_block_dimensions(FlashSV2Context *s, int block_width, int block_height)
180 s->block_width = block_width;
181 s->block_height = block_height;
182 s->rows = (s->image_height + s->block_height - 1) / s->block_height;
183 s->cols = (s->image_width + s->block_width - 1) / s->block_width;
184 if (s->rows * s->cols > s->blocks_size / sizeof(Block)) {
185 s->frame_blocks = av_realloc_array(s->frame_blocks, s->rows, s->cols * sizeof(Block));
186 s->key_blocks = av_realloc_array(s->key_blocks, s->cols, s->rows * sizeof(Block));
187 if (!s->frame_blocks || !s->key_blocks) {
188 av_log(s->avctx, AV_LOG_ERROR, "Memory allocation failed.\n");
189 return AVERROR(ENOMEM);
191 s->blocks_size = s->rows * s->cols * sizeof(Block);
193 init_blocks(s, s->frame_blocks, s->encbuffer, s->databuffer);
194 init_blocks(s, s->key_blocks, s->keybuffer, 0);
196 av_fast_malloc(&s->blockbuffer, &s->blockbuffer_size, block_width * block_height * 6);
197 if (!s->blockbuffer) {
198 av_log(s->avctx, AV_LOG_ERROR, "Could not allocate block buffer.\n");
199 return AVERROR(ENOMEM);
205 static av_cold int flashsv2_encode_init(AVCodecContext * avctx)
207 FlashSV2Context *s = avctx->priv_data;
212 s->comp = avctx->compression_level;
215 if (s->comp < 0 || s->comp > 9) {
216 av_log(avctx, AV_LOG_ERROR,
217 "Compression level should be 0-9, not %d\n", s->comp);
218 return AVERROR(EINVAL);
222 if ((avctx->width > 4095) || (avctx->height > 4095)) {
223 av_log(avctx, AV_LOG_ERROR,
224 "Input dimensions too large, input must be max 4095x4095 !\n");
225 return AVERROR(EINVAL);
227 if ((avctx->width < 16) || (avctx->height < 16)) {
228 av_log(avctx, AV_LOG_ERROR,
229 "Input dimensions too small, input must be at least 16x16 !\n");
230 return AVERROR(EINVAL);
233 if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
237 s->last_key_frame = 0;
239 s->image_width = avctx->width;
240 s->image_height = avctx->height;
242 s->frame_size = s->image_width * s->image_height * 3;
244 s->encbuffer = av_mallocz(s->frame_size);
245 s->keybuffer = av_mallocz(s->frame_size);
246 s->databuffer = av_mallocz(s->frame_size * 6);
247 s->current_frame = av_mallocz(s->frame_size);
248 s->key_frame = av_mallocz(s->frame_size);
249 if (!s->encbuffer || !s->keybuffer || !s->databuffer
250 || !s->current_frame || !s->key_frame) {
251 av_log(avctx, AV_LOG_ERROR, "Memory allocation failed.\n");
252 return AVERROR(ENOMEM);
256 #ifndef FLASHSV2_DUMB
260 s->use_custom_palette = 0;
261 s->palette_type = -1; // so that the palette will be generated in reconfigure_at_keyframe
263 return update_block_dimensions(s, 64, 64);
266 static int new_key_frame(FlashSV2Context * s)
269 memcpy(s->key_blocks, s->frame_blocks, s->blocks_size);
270 memcpy(s->key_frame, s->current_frame, s->frame_size);
272 for (i = 0; i < s->rows * s->cols; i++) {
273 s->key_blocks[i].enc += (s->keybuffer - s->encbuffer);
274 s->key_blocks[i].sl_begin = 0;
275 s->key_blocks[i].sl_end = 0;
276 s->key_blocks[i].data = 0;
278 memcpy(s->keybuffer, s->encbuffer, s->frame_size);
283 static int write_palette(FlashSV2Context * s, uint8_t * buf, int buf_size)
285 //this isn't implemented yet! Default palette only!
289 static int write_header(FlashSV2Context * s, uint8_t * buf, int buf_size)
297 init_put_bits(&pb, buf, buf_size);
299 put_bits(&pb, 4, (s->block_width >> 4) - 1);
300 put_bits(&pb, 12, s->image_width);
301 put_bits(&pb, 4, (s->block_height >> 4) - 1);
302 put_bits(&pb, 12, s->image_height);
307 buf[buf_pos++] = s->flags;
309 if (s->flags & HAS_PALLET_INFO) {
310 len = write_palette(s, buf + buf_pos, buf_size - buf_pos);
319 static int write_block(Block * b, uint8_t * buf, int buf_size)
322 unsigned block_size = b->data_size;
324 if (b->flags & HAS_DIFF_BLOCKS)
326 if (b->flags & ZLIB_PRIME_COMPRESS_CURRENT)
330 if (buf_size < block_size + 2)
333 buf[buf_pos++] = block_size >> 8;
334 buf[buf_pos++] = block_size;
339 buf[buf_pos++] = b->flags;
341 if (b->flags & HAS_DIFF_BLOCKS) {
342 buf[buf_pos++] = (b->start);
343 buf[buf_pos++] = (b->len);
346 if (b->flags & ZLIB_PRIME_COMPRESS_CURRENT) {
347 //This feature of the format is poorly understood, and as of now, unused.
348 buf[buf_pos++] = (b->col);
349 buf[buf_pos++] = (b->row);
352 memcpy(buf + buf_pos, b->data, b->data_size);
354 buf_pos += b->data_size;
359 static int encode_zlib(Block * b, uint8_t * buf, unsigned long *buf_size, int comp)
361 int res = compress2(buf, buf_size, b->sl_begin, b->sl_end - b->sl_begin, comp);
362 return res == Z_OK ? 0 : -1;
365 static int encode_zlibprime(Block * b, Block * prime, uint8_t * buf,
366 int *buf_size, int comp)
373 res = deflateInit(&s, comp);
377 s.next_in = prime->enc;
378 s.avail_in = prime->enc_size;
379 while (s.avail_in > 0) {
381 s.avail_out = *buf_size;
382 res = deflate(&s, Z_SYNC_FLUSH);
387 s.next_in = b->sl_begin;
388 s.avail_in = b->sl_end - b->sl_begin;
390 s.avail_out = *buf_size;
391 res = deflate(&s, Z_FINISH);
393 *buf_size -= s.avail_out;
394 if (res != Z_STREAM_END)
399 static int encode_bgr(Block * b, const uint8_t * src, int stride)
402 uint8_t *ptr = b->enc;
403 for (i = 0; i < b->start; i++)
404 memcpy(ptr + i * b->width * 3, src + i * stride, b->width * 3);
405 b->sl_begin = ptr + i * b->width * 3;
406 for (; i < b->start + b->len; i++)
407 memcpy(ptr + i * b->width * 3, src + i * stride, b->width * 3);
408 b->sl_end = ptr + i * b->width * 3;
409 for (; i < b->height; i++)
410 memcpy(ptr + i * b->width * 3, src + i * stride, b->width * 3);
411 b->enc_size = ptr + i * b->width * 3 - b->enc;
415 static inline unsigned pixel_color15(const uint8_t * src)
417 return (src[0] >> 3) | ((src[1] & 0xf8) << 2) | ((src[2] & 0xf8) << 7);
420 static inline unsigned int chroma_diff(unsigned int c1, unsigned int c2)
422 #define ABSDIFF(a,b) (abs((int)(a)-(int)(b)))
424 unsigned int t1 = (c1 & 0x000000ff) + ((c1 & 0x0000ff00) >> 8) + ((c1 & 0x00ff0000) >> 16);
425 unsigned int t2 = (c2 & 0x000000ff) + ((c2 & 0x0000ff00) >> 8) + ((c2 & 0x00ff0000) >> 16);
427 return ABSDIFF(t1, t2) + ABSDIFF(c1 & 0x000000ff, c2 & 0x000000ff) +
428 ABSDIFF((c1 & 0x0000ff00) >> 8 , (c2 & 0x0000ff00) >> 8) +
429 ABSDIFF((c1 & 0x00ff0000) >> 16, (c2 & 0x00ff0000) >> 16);
432 static inline int pixel_color7_fast(Palette * palette, unsigned c15)
434 return palette->index[c15];
437 static int pixel_color7_slow(Palette * palette, unsigned color)
439 int i, min = 0x7fffffff;
441 for (i = 0; i < 128; i++) {
442 int c1 = palette->colors[i];
443 int diff = chroma_diff(c1, color);
452 static inline unsigned pixel_bgr(const uint8_t * src)
454 return (src[0]) | (src[1] << 8) | (src[2] << 16);
457 static int write_pixel_15_7(Palette * palette, uint8_t * dest, const uint8_t * src,
460 unsigned c15 = pixel_color15(src);
461 unsigned color = pixel_bgr(src);
462 int d15 = chroma_diff(color, color & 0x00f8f8f8);
463 int c7 = pixel_color7_fast(palette, c15);
464 int d7 = chroma_diff(color, palette->colors[c7]);
465 if (dist + d15 >= d7) {
469 dest[0] = 0x80 | (c15 >> 8);
470 dest[1] = c15 & 0xff;
475 static int update_palette_index(Palette * palette)
478 unsigned int bgr, c15, index;
479 for (r = 4; r < 256; r += 8) {
480 for (g = 4; g < 256; g += 8) {
481 for (b = 4; b < 256; b += 8) {
482 bgr = b | (g << 8) | (r << 16);
483 c15 = (b >> 3) | ((g & 0xf8) << 2) | ((r & 0xf8) << 7);
484 index = pixel_color7_slow(palette, bgr);
486 palette->index[c15] = index;
493 static const unsigned int default_screen_video_v2_palette[128] = {
494 0x00000000, 0x00333333, 0x00666666, 0x00999999, 0x00CCCCCC, 0x00FFFFFF,
495 0x00330000, 0x00660000, 0x00990000, 0x00CC0000, 0x00FF0000, 0x00003300,
496 0x00006600, 0x00009900, 0x0000CC00, 0x0000FF00, 0x00000033, 0x00000066,
497 0x00000099, 0x000000CC, 0x000000FF, 0x00333300, 0x00666600, 0x00999900,
498 0x00CCCC00, 0x00FFFF00, 0x00003333, 0x00006666, 0x00009999, 0x0000CCCC,
499 0x0000FFFF, 0x00330033, 0x00660066, 0x00990099, 0x00CC00CC, 0x00FF00FF,
500 0x00FFFF33, 0x00FFFF66, 0x00FFFF99, 0x00FFFFCC, 0x00FF33FF, 0x00FF66FF,
501 0x00FF99FF, 0x00FFCCFF, 0x0033FFFF, 0x0066FFFF, 0x0099FFFF, 0x00CCFFFF,
502 0x00CCCC33, 0x00CCCC66, 0x00CCCC99, 0x00CCCCFF, 0x00CC33CC, 0x00CC66CC,
503 0x00CC99CC, 0x00CCFFCC, 0x0033CCCC, 0x0066CCCC, 0x0099CCCC, 0x00FFCCCC,
504 0x00999933, 0x00999966, 0x009999CC, 0x009999FF, 0x00993399, 0x00996699,
505 0x0099CC99, 0x0099FF99, 0x00339999, 0x00669999, 0x00CC9999, 0x00FF9999,
506 0x00666633, 0x00666699, 0x006666CC, 0x006666FF, 0x00663366, 0x00669966,
507 0x0066CC66, 0x0066FF66, 0x00336666, 0x00996666, 0x00CC6666, 0x00FF6666,
508 0x00333366, 0x00333399, 0x003333CC, 0x003333FF, 0x00336633, 0x00339933,
509 0x0033CC33, 0x0033FF33, 0x00663333, 0x00993333, 0x00CC3333, 0x00FF3333,
510 0x00003366, 0x00336600, 0x00660033, 0x00006633, 0x00330066, 0x00663300,
511 0x00336699, 0x00669933, 0x00993366, 0x00339966, 0x00663399, 0x00996633,
512 0x006699CC, 0x0099CC66, 0x00CC6699, 0x0066CC99, 0x009966CC, 0x00CC9966,
513 0x0099CCFF, 0x00CCFF99, 0x00FF99CC, 0x0099FFCC, 0x00CC99FF, 0x00FFCC99,
514 0x00111111, 0x00222222, 0x00444444, 0x00555555, 0x00AAAAAA, 0x00BBBBBB,
515 0x00DDDDDD, 0x00EEEEEE
518 static int generate_default_palette(Palette * palette)
520 memcpy(palette->colors, default_screen_video_v2_palette,
521 sizeof(default_screen_video_v2_palette));
523 return update_palette_index(palette);
526 static int generate_optimum_palette(Palette * palette, const uint8_t * image,
527 int width, int height, int stride)
529 //this isn't implemented yet! Default palette only!
533 static inline int encode_15_7_sl(Palette * palette, uint8_t * dest,
534 const uint8_t * src, int width, int dist)
537 for (x = 0; x < width; x++) {
538 len += write_pixel_15_7(palette, dest + len, src + 3 * x, dist);
543 static int encode_15_7(Palette * palette, Block * b, const uint8_t * src,
544 int stride, int dist)
547 uint8_t *ptr = b->enc;
548 for (i = 0; i < b->start; i++)
549 ptr += encode_15_7_sl(palette, ptr, src + i * stride, b->width, dist);
551 for (; i < b->start + b->len; i++)
552 ptr += encode_15_7_sl(palette, ptr, src + i * stride, b->width, dist);
554 for (; i < b->height; i++)
555 ptr += encode_15_7_sl(palette, ptr, src + i * stride, b->width, dist);
556 b->enc_size = ptr - b->enc;
560 static int encode_block(FlashSV2Context *s, Palette * palette, Block * b,
561 Block * prev, const uint8_t * src, int stride, int comp,
562 int dist, int keyframe)
564 unsigned buf_size = b->width * b->height * 6;
565 uint8_t *buf = s->blockbuffer;
568 if (b->flags & COLORSPACE_15_7) {
569 encode_15_7(palette, b, src, stride, dist);
571 encode_bgr(b, src, stride);
575 b->data_size = buf_size;
576 res = encode_zlib(b, b->data, &b->data_size, comp);
581 res = encode_zlibprime(b, prev, buf, &buf_size, comp);
585 if (buf_size < b->data_size) {
586 b->data_size = buf_size;
587 memcpy(b->data, buf, buf_size);
588 b->flags |= ZLIB_PRIME_COMPRESS_PREVIOUS;
597 static int compare_sl(FlashSV2Context * s, Block * b, const uint8_t * src,
598 uint8_t * frame, uint8_t * key, int y, int keyframe)
600 if (memcmp(src, frame, b->width * 3) != 0) {
602 memcpy(frame, src, b->width * 3);
603 #ifndef FLASHSV2_DUMB
607 if (memcmp(src, key, b->width * 3) != 0) {
610 b->len = y + 1 - b->start;
615 static int mark_all_blocks(FlashSV2Context * s, const uint8_t * src, int stride,
618 int sl, rsl, col, pos, possl;
620 for (sl = s->image_height - 1; sl >= 0; sl--) {
621 for (col = 0; col < s->cols; col++) {
622 rsl = s->image_height - sl - 1;
623 b = s->frame_blocks + col + rsl / s->block_height * s->cols;
624 possl = stride * sl + col * s->block_width * 3;
625 pos = s->image_width * rsl * 3 + col * s->block_width * 3;
626 compare_sl(s, b, src + possl, s->current_frame + pos,
627 s->key_frame + pos, rsl % s->block_height, keyframe);
630 #ifndef FLASHSV2_DUMB
631 s->tot_lines += s->image_height * s->cols;
636 static int encode_all_blocks(FlashSV2Context * s, int keyframe)
641 for (row = 0; row < s->rows; row++) {
642 for (col = 0; col < s->cols; col++) {
643 b = s->frame_blocks + (row * s->cols + col);
644 prev = s->key_blocks + (row * s->cols + col);
645 b->flags = s->use15_7 ? COLORSPACE_15_7 : 0;
649 } else if (!b->dirty) {
654 } else if (b->start != 0 || b->len != b->height) {
655 b->flags |= HAS_DIFF_BLOCKS;
657 data = s->current_frame + s->image_width * 3 * s->block_height * row + s->block_width * col * 3;
658 res = encode_block(s, &s->palette, b, prev, data, s->image_width * 3, s->comp, s->dist, keyframe);
659 #ifndef FLASHSV2_DUMB
662 s->comp_size += b->data_size;
663 s->uncomp_size += b->enc_size;
669 #ifndef FLASHSV2_DUMB
670 s->raw_size += s->image_width * s->image_height * 3;
671 s->tot_blocks += s->rows * s->cols;
676 static int write_all_blocks(FlashSV2Context * s, uint8_t * buf,
679 int row, col, buf_pos = 0, len;
681 for (row = 0; row < s->rows; row++) {
682 for (col = 0; col < s->cols; col++) {
683 b = s->frame_blocks + row * s->cols + col;
684 len = write_block(b, buf + buf_pos, buf_size - buf_pos);
685 b->start = b->len = b->dirty = 0;
694 static int write_bitstream(FlashSV2Context * s, const uint8_t * src, int stride,
695 uint8_t * buf, int buf_size, int keyframe)
699 res = mark_all_blocks(s, src, stride, keyframe);
702 res = encode_all_blocks(s, keyframe);
706 res = write_header(s, buf, buf_size);
712 res = write_all_blocks(s, buf + buf_pos, buf_size - buf_pos);
716 #ifndef FLASHSV2_DUMB
717 s->total_bits += ((double) buf_pos) * 8.0;
723 static void recommend_keyframe(FlashSV2Context * s, int *keyframe)
725 #ifndef FLASHSV2_DUMB
726 double block_ratio, line_ratio, enc_ratio, comp_ratio, data_ratio;
727 if (s->avctx->gop_size > 0) {
728 block_ratio = s->diff_blocks / s->tot_blocks;
729 line_ratio = s->diff_lines / s->tot_lines;
730 enc_ratio = s->uncomp_size / s->raw_size;
731 comp_ratio = s->comp_size / s->uncomp_size;
732 data_ratio = s->comp_size / s->raw_size;
734 if ((block_ratio >= 0.5 && line_ratio / block_ratio <= 0.5) || line_ratio >= 0.95) {
744 #ifndef FLASHSV2_DUMB
745 static const double block_size_fraction = 1.0 / 300;
746 static const double use15_7_threshold = 8192;
747 static const double color15_7_factor = 100;
749 static int optimum_block_width(FlashSV2Context * s)
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;
753 double width = block_size_fraction * sqrt(0.5 * save * s->rows * s->cols) * s->image_width;
754 int pwidth = ((int) width);
755 return FFCLIP(pwidth & ~15, 256, 16);
761 static int optimum_block_height(FlashSV2Context * s)
763 #ifndef FLASHSV2_DUMB
764 double save = (1-pow(s->diff_lines/s->diff_blocks/s->block_height, 0.5)) * s->comp_size/s->tot_blocks;
765 double height = block_size_fraction * sqrt(0.5 * save * s->rows * s->cols) * s->image_height;
766 int pheight = ((int) height);
767 return FFCLIP(pheight & ~15, 256, 16);
773 static int optimum_use15_7(FlashSV2Context * s)
775 #ifndef FLASHSV2_DUMB
776 double ideal = ((double)(s->avctx->bit_rate * s->avctx->time_base.den * s->avctx->ticks_per_frame)) /
777 ((double) s->avctx->time_base.num) * s->avctx->frame_number;
778 if (ideal + use15_7_threshold < s->total_bits) {
784 return s->avctx->global_quality == 0;
788 static int optimum_dist(FlashSV2Context * s)
790 #ifndef FLASHSV2_DUMB
792 s->avctx->bit_rate * s->avctx->time_base.den *
793 s->avctx->ticks_per_frame;
794 int dist = pow((s->total_bits / ideal) * color15_7_factor, 3);
795 av_log(s->avctx, AV_LOG_DEBUG, "dist: %d\n", dist);
803 static int reconfigure_at_keyframe(FlashSV2Context * s, const uint8_t * image,
806 int update_palette = 0;
808 int block_width = optimum_block_width (s);
809 int block_height = optimum_block_height(s);
811 if (block_width != s->block_width || block_height != s->block_height) {
812 res = update_block_dimensions(s, block_width, block_height);
817 s->use15_7 = optimum_use15_7(s);
819 if ((s->use_custom_palette && s->palette_type != 1) || update_palette) {
820 res = generate_optimum_palette(&s->palette, image, s->image_width, s->image_height, stride);
824 av_log(s->avctx, AV_LOG_DEBUG, "Generated optimum palette\n");
825 } else if (!s->use_custom_palette && s->palette_type != 0) {
826 res = generate_default_palette(&s->palette);
830 av_log(s->avctx, AV_LOG_DEBUG, "Generated default palette\n");
840 static int flashsv2_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
841 const AVFrame *p, int *got_packet)
843 FlashSV2Context *const s = avctx->priv_data;
847 if ((res = ff_alloc_packet2(avctx, pkt, s->frame_size + AV_INPUT_BUFFER_MIN_SIZE, 0)) < 0)
850 /* First frame needs to be a keyframe */
851 if (avctx->frame_number == 0)
854 /* Check the placement of keyframes */
855 if (avctx->gop_size > 0) {
856 if (avctx->frame_number >= s->last_key_frame + avctx->gop_size)
861 && avctx->frame_number > s->last_key_frame + avctx->keyint_min) {
862 recommend_keyframe(s, &keyframe);
864 av_log(avctx, AV_LOG_DEBUG, "Recommending key frame at frame %d\n", avctx->frame_number);
868 res = reconfigure_at_keyframe(s, p->data[0], p->linesize[0]);
874 s->dist = optimum_dist(s);
876 res = write_bitstream(s, p->data[0], p->linesize[0], pkt->data, pkt->size, keyframe);
880 s->last_key_frame = avctx->frame_number;
881 pkt->flags |= AV_PKT_FLAG_KEY;
882 av_log(avctx, AV_LOG_DEBUG, "Inserting key frame at frame %d\n", avctx->frame_number);
891 static av_cold int flashsv2_encode_end(AVCodecContext * avctx)
893 FlashSV2Context *s = avctx->priv_data;
900 const AVCodec ff_flashsv2_encoder = {
902 .long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video Version 2"),
903 .type = AVMEDIA_TYPE_VIDEO,
904 .id = AV_CODEC_ID_FLASHSV2,
905 .priv_data_size = sizeof(FlashSV2Context),
906 .init = flashsv2_encode_init,
907 .encode2 = flashsv2_encode_frame,
908 .close = flashsv2_encode_end,
909 .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE },
910 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,