2015-09-17 22:18:16 +02:00
|
|
|
/*
|
2020-01-18 19:22:19 +01:00
|
|
|
* Copyright 2003-2020 The Music Player Daemon Project
|
2015-09-17 22:18:16 +02:00
|
|
|
* http://www.musicpd.org
|
|
|
|
* Copyright (C) 2014-2015 François 'mmu_man' Revol
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License along
|
|
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "HaikuOutputPlugin.hxx"
|
|
|
|
#include "../OutputAPI.hxx"
|
|
|
|
#include "mixer/MixerList.hxx"
|
|
|
|
#include "util/Domain.hxx"
|
2020-02-03 06:21:57 +01:00
|
|
|
#include "util/Math.hxx"
|
2017-02-20 00:45:46 +01:00
|
|
|
#include "system/Error.hxx"
|
2015-09-17 22:18:16 +02:00
|
|
|
#include "Log.hxx"
|
|
|
|
|
|
|
|
#include <AppFileInfo.h>
|
|
|
|
#include <Application.h>
|
|
|
|
#include <Bitmap.h>
|
|
|
|
#include <IconUtils.h>
|
|
|
|
#include <MediaDefs.h>
|
|
|
|
#include <MediaRoster.h>
|
|
|
|
#include <Notification.h>
|
|
|
|
#include <OS.h>
|
|
|
|
#include <Resources.h>
|
|
|
|
#include <StringList.h>
|
|
|
|
#include <SoundPlayer.h>
|
|
|
|
|
|
|
|
#include <string.h>
|
|
|
|
|
|
|
|
#define UTF8_PLAY "\xE2\x96\xB6"
|
|
|
|
|
2017-08-09 16:58:44 +02:00
|
|
|
class HaikuOutput final: AudioOutput {
|
2015-09-17 22:18:16 +02:00
|
|
|
friend int haiku_output_get_volume(HaikuOutput &haiku);
|
|
|
|
friend bool haiku_output_set_volume(HaikuOutput &haiku, unsigned volume);
|
|
|
|
|
|
|
|
size_t write_size;
|
|
|
|
|
2016-11-09 11:36:38 +01:00
|
|
|
media_raw_audio_format format;
|
2015-09-17 22:18:16 +02:00
|
|
|
BSoundPlayer* sound_player;
|
|
|
|
|
|
|
|
sem_id new_buffer;
|
|
|
|
sem_id buffer_done;
|
|
|
|
|
|
|
|
uint8* buffer;
|
|
|
|
size_t buffer_size;
|
|
|
|
size_t buffer_filled;
|
|
|
|
|
|
|
|
unsigned buffer_delay;
|
|
|
|
|
|
|
|
public:
|
2016-11-09 11:30:17 +01:00
|
|
|
HaikuOutput(const ConfigBlock &block)
|
2017-08-09 16:58:44 +02:00
|
|
|
:AudioOutput(0),
|
2016-11-09 11:30:17 +01:00
|
|
|
/* XXX: by default we should let the MediaKit propose the buffer size */
|
2018-01-02 17:22:25 +01:00
|
|
|
write_size(block.GetPositiveValue("write_size", 4096u)) {}
|
2015-09-17 22:18:16 +02:00
|
|
|
|
2016-11-09 11:30:17 +01:00
|
|
|
~HaikuOutput();
|
2015-09-17 22:18:16 +02:00
|
|
|
|
2017-08-09 16:58:44 +02:00
|
|
|
static AudioOutput *Create(EventLoop &event_loop,
|
2017-01-25 09:47:43 +01:00
|
|
|
const ConfigBlock &block);
|
2015-09-17 22:18:16 +02:00
|
|
|
|
2017-08-09 16:58:44 +02:00
|
|
|
private:
|
|
|
|
void Open(AudioFormat &audio_format) override;
|
|
|
|
void Close() noexcept override;
|
2015-09-17 22:18:16 +02:00
|
|
|
|
2017-08-09 16:58:44 +02:00
|
|
|
size_t Play(const void *chunk, size_t size) override;
|
2015-09-17 22:18:16 +02:00
|
|
|
|
2017-08-09 16:58:44 +02:00
|
|
|
std::chrono::steady_clock::duration Delay() const noexcept override;
|
2015-09-17 22:18:16 +02:00
|
|
|
|
2018-01-05 23:07:18 +01:00
|
|
|
static void _FillBuffer(void* cookie, void* _buffer, size_t size,
|
2020-03-12 20:56:11 +01:00
|
|
|
[[maybe_unused]] const media_raw_audio_format& _format);
|
2015-09-17 22:18:16 +02:00
|
|
|
void FillBuffer(void* _buffer, size_t size,
|
2020-03-12 20:56:11 +01:00
|
|
|
[[maybe_unused]] const media_raw_audio_format& _format);
|
2015-09-17 22:18:16 +02:00
|
|
|
|
2017-08-09 16:58:44 +02:00
|
|
|
void SendTag(const Tag &tag) override;
|
2015-09-17 22:18:16 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
static constexpr Domain haiku_output_domain("haiku_output");
|
|
|
|
|
|
|
|
static void
|
|
|
|
initialize_application()
|
|
|
|
{
|
|
|
|
// required to send the notification with a bitmap
|
|
|
|
// TODO: actually Run() it and handle B_QUIT_REQUESTED
|
|
|
|
// TODO: use some locking?
|
|
|
|
if (be_app == NULL) {
|
|
|
|
FormatDebug(haiku_output_domain, "creating be_app\n");
|
|
|
|
new BApplication("application/x-vnd.MusicPD");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
finalize_application()
|
|
|
|
{
|
|
|
|
// TODO: use some locking?
|
|
|
|
delete be_app;
|
|
|
|
be_app = NULL;
|
|
|
|
FormatDebug(haiku_output_domain, "deleting be_app\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool
|
|
|
|
haiku_test_default_device(void)
|
|
|
|
{
|
|
|
|
BSoundPlayer testPlayer;
|
|
|
|
return testPlayer.InitCheck() == B_OK;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-08-09 16:58:44 +02:00
|
|
|
inline AudioOutput *
|
2017-01-25 09:47:43 +01:00
|
|
|
HaikuOutput::Create(EventLoop &, const ConfigBlock &block)
|
2015-09-17 22:18:16 +02:00
|
|
|
{
|
|
|
|
initialize_application();
|
|
|
|
|
2016-11-09 11:30:17 +01:00
|
|
|
return new HaikuOutput(block);
|
2015-09-17 22:18:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2017-08-09 16:58:44 +02:00
|
|
|
HaikuOutput::Close() noexcept
|
2015-09-17 22:18:16 +02:00
|
|
|
{
|
|
|
|
sound_player->SetHasData(false);
|
|
|
|
delete_sem(new_buffer);
|
|
|
|
delete_sem(buffer_done);
|
|
|
|
sound_player->Stop();
|
|
|
|
delete sound_player;
|
|
|
|
sound_player = nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
HaikuOutput::~HaikuOutput()
|
|
|
|
{
|
|
|
|
finalize_application();
|
|
|
|
}
|
|
|
|
|
2018-01-05 23:07:18 +01:00
|
|
|
void
|
|
|
|
HaikuOutput::_FillBuffer(void* cookie, void* buffer, size_t size,
|
2015-09-17 22:18:16 +02:00
|
|
|
const media_raw_audio_format& format)
|
|
|
|
{
|
|
|
|
HaikuOutput *ad = (HaikuOutput *)cookie;
|
|
|
|
ad->FillBuffer(buffer, size, format);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
HaikuOutput::FillBuffer(void* _buffer, size_t size,
|
2020-03-12 20:56:11 +01:00
|
|
|
[[maybe_unused]] const media_raw_audio_format& _format)
|
2015-09-17 22:18:16 +02:00
|
|
|
{
|
|
|
|
|
|
|
|
buffer = (uint8*)_buffer;
|
|
|
|
buffer_size = size;
|
|
|
|
buffer_filled = 0;
|
|
|
|
bigtime_t start = system_time();
|
|
|
|
release_sem(new_buffer);
|
|
|
|
acquire_sem(buffer_done);
|
|
|
|
bigtime_t w = system_time() - start;
|
|
|
|
|
|
|
|
if (w > 5000LL) {
|
|
|
|
FormatDebug(haiku_output_domain,
|
|
|
|
"haiku:fill_buffer waited %Ldus\n", w);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (buffer_filled < buffer_size) {
|
|
|
|
memset(buffer + buffer_filled, 0,
|
|
|
|
buffer_size - buffer_filled);
|
|
|
|
FormatDebug(haiku_output_domain,
|
|
|
|
"haiku:fill_buffer filled %d size %d clearing remainder\n",
|
|
|
|
(int)buffer_filled, (int)buffer_size);
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-08-09 16:58:44 +02:00
|
|
|
void
|
2016-11-09 11:56:01 +01:00
|
|
|
HaikuOutput::Open(AudioFormat &audio_format)
|
2015-09-17 22:18:16 +02:00
|
|
|
{
|
|
|
|
status_t err;
|
2016-11-09 11:36:38 +01:00
|
|
|
format = media_multi_audio_format::wildcard;
|
2015-09-17 22:18:16 +02:00
|
|
|
|
|
|
|
switch (audio_format.format) {
|
|
|
|
case SampleFormat::S8:
|
2016-11-09 11:36:38 +01:00
|
|
|
format.format = media_raw_audio_format::B_AUDIO_CHAR;
|
2015-09-17 22:18:16 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SampleFormat::S16:
|
2016-11-09 11:36:38 +01:00
|
|
|
format.format = media_raw_audio_format::B_AUDIO_SHORT;
|
2015-09-17 22:18:16 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SampleFormat::S32:
|
2016-11-09 11:36:38 +01:00
|
|
|
format.format = media_raw_audio_format::B_AUDIO_INT;
|
2015-09-17 22:18:16 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SampleFormat::FLOAT:
|
2016-11-09 11:36:38 +01:00
|
|
|
format.format = media_raw_audio_format::B_AUDIO_FLOAT;
|
2015-09-17 22:18:16 +02:00
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
/* fall back to float */
|
|
|
|
audio_format.format = SampleFormat::FLOAT;
|
2016-11-09 11:36:38 +01:00
|
|
|
format.format = media_raw_audio_format::B_AUDIO_FLOAT;
|
2015-09-17 22:18:16 +02:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2016-11-09 11:36:38 +01:00
|
|
|
format.frame_rate = audio_format.sample_rate;
|
|
|
|
format.byte_order = B_MEDIA_HOST_ENDIAN;
|
|
|
|
format.channel_count = audio_format.channels;
|
2015-09-17 22:18:16 +02:00
|
|
|
|
|
|
|
buffer_size = 0;
|
|
|
|
|
|
|
|
if (write_size)
|
2016-11-09 11:36:38 +01:00
|
|
|
format.buffer_size = write_size;
|
2015-09-17 22:18:16 +02:00
|
|
|
else
|
2016-11-09 11:36:38 +01:00
|
|
|
format.buffer_size = BMediaRoster::Roster()->AudioBufferSizeFor(
|
|
|
|
format.channel_count, format.format,
|
|
|
|
format.frame_rate, B_UNKNOWN_BUS) * 2;
|
2015-09-17 22:18:16 +02:00
|
|
|
|
|
|
|
FormatDebug(haiku_output_domain,
|
|
|
|
"using haiku driver ad: bs: %d ws: %d "
|
|
|
|
"channels %d rate %f fmt %08lx bs %d\n",
|
|
|
|
(int)buffer_size, (int)write_size,
|
2016-11-09 11:36:38 +01:00
|
|
|
(int)format.channel_count, format.frame_rate,
|
|
|
|
format.format, (int)format.buffer_size);
|
2015-09-17 22:18:16 +02:00
|
|
|
|
2016-11-09 11:36:38 +01:00
|
|
|
sound_player = new BSoundPlayer(&format, "MPD Output",
|
2018-01-05 23:07:18 +01:00
|
|
|
HaikuOutput::_FillBuffer, NULL, this);
|
2015-09-17 22:18:16 +02:00
|
|
|
|
|
|
|
err = sound_player->InitCheck();
|
|
|
|
if (err != B_OK) {
|
|
|
|
delete sound_player;
|
|
|
|
sound_player = NULL;
|
2016-11-09 11:30:17 +01:00
|
|
|
throw MakeErrno(err, "BSoundPlayer::InitCheck() failed");
|
2015-09-17 22:18:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
// calculate the allowable delay for the buffer (ms)
|
2016-11-09 11:36:38 +01:00
|
|
|
buffer_delay = format.buffer_size;
|
|
|
|
buffer_delay /= (format.format &
|
2015-09-17 22:18:16 +02:00
|
|
|
media_raw_audio_format::B_AUDIO_SIZE_MASK);
|
2016-11-09 11:36:38 +01:00
|
|
|
buffer_delay /= format.channel_count;
|
|
|
|
buffer_delay *= 1000 / format.frame_rate;
|
2015-09-17 22:18:16 +02:00
|
|
|
// half of the total buffer play time
|
|
|
|
buffer_delay /= 2;
|
|
|
|
FormatDebug(haiku_output_domain,
|
|
|
|
"buffer delay: %d ms\n", buffer_delay);
|
|
|
|
|
|
|
|
new_buffer = create_sem(0, "New buffer request");
|
|
|
|
buffer_done = create_sem(0, "Buffer done");
|
|
|
|
|
|
|
|
sound_player->SetVolume(1.0);
|
|
|
|
sound_player->Start();
|
|
|
|
sound_player->SetHasData(false);
|
|
|
|
}
|
|
|
|
|
2017-08-09 16:58:44 +02:00
|
|
|
size_t
|
2016-11-09 11:56:01 +01:00
|
|
|
HaikuOutput::Play(const void *chunk, size_t size)
|
2015-09-17 22:18:16 +02:00
|
|
|
{
|
|
|
|
BSoundPlayer* const soundPlayer = sound_player;
|
|
|
|
const uint8 *data = (const uint8 *)chunk;
|
|
|
|
|
|
|
|
if (!soundPlayer->HasData())
|
|
|
|
soundPlayer->SetHasData(true);
|
|
|
|
acquire_sem(new_buffer);
|
|
|
|
|
|
|
|
size_t bytesLeft = size;
|
|
|
|
while (bytesLeft > 0) {
|
|
|
|
if (buffer_filled == buffer_size) {
|
|
|
|
// Request another buffer from BSoundPlayer
|
|
|
|
release_sem(buffer_done);
|
|
|
|
acquire_sem(new_buffer);
|
|
|
|
}
|
|
|
|
|
|
|
|
const size_t copyBytes = std::min(bytesLeft, buffer_size
|
|
|
|
- buffer_filled);
|
|
|
|
memcpy(buffer + buffer_filled, data,
|
|
|
|
copyBytes);
|
|
|
|
buffer_filled += copyBytes;
|
|
|
|
data += copyBytes;
|
|
|
|
bytesLeft -= copyBytes;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (buffer_filled < buffer_size) {
|
|
|
|
// Continue filling this buffer the next time this function is called
|
|
|
|
release_sem(new_buffer);
|
|
|
|
} else {
|
|
|
|
// Buffer is full
|
|
|
|
release_sem(buffer_done);
|
|
|
|
//soundPlayer->SetHasData(false);
|
|
|
|
}
|
|
|
|
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
2016-12-28 21:44:18 +01:00
|
|
|
inline std::chrono::steady_clock::duration
|
2017-08-09 16:58:44 +02:00
|
|
|
HaikuOutput::Delay() const noexcept
|
2015-09-17 22:18:16 +02:00
|
|
|
{
|
|
|
|
unsigned delay = buffer_filled ? 0 : buffer_delay;
|
|
|
|
|
|
|
|
//FormatDebug(haiku_output_domain,
|
|
|
|
// "delay=%d\n", delay / 2);
|
|
|
|
// XXX: doesn't work
|
|
|
|
//return (delay / 2) ? 1 : 0;
|
|
|
|
(void)delay;
|
|
|
|
|
2016-12-28 21:44:18 +01:00
|
|
|
return std::chrono::steady_clock::duration::zero();
|
2015-09-17 22:18:16 +02:00
|
|
|
}
|
|
|
|
|
2017-08-09 16:58:44 +02:00
|
|
|
void
|
2015-09-17 22:18:16 +02:00
|
|
|
HaikuOutput::SendTag(const Tag &tag)
|
|
|
|
{
|
|
|
|
status_t err;
|
|
|
|
|
|
|
|
/* lazily initialized */
|
|
|
|
static BBitmap *icon = NULL;
|
|
|
|
|
|
|
|
if (icon == NULL) {
|
|
|
|
BAppFileInfo info;
|
|
|
|
BResources resources;
|
|
|
|
err = resources.SetToImage((const void *)&HaikuOutput::SendTag);
|
|
|
|
BFile file(resources.File());
|
|
|
|
err = info.SetTo(&file);
|
|
|
|
icon = new BBitmap(BRect(0, 0, (float)B_LARGE_ICON - 1,
|
|
|
|
(float)B_LARGE_ICON - 1), B_BITMAP_NO_SERVER_LINK, B_RGBA32);
|
|
|
|
err = info.GetIcon(icon, B_LARGE_ICON);
|
|
|
|
if (err != B_OK) {
|
|
|
|
delete icon;
|
|
|
|
icon = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
BNotification notification(B_INFORMATION_NOTIFICATION);
|
|
|
|
|
|
|
|
BString messageId("mpd_");
|
|
|
|
messageId << find_thread(NULL);
|
|
|
|
notification.SetMessageID(messageId);
|
|
|
|
|
|
|
|
notification.SetGroup("Music Player Daemon");
|
|
|
|
|
|
|
|
char timebuf[16];
|
|
|
|
unsigned seconds = 0;
|
|
|
|
if (!tag.duration.IsNegative()) {
|
|
|
|
seconds = tag.duration.ToS();
|
2020-03-24 05:02:03 +01:00
|
|
|
snprintf(timebuf, sizeof(timebuf), "%02u:%02u:%02u",
|
2015-09-17 22:18:16 +02:00
|
|
|
seconds / 3600, (seconds % 3600) / 60, seconds % 60);
|
|
|
|
}
|
|
|
|
|
|
|
|
BString artist;
|
|
|
|
BString album;
|
|
|
|
BString title;
|
|
|
|
BString track;
|
|
|
|
BString name;
|
|
|
|
|
|
|
|
for (const auto &item : tag)
|
|
|
|
{
|
|
|
|
switch (item.type) {
|
|
|
|
case TAG_ARTIST:
|
|
|
|
case TAG_ALBUM_ARTIST:
|
|
|
|
if (artist.Length() == 0)
|
|
|
|
artist << item.value;
|
|
|
|
break;
|
|
|
|
case TAG_ALBUM:
|
|
|
|
if (album.Length() == 0)
|
|
|
|
album << item.value;
|
|
|
|
break;
|
|
|
|
case TAG_TITLE:
|
|
|
|
if (title.Length() == 0)
|
|
|
|
title << item.value;
|
|
|
|
break;
|
|
|
|
case TAG_TRACK:
|
|
|
|
if (track.Length() == 0)
|
|
|
|
track << item.value;
|
|
|
|
break;
|
|
|
|
case TAG_NAME:
|
|
|
|
if (name.Length() == 0)
|
|
|
|
name << item.value;
|
|
|
|
break;
|
|
|
|
case TAG_GENRE:
|
|
|
|
case TAG_DATE:
|
2017-04-17 01:08:19 +02:00
|
|
|
case TAG_ORIGINAL_DATE:
|
2015-09-17 22:18:16 +02:00
|
|
|
case TAG_PERFORMER:
|
|
|
|
case TAG_COMMENT:
|
|
|
|
case TAG_DISC:
|
|
|
|
case TAG_COMPOSER:
|
|
|
|
case TAG_MUSICBRAINZ_ARTISTID:
|
|
|
|
case TAG_MUSICBRAINZ_ALBUMID:
|
|
|
|
case TAG_MUSICBRAINZ_ALBUMARTISTID:
|
|
|
|
case TAG_MUSICBRAINZ_TRACKID:
|
|
|
|
default:
|
|
|
|
FormatDebug(haiku_output_domain,
|
|
|
|
"tag item: type %d value '%s'\n", item.type, item.value);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
notification.SetTitle(UTF8_PLAY " Now Playing:");
|
|
|
|
|
|
|
|
BStringList content;
|
|
|
|
if (name.Length())
|
|
|
|
content.Add(name);
|
|
|
|
if (artist.Length())
|
|
|
|
content.Add(artist);
|
|
|
|
if (album.Length())
|
|
|
|
content.Add(album);
|
|
|
|
if (track.Length())
|
|
|
|
content.Add(track);
|
|
|
|
if (title.Length())
|
|
|
|
content.Add(title);
|
|
|
|
|
|
|
|
if (content.CountStrings() == 0)
|
|
|
|
content.Add("(Unknown)");
|
|
|
|
|
|
|
|
BString full = content.Join(" " B_UTF8_BULLET " ");
|
|
|
|
|
|
|
|
if (seconds > 0)
|
|
|
|
full << " (" << timebuf << ")";
|
|
|
|
|
|
|
|
notification.SetContent(full);
|
|
|
|
|
|
|
|
err = notification.SetIcon(icon);
|
|
|
|
|
|
|
|
notification.Send();
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
haiku_output_get_volume(HaikuOutput &haiku)
|
|
|
|
{
|
|
|
|
BSoundPlayer* const soundPlayer = haiku.sound_player;
|
|
|
|
|
|
|
|
if (soundPlayer == NULL || soundPlayer->InitCheck() != B_OK)
|
|
|
|
return 0;
|
|
|
|
|
2018-09-22 19:08:03 +02:00
|
|
|
return lround(soundPlayer->Volume() * 100);
|
2015-09-17 22:18:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
haiku_output_set_volume(HaikuOutput &haiku, unsigned volume)
|
|
|
|
{
|
|
|
|
BSoundPlayer* const soundPlayer = haiku.sound_player;
|
|
|
|
|
|
|
|
if (soundPlayer == NULL || soundPlayer->InitCheck() != B_OK)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
soundPlayer->SetVolume((float)volume / 100);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
const struct AudioOutputPlugin haiku_output_plugin = {
|
|
|
|
"haiku",
|
|
|
|
haiku_test_default_device,
|
2017-08-09 16:58:44 +02:00
|
|
|
&HaikuOutput::Create,
|
2015-09-17 22:18:16 +02:00
|
|
|
&haiku_mixer_plugin,
|
|
|
|
};
|