src/media/audio/audio_core/reporter.cc - fuchsia - Git at Google

 // Copyright 2019 The Fuchsia Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.

 #include "src/media/audio/audio_core/reporter.h"

 #include "src/lib/fxl/logging.h"
 #include "src/media/audio/audio_core/audio_device.h"

 namespace media::audio {

 #if ENABLE_REPORTER

 // static
 Reporter& Reporter::Singleton() {
   static Reporter singleton;
   return singleton;
 }

 void Reporter::Init(sys::ComponentContext* component_context) {
   FXL_DCHECK(component_context);
   FXL_DCHECK(!component_context_);
   component_context_ = component_context;

   inspector_ = inspect_deprecated::ComponentInspector::Initialize(component_context_);
   inspect_deprecated::Node& root_node = inspector_->root_tree()->GetRoot();
   failed_to_open_device_count_ = root_node.CreateUIntMetric("count of failures to open device", 0);
   failed_to_obtain_fdio_service_channel_count_ =
       root_node.CreateUIntMetric("count of failures to obtain device fdio service channel", 0);
   failed_to_obtain_stream_channel_count_ =
       root_node.CreateUIntMetric("count of failures to obtain device stream channel", 0);
   device_startup_failed_count_ =
       root_node.CreateUIntMetric("count of failures to start a device", 0);

   outputs_node_ = root_node.CreateChild("output devices");
   inputs_node_ = root_node.CreateChild("input devices");
   renderers_node_ = root_node.CreateChild("renderers");
   capturers_node_ = root_node.CreateChild("capturers");
 }

 void Reporter::FailedToOpenDevice(const std::string& name, bool is_input, int err) {
   failed_to_open_device_count_.Add(1);
 }

 void Reporter::FailedToObtainFdioServiceChannel(const std::string& name, bool is_input,
                                                 zx_status_t status) {
   failed_to_obtain_fdio_service_channel_count_.Add(1);
 }

 void Reporter::FailedToObtainStreamChannel(const std::string& name, bool is_input,
                                            zx_status_t status) {
   failed_to_obtain_stream_channel_count_.Add(1);
 }

 void Reporter::AddingDevice(const std::string& name, const AudioDevice& device) {
   if (device.is_output()) {
     outputs_.emplace(&device, Output(outputs_node_.CreateChild(name)));
   } else {
     FXL_DCHECK(device.is_input());
     inputs_.emplace(&device, Input(inputs_node_.CreateChild(name)));
   }
 }

 void Reporter::RemovingDevice(const AudioDevice& device) {
   if (device.is_output()) {
     outputs_.erase(&device);
   } else {
     FXL_DCHECK(device.is_input());
     inputs_.erase(&device);
   }
 }

 void Reporter::DeviceStartupFailed(const AudioDevice& device) {
   device_startup_failed_count_.Add(1);
 }

 void Reporter::IgnoringDevice(const AudioDevice& device) {
   // Not reporting this via inspect.
 }

 void Reporter::ActivatingDevice(const AudioDevice& device) {
   // Not reporting this via inspect...devices not activated are quickly removed.
 }

 void Reporter::SettingDeviceGainInfo(const AudioDevice& device,
                                      const fuchsia::media::AudioGainInfo& gain_info,
                                      uint32_t set_flags) {
   Device* d = device.is_output() ? FindOutput(device) : FindInput(device);
   if (d == nullptr) {
     FXL_DLOG(FATAL);
     return;
   }

   if (set_flags & fuchsia::media::SetAudioGainFlag_GainValid) {
     d->gain_db_.Set(gain_info.gain_db);
   }

   if (set_flags & fuchsia::media::SetAudioGainFlag_MuteValid) {
     d->muted_.Set((gain_info.flags & fuchsia::media::AudioGainInfoFlag_Mute) ? 1 : 0);
   }

   if (set_flags & fuchsia::media::SetAudioGainFlag_AgcValid) {
     d->agc_supported_.Set((gain_info.flags & fuchsia::media::AudioGainInfoFlag_AgcSupported) ? 1
                                                                                              : 0);
     d->agc_enabled_.Set((gain_info.flags & fuchsia::media::AudioGainInfoFlag_AgcEnabled) ? 1 : 0);
   }
 }

 void Reporter::AddingRenderer(const AudioRendererImpl& renderer) {
   renderers_.emplace(&renderer, Renderer(renderers_node_.CreateChild(NextRendererName())));
 }

 void Reporter::RemovingRenderer(const AudioRendererImpl& renderer) { renderers_.erase(&renderer); }

 void Reporter::SettingRendererStreamType(const AudioRendererImpl& renderer,
                                          const fuchsia::media::AudioStreamType& stream_type) {
   Renderer* r = FindRenderer(renderer);
   if (r == nullptr) {
     FXL_DLOG(FATAL);
     return;
   }

   r->sample_format_.Set(static_cast<uint64_t>(stream_type.sample_format));
   r->channels_.Set(stream_type.channels);
   r->frames_per_second_.Set(stream_type.frames_per_second);
 }

 void Reporter::AddingRendererPayloadBuffer(const AudioRendererImpl& renderer, uint32_t buffer_id,
                                            uint64_t size) {
   Renderer* r = FindRenderer(renderer);
   if (r == nullptr) {
     FXL_DLOG(FATAL);
     return;
   }

   r->payload_buffers_.emplace(
       buffer_id,
       PayloadBuffer(r->payload_buffers_node_.CreateChild(std::to_string(buffer_id)), size));
 }

 void Reporter::RemovingRendererPayloadBuffer(const AudioRendererImpl& renderer,
                                              uint32_t buffer_id) {
   Renderer* r = FindRenderer(renderer);
   if (r == nullptr) {
     FXL_DLOG(FATAL);
     return;
   }
   r->payload_buffers_.erase(buffer_id);
 }

 void Reporter::SendingRendererPacket(const AudioRendererImpl& renderer,
                                      const fuchsia::media::StreamPacket& packet) {
   Renderer* r = FindRenderer(renderer);
   if (r == nullptr) {
     FXL_DLOG(FATAL);
     return;
   }
   auto payload_buffer = r->payload_buffers_.find(packet.payload_buffer_id);
   if (payload_buffer == r->payload_buffers_.end()) {
     FXL_DLOG(FATAL);
     return;
   }
   payload_buffer->second.packets_.Add(1);
 }

 void Reporter::SettingRendererGain(const AudioRendererImpl& renderer, float gain_db) {
   Renderer* r = FindRenderer(renderer);
   if (r == nullptr) {
     FXL_DLOG(FATAL);
     return;
   }

   r->gain_db_.Set(gain_db);
 }

 void Reporter::SettingRendererGainWithRamp(const AudioRendererImpl& renderer, float gain_db,
                                            zx_duration_t duration_ns,
                                            fuchsia::media::audio::RampType ramp_type) {
   Renderer* r = FindRenderer(renderer);
   if (r == nullptr) {
     FXL_DLOG(FATAL);
     return;
   }

   // Just counting these for now.
   r->set_gain_with_ramp_calls_.Add(1);
 }

 void Reporter::SettingRendererMute(const AudioRendererImpl& renderer, bool muted) {
   Renderer* r = FindRenderer(renderer);
   if (r == nullptr) {
     FXL_DLOG(FATAL);
     return;
   }

   r->muted_.Set(muted);
 }

 void Reporter::SettingRendererMinClockLeadTime(const AudioRendererImpl& renderer,
                                                int64_t min_clock_lead_time_ns) {
   Renderer* r = FindRenderer(renderer);
   if (r == nullptr) {
     FXL_DLOG(FATAL);
     return;
   }

   r->min_clock_lead_time_ns_.Set(static_cast<uint64_t>(min_clock_lead_time_ns));
 }

 void Reporter::SettingRendererPtsContinuityThreshold(const AudioRendererImpl& renderer,
                                                      float threshold_seconds) {
   Renderer* r = FindRenderer(renderer);
   if (r == nullptr) {
     FXL_DLOG(FATAL);
     return;
   }

   r->pts_continuity_threshold_seconds_.Set(threshold_seconds);
 }

 void Reporter::AddingCapturer(const AudioCapturerImpl& capturer) {
   capturers_.emplace(&capturer, Capturer(capturers_node_.CreateChild(NextCapturerName())));
 }

 void Reporter::RemovingCapturer(const AudioCapturerImpl& capturer) { capturers_.erase(&capturer); }

 void Reporter::SettingCapturerStreamType(const AudioCapturerImpl& capturer,
                                          const fuchsia::media::AudioStreamType& stream_type) {
   Capturer* c = FindCapturer(capturer);
   if (c == nullptr) {
     FXL_DLOG(FATAL);
     return;
   }

   c->sample_format_.Set(static_cast<uint64_t>(stream_type.sample_format));
   c->channels_.Set(stream_type.channels);
   c->frames_per_second_.Set(stream_type.frames_per_second);
 }

 void Reporter::AddingCapturerPayloadBuffer(const AudioCapturerImpl& capturer, uint32_t buffer_id,
                                            uint64_t size) {
   Capturer* c = FindCapturer(capturer);
   if (c == nullptr) {
     FXL_DLOG(FATAL);
     return;
   }

   c->payload_buffers_.emplace(
       buffer_id,
       PayloadBuffer(c->payload_buffers_node_.CreateChild(std::to_string(buffer_id)), size));
 }

 void Reporter::SendingCapturerPacket(const AudioCapturerImpl& capturer,
                                      const fuchsia::media::StreamPacket& packet) {
   Capturer* c = FindCapturer(capturer);
   if (c == nullptr) {
     FXL_DLOG(FATAL);
     return;
   }
   auto payload_buffer = c->payload_buffers_.find(packet.payload_buffer_id);
   if (payload_buffer == c->payload_buffers_.end()) {
     FXL_DLOG(FATAL);
     return;
   }
   payload_buffer->second.packets_.Add(1);
 }

 void Reporter::SettingCapturerGain(const AudioCapturerImpl& capturer, float gain_db) {
   Capturer* c = FindCapturer(capturer);
   if (c == nullptr) {
     FXL_DLOG(FATAL);
     return;
   }

   c->gain_db_.Set(gain_db);
 }

 void Reporter::SettingCapturerGainWithRamp(const AudioCapturerImpl& capturer, float gain_db,
                                            zx_duration_t duration_ns,
                                            fuchsia::media::audio::RampType ramp_type) {
   Capturer* c = FindCapturer(capturer);
   if (c == nullptr) {
     FXL_DLOG(FATAL);
     return;
   }

   // Just counting these for now.
   c->set_gain_with_ramp_calls_.Add(1);
 }

 void Reporter::SettingCapturerMute(const AudioCapturerImpl& capturer, bool muted) {
   Capturer* c = FindCapturer(capturer);
   if (c == nullptr) {
     FXL_DLOG(FATAL);
     return;
   }

   c->muted_.Set(muted);
 }

 Reporter::Device* Reporter::FindOutput(const AudioDevice& device) {
   auto i = outputs_.find(&device);
   return i == outputs_.end() ? nullptr : &i->second;
 }

 Reporter::Device* Reporter::FindInput(const AudioDevice& device) {
   auto i = inputs_.find(&device);
   return i == inputs_.end() ? nullptr : &i->second;
 }

 Reporter::Renderer* Reporter::FindRenderer(const AudioRendererImpl& renderer) {
   auto i = renderers_.find(&renderer);
   return i == renderers_.end() ? nullptr : &i->second;
 }

 Reporter::Capturer* Reporter::FindCapturer(const AudioCapturerImpl& capturer) {
   auto i = capturers_.find(&capturer);
   return i == capturers_.end() ? nullptr : &i->second;
 }

 std::string Reporter::NextRendererName() {
   std::ostringstream os;
   os << ++next_renderer_name_;
   return os.str();
 }

 std::string Reporter::NextCapturerName() {
   std::ostringstream os;
   os << ++next_capturer_name_;
   return os.str();
 }

 #endif  // ENABLE_REPORTER

 }  // namespace media::audio
	// Copyright 2019 The Fuchsia Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be found in the LICENSE file.

	#include "src/media/audio/audio_core/reporter.h"

	#include "src/lib/fxl/logging.h"
	#include "src/media/audio/audio_core/audio_device.h"

	namespace media::audio {

	#if ENABLE_REPORTER

	// static
	Reporter& Reporter::Singleton() {
	static Reporter singleton;
	return singleton;
	}

	void Reporter::Init(sys::ComponentContext* component_context) {
	FXL_DCHECK(component_context);
	FXL_DCHECK(!component_context_);
	component_context_ = component_context;

	inspector_ = inspect_deprecated::ComponentInspector::Initialize(component_context_);
	inspect_deprecated::Node& root_node = inspector_->root_tree()->GetRoot();
	failed_to_open_device_count_ = root_node.CreateUIntMetric("count of failures to open device", 0);
	failed_to_obtain_fdio_service_channel_count_ =
	root_node.CreateUIntMetric("count of failures to obtain device fdio service channel", 0);
	failed_to_obtain_stream_channel_count_ =
	root_node.CreateUIntMetric("count of failures to obtain device stream channel", 0);
	device_startup_failed_count_ =
	root_node.CreateUIntMetric("count of failures to start a device", 0);

	outputs_node_ = root_node.CreateChild("output devices");
	inputs_node_ = root_node.CreateChild("input devices");
	renderers_node_ = root_node.CreateChild("renderers");
	capturers_node_ = root_node.CreateChild("capturers");
	}

	void Reporter::FailedToOpenDevice(const std::string& name, bool is_input, int err) {
	failed_to_open_device_count_.Add(1);
	}

	void Reporter::FailedToObtainFdioServiceChannel(const std::string& name, bool is_input,
	zx_status_t status) {
	failed_to_obtain_fdio_service_channel_count_.Add(1);
	}

	void Reporter::FailedToObtainStreamChannel(const std::string& name, bool is_input,
	zx_status_t status) {
	failed_to_obtain_stream_channel_count_.Add(1);
	}

	void Reporter::AddingDevice(const std::string& name, const AudioDevice& device) {
	if (device.is_output()) {
	outputs_.emplace(&device, Output(outputs_node_.CreateChild(name)));
	} else {
	FXL_DCHECK(device.is_input());
	inputs_.emplace(&device, Input(inputs_node_.CreateChild(name)));
	}
	}

	void Reporter::RemovingDevice(const AudioDevice& device) {
	if (device.is_output()) {
	outputs_.erase(&device);
	} else {
	FXL_DCHECK(device.is_input());
	inputs_.erase(&device);
	}
	}

	void Reporter::DeviceStartupFailed(const AudioDevice& device) {
	device_startup_failed_count_.Add(1);
	}

	void Reporter::IgnoringDevice(const AudioDevice& device) {
	// Not reporting this via inspect.
	}

	void Reporter::ActivatingDevice(const AudioDevice& device) {
	// Not reporting this via inspect...devices not activated are quickly removed.
	}

	void Reporter::SettingDeviceGainInfo(const AudioDevice& device,
	const fuchsia::media::AudioGainInfo& gain_info,
	uint32_t set_flags) {
	Device* d = device.is_output() ? FindOutput(device) : FindInput(device);
	if (d == nullptr) {
	FXL_DLOG(FATAL);
	return;
	}

	if (set_flags & fuchsia::media::SetAudioGainFlag_GainValid) {
	d->gain_db_.Set(gain_info.gain_db);
	}

	if (set_flags & fuchsia::media::SetAudioGainFlag_MuteValid) {
	d->muted_.Set((gain_info.flags & fuchsia::media::AudioGainInfoFlag_Mute) ? 1 : 0);
	}

	if (set_flags & fuchsia::media::SetAudioGainFlag_AgcValid) {
	d->agc_supported_.Set((gain_info.flags & fuchsia::media::AudioGainInfoFlag_AgcSupported) ? 1
	: 0);
	d->agc_enabled_.Set((gain_info.flags & fuchsia::media::AudioGainInfoFlag_AgcEnabled) ? 1 : 0);
	}
	}

	void Reporter::AddingRenderer(const AudioRendererImpl& renderer) {
	renderers_.emplace(&renderer, Renderer(renderers_node_.CreateChild(NextRendererName())));
	}

	void Reporter::RemovingRenderer(const AudioRendererImpl& renderer) { renderers_.erase(&renderer); }

	void Reporter::SettingRendererStreamType(const AudioRendererImpl& renderer,
	const fuchsia::media::AudioStreamType& stream_type) {
	Renderer* r = FindRenderer(renderer);
	if (r == nullptr) {
	FXL_DLOG(FATAL);
	return;
	}

	r->sample_format_.Set(static_cast<uint64_t>(stream_type.sample_format));
	r->channels_.Set(stream_type.channels);
	r->frames_per_second_.Set(stream_type.frames_per_second);
	}

	void Reporter::AddingRendererPayloadBuffer(const AudioRendererImpl& renderer, uint32_t buffer_id,
	uint64_t size) {
	Renderer* r = FindRenderer(renderer);
	if (r == nullptr) {
	FXL_DLOG(FATAL);
	return;
	}

	r->payload_buffers_.emplace(
	buffer_id,
	PayloadBuffer(r->payload_buffers_node_.CreateChild(std::to_string(buffer_id)), size));
	}

	void Reporter::RemovingRendererPayloadBuffer(const AudioRendererImpl& renderer,
	uint32_t buffer_id) {
	Renderer* r = FindRenderer(renderer);
	if (r == nullptr) {
	FXL_DLOG(FATAL);
	return;
	}
	r->payload_buffers_.erase(buffer_id);
	}

	void Reporter::SendingRendererPacket(const AudioRendererImpl& renderer,
	const fuchsia::media::StreamPacket& packet) {
	Renderer* r = FindRenderer(renderer);
	if (r == nullptr) {
	FXL_DLOG(FATAL);
	return;
	}
	auto payload_buffer = r->payload_buffers_.find(packet.payload_buffer_id);
	if (payload_buffer == r->payload_buffers_.end()) {
	FXL_DLOG(FATAL);
	return;
	}
	payload_buffer->second.packets_.Add(1);
	}

	void Reporter::SettingRendererGain(const AudioRendererImpl& renderer, float gain_db) {
	Renderer* r = FindRenderer(renderer);
	if (r == nullptr) {
	FXL_DLOG(FATAL);
	return;
	}

	r->gain_db_.Set(gain_db);
	}

	void Reporter::SettingRendererGainWithRamp(const AudioRendererImpl& renderer, float gain_db,
	zx_duration_t duration_ns,
	fuchsia::media::audio::RampType ramp_type) {
	Renderer* r = FindRenderer(renderer);
	if (r == nullptr) {
	FXL_DLOG(FATAL);
	return;
	}

	// Just counting these for now.
	r->set_gain_with_ramp_calls_.Add(1);
	}

	void Reporter::SettingRendererMute(const AudioRendererImpl& renderer, bool muted) {
	Renderer* r = FindRenderer(renderer);
	if (r == nullptr) {
	FXL_DLOG(FATAL);
	return;
	}

	r->muted_.Set(muted);
	}

	void Reporter::SettingRendererMinClockLeadTime(const AudioRendererImpl& renderer,
	int64_t min_clock_lead_time_ns) {
	Renderer* r = FindRenderer(renderer);
	if (r == nullptr) {
	FXL_DLOG(FATAL);
	return;
	}

	r->min_clock_lead_time_ns_.Set(static_cast<uint64_t>(min_clock_lead_time_ns));
	}

	void Reporter::SettingRendererPtsContinuityThreshold(const AudioRendererImpl& renderer,
	float threshold_seconds) {
	Renderer* r = FindRenderer(renderer);
	if (r == nullptr) {
	FXL_DLOG(FATAL);
	return;
	}

	r->pts_continuity_threshold_seconds_.Set(threshold_seconds);
	}

	void Reporter::AddingCapturer(const AudioCapturerImpl& capturer) {
	capturers_.emplace(&capturer, Capturer(capturers_node_.CreateChild(NextCapturerName())));
	}

	void Reporter::RemovingCapturer(const AudioCapturerImpl& capturer) { capturers_.erase(&capturer); }

	void Reporter::SettingCapturerStreamType(const AudioCapturerImpl& capturer,
	const fuchsia::media::AudioStreamType& stream_type) {
	Capturer* c = FindCapturer(capturer);
	if (c == nullptr) {
	FXL_DLOG(FATAL);
	return;
	}

	c->sample_format_.Set(static_cast<uint64_t>(stream_type.sample_format));
	c->channels_.Set(stream_type.channels);
	c->frames_per_second_.Set(stream_type.frames_per_second);
	}

	void Reporter::AddingCapturerPayloadBuffer(const AudioCapturerImpl& capturer, uint32_t buffer_id,
	uint64_t size) {
	Capturer* c = FindCapturer(capturer);
	if (c == nullptr) {
	FXL_DLOG(FATAL);
	return;
	}

	c->payload_buffers_.emplace(
	buffer_id,
	PayloadBuffer(c->payload_buffers_node_.CreateChild(std::to_string(buffer_id)), size));
	}

	void Reporter::SendingCapturerPacket(const AudioCapturerImpl& capturer,
	const fuchsia::media::StreamPacket& packet) {
	Capturer* c = FindCapturer(capturer);
	if (c == nullptr) {
	FXL_DLOG(FATAL);
	return;
	}
	auto payload_buffer = c->payload_buffers_.find(packet.payload_buffer_id);
	if (payload_buffer == c->payload_buffers_.end()) {
	FXL_DLOG(FATAL);
	return;
	}
	payload_buffer->second.packets_.Add(1);
	}

	void Reporter::SettingCapturerGain(const AudioCapturerImpl& capturer, float gain_db) {
	Capturer* c = FindCapturer(capturer);
	if (c == nullptr) {
	FXL_DLOG(FATAL);
	return;
	}

	c->gain_db_.Set(gain_db);
	}

	void Reporter::SettingCapturerGainWithRamp(const AudioCapturerImpl& capturer, float gain_db,
	zx_duration_t duration_ns,
	fuchsia::media::audio::RampType ramp_type) {
	Capturer* c = FindCapturer(capturer);
	if (c == nullptr) {
	FXL_DLOG(FATAL);
	return;
	}

	// Just counting these for now.
	c->set_gain_with_ramp_calls_.Add(1);
	}

	void Reporter::SettingCapturerMute(const AudioCapturerImpl& capturer, bool muted) {
	Capturer* c = FindCapturer(capturer);
	if (c == nullptr) {
	FXL_DLOG(FATAL);
	return;
	}

	c->muted_.Set(muted);
	}

	Reporter::Device* Reporter::FindOutput(const AudioDevice& device) {
	auto i = outputs_.find(&device);
	return i == outputs_.end() ? nullptr : &i->second;
	}

	Reporter::Device* Reporter::FindInput(const AudioDevice& device) {
	auto i = inputs_.find(&device);
	return i == inputs_.end() ? nullptr : &i->second;
	}

	Reporter::Renderer* Reporter::FindRenderer(const AudioRendererImpl& renderer) {
	auto i = renderers_.find(&renderer);
	return i == renderers_.end() ? nullptr : &i->second;
	}

	Reporter::Capturer* Reporter::FindCapturer(const AudioCapturerImpl& capturer) {
	auto i = capturers_.find(&capturer);
	return i == capturers_.end() ? nullptr : &i->second;
	}

	std::string Reporter::NextRendererName() {
	std::ostringstream os;
	os << ++next_renderer_name_;
	return os.str();
	}

	std::string Reporter::NextCapturerName() {
	std::ostringstream os;
	os << ++next_capturer_name_;
	return os.str();
	}

	#endif // ENABLE_REPORTER

	} // namespace media::audio