FFmpeg
brstm.c
Go to the documentation of this file.
1 /*
2  * BRSTM demuxer
3  * Copyright (c) 2012 Paul B Mahol
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 #include "libavutil/intreadwrite.h"
23 #include "libavcodec/bytestream.h"
24 #include "avformat.h"
25 #include "internal.h"
26 
27 typedef struct BRSTMCoeffOffset {
29  uint32_t offset;
31 
32 typedef struct BRSTMDemuxContext {
33  uint32_t block_size;
34  uint32_t block_count;
35  uint32_t current_block;
38  uint32_t last_block_size;
40  uint32_t data_start;
41  uint8_t table[256 * 32];
43  BRSTMCoeffOffset offsets[256];
46 
47 static int probe(const AVProbeData *p)
48 {
49  if (AV_RL32(p->buf) == MKTAG('R','S','T','M') &&
50  (AV_RL16(p->buf + 4) == 0xFFFE ||
51  AV_RL16(p->buf + 4) == 0xFEFF))
52  return AVPROBE_SCORE_MAX / 3 * 2;
53  return 0;
54 }
55 
56 static int probe_bfstm(const AVProbeData *p)
57 {
58  if ((AV_RL32(p->buf) == MKTAG('F','S','T','M') ||
59  AV_RL32(p->buf) == MKTAG('C','S','T','M')) &&
60  (AV_RL16(p->buf + 4) == 0xFFFE ||
61  AV_RL16(p->buf + 4) == 0xFEFF))
62  return AVPROBE_SCORE_MAX / 3 * 2;
63  return 0;
64 }
65 
67 {
69 
70  av_freep(&b->adpc);
71 
72  return 0;
73 }
74 
75 static int sort_offsets(const void *a, const void *b)
76 {
77  const BRSTMCoeffOffset *s1 = a;
78  const BRSTMCoeffOffset *s2 = b;
79  return FFDIFFSIGN(s1->offset, s2->offset);
80 }
81 
83 {
85  if (b->little_endian)
86  return avio_rl16(s->pb);
87  else
88  return avio_rb16(s->pb);
89 }
90 
92 {
94  if (b->little_endian)
95  return avio_rl32(s->pb);
96  else
97  return avio_rb32(s->pb);
98 }
99 
101 {
103  int bom, major, minor, codec, chunk;
104  int64_t h1offset, pos, toffset;
105  uint32_t size, asize, start = 0;
106  AVStream *st;
107  int ret = AVERROR_EOF;
108  int loop = 0;
109  int bfstm = !strcmp("bfstm", s->iformat->name);
110 
111  st = avformat_new_stream(s, NULL);
112  if (!st)
113  return AVERROR(ENOMEM);
115 
116  avio_skip(s->pb, 4);
117 
118  bom = avio_rb16(s->pb);
119  if (bom != 0xFEFF && bom != 0xFFFE) {
120  av_log(s, AV_LOG_ERROR, "invalid byte order: %X\n", bom);
121  return AVERROR_INVALIDDATA;
122  }
123 
124  if (bom == 0xFFFE)
125  b->little_endian = 1;
126 
127  if (!bfstm) {
128  major = avio_r8(s->pb);
129  minor = avio_r8(s->pb);
130  avio_skip(s->pb, 4); // size of file
131  size = read16(s);
132  if (size < 14)
133  return AVERROR_INVALIDDATA;
134 
135  avio_skip(s->pb, size - 14);
136  pos = avio_tell(s->pb);
137  if (avio_rl32(s->pb) != MKTAG('H','E','A','D'))
138  return AVERROR_INVALIDDATA;
139  } else {
140  uint32_t info_offset = 0;
141  uint16_t section_count, header_size, i;
142 
143  header_size = read16(s); // 6
144 
145  avio_skip(s->pb, 4); // Unknown constant 0x00030000
146  avio_skip(s->pb, 4); // size of file
147  section_count = read16(s);
148  avio_skip(s->pb, 2); // padding
149  for (i = 0; avio_tell(s->pb) < header_size
150  && !(start && info_offset)
151  && i < section_count; i++) {
152  uint16_t flag = read16(s);
153  avio_skip(s->pb, 2);
154  switch (flag) {
155  case 0x4000:
156  info_offset = read32(s);
157  /*info_size =*/ read32(s);
158  break;
159  case 0x4001:
160  avio_skip(s->pb, 4); // seek offset
161  avio_skip(s->pb, 4); // seek size
162  break;
163  case 0x4002:
164  start = read32(s) + 8;
165  avio_skip(s->pb, 4); //data_size = read32(s);
166  break;
167  case 0x4003:
168  avio_skip(s->pb, 4); // REGN offset
169  avio_skip(s->pb, 4); // REGN size
170  break;
171  }
172  }
173 
174  if (!info_offset || !start)
175  return AVERROR_INVALIDDATA;
176 
177  avio_skip(s->pb, info_offset - avio_tell(s->pb));
178  pos = avio_tell(s->pb);
179  if (avio_rl32(s->pb) != MKTAG('I','N','F','O'))
180  return AVERROR_INVALIDDATA;
181  }
182 
183  size = read32(s);
184  if (size < 40)
185  return AVERROR_INVALIDDATA;
186  avio_skip(s->pb, 4); // unknown
187  h1offset = read32(s);
188  if (h1offset > size)
189  return AVERROR_INVALIDDATA;
190  avio_skip(s->pb, 12);
191  toffset = read32(s) + 16LL;
192  if (toffset > size)
193  return AVERROR_INVALIDDATA;
194 
195  avio_skip(s->pb, pos + h1offset + 8 - avio_tell(s->pb));
196  codec = avio_r8(s->pb);
197 
198  switch (codec) {
199  case 0: codec = AV_CODEC_ID_PCM_S8_PLANAR; break;
200  case 1: codec = b->little_endian ?
203  case 2: codec = b->little_endian ?
205  AV_CODEC_ID_ADPCM_THP; break;
206  default:
207  avpriv_request_sample(s, "codec %d", codec);
208  return AVERROR_PATCHWELCOME;
209  }
210 
211  loop = avio_r8(s->pb); // loop flag
212  st->codecpar->codec_id = codec;
213  st->codecpar->channels = avio_r8(s->pb);
214  if (!st->codecpar->channels)
215  return AVERROR_INVALIDDATA;
216 
217  avio_skip(s->pb, 1); // padding
218 
219  st->codecpar->sample_rate = bfstm ? read32(s) : read16(s);
220  if (st->codecpar->sample_rate <= 0)
221  return AVERROR_INVALIDDATA;
222 
223  if (!bfstm)
224  avio_skip(s->pb, 2); // padding
225 
226  if (loop) {
227  if (av_dict_set_int(&s->metadata, "loop_start",
229  st->codecpar->sample_rate),
230  0) < 0)
231  return AVERROR(ENOMEM);
232  } else {
233  avio_skip(s->pb, 4);
234  }
235 
236  st->start_time = 0;
237  st->duration = read32(s);
238  avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
239 
240  if (!bfstm)
241  start = read32(s);
242  b->current_block = 0;
243  b->block_count = read32(s);
244  if (b->block_count > UINT16_MAX) {
245  av_log(s, AV_LOG_WARNING, "too many blocks: %"PRIu32"\n", b->block_count);
246  return AVERROR_INVALIDDATA;
247  }
248 
249  b->block_size = read32(s);
250  if (b->block_size > UINT32_MAX / st->codecpar->channels)
251  return AVERROR_INVALIDDATA;
252 
253  b->samples_per_block = read32(s);
255  b->last_block_samples = read32(s);
256  b->last_block_size = read32(s);
257  if (b->last_block_size > UINT32_MAX / st->codecpar->channels)
258  return AVERROR_INVALIDDATA;
260  return AVERROR_INVALIDDATA;
261 
262 
263  if (codec == AV_CODEC_ID_ADPCM_THP || codec == AV_CODEC_ID_ADPCM_THP_LE) {
264  int ch;
265 
266  avio_skip(s->pb, pos + toffset - avio_tell(s->pb));
267  if (!bfstm)
268  toffset = read32(s) + 16LL;
269  else
270  toffset = toffset + read32(s) + st->codecpar->channels * 8 - 8;
271  if (toffset > size)
272  return AVERROR_INVALIDDATA;
273 
274  if (!bfstm) {
275  avio_skip(s->pb, pos + toffset - avio_tell(s->pb) - 8LL * (st->codecpar->channels + 1));
276  for (ch = 0; ch < st->codecpar->channels; ch++) {
277  avio_skip(s->pb, 4);
278  b->offsets[ch].channel = ch;
279  b->offsets[ch].offset = read32(s);
280  }
281 
282  qsort(b->offsets, st->codecpar->channels, sizeof(*b->offsets), sort_offsets);
283  }
284 
285  avio_skip(s->pb, pos + toffset - avio_tell(s->pb));
286 
287  for (ch = 0; ch < st->codecpar->channels; ch++) {
288  if (!bfstm)
289  avio_skip(s->pb, pos + 16LL + b->offsets[ch].offset - avio_tell(s->pb));
290 
291  if (avio_read(s->pb, b->table + ch * 32, 32) != 32) {
292  ret = AVERROR_INVALIDDATA;
293  goto fail;
294  }
295 
296  if (bfstm)
297  avio_skip(s->pb, 14);
298  }
299  }
300 
301  if (size < (avio_tell(s->pb) - pos)) {
302  ret = AVERROR_INVALIDDATA;
303  goto fail;
304  }
305 
306  avio_skip(s->pb, size - (avio_tell(s->pb) - pos));
307 
308  while (!avio_feof(s->pb)) {
309  chunk = avio_rl32(s->pb);
310  size = read32(s);
311  if (size < 8) {
312  ret = AVERROR_INVALIDDATA;
313  goto fail;
314  }
315  size -= 8;
316  switch (chunk) {
317  case MKTAG('S','E','E','K'):
318  case MKTAG('A','D','P','C'):
319  if (codec != AV_CODEC_ID_ADPCM_THP &&
320  codec != AV_CODEC_ID_ADPCM_THP_LE)
321  goto skip;
322 
323  asize = b->block_count * st->codecpar->channels * 4;
324  if (size < asize) {
325  ret = AVERROR_INVALIDDATA;
326  goto fail;
327  }
328  if (b->adpc) {
329  av_log(s, AV_LOG_WARNING, "skipping additional ADPC chunk\n");
330  goto skip;
331  } else {
332  b->adpc = av_mallocz(asize);
333  if (!b->adpc) {
334  ret = AVERROR(ENOMEM);
335  goto fail;
336  }
337  if (bfstm && codec != AV_CODEC_ID_ADPCM_THP_LE) {
338  // Big-endian BFSTMs have little-endian SEEK tables
339  // for some strange reason.
340  int i;
341  for (i = 0; i < asize; i += 2) {
342  b->adpc[i+1] = avio_r8(s->pb);
343  b->adpc[i] = avio_r8(s->pb);
344  }
345  } else {
346  avio_read(s->pb, b->adpc, asize);
347  }
348  avio_skip(s->pb, size - asize);
349  }
350  break;
351  case MKTAG('D','A','T','A'):
352  if ((start < avio_tell(s->pb)) ||
353  (!b->adpc && (codec == AV_CODEC_ID_ADPCM_THP ||
354  codec == AV_CODEC_ID_ADPCM_THP_LE))) {
355  ret = AVERROR_INVALIDDATA;
356  goto fail;
357  }
358  avio_skip(s->pb, start - avio_tell(s->pb));
359 
360  if (bfstm && (codec == AV_CODEC_ID_ADPCM_THP ||
361  codec == AV_CODEC_ID_ADPCM_THP_LE))
362  avio_skip(s->pb, 24);
363 
364  b->data_start = avio_tell(s->pb);
365 
366  if (!bfstm && (major != 1 || minor))
367  avpriv_request_sample(s, "Version %d.%d", major, minor);
368 
369  return 0;
370  default:
371  av_log(s, AV_LOG_WARNING, "skipping unknown chunk: %X\n", chunk);
372 skip:
373  avio_skip(s->pb, size);
374  }
375  }
376 
377 fail:
378  read_close(s);
379 
380  return ret;
381 }
382 
384 {
385  AVCodecParameters *par = s->streams[0]->codecpar;
387  uint32_t samples, size, skip = 0;
388  int ret, i;
389 
390  if (avio_feof(s->pb))
391  return AVERROR_EOF;
392  b->current_block++;
393  if (b->current_block == b->block_count) {
394  size = b->last_block_used_bytes;
395  samples = b->last_block_samples;
396  skip = b->last_block_size - b->last_block_used_bytes;
397 
398  if (samples < size * 14 / 8) {
399  uint32_t adjusted_size = samples / 14 * 8;
400  if (samples % 14)
401  adjusted_size += (samples % 14 + 1) / 2 + 1;
402 
403  skip += size - adjusted_size;
404  size = adjusted_size;
405  }
406  } else if (b->current_block < b->block_count) {
407  size = b->block_size;
408  samples = b->samples_per_block;
409  } else {
410  return AVERROR_EOF;
411  }
412 
413  if (par->codec_id == AV_CODEC_ID_ADPCM_THP ||
415  uint8_t *dst;
416 
417  if (!b->adpc) {
418  av_log(s, AV_LOG_ERROR, "adpcm_thp requires ADPC chunk, but none was found.\n");
419  return AVERROR_INVALIDDATA;
420  }
421 
422  if (size > (INT_MAX - 32 - 4) ||
423  (32 + 4 + size) > (INT_MAX / par->channels) ||
424  (32 + 4 + size) * par->channels > INT_MAX - 8)
425  return AVERROR_INVALIDDATA;
426  if ((ret = av_new_packet(pkt, 8 + (32 + 4 + size) * par->channels)) < 0)
427  return ret;
428  dst = pkt->data;
429  if (par->codec_id == AV_CODEC_ID_ADPCM_THP_LE) {
430  bytestream_put_le32(&dst, size * par->channels);
431  bytestream_put_le32(&dst, samples);
432  } else {
433  bytestream_put_be32(&dst, size * par->channels);
434  bytestream_put_be32(&dst, samples);
435  }
436  bytestream_put_buffer(&dst, b->table, 32 * par->channels);
437  bytestream_put_buffer(&dst, b->adpc + 4 * par->channels *
438  (b->current_block - 1), 4 * par->channels);
439 
440  for (i = 0; i < par->channels; i++) {
441  ret = avio_read(s->pb, dst, size);
442  dst += size;
443  avio_skip(s->pb, skip);
444  if (ret != size) {
445  return AVERROR(EIO);
446  }
447  }
448  pkt->duration = samples;
449  } else {
450  size *= par->channels;
451  ret = av_get_packet(s->pb, pkt, size);
452  }
453 
454  pkt->stream_index = 0;
455 
456  if (ret != size)
457  ret = AVERROR(EIO);
458 
459  return ret;
460 }
461 
462 static int read_seek(AVFormatContext *s, int stream_index,
463  int64_t timestamp, int flags)
464 {
465  AVStream *st = s->streams[stream_index];
467  int64_t ret = 0;
468 
469  if (timestamp < 0)
470  timestamp = 0;
471  timestamp /= b->samples_per_block;
472  if (timestamp >= b->block_count)
473  timestamp = b->block_count - 1;
474  ret = avio_seek(s->pb, b->data_start + timestamp * b->block_size *
475  st->codecpar->channels, SEEK_SET);
476  if (ret < 0)
477  return ret;
478 
479  b->current_block = timestamp;
480  ff_update_cur_dts(s, st, timestamp * b->samples_per_block);
481  return 0;
482 }
483 
485  .name = "brstm",
486  .long_name = NULL_IF_CONFIG_SMALL("BRSTM (Binary Revolution Stream)"),
487  .priv_data_size = sizeof(BRSTMDemuxContext),
488  .read_probe = probe,
492  .read_seek = read_seek,
493  .extensions = "brstm",
494 };
495 
497  .name = "bfstm",
498  .long_name = NULL_IF_CONFIG_SMALL("BFSTM (Binary Cafe Stream)"),
499  .priv_data_size = sizeof(BRSTMDemuxContext),
504  .read_seek = read_seek,
505  .extensions = "bfstm,bcstm",
506 };
#define NULL
Definition: coverity.c:32
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
uint32_t block_count
Definition: brstm.c:34
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
uint32_t data_start
Definition: brstm.c:40
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:4871
#define avpriv_request_sample(...)
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AVInputFormat ff_bfstm_demuxer
Definition: brstm.c:496
static int probe_bfstm(const AVProbeData *p)
Definition: brstm.c:56
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:253
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
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:341
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
static AVPacket pkt
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:770
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:91
static av_always_inline unsigned int read16(AVFormatContext *s)
Definition: brstm.c:82
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
Format I/O context.
Definition: avformat.h:1239
uint32_t offset
Definition: brstm.c:29
void ff_update_cur_dts(AVFormatContext *s, AVStream *ref_st, int64_t timestamp)
Update cur_dts of all streams based on the given timestamp and AVStream.
Definition: utils.c:1898
BRSTMCoeffOffset offsets[256]
Definition: brstm.c:43
uint8_t
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:785
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:381
uint32_t block_size
Definition: brstm.c:33
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4453
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1307
uint8_t * data
Definition: packet.h:363
uint32_t samples_per_block
Definition: brstm.c:36
#define AVERROR_EOF
End of file.
Definition: error.h:55
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
Allocate and read the payload of a packet and initialize its fields with default values.
Definition: utils.c:305
ptrdiff_t size
Definition: opengl_enc.c:100
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
static const char * bom
Definition: microdvddec.c:77
#define av_log(a,...)
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:637
static const uint16_t table[]
Definition: prosumer.c:206
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:88
uint32_t last_block_samples
Definition: brstm.c:39
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
AVDictionary * metadata
Metadata that applies to the whole file.
Definition: avformat.h:1479
#define s2
Definition: regdef.h:39
uint32_t last_block_used_bytes
Definition: brstm.c:37
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:754
uint8_t channel
Definition: brstm.c:28
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
ff_const59 struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1251
unsigned int pos
Definition: spdifenc.c:410
uint8_t table[256 *32]
Definition: brstm.c:41
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
#define fail()
Definition: checkasm.h:123
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:628
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
#define FFDIFFSIGN(x, y)
Comparator.
Definition: common.h:92
#define b
Definition: input.c:41
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
uint32_t current_block
Definition: brstm.c:35
static int read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: brstm.c:462
#define s(width, name)
Definition: cbs_vp9.c:257
Stream structure.
Definition: avformat.h:880
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
uint8_t * adpc
Definition: brstm.c:42
AVIOContext * pb
I/O context.
Definition: avformat.h:1281
static int loop
Definition: ffplay.c:341
int little_endian
Definition: brstm.c:44
#define s1
Definition: regdef.h:38
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
static int sort_offsets(const void *a, const void *b)
Definition: brstm.c:75
#define flags(name, subs,...)
Definition: cbs_av1.c:560
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
AVInputFormat ff_brstm_demuxer
Definition: brstm.c:484
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:929
int sample_rate
Audio only.
Definition: codec_par.h:170
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
static int probe(const AVProbeData *p)
Definition: brstm.c:47
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:738
Main libavformat public API header.
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base...
Definition: avformat.h:919
#define flag(name)
Definition: cbs_av1.c:552
int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags)
Convenience wrapper for av_dict_set that converts the value to a string and stores it...
Definition: dict.c:147
static int read_header(AVFormatContext *s)
Definition: brstm.c:100
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
Definition: bytestream.h:372
void * priv_data
Format private data.
Definition: avformat.h:1267
static av_always_inline unsigned int read32(AVFormatContext *s)
Definition: brstm.c:91
int channels
Audio only.
Definition: codec_par.h:166
static int read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: brstm.c:383
Filter the word “frame” indicates either a video frame or a group of audio samples
#define av_freep(p)
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:652
#define av_always_inline
Definition: attributes.h:45
static int read_close(AVFormatContext *s)
Definition: brstm.c:66
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1045
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:368
int stream_index
Definition: packet.h:365
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
#define MKTAG(a, b, c, d)
Definition: common.h:405
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:91
This structure stores compressed data.
Definition: packet.h:340
uint32_t last_block_size
Definition: brstm.c:38
int i
Definition: input.c:407