FFmpeg  4.3
au.c
Go to the documentation of this file.
1 /*
2  * AU muxer and demuxer
3  * Copyright (c) 2001 Fabrice Bellard
4  *
5  * first version by Francois Revol <revol@free.fr>
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  */
23 
24 /*
25  * Reference documents:
26  * http://www.opengroup.org/public/pubs/external/auformat.html
27  * http://www.goice.co.jp/member/mo/formats/au.html
28  */
29 
30 #include "avformat.h"
31 #include "internal.h"
32 #include "avio_internal.h"
33 #include "pcm.h"
34 #include "libavutil/avassert.h"
35 
36 /* if we don't know the size in advance */
37 #define AU_UNKNOWN_SIZE ((uint32_t)(~0))
38 /* the specification requires an annotation field of at least eight bytes */
39 #define AU_DEFAULT_HEADER_SIZE (24+8)
40 
41 static const AVCodecTag codec_au_tags[] = {
42  { AV_CODEC_ID_PCM_MULAW, 1 },
43  { AV_CODEC_ID_PCM_S8, 2 },
44  { AV_CODEC_ID_PCM_S16BE, 3 },
45  { AV_CODEC_ID_PCM_S24BE, 4 },
46  { AV_CODEC_ID_PCM_S32BE, 5 },
47  { AV_CODEC_ID_PCM_F32BE, 6 },
48  { AV_CODEC_ID_PCM_F64BE, 7 },
53  { AV_CODEC_ID_PCM_ALAW, 27 },
54  { AV_CODEC_ID_ADPCM_G726LE, MKBETAG('7','2','6','2') },
55  { AV_CODEC_ID_NONE, 0 },
56 };
57 
58 #if CONFIG_AU_DEMUXER
59 
60 static int au_probe(const AVProbeData *p)
61 {
62  if (p->buf[0] == '.' && p->buf[1] == 's' &&
63  p->buf[2] == 'n' && p->buf[3] == 'd')
64  return AVPROBE_SCORE_MAX;
65  else
66  return 0;
67 }
68 
69 static int au_read_annotation(AVFormatContext *s, int size)
70 {
71  static const char * keys[] = {
72  "title",
73  "artist",
74  "album",
75  "track",
76  "genre",
77  NULL };
78  AVIOContext *pb = s->pb;
79  enum { PARSE_KEY, PARSE_VALUE, PARSE_FINISHED } state = PARSE_KEY;
80  char c;
81  AVBPrint bprint;
82  char * key = NULL;
83  char * value = NULL;
84  int i;
85 
87 
88  while (size-- > 0) {
89  c = avio_r8(pb);
90  switch(state) {
91  case PARSE_KEY:
92  if (c == '\0') {
93  state = PARSE_FINISHED;
94  } else if (c == '=') {
95  av_bprint_finalize(&bprint, &key);
97  state = PARSE_VALUE;
98  } else {
99  av_bprint_chars(&bprint, c, 1);
100  }
101  break;
102  case PARSE_VALUE:
103  if (c == '\0' || c == '\n') {
104  if (av_bprint_finalize(&bprint, &value) != 0) {
105  av_log(s, AV_LOG_ERROR, "Memory error while parsing AU metadata.\n");
106  } else {
108  for (i = 0; keys[i] != NULL && key != NULL; i++) {
109  if (av_strcasecmp(keys[i], key) == 0) {
110  av_dict_set(&(s->metadata), keys[i], value, AV_DICT_DONT_STRDUP_VAL);
111  av_freep(&key);
112  value = NULL;
113  }
114  }
115  }
116  av_freep(&key);
117  av_freep(&value);
118  state = (c == '\0') ? PARSE_FINISHED : PARSE_KEY;
119  } else {
120  av_bprint_chars(&bprint, c, 1);
121  }
122  break;
123  case PARSE_FINISHED:
124  break;
125  default:
126  /* should never happen */
127  av_assert0(0);
128  }
129  }
130  av_bprint_finalize(&bprint, NULL);
131  av_freep(&key);
132  return 0;
133 }
134 
135 #define BLOCK_SIZE 1024
136 
137 static int au_read_header(AVFormatContext *s)
138 {
139  int size, data_size = 0;
140  unsigned int tag;
141  AVIOContext *pb = s->pb;
142  unsigned int id, channels, rate;
143  int bps, ba = 0;
144  enum AVCodecID codec;
145  AVStream *st;
146 
147  tag = avio_rl32(pb);
148  if (tag != MKTAG('.', 's', 'n', 'd'))
149  return AVERROR_INVALIDDATA;
150  size = avio_rb32(pb); /* header size */
151  data_size = avio_rb32(pb); /* data size in bytes */
152 
153  if (data_size < 0 && data_size != AU_UNKNOWN_SIZE) {
154  av_log(s, AV_LOG_ERROR, "Invalid negative data size '%d' found\n", data_size);
155  return AVERROR_INVALIDDATA;
156  }
157 
158  id = avio_rb32(pb);
159  rate = avio_rb32(pb);
160  channels = avio_rb32(pb);
161 
162  if (size > 24) {
163  /* parse annotation field to get metadata */
164  au_read_annotation(s, size - 24);
165  }
166 
167  codec = ff_codec_get_id(codec_au_tags, id);
168 
169  if (codec == AV_CODEC_ID_NONE) {
170  avpriv_request_sample(s, "unknown or unsupported codec tag: %u", id);
171  return AVERROR_PATCHWELCOME;
172  }
173 
174  bps = av_get_bits_per_sample(codec);
175  if (codec == AV_CODEC_ID_ADPCM_G726LE) {
176  if (id == MKBETAG('7','2','6','2')) {
177  bps = 2;
178  } else {
179  const uint8_t bpcss[] = {4, 0, 3, 5};
180  av_assert0(id >= 23 && id < 23 + 4);
181  ba = bpcss[id - 23];
182  bps = bpcss[id - 23];
183  }
184  } else if (!bps) {
185  avpriv_request_sample(s, "Unknown bits per sample");
186  return AVERROR_PATCHWELCOME;
187  }
188 
189  if (channels == 0 || channels >= INT_MAX / (BLOCK_SIZE * bps >> 3)) {
190  av_log(s, AV_LOG_ERROR, "Invalid number of channels %u\n", channels);
191  return AVERROR_INVALIDDATA;
192  }
193 
194  if (rate == 0 || rate > INT_MAX) {
195  av_log(s, AV_LOG_ERROR, "Invalid sample rate: %u\n", rate);
196  return AVERROR_INVALIDDATA;
197  }
198 
199  st = avformat_new_stream(s, NULL);
200  if (!st)
201  return AVERROR(ENOMEM);
203  st->codecpar->codec_tag = id;
204  st->codecpar->codec_id = codec;
205  st->codecpar->channels = channels;
206  st->codecpar->sample_rate = rate;
208  st->codecpar->bit_rate = channels * rate * bps;
209  st->codecpar->block_align = ba ? ba : FFMAX(bps * st->codecpar->channels / 8, 1);
210  if (data_size != AU_UNKNOWN_SIZE)
211  st->duration = (((int64_t)data_size)<<3) / (st->codecpar->channels * (int64_t)bps);
212 
213  st->start_time = 0;
214  avpriv_set_pts_info(st, 64, 1, rate);
215 
216  return 0;
217 }
218 
220  .name = "au",
221  .long_name = NULL_IF_CONFIG_SMALL("Sun AU"),
222  .read_probe = au_probe,
223  .read_header = au_read_header,
224  .read_packet = ff_pcm_read_packet,
225  .read_seek = ff_pcm_read_seek,
226  .codec_tag = (const AVCodecTag* const []) { codec_au_tags, 0 },
227 };
228 
229 #endif /* CONFIG_AU_DEMUXER */
230 
231 #if CONFIG_AU_MUXER
232 
233 typedef struct AUContext {
234  uint32_t header_size;
235 } AUContext;
236 
237 #include "rawenc.h"
238 
239 static int au_get_annotations(AVFormatContext *s, char **buffer)
240 {
241  static const char * keys[] = {
242  "Title",
243  "Artist",
244  "Album",
245  "Track",
246  "Genre",
247  NULL };
248  int i;
249  int cnt = 0;
250  AVDictionary *m = s->metadata;
251  AVDictionaryEntry *t = NULL;
252  AVBPrint bprint;
253 
255 
256  for (i = 0; keys[i] != NULL; i++) {
257  t = av_dict_get(m, keys[i], NULL, 0);
258  if (t != NULL) {
259  if (cnt++)
260  av_bprint_chars(&bprint, '\n', 1);
261  av_bprint_append_data(&bprint, keys[i], strlen(keys[i]));
262  av_bprint_chars(&bprint, '=', 1);
263  av_bprint_append_data(&bprint, t->value, strlen(t->value));
264  }
265  }
266  /* pad with 0's */
267  av_bprint_append_data(&bprint, "\0\0\0\0\0\0\0\0", 8);
268  return av_bprint_finalize(&bprint, buffer);
269 }
270 
271 static int au_write_header(AVFormatContext *s)
272 {
273  int ret;
274  AUContext *au = s->priv_data;
275  AVIOContext *pb = s->pb;
276  AVCodecParameters *par = s->streams[0]->codecpar;
277  char *annotations = NULL;
278 
279  au->header_size = AU_DEFAULT_HEADER_SIZE;
280 
281  if (s->nb_streams != 1) {
282  av_log(s, AV_LOG_ERROR, "only one stream is supported\n");
283  return AVERROR(EINVAL);
284  }
285 
287  if (!par->codec_tag) {
288  av_log(s, AV_LOG_ERROR, "unsupported codec\n");
289  return AVERROR(EINVAL);
290  }
291 
292  if (av_dict_count(s->metadata) > 0) {
293  ret = au_get_annotations(s, &annotations);
294  if (ret < 0)
295  return ret;
296  if (annotations != NULL) {
297  au->header_size = (24 + strlen(annotations) + 8) & ~7;
298  if (au->header_size < AU_DEFAULT_HEADER_SIZE)
299  au->header_size = AU_DEFAULT_HEADER_SIZE;
300  }
301  }
302  ffio_wfourcc(pb, ".snd"); /* magic number */
303  avio_wb32(pb, au->header_size); /* header size */
304  avio_wb32(pb, AU_UNKNOWN_SIZE); /* data size */
305  avio_wb32(pb, par->codec_tag); /* codec ID */
306  avio_wb32(pb, par->sample_rate);
307  avio_wb32(pb, par->channels);
308  if (annotations != NULL) {
309  avio_write(pb, annotations, au->header_size - 24);
310  av_freep(&annotations);
311  } else {
312  avio_wb64(pb, 0); /* annotation field */
313  }
314 
315  return 0;
316 }
317 
318 static int au_write_trailer(AVFormatContext *s)
319 {
320  AVIOContext *pb = s->pb;
321  AUContext *au = s->priv_data;
322  int64_t file_size = avio_tell(pb);
323 
324  if ((s->pb->seekable & AVIO_SEEKABLE_NORMAL) && file_size < INT32_MAX) {
325  /* update file size */
326  avio_seek(pb, 8, SEEK_SET);
327  avio_wb32(pb, (uint32_t)(file_size - au->header_size));
328  avio_seek(pb, file_size, SEEK_SET);
329  }
330 
331  return 0;
332 }
333 
335  .name = "au",
336  .long_name = NULL_IF_CONFIG_SMALL("Sun AU"),
337  .mime_type = "audio/basic",
338  .extensions = "au",
339  .priv_data_size = sizeof(AUContext),
340  .audio_codec = AV_CODEC_ID_PCM_S16BE,
341  .video_codec = AV_CODEC_ID_NONE,
342  .write_header = au_write_header,
344  .write_trailer = au_write_trailer,
345  .codec_tag = (const AVCodecTag* const []) { codec_au_tags, 0 },
346  .flags = AVFMT_NOTIMESTAMPS,
347 };
348 
349 #endif /* CONFIG_AU_MUXER */
AV_BPRINT_SIZE_UNLIMITED
#define AV_BPRINT_SIZE_UNLIMITED
AV_CODEC_ID_PCM_F32BE
@ AV_CODEC_ID_PCM_F32BE
Definition: codec_id.h:321
codec_au_tags
static const AVCodecTag codec_au_tags[]
Definition: au.c:41
AVOutputFormat::name
const char * name
Definition: avformat.h:491
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
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4519
pcm.h
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
ffio_wfourcc
static av_always_inline void ffio_wfourcc(AVIOContext *pb, const uint8_t *s)
Definition: avio_internal.h:58
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:406
av_dict_count
int av_dict_count(const AVDictionary *m)
Get number of entries in dictionary.
Definition: dict.c:35
AVFMT_NOTIMESTAMPS
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:462
av_strcasecmp
int av_strcasecmp(const char *a, const char *b)
Locale-independent case-insensitive compare.
Definition: avstring.c:213
AV_CODEC_ID_ADPCM_G722
@ AV_CODEC_ID_ADPCM_G722
Definition: codec_id.h:368
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:64
AVDictionary
Definition: dict.c:30
av_bprint_append_data
void av_bprint_append_data(AVBPrint *buf, const char *data, unsigned size)
Append data to a print buffer.
Definition: bprint.c:158
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
AV_CODEC_ID_PCM_S16BE
@ AV_CODEC_ID_PCM_S16BE
Definition: codec_id.h:302
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:914
AV_DICT_DONT_STRDUP_VAL
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that's been allocated with av_malloc() or another memory allocation functio...
Definition: dict.h:74
AV_CODEC_ID_PCM_S8
@ AV_CODEC_ID_PCM_S8
Definition: codec_id.h:305
avassert.h
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:778
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
AVInputFormat
Definition: avformat.h:636
AVCodecTag
Definition: internal.h:42
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:40
s
#define s(width, name)
Definition: cbs_vp9.c:257
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:641
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
channels
channels
Definition: aptx.h:33
ff_raw_write_packet
int ff_raw_write_packet(AVFormatContext *s, AVPacket *pkt)
Definition: rawenc.c:29
AV_CODEC_ID_PCM_MULAW
@ AV_CODEC_ID_PCM_MULAW
Definition: codec_id.h:307
key
const char * key
Definition: hwcontext_opencl.c:168
AVFormatContext
Format I/O context.
Definition: avformat.h:1335
AV_CODEC_ID_PCM_ALAW
@ AV_CODEC_ID_PCM_ALAW
Definition: codec_id.h:308
internal.h
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1012
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
AU_DEFAULT_HEADER_SIZE
#define AU_DEFAULT_HEADER_SIZE
Definition: au.c:39
write_trailer
static int write_trailer(AVFormatContext *s1)
Definition: v4l2enc.c:98
ff_au_muxer
AVOutputFormat ff_au_muxer
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
c
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
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:170
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
av_get_bits_per_sample
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:1552
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:747
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
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:186
id
enum AVCodecID id
Definition: extract_extradata_bsf.c:332
ff_codec_get_id
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:3158
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4938
bps
unsigned bps
Definition: movenc.c:1533
size
int size
Definition: twinvq_data.h:11134
state
static struct @314 state
MKBETAG
#define MKBETAG(a, b, c, d)
Definition: common.h:407
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:213
avio_wb32
void avio_wb32(AVIOContext *s, unsigned int val)
Definition: aviobuf.c:375
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:616
rawenc.h
write_packet
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:701
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:47
AVOutputFormat
Definition: avformat.h:490
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
avio_internal.h
AVCodecParameters::block_align
int block_align
Audio only.
Definition: codec_par.h:177
AV_CODEC_ID_PCM_F64BE
@ AV_CODEC_ID_PCM_F64BE
Definition: codec_id.h:323
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
AV_CODEC_ID_PCM_S32BE
@ AV_CODEC_ID_PCM_S32BE
Definition: codec_id.h:310
uint8_t
uint8_t
Definition: audio_convert.c:194
ff_pcm_read_packet
int ff_pcm_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: pcm.c:29
tag
uint32_t tag
Definition: movenc.c:1532
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:865
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:241
ff_pcm_read_seek
int ff_pcm_read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: pcm.c:52
avformat.h
AV_CODEC_ID_ADPCM_G726LE
@ AV_CODEC_ID_ADPCM_G726LE
Definition: codec_id.h:376
AVIO_SEEKABLE_NORMAL
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
ff_codec_get_tag
unsigned int ff_codec_get_tag(const AVCodecTag *tags, enum AVCodecID id)
Definition: utils.c:3148
AU_UNKNOWN_SIZE
#define AU_UNKNOWN_SIZE
Definition: au.c:37
avio_wb64
void avio_wb64(AVIOContext *s, uint64_t val)
Definition: aviobuf.c:441
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:102
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:39
AVDictionaryEntry
Definition: dict.h:81
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:89
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
BLOCK_SIZE
#define BLOCK_SIZE
Definition: adx.h:53
AVDictionaryEntry::value
char * value
Definition: dict.h:83
AVStream::start_time
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base.
Definition: avformat.h:904
write_header
static void write_header(FFV1Context *f)
Definition: ffv1enc.c:346
AV_CODEC_ID_PCM_S24BE
@ AV_CODEC_ID_PCM_S24BE
Definition: codec_id.h:314
ff_au_demuxer
AVInputFormat ff_au_demuxer
av_bprint_chars
void av_bprint_chars(AVBPrint *buf, char c, unsigned n)
Append char c n times to a print buffer.
Definition: bprint.c:140