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 #include "common_audio/wav_file.h"
12
13 #include <algorithm>
14 #include <cstdio>
15 #include <limits>
16 #include <sstream>
17
18 #include "common_audio/include/audio_util.h"
19 #include "common_audio/wav_header.h"
20 #include "rtc_base/checks.h"
21 #include "rtc_base/numerics/safe_conversions.h"
22
23 namespace webrtc {
24
25 // We write 16-bit PCM WAV files.
26 static const WavFormat kWavFormat = kWavFormatPcm;
27 static const size_t kBytesPerSample = 2;
28
29 // Doesn't take ownership of the file handle and won't close it.
30 class ReadableWavFile : public ReadableWav {
31 public:
ReadableWavFile(FILE * file)32 explicit ReadableWavFile(FILE* file) : file_(file) {}
Read(void * buf,size_t num_bytes)33 virtual size_t Read(void* buf, size_t num_bytes) {
34 return fread(buf, 1, num_bytes, file_);
35 }
36
37 private:
38 FILE* file_;
39 };
40
FormatAsString() const41 std::string WavFile::FormatAsString() const {
42 std::ostringstream s;
43 s << "Sample rate: " << sample_rate() << " Hz, Channels: " << num_channels()
44 << ", Duration: "
45 << (1.f * num_samples()) / (num_channels() * sample_rate()) << " s";
46 return s.str();
47 }
48
WavReader(const std::string & filename)49 WavReader::WavReader(const std::string& filename)
50 : file_handle_(fopen(filename.c_str(), "rb")) {
51 RTC_CHECK(file_handle_) << "Could not open wav file for reading.";
52
53 ReadableWavFile readable(file_handle_);
54 WavFormat format;
55 size_t bytes_per_sample;
56 RTC_CHECK(ReadWavHeader(&readable, &num_channels_, &sample_rate_, &format,
57 &bytes_per_sample, &num_samples_));
58 num_samples_remaining_ = num_samples_;
59 RTC_CHECK_EQ(kWavFormat, format);
60 RTC_CHECK_EQ(kBytesPerSample, bytes_per_sample);
61 }
62
~WavReader()63 WavReader::~WavReader() {
64 Close();
65 }
66
sample_rate() const67 int WavReader::sample_rate() const {
68 return sample_rate_;
69 }
70
num_channels() const71 size_t WavReader::num_channels() const {
72 return num_channels_;
73 }
74
num_samples() const75 size_t WavReader::num_samples() const {
76 return num_samples_;
77 }
78
ReadSamples(size_t num_samples,int16_t * samples)79 size_t WavReader::ReadSamples(size_t num_samples, int16_t* samples) {
80 // There could be metadata after the audio; ensure we don't read it.
81 num_samples = std::min(num_samples, num_samples_remaining_);
82 const size_t read =
83 fread(samples, sizeof(*samples), num_samples, file_handle_);
84 // If we didn't read what was requested, ensure we've reached the EOF.
85 RTC_CHECK(read == num_samples || feof(file_handle_));
86 RTC_CHECK_LE(read, num_samples_remaining_);
87 num_samples_remaining_ -= read;
88 #ifndef WEBRTC_ARCH_LITTLE_ENDIAN
89 //convert to big-endian
90 for (size_t idx = 0; idx < num_samples; idx++) {
91 samples[idx] = (samples[idx]<<8) | (samples[idx]>>8);
92 }
93 #endif
94 return read;
95 }
96
ReadSamples(size_t num_samples,float * samples)97 size_t WavReader::ReadSamples(size_t num_samples, float* samples) {
98 static const size_t kChunksize = 4096 / sizeof(uint16_t);
99 size_t read = 0;
100 for (size_t i = 0; i < num_samples; i += kChunksize) {
101 int16_t isamples[kChunksize];
102 size_t chunk = std::min(kChunksize, num_samples - i);
103 chunk = ReadSamples(chunk, isamples);
104 for (size_t j = 0; j < chunk; ++j)
105 samples[i + j] = isamples[j];
106 read += chunk;
107 }
108 return read;
109 }
110
Close()111 void WavReader::Close() {
112 RTC_CHECK_EQ(0, fclose(file_handle_));
113 file_handle_ = nullptr;
114 }
115
WavWriter(const std::string & filename,int sample_rate,size_t num_channels)116 WavWriter::WavWriter(const std::string& filename, int sample_rate,
117 size_t num_channels)
118 : sample_rate_(sample_rate),
119 num_channels_(num_channels),
120 num_samples_(0),
121 file_handle_(fopen(filename.c_str(), "wb")) {
122 if (file_handle_) {
123 RTC_CHECK(CheckWavParameters(num_channels_, sample_rate_, kWavFormat,
124 kBytesPerSample, num_samples_));
125
126 // Write a blank placeholder header, since we need to know the total number
127 // of samples before we can fill in the real data.
128 static const uint8_t blank_header[kWavHeaderSize] = {0};
129 RTC_CHECK_EQ(1, fwrite(blank_header, kWavHeaderSize, 1, file_handle_));
130 }
131 }
132
~WavWriter()133 WavWriter::~WavWriter() {
134 Close();
135 }
136
sample_rate() const137 int WavWriter::sample_rate() const {
138 return sample_rate_;
139 }
140
num_channels() const141 size_t WavWriter::num_channels() const {
142 return num_channels_;
143 }
144
num_samples() const145 size_t WavWriter::num_samples() const {
146 return num_samples_;
147 }
148
WriteSamples(const int16_t * samples,size_t num_samples)149 void WavWriter::WriteSamples(const int16_t* samples, size_t num_samples) {
150 if (!file_handle_) {
151 return;
152 }
153 #ifndef WEBRTC_ARCH_LITTLE_ENDIAN
154 int16_t * le_samples = new int16_t[num_samples];
155 for(size_t idx = 0; idx < num_samples; idx++) {
156 le_samples[idx] = (samples[idx]<<8) | (samples[idx]>>8);
157 }
158 const size_t written =
159 fwrite(le_samples, sizeof(*le_samples), num_samples, file_handle_);
160 delete []le_samples;
161 #else
162 const size_t written =
163 fwrite(samples, sizeof(*samples), num_samples, file_handle_);
164 #endif
165 RTC_CHECK_EQ(num_samples, written);
166 num_samples_ += written;
167 RTC_CHECK(num_samples_ >= written); // detect size_t overflow
168 }
169
WriteSamples(const float * samples,size_t num_samples)170 void WavWriter::WriteSamples(const float* samples, size_t num_samples) {
171 static const size_t kChunksize = 4096 / sizeof(uint16_t);
172 for (size_t i = 0; i < num_samples; i += kChunksize) {
173 int16_t isamples[kChunksize];
174 const size_t chunk = std::min(kChunksize, num_samples - i);
175 FloatS16ToS16(samples + i, chunk, isamples);
176 WriteSamples(isamples, chunk);
177 }
178 }
179
Close()180 void WavWriter::Close() {
181 if (!file_handle_) {
182 return;
183 }
184 RTC_CHECK_EQ(0, fseek(file_handle_, 0, SEEK_SET));
185 uint8_t header[kWavHeaderSize];
186 WriteWavHeader(header, num_channels_, sample_rate_, kWavFormat,
187 kBytesPerSample, num_samples_);
188 RTC_CHECK_EQ(1, fwrite(header, kWavHeaderSize, 1, file_handle_));
189 RTC_CHECK_EQ(0, fclose(file_handle_));
190 file_handle_ = nullptr;
191 }
192
193 } // namespace webrtc
194
rtc_WavOpen(const char * filename,int sample_rate,size_t num_channels)195 rtc_WavWriter* rtc_WavOpen(const char* filename,
196 int sample_rate,
197 size_t num_channels) {
198 return reinterpret_cast<rtc_WavWriter*>(
199 new webrtc::WavWriter(filename, sample_rate, num_channels));
200 }
201
rtc_WavClose(rtc_WavWriter * wf)202 void rtc_WavClose(rtc_WavWriter* wf) {
203 delete reinterpret_cast<webrtc::WavWriter*>(wf);
204 }
205
rtc_WavWriteSamples(rtc_WavWriter * wf,const float * samples,size_t num_samples)206 void rtc_WavWriteSamples(rtc_WavWriter* wf,
207 const float* samples,
208 size_t num_samples) {
209 reinterpret_cast<webrtc::WavWriter*>(wf)->WriteSamples(samples, num_samples);
210 }
211
rtc_WavSampleRate(const rtc_WavWriter * wf)212 int rtc_WavSampleRate(const rtc_WavWriter* wf) {
213 return reinterpret_cast<const webrtc::WavWriter*>(wf)->sample_rate();
214 }
215
rtc_WavNumChannels(const rtc_WavWriter * wf)216 size_t rtc_WavNumChannels(const rtc_WavWriter* wf) {
217 return reinterpret_cast<const webrtc::WavWriter*>(wf)->num_channels();
218 }
219
rtc_WavNumSamples(const rtc_WavWriter * wf)220 size_t rtc_WavNumSamples(const rtc_WavWriter* wf) {
221 return reinterpret_cast<const webrtc::WavWriter*>(wf)->num_samples();
222 }
223