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];
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 {
68  BRSTMDemuxContext *b = s->priv_data;
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 {
84  BRSTMDemuxContext *b = s->priv_data;
85  if (b->little_endian)
86  return avio_rl16(s->pb);
87  else
88  return avio_rb16(s->pb);
89 }
90 
92 {
93  BRSTMDemuxContext *b = s->priv_data;
94  if (b->little_endian)
95  return avio_rl32(s->pb);
96  else
97  return avio_rb32(s->pb);
98 }
99 
101 {
102  BRSTMDemuxContext *b = s->priv_data;
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);
254  b->last_block_used_bytes = 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;
259  if (b->last_block_used_bytes > b->last_block_size)
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) {
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)) {
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) {
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) {
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))) {
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;
386  BRSTMDemuxContext *b = s->priv_data;
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];
466  BRSTMDemuxContext *b = s->priv_data;
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 };
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
sort_offsets
static int sort_offsets(const void *a, const void *b)
Definition: brstm.c:75
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:4509
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
read_seek
static int read_seek(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Definition: brstm.c:462
BRSTMDemuxContext::last_block_used_bytes
uint32_t last_block_used_bytes
Definition: brstm.c:37
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
ff_brstm_demuxer
AVInputFormat ff_brstm_demuxer
Definition: brstm.c:484
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:478
AVPacket::data
uint8_t * data
Definition: packet.h:369
AV_CODEC_ID_PCM_S16BE_PLANAR
@ AV_CODEC_ID_PCM_S16BE_PLANAR
Definition: codec_id.h:343
b
#define b
Definition: input.c:41
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:387
BRSTMDemuxContext::last_block_size
uint32_t last_block_size
Definition: brstm.c:38
BRSTMDemuxContext::last_block_samples
uint32_t last_block_samples
Definition: brstm.c:39
AV_CODEC_ID_PCM_S16LE_PLANAR
@ AV_CODEC_ID_PCM_S16LE_PLANAR
Definition: codec_id.h:331
AV_CODEC_ID_ADPCM_THP_LE
@ AV_CODEC_ID_ADPCM_THP_LE
Definition: codec_id.h:390
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
fail
#define fail()
Definition: checkasm.h:133
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
BRSTMCoeffOffset::offset
uint32_t offset
Definition: brstm.c:29
AVStream::duration
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:922
loop
static int loop
Definition: ffplay.c:341
avio_rl16
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:734
BRSTMDemuxContext::block_size
uint32_t block_size
Definition: brstm.c:33
BRSTMCoeffOffset
Definition: brstm.c:27
BRSTMDemuxContext::current_block
uint32_t current_block
Definition: brstm.c:35
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:781
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:194
AVInputFormat
Definition: avformat.h:640
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:257
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:99
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:645
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
s1
#define s1
Definition: regdef.h:38
AV_RL16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:94
read_close
static int read_close(AVFormatContext *s)
Definition: brstm.c:66
AVFormatContext
Format I/O context.
Definition: avformat.h:1232
internal.h
ff_update_cur_dts
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:1927
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1038
NULL
#define NULL
Definition: coverity.c:32
BRSTMDemuxContext::adpc
uint8_t * adpc
Definition: brstm.c:42
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
read_probe
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
convert_header.major
int major
Definition: convert_header.py:23
BRSTMDemuxContext::samples_per_block
uint32_t samples_per_block
Definition: brstm.c:36
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:170
s2
#define s2
Definition: regdef.h:39
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:750
BRSTMCoeffOffset::channel
uint8_t channel
Definition: brstm.c:28
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:117
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:4945
size
int size
Definition: twinvq_data.h:10344
FFDIFFSIGN
#define FFDIFFSIGN(x, y)
Comparator.
Definition: common.h:101
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:624
a
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:41
flag
#define flag(name)
Definition: cbs_av1.c:553
convert_header.minor
int minor
Definition: convert_header.py:26
bytestream_put_buffer
static av_always_inline void bytestream_put_buffer(uint8_t **b, const uint8_t *src, unsigned int size)
Definition: bytestream.h:372
i
int i
Definition: input.c:407
BRSTMDemuxContext::block_count
uint32_t block_count
Definition: brstm.c:34
BRSTMDemuxContext
Definition: brstm.c:32
BRSTMDemuxContext::table
uint8_t table[256 *32]
Definition: brstm.c:41
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
BRSTMDemuxContext::offsets
BRSTMCoeffOffset offsets[256]
Definition: brstm.c:43
av_always_inline
#define av_always_inline
Definition: attributes.h:49
uint8_t
uint8_t
Definition: audio_convert.c:194
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:237
av_rescale
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
BRSTMDemuxContext::data_start
uint32_t data_start
Definition: brstm.c:40
ff_bfstm_demuxer
AVInputFormat ff_bfstm_demuxer
Definition: brstm.c:496
av_get_packet
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:310
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:873
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:253
avio_rb16
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:766
pos
unsigned int pos
Definition: spdifenc.c:412
avformat.h
read32
static av_always_inline unsigned int read32(AVFormatContext *s)
Definition: brstm.c:91
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
probe
static int probe(const AVProbeData *p)
Definition: brstm.c:47
probe_bfstm
static int probe_bfstm(const AVProbeData *p)
Definition: brstm.c:56
BRSTMDemuxContext::little_endian
int little_endian
Definition: brstm.c:44
read_packet
static int read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: brstm.c:383
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:633
samples
Filter the word “frame” indicates either a video frame or a group of audio samples
Definition: filter_design.txt:8
AVPacket::stream_index
int stream_index
Definition: packet.h:371
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:337
av_dict_set_int
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
AV_CODEC_ID_ADPCM_THP
@ AV_CODEC_ID_ADPCM_THP
Definition: codec_id.h:371
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:39
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AVPacket
This structure stores compressed data.
Definition: packet.h:346
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AV_CODEC_ID_PCM_S8_PLANAR
@ AV_CODEC_ID_PCM_S8_PLANAR
Definition: codec_id.h:340
bytestream.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
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
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:912
read_header
static int read_header(AVFormatContext *s)
Definition: brstm.c:100
read16
static av_always_inline unsigned int read16(AVFormatContext *s)
Definition: brstm.c:82
bom
static const char * bom
Definition: microdvddec.c:77
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:364