modules/audio_processing/aec_dump/aec_dump_impl.cc - src/webrtc - Git at Google

 /*
  *  Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */

 #include <utility>

 #include "webrtc/modules/audio_processing/aec_dump/aec_dump_impl.h"

 #include "webrtc/modules/audio_processing/aec_dump/aec_dump_factory.h"
 #include "webrtc/rtc_base/checks.h"
 #include "webrtc/rtc_base/event.h"
 #include "webrtc/rtc_base/ptr_util.h"

 namespace webrtc {

 namespace {
 void CopyFromConfigToEvent(const webrtc::InternalAPMConfig& config,
                            webrtc::audioproc::Config* pb_cfg) {
   pb_cfg->set_aec_enabled(config.aec_enabled);
   pb_cfg->set_aec_delay_agnostic_enabled(config.aec_delay_agnostic_enabled);
   pb_cfg->set_aec_drift_compensation_enabled(
       config.aec_drift_compensation_enabled);
   pb_cfg->set_aec_extended_filter_enabled(config.aec_extended_filter_enabled);
   pb_cfg->set_aec_suppression_level(config.aec_suppression_level);

   pb_cfg->set_aecm_enabled(config.aecm_enabled);
   pb_cfg->set_aecm_comfort_noise_enabled(config.aecm_comfort_noise_enabled);
   pb_cfg->set_aecm_routing_mode(config.aecm_routing_mode);

   pb_cfg->set_agc_enabled(config.agc_enabled);
   pb_cfg->set_agc_mode(config.agc_mode);
   pb_cfg->set_agc_limiter_enabled(config.agc_limiter_enabled);
   pb_cfg->set_noise_robust_agc_enabled(config.noise_robust_agc_enabled);

   pb_cfg->set_hpf_enabled(config.hpf_enabled);

   pb_cfg->set_ns_enabled(config.ns_enabled);
   pb_cfg->set_ns_level(config.ns_level);

   pb_cfg->set_transient_suppression_enabled(
       config.transient_suppression_enabled);
   pb_cfg->set_intelligibility_enhancer_enabled(
       config.intelligibility_enhancer_enabled);

   pb_cfg->set_experiments_description(config.experiments_description);
 }

 }  // namespace

 AecDumpImpl::AecDumpImpl(std::unique_ptr<FileWrapper> debug_file,
                          int64_t max_log_size_bytes,
                          rtc::TaskQueue* worker_queue)
     : debug_file_(std::move(debug_file)),
       num_bytes_left_for_log_(max_log_size_bytes),
       worker_queue_(worker_queue),
       capture_stream_info_(CreateWriteToFileTask()) {}

 AecDumpImpl::~AecDumpImpl() {
   // Block until all tasks have finished running.
   rtc::Event thread_sync_event(false /* manual_reset */, false);
   worker_queue_->PostTask([&thread_sync_event] { thread_sync_event.Set(); });
   // Wait until the event has been signaled with .Set(). By then all
   // pending tasks will have finished.
   thread_sync_event.Wait(rtc::Event::kForever);
 }

 void AecDumpImpl::WriteInitMessage(
     const InternalAPMStreamsConfig& streams_config) {
   auto task = CreateWriteToFileTask();
   auto* event = task->GetEvent();
   event->set_type(audioproc::Event::INIT);
   audioproc::Init* msg = event->mutable_init();

   msg->set_sample_rate(streams_config.input_sample_rate);
   msg->set_output_sample_rate(streams_config.output_sample_rate);
   msg->set_reverse_sample_rate(streams_config.render_input_sample_rate);
   msg->set_reverse_output_sample_rate(streams_config.render_output_sample_rate);

   msg->set_num_input_channels(
       static_cast<int32_t>(streams_config.input_num_channels));
   msg->set_num_output_channels(
       static_cast<int32_t>(streams_config.output_num_channels));
   msg->set_num_reverse_channels(
       static_cast<int32_t>(streams_config.render_input_num_channels));
   msg->set_num_reverse_output_channels(
       streams_config.render_output_num_channels);

   worker_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(std::move(task)));
 }

 void AecDumpImpl::AddCaptureStreamInput(const FloatAudioFrame& src) {
   capture_stream_info_.AddInput(src);
 }

 void AecDumpImpl::AddCaptureStreamOutput(const FloatAudioFrame& src) {
   capture_stream_info_.AddOutput(src);
 }

 void AecDumpImpl::AddCaptureStreamInput(const AudioFrame& frame) {
   capture_stream_info_.AddInput(frame);
 }

 void AecDumpImpl::AddCaptureStreamOutput(const AudioFrame& frame) {
   capture_stream_info_.AddOutput(frame);
 }

 void AecDumpImpl::AddAudioProcessingState(const AudioProcessingState& state) {
   capture_stream_info_.AddAudioProcessingState(state);
 }

 void AecDumpImpl::WriteCaptureStreamMessage() {
   auto task = capture_stream_info_.GetTask();
   RTC_DCHECK(task);
   std::move(task);
   worker_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(std::move(task)));
   capture_stream_info_.SetTask(CreateWriteToFileTask());
 }

 void AecDumpImpl::WriteRenderStreamMessage(const AudioFrame& frame) {
   auto task = CreateWriteToFileTask();
   auto* event = task->GetEvent();

   event->set_type(audioproc::Event::REVERSE_STREAM);
   audioproc::ReverseStream* msg = event->mutable_reverse_stream();
   const size_t data_size =
       sizeof(int16_t) * frame.samples_per_channel_ * frame.num_channels_;
   msg->set_data(frame.data(), data_size);

   worker_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(std::move(task)));
 }

 void AecDumpImpl::WriteRenderStreamMessage(const FloatAudioFrame& src) {
   auto task = CreateWriteToFileTask();
   auto* event = task->GetEvent();

   event->set_type(audioproc::Event::REVERSE_STREAM);

   audioproc::ReverseStream* msg = event->mutable_reverse_stream();

   for (size_t i = 0; i < src.num_channels(); ++i) {
     const auto& channel_view = src.channel(i);
     msg->add_channel(channel_view.begin(), sizeof(float) * channel_view.size());
   }

   worker_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(std::move(task)));
 }

 void AecDumpImpl::WriteConfig(const InternalAPMConfig& config) {
   RTC_DCHECK_RUNS_SERIALIZED(&race_checker_);
   auto task = CreateWriteToFileTask();
   auto* event = task->GetEvent();
   event->set_type(audioproc::Event::CONFIG);
   CopyFromConfigToEvent(config, event->mutable_config());
   worker_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(std::move(task)));
 }

 std::unique_ptr<WriteToFileTask> AecDumpImpl::CreateWriteToFileTask() {
   return rtc::MakeUnique<WriteToFileTask>(debug_file_.get(),
                                           &num_bytes_left_for_log_);
 }

 std::unique_ptr<AecDump> AecDumpFactory::Create(rtc::PlatformFile file,
                                                 int64_t max_log_size_bytes,
                                                 rtc::TaskQueue* worker_queue) {
   RTC_DCHECK(worker_queue);
   std::unique_ptr<FileWrapper> debug_file(FileWrapper::Create());
   FILE* handle = rtc::FdopenPlatformFileForWriting(file);
   if (!handle) {
     return nullptr;
   }
   if (!debug_file->OpenFromFileHandle(handle)) {
     return nullptr;
   }
   return rtc::MakeUnique<AecDumpImpl>(std::move(debug_file), max_log_size_bytes,
                                       worker_queue);
 }

 std::unique_ptr<AecDump> AecDumpFactory::Create(std::string file_name,
                                                 int64_t max_log_size_bytes,
                                                 rtc::TaskQueue* worker_queue) {
   RTC_DCHECK(worker_queue);
   std::unique_ptr<FileWrapper> debug_file(FileWrapper::Create());
   if (!debug_file->OpenFile(file_name.c_str(), false)) {
     return nullptr;
   }
   return rtc::MakeUnique<AecDumpImpl>(std::move(debug_file), max_log_size_bytes,
                                       worker_queue);
 }

 std::unique_ptr<AecDump> AecDumpFactory::Create(FILE* handle,
                                                 int64_t max_log_size_bytes,
                                                 rtc::TaskQueue* worker_queue) {
   RTC_DCHECK(worker_queue);
   RTC_DCHECK(handle);
   std::unique_ptr<FileWrapper> debug_file(FileWrapper::Create());
   if (!debug_file->OpenFromFileHandle(handle)) {
     return nullptr;
   }
   return rtc::MakeUnique<AecDumpImpl>(std::move(debug_file), max_log_size_bytes,
                                       worker_queue);
 }
 }  // namespace webrtc
	/*
	* Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
	*
	* Use of this source code is governed by a BSD-style license
	* that can be found in the LICENSE file in the root of the source
	* tree. An additional intellectual property rights grant can be found
	* in the file PATENTS. All contributing project authors may
	* be found in the AUTHORS file in the root of the source tree.
	*/

	#include <utility>

	#include "webrtc/modules/audio_processing/aec_dump/aec_dump_impl.h"

	#include "webrtc/modules/audio_processing/aec_dump/aec_dump_factory.h"
	#include "webrtc/rtc_base/checks.h"
	#include "webrtc/rtc_base/event.h"
	#include "webrtc/rtc_base/ptr_util.h"

	namespace webrtc {

	namespace {
	void CopyFromConfigToEvent(const webrtc::InternalAPMConfig& config,
	webrtc::audioproc::Config* pb_cfg) {
	pb_cfg->set_aec_enabled(config.aec_enabled);
	pb_cfg->set_aec_delay_agnostic_enabled(config.aec_delay_agnostic_enabled);
	pb_cfg->set_aec_drift_compensation_enabled(
	config.aec_drift_compensation_enabled);
	pb_cfg->set_aec_extended_filter_enabled(config.aec_extended_filter_enabled);
	pb_cfg->set_aec_suppression_level(config.aec_suppression_level);

	pb_cfg->set_aecm_enabled(config.aecm_enabled);
	pb_cfg->set_aecm_comfort_noise_enabled(config.aecm_comfort_noise_enabled);
	pb_cfg->set_aecm_routing_mode(config.aecm_routing_mode);

	pb_cfg->set_agc_enabled(config.agc_enabled);
	pb_cfg->set_agc_mode(config.agc_mode);
	pb_cfg->set_agc_limiter_enabled(config.agc_limiter_enabled);
	pb_cfg->set_noise_robust_agc_enabled(config.noise_robust_agc_enabled);

	pb_cfg->set_hpf_enabled(config.hpf_enabled);

	pb_cfg->set_ns_enabled(config.ns_enabled);
	pb_cfg->set_ns_level(config.ns_level);

	pb_cfg->set_transient_suppression_enabled(
	config.transient_suppression_enabled);
	pb_cfg->set_intelligibility_enhancer_enabled(
	config.intelligibility_enhancer_enabled);

	pb_cfg->set_experiments_description(config.experiments_description);
	}

	} // namespace

	AecDumpImpl::AecDumpImpl(std::unique_ptr<FileWrapper> debug_file,
	int64_t max_log_size_bytes,
	rtc::TaskQueue* worker_queue)
	: debug_file_(std::move(debug_file)),
	num_bytes_left_for_log_(max_log_size_bytes),
	worker_queue_(worker_queue),
	capture_stream_info_(CreateWriteToFileTask()) {}

	AecDumpImpl::~AecDumpImpl() {
	// Block until all tasks have finished running.
	rtc::Event thread_sync_event(false /* manual_reset */, false);
	worker_queue_->PostTask([&thread_sync_event] { thread_sync_event.Set(); });
	// Wait until the event has been signaled with .Set(). By then all
	// pending tasks will have finished.
	thread_sync_event.Wait(rtc::Event::kForever);
	}

	void AecDumpImpl::WriteInitMessage(
	const InternalAPMStreamsConfig& streams_config) {
	auto task = CreateWriteToFileTask();
	auto* event = task->GetEvent();
	event->set_type(audioproc::Event::INIT);
	audioproc::Init* msg = event->mutable_init();

	msg->set_sample_rate(streams_config.input_sample_rate);
	msg->set_output_sample_rate(streams_config.output_sample_rate);
	msg->set_reverse_sample_rate(streams_config.render_input_sample_rate);
	msg->set_reverse_output_sample_rate(streams_config.render_output_sample_rate);

	msg->set_num_input_channels(
	static_cast<int32_t>(streams_config.input_num_channels));
	msg->set_num_output_channels(
	static_cast<int32_t>(streams_config.output_num_channels));
	msg->set_num_reverse_channels(
	static_cast<int32_t>(streams_config.render_input_num_channels));
	msg->set_num_reverse_output_channels(
	streams_config.render_output_num_channels);

	worker_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(std::move(task)));
	}

	void AecDumpImpl::AddCaptureStreamInput(const FloatAudioFrame& src) {
	capture_stream_info_.AddInput(src);
	}

	void AecDumpImpl::AddCaptureStreamOutput(const FloatAudioFrame& src) {
	capture_stream_info_.AddOutput(src);
	}

	void AecDumpImpl::AddCaptureStreamInput(const AudioFrame& frame) {
	capture_stream_info_.AddInput(frame);
	}

	void AecDumpImpl::AddCaptureStreamOutput(const AudioFrame& frame) {
	capture_stream_info_.AddOutput(frame);
	}

	void AecDumpImpl::AddAudioProcessingState(const AudioProcessingState& state) {
	capture_stream_info_.AddAudioProcessingState(state);
	}

	void AecDumpImpl::WriteCaptureStreamMessage() {
	auto task = capture_stream_info_.GetTask();
	RTC_DCHECK(task);
	std::move(task);
	worker_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(std::move(task)));
	capture_stream_info_.SetTask(CreateWriteToFileTask());
	}

	void AecDumpImpl::WriteRenderStreamMessage(const AudioFrame& frame) {
	auto task = CreateWriteToFileTask();
	auto* event = task->GetEvent();

	event->set_type(audioproc::Event::REVERSE_STREAM);
	audioproc::ReverseStream* msg = event->mutable_reverse_stream();
	const size_t data_size =
	sizeof(int16_t) * frame.samples_per_channel_ * frame.num_channels_;
	msg->set_data(frame.data(), data_size);

	worker_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(std::move(task)));
	}

	void AecDumpImpl::WriteRenderStreamMessage(const FloatAudioFrame& src) {
	auto task = CreateWriteToFileTask();
	auto* event = task->GetEvent();

	event->set_type(audioproc::Event::REVERSE_STREAM);

	audioproc::ReverseStream* msg = event->mutable_reverse_stream();

	for (size_t i = 0; i < src.num_channels(); ++i) {
	const auto& channel_view = src.channel(i);
	msg->add_channel(channel_view.begin(), sizeof(float) * channel_view.size());
	}

	worker_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(std::move(task)));
	}

	void AecDumpImpl::WriteConfig(const InternalAPMConfig& config) {
	RTC_DCHECK_RUNS_SERIALIZED(&race_checker_);
	auto task = CreateWriteToFileTask();
	auto* event = task->GetEvent();
	event->set_type(audioproc::Event::CONFIG);
	CopyFromConfigToEvent(config, event->mutable_config());
	worker_queue_->PostTask(std::unique_ptr<rtc::QueuedTask>(std::move(task)));
	}

	std::unique_ptr<WriteToFileTask> AecDumpImpl::CreateWriteToFileTask() {
	return rtc::MakeUnique<WriteToFileTask>(debug_file_.get(),
	&num_bytes_left_for_log_);
	}

	std::unique_ptr<AecDump> AecDumpFactory::Create(rtc::PlatformFile file,
	int64_t max_log_size_bytes,
	rtc::TaskQueue* worker_queue) {
	RTC_DCHECK(worker_queue);
	std::unique_ptr<FileWrapper> debug_file(FileWrapper::Create());
	FILE* handle = rtc::FdopenPlatformFileForWriting(file);
	if (!handle) {
	return nullptr;
	}
	if (!debug_file->OpenFromFileHandle(handle)) {
	return nullptr;
	}
	return rtc::MakeUnique<AecDumpImpl>(std::move(debug_file), max_log_size_bytes,
	worker_queue);
	}

	std::unique_ptr<AecDump> AecDumpFactory::Create(std::string file_name,
	int64_t max_log_size_bytes,
	rtc::TaskQueue* worker_queue) {
	RTC_DCHECK(worker_queue);
	std::unique_ptr<FileWrapper> debug_file(FileWrapper::Create());
	if (!debug_file->OpenFile(file_name.c_str(), false)) {
	return nullptr;
	}
	return rtc::MakeUnique<AecDumpImpl>(std::move(debug_file), max_log_size_bytes,
	worker_queue);
	}

	std::unique_ptr<AecDump> AecDumpFactory::Create(FILE* handle,
	int64_t max_log_size_bytes,
	rtc::TaskQueue* worker_queue) {
	RTC_DCHECK(worker_queue);
	RTC_DCHECK(handle);
	std::unique_ptr<FileWrapper> debug_file(FileWrapper::Create());
	if (!debug_file->OpenFromFileHandle(handle)) {
	return nullptr;
	}
	return rtc::MakeUnique<AecDumpImpl>(std::move(debug_file), max_log_size_bytes,
	worker_queue);
	}
	} // namespace webrtc