WebSVN – mdb – Diff – /trunk/play_flac.c

 #include <strings.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <syslog.h>
 #include <ao/ao.h>
-#include <FLAC/stream_decoder.h>
+#include <FLAC/all.h>
 #include "config.h"
 #include "helplib.h"
 #include "play.h"
 #include "user.h"
 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 unsigned total_seconds;
+static double f_el_time;
 ao_device *dev;
+int last_todo;
 struct st_params
+{
 	int s1;
 	int driver;
 	(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);
 		return;
+	}
 	if (!FLAC__stream_decoder_process_until_end_of_stream(fsd))
+	{
+		if (last_todo != PLAY_STATUS_STOP)
+		{
-		syslog(LOG_DAEMON, "Error processing stream: %s", FLAC__StreamDecoderStateString[FLAC__stream_decoder_get_state(fsd)]);
+			syslog(LOG_DAEMON, "Error processing stream: %s", FLAC__StreamDecoderStateString[FLAC__stream_decoder_get_state(fsd)]);
-		FLAC__stream_decoder_finish(fsd);
+			FLAC__stream_decoder_finish(fsd);
-		FLAC__stream_decoder_delete(fsd);
+			FLAC__stream_decoder_delete(fsd);
-		ao_shutdown();
+			ao_shutdown();
+			last_todo = 0;
-		return;
+			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;
-const FLAC__uint32 total_size = (FLAC__uint32)(total_samples * channels * (bps / 8));
+//const FLAC__uint32 total_size = (FLAC__uint32)(total_samples * channels * (bps / 8));
+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_16 *u16aobuf = (uint_16 *) aobuf;
+uint_8   *u8aobuf = (uint_8  *) aobuf;
 size_t i, j;
+uint_32 sample, channel;
 int todo;
-FLAC__uint16 *buf;
-unsigned second;
 	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 != 2 || bps != 16)
+	if (channels != 2 || (bps != 16 && bps != 8))
+	{
-		syslog(LOG_DAEMON, "ERROR: Currently only 16bit stereo streams supported!");
+		syslog(LOG_DAEMON, "ERROR: Currently only 8bit or 16bit streams supported!");
 		return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
+	}
-	if (frame->header.channels != 2)
-	{
-		syslog(LOG_DAEMON, "ERROR: This frame contains %d channels (should be 2)", frame->header.channels);
-		return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
-	}
-	if (buffer [0] == NULL)
+	if (buffer[0] == NULL)
+	{
 		syslog(LOG_DAEMON, "ERROR: buffer [0] is NULL\n");
 		return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
+	}
-	if(buffer[1] == NULL)
+	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);
 		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", strerror(errno));
+			syslog(LOG_DAEMON, "Error opening live playback device: %s", hv0);
-/*			return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
+			return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
+		}
-*/
 		playStatus = PLAY_STATUS_PLAY;
 		strcpy (hv0, "PLAYER:PLAY;");
 		write(s1, hv0, strlen(hv0));
+	}
-	/* allocate memory for the buffer */
+	if (bps == 8)
-	if ((buf = (FLAC__uint16 *)calloc(frame->header.blocksize * 2, sizeof(FLAC__uint16))) == NULL)
+	{
-		syslog(LOG_DAEMON, "Error allocating memory for a buffer!");
+		for (sample = i = 0; sample < samples; sample++)
+		{
+			for (channel = 0; channel < frame->header.channels; channel++,i++)
+			{
+				/* 8 bit wav data is unsigned */
-		return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
+				u8aobuf[i] = (uint_8)(buffer[channel][sample] + 0x80);
+			}
+		}
+	}
-	j = 0;
+	else if (bps == 16)
-	for (i = 0; i < frame->header.blocksize; i++)
+	{
-		buf[j] = (FLAC__uint16)buffer[0][i];
+		for (sample = i = 0; sample < samples; sample++)
+		{
+			for(channel = 0; channel < frame->header.channels; channel++,i++)
-		buf[j+1] = (FLAC__uint16)buffer[1][i];
+				u16aobuf[i] = (uint_16)(buffer[channel][sample]);
-		j += 2;
+		}
+	}
+	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;
-		second = frame->header.number.sample_number / sample_rate;
+		current_sample += samples;
-		sprintf(hv0, "POSITION:%s:%s:%s;", secondsToString(second, &hv1[0]), secondsToString(total_seconds - second, &hv2[0]), secondsToString(total_seconds, &hv3[0]));
+		f_tm = (double)samples / (double)frame->header.sample_rate;
+		f_el_time += f_tm;
-		write(s1, hv0, strlen(hv0));
+		elapsed_seconds = (unsigned)f_el_time;
-	}
-	ao_play(dev, (char *)buf, frame->header.blocksize);
+		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]));
-	free (buf);
+			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;
+		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;
+	}

Subversion Repositories mdb

(root)/trunk/play_flac.c – Rev 33 → 35