//
//  Copyright(C) Renesas Technology Corp. 2002-2003. All rights reserved.
//
//  sample program for HSpdifRx for ITS-DS7
//
//  FILE     : HSpdifin.c
//  CREATED  : 2002.06.26
//  MODIFIED : 2003.12.25
//  AUTHOR   : Renesas Technology Corp.
//  HARDWARE : RENESAS ITS-DS7
//  HISTORY  : 
//             2003.06.20
//             - Created release code.
//                (based on sample program for HSpdifRx for ITS-DS4 Ver.1.0.0)
//             2003.12.25
//             - Supported .wav file.
//             - Added parameter.
//             - Supported recording time.
//

#include <windows.h>
#include "ioctl_its_ds7.h"
#include "wavefile.h"

#define BUFF_SIZE	0x8000
#define TIMEOUT_MAX	5

#define NELEMS(a) (sizeof(a)/sizeof((a)[0]))
#define MRCHECK(mr,str)\
    if ((mr != MMSYSERR_NOERROR)) { RETAILMSG(1, (TEXT(#str) TEXT(" failed. mr=%08x\r\n"), mr)); goto ERROR_RET;}

typedef struct {
  unsigned char FName[16];
  unsigned long Dmy1[2];
  unsigned long SamplingRate1;
  unsigned long SamplingRate2;
  unsigned short Dmy2;
  unsigned short BitsPerSample;
  unsigned long Dmy3;
  unsigned long Length;
} HEADER;

PBYTE Data;

PTSTR usage_text[] =
{
    TEXT("usage:\r\n"),
    TEXT("       -f <filename>    outpout filename(.wav file or PCM raw data file)\r\n"),
    TEXT("       -b <bitsize>     sample bit size(16/20/24)\r\n"),
    TEXT("       -t <duration>	  recording time in milliseconds\r\n"),
    TEXT("       -m <mode>		  output file mode(0:pcm/1:wav)\r\n"),
    TEXT("       -?               help\r\n"),
    TEXT("note:\r\n"),
    TEXT("       HSPDIF supported only 44.1kHz stereo.\r\n"),
};

void
Usage(void)
{ int i;

    for (i = 0; i < NELEMS(usage_text); i++) {
        RETAILMSG(1, (usage_text[i]));
    }
}

int WINAPI
WinMain (
	HINSTANCE hInstance,
	HINSTANCE hPrevInstance,
    LPWSTR lpCmdLine,
	int nCmdShow)
{
HANDLE	hDevice=NULL;
HANDLE  hDriver;
DWORD	dwRet;
DWORD	dwData;
HANDLE	hFile=NULL;
//HEADER	Head;
DWORD	nCnt;
//DWORD	TickCnt, TransNum;
DWORD NoDataNum;
BOOL	RetCode;

PTSTR pOption;
TCHAR ws[] = TEXT(" \t");
int errors = 0;
PTSTR pszFilename = TEXT("spdifout.pcm");
DWORD	dwBitSize=16;
DWORD dwDuration = 5 * 1000;    // record for 5 seconds
DWORD dwMode = 0;
DWORD	dwRemain;
DWORD	dwBytesRecorded;
MMRESULT mr;

PBYTE pBufferBits=NULL;
DWORD dwBufferSize;
WAVEFORMATEX wfx;

	RETAILMSG(1, (TEXT("SPDIF recording start.\r\n")));

    // parse the command line
    for (pOption = _tcstok(lpCmdLine, ws); pOption != NULL; pOption = _tcstok(NULL, ws)) {
        if (pOption[0] != '/' && pOption[0] != '-') {
            RETAILMSG(1, (TEXT("Unrecognized argument %s\r\n"), pOption));
            errors++;
            continue;
        }
        PTSTR pParameter = _tcstok(NULL, ws);
        if (pParameter == NULL) {
            RETAILMSG(1, (TEXT("Missing parameter to option %s\r\n"), pOption));
        }
        switch (pOption[1]) {
        case 'f':
            pszFilename = pParameter;
            break;

        case 'b':
            dwBitSize = _ttoi(pParameter);
			switch(dwBitSize){
			case 16:
			case 20:
			case 24:
				break;
			default:
	            RETAILMSG(1, (TEXT("Illegal sample bit size %d\r\n"),dwBitSize));
	            errors++;
				break;
			}
            break;

        case 't':
            dwDuration = _ttoi(pParameter);
            break;

        case 'm':
            dwMode = _ttoi(pParameter);
			if(dwMode < 0 || 1 < dwMode){
	            RETAILMSG(1, (TEXT("Illegal output file mode %d\r\n"),dwMode));
	            errors++;
				break;
			}
            break;

        case '?':
        case 'h':
            Usage();
            errors++;
            break;

        default:
            RETAILMSG(1, (TEXT("Unrecognized option %s\r\n"), pOption));
            errors++;
            break;
        }
    }

    if (errors > 0) {
        // we've already issued complaint, now just exit
        return -1;
    }

    // set up the wave format structure
    wfx.cbSize = 0;
    wfx.wFormatTag = WAVE_FORMAT_PCM;
    wfx.wBitsPerSample = (WORD) dwBitSize;
    wfx.nSamplesPerSec = 44100;
    wfx.nChannels = (WORD) 2;
    wfx.nBlockAlign = wfx.nChannels * wfx.wBitsPerSample / 8;
    wfx.nAvgBytesPerSec = wfx.nBlockAlign * wfx.nSamplesPerSec;

    // compute the size of the capture buffer
    // compute total # of samples & multiply by blocksize to get sample-aligned buffer size
    dwBufferSize = (dwDuration * wfx.nSamplesPerSec / 1000) * wfx.nBlockAlign;

    // let user know what's going on
    RETAILMSG(1, (TEXT("Recording %5d ms to \"%s\": S%02d 44100Hz (%8d bytes)\r\n")
        , dwDuration
        , pszFilename
        , dwBitSize
        , dwBufferSize
        ));

	if(dwMode==0){
		// pcm
		hFile = CreateFile(pszFilename, GENERIC_WRITE, FILE_SHARE_WRITE,
						NULL, CREATE_ALWAYS, 0, NULL);
		if ( hFile == INVALID_HANDLE_VALUE ){
			RETAILMSG(1, (TEXT("File open failed. rc %d\r\n"), GetLastError()));
			return 0;
		}

	    pBufferBits = new BYTE[BUFF_SIZE];
	    if (pBufferBits == NULL) {
	        RETAILMSG(1, (TEXT("Unable to allocate chunk buffer\r\n")));
			CloseHandle(hFile);
	        goto ERROR_RET;
	    }
	}
	else{
		// wav
	    
	    // try to allocate the capture buffer
	    pBufferBits = new BYTE [dwBufferSize];
	    if (pBufferBits == NULL) {
	        RETAILMSG (1, (TEXT("Unable to allocate %d bytes for %d ms of audio data\r\n"), dwBufferSize, dwDuration));
	        goto ERROR_RET;
	    }

	}
//	WriteFile(hFile, &Head, sizeof(HEADER), &nCnt, NULL);

//	DEBUGMSG(1, (TEXT("Sampling rate : %dHz BitsPerSample : %d\r\n"),
//			Head.SamplingRate1, Head.BitsPerSample));

	hDevice = CreateFile(
			TEXT("SPD1:"),
			GENERIC_READ,
			0,
			NULL,
			OPEN_EXISTING,
			FILE_ATTRIBUTE_NORMAL,
			NULL);
	if ( hDevice == INVALID_HANDLE_VALUE ){
		if ( GetLastError() == ERROR_DEV_NOT_EXIST ){
			//register spdif driver 
			hDriver = RegisterDevice(TEXT("SPD"), 1, TEXT("HSPDIF.DLL"), 0);
			if ( !hDriver ){
				RETAILMSG(1, (TEXT("Failed to register spdif device driver.\r\n")));
			}
			hDevice = CreateFile(TEXT("SPD1:"),
					GENERIC_READ,
					0, NULL, OPEN_EXISTING,
					FILE_ATTRIBUTE_NORMAL, NULL);
		}
		if ( hDevice == INVALID_HANDLE_VALUE ){
			RETAILMSG(1, (TEXT("Failed to open spdif device driver.\r\n")));
			CloseHandle(hFile);
			return 0;
		}
	}

	switch(dwBitSize){
	case 16:	dwData = SPDIF_SAMPLE_BIT_SIZE_16;	break;
	case 20:	dwData = SPDIF_SAMPLE_BIT_SIZE_20;	break;
	case 24:	dwData = SPDIF_SAMPLE_BIT_SIZE_24;	break;
	default:	break;
	}

	switch( dwData ){
		case SPDIF_SAMPLE_BIT_SIZE_16:
			RETAILMSG(1, (TEXT("Set SampleSize : 16\r\n")));
			break;

		case SPDIF_SAMPLE_BIT_SIZE_20:
			RETAILMSG(1, (TEXT("Set SampleSize : 20\r\n")));
			break;

		case SPDIF_SAMPLE_BIT_SIZE_24:
			RETAILMSG(1, (TEXT("Set SampleSize : 24\r\n")));
			break;

		default : 
			break;
	}

	RetCode = DeviceIoControl(hDevice, IOCTL_SPDIF_SET_RXSAMPLE_SIZE,
		&dwData, sizeof(DWORD), NULL, 0, &dwRet, NULL);
	if (RetCode == FALSE) {
		RETAILMSG(1, (TEXT("Error : IOCTL_SPDIF_SET_RXSAMPLE_SIZE\r\n")));
		CloseHandle( hFile );
		CloseHandle( hDevice );
		return 0;
	}

	RetCode = DeviceIoControl(hDevice, IOCTL_SPDIF_GET_RXSAMPLE_SIZE,
		NULL, 0, &dwData, sizeof(DWORD), &dwRet, NULL);
	if (RetCode == FALSE) {
		RETAILMSG(1, (TEXT("Error : IOCTL_SPDIF_GET_RXSAMPLE_SIZE\r\n")));
		CloseHandle( hFile );
		CloseHandle( hDevice );
		return 0;
	}

	switch( dwData ){
		case SPDIF_SAMPLE_BIT_SIZE_16: dwData = 16;break;
		case SPDIF_SAMPLE_BIT_SIZE_20: dwData = 20;break;
		case SPDIF_SAMPLE_BIT_SIZE_24: dwData = 24;break;
		default : dwData = 0;break;
	}
	RETAILMSG(1, (TEXT("Get SampleSize : %d\r\n"), dwData));

//	TickCnt = GetTickCount();
//	TransNum = 0;
	NoDataNum = 0;
	Data = pBufferBits;
	dwRemain = dwBufferSize;
	dwBytesRecorded=0;

	while(1){
		if(hFile){
			Data = pBufferBits;
		}
		nCnt = BUFF_SIZE;
		if(dwRemain < BUFF_SIZE){
			nCnt = dwRemain;
		}

		dwRet= 0;
		RetCode = DeviceIoControl(hDevice, IOCTL_SPDIF_RECEIVING_DATA,
			NULL, 0, Data, nCnt, &dwRet, NULL);
		if (RetCode == FALSE) {
			if (GetLastError() == ERROR_INVALID_PARAMETER) {
				RETAILMSG(1, (TEXT("Error : IOCTL_SPDIF_RECEIVING_DATA - Invalid Params.\r\n")));
				break;
			} else if (GetLastError() == ERROR_TIMEOUT) {
				RETAILMSG(1, (TEXT("Error : IOCTL_SPDIF_RECEIVING_DATA - TimeOut.\r\n")));
			}
		}
		if ( dwRet == 0 ){
			NoDataNum ++;
			if ( NoDataNum > TIMEOUT_MAX ){
				RETAILMSG(1, (TEXT("TimeOut. Stop recording.\r\n")));
				break;
			}
			continue;
		}
		
		dwBytesRecorded+=dwRet;
		if(hFile){
//			dwRet = BUFF_SIZE;
			WriteFile(hFile, Data, dwRet, &nCnt, NULL);
//			TransNum ++;
		}
		if(dwRemain<=dwRet){
			break;
		}
		dwRemain-=dwRet;
		if(!hFile){
			Data+=dwRet;
		}
		

//		DEBUGMSG(1, (TEXT("Spdif in %d  %d bytes received.\r\n"), TransNum, dwRet));
//		if ( nCnt != BUFF_SIZE )
//			break;

//		if ( TransNum == 100 )
//			break;
	}
	DeviceIoControl(hDevice, IOCTL_SPDIF_STOP_RECEIVE,
		NULL, 0, NULL, 0, &dwRet, NULL);
//	RETAILMSG(1, (TEXT("Number of received : %d Time(ms) : %d\r\n"),
//			TransNum, GetTickCount() - TickCnt));

    RETAILMSG(1, (TEXT("Capture completed. Writing %s\r\n"), pszFilename));
	if(!hFile){
	    // finally, write the captured buffer to the file
	    // note that we use hdr.dwBytesRecorded, not dwBuffersize.
	    mr = WriteWaveFile(pszFilename, &wfx, dwBytesRecorded, pBufferBits);
	    MRCHECK(mr, WriteWaveFile);
	}

	RETAILMSG(1, (TEXT("SPDIF recording finished. %s\r\n"),pszFilename));

ERROR_RET:
    if(pBufferBits) delete [] pBufferBits;
	if(hFile) CloseHandle( hFile );
	if(hDevice) CloseHandle( hDevice );
	return 0;
}