Subversion Repositories mdb

/*

 * Copyright (C) 2015 by Andreas Theofilu <andreas@theosys.at>

 *

 * All rights reserved. No warranty, explicit or implicit, provided.

 *

 * NOTICE:  All information contained herein is, and remains

 * the property of Andreas Theofilu and his suppliers, if any.

 * The intellectual and technical concepts contained

 * herein are proprietary to Andreas Theofilu and its suppliers and

 * may be covered by European and Foreign Patents, patents in process,

 * and are protected by trade secret or copyright law.

 * Dissemination of this information or reproduction of this material

 * is strictly forbidden unless prior written permission is obtained

 * from Andreas Theofilu.

 */

#include <stdio.h>

#include <string.h>

#include <strings.h>

#include <unistd.h>

#include <stdlib.h>

#include <syslog.h>

#include <ao/ao.h>

#include <FLAC/all.h>

#include "config.h"

#include "helplib.h"

#include "play.h"

#include "user.h"

static FLAC__StreamDecoderWriteStatus sdWriteCallback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data);

static void sdMetadataCallback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data);

static void sdErrorCallback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void * client_data);

FLAC__StreamDecoder *fsd;

static FLAC__uint64 total_samples = 0;

static unsigned current_sample;

static unsigned sample_rate = 0;

static unsigned channels = 0;

static unsigned bps = 0;

static unsigned total_seconds, elapsed_seconds, old_second;

static double f_el_time;

ao_device *dev;

int last_todo;

struct st_params

{

	int s1;

	int driver;

};

extern char aoOutPlayers[15][16];

void playFlac(int s1, char *file)

{

int i, flag;

int driver;

char hv0[64];

struct st_params params;

	/* Check if we've a valid sound driver defined */

	flag = FALSE;

	i = 0;

	while (aoOutPlayers[i][0])

	{

		if (!strcasecmp(aoOutPlayers[i], configs.player))

		{

			flag = TRUE;

			break;

		}

		i++;

	}

	/* initializations */

	ao_initialize();

	if (flag)

	{

		if ((driver = ao_driver_id(configs.player)) == -1)

		{

			syslog(LOG_DAEMON, "Error finding the audio out driver %s!", configs.player);

			ao_shutdown();

			return;

		}

	}

	else if ((driver = ao_default_driver_id()) == -1)

	{

		syslog(LOG_DAEMON, "Error finding a default audio driver!");

		ao_shutdown();

		return;

	}

	if ((fsd = FLAC__stream_decoder_new()) == NULL)

	{

		syslog(LOG_DAEMON, "Error allocating memory for a new instance of FLAC stream decoder!");

		ao_shutdown();

		return;

	}

	(void)FLAC__stream_decoder_set_md5_checking(fsd, true);

	params.s1 = s1;

	params.driver = driver;

	current_sample = 0;

	old_second = 0;

	f_el_time = 0.0;

	if (FLAC__stream_decoder_init_file(fsd, file, sdWriteCallback, sdMetadataCallback, sdErrorCallback, (void *)&params) != FLAC__STREAM_DECODER_INIT_STATUS_OK)

	{

		syslog(LOG_DAEMON, "Error initializing file: %s [%s]", file, FLAC__StreamDecoderStateString[FLAC__stream_decoder_get_state(fsd)]);

		FLAC__stream_decoder_finish(fsd);

		FLAC__stream_decoder_delete(fsd);

		ao_shutdown();

		return;

	}

	if (!FLAC__stream_decoder_process_until_end_of_stream(fsd))

	{

		if (last_todo != PLAY_STATUS_STOP)

		{

			syslog(LOG_WARNING, "Error playing file %s", file);

			syslog(LOG_WARNING, "Error processing stream: %s", FLAC__StreamDecoderStateString[FLAC__stream_decoder_get_state(fsd)]);

			ao_close(dev);

			FLAC__stream_decoder_finish(fsd);

			FLAC__stream_decoder_delete(fsd);

			ao_shutdown();

			last_todo = 0;

			return;

		}

	}

	/* clean up */

	strcpy(hv0, "PLAYER:STOP;");

	write (s1, hv0, strlen(hv0));

	last_todo = 0;

	ao_close(dev);

	FLAC__stream_decoder_finish(fsd);

	FLAC__stream_decoder_delete(fsd);

	ao_shutdown();

}

FLAC__StreamDecoderWriteStatus sdWriteCallback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)

{

struct st_params *params = (struct st_params *)client_data;

int driver = params->driver;

int s1 = params->s1;

uint_32 samples = frame->header.blocksize;

uint_32 decoded_size = frame->header.blocksize * frame->header.channels * (bps / 8);

static uint_8 aobuf[FLAC__MAX_BLOCK_SIZE * FLAC__MAX_CHANNELS * sizeof(uint_32)]; /*oink!*/

uint_32 *u32aobuf = (uint_32 *) aobuf;

uint_16 *u16aobuf = (uint_16 *) aobuf;

uint_8   *u8aobuf = (uint_8  *) aobuf;

size_t i, j;

uint_32 sample, channel;

int todo;

	if (total_samples == 0) 

	{

		syslog(LOG_DAEMON, "ERROR: FLAC file have to have a total_samples count in STREAMINFO");

		return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;

	}

	if (channels <= 0 || (bps != 32 && bps != 16 && bps != 8))

	{

		syslog(LOG_DAEMON, "ERROR: Currently only 8bit, 16bit or 32bit streams supported!");

		return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;

	}

	if (buffer[0] == NULL) 

	{

		syslog(LOG_DAEMON, "ERROR: buffer [0] is NULL\n");

		return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;

	}

	if (buffer[1] == NULL) 

	{

		syslog(LOG_DAEMON, "ERROR: buffer [1] is NULL\n");

		return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;

	}

	todo = check_command(s1);

	if (todo == PLAY_STATUS_STOP)

	{

		last_todo = PLAY_STATUS_STOP;

		return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;

	}

	else if (todo == PLAY_STATUS_FWD)

	{

		FLAC__uint64 fr;

		FLAC__stream_decoder_get_decode_position(decoder, &fr);

		fr += 100;

		playStatus = PLAY_STATUS_PLAY;

		if (!FLAC__stream_decoder_seek_absolute(fsd, fr))

			return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;

		return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;

	}

	else if (todo == PLAY_STATUS_REW)

	{

		FLAC__uint64 fr;

		FLAC__stream_decoder_get_decode_position(decoder, &fr);

		if (fr > 100)

			fr -= 100;

		else

			fr = 0;

		playStatus = PLAY_STATUS_PLAY;

		if (!FLAC__stream_decoder_seek_absolute(fsd, fr))

			return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;

		return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;

	}

	/* Initialize audio out device */

	if (frame->header.number.sample_number == 0) 

	{

		ao_sample_format format;

		char hv0[256];

		/* set the output format and open the output device */

		format.bits = bps;

		format.rate = sample_rate;

		format.channels = channels;

		format.byte_format = AO_FMT_NATIVE;

		format.matrix = 0;

		if ((dev = ao_open_live(driver, &format, NULL)) == NULL)

		{

			switch (errno)

			{

				case AO_ENODRIVER:	sprintf(hv0, "No driver corresponds to \"driver_id\"."); break;

				case AO_ENOTLIVE:	sprintf(hv0, "This driver (%s) is not a live output device.", configs.player); break;

				case AO_EBADOPTION:	sprintf(hv0, "A valid option key has an invalid value."); break;

				case AO_EOPENDEVICE:sprintf(hv0, "Cannot open the device."); break;

				default:

					sprintf(hv0, "%s", strerror(errno));

			}

			syslog(LOG_DAEMON, "Error opening live playback device: %s", hv0);

			return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;

		}

		playStatus = PLAY_STATUS_PLAY;

		strcpy (hv0, "PLAYER:PLAY;");

		write(s1, hv0, strlen(hv0));

	}

	if (bps == 8)

	{

		for (sample = i = 0; sample < samples; sample++) 

		{

			for (channel = 0; channel < frame->header.channels; channel++,i++)

			{

				/* 8 bit wav data is unsigned */

				u8aobuf[i] = (uint_8)(buffer[channel][sample] + 0x80);

			}

		} 

	}

	else if (bps == 16)

	{

		for (sample = i = 0; sample < samples; sample++)

		{

			for(channel = 0; channel < frame->header.channels; channel++,i++)

				u16aobuf[i] = (uint_16)(buffer[channel][sample]);

		} 

	}

	else if (bps == 32)

	{

		for (sample = i = 0; sample < samples; sample++)

		{

			for(channel = 0; channel < frame->header.channels; channel++,i++)

				u32aobuf[i] = (uint_32)(buffer[channel][sample]);

		} 

	}

	ao_play(dev, (char *)aobuf, decoded_size);

	if (frame->header.number_type == FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER)

	{

		char hv0[255], hv1[32], hv2[32], hv3[32];

		double f_tm;

		current_sample += samples;

		f_tm = (double)samples / (double)frame->header.sample_rate;

		f_el_time += f_tm;

		elapsed_seconds = (unsigned)f_el_time;

		if (elapsed_seconds != old_second)

		{

			sprintf(hv0, "POSITION:%s:%s:%s;", secondsToString(elapsed_seconds, &hv1[0]), secondsToString(total_seconds - elapsed_seconds, &hv2[0]), secondsToString(total_seconds, &hv3[0]));

			write(s1, hv0, strlen(hv0));

			old_second = elapsed_seconds;

		}

	}

	return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;

}

static void sdMetadataCallback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)

{

	if(metadata->type == FLAC__METADATA_TYPE_STREAMINFO) 

	{

		/* save for later */

		FLAC__ASSERT(metadata->data.stream_info.total_samples < 0x100000000); /* we can handle < 4 gigasamples */

		total_samples = metadata->data.stream_info.total_samples & 0xffffffff;	/* metadata->data.stream_info.total_samples; */

		sample_rate = metadata->data.stream_info.sample_rate;

		channels = metadata->data.stream_info.channels;

		bps = metadata->data.stream_info.bits_per_sample;

		total_seconds = (unsigned)total_samples / sample_rate;

	}

}

static void sdErrorCallback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void * client_data)

{

	syslog(LOG_WARNING, "Got error callback: %s", FLAC__StreamDecoderErrorStatusString[status]);

}