FFmpeg: libavcodec/flashsv2enc.c Source File

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

AltStyle によって変換されたページ (->オリジナル) /