| // Copyright 2018 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. |
| |
| #ifndef SRC_MEDIA_AUDIO_TOOLS_SIGNAL_GENERATOR_SIGNAL_GENERATOR_H_ |
| #define SRC_MEDIA_AUDIO_TOOLS_SIGNAL_GENERATOR_SIGNAL_GENERATOR_H_ |
| |
| #include <fuchsia/media/cpp/fidl.h> |
| #include <lib/async-loop/cpp/loop.h> |
| #include <lib/async-loop/default.h> |
| #include <lib/async/cpp/task.h> |
| #include <lib/async/cpp/wait.h> |
| #include <lib/fit/function.h> |
| #include <lib/fzl/vmo-mapper.h> |
| #include <lib/sys/cpp/component_context.h> |
| #include <lib/zx/clock.h> |
| |
| #include "src/media/audio/lib/wav/wav_writer.h" |
| |
| namespace { |
| constexpr float kUnityGainDb = 0.0f; |
| |
| typedef enum { |
| kOutputTypeNoise, |
| kOutputTypePinkNoise, |
| kOutputTypeSine, |
| kOutputTypeSquare, |
| kOutputTypeSawtooth, |
| kOutputTypeTriangle, |
| } OutputSignalType; |
| // TODO(fxbug.dev/49220): refactor signal-generation to make it easier to add new generators. |
| |
| typedef enum { Default, Flexible, Monotonic, Custom } ClockType; |
| |
| constexpr std::array<std::pair<const char*, fuchsia::media::AudioRenderUsage>, |
| fuchsia::media::RENDER_USAGE_COUNT> |
| kRenderUsageOptions = {{ |
| {"BACKGROUND", fuchsia::media::AudioRenderUsage::BACKGROUND}, |
| {"MEDIA", fuchsia::media::AudioRenderUsage::MEDIA}, |
| {"INTERRUPTION", fuchsia::media::AudioRenderUsage::INTERRUPTION}, |
| {"SYSTEM_AGENT", fuchsia::media::AudioRenderUsage::SYSTEM_AGENT}, |
| {"COMMUNICATION", fuchsia::media::AudioRenderUsage::COMMUNICATION}, |
| }}; |
| |
| // Any audio output device fed by the system audio mixer will have this min_lead_time, at least. |
| // Until then, we cannot be confident that our renderer is routed to an actual device. |
| // TODO(fxbug.dev/50117): remove the workaround once audio_core fixes the underlying fxbug.dev/50017 |
| constexpr zx::duration kRealDeviceMinLeadTime = zx::msec(1); |
| } // namespace |
| |
| namespace media::tools { |
| class MediaApp { |
| public: |
| MediaApp(fit::closure quit_callback); |
| |
| void set_num_channels(uint32_t num_channels) { num_channels_ = num_channels; } |
| void set_frame_rate(uint32_t frame_rate) { frame_rate_ = frame_rate; } |
| void set_sample_format(fuchsia::media::AudioSampleFormat format) { sample_format_ = format; } |
| |
| void set_output_type(OutputSignalType output_type) { output_signal_type_ = output_type; } |
| void set_usage(fuchsia::media::AudioRenderUsage usage) { usage_ = usage; } |
| void set_frequency(double frequency) { frequency_ = frequency; } |
| void set_amplitude(float amplitude) { amplitude_ = amplitude; } |
| |
| void set_duration(double duration_secs) { duration_secs_ = duration_secs; } |
| double get_duration() { return duration_secs_; } |
| |
| void set_frames_per_packet(uint32_t set_frames_per_packet) { |
| frames_per_packet_ = set_frames_per_packet; |
| } |
| void set_frames_per_payload_buffer(uint32_t frames_per_payload_buffer) { |
| frames_per_payload_buffer_ = frames_per_payload_buffer; |
| } |
| void set_num_payload_buffers(uint32_t num_payload_buffers) { |
| num_payload_buffers_ = num_payload_buffers; |
| } |
| |
| void set_clock_type(ClockType type) { clock_type_ = type; } |
| void adjust_clock_rate(int32_t rate_adjustment) { clock_rate_adjustment_ = rate_adjustment; } |
| |
| void set_ref_start_time(bool set_ref_time) { set_ref_start_time_ = set_ref_time; } |
| void set_media_start_pts(int64_t media_start_pts) { media_start_pts_ = media_start_pts; } |
| void use_pkt_pts(bool use_pts) { timestamp_packets_ = use_pts; } |
| void set_pts_continuity_threshold(float pts_continuity_threshold) { |
| pts_continuity_threshold_secs_ = pts_continuity_threshold; |
| } |
| |
| void set_save_file_name(std::string file_name) { file_name_ = file_name; } |
| |
| void set_stream_gain(float gain_db) { stream_gain_db_ = gain_db; } |
| void set_stream_mute(bool mute) { stream_mute_ = mute; } |
| |
| void set_ramp_duration_nsec(zx_duration_t duration_nsec) { ramp_duration_nsec_ = duration_nsec; } |
| void set_ramp_target_gain_db(float gain_db) { ramp_target_gain_db_ = gain_db; } |
| |
| void set_usage_gain(float gain_db) { usage_gain_db_ = gain_db; } |
| void set_usage_volume(float volume) { usage_volume_ = volume; } |
| |
| void set_ultrasound(bool ultrasound) { ultrasound_ = ultrasound; } |
| void set_online(bool online) { online_ = online; } |
| void set_verbose(bool verbose) { verbose_ = verbose; } |
| |
| bool playing() const { return playing_; } |
| void set_playing() { playing_ = true; } |
| |
| void Run(sys::ComponentContext* app_context); |
| |
| private: |
| void ParameterRangeChecks(); |
| void SetupPayloadCoefficients(); |
| void DisplayConfigurationSettings(); |
| |
| void SetAudioCoreSettings(sys::ComponentContext* app_context); |
| void AcquireAudioRenderer(sys::ComponentContext* app_context); |
| void SetAudioRendererEvents(); |
| void InitializeAudibleRenderer(); |
| void ConfigureAudioRendererPts(); |
| void InitializeWavWriter(); |
| void CreateMemoryMapping(); |
| |
| void GetClockAndStart(); |
| void Play(); |
| |
| void SendPacket(); |
| bool CheckPayloadSpace(); |
| void OnSendPacketTimer(); |
| void ScheduleNextSendPacket(); |
| void OnSendPacketComplete(uint64_t frames_completed); |
| |
| struct AudioPacket { |
| fuchsia::media::StreamPacket stream_packet; |
| fzl::VmoMapper* vmo; |
| }; |
| AudioPacket CreateAudioPacket(uint64_t packet_num); |
| |
| void PrimePinkNoiseFilter(); |
| void AdvancePinkNoiseFrame(); |
| double NextPinkNoiseSample(uint32_t chan_num); |
| |
| void GenerateAudioForPacket(const AudioPacket& packet, uint64_t packet_num); |
| template <typename SampleType> |
| void WriteAudioIntoBuffer(SampleType* audio_buffer, uint32_t num_frames, |
| uint64_t frames_since_start); |
| |
| bool Shutdown(); |
| fit::closure quit_callback_; |
| |
| fuchsia::media::AudioRendererPtr audio_renderer_; |
| fuchsia::media::audio::GainControlPtr gain_control_; |
| zx::duration min_lead_time_; |
| |
| std::vector<fzl::VmoMapper> payload_buffers_; |
| |
| uint32_t num_channels_; |
| uint32_t frame_rate_; |
| fuchsia::media::AudioSampleFormat sample_format_ = fuchsia::media::AudioSampleFormat::FLOAT; |
| uint32_t sample_size_; |
| uint32_t frame_size_; |
| |
| fuchsia::media::AudioRenderUsage usage_ = fuchsia::media::AudioRenderUsage::MEDIA; |
| fuchsia::media::audio::VolumeControlPtr usage_volume_control_; // for usage volume |
| |
| OutputSignalType output_signal_type_; |
| |
| double frequency_; |
| double frames_per_period_; // frame_rate_ / frequency_ |
| |
| double amplitude_; // Amplitude between 0.0 and 1.0 (full-scale). |
| double amplitude_scalar_; // Amp translated to container-specific magn. |
| |
| uint32_t bytes_per_packet_; |
| uint32_t frames_per_packet_; |
| |
| uint32_t frames_per_payload_buffer_; |
| uint32_t packets_per_payload_buffer_; |
| |
| uint32_t num_payload_buffers_; |
| |
| uint32_t total_mappable_packets_; |
| uint32_t target_num_packets_outstanding_; |
| |
| double duration_secs_; |
| uint64_t total_frames_to_send_; |
| uint64_t num_packets_to_send_; |
| uint64_t num_packets_sent_ = 0u; |
| uint64_t num_packets_completed_ = 0u; |
| uint64_t num_frames_completed_ = 0u; |
| |
| zx::clock reference_clock_; |
| ClockType clock_type_ = ClockType::Default; |
| std::optional<int32_t> clock_rate_adjustment_ = std::nullopt; |
| |
| async::TaskClosureMethod<MediaApp, &MediaApp::OnSendPacketTimer> online_send_packet_timer_{this}; |
| |
| zx::time target_online_send_packet_ref_time_; |
| zx::duration online_send_packet_ref_period_; |
| |
| bool set_ref_start_time_ = false; |
| zx::time reference_start_time_; |
| |
| std::optional<int64_t> media_start_pts_ = std::nullopt; |
| |
| bool timestamp_packets_ = false; |
| std::optional<float> pts_continuity_threshold_secs_ = std::nullopt; |
| |
| bool online_; |
| // In online mode, we preload the payload buffer half-full then send additional packets per timer. |
| // For convenience of calculations later, we extrapolate backwards to calculate and store this |
| // value: the hypothetical reference time when we would have sent the first packet. |
| zx::time target_online_send_first_packet_ref_time_; |
| |
| std::optional<std::string> file_name_ = std::nullopt; |
| media::audio::WavWriter<> wav_writer_; |
| bool wav_writer_initialized_ = false; |
| |
| std::optional<float> stream_gain_db_ = std::nullopt; |
| std::optional<bool> stream_mute_ = std::nullopt; |
| |
| std::optional<float> ramp_target_gain_db_ = std::nullopt; |
| zx_duration_t ramp_duration_nsec_; |
| |
| std::optional<float> usage_gain_db_ = std::nullopt; |
| std::optional<float> usage_volume_ = std::nullopt; |
| |
| // To produce pink noise, we first generate white noise then run it through a "pinking" filter to |
| // progressively attenuate high frequencies. |
| // |
| // This 4-stage feedforward/feedback filter attenuates by 1/f to convert white noise to pink. |
| static constexpr double kFeedFwd[] = {0.049922035, -0.095993537, 0.050612699, -0.004408786}; |
| static constexpr double kFeedBack[] = {1, -2.494956002, 2.017265875, -0.522189400}; |
| typedef double HistoryBuffer[4]; |
| std::unique_ptr<HistoryBuffer[]> input_history_; |
| std::unique_ptr<HistoryBuffer[]> output_history_; |
| // The above filtering produces a signal with an average min/max of approx [-0.20, +0.20], only |
| // very rarely exceeding [-0.24,0.24]. To normalize the pink-noise signal (making its loudness for |
| // a given amplitude closer to that of white noise), we boost our source white-noise signal by 4x. |
| static constexpr double kPinkNoiseSignalBoostFactor = 4.0; |
| |
| bool ultrasound_ = false; |
| bool verbose_; |
| bool playing_ = false; |
| }; |
| |
| } // namespace media::tools |
| |
| #endif // SRC_MEDIA_AUDIO_TOOLS_SIGNAL_GENERATOR_SIGNAL_GENERATOR_H_ |