OSSForks/ladybird
1
0
Fork 0
mirror of https://github.com/zebrajr/ladybird.git synced 2026-01-15 12:15:15 +00:00
Code Issues Actions 3 Packages Projects Releases Wiki Activity
Files
master
ladybird/Tests/LibMedia/TestPlaybackStream.cpp

58 lines
2.0 KiB
C++
Raw Permalink Normal View History

LibAudio: Add a test for creating and destructing a PlaybackStream This will ensure that we don't leak any memory while playing back audio. There is an expectation value in the test that is only set to true when PulseAudio is present for the moment. When any new implementation is added for other libraries/platforms, we should hopefully get a CI failure due to unexpected success in creating the `PlaybackStream`. To ensure that we clean up our PulseAudio connection whenever audio output is not needed, add `PulseAudioContext::weak_instance()` to allow us to check whether an instance exists without creating one.
2023-08-06 01:59:47 -05:00
/*
LibMedia: Only use floats for audio data callbacks We were already assuming that our streams were using floats, we may as well hardcode this. If we ever encounter a platform API that doesn't support or convert from float, we can always bring this back. Also, since we don't support big-endian systems, remove that check in PulseAudioWrappers.
2025-12-10 18:28:57 -06:00
* Copyright (c) 2023-2025, Gregory Bertilson <gregory@ladybird.org>
LibAudio: Add a test for creating and destructing a PlaybackStream This will ensure that we don't leak any memory while playing back audio. There is an expectation value in the test that is only set to true when PulseAudio is present for the moment. When any new implementation is added for other libraries/platforms, we should hopefully get a CI failure due to unexpected success in creating the `PlaybackStream`. To ensure that we clean up our PulseAudio connection whenever audio output is not needed, add `PulseAudioContext::weak_instance()` to allow us to check whether an instance exists without creating one.
2023-08-06 01:59:47 -05:00
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <AK/Math.h>
#include <AK/MemoryStream.h>
#include <AK/WeakPtr.h>
LibAudio: Add a Serenity implementation of PlaybackStream This implementation is very naive compared to the PulseAudio one. Instead of using a callback implemented by the audio server connection to push audio to the buffer, we have to poll on a timer to check when we need to push the audio buffers. Implementing cross-process condition variables into the audio queue class could allow us to avoid polling, which may prove beneficial to CPU usage. Audio timestamps will be accurate to the number of samples available, but will count in increments of about 100ms and run ahead of the actual audio being pushed to the device by the server. Buffer underruns are completely ignored for now as well, since the `AudioServer` has no way to know how many samples are actually written in a single audio buffer.
2023-08-02 19:05:47 -05:00
#include <LibCore/EventLoop.h>
Tests/LibMedia: Enable in Windows CI
2025-08-04 01:59:24 -07:00
#include <LibCore/System.h>
LibMedia: Absorb LibAudio LibMedia will be responsible for both audio and video decoding.
2024-08-28 12:08:38 +02:00
#include <LibMedia/Audio/PlaybackStream.h>
LibAudio: Add a test for creating and destructing a PlaybackStream This will ensure that we don't leak any memory while playing back audio. There is an expectation value in the test that is only set to true when PulseAudio is present for the moment. When any new implementation is added for other libraries/platforms, we should hopefully get a CI failure due to unexpected success in creating the `PlaybackStream`. To ensure that we clean up our PulseAudio connection whenever audio output is not needed, add `PulseAudioContext::weak_instance()` to allow us to check whether an instance exists without creating one.
2023-08-06 01:59:47 -05:00
#include <LibTest/TestSuite.h>
#if defined(HAVE_PULSEAUDIO)
LibMedia: Absorb LibAudio LibMedia will be responsible for both audio and video decoding.
2024-08-28 12:08:38 +02:00
# include <LibMedia/Audio/PulseAudioWrappers.h>
LibAudio: Add a test for creating and destructing a PlaybackStream This will ensure that we don't leak any memory while playing back audio. There is an expectation value in the test that is only set to true when PulseAudio is present for the moment. When any new implementation is added for other libraries/platforms, we should hopefully get a CI failure due to unexpected success in creating the `PlaybackStream`. To ensure that we clean up our PulseAudio connection whenever audio output is not needed, add `PulseAudioContext::weak_instance()` to allow us to check whether an instance exists without creating one.
2023-08-06 01:59:47 -05:00
#endif
LibMedia: Add a WASAPI playback stream for Windows Implement PlaybackStream using WASAPI. The design is similar to PlaybackStreamAudioUnit in that it uses a task queue. A high priority thread is used to render the stream. All the stream controls save for the exit being requested which happens on destruction of the stream are managed by the render thread. Due to the design of the windows audio mixer the audio we receive must be resampled to match the sample rate of the mixer. We use a float based interleaved PCM stream which matches both our existing code and the audio mixer which internally usues floats. Having to use a mutex around a queue for the task queue is suboptimal, in a future PR a MPSC queue could be added to AK and used instead.
2025-09-11 21:55:03 +02:00
// We are unable to create a playback stream on windows without an audio output device, so this would fail in CI
#if !defined(AK_OS_WINDOWS)
LibMedia: Remove outdated FIXME regarding Audio tests This FIXME does not apply to Ladybird outside Serenity.
2024-12-23 13:37:10 -05:00
TEST_CASE(create_and_destroy_playback_stream)
LibAudio: Add a test for creating and destructing a PlaybackStream This will ensure that we don't leak any memory while playing back audio. There is an expectation value in the test that is only set to true when PulseAudio is present for the moment. When any new implementation is added for other libraries/platforms, we should hopefully get a CI failure due to unexpected success in creating the `PlaybackStream`. To ensure that we clean up our PulseAudio connection whenever audio output is not needed, add `PulseAudioContext::weak_instance()` to allow us to check whether an instance exists without creating one.
2023-08-06 01:59:47 -05:00
{
LibAudio: Add a Serenity implementation of PlaybackStream This implementation is very naive compared to the PulseAudio one. Instead of using a callback implemented by the audio server connection to push audio to the buffer, we have to poll on a timer to check when we need to push the audio buffers. Implementing cross-process condition variables into the audio queue class could allow us to avoid polling, which may prove beneficial to CPU usage. Audio timestamps will be accurate to the number of samples available, but will count in increments of about 100ms and run ahead of the actual audio being pushed to the device by the server. Buffer underruns are completely ignored for now as well, since the `AudioServer` has no way to know how many samples are actually written in a single audio buffer.
2023-08-02 19:05:47 -05:00
Core::EventLoop event_loop;
LibAudio: Add a test for creating and destructing a PlaybackStream This will ensure that we don't leak any memory while playing back audio. There is an expectation value in the test that is only set to true when PulseAudio is present for the moment. When any new implementation is added for other libraries/platforms, we should hopefully get a CI failure due to unexpected success in creating the `PlaybackStream`. To ensure that we clean up our PulseAudio connection whenever audio output is not needed, add `PulseAudioContext::weak_instance()` to allow us to check whether an instance exists without creating one.
2023-08-06 01:59:47 -05:00
bool has_implementation = false;
LibMedia: Add a WASAPI playback stream for Windows Implement PlaybackStream using WASAPI. The design is similar to PlaybackStreamAudioUnit in that it uses a task queue. A high priority thread is used to render the stream. All the stream controls save for the exit being requested which happens on destruction of the stream are managed by the render thread. Due to the design of the windows audio mixer the audio we receive must be resampled to match the sample rate of the mixer. We use a float based interleaved PCM stream which matches both our existing code and the audio mixer which internally usues floats. Having to use a mutex around a queue for the task queue is suboptimal, in a future PR a MPSC queue could be added to AK and used instead.
2025-09-11 21:55:03 +02:00
# if defined(HAVE_PULSEAUDIO) || defined(AK_OS_MACOS)
LibAudio: Add a test for creating and destructing a PlaybackStream This will ensure that we don't leak any memory while playing back audio. There is an expectation value in the test that is only set to true when PulseAudio is present for the moment. When any new implementation is added for other libraries/platforms, we should hopefully get a CI failure due to unexpected success in creating the `PlaybackStream`. To ensure that we clean up our PulseAudio connection whenever audio output is not needed, add `PulseAudioContext::weak_instance()` to allow us to check whether an instance exists without creating one.
2023-08-06 01:59:47 -05:00
has_implementation = true;
LibMedia: Add a WASAPI playback stream for Windows Implement PlaybackStream using WASAPI. The design is similar to PlaybackStreamAudioUnit in that it uses a task queue. A high priority thread is used to render the stream. All the stream controls save for the exit being requested which happens on destruction of the stream are managed by the render thread. Due to the design of the windows audio mixer the audio we receive must be resampled to match the sample rate of the mixer. We use a float based interleaved PCM stream which matches both our existing code and the audio mixer which internally usues floats. Having to use a mutex around a queue for the task queue is suboptimal, in a future PR a MPSC queue could be added to AK and used instead.
2025-09-11 21:55:03 +02:00
# endif
LibAudio: Add a test for creating and destructing a PlaybackStream This will ensure that we don't leak any memory while playing back audio. There is an expectation value in the test that is only set to true when PulseAudio is present for the moment. When any new implementation is added for other libraries/platforms, we should hopefully get a CI failure due to unexpected success in creating the `PlaybackStream`. To ensure that we clean up our PulseAudio connection whenever audio output is not needed, add `PulseAudioContext::weak_instance()` to allow us to check whether an instance exists without creating one.
2023-08-06 01:59:47 -05:00
{
LibMedia: Make PlaybackStream use the output's sample specification Instead of specifying the sample rate, channel count/map, etc. to the PlaybackStream, we'll now use the output device's sample specification whenever possible. If necessary, the stream will fall back to sane default. This hugely simplifies AudioMixingSink, since it no longer has to take care of reinitializing the stream with a new sample specification when it encounters a track with a higher sample rate or more channels. We wouldn't be likely to benefit from this anyway, since it turns out that at least Windows's virtual surround doesn't work through WASAPI at all, and WASAPI likely wouldn't support downmixing. This commit breaks playback of audio files that don't match the system default audio device's sample rate and channel count. The next commit introduces a converter into the pipeline to allow mixing of any sample specification.
2025-12-10 18:49:25 -06:00
auto stream_result = Audio::PlaybackStream::create(Audio::OutputState::Playing, 100, [](Audio::SampleSpecification) {}, [](Span<float> buffer) -> ReadonlySpan<float> { return buffer.trim(0); });
Tests: Use some tasks when testing PlaybackStream This doesn't help to reproduce the potential UAF in the previous commit, but it doesn't hurt to include this nonetheless.
2025-12-29 19:23:55 -06:00
if (has_implementation) {
auto stream = stream_result.release_value();
EXPECT_EQ(stream->total_time_played(), AK::Duration::zero());
for (int i = 0; i < 5; i++) {
stream->resume()->when_rejected([](Error const&) { VERIFY_NOT_REACHED(); });
stream->drain_buffer_and_suspend()->when_rejected([](Error const&) { VERIFY_NOT_REACHED(); });
}
} else {
EXPECT(stream_result.is_error());
LibMedia: Add a WASAPI playback stream for Windows Implement PlaybackStream using WASAPI. The design is similar to PlaybackStreamAudioUnit in that it uses a task queue. A high priority thread is used to render the stream. All the stream controls save for the exit being requested which happens on destruction of the stream are managed by the render thread. Due to the design of the windows audio mixer the audio we receive must be resampled to match the sample rate of the mixer. We use a float based interleaved PCM stream which matches both our existing code and the audio mixer which internally usues floats. Having to use a mutex around a queue for the task queue is suboptimal, in a future PR a MPSC queue could be added to AK and used instead.
2025-09-11 21:55:03 +02:00
dbgln("Failed to create playback stream: {}", stream_result.error());
Tests: Use some tasks when testing PlaybackStream This doesn't help to reproduce the potential UAF in the previous commit, but it doesn't hurt to include this nonetheless.
2025-12-29 19:23:55 -06:00
}
LibAudio: Add a test for creating and destructing a PlaybackStream This will ensure that we don't leak any memory while playing back audio. There is an expectation value in the test that is only set to true when PulseAudio is present for the moment. When any new implementation is added for other libraries/platforms, we should hopefully get a CI failure due to unexpected success in creating the `PlaybackStream`. To ensure that we clean up our PulseAudio connection whenever audio output is not needed, add `PulseAudioContext::weak_instance()` to allow us to check whether an instance exists without creating one.
2023-08-06 01:59:47 -05:00
}
LibMedia: Add a WASAPI playback stream for Windows Implement PlaybackStream using WASAPI. The design is similar to PlaybackStreamAudioUnit in that it uses a task queue. A high priority thread is used to render the stream. All the stream controls save for the exit being requested which happens on destruction of the stream are managed by the render thread. Due to the design of the windows audio mixer the audio we receive must be resampled to match the sample rate of the mixer. We use a float based interleaved PCM stream which matches both our existing code and the audio mixer which internally usues floats. Having to use a mutex around a queue for the task queue is suboptimal, in a future PR a MPSC queue could be added to AK and used instead.
2025-09-11 21:55:03 +02:00
# if defined(HAVE_PULSEAUDIO)
Tests: Wait for PulseAudio context destruction in TestPlaybackStream The stream was being kept alive until the moment before we check if the context is still alive. The stream's control thread holds a reference to the PulseAudioContext, so that should almost never be destroyed before the VERIFY in the test. Instead, wait at most 100ms for it to be destroyed.
2025-11-25 12:42:19 -06:00
// The PulseAudio context is kept alive by the PlaybackStream's control thread, which blocks on
// some operations, so it won't necessarily be destroyed immediately.
auto wait_start = MonotonicTime::now_coarse();
while (Audio::PulseAudioContext::is_connected()) {
if (MonotonicTime::now_coarse() - wait_start > AK::Duration::from_milliseconds(100))
VERIFY_NOT_REACHED();
}
LibMedia: Add a WASAPI playback stream for Windows Implement PlaybackStream using WASAPI. The design is similar to PlaybackStreamAudioUnit in that it uses a task queue. A high priority thread is used to render the stream. All the stream controls save for the exit being requested which happens on destruction of the stream are managed by the render thread. Due to the design of the windows audio mixer the audio we receive must be resampled to match the sample rate of the mixer. We use a float based interleaved PCM stream which matches both our existing code and the audio mixer which internally usues floats. Having to use a mutex around a queue for the task queue is suboptimal, in a future PR a MPSC queue could be added to AK and used instead.
2025-09-11 21:55:03 +02:00
# endif
LibAudio: Add a test for creating and destructing a PlaybackStream This will ensure that we don't leak any memory while playing back audio. There is an expectation value in the test that is only set to true when PulseAudio is present for the moment. When any new implementation is added for other libraries/platforms, we should hopefully get a CI failure due to unexpected success in creating the `PlaybackStream`. To ensure that we clean up our PulseAudio connection whenever audio output is not needed, add `PulseAudioContext::weak_instance()` to allow us to check whether an instance exists without creating one.
2023-08-06 01:59:47 -05:00
}
LibMedia: Add a WASAPI playback stream for Windows Implement PlaybackStream using WASAPI. The design is similar to PlaybackStreamAudioUnit in that it uses a task queue. A high priority thread is used to render the stream. All the stream controls save for the exit being requested which happens on destruction of the stream are managed by the render thread. Due to the design of the windows audio mixer the audio we receive must be resampled to match the sample rate of the mixer. We use a float based interleaved PCM stream which matches both our existing code and the audio mixer which internally usues floats. Having to use a mutex around a queue for the task queue is suboptimal, in a future PR a MPSC queue could be added to AK and used instead.
2025-09-11 21:55:03 +02:00
#endif
Reference in New Issue Copy Permalink