FFmpeg
riffdec.c
Go to the documentation of this file.
1 /*
2  * RIFF demuxing functions and data
3  * Copyright (c) 2000 Fabrice Bellard
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/avassert.h"
23 #include "libavutil/dict.h"
24 #include "libavutil/error.h"
25 #include "libavutil/intreadwrite.h"
26 #include "libavutil/log.h"
27 #include "libavutil/mem.h"
28 #include "avformat.h"
29 #include "avio_internal.h"
30 #include "demux.h"
31 #include "riff.h"
32 
34 {
35  int ret;
36  av_assert0(sizeof(*g) == 16); //compiler will optimize this out
37  ret = ffio_read_size(s, *g, sizeof(*g));
38  if (ret < 0) {
39  memset(*g, 0, sizeof(*g));
40  return ret;
41  }
42  return 0;
43 }
44 
46 {
47  int i;
48  for (i = 0; guids[i].id != AV_CODEC_ID_NONE; i++)
49  if (!ff_guidcmp(guids[i].guid, guid))
50  return guids[i].id;
51  return AV_CODEC_ID_NONE;
52 }
53 
54 /* We could be given one of the three possible structures here:
55  * WAVEFORMAT, PCMWAVEFORMAT or WAVEFORMATEX. Each structure
56  * is an expansion of the previous one with the fields added
57  * at the bottom. PCMWAVEFORMAT adds 'WORD wBitsPerSample' and
58  * WAVEFORMATEX adds 'WORD cbSize' and basically makes itself
59  * an openended structure.
60  */
61 
62 static void parse_waveformatex(void *logctx, AVIOContext *pb, AVCodecParameters *par)
63 {
64  ff_asf_guid subformat;
65  int bps;
66  uint64_t mask;
67 
68  bps = avio_rl16(pb);
69  if (bps)
71 
72  mask = avio_rl32(pb); /* dwChannelMask */
74 
75  ff_get_guid(pb, &subformat);
76  if (!memcmp(subformat + 4,
77  (const uint8_t[]){ FF_AMBISONIC_BASE_GUID }, 12) ||
78  !memcmp(subformat + 4,
79  (const uint8_t[]){ FF_BROKEN_BASE_GUID }, 12) ||
80  !memcmp(subformat + 4,
81  (const uint8_t[]){ FF_MEDIASUBTYPE_BASE_GUID }, 12)) {
82  par->codec_tag = AV_RL32(subformat);
85  } else {
87  if (!par->codec_id)
88  av_log(logctx, AV_LOG_WARNING,
89  "unknown subformat:"FF_PRI_GUID"\n",
90  FF_ARG_GUID(subformat));
91  }
92 }
93 
94 /* "big_endian" values are needed for RIFX file format */
95 int ff_get_wav_header(void *logctx, AVIOContext *pb,
96  AVCodecParameters *par, int size, int big_endian)
97 {
98  int id, channels = 0, ret;
99  uint64_t bitrate = 0;
100 
101  if (size < 14) {
102  avpriv_request_sample(logctx, "wav header size < 14");
103  return AVERROR_INVALIDDATA;
104  }
105 
107 
109  if (!big_endian) {
110  id = avio_rl16(pb);
111  if (id != 0x0165) {
112  channels = avio_rl16(pb);
113  par->sample_rate = avio_rl32(pb);
114  bitrate = avio_rl32(pb) * 8LL;
115  par->block_align = avio_rl16(pb);
116  }
117  } else {
118  id = avio_rb16(pb);
119  channels = avio_rb16(pb);
120  par->sample_rate = avio_rb32(pb);
121  bitrate = avio_rb32(pb) * 8LL;
122  par->block_align = avio_rb16(pb);
123  }
124  if (size == 14) { /* We're dealing with plain vanilla WAVEFORMAT */
125  par->bits_per_coded_sample = 8;
126  } else {
127  if (!big_endian) {
128  par->bits_per_coded_sample = avio_rl16(pb);
129  } else {
130  par->bits_per_coded_sample = avio_rb16(pb);
131  }
132  }
133  if (id == 0xFFFE) {
134  par->codec_tag = 0;
135  } else {
136  par->codec_tag = id;
137  par->codec_id = ff_wav_codec_get_id(id,
138  par->bits_per_coded_sample);
139  }
140  if (size >= 18 && id != 0x0165) { /* We're obviously dealing with WAVEFORMATEX */
141  int cbSize = avio_rl16(pb); /* cbSize */
142  if (big_endian) {
143  avpriv_report_missing_feature(logctx, "WAVEFORMATEX support for RIFX files");
144  return AVERROR_PATCHWELCOME;
145  }
146  size -= 18;
147  cbSize = FFMIN(size, cbSize);
148  if (cbSize >= 22 && id == 0xfffe) { /* WAVEFORMATEXTENSIBLE */
149  parse_waveformatex(logctx, pb, par);
150  cbSize -= 22;
151  size -= 22;
152  }
153  if (cbSize > 0) {
154  ret = ff_get_extradata(logctx, par, pb, cbSize);
155  if (ret < 0)
156  return ret;
157  size -= cbSize;
158  }
159 
160  /* It is possible for the chunk to contain garbage at the end */
161  if (size > 0)
162  avio_skip(pb, size);
163  } else if (id == 0x0165 && size >= 32) {
164  int nb_streams, i;
165 
166  size -= 4;
167  ret = ff_get_extradata(logctx, par, pb, size);
168  if (ret < 0)
169  return ret;
170  nb_streams = AV_RL16(par->extradata + 4);
171  par->sample_rate = AV_RL32(par->extradata + 12);
172  channels = 0;
173  bitrate = 0;
174  if (size < 8 + nb_streams * 20)
175  return AVERROR_INVALIDDATA;
176  for (i = 0; i < nb_streams; i++)
177  channels += par->extradata[8 + i * 20 + 17];
178  }
179 
180  par->bit_rate = bitrate;
181 
182  if (par->sample_rate <= 0) {
183  av_log(logctx, AV_LOG_ERROR,
184  "Invalid sample rate: %d\n", par->sample_rate);
185  return AVERROR_INVALIDDATA;
186  }
187  if (par->codec_id == AV_CODEC_ID_AAC_LATM) {
188  /* Channels and sample_rate values are those prior to applying SBR
189  * and/or PS. */
190  channels = 0;
191  par->sample_rate = 0;
192  }
193  /* override bits_per_coded_sample for G.726 */
194  if (par->codec_id == AV_CODEC_ID_ADPCM_G726 && par->sample_rate)
195  par->bits_per_coded_sample = par->bit_rate / par->sample_rate;
196 
197  /* ignore WAVEFORMATEXTENSIBLE layout if different from channel count */
198  if (channels != par->ch_layout.nb_channels) {
202  }
203 
204  return 0;
205 }
206 
207 enum AVCodecID ff_wav_codec_get_id(unsigned int tag, int bps)
208 {
209  enum AVCodecID id;
211  if (id <= 0)
212  return id;
213 
214  if (id == AV_CODEC_ID_PCM_S16LE)
215  id = ff_get_pcm_codec_id(bps, 0, 0, ~1);
216  else if (id == AV_CODEC_ID_PCM_F32LE)
217  id = ff_get_pcm_codec_id(bps, 1, 0, 0);
218 
219  if (id == AV_CODEC_ID_ADPCM_IMA_WAV && bps == 8)
221  return id;
222 }
223 
224 int ff_get_bmp_header(AVIOContext *pb, AVStream *st, uint32_t *size)
225 {
226  int tag1;
227  uint32_t size_ = avio_rl32(pb);
228  if (size)
229  *size = size_;
230  st->codecpar->width = avio_rl32(pb);
231  st->codecpar->height = (int32_t)avio_rl32(pb);
232  avio_rl16(pb); /* planes */
233  st->codecpar->bits_per_coded_sample = avio_rl16(pb); /* depth */
234  tag1 = avio_rl32(pb);
235  avio_rl32(pb); /* ImageSize */
236  avio_rl32(pb); /* XPelsPerMeter */
237  avio_rl32(pb); /* YPelsPerMeter */
238  avio_rl32(pb); /* ClrUsed */
239  avio_rl32(pb); /* ClrImportant */
240  return tag1;
241 }
242 
244 {
245  int64_t start, end, cur;
246  AVIOContext *pb = s->pb;
247 
248  start = avio_tell(pb);
249  end = start + size;
250 
251  while ((cur = avio_tell(pb)) >= 0 &&
252  cur <= end - 8 /* = tag + size */) {
253  uint32_t chunk_code;
254  int64_t chunk_size;
255  char key[5] = { 0 };
256  char *value;
257 
258  chunk_code = avio_rl32(pb);
259  chunk_size = avio_rl32(pb);
260  if (avio_feof(pb)) {
261  if (chunk_code || chunk_size) {
262  av_log(s, AV_LOG_WARNING, "INFO subchunk truncated\n");
263  return AVERROR_INVALIDDATA;
264  }
265  return AVERROR_EOF;
266  }
267  if (chunk_size > end ||
268  end - chunk_size < cur ||
269  chunk_size == UINT_MAX) {
270  avio_seek(pb, -9, SEEK_CUR);
271  chunk_code = avio_rl32(pb);
272  chunk_size = avio_rl32(pb);
273  if (chunk_size > end || end - chunk_size < cur || chunk_size == UINT_MAX) {
274  av_log(s, AV_LOG_WARNING, "too big INFO subchunk\n");
275  return AVERROR_INVALIDDATA;
276  }
277  }
278 
279  chunk_size += (chunk_size & 1);
280 
281  if (!chunk_code) {
282  if (chunk_size)
283  avio_skip(pb, chunk_size);
284  else if (pb->eof_reached) {
285  av_log(s, AV_LOG_WARNING, "truncated file\n");
286  return AVERROR_EOF;
287  }
288  continue;
289  }
290 
291  value = av_mallocz(chunk_size + 1);
292  if (!value) {
294  "out of memory, unable to read INFO tag\n");
295  return AVERROR(ENOMEM);
296  }
297 
298  AV_WL32(key, chunk_code);
299  // Work around VC++ 2015 Update 1 code-gen bug:
300  // https://connect.microsoft.com/VisualStudio/feedback/details/2291638
301  key[4] = 0;
302 
303  if (avio_read(pb, value, chunk_size) != chunk_size) {
305  "premature end of file while reading INFO tag\n");
306  }
307 
309  }
310 
311  return 0;
312 }
AV_CODEC_ID_PCM_S16LE
@ AV_CODEC_ID_PCM_S16LE
Definition: codec_id.h:328
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
ff_get_pcm_codec_id
enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags)
Select a PCM codec based on the given parameters.
Definition: utils.c:144
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:69
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
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:424
FF_AMBISONIC_BASE_GUID
#define FF_AMBISONIC_BASE_GUID
Definition: riff.h:117
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
ff_wav_codec_get_id
enum AVCodecID ff_wav_codec_get_id(unsigned int tag, int bps)
Definition: riffdec.c:207
ff_get_guid
int ff_get_guid(AVIOContext *s, ff_asf_guid *g)
Definition: riffdec.c:33
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
ff_get_bmp_header
int ff_get_bmp_header(AVIOContext *pb, AVStream *st, uint32_t *size)
Read BITMAPINFOHEADER structure and set AVStream codec width, height and bits_per_encoded_sample fiel...
Definition: riffdec.c:224
ff_codec_wav_tags
const AVCodecTag ff_codec_wav_tags[]
Definition: riff.c:519
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:59
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:308
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:313
ff_get_wav_header
int ff_get_wav_header(void *logctx, AVIOContext *pb, AVCodecParameters *par, int size, int big_endian)
Definition: riffdec.c:95
ff_get_extradata
int ff_get_extradata(void *logctx, AVCodecParameters *par, AVIOContext *pb, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0 and f...
Definition: demux_utils.c:335
ff_guidcmp
static av_always_inline int ff_guidcmp(const void *g1, const void *g2)
Definition: riff.h:122
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:494
avio_rl16
unsigned int avio_rl16(AVIOContext *s)
Definition: aviobuf.c:714
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:79
avassert.h
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:761
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
mask
static const uint16_t mask[17]
Definition: lzw.c:38
FF_ARG_GUID
#define FF_ARG_GUID(g)
Definition: riff.h:109
AV_CODEC_ID_ADPCM_G726
@ AV_CODEC_ID_ADPCM_G726
Definition: codec_id.h:378
intreadwrite.h
s
#define s(width, name)
Definition: cbs_vp9.c:198
bitrate
int64_t bitrate
Definition: av1_levels.c:47
g
const char * g
Definition: vf_curves.c:128
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
AV_CHANNEL_ORDER_UNSPEC
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
Definition: channel_layout.h:112
av_channel_layout_from_mask
int av_channel_layout_from_mask(AVChannelLayout *channel_layout, uint64_t mask)
Initialize a native channel layout from a bitmask indicating which channels are present.
Definition: channel_layout.c:243
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
channels
channels
Definition: aptx.h:31
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
nb_streams
static int nb_streams
Definition: ffprobe.c:384
key
const char * key
Definition: hwcontext_opencl.c:189
AVFormatContext
Format I/O context.
Definition: avformat.h:1255
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:766
ff_asf_guid
uint8_t ff_asf_guid[16]
Definition: riff.h:96
parse_waveformatex
static void parse_waveformatex(void *logctx, AVIOContext *pb, AVCodecParameters *par)
Definition: riffdec.c:62
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
ff_codec_guid_get_id
enum AVCodecID ff_codec_guid_get_id(const AVCodecGuid *guids, ff_asf_guid guid)
Definition: riffdec.c:45
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:184
error.h
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:49
AV_CODEC_ID_ADPCM_ZORK
@ AV_CODEC_ID_ADPCM_ZORK
Definition: codec_id.h:411
avio_rl32
unsigned int avio_rl32(AVIOContext *s)
Definition: aviobuf.c:730
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
ff_codec_get_id
enum AVCodecID ff_codec_get_id(const AVCodecTag *tags, unsigned int tag)
Definition: utils.c:133
AVCodecGuid::id
enum AVCodecID id
Definition: riff.h:99
bps
unsigned bps
Definition: movenc.c:1789
size
int size
Definition: twinvq_data.h:10344
AVCodecGuid
Definition: riff.h:98
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
log.h
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
avio_internal.h
AVCodecParameters::height
int height
Definition: codec_par.h:135
AVCodecParameters::block_align
int block_align
Audio only.
Definition: codec_par.h:191
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
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
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:256
demux.h
tag
uint32_t tag
Definition: movenc.c:1788
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:743
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:231
avio_rb16
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:746
avformat.h
dict.h
id
enum AVCodecID id
Definition: dts2pts.c:365
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:433
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:612
AVIOContext::eof_reached
int eof_reached
true if was unable to read due to error or eof
Definition: avio.h:238
FF_MEDIASUBTYPE_BASE_GUID
#define FF_MEDIASUBTYPE_BASE_GUID
Definition: riff.h:115
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:318
AVCodecParameters::bits_per_coded_sample
int bits_per_coded_sample
The number of bits per sample in the codedwords.
Definition: codec_par.h:110
mem.h
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AV_CODEC_ID_ADPCM_IMA_WAV
@ AV_CODEC_ID_ADPCM_IMA_WAV
Definition: codec_id.h:368
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:88
riff.h
ff_codec_wav_guids
const AVCodecGuid ff_codec_wav_guids[]
Definition: riff.c:649
int32_t
int32_t
Definition: audioconvert.c:56
AV_CODEC_ID_PCM_F32LE
@ AV_CODEC_ID_PCM_F32LE
Definition: codec_id.h:349
AVCodecParameters::bit_rate
int64_t bit_rate
The average bitrate of the encoded data (in bits per second).
Definition: codec_par.h:97
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AV_CODEC_ID_AAC_LATM
@ AV_CODEC_ID_AAC_LATM
Definition: codec_id.h:489
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
ffio_read_size
int ffio_read_size(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:662
FF_BROKEN_BASE_GUID
#define FF_BROKEN_BASE_GUID
Definition: riff.h:119
ff_read_riff_info
int ff_read_riff_info(AVFormatContext *s, int64_t size)
Definition: riffdec.c:243
FF_PRI_GUID
#define FF_PRI_GUID
Definition: riff.h:105
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:346