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  uint8_t index1[256];
111  uint8_t index2[256];
112  uint8_t dither[256];
113  int i;
114  int distance;
115 
116  /* Generate lookup-tables for dither and index before looping.
117  * This code relies on c->mc_luma_vals[c->mc_pal_size - 1] being
118  * the maximum of all the mc_luma_vals values and on the minimum
119  * being zero; this ensures that dither is properly initialized. */
120  i = 0;
121  for (a=0; a < 256; a++) {
122  if(i < c->mc_pal_size -1 && a == c->mc_luma_vals[i + 1]) {
123  distance = c->mc_luma_vals[i + 1] - c->mc_luma_vals[i];
124  for(b = 0; b <= distance; b++) {
125  dither[c->mc_luma_vals[i] + b] = b * (DITHERSTEPS - 1) / distance;
126  }
127  i++;
128  }
129  if(i >= c->mc_pal_size - 1) dither[a] = 0;
130  index1[a] = i;
131  index2[a] = FFMIN(i + 1, c->mc_pal_size - 1);
132  }
133 
134  /* and render charset */
135  for (charpos = 0; charpos < CHARSET_CHARS; charpos++) {
136  lowdiff = 0;
137  highdiff = 0;
138  for (y = 0; y < 8; y++) {
139  row1 = 0; row2 = 0;
140  for (x = 0; x < 4; x++) {
141  pix = best_cb[y * 4 + x];
142 
143  /* accumulate error for brightest/darkest color */
144  if (index1[pix] >= 3)
145  highdiff += pix - c->mc_luma_vals[3];
146  if (index1[pix] < 1)
147  lowdiff += c->mc_luma_vals[1] - pix;
148 
149  row1 <<= 2;
150 
151  if (INTERLACED) {
152  row2 <<= 2;
153  if (interlaced_dither_patterns[dither[pix]][(y & 3) * 2 + 0][x & 3])
154  row1 |= 3-(index2[pix] & 3);
155  else
156  row1 |= 3-(index1[pix] & 3);
157 
158  if (interlaced_dither_patterns[dither[pix]][(y & 3) * 2 + 1][x & 3])
159  row2 |= 3-(index2[pix] & 3);
160  else
161  row2 |= 3-(index1[pix] & 3);
162  }
163  else {
164  if (multi_dither_patterns[dither[pix]][(y & 3)][x & 3])
165  row1 |= 3-(index2[pix] & 3);
166  else
167  row1 |= 3-(index1[pix] & 3);
168  }
169  }
170  charset[y+0x000] = row1;
171  if (INTERLACED) charset[y+0x800] = row2;
172  }
173  /* do we need to adjust pixels? */
174  if (highdiff > 0 && lowdiff > 0 && c->mc_use_5col) {
175  if (lowdiff > highdiff) {
176  for (x = 0; x < 32; x++)
177  best_cb[x] = FFMIN(c->mc_luma_vals[3], best_cb[x]);
178  } else {
179  for (x = 0; x < 32; x++)
180  best_cb[x] = FFMAX(c->mc_luma_vals[1], best_cb[x]);
181  }
182  charpos--; /* redo now adjusted char */
183  /* no adjustment needed, all fine */
184  } else {
185  /* advance pointers */
186  best_cb += 32;
187  charset += 8;
188 
189  /* remember colorram value */
190  colrammap[charpos] = (highdiff > 0);
191  }
192  }
193 }
194 
196 {
197  A64Context *c = avctx->priv_data;
199  av_freep(&c->mc_best_cb);
200  av_freep(&c->mc_charset);
201  av_freep(&c->mc_charmap);
202  av_freep(&c->mc_colram);
203  return 0;
204 }
205 
207 {
208  A64Context *c = avctx->priv_data;
209  int a;
210  av_lfg_init(&c->randctx, 1);
211 
212  if (avctx->global_quality < 1) {
213  c->mc_lifetime = 4;
214  } else {
215  c->mc_lifetime = avctx->global_quality /= FF_QP2LAMBDA;
216  }
217 
218  av_log(avctx, AV_LOG_INFO, "charset lifetime set to %d frame(s)\n", c->mc_lifetime);
219 
220  c->mc_frame_counter = 0;
221  c->mc_use_5col = avctx->codec->id == AV_CODEC_ID_A64_MULTI5;
222  c->mc_pal_size = 4 + c->mc_use_5col;
223 
224  /* precalc luma values for later use */
225  for (a = 0; a < c->mc_pal_size; a++) {
226  c->mc_luma_vals[a]=a64_palette[mc_colors[a]][0] * 0.30 +
227  a64_palette[mc_colors[a]][1] * 0.59 +
228  a64_palette[mc_colors[a]][2] * 0.11;
229  }
230 
231  if (!(c->mc_meta_charset = av_mallocz_array(c->mc_lifetime, 32000 * sizeof(int))) ||
232  !(c->mc_best_cb = av_malloc(CHARSET_CHARS * 32 * sizeof(int))) ||
233  !(c->mc_charmap = av_mallocz_array(c->mc_lifetime, 1000 * sizeof(int))) ||
234  !(c->mc_colram = av_mallocz(CHARSET_CHARS * sizeof(uint8_t))) ||
235  !(c->mc_charset = av_malloc(0x800 * (INTERLACED+1) * sizeof(uint8_t)))) {
236  av_log(avctx, AV_LOG_ERROR, "Failed to allocate buffer memory.\n");
237  return AVERROR(ENOMEM);
238  }
239 
240  /* set up extradata */
241  if (!(avctx->extradata = av_mallocz(8 * 4 + AV_INPUT_BUFFER_PADDING_SIZE))) {
242  av_log(avctx, AV_LOG_ERROR, "Failed to allocate memory for extradata.\n");
243  return AVERROR(ENOMEM);
244  }
245  avctx->extradata_size = 8 * 4;
246  AV_WB32(avctx->extradata, c->mc_lifetime);
247  AV_WB32(avctx->extradata + 16, INTERLACED);
248 
249  if (!avctx->codec_tag)
250  avctx->codec_tag = AV_RL32("a64m");
251 
253 
254  return 0;
255 }
256 
257 static void a64_compress_colram(unsigned char *buf, int *charmap, uint8_t *colram)
258 {
259  int a;
260  uint8_t temp;
261  /* only needs to be done in 5col mode */
262  /* XXX could be squeezed to 0x80 bytes */
263  for (a = 0; a < 256; a++) {
264  temp = colram[charmap[a + 0x000]] << 0;
265  temp |= colram[charmap[a + 0x100]] << 1;
266  temp |= colram[charmap[a + 0x200]] << 2;
267  if (a < 0xe8) temp |= colram[charmap[a + 0x300]] << 3;
268  buf[a] = temp << 2;
269  }
270 }
271 
273  const AVFrame *p, int *got_packet)
274 {
275  A64Context *c = avctx->priv_data;
276 
277  int frame;
278  int x, y;
279  int b_height;
280  int b_width;
281 
282  int req_size, ret;
283  uint8_t *buf = NULL;
284 
285  int *charmap = c->mc_charmap;
286  uint8_t *colram = c->mc_colram;
287  uint8_t *charset = c->mc_charset;
288  int *meta = c->mc_meta_charset;
289  int *best_cb = c->mc_best_cb;
290 
291  int charset_size = 0x800 * (INTERLACED + 1);
292  int colram_size = 0x100 * c->mc_use_5col;
293  int screen_size;
294 
295  if(CROP_SCREENS) {
296  b_height = FFMIN(avctx->height,C64YRES) >> 3;
297  b_width = FFMIN(avctx->width ,C64XRES) >> 3;
298  screen_size = b_width * b_height;
299  } else {
300  b_height = C64YRES >> 3;
301  b_width = C64XRES >> 3;
302  screen_size = 0x400;
303  }
304 
305  /* no data, means end encoding asap */
306  if (!p) {
307  /* all done, end encoding */
308  if (!c->mc_lifetime) return 0;
309  /* no more frames in queue, prepare to flush remaining frames */
310  if (!c->mc_frame_counter) {
311  c->mc_lifetime = 0;
312  }
313  /* still frames in queue so limit lifetime to remaining frames */
314  else c->mc_lifetime = c->mc_frame_counter;
315  /* still new data available */
316  } else {
317  /* fill up mc_meta_charset with data until lifetime exceeds */
318  if (c->mc_frame_counter < c->mc_lifetime) {
319  to_meta_with_crop(avctx, p, meta + 32000 * c->mc_frame_counter);
320  c->mc_frame_counter++;
321  if (c->next_pts == AV_NOPTS_VALUE)
322  c->next_pts = p->pts;
323  /* lifetime is not reached so wait for next frame first */
324  return 0;
325  }
326  }
327 
328  /* lifetime reached so now convert X frames at once */
329  if (c->mc_frame_counter == c->mc_lifetime) {
330  req_size = 0;
331  /* any frames to encode? */
332  if (c->mc_lifetime) {
333  int alloc_size = charset_size + c->mc_lifetime*(screen_size + colram_size);
334  if ((ret = ff_alloc_packet2(avctx, pkt, alloc_size, 0)) < 0)
335  return ret;
336  buf = pkt->data;
337 
338  /* calc optimal new charset + charmaps */
339  ret = avpriv_init_elbg(meta, 32, 1000 * c->mc_lifetime, best_cb,
340  CHARSET_CHARS, 50, charmap, &c->randctx);
341  if (ret < 0)
342  return ret;
343  ret = avpriv_do_elbg(meta, 32, 1000 * c->mc_lifetime, best_cb,
344  CHARSET_CHARS, 50, charmap, &c->randctx);
345  if (ret < 0)
346  return ret;
347 
348  /* create colorram map and a c64 readable charset */
349  render_charset(avctx, charset, colram);
350 
351  /* copy charset to buf */
352  memcpy(buf, charset, charset_size);
353 
354  /* advance pointers */
355  buf += charset_size;
356  req_size += charset_size;
357  }
358 
359  /* write x frames to buf */
360  for (frame = 0; frame < c->mc_lifetime; frame++) {
361  /* copy charmap to buf. buf is uchar*, charmap is int*, so no memcpy here, sorry */
362  for (y = 0; y < b_height; y++) {
363  for (x = 0; x < b_width; x++) {
364  buf[y * b_width + x] = charmap[y * b_width + x];
365  }
366  }
367  /* advance pointers */
368  buf += screen_size;
369  req_size += screen_size;
370 
371  /* compress and copy colram to buf */
372  if (c->mc_use_5col) {
373  a64_compress_colram(buf, charmap, colram);
374  /* advance pointers */
375  buf += colram_size;
376  req_size += colram_size;
377  }
378 
379  /* advance to next charmap */
380  charmap += 1000;
381  }
382 
383  AV_WB32(avctx->extradata + 4, c->mc_frame_counter);
384  AV_WB32(avctx->extradata + 8, charset_size);
385  AV_WB32(avctx->extradata + 12, screen_size + colram_size);
386 
387  /* reset counter */
388  c->mc_frame_counter = 0;
389 
390  pkt->pts = pkt->dts = c->next_pts;
392 
393  av_assert0(pkt->size >= req_size);
394  pkt->size = req_size;
395  pkt->flags |= AV_PKT_FLAG_KEY;
396  *got_packet = !!req_size;
397  }
398  return 0;
399 }
400 
401 #if CONFIG_A64MULTI_ENCODER
403  .name = "a64multi",
404  .long_name = NULL_IF_CONFIG_SMALL("Multicolor charset for Commodore 64"),
405  .type = AVMEDIA_TYPE_VIDEO,
406  .id = AV_CODEC_ID_A64_MULTI,
407  .priv_data_size = sizeof(A64Context),
409  .encode2 = a64multi_encode_frame,
410  .close = a64multi_close_encoder,
412  .capabilities = AV_CODEC_CAP_DELAY,
414 };
415 #endif
416 #if CONFIG_A64MULTI5_ENCODER
418  .name = "a64multi5",
419  .long_name = NULL_IF_CONFIG_SMALL("Multicolor charset for Commodore 64, extended with 5th color (colram)"),
420  .type = AVMEDIA_TYPE_VIDEO,
422  .priv_data_size = sizeof(A64Context),
424  .encode2 = a64multi_encode_frame,
425  .close = a64multi_close_encoder,
427  .capabilities = AV_CODEC_CAP_DELAY,
429 };
430 #endif
#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:49
Context structure for the Lagged Fibonacci PRNG.
Definition: lfg.h:33
#define NULL
Definition: coverity.c:32
const struct AVCodec * codec
Definition: avcodec.h:545
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:318
#define INTERLACED
Definition: a64multienc.c:37
else temp
Definition: vf_mcdeint.c:259
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
uint8_t * mc_palette
Definition: a64multienc.c:55
AVCodec ff_a64multi_encoder
int size
Definition: packet.h:370
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:237
AVPacket * pkt
Definition: movenc.c:59
AVCodec.
Definition: codec.h:197
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: codec.h:77
#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:33
#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:41
uint8_t
#define av_cold
Definition: attributes.h:88
#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:411
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:637
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: packet.h:369
int * mc_best_cb
Definition: a64multienc.c:51
#define av_log(a,...)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:410
#define src
Definition: vp8dsp.c:255
enum AVCodecID id
Definition: codec.h:211
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:117
#define CROP_SCREENS
Definition: a64multienc.c:38
static const uint8_t dither[8][8]
Definition: vf_fspp.c:59
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: codec.h:204
#define DITHERSTEPS
Definition: a64multienc.c:35
#define FFMAX(a, b)
Definition: common.h:103
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:375
#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:272
#define CHARSET_CHARS
Definition: a64multienc.c:36
#define FFMIN(a, b)
Definition: common.h:105
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:257
int width
picture width / height.
Definition: avcodec.h:709
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:205
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:349
main external API structure.
Definition: avcodec.h:536
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:561
int extradata_size
Definition: avcodec.h:638
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:303
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:602
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
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:206
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:215
void * priv_data
Definition: avcodec.h:563
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:195
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: packet.h:368
#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:91
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: packet.h:346
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:362
int i
Definition: input.c:407
#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:190