| OLD | NEW |
|---|
| (Empty) |
| 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 "webrtc/modules/audio_processing/test/audio_file_processor.h" | |
| 12 | |
| 13 #include <algorithm> | |
| 14 #include <utility> | |
| 15 | |
| 16 #include "webrtc/base/checks.h" | |
| 17 #include "webrtc/modules/audio_processing/test/protobuf_utils.h" | |
| 18 | |
| 19 using rtc::CheckedDivExact; | |
| 20 using std::vector; | |
| 21 using webrtc::audioproc::Event; | |
| 22 using webrtc::audioproc::Init; | |
| 23 using webrtc::audioproc::ReverseStream; | |
| 24 using webrtc::audioproc::Stream; | |
| 25 | |
| 26 namespace webrtc { | |
| 27 namespace { | |
| 28 | |
| 29 // Returns a StreamConfig corresponding to file. | |
| 30 StreamConfig GetStreamConfig(const WavFile& file) { | |
| 31 return StreamConfig(file.sample_rate(), file.num_channels()); | |
| 32 } | |
| 33 | |
| 34 // Returns a ChannelBuffer corresponding to file. | |
| 35 ChannelBuffer<float> GetChannelBuffer(const WavFile& file) { | |
| 36 return ChannelBuffer<float>( | |
| 37 CheckedDivExact(file.sample_rate(), AudioFileProcessor::kChunksPerSecond), | |
| 38 file.num_channels()); | |
| 39 } | |
| 40 | |
| 41 } // namespace | |
| 42 | |
| 43 WavFileProcessor::WavFileProcessor(std::unique_ptr<AudioProcessing> ap, | |
| 44 std::unique_ptr<WavReader> in_file, | |
| 45 std::unique_ptr<WavWriter> out_file, | |
| 46 std::unique_ptr<WavReader> reverse_in_file, | |
| 47 std::unique_ptr<WavWriter> reverse_out_file) | |
| 48 : ap_(std::move(ap)), | |
| 49 in_buf_(GetChannelBuffer(*in_file)), | |
| 50 out_buf_(GetChannelBuffer(*out_file)), | |
| 51 input_config_(GetStreamConfig(*in_file)), | |
| 52 output_config_(GetStreamConfig(*out_file)), | |
| 53 buffer_reader_(std::move(in_file)), | |
| 54 buffer_writer_(std::move(out_file)) { | |
| 55 if (reverse_in_file) { | |
| 56 const WavFile* reverse_out_config; | |
| 57 if (reverse_out_file) { | |
| 58 reverse_out_config = reverse_out_file.get(); | |
| 59 } else { | |
| 60 reverse_out_config = reverse_in_file.get(); | |
| 61 } | |
| 62 reverse_in_buf_.reset( | |
| 63 new ChannelBuffer<float>(GetChannelBuffer(*reverse_in_file))); | |
| 64 reverse_out_buf_.reset( | |
| 65 new ChannelBuffer<float>(GetChannelBuffer(*reverse_out_config))); | |
| 66 reverse_input_config_.reset( | |
| 67 new StreamConfig(GetStreamConfig(*reverse_in_file))); | |
| 68 reverse_output_config_.reset( | |
| 69 new StreamConfig(GetStreamConfig(*reverse_out_config))); | |
| 70 reverse_buffer_reader_.reset( | |
| 71 new ChannelBufferWavReader(std::move(reverse_in_file))); | |
| 72 if (reverse_out_file) { | |
| 73 reverse_buffer_writer_.reset( | |
| 74 new ChannelBufferWavWriter(std::move(reverse_out_file))); | |
| 75 } | |
| 76 } | |
| 77 } | |
| 78 | |
| 79 bool WavFileProcessor::ProcessChunk() { | |
| 80 if (!buffer_reader_.Read(&in_buf_)) { | |
| 81 return false; | |
| 82 } | |
| 83 { | |
| 84 const auto st = ScopedTimer(mutable_proc_time()); | |
| 85 RTC_CHECK_EQ(kNoErr, | |
| 86 ap_->ProcessStream(in_buf_.channels(), input_config_, | |
| 87 output_config_, out_buf_.channels())); | |
| 88 } | |
| 89 buffer_writer_.Write(out_buf_); | |
| 90 if (reverse_buffer_reader_) { | |
| 91 if (!reverse_buffer_reader_->Read(reverse_in_buf_.get())) { | |
| 92 return false; | |
| 93 } | |
| 94 { | |
| 95 const auto st = ScopedTimer(mutable_proc_time()); | |
| 96 RTC_CHECK_EQ(kNoErr, | |
| 97 ap_->ProcessReverseStream(reverse_in_buf_->channels(), | |
| 98 *reverse_input_config_.get(), | |
| 99 *reverse_output_config_.get(), | |
| 100 reverse_out_buf_->channels())); | |
| 101 } | |
| 102 if (reverse_buffer_writer_) { | |
| 103 reverse_buffer_writer_->Write(*reverse_out_buf_.get()); | |
| 104 } | |
| 105 } | |
| 106 return true; | |
| 107 } | |
| 108 | |
| 109 AecDumpFileProcessor::AecDumpFileProcessor(std::unique_ptr<AudioProcessing> ap, | |
| 110 FILE* dump_file, | |
| 111 std::unique_ptr<WavWriter> out_file) | |
| 112 : ap_(std::move(ap)), | |
| 113 dump_file_(dump_file), | |
| 114 out_buf_(GetChannelBuffer(*out_file)), | |
| 115 output_config_(GetStreamConfig(*out_file)), | |
| 116 buffer_writer_(std::move(out_file)) { | |
| 117 RTC_CHECK(dump_file_) << "Could not open dump file for reading."; | |
| 118 } | |
| 119 | |
| 120 AecDumpFileProcessor::~AecDumpFileProcessor() { | |
| 121 fclose(dump_file_); | |
| 122 } | |
| 123 | |
| 124 bool AecDumpFileProcessor::ProcessChunk() { | |
| 125 Event event_msg; | |
| 126 | |
| 127 // Continue until we process our first Stream message. | |
| 128 do { | |
| 129 if (!ReadMessageFromFile(dump_file_, &event_msg)) { | |
| 130 return false; | |
| 131 } | |
| 132 | |
| 133 if (event_msg.type() == Event::INIT) { | |
| 134 RTC_CHECK(event_msg.has_init()); | |
| 135 HandleMessage(event_msg.init()); | |
| 136 | |
| 137 } else if (event_msg.type() == Event::STREAM) { | |
| 138 RTC_CHECK(event_msg.has_stream()); | |
| 139 HandleMessage(event_msg.stream()); | |
| 140 | |
| 141 } else if (event_msg.type() == Event::REVERSE_STREAM) { | |
| 142 RTC_CHECK(event_msg.has_reverse_stream()); | |
| 143 HandleMessage(event_msg.reverse_stream()); | |
| 144 } | |
| 145 } while (event_msg.type() != Event::STREAM); | |
| 146 | |
| 147 return true; | |
| 148 } | |
| 149 | |
| 150 void AecDumpFileProcessor::HandleMessage(const Init& msg) { | |
| 151 RTC_CHECK(msg.has_sample_rate()); | |
| 152 RTC_CHECK(msg.has_num_input_channels()); | |
| 153 RTC_CHECK(msg.has_num_reverse_channels()); | |
| 154 | |
| 155 in_buf_.reset(new ChannelBuffer<float>( | |
| 156 CheckedDivExact(msg.sample_rate(), kChunksPerSecond), | |
| 157 msg.num_input_channels())); | |
| 158 const int reverse_sample_rate = msg.has_reverse_sample_rate() | |
| 159 ? msg.reverse_sample_rate() | |
| 160 : msg.sample_rate(); | |
| 161 reverse_buf_.reset(new ChannelBuffer<float>( | |
| 162 CheckedDivExact(reverse_sample_rate, kChunksPerSecond), | |
| 163 msg.num_reverse_channels())); | |
| 164 input_config_ = StreamConfig(msg.sample_rate(), msg.num_input_channels()); | |
| 165 reverse_config_ = | |
| 166 StreamConfig(reverse_sample_rate, msg.num_reverse_channels()); | |
| 167 | |
| 168 const ProcessingConfig config = { | |
| 169 {input_config_, output_config_, reverse_config_, reverse_config_}}; | |
| 170 RTC_CHECK_EQ(kNoErr, ap_->Initialize(config)); | |
| 171 } | |
| 172 | |
| 173 void AecDumpFileProcessor::HandleMessage(const Stream& msg) { | |
| 174 RTC_CHECK(!msg.has_input_data()); | |
| 175 RTC_CHECK_EQ(in_buf_->num_channels(), | |
| 176 static_cast<size_t>(msg.input_channel_size())); | |
| 177 | |
| 178 for (int i = 0; i < msg.input_channel_size(); ++i) { | |
| 179 RTC_CHECK_EQ(in_buf_->num_frames() * sizeof(*in_buf_->channels()[i]), | |
| 180 msg.input_channel(i).size()); | |
| 181 std::memcpy(in_buf_->channels()[i], msg.input_channel(i).data(), | |
| 182 msg.input_channel(i).size()); | |
| 183 } | |
| 184 { | |
| 185 const auto st = ScopedTimer(mutable_proc_time()); | |
| 186 RTC_CHECK_EQ(kNoErr, ap_->set_stream_delay_ms(msg.delay())); | |
| 187 ap_->echo_cancellation()->set_stream_drift_samples(msg.drift()); | |
| 188 if (msg.has_keypress()) { | |
| 189 ap_->set_stream_key_pressed(msg.keypress()); | |
| 190 } | |
| 191 RTC_CHECK_EQ(kNoErr, | |
| 192 ap_->ProcessStream(in_buf_->channels(), input_config_, | |
| 193 output_config_, out_buf_.channels())); | |
| 194 } | |
| 195 | |
| 196 buffer_writer_.Write(out_buf_); | |
| 197 } | |
| 198 | |
| 199 void AecDumpFileProcessor::HandleMessage(const ReverseStream& msg) { | |
| 200 RTC_CHECK(!msg.has_data()); | |
| 201 RTC_CHECK_EQ(reverse_buf_->num_channels(), | |
| 202 static_cast<size_t>(msg.channel_size())); | |
| 203 | |
| 204 for (int i = 0; i < msg.channel_size(); ++i) { | |
| 205 RTC_CHECK_EQ(reverse_buf_->num_frames() * sizeof(*in_buf_->channels()[i]), | |
| 206 msg.channel(i).size()); | |
| 207 std::memcpy(reverse_buf_->channels()[i], msg.channel(i).data(), | |
| 208 msg.channel(i).size()); | |
| 209 } | |
| 210 { | |
| 211 const auto st = ScopedTimer(mutable_proc_time()); | |
| 212 // TODO(ajm): This currently discards the processed output, which is needed | |
| 213 // for e.g. intelligibility enhancement. | |
| 214 RTC_CHECK_EQ(kNoErr, ap_->ProcessReverseStream( | |
| 215 reverse_buf_->channels(), reverse_config_, | |
| 216 reverse_config_, reverse_buf_->channels())); | |
| 217 } | |
| 218 } | |
| 219 | |
| 220 } // namespace webrtc | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1907223003:
Extension and refactoring of the audioproc_f tool to be a fully fledged tool for audio processing m… (Closed)
Base URL: https://chromium.googlesource.com/external/webrtc.git@master