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