#include <SPI.h>
#include <SD.h>
#include <FS.h>

#define SD_CS   A3
#define SDSPEED 40000000

#define PIN_BCK    A6   // 1:BCK
#define PIN_WS     A1   // 2:WS
#define PIN_DIN    A2   // 3:DIN

#define NOP __asm__ __volatile__ ("nop\n\t")

#define BUFFER_SIZE  2048

#define NORMAL      0.65
#define LIGHT_LOLI  0.6
#define HEAVY_LOLI  0.5

#define ETS_DELAY_US_RATE  NORMAL
//#define ETS_DELAY_US_RATE  LIGHT_LOLI
//#define ETS_DELAY_US_RATE  HEAVY_LOLI

// The Canonical WAVE file format
typedef struct {
	uint8_t  ChunkID[4];
	uint32_t ChunkSize;
	uint8_t  Format[4];
	uint8_t  Subchunk1ID[4];
	uint32_t Subchunk1Size;
	uint16_t AudioFormat;
	uint16_t NumChannels;
	uint32_t SampleRate;
	uint32_t ByteRate;
	uint16_t BlockAlign;
	uint16_t BitPerSample;
	uint8_t  Subchunk2ID[4];
	uint32_t Subchunk2Size;
} WAV_FORMAT;


File       file;
WAV_FORMAT pwf;
uint8_t    buf[BUFFER_SIZE];

boolean getWavFormat()
{
	long len;
	short cbsize;

	if (file.read((uint8_t *)&pwf,20) == -1) return false;

	if (memcmp(pwf.Subchunk1ID,"fmt ",4)==0) {
		if((len = file.read((uint8_t *)&pwf+20,24))==-1) return false;
	} else if (memcmp(pwf.Subchunk1ID,"LIST",4)==0) {
		if (file.seek(20+pwf.Subchunk1Size)) {
			if((len = file.read((uint8_t *)&pwf+12,24))==-1) return false;
			if (pwf.Subchunk1Size == 18) {
				// skip cbsize on WAVEFORMATEX
				if((len = file.read((uint8_t *)&cbsize,2))==-1) return false;
			}
			if((len = file.read((uint8_t *)&pwf+36,8))==-1) return false;
		} else {
			return false;
		}
	} else {
		return false;
	}

	if(  memcmp(pwf.ChunkID,     "RIFF", 4)
	   ||memcmp(pwf.Format,      "WAVE", 4)
	   ||memcmp(pwf.Subchunk1ID, "fmt ", 4)
	   ||memcmp(pwf.Subchunk2ID, "data", 4))
	     return false;
	else return true;
}

void writeDACChannel(int16_t mono)
{
	unsigned char pos = 16;

	// Send data into PT8211 in least significant bit justified (LSBJ) format.
	while(pos > 0) {
		pos--;
		digitalWrite(PIN_BCK, LOW);
		digitalWrite(PIN_DIN, (mono & (1 << pos)) ? HIGH: LOW);
		NOP;
		// Toggle BCK.
		digitalWrite(PIN_BCK, HIGH);
		NOP;
	}
}

boolean writeDAC(char *filename)
{
	unsigned short left, right, delayus;
	long block;

	if(!(file = SD.open(filename))) return false;

	getWavFormat();
	delayus = (1000000 / pwf.SampleRate) * ETS_DELAY_US_RATE;
	long len = pwf.Subchunk2Size;

	while(len>0) {
		if (len>BUFFER_SIZE) block = BUFFER_SIZE; else block = len;
		file.readBytes((char*)buf, block);
		for(int pos=0;pos<block;pos+=4)
		{
			left  = buf[pos+1];
			left  = (left<<8) + buf[pos];
			right = buf[pos+3];
			right = (right<<8) + buf[pos+2];

			digitalWrite(PIN_WS,  LOW); // right channel
			writeDACChannel(left);

			digitalWrite(PIN_WS,  HIGH); // left channel
			writeDACChannel(right);

			ets_delay_us(delayus);
		}
		len -= BUFFER_SIZE;
	}
	file.close();

	return true;
}

void setup()
{
	pinMode(PIN_BCK, OUTPUT);
	pinMode(PIN_WS,  OUTPUT);
	pinMode(PIN_DIN, OUTPUT);

	if (SD.begin( SD_CS, SPI, SDSPEED)) {
		writeDAC("/sound/odeon_16bit11KHz.wav");
	}
}

void loop() {}