Add mpd-indent.sh

src/audio.h

@@ -42,7 +42,7 @@ int cmpAudioFormat(AudioFormat * dest, AudioFormat * src);
 
 void getOutputAudioFormat(AudioFormat * inFormat, AudioFormat * outFormat);
 
-int parseAudioConfig(AudioFormat * audioFormat, char * conf);
+int parseAudioConfig(AudioFormat * audioFormat, char *conf);
 
 /* make sure initPlayerData is called before this function!! */
 void initAudioConfig();
@@ -55,7 +55,7 @@ void finishAudioDriver();
 
 int openAudioDevice(AudioFormat * audioFormat);
 
-int playAudio(char * playChunk,int size);
+int playAudio(char *playChunk, int size);
 
 void dropBufferedAudio();
 

src/audioOutput.c

@@ -22,30 +22,36 @@
 #include "log.h"
 #include "pcm_utils.h"
 
-#include <string.h> 
+#include <string.h>
 
 #define AUDIO_OUTPUT_TYPE	"type"
 #define AUDIO_OUTPUT_NAME	"name"
 #define AUDIO_OUTPUT_FORMAT	"format"
 
-static List * audioOutputPluginList;
+static List *audioOutputPluginList;
 
-void loadAudioOutputPlugin(AudioOutputPlugin * audioOutputPlugin) {
-	if(!audioOutputPlugin->name) return;
+void loadAudioOutputPlugin(AudioOutputPlugin * audioOutputPlugin)
+{
+	if (!audioOutputPlugin->name)
+		return;
 	insertInList(audioOutputPluginList, audioOutputPlugin->name,
-			audioOutputPlugin);
+		     audioOutputPlugin);
 }
 
-void unloadAudioOutputPlugin(AudioOutputPlugin * audioOutputPlugin) {
-	if(!audioOutputPlugin->name) return;
+void unloadAudioOutputPlugin(AudioOutputPlugin * audioOutputPlugin)
+{
+	if (!audioOutputPlugin->name)
+		return;
 	deleteFromList(audioOutputPluginList, audioOutputPlugin->name);
 }
 
-void initAudioOutputPlugins(void) {
+void initAudioOutputPlugins(void)
+{
 	audioOutputPluginList = makeList(NULL, 0);
 }
 
-void finishAudioOutputPlugins(void) {
+void finishAudioOutputPlugins(void)
+{
 	freeList(audioOutputPluginList);
 }
 
@@ -60,52 +66,50 @@ void finishAudioOutputPlugins(void) {
 	if(bp) str = bp->value; \
 }
 
-AudioOutput * newAudioOutput(ConfigParam * param) {
-	AudioOutput * ret = NULL;
-	void * data = NULL;
-	char * name = NULL;
-	char * format = NULL;
-	char * type = NULL;
-	BlockParam * bp = NULL;
-	AudioOutputPlugin * plugin = NULL;
-
-	if(param) {
+AudioOutput *newAudioOutput(ConfigParam * param)
+{
+	AudioOutput *ret = NULL;
+	void *data = NULL;
+	char *name = NULL;
+	char *format = NULL;
+	char *type = NULL;
+	BlockParam *bp = NULL;
+	AudioOutputPlugin *plugin = NULL;
+
+	if (param) {
 		getBlockParam(AUDIO_OUTPUT_NAME, name, 1);
 		getBlockParam(AUDIO_OUTPUT_TYPE, type, 1);
 		getBlockParam(AUDIO_OUTPUT_FORMAT, format, 0);
 
-		if(!findInList(audioOutputPluginList, type, &data)) {
+		if (!findInList(audioOutputPluginList, type, &data)) {
 			ERROR("couldn't find audio output plugin for type "
-					"\"%s\" at line %i\n", type, 
-					param->line);
+			      "\"%s\" at line %i\n", type, param->line);
 			exit(EXIT_FAILURE);
 		}
 
 		plugin = (AudioOutputPlugin *) data;
-	}
-	else {
-		ListNode * node = audioOutputPluginList->firstNode;
+	} else {
+		ListNode *node = audioOutputPluginList->firstNode;
 
-		WARNING("No \"%s\" defined in config file\n", 
-				CONF_AUDIO_OUTPUT);
+		WARNING("No \"%s\" defined in config file\n",
+			CONF_AUDIO_OUTPUT);
 		WARNING("Attempt to detect audio output device\n");
 
-		while(node) {
+		while (node) {
 			plugin = (AudioOutputPlugin *) node->data;
-			if(plugin->testDefaultDeviceFunc) {
+			if (plugin->testDefaultDeviceFunc) {
 				WARNING("Attempting to detect a %s audio "
-						"device\n", plugin->name);
-				if(plugin->testDefaultDeviceFunc() == 0) {
+					"device\n", plugin->name);
+				if (plugin->testDefaultDeviceFunc() == 0) {
 					WARNING("Successfully detected a %s "
-							"audio device\n",
-							plugin->name);
+						"audio device\n", plugin->name);
 					break;
 				}
 			}
 			node = node->nextNode;
 		}
 
-		if(!node) {
+		if (!node) {
 			WARNING("Unable to detect an audio device\n");
 			return NULL;
 		}
@@ -134,20 +138,18 @@ AudioOutput * newAudioOutput(ConfigParam * param) {
 	memset(&ret->outAudioFormat, 0, sizeof(AudioFormat));
 	memset(&ret->reqAudioFormat, 0, sizeof(AudioFormat));
 
-	if(format) {
+	if (format) {
 		ret->convertAudioFormat = 1;
 
-		if(0 != parseAudioConfig(&ret->reqAudioFormat, format))
-		{
-			ERROR("error parsing format at line %i\n", 
-					bp->line);
+		if (0 != parseAudioConfig(&ret->reqAudioFormat, format)) {
+			ERROR("error parsing format at line %i\n", bp->line);
 			exit(EXIT_FAILURE);
 		}
 
 		copyAudioFormat(&ret->outAudioFormat, &ret->reqAudioFormat);
 	}
 
-	if(plugin->initDriverFunc(ret, param) != 0) {
+	if (plugin->initDriverFunc(ret, param) != 0) {
 		free(ret);
 		ret = NULL;
 	}
@@ -155,13 +157,13 @@ AudioOutput * newAudioOutput(ConfigParam * param) {
 	return ret;
 }
 
-int openAudioOutput(AudioOutput * audioOutput, AudioFormat * audioFormat) {
+int openAudioOutput(AudioOutput * audioOutput, AudioFormat * audioFormat)
+{
 	int ret;
-	
-	if(audioOutput->open) {
-		if(cmpAudioFormat(audioFormat, &audioOutput->inAudioFormat) 
-				== 0) 
-		{
+
+	if (audioOutput->open) {
+		if (cmpAudioFormat(audioFormat, &audioOutput->inAudioFormat)
+		    == 0) {
 			return 0;
 		}
 		closeAudioOutput(audioOutput);
@@ -169,92 +171,103 @@ int openAudioOutput(AudioOutput * audioOutput, AudioFormat * audioFormat) {
 
 	copyAudioFormat(&audioOutput->inAudioFormat, audioFormat);
 
-	if(audioOutput->convertAudioFormat) {
+	if (audioOutput->convertAudioFormat) {
 		copyAudioFormat(&audioOutput->outAudioFormat,
 				&audioOutput->reqAudioFormat);
-	}
-	else {
-		copyAudioFormat(&audioOutput->outAudioFormat, 
+	} else {
+		copyAudioFormat(&audioOutput->outAudioFormat,
 				&audioOutput->inAudioFormat);
 	}
 
 	ret = audioOutput->openDeviceFunc(audioOutput);
 
-	if(cmpAudioFormat(&audioOutput->inAudioFormat, 
-			  &audioOutput->outAudioFormat) == 0)
-	{
+	if (cmpAudioFormat(&audioOutput->inAudioFormat,
+			   &audioOutput->outAudioFormat) == 0) {
 		audioOutput->sameInAndOutFormats = 1;
-	}
-	else audioOutput->sameInAndOutFormats = 0;
+	} else
+		audioOutput->sameInAndOutFormats = 0;
 
 	return ret;
 }
 
-static void convertAudioFormat(AudioOutput * audioOutput, char ** chunkArgPtr,
-		int * sizeArgPtr)
+static void convertAudioFormat(AudioOutput * audioOutput, char **chunkArgPtr,
+			       int *sizeArgPtr)
 {
-	int size = pcm_sizeOfOutputBufferForAudioFormatConversion(
-			&(audioOutput->inAudioFormat), *sizeArgPtr, 
-			&(audioOutput->outAudioFormat));
-
-	if(size > audioOutput->convBufferLen) {
-		audioOutput->convBuffer = 
-				realloc(audioOutput->convBuffer, size);
+	int size =
+	    pcm_sizeOfOutputBufferForAudioFormatConversion(&
+							   (audioOutput->
+							    inAudioFormat),
+							   *sizeArgPtr,
+&(audioOutput->outAudioFormat));
+
+	if (size > audioOutput->convBufferLen) {
+		audioOutput->convBuffer =
+		    realloc(audioOutput->convBuffer, size);
 		audioOutput->convBufferLen = size;
 	}
 
-	pcm_convertAudioFormat(&(audioOutput->inAudioFormat), *chunkArgPtr, 
-			*sizeArgPtr, &(audioOutput->outAudioFormat), 
-			audioOutput->convBuffer);
-	
+	pcm_convertAudioFormat(&(audioOutput->inAudioFormat), *chunkArgPtr,
+			       *sizeArgPtr, &(audioOutput->outAudioFormat),
+			       audioOutput->convBuffer);
+
 	*sizeArgPtr = size;
 	*chunkArgPtr = audioOutput->convBuffer;
 }
 
-int playAudioOutput(AudioOutput * audioOutput, char * playChunk, int size) {
+int playAudioOutput(AudioOutput * audioOutput, char *playChunk, int size)
+{
 	int ret;
 
-	if(!audioOutput->open) return -1;
+	if (!audioOutput->open)
+		return -1;
 
-	if(!audioOutput->sameInAndOutFormats) {
+	if (!audioOutput->sameInAndOutFormats) {
 		convertAudioFormat(audioOutput, &playChunk, &size);
 	}
 
-
 	ret = audioOutput->playFunc(audioOutput, playChunk, size);
 
 	return ret;
 }
 
-void dropBufferedAudioOutput(AudioOutput * audioOutput) {
-	if(audioOutput->open) audioOutput->dropBufferedAudioFunc(audioOutput);
+void dropBufferedAudioOutput(AudioOutput * audioOutput)
+{
+	if (audioOutput->open)
+		audioOutput->dropBufferedAudioFunc(audioOutput);
 }
 
-void closeAudioOutput(AudioOutput * audioOutput) {
-	if(audioOutput->open) audioOutput->closeDeviceFunc(audioOutput);
+void closeAudioOutput(AudioOutput * audioOutput)
+{
+	if (audioOutput->open)
+		audioOutput->closeDeviceFunc(audioOutput);
 }
 
-void finishAudioOutput(AudioOutput * audioOutput) {
+void finishAudioOutput(AudioOutput * audioOutput)
+{
 	closeAudioOutput(audioOutput);
 	audioOutput->finishDriverFunc(audioOutput);
-	if(audioOutput->convBuffer) free(audioOutput->convBuffer);
+	if (audioOutput->convBuffer)
+		free(audioOutput->convBuffer);
 	free(audioOutput->type);
 	free(audioOutput->name);
 	free(audioOutput);
 }
 
-void sendMetadataToAudioOutput(AudioOutput * audioOutput, MpdTag * tag) {
-	if(!audioOutput->sendMetdataFunc) return;
+void sendMetadataToAudioOutput(AudioOutput * audioOutput, MpdTag * tag)
+{
+	if (!audioOutput->sendMetdataFunc)
+		return;
 	audioOutput->sendMetdataFunc(audioOutput, tag);
 }
 
-void printAllOutputPluginTypes(FILE *fp) {
+void printAllOutputPluginTypes(FILE * fp)
+{
 	ListNode *node = audioOutputPluginList->firstNode;
 	AudioOutputPlugin *plugin;
-		
-	while(node) {
-		plugin = (AudioOutputPlugin *)node->data;
-		myfprintf(fp, "%s ", plugin->name);	
+
+	while (node) {
+		plugin = (AudioOutputPlugin *) node->data;
+		myfprintf(fp, "%s ", plugin->name);
 		node = node->nextNode;
 	}
 	myfprintf(fp, "\n");

src/audioOutput.h

@@ -40,59 +40,59 @@
 
 typedef struct _AudioOutput AudioOutput;
 
-typedef int (* AudioOutputTestDefaultDeviceFunc) ();
+typedef int (*AudioOutputTestDefaultDeviceFunc) ();
 
-typedef int (* AudioOutputInitDriverFunc) (AudioOutput * audioOutput, 
-		ConfigParam * param);
+typedef int (*AudioOutputInitDriverFunc) (AudioOutput * audioOutput,
+					  ConfigParam * param);
 
-typedef void (* AudioOutputFinishDriverFunc) (AudioOutput * audioOutput);
+typedef void (*AudioOutputFinishDriverFunc) (AudioOutput * audioOutput);
 
-typedef int (* AudioOutputOpenDeviceFunc) (AudioOutput * audioOutput);
+typedef int (*AudioOutputOpenDeviceFunc) (AudioOutput * audioOutput);
 
-typedef int (* AudioOutputPlayFunc) (AudioOutput * audioOutput,
-                char * playChunk, int size);
+typedef int (*AudioOutputPlayFunc) (AudioOutput * audioOutput,
+				    char *playChunk, int size);
 
-typedef void (* AudioOutputDropBufferedAudioFunc) (AudioOutput * audioOutput);
+typedef void (*AudioOutputDropBufferedAudioFunc) (AudioOutput * audioOutput);
 
-typedef void (* AudioOutputCloseDeviceFunc) (AudioOutput * audioOutput);
+typedef void (*AudioOutputCloseDeviceFunc) (AudioOutput * audioOutput);
 
-typedef void (* AudioOutputSendMetadataFunc) (AudioOutput * audioOutput,
-		MpdTag * tag);
+typedef void (*AudioOutputSendMetadataFunc) (AudioOutput * audioOutput,
+					     MpdTag * tag);
 
 struct _AudioOutput {
 	int open;
-	char * name;
-	char * type;
-
-        AudioOutputFinishDriverFunc finishDriverFunc;
-        AudioOutputOpenDeviceFunc openDeviceFunc;
-        AudioOutputPlayFunc playFunc;
-        AudioOutputDropBufferedAudioFunc dropBufferedAudioFunc;
-        AudioOutputCloseDeviceFunc closeDeviceFunc;
+	char *name;
+	char *type;
+
+	AudioOutputFinishDriverFunc finishDriverFunc;
+	AudioOutputOpenDeviceFunc openDeviceFunc;
+	AudioOutputPlayFunc playFunc;
+	AudioOutputDropBufferedAudioFunc dropBufferedAudioFunc;
+	AudioOutputCloseDeviceFunc closeDeviceFunc;
 	AudioOutputSendMetadataFunc sendMetdataFunc;
 
 	int convertAudioFormat;
 	AudioFormat inAudioFormat;
 	AudioFormat outAudioFormat;
 	AudioFormat reqAudioFormat;
-	char * convBuffer;
+	char *convBuffer;
 	int convBufferLen;
 	int sameInAndOutFormats;
 
-        void * data;
+	void *data;
 };
 
 typedef struct _AudioOutputPlugin {
-	char * name;
+	char *name;
 
 	AudioOutputTestDefaultDeviceFunc testDefaultDeviceFunc;
-        AudioOutputInitDriverFunc initDriverFunc;
-        AudioOutputFinishDriverFunc finishDriverFunc;
-        AudioOutputOpenDeviceFunc openDeviceFunc;
-        AudioOutputPlayFunc playFunc;
-        AudioOutputDropBufferedAudioFunc dropBufferedAudioFunc;
-        AudioOutputCloseDeviceFunc closeDeviceFunc;
-        AudioOutputSendMetadataFunc sendMetdataFunc;
+	AudioOutputInitDriverFunc initDriverFunc;
+	AudioOutputFinishDriverFunc finishDriverFunc;
+	AudioOutputOpenDeviceFunc openDeviceFunc;
+	AudioOutputPlayFunc playFunc;
+	AudioOutputDropBufferedAudioFunc dropBufferedAudioFunc;
+	AudioOutputCloseDeviceFunc closeDeviceFunc;
+	AudioOutputSendMetadataFunc sendMetdataFunc;
 } AudioOutputPlugin;
 
 void initAudioOutputPlugins();
@@ -101,14 +101,14 @@ void finishAudioOutputPlugins();
 void loadAudioOutputPlugin(AudioOutputPlugin * audioOutputPlugin);
 void unloadAudioOutputPlugin(AudioOutputPlugin * audioOutputPlugin);
 
-AudioOutput * newAudioOutput(ConfigParam * param);
+AudioOutput *newAudioOutput(ConfigParam * param);
 int openAudioOutput(AudioOutput * audioOutput, AudioFormat * audioFormat);
-int playAudioOutput(AudioOutput * audioOutput, char * playChunk, int size);
+int playAudioOutput(AudioOutput * audioOutput, char *playChunk, int size);
 void dropBufferedAudioOutput(AudioOutput * audioOutput);
 void closeAudioOutput(AudioOutput * audioOutput);
 void finishAudioOutput(AudioOutput * audioOutput);
 int keepAudioOutputAlive(AudioOutput * audioOutput, int ms);
 void sendMetadataToAudioOutput(AudioOutput * audioOutput, MpdTag * tag);
 
-void printAllOutputPluginTypes(FILE *fp);
+void printAllOutputPluginTypes(FILE * fp);
 #endif

src/audioOutputs/audioOutput_ao.c

@@ -34,122 +34,120 @@ static int driverInitCount = 0;
 typedef struct _AoData {
 	int writeSize;
 	int driverId;
-	ao_option * options;
-	ao_device * device;
+	ao_option *options;
+	ao_device *device;
 } AoData;
 
-static AoData * newAoData() {
-	AoData * ret = malloc(sizeof(AoData));
+static AoData *newAoData()
+{
+	AoData *ret = malloc(sizeof(AoData));
 	ret->device = NULL;
 	ret->options = NULL;
 
 	return ret;
 }
 
-static void audioOutputAo_error() {
-	if(errno==AO_ENOTLIVE) {
+static void audioOutputAo_error()
+{
+	if (errno == AO_ENOTLIVE) {
 		ERROR("not a live ao device\n");
-	}
-	else if(errno==AO_EOPENDEVICE) {
+	} else if (errno == AO_EOPENDEVICE) {
 		ERROR("not able to open audio device\n");
-	}
-	else if(errno==AO_EBADOPTION) {
+	} else if (errno == AO_EBADOPTION) {
 		ERROR("bad driver option\n");
 	}
 }
 
 static int audioOutputAo_initDriver(AudioOutput * audioOutput,
-		ConfigParam * param)
+				    ConfigParam * param)
 {
-	ao_info * ai;
-	char * dup;
-	char * stk1;
-	char * stk2;
-	char * n1;
-	char * key;
-	char * value;
-	char * test;
-	AoData * ad  = newAoData();
-	BlockParam * blockParam;
+	ao_info *ai;
+	char *dup;
+	char *stk1;
+	char *stk2;
+	char *n1;
+	char *key;
+	char *value;
+	char *test;
+	AoData *ad = newAoData();
+	BlockParam *blockParam;
 
 	audioOutput->data = ad;
 
-	if((blockParam = getBlockParam(param, "write_size"))) {
+	if ((blockParam = getBlockParam(param, "write_size"))) {
 		ad->writeSize = strtol(blockParam->value, &test, 10);
-		if (*test!='\0') {
+		if (*test != '\0') {
 			ERROR("\"%s\" is not a valid write size at line %i\n",
-				blockParam->value, blockParam->line);
+			      blockParam->value, blockParam->line);
 			exit(EXIT_FAILURE);
 		}
-	}
-	else ad->writeSize = 1024;
+	} else
+		ad->writeSize = 1024;
 
-	if(driverInitCount == 0) {
+	if (driverInitCount == 0) {
 		ao_initialize();
 	}
 	driverInitCount++;
 
 	blockParam = getBlockParam(param, "driver");
 
-	if(!blockParam || 0 == strcmp(blockParam->value,"default")) {
+	if (!blockParam || 0 == strcmp(blockParam->value, "default")) {
 		ad->driverId = ao_default_driver_id();
-	}
-	else if((ad->driverId = 
-		ao_driver_id(blockParam->value))<0) {
+	} else if ((ad->driverId = ao_driver_id(blockParam->value)) < 0) {
 		ERROR("\"%s\" is not a valid ao driver at line %i\n",
-			blockParam->value, blockParam->line);
+		      blockParam->value, blockParam->line);
 		exit(EXIT_FAILURE);
 	}
-	
-	if((ai = ao_driver_info(ad->driverId))==NULL) {
+
+	if ((ai = ao_driver_info(ad->driverId)) == NULL) {
 		ERROR("problems getting driver info for device defined at "
-				"line %i\n", param->line);
+		      "line %i\n", param->line);
 		ERROR("you may not have permission to the audio device\n");
 		exit(EXIT_FAILURE);
 	}
 
-	DEBUG("using ao driver \"%s\" for \"%s\"\n", ai->short_name, 
-			audioOutput->name); 
+	DEBUG("using ao driver \"%s\" for \"%s\"\n", ai->short_name,
+	      audioOutput->name);
 
 	blockParam = getBlockParam(param, "options");
 
-	if(blockParam) {
+	if (blockParam) {
 		dup = strdup(blockParam->value);
-	}
-	else dup = strdup("");
+	} else
+		dup = strdup("");
 
-	if(strlen(dup)) {
+	if (strlen(dup)) {
 		stk1 = NULL;
-		n1 = strtok_r(dup,";",&stk1);
-		while(n1) {
+		n1 = strtok_r(dup, ";", &stk1);
+		while (n1) {
 			stk2 = NULL;
-			key = strtok_r(n1,"=",&stk2);
-			if(!key) {
+			key = strtok_r(n1, "=", &stk2);
+			if (!key) {
 				ERROR("problems parsing "
-					"ao_driver_options \"%s\"\n", n1);
+				      "ao_driver_options \"%s\"\n", n1);
 				exit(EXIT_FAILURE);
 			}
 			/*found = 0;
-			for(i=0;i<ai->option_count;i++) {
-				if(strcmp(ai->options[i],key)==0) {
-					found = 1;
-					break;
-				}
-			}
-			if(!found) {
-				ERROR("\"%s\" is not an option for "
-					 "\"%s\" ao driver\n",key,
-					 ai->short_name);
-				exit(EXIT_FAILURE);
-			}*/
-			value = strtok_r(NULL,"",&stk2);
-			if(!value) {
+			   for(i=0;i<ai->option_count;i++) {
+			   if(strcmp(ai->options[i],key)==0) {
+			   found = 1;
+			   break;
+			   }
+			   }
+			   if(!found) {
+			   ERROR("\"%s\" is not an option for "
+			   "\"%s\" ao driver\n",key,
+			   ai->short_name);
+			   exit(EXIT_FAILURE);
+			   } */
+			value = strtok_r(NULL, "", &stk2);
+			if (!value) {
 				ERROR("problems parsing "
-					"ao_driver_options \"%s\"\n", n1);
+				      "ao_driver_options \"%s\"\n", n1);
 				exit(EXIT_FAILURE);
 			}
-			ao_append_option(&ad->options,key,value);
-			n1 = strtok_r(NULL,";",&stk1);
+			ao_append_option(&ad->options, key, value);
+			n1 = strtok_r(NULL, ";", &stk1);
 		}
 	}
 	free(dup);
@@ -157,28 +155,33 @@ static int audioOutputAo_initDriver(AudioOutput * audioOutput,
 	return 0;
 }
 
-static void freeAoData(AoData * ad) {
+static void freeAoData(AoData * ad)
+{
 	ao_free_options(ad->options);
 	free(ad);
 }
 
-static void audioOutputAo_finishDriver(AudioOutput * audioOutput) {
-	AoData * ad = (AoData *)audioOutput->data;
+static void audioOutputAo_finishDriver(AudioOutput * audioOutput)
+{
+	AoData *ad = (AoData *) audioOutput->data;
 	freeAoData(ad);
 
 	driverInitCount--;
 
-	if(driverInitCount == 0) ao_shutdown();
+	if (driverInitCount == 0)
+		ao_shutdown();
 }
 
-static void audioOutputAo_dropBufferedAudio(AudioOutput * audioOutput) {
+static void audioOutputAo_dropBufferedAudio(AudioOutput * audioOutput)
+{
 	/* not supported by libao */
 }
 
-static void audioOutputAo_closeDevice(AudioOutput * audioOutput) {
-	AoData * ad = (AoData *) audioOutput->data;
+static void audioOutputAo_closeDevice(AudioOutput * audioOutput)
+{
+	AoData *ad = (AoData *) audioOutput->data;
 
-	if(ad->device) {
+	if (ad->device) {
 		ao_close(ad->device);
 		ad->device = NULL;
 	}
@@ -186,11 +189,12 @@ static void audioOutputAo_closeDevice(AudioOutput * audioOutput) {
 	audioOutput->open = 0;
 }
 
-static int audioOutputAo_openDevice(AudioOutput * audioOutput) {
+static int audioOutputAo_openDevice(AudioOutput * audioOutput)
+{
 	ao_sample_format format;
-	AoData * ad = (AoData *)audioOutput->data;
+	AoData *ad = (AoData *) audioOutput->data;
 
-	if(ad->device) {
+	if (ad->device) {
 		audioOutputAo_closeDevice(audioOutput);
 	}
 
@@ -201,41 +205,41 @@ static int audioOutputAo_openDevice(AudioOutput * audioOutput) {
 
 	ad->device = ao_open_live(ad->driverId, &format, ad->options);
 
-	if(ad->device==NULL) return -1;
+	if (ad->device == NULL)
+		return -1;
 
 	audioOutput->open = 1;
 
 	return 0;
 }
 
-
-static int audioOutputAo_play(AudioOutput * audioOutput, char * playChunk, 
-		int size) 
+static int audioOutputAo_play(AudioOutput * audioOutput, char *playChunk,
+			      int size)
 {
 	int send;
-	AoData * ad = (AoData *)audioOutput->data;
+	AoData *ad = (AoData *) audioOutput->data;
+
+	if (ad->device == NULL)
+		return -1;
 
-	if(ad->device==NULL) return -1;
-	
-	while(size>0) {
+	while (size > 0) {
 		send = ad->writeSize > size ? size : ad->writeSize;
-		
-		if(ao_play(ad->device, playChunk, send)==0) {
+
+		if (ao_play(ad->device, playChunk, send) == 0) {
 			audioOutputAo_error();
 			ERROR("closing audio device due to write error\n");
 			audioOutputAo_closeDevice(audioOutput);
 			return -1;
 		}
 
-		playChunk+=send;
-		size-=send;
+		playChunk += send;
+		size -= send;
 	}
 
 	return 0;
 }
 
-AudioOutputPlugin aoPlugin = 
-{
+AudioOutputPlugin aoPlugin = {
 	"ao",
 	NULL,
 	audioOutputAo_initDriver,
@@ -244,7 +248,7 @@ AudioOutputPlugin aoPlugin =
 	audioOutputAo_play,
 	audioOutputAo_dropBufferedAudio,
 	audioOutputAo_closeDevice,
-	NULL, /* sendMetadataFunc */
+	NULL,			/* sendMetadataFunc */
 };
 
 #else
@@ -252,5 +256,4 @@ AudioOutputPlugin aoPlugin =
 #include <stdio.h>
 
 DISABLED_AUDIO_OUTPUT_PLUGIN(aoPlugin)
-
 #endif

src/audioOutputs/audioOutput_pulse.c

@@ -34,17 +34,17 @@
 #define CONN_ATTEMPT_INTERVAL 60
 
 typedef struct _PulseData {
-	pa_simple * s;
-	char * server;
-	char * sink;
+	pa_simple *s;
+	char *server;
+	char *sink;
 	int connAttempts;
 	time_t lastAttempt;
 } PulseData;
 
-static PulseData * newPulseData()
+static PulseData *newPulseData()
 {
-	PulseData * ret;
-	
+	PulseData *ret;
+
 	ret = malloc(sizeof(PulseData));
 
 	ret->s = NULL;
@@ -58,16 +58,18 @@ static PulseData * newPulseData()
 
 static void freePulseData(PulseData * pd)
 {
-	if (pd->server) free(pd->server);
-	if (pd->sink) free(pd->sink);
+	if (pd->server)
+		free(pd->server);
+	if (pd->sink)
+		free(pd->sink);
 	free(pd);
 }
 
 static int pulse_initDriver(AudioOutput * audioOutput, ConfigParam * param)
 {
-	BlockParam * server = NULL;
-	BlockParam * sink = NULL;
-	PulseData * pd;
+	BlockParam *server = NULL;
+	BlockParam *sink = NULL;
+	PulseData *pd;
 
 	if (param) {
 		server = getBlockParam(param, "server");
@@ -89,7 +91,7 @@ static void pulse_finishDriver(AudioOutput * audioOutput)
 
 static int pulse_testDefault()
 {
-	pa_simple * s;
+	pa_simple *s;
 	pa_sample_spec ss;
 	int error;
 
@@ -98,10 +100,10 @@ static int pulse_testDefault()
 	ss.channels = 2;
 
 	s = pa_simple_new(NULL, MPD_PULSE_NAME, PA_STREAM_PLAYBACK, NULL,
-	                  MPD_PULSE_NAME, &ss, NULL, NULL, &error);
+			  MPD_PULSE_NAME, &ss, NULL, NULL, &error);
 	if (!s) {
 		WARNING("Cannot connect to default PulseAudio server: %s\n",
-		        pa_strerror(error));
+			pa_strerror(error));
 		return -1;
 	}
 
@@ -112,8 +114,8 @@ static int pulse_testDefault()
 
 static int pulse_openDevice(AudioOutput * audioOutput)
 {
-	PulseData * pd;
-	AudioFormat * audioFormat;
+	PulseData *pd;
+	AudioFormat *audioFormat;
 	pa_sample_spec ss;
 	time_t t;
 	int error;
@@ -123,7 +125,8 @@ static int pulse_openDevice(AudioOutput * audioOutput)
 	audioFormat = &audioOutput->outAudioFormat;
 
 	if (pd->connAttempts != 0 &&
-	    (t - pd->lastAttempt) < CONN_ATTEMPT_INTERVAL) return -1;
+	    (t - pd->lastAttempt) < CONN_ATTEMPT_INTERVAL)
+		return -1;
 
 	pd->connAttempts++;
 	pd->lastAttempt = t;
@@ -139,10 +142,10 @@ static int pulse_openDevice(AudioOutput * audioOutput)
 	ss.channels = audioFormat->channels;
 
 	pd->s = pa_simple_new(pd->server, MPD_PULSE_NAME, PA_STREAM_PLAYBACK,
-	                      pd->sink, audioOutput->name, &ss, NULL, NULL,
-	                      &error);
+			      pd->sink, audioOutput->name, &ss, NULL, NULL,
+			      &error);
 	if (!pd->s) {
-		ERROR("Cannot connect to server in PulseAudio output " \
+		ERROR("Cannot connect to server in PulseAudio output "
 		      "\"%s\" (attempt %i): %s\n", audioOutput->name,
 		      pd->connAttempts, pa_strerror(error));
 		return -1;
@@ -151,7 +154,7 @@ static int pulse_openDevice(AudioOutput * audioOutput)
 	pd->connAttempts = 0;
 	audioOutput->open = 1;
 
-	DEBUG("PulseAudio output \"%s\" connected and playing %i bit, %i " \
+	DEBUG("PulseAudio output \"%s\" connected and playing %i bit, %i "
 	      "channel audio at %i Hz\n", audioOutput->name, audioFormat->bits,
 	      audioFormat->channels, audioFormat->sampleRate);
 
@@ -160,18 +163,18 @@ static int pulse_openDevice(AudioOutput * audioOutput)
 
 static void pulse_dropBufferedAudio(AudioOutput * audioOutput)
 {
-	PulseData * pd;
+	PulseData *pd;
 	int error;
 
 	pd = audioOutput->data;
-	if (pa_simple_flush(pd->s, &error) < 0) 
+	if (pa_simple_flush(pd->s, &error) < 0)
 		WARNING("Flush failed in PulseAudio output \"%s\": %s\n",
-		        audioOutput->name, pa_strerror(error));
+			audioOutput->name, pa_strerror(error));
 }
 
 static void pulse_closeDevice(AudioOutput * audioOutput)
 {
-	PulseData * pd;
+	PulseData *pd;
 
 	pd = audioOutput->data;
 	if (pd->s) {
@@ -182,16 +185,15 @@ static void pulse_closeDevice(AudioOutput * audioOutput)
 	audioOutput->open = 0;
 }
 
-static int pulse_playAudio(AudioOutput * audioOutput, char * playChunk,
-                           int size)
+static int pulse_playAudio(AudioOutput * audioOutput, char *playChunk, int size)
 {
-	PulseData * pd;
+	PulseData *pd;
 	int error;
 
 	pd = audioOutput->data;
 
 	if (pa_simple_write(pd->s, playChunk, size, &error) < 0) {
-		ERROR("PulseAudio output \"%s\" disconnecting due to write " \
+		ERROR("PulseAudio output \"%s\" disconnecting due to write "
 		      "error: %s\n", audioOutput->name, pa_strerror(error));
 		pulse_closeDevice(audioOutput);
 		return -1;
@@ -209,11 +211,10 @@ AudioOutputPlugin pulsePlugin = {
 	pulse_playAudio,
 	pulse_dropBufferedAudio,
 	pulse_closeDevice,
-	NULL, /* sendMetadataFunc */
+	NULL,			/* sendMetadataFunc */
 };
 
-#else /* HAVE_PULSE */
+#else				/* HAVE_PULSE */
 
 DISABLED_AUDIO_OUTPUT_PLUGIN(pulsePlugin)
-
-#endif /* HAVE_PULSE */
+#endif				/* HAVE_PULSE */

src/buffer2array.c

@@ -22,79 +22,74 @@
 #include <stdlib.h>
 #include <string.h>
 
-int buffer2array(char * origBuffer, char *** array) {
+int buffer2array(char *origBuffer, char ***array)
+{
 	int quotes = 0;
 	int count = 0;
 	int i;
 	int curr;
-	int * beginArray;
-	char * buffer = strdup(origBuffer);
+	int *beginArray;
+	char *buffer = strdup(origBuffer);
 	int bufferLength = strlen(buffer);
-	char * markArray = malloc(sizeof(char)*(bufferLength+1));
+	char *markArray = malloc(sizeof(char) * (bufferLength + 1));
 
-	for(curr=0;curr<bufferLength;curr++) {
-		if(!quotes && (buffer[curr]==' ' || buffer[curr]=='\t') ) {
+	for (curr = 0; curr < bufferLength; curr++) {
+		if (!quotes && (buffer[curr] == ' ' || buffer[curr] == '\t')) {
 			markArray[curr] = '0';
-		}
-		else if(buffer[curr] == '\"') {
-			if(curr>0 && buffer[curr-1]!='\\') {
-				quotes = quotes?0:1;
+		} else if (buffer[curr] == '\"') {
+			if (curr > 0 && buffer[curr - 1] != '\\') {
+				quotes = quotes ? 0 : 1;
 				markArray[curr] = '0';
-			}
-			else {
+			} else {
 				markArray[curr] = '1';
 			}
-		}
-		else {
+		} else {
 			markArray[curr] = '1';
 		}
-		if(markArray[curr]=='1') {
-			if(curr>0) {
-				if(markArray[curr-1]=='0') {
+		if (markArray[curr] == '1') {
+			if (curr > 0) {
+				if (markArray[curr - 1] == '0') {
 					count++;
 				}
-			}
-			else {
+			} else {
 				count++;
 			}
 		}
 	}
 	markArray[bufferLength] = '\0';
 
-	if(!count) {
+	if (!count) {
 		free(buffer);
 		free(markArray);
 		return count;
 	}
 
-	beginArray = malloc(sizeof(int)*count);
-	(*array) = malloc(sizeof(char *)*count);
+	beginArray = malloc(sizeof(int) * count);
+	(*array) = malloc(sizeof(char *) * count);
 
 	count = 0;
-	
-	for(curr=0;curr<bufferLength;curr++) {
-		if(markArray[curr]=='1') {
-			if(curr>0) {
-				if(markArray[curr-1]=='0') {
+
+	for (curr = 0; curr < bufferLength; curr++) {
+		if (markArray[curr] == '1') {
+			if (curr > 0) {
+				if (markArray[curr - 1] == '0') {
 					beginArray[count++] = curr;
 				}
-			}
-			else {
+			} else {
 				beginArray[count++] = curr;
 			}
-		}
-		else {
+		} else {
 			buffer[curr] = '\0';
 		}
 	}
 
-	for(i=0;i<count;i++) {
-		int len = strlen(buffer+beginArray[i])+1;
+	for (i = 0; i < count; i++) {
+		int len = strlen(buffer + beginArray[i]) + 1;
 		int arrayCurr = 0;
-		(*array)[i] = malloc(sizeof(char)*len);
-		for(curr=beginArray[i];buffer[curr]!='\0';curr++) {
-			if(buffer[curr]=='\\') {
-				if(buffer[curr+1]!='\0') {
+		(*array)[i] = malloc(sizeof(char) * len);
+		for (curr = beginArray[i]; buffer[curr] != '\0'; curr++) {
+			if (buffer[curr] == '\\') {
+				if (buffer[curr + 1] != '\0') {
 					curr++;
 				}
 			}
@@ -110,12 +105,14 @@ int buffer2array(char * origBuffer, char *** array) {
 	return count;
 }
 
-void freeArgArray(char ** array, int argArrayLength) {
+void freeArgArray(char **array, int argArrayLength)
+{
 	int i;
 
-	if(argArrayLength==0) return;
+	if (argArrayLength == 0)
+		return;
 
-	for(i=0;i<argArrayLength;i++) {
+	for (i = 0; i < argArrayLength; i++) {
 		free(array[i]);
 	}
 	free(array);

src/buffer2array.h

@@ -21,8 +21,8 @@
 
 #include "../config.h"
 
-int buffer2array(char * buffer, char *** array);
+int buffer2array(char *buffer, char ***array);
 
-void freeArgArray(char ** array, int argArrayLength);
+void freeArgArray(char **array, int argArrayLength);
 
 #endif

src/charConv.c

@@ -29,8 +29,8 @@
 iconv_t char_conv_iconv;
 #endif
 
-char * char_conv_to = NULL;
-char * char_conv_from = NULL;
+char *char_conv_to = NULL;
+char *char_conv_from = NULL;
 mpd_sint8 char_conv_same = 0;
 mpd_sint8 char_conv_use_iconv = 0;
 
@@ -43,37 +43,37 @@ mpd_sint8 char_conv_latin1ToUtf8 = 0;
 
 static void closeCharSetConversion();
 
-int setCharSetConversion(char * to, char * from) {
-	if(char_conv_to && char_conv_from &&
-	   strcmp(to,char_conv_to)==0 && strcmp(from,char_conv_from)==0) 
+int setCharSetConversion(char *to, char *from)
+{
+	if (char_conv_to && char_conv_from &&
+	    strcmp(to, char_conv_to) == 0 && strcmp(from, char_conv_from) == 0)
 	{
 		return 0;
 	}
 
 	closeCharSetConversion();
 
-	if(0==strcmp(to,from)) {
+	if (0 == strcmp(to, from)) {
 		char_conv_same = 1;
 		char_conv_to = strdup(to);
 		char_conv_from = strdup(from);
 		return 0;
 	}
 
-	if(strcmp(to,"UTF-8")==0 && strcmp(from,"ISO-8859-1")==0) {
+	if (strcmp(to, "UTF-8") == 0 && strcmp(from, "ISO-8859-1") == 0) {
 		char_conv_latin1ToUtf8 = 1;
-	}
-	else if(strcmp(to,"ISO-8859-1")==0 && strcmp(from,"UTF-8")==0) {
+	} else if (strcmp(to, "ISO-8859-1") == 0 && strcmp(from, "UTF-8") == 0) {
 		char_conv_latin1ToUtf8 = -1;
 	}
 
-	if(char_conv_latin1ToUtf8!=0) {
+	if (char_conv_latin1ToUtf8 != 0) {
 		char_conv_to = strdup(to);
 		char_conv_from = strdup(from);
 		return 0;
 	}
-
 #ifdef HAVE_ICONV
-	if((char_conv_iconv = iconv_open(to,from))==(iconv_t)(-1)) return -1;
+	if ((char_conv_iconv = iconv_open(to, from)) == (iconv_t) (-1))
+		return -1;
 
 	char_conv_to = strdup(to);
 	char_conv_from = strdup(from);
@@ -85,37 +85,42 @@ int setCharSetConversion(char * to, char * from) {
 	return -1;
 }
 
-char * convStrDup(char * string) {
-	if(!char_conv_to) return NULL;
+char *convStrDup(char *string)
+{
+	if (!char_conv_to)
+		return NULL;
 
-	if(char_conv_same) return strdup(string);
+	if (char_conv_same)
+		return strdup(string);
 
 #ifdef HAVE_ICONV
-	if(char_conv_use_iconv) {
+	if (char_conv_use_iconv) {
 		char buffer[BUFFER_SIZE];
 		size_t inleft = strlen(string);
-		char * ret;
+		char *ret;
 		size_t outleft;
 		size_t retlen = 0;
 		size_t err;
-		char * bufferPtr;
+		char *bufferPtr;
 
 		ret = malloc(1);
 		ret[0] = '\0';
 
-		while(inleft) {
+		while (inleft) {
 			bufferPtr = buffer;
 			outleft = BUFFER_SIZE;
-			err = iconv(char_conv_iconv,&string,&inleft,&bufferPtr,
-					&outleft);
-			if(outleft==BUFFER_SIZE || (err<0 && errno!=E2BIG)) {
+			err =
+			    iconv(char_conv_iconv, &string, &inleft, &bufferPtr,
+				  &outleft);
+			if (outleft == BUFFER_SIZE
+			    || (err < 0 && errno != E2BIG)) {
 				free(ret);
 				return NULL;
 			}
 
-			ret = realloc(ret,retlen+BUFFER_SIZE-outleft+1);
-			memcpy(ret+retlen,buffer,BUFFER_SIZE-outleft);
-			retlen+=BUFFER_SIZE-outleft;
+			ret = realloc(ret, retlen + BUFFER_SIZE - outleft + 1);
+			memcpy(ret + retlen, buffer, BUFFER_SIZE - outleft);
+			retlen += BUFFER_SIZE - outleft;
 			ret[retlen] = '\0';
 		}
 
@@ -123,8 +128,8 @@ char * convStrDup(char * string) {
 	}
 #endif
 
-	switch(char_conv_latin1ToUtf8) {
-	case 1: 
+	switch (char_conv_latin1ToUtf8) {
+	case 1:
 		return latin1StrToUtf8Dup(string);
 		break;
 	case -1:
@@ -135,10 +140,12 @@ char * convStrDup(char * string) {
 	return NULL;
 }
 
-static void closeCharSetConversion(void) {
-	if(char_conv_to) {
+static void closeCharSetConversion(void)
+{
+	if (char_conv_to) {
 #ifdef HAVE_ICONV
-		if(char_conv_use_iconv) iconv_close(char_conv_iconv);
+		if (char_conv_use_iconv)
+			iconv_close(char_conv_iconv);
 #endif
 		free(char_conv_to);
 		free(char_conv_from);

src/charConv.h

@@ -21,8 +21,8 @@
 
 #include "../config.h"
 
-int setCharSetConversion(char * to, char * from);
+int setCharSetConversion(char *to, char *from);
 
-char * convStrDup(char * string);
+char *convStrDup(char *string);
 
 #endif

src/command.h

@@ -32,13 +32,13 @@
 #define COMMAND_RETURN_CLOSE	20
 #define COMMAND_MASTER_READY	30
 
-extern char * current_command;
+extern char *current_command;
 extern int command_listNum;
 
-int processListOfCommands(FILE * fp, int * permission, int * expired, 
-		int listOK, List * list);
+int processListOfCommands(FILE * fp, int *permission, int *expired,
+			  int listOK, List * list);
 
-int processCommand(FILE * fp, int * permission, char * commandString);
+int processCommand(FILE * fp, int *permission, char *commandString);
 
 void initCommands();
 

src/conf.h

@@ -60,33 +60,33 @@
 #define CONF_ID3V1_ENCODING		"id3v1_encoding"
 
 typedef struct _BlockParam {
-	char * name;
-	char * value;
+	char *name;
+	char *value;
 	int line;
 } BlockParam;
 
 typedef struct _ConfigParam {
-	char * value;
+	char *value;
 	unsigned int line;
-	BlockParam * blockParams;
+	BlockParam *blockParams;
 	int numberOfBlockParams;
 } ConfigParam;
 
 void initConf();
 void finishConf();
 
-void readConf(char * file);
+void readConf(char *file);
 
 /* don't free the returned value
    set _last_ to NULL to get first entry */
-ConfigParam * getNextConfigParam(char * name, ConfigParam * last);
+ConfigParam *getNextConfigParam(char *name, ConfigParam * last);
 
 #define getConfigParam(name) 	getNextConfigParam(name, NULL)
 
-char * getConfigParamValue(char * name);
+char *getConfigParamValue(char *name);
 
-BlockParam * getBlockParam(ConfigParam * param, char * name);
+BlockParam *getBlockParam(ConfigParam * param, char *name);
 
-ConfigParam * parseConfigFilePath(char * name, int force);
+ConfigParam *parseConfigFilePath(char *name, int force);
 
 #endif

src/dbUtils.h

@@ -27,41 +27,39 @@
 typedef struct _LocateTagItem {
 	mpd_sint8 tagType;
 	/* what we are looking for */
-	char * needle;
+	char *needle;
 } LocateTagItem;
 
-int getLocateTagItemType(char * str);
+int getLocateTagItemType(char *str);
 
 /* returns NULL if not a known type */
-LocateTagItem * newLocateTagItem(char * typeString, char * needle);
+LocateTagItem *newLocateTagItem(char *typeString, char *needle);
 
 /* return number of items or -1 on error */
-int newLocateTagItemArrayFromArgArray(char * argArray[], int numArgs,
-					LocateTagItem ** arrayRet);
-						
+int newLocateTagItemArrayFromArgArray(char *argArray[], int numArgs,
+				      LocateTagItem ** arrayRet);
 
 void freeLocateTagItemArray(int count, LocateTagItem * array);
 
 void freeLocateTagItem(LocateTagItem * item);
 
-int printAllIn(FILE * fp, char * name);
+int printAllIn(FILE * fp, char *name);
 
-int addAllIn(FILE * fp, char * name);
+int addAllIn(FILE * fp, char *name);
 
-int printInfoForAllIn(FILE * fp, char * name);
+int printInfoForAllIn(FILE * fp, char *name);
 
-int searchForSongsIn(FILE * fp, char * name, int numItems,
-				LocateTagItem * items);
+int searchForSongsIn(FILE * fp, char *name, int numItems,
+		     LocateTagItem * items);
 
-int findSongsIn(FILE * fp, char * name, int numItems, 
-				LocateTagItem * items);
+int findSongsIn(FILE * fp, char *name, int numItems, LocateTagItem * items);
 
-int countSongsIn(FILE * fp, char * name);
+int countSongsIn(FILE * fp, char *name);
 
-unsigned long sumSongTimesIn(FILE * fp, char * name);
+unsigned long sumSongTimesIn(FILE * fp, char *name);
 
-int listAllUniqueTags(FILE * fp, int type, int numConditiionals, 
-		LocateTagItem * conditionals);
+int listAllUniqueTags(FILE * fp, int type, int numConditiionals,
+		      LocateTagItem * conditionals);
 
 void printSavedMemoryFromFilenames();
 

src/decode.h

@@ -57,12 +57,12 @@ typedef struct _DecoderControl {
 	volatile mpd_sint8 seekable;
 	volatile mpd_sint8 cycleLogFiles;
 	volatile double seekWhere;
-        AudioFormat audioFormat;
-        char utf8url[MAXPATHLEN+1];
-        volatile float totalTime;
+	AudioFormat audioFormat;
+	char utf8url[MAXPATHLEN + 1];
+	volatile float totalTime;
 } DecoderControl;
 
-void decodeSigHandler(int sig, siginfo_t * siginfo, void * v);
+void decodeSigHandler(int sig, siginfo_t * siginfo, void *v);
 
 void decode();
 

src/directory.h

@@ -32,11 +32,11 @@ typedef struct _DirectoryStat {
 } DirectoryStat;
 
 typedef struct _Directory {
-	char * path;
-	DirectoryList * subDirectories;
-	SongList * songs;
-	struct _Directory * parent;
-	DirectoryStat * stat;
+	char *path;
+	DirectoryList *subDirectories;
+	SongList *songs;
+	struct _Directory *parent;
+	DirectoryStat *stat;
 } Directory;
 
 void readDirectoryDBIfUpdateIsFinished();
@@ -51,7 +51,7 @@ void initMp3Directory();
 
 void closeMp3Directory();
 
-int printDirectoryInfo(FILE * fp, char * dirname);
+int printDirectoryInfo(FILE * fp, char *dirname);
 
 int checkDirectoryDB();
 
@@ -61,14 +61,13 @@ int readDirectoryDB();
 
 void updateMp3Directory();
 
-Song * getSongFromDB(char * file);
+Song *getSongFromDB(char *file);
 
 time_t getDbModTime();
 
-int traverseAllIn(FILE * fp, char * name, 
-			int (*forEachSong)(FILE *, Song *, void *),
-			int (*forEachDir)(FILE *, Directory *, void *),
-			void * data);
+int traverseAllIn(FILE * fp, char *name,
+		  int (*forEachSong) (FILE *, Song *, void *),
+		  int (*forEachDir) (FILE *, Directory *, void *), void *data);
 
 #define getDirectoryPath(dir) ((dir && dir->path) ? dir->path : "")
 

src/inputPlugin.c

@@ -24,47 +24,59 @@
 #include <stdlib.h>
 #include <string.h>
 
-static List * inputPlugin_list = NULL;
+static List *inputPlugin_list = NULL;
 
-void loadInputPlugin(InputPlugin * inputPlugin) {
-	if(!inputPlugin) return;
-	if(!inputPlugin->name) return;
+void loadInputPlugin(InputPlugin * inputPlugin)
+{
+	if (!inputPlugin)
+		return;
+	if (!inputPlugin->name)
+		return;
 
-	if(inputPlugin->initFunc && inputPlugin->initFunc() < 0) return;
+	if (inputPlugin->initFunc && inputPlugin->initFunc() < 0)
+		return;
 
 	insertInList(inputPlugin_list, inputPlugin->name, (void *)inputPlugin);
 }
 
-void unloadInputPlugin(InputPlugin * inputPlugin) {
-	if(inputPlugin->finishFunc) inputPlugin->finishFunc();
+void unloadInputPlugin(InputPlugin * inputPlugin)
+{
+	if (inputPlugin->finishFunc)
+		inputPlugin->finishFunc();
 	deleteFromList(inputPlugin_list, inputPlugin->name);
 }
 
-static int stringFoundInStringArray(char ** array, char * suffix) {
-	while(array && *array) {
-		if(strcasecmp(*array, suffix) == 0) return 1;
+static int stringFoundInStringArray(char **array, char *suffix)
+{
+	while (array && *array) {
+		if (strcasecmp(*array, suffix) == 0)
+			return 1;
 		array++;
 	}
-	
+
 	return 0;
 }
 
-InputPlugin * getInputPluginFromSuffix(char * suffix, unsigned int next) {
-	static ListNode * pos = NULL;
-	ListNode * node;
-	InputPlugin * plugin;
+InputPlugin *getInputPluginFromSuffix(char *suffix, unsigned int next)
+{
+	static ListNode *pos = NULL;
+	ListNode *node;
+	InputPlugin *plugin;
+
+	if (suffix == NULL)
+		return NULL;
 
-	if(suffix == NULL) return NULL;
-	
 	if (next) {
-		if (pos) node = pos;
-		else return NULL;
+		if (pos)
+			node = pos;
+		else
+			return NULL;
 	} else
 		node = inputPlugin_list->firstNode;
 
-	while(node != NULL) {
+	while (node != NULL) {
 		plugin = node->data;
-		if(stringFoundInStringArray(plugin->suffixes, suffix)) {
+		if (stringFoundInStringArray(plugin->suffixes, suffix)) {
 			pos = node->nextNode;
 			return plugin;
 		}
@@ -74,18 +86,20 @@ InputPlugin * getInputPluginFromSuffix(char * suffix, unsigned int next) {
 	return NULL;
 }
 
-InputPlugin * getInputPluginFromMimeType(char * mimeType, unsigned int next) {
-	static ListNode * pos = NULL;
-	ListNode * node;
-	InputPlugin * plugin;
+InputPlugin *getInputPluginFromMimeType(char *mimeType, unsigned int next)
+{
+	static ListNode *pos = NULL;
+	ListNode *node;
+	InputPlugin *plugin;
+
+	if (mimeType == NULL)
+		return NULL;
 
-	if(mimeType == NULL) return NULL;
-	
 	node = (next && pos) ? pos : inputPlugin_list->firstNode;
 
-	while(node != NULL) {
+	while (node != NULL) {
 		plugin = node->data;
-		if(stringFoundInStringArray(plugin->mimeTypes, mimeType)) {
+		if (stringFoundInStringArray(plugin->mimeTypes, mimeType)) {
 			pos = node->nextNode;
 			return plugin;
 		}
@@ -95,23 +109,25 @@ InputPlugin * getInputPluginFromMimeType(char * mimeType, unsigned int next) {
 	return NULL;
 }
 
-InputPlugin * getInputPluginFromName(char * name) {
-	void * plugin = NULL;
+InputPlugin *getInputPluginFromName(char *name)
+{
+	void *plugin = NULL;
 
 	findInList(inputPlugin_list, name, &plugin);
 
-	return (InputPlugin *)plugin;
+	return (InputPlugin *) plugin;
 }
 
-void printAllInputPluginSuffixes(FILE * fp) {
-	ListNode * node = inputPlugin_list->firstNode;
-	InputPlugin * plugin;
-	char ** suffixes;
+void printAllInputPluginSuffixes(FILE * fp)
+{
+	ListNode *node = inputPlugin_list->firstNode;
+	InputPlugin *plugin;
+	char **suffixes;
 
-	while(node) {
-		plugin = (InputPlugin *)node->data;
+	while (node) {
+		plugin = (InputPlugin *) node->data;
 		suffixes = plugin->suffixes;
-		while(suffixes && *suffixes) {
+		while (suffixes && *suffixes) {
 			myfprintf(fp, "%s ", *suffixes);
 			suffixes++;
 		}
@@ -130,7 +146,8 @@ extern InputPlugin mpcPlugin;
 extern InputPlugin aacPlugin;
 extern InputPlugin modPlugin;
 
-void initInputPlugins(void) {
+void initInputPlugins(void)
+{
 	inputPlugin_list = makeList(NULL, 1);
 
 	/* load plugins here */
@@ -144,6 +161,7 @@ void initInputPlugins(void) {
 	loadInputPlugin(&modPlugin);
 }
 
-void finishInputPlugins(void) {
+void finishInputPlugins(void)
+{
 	freeList(inputPlugin_list);
 }

src/inputPlugin.h

@@ -31,36 +31,36 @@
 
 /* optional, set this to NULL if the InputPlugin doesn't have/need one
  * this must return < 0 if there is an error and >= 0 otherwise */
-typedef int (* InputPlugin_initFunc) ();
+typedef int (*InputPlugin_initFunc) ();
 
 /* optional, set this to NULL if the InputPlugin doesn't have/need one */
-typedef void (* InputPlugin_finishFunc) ();
+typedef void (*InputPlugin_finishFunc) ();
 
 /* boolean return value, returns 1 if the InputStream is decodable by
  * the InputPlugin, 0 if not */
-typedef unsigned int (* InputPlugin_tryDecodeFunc) (InputStream *);
+typedef unsigned int (*InputPlugin_tryDecodeFunc) (InputStream *);
 
 /* this will be used to decode InputStreams, and is recommended for files
  * and networked (HTTP) connections.
  *
  * returns -1 on error, 0 on success */
-typedef int (* InputPlugin_streamDecodeFunc) (OutputBuffer *, DecoderControl *,
-		InputStream *);
+typedef int (*InputPlugin_streamDecodeFunc) (OutputBuffer *, DecoderControl *,
+					     InputStream *);
 
 /* use this if and only if your InputPlugin can only be passed a filename or
  * handle as input, and will not allow callbacks to be set (like Ogg-Vorbis
  * and FLAC libraries allow)
  *
  * returns -1 on error, 0 on success */
-typedef int (* InputPlugin_fileDecodeFunc) (OutputBuffer *, DecoderControl *,
-		char * path);
+typedef int (*InputPlugin_fileDecodeFunc) (OutputBuffer *, DecoderControl *,
+					   char *path);
 
 /* file should be the full path!  Returns NULL if a tag cannot be found
  * or read */
-typedef MpdTag * (* InputPlugin_tagDupFunc) (char * file);
+typedef MpdTag *(*InputPlugin_tagDupFunc) (char *file);
 
 typedef struct _InputPlugin {
-	char * name;
+	char *name;
 	InputPlugin_initFunc initFunc;
 	InputPlugin_finishFunc finishFunc;
 	InputPlugin_tryDecodeFunc tryDecodeFunc;
@@ -72,8 +72,8 @@ typedef struct _InputPlugin {
 	unsigned char streamTypes;
 
 	/* last element in these arrays must always be a NULL: */
-	char ** suffixes;
-	char ** mimeTypes;
+	char **suffixes;
+	char **mimeTypes;
 } InputPlugin;
 
 /* individual functions to load/unload plugins */
@@ -82,11 +82,11 @@ void unloadInputPlugin(InputPlugin * inputPlugin);
 
 /* interface for using plugins */
 
-InputPlugin * getInputPluginFromSuffix(char * suffix, unsigned int next);
+InputPlugin *getInputPluginFromSuffix(char *suffix, unsigned int next);
 
-InputPlugin * getInputPluginFromMimeType(char * mimeType, unsigned int next);
+InputPlugin *getInputPluginFromMimeType(char *mimeType, unsigned int next);
 
-InputPlugin * getInputPluginFromName(char * name);
+InputPlugin *getInputPluginFromName(char *name);
 
 void printAllInputPluginSuffixes(FILE * fp);
 

src/inputPlugins/_flac_common.c

@@ -38,8 +38,8 @@
 #include <FLAC/format.h>
 #include <FLAC/metadata.h>
 
-void init_FlacData (FlacData * data, OutputBuffer * cb,
-		DecoderControl * dc, InputStream * inStream)
+void init_FlacData(FlacData * data, OutputBuffer * cb,
+		   DecoderControl * dc, InputStream * inStream)
 {
 	data->chunk_length = 0;
 	data->time = 0;
@@ -53,24 +53,24 @@ void init_FlacData (FlacData * data, OutputBuffer * cb,
 }
 
 static int flacFindVorbisCommentFloat(const FLAC__StreamMetadata * block,
-		char * cmnt, float * fl)
+				      char *cmnt, float *fl)
 {
-	int offset = FLAC__metadata_object_vorbiscomment_find_entry_from(
-			block,0,cmnt);
+	int offset =
+	    FLAC__metadata_object_vorbiscomment_find_entry_from(block, 0, cmnt);
 
-	if(offset >= 0) {
-		size_t pos = strlen(cmnt)+1; /* 1 is for '=' */
+	if (offset >= 0) {
+		size_t pos = strlen(cmnt) + 1;	/* 1 is for '=' */
 		int len = block->data.vorbis_comment.comments[offset].length
-				-pos;
-		if(len > 0) {
+		    - pos;
+		if (len > 0) {
 			unsigned char tmp;
-			unsigned char * dup = &(block->data.vorbis_comment.
-						comments[offset].entry[pos]);
+			unsigned char *dup = &(block->data.vorbis_comment.
+					       comments[offset].entry[pos]);
 			tmp = dup[len];
 			dup[len] = '\0';
 			*fl = atof((char *)dup);
 			dup[len] = tmp;
-			
+
 			return 1;
 		}
 	}
@@ -79,8 +79,9 @@ static int flacFindVorbisCommentFloat(const FLAC__StreamMetadata * block,
 }
 
 /* replaygain stuff by AliasMrJones */
-static void flacParseReplayGain(const FLAC__StreamMetadata *block,
-				FlacData * data) {
+static void flacParseReplayGain(const FLAC__StreamMetadata * block,
+				FlacData * data)
+{
 	unsigned int found = 0;
 
 	if (data->replayGainInfo)
@@ -88,14 +89,14 @@ static void flacParseReplayGain(const FLAC__StreamMetadata *block,
 
 	data->replayGainInfo = newReplayGainInfo();
 
-	found &= flacFindVorbisCommentFloat(block,"replaygain_album_gain",
-					&data->replayGainInfo->albumGain);
-	found &= flacFindVorbisCommentFloat(block,"replaygain_album_peak",
-					&data->replayGainInfo->albumPeak);
-	found &= flacFindVorbisCommentFloat(block,"replaygain_track_gain",
-					&data->replayGainInfo->trackGain);
-	found &= flacFindVorbisCommentFloat(block,"replaygain_track_peak",
-					&data->replayGainInfo->trackPeak);
+	found &= flacFindVorbisCommentFloat(block, "replaygain_album_gain",
+					    &data->replayGainInfo->albumGain);
+	found &= flacFindVorbisCommentFloat(block, "replaygain_album_peak",
+					    &data->replayGainInfo->albumPeak);
+	found &= flacFindVorbisCommentFloat(block, "replaygain_track_gain",
+					    &data->replayGainInfo->trackGain);
+	found &= flacFindVorbisCommentFloat(block, "replaygain_track_peak",
+					    &data->replayGainInfo->trackPeak);
 
 	if (!found) {
 		freeReplayGainInfo(data->replayGainInfo);
@@ -105,50 +106,55 @@ static void flacParseReplayGain(const FLAC__StreamMetadata *block,
 
 /* tracknumber is used in VCs, MPD uses "track" ..., all the other
  * tag names match */
-static const char * VORBIS_COMMENT_TRACK_KEY = "tracknumber";
-static const char * VORBIS_COMMENT_DISC_KEY  = "discnumber";
+static const char *VORBIS_COMMENT_TRACK_KEY = "tracknumber";
+static const char *VORBIS_COMMENT_DISC_KEY = "discnumber";
 
-static unsigned int commentMatchesAddToTag(
-		const FLAC__StreamMetadata_VorbisComment_Entry * entry,
-		unsigned int itemType,
-		MpdTag ** tag)
+static unsigned int commentMatchesAddToTag(const
+					   FLAC__StreamMetadata_VorbisComment_Entry
+					   * entry, unsigned int itemType,
+					   MpdTag ** tag)
 {
-	const char * str;
+	const char *str;
 	size_t slen;
 	int vlen;
 
 	switch (itemType) {
-	case TAG_ITEM_TRACK: str = VORBIS_COMMENT_TRACK_KEY; break;
-	case TAG_ITEM_DISC:  str = VORBIS_COMMENT_DISC_KEY;  break;
-	default:             str = mpdTagItemKeys[itemType];
+	case TAG_ITEM_TRACK:
+		str = VORBIS_COMMENT_TRACK_KEY;
+		break;
+	case TAG_ITEM_DISC:
+		str = VORBIS_COMMENT_DISC_KEY;
+		break;
+	default:
+		str = mpdTagItemKeys[itemType];
 	}
 	slen = strlen(str);
 	vlen = entry->length - slen - 1;
 
-	if ((vlen > 0) && (0 == strncasecmp(str,(char *)entry->entry, slen))
-				&& (*(entry->entry + slen) == '=')) {
+	if ((vlen > 0) && (0 == strncasecmp(str, (char *)entry->entry, slen))
+	    && (*(entry->entry + slen) == '=')) {
 		if (!*tag)
 			*tag = newMpdTag();
-		
-		addItemToMpdTagWithLen(*tag, itemType, 
-				(char *)(entry->entry+slen + 1), vlen);
-		
+
+		addItemToMpdTagWithLen(*tag, itemType,
+				       (char *)(entry->entry + slen + 1), vlen);
+
 		return 1;
 	}
-	
+
 	return 0;
 }
-		
-MpdTag * copyVorbisCommentBlockToMpdTag(const FLAC__StreamMetadata * block, 
-		MpdTag * tag)
+
+MpdTag *copyVorbisCommentBlockToMpdTag(const FLAC__StreamMetadata * block,
+				       MpdTag * tag)
 {
 	unsigned int i, j;
 	FLAC__StreamMetadata_VorbisComment_Entry *comments;
-	
+
 	comments = block->data.vorbis_comment.comments;
-	
+
 	for (i = block->data.vorbis_comment.num_comments; i != 0; --i) {
-		for (j = TAG_NUM_OF_ITEM_TYPES; j--; ) {
+		for (j = TAG_NUM_OF_ITEM_TYPES; j--;) {
 			if (commentMatchesAddToTag(comments, j, &tag))
 				break;
 		}
@@ -158,34 +164,36 @@ MpdTag * copyVorbisCommentBlockToMpdTag(const FLAC__StreamMetadata * block,
 	return tag;
 }
 
-void flac_metadata_common_cb(const FLAC__StreamMetadata *block, FlacData *data)
+void flac_metadata_common_cb(const FLAC__StreamMetadata * block,
+			     FlacData * data)
 {
 	DecoderControl *dc = data->dc;
 	const FLAC__StreamMetadata_StreamInfo *si = &(block->data.stream_info);
 
-	switch(block->type) {
+	switch (block->type) {
 	case FLAC__METADATA_TYPE_STREAMINFO:
 		dc->audioFormat.bits = si->bits_per_sample;
 		dc->audioFormat.sampleRate = si->sample_rate;
 		dc->audioFormat.channels = si->channels;
 		dc->totalTime = ((float)si->total_samples) / (si->sample_rate);
 		getOutputAudioFormat(&(dc->audioFormat),
-				&(data->cb->audioFormat));
+				     &(data->cb->audioFormat));
 		break;
 	case FLAC__METADATA_TYPE_VORBIS_COMMENT:
-		flacParseReplayGain(block,data);
-        default:
-                break;
+		flacParseReplayGain(block, data);
+	default:
+		break;
 	}
 }
 
-void flac_error_common_cb(	const char * plugin,
-				const FLAC__StreamDecoderErrorStatus status,
-				FlacData *data)
+void flac_error_common_cb(const char *plugin,
+			  const FLAC__StreamDecoderErrorStatus status,
+			  FlacData * data)
 {
-	if(data->dc->stop) return;
+	if (data->dc->stop)
+		return;
 
-	switch(status) {
+	switch (status) {
 	case FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC:
 		ERROR("%s lost sync\n", plugin);
 		break;
@@ -196,8 +204,8 @@ void flac_error_common_cb(	const char * plugin,
 		ERROR("%s crc mismatch\n", plugin);
 		break;
 	default:
-		ERROR("unknown %s error\n",plugin);
+		ERROR("unknown %s error\n", plugin);
 	}
 }
 
-#endif /* HAVE_FLAC || HAVE_OGGFLAC */
+#endif				/* HAVE_FLAC || HAVE_OGGFLAC */

src/inputPlugins/_flac_common.h

@@ -41,38 +41,38 @@ typedef struct {
 	float time;
 	int bitRate;
 	FLAC__uint64 position;
-	OutputBuffer * cb;
-	DecoderControl * dc;
-	InputStream * inStream;
-	ReplayGainInfo * replayGainInfo;
-	MpdTag * tag;
+	OutputBuffer *cb;
+	DecoderControl *dc;
+	InputStream *inStream;
+	ReplayGainInfo *replayGainInfo;
+	MpdTag *tag;
 } FlacData;
 
 /* initializes a given FlacData struct */
-void init_FlacData (FlacData * data, OutputBuffer * cb,
-		DecoderControl * dc, InputStream * inStream);
-void flac_metadata_common_cb(	const FLAC__StreamMetadata *block,
-				FlacData *data);
-void flac_error_common_cb(	const char * plugin,
-				FLAC__StreamDecoderErrorStatus status,
-				FlacData *data);
+void init_FlacData(FlacData * data, OutputBuffer * cb,
+		   DecoderControl * dc, InputStream * inStream);
+void flac_metadata_common_cb(const FLAC__StreamMetadata * block,
+			     FlacData * data);
+void flac_error_common_cb(const char *plugin,
+			  FLAC__StreamDecoderErrorStatus status,
+			  FlacData * data);
 
-MpdTag * copyVorbisCommentBlockToMpdTag(const FLAC__StreamMetadata * block, 
-		MpdTag * tag);
+MpdTag *copyVorbisCommentBlockToMpdTag(const FLAC__StreamMetadata * block,
+				       MpdTag * tag);
 
 /* keep this inlined, this is just macro but prettier :) */
 static inline int flacSendChunk(FlacData * data)
 {
 	if (sendDataToOutputBuffer(data->cb, NULL, data->dc, 1, data->chunk,
-			data->chunk_length, data->time, data->bitRate,
-			data->replayGainInfo) == OUTPUT_BUFFER_DC_STOP)
+				   data->chunk_length, data->time,
+				   data->bitRate,
+				   data->replayGainInfo) ==
+	    OUTPUT_BUFFER_DC_STOP)
 		return -1;
 
 	return 0;
 }
 
+#endif				/* HAVE_FLAC || HAVE_OGGFLAC */
 
-#endif /* HAVE_FLAC || HAVE_OGGFLAC */
-
-#endif /* _FLAC_COMMON_H */
-
+#endif				/* _FLAC_COMMON_H */

src/inputPlugins/_ogg_common.c

@@ -37,29 +37,37 @@ ogg_stream_type ogg_stream_type_detect(InputStream * inStream)
 	size_t r, to_read = 41;
 
 	seekInputStream(inStream, 0, SEEK_SET);
-	
+
 	while (to_read) {
 		r = readFromInputStream(inStream, buf, 1, to_read);
 		if (r < 0)
 			break;
 		to_read -= r;
-		if (!r && !inputStreamAtEOF(inStream)) 
+		if (!r && !inputStreamAtEOF(inStream))
 			my_usleep(10000);
 		else
 			break;
 	}
-	
+
 	seekInputStream(inStream, 0, SEEK_SET);
-	
-	if (r >= 32 && memcmp(buf, "OggS", 4) == 0 && (
-				(memcmp(buf+29, "FLAC", 4) == 0
-					&& memcmp(buf+37, "fLaC", 4) == 0)
-				|| (memcmp(buf+28, "FLAC", 4) == 0)
-				|| (memcmp(buf+28, "fLaC", 4) == 0))) {
+
+	if (r >= 32 && memcmp(buf, "OggS", 4) == 0 && ((memcmp
+							(buf + 29, "FLAC",
+							 4) == 0
+							&& memcmp(buf + 37,
+								  "fLaC",
+								  4) == 0)
+						       ||
+						       (memcmp
+							(buf + 28, "FLAC",
+							 4) == 0)
+						       ||
+						       (memcmp
+							(buf + 28, "fLaC",
+							 4) == 0))) {
 		return FLAC;
 	}
 	return VORBIS;
 }
 
-#endif /* defined(HAVE_OGGFLAC || defined(HAVE_OGGVORBIS) */
-
+#endif				/* defined(HAVE_OGGFLAC || defined(HAVE_OGGVORBIS) */

src/inputPlugins/_ogg_common.h

@@ -30,6 +30,6 @@ typedef enum _ogg_stream_type { VORBIS, FLAC } ogg_stream_type;
 
 ogg_stream_type ogg_stream_type_detect(InputStream * inStream);
 
-#endif /* defined(HAVE_OGGFLAC || defined(HAVE_OGGVORBIS) */
+#endif				/* defined(HAVE_OGGFLAC || defined(HAVE_OGGVORBIS) */
 
-#endif /* _OGG_COMMON_H */
+#endif				/* _OGG_COMMON_H */

src/inputPlugins/audiofile_plugin.c

@@ -37,34 +37,35 @@
 #include <unistd.h>
 #include <audiofile.h>
 
-static int getAudiofileTotalTime(char * file)
+static int getAudiofileTotalTime(char *file)
 {
 	int time;
 	AFfilehandle af_fp = afOpenFile(file, "r", NULL);
-	if(af_fp == AF_NULL_FILEHANDLE) {
+	if (af_fp == AF_NULL_FILEHANDLE) {
 		return -1;
 	}
 	time = (int)
-		((double)afGetFrameCount(af_fp,AF_DEFAULT_TRACK)
-		 /afGetRate(af_fp,AF_DEFAULT_TRACK));
+	    ((double)afGetFrameCount(af_fp, AF_DEFAULT_TRACK)
+	     / afGetRate(af_fp, AF_DEFAULT_TRACK));
 	afCloseFile(af_fp);
 	return time;
 }
 
-static int audiofile_decode(OutputBuffer * cb, DecoderControl * dc, char * path) {
+static int audiofile_decode(OutputBuffer * cb, DecoderControl * dc, char *path)
+{
 	int fs, frame_count;
 	AFfilehandle af_fp;
 	int bits;
 	mpd_uint16 bitRate;
 	struct stat st;
 
-	if(stat(path, &st) < 0) {
+	if (stat(path, &st) < 0) {
 		ERROR("failed to stat: %s\n", path);
 		return -1;
 	}
 
 	af_fp = afOpenFile(path, "r", NULL);
-	if(af_fp == AF_NULL_FILEHANDLE) {
+	if (af_fp == AF_NULL_FILEHANDLE) {
 		ERROR("failed to open: %s\n", path);
 		return -1;
 	}
@@ -72,119 +73,125 @@ static int audiofile_decode(OutputBuffer * cb, DecoderControl * dc, char * path)
 	afGetSampleFormat(af_fp, AF_DEFAULT_TRACK, &fs, &bits);
 	dc->audioFormat.bits = bits;
 	dc->audioFormat.sampleRate = afGetRate(af_fp, AF_DEFAULT_TRACK);
-	dc->audioFormat.channels = afGetChannels(af_fp,AF_DEFAULT_TRACK);
-        getOutputAudioFormat(&(dc->audioFormat),&(cb->audioFormat));
-	
-	frame_count = afGetFrameCount(af_fp,AF_DEFAULT_TRACK);
-	
-	dc->totalTime = ((float)frame_count/(float)dc->audioFormat.sampleRate);
-
-	bitRate = st.st_size*8.0/dc->totalTime/1000.0+0.5;
-	
+	dc->audioFormat.channels = afGetChannels(af_fp, AF_DEFAULT_TRACK);
+	getOutputAudioFormat(&(dc->audioFormat), &(cb->audioFormat));
+
+	frame_count = afGetFrameCount(af_fp, AF_DEFAULT_TRACK);
+
+	dc->totalTime =
+	    ((float)frame_count / (float)dc->audioFormat.sampleRate);
+
+	bitRate = st.st_size * 8.0 / dc->totalTime / 1000.0 + 0.5;
+
 	if (dc->audioFormat.bits != 8 && dc->audioFormat.bits != 16) {
 		ERROR("Only 8 and 16-bit files are supported. %s is %i-bit\n",
-			path, dc->audioFormat.bits);
+		      path, dc->audioFormat.bits);
 		afCloseFile(af_fp);
 		return -1;
 	}
-	
-	fs = (int)afGetFrameSize(af_fp, AF_DEFAULT_TRACK,1);
+
+	fs = (int)afGetFrameSize(af_fp, AF_DEFAULT_TRACK, 1);
 
 	dc->state = DECODE_STATE_DECODE;
 	{
 		int ret, eof = 0, current = 0;
 		char chunk[CHUNK_SIZE];
 
-		while(!eof) {
-			if(dc->seek) {
-                                clearOutputBuffer(cb);
-				current = dc->seekWhere * 
-                                                dc->audioFormat.sampleRate;
-				afSeekFrame(af_fp, AF_DEFAULT_TRACK,current);
+		while (!eof) {
+			if (dc->seek) {
+				clearOutputBuffer(cb);
+				current = dc->seekWhere *
+				    dc->audioFormat.sampleRate;
+				afSeekFrame(af_fp, AF_DEFAULT_TRACK, current);
 				dc->seek = 0;
 			}
 
-			ret = afReadFrames(af_fp, AF_DEFAULT_TRACK, chunk, CHUNK_SIZE/fs);
-			if(ret<=0) eof = 1;
+			ret =
+			    afReadFrames(af_fp, AF_DEFAULT_TRACK, chunk,
+					 CHUNK_SIZE / fs);
+			if (ret <= 0)
+				eof = 1;
 			else {
 				current += ret;
-				sendDataToOutputBuffer(cb, 
-                                        NULL,
-                                        dc,
-                                        1,
-                                        chunk,
-                                        ret*fs,
-					(float)current /
-					(float)dc->audioFormat.sampleRate,
-					bitRate,
-					NULL);
-				if(dc->stop) break;
+				sendDataToOutputBuffer(cb,
+						       NULL,
+						       dc,
+						       1,
+						       chunk,
+						       ret * fs,
+						       (float)current /
+						       (float)dc->audioFormat.
+						       sampleRate, bitRate,
+						       NULL);
+				if (dc->stop)
+					break;
 			}
 		}
 
 		flushOutputBuffer(cb);
 
 		/*if(dc->seek) {
-                        dc->seekError = 1;
-                        dc->seek = 0;
-                }*/
+		   dc->seekError = 1;
+		   dc->seek = 0;
+		   } */
 
-		if(dc->stop) {
+		if (dc->stop) {
 			dc->state = DECODE_STATE_STOP;
 			dc->stop = 0;
-		}
-		else dc->state = DECODE_STATE_STOP;
+		} else
+			dc->state = DECODE_STATE_STOP;
 	}
 	afCloseFile(af_fp);
 
 	return 0;
 }
 
-static MpdTag * audiofileTagDup(char * file) {
-	MpdTag * ret = NULL;
+static MpdTag *audiofileTagDup(char *file)
+{
+	MpdTag *ret = NULL;
 	int time = getAudiofileTotalTime(file);
-	
-	if (time>=0) {
-		if(!ret) ret = newMpdTag();
+
+	if (time >= 0) {
+		if (!ret)
+			ret = newMpdTag();
 		ret->time = time;
-	}
-	else {
-		DEBUG("audiofileTagDup: Failed to get total song time from: %s\n", file);
+	} else {
+		DEBUG
+		    ("audiofileTagDup: Failed to get total song time from: %s\n",
+		     file);
 	}
 
 	return ret;
 }
 
-static char * audiofileSuffixes[] = {"wav", "au", "aiff", "aif",  NULL};
+static char *audiofileSuffixes[] = { "wav", "au", "aiff", "aif", NULL };
 
-InputPlugin audiofilePlugin = 
-{
-        "audiofile",
-        NULL,
+InputPlugin audiofilePlugin = {
+	"audiofile",
+	NULL,
 	NULL,
 	NULL,
 	NULL,
-        audiofile_decode,
-        audiofileTagDup,
-        INPUT_PLUGIN_STREAM_FILE,
-        audiofileSuffixes,
-        NULL
+	audiofile_decode,
+	audiofileTagDup,
+	INPUT_PLUGIN_STREAM_FILE,
+	audiofileSuffixes,
+	NULL
 };
 
 #else
 
-InputPlugin audiofilePlugin =
-{
-        NULL,
-        NULL,
+InputPlugin audiofilePlugin = {
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	NULL,
 	NULL,
-        NULL,
-        NULL,
 	NULL,
+	0,
 	NULL,
-        0,
-        NULL,
-        NULL
+	NULL
 };
 
-#endif /* HAVE_AUDIOFILE */
+#endif				/* HAVE_AUDIOFILE */

src/inputPlugins/mod_plugin.c

@@ -39,23 +39,26 @@
 
 #define MIKMOD_FRAME_SIZE	4096
 
-static BOOL mod_mpd_Init(void) {
+static BOOL mod_mpd_Init(void)
+{
 	return VC_Init();
 }
 
-static void mod_mpd_Exit(void) {
+static void mod_mpd_Exit(void)
+{
 	VC_Exit();
 }
 
-static void mod_mpd_Update(void) {
+static void mod_mpd_Update(void)
+{
 }
 
-static BOOL mod_mpd_IsThere(void) {
+static BOOL mod_mpd_IsThere(void)
+{
 	return 1;
 }
 
-static MDRIVER drv_mpd =
-{
+static MDRIVER drv_mpd = {
 	NULL,
 	"MPD",
 	"MPD Output Driver v0.1",
@@ -92,10 +95,12 @@ static MDRIVER drv_mpd =
 static int mod_mikModInitiated = 0;
 static int mod_mikModInitError = 0;
 
-static int mod_initMikMod(void) {
-	if(mod_mikModInitError) return -1;
+static int mod_initMikMod(void)
+{
+	if (mod_mikModInitError)
+		return -1;
 
-	if(!mod_mikModInitiated) {
+	if (!mod_mikModInitiated) {
 		mod_mikModInitiated = 1;
 
 		md_device = 0;
@@ -108,11 +113,11 @@ static int mod_initMikMod(void) {
 	md_pansep = 64;
 	md_mixfreq = 44100;
 	md_mode = (DMODE_SOFT_MUSIC | DMODE_INTERP | DMODE_STEREO |
-			DMODE_16BITS);
+		   DMODE_16BITS);
 
-	if(MikMod_Init("")) {
-		ERROR("Could not init MikMod: %s\n", 
-			MikMod_strerror(MikMod_errno));
+	if (MikMod_Init("")) {
+		ERROR("Could not init MikMod: %s\n",
+		      MikMod_strerror(MikMod_errno));
 		mod_mikModInitError = 1;
 		return -1;
 	}
@@ -120,20 +125,23 @@ static int mod_initMikMod(void) {
 	return 0;
 }
 
-static void mod_finishMikMod(void) {
+static void mod_finishMikMod(void)
+{
 	MikMod_Exit();
 }
 
 typedef struct _mod_Data {
-	MODULE * moduleHandle;
-	SBYTE * audio_buffer;
-} mod_Data; 
+	MODULE *moduleHandle;
+	SBYTE *audio_buffer;
+} mod_Data;
 
-static mod_Data * mod_open(char * path) {
-	MODULE * moduleHandle;
-	mod_Data * data;
+static mod_Data *mod_open(char *path)
+{
+	MODULE *moduleHandle;
+	mod_Data *data;
 
-	if(!(moduleHandle = Player_Load(path, 128, 0))) return NULL;
+	if (!(moduleHandle = Player_Load(path, 128, 0)))
+		return NULL;
 
 	data = malloc(sizeof(mod_Data));
 
@@ -145,51 +153,57 @@ static mod_Data * mod_open(char * path) {
 	return data;
 }
 
-static void mod_close(mod_Data * data) {
+static void mod_close(mod_Data * data)
+{
 	Player_Stop();
 	Player_Free(data->moduleHandle);
 	free(data->audio_buffer);
 	free(data);
 }
 
-static int mod_decode(OutputBuffer * cb, DecoderControl * dc, char * path) {
-	mod_Data * data;
+static int mod_decode(OutputBuffer * cb, DecoderControl * dc, char *path)
+{
+	mod_Data *data;
 	float time = 0.0;
 	int ret;
 	float secPerByte;
 
-	if(mod_initMikMod() < 0) return -1;
+	if (mod_initMikMod() < 0)
+		return -1;
 
-	if(!(data = mod_open(path))) {
+	if (!(data = mod_open(path))) {
 		ERROR("failed to open mod: %s\n", path);
 		MikMod_Exit();
 		return -1;
 	}
-	
+
 	dc->audioFormat.bits = 16;
 	dc->audioFormat.sampleRate = 44100;
 	dc->audioFormat.channels = 2;
-        getOutputAudioFormat(&(dc->audioFormat),&(cb->audioFormat));
+	getOutputAudioFormat(&(dc->audioFormat), &(cb->audioFormat));
+
+	secPerByte =
+	    1.0 / ((dc->audioFormat.bits * dc->audioFormat.channels / 8.0) *
+		   (float)dc->audioFormat.sampleRate);
 
-	secPerByte = 1.0/((dc->audioFormat.bits*dc->audioFormat.channels/8.0)*
-				(float)dc->audioFormat.sampleRate);
-	
 	dc->state = DECODE_STATE_DECODE;
-	while(1) {
-		if(dc->seek) {
+	while (1) {
+		if (dc->seek) {
 			dc->seekError = 1;
 			dc->seek = 0;
 		}
 
-		if(dc->stop) break;
+		if (dc->stop)
+			break;
 
-		if(!Player_Active()) break;
+		if (!Player_Active())
+			break;
 
 		ret = VC_WriteBytes(data->audio_buffer, MIKMOD_FRAME_SIZE);
-		time += ret*secPerByte;
-		sendDataToOutputBuffer(cb, NULL, dc, 0, 
-					(char *)data->audio_buffer, ret, time,
-					0, NULL);
+		time += ret * secPerByte;
+		sendDataToOutputBuffer(cb, NULL, dc, 0,
+				       (char *)data->audio_buffer, ret, time,
+				       0, NULL);
 	}
 
 	flushOutputBuffer(cb);
@@ -198,27 +212,28 @@ static int mod_decode(OutputBuffer * cb, DecoderControl * dc, char * path) {
 
 	MikMod_Exit();
 
-	if(dc->stop) {
+	if (dc->stop) {
 		dc->state = DECODE_STATE_STOP;
 		dc->stop = 0;
-	}
-	else dc->state = DECODE_STATE_STOP;
+	} else
+		dc->state = DECODE_STATE_STOP;
 
 	return 0;
 }
 
-static MpdTag * modTagDup(char * file) {
-	MpdTag * ret = NULL;
-	MODULE * moduleHandle;
-	char * title;
+static MpdTag *modTagDup(char *file)
+{
+	MpdTag *ret = NULL;
+	MODULE *moduleHandle;
+	char *title;
 
-	if(mod_initMikMod() < 0) {
+	if (mod_initMikMod() < 0) {
 		DEBUG("modTagDup: Failed to initialize MikMod\n");
 		return NULL;
 	}
 
-	if(!(moduleHandle = Player_Load(file, 128, 0))) {
-		DEBUG("modTagDup: Failed to open file: %s\n",file);
+	if (!(moduleHandle = Player_Load(file, 128, 0))) {
+		DEBUG("modTagDup: Failed to open file: %s\n", file);
 		MikMod_Exit();
 		return NULL;
 
@@ -229,58 +244,58 @@ static MpdTag * modTagDup(char * file) {
 
 	ret->time = 0;
 	title = strdup(Player_LoadTitle(file));
-	if(title) addItemToMpdTag(ret, TAG_ITEM_TITLE, title);
+	if (title)
+		addItemToMpdTag(ret, TAG_ITEM_TITLE, title);
 
 	MikMod_Exit();
 
 	return ret;
 }
 
-static char * modSuffixes[] = {"amf",
-			"dsm",
-			"far",
-			"gdm",
-			"imf",
-			"it",
-			"med",
-			"mod",
-			"mtm",
-			"s3m",
-			"stm",
-			"stx",
-			"ult",
-			"uni",
-			"xm",
-			NULL};
-
-InputPlugin modPlugin = 
-{
-        "mod",
-        NULL,
+static char *modSuffixes[] = { "amf",
+	"dsm",
+	"far",
+	"gdm",
+	"imf",
+	"it",
+	"med",
+	"mod",
+	"mtm",
+	"s3m",
+	"stm",
+	"stx",
+	"ult",
+	"uni",
+	"xm",
+	NULL
+};
+
+InputPlugin modPlugin = {
+	"mod",
+	NULL,
 	mod_finishMikMod,
 	NULL,
 	NULL,
-        mod_decode,
-        modTagDup,
-        INPUT_PLUGIN_STREAM_FILE,
-        modSuffixes,
-        NULL
+	mod_decode,
+	modTagDup,
+	INPUT_PLUGIN_STREAM_FILE,
+	modSuffixes,
+	NULL
 };
 
 #else
 
-InputPlugin modPlugin =
-{
-        NULL,
-        NULL,
-        NULL,
+InputPlugin modPlugin = {
+	NULL,
+	NULL,
+	NULL,
 	NULL,
-        NULL,
 	NULL,
 	NULL,
-        0,
-        NULL,
-        NULL
+	NULL,
+	0,
+	NULL,
+	NULL
 };
 
-#endif /* HAVE_AUDIOFILE */
+#endif				/* HAVE_AUDIOFILE */

src/inputStream.c

@@ -25,48 +25,59 @@
 #include <sys/types.h>
 #include <unistd.h>
 
-void initInputStream(void) {
+void initInputStream(void)
+{
 	inputStream_initFile();
 	inputStream_initHttp();
 }
 
-int openInputStream(InputStream * inStream, char * url) {
-        inStream->offset = 0;
-        inStream->size = 0;
-        inStream->error = 0;
-        inStream->mime = NULL;
-        inStream->seekable = 0;
-        inStream->metaName = NULL;
-        inStream->metaTitle = NULL;
+int openInputStream(InputStream * inStream, char *url)
+{
+	inStream->offset = 0;
+	inStream->size = 0;
+	inStream->error = 0;
+	inStream->mime = NULL;
+	inStream->seekable = 0;
+	inStream->metaName = NULL;
+	inStream->metaTitle = NULL;
 
-        if(inputStream_fileOpen(inStream,url) == 0) return 0;
-        if(inputStream_httpOpen(inStream,url) == 0) return 0;
+	if (inputStream_fileOpen(inStream, url) == 0)
+		return 0;
+	if (inputStream_httpOpen(inStream, url) == 0)
+		return 0;
 
-        return -1;
+	return -1;
 }
 
-int seekInputStream(InputStream * inStream, long offset, int whence) {
-        return inStream->seekFunc(inStream,offset,whence);
+int seekInputStream(InputStream * inStream, long offset, int whence)
+{
+	return inStream->seekFunc(inStream, offset, whence);
 }
 
-size_t readFromInputStream(InputStream * inStream, void * ptr, size_t size, 
-		size_t nmemb)
+size_t readFromInputStream(InputStream * inStream, void *ptr, size_t size,
+			   size_t nmemb)
 {
-        return inStream->readFunc(inStream,ptr,size,nmemb);
+	return inStream->readFunc(inStream, ptr, size, nmemb);
 }
 
-int closeInputStream(InputStream * inStream) {
-        if(inStream->mime) free(inStream->mime);
-        if(inStream->metaName) free(inStream->metaName);
-        if(inStream->metaTitle) free(inStream->metaTitle);
+int closeInputStream(InputStream * inStream)
+{
+	if (inStream->mime)
+		free(inStream->mime);
+	if (inStream->metaName)
+		free(inStream->metaName);
+	if (inStream->metaTitle)
+		free(inStream->metaTitle);
 
-        return inStream->closeFunc(inStream);
+	return inStream->closeFunc(inStream);
 }
 
-int inputStreamAtEOF(InputStream * inStream) {
-        return inStream->atEOFFunc(inStream);
+int inputStreamAtEOF(InputStream * inStream)
+{
+	return inStream->atEOFFunc(inStream);
 }
 
-int bufferInputStream(InputStream * inStream) {
-        return inStream->bufferFunc(inStream);
+int bufferInputStream(InputStream * inStream)
+{
+	return inStream->bufferFunc(inStream);
 }

src/inputStream.h

@@ -23,39 +23,39 @@
 
 typedef struct _InputStream InputStream;
 
-typedef int (* InputStreamSeekFunc) (InputStream * inStream, long offset, 
-                int whence);
-typedef size_t (* InputStreamReadFunc) (InputStream * inStream, void * ptr, size_t size, 
-		size_t nmemb);
-typedef int (* InputStreamCloseFunc) (InputStream * inStream);
-typedef int (* InputStreamAtEOFFunc) (InputStream * inStream);
-typedef int (* InputStreamBufferFunc) (InputStream * inStream);
+typedef int (*InputStreamSeekFunc) (InputStream * inStream, long offset,
+				    int whence);
+typedef size_t(*InputStreamReadFunc) (InputStream * inStream, void *ptr,
+				      size_t size, size_t nmemb);
+typedef int (*InputStreamCloseFunc) (InputStream * inStream);
+typedef int (*InputStreamAtEOFFunc) (InputStream * inStream);
+typedef int (*InputStreamBufferFunc) (InputStream * inStream);
 
 struct _InputStream {
 	int error;
 	long offset;
 	size_t size;
-        char * mime;
-        int seekable;
+	char *mime;
+	int seekable;
 
-        /* don't touc this stuff */
-        InputStreamSeekFunc seekFunc;
-        InputStreamReadFunc readFunc;
-        InputStreamCloseFunc closeFunc;
-        InputStreamAtEOFFunc atEOFFunc;
-        InputStreamBufferFunc bufferFunc;
-        void * data;
-        char * metaName;
-        char * metaTitle;
+	/* don't touc this stuff */
+	InputStreamSeekFunc seekFunc;
+	InputStreamReadFunc readFunc;
+	InputStreamCloseFunc closeFunc;
+	InputStreamAtEOFFunc atEOFFunc;
+	InputStreamBufferFunc bufferFunc;
+	void *data;
+	char *metaName;
+	char *metaTitle;
 };
 
 void initInputStream();
 
-int isUrlSaneForInputStream(char * url);
+int isUrlSaneForInputStream(char *url);
 
 /* if an error occurs for these 3 functions, then -1 is returned and errno
    for the input stream is set */
-int openInputStream(InputStream * inStream, char * url);
+int openInputStream(InputStream * inStream, char *url);
 int seekInputStream(InputStream * inStream, long offset, int whence);
 int closeInputStream(InputStream * inStream);
 int inputStreamAtEOF(InputStream * inStream);
@@ -64,7 +64,7 @@ int inputStreamAtEOF(InputStream * inStream);
    was buffered */
 int bufferInputStream(InputStream * inStream);
 
-size_t readFromInputStream(InputStream * inStream, void * ptr, size_t size,
-		size_t nmemb);
+size_t readFromInputStream(InputStream * inStream, void *ptr, size_t size,
+			   size_t nmemb);
 
 #endif

src/inputStream_file.c

@@ -26,39 +26,41 @@
 #include <unistd.h>
 #include <errno.h>
 
-void inputStream_initFile(void) {
+void inputStream_initFile(void)
+{
 }
 
-int inputStream_fileOpen(InputStream * inStream, char * filename) {
-        FILE * fp;
+int inputStream_fileOpen(InputStream * inStream, char *filename)
+{
+	FILE *fp;
 
-	fp = fopen(filename,"r");
-	if(!fp) {
+	fp = fopen(filename, "r");
+	if (!fp) {
 		inStream->error = errno;
 		return -1;
 	}
 
-        inStream->seekable = 1;
+	inStream->seekable = 1;
 
-	fseek(fp,0,SEEK_END);
+	fseek(fp, 0, SEEK_END);
 	inStream->size = ftell(fp);
-	fseek(fp,0,SEEK_SET);
+	fseek(fp, 0, SEEK_SET);
 
-        inStream->data = fp;
-        inStream->seekFunc = inputStream_fileSeek;
-        inStream->closeFunc = inputStream_fileClose;
-        inStream->readFunc = inputStream_fileRead;
-        inStream->atEOFFunc = inputStream_fileAtEOF;
-        inStream->bufferFunc = inputStream_fileBuffer;
+	inStream->data = fp;
+	inStream->seekFunc = inputStream_fileSeek;
+	inStream->closeFunc = inputStream_fileClose;
+	inStream->readFunc = inputStream_fileRead;
+	inStream->atEOFFunc = inputStream_fileAtEOF;
+	inStream->bufferFunc = inputStream_fileBuffer;
 
 	return 0;
 }
 
-int inputStream_fileSeek(InputStream * inStream, long offset, int whence) {
-	if(fseek((FILE *)inStream->data,offset,whence)==0) {
-		inStream->offset = ftell((FILE *)inStream->data);
-	}
-	else {
+int inputStream_fileSeek(InputStream * inStream, long offset, int whence)
+{
+	if (fseek((FILE *) inStream->data, offset, whence) == 0) {
+		inStream->offset = ftell((FILE *) inStream->data);
+	} else {
 		inStream->error = errno;
 		return -1;
 	}
@@ -66,25 +68,26 @@ int inputStream_fileSeek(InputStream * inStream, long offset, int whence) {
 	return 0;
 }
 
-size_t inputStream_fileRead(InputStream * inStream, void * ptr, size_t size, 
-		size_t nmemb)
+size_t inputStream_fileRead(InputStream * inStream, void *ptr, size_t size,
+			    size_t nmemb)
 {
 	size_t readSize;
 
-	readSize = fread(ptr,size,nmemb,(FILE *)inStream->data);
-        if(readSize <=0 && ferror((FILE *)inStream->data)) {
-                inStream->error = errno;
-		DEBUG("inputStream_fileRead: error reading: %s\n",  
-				strerror(inStream->error));
-        }
+	readSize = fread(ptr, size, nmemb, (FILE *) inStream->data);
+	if (readSize <= 0 && ferror((FILE *) inStream->data)) {
+		inStream->error = errno;
+		DEBUG("inputStream_fileRead: error reading: %s\n",
+		      strerror(inStream->error));
+	}
 
-	inStream->offset = ftell((FILE *)inStream->data);
+	inStream->offset = ftell((FILE *) inStream->data);
 
 	return readSize;
 }
 
-int inputStream_fileClose(InputStream * inStream) {
-	if(fclose((FILE *)inStream->data)<0) {
+int inputStream_fileClose(InputStream * inStream)
+{
+	if (fclose((FILE *) inStream->data) < 0) {
 		inStream->error = errno;
 		return -1;
 	}
@@ -92,16 +95,19 @@ int inputStream_fileClose(InputStream * inStream) {
 	return 0;
 }
 
-int inputStream_fileAtEOF(InputStream * inStream) {
-	if(feof((FILE *)inStream->data)) return 1;
+int inputStream_fileAtEOF(InputStream * inStream)
+{
+	if (feof((FILE *) inStream->data))
+		return 1;
 
-        if(ferror((FILE *)inStream->data) && inStream->error != EINTR)  {
-                return 1;
-        }
+	if (ferror((FILE *) inStream->data) && inStream->error != EINTR) {
+		return 1;
+	}
 
-        return 0;
+	return 0;
 }
 
-int inputStream_fileBuffer(InputStream * inStream) {
-        return 0;
+int inputStream_fileBuffer(InputStream * inStream)
+{
+	return 0;
 }

src/inputStream_file.h

@@ -23,12 +23,12 @@
 
 void inputStream_initFile();
 
-int inputStream_fileOpen(InputStream * inStream, char * filename);
+int inputStream_fileOpen(InputStream * inStream, char *filename);
 
 int inputStream_fileSeek(InputStream * inStream, long offset, int whence);
 
-size_t inputStream_fileRead(InputStream * inStream, void * ptr, size_t size, 
-		size_t nmemb);
+size_t inputStream_fileRead(InputStream * inStream, void *ptr, size_t size,
+			    size_t nmemb);
 
 int inputStream_fileClose(InputStream * inStream);
 

src/inputStream_http.h

@@ -23,12 +23,12 @@
 
 void inputStream_initHttp();
 
-int inputStream_httpOpen(InputStream * inStream, char * filename);
+int inputStream_httpOpen(InputStream * inStream, char *filename);
 
 int inputStream_httpSeek(InputStream * inStream, long offset, int whence);
 
-size_t inputStream_httpRead(InputStream * inStream, void * ptr, size_t size, 
-		size_t nmemb);
+size_t inputStream_httpRead(InputStream * inStream, void *ptr, size_t size,
+			    size_t nmemb);
 
 int inputStream_httpClose(InputStream * inStream);
 

src/interface.h

@@ -27,10 +27,10 @@
 #include <sys/socket.h>
 
 void initInterfaces();
-void openAInterface(int fd, struct sockaddr * addr);
+void openAInterface(int fd, struct sockaddr *addr);
 void freeAllInterfaces();
 void closeOldInterfaces();
-int interfacePrintWithFD(int fd, char * buffer, int len);
+int interfacePrintWithFD(int fd, char *buffer, int len);
 
 int doIOForInterfaces();
 

src/list.h

@@ -16,7 +16,6 @@
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
-
 #ifndef LIST_H
 #define LIST_H
 
@@ -32,26 +31,26 @@ typedef void ListFreeDataFunc(void *);
 
 typedef struct _ListNode {
 	/* used to identify node (ie. when using findInList) */
-	char * key;
+	char *key;
 	/* data store in node */
-	void * data;
+	void *data;
 	/* next node in list */
-	struct _ListNode * nextNode;
+	struct _ListNode *nextNode;
 	/* previous node in list */
-	struct _ListNode * prevNode;
+	struct _ListNode *prevNode;
 } ListNode;
 
 typedef struct _List {
 	/* first node in list */
-	ListNode * firstNode;
+	ListNode *firstNode;
 	/* last node in list */
-	ListNode * lastNode;
+	ListNode *lastNode;
 	/* function used to free data stored in nodes of the list */
-	ListFreeDataFunc * freeDataFunc;
+	ListFreeDataFunc *freeDataFunc;
 	/* number of nodes */
 	long numberOfNodes;
 	/* array for searching when list is sorted */
-	ListNode ** nodesArray;
+	ListNode **nodesArray;
 	/* sorted */
 	int sorted;
 	/* weather to strdup() key's on insertion */
@@ -63,29 +62,29 @@ typedef struct _List {
  *                    DEFAULT_FREE_DATAFUNC to use free()
  * returns pointer to new list if successful, NULL otherwise
  */
-List * makeList(ListFreeDataFunc * freeDataFunc, int strdupKeys);
+List *makeList(ListFreeDataFunc * freeDataFunc, int strdupKeys);
 
 /* inserts a node into _list_ with _key_ and _data_
  *  _list_ -> list the data will be inserted in
  *  _key_ -> identifier for node/data to be inserted into list
  *  _data_ -> data to be inserted in list
  * returns 1 if successful, 0 otherwise
- */ 
-ListNode * insertInList(List * list,char * key,void * data);
+ */
+ListNode *insertInList(List * list, char *key, void *data);
+
+ListNode *insertInListBeforeNode(List * list, ListNode * beforeNode,
+				 int pos, char *key, void *data);
 
-ListNode * insertInListBeforeNode(List * list, ListNode * beforeNode, 
-		int pos, char * key, void * data);
- 
-int insertInListWithoutKey(List * list,void * data);
+int insertInListWithoutKey(List * list, void *data);
 
 /* deletes the first node in the list with the key _key_
  *  _list_ -> list the node will be deleted from
  *  _key_ -> key used to identify node to delete
  *  returns 1 if node is found and deleted, 0 otherwise
  */
-int deleteFromList(List * list,char * key);
+int deleteFromList(List * list, char *key);
 
-void deleteNodeFromList(List * list,ListNode * node);
+void deleteNodeFromList(List * list, ListNode * node);
 
 /* finds data in a list based on key
  *  _list_ -> list to search for _key_ in
@@ -95,16 +94,16 @@ void deleteNodeFromList(List * list,ListNode * node);
  *      _data_ can be NULL
  * returns 1 if successful, 0 otherwise
  */
-int findInList(List * list, char * key, void ** data);
+int findInList(List * list, char *key, void **data);
 
 /* if _key_ is not found, *_node_ is assigned to the node before which
 	the info would be found */
-int findNodeInList(List * list, char * key, ListNode ** node, int * pos);
+int findNodeInList(List * list, char *key, ListNode ** node, int *pos);
 
 /* frees memory malloc'd for list and its nodes
  *  _list_ -> List to be free'd
  */
-void freeList(void * list);
+void freeList(void *list);
 
 void sortList(List * list);
 

src/listen.c

@@ -40,18 +40,17 @@
 
 #define DEFAULT_PORT	6600
 
-int * listenSockets = NULL;
+int *listenSockets = NULL;
 int numberOfListenSockets = 0;
 
 static void establishListen(unsigned int port,
-			    struct sockaddr * addrp, 
-			    socklen_t addrlen) 
+			    struct sockaddr *addrp, socklen_t addrlen)
 {
 	int pf;
 	int sock;
 	int allowReuse = ALLOW_REUSE;
 
-	switch(addrp->sa_family) {
+	switch (addrp->sa_family) {
 	case AF_INET:
 		pf = PF_INET;
 		break;
@@ -64,49 +63,49 @@ static void establishListen(unsigned int port,
 		pf = PF_UNIX;
 		break;
 	default:
-		ERROR("unknown address family: %i\n",addrp->sa_family);
+		ERROR("unknown address family: %i\n", addrp->sa_family);
 		exit(EXIT_FAILURE);
 	}
 
-	if((sock = socket(pf,SOCK_STREAM,0)) < 0) {
+	if ((sock = socket(pf, SOCK_STREAM, 0)) < 0) {
 		ERROR("socket < 0\n");
 		exit(EXIT_FAILURE);
 	}
 
-	if(fcntl(sock, F_SETFL ,fcntl(sock, F_GETFL) | O_NONBLOCK) < 0) {
+	if (fcntl(sock, F_SETFL, fcntl(sock, F_GETFL) | O_NONBLOCK) < 0) {
 		ERROR("problems setting nonblocking on listen socket: %s\n",
-				strerror(errno));
+		      strerror(errno));
 		exit(EXIT_FAILURE);
 	}
 
-	if(setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,(char *)&allowReuse,
-			sizeof(allowReuse))<0) 
-	{
+	if (setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, (char *)&allowReuse,
+		       sizeof(allowReuse)) < 0) {
 		ERROR("problems setsockopt'ing: %s\n", strerror(errno));
 		exit(EXIT_FAILURE);
 	}
 
-	if(bind(sock,addrp,addrlen)<0) {
+	if (bind(sock, addrp, addrlen) < 0) {
 		ERROR("unable to bind port %u", port);
 		ERROR(": %s\n", strerror(errno));
 		ERROR("maybe MPD is still running?\n");
 		exit(EXIT_FAILURE);
 	}
-	
-	if(listen(sock,5)<0) {
+
+	if (listen(sock, 5) < 0) {
 		ERROR("problems listen'ing: %s\n", strerror(errno));
 		exit(EXIT_FAILURE);
 	}
 
 	numberOfListenSockets++;
-	listenSockets = 
-	    realloc(listenSockets,sizeof(int)*numberOfListenSockets);
+	listenSockets =
+	    realloc(listenSockets, sizeof(int) * numberOfListenSockets);
 
-	listenSockets[numberOfListenSockets-1] = sock;
+	listenSockets[numberOfListenSockets - 1] = sock;
 }
 
-static void parseListenConfigParam(unsigned int port, ConfigParam * param) {
-	struct sockaddr * addrp;
+static void parseListenConfigParam(unsigned int port, ConfigParam * param)
+{
+	struct sockaddr *addrp;
 	socklen_t addrlen;
 	struct sockaddr_in sin;
 #ifdef HAVE_IPV6
@@ -120,54 +119,52 @@ static void parseListenConfigParam(unsigned int port, ConfigParam * param) {
 	sin.sin_port = htons(port);
 	sin.sin_family = AF_INET;
 
-	if(!param || 0==strcmp(param->value, "any")) {
+	if (!param || 0 == strcmp(param->value, "any")) {
 		DEBUG("binding to any address\n");
 #ifdef HAVE_IPV6
-		if(ipv6Supported()) {
+		if (ipv6Supported()) {
 			sin6.sin6_addr = in6addr_any;
-			addrp = (struct sockaddr *) &sin6;
+			addrp = (struct sockaddr *)&sin6;
 			addrlen = sizeof(struct sockaddr_in6);
 			establishListen(port, addrp, addrlen);
 		}
 #endif
 		sin.sin_addr.s_addr = INADDR_ANY;
-		addrp = (struct sockaddr *) &sin;
+		addrp = (struct sockaddr *)&sin;
 		addrlen = sizeof(struct sockaddr_in);
 		establishListen(port, addrp, addrlen);
-	}
-	else {
-		struct hostent * he;
+	} else {
+		struct hostent *he;
 		DEBUG("binding to address for %s\n", param->value);
-		if(!(he = gethostbyname(param->value))) {
+		if (!(he = gethostbyname(param->value))) {
 			ERROR("can't lookup host \"%s\" at line %i\n",
-                                        param->value, param->line);
+			      param->value, param->line);
 			exit(EXIT_FAILURE);
 		}
-		switch(he->h_addrtype) {
+		switch (he->h_addrtype) {
 #ifdef HAVE_IPV6
 		case AF_INET6:
-			if(!ipv6Supported()) {
+			if (!ipv6Supported()) {
 				ERROR("no IPv6 support, but a IPv6 address "
-					"found for \"%s\" at line %i\n",
-					param->value, param->line);
+				      "found for \"%s\" at line %i\n",
+				      param->value, param->line);
 				exit(EXIT_FAILURE);
 			}
-			bcopy((char *)he->h_addr,(char *)
-					&sin6.sin6_addr.s6_addr,he->h_length);
-			addrp = (struct sockaddr *) &sin6;
+			bcopy((char *)he->h_addr, (char *)
+			      &sin6.sin6_addr.s6_addr, he->h_length);
+			addrp = (struct sockaddr *)&sin6;
 			addrlen = sizeof(struct sockaddr_in6);
 			break;
 #endif
 		case AF_INET:
-			bcopy((char *)he->h_addr,(char *)&sin.sin_addr.s_addr,
-				he->h_length);
-			addrp = (struct sockaddr *) &sin;
+			bcopy((char *)he->h_addr, (char *)&sin.sin_addr.s_addr,
+			      he->h_length);
+			addrp = (struct sockaddr *)&sin;
 			addrlen = sizeof(struct sockaddr_in);
 			break;
 		default:
 			ERROR("address type for \"%s\" is not IPv4 or IPv6 "
-                                        "at line %i\n",
-					param->value, param->line);
+			      "at line %i\n", param->value, param->line);
 			exit(EXIT_FAILURE);
 		}
 
@@ -175,73 +172,77 @@ static void parseListenConfigParam(unsigned int port, ConfigParam * param) {
 	}
 }
 
-void listenOnPort(void) {
+void listenOnPort(void)
+{
 	int port = DEFAULT_PORT;
-	ConfigParam * param = getNextConfigParam(CONF_BIND_TO_ADDRESS,NULL);
+	ConfigParam *param = getNextConfigParam(CONF_BIND_TO_ADDRESS, NULL);
 
 	{
-		ConfigParam * portParam = getConfigParam(CONF_PORT);
+		ConfigParam *portParam = getConfigParam(CONF_PORT);
 
-		if(portParam) {
-			char * test;
+		if (portParam) {
+			char *test;
 			port = strtol(portParam->value, &test, 10);
-			if(port <= 0 || *test != '\0') {
+			if (port <= 0 || *test != '\0') {
 				ERROR("%s \"%s\" specified at line %i is not a "
-						"positive integer", CONF_PORT,
-						portParam->value, 
-						portParam->line);
+				      "positive integer", CONF_PORT,
+				      portParam->value, portParam->line);
 				exit(EXIT_FAILURE);
 			}
 		}
 	}
 
 	do {
-	    parseListenConfigParam(port, param);
+		parseListenConfigParam(port, param);
 	} while ((param = getNextConfigParam(CONF_BIND_TO_ADDRESS, param)));
 }
 
-void addListenSocketsToFdSet(fd_set * fds, int * fdmax) {
+void addListenSocketsToFdSet(fd_set * fds, int *fdmax)
+{
 	int i;
 
-	for(i=0; i<numberOfListenSockets; i++) {
+	for (i = 0; i < numberOfListenSockets; i++) {
 		FD_SET(listenSockets[i], fds);
-		if(listenSockets[i] > *fdmax) *fdmax = listenSockets[i];
+		if (listenSockets[i] > *fdmax)
+			*fdmax = listenSockets[i];
 	}
 }
 
-void closeAllListenSockets(void) {
+void closeAllListenSockets(void)
+{
 	int i;
 
 	DEBUG("closeAllListenSockets called\n");
 
-	for(i=0; i<numberOfListenSockets; i++) {
+	for (i = 0; i < numberOfListenSockets; i++) {
 		DEBUG("closing listen socket %i\n", i);
-		while(close(listenSockets[i]) < 0 && errno==EINTR);
+		while (close(listenSockets[i]) < 0 && errno == EINTR) ;
 	}
 	freeAllListenSockets();
 }
 
-void freeAllListenSockets(void) {
+void freeAllListenSockets(void)
+{
 	numberOfListenSockets = 0;
 	free(listenSockets);
 	listenSockets = NULL;
 }
 
-void getConnections(fd_set * fds) {
+void getConnections(fd_set * fds)
+{
 	int i;
 	int fd = 0;
 	struct sockaddr sockAddr;
 	socklen_t socklen = sizeof(sockAddr);
 
-	for(i=0; i<numberOfListenSockets; i++) {
-		if(FD_ISSET(listenSockets[i], fds)) {
-			if((fd = accept(listenSockets[i], &sockAddr, &socklen)) 
-					>= 0) 
-			{
-				openAInterface(fd,&sockAddr);
-			}
-			else if(fd<0 && (errno!=EAGAIN && errno!=EINTR)) {
-				 ERROR("Problems accept()'ing\n");
+	for (i = 0; i < numberOfListenSockets; i++) {
+		if (FD_ISSET(listenSockets[i], fds)) {
+			if ((fd = accept(listenSockets[i], &sockAddr, &socklen))
+			    >= 0) {
+				openAInterface(fd, &sockAddr);
+			} else if (fd < 0
+				   && (errno != EAGAIN && errno != EINTR)) {
+				ERROR("Problems accept()'ing\n");
 			}
 		}
 	}

src/listen.h

@@ -34,6 +34,6 @@ void closeAllListenSockets();
 void freeAllListenSockets();
 
 /* fdmax should be initialized to something */
-void addListenSocketsToFdSet(fd_set * fds, int * fdmax);
+void addListenSocketsToFdSet(fd_set * fds, int *fdmax);
 
 #endif

src/log.c

@@ -29,36 +29,39 @@
 int logLevel = LOG_LEVEL_LOW;
 short warningFlushed = 0;
 
-static char * warningBuffer = NULL;
-
-void initLog(void) {
-	ConfigParam * param = getConfigParam(CONF_LOG_LEVEL);
-
-	if(!param) return;
-
-	if(0 == strcmp(param->value, "default")) {
-		if(logLevel<LOG_LEVEL_LOW) logLevel = LOG_LEVEL_LOW;
-	}
-	else if(0 == strcmp(param->value, "secure")) {
-		if(logLevel<LOG_LEVEL_SECURE) logLevel = LOG_LEVEL_SECURE;
-	}
-	else if(0 == strcmp(param->value, "verbose")) {
-		if(logLevel<LOG_LEVEL_DEBUG) logLevel = LOG_LEVEL_DEBUG;
-	}
-	else {
+static char *warningBuffer = NULL;
+
+void initLog(void)
+{
+	ConfigParam *param = getConfigParam(CONF_LOG_LEVEL);
+
+	if (!param)
+		return;
+
+	if (0 == strcmp(param->value, "default")) {
+		if (logLevel < LOG_LEVEL_LOW)
+			logLevel = LOG_LEVEL_LOW;
+	} else if (0 == strcmp(param->value, "secure")) {
+		if (logLevel < LOG_LEVEL_SECURE)
+			logLevel = LOG_LEVEL_SECURE;
+	} else if (0 == strcmp(param->value, "verbose")) {
+		if (logLevel < LOG_LEVEL_DEBUG)
+			logLevel = LOG_LEVEL_DEBUG;
+	} else {
 		ERROR("unknown log level \"%s\" at line %i\n",
-				param->value, param->line);
+		      param->value, param->line);
 		exit(EXIT_FAILURE);
 	}
 }
 
 #define BUFFER_LENGTH	4096
 
-void bufferWarning(char * format, ... ) {
+void bufferWarning(char *format, ...)
+{
 	va_list arglist;
-	char temp[BUFFER_LENGTH+1];
+	char temp[BUFFER_LENGTH + 1];
 
-	memset(temp, 0, BUFFER_LENGTH+1);
+	memset(temp, 0, BUFFER_LENGTH + 1);
 
 	va_start(arglist, format);
 
@@ -69,15 +72,17 @@ void bufferWarning(char * format, ... ) {
 	va_end(arglist);
 }
 
-void flushWarningLog(void) {
-	char * s;
+void flushWarningLog(void)
+{
+	char *s;
 
 	DEBUG("flushing warning messages\n");
 
-	if(warningBuffer == NULL) return;
+	if (warningBuffer == NULL)
+		return;
 
 	s = strtok(warningBuffer, "\n");
-	while ( s != NULL ) {
+	while (s != NULL) {
 		myfprintf(stderr, "%s\n", s);
 
 		s = strtok(NULL, "\n");

src/log.h

@@ -36,7 +36,6 @@ extern short warningFlushed;
 
 #define SECURE(...) if(logLevel>=LOG_LEVEL_SECURE) \
 				myfprintf(stdout, __VA_ARGS__)
-		
 
 #define DEBUG(...) if(logLevel>=LOG_LEVEL_DEBUG) \
 				myfprintf(stdout, __VA_ARGS__)
@@ -48,7 +47,7 @@ extern short warningFlushed;
 
 void initLog();
 
-void bufferWarning(char * format, ... );
+void bufferWarning(char *format, ...);
 
 void flushWarningLog();
 

src/ls.c

@@ -27,74 +27,72 @@
 #include <stdio.h>
 #include <errno.h>
 
-static char * remoteUrlPrefixes[] = 	
-{
-        "http://",
+static char *remoteUrlPrefixes[] = {
+	"http://",
 	NULL
 };
 
-int printRemoteUrlHandlers(FILE * fp) {
-        char ** prefixes = remoteUrlPrefixes;
+int printRemoteUrlHandlers(FILE * fp)
+{
+	char **prefixes = remoteUrlPrefixes;
 
-        while (*prefixes) {
-                myfprintf(fp,"handler: %s\n", *prefixes);
-                prefixes++;
-        }
+	while (*prefixes) {
+		myfprintf(fp, "handler: %s\n", *prefixes);
+		prefixes++;
+	}
 
-        return 0;
+	return 0;
 }
 
-int isValidRemoteUtf8Url(char * utf8url) {
-        int ret = 0;
-        char * temp;
-
-        switch(isRemoteUrl(utf8url)) {
-        case 1:
-                ret = 1;
-                temp = utf8url;
-                while(*temp) {
-                        if((*temp >= 'a' && *temp <= 'z') || 
-                                        (*temp >= 'A' && *temp <= 'Z') ||
-                                        (*temp >= '0' && *temp <= '9') ||
-                                        *temp == '$' ||
-                                        *temp == '-' ||
-                                        *temp == '.' ||
-                                        *temp == '+' ||
-                                        *temp == '!' ||
-                                        *temp == '*' ||
-                                        *temp == '\'' ||
-                                        *temp == '(' ||
-                                        *temp == ')' ||
-                                        *temp == ',' ||
-                                        *temp == '%' ||
-                                        *temp == '/' ||
-                                        *temp == ':' ||
-                                        *temp == '?' ||
-                                        *temp == ';' ||
-                                        *temp == '&' ||
-                                        *temp == '=') 
-                        {
-                        }
-                        else {
-                                ret = 1;
-                                break;
-                        }
-                        temp++;
-                }
-                break;
-        }
-
-        return ret;
+int isValidRemoteUtf8Url(char *utf8url)
+{
+	int ret = 0;
+	char *temp;
+
+	switch (isRemoteUrl(utf8url)) {
+	case 1:
+		ret = 1;
+		temp = utf8url;
+		while (*temp) {
+			if ((*temp >= 'a' && *temp <= 'z') ||
+			    (*temp >= 'A' && *temp <= 'Z') ||
+			    (*temp >= '0' && *temp <= '9') ||
+			    *temp == '$' ||
+			    *temp == '-' ||
+			    *temp == '.' ||
+			    *temp == '+' ||
+			    *temp == '!' ||
+			    *temp == '*' ||
+			    *temp == '\'' ||
+			    *temp == '(' ||
+			    *temp == ')' ||
+			    *temp == ',' ||
+			    *temp == '%' ||
+			    *temp == '/' ||
+			    *temp == ':' ||
+			    *temp == '?' ||
+			    *temp == ';' || *temp == '&' || *temp == '=') {
+			} else {
+				ret = 1;
+				break;
+			}
+			temp++;
+		}
+		break;
+	}
+
+	return ret;
 }
 
-int isRemoteUrl(char * url) {
-        int count = 0;
-	char ** urlPrefixes = remoteUrlPrefixes;
+int isRemoteUrl(char *url)
+{
+	int count = 0;
+	char **urlPrefixes = remoteUrlPrefixes;
 
-	while(*urlPrefixes) {
-                count++;
-		if(strncmp(*urlPrefixes,url,strlen(*urlPrefixes)) == 0) {
-                        return count;
+	while (*urlPrefixes) {
+		count++;
+		if (strncmp(*urlPrefixes, url, strlen(*urlPrefixes)) == 0) {
+			return count;
 		}
 		urlPrefixes++;
 	}
@@ -102,72 +100,75 @@ int isRemoteUrl(char * url) {
 	return 0;
 }
 
-int lsPlaylists(FILE * fp, char * utf8path) {
-	DIR * dir;
+int lsPlaylists(FILE * fp, char *utf8path)
+{
+	DIR *dir;
 	struct stat st;
-	struct dirent * ent;
-	char * dup;
-	char * utf8;
-	char s[MAXPATHLEN+1];
-	List * list = NULL;
-	ListNode * node = NULL;
-	char * path = utf8ToFsCharset(utf8path);
-	char * actualPath = rpp2app(path);
-	int actlen = strlen(actualPath)+1;
-	int maxlen = MAXPATHLEN-actlen;
-	int suflen = strlen(PLAYLIST_FILE_SUFFIX)+1;
+	struct dirent *ent;
+	char *dup;
+	char *utf8;
+	char s[MAXPATHLEN + 1];
+	List *list = NULL;
+	ListNode *node = NULL;
+	char *path = utf8ToFsCharset(utf8path);
+	char *actualPath = rpp2app(path);
+	int actlen = strlen(actualPath) + 1;
+	int maxlen = MAXPATHLEN - actlen;
+	int suflen = strlen(PLAYLIST_FILE_SUFFIX) + 1;
 	int suff;
 
-	if(actlen>MAXPATHLEN-1 || (dir = opendir(actualPath))==NULL) {
+	if (actlen > MAXPATHLEN - 1 || (dir = opendir(actualPath)) == NULL) {
 		free(path);
 		return 0;
 	}
 
 	s[MAXPATHLEN] = '\0';
 	/* this is safe, notice actlen > MAXPATHLEN-1 above */
-	strcpy(s,actualPath);
-	strcat(s,"/");
+	strcpy(s, actualPath);
+	strcat(s, "/");
 
-	while((ent = readdir(dir))) {
+	while ((ent = readdir(dir))) {
 		dup = ent->d_name;
-		if(dup[0]!='.' && 
-				(suff=strlen(dup)-suflen)>0 && 
-				dup[suff]=='.' &&
-				strcmp(dup+suff+1,PLAYLIST_FILE_SUFFIX)==0) 
-		{
-			strncpy(s+actlen,ent->d_name,maxlen);
-			if(stat(s,&st)==0) {
-				if(S_ISREG(st.st_mode)) {
-					if(list==NULL) list = makeList(NULL, 1);
+		if (dup[0] != '.' &&
+		    (suff = strlen(dup) - suflen) > 0 &&
+		    dup[suff] == '.' &&
+		    strcmp(dup + suff + 1, PLAYLIST_FILE_SUFFIX) == 0) {
+			strncpy(s + actlen, ent->d_name, maxlen);
+			if (stat(s, &st) == 0) {
+				if (S_ISREG(st.st_mode)) {
+					if (list == NULL)
+						list = makeList(NULL, 1);
 					dup[suff] = '\0';
-					if((utf8 = fsCharsetToUtf8(dup))) {
-						insertInList(list,utf8,NULL);
+					if ((utf8 = fsCharsetToUtf8(dup))) {
+						insertInList(list, utf8, NULL);
 						free(utf8);
 					}
 				}
 			}
 		}
 	}
-	
+
 	closedir(dir);
 	free(path);
 
-	if(list) {
+	if (list) {
 		int i;
 		sortList(list);
 
-		dup = malloc(strlen(utf8path)+2);
-		strcpy(dup,utf8path);
-		for(i = strlen(dup)-1; i >= 0 && dup[i]=='/'; i--) {
+		dup = malloc(strlen(utf8path) + 2);
+		strcpy(dup, utf8path);
+		for (i = strlen(dup) - 1; i >= 0 && dup[i] == '/'; i--) {
 			dup[i] = '\0';
 		}
-		if(strlen(dup)) strcat(dup,"/");
+		if (strlen(dup))
+			strcat(dup, "/");
 
 		node = list->firstNode;
-		while(node!=NULL) {
-                        if(!strchr(node->key, '\n')) {
-			        myfprintf(fp,"playlist: %s%s\n",dup,node->key);
-                        }
+		while (node != NULL) {
+			if (!strchr(node->key, '\n')) {
+				myfprintf(fp, "playlist: %s%s\n", dup,
+					  node->key);
+			}
 			node = node->nextNode;
 		}
 
@@ -178,71 +179,79 @@ int lsPlaylists(FILE * fp, char * utf8path) {
 	return 0;
 }
 
-int myStat(char * utf8file, struct stat * st) {
-	char * file = utf8ToFsCharset(utf8file);
-	char * actualFile = file;
+int myStat(char *utf8file, struct stat *st)
+{
+	char *file = utf8ToFsCharset(utf8file);
+	char *actualFile = file;
 	int ret;
 
-	if(actualFile[0]!='/') actualFile = rmp2amp(file);
+	if (actualFile[0] != '/')
+		actualFile = rmp2amp(file);
 
-	ret = stat(actualFile,st);
+	ret = stat(actualFile, st);
 
 	free(file);
 
 	return ret;
 }
 
-static int isFile(char * utf8file, time_t * mtime) {
+static int isFile(char *utf8file, time_t * mtime)
+{
 	struct stat st;
 
-	if(myStat(utf8file,&st)==0) {
-		if(S_ISREG(st.st_mode)) {
-			if(mtime) *mtime = st.st_mtime;
+	if (myStat(utf8file, &st) == 0) {
+		if (S_ISREG(st.st_mode)) {
+			if (mtime)
+				*mtime = st.st_mtime;
 			return 1;
+		} else {
+			DEBUG("isFile: %s is not a regular file\n", utf8file);
+			return 0;
 		}
-		else
-		{
-		 DEBUG("isFile: %s is not a regular file\n",utf8file);
-		 return 0;
-		}
-	}
-	else {
-		DEBUG("isFile: failed to stat: %s: %s\n", utf8file, strerror(errno));
+	} else {
+		DEBUG("isFile: failed to stat: %s: %s\n", utf8file,
+		      strerror(errno));
 	}
 
 	return 0;
 }
 
 /* suffixes should be ascii only characters */
-char * getSuffix(char * utf8file) {
-        char * ret = NULL;
+char *getSuffix(char *utf8file)
+{
+	char *ret = NULL;
 
-        while(*utf8file) {
-                if(*utf8file == '.') ret = utf8file+1;
-                utf8file++;
-        }
+	while (*utf8file) {
+		if (*utf8file == '.')
+			ret = utf8file + 1;
+		utf8file++;
+	}
 
 	return ret;
 }
 
-int hasSuffix(char * utf8file, char * suffix) {
-        char * s = getSuffix(utf8file);
-        if(s && 0==strcmp(s,suffix)) return 1;
-        return 0;
+int hasSuffix(char *utf8file, char *suffix)
+{
+	char *s = getSuffix(utf8file);
+	if (s && 0 == strcmp(s, suffix))
+		return 1;
+	return 0;
 }
 
-int isPlaylist(char * utf8file) {
-	if(isFile(utf8file,NULL)) {
-		return hasSuffix(utf8file,PLAYLIST_FILE_SUFFIX);
+int isPlaylist(char *utf8file)
+{
+	if (isFile(utf8file, NULL)) {
+		return hasSuffix(utf8file, PLAYLIST_FILE_SUFFIX);
 	}
 	return 0;
 }
 
-int isDir(char * utf8name) {
+int isDir(char *utf8name)
+{
 	struct stat st;
 
-	if(myStat(utf8name,&st)==0) {
-		if(S_ISDIR(st.st_mode)) {
+	if (myStat(utf8name, &st) == 0) {
+		if (S_ISDIR(st.st_mode)) {
 			return 1;
 		}
 	}
@@ -250,26 +259,28 @@ int isDir(char * utf8name) {
 	return 0;
 }
 
-InputPlugin * hasMusicSuffix(char * utf8file, unsigned int next) {
-        InputPlugin * ret = NULL;
-
-        char * s = getSuffix(utf8file);
-	if(s) {
-		 ret = getInputPluginFromSuffix(s, next);
-	}	
-	else {
-		DEBUG("hasMusicSuffix: The file: %s has no valid suffix\n",utf8file);
+InputPlugin *hasMusicSuffix(char *utf8file, unsigned int next)
+{
+	InputPlugin *ret = NULL;
+
+	char *s = getSuffix(utf8file);
+	if (s) {
+		ret = getInputPluginFromSuffix(s, next);
+	} else {
+		DEBUG("hasMusicSuffix: The file: %s has no valid suffix\n",
+		      utf8file);
 	}
 
 	return ret;
 }
 
-InputPlugin * isMusic(char * utf8file, time_t * mtime, unsigned int next) {
-	if(isFile(utf8file,mtime)) {
-		InputPlugin * plugin = hasMusicSuffix(utf8file, next);
+InputPlugin *isMusic(char *utf8file, time_t * mtime, unsigned int next)
+{
+	if (isFile(utf8file, mtime)) {
+		InputPlugin *plugin = hasMusicSuffix(utf8file, next);
 		if (plugin != NULL)
 			return plugin;
 	}
-	DEBUG("isMusic: %s is not a valid file\n",utf8file);
+	DEBUG("isMusic: %s is not a valid file\n", utf8file);
 	return NULL;
 }

src/ls.h

@@ -21,7 +21,7 @@
 
 #include "../config.h"
 
-#include "inputPlugin.h" 
+#include "inputPlugin.h"
 
 #include <stdio.h>
 #include <sys/types.h>
@@ -29,23 +29,23 @@
 #include <unistd.h>
 #include <time.h>
 
-int lsPlaylists(FILE * fp, char * utf8path);
+int lsPlaylists(FILE * fp, char *utf8path);
 
-char * getSuffix(char * utf8file);
+char *getSuffix(char *utf8file);
 
-int isValidRemoteUtf8Url(char * utf8url);
+int isValidRemoteUtf8Url(char *utf8url);
 
-int isRemoteUrl(char * url);
+int isRemoteUrl(char *url);
 
-int myStat(char * utf8file, struct stat * st);
+int myStat(char *utf8file, struct stat *st);
 
-int isDir(char * utf8name);
+int isDir(char *utf8name);
 
-int isPlaylist(char * utf8file);
+int isPlaylist(char *utf8file);
 
-InputPlugin * hasMusicSuffix(char * utf8file, unsigned int next);
+InputPlugin *hasMusicSuffix(char *utf8file, unsigned int next);
 
-InputPlugin * isMusic(char * utf8file, time_t * mtime, unsigned int next);
+InputPlugin *isMusic(char *utf8file, time_t * mtime, unsigned int next);
 
 int printRemoteUrlHandlers(FILE * fp);
 

src/metadataChunk.c

@@ -20,9 +20,10 @@
 
 #include <string.h>
 
-static void initMetadataChunk(MetadataChunk * chunk) {
+static void initMetadataChunk(MetadataChunk * chunk)
+{
 	memset(chunk, 0, sizeof(MetadataChunk));
-	
+
 	chunk->name = -1;
 	chunk->artist = -1;
 	chunk->album = -1;
@@ -35,10 +36,11 @@ static void initMetadataChunk(MetadataChunk * chunk) {
 	} \
 }
 
-MpdTag * metadataChunkToMpdTagDup(MetadataChunk * chunk) {
-	MpdTag * ret = newMpdTag();
+MpdTag *metadataChunkToMpdTagDup(MetadataChunk * chunk)
+{
+	MpdTag *ret = newMpdTag();
 
-	chunk->buffer[METADATA_BUFFER_LENGTH-1] = '\0';
+	chunk->buffer[METADATA_BUFFER_LENGTH - 1] = '\0';
 
 	dupElementToTag(TAG_ITEM_NAME, chunk->name);
 	dupElementToTag(TAG_ITEM_TITLE, chunk->title);
@@ -59,17 +61,19 @@ MpdTag * metadataChunkToMpdTagDup(MetadataChunk * chunk) {
 	} \
 }
 
-void copyMpdTagToMetadataChunk(MpdTag * tag, MetadataChunk * chunk) {
+void copyMpdTagToMetadataChunk(MpdTag * tag, MetadataChunk * chunk)
+{
 	int pos = 0;
 	int slen;
 	int i;
 
 	initMetadataChunk(chunk);
 
-	if(!tag) return;
+	if (!tag)
+		return;
 
-	for(i = 0; i < tag->numOfItems; i++) {
-		switch(tag->items[i].type) {
+	for (i = 0; i < tag->numOfItems; i++) {
+		switch (tag->items[i].type) {
 		case TAG_ITEM_NAME:
 			copyStringToChunk(tag->items[i].value, chunk->name);
 			break;

src/metadataChunk.h

@@ -31,7 +31,7 @@ typedef struct _MetadataChunk {
 	char buffer[METADATA_BUFFER_LENGTH];
 } MetadataChunk;
 
-MpdTag * metadataChunkToMpdTagDup(MetadataChunk * chunk);
+MpdTag *metadataChunkToMpdTagDup(MetadataChunk * chunk);
 
 void copyMpdTagToMetadataChunk(MpdTag * tag, MetadataChunk * chunk);
 

src/mpd_types.h

@@ -21,23 +21,23 @@
 
 #include "../config.h"
 
-typedef unsigned char	mpd_uint8;
-typedef signed char	mpd_sint8;
+typedef unsigned char mpd_uint8;
+typedef signed char mpd_sint8;
 
 #if SIZEOF_SHORT == 2
-typedef unsigned short 	mpd_uint16;
-typedef signed short	mpd_sint16;
+typedef unsigned short mpd_uint16;
+typedef signed short mpd_sint16;
 #elif SIZEOF_INT == 2
-typedef unsigned int 	mpd_uint16;
-typedef signed int	mpd_sint16;
+typedef unsigned int mpd_uint16;
+typedef signed int mpd_sint16;
 #endif
 
 #if SIZEOF_INT == 4
-typedef unsigned int 	mpd_uint32;
-typedef signed int	mpd_sint32;
+typedef unsigned int mpd_uint32;
+typedef signed int mpd_sint32;
 #elif SIZEOF_LONG == 4
-typedef unsigned long 	mpd_uint32;
-typedef signed long	mpd_sint32;
+typedef unsigned long mpd_uint32;
+typedef signed long mpd_sint32;
 #endif
 
 #endif

src/myfprintf.c

@@ -33,19 +33,21 @@
 #define BUFFER_LENGTH	MAXPATHLEN+1024
 
 static int myfprintf_stdLogMode = 0;
-static FILE * myfprintf_out;
-static FILE * myfprintf_err;
-static char * myfprintf_outFilename;
-static char * myfprintf_errFilename;
+static FILE *myfprintf_out;
+static FILE *myfprintf_err;
+static char *myfprintf_outFilename;
+static char *myfprintf_errFilename;
 
-static void blockingWrite(int fd, char * string, int len) {
+static void blockingWrite(int fd, char *string, int len)
+{
 	int ret;
 
-	while(len) {
-		ret = write(fd,string,len);
-		if(ret==0) return;
-		if(ret<0) {
-			switch(errno) {
+	while (len) {
+		ret = write(fd, string, len);
+		if (ret == 0)
+			return;
+		if (ret < 0) {
+			switch (errno) {
 			case EAGAIN:
 			case EINTR:
 				continue;
@@ -53,77 +55,82 @@ static void blockingWrite(int fd, char * string, int len) {
 				return;
 			}
 		}
-		len-= ret;
-		string+= ret;
+		len -= ret;
+		string += ret;
 	}
 }
 
-void myfprintfStdLogMode(FILE * out, FILE * err) {
+void myfprintfStdLogMode(FILE * out, FILE * err)
+{
 	myfprintf_stdLogMode = 1;
 	myfprintf_out = out;
 	myfprintf_err = err;
-        myfprintf_outFilename = getConfigParamValue(CONF_LOG_FILE);
-        myfprintf_errFilename = getConfigParamValue(CONF_ERROR_FILE);
+	myfprintf_outFilename = getConfigParamValue(CONF_LOG_FILE);
+	myfprintf_errFilename = getConfigParamValue(CONF_ERROR_FILE);
 }
 
-void myfprintf(FILE * fp, char * format, ... ) {
-	static char buffer[BUFFER_LENGTH+1];
+void myfprintf(FILE * fp, char *format, ...)
+{
+	static char buffer[BUFFER_LENGTH + 1];
 	va_list arglist;
 	int fd = fileno(fp);
 
-	va_start(arglist,format);
-	if(fd==1 || fd==2) {
-		if(myfprintf_stdLogMode) {
+	va_start(arglist, format);
+	if (fd == 1 || fd == 2) {
+		if (myfprintf_stdLogMode) {
 			time_t t = time(NULL);
-			if(fd==1) fp = myfprintf_out;
-			else fp = myfprintf_err;
-			strftime(buffer,14,"%b %e %R",localtime(&t));
-			blockingWrite(fd,buffer,strlen(buffer));
-			blockingWrite(fd," : ",3);
+			if (fd == 1)
+				fp = myfprintf_out;
+			else
+				fp = myfprintf_err;
+			strftime(buffer, 14, "%b %e %R", localtime(&t));
+			blockingWrite(fd, buffer, strlen(buffer));
+			blockingWrite(fd, " : ", 3);
 		}
-		vsnprintf(buffer,BUFFER_LENGTH,format,arglist);
-		blockingWrite(fd,buffer,strlen(buffer));
-	}
-	else {
+		vsnprintf(buffer, BUFFER_LENGTH, format, arglist);
+		blockingWrite(fd, buffer, strlen(buffer));
+	} else {
 		int len;
-		vsnprintf(buffer,BUFFER_LENGTH,format,arglist);
+		vsnprintf(buffer, BUFFER_LENGTH, format, arglist);
 		len = strlen(buffer);
-		if(interfacePrintWithFD(fd,buffer,len)<0) {
-			blockingWrite(fd,buffer,len);
+		if (interfacePrintWithFD(fd, buffer, len) < 0) {
+			blockingWrite(fd, buffer, len);
 		}
 	}
 
 	va_end(arglist);
 }
 
-int myfprintfCloseAndOpenLogFile(void) {
-        if(myfprintf_stdLogMode) {
-                while(fclose(myfprintf_out)<0 && errno==EINTR);
-                while(fclose(myfprintf_err)<0 && errno==EINTR);
-                while((myfprintf_out = fopen(myfprintf_outFilename,"a+"))==NULL
-                                && errno==EINTR);
-                if(!myfprintf_out) {
-                        ERROR("error re-opening log file: %s\n",
-                                myfprintf_out);
-                        return -1;
-                }
-                while((myfprintf_err = fopen(myfprintf_errFilename,"a+"))==NULL
-                                && errno==EINTR);
-                if(!myfprintf_out) {
-                        ERROR("error re-opening log file: %s\n",
-                                myfprintf_out);
-                        return -1;
-                }
-                while(dup2(fileno(myfprintf_out),1)<0 && errno==EINTR);
-                while(dup2(fileno(myfprintf_err),2)<0 && errno==EINTR);
-        }
+int myfprintfCloseAndOpenLogFile(void)
+{
+	if (myfprintf_stdLogMode) {
+		while (fclose(myfprintf_out) < 0 && errno == EINTR) ;
+		while (fclose(myfprintf_err) < 0 && errno == EINTR) ;
+		while ((myfprintf_out =
+			fopen(myfprintf_outFilename, "a+")) == NULL
+		       && errno == EINTR) ;
+		if (!myfprintf_out) {
+			ERROR("error re-opening log file: %s\n", myfprintf_out);
+			return -1;
+		}
+		while ((myfprintf_err =
+			fopen(myfprintf_errFilename, "a+")) == NULL
+		       && errno == EINTR) ;
+		if (!myfprintf_out) {
+			ERROR("error re-opening log file: %s\n", myfprintf_out);
+			return -1;
+		}
+		while (dup2(fileno(myfprintf_out), 1) < 0 && errno == EINTR) ;
+		while (dup2(fileno(myfprintf_err), 2) < 0 && errno == EINTR) ;
+	}
 
-        return 0;
+	return 0;
 }
 
-void myfprintfCloseLogFile(void) {
-        if(myfprintf_stdLogMode) {
-                while(fclose(myfprintf_out)<0 && errno==EINTR);
-                while(fclose(myfprintf_err)<0 && errno==EINTR);
+void myfprintfCloseLogFile(void)
+{
+	if (myfprintf_stdLogMode) {
+		while (fclose(myfprintf_out) < 0 && errno == EINTR) ;
+		while (fclose(myfprintf_err) < 0 && errno == EINTR) ;
 	}
 }

src/myfprintf.h

@@ -25,7 +25,7 @@
 
 void myfprintfStdLogMode(FILE * out, FILE * err);
 
-void myfprintf(FILE * fp, char * format, ... );
+void myfprintf(FILE * fp, char *format, ...);
 
 int myfprintfCloseAndOpenLogFile();
 

src/outputBuffer.c

@@ -30,149 +30,156 @@ static mpd_sint16 currentChunk = -1;
 static mpd_sint8 currentMetaChunk = -1;
 static mpd_sint8 sendMetaChunk = 0;
 
-void clearAllMetaChunkSets(OutputBuffer * cb) {
+void clearAllMetaChunkSets(OutputBuffer * cb)
+{
 	memset(cb->metaChunkSet, 0, BUFFERED_METACHUNKS);
 }
 
-void clearOutputBuffer(OutputBuffer * cb) {
+void clearOutputBuffer(OutputBuffer * cb)
+{
 	int currentSet = 1;
 
-        currentChunk = -1;
-        cb->end = cb->begin;
+	currentChunk = -1;
+	cb->end = cb->begin;
 
 	/* be sure to reset metaChunkSets cause we are skipping over audio
-         * audio chunks, and thus skipping over metadata */
-	if(sendMetaChunk == 0 && currentMetaChunk >= 0) {
+	 * audio chunks, and thus skipping over metadata */
+	if (sendMetaChunk == 0 && currentMetaChunk >= 0) {
 		currentSet = cb->metaChunkSet[currentChunk];
 	}
 	clearAllMetaChunkSets(cb);
-	if(sendMetaChunk == 0 && currentMetaChunk >= 0) {
+	if (sendMetaChunk == 0 && currentMetaChunk >= 0) {
 		cb->metaChunkSet[currentChunk] = currentSet;
 	}
 }
 
-void flushOutputBuffer(OutputBuffer * cb) {
-	if(currentChunk == cb->end) {
-	        int next = cb->end+1;
-	        if(next>=buffered_chunks) {
-		       	next = 0;
-	        }
+void flushOutputBuffer(OutputBuffer * cb)
+{
+	if (currentChunk == cb->end) {
+		int next = cb->end + 1;
+		if (next >= buffered_chunks) {
+			next = 0;
+		}
 		cb->end = next;
 		currentChunk = -1;
 	}
 }
 
-int sendDataToOutputBuffer(OutputBuffer * cb, InputStream * inStream,  
-                DecoderControl * dc, int seekable, void * dataIn, 
-                long dataInLen, float time, mpd_uint16 bitRate,
-		ReplayGainInfo * replayGainInfo)
+int sendDataToOutputBuffer(OutputBuffer * cb, InputStream * inStream,
+			   DecoderControl * dc, int seekable, void *dataIn,
+			   long dataInLen, float time, mpd_uint16 bitRate,
+			   ReplayGainInfo * replayGainInfo)
 {
-        mpd_uint16 dataToSend;
+	mpd_uint16 dataToSend;
 	mpd_uint16 chunkLeft;
-	char * data;
+	char *data;
 	size_t datalen;
-	static char * convBuffer = NULL;
+	static char *convBuffer = NULL;
 	static long convBufferLen = 0;
 
-	if(cmpAudioFormat(&(cb->audioFormat),&(dc->audioFormat))==0)
-	{
+	if (cmpAudioFormat(&(cb->audioFormat), &(dc->audioFormat)) == 0) {
 		data = dataIn;
 		datalen = dataInLen;
-	}
-	else {
-		datalen = pcm_sizeOfOutputBufferForAudioFormatConversion(
-				&(dc->audioFormat), dataInLen,
-				&(cb->audioFormat));
-		if(datalen > convBufferLen) {
-			convBuffer = realloc(convBuffer,datalen);
+	} else {
+		datalen =
+		    pcm_sizeOfOutputBufferForAudioFormatConversion(&
+								   (dc->
+								    audioFormat),
+								   dataInLen,
+								   &(cb->
+								     audioFormat));
+		if (datalen > convBufferLen) {
+			convBuffer = realloc(convBuffer, datalen);
 			convBufferLen = datalen;
 		}
 		data = convBuffer;
 		pcm_convertAudioFormat(&(dc->audioFormat), dataIn, dataInLen,
-				&(cb->audioFormat),data);
+				       &(cb->audioFormat), data);
 	}
 
-	if(replayGainInfo) {
+	if (replayGainInfo) {
 		doReplayGain(replayGainInfo, data, datalen, &cb->audioFormat);
 	}
 
-        while(datalen) {
-		if(currentChunk != cb->end) {
-	        	int next = cb->end+1;
-	        	if(next>=buffered_chunks) {
-		       		next = 0;
-	        	}
-	        	while(cb->begin==next && !dc->stop) {
-                                if(dc->seek) {
-                                        if(seekable) {
-                                                return OUTPUT_BUFFER_DC_SEEK;
-                                        }
-                                        else {
-                                                dc->seekError = 1;
-                                                dc->seek = 0;
-                                        }
-                                }
-                                if(!inStream || 
-                                        bufferInputStream(inStream) <= 0)
-                                {
-		        	        my_usleep(10000);
-                                }
+	while (datalen) {
+		if (currentChunk != cb->end) {
+			int next = cb->end + 1;
+			if (next >= buffered_chunks) {
+				next = 0;
 			}
-	        	if(dc->stop) return OUTPUT_BUFFER_DC_STOP;
+			while (cb->begin == next && !dc->stop) {
+				if (dc->seek) {
+					if (seekable) {
+						return OUTPUT_BUFFER_DC_SEEK;
+					} else {
+						dc->seekError = 1;
+						dc->seek = 0;
+					}
+				}
+				if (!inStream ||
+				    bufferInputStream(inStream) <= 0) {
+					my_usleep(10000);
+				}
+			}
+			if (dc->stop)
+				return OUTPUT_BUFFER_DC_STOP;
 
 			currentChunk = cb->end;
 			cb->chunkSize[currentChunk] = 0;
 
-			if(sendMetaChunk) {
+			if (sendMetaChunk) {
 				cb->metaChunk[currentChunk] = currentMetaChunk;
-			}
-			else cb->metaChunk[currentChunk] = -1;
-	        	cb->bitRate[currentChunk] = bitRate;
-	        	cb->times[currentChunk] = time;
+			} else
+				cb->metaChunk[currentChunk] = -1;
+			cb->bitRate[currentChunk] = bitRate;
+			cb->times[currentChunk] = time;
 		}
 
-		chunkLeft = CHUNK_SIZE-cb->chunkSize[currentChunk];
-                dataToSend = datalen > chunkLeft ? chunkLeft : datalen;
+		chunkLeft = CHUNK_SIZE - cb->chunkSize[currentChunk];
+		dataToSend = datalen > chunkLeft ? chunkLeft : datalen;
 
-	        memcpy(cb->chunks+currentChunk*CHUNK_SIZE+
-			cb->chunkSize[currentChunk],
-			data, dataToSend);
-	        cb->chunkSize[currentChunk]+= dataToSend;
-                datalen-= dataToSend;
-                data+= dataToSend;
+		memcpy(cb->chunks + currentChunk * CHUNK_SIZE +
+		       cb->chunkSize[currentChunk], data, dataToSend);
+		cb->chunkSize[currentChunk] += dataToSend;
+		datalen -= dataToSend;
+		data += dataToSend;
 
-		if(cb->chunkSize[currentChunk] == CHUNK_SIZE) {
+		if (cb->chunkSize[currentChunk] == CHUNK_SIZE) {
 			flushOutputBuffer(cb);
 		}
-        }
+	}
 
 	return 0;
 }
 
-int copyMpdTagToOutputBuffer(OutputBuffer * cb, MpdTag * tag) {
+int copyMpdTagToOutputBuffer(OutputBuffer * cb, MpdTag * tag)
+{
 	int nextChunk;
-	static MpdTag * last = NULL;
+	static MpdTag *last = NULL;
 
-        if(!cb->acceptMetadata || !tag) {
+	if (!cb->acceptMetadata || !tag) {
 		sendMetaChunk = 0;
-		if(last) freeMpdTag(last);
+		if (last)
+			freeMpdTag(last);
 		last = NULL;
 		DEBUG("copyMpdTagToOB: !acceptMetadata || !tag\n");
 		return 0;
 	}
 
-	if(last && mpdTagsAreEqual(last, tag)) {
+	if (last && mpdTagsAreEqual(last, tag)) {
 		DEBUG("copyMpdTagToOB: same as last\n");
 		return 0;
 	}
 
-	if(last) freeMpdTag(last);
+	if (last)
+		freeMpdTag(last);
 	last = NULL;
 
-	nextChunk = currentMetaChunk+1;
-	if(nextChunk >= BUFFERED_METACHUNKS) nextChunk = 0;
+	nextChunk = currentMetaChunk + 1;
+	if (nextChunk >= BUFFERED_METACHUNKS)
+		nextChunk = 0;
 
-	if(cb->metaChunkSet[nextChunk]) {
+	if (cb->metaChunkSet[nextChunk]) {
 		sendMetaChunk = 0;
 		DEBUG("copyMpdTagToOB: metachunk in use!\n");
 		return -1;

src/outputBuffer.h

@@ -32,16 +32,16 @@
 #define BUFFERED_METACHUNKS	25
 
 typedef struct _OutputBuffer {
-	char * volatile chunks;
-	mpd_uint16 * volatile chunkSize;
-	mpd_uint16 * volatile bitRate;
-	float * volatile times;
+	char *volatile chunks;
+	mpd_uint16 *volatile chunkSize;
+	mpd_uint16 *volatile bitRate;
+	float *volatile times;
 	mpd_sint16 volatile begin;
 	mpd_sint16 volatile end;
-        AudioFormat audioFormat;
+	AudioFormat audioFormat;
 	MetadataChunk metadataChunks[BUFFERED_METACHUNKS];
 	mpd_sint8 metaChunkSet[BUFFERED_METACHUNKS];
-	mpd_sint8 * volatile metaChunk;
+	mpd_sint8 *volatile metaChunk;
 	volatile mpd_sint8 acceptMetadata;
 } OutputBuffer;
 
@@ -51,16 +51,14 @@ void flushOutputBuffer(OutputBuffer * cb);
 
 /* we send inStream for buffering the inputStream while waiting to
    send the next chunk */
-int sendDataToOutputBuffer(
-		OutputBuffer * cb, 
-		InputStream * inStream,
-                DecoderControl * dc, 
-		int seekable, 
-		void * data, 
-		long datalen, 
-                float time, 
-		mpd_uint16 bitRate, 
-		ReplayGainInfo * replayGainInfo);
+int sendDataToOutputBuffer(OutputBuffer * cb,
+			   InputStream * inStream,
+			   DecoderControl * dc,
+			   int seekable,
+			   void *data,
+			   long datalen,
+			   float time,
+			   mpd_uint16 bitRate, ReplayGainInfo * replayGainInfo);
 
 int copyMpdTagToOutputBuffer(OutputBuffer * cb, MpdTag * tag);
 

src/path.c

@@ -37,23 +37,25 @@
 #endif
 #endif
 
-char * musicDir;
-char * playlistDir;
+char *musicDir;
+char *playlistDir;
 
-char * fsCharset = NULL;
+char *fsCharset = NULL;
 
-static char * pathConvCharset(char * to, char * from, char * str) {
-	if(setCharSetConversion(to,from)==0) {
+static char *pathConvCharset(char *to, char *from, char *str)
+{
+	if (setCharSetConversion(to, from) == 0) {
 		return convStrDup(str);
 	}
 
 	return NULL;
 }
 
-char * fsCharsetToUtf8(char * str) {
-	char * ret = pathConvCharset("UTF-8",fsCharset,str);
+char *fsCharsetToUtf8(char *str)
+{
+	char *ret = pathConvCharset("UTF-8", fsCharset, str);
 
-	if(ret && !validUtf8String(ret)) {
+	if (ret && !validUtf8String(ret)) {
 		free(ret);
 		ret = NULL;
 	}
@@ -61,54 +63,60 @@ char * fsCharsetToUtf8(char * str) {
 	return ret;
 }
 
-char * utf8ToFsCharset(char * str) {
-	char * ret = pathConvCharset(fsCharset,"UTF-8",str);
+char *utf8ToFsCharset(char *str)
+{
+	char *ret = pathConvCharset(fsCharset, "UTF-8", str);
 
-	if(!ret) ret = strdup(str);
+	if (!ret)
+		ret = strdup(str);
 
 	return ret;
 }
 
-void setFsCharset(char * charset) {
+void setFsCharset(char *charset)
+{
 	int error = 0;
 
-	if(fsCharset) free(fsCharset);
+	if (fsCharset)
+		free(fsCharset);
 
 	fsCharset = strdup(charset);
 
-	DEBUG("setFsCharset: fs charset is: %s\n",fsCharset);
-	
-	if(setCharSetConversion("UTF-8",fsCharset)!=0) {
+	DEBUG("setFsCharset: fs charset is: %s\n", fsCharset);
+
+	if (setCharSetConversion("UTF-8", fsCharset) != 0) {
 		WARNING("fs charset conversion problem: "
 			"not able to convert from \"%s\" to \"%s\"\n",
-			fsCharset,"UTF-8");
+			fsCharset, "UTF-8");
 		error = 1;
 	}
-	if(setCharSetConversion(fsCharset,"UTF-8")!=0) {
+	if (setCharSetConversion(fsCharset, "UTF-8") != 0) {
 		WARNING("fs charset conversion problem: "
 			"not able to convert from \"%s\" to \"%s\"\n",
-			"UTF-8",fsCharset);
+			"UTF-8", fsCharset);
 		error = 1;
 	}
-	
-	if(error) {
+
+	if (error) {
 		free(fsCharset);
 		WARNING("setting fs charset to ISO-8859-1!\n");
 		fsCharset = strdup("ISO-8859-1");
 	}
 }
 
-char * getFsCharset(void) {
+char *getFsCharset(void)
+{
 	return fsCharset;
 }
 
-static char * appendSlash(char ** path) {
-	char * temp = *path;
+static char *appendSlash(char **path)
+{
+	char *temp = *path;
 	int len = strlen(temp);
 
-	if(temp[len-1] != '/') {
-		temp = malloc(len+2);
-		memset(temp, 0, len+2);
+	if (temp[len - 1] != '/') {
+		temp = malloc(len + 2);
+		memset(temp, 0, len + 2);
 		memcpy(temp, *path, len);
 		temp[len] = '/';
 		free(*path);
@@ -118,160 +126,165 @@ static char * appendSlash(char ** path) {
 	return temp;
 }
 
-void initPaths(void) {
-	ConfigParam * musicParam = parseConfigFilePath(CONF_MUSIC_DIR, 1);
-	ConfigParam * playlistParam = parseConfigFilePath(CONF_PLAYLIST_DIR, 1);
-        ConfigParam * fsCharsetParam = getConfigParam(CONF_FS_CHARSET);
+void initPaths(void)
+{
+	ConfigParam *musicParam = parseConfigFilePath(CONF_MUSIC_DIR, 1);
+	ConfigParam *playlistParam = parseConfigFilePath(CONF_PLAYLIST_DIR, 1);
+	ConfigParam *fsCharsetParam = getConfigParam(CONF_FS_CHARSET);
 
-	char * charset = NULL;
-	char * originalLocale;
-	DIR * dir;
+	char *charset = NULL;
+	char *originalLocale;
+	DIR *dir;
 
 	musicDir = appendSlash(&(musicParam->value));
 	playlistDir = appendSlash(&(playlistParam->value));
 
-        if((dir = opendir(playlistDir)) == NULL) {
-                ERROR("cannot open %s \"%s\" (config line %i): %s\n", 
-				CONF_PLAYLIST_DIR, playlistParam->value, 
-				playlistParam->line, strerror(errno));
-                exit(EXIT_FAILURE);
-        }
+	if ((dir = opendir(playlistDir)) == NULL) {
+		ERROR("cannot open %s \"%s\" (config line %i): %s\n",
+		      CONF_PLAYLIST_DIR, playlistParam->value,
+		      playlistParam->line, strerror(errno));
+		exit(EXIT_FAILURE);
+	}
 	closedir(dir);
 
-        if((dir = opendir(musicDir)) == NULL) {
-                ERROR("cannot open %s \"%s\" (config line %i): %s\n", 
-				CONF_MUSIC_DIR, musicParam->value, 
-				musicParam->line, strerror(errno));
-                exit(EXIT_FAILURE);
-        }
+	if ((dir = opendir(musicDir)) == NULL) {
+		ERROR("cannot open %s \"%s\" (config line %i): %s\n",
+		      CONF_MUSIC_DIR, musicParam->value,
+		      musicParam->line, strerror(errno));
+		exit(EXIT_FAILURE);
+	}
 	closedir(dir);
 
-	if(fsCharsetParam) {
+	if (fsCharsetParam) {
 		charset = strdup(fsCharsetParam->value);
 	}
 #ifdef HAVE_LOCALE
 #ifdef HAVE_LANGINFO_CODESET
-	else if((originalLocale = setlocale(LC_CTYPE,NULL))) {
-		char * temp;
-		char * currentLocale;
+	else if ((originalLocale = setlocale(LC_CTYPE, NULL))) {
+		char *temp;
+		char *currentLocale;
 		originalLocale = strdup(originalLocale);
 
-		if(!(currentLocale = setlocale(LC_CTYPE,""))) {
+		if (!(currentLocale = setlocale(LC_CTYPE, ""))) {
 			WARNING("problems setting current locale with "
-					"setlocale()\n");
-		}
-		else {
-			if(strcmp(currentLocale,"C")==0 ||
-					strcmp(currentLocale,"POSIX")==0) 
-			{
+				"setlocale()\n");
+		} else {
+			if (strcmp(currentLocale, "C") == 0 ||
+			    strcmp(currentLocale, "POSIX") == 0) {
 				WARNING("current locale is \"%s\"\n",
-						currentLocale);
-			}
-			else if((temp = nl_langinfo(CODESET))) {
+					currentLocale);
+			} else if ((temp = nl_langinfo(CODESET))) {
 				charset = strdup(temp);
-			}
-			else WARNING("problems getting charset for locale\n");
-			if(!setlocale(LC_CTYPE,originalLocale)) {
-				WARNING("problems resetting locale with setlocale()\n");
+			} else
+				WARNING
+				    ("problems getting charset for locale\n");
+			if (!setlocale(LC_CTYPE, originalLocale)) {
+				WARNING
+				    ("problems resetting locale with setlocale()\n");
 			}
 		}
 
 		free(originalLocale);
-	}
-	else WARNING("problems getting locale with setlocale()\n");
+	} else
+		WARNING("problems getting locale with setlocale()\n");
 #endif
 #endif
 
-	if(charset) {
+	if (charset) {
 		setFsCharset(charset);
 		free(charset);
-	}
-	else {
+	} else {
 		WARNING("setting filesystem charset to ISO-8859-1\n");
 		setFsCharset("ISO-8859-1");
 	}
 }
 
-void finishPaths(void) {
+void finishPaths(void)
+{
 	free(fsCharset);
 	fsCharset = NULL;
 }
 
-char * rmp2amp(char * relativePath) {
-	static char absolutePath[MAXPATHLEN+1];
+char *rmp2amp(char *relativePath)
+{
+	static char absolutePath[MAXPATHLEN + 1];
 
-	memset(absolutePath,0,MAXPATHLEN+1);
+	memset(absolutePath, 0, MAXPATHLEN + 1);
 
-	strncpy(absolutePath,musicDir,MAXPATHLEN);
-	strncat(absolutePath,relativePath,MAXPATHLEN-strlen(musicDir));
+	strncpy(absolutePath, musicDir, MAXPATHLEN);
+	strncat(absolutePath, relativePath, MAXPATHLEN - strlen(musicDir));
 
 	return absolutePath;
 }
 
-char * rpp2app(char * relativePath) {
-	static char absolutePath[MAXPATHLEN+1];
+char *rpp2app(char *relativePath)
+{
+	static char absolutePath[MAXPATHLEN + 1];
 
-	memset(absolutePath,0,MAXPATHLEN+1);
+	memset(absolutePath, 0, MAXPATHLEN + 1);
 
-	strncpy(absolutePath,playlistDir,MAXPATHLEN);
-	strncat(absolutePath,relativePath,MAXPATHLEN-strlen(musicDir));
+	strncpy(absolutePath, playlistDir, MAXPATHLEN);
+	strncat(absolutePath, relativePath, MAXPATHLEN - strlen(musicDir));
 
 	return absolutePath;
 }
 
-char * parentPath(char * path) {
-	static char parentPath[MAXPATHLEN+1];
-	char * c;
+char *parentPath(char *path)
+{
+	static char parentPath[MAXPATHLEN + 1];
+	char *c;
 
-	memset(parentPath,0,MAXPATHLEN+1);
-	strncpy(parentPath,path,MAXPATHLEN);
-	
-	c = strrchr(parentPath,'/');
+	memset(parentPath, 0, MAXPATHLEN + 1);
+	strncpy(parentPath, path, MAXPATHLEN);
+
+	c = strrchr(parentPath, '/');
 	if (c == NULL)
 		parentPath[0] = '\0';
 	else {
-		while ((parentPath <= c) && *(--c) == '/') /* nothing */;
+		while ((parentPath <= c) && *(--c) == '/')	/* nothing */
+			;
 		c[1] = '\0';
- 	}
+	}
 
 	return parentPath;
 }
 
-char * sanitizePathDup(char * path) {
-	int len = strlen(path)+1;
-	char * ret = malloc(len);
-	char * cp = ret;
+char *sanitizePathDup(char *path)
+{
+	int len = strlen(path) + 1;
+	char *ret = malloc(len);
+	char *cp = ret;
 
-	memset(ret,0,len);
+	memset(ret, 0, len);
 
 	len = 0;
 
 	/* illeminate more than one '/' in a row, like "///" */
-	while(*path) {
-		while(*path=='/') path++;
-		if(*path=='.') {
+	while (*path) {
+		while (*path == '/')
+			path++;
+		if (*path == '.') {
 			/* we dont want to have hidden directoires, or '.' or
 			   ".." in our path */
 			free(ret);
 			return NULL;
 		}
-		while(*path && *path!='/') {
+		while (*path && *path != '/') {
 			*(cp++) = *(path++);
 			len++;
 		}
-		if(*path=='/') {
+		if (*path == '/') {
 			*(cp++) = *(path++);
 			len++;
 		}
 	}
 
-	if(len && ret[len-1]=='/') {
+	if (len && ret[len - 1] == '/') {
 		len--;
 		ret[len] = '\0';
 	}
 
 	DEBUG("sanitized: %s\n", ret);
 
-	return realloc(ret,len+1);
+	return realloc(ret, len + 1);
 }
-