OLD | NEW |
(Empty) | |
| 1 /* |
| 2 * Copyright (c) 2017 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/modules/audio_processing/aec_dump/aec_dump_impl.h" |
| 14 |
| 15 #include "webrtc/base/checks.h" |
| 16 #include "webrtc/base/event.h" |
| 17 #include "webrtc/base/ptr_util.h" |
| 18 #include "webrtc/modules/audio_processing/aec_dump/aec_dump_factory.h" |
| 19 |
| 20 namespace webrtc { |
| 21 |
| 22 namespace { |
| 23 void CopyFromConfigToEvent(const webrtc::InternalAPMConfig& config, |
| 24 webrtc::audioproc::Config* pb_cfg) { |
| 25 pb_cfg->set_aec_enabled(config.aec_enabled); |
| 26 pb_cfg->set_aec_delay_agnostic_enabled(config.aec_delay_agnostic_enabled); |
| 27 pb_cfg->set_aec_drift_compensation_enabled( |
| 28 config.aec_drift_compensation_enabled); |
| 29 pb_cfg->set_aec_extended_filter_enabled(config.aec_extended_filter_enabled); |
| 30 pb_cfg->set_aec_suppression_level(config.aec_suppression_level); |
| 31 |
| 32 pb_cfg->set_aecm_enabled(config.aecm_enabled); |
| 33 pb_cfg->set_aecm_comfort_noise_enabled(config.aecm_comfort_noise_enabled); |
| 34 pb_cfg->set_aecm_routing_mode(config.aecm_routing_mode); |
| 35 |
| 36 pb_cfg->set_agc_enabled(config.agc_enabled); |
| 37 pb_cfg->set_agc_mode(config.agc_mode); |
| 38 pb_cfg->set_agc_limiter_enabled(config.agc_limiter_enabled); |
| 39 pb_cfg->set_noise_robust_agc_enabled(config.noise_robust_agc_enabled); |
| 40 |
| 41 pb_cfg->set_hpf_enabled(config.hpf_enabled); |
| 42 |
| 43 pb_cfg->set_ns_enabled(config.ns_enabled); |
| 44 pb_cfg->set_ns_level(config.ns_level); |
| 45 |
| 46 pb_cfg->set_transient_suppression_enabled( |
| 47 config.transient_suppression_enabled); |
| 48 pb_cfg->set_intelligibility_enhancer_enabled( |
| 49 config.intelligibility_enhancer_enabled); |
| 50 |
| 51 pb_cfg->set_experiments_description(config.experiments_description); |
| 52 } |
| 53 |
| 54 } // namespace |
| 55 |
| 56 AecDumpImpl::AecDumpImpl(std::unique_ptr<FileWrapper> debug_file, |
| 57 int64_t max_log_size_bytes, |
| 58 rtc::TaskQueue* worker_queue) |
| 59 : debug_file_(std::move(debug_file)), |
| 60 num_bytes_left_for_log_(max_log_size_bytes), |
| 61 worker_queue_(worker_queue), |
| 62 capture_stream_info_(CreateWriteToFileTask()) {} |
| 63 |
| 64 AecDumpImpl::~AecDumpImpl() { |
| 65 // Block until all tasks have finished running. |
| 66 rtc::Event thread_sync_event(false /* manual_reset */, false); |
| 67 worker_queue_->PostTask([&thread_sync_event] { thread_sync_event.Set(); }); |
| 68 // Wait until the event has been signaled with .Set(). By then all |
| 69 // pending tasks will have finished. |
| 70 thread_sync_event.Wait(rtc::Event::kForever); |
| 71 } |
| 72 |
| 73 void AecDumpImpl::WriteInitMessage( |
| 74 const InternalAPMStreamsConfig& streams_config) { |
| 75 auto task = CreateWriteToFileTask(); |
| 76 auto* event = task->GetEvent(); |
| 77 event->set_type(audioproc::Event::INIT); |
| 78 audioproc::Init* msg = event->mutable_init(); |
| 79 |
| 80 msg->set_sample_rate(streams_config.input_sample_rate); |
| 81 msg->set_output_sample_rate(streams_config.output_sample_rate); |
| 82 msg->set_reverse_sample_rate(streams_config.render_input_sample_rate); |
| 83 msg->set_reverse_output_sample_rate(streams_config.render_output_sample_rate); |
| 84 |
| 85 msg->set_num_input_channels( |
| 86 static_cast<int32_t>(streams_config.input_num_channels)); |
| 87 msg->set_num_output_channels( |
| 88 static_cast<int32_t>(streams_config.output_num_channels)); |
| 89 msg->set_num_reverse_channels( |
| 90 static_cast<int32_t>(streams_config.render_input_num_channels)); |
| 91 msg->set_num_reverse_output_channels( |
| 92 streams_config.render_output_num_channels); |
| 93 |
| 94 worker_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(std::move(task))); |
| 95 } |
| 96 |
| 97 void AecDumpImpl::AddCaptureStreamInput(const FloatAudioFrame& src) { |
| 98 capture_stream_info_.AddInput(src); |
| 99 } |
| 100 |
| 101 void AecDumpImpl::AddCaptureStreamOutput(const FloatAudioFrame& src) { |
| 102 capture_stream_info_.AddOutput(src); |
| 103 } |
| 104 |
| 105 void AecDumpImpl::AddCaptureStreamInput(const AudioFrame& frame) { |
| 106 capture_stream_info_.AddInput(frame); |
| 107 } |
| 108 |
| 109 void AecDumpImpl::AddCaptureStreamOutput(const AudioFrame& frame) { |
| 110 capture_stream_info_.AddOutput(frame); |
| 111 } |
| 112 |
| 113 void AecDumpImpl::AddAudioProcessingState(const AudioProcessingState& state) { |
| 114 capture_stream_info_.AddAudioProcessingState(state); |
| 115 } |
| 116 |
| 117 void AecDumpImpl::WriteCaptureStreamMessage() { |
| 118 auto task = capture_stream_info_.GetTask(); |
| 119 RTC_DCHECK(task); |
| 120 std::move(task); |
| 121 worker_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(std::move(task))); |
| 122 capture_stream_info_.SetTask(CreateWriteToFileTask()); |
| 123 } |
| 124 |
| 125 void AecDumpImpl::WriteRenderStreamMessage(const AudioFrame& frame) { |
| 126 auto task = CreateWriteToFileTask(); |
| 127 auto* event = task->GetEvent(); |
| 128 |
| 129 event->set_type(audioproc::Event::REVERSE_STREAM); |
| 130 audioproc::ReverseStream* msg = event->mutable_reverse_stream(); |
| 131 const size_t data_size = |
| 132 sizeof(int16_t) * frame.samples_per_channel_ * frame.num_channels_; |
| 133 msg->set_data(frame.data_, data_size); |
| 134 |
| 135 worker_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(std::move(task))); |
| 136 } |
| 137 |
| 138 void AecDumpImpl::WriteRenderStreamMessage(const FloatAudioFrame& src) { |
| 139 auto task = CreateWriteToFileTask(); |
| 140 auto* event = task->GetEvent(); |
| 141 |
| 142 event->set_type(audioproc::Event::REVERSE_STREAM); |
| 143 |
| 144 audioproc::ReverseStream* msg = event->mutable_reverse_stream(); |
| 145 |
| 146 for (size_t i = 0; i < src.num_channels(); ++i) { |
| 147 const auto& channel_view = src.channel(i); |
| 148 msg->add_channel(channel_view.begin(), sizeof(float) * channel_view.size()); |
| 149 } |
| 150 |
| 151 worker_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(std::move(task))); |
| 152 } |
| 153 |
| 154 void AecDumpImpl::WriteConfig(const InternalAPMConfig& config) { |
| 155 RTC_DCHECK_RUNS_SERIALIZED(&race_checker_); |
| 156 auto task = CreateWriteToFileTask(); |
| 157 auto* event = task->GetEvent(); |
| 158 event->set_type(audioproc::Event::CONFIG); |
| 159 CopyFromConfigToEvent(config, event->mutable_config()); |
| 160 worker_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(std::move(task))); |
| 161 } |
| 162 |
| 163 std::unique_ptr<WriteToFileTask> AecDumpImpl::CreateWriteToFileTask() { |
| 164 return rtc::MakeUnique<WriteToFileTask>(debug_file_.get(), |
| 165 &num_bytes_left_for_log_); |
| 166 } |
| 167 |
| 168 std::unique_ptr<AecDump> AecDumpFactory::Create(rtc::PlatformFile file, |
| 169 int64_t max_log_size_bytes, |
| 170 rtc::TaskQueue* worker_queue) { |
| 171 RTC_DCHECK(worker_queue); |
| 172 std::unique_ptr<FileWrapper> debug_file(FileWrapper::Create()); |
| 173 FILE* handle = rtc::FdopenPlatformFileForWriting(file); |
| 174 if (!handle) { |
| 175 return nullptr; |
| 176 } |
| 177 if (!debug_file->OpenFromFileHandle(handle)) { |
| 178 return nullptr; |
| 179 } |
| 180 return rtc::MakeUnique<AecDumpImpl>(std::move(debug_file), max_log_size_bytes, |
| 181 worker_queue); |
| 182 } |
| 183 |
| 184 std::unique_ptr<AecDump> AecDumpFactory::Create(std::string file_name, |
| 185 int64_t max_log_size_bytes, |
| 186 rtc::TaskQueue* worker_queue) { |
| 187 RTC_DCHECK(worker_queue); |
| 188 std::unique_ptr<FileWrapper> debug_file(FileWrapper::Create()); |
| 189 if (!debug_file->OpenFile(file_name.c_str(), false)) { |
| 190 return nullptr; |
| 191 } |
| 192 return rtc::MakeUnique<AecDumpImpl>(std::move(debug_file), max_log_size_bytes, |
| 193 worker_queue); |
| 194 } |
| 195 |
| 196 std::unique_ptr<AecDump> AecDumpFactory::Create(FILE* handle, |
| 197 int64_t max_log_size_bytes, |
| 198 rtc::TaskQueue* worker_queue) { |
| 199 RTC_DCHECK(worker_queue); |
| 200 RTC_DCHECK(handle); |
| 201 std::unique_ptr<FileWrapper> debug_file(FileWrapper::Create()); |
| 202 if (!debug_file->OpenFromFileHandle(handle)) { |
| 203 return nullptr; |
| 204 } |
| 205 return rtc::MakeUnique<AecDumpImpl>(std::move(debug_file), max_log_size_bytes, |
| 206 worker_queue); |
| 207 } |
| 208 } // namespace webrtc |
OLD | NEW |