lavc: replace rest of deprecated FF_*_TYPE with AV_PICTURE_TYPE_*
[ffmpeg.git] / libavcodec / flashsv2enc.c
1 /*
2  * Flash Screen Video Version 2 encoder
3  * Copyright (C) 2009 Joshua Warner
4  *
5  * This file is part of FFmpeg.
6  *
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.
11  *
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.
16  *
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
20  */
21
22 /**
23  * @file
24  * Flash Screen Video Version 2 encoder
25  * @author Joshua Warner
26  */
27
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.
35  */
36
37 /* TODO:
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.
43  */
44
45 #include <stdio.h>
46 #include <stdlib.h>
47 #include <zlib.h>
48
49 #include "libavutil/imgutils.h"
50 #include "avcodec.h"
51 #include "put_bits.h"
52 #include "bytestream.h"
53
54 #define HAS_IFRAME_IMAGE 0x02
55 #define HAS_PALLET_INFO 0x01
56
57 #define COLORSPACE_BGR 0x00
58 #define COLORSPACE_15_7 0x10
59 #define HAS_DIFF_BLOCKS 0x04
60 #define ZLIB_PRIME_COMPRESS_CURRENT 0x02
61 #define ZLIB_PRIME_COMPRESS_PREVIOUS 0x01
62
63 // Disables experimental "smart" parameter-choosing code, as well as the statistics that it depends on.
64 // At the moment, the "smart" code is a great example of how the parameters *shouldn't* be chosen.
65 #define FLASHSV2_DUMB
66
67 typedef struct Block {
68     uint8_t *enc;
69     uint8_t *sl_begin, *sl_end;
70     int enc_size;
71     uint8_t *data;
72     unsigned long data_size;
73
74     uint8_t start, len;
75     uint8_t dirty;
76     uint8_t col, row, width, height;
77     uint8_t flags;
78 } Block;
79
80 typedef struct Palette {
81     unsigned colors[128];
82     uint8_t index[1 << 15];
83 } Palette;
84
85 typedef struct FlashSV2Context {
86     AVCodecContext *avctx;
87     uint8_t *current_frame;
88     uint8_t *key_frame;
89     AVFrame frame;
90     uint8_t *encbuffer;
91     uint8_t *keybuffer;
92     uint8_t *databuffer;
93
94     Block *frame_blocks;
95     Block *key_blocks;
96     int frame_size;
97     int blocks_size;
98
99     int use15_7, dist, comp;
100
101     int rows, cols;
102
103     int last_key_frame;
104
105     int image_width, image_height;
106     int block_width, block_height;
107     uint8_t flags;
108     uint8_t use_custom_palette;
109     uint8_t palette_type;       ///< 0=>default, 1=>custom - changed when palette regenerated.
110     Palette palette;
111 #ifndef FLASHSV2_DUMB
112     double tot_blocks;          ///< blocks encoded since last keyframe
113     double diff_blocks;         ///< blocks that were different since last keyframe
114     double tot_lines;           ///< total scanlines in image since last keyframe
115     double diff_lines;          ///< scanlines that were different since last keyframe
116     double raw_size;            ///< size of raw frames since last keyframe
117     double comp_size;           ///< size of compressed data since last keyframe
118     double uncomp_size;         ///< size of uncompressed data since last keyframe
119
120     double total_bits;          ///< total bits written to stream so far
121 #endif
122 } FlashSV2Context;
123
124 static av_cold void cleanup(FlashSV2Context * s)
125 {
126     av_freep(&s->encbuffer);
127     av_freep(&s->keybuffer);
128     av_freep(&s->databuffer);
129     av_freep(&s->current_frame);
130     av_freep(&s->key_frame);
131
132     av_freep(&s->frame_blocks);
133     av_freep(&s->key_blocks);
134 }
135
136 static void init_blocks(FlashSV2Context * s, Block * blocks,
137                         uint8_t * encbuf, uint8_t * databuf)
138 {
139     int row, col;
140     Block *b;
141     for (col = 0; col < s->cols; col++) {
142         for (row = 0; row < s->rows; row++) {
143             b = blocks + (col + row * s->cols);
144             b->width = (col < s->cols - 1) ?
145                 s->block_width :
146                 s->image_width - col * s->block_width;
147
148             b->height = (row < s->rows - 1) ?
149                 s->block_height :
150                 s->image_height - row * s->block_height;
151
152             b->row   = row;
153             b->col   = col;
154             b->enc   = encbuf;
155             b->data  = databuf;
156             encbuf  += b->width * b->height * 3;
157             databuf += !databuf ? 0 : b->width * b->height * 6;
158         }
159     }
160 }
161
162 static void reset_stats(FlashSV2Context * s)
163 {
164 #ifndef FLASHSV2_DUMB
165     s->diff_blocks = 0.1;
166     s->tot_blocks = 1;
167     s->diff_lines = 0.1;
168     s->tot_lines = 1;
169     s->raw_size = s->comp_size = s->uncomp_size = 10;
170 #endif
171 }
172
173 static av_cold int flashsv2_encode_init(AVCodecContext * avctx)
174 {
175     FlashSV2Context *s = avctx->priv_data;
176
177     s->avctx = avctx;
178
179     s->comp = avctx->compression_level;
180     if (s->comp == -1)
181         s->comp = 9;
182     if (s->comp < 0 || s->comp > 9) {
183         av_log(avctx, AV_LOG_ERROR,
184                "Compression level should be 0-9, not %d\n", s->comp);
185         return -1;
186     }
187
188
189     if ((avctx->width > 4095) || (avctx->height > 4095)) {
190         av_log(avctx, AV_LOG_ERROR,
191                "Input dimensions too large, input must be max 4096x4096 !\n");
192         return -1;
193     }
194
195     if (av_image_check_size(avctx->width, avctx->height, 0, avctx) < 0)
196         return -1;
197
198
199     s->last_key_frame = 0;
200
201     s->image_width  = avctx->width;
202     s->image_height = avctx->height;
203
204     s->block_width  = (s->image_width /  12) & ~15;
205     s->block_height = (s->image_height / 12) & ~15;
206
207     s->rows = (s->image_height + s->block_height - 1) / s->block_height;
208     s->cols = (s->image_width +  s->block_width -  1) / s->block_width;
209
210     s->frame_size  = s->image_width * s->image_height * 3;
211     s->blocks_size = s->rows * s->cols * sizeof(Block);
212
213     s->encbuffer     = av_mallocz(s->frame_size);
214     s->keybuffer     = av_mallocz(s->frame_size);
215     s->databuffer    = av_mallocz(s->frame_size * 6);
216     s->current_frame = av_mallocz(s->frame_size);
217     s->key_frame     = av_mallocz(s->frame_size);
218     s->frame_blocks  = av_mallocz(s->blocks_size);
219     s->key_blocks    = av_mallocz(s->blocks_size);
220
221     init_blocks(s, s->frame_blocks, s->encbuffer, s->databuffer);
222     init_blocks(s, s->key_blocks,   s->keybuffer, 0);
223     reset_stats(s);
224 #ifndef FLASHSV2_DUMB
225     s->total_bits = 1;
226 #endif
227
228     s->use_custom_palette =  0;
229     s->palette_type       = -1;        // so that the palette will be generated in reconfigure_at_keyframe
230
231     if (!s->encbuffer || !s->keybuffer || !s->databuffer
232         || !s->current_frame || !s->key_frame || !s->key_blocks
233         || !s->frame_blocks) {
234         av_log(avctx, AV_LOG_ERROR, "Memory allocation failed.\n");
235         cleanup(s);
236         return -1;
237     }
238
239     return 0;
240 }
241
242 static int new_key_frame(FlashSV2Context * s)
243 {
244     int i;
245     memcpy(s->key_blocks, s->frame_blocks, s->blocks_size);
246     memcpy(s->key_frame, s->current_frame, s->frame_size);
247
248     for (i = 0; i < s->rows * s->cols; i++) {
249         s->key_blocks[i].enc += (s->keybuffer - s->encbuffer);
250         s->key_blocks[i].sl_begin = 0;
251         s->key_blocks[i].sl_end   = 0;
252         s->key_blocks[i].data     = 0;
253     }
254     FFSWAP(uint8_t * , s->keybuffer, s->encbuffer);
255
256     return 0;
257 }
258
259 static int write_palette(FlashSV2Context * s, uint8_t * buf, int buf_size)
260 {
261     //this isn't implemented yet!  Default palette only!
262     return -1;
263 }
264
265 static int write_header(FlashSV2Context * s, uint8_t * buf, int buf_size)
266 {
267     PutBitContext pb;
268     int buf_pos, len;
269
270     if (buf_size < 5)
271         return -1;
272
273     init_put_bits(&pb, buf, buf_size * 8);
274
275     put_bits(&pb, 4, (s->block_width  >> 4) - 1);
276     put_bits(&pb, 12, s->image_width);
277     put_bits(&pb, 4, (s->block_height >> 4) - 1);
278     put_bits(&pb, 12, s->image_height);
279
280     flush_put_bits(&pb);
281     buf_pos = 4;
282
283     buf[buf_pos++] = s->flags;
284
285     if (s->flags & HAS_PALLET_INFO) {
286         len = write_palette(s, buf + buf_pos, buf_size - buf_pos);
287         if (len < 0)
288             return -1;
289         buf_pos += len;
290     }
291
292     return buf_pos;
293 }
294
295 static int write_block(Block * b, uint8_t * buf, int buf_size)
296 {
297     int buf_pos = 0;
298     unsigned block_size = b->data_size;
299
300     if (b->flags & HAS_DIFF_BLOCKS)
301         block_size += 2;
302     if (b->flags & ZLIB_PRIME_COMPRESS_CURRENT)
303         block_size += 2;
304     if (block_size > 0)
305         block_size += 1;
306     if (buf_size < block_size + 2)
307         return -1;
308
309     buf[buf_pos++] = block_size >> 8;
310     buf[buf_pos++] = block_size;
311
312     if (block_size == 0)
313         return buf_pos;
314
315     buf[buf_pos++] = b->flags;
316
317     if (b->flags & HAS_DIFF_BLOCKS) {
318         buf[buf_pos++] = (b->start);
319         buf[buf_pos++] = (b->len);
320     }
321
322     if (b->flags & ZLIB_PRIME_COMPRESS_CURRENT) {
323         //This feature of the format is poorly understood, and as of now, unused.
324         buf[buf_pos++] = (b->col);
325         buf[buf_pos++] = (b->row);
326     }
327
328     memcpy(buf + buf_pos, b->data, b->data_size);
329
330     buf_pos += b->data_size;
331
332     return buf_pos;
333 }
334
335 static int encode_zlib(Block * b, uint8_t * buf, unsigned long *buf_size, int comp)
336 {
337     int res = compress2(buf, buf_size, b->sl_begin, b->sl_end - b->sl_begin, comp);
338     return res == Z_OK ? 0 : -1;
339 }
340
341 static int encode_zlibprime(Block * b, Block * prime, uint8_t * buf,
342                             int *buf_size, int comp)
343 {
344     z_stream s;
345     int res;
346     s.zalloc = NULL;
347     s.zfree  = NULL;
348     s.opaque = NULL;
349     res = deflateInit(&s, comp);
350     if (res < 0)
351         return -1;
352
353     s.next_in  = prime->enc;
354     s.avail_in = prime->enc_size;
355     while (s.avail_in > 0) {
356         s.next_out  = buf;
357         s.avail_out = *buf_size;
358         res = deflate(&s, Z_SYNC_FLUSH);
359         if (res < 0)
360             return -1;
361     }
362
363     s.next_in   = b->sl_begin;
364     s.avail_in  = b->sl_end - b->sl_begin;
365     s.next_out  = buf;
366     s.avail_out = *buf_size;
367     res = deflate(&s, Z_FINISH);
368     deflateEnd(&s);
369     *buf_size -= s.avail_out;
370     if (res != Z_STREAM_END)
371         return -1;
372     return 0;
373 }
374
375 static int encode_bgr(Block * b, const uint8_t * src, int stride)
376 {
377     int i;
378     uint8_t *ptr = b->enc;
379     for (i = 0; i < b->start; i++)
380         memcpy(ptr + i * b->width * 3, src + i * stride, b->width * 3);
381     b->sl_begin = ptr + i * b->width * 3;
382     for (; i < b->start + b->len; i++)
383         memcpy(ptr + i * b->width * 3, src + i * stride, b->width * 3);
384     b->sl_end = ptr + i * b->width * 3;
385     for (; i < b->height; i++)
386         memcpy(ptr + i * b->width * 3, src + i * stride, b->width * 3);
387     b->enc_size = ptr + i * b->width * 3 - b->enc;
388     return b->enc_size;
389 }
390
391 static inline unsigned pixel_color15(const uint8_t * src)
392 {
393     return (src[0] >> 3) | ((src[1] & 0xf8) << 2) | ((src[2] & 0xf8) << 7);
394 }
395
396 static inline unsigned int chroma_diff(unsigned int c1, unsigned int c2)
397 {
398     unsigned int t1 = (c1 & 0x000000ff) + ((c1 & 0x0000ff00) >> 8) + ((c1 & 0x00ff0000) >> 16);
399     unsigned int t2 = (c2 & 0x000000ff) + ((c2 & 0x0000ff00) >> 8) + ((c2 & 0x00ff0000) >> 16);
400
401     return abs(t1 - t2) + abs((c1 & 0x000000ff) - (c2 & 0x000000ff)) +
402         abs(((c1 & 0x0000ff00) >> 8) - ((c2 & 0x0000ff00) >> 8)) +
403         abs(((c1 & 0x00ff0000) >> 16) - ((c2 & 0x00ff0000) >> 16));
404 }
405
406 static inline int pixel_color7_fast(Palette * palette, unsigned c15)
407 {
408     return palette->index[c15];
409 }
410
411 static int pixel_color7_slow(Palette * palette, unsigned color)
412 {
413     int i, min = 0x7fffffff;
414     int minc = -1;
415     for (i = 0; i < 128; i++) {
416         int c1 = palette->colors[i];
417         int diff = chroma_diff(c1, color);
418         if (diff < min) {
419             min = diff;
420             minc = i;
421         }
422     }
423     return minc;
424 }
425
426 static inline unsigned pixel_bgr(const uint8_t * src)
427 {
428     return (src[0]) | (src[1] << 8) | (src[2] << 16);
429 }
430
431 static int write_pixel_15_7(Palette * palette, uint8_t * dest, const uint8_t * src,
432                             int dist)
433 {
434     unsigned c15 = pixel_color15(src);
435     unsigned color = pixel_bgr(src);
436     int d15 = chroma_diff(color, color & 0x00f8f8f8);
437     int c7 = pixel_color7_fast(palette, c15);
438     int d7 = chroma_diff(color, palette->colors[c7]);
439     if (dist + d15 >= d7) {
440         dest[0] = c7;
441         return 1;
442     } else {
443         dest[0] = 0x80 | (c15 >> 8);
444         dest[1] = c15 & 0xff;
445         return 2;
446     }
447 }
448
449 static int update_palette_index(Palette * palette)
450 {
451     int r, g, b;
452     unsigned int bgr, c15, index;
453     for (r = 4; r < 256; r += 8) {
454         for (g = 4; g < 256; g += 8) {
455             for (b = 4; b < 256; b += 8) {
456                 bgr = b | (g << 8) | (r << 16);
457                 c15 = (b >> 3) | ((g & 0xf8) << 2) | ((r & 0xf8) << 7);
458                 index = pixel_color7_slow(palette, bgr);
459
460                 palette->index[c15] = index;
461             }
462         }
463     }
464     return 0;
465 }
466
467 static const unsigned int default_screen_video_v2_palette[128] = {
468     0x00000000, 0x00333333, 0x00666666, 0x00999999, 0x00CCCCCC, 0x00FFFFFF,
469     0x00330000, 0x00660000, 0x00990000, 0x00CC0000, 0x00FF0000, 0x00003300,
470     0x00006600, 0x00009900, 0x0000CC00, 0x0000FF00, 0x00000033, 0x00000066,
471     0x00000099, 0x000000CC, 0x000000FF, 0x00333300, 0x00666600, 0x00999900,
472     0x00CCCC00, 0x00FFFF00, 0x00003333, 0x00006666, 0x00009999, 0x0000CCCC,
473     0x0000FFFF, 0x00330033, 0x00660066, 0x00990099, 0x00CC00CC, 0x00FF00FF,
474     0x00FFFF33, 0x00FFFF66, 0x00FFFF99, 0x00FFFFCC, 0x00FF33FF, 0x00FF66FF,
475     0x00FF99FF, 0x00FFCCFF, 0x0033FFFF, 0x0066FFFF, 0x0099FFFF, 0x00CCFFFF,
476     0x00CCCC33, 0x00CCCC66, 0x00CCCC99, 0x00CCCCFF, 0x00CC33CC, 0x00CC66CC,
477     0x00CC99CC, 0x00CCFFCC, 0x0033CCCC, 0x0066CCCC, 0x0099CCCC, 0x00FFCCCC,
478     0x00999933, 0x00999966, 0x009999CC, 0x009999FF, 0x00993399, 0x00996699,
479     0x0099CC99, 0x0099FF99, 0x00339999, 0x00669999, 0x00CC9999, 0x00FF9999,
480     0x00666633, 0x00666699, 0x006666CC, 0x006666FF, 0x00663366, 0x00669966,
481     0x0066CC66, 0x0066FF66, 0x00336666, 0x00996666, 0x00CC6666, 0x00FF6666,
482     0x00333366, 0x00333399, 0x003333CC, 0x003333FF, 0x00336633, 0x00339933,
483     0x0033CC33, 0x0033FF33, 0x00663333, 0x00993333, 0x00CC3333, 0x00FF3333,
484     0x00003366, 0x00336600, 0x00660033, 0x00006633, 0x00330066, 0x00663300,
485     0x00336699, 0x00669933, 0x00993366, 0x00339966, 0x00663399, 0x00996633,
486     0x006699CC, 0x0099CC66, 0x00CC6699, 0x0066CC99, 0x009966CC, 0x00CC9966,
487     0x0099CCFF, 0x00CCFF99, 0x00FF99CC, 0x0099FFCC, 0x00CC99FF, 0x00FFCC99,
488     0x00111111, 0x00222222, 0x00444444, 0x00555555, 0x00AAAAAA, 0x00BBBBBB,
489     0x00DDDDDD, 0x00EEEEEE
490 };
491
492 static int generate_default_palette(Palette * palette)
493 {
494     memcpy(palette->colors, default_screen_video_v2_palette,
495            sizeof(default_screen_video_v2_palette));
496
497     return update_palette_index(palette);
498 }
499
500 static int generate_optimum_palette(Palette * palette, const uint8_t * image,
501                                    int width, int height, int stride)
502 {
503     //this isn't implemented yet!  Default palette only!
504     return -1;
505 }
506
507 static inline int encode_15_7_sl(Palette * palette, uint8_t * dest,
508                                  const uint8_t * src, int width, int dist)
509 {
510     int len = 0, x;
511     for (x = 0; x < width; x++) {
512         len += write_pixel_15_7(palette, dest + len, src + 3 * x, dist);
513     }
514     return len;
515 }
516
517 static int encode_15_7(Palette * palette, Block * b, const uint8_t * src,
518                        int stride, int dist)
519 {
520     int i;
521     uint8_t *ptr = b->enc;
522     for (i = 0; i < b->start; i++)
523         ptr += encode_15_7_sl(palette, ptr, src + i * stride, b->width, dist);
524     b->sl_begin = ptr;
525     for (; i < b->start + b->len; i++)
526         ptr += encode_15_7_sl(palette, ptr, src + i * stride, b->width, dist);
527     b->sl_end = ptr;
528     for (; i < b->height; i++)
529         ptr += encode_15_7_sl(palette, ptr, src + i * stride, b->width, dist);
530     b->enc_size = ptr - b->enc;
531     return b->enc_size;
532 }
533
534 static int encode_block(Palette * palette, Block * b, Block * prev,
535                         const uint8_t * src, int stride, int comp, int dist,
536                         int keyframe)
537 {
538     unsigned buf_size = b->width * b->height * 6;
539     uint8_t buf[buf_size];
540     int res;
541     if (b->flags & COLORSPACE_15_7) {
542         encode_15_7(palette, b, src, stride, dist);
543     } else {
544         encode_bgr(b, src, stride);
545     }
546
547     if (b->len > 0) {
548         b->data_size = buf_size;
549         res = encode_zlib(b, b->data, &b->data_size, comp);
550         if (res)
551             return res;
552
553         if (!keyframe) {
554             res = encode_zlibprime(b, prev, buf, &buf_size, comp);
555             if (res)
556                 return res;
557
558             if (buf_size < b->data_size) {
559                 b->data_size = buf_size;
560                 memcpy(b->data, buf, buf_size);
561                 b->flags |= ZLIB_PRIME_COMPRESS_PREVIOUS;
562             }
563         }
564     } else {
565         b->data_size = 0;
566     }
567     return 0;
568 }
569
570 static int compare_sl(FlashSV2Context * s, Block * b, const uint8_t * src,
571                       uint8_t * frame, uint8_t * key, int y, int keyframe)
572 {
573     if (memcmp(src, frame, b->width * 3) != 0) {
574         b->dirty = 1;
575         memcpy(frame, src, b->width * 3);
576 #ifndef FLASHSV2_DUMB
577         s->diff_lines++;
578 #endif
579     }
580     if (memcmp(src, key, b->width * 3) != 0) {
581         if (b->len == 0)
582             b->start = y;
583         b->len = y + 1 - b->start;
584     }
585     return 0;
586 }
587
588 static int mark_all_blocks(FlashSV2Context * s, const uint8_t * src, int stride,
589                            int keyframe)
590 {
591     int sl, rsl, col, pos, possl;
592     Block *b;
593     for (sl = s->image_height - 1; sl >= 0; sl--) {
594         for (col = 0; col < s->cols; col++) {
595             rsl = s->image_height - sl - 1;
596             b = s->frame_blocks + col + rsl / s->block_height * s->cols;
597             possl = stride * sl + col * s->block_width * 3;
598             pos = s->image_width * rsl * 3 + col * s->block_width * 3;
599             compare_sl(s, b, src + possl, s->current_frame + pos,
600                        s->key_frame + pos, rsl % s->block_height, keyframe);
601         }
602     }
603 #ifndef FLASHSV2_DUMB
604     s->tot_lines += s->image_height * s->cols;
605 #endif
606     return 0;
607 }
608
609 static int encode_all_blocks(FlashSV2Context * s, int keyframe)
610 {
611     int row, col, res;
612     uint8_t *data;
613     Block *b, *prev;
614     for (row = 0; row < s->rows; row++) {
615         for (col = 0; col < s->cols; col++) {
616             b = s->frame_blocks + (row * s->cols + col);
617             prev = s->key_blocks + (row * s->cols + col);
618             if (keyframe) {
619                 b->start = 0;
620                 b->len = b->height;
621                 b->flags = s->use15_7 ? COLORSPACE_15_7 : 0;
622             } else if (!b->dirty) {
623                 b->start = 0;
624                 b->len = 0;
625                 b->data_size = 0;
626                 b->flags = s->use15_7 ? COLORSPACE_15_7 : 0;
627                 continue;
628             } else {
629                 b->flags = s->use15_7 ? COLORSPACE_15_7 | HAS_DIFF_BLOCKS : HAS_DIFF_BLOCKS;
630             }
631             data = s->current_frame + s->image_width * 3 * s->block_height * row + s->block_width * col * 3;
632             res = encode_block(&s->palette, b, prev, data, s->image_width * 3, s->comp, s->dist, keyframe);
633 #ifndef FLASHSV2_DUMB
634             if (b->dirty)
635                 s->diff_blocks++;
636             s->comp_size += b->data_size;
637             s->uncomp_size += b->enc_size;
638 #endif
639             if (res)
640                 return res;
641         }
642     }
643 #ifndef FLASHSV2_DUMB
644     s->raw_size += s->image_width * s->image_height * 3;
645     s->tot_blocks += s->rows * s->cols;
646 #endif
647     return 0;
648 }
649
650 static int write_all_blocks(FlashSV2Context * s, uint8_t * buf,
651                             int buf_size)
652 {
653     int row, col, buf_pos = 0, len;
654     Block *b;
655     for (row = 0; row < s->rows; row++) {
656         for (col = 0; col < s->cols; col++) {
657             b = s->frame_blocks + row * s->cols + col;
658             len = write_block(b, buf + buf_pos, buf_size - buf_pos);
659             b->start = b->len = b->dirty = 0;
660             if (len < 0)
661                 return len;
662             buf_pos += len;
663         }
664     }
665     return buf_pos;
666 }
667
668 static int write_bitstream(FlashSV2Context * s, const uint8_t * src, int stride,
669                            uint8_t * buf, int buf_size, int keyframe)
670 {
671     int buf_pos, res;
672
673     res = mark_all_blocks(s, src, stride, keyframe);
674     if (res)
675         return res;
676     res = encode_all_blocks(s, keyframe);
677     if (res)
678         return res;
679
680     res = write_header(s, buf, buf_size);
681     if (res < 0) {
682         return res;
683     } else {
684         buf_pos = res;
685     }
686     res = write_all_blocks(s, buf + buf_pos, buf_size - buf_pos);
687     if (res < 0)
688         return res;
689     buf_pos += res;
690 #ifndef FLASHSV2_DUMB
691     s->total_bits += ((double) buf_pos) * 8.0;
692 #endif
693
694     return buf_pos;
695 }
696
697 static void recommend_keyframe(FlashSV2Context * s, int *keyframe)
698 {
699 #ifndef FLASHSV2_DUMB
700     double block_ratio, line_ratio, enc_ratio, comp_ratio, data_ratio;
701     if (s->avctx->gop_size > 0) {
702         block_ratio = s->diff_blocks / s->tot_blocks;
703         line_ratio = s->diff_lines / s->tot_lines;
704         enc_ratio = s->uncomp_size / s->raw_size;
705         comp_ratio = s->comp_size / s->uncomp_size;
706         data_ratio = s->comp_size / s->raw_size;
707
708         if ((block_ratio >= 0.5 && line_ratio / block_ratio <= 0.5) || line_ratio >= 0.95) {
709             *keyframe = 1;
710             return;
711         }
712     }
713 #else
714     return;
715 #endif
716 }
717
718 static const double block_size_fraction = 1.0 / 300;
719 static int optimum_block_width(FlashSV2Context * s)
720 {
721 #ifndef FLASHSV2_DUMB
722     double save = (1-pow(s->diff_lines/s->diff_blocks/s->block_height, 0.5)) * s->comp_size/s->tot_blocks;
723     double width = block_size_fraction * sqrt(0.5 * save * s->rows * s->cols) * s->image_width;
724     int pwidth = ((int) width);
725     return FFCLIP(pwidth & ~15, 256, 16);
726 #else
727     return 64;
728 #endif
729 }
730
731 static int optimum_block_height(FlashSV2Context * s)
732 {
733 #ifndef FLASHSV2_DUMB
734     double save = (1-pow(s->diff_lines/s->diff_blocks/s->block_height, 0.5)) * s->comp_size/s->tot_blocks;
735     double height = block_size_fraction * sqrt(0.5 * save * s->rows * s->cols) * s->image_height;
736     int pheight = ((int) height);
737     return FFCLIP(pheight & ~15, 256, 16);
738 #else
739     return 64;
740 #endif
741 }
742
743 static const double use15_7_threshold = 8192;
744
745 static int optimum_use15_7(FlashSV2Context * s)
746 {
747 #ifndef FLASHSV2_DUMB
748     double ideal = ((double)(s->avctx->bit_rate * s->avctx->time_base.den * s->avctx->ticks_per_frame)) /
749         ((double) s->avctx->time_base.num) * s->avctx->frame_number;
750     if (ideal + use15_7_threshold < s->total_bits) {
751         return 1;
752     } else {
753         return 0;
754     }
755 #else
756     return s->avctx->global_quality == 0;
757 #endif
758 }
759
760 static const double color15_7_factor = 100;
761
762 static int optimum_dist(FlashSV2Context * s)
763 {
764 #ifndef FLASHSV2_DUMB
765     double ideal =
766         s->avctx->bit_rate * s->avctx->time_base.den *
767         s->avctx->ticks_per_frame;
768     int dist = pow((s->total_bits / ideal) * color15_7_factor, 3);
769     av_log(s->avctx, AV_LOG_DEBUG, "dist: %d\n", dist);
770     return dist;
771 #else
772     return 15;
773 #endif
774 }
775
776
777 static int reconfigure_at_keyframe(FlashSV2Context * s, const uint8_t * image,
778                                    int stride)
779 {
780     int update_palette = 0;
781     int res;
782     s->block_width = optimum_block_width(s);
783     s->block_height = optimum_block_height(s);
784
785     s->rows = (s->image_height + s->block_height - 1) / s->block_height;
786     s->cols = (s->image_width +  s->block_width -  1) / s->block_width;
787
788     if (s->rows * s->cols != s->blocks_size / sizeof(Block)) {
789         if (s->rows * s->cols > s->blocks_size / sizeof(Block)) {
790             s->frame_blocks = av_realloc(s->frame_blocks, s->rows * s->cols * sizeof(Block));
791             s->key_blocks = av_realloc(s->key_blocks, s->cols * s->rows * sizeof(Block));
792             if (!s->frame_blocks || !s->key_blocks) {
793                 av_log(s->avctx, AV_LOG_ERROR, "Memory allocation failed.\n");
794                 return -1;
795             }
796             s->blocks_size = s->rows * s->cols * sizeof(Block);
797         }
798         init_blocks(s, s->frame_blocks, s->encbuffer, s->databuffer);
799         init_blocks(s, s->key_blocks, s->keybuffer, 0);
800
801     }
802
803     s->use15_7 = optimum_use15_7(s);
804     if (s->use15_7) {
805         if ((s->use_custom_palette && s->palette_type != 1) || update_palette) {
806             res = generate_optimum_palette(&s->palette, image, s->image_width, s->image_height, stride);
807             if (res)
808                 return res;
809             s->palette_type = 1;
810             av_log(s->avctx, AV_LOG_DEBUG, "Generated optimum palette\n");
811         } else if (!s->use_custom_palette && s->palette_type != 0) {
812             res = generate_default_palette(&s->palette);
813             if (res)
814                 return res;
815             s->palette_type = 0;
816             av_log(s->avctx, AV_LOG_DEBUG, "Generated default palette\n");
817         }
818     }
819
820
821     reset_stats(s);
822
823     return 0;
824 }
825
826 static int flashsv2_encode_frame(AVCodecContext * avctx, uint8_t * buf,
827                                  int buf_size, void *data)
828 {
829     FlashSV2Context *const s = avctx->priv_data;
830     AVFrame *pict = data;
831     AVFrame *const p = &s->frame;
832     int res;
833     int keyframe = 0;
834
835     *p = *pict;
836
837     /* First frame needs to be a keyframe */
838     if (avctx->frame_number == 0)
839         keyframe = 1;
840
841     /* Check the placement of keyframes */
842     if (avctx->gop_size > 0) {
843         if (avctx->frame_number >= s->last_key_frame + avctx->gop_size)
844             keyframe = 1;
845     }
846
847     if (buf_size < s->frame_size) {
848         //Conservative upper bound check for compressed data
849         av_log(avctx, AV_LOG_ERROR, "buf_size %d <  %d\n", buf_size, s->frame_size);
850         return -1;
851     }
852
853     if (!keyframe
854         && avctx->frame_number > s->last_key_frame + avctx->keyint_min) {
855         recommend_keyframe(s, &keyframe);
856         if (keyframe)
857             av_log(avctx, AV_LOG_DEBUG, "Recommending key frame at frame %d\n", avctx->frame_number);
858     }
859
860     if (keyframe) {
861         res = reconfigure_at_keyframe(s, p->data[0], p->linesize[0]);
862         if (res)
863             return res;
864     }
865
866     if (s->use15_7)
867         s->dist = optimum_dist(s);
868
869     res = write_bitstream(s, p->data[0], p->linesize[0], buf, buf_size, keyframe);
870
871     if (keyframe) {
872         new_key_frame(s);
873         p->pict_type = AV_PICTURE_TYPE_I;
874         p->key_frame = 1;
875         s->last_key_frame = avctx->frame_number;
876         av_log(avctx, AV_LOG_DEBUG, "Inserting key frame at frame %d\n", avctx->frame_number);
877     } else {
878         p->pict_type = AV_PICTURE_TYPE_P;
879         p->key_frame = 0;
880     }
881
882     avctx->coded_frame = p;
883
884     return res;
885 }
886
887 static av_cold int flashsv2_encode_end(AVCodecContext * avctx)
888 {
889     FlashSV2Context *s = avctx->priv_data;
890
891     cleanup(s);
892
893     return 0;
894 }
895
896 AVCodec ff_flashsv2_encoder = {
897     .name           = "flashsv2",
898     .type           = AVMEDIA_TYPE_VIDEO,
899     .id             = CODEC_ID_FLASHSV2,
900     .priv_data_size = sizeof(FlashSV2Context),
901     .init           = flashsv2_encode_init,
902     .encode         = flashsv2_encode_frame,
903     .close          = flashsv2_encode_end,
904     .pix_fmts = (enum PixelFormat[]) {PIX_FMT_BGR24, PIX_FMT_NONE},
905     .long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video Version 2"),
906     .capabilities   =  CODEC_CAP_EXPERIMENTAL,
907 };