30507431705

Committed 30 Jul 2026 02:04AM UTC coverage: 15.263% (-0.06%) from 15.321%

Build # 30507431705

Build Type

push

github

Committed by

jcelerier

Commit Message

audio: simplify pretty name for Default device

Coverage Stats

0 of 2 new or added lines in 1 file covered. (0.0%)

1386 existing lines in 18 files now uncovered.

30460 of 199565 relevant lines covered (15.26%)

1075.35 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

68.18

/src/plugins/score-plugin-audio/score_plugin_audio.cpp

// This is an open source non-commercial project. Dear PVS-Studio, please check
// it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com

#include "score_plugin_audio.hpp"

#include <Audio/ALSAInterface.hpp>
#include <Audio/ALSAMiniAudioInterface.hpp>
#include <Audio/ALSAPortAudioInterface.hpp>
#include <Audio/ASIOPortAudioInterface.hpp>
#include <Audio/AudioApplicationPlugin.hpp>
#include <Audio/AudioDevice.hpp>
#include <Audio/AudioPreviewExecutor.hpp>
#include <Audio/CoreAudioInterface.hpp>
#include <Audio/DummyInterface.hpp>
#include <Audio/GenericPortAudioInterface.hpp>
#include <Audio/JackInterface.hpp>
#include <Audio/MMEPortAudioInterface.hpp>
#include <Audio/PipeWireInterface.hpp>
#include <Audio/PortAudioInterface.hpp>
#include <Audio/SDLInterface.hpp>
#include <Audio/Settings/Factory.hpp>
#include <Audio/WASAPIPortAudioInterface.hpp>
#include <Audio/WASAPIMiniAudioInterface.hpp>
#include <Audio/WASMMiniAudioInterface.hpp>
#include <Audio/WDMKSPortAudioInterface.hpp>

#include <score/plugins/FactorySetup.hpp>
#include <score/plugins/InterfaceList.hpp>
#include <score/plugins/StringFactoryKey.hpp>
#include <score/plugins/UuidKeySerialization.hpp>

#include <wobjectimpl.h>

#include <ossia-config.hpp>

#if OSSIA_AUDIO_PORTAUDIO && defined(__linux__) && __has_include(<alsa/asoundlib.h>)
#include <alsa/asoundlib.h>
static void asound_error(
    const char* file, int line, const char* function, int err, const char* fmt, ...)
{
}
#endif

score_plugin_audio::score_plugin_audio()
{
  qRegisterMetaType<Audio::AudioFactory::ConcreteKey>(
      "Audio::AudioFactory::ConcreteKey");
  qRegisterMetaType<Audio::Settings::ExternalTransport>(
      "Audio::Settings::ExternalTransport");

  auto only_dummy_audio = qEnvironmentVariableIntValue("SCORE_ONLY_DUMMY_AUDIO") > 0;

  if(!only_dummy_audio)
  {
#if OSSIA_AUDIO_JACK
    jack_set_error_function(
        [](const char* str) { std::cerr << "JACK ERROR: " << str << std::endl; });
    jack_set_info_function([](const char* str) {
      // std::cerr << "JACK INFO: " << str << std::endl;
    });
#endif
#if OSSIA_AUDIO_PORTAUDIO && defined(__linux__) && __has_include(<alsa/asoundlib.h>)
    auto asound = dlopen("libasound.so.2", RTLD_LAZY | RTLD_LOCAL);
    auto sym = (decltype(snd_lib_error_set_handler)*)dlsym(
        asound, "snd_lib_error_set_handler");
    sym(asound_error);
#endif
  }
}

score_plugin_audio::~score_plugin_audio() { }

score::GUIApplicationPlugin*
score_plugin_audio::make_guiApplicationPlugin(const score::GUIApplicationContext& app)
{
  return new Audio::ApplicationPlugin{app};
}

std::vector<std::unique_ptr<score::InterfaceListBase>>
score_plugin_audio::factoryFamilies()
{
  return make_ptr_vector<score::InterfaceListBase, Audio::AudioFactoryList>();
}

template <typename... Args>
auto add_factories(
    std::vector<score::InterfaceBase*>& vec, const auto& ctx,
    const score::InterfaceKey& key) noexcept
{
  ossia::for_each_type_if_tagged<Args...>([&](auto t) {
    using fw_t = typename decltype(t)::type;
    return fw_t{}(ctx, key, vec);
  });
}

std::vector<score::InterfaceBase*> score_plugin_audio::factories(
    const score::ApplicationContext& ctx, const score::InterfaceKey& key) const
{
  std::vector<score::InterfaceBase*> vec;
  {
    // Common stuff
    add_factories<
        FW<Device::ProtocolFactory
#if defined(OSSIA_PROTOCOL_AUDIO)
           ,
           Dataflow::AudioProtocolFactory
#endif
           >,
        FW<score::SettingsDelegateFactory, Audio::Settings::Factory>,
        FW<Execution::ExecutionAction, Audio::AudioPreviewExecutor>>(vec, ctx, key);
  }

  using namespace Audio;
  auto only_dummy_audio = qEnvironmentVariableIntValue("SCORE_ONLY_DUMMY_AUDIO") > 0;
  auto forced_backend = qEnvironmentVariable("SCORE_AUDIO_BACKEND").toLower();
  if(only_dummy_audio)
  {
    add_factories<FW<Audio::AudioFactory, Audio::DummyFactory>>(vec, ctx, key);
    return vec;
  }
  else if(!forced_backend.isEmpty())
  {
    if(forced_backend == "sdl")
    {
#if defined(OSSIA_AUDIO_SDL)
      add_factories<FW<Audio::AudioFactory, Audio::SDLFactory>>(vec, ctx, key);
      return vec;
#endif
    }
    else if(forced_backend == "jack")
    {
#if defined(OSSIA_AUDIO_JACK)
      add_factories<FW<Audio::AudioFactory, Audio::JackFactory>>(vec, ctx, key);
      return vec;
#endif
    }
    else if(forced_backend == "pipewire")
    {
#if defined(OSSIA_AUDIO_PIPEWIRE)
      add_factories<FW<Audio::AudioFactory, Audio::PipeWireAudioFactory>>(vec, ctx, key);
      return vec;
#endif
    }
    else if(forced_backend == "alsa")
    {
#if OSSIA_AUDIO_ALSA
      add_factories<FW<Audio::AudioFactory, Audio::ALSAFactory>>(vec, ctx, key);
      return vec;
#endif
    }
    else if(forced_backend == "alsa_miniaudio")
    {
#if defined(__linux__) && defined(OSSIA_AUDIO_MINIAUDIO)
      add_factories<FW<Audio::AudioFactory, Audio::ALSAMiniAudioFactory>>(vec, ctx, key);
      return vec;
#endif
    }
    else if(forced_backend == "wasapi_miniaudio")
    {
#if defined(_WIN32) && defined(OSSIA_AUDIO_MINIAUDIO)
      add_factories<FW<Audio::AudioFactory, Audio::WASAPIMiniAudioFactory>>(
          vec, ctx, key);
      return vec;
#endif
    }
    else if(forced_backend == "dummy")
    {
      add_factories<FW<Audio::AudioFactory, Audio::DummyFactory>>(vec, ctx, key);
      return vec;
    }
  }

  add_factories<
      FW<Audio::AudioFactory, Audio::DummyFactory
#if defined(OSSIA_AUDIO_JACK)
         ,
         Audio::JackFactory
#endif
// #if defined(OSSIA_AUDIO_PULSEAUDIO)
//          ,
//          Audio::PulseAudioFactory
// #endif
#if OSSIA_AUDIO_ALSA
         ,
         Audio::ALSAFactory
#endif
#if defined(OSSIA_AUDIO_PORTAUDIO)
#if __has_include(<pa_asio.h>)
         ,
         Audio::ASIOFactory
#endif
//#if __has_include(<pa_win_wdmks.h>)
//         ,
//         Audio::WDMKSFactory
//#endif
#if __has_include(<pa_win_wasapi.h>)
         ,
         Audio::WASAPIFactory
#endif
//#if __has_include(<pa_win_wmme.h>)
//         ,
//         Audio::MMEFactory
//#endif
#if __has_include(<pa_linux_alsa.h>)
         ,
         Audio::ALSAPortAudioFactory
#endif
#if defined(__linux__) && defined(OSSIA_AUDIO_MINIAUDIO)
         ,
         Audio::ALSAMiniAudioFactory
#endif
#if !__has_include(<pa_asio.h>) && \
    !__has_include(<pa_win_wdmks.h>) && \
    !__has_include(<pa_win_wasapi.h>) && \
    !__has_include(<pa_win_wmme.h>) && \
    !__has_include(<pa_linux_alsa.h>) && \
    !__has_include(<pa_mac_core.h>)
         ,
         Audio::PortAudioFactory
#endif
#endif
#if defined(OSSIA_AUDIO_SDL)
         ,
         Audio::SDLFactory
#endif
#if defined(OSSIA_AUDIO_PIPEWIRE)
         ,
         Audio::PipeWireAudioFactory
#endif
#if defined(__APPLE__) && defined(OSSIA_AUDIO_MINIAUDIO)
         ,
         Audio::CoreAudioFactory
#endif
#if defined(_WIN32) && defined(OSSIA_AUDIO_MINIAUDIO)
         ,
         Audio::WASAPIMiniAudioFactory
#endif
#if defined(__EMSCRIPTEN__) && defined(OSSIA_AUDIO_MINIAUDIO)
         ,
         Audio::WASMMiniAudioFactory
#endif
         >>(vec, ctx, key);

  return vec;
}

auto score_plugin_audio::required() const -> std::vector<score::PluginKey>
{
  return {};
}

#include <score/plugins/PluginInstances.hpp>
SCORE_EXPORT_PLUGIN(score_plugin_audio)

1	// This is an open source non-commercial project. Dear PVS-Studio, please check
2	// it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
3
4	#include "score_plugin_audio.hpp"
5
6	#include <Audio/ALSAInterface.hpp>
7	#include <Audio/ALSAMiniAudioInterface.hpp>
8	#include <Audio/ALSAPortAudioInterface.hpp>
9	#include <Audio/ASIOPortAudioInterface.hpp>
10	#include <Audio/AudioApplicationPlugin.hpp>
11	#include <Audio/AudioDevice.hpp>
12	#include <Audio/AudioPreviewExecutor.hpp>
13	#include <Audio/CoreAudioInterface.hpp>
14	#include <Audio/DummyInterface.hpp>
15	#include <Audio/GenericPortAudioInterface.hpp>
16	#include <Audio/JackInterface.hpp>
17	#include <Audio/MMEPortAudioInterface.hpp>
18	#include <Audio/PipeWireInterface.hpp>
19	#include <Audio/PortAudioInterface.hpp>
20	#include <Audio/SDLInterface.hpp>
21	#include <Audio/Settings/Factory.hpp>
22	#include <Audio/WASAPIPortAudioInterface.hpp>
23	#include <Audio/WASAPIMiniAudioInterface.hpp>
24	#include <Audio/WASMMiniAudioInterface.hpp>
25	#include <Audio/WDMKSPortAudioInterface.hpp>
26
27	#include <score/plugins/FactorySetup.hpp>
28	#include <score/plugins/InterfaceList.hpp>
29	#include <score/plugins/StringFactoryKey.hpp>
30	#include <score/plugins/UuidKeySerialization.hpp>
31
32	#include <wobjectimpl.h>
33
34	#include <ossia-config.hpp>
35
36	#if OSSIA_AUDIO_PORTAUDIO && defined(__linux__) && __has_include(<alsa/asoundlib.h>)
37	#include <alsa/asoundlib.h>
UNCOV 38	static void asound_error(	×
39	const char* file, int line, const char* function, int err, const char* fmt, ...)
40	{
UNCOV 41	}	×
42	#endif
43
44	score_plugin_audio::score_plugin_audio()	128✔
45	{	128✔
46	qRegisterMetaType<Audio::AudioFactory::ConcreteKey>(	32✔
47	"Audio::AudioFactory::ConcreteKey");
48	qRegisterMetaType<Audio::Settings::ExternalTransport>(	32✔
49	"Audio::Settings::ExternalTransport");
50
51	auto only_dummy_audio = qEnvironmentVariableIntValue("SCORE_ONLY_DUMMY_AUDIO") > 0;	32✔
52
53	if(!only_dummy_audio)	32✔
54	{
55	#if OSSIA_AUDIO_JACK
56	jack_set_error_function(	32✔
57	[](const char* str) { std::cerr << "JACK ERROR: " << str << std::endl; });	32✔
58	jack_set_info_function([](const char* str) {	32✔
59	// std::cerr << "JACK INFO: " << str << std::endl;
UNCOV 60	});	×
61	#endif
62	#if OSSIA_AUDIO_PORTAUDIO && defined(__linux__) && __has_include(<alsa/asoundlib.h>)
63	auto asound = dlopen("libasound.so.2", RTLD_LAZY \| RTLD_LOCAL);	32✔
64	auto sym = (decltype(snd_lib_error_set_handler)*)dlsym(	32✔
65	asound, "snd_lib_error_set_handler");	32✔
66	sym(asound_error);	32✔
67	#endif
68	}	32✔
69	}	32✔
70
71	score_plugin_audio::~score_plugin_audio() { }	32✔
72
73	score::GUIApplicationPlugin*
74	score_plugin_audio::make_guiApplicationPlugin(const score::GUIApplicationContext& app)	39✔
75	{
76	return new Audio::ApplicationPlugin{app};	39✔
UNCOV 77	}	×
78
79	std::vector<std::unique_ptr<score::InterfaceListBase>>
80	score_plugin_audio::factoryFamilies()	39✔
81	{
82	return make_ptr_vector<score::InterfaceListBase, Audio::AudioFactoryList>();	39✔
83	}
84
85	template <typename... Args>
86	auto add_factories(	2,886✔
87	std::vector<score::InterfaceBase*>& vec, const auto& ctx,
88	const score::InterfaceKey& key) noexcept
89	{
90	ossia::for_each_type_if_tagged<Args...>([&](auto t) {	8,541✔
91	using fw_t = typename decltype(t)::type;
92	return fw_t{}(ctx, key, vec);	5,655✔
93	});
94	}	2,886✔
95
96	std::vector<score::InterfaceBase*> score_plugin_audio::factories(	1,443✔
97	const score::ApplicationContext& ctx, const score::InterfaceKey& key) const
98	{
99	std::vector<score::InterfaceBase*> vec;	1,443✔
100	{
101	// Common stuff
102	add_factories<	1,443✔
103	FW<Device::ProtocolFactory
104	#if defined(OSSIA_PROTOCOL_AUDIO)
105	,
106	Dataflow::AudioProtocolFactory
107	#endif
108	>,
109	FW<score::SettingsDelegateFactory, Audio::Settings::Factory>,
110	FW<Execution::ExecutionAction, Audio::AudioPreviewExecutor>>(vec, ctx, key);	1,443✔
111	}
112
113	using namespace Audio;
114	auto only_dummy_audio = qEnvironmentVariableIntValue("SCORE_ONLY_DUMMY_AUDIO") > 0;	1,443✔
115	auto forced_backend = qEnvironmentVariable("SCORE_AUDIO_BACKEND").toLower();	1,443✔
116	if(only_dummy_audio)	1,443✔
117	{
118	add_factories<FW<Audio::AudioFactory, Audio::DummyFactory>>(vec, ctx, key);	×
UNCOV 119	return vec;	×
120	}
121	else if(!forced_backend.isEmpty())	1,443✔
122	{
123	if(forced_backend == "sdl")	1,443✔
124	{
125	#if defined(OSSIA_AUDIO_SDL)
126	add_factories<FW<Audio::AudioFactory, Audio::SDLFactory>>(vec, ctx, key);	×
UNCOV 127	return vec;	×
128	#endif
129	}
130	else if(forced_backend == "jack")	1,443✔
131	{
132	#if defined(OSSIA_AUDIO_JACK)
133	add_factories<FW<Audio::AudioFactory, Audio::JackFactory>>(vec, ctx, key);	×
UNCOV 134	return vec;	×
135	#endif
136	}
137	else if(forced_backend == "pipewire")	1,443✔
138	{
139	#if defined(OSSIA_AUDIO_PIPEWIRE)
140	add_factories<FW<Audio::AudioFactory, Audio::PipeWireAudioFactory>>(vec, ctx, key);	×
UNCOV 141	return vec;	×
142	#endif
143	}
144	else if(forced_backend == "alsa")	1,443✔
145	{
146	#if OSSIA_AUDIO_ALSA
147	add_factories<FW<Audio::AudioFactory, Audio::ALSAFactory>>(vec, ctx, key);	×
UNCOV 148	return vec;	×
149	#endif
150	}
151	else if(forced_backend == "alsa_miniaudio")	1,443✔
152	{
153	#if defined(__linux__) && defined(OSSIA_AUDIO_MINIAUDIO)
154	add_factories<FW<Audio::AudioFactory, Audio::ALSAMiniAudioFactory>>(vec, ctx, key);	×
UNCOV 155	return vec;	×
156	#endif
157	}
158	else if(forced_backend == "wasapi_miniaudio")	1,443✔
159	{
160	#if defined(_WIN32) && defined(OSSIA_AUDIO_MINIAUDIO)
161	add_factories<FW<Audio::AudioFactory, Audio::WASAPIMiniAudioFactory>>(
162	vec, ctx, key);
163	return vec;
164	#endif
UNCOV 165	}	×
166	else if(forced_backend == "dummy")	1,443✔
167	{
168	add_factories<FW<Audio::AudioFactory, Audio::DummyFactory>>(vec, ctx, key);	1,443✔
169	return vec;	1,443✔
170	}
UNCOV 171	}	×
172
UNCOV 173	add_factories<	×
174	FW<Audio::AudioFactory, Audio::DummyFactory
175	#if defined(OSSIA_AUDIO_JACK)
176	,
177	Audio::JackFactory
178	#endif
179	// #if defined(OSSIA_AUDIO_PULSEAUDIO)
180	// ,
181	// Audio::PulseAudioFactory
182	// #endif
183	#if OSSIA_AUDIO_ALSA
184	,
185	Audio::ALSAFactory
186	#endif
187	#if defined(OSSIA_AUDIO_PORTAUDIO)
188	#if __has_include(<pa_asio.h>)
189	,
190	Audio::ASIOFactory
191	#endif
192	//#if __has_include(<pa_win_wdmks.h>)
193	// ,
194	// Audio::WDMKSFactory
195	//#endif
196	#if __has_include(<pa_win_wasapi.h>)
197	,
198	Audio::WASAPIFactory
199	#endif
200	//#if __has_include(<pa_win_wmme.h>)
201	// ,
202	// Audio::MMEFactory
203	//#endif
204	#if __has_include(<pa_linux_alsa.h>)
205	,
206	Audio::ALSAPortAudioFactory
207	#endif
208	#if defined(__linux__) && defined(OSSIA_AUDIO_MINIAUDIO)
209	,
210	Audio::ALSAMiniAudioFactory
211	#endif
212	#if !__has_include(<pa_asio.h>) && \
213	!__has_include(<pa_win_wdmks.h>) && \
214	!__has_include(<pa_win_wasapi.h>) && \
215	!__has_include(<pa_win_wmme.h>) && \
216	!__has_include(<pa_linux_alsa.h>) && \
217	!__has_include(<pa_mac_core.h>)
218	,
219	Audio::PortAudioFactory
220	#endif
221	#endif
222	#if defined(OSSIA_AUDIO_SDL)
223	,
224	Audio::SDLFactory
225	#endif
226	#if defined(OSSIA_AUDIO_PIPEWIRE)
227	,
228	Audio::PipeWireAudioFactory
229	#endif
230	#if defined(__APPLE__) && defined(OSSIA_AUDIO_MINIAUDIO)
231	,
232	Audio::CoreAudioFactory
233	#endif
234	#if defined(_WIN32) && defined(OSSIA_AUDIO_MINIAUDIO)
235	,
236	Audio::WASAPIMiniAudioFactory
237	#endif
238	#if defined(__EMSCRIPTEN__) && defined(OSSIA_AUDIO_MINIAUDIO)
239	,
240	Audio::WASMMiniAudioFactory
241	#endif
UNCOV 242	>>(vec, ctx, key);	×
243
UNCOV 244	return vec;	×
245	}	1,443✔
246
247	auto score_plugin_audio::required() const -> std::vector<score::PluginKey>	39✔
248	{
249	return {};	39✔
250	}
251
252	#include <score/plugins/PluginInstances.hpp>
253	SCORE_EXPORT_PLUGIN(score_plugin_audio)	39✔

ossia / score / 30507431705

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous