示例#1
0
void audioPlayNote(U8 note)
{
	int fifospaceR,fifospaceL;
	U16 toWriteNbL=100,toWriteNbR=100;


	if(audioOutLIndex>=zMax[note])
		audioOutLIndex=0;

	if(audioOutRIndex>=zMax[note])
		audioOutRIndex=0;

	if((zMax[note]-audioOutLIndex)<100)
		toWriteNbL=zMax[note]-audioOutLIndex;

	if((zMax[note]-audioOutRIndex)<100)
		toWriteNbR=zMax[note]-audioOutRIndex;

	fifospaceR = (IORD_ALT_UP_AUDIO_FIFOSPACE(audio_dev->base)& ALT_UP_AUDIO_FIFOSPACE_WSRC_MSK) >> ALT_UP_AUDIO_FIFOSPACE_WSRC_OFST;
	fifospaceL = (IORD_ALT_UP_AUDIO_FIFOSPACE(audio_dev->base)& ALT_UP_AUDIO_FIFOSPACE_WSLC_MSK) >> ALT_UP_AUDIO_FIFOSPACE_WSLC_OFST;

	if(fifospaceL > toWriteNbL)
	{
		alt_up_audio_write_fifo(audio_dev,&audioYout[note][audioOutLIndex],toWriteNbL, ALT_UP_AUDIO_LEFT);
		audioOutLIndex+=toWriteNbL;
	}
	if(fifospaceR > toWriteNbR)
	{
		alt_up_audio_write_fifo(audio_dev,&audioYout[note][audioOutRIndex],toWriteNbR, ALT_UP_AUDIO_RIGHT);
		audioOutRIndex+=toWriteNbR;
	}
}
示例#2
0
int main()
{
	int main(void)
	{
	alt_up_audio_dev * audio_dev;
	/* used for audio record/playback */
	unsigned int l_buf;
	unsigned int r_buf;
	// open the Audio port
	audio_dev = alt_up_audio_open_dev ("/dev/Audio");
	if ( audio_dev == NULL)
	alt_printf ("Error: could not open audio device \n");
	else
	alt_printf ("Opened audio device \n");
	/* read and echo audio data */
	while(1)
	{
	int fifospace = alt_up_audio_read_fifo_avail (audio_dev, ALT_UP_AUDIO_RIGHT);
	if ( fifospace > 0 ) // check if data is available
	{
	// read audio buffer
	alt_up_audio_read_fifo (audio_dev, &(r_buf), 1, ALT_UP_AUDIO_RIGHT);
	alt_up_audio_read_fifo (audio_dev, &(l_buf), 1, ALT_UP_AUDIO_LEFT);
	// write audio buffer
	alt_up_audio_write_fifo (audio_dev, &(r_buf), 1, ALT_UP_AUDIO_RIGHT);
	alt_up_audio_write_fifo (audio_dev, &(l_buf), 1, ALT_UP_AUDIO_LEFT);
	}
	}
	}
示例#3
0
/*
 * Overview: This plays the boom sound when the tanks are hit
 *
 */
void play_doh(alt_up_audio_dev *audio, unsigned int *buffer, short int handle)
{

	int lbytes;
	int rbytes;
	int lindex=22;
	int rindex=22;
	alt_up_audio_dev* aud=audio;
	int i=0;


	while(i<DOH_LENGTH) //200 for cha ching
	{
		if (alt_up_audio_write_fifo_space(audio, ALT_UP_AUDIO_LEFT) > 22)
		{
			lbytes = alt_up_audio_write_fifo(aud, &buffer[lindex], 96, ALT_UP_AUDIO_LEFT);
			rbytes = alt_up_audio_write_fifo(aud, &buffer[rindex], 96, ALT_UP_AUDIO_RIGHT);
			lindex += lbytes;
			rindex += rbytes;
			i++;
		}

	}
	//printf("all good things come to an end\n");
	alt_up_sd_card_fclose(handle);
}
示例#4
0
void lose_isr(void* context, alt_u32 id)
{
	// FIFO is 75% empty, need to fill it up
	int sample_counter;
	for (sample_counter = 0; sample_counter < SAMPLE_SIZE; sample_counter++)
	{
		// take 2 bytes at a time
		byte_data[0] = lose_data[sound_data_counter];
		byte_data[1] = lose_data[sound_data_counter+1];
		sound_data_counter += 2;

		// combine the two bytes and store into sample buffer
		sound_buff[sample_counter] = (byte_data[1] << 8) | byte_data[0];

		// if we finish reading our data buffer, then we loop back to start over
		if (sound_data_counter >= LOSE_SIZE)
		{
			sound_data_counter = 0;
			alt_up_audio_disable_write_interrupt(audio_dev);
		}
	}
	// finally, we write this sample data to the FIFO
	alt_up_audio_write_fifo(audio_dev, sound_buff, SAMPLE_SIZE, ALT_UP_AUDIO_LEFT);
	alt_up_audio_write_fifo(audio_dev, sound_buff, SAMPLE_SIZE, ALT_UP_AUDIO_RIGHT);
}
示例#5
0
void audio_ISR() {
	alt_up_audio_write_fifo(audio, &audio_stream[stream_position], BUFFER_SIZE, ALT_UP_AUDIO_LEFT);
	alt_up_audio_write_fifo(audio, &audio_stream[stream_position], BUFFER_SIZE, ALT_UP_AUDIO_RIGHT);
	stream_position += BUFFER_SIZE;
	if (stream_position >= song_size - BUFFER_SIZE) {
		stream_position = 0;
	}
}
示例#6
0
// Requires:
// Effects: Plays an audio .wav file, blocking the CPU until the song has completed.
int playBlockingMusic(char* audioFile)
{
	int i = 0;
	int currentSample = 0;
	unsigned int *sample;

	file_handle fileHandle = open_file(audioFile, false);

	if (fileHandle < 0) {
		printf("Reading file failed \n");
		return AUDIO_ERROR;
	}

	int fileLength = findWavSize(fileHandle);

	// Allocate a buffer that is the same byte size as the file
	unsigned int *buf = (unsigned int*) malloc(fileLength * 2);

	int bufSize = fileLength/2;

	for (i = 0; i < bufSize; i++)
	{
		// Extract data and store in the buf.
		unsigned char firstByte = read_file(fileHandle);
		unsigned char secondByte = read_file(fileHandle);
		unsigned short val = (secondByte << 8) | firstByte;
		buf[i] = val;
	}

	// Close the file on the sd card.
	alt_up_sd_card_fclose(fileHandle);

	while (currentSample < bufSize)
	{
		unsigned int space = alt_up_audio_write_fifo_space(audio, ALT_UP_AUDIO_RIGHT);

		if (space > bufSize - currentSample)
		{
			// Don't need to fully fill the rest of the buffer.
			space = bufSize - currentSample;
		}

		if (space > 0)
		{
			sample = &(buf[currentSample]);
			alt_up_audio_write_fifo(audio, sample, space, ALT_UP_AUDIO_LEFT);
			alt_up_audio_write_fifo(audio, sample, space, ALT_UP_AUDIO_RIGHT);
			currentSample += space;
		}
	}

	free(buf);
	return 0;
}
示例#7
0
void swapInSound(int* buf, int len)
{
	if (bufSizeSwap == 0)
	{
		musicSwapBuffer = interruptMusicBuffer;
		bufSizeSwap = interruptBufSize;
		swapSample = interruptSample;
		swapLoop = musicLoop;
		swapDone = musicDone;

		interruptMusicBuffer = buf;
		interruptBufSize = len;
		interruptSample = 0;
		musicLoop = 0;
		musicDone = 0;

		unsigned int space = alt_up_audio_write_fifo_space(audio, ALT_UP_AUDIO_RIGHT);
		unsigned int* sample;

		if (space > interruptBufSize - interruptSample)
		{
			// Don't need to fully fill the rest of the buffer.
			space = interruptBufSize - interruptSample;
		}

		if (space > 0)
		{
			sample = &(interruptMusicBuffer[interruptSample]);
			alt_up_audio_write_fifo(audio, sample, space, ALT_UP_AUDIO_LEFT);
			alt_up_audio_write_fifo(audio, sample, space, ALT_UP_AUDIO_RIGHT);
			interruptSample += space;
		}

		if (interruptSample >= interruptBufSize)
		{
			if (musicLoop)
			{
				interruptSample = 0;
				alt_up_audio_enable_write_interrupt(audio);
			}
		}
		else
		{
			printf("Enabling interrupt.");
			// Enable the write interrupt
			alt_up_audio_enable_write_interrupt(audio);
		}
	}
}
/* Checks if the write FIFO for the left channel has at least BUF_THRESHOLD space available.
 * If it doesn't, then just returns 0. If it does, then data from buf is written into the 
 * FIFO, up to a maximum of len words.
 */
unsigned int alt_up_audio_play_l(alt_up_audio_dev *audio, unsigned int *buf, int len)
{
	unsigned int space = alt_up_audio_write_fifo_space (audio, ALT_UP_AUDIO_LEFT);
	if (space <= BUF_THRESHOLD)
		return 0;
	else
		return (alt_up_audio_write_fifo(audio, buf, len, ALT_UP_AUDIO_LEFT));
}
示例#9
0
/***************************************************************************************
 * Audio - Interrupt Service Routine
 *
 * This interrupt service routine records or plays back audio, depending on which type
 * interrupt (read or write) is pending in the audio device.
****************************************************************************************/
void audio_ISR(alt_up_audio_dev* audio_dev, unsigned int id)
{
	if (alt_up_audio_write_interrupt_pending(audio_dev))	// check for write interrupt
	{
		//int numToWrite = 0;
		//int spaceAvailable = alt_up_audio_write_fifo_space(audio_dev, ALT_UP_AUDIO_LEFT);
		int temp = 0, temp1 = 0;
		if(soundMixer->indexSize <= 0) return;
		temp = alt_up_audio_write_fifo(audio_dev, soundMixer->buffer[soundMixer->currIndex], 96, ALT_UP_AUDIO_LEFT);
		temp1 = alt_up_audio_write_fifo(audio_dev, soundMixer->buffer[soundMixer->currIndex], 96, ALT_UP_AUDIO_RIGHT);
		/*s->position += 96;
		if(s->position>=s->length)
			s->position = 0;*/
		incIndex();
	}
	return;
}
示例#10
0
文件: audio.c 项目: RedTn/niostank
void play_wav (unsigned int **arr)
{
	alt_up_audio_reset_audio_core(audio);
	unsigned int * input;
	int k = 0;
	input = arr[k];
	while (1) {
		if (alt_up_audio_write_interrupt_pending(audio) == 1)
		{
			alt_up_audio_write_fifo(audio, input, 100, ALT_UP_AUDIO_LEFT);
			alt_up_audio_write_fifo(audio, input, 100, ALT_UP_AUDIO_RIGHT);
			k++;
			input = arr[k];
		}
		if (k >= 4377)
			break;
	}

}
示例#11
0
void audioPlaySampling(void)
{
	int fifospaceL,fifospaceR;
	U32 ptrIndexL=0,ptrIndexR=0;
	while(ptrIndexR<AUDIO_SAMPLING_MAX_DATA||ptrIndexL<AUDIO_SAMPLING_MAX_DATA)
	{


			fifospaceL = (IORD_ALT_UP_AUDIO_FIFOSPACE(audio_dev->base)& ALT_UP_AUDIO_FIFOSPACE_WSLC_MSK) >> ALT_UP_AUDIO_FIFOSPACE_WSLC_OFST;

			if(fifospaceL>100&&ptrIndexL<AUDIO_SAMPLING_MAX_DATA)
			{
				alt_up_audio_write_fifo(audio_dev,&audioSamplingLData[ptrIndexL],100, ALT_UP_AUDIO_LEFT);
				ptrIndexL+=100;
			}
			fifospaceR = (IORD_ALT_UP_AUDIO_FIFOSPACE(audio_dev->base)& ALT_UP_AUDIO_FIFOSPACE_WSRC_MSK) >> ALT_UP_AUDIO_FIFOSPACE_WSRC_OFST;
			if(fifospaceR>100&&ptrIndexR<AUDIO_SAMPLING_MAX_DATA)
			{
				alt_up_audio_write_fifo(audio_dev,&audioSamplingRData[ptrIndexR],100, ALT_UP_AUDIO_RIGHT);
				ptrIndexR+=100;
			}
	}
}
示例#12
0
int loadMusic(char* audioFile, unsigned short loop, float volumeFactor)
{
	int i = 0;
	unsigned int *sample;

	alt_up_audio_disable_write_interrupt(audio);

	printf("Opening file\n");

	file_handle fileHandle = open_file(audioFile, false);

	if (fileHandle < 0) {
		printf("Reading file failed \n");
		return AUDIO_ERROR;
	}

	int fileLength = findWavSize(fileHandle);

	// Discard header-- we are making an assumption about
	// how the data is stored to make it easier to
	// add sound to the music.
	for (i = 0; i < 32; i++) read_file(fileHandle);

	// Allocate the main music buffer to be the size of the file.
	if (interruptMusicBuffer != 0) free(interruptMusicBuffer);
	musicLoop = loop;
	musicDone = 0;
	interruptMusicBuffer = (int*) malloc((fileLength-32) * 2);

	interruptBufSize = (fileLength-32)/2;
	interruptSample = 0;

	if (volumeFactor <= 0) volumeFactor = 1;

	for (i = 0; i < interruptBufSize; i++)
	{
		// Extract data and store in the buf.
		char firstByte = read_file(fileHandle);
		char secondByte = read_file(fileHandle);
		short val = ( (unsigned char) secondByte << 8) | (unsigned char) firstByte;

		val = val * volumeFactor;
		interruptMusicBuffer[i] = val;
	}

	alt_up_sd_card_fclose(fileHandle);

	unsigned int space = alt_up_audio_write_fifo_space(audio, ALT_UP_AUDIO_RIGHT);

	if (space > interruptBufSize - interruptSample)
	{
		// Don't need to fully fill the rest of the buffer.
		space = interruptBufSize - interruptSample;
	}

	if (space > 0)
	{
		sample = &(interruptMusicBuffer[interruptSample]);
		alt_up_audio_write_fifo(audio, sample, space, ALT_UP_AUDIO_LEFT);
		alt_up_audio_write_fifo(audio, sample, space, ALT_UP_AUDIO_RIGHT);
		interruptSample += space;
	}

	if (interruptSample >= interruptBufSize)
	{
		if (musicLoop)
		{
			interruptSample = 0;
			alt_up_audio_enable_write_interrupt(audio);
		}
	}
	else
	{
		// Enable the write interrupt
		alt_up_audio_enable_write_interrupt(audio);
	}

	return 0;
}
示例#13
0
static void playMusicISR (void* context, alt_u32 id)
#endif
{
	/* Interrupt for writing*/
	unsigned int space = alt_up_audio_write_fifo_space(audio, ALT_UP_AUDIO_RIGHT);
	unsigned int* sample;
	int i;

	if (space > interruptBufSize - interruptSample)
	{
		// Don't need to fully fill the rest of the buffer.
		space = interruptBufSize - interruptSample;
	}

	if (space > 0)
	{
		if (addSound)
		{
			/* Add a sound in-- must add word by word. */
			for (i = 0; i < space; i++)
			{
				int currentWord = interruptMusicBuffer[interruptSample++];
				if (soundBufferSample < soundBufSize)
				{
					currentWord += soundBuffer[soundBufferSample++];
				}
				else
				{
					removeSound();
				}

				alt_up_audio_write_fifo(audio, &currentWord, 1, ALT_UP_AUDIO_LEFT);
				alt_up_audio_write_fifo(audio, &currentWord, 1, ALT_UP_AUDIO_RIGHT);
			}
		}
		else
		{
			sample = &(interruptMusicBuffer[interruptSample]);

			alt_up_audio_write_fifo(audio, sample, space, ALT_UP_AUDIO_LEFT);
			alt_up_audio_write_fifo(audio, sample, space, ALT_UP_AUDIO_RIGHT);
			interruptSample += space;
		}
	}

	if (interruptSample >= interruptBufSize)
	{
		if (musicLoop)
		{
			interruptSample = 0;
		}
		else
		{
			musicDone = 1;
			alt_up_audio_disable_write_interrupt(audio);

			if (bufSizeSwap != 0)
			{
				swapOutSound();
			}
		}
	}
}
示例#14
0
文件: audio.c 项目: RedTn/niosmusic
//Audio interrupt function, plays sound effects and/or loops audio
//REQ: audmode->id must point to correct id
void audio_isr(audisr * audmode, alt_u32 irq_id) {
	int i;
	unsigned int ** temp;
	unsigned int * second;

	if (audmode->resetmix == true) {
		audmode->resetmix = false;
		audio_isr_2 = 0;
	}
	//if (audmode->mode == 0) {
	if (audmode->id != audmode->oldid) {
		audio_isr_k = 0;
		seek = 0;
		init_copy(audmode->id, audmode->oldid);
		audmode->oldid = audmode->id;
	}
	if (audmode->id2 != audmode->oldid2) {
		audio_isr_2 = 0;
		audmode->oldid2 = audmode->id2;
	}
	if (audio_isr_k == 0) {
		copy_bgm(audmode->id);
		alt_up_rs232_write_data(uart, 0x6);
		alt_up_rs232_write_data(uart, (int)audiosecs[audmode->id]);
	}
	audio_log.bgmin = copyarr[audio_isr_k];

	//Mode 0, loop music
	if (audmode->mode == 0) {
		for (i = 0; i < 96; i++) {
			audio_log.bgmin[i] = volume_adjust(audio_log.bgmin[i], audmode->newvolume);
		}
	}
	else if (audmode->mode == 1) {
		temp = arr[audmode->id2];
		second = temp[audio_isr_2];
		for (i = 0; i < 96; i++) {
			unsigned int tempmix = audio_log.bgmin[i];
			audio_log.bgmin[i] = mix_adjust(tempmix,second[i],5);
		}
		audio_isr_2++;
		if (audio_isr_2 > audiosize[audmode->id2]) {
			audio_isr_2 = 0;
			audmode->mode = 0;
		}
	}
	if (alt_up_audio_write_interrupt_pending(audio) == 1) {
		alt_up_audio_write_fifo(audio, audio_log.bgmin, 96, ALT_UP_AUDIO_LEFT);
		alt_up_audio_write_fifo(audio, audio_log.bgmin, 96, ALT_UP_AUDIO_RIGHT);
		if (audmode->loop == true){
			audio_isr_k = (audio_isr_k + 1) % audiosize[audmode->id];
			seek = (seek + 1) % 333;
			if (seek == 0) {
				//alt_up_rs232_write_data(uart, 0x0A);
			}
			if (audio_isr_k == 0) {
				alt_up_rs232_write_data(uart, 0x3);
			}
		}
		else
		{
			if(audio_isr_k <= audiosize[audmode->id])
			{
				audio_isr_k += 1;
				seek = (seek + 1) % 333;
				if (seek == 0) {
					//alt_up_rs232_write_data(uart, 0x0A);
				}
			}
			else
			{
				seek = 0;
				audmode->mode = 0;
				audio_isr_2 = 0;
				audio_isr_k = 0;
				//alt_up_rs232_write_data(uart, 0x3);
				alt_up_rs232_write_data(uart, 0x4);
				wait();
				if (audmode->shuffle == false) {
					audmode->id += 1;
					if ((audmode->id >= audmode->files) && (audmode->listloop == true)) {
						audmode->id = 0;
						//printf("Restarting songs\n");
					}
					else if((audmode->id >= audmode->files) && (audmode->listloop == false)) {
						printf("End of Playlist\n");
						audmode->id = 0;
						alt_up_audio_disable_write_interrupt(audio);
					}
				}
				else {
					/*
					do {
						while(rs_flag == false);
						alt_up_rs232_read_data(uart, &data, &parity);
					}while((int)data == 0);
					 */
					wait();
					alt_up_rs232_read_data(uart, &data, &parity);
					int nextindex = (int)data;
					nextindex -= 4;
					//printf("Next Index: %d\n", nextindex);
					if ((nextindex < 0) || (nextindex > audmode->files)) {
						nextindex = 0;
						printf("Error, next Index: %d\n", nextindex);
					}
					audmode->id = nextindex;
				}
			}
		}
	}
	//}
	/*
	else if (audmode->mode == 1) {

		if (audmode->id != audmode->oldid) {
			//TEMP
			audmode->id2 = audmode->id++;
			if (audmode->id2 >= audmode->files) {
				audmode->id2 = 0;
			}
			if (audiosize[audmode->id] > audiosize[audmode->id2]) {
				audmode->large = audmode->id;
			}
			else {
				audmode->large = audmode->id2;
			}
			//
			audio_isr_k = 0;
			init_copy(audmode->large, audmode->oldid);
			audmode->oldid = audmode->id;
		}
		if (audio_isr_k == 0) {
			copy_bgm(audmode->large);
			alt_up_rs232_write_data(uart, 0x6);
		}
		audio_log.bgmin = copyarr[audio_isr_k];

		for (i = 0; i < 96; i++) {
			//audio_log.bgmin[i] = mix_adjust(audio_log.bgmin[i],  ,audmode->newvolume);
		}

		if (alt_up_audio_write_interrupt_pending(audio) == 1) {


			audio_isr_k = 0;
			audmode->id += 1;
			alt_up_rs232_write_data(uart, 0x3);
			if ((audmode->id >= audmode->files) && (audmode->listloop == true)) {
				audmode->id = 0;
				printf("Restarting songs\n");
			}
			else if((audmode->id >= audmode->files) && (audmode->listloop == false)) {
				printf("End of Playlist\n");
				audmode->id = 0;
				alt_up_audio_disable_write_interrupt(audio);
			}
		}

	}
	 */
}
示例#15
0
euint8 open_wav(SDfile fileinfo)
{
	euint8 buff[600];
	euint32 buff2[512];
	euint32 right[512];
	euint32 left[512];
	euint8 leftovers[512];
	euint8 leftoverCount=0;
	euint32 count = 0;
	euint32 i,zz;
	euint32 tempright;
	euint32 temp[5];
	euint32 overflow_amount = 0;
	euint32 LoopC = 0;
	euint32 stuff_to_write = 0;
	euint32 ints_to_send = 0;
	euint32 sample_rate = 0;
	euint32 bitdepth = 0;
	euint32 channels = 0;
	euint32 formatcode = 0;
	euint32 blocksize = 0;
	euint32 header_size = 0;
	euint32 next_address = 0;
	euint32 clust_address = 0;
	euint32 FAT_address = 0;
	euint32 filesize = 0;
	euint32 end_offset = 0;
	euint32 bytes_read = 0;
	euint8 end_of_file = 0;

	alt_up_audio_dev*  audio_dev = alt_up_audio_open_dev(AUDIO_NAME);
	alt_up_audio_reset_audio_core(audio_dev);

	filesize = fileinfo.file_size;

	FAT_address = (euint32)fileinfo.startL | ((euint32)fileinfo.startH)<<16;

	clust_address = (FAT_address-2)*Part_Boot.sec_per_clust + clust_start;

	sd_readSector(clust_address,buff);		//read in wav header info
	bytes_read += 512;

	//address = next_sect_address(address);

	header_size = get_wav_header(buff,&sample_rate,&bitdepth,&channels,&formatcode,&blocksize); //psuedo code for reading in wav details, returns wav info

	if(formatcode != 1)
	{
		UART_write("Error: incorrect wav format type, please use PCM\n\r");
		return(1);
	}
	if(channels != 2)
	{
		UART_write("Error, number of channels must be 2\n\r");
		return(1);
	}
	if((bitdepth != 32)&&(bitdepth != 16)&&(bitdepth != 24)&&(bitdepth != 8))
	{
		UART_write("Error, bitdepth is incorrect\n\r");
		return(1);
	}
	if(sample_rate != 8000)
		{
			UART_write("Error, sample rate is incorrect\n\r");
			return(1);
		}
	switch(sample_rate)
		{
		  case 8000:  AUDIO_SetSampleRate(RATE_ADC8K_DAC8K_USB); break;
		  case 32000: AUDIO_SetSampleRate(RATE_ADC32K_DAC32K_USB); break;
		  case 44100: AUDIO_SetSampleRate(RATE_ADC44K_DAC44K_USB); break;
		  case 48000: AUDIO_SetSampleRate(RATE_ADC48K_DAC48K_USB); break;
		  case 96000: AUDIO_SetSampleRate(RATE_ADC96K_DAC96K_USB); break;
		  default:  printf("Non-standard sampling rate\n"); return -1;
	   }
	count = count + header_size;
	while(end_of_file == 0)	//start reading bytes from offset position, if  there are bytes to be read, continue
	{
		//convert char buffer into 32 bit buffer
		while(LoopC < Part_Boot.sec_per_clust)
		{
			if(bitdepth == 32)
			{
				for(i=0;i<128;i++)
				{
					*((unsigned char*)&buff2[i]+0) = buff[count+0];
					*((unsigned char*)&buff2[i]+1) = buff[count+1];
					*((unsigned char*)&buff2[i]+2) = buff[count+2];
					*((unsigned char*)&buff2[i]+3) = buff[count+3];
					count += 4;
					if(count > 512)
					{
						ints_to_send = i+1;
						break;
					}
					if(i==127) ints_to_send = i+1;
				}
				count = 0;
			}
			if(bitdepth == 24)
			{
				for(i=0;i<170;i++)		// PROBLEM HERE PROBS SINCE 512/3 ISNT WHOLE NUMBER
				{
					*((unsigned char*)&buff2[i]+0) = 0;
					*((unsigned char*)&buff2[i]+1) = buff[count+0];
					*((unsigned char*)&buff2[i]+2) = buff[count+1];
					*((unsigned char*)&buff2[i]+3) = buff[count+2];
					count += 3;
					if(count >= 512)
					{
						count = (count-512)+3;
						ints_to_send = i+1;
						break;
					}
				}
			}
			if(bitdepth == 16)
			{
				for(i=0;i<256;i++)
				{
					*((unsigned char*)&buff2[i]+0) = 0;
					*((unsigned char*)&buff2[i]+1) = 0;
					*((unsigned char*)&buff2[i]+2) = buff[count+0];
					*((unsigned char*)&buff2[i]+3) = buff[count+1];
					count += 2;

					if(count > 512)
					{
						ints_to_send = i+1;
						break;
					}
					if(i==255) ints_to_send = i+1;
				}
				count = 0;
			}
			if(bitdepth == 8)
			{
				for(i=0;i<512;i++)
				{
					*((unsigned char*)&buff2[i]+0) = 0;
					*((unsigned char*)&buff2[i]+1) = 0;
					*((unsigned char*)&buff2[i]+2) = 0;
					*((unsigned char*)&buff2[i]+3) = buff[count+0];
					count++;

					if(count > 512)
					{
						ints_to_send = i+1;
						break;
					}
					if(i==511) ints_to_send = i+1;
				}
				count = 0;
			}
			// pass to left and right channels
			for(i=0;i<256;i++)
			{
				left[i] = buff2[i*2];
				right[i] = buff2[i*2+1];
			}

			if(end_offset != 0)
			{
				stuff_to_write = end_offset/(1024/ints_to_send);
				end_of_file = 1;
				end_offset = 0;
			}
			else
			{
				stuff_to_write = ints_to_send/2;
			}
			//is there space in the fifo?
			while(alt_up_audio_write_fifo_space(audio_dev,0) < stuff_to_write);
			//send to audio channels
			alt_up_audio_write_fifo(audio_dev,right,stuff_to_write,ALT_UP_AUDIO_RIGHT);
			alt_up_audio_write_fifo(audio_dev,left,stuff_to_write,ALT_UP_AUDIO_LEFT);
			clust_address++;
			sd_readSector(clust_address,buff);
			bytes_read += 512;
			LoopC++;
			if(bytes_read >= filesize)
			{
				end_of_file = 1;
				//end_offset = 512 - (bytes_read-filesize);
			}
		}
		LoopC = 0;
		clust_address = next_sect_address(FAT_address,&next_address);
		FAT_address = next_address;
		if(bytes_read >= filesize)
		{
			end_of_file = 1;
			//end_offset = 512 - (bytes_read-filesize);
		}
	}
	return(0);
}