HaikuOutputPlugin.cxx 10.7 KB
Newer Older
1
/*
Max Kellermann's avatar
Max Kellermann committed
2
 * Copyright 2003-2017 The Music Player Daemon Project
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
 * 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 "config.h"
#include "HaikuOutputPlugin.hxx"
#include "../OutputAPI.hxx"
#include "mixer/MixerList.hxx"
#include "util/Domain.hxx"
François Revol's avatar
François Revol committed
26
#include "system/Error.hxx"
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44
#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"

45
class HaikuOutput final: AudioOutput {
46 47 48 49 50
	friend int haiku_output_get_volume(HaikuOutput &haiku);
	friend bool haiku_output_set_volume(HaikuOutput &haiku, unsigned volume);

	size_t write_size;

51
	media_raw_audio_format format;
52 53 54 55 56 57 58 59 60 61 62 63
	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:
64
	HaikuOutput(const ConfigBlock &block)
65
		:AudioOutput(0),
66 67
		 /* XXX: by default we should let the MediaKit propose the buffer size */
		 write_size(block.GetBlockValue("write_size", 4096u)) {}
68

69
	~HaikuOutput();
70

71
	static AudioOutput *Create(EventLoop &event_loop,
72
				   const ConfigBlock &block);
73

74 75 76
private:
	void Open(AudioFormat &audio_format) override;
	void Close() noexcept override;
77

78 79
	size_t Play(const void *chunk, size_t size) override;
	void Cancel() noexcept override;
80

81
	std::chrono::steady_clock::duration Delay() const noexcept override;
82 83 84 85

	void FillBuffer(void* _buffer, size_t size,
		gcc_unused const media_raw_audio_format& _format);

86
	void SendTag(const Tag &tag) override;
87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
};

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;

}

120
inline AudioOutput *
121
HaikuOutput::Create(EventLoop &, const ConfigBlock &block)
122 123 124
{
	initialize_application();

125
	return new HaikuOutput(block);
126 127 128
}

void
129
HaikuOutput::Close() noexcept
130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183
{
	sound_player->SetHasData(false);
	delete_sem(new_buffer);
	delete_sem(buffer_done);
	sound_player->Stop();
	delete sound_player;
	sound_player = nullptr;
}

HaikuOutput::~HaikuOutput()
{
	delete_sem(new_buffer);
	delete_sem(buffer_done);

	finalize_application();
}

static void
fill_buffer(void* cookie, void* buffer, size_t size,
	const media_raw_audio_format& format)
{
	HaikuOutput *ad = (HaikuOutput *)cookie;
	ad->FillBuffer(buffer, size, format);
}


void
HaikuOutput::FillBuffer(void* _buffer, size_t size,
	gcc_unused const media_raw_audio_format& _format)
{

	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);

	}
}

184
void
185
HaikuOutput::Open(AudioFormat &audio_format)
186 187
{
	status_t err;
188
	format = media_multi_audio_format::wildcard;
189 190 191

	switch (audio_format.format) {
	case SampleFormat::S8:
192
		format.format = media_raw_audio_format::B_AUDIO_CHAR;
193 194 195
		break;

	case SampleFormat::S16:
196
		format.format = media_raw_audio_format::B_AUDIO_SHORT;
197 198 199
		break;

	case SampleFormat::S32:
200
		format.format = media_raw_audio_format::B_AUDIO_INT;
201 202 203
		break;

	case SampleFormat::FLOAT:
204
		format.format = media_raw_audio_format::B_AUDIO_FLOAT;
205 206 207 208 209
		break;

	default:
		/* fall back to float */
		audio_format.format = SampleFormat::FLOAT;
210
		format.format = media_raw_audio_format::B_AUDIO_FLOAT;
211 212 213
		break;
	}

214 215 216
	format.frame_rate = audio_format.sample_rate;
	format.byte_order = B_MEDIA_HOST_ENDIAN;
	format.channel_count = audio_format.channels;
217 218 219 220

	buffer_size = 0;

	if (write_size)
221
		format.buffer_size = write_size;
222
	else
223 224 225
		format.buffer_size = BMediaRoster::Roster()->AudioBufferSizeFor(
			format.channel_count, format.format,
			format.frame_rate, B_UNKNOWN_BUS) * 2;
226 227 228 229 230

	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,
231 232
			(int)format.channel_count, format.frame_rate,
			format.format, (int)format.buffer_size);
233

234
	sound_player = new BSoundPlayer(&format, "MPD Output",
235 236 237 238 239 240
		fill_buffer, NULL, this);

	err = sound_player->InitCheck();
	if (err != B_OK) {
		delete sound_player;
		sound_player = NULL;
241
		throw MakeErrno(err, "BSoundPlayer::InitCheck() failed");
242 243 244
	}

	// calculate the allowable delay for the buffer (ms)
245 246
	buffer_delay = format.buffer_size;
	buffer_delay /= (format.format &
247
		media_raw_audio_format::B_AUDIO_SIZE_MASK);
248 249
	buffer_delay /= format.channel_count;
	buffer_delay *= 1000 / format.frame_rate;
250 251 252 253 254 255 256 257 258 259 260 261 262
	// 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);
}

263
size_t
264
HaikuOutput::Play(const void *chunk, size_t size)
265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307
{
	BSoundPlayer* const soundPlayer = sound_player;
	const uint8 *data = (const uint8 *)chunk;

	if (size == 0) {
		soundPlayer->SetHasData(false);
		return 0;
	}

	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;
}

308
inline std::chrono::steady_clock::duration
309
HaikuOutput::Delay() const noexcept
310 311 312 313 314 315 316 317 318
{
	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;

319
	return std::chrono::steady_clock::duration::zero();
320 321
}

322
void
323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392
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();
		snprintf(timebuf, sizeof(timebuf), "%02d:%02d:%02d",
			 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:
393
		case TAG_ORIGINAL_DATE:
394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465
		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;

	return (int)(soundPlayer->Volume() * 100 + 0.5);
}

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;
}

typedef AudioOutputWrapper<HaikuOutput> Wrapper;

const struct AudioOutputPlugin haiku_output_plugin = {
	"haiku",
	haiku_test_default_device,
466
	&HaikuOutput::Create,
467 468
	&haiku_mixer_plugin,
};