FFmpeg
a64multienc.c
Go to the documentation of this file.
1 /*
2  * a64 video encoder - multicolor modes
3  * Copyright (c) 2009 Tobias Bindhammer
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  * a64 video encoder - multicolor modes
25  */
26 
27 #include "a64colors.h"
28 #include "a64tables.h"
29 #include "elbg.h"
30 #include "internal.h"
31 #include "libavutil/avassert.h"
32 #include "libavutil/common.h"
33 #include "libavutil/intreadwrite.h"
34 
35 #define DITHERSTEPS 8
36 #define CHARSET_CHARS 256
37 #define INTERLACED 1
38 #define CROP_SCREENS 1
39 
40 #define C64XRES 320
41 #define C64YRES 200
42 
43 typedef struct A64Context {
44  /* variables for multicolor modes */
48  unsigned mc_frame_counter;
50  int *mc_charmap;
51  int *mc_best_cb;
52  int mc_luma_vals[5];
57 
58  /* pts of the next packet that will be output */
59  int64_t next_pts;
60 } A64Context;
61 
62 /* gray gradient */
63 static const uint8_t mc_colors[5]={0x0,0xb,0xc,0xf,0x1};
64 
65 /* other possible gradients - to be tested */
66 //static const uint8_t mc_colors[5]={0x0,0x8,0xa,0xf,0x7};
67 //static const uint8_t mc_colors[5]={0x0,0x9,0x8,0xa,0x3};
68 
69 static void to_meta_with_crop(AVCodecContext *avctx,
70  const AVFrame *p, int *dest)
71 {
72  int blockx, blocky, x, y;
73  int luma = 0;
74  int height = FFMIN(avctx->height, C64YRES);
75  int width = FFMIN(avctx->width , C64XRES);
76  uint8_t *src = p->data[0];
77 
78  for (blocky = 0; blocky < C64YRES; blocky += 8) {
79  for (blockx = 0; blockx < C64XRES; blockx += 8) {
80  for (y = blocky; y < blocky + 8 && y < C64YRES; y++) {
81  for (x = blockx; x < blockx + 8 && x < C64XRES; x += 2) {
82  if(x < width && y < height) {
83  if (x + 1 < width) {
84  /* build average over 2 pixels */
85  luma = (src[(x + 0 + y * p->linesize[0])] +
86  src[(x + 1 + y * p->linesize[0])]) / 2;
87  } else {
88  luma = src[(x + y * p->linesize[0])];
89  }
90  /* write blocks as linear data now so they are suitable for elbg */
91  dest[0] = luma;
92  }
93  dest++;
94  }
95  }
96  }
97  }
98 }
99 
100 static void render_charset(AVCodecContext *avctx, uint8_t *charset,
101  uint8_t *colrammap)
102 {
103  A64Context *c = avctx->priv_data;
104  uint8_t row1, row2;
105  int charpos, x, y;
106  int a, b;
107  uint8_t pix;
108  int lowdiff, highdiff;
109  int *best_cb = c->mc_best_cb;
110  static uint8_t index1[256];
111  static uint8_t index2[256];
112  static uint8_t dither[256];
113  int i;
114  int distance;
115 
116  /* generate lookup-tables for dither and index before looping */
117  i = 0;
118  for (a=0; a < 256; a++) {
119  if(i < c->mc_pal_size -1 && a == c->mc_luma_vals[i + 1]) {
120  distance = c->mc_luma_vals[i + 1] - c->mc_luma_vals[i];
121  for(b = 0; b <= distance; b++) {
122  dither[c->mc_luma_vals[i] + b] = b * (DITHERSTEPS - 1) / distance;
123  }
124  i++;
125  }
126  if(i >= c->mc_pal_size - 1) dither[a] = 0;
127  index1[a] = i;
128  index2[a] = FFMIN(i + 1, c->mc_pal_size - 1);
129  }
130 
131  /* and render charset */
132  for (charpos = 0; charpos < CHARSET_CHARS; charpos++) {
133  lowdiff = 0;
134  highdiff = 0;
135  for (y = 0; y < 8; y++) {
136  row1 = 0; row2 = 0;
137  for (x = 0; x < 4; x++) {
138  pix = best_cb[y * 4 + x];
139 
140  /* accumulate error for brightest/darkest color */
141  if (index1[pix] >= 3)
142  highdiff += pix - c->mc_luma_vals[3];
143  if (index1[pix] < 1)
144  lowdiff += c->mc_luma_vals[1] - pix;
145 
146  row1 <<= 2;
147 
148  if (INTERLACED) {
149  row2 <<= 2;
150  if (interlaced_dither_patterns[dither[pix]][(y & 3) * 2 + 0][x & 3])
151  row1 |= 3-(index2[pix] & 3);
152  else
153  row1 |= 3-(index1[pix] & 3);
154 
155  if (interlaced_dither_patterns[dither[pix]][(y & 3) * 2 + 1][x & 3])
156  row2 |= 3-(index2[pix] & 3);
157  else
158  row2 |= 3-(index1[pix] & 3);
159  }
160  else {
161  if (multi_dither_patterns[dither[pix]][(y & 3)][x & 3])
162  row1 |= 3-(index2[pix] & 3);
163  else
164  row1 |= 3-(index1[pix] & 3);
165  }
166  }
167  charset[y+0x000] = row1;
168  if (INTERLACED) charset[y+0x800] = row2;
169  }
170  /* do we need to adjust pixels? */
171  if (highdiff > 0 && lowdiff > 0 && c->mc_use_5col) {
172  if (lowdiff > highdiff) {
173  for (x = 0; x < 32; x++)
174  best_cb[x] = FFMIN(c->mc_luma_vals[3], best_cb[x]);
175  } else {
176  for (x = 0; x < 32; x++)
177  best_cb[x] = FFMAX(c->mc_luma_vals[1], best_cb[x]);
178  }
179  charpos--; /* redo now adjusted char */
180  /* no adjustment needed, all fine */
181  } else {
182  /* advance pointers */
183  best_cb += 32;
184  charset += 8;
185 
186  /* remember colorram value */
187  colrammap[charpos] = (highdiff > 0);
188  }
189  }
190 }
191 
193 {
194  A64Context *c = avctx->priv_data;
196  av_freep(&c->mc_best_cb);
197  av_freep(&c->mc_charset);
198  av_freep(&c->mc_charmap);
199  av_freep(&c->mc_colram);
200  return 0;
201 }
202 
204 {
205  A64Context *c = avctx->priv_data;
206  int a;
207  av_lfg_init(&c->randctx, 1);
208 
209  if (avctx->global_quality < 1) {
210  c->mc_lifetime = 4;
211  } else {
212  c->mc_lifetime = avctx->global_quality /= FF_QP2LAMBDA;
213  }
214 
215  av_log(avctx, AV_LOG_INFO, "charset lifetime set to %d frame(s)\n", c->mc_lifetime);
216 
217  c->mc_frame_counter = 0;
218  c->mc_use_5col = avctx->codec->id == AV_CODEC_ID_A64_MULTI5;
219  c->mc_pal_size = 4 + c->mc_use_5col;
220 
221  /* precalc luma values for later use */
222  for (a = 0; a < c->mc_pal_size; a++) {
223  c->mc_luma_vals[a]=a64_palette[mc_colors[a]][0] * 0.30 +
224  a64_palette[mc_colors[a]][1] * 0.59 +
225  a64_palette[mc_colors[a]][2] * 0.11;
226  }
227 
228  if (!(c->mc_meta_charset = av_mallocz_array(c->mc_lifetime, 32000 * sizeof(int))) ||
229  !(c->mc_best_cb = av_malloc(CHARSET_CHARS * 32 * sizeof(int))) ||
230  !(c->mc_charmap = av_mallocz_array(c->mc_lifetime, 1000 * sizeof(int))) ||
231  !(c->mc_colram = av_mallocz(CHARSET_CHARS * sizeof(uint8_t))) ||
232  !(c->mc_charset = av_malloc(0x800 * (INTERLACED+1) * sizeof(uint8_t)))) {
233  av_log(avctx, AV_LOG_ERROR, "Failed to allocate buffer memory.\n");
234  return AVERROR(ENOMEM);
235  }
236 
237  /* set up extradata */
238  if (!(avctx->extradata = av_mallocz(8 * 4 + AV_INPUT_BUFFER_PADDING_SIZE))) {
239  av_log(avctx, AV_LOG_ERROR, "Failed to allocate memory for extradata.\n");
240  return AVERROR(ENOMEM);
241  }
242  avctx->extradata_size = 8 * 4;
243  AV_WB32(avctx->extradata, c->mc_lifetime);
244  AV_WB32(avctx->extradata + 16, INTERLACED);
245 
246  if (!avctx->codec_tag)
247  avctx->codec_tag = AV_RL32("a64m");
248 
250 
251  return 0;
252 }
253 
254 static void a64_compress_colram(unsigned char *buf, int *charmap, uint8_t *colram)
255 {
256  int a;
257  uint8_t temp;
258  /* only needs to be done in 5col mode */
259  /* XXX could be squeezed to 0x80 bytes */
260  for (a = 0; a < 256; a++) {
261  temp = colram[charmap[a + 0x000]] << 0;
262  temp |= colram[charmap[a + 0x100]] << 1;
263  temp |= colram[charmap[a + 0x200]] << 2;
264  if (a < 0xe8) temp |= colram[charmap[a + 0x300]] << 3;
265  buf[a] = temp << 2;
266  }
267 }
268 
270  const AVFrame *p, int *got_packet)
271 {
272  A64Context *c = avctx->priv_data;
273 
274  int frame;
275  int x, y;
276  int b_height;
277  int b_width;
278 
279  int req_size, ret;
280  uint8_t *buf = NULL;
281 
282  int *charmap = c->mc_charmap;
283  uint8_t *colram = c->mc_colram;
284  uint8_t *charset = c->mc_charset;
285  int *meta = c->mc_meta_charset;
286  int *best_cb = c->mc_best_cb;
287 
288  int charset_size = 0x800 * (INTERLACED + 1);
289  int colram_size = 0x100 * c->mc_use_5col;
290  int screen_size;
291 
292  if(CROP_SCREENS) {
293  b_height = FFMIN(avctx->height,C64YRES) >> 3;
294  b_width = FFMIN(avctx->width ,C64XRES) >> 3;
295  screen_size = b_width * b_height;
296  } else {
297  b_height = C64YRES >> 3;
298  b_width = C64XRES >> 3;
299  screen_size = 0x400;
300  }
301 
302  /* no data, means end encoding asap */
303  if (!p) {
304  /* all done, end encoding */
305  if (!c->mc_lifetime) return 0;
306  /* no more frames in queue, prepare to flush remaining frames */
307  if (!c->mc_frame_counter) {
308  c->mc_lifetime = 0;
309  }
310  /* still frames in queue so limit lifetime to remaining frames */
311  else c->mc_lifetime = c->mc_frame_counter;
312  /* still new data available */
313  } else {
314  /* fill up mc_meta_charset with data until lifetime exceeds */
315  if (c->mc_frame_counter < c->mc_lifetime) {
316  to_meta_with_crop(avctx, p, meta + 32000 * c->mc_frame_counter);
317  c->mc_frame_counter++;
318  if (c->next_pts == AV_NOPTS_VALUE)
319  c->next_pts = p->pts;
320  /* lifetime is not reached so wait for next frame first */
321  return 0;
322  }
323  }
324 
325  /* lifetime reached so now convert X frames at once */
326  if (c->mc_frame_counter == c->mc_lifetime) {
327  req_size = 0;
328  /* any frames to encode? */
329  if (c->mc_lifetime) {
330  int alloc_size = charset_size + c->mc_lifetime*(screen_size + colram_size);
331  if ((ret = ff_alloc_packet2(avctx, pkt, alloc_size, 0)) < 0)
332  return ret;
333  buf = pkt->data;
334 
335  /* calc optimal new charset + charmaps */
336  ret = avpriv_init_elbg(meta, 32, 1000 * c->mc_lifetime, best_cb,
337  CHARSET_CHARS, 50, charmap, &c->randctx);
338  if (ret < 0)
339  return ret;
340  ret = avpriv_do_elbg(meta, 32, 1000 * c->mc_lifetime, best_cb,
341  CHARSET_CHARS, 50, charmap, &c->randctx);
342  if (ret < 0)
343  return ret;
344 
345  /* create colorram map and a c64 readable charset */
346  render_charset(avctx, charset, colram);
347 
348  /* copy charset to buf */
349  memcpy(buf, charset, charset_size);
350 
351  /* advance pointers */
352  buf += charset_size;
353  req_size += charset_size;
354  }
355 
356  /* write x frames to buf */
357  for (frame = 0; frame < c->mc_lifetime; frame++) {
358  /* copy charmap to buf. buf is uchar*, charmap is int*, so no memcpy here, sorry */
359  for (y = 0; y < b_height; y++) {
360  for (x = 0; x < b_width; x++) {
361  buf[y * b_width + x] = charmap[y * b_width + x];
362  }
363  }
364  /* advance pointers */
365  buf += screen_size;
366  req_size += screen_size;
367 
368  /* compress and copy colram to buf */
369  if (c->mc_use_5col) {
370  a64_compress_colram(buf, charmap, colram);
371  /* advance pointers */
372  buf += colram_size;
373  req_size += colram_size;
374  }
375 
376  /* advance to next charmap */
377  charmap += 1000;
378  }
379 
380  AV_WB32(avctx->extradata + 4, c->mc_frame_counter);
381  AV_WB32(avctx->extradata + 8, charset_size);
382  AV_WB32(avctx->extradata + 12, screen_size + colram_size);
383 
384  /* reset counter */
385  c->mc_frame_counter = 0;
386 
387  pkt->pts = pkt->dts = c->next_pts;
389 
390  av_assert0(pkt->size >= req_size);
391  pkt->size = req_size;
392  pkt->flags |= AV_PKT_FLAG_KEY;
393  *got_packet = !!req_size;
394  }
395  return 0;
396 }
397 
398 #if CONFIG_A64MULTI_ENCODER
400  .name = "a64multi",
401  .long_name = NULL_IF_CONFIG_SMALL("Multicolor charset for Commodore 64"),
402  .type = AVMEDIA_TYPE_VIDEO,
403  .id = AV_CODEC_ID_A64_MULTI,
404  .priv_data_size = sizeof(A64Context),
406  .encode2 = a64multi_encode_frame,
407  .close = a64multi_close_encoder,
409  .capabilities = AV_CODEC_CAP_DELAY,
410 };
411 #endif
412 #if CONFIG_A64MULTI5_ENCODER
414  .name = "a64multi5",
415  .long_name = NULL_IF_CONFIG_SMALL("Multicolor charset for Commodore 64, extended with 5th color (colram)"),
416  .type = AVMEDIA_TYPE_VIDEO,
418  .priv_data_size = sizeof(A64Context),
420  .encode2 = a64multi_encode_frame,
421  .close = a64multi_close_encoder,
423  .capabilities = AV_CODEC_CAP_DELAY,
424 };
425 #endif
Definition: lfg.h:27
#define NULL
Definition: coverity.c:32
const struct AVCodec * codec
Definition: avcodec.h:1574
static const uint8_t mc_colors[5]
Definition: a64multienc.c:63
#define C64XRES
Definition: a64multienc.c:40
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
#define INTERLACED
Definition: a64multienc.c:37
else temp
Definition: vf_mcdeint.c:256
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
uint8_t * mc_palette
Definition: a64multienc.c:55
AVCodec ff_a64multi_encoder
int size
Definition: avcodec.h:1478
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
static AVPacket pkt
#define src
Definition: vp8dsp.c:254
AVCodec.
Definition: avcodec.h:3481
int mc_luma_vals[5]
Definition: a64multienc.c:52
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: avcodec.h:1006
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
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:32
uint8_t
#define av_cold
Definition: attributes.h:82
#define av_malloc(s)
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:388
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1666
int avpriv_do_elbg(int *points, int dim, int numpoints, int *codebook, int numCB, int max_steps, int *closest_cb, AVLFG *rand_state)
Implementation of the Enhanced LBG Algorithm Based on the paper "Neural Networks 14:1219-1237" that c...
Definition: elbg.c:371
int mc_use_5col
Definition: a64multienc.c:47
#define height
uint8_t * data
Definition: avcodec.h:1477
int * mc_best_cb
Definition: a64multienc.c:51
#define av_log(a,...)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1509
enum AVCodecID id
Definition: avcodec.h:3495
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
#define CROP_SCREENS
Definition: a64multienc.c:38
static const uint8_t dither[8][8]
Definition: vf_fspp.c:57
simple assert() macros that are a bit more flexible than ISO C assert().
a64 video encoder - tables used by a64 encoders
const char * name
Name of the codec implementation.
Definition: avcodec.h:3488
#define DITHERSTEPS
Definition: a64multienc.c:35
#define FFMAX(a, b)
Definition: common.h:94
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1483
#define C64YRES
Definition: a64multienc.c:41
static float distance(float x, float y, int band)
#define b
Definition: input.c:41
int * mc_meta_charset
Definition: a64multienc.c:49
static int a64multi_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *p, int *got_packet)
Definition: a64multienc.c:269
#define CHARSET_CHARS
Definition: a64multienc.c:36
#define FFMIN(a, b)
Definition: common.h:96
unsigned mc_frame_counter
Definition: a64multienc.c:48
#define width
static void a64_compress_colram(unsigned char *buf, int *charmap, uint8_t *colram)
Definition: a64multienc.c:254
int width
picture width / height.
Definition: avcodec.h:1738
uint8_t * mc_charset
Definition: a64multienc.c:53
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
int mc_pal_size
Definition: a64multienc.c:56
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
static void render_charset(AVCodecContext *avctx, uint8_t *charset, uint8_t *colrammap)
Definition: a64multienc.c:100
int avpriv_init_elbg(int *points, int dim, int numpoints, int *codebook, int numCB, int max_steps, int *closest_cb, AVLFG *rand_state)
Initialize the **codebook vector for the elbg algorithm.
Definition: elbg.c:337
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
main external API structure.
Definition: avcodec.h:1565
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> (&#39;D&#39;<<24) + (&#39;C&#39;<<16) + (&#39;B&#39;<<8) + &#39;A&#39;).
Definition: avcodec.h:1590
void * buf
Definition: avisynth_c.h:766
int extradata_size
Definition: avcodec.h:1667
static void to_meta_with_crop(AVCodecContext *avctx, const AVFrame *p, int *dest)
Definition: a64multienc.c:69
#define AV_WB32(p, v)
Definition: intreadwrite.h:419
a64 video encoder - c64 colors in rgb
av_cold void av_lfg_init(AVLFG *c, unsigned int seed)
Definition: lfg.c:32
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1631
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
int64_t next_pts
Definition: a64multienc.c:59
Y , 8bpp.
Definition: pixfmt.h:74
static av_cold int a64multi_encode_init(AVCodecContext *avctx)
Definition: a64multienc.c:203
common internal api header.
common internal and external API header
int * mc_charmap
Definition: a64multienc.c:50
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:790
void * priv_data
Definition: avcodec.h:1592
static const uint8_t a64_palette[16][3]
Definition: a64colors.h:33
static const uint8_t interlaced_dither_patterns[9][8][4]
Definition: a64tables.h:93
AVLFG randctx
Definition: a64multienc.c:45
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
static av_cold int a64multi_close_encoder(AVCodecContext *avctx)
Definition: a64multienc.c:192
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1476
#define av_freep(p)
uint8_t * mc_colram
Definition: a64multienc.c:54
AVCodec ff_a64multi5_encoder
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
int mc_lifetime
Definition: a64multienc.c:46
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1454
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1470
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
static const uint8_t multi_dither_patterns[9][4][4]
dither patterns used vor rendering the multicolor charset
Definition: a64tables.h:36
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191