• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "webrtc/common_audio/wav_header.h"
16 
17 #include <algorithm>
18 #include <cstring>
19 #include <limits>
20 
21 #include "webrtc/common_audio/include/audio_util.h"
22 
23 namespace webrtc {
24 
25 struct ChunkHeader {
26   uint32_t ID;
27   uint32_t Size;
28 };
29 COMPILE_ASSERT(sizeof(ChunkHeader) == 8, chunk_header_size);
30 
CheckWavParameters(int num_channels,int sample_rate,WavFormat format,int bytes_per_sample,uint32_t num_samples)31 bool CheckWavParameters(int num_channels,
32                         int sample_rate,
33                         WavFormat format,
34                         int bytes_per_sample,
35                         uint32_t num_samples) {
36   // num_channels, sample_rate, and bytes_per_sample must be positive, must fit
37   // in their respective fields, and their product must fit in the 32-bit
38   // ByteRate field.
39   if (num_channels <= 0 || sample_rate <= 0 || bytes_per_sample <= 0)
40     return false;
41   if (static_cast<uint64_t>(sample_rate) > std::numeric_limits<uint32_t>::max())
42     return false;
43   if (static_cast<uint64_t>(num_channels) >
44       std::numeric_limits<uint16_t>::max())
45     return false;
46   if (static_cast<uint64_t>(bytes_per_sample) * 8 >
47       std::numeric_limits<uint16_t>::max())
48     return false;
49   if (static_cast<uint64_t>(sample_rate) * num_channels * bytes_per_sample >
50       std::numeric_limits<uint32_t>::max())
51     return false;
52 
53   // format and bytes_per_sample must agree.
54   switch (format) {
55     case kWavFormatPcm:
56       // Other values may be OK, but for now we're conservative:
57       if (bytes_per_sample != 1 && bytes_per_sample != 2)
58         return false;
59       break;
60     case kWavFormatALaw:
61     case kWavFormatMuLaw:
62       if (bytes_per_sample != 1)
63         return false;
64       break;
65     default:
66       return false;
67   }
68 
69   // The number of bytes in the file, not counting the first ChunkHeader, must
70   // be less than 2^32; otherwise, the ChunkSize field overflows.
71   const uint32_t max_samples =
72       (std::numeric_limits<uint32_t>::max()
73        - (kWavHeaderSize - sizeof(ChunkHeader))) /
74       bytes_per_sample;
75   if (num_samples > max_samples)
76     return false;
77 
78   // Each channel must have the same number of samples.
79   if (num_samples % num_channels != 0)
80     return false;
81 
82   return true;
83 }
84 
85 #ifdef WEBRTC_ARCH_LITTLE_ENDIAN
WriteLE16(uint16_t * f,uint16_t x)86 static inline void WriteLE16(uint16_t* f, uint16_t x) { *f = x; }
WriteLE32(uint32_t * f,uint32_t x)87 static inline void WriteLE32(uint32_t* f, uint32_t x) { *f = x; }
WriteFourCC(uint32_t * f,char a,char b,char c,char d)88 static inline void WriteFourCC(uint32_t* f, char a, char b, char c, char d) {
89   *f = static_cast<uint32_t>(a)
90       | static_cast<uint32_t>(b) << 8
91       | static_cast<uint32_t>(c) << 16
92       | static_cast<uint32_t>(d) << 24;
93 }
94 #else
95 #error "Write be-to-le conversion functions"
96 #endif
97 
WriteWavHeader(uint8_t * buf,int num_channels,int sample_rate,WavFormat format,int bytes_per_sample,uint32_t num_samples)98 void WriteWavHeader(uint8_t* buf,
99                     int num_channels,
100                     int sample_rate,
101                     WavFormat format,
102                     int bytes_per_sample,
103                     uint32_t num_samples) {
104   assert(CheckWavParameters(num_channels, sample_rate, format,
105                             bytes_per_sample, num_samples));
106 
107   struct {
108     struct {
109       ChunkHeader header;
110       uint32_t Format;
111     } riff;
112     struct {
113       ChunkHeader header;
114       uint16_t AudioFormat;
115       uint16_t NumChannels;
116       uint32_t SampleRate;
117       uint32_t ByteRate;
118       uint16_t BlockAlign;
119       uint16_t BitsPerSample;
120     } fmt;
121     struct {
122       ChunkHeader header;
123     } data;
124   } header;
125   COMPILE_ASSERT(sizeof(header) == kWavHeaderSize, no_padding_in_header);
126 
127   const uint32_t bytes_in_payload = bytes_per_sample * num_samples;
128 
129   WriteFourCC(&header.riff.header.ID, 'R', 'I', 'F', 'F');
130   WriteLE32(&header.riff.header.Size,
131             bytes_in_payload + kWavHeaderSize - sizeof(ChunkHeader));
132   WriteFourCC(&header.riff.Format, 'W', 'A', 'V', 'E');
133 
134   WriteFourCC(&header.fmt.header.ID, 'f', 'm', 't', ' ');
135   WriteLE32(&header.fmt.header.Size, sizeof(header.fmt) - sizeof(ChunkHeader));
136   WriteLE16(&header.fmt.AudioFormat, format);
137   WriteLE16(&header.fmt.NumChannels, num_channels);
138   WriteLE32(&header.fmt.SampleRate, sample_rate);
139   WriteLE32(&header.fmt.ByteRate, (static_cast<uint32_t>(num_channels)
140                                    * sample_rate * bytes_per_sample));
141   WriteLE16(&header.fmt.BlockAlign, num_channels * bytes_per_sample);
142   WriteLE16(&header.fmt.BitsPerSample, 8 * bytes_per_sample);
143 
144   WriteFourCC(&header.data.header.ID, 'd', 'a', 't', 'a');
145   WriteLE32(&header.data.header.Size, bytes_in_payload);
146 
147   // Do an extra copy rather than writing everything to buf directly, since buf
148   // might not be correctly aligned.
149   memcpy(buf, &header, kWavHeaderSize);
150 }
151 
152 }  // namespace webrtc
153