output_all.c 10.7 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13
/*
 * Copyright (C) 2003-2009 The Music Player Daemon Project
 * http://www.musicpd.org
 *
 * 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.
14 15 16 17
 *
 * 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.
18 19 20 21 22
 */

#include "output_all.h"
#include "output_internal.h"
#include "output_control.h"
23
#include "chunk.h"
Max Kellermann's avatar
Max Kellermann committed
24
#include "conf.h"
25 26
#include "pipe.h"
#include "buffer.h"
27
#include "player_control.h"
28 29 30 31

#ifndef NDEBUG
#include "chunk.h"
#endif
32 33

#include <assert.h>
Max Kellermann's avatar
Max Kellermann committed
34
#include <string.h>
35

36 37 38
#undef G_LOG_DOMAIN
#define G_LOG_DOMAIN "output"

39 40
static struct audio_format input_audio_format;

41 42
static struct audio_output *audio_outputs;
static unsigned int num_audio_outputs;
43

44 45 46 47 48 49 50 51 52 53 54
/**
 * The #music_buffer object where consumed chunks are returned.
 */
static struct music_buffer *g_music_buffer;

/**
 * The #music_pipe object which feeds all audio outputs.  It is filled
 * by audio_output_all_play().
 */
static struct music_pipe *g_mp;

55 56 57 58 59
/**
 * The "elapsed_time" stamp of the most recently finished chunk.
 */
static float audio_output_all_elapsed_time;

60 61
unsigned int audio_output_count(void)
{
62
	return num_audio_outputs;
63 64 65 66 67
}

struct audio_output *
audio_output_get(unsigned i)
{
68
	assert(i < num_audio_outputs);
69

70
	return &audio_outputs[i];
71 72 73 74 75
}

struct audio_output *
audio_output_find(const char *name)
{
76
	for (unsigned i = 0; i < num_audio_outputs; ++i) {
77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
		struct audio_output *ao = audio_output_get(i);

		if (strcmp(ao->name, name) == 0)
			return ao;
	}

	/* name not found */
	return NULL;
}

static unsigned
audio_output_config_count(void)
{
	unsigned int nr = 0;
	const struct config_param *param = NULL;

	while ((param = config_get_next_param(CONF_AUDIO_OUTPUT, param)))
		nr++;
	if (!nr)
		nr = 1; /* we'll always have at least one device  */
	return nr;
}

100 101
void
audio_output_all_init(void)
102 103 104
{
	const struct config_param *param = NULL;
	unsigned int i;
105
	GError *error = NULL;
106 107 108

	notify_init(&audio_output_client_notify);

109 110
	num_audio_outputs = audio_output_config_count();
	audio_outputs = g_new(struct audio_output, num_audio_outputs);
111

112
	for (i = 0; i < num_audio_outputs; i++)
113
	{
114
		struct audio_output *output = &audio_outputs[i];
115 116 117 118 119
		unsigned int j;

		param = config_get_next_param(CONF_AUDIO_OUTPUT, param);

		/* only allow param to be NULL if there just one audioOutput */
120
		assert(param || (num_audio_outputs == 1));
121

122 123 124 125 126 127 128
		if (!audio_output_init(output, param, &error)) {
			if (param != NULL)
				g_error("line %i: %s",
					param->line, error->message);
			else
				g_error("%s", error->message);
		}
129 130 131

		/* require output names to be unique: */
		for (j = 0; j < i; j++) {
132
			if (!strcmp(output->name, audio_outputs[j].name)) {
133 134 135 136 137 138 139
				g_error("output devices with identical "
					"names: %s\n", output->name);
			}
		}
	}
}

140 141
void
audio_output_all_finish(void)
142 143 144
{
	unsigned int i;

145 146
	for (i = 0; i < num_audio_outputs; i++) {
		audio_output_finish(&audio_outputs[i]);
147 148
	}

149 150 151
	g_free(audio_outputs);
	audio_outputs = NULL;
	num_audio_outputs = 0;
152 153 154 155

	notify_deinit(&audio_output_client_notify);
}

156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174
void
audio_output_all_enable_disable(void)
{
	for (unsigned i = 0; i < num_audio_outputs; i++) {
		struct audio_output *ao = &audio_outputs[i];
		bool enabled;

		g_mutex_lock(ao->mutex);
		enabled = ao->really_enabled;
		g_mutex_unlock(ao->mutex);

		if (ao->enabled != enabled) {
			if (ao->enabled)
				audio_output_enable(ao);
			else
				audio_output_disable(ao);
		}
	}
}
175

176 177 178 179 180 181 182
/**
 * Determine if all (active) outputs have finished the current
 * command.
 */
static bool
audio_output_all_finished(void)
{
183 184 185 186 187 188 189 190 191 192
	for (unsigned i = 0; i < num_audio_outputs; ++i) {
		struct audio_output *ao = &audio_outputs[i];
		bool not_finished;

		g_mutex_lock(ao->mutex);
		not_finished = audio_output_is_open(ao) &&
			!audio_output_command_is_finished(ao);
		g_mutex_unlock(ao->mutex);

		if (not_finished)
193
			return false;
194
	}
195

196 197
	return true;
}
198

199 200 201
static void audio_output_wait_all(void)
{
	while (!audio_output_all_finished())
202 203 204
		notify_wait(&audio_output_client_notify);
}

205 206 207 208 209 210 211 212 213 214 215 216 217
static void
audio_output_reset_reopen(struct audio_output *ao)
{
	g_mutex_lock(ao->mutex);

	if (!ao->open && ao->fail_timer != NULL) {
		g_timer_destroy(ao->fail_timer);
		ao->fail_timer = NULL;
	}

	g_mutex_unlock(ao->mutex);
}

218 219 220 221 222 223 224 225
/**
 * Resets the "reopen" flag on all audio devices.  MPD should
 * immediately retry to open the device instead of waiting for the
 * timeout when the user wants to start playback.
 */
static void
audio_output_all_reset_reopen(void)
{
226 227 228
	for (unsigned i = 0; i < num_audio_outputs; ++i) {
		struct audio_output *ao = &audio_outputs[i];

229
		audio_output_reset_reopen(ao);
230
	}
231 232
}

233 234 235 236 237 238
/**
 * Opens all output devices which are enabled, but closed.
 *
 * @return true if there is at least open output device which is open
 */
static bool
239
audio_output_all_update(void)
240 241
{
	unsigned int i;
242
	bool ret = false;
243 244

	if (!audio_format_defined(&input_audio_format))
245
		return false;
246

247
	for (i = 0; i < num_audio_outputs; ++i)
248
		ret = audio_output_update(&audio_outputs[i],
249
					  &input_audio_format, g_mp) || ret;
250 251

	return ret;
252 253
}

254
bool
255
audio_output_all_play(struct music_chunk *chunk)
256
{
257
	bool ret;
258 259
	unsigned int i;

260 261 262 263
	assert(g_music_buffer != NULL);
	assert(g_mp != NULL);
	assert(chunk != NULL);
	assert(music_chunk_check_format(chunk, &input_audio_format));
264

265 266 267 268 269
	ret = audio_output_all_update();
	if (!ret)
		return false;

	music_pipe_push(g_mp, chunk);
270

271
	for (i = 0; i < num_audio_outputs; ++i)
272
		audio_output_play(&audio_outputs[i]);
273

274
	return true;
275 276
}

277
bool
278 279
audio_output_all_open(const struct audio_format *audio_format,
		      struct music_buffer *buffer)
280
{
281
	bool ret = false, enabled = false;
282 283
	unsigned int i;

284
	assert(audio_format != NULL);
285 286 287 288 289 290 291 292
	assert(buffer != NULL);
	assert(g_music_buffer == NULL || g_music_buffer == buffer);
	assert((g_mp == NULL) == (g_music_buffer == NULL));

	g_music_buffer = buffer;

	/* the audio format must be the same as existing chunks in the
	   pipe */
293
	assert(g_mp == NULL || music_pipe_check_format(g_mp, audio_format));
294 295 296 297 298 299 300 301 302 303

	if (g_mp == NULL)
		g_mp = music_pipe_new();
	else
		/* if the pipe hasn't been cleared, the the audio
		   format must not have changed */
		assert(music_pipe_size(g_mp) == 0 ||
		       audio_format_equals(audio_format,
					   &input_audio_format));

304
	input_audio_format = *audio_format;
305

306
	audio_output_all_reset_reopen();
307
	audio_output_all_update();
308

309
	for (i = 0; i < num_audio_outputs; ++i) {
310 311 312
		if (audio_outputs[i].enabled)
			enabled = true;

313
		if (audio_outputs[i].open)
314 315 316
			ret = true;
	}

317 318 319
	if (!enabled)
		g_warning("All audio outputs are disabled");

320 321
	if (!ret)
		/* close all devices if there was an error */
322
		audio_output_all_close();
323 324 325 326

	return ret;
}

327 328 329 330 331 332 333
/**
 * Has the specified audio output already consumed this chunk?
 */
static bool
chunk_is_consumed_in(const struct audio_output *ao,
		     const struct music_chunk *chunk)
{
334 335 336
	if (!ao->open)
		return true;

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
	if (ao->chunk == NULL)
		return false;

	assert(chunk == ao->chunk || music_pipe_contains(g_mp, ao->chunk));

	if (chunk != ao->chunk) {
		assert(chunk->next != NULL);
		return true;
	}

	return ao->chunk_finished && chunk->next == NULL;
}

/**
 * Has this chunk been consumed by all audio outputs?
 */
static bool
chunk_is_consumed(const struct music_chunk *chunk)
{
	for (unsigned i = 0; i < num_audio_outputs; ++i) {
		const struct audio_output *ao = &audio_outputs[i];
		bool consumed;

		g_mutex_lock(ao->mutex);
		consumed = chunk_is_consumed_in(ao, chunk);
		g_mutex_unlock(ao->mutex);

		if (!consumed)
			return false;
	}

	return true;
}

/**
 * There's only one chunk left in the pipe (#g_mp), and all audio
 * outputs have consumed it already.  Clear the reference.
 */
static void
376
clear_tail_chunk(G_GNUC_UNUSED const struct music_chunk *chunk, bool *locked)
377 378 379 380 381 382 383 384 385 386
{
	assert(chunk->next == NULL);
	assert(music_pipe_contains(g_mp, chunk));

	for (unsigned i = 0; i < num_audio_outputs; ++i) {
		struct audio_output *ao = &audio_outputs[i];

		/* this mutex will be unlocked by the caller when it's
		   ready */
		g_mutex_lock(ao->mutex);
387 388 389 390 391 392
		locked[i] = ao->open;

		if (!locked[i]) {
			g_mutex_unlock(ao->mutex);
			continue;
		}
393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416

		assert(ao->chunk == chunk);
		assert(ao->chunk_finished);
		ao->chunk = NULL;
	}
}

unsigned
audio_output_all_check(void)
{
	const struct music_chunk *chunk;
	bool is_tail;
	struct music_chunk *shifted;
	bool locked[num_audio_outputs];

	assert(g_music_buffer != NULL);
	assert(g_mp != NULL);

	while ((chunk = music_pipe_peek(g_mp)) != NULL) {
		assert(music_pipe_size(g_mp) > 0);

		if (!chunk_is_consumed(chunk))
			/* at least one output is not finished playing
			   this chunk */
417
			return music_pipe_size(g_mp);
418

419 420
		audio_output_all_elapsed_time = chunk->times;

421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444
		is_tail = chunk->next == NULL;
		if (is_tail)
			/* this is the tail of the pipe - clear the
			   chunk reference in all outputs */
			clear_tail_chunk(chunk, locked);

		/* remove the chunk from the pipe */
		shifted = music_pipe_shift(g_mp);
		assert(shifted == chunk);

		if (is_tail)
			/* unlock all audio outputs which were locked
			   by clear_tail_chunk() */
			for (unsigned i = 0; i < num_audio_outputs; ++i)
				if (locked[i])
					g_mutex_unlock(audio_outputs[i].mutex);

		/* return the chunk to the buffer */
		music_buffer_return(g_music_buffer, shifted);
	}

	return 0;
}

445 446 447 448 449 450
bool
audio_output_all_wait(unsigned threshold)
{
	if (audio_output_all_check() < threshold)
		return true;

451
	notify_wait(&pc.notify);
452 453 454 455

	return audio_output_all_check() < threshold;
}

456 457
void
audio_output_all_pause(void)
458 459 460
{
	unsigned int i;

461
	audio_output_all_update();
462

463
	for (i = 0; i < num_audio_outputs; ++i)
464
		audio_output_pause(&audio_outputs[i]);
465 466 467 468

	audio_output_wait_all();
}

469 470
void
audio_output_all_cancel(void)
471 472 473
{
	unsigned int i;

474 475
	/* send the cancel() command to all audio outputs */

476 477
	for (i = 0; i < num_audio_outputs; ++i)
		audio_output_cancel(&audio_outputs[i]);
478 479

	audio_output_wait_all();
480 481 482 483 484

	/* clear the music pipe and return all chunks to the buffer */

	if (g_mp != NULL)
		music_pipe_clear(g_mp, g_music_buffer);
485 486
}

487 488
void
audio_output_all_close(void)
489 490 491
{
	unsigned int i;

492 493
	for (i = 0; i < num_audio_outputs; ++i)
		audio_output_close(&audio_outputs[i]);
494

495 496
	if (g_mp != NULL) {
		assert(g_music_buffer != NULL);
497

498 499 500
		music_pipe_clear(g_mp, g_music_buffer);
		music_pipe_free(g_mp);
		g_mp = NULL;
501
		audio_output_all_elapsed_time = 0.0;
502
	}
503

504
	g_music_buffer = NULL;
505 506

	audio_format_clear(&input_audio_format);
507
}
508 509 510 511 512 513

float
audio_output_all_get_elapsed_time(void)
{
	return audio_output_all_elapsed_time;
}