1 /*
2 * Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
3 *
4 * Use of this source code is governed by a BSD-style license
5 * that can be found in the LICENSE file in the root of the source
6 * tree. An additional intellectual property rights grant can be found
7 * in the file PATENTS. All contributing project authors may
8 * be found in the AUTHORS file in the root of the source tree.
9 */
10
11 // Based on the WAV file format documentation at
12 // https://ccrma.stanford.edu/courses/422/projects/WaveFormat/ and
13 // http://www-mmsp.ece.mcgill.ca/Documents/AudioFormats/WAVE/WAVE.html
14
15 #include "common_audio/wav_header.h"
16
17 #include <algorithm>
18 #include <cstring>
19 #include <limits>
20 #include <string>
21
22 #include "common_audio/include/audio_util.h"
23 #include "rtc_base/checks.h"
24
25 namespace webrtc {
26 namespace {
27
28 struct ChunkHeader {
29 uint32_t ID;
30 uint32_t Size;
31 };
32 static_assert(sizeof(ChunkHeader) == 8, "ChunkHeader size");
33
34 // We can't nest this definition in WavHeader, because VS2013 gives an error
35 // on sizeof(WavHeader::fmt): "error C2070: 'unknown': illegal sizeof operand".
36 struct FmtSubchunk {
37 ChunkHeader header;
38 uint16_t AudioFormat;
39 uint16_t NumChannels;
40 uint32_t SampleRate;
41 uint32_t ByteRate;
42 uint16_t BlockAlign;
43 uint16_t BitsPerSample;
44 };
45 static_assert(sizeof(FmtSubchunk) == 24, "FmtSubchunk size");
46 const uint32_t kFmtSubchunkSize = sizeof(FmtSubchunk) - sizeof(ChunkHeader);
47
48 struct WavHeader {
49 struct {
50 ChunkHeader header;
51 uint32_t Format;
52 } riff;
53 FmtSubchunk fmt;
54 struct {
55 ChunkHeader header;
56 } data;
57 };
58 static_assert(sizeof(WavHeader) == kWavHeaderSize, "no padding in header");
59
60 } // namespace
61
CheckWavParameters(size_t num_channels,int sample_rate,WavFormat format,size_t bytes_per_sample,size_t num_samples)62 bool CheckWavParameters(size_t num_channels,
63 int sample_rate,
64 WavFormat format,
65 size_t bytes_per_sample,
66 size_t num_samples) {
67 // num_channels, sample_rate, and bytes_per_sample must be positive, must fit
68 // in their respective fields, and their product must fit in the 32-bit
69 // ByteRate field.
70 if (num_channels == 0 || sample_rate <= 0 || bytes_per_sample == 0)
71 return false;
72 if (static_cast<uint64_t>(sample_rate) > std::numeric_limits<uint32_t>::max())
73 return false;
74 if (num_channels > std::numeric_limits<uint16_t>::max())
75 return false;
76 if (static_cast<uint64_t>(bytes_per_sample) * 8 >
77 std::numeric_limits<uint16_t>::max())
78 return false;
79 if (static_cast<uint64_t>(sample_rate) * num_channels * bytes_per_sample >
80 std::numeric_limits<uint32_t>::max())
81 return false;
82
83 // format and bytes_per_sample must agree.
84 switch (format) {
85 case kWavFormatPcm:
86 // Other values may be OK, but for now we're conservative:
87 if (bytes_per_sample != 1 && bytes_per_sample != 2)
88 return false;
89 break;
90 case kWavFormatALaw:
91 case kWavFormatMuLaw:
92 if (bytes_per_sample != 1)
93 return false;
94 break;
95 default:
96 return false;
97 }
98
99 // The number of bytes in the file, not counting the first ChunkHeader, must
100 // be less than 2^32; otherwise, the ChunkSize field overflows.
101 const size_t header_size = kWavHeaderSize - sizeof(ChunkHeader);
102 const size_t max_samples =
103 (std::numeric_limits<uint32_t>::max() - header_size) / bytes_per_sample;
104 if (num_samples > max_samples)
105 return false;
106
107 // Each channel must have the same number of samples.
108 if (num_samples % num_channels != 0)
109 return false;
110
111 return true;
112 }
113
114 #ifdef WEBRTC_ARCH_LITTLE_ENDIAN
WriteLE16(uint16_t * f,uint16_t x)115 static inline void WriteLE16(uint16_t* f, uint16_t x) { *f = x; }
WriteLE32(uint32_t * f,uint32_t x)116 static inline void WriteLE32(uint32_t* f, uint32_t x) { *f = x; }
WriteFourCC(uint32_t * f,char a,char b,char c,char d)117 static inline void WriteFourCC(uint32_t* f, char a, char b, char c, char d) {
118 *f = static_cast<uint32_t>(a)
119 | static_cast<uint32_t>(b) << 8
120 | static_cast<uint32_t>(c) << 16
121 | static_cast<uint32_t>(d) << 24;
122 }
123
ReadLE16(uint16_t x)124 static inline uint16_t ReadLE16(uint16_t x) { return x; }
ReadLE32(uint32_t x)125 static inline uint32_t ReadLE32(uint32_t x) { return x; }
ReadFourCC(uint32_t x)126 static inline std::string ReadFourCC(uint32_t x) {
127 return std::string(reinterpret_cast<char*>(&x), 4);
128 }
129 #else
WriteLE16(uint16_t * f,uint16_t x)130 static inline void WriteLE16(uint16_t* f, uint16_t x) {
131 *f = ((x << 8) & 0xff00) | ( ( x >> 8) & 0x00ff);
132 }
133
WriteLE32(uint32_t * f,uint32_t x)134 static inline void WriteLE32(uint32_t* f, uint32_t x) {
135 *f = ( (x & 0x000000ff) << 24 )
136 | ((x & 0x0000ff00) << 8)
137 | ((x & 0x00ff0000) >> 8)
138 | ((x & 0xff000000) >> 24 );
139 }
140
WriteFourCC(uint32_t * f,char a,char b,char c,char d)141 static inline void WriteFourCC(uint32_t* f, char a, char b, char c, char d) {
142 *f = (static_cast<uint32_t>(a) << 24 )
143 | (static_cast<uint32_t>(b) << 16)
144 | (static_cast<uint32_t>(c) << 8)
145 | (static_cast<uint32_t>(d) );
146 }
147
ReadLE16(uint16_t x)148 static inline uint16_t ReadLE16(uint16_t x) {
149 return (( x & 0x00ff) << 8 )| ((x & 0xff00)>>8);
150 }
151
ReadLE32(uint32_t x)152 static inline uint32_t ReadLE32(uint32_t x) {
153 return ( (x & 0x000000ff) << 24 )
154 | ( (x & 0x0000ff00) << 8 )
155 | ( (x & 0x00ff0000) >> 8)
156 | ( (x & 0xff000000) >> 24 );
157 }
158
ReadFourCC(uint32_t x)159 static inline std::string ReadFourCC(uint32_t x) {
160 x = ReadLE32(x);
161 return std::string(reinterpret_cast<char*>(&x), 4);
162 }
163 #endif
164
RiffChunkSize(size_t bytes_in_payload)165 static inline uint32_t RiffChunkSize(size_t bytes_in_payload) {
166 return static_cast<uint32_t>(
167 bytes_in_payload + kWavHeaderSize - sizeof(ChunkHeader));
168 }
169
ByteRate(size_t num_channels,int sample_rate,size_t bytes_per_sample)170 static inline uint32_t ByteRate(size_t num_channels, int sample_rate,
171 size_t bytes_per_sample) {
172 return static_cast<uint32_t>(num_channels * sample_rate * bytes_per_sample);
173 }
174
BlockAlign(size_t num_channels,size_t bytes_per_sample)175 static inline uint16_t BlockAlign(size_t num_channels,
176 size_t bytes_per_sample) {
177 return static_cast<uint16_t>(num_channels * bytes_per_sample);
178 }
179
WriteWavHeader(uint8_t * buf,size_t num_channels,int sample_rate,WavFormat format,size_t bytes_per_sample,size_t num_samples)180 void WriteWavHeader(uint8_t* buf,
181 size_t num_channels,
182 int sample_rate,
183 WavFormat format,
184 size_t bytes_per_sample,
185 size_t num_samples) {
186 RTC_CHECK(CheckWavParameters(num_channels, sample_rate, format,
187 bytes_per_sample, num_samples));
188
189 WavHeader header;
190 const size_t bytes_in_payload = bytes_per_sample * num_samples;
191
192 WriteFourCC(&header.riff.header.ID, 'R', 'I', 'F', 'F');
193 WriteLE32(&header.riff.header.Size, RiffChunkSize(bytes_in_payload));
194 WriteFourCC(&header.riff.Format, 'W', 'A', 'V', 'E');
195
196 WriteFourCC(&header.fmt.header.ID, 'f', 'm', 't', ' ');
197 WriteLE32(&header.fmt.header.Size, kFmtSubchunkSize);
198 WriteLE16(&header.fmt.AudioFormat, format);
199 WriteLE16(&header.fmt.NumChannels, static_cast<uint16_t>(num_channels));
200 WriteLE32(&header.fmt.SampleRate, sample_rate);
201 WriteLE32(&header.fmt.ByteRate, ByteRate(num_channels, sample_rate,
202 bytes_per_sample));
203 WriteLE16(&header.fmt.BlockAlign, BlockAlign(num_channels, bytes_per_sample));
204 WriteLE16(&header.fmt.BitsPerSample,
205 static_cast<uint16_t>(8 * bytes_per_sample));
206
207 WriteFourCC(&header.data.header.ID, 'd', 'a', 't', 'a');
208 WriteLE32(&header.data.header.Size, static_cast<uint32_t>(bytes_in_payload));
209
210 // Do an extra copy rather than writing everything to buf directly, since buf
211 // might not be correctly aligned.
212 memcpy(buf, &header, kWavHeaderSize);
213 }
214
ReadWavHeader(ReadableWav * readable,size_t * num_channels,int * sample_rate,WavFormat * format,size_t * bytes_per_sample,size_t * num_samples)215 bool ReadWavHeader(ReadableWav* readable,
216 size_t* num_channels,
217 int* sample_rate,
218 WavFormat* format,
219 size_t* bytes_per_sample,
220 size_t* num_samples) {
221 WavHeader header;
222 if (readable->Read(&header, kWavHeaderSize - sizeof(header.data)) !=
223 kWavHeaderSize - sizeof(header.data))
224 return false;
225
226 const uint32_t fmt_size = ReadLE32(header.fmt.header.Size);
227 if (fmt_size != kFmtSubchunkSize) {
228 // There is an optional two-byte extension field permitted to be present
229 // with PCM, but which must be zero.
230 int16_t ext_size;
231 if (kFmtSubchunkSize + sizeof(ext_size) != fmt_size)
232 return false;
233 if (readable->Read(&ext_size, sizeof(ext_size)) != sizeof(ext_size))
234 return false;
235 if (ext_size != 0)
236 return false;
237 }
238 if (readable->Read(&header.data, sizeof(header.data)) != sizeof(header.data))
239 return false;
240
241 // Parse needed fields.
242 *format = static_cast<WavFormat>(ReadLE16(header.fmt.AudioFormat));
243 *num_channels = ReadLE16(header.fmt.NumChannels);
244 *sample_rate = ReadLE32(header.fmt.SampleRate);
245 *bytes_per_sample = ReadLE16(header.fmt.BitsPerSample) / 8;
246 const size_t bytes_in_payload = ReadLE32(header.data.header.Size);
247 if (*bytes_per_sample == 0)
248 return false;
249 *num_samples = bytes_in_payload / *bytes_per_sample;
250
251 // Sanity check remaining fields.
252 if (ReadFourCC(header.riff.header.ID) != "RIFF")
253 return false;
254 if (ReadFourCC(header.riff.Format) != "WAVE")
255 return false;
256 if (ReadFourCC(header.fmt.header.ID) != "fmt ")
257 return false;
258 if (ReadFourCC(header.data.header.ID) != "data")
259 return false;
260
261 if (ReadLE32(header.riff.header.Size) < RiffChunkSize(bytes_in_payload))
262 return false;
263 if (ReadLE32(header.fmt.ByteRate) !=
264 ByteRate(*num_channels, *sample_rate, *bytes_per_sample))
265 return false;
266 if (ReadLE16(header.fmt.BlockAlign) !=
267 BlockAlign(*num_channels, *bytes_per_sample))
268 return false;
269
270 return CheckWavParameters(*num_channels, *sample_rate, *format,
271 *bytes_per_sample, *num_samples);
272 }
273
274
275 } // namespace webrtc
276