1 /*
2 * Copyright (c) 2015 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 <utility>
12
13 #include "webrtc/base/checks.h"
14 #include "webrtc/modules/audio_processing/test/test_utils.h"
15
16 namespace webrtc {
17
RawFile(const std::string & filename)18 RawFile::RawFile(const std::string& filename)
19 : file_handle_(fopen(filename.c_str(), "wb")) {}
20
~RawFile()21 RawFile::~RawFile() {
22 fclose(file_handle_);
23 }
24
WriteSamples(const int16_t * samples,size_t num_samples)25 void RawFile::WriteSamples(const int16_t* samples, size_t num_samples) {
26 #ifndef WEBRTC_ARCH_LITTLE_ENDIAN
27 #error "Need to convert samples to little-endian when writing to PCM file"
28 #endif
29 fwrite(samples, sizeof(*samples), num_samples, file_handle_);
30 }
31
WriteSamples(const float * samples,size_t num_samples)32 void RawFile::WriteSamples(const float* samples, size_t num_samples) {
33 fwrite(samples, sizeof(*samples), num_samples, file_handle_);
34 }
35
ChannelBufferWavReader(rtc::scoped_ptr<WavReader> file)36 ChannelBufferWavReader::ChannelBufferWavReader(rtc::scoped_ptr<WavReader> file)
37 : file_(std::move(file)) {}
38
Read(ChannelBuffer<float> * buffer)39 bool ChannelBufferWavReader::Read(ChannelBuffer<float>* buffer) {
40 RTC_CHECK_EQ(file_->num_channels(), buffer->num_channels());
41 interleaved_.resize(buffer->size());
42 if (file_->ReadSamples(interleaved_.size(), &interleaved_[0]) !=
43 interleaved_.size()) {
44 return false;
45 }
46
47 FloatS16ToFloat(&interleaved_[0], interleaved_.size(), &interleaved_[0]);
48 Deinterleave(&interleaved_[0], buffer->num_frames(), buffer->num_channels(),
49 buffer->channels());
50 return true;
51 }
52
ChannelBufferWavWriter(rtc::scoped_ptr<WavWriter> file)53 ChannelBufferWavWriter::ChannelBufferWavWriter(rtc::scoped_ptr<WavWriter> file)
54 : file_(std::move(file)) {}
55
Write(const ChannelBuffer<float> & buffer)56 void ChannelBufferWavWriter::Write(const ChannelBuffer<float>& buffer) {
57 RTC_CHECK_EQ(file_->num_channels(), buffer.num_channels());
58 interleaved_.resize(buffer.size());
59 Interleave(buffer.channels(), buffer.num_frames(), buffer.num_channels(),
60 &interleaved_[0]);
61 FloatToFloatS16(&interleaved_[0], interleaved_.size(), &interleaved_[0]);
62 file_->WriteSamples(&interleaved_[0], interleaved_.size());
63 }
64
WriteIntData(const int16_t * data,size_t length,WavWriter * wav_file,RawFile * raw_file)65 void WriteIntData(const int16_t* data,
66 size_t length,
67 WavWriter* wav_file,
68 RawFile* raw_file) {
69 if (wav_file) {
70 wav_file->WriteSamples(data, length);
71 }
72 if (raw_file) {
73 raw_file->WriteSamples(data, length);
74 }
75 }
76
WriteFloatData(const float * const * data,size_t samples_per_channel,size_t num_channels,WavWriter * wav_file,RawFile * raw_file)77 void WriteFloatData(const float* const* data,
78 size_t samples_per_channel,
79 size_t num_channels,
80 WavWriter* wav_file,
81 RawFile* raw_file) {
82 size_t length = num_channels * samples_per_channel;
83 rtc::scoped_ptr<float[]> buffer(new float[length]);
84 Interleave(data, samples_per_channel, num_channels, buffer.get());
85 if (raw_file) {
86 raw_file->WriteSamples(buffer.get(), length);
87 }
88 // TODO(aluebs): Use ScaleToInt16Range() from audio_util
89 for (size_t i = 0; i < length; ++i) {
90 buffer[i] = buffer[i] > 0 ?
91 buffer[i] * std::numeric_limits<int16_t>::max() :
92 -buffer[i] * std::numeric_limits<int16_t>::min();
93 }
94 if (wav_file) {
95 wav_file->WriteSamples(buffer.get(), length);
96 }
97 }
98
OpenFile(const std::string & filename,const char * mode)99 FILE* OpenFile(const std::string& filename, const char* mode) {
100 FILE* file = fopen(filename.c_str(), mode);
101 if (!file) {
102 printf("Unable to open file %s\n", filename.c_str());
103 exit(1);
104 }
105 return file;
106 }
107
SamplesFromRate(int rate)108 size_t SamplesFromRate(int rate) {
109 return static_cast<size_t>(AudioProcessing::kChunkSizeMs * rate / 1000);
110 }
111
SetFrameSampleRate(AudioFrame * frame,int sample_rate_hz)112 void SetFrameSampleRate(AudioFrame* frame,
113 int sample_rate_hz) {
114 frame->sample_rate_hz_ = sample_rate_hz;
115 frame->samples_per_channel_ = AudioProcessing::kChunkSizeMs *
116 sample_rate_hz / 1000;
117 }
118
LayoutFromChannels(size_t num_channels)119 AudioProcessing::ChannelLayout LayoutFromChannels(size_t num_channels) {
120 switch (num_channels) {
121 case 1:
122 return AudioProcessing::kMono;
123 case 2:
124 return AudioProcessing::kStereo;
125 default:
126 RTC_CHECK(false);
127 return AudioProcessing::kMono;
128 }
129 }
130
ParseArrayGeometry(const std::string & mic_positions)131 std::vector<Point> ParseArrayGeometry(const std::string& mic_positions) {
132 const std::vector<float> values = ParseList<float>(mic_positions);
133 const size_t num_mics =
134 rtc::CheckedDivExact(values.size(), static_cast<size_t>(3));
135 RTC_CHECK_GT(num_mics, 0u) << "mic_positions is not large enough.";
136
137 std::vector<Point> result;
138 result.reserve(num_mics);
139 for (size_t i = 0; i < values.size(); i += 3) {
140 result.push_back(Point(values[i + 0], values[i + 1], values[i + 2]));
141 }
142
143 return result;
144 }
145
ParseArrayGeometry(const std::string & mic_positions,size_t num_mics)146 std::vector<Point> ParseArrayGeometry(const std::string& mic_positions,
147 size_t num_mics) {
148 std::vector<Point> result = ParseArrayGeometry(mic_positions);
149 RTC_CHECK_EQ(result.size(), num_mics)
150 << "Could not parse mic_positions or incorrect number of points.";
151 return result;
152 }
153
154 } // namespace webrtc
155