andrew@webrtc.org | a3ed713 | 2014-10-31 21:51:03 +0000 | [diff] [blame] | 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 "webrtc/common_audio/wav_file.h" |
| 12 | |
| 13 | #include <algorithm> |
| 14 | #include <cstdio> |
| 15 | #include <limits> |
| 16 | |
| 17 | #include "webrtc/base/checks.h" |
andrew@webrtc.org | 0ab42bc | 2014-12-17 22:56:09 +0000 | [diff] [blame] | 18 | #include "webrtc/base/safe_conversions.h" |
andrew@webrtc.org | a3ed713 | 2014-10-31 21:51:03 +0000 | [diff] [blame] | 19 | #include "webrtc/common_audio/include/audio_util.h" |
| 20 | #include "webrtc/common_audio/wav_header.h" |
| 21 | |
| 22 | namespace webrtc { |
| 23 | |
| 24 | // We write 16-bit PCM WAV files. |
| 25 | static const WavFormat kWavFormat = kWavFormatPcm; |
| 26 | static const int kBytesPerSample = 2; |
| 27 | |
andrew@webrtc.org | 048c502 | 2014-12-16 20:17:21 +0000 | [diff] [blame] | 28 | // Doesn't take ownership of the file handle and won't close it. |
| 29 | class ReadableWavFile : public ReadableWav { |
| 30 | public: |
| 31 | explicit ReadableWavFile(FILE* file) : file_(file) {} |
| 32 | virtual size_t Read(void* buf, size_t num_bytes) { |
| 33 | return fread(buf, 1, num_bytes, file_); |
| 34 | } |
| 35 | |
| 36 | private: |
| 37 | FILE* file_; |
| 38 | }; |
| 39 | |
andrew@webrtc.org | a3ed713 | 2014-10-31 21:51:03 +0000 | [diff] [blame] | 40 | WavReader::WavReader(const std::string& filename) |
| 41 | : file_handle_(fopen(filename.c_str(), "rb")) { |
kjellander | b7a5c16 | 2015-11-05 12:33:18 -0800 | [diff] [blame] | 42 | RTC_CHECK(file_handle_ && "Could not open wav file for reading."); |
andrew@webrtc.org | a3ed713 | 2014-10-31 21:51:03 +0000 | [diff] [blame] | 43 | |
andrew@webrtc.org | 048c502 | 2014-12-16 20:17:21 +0000 | [diff] [blame] | 44 | ReadableWavFile readable(file_handle_); |
andrew@webrtc.org | a3ed713 | 2014-10-31 21:51:03 +0000 | [diff] [blame] | 45 | WavFormat format; |
| 46 | int bytes_per_sample; |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 47 | RTC_CHECK(ReadWavHeader(&readable, &num_channels_, &sample_rate_, &format, |
| 48 | &bytes_per_sample, &num_samples_)); |
andrew@webrtc.org | 048c502 | 2014-12-16 20:17:21 +0000 | [diff] [blame] | 49 | num_samples_remaining_ = num_samples_; |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 50 | RTC_CHECK_EQ(kWavFormat, format); |
| 51 | RTC_CHECK_EQ(kBytesPerSample, bytes_per_sample); |
andrew@webrtc.org | a3ed713 | 2014-10-31 21:51:03 +0000 | [diff] [blame] | 52 | } |
| 53 | |
| 54 | WavReader::~WavReader() { |
| 55 | Close(); |
| 56 | } |
| 57 | |
| 58 | size_t WavReader::ReadSamples(size_t num_samples, int16_t* samples) { |
| 59 | #ifndef WEBRTC_ARCH_LITTLE_ENDIAN |
| 60 | #error "Need to convert samples to big-endian when reading from WAV file" |
| 61 | #endif |
andrew@webrtc.org | 048c502 | 2014-12-16 20:17:21 +0000 | [diff] [blame] | 62 | // There could be metadata after the audio; ensure we don't read it. |
andrew@webrtc.org | 0ab42bc | 2014-12-17 22:56:09 +0000 | [diff] [blame] | 63 | num_samples = std::min(rtc::checked_cast<uint32_t>(num_samples), |
andrew@webrtc.org | 048c502 | 2014-12-16 20:17:21 +0000 | [diff] [blame] | 64 | num_samples_remaining_); |
andrew@webrtc.org | a3ed713 | 2014-10-31 21:51:03 +0000 | [diff] [blame] | 65 | const size_t read = |
| 66 | fread(samples, sizeof(*samples), num_samples, file_handle_); |
| 67 | // If we didn't read what was requested, ensure we've reached the EOF. |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 68 | RTC_CHECK(read == num_samples || feof(file_handle_)); |
| 69 | RTC_CHECK_LE(read, num_samples_remaining_); |
andrew@webrtc.org | 0ab42bc | 2014-12-17 22:56:09 +0000 | [diff] [blame] | 70 | num_samples_remaining_ -= rtc::checked_cast<uint32_t>(read); |
andrew@webrtc.org | a3ed713 | 2014-10-31 21:51:03 +0000 | [diff] [blame] | 71 | return read; |
| 72 | } |
| 73 | |
| 74 | size_t WavReader::ReadSamples(size_t num_samples, float* samples) { |
| 75 | static const size_t kChunksize = 4096 / sizeof(uint16_t); |
| 76 | size_t read = 0; |
| 77 | for (size_t i = 0; i < num_samples; i += kChunksize) { |
| 78 | int16_t isamples[kChunksize]; |
| 79 | size_t chunk = std::min(kChunksize, num_samples - i); |
| 80 | chunk = ReadSamples(chunk, isamples); |
| 81 | for (size_t j = 0; j < chunk; ++j) |
| 82 | samples[i + j] = isamples[j]; |
| 83 | read += chunk; |
| 84 | } |
| 85 | return read; |
| 86 | } |
| 87 | |
| 88 | void WavReader::Close() { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 89 | RTC_CHECK_EQ(0, fclose(file_handle_)); |
andrew@webrtc.org | a3ed713 | 2014-10-31 21:51:03 +0000 | [diff] [blame] | 90 | file_handle_ = NULL; |
| 91 | } |
| 92 | |
| 93 | WavWriter::WavWriter(const std::string& filename, int sample_rate, |
| 94 | int num_channels) |
| 95 | : sample_rate_(sample_rate), |
| 96 | num_channels_(num_channels), |
| 97 | num_samples_(0), |
| 98 | file_handle_(fopen(filename.c_str(), "wb")) { |
kjellander | b7a5c16 | 2015-11-05 12:33:18 -0800 | [diff] [blame] | 99 | RTC_CHECK(file_handle_ && "Could not open wav file for writing."); |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 100 | RTC_CHECK(CheckWavParameters(num_channels_, sample_rate_, kWavFormat, |
| 101 | kBytesPerSample, num_samples_)); |
andrew@webrtc.org | a3ed713 | 2014-10-31 21:51:03 +0000 | [diff] [blame] | 102 | |
| 103 | // Write a blank placeholder header, since we need to know the total number |
| 104 | // of samples before we can fill in the real data. |
| 105 | static const uint8_t blank_header[kWavHeaderSize] = {0}; |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 106 | RTC_CHECK_EQ(1u, fwrite(blank_header, kWavHeaderSize, 1, file_handle_)); |
andrew@webrtc.org | a3ed713 | 2014-10-31 21:51:03 +0000 | [diff] [blame] | 107 | } |
| 108 | |
| 109 | WavWriter::~WavWriter() { |
| 110 | Close(); |
| 111 | } |
| 112 | |
| 113 | void WavWriter::WriteSamples(const int16_t* samples, size_t num_samples) { |
| 114 | #ifndef WEBRTC_ARCH_LITTLE_ENDIAN |
| 115 | #error "Need to convert samples to little-endian when writing to WAV file" |
| 116 | #endif |
| 117 | const size_t written = |
| 118 | fwrite(samples, sizeof(*samples), num_samples, file_handle_); |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 119 | RTC_CHECK_EQ(num_samples, written); |
andrew@webrtc.org | a3ed713 | 2014-10-31 21:51:03 +0000 | [diff] [blame] | 120 | num_samples_ += static_cast<uint32_t>(written); |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 121 | RTC_CHECK(written <= std::numeric_limits<uint32_t>::max() || |
| 122 | num_samples_ >= written); // detect uint32_t overflow |
andrew@webrtc.org | a3ed713 | 2014-10-31 21:51:03 +0000 | [diff] [blame] | 123 | } |
| 124 | |
| 125 | void WavWriter::WriteSamples(const float* samples, size_t num_samples) { |
| 126 | static const size_t kChunksize = 4096 / sizeof(uint16_t); |
| 127 | for (size_t i = 0; i < num_samples; i += kChunksize) { |
| 128 | int16_t isamples[kChunksize]; |
| 129 | const size_t chunk = std::min(kChunksize, num_samples - i); |
| 130 | FloatS16ToS16(samples + i, chunk, isamples); |
| 131 | WriteSamples(isamples, chunk); |
| 132 | } |
| 133 | } |
| 134 | |
| 135 | void WavWriter::Close() { |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 136 | RTC_CHECK_EQ(0, fseek(file_handle_, 0, SEEK_SET)); |
andrew@webrtc.org | a3ed713 | 2014-10-31 21:51:03 +0000 | [diff] [blame] | 137 | uint8_t header[kWavHeaderSize]; |
andrew@webrtc.org | f866b2d | 2014-11-03 18:20:06 +0000 | [diff] [blame] | 138 | WriteWavHeader(header, num_channels_, sample_rate_, kWavFormat, |
| 139 | kBytesPerSample, num_samples_); |
henrikg | 91d6ede | 2015-09-17 00:24:34 -0700 | [diff] [blame] | 140 | RTC_CHECK_EQ(1u, fwrite(header, kWavHeaderSize, 1, file_handle_)); |
| 141 | RTC_CHECK_EQ(0, fclose(file_handle_)); |
andrew@webrtc.org | a3ed713 | 2014-10-31 21:51:03 +0000 | [diff] [blame] | 142 | file_handle_ = NULL; |
| 143 | } |
| 144 | |
| 145 | } // namespace webrtc |
| 146 | |
| 147 | rtc_WavWriter* rtc_WavOpen(const char* filename, |
| 148 | int sample_rate, |
| 149 | int num_channels) { |
| 150 | return reinterpret_cast<rtc_WavWriter*>( |
| 151 | new webrtc::WavWriter(filename, sample_rate, num_channels)); |
| 152 | } |
| 153 | |
| 154 | void rtc_WavClose(rtc_WavWriter* wf) { |
| 155 | delete reinterpret_cast<webrtc::WavWriter*>(wf); |
| 156 | } |
| 157 | |
| 158 | void rtc_WavWriteSamples(rtc_WavWriter* wf, |
| 159 | const float* samples, |
| 160 | size_t num_samples) { |
| 161 | reinterpret_cast<webrtc::WavWriter*>(wf)->WriteSamples(samples, num_samples); |
| 162 | } |
| 163 | |
| 164 | int rtc_WavSampleRate(const rtc_WavWriter* wf) { |
| 165 | return reinterpret_cast<const webrtc::WavWriter*>(wf)->sample_rate(); |
| 166 | } |
| 167 | |
| 168 | int rtc_WavNumChannels(const rtc_WavWriter* wf) { |
| 169 | return reinterpret_cast<const webrtc::WavWriter*>(wf)->num_channels(); |
| 170 | } |
| 171 | |
| 172 | uint32_t rtc_WavNumSamples(const rtc_WavWriter* wf) { |
| 173 | return reinterpret_cast<const webrtc::WavWriter*>(wf)->num_samples(); |
| 174 | } |