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;
100 int use15_7, dist, comp;
106 int image_width, image_height;
107 int block_width, block_height;
109 uint8_t use_custom_palette;
110 uint8_t palette_type; ///< 0=>default, 1=>custom - changed when palette regenerated.
112 #ifndef FLASHSV2_DUMB
113 double tot_blocks; ///< blocks encoded since last keyframe
114 double diff_blocks; ///< blocks that were different since last keyframe
115 double tot_lines; ///< total scanlines in image since last keyframe
116 double diff_lines; ///< scanlines that were different since last keyframe
117 double raw_size; ///< size of raw frames since last keyframe
118 double comp_size; ///< size of compressed data since last keyframe
119 double uncomp_size; ///< size of uncompressed data since last keyframe
121 double total_bits; ///< total bits written to stream so far
125 static av_cold void cleanup(FlashSV2Context * s)
127 av_freep(&s->encbuffer);
128 av_freep(&s->keybuffer);
129 av_freep(&s->databuffer);
130 av_freep(&s->current_frame);
131 av_freep(&s->key_frame);
133 av_freep(&s->frame_blocks);
134 av_freep(&s->key_blocks);
137 static void init_blocks(FlashSV2Context * s, Block * blocks,
138 uint8_t * encbuf, uint8_t * databuf)
142 for (col = 0; col < s->cols; col++) {
143 for (row = 0; row < s->rows; row++) {
144 b = blocks + (col + row * s->cols);
145 b->width = (col < s->cols - 1) ?
147 s->image_width - col * s->block_width;
149 b->height = (row < s->rows - 1) ?
151 s->image_height - row * s->block_height;
157 encbuf += b->width * b->height * 3;
158 databuf += !databuf ? 0 : b->width * b->height * 6;
163 static void reset_stats(FlashSV2Context * s)
165 #ifndef FLASHSV2_DUMB
166 s->diff_blocks = 0.1;
170 s->raw_size = s->comp_size = s->uncomp_size = 10;
174 static av_cold int flashsv2_encode_init(AVCodecContext * avctx)
176 FlashSV2Context *s = avctx->priv_data;
180 s->comp = avctx->compression_level;
183 if (s->comp < 0 || s->comp > 9) {
184 av_log(avctx, AV_LOG_ERROR,
185 "Compression level should be 0-9, not %d\n", s->comp);
190 if ((avctx->width > 4095) || (avctx->height > 4095)) {
191 av_log(avctx, AV_LOG_ERROR,
192 "Input dimensions too large, input must be max 4096x4096 !\n");
196 if (av_image_check_size(avctx->width, avctx->height, 0, avctx) < 0)
200 s->last_key_frame = 0;
202 s->image_width = avctx->width;
203 s->image_height = avctx->height;
205 s->block_width = (s->image_width / 12) & ~15;
206 s->block_height = (s->image_height / 12) & ~15;
208 s->rows = (s->image_height + s->block_height - 1) / s->block_height;
209 s->cols = (s->image_width + s->block_width - 1) / s->block_width;
211 s->frame_size = s->image_width * s->image_height * 3;
212 s->blocks_size = s->rows * s->cols * sizeof(Block);
214 s->encbuffer = av_mallocz(s->frame_size);
215 s->keybuffer = av_mallocz(s->frame_size);
216 s->databuffer = av_mallocz(s->frame_size * 6);
217 s->current_frame = av_mallocz(s->frame_size);
218 s->key_frame = av_mallocz(s->frame_size);
219 s->frame_blocks = av_mallocz(s->blocks_size);
220 s->key_blocks = av_mallocz(s->blocks_size);
222 init_blocks(s, s->frame_blocks, s->encbuffer, s->databuffer);
223 init_blocks(s, s->key_blocks, s->keybuffer, 0);
225 #ifndef FLASHSV2_DUMB
229 s->use_custom_palette = 0;
230 s->palette_type = -1; // so that the palette will be generated in reconfigure_at_keyframe
232 if (!s->encbuffer || !s->keybuffer || !s->databuffer
233 || !s->current_frame || !s->key_frame || !s->key_blocks
234 || !s->frame_blocks) {
235 av_log(avctx, AV_LOG_ERROR, "Memory allocation failed.\n");
243 static int new_key_frame(FlashSV2Context * s)
246 memcpy(s->key_blocks, s->frame_blocks, s->blocks_size);
247 memcpy(s->key_frame, s->current_frame, s->frame_size);
249 for (i = 0; i < s->rows * s->cols; i++) {
250 s->key_blocks[i].enc += (s->keybuffer - s->encbuffer);
251 s->key_blocks[i].sl_begin = 0;
252 s->key_blocks[i].sl_end = 0;
253 s->key_blocks[i].data = 0;
255 FFSWAP(uint8_t * , s->keybuffer, s->encbuffer);
260 static int write_palette(FlashSV2Context * s, uint8_t * buf, int buf_size)
262 //this isn't implemented yet! Default palette only!
266 static int write_header(FlashSV2Context * s, uint8_t * buf, int buf_size)
274 init_put_bits(&pb, buf, buf_size * 8);
276 put_bits(&pb, 4, (s->block_width >> 4) - 1);
277 put_bits(&pb, 12, s->image_width);
278 put_bits(&pb, 4, (s->block_height >> 4) - 1);
279 put_bits(&pb, 12, s->image_height);
284 buf[buf_pos++] = s->flags;
286 if (s->flags & HAS_PALLET_INFO) {
287 len = write_palette(s, buf + buf_pos, buf_size - buf_pos);
296 static int write_block(Block * b, uint8_t * buf, int buf_size)
299 unsigned block_size = b->data_size;
301 if (b->flags & HAS_DIFF_BLOCKS)
303 if (b->flags & ZLIB_PRIME_COMPRESS_CURRENT)
307 if (buf_size < block_size + 2)
310 buf[buf_pos++] = block_size >> 8;
311 buf[buf_pos++] = block_size;
316 buf[buf_pos++] = b->flags;
318 if (b->flags & HAS_DIFF_BLOCKS) {
319 buf[buf_pos++] = (b->start);
320 buf[buf_pos++] = (b->len);
323 if (b->flags & ZLIB_PRIME_COMPRESS_CURRENT) {
324 //This feature of the format is poorly understood, and as of now, unused.
325 buf[buf_pos++] = (b->col);
326 buf[buf_pos++] = (b->row);
329 memcpy(buf + buf_pos, b->data, b->data_size);
331 buf_pos += b->data_size;
336 static int encode_zlib(Block * b, uint8_t * buf, unsigned long *buf_size, int comp)
338 int res = compress2(buf, buf_size, b->sl_begin, b->sl_end - b->sl_begin, comp);
339 return res == Z_OK ? 0 : -1;
342 static int encode_zlibprime(Block * b, Block * prime, uint8_t * buf,
343 int *buf_size, int comp)
350 res = deflateInit(&s, comp);
354 s.next_in = prime->enc;
355 s.avail_in = prime->enc_size;
356 while (s.avail_in > 0) {
358 s.avail_out = *buf_size;
359 res = deflate(&s, Z_SYNC_FLUSH);
364 s.next_in = b->sl_begin;
365 s.avail_in = b->sl_end - b->sl_begin;
367 s.avail_out = *buf_size;
368 res = deflate(&s, Z_FINISH);
370 *buf_size -= s.avail_out;
371 if (res != Z_STREAM_END)
376 static int encode_bgr(Block * b, const uint8_t * src, int stride)
379 uint8_t *ptr = b->enc;
380 for (i = 0; i < b->start; i++)
381 memcpy(ptr + i * b->width * 3, src + i * stride, b->width * 3);
382 b->sl_begin = ptr + i * b->width * 3;
383 for (; i < b->start + b->len; i++)
384 memcpy(ptr + i * b->width * 3, src + i * stride, b->width * 3);
385 b->sl_end = ptr + i * b->width * 3;
386 for (; i < b->height; i++)
387 memcpy(ptr + i * b->width * 3, src + i * stride, b->width * 3);
388 b->enc_size = ptr + i * b->width * 3 - b->enc;
392 static inline unsigned pixel_color15(const uint8_t * src)
394 return (src[0] >> 3) | ((src[1] & 0xf8) << 2) | ((src[2] & 0xf8) << 7);
397 static inline unsigned int chroma_diff(unsigned int c1, unsigned int c2)
399 unsigned int t1 = (c1 & 0x000000ff) + ((c1 & 0x0000ff00) >> 8) + ((c1 & 0x00ff0000) >> 16);
400 unsigned int t2 = (c2 & 0x000000ff) + ((c2 & 0x0000ff00) >> 8) + ((c2 & 0x00ff0000) >> 16);
402 return abs(t1 - t2) + abs((c1 & 0x000000ff) - (c2 & 0x000000ff)) +
403 abs(((c1 & 0x0000ff00) >> 8) - ((c2 & 0x0000ff00) >> 8)) +
404 abs(((c1 & 0x00ff0000) >> 16) - ((c2 & 0x00ff0000) >> 16));
407 static inline int pixel_color7_fast(Palette * palette, unsigned c15)
409 return palette->index[c15];
412 static int pixel_color7_slow(Palette * palette, unsigned color)
414 int i, min = 0x7fffffff;
416 for (i = 0; i < 128; i++) {
417 int c1 = palette->colors[i];
418 int diff = chroma_diff(c1, color);
427 static inline unsigned pixel_bgr(const uint8_t * src)
429 return (src[0]) | (src[1] << 8) | (src[2] << 16);
432 static int write_pixel_15_7(Palette * palette, uint8_t * dest, const uint8_t * src,
435 unsigned c15 = pixel_color15(src);
436 unsigned color = pixel_bgr(src);
437 int d15 = chroma_diff(color, color & 0x00f8f8f8);
438 int c7 = pixel_color7_fast(palette, c15);
439 int d7 = chroma_diff(color, palette->colors[c7]);
440 if (dist + d15 >= d7) {
444 dest[0] = 0x80 | (c15 >> 8);
445 dest[1] = c15 & 0xff;
450 static int update_palette_index(Palette * palette)
453 unsigned int bgr, c15, index;
454 for (r = 4; r < 256; r += 8) {
455 for (g = 4; g < 256; g += 8) {
456 for (b = 4; b < 256; b += 8) {
457 bgr = b | (g << 8) | (r << 16);
458 c15 = (b >> 3) | ((g & 0xf8) << 2) | ((r & 0xf8) << 7);
459 index = pixel_color7_slow(palette, bgr);
461 palette->index[c15] = index;
468 static const unsigned int default_screen_video_v2_palette[128] = {
469 0x00000000, 0x00333333, 0x00666666, 0x00999999, 0x00CCCCCC, 0x00FFFFFF,
470 0x00330000, 0x00660000, 0x00990000, 0x00CC0000, 0x00FF0000, 0x00003300,
471 0x00006600, 0x00009900, 0x0000CC00, 0x0000FF00, 0x00000033, 0x00000066,
472 0x00000099, 0x000000CC, 0x000000FF, 0x00333300, 0x00666600, 0x00999900,
473 0x00CCCC00, 0x00FFFF00, 0x00003333, 0x00006666, 0x00009999, 0x0000CCCC,
474 0x0000FFFF, 0x00330033, 0x00660066, 0x00990099, 0x00CC00CC, 0x00FF00FF,
475 0x00FFFF33, 0x00FFFF66, 0x00FFFF99, 0x00FFFFCC, 0x00FF33FF, 0x00FF66FF,
476 0x00FF99FF, 0x00FFCCFF, 0x0033FFFF, 0x0066FFFF, 0x0099FFFF, 0x00CCFFFF,
477 0x00CCCC33, 0x00CCCC66, 0x00CCCC99, 0x00CCCCFF, 0x00CC33CC, 0x00CC66CC,
478 0x00CC99CC, 0x00CCFFCC, 0x0033CCCC, 0x0066CCCC, 0x0099CCCC, 0x00FFCCCC,
479 0x00999933, 0x00999966, 0x009999CC, 0x009999FF, 0x00993399, 0x00996699,
480 0x0099CC99, 0x0099FF99, 0x00339999, 0x00669999, 0x00CC9999, 0x00FF9999,
481 0x00666633, 0x00666699, 0x006666CC, 0x006666FF, 0x00663366, 0x00669966,
482 0x0066CC66, 0x0066FF66, 0x00336666, 0x00996666, 0x00CC6666, 0x00FF6666,
483 0x00333366, 0x00333399, 0x003333CC, 0x003333FF, 0x00336633, 0x00339933,
484 0x0033CC33, 0x0033FF33, 0x00663333, 0x00993333, 0x00CC3333, 0x00FF3333,
485 0x00003366, 0x00336600, 0x00660033, 0x00006633, 0x00330066, 0x00663300,
486 0x00336699, 0x00669933, 0x00993366, 0x00339966, 0x00663399, 0x00996633,
487 0x006699CC, 0x0099CC66, 0x00CC6699, 0x0066CC99, 0x009966CC, 0x00CC9966,
488 0x0099CCFF, 0x00CCFF99, 0x00FF99CC, 0x0099FFCC, 0x00CC99FF, 0x00FFCC99,
489 0x00111111, 0x00222222, 0x00444444, 0x00555555, 0x00AAAAAA, 0x00BBBBBB,
490 0x00DDDDDD, 0x00EEEEEE
493 static int generate_default_palette(Palette * palette)
495 memcpy(palette->colors, default_screen_video_v2_palette,
496 sizeof(default_screen_video_v2_palette));
498 return update_palette_index(palette);
501 static int generate_optimum_palette(Palette * palette, const uint8_t * image,
502 int width, int height, int stride)
504 //this isn't implemented yet! Default palette only!
508 static inline int encode_15_7_sl(Palette * palette, uint8_t * dest,
509 const uint8_t * src, int width, int dist)
512 for (x = 0; x < width; x++) {
513 len += write_pixel_15_7(palette, dest + len, src + 3 * x, dist);
518 static int encode_15_7(Palette * palette, Block * b, const uint8_t * src,
519 int stride, int dist)
522 uint8_t *ptr = b->enc;
523 for (i = 0; i < b->start; i++)
524 ptr += encode_15_7_sl(palette, ptr, src + i * stride, b->width, dist);
526 for (; i < b->start + b->len; i++)
527 ptr += encode_15_7_sl(palette, ptr, src + i * stride, b->width, dist);
529 for (; i < b->height; i++)
530 ptr += encode_15_7_sl(palette, ptr, src + i * stride, b->width, dist);
531 b->enc_size = ptr - b->enc;
535 static int encode_block(Palette * palette, Block * b, Block * prev,
536 const uint8_t * src, int stride, int comp, int dist,
539 unsigned buf_size = b->width * b->height * 6;
540 uint8_t buf[buf_size];
542 if (b->flags & COLORSPACE_15_7) {
543 encode_15_7(palette, b, src, stride, dist);
545 encode_bgr(b, src, stride);
549 b->data_size = buf_size;
550 res = encode_zlib(b, b->data, &b->data_size, comp);
555 res = encode_zlibprime(b, prev, buf, &buf_size, comp);
559 if (buf_size < b->data_size) {
560 b->data_size = buf_size;
561 memcpy(b->data, buf, buf_size);
562 b->flags |= ZLIB_PRIME_COMPRESS_PREVIOUS;
571 static int compare_sl(FlashSV2Context * s, Block * b, const uint8_t * src,
572 uint8_t * frame, uint8_t * key, int y, int keyframe)
574 if (memcmp(src, frame, b->width * 3) != 0) {
576 memcpy(frame, src, b->width * 3);
577 #ifndef FLASHSV2_DUMB
581 if (memcmp(src, key, b->width * 3) != 0) {
584 b->len = y + 1 - b->start;
589 static int mark_all_blocks(FlashSV2Context * s, const uint8_t * src, int stride,
592 int sl, rsl, col, pos, possl;
594 for (sl = s->image_height - 1; sl >= 0; sl--) {
595 for (col = 0; col < s->cols; col++) {
596 rsl = s->image_height - sl - 1;
597 b = s->frame_blocks + col + rsl / s->block_height * s->cols;
598 possl = stride * sl + col * s->block_width * 3;
599 pos = s->image_width * rsl * 3 + col * s->block_width * 3;
600 compare_sl(s, b, src + possl, s->current_frame + pos,
601 s->key_frame + pos, rsl % s->block_height, keyframe);
604 #ifndef FLASHSV2_DUMB
605 s->tot_lines += s->image_height * s->cols;
610 static int encode_all_blocks(FlashSV2Context * s, int keyframe)
615 for (row = 0; row < s->rows; row++) {
616 for (col = 0; col < s->cols; col++) {
617 b = s->frame_blocks + (row * s->cols + col);
618 prev = s->key_blocks + (row * s->cols + col);
622 b->flags = s->use15_7 ? COLORSPACE_15_7 : 0;
623 } else if (!b->dirty) {
627 b->flags = s->use15_7 ? COLORSPACE_15_7 : 0;
630 b->flags = s->use15_7 ? COLORSPACE_15_7 | HAS_DIFF_BLOCKS : HAS_DIFF_BLOCKS;
632 data = s->current_frame + s->image_width * 3 * s->block_height * row + s->block_width * col * 3;
633 res = encode_block(&s->palette, b, prev, data, s->image_width * 3, s->comp, s->dist, keyframe);
634 #ifndef FLASHSV2_DUMB
637 s->comp_size += b->data_size;
638 s->uncomp_size += b->enc_size;
644 #ifndef FLASHSV2_DUMB
645 s->raw_size += s->image_width * s->image_height * 3;
646 s->tot_blocks += s->rows * s->cols;
651 static int write_all_blocks(FlashSV2Context * s, uint8_t * buf,
654 int row, col, buf_pos = 0, len;
656 for (row = 0; row < s->rows; row++) {
657 for (col = 0; col < s->cols; col++) {
658 b = s->frame_blocks + row * s->cols + col;
659 len = write_block(b, buf + buf_pos, buf_size - buf_pos);
660 b->start = b->len = b->dirty = 0;
669 static int write_bitstream(FlashSV2Context * s, const uint8_t * src, int stride,
670 uint8_t * buf, int buf_size, int keyframe)
674 res = mark_all_blocks(s, src, stride, keyframe);
677 res = encode_all_blocks(s, keyframe);
681 res = write_header(s, buf, buf_size);
687 res = write_all_blocks(s, buf + buf_pos, buf_size - buf_pos);
691 #ifndef FLASHSV2_DUMB
692 s->total_bits += ((double) buf_pos) * 8.0;
698 static void recommend_keyframe(FlashSV2Context * s, int *keyframe)
700 #ifndef FLASHSV2_DUMB
701 double block_ratio, line_ratio, enc_ratio, comp_ratio, data_ratio;
702 if (s->avctx->gop_size > 0) {
703 block_ratio = s->diff_blocks / s->tot_blocks;
704 line_ratio = s->diff_lines / s->tot_lines;
705 enc_ratio = s->uncomp_size / s->raw_size;
706 comp_ratio = s->comp_size / s->uncomp_size;
707 data_ratio = s->comp_size / s->raw_size;
709 if ((block_ratio >= 0.5 && line_ratio / block_ratio <= 0.5) || line_ratio >= 0.95) {
719 static const double block_size_fraction = 1.0 / 300;
720 static int optimum_block_width(FlashSV2Context * s)
722 #ifndef FLASHSV2_DUMB
723 double save = (1-pow(s->diff_lines/s->diff_blocks/s->block_height, 0.5)) * s->comp_size/s->tot_blocks;
724 double width = block_size_fraction * sqrt(0.5 * save * s->rows * s->cols) * s->image_width;
725 int pwidth = ((int) width);
726 return FFCLIP(pwidth & ~15, 256, 16);
732 static int optimum_block_height(FlashSV2Context * s)
734 #ifndef FLASHSV2_DUMB
735 double save = (1-pow(s->diff_lines/s->diff_blocks/s->block_height, 0.5)) * s->comp_size/s->tot_blocks;
736 double height = block_size_fraction * sqrt(0.5 * save * s->rows * s->cols) * s->image_height;
737 int pheight = ((int) height);
738 return FFCLIP(pheight & ~15, 256, 16);
744 static const double use15_7_threshold = 8192;
746 static int optimum_use15_7(FlashSV2Context * s)
748 #ifndef FLASHSV2_DUMB
749 double ideal = ((double)(s->avctx->bit_rate * s->avctx->time_base.den * s->avctx->ticks_per_frame)) /
750 ((double) s->avctx->time_base.num) * s->avctx->frame_number;
751 if (ideal + use15_7_threshold < s->total_bits) {
757 return s->avctx->global_quality == 0;
761 static const double color15_7_factor = 100;
763 static int optimum_dist(FlashSV2Context * s)
765 #ifndef FLASHSV2_DUMB
767 s->avctx->bit_rate * s->avctx->time_base.den *
768 s->avctx->ticks_per_frame;
769 int dist = pow((s->total_bits / ideal) * color15_7_factor, 3);
770 av_log(s->avctx, AV_LOG_DEBUG, "dist: %d\n", dist);
778 static int reconfigure_at_keyframe(FlashSV2Context * s, const uint8_t * image,
781 int update_palette = 0;
783 s->block_width = optimum_block_width(s);
784 s->block_height = optimum_block_height(s);
786 s->rows = (s->image_height + s->block_height - 1) / s->block_height;
787 s->cols = (s->image_width + s->block_width - 1) / s->block_width;
789 if (s->rows * s->cols != s->blocks_size / sizeof(Block)) {
790 if (s->rows * s->cols > s->blocks_size / sizeof(Block)) {
791 s->frame_blocks = av_realloc(s->frame_blocks, s->rows * s->cols * sizeof(Block));
792 s->key_blocks = av_realloc(s->key_blocks, s->cols * s->rows * sizeof(Block));
793 if (!s->frame_blocks || !s->key_blocks) {
794 av_log(s->avctx, AV_LOG_ERROR, "Memory allocation failed.\n");
797 s->blocks_size = s->rows * s->cols * sizeof(Block);
799 init_blocks(s, s->frame_blocks, s->encbuffer, s->databuffer);
800 init_blocks(s, s->key_blocks, s->keybuffer, 0);
804 s->use15_7 = optimum_use15_7(s);
806 if ((s->use_custom_palette && s->palette_type != 1) || update_palette) {
807 res = generate_optimum_palette(&s->palette, image, s->image_width, s->image_height, stride);
811 av_log(s->avctx, AV_LOG_DEBUG, "Generated optimum palette\n");
812 } else if (!s->use_custom_palette && s->palette_type != 0) {
813 res = generate_default_palette(&s->palette);
817 av_log(s->avctx, AV_LOG_DEBUG, "Generated default palette\n");
827 static int flashsv2_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
828 const AVFrame *pict, int *got_packet)
830 FlashSV2Context *const s = avctx->priv_data;
831 AVFrame *const p = &s->frame;
837 if ((res = ff_alloc_packet2(avctx, pkt, s->frame_size + FF_MIN_BUFFER_SIZE)) < 0)
840 /* First frame needs to be a keyframe */
841 if (avctx->frame_number == 0)
844 /* Check the placement of keyframes */
845 if (avctx->gop_size > 0) {
846 if (avctx->frame_number >= s->last_key_frame + avctx->gop_size)
851 && avctx->frame_number > s->last_key_frame + avctx->keyint_min) {
852 recommend_keyframe(s, &keyframe);
854 av_log(avctx, AV_LOG_DEBUG, "Recommending key frame at frame %d\n", avctx->frame_number);
858 res = reconfigure_at_keyframe(s, p->data[0], p->linesize[0]);
864 s->dist = optimum_dist(s);
866 res = write_bitstream(s, p->data[0], p->linesize[0], pkt->data, pkt->size, keyframe);
870 p->pict_type = AV_PICTURE_TYPE_I;
872 s->last_key_frame = avctx->frame_number;
873 pkt->flags |= AV_PKT_FLAG_KEY;
874 av_log(avctx, AV_LOG_DEBUG, "Inserting key frame at frame %d\n", avctx->frame_number);
876 p->pict_type = AV_PICTURE_TYPE_P;
880 avctx->coded_frame = p;
888 static av_cold int flashsv2_encode_end(AVCodecContext * avctx)
890 FlashSV2Context *s = avctx->priv_data;
897 AVCodec ff_flashsv2_encoder = {
899 .type = AVMEDIA_TYPE_VIDEO,
900 .id = CODEC_ID_FLASHSV2,
901 .priv_data_size = sizeof(FlashSV2Context),
902 .init = flashsv2_encode_init,
903 .encode2 = flashsv2_encode_frame,
904 .close = flashsv2_encode_end,
905 .pix_fmts = (enum PixelFormat[]) {PIX_FMT_BGR24, PIX_FMT_NONE},
906 .long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video Version 2"),
907 .capabilities = CODEC_CAP_EXPERIMENTAL,