FFmpeg
flashsv2enc.c
Go to the documentation of this file.
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 "internal.h"
52 #include "put_bits.h"
53 #include "bytestream.h"
54 
55 #define HAS_IFRAME_IMAGE 0x02
56 #define HAS_PALLET_INFO 0x01
57 
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
63 
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.
66 #define FLASHSV2_DUMB
67 
68 typedef struct Block {
71  int enc_size;
73  unsigned long data_size;
74 
79 } Block;
80 
81 typedef struct Palette {
82  unsigned colors[128];
83  uint8_t index[1 << 15];
84 } Palette;
85 
86 typedef struct FlashSV2Context {
93 
96 
101 
102  int use15_7, dist, comp;
103 
104  int rows, cols;
105 
107 
108  int image_width, image_height;
109  int block_width, block_height;
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
122 
123  double total_bits; ///< total bits written to stream so far
124 #endif
126 
128 {
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);
135 
136  av_freep(&s->frame_blocks);
137  av_freep(&s->key_blocks);
138 }
139 
140 static void init_blocks(FlashSV2Context * s, Block * blocks,
141  uint8_t * encbuf, uint8_t * databuf)
142 {
143  int row, col;
144  Block *b;
145  for (col = 0; col < s->cols; col++) {
146  for (row = 0; row < s->rows; row++) {
147  b = blocks + (col + row * s->cols);
148  b->width = (col < s->cols - 1) ?
149  s->block_width :
150  s->image_width - col * s->block_width;
151 
152  b->height = (row < s->rows - 1) ?
153  s->block_height :
154  s->image_height - row * s->block_height;
155 
156  b->row = row;
157  b->col = col;
158  b->enc = encbuf;
159  b->data = databuf;
160  encbuf += b->width * b->height * 3;
161  databuf += !databuf ? 0 : b->width * b->height * 6;
162  }
163  }
164 }
165 
167 {
168 #ifndef FLASHSV2_DUMB
169  s->diff_blocks = 0.1;
170  s->tot_blocks = 1;
171  s->diff_lines = 0.1;
172  s->tot_lines = 1;
173  s->raw_size = s->comp_size = s->uncomp_size = 10;
174 #endif
175 }
176 
178 {
179  FlashSV2Context *s = avctx->priv_data;
180  int ret;
181 
182  s->avctx = avctx;
183 
184  s->comp = avctx->compression_level;
185  if (s->comp == -1)
186  s->comp = 9;
187  if (s->comp < 0 || s->comp > 9) {
188  av_log(avctx, AV_LOG_ERROR,
189  "Compression level should be 0-9, not %d\n", s->comp);
190  return AVERROR(EINVAL);
191  }
192 
193 
194  if ((avctx->width > 4095) || (avctx->height > 4095)) {
195  av_log(avctx, AV_LOG_ERROR,
196  "Input dimensions too large, input must be max 4095x4095 !\n");
197  return AVERROR(EINVAL);
198  }
199  if ((avctx->width < 16) || (avctx->height < 16)) {
200  av_log(avctx, AV_LOG_ERROR,
201  "Input dimensions too small, input must be at least 16x16 !\n");
202  return AVERROR(EINVAL);
203  }
204 
205  if ((ret = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
206  return ret;
207 
208 
209  s->last_key_frame = 0;
210 
211  s->image_width = avctx->width;
212  s->image_height = avctx->height;
213 
214  s->block_width = (s->image_width / 12) & ~15;
215  s->block_height = (s->image_height / 12) & ~15;
216 
217  if(!s->block_width)
218  s->block_width = 1;
219  if(!s->block_height)
220  s->block_height = 1;
221 
222  s->rows = (s->image_height + s->block_height - 1) / s->block_height;
223  s->cols = (s->image_width + s->block_width - 1) / s->block_width;
224 
225  s->frame_size = s->image_width * s->image_height * 3;
226  s->blocks_size = s->rows * s->cols * sizeof(Block);
227 
230  s->databuffer = av_mallocz(s->frame_size * 6);
235  if (!s->encbuffer || !s->keybuffer || !s->databuffer
236  || !s->current_frame || !s->key_frame || !s->key_blocks
237  || !s->frame_blocks) {
238  av_log(avctx, AV_LOG_ERROR, "Memory allocation failed.\n");
239  return AVERROR(ENOMEM);
240  }
241 
242  s->blockbuffer = NULL;
243  s->blockbuffer_size = 0;
244 
246  init_blocks(s, s->key_blocks, s->keybuffer, 0);
247  reset_stats(s);
248 #ifndef FLASHSV2_DUMB
249  s->total_bits = 1;
250 #endif
251 
252  s->use_custom_palette = 0;
253  s->palette_type = -1; // so that the palette will be generated in reconfigure_at_keyframe
254 
255  return 0;
256 }
257 
259 {
260  int i;
261  memcpy(s->key_blocks, s->frame_blocks, s->blocks_size);
262  memcpy(s->key_frame, s->current_frame, s->frame_size);
263 
264  for (i = 0; i < s->rows * s->cols; i++) {
265  s->key_blocks[i].enc += (s->keybuffer - s->encbuffer);
266  s->key_blocks[i].sl_begin = 0;
267  s->key_blocks[i].sl_end = 0;
268  s->key_blocks[i].data = 0;
269  }
270  memcpy(s->keybuffer, s->encbuffer, s->frame_size);
271 
272  return 0;
273 }
274 
275 static int write_palette(FlashSV2Context * s, uint8_t * buf, int buf_size)
276 {
277  //this isn't implemented yet! Default palette only!
278  return -1;
279 }
280 
281 static int write_header(FlashSV2Context * s, uint8_t * buf, int buf_size)
282 {
283  PutBitContext pb;
284  int buf_pos, len;
285 
286  if (buf_size < 5)
287  return -1;
288 
289  init_put_bits(&pb, buf, buf_size);
290 
291  put_bits(&pb, 4, (s->block_width >> 4) - 1);
292  put_bits(&pb, 12, s->image_width);
293  put_bits(&pb, 4, (s->block_height >> 4) - 1);
294  put_bits(&pb, 12, s->image_height);
295 
296  flush_put_bits(&pb);
297  buf_pos = 4;
298 
299  buf[buf_pos++] = s->flags;
300 
301  if (s->flags & HAS_PALLET_INFO) {
302  len = write_palette(s, buf + buf_pos, buf_size - buf_pos);
303  if (len < 0)
304  return -1;
305  buf_pos += len;
306  }
307 
308  return buf_pos;
309 }
310 
311 static int write_block(Block * b, uint8_t * buf, int buf_size)
312 {
313  int buf_pos = 0;
314  unsigned block_size = b->data_size;
315 
316  if (b->flags & HAS_DIFF_BLOCKS)
317  block_size += 2;
319  block_size += 2;
320  if (block_size > 0)
321  block_size += 1;
322  if (buf_size < block_size + 2)
323  return -1;
324 
325  buf[buf_pos++] = block_size >> 8;
326  buf[buf_pos++] = block_size;
327 
328  if (block_size == 0)
329  return buf_pos;
330 
331  buf[buf_pos++] = b->flags;
332 
333  if (b->flags & HAS_DIFF_BLOCKS) {
334  buf[buf_pos++] = (b->start);
335  buf[buf_pos++] = (b->len);
336  }
337 
339  //This feature of the format is poorly understood, and as of now, unused.
340  buf[buf_pos++] = (b->col);
341  buf[buf_pos++] = (b->row);
342  }
343 
344  memcpy(buf + buf_pos, b->data, b->data_size);
345 
346  buf_pos += b->data_size;
347 
348  return buf_pos;
349 }
350 
351 static int encode_zlib(Block * b, uint8_t * buf, unsigned long *buf_size, int comp)
352 {
353  int res = compress2(buf, buf_size, b->sl_begin, b->sl_end - b->sl_begin, comp);
354  return res == Z_OK ? 0 : -1;
355 }
356 
357 static int encode_zlibprime(Block * b, Block * prime, uint8_t * buf,
358  int *buf_size, int comp)
359 {
360  z_stream s;
361  int res;
362  s.zalloc = NULL;
363  s.zfree = NULL;
364  s.opaque = NULL;
365  res = deflateInit(&s, comp);
366  if (res < 0)
367  return -1;
368 
369  s.next_in = prime->enc;
370  s.avail_in = prime->enc_size;
371  while (s.avail_in > 0) {
372  s.next_out = buf;
373  s.avail_out = *buf_size;
374  res = deflate(&s, Z_SYNC_FLUSH);
375  if (res < 0)
376  return -1;
377  }
378 
379  s.next_in = b->sl_begin;
380  s.avail_in = b->sl_end - b->sl_begin;
381  s.next_out = buf;
382  s.avail_out = *buf_size;
383  res = deflate(&s, Z_FINISH);
384  deflateEnd(&s);
385  *buf_size -= s.avail_out;
386  if (res != Z_STREAM_END)
387  return -1;
388  return 0;
389 }
390 
391 static int encode_bgr(Block * b, const uint8_t * src, int stride)
392 {
393  int i;
394  uint8_t *ptr = b->enc;
395  for (i = 0; i < b->start; i++)
396  memcpy(ptr + i * b->width * 3, src + i * stride, b->width * 3);
397  b->sl_begin = ptr + i * b->width * 3;
398  for (; i < b->start + b->len; i++)
399  memcpy(ptr + i * b->width * 3, src + i * stride, b->width * 3);
400  b->sl_end = ptr + i * b->width * 3;
401  for (; i < b->height; i++)
402  memcpy(ptr + i * b->width * 3, src + i * stride, b->width * 3);
403  b->enc_size = ptr + i * b->width * 3 - b->enc;
404  return b->enc_size;
405 }
406 
407 static inline unsigned pixel_color15(const uint8_t * src)
408 {
409  return (src[0] >> 3) | ((src[1] & 0xf8) << 2) | ((src[2] & 0xf8) << 7);
410 }
411 
412 static inline unsigned int chroma_diff(unsigned int c1, unsigned int c2)
413 {
414 #define ABSDIFF(a,b) (abs((int)(a)-(int)(b)))
415 
416  unsigned int t1 = (c1 & 0x000000ff) + ((c1 & 0x0000ff00) >> 8) + ((c1 & 0x00ff0000) >> 16);
417  unsigned int t2 = (c2 & 0x000000ff) + ((c2 & 0x0000ff00) >> 8) + ((c2 & 0x00ff0000) >> 16);
418 
419  return ABSDIFF(t1, t2) + ABSDIFF(c1 & 0x000000ff, c2 & 0x000000ff) +
420  ABSDIFF((c1 & 0x0000ff00) >> 8 , (c2 & 0x0000ff00) >> 8) +
421  ABSDIFF((c1 & 0x00ff0000) >> 16, (c2 & 0x00ff0000) >> 16);
422 }
423 
424 static inline int pixel_color7_fast(Palette * palette, unsigned c15)
425 {
426  return palette->index[c15];
427 }
428 
429 static int pixel_color7_slow(Palette * palette, unsigned color)
430 {
431  int i, min = 0x7fffffff;
432  int minc = -1;
433  for (i = 0; i < 128; i++) {
434  int c1 = palette->colors[i];
435  int diff = chroma_diff(c1, color);
436  if (diff < min) {
437  min = diff;
438  minc = i;
439  }
440  }
441  return minc;
442 }
443 
444 static inline unsigned pixel_bgr(const uint8_t * src)
445 {
446  return (src[0]) | (src[1] << 8) | (src[2] << 16);
447 }
448 
449 static int write_pixel_15_7(Palette * palette, uint8_t * dest, const uint8_t * src,
450  int dist)
451 {
452  unsigned c15 = pixel_color15(src);
453  unsigned color = pixel_bgr(src);
454  int d15 = chroma_diff(color, color & 0x00f8f8f8);
455  int c7 = pixel_color7_fast(palette, c15);
456  int d7 = chroma_diff(color, palette->colors[c7]);
457  if (dist + d15 >= d7) {
458  dest[0] = c7;
459  return 1;
460  } else {
461  dest[0] = 0x80 | (c15 >> 8);
462  dest[1] = c15 & 0xff;
463  return 2;
464  }
465 }
466 
467 static int update_palette_index(Palette * palette)
468 {
469  int r, g, b;
470  unsigned int bgr, c15, index;
471  for (r = 4; r < 256; r += 8) {
472  for (g = 4; g < 256; g += 8) {
473  for (b = 4; b < 256; b += 8) {
474  bgr = b | (g << 8) | (r << 16);
475  c15 = (b >> 3) | ((g & 0xf8) << 2) | ((r & 0xf8) << 7);
476  index = pixel_color7_slow(palette, bgr);
477 
478  palette->index[c15] = index;
479  }
480  }
481  }
482  return 0;
483 }
484 
485 static const unsigned int default_screen_video_v2_palette[128] = {
486  0x00000000, 0x00333333, 0x00666666, 0x00999999, 0x00CCCCCC, 0x00FFFFFF,
487  0x00330000, 0x00660000, 0x00990000, 0x00CC0000, 0x00FF0000, 0x00003300,
488  0x00006600, 0x00009900, 0x0000CC00, 0x0000FF00, 0x00000033, 0x00000066,
489  0x00000099, 0x000000CC, 0x000000FF, 0x00333300, 0x00666600, 0x00999900,
490  0x00CCCC00, 0x00FFFF00, 0x00003333, 0x00006666, 0x00009999, 0x0000CCCC,
491  0x0000FFFF, 0x00330033, 0x00660066, 0x00990099, 0x00CC00CC, 0x00FF00FF,
492  0x00FFFF33, 0x00FFFF66, 0x00FFFF99, 0x00FFFFCC, 0x00FF33FF, 0x00FF66FF,
493  0x00FF99FF, 0x00FFCCFF, 0x0033FFFF, 0x0066FFFF, 0x0099FFFF, 0x00CCFFFF,
494  0x00CCCC33, 0x00CCCC66, 0x00CCCC99, 0x00CCCCFF, 0x00CC33CC, 0x00CC66CC,
495  0x00CC99CC, 0x00CCFFCC, 0x0033CCCC, 0x0066CCCC, 0x0099CCCC, 0x00FFCCCC,
496  0x00999933, 0x00999966, 0x009999CC, 0x009999FF, 0x00993399, 0x00996699,
497  0x0099CC99, 0x0099FF99, 0x00339999, 0x00669999, 0x00CC9999, 0x00FF9999,
498  0x00666633, 0x00666699, 0x006666CC, 0x006666FF, 0x00663366, 0x00669966,
499  0x0066CC66, 0x0066FF66, 0x00336666, 0x00996666, 0x00CC6666, 0x00FF6666,
500  0x00333366, 0x00333399, 0x003333CC, 0x003333FF, 0x00336633, 0x00339933,
501  0x0033CC33, 0x0033FF33, 0x00663333, 0x00993333, 0x00CC3333, 0x00FF3333,
502  0x00003366, 0x00336600, 0x00660033, 0x00006633, 0x00330066, 0x00663300,
503  0x00336699, 0x00669933, 0x00993366, 0x00339966, 0x00663399, 0x00996633,
504  0x006699CC, 0x0099CC66, 0x00CC6699, 0x0066CC99, 0x009966CC, 0x00CC9966,
505  0x0099CCFF, 0x00CCFF99, 0x00FF99CC, 0x0099FFCC, 0x00CC99FF, 0x00FFCC99,
506  0x00111111, 0x00222222, 0x00444444, 0x00555555, 0x00AAAAAA, 0x00BBBBBB,
507  0x00DDDDDD, 0x00EEEEEE
508 };
509 
510 static int generate_default_palette(Palette * palette)
511 {
512  memcpy(palette->colors, default_screen_video_v2_palette,
514 
515  return update_palette_index(palette);
516 }
517 
518 static int generate_optimum_palette(Palette * palette, const uint8_t * image,
519  int width, int height, int stride)
520 {
521  //this isn't implemented yet! Default palette only!
522  return -1;
523 }
524 
525 static inline int encode_15_7_sl(Palette * palette, uint8_t * dest,
526  const uint8_t * src, int width, int dist)
527 {
528  int len = 0, x;
529  for (x = 0; x < width; x++) {
530  len += write_pixel_15_7(palette, dest + len, src + 3 * x, dist);
531  }
532  return len;
533 }
534 
535 static int encode_15_7(Palette * palette, Block * b, const uint8_t * src,
536  int stride, int dist)
537 {
538  int i;
539  uint8_t *ptr = b->enc;
540  for (i = 0; i < b->start; i++)
541  ptr += encode_15_7_sl(palette, ptr, src + i * stride, b->width, dist);
542  b->sl_begin = ptr;
543  for (; i < b->start + b->len; i++)
544  ptr += encode_15_7_sl(palette, ptr, src + i * stride, b->width, dist);
545  b->sl_end = ptr;
546  for (; i < b->height; i++)
547  ptr += encode_15_7_sl(palette, ptr, src + i * stride, b->width, dist);
548  b->enc_size = ptr - b->enc;
549  return b->enc_size;
550 }
551 
552 static int encode_block(FlashSV2Context *s, Palette * palette, Block * b,
553  Block * prev, const uint8_t * src, int stride, int comp,
554  int dist, int keyframe)
555 {
556  unsigned buf_size = b->width * b->height * 6;
557  uint8_t *buf = s->blockbuffer;
558  int res;
559 
560  if (b->flags & COLORSPACE_15_7) {
561  encode_15_7(palette, b, src, stride, dist);
562  } else {
563  encode_bgr(b, src, stride);
564  }
565 
566  if (b->len > 0) {
567  b->data_size = buf_size;
568  res = encode_zlib(b, b->data, &b->data_size, comp);
569  if (res)
570  return res;
571 
572  if (!keyframe) {
573  res = encode_zlibprime(b, prev, buf, &buf_size, comp);
574  if (res)
575  return res;
576 
577  if (buf_size < b->data_size) {
578  b->data_size = buf_size;
579  memcpy(b->data, buf, buf_size);
581  }
582  }
583  } else {
584  b->data_size = 0;
585  }
586  return 0;
587 }
588 
589 static int compare_sl(FlashSV2Context * s, Block * b, const uint8_t * src,
590  uint8_t * frame, uint8_t * key, int y, int keyframe)
591 {
592  if (memcmp(src, frame, b->width * 3) != 0) {
593  b->dirty = 1;
594  memcpy(frame, src, b->width * 3);
595 #ifndef FLASHSV2_DUMB
596  s->diff_lines++;
597 #endif
598  }
599  if (memcmp(src, key, b->width * 3) != 0) {
600  if (b->len == 0)
601  b->start = y;
602  b->len = y + 1 - b->start;
603  }
604  return 0;
605 }
606 
607 static int mark_all_blocks(FlashSV2Context * s, const uint8_t * src, int stride,
608  int keyframe)
609 {
610  int sl, rsl, col, pos, possl;
611  Block *b;
612  for (sl = s->image_height - 1; sl >= 0; sl--) {
613  for (col = 0; col < s->cols; col++) {
614  rsl = s->image_height - sl - 1;
615  b = s->frame_blocks + col + rsl / s->block_height * s->cols;
616  possl = stride * sl + col * s->block_width * 3;
617  pos = s->image_width * rsl * 3 + col * s->block_width * 3;
618  compare_sl(s, b, src + possl, s->current_frame + pos,
619  s->key_frame + pos, rsl % s->block_height, keyframe);
620  }
621  }
622 #ifndef FLASHSV2_DUMB
623  s->tot_lines += s->image_height * s->cols;
624 #endif
625  return 0;
626 }
627 
628 static int encode_all_blocks(FlashSV2Context * s, int keyframe)
629 {
630  int row, col, res;
631  uint8_t *data;
632  Block *b, *prev;
633  for (row = 0; row < s->rows; row++) {
634  for (col = 0; col < s->cols; col++) {
635  b = s->frame_blocks + (row * s->cols + col);
636  prev = s->key_blocks + (row * s->cols + col);
637  b->flags = s->use15_7 ? COLORSPACE_15_7 : 0;
638  if (keyframe) {
639  b->start = 0;
640  b->len = b->height;
641  } else if (!b->dirty) {
642  b->start = 0;
643  b->len = 0;
644  b->data_size = 0;
645  continue;
646  } else if (b->start != 0 || b->len != b->height) {
647  b->flags |= HAS_DIFF_BLOCKS;
648  }
649  data = s->current_frame + s->image_width * 3 * s->block_height * row + s->block_width * col * 3;
650  res = encode_block(s, &s->palette, b, prev, data, s->image_width * 3, s->comp, s->dist, keyframe);
651 #ifndef FLASHSV2_DUMB
652  if (b->dirty)
653  s->diff_blocks++;
654  s->comp_size += b->data_size;
655  s->uncomp_size += b->enc_size;
656 #endif
657  if (res)
658  return res;
659  }
660  }
661 #ifndef FLASHSV2_DUMB
662  s->raw_size += s->image_width * s->image_height * 3;
663  s->tot_blocks += s->rows * s->cols;
664 #endif
665  return 0;
666 }
667 
669  int buf_size)
670 {
671  int row, col, buf_pos = 0, len;
672  Block *b;
673  for (row = 0; row < s->rows; row++) {
674  for (col = 0; col < s->cols; col++) {
675  b = s->frame_blocks + row * s->cols + col;
676  len = write_block(b, buf + buf_pos, buf_size - buf_pos);
677  b->start = b->len = b->dirty = 0;
678  if (len < 0)
679  return len;
680  buf_pos += len;
681  }
682  }
683  return buf_pos;
684 }
685 
686 static int write_bitstream(FlashSV2Context * s, const uint8_t * src, int stride,
687  uint8_t * buf, int buf_size, int keyframe)
688 {
689  int buf_pos, res;
690 
691  res = mark_all_blocks(s, src, stride, keyframe);
692  if (res)
693  return res;
694  res = encode_all_blocks(s, keyframe);
695  if (res)
696  return res;
697 
698  res = write_header(s, buf, buf_size);
699  if (res < 0) {
700  return res;
701  } else {
702  buf_pos = res;
703  }
704  res = write_all_blocks(s, buf + buf_pos, buf_size - buf_pos);
705  if (res < 0)
706  return res;
707  buf_pos += res;
708 #ifndef FLASHSV2_DUMB
709  s->total_bits += ((double) buf_pos) * 8.0;
710 #endif
711 
712  return buf_pos;
713 }
714 
715 static void recommend_keyframe(FlashSV2Context * s, int *keyframe)
716 {
717 #ifndef FLASHSV2_DUMB
718  double block_ratio, line_ratio, enc_ratio, comp_ratio, data_ratio;
719  if (s->avctx->gop_size > 0) {
720  block_ratio = s->diff_blocks / s->tot_blocks;
721  line_ratio = s->diff_lines / s->tot_lines;
722  enc_ratio = s->uncomp_size / s->raw_size;
723  comp_ratio = s->comp_size / s->uncomp_size;
724  data_ratio = s->comp_size / s->raw_size;
725 
726  if ((block_ratio >= 0.5 && line_ratio / block_ratio <= 0.5) || line_ratio >= 0.95) {
727  *keyframe = 1;
728  return;
729  }
730  }
731 #else
732  return;
733 #endif
734 }
735 
736 #ifndef FLASHSV2_DUMB
737 static const double block_size_fraction = 1.0 / 300;
738 static const double use15_7_threshold = 8192;
739 static const double color15_7_factor = 100;
740 #endif
742 {
743 #ifndef FLASHSV2_DUMB
744  double save = (1-pow(s->diff_lines/s->diff_blocks/s->block_height, 0.5)) * s->comp_size/s->tot_blocks;
745  double width = block_size_fraction * sqrt(0.5 * save * s->rows * s->cols) * s->image_width;
746  int pwidth = ((int) width);
747  return FFCLIP(pwidth & ~15, 256, 16);
748 #else
749  return 64;
750 #endif
751 }
752 
754 {
755 #ifndef FLASHSV2_DUMB
756  double save = (1-pow(s->diff_lines/s->diff_blocks/s->block_height, 0.5)) * s->comp_size/s->tot_blocks;
757  double height = block_size_fraction * sqrt(0.5 * save * s->rows * s->cols) * s->image_height;
758  int pheight = ((int) height);
759  return FFCLIP(pheight & ~15, 256, 16);
760 #else
761  return 64;
762 #endif
763 }
764 
766 {
767 #ifndef FLASHSV2_DUMB
768  double ideal = ((double)(s->avctx->bit_rate * s->avctx->time_base.den * s->avctx->ticks_per_frame)) /
769  ((double) s->avctx->time_base.num) * s->avctx->frame_number;
770  if (ideal + use15_7_threshold < s->total_bits) {
771  return 1;
772  } else {
773  return 0;
774  }
775 #else
776  return s->avctx->global_quality == 0;
777 #endif
778 }
779 
781 {
782 #ifndef FLASHSV2_DUMB
783  double ideal =
784  s->avctx->bit_rate * s->avctx->time_base.den *
786  int dist = pow((s->total_bits / ideal) * color15_7_factor, 3);
787  av_log(s->avctx, AV_LOG_DEBUG, "dist: %d\n", dist);
788  return dist;
789 #else
790  return 15;
791 #endif
792 }
793 
794 
795 static int reconfigure_at_keyframe(FlashSV2Context * s, const uint8_t * image,
796  int stride)
797 {
798  int update_palette = 0;
799  int res;
800  int block_width = optimum_block_width (s);
801  int block_height = optimum_block_height(s);
802 
803  s->rows = (s->image_height + block_height - 1) / block_height;
804  s->cols = (s->image_width + block_width - 1) / block_width;
805 
806  if (block_width != s->block_width || block_height != s->block_height) {
807  s->block_width = block_width;
808  s->block_height = block_height;
809  if (s->rows * s->cols > s->blocks_size / sizeof(Block)) {
810  s->frame_blocks = av_realloc_array(s->frame_blocks, s->rows, s->cols * sizeof(Block));
811  s->key_blocks = av_realloc_array(s->key_blocks, s->cols, s->rows * sizeof(Block));
812  if (!s->frame_blocks || !s->key_blocks) {
813  av_log(s->avctx, AV_LOG_ERROR, "Memory allocation failed.\n");
814  return -1;
815  }
816  s->blocks_size = s->rows * s->cols * sizeof(Block);
817  }
819  init_blocks(s, s->key_blocks, s->keybuffer, 0);
820 
821  av_fast_malloc(&s->blockbuffer, &s->blockbuffer_size, block_width * block_height * 6);
822  if (!s->blockbuffer) {
823  av_log(s->avctx, AV_LOG_ERROR, "Could not allocate block buffer.\n");
824  return AVERROR(ENOMEM);
825  }
826  }
827 
828  s->use15_7 = optimum_use15_7(s);
829  if (s->use15_7) {
830  if ((s->use_custom_palette && s->palette_type != 1) || update_palette) {
831  res = generate_optimum_palette(&s->palette, image, s->image_width, s->image_height, stride);
832  if (res)
833  return res;
834  s->palette_type = 1;
835  av_log(s->avctx, AV_LOG_DEBUG, "Generated optimum palette\n");
836  } else if (!s->use_custom_palette && s->palette_type != 0) {
838  if (res)
839  return res;
840  s->palette_type = 0;
841  av_log(s->avctx, AV_LOG_DEBUG, "Generated default palette\n");
842  }
843  }
844 
845 
846  reset_stats(s);
847 
848  return 0;
849 }
850 
852  const AVFrame *p, int *got_packet)
853 {
854  FlashSV2Context *const s = avctx->priv_data;
855  int res;
856  int keyframe = 0;
857 
858  if ((res = ff_alloc_packet2(avctx, pkt, s->frame_size + AV_INPUT_BUFFER_MIN_SIZE, 0)) < 0)
859  return res;
860 
861  /* First frame needs to be a keyframe */
862  if (avctx->frame_number == 0)
863  keyframe = 1;
864 
865  /* Check the placement of keyframes */
866  if (avctx->gop_size > 0) {
867  if (avctx->frame_number >= s->last_key_frame + avctx->gop_size)
868  keyframe = 1;
869  }
870 
871  if (!keyframe
872  && avctx->frame_number > s->last_key_frame + avctx->keyint_min) {
873  recommend_keyframe(s, &keyframe);
874  if (keyframe)
875  av_log(avctx, AV_LOG_DEBUG, "Recommending key frame at frame %d\n", avctx->frame_number);
876  }
877 
878  if (keyframe) {
879  res = reconfigure_at_keyframe(s, p->data[0], p->linesize[0]);
880  if (res)
881  return res;
882  }
883 
884  if (s->use15_7)
885  s->dist = optimum_dist(s);
886 
887  res = write_bitstream(s, p->data[0], p->linesize[0], pkt->data, pkt->size, keyframe);
888 
889  if (keyframe) {
890  new_key_frame(s);
891  s->last_key_frame = avctx->frame_number;
892  pkt->flags |= AV_PKT_FLAG_KEY;
893  av_log(avctx, AV_LOG_DEBUG, "Inserting key frame at frame %d\n", avctx->frame_number);
894  }
895 
896  pkt->size = res;
897  *got_packet = 1;
898 
899  return 0;
900 }
901 
903 {
904  FlashSV2Context *s = avctx->priv_data;
905 
906  cleanup(s);
907 
908  return 0;
909 }
910 
912  .name = "flashsv2",
913  .long_name = NULL_IF_CONFIG_SMALL("Flash Screen Video Version 2"),
914  .type = AVMEDIA_TYPE_VIDEO,
915  .id = AV_CODEC_ID_FLASHSV2,
916  .priv_data_size = sizeof(FlashSV2Context),
918  .encode2 = flashsv2_encode_frame,
919  .close = flashsv2_encode_end,
921  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
922 };
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
uint8_t use_custom_palette
Definition: flashsv2enc.c:111
uint8_t index[1<< 15]
Definition: flashsv2enc.c:83
#define NULL
Definition: coverity.c:32
static int compare_sl(FlashSV2Context *s, Block *b, const uint8_t *src, uint8_t *frame, uint8_t *key, int y, int keyframe)
Definition: flashsv2enc.c:589
static int optimum_block_width(FlashSV2Context *s)
Definition: flashsv2enc.c:741
static void recommend_keyframe(FlashSV2Context *s, int *keyframe)
Definition: flashsv2enc.c:715
This structure describes decoded (raw) audio or video data.
Definition: frame.h:314
static int new_key_frame(FlashSV2Context *s)
Definition: flashsv2enc.c:258
uint8_t len
Definition: flashsv2enc.c:75
static unsigned pixel_color15(const uint8_t *src)
Definition: flashsv2enc.c:407
Block * frame_blocks
Definition: flashsv2enc.c:97
static int optimum_use15_7(FlashSV2Context *s)
Definition: flashsv2enc.c:765
misc image utilities
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:218
int64_t bit_rate
the average bitrate
Definition: avcodec.h:581
static int encode_zlibprime(Block *b, Block *prime, uint8_t *buf, int *buf_size, int comp)
Definition: flashsv2enc.c:357
const char * g
Definition: vf_curves.c:115
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int num
Numerator.
Definition: rational.h:59
static const unsigned int default_screen_video_v2_palette[128]
Definition: flashsv2enc.c:485
int size
Definition: packet.h:364
uint8_t * sl_begin
Definition: flashsv2enc.c:70
static int generate_optimum_palette(Palette *palette, const uint8_t *image, int width, int height, int stride)
Definition: flashsv2enc.c:518
uint8_t width
Definition: flashsv2enc.c:77
int enc_size
Definition: flashsv2enc.c:71
static int optimum_dist(FlashSV2Context *s)
Definition: flashsv2enc.c:780
const char * key
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
static AVPacket pkt
AVCodec.
Definition: codec.h:190
AVCodecContext * avctx
Definition: flashsv2enc.c:87
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:654
static av_cold int flashsv2_encode_end(AVCodecContext *avctx)
Definition: flashsv2enc.c:902
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:33
#define HAS_PALLET_INFO
Definition: flashsv2enc.c:56
uint8_t
#define av_cold
Definition: attributes.h:88
static int generate_default_palette(Palette *palette)
Definition: flashsv2enc.c:510
static int flashsv2_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *p, int *got_packet)
Definition: flashsv2enc.c:851
uint8_t * data
Definition: flashsv2enc.c:72
static int encode_block(FlashSV2Context *s, Palette *palette, Block *b, Block *prev, const uint8_t *src, int stride, int comp, int dist, int keyframe)
Definition: flashsv2enc.c:552
#define ZLIB_PRIME_COMPRESS_CURRENT
Definition: flashsv2enc.c:61
uint8_t * data
Definition: packet.h:363
static const uint64_t c1
Definition: murmur3.c:51
uint8_t flags
Definition: flashsv2enc.c:78
#define COLORSPACE_15_7
Definition: flashsv2enc.c:59
static unsigned int chroma_diff(unsigned int c1, unsigned int c2)
Definition: flashsv2enc.c:412
Block * key_blocks
Definition: flashsv2enc.c:98
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:198
#define AV_INPUT_BUFFER_MIN_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
Definition: avcodec.h:222
#define av_log(a,...)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:401
static av_cold int flashsv2_encode_init(AVCodecContext *avctx)
Definition: flashsv2enc.c:177
#define src
Definition: vp8dsp.c:254
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
#define ZLIB_PRIME_COMPRESS_PREVIOUS
Definition: flashsv2enc.c:62
static int encode_zlib(Block *b, uint8_t *buf, unsigned long *buf_size, int comp)
Definition: flashsv2enc.c:351
static int encode_15_7(Palette *palette, Block *b, const uint8_t *src, int stride, int dist)
Definition: flashsv2enc.c:535
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
uint8_t * blockbuffer
Definition: flashsv2enc.c:94
const char * r
Definition: vf_curves.c:114
unsigned int pos
Definition: spdifenc.c:410
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
#define t1
Definition: regdef.h:29
const char * name
Name of the codec implementation.
Definition: codec.h:197
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:369
AVCodec ff_flashsv2_encoder
Definition: flashsv2enc.c:911
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:502
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:317
#define b
Definition: input.c:41
uint8_t * databuffer
Definition: flashsv2enc.c:92
uint8_t dirty
Definition: flashsv2enc.c:76
int width
picture width / height.
Definition: avcodec.h:704
static int pixel_color7_slow(Palette *palette, unsigned color)
Definition: flashsv2enc.c:429
uint8_t * keybuffer
Definition: flashsv2enc.c:91
uint8_t * key_frame
Definition: flashsv2enc.c:89
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define s(width, name)
Definition: cbs_vp9.c:257
static int write_block(Block *b, uint8_t *buf, int buf_size)
Definition: flashsv2enc.c:311
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:663
static int encode_bgr(Block *b, const uint8_t *src, int stride)
Definition: flashsv2enc.c:391
static int reconfigure_at_keyframe(FlashSV2Context *s, const uint8_t *image, int stride)
Definition: flashsv2enc.c:795
if(ret)
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:83
#define HAS_DIFF_BLOCKS
Definition: flashsv2enc.c:60
static int write_palette(FlashSV2Context *s, uint8_t *buf, int buf_size)
Definition: flashsv2enc.c:275
static int update_palette_index(Palette *palette)
Definition: flashsv2enc.c:467
Libavcodec external API header.
int compression_level
Definition: avcodec.h:603
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:345
main external API structure.
Definition: avcodec.h:531
static int write_header(FlashSV2Context *s, uint8_t *buf, int buf_size)
Definition: flashsv2enc.c:281
unsigned long data_size
Definition: flashsv2enc.c:73
static int encode_15_7_sl(Palette *palette, uint8_t *dest, const uint8_t *src, int width, int dist)
Definition: flashsv2enc.c:525
uint8_t row
Definition: flashsv2enc.c:77
uint8_t start
Definition: flashsv2enc.c:75
static int mark_all_blocks(FlashSV2Context *s, const uint8_t *src, int stride, int keyframe)
Definition: flashsv2enc.c:607
int index
Definition: gxfenc.c:89
static int pixel_color7_fast(Palette *palette, unsigned c15)
Definition: flashsv2enc.c:424
static void init_blocks(FlashSV2Context *s, Block *blocks, uint8_t *encbuf, uint8_t *databuf)
Definition: flashsv2enc.c:140
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:300
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:597
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:328
uint8_t * enc
Definition: flashsv2enc.c:69
int gop_size
the number of pictures in a group of pictures, or 0 for intra_only
Definition: avcodec.h:726
uint8_t height
Definition: flashsv2enc.c:77
int
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
static unsigned pixel_bgr(const uint8_t *src)
Definition: flashsv2enc.c:444
uint8_t palette_type
0=>default, 1=>custom - changed when palette regenerated.
Definition: flashsv2enc.c:112
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:117
static int write_all_blocks(FlashSV2Context *s, uint8_t *buf, int buf_size)
Definition: flashsv2enc.c:668
static const uint64_t c2
Definition: murmur3.c:52
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:64
int den
Denominator.
Definition: rational.h:60
unsigned colors[128]
Definition: flashsv2enc.c:82
static void deflate(uint8_t *dst, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord, int maxc)
Definition: vf_neighbor.c:165
void * priv_data
Definition: avcodec.h:558
static av_always_inline int diff(const uint32_t a, const uint32_t b)
uint8_t * current_frame
Definition: flashsv2enc.c:88
static int encode_all_blocks(FlashSV2Context *s, int keyframe)
Definition: flashsv2enc.c:628
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1222
#define av_freep(p)
static int optimum_block_height(FlashSV2Context *s)
Definition: flashsv2enc.c:753
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
float min
#define ABSDIFF(a, b)
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: packet.h:340
static int write_bitstream(FlashSV2Context *s, const uint8_t *src, int stride, uint8_t *buf, int buf_size, int keyframe)
Definition: flashsv2enc.c:686
static int write_pixel_15_7(Palette *palette, uint8_t *dest, const uint8_t *src, int dist)
Definition: flashsv2enc.c:449
#define t2
Definition: regdef.h:30
int i
Definition: input.c:407
static void reset_stats(FlashSV2Context *s)
Definition: flashsv2enc.c:166
static av_cold void cleanup(FlashSV2Context *s)
Definition: flashsv2enc.c:127
uint8_t col
Definition: flashsv2enc.c:77
uint8_t * encbuffer
Definition: flashsv2enc.c:90
int keyint_min
minimum GOP size
Definition: avcodec.h:1112
uint8_t * sl_end
Definition: flashsv2enc.c:70
bitstream writer API