CNFA_sf.h

//This file was automatically generated by Makefile at https://github.com/cnlohr/cnfa
//Generated from files git hash da3569ad3b7ce480747db039037d7495b87bc18a on Wed Dec 31 05:07:19 PM EST 2025 (This is not the git hash of this file)
//Copyright <>< 2010-2020 Charles Lohr (And other authors as cited)
//CNFA is licensed under the MIT/x11, ColorChord or NewBSD Licenses. You choose.
//
// CN's Platform-agnostic, foundational sound driver subsystem.
// Easily output and input sound on a variety of platforms.
//
// Options:
//  * #define CNFA_IMPLEMENTATION before this header and it will build all
//    definitions in.
//


#ifndef _CNFA_H
#define _CNFA_H



//this #define is per-platform.  For instance on Linux, you have ALSA, Pulse and null
#define MAX_CNFA_DRIVERS 4

struct CNFADriver;

#ifdef __cplusplus
extern "C" {
#endif

#ifdef BUILD_DLL
	#ifdef WINDOWS
		#define DllExport __declspec( dllexport )
	#else
		#define DllExport extern
	#endif
#else
	#define DllExport
#endif

//NOTE: Some drivers have synchronous duplex mode, other drivers will use two different callbacks.  If ether is unavailable, it will be NULL.
//I.e. if `out` is null, only use in to read.  If in is null, only place samples in out.
typedef void(*CNFACBType)( struct CNFADriver * sd, short * out, short * in, int framesp, int framesr );

typedef void*(CNFAInitFn)( CNFACBType cb, const char * your_name, int reqSPSPlay, int reqSPSRec, int reqChannelsPlay, int reqChannelsRec, int sugBufferSize, const char * outputSelect, const char * inputSelect, void * opaque );

struct CNFADriver
{
	void (*CloseFn)( void * object );
	int (*StateFn)( void * object );
	CNFACBType callback;
	short channelsPlay;
	short channelsRec;
	int spsPlay;
	int spsRec;
	void * opaque;

	//More fields may exist on a per-sound-driver basis
};

//Accepts:
//If DriverName = 0 or empty, will try to find best driver.
//
// our_source_name is an optional argument, but on some platforms controls the name of your endpoint.
// reqSPSPlay = 44100 is guaranteed on many platforms.
// reqSPSRec = 44100 is guaranteed on many platforms.
//   NOTE: Some platforms do not allow SPS play and REC to deviate from each other.
// reqChannelsRec = 1 or 2 guaranteed on many platforms.
// reqChannelsPlay = 1 or 2 guaranteedon many platforms. NOTE: Some systems require ChannelsPlay == ChannelsRec!
// sugBufferSize = No promises.
// outputSelect = No standardization, NULL is OK for default.
// inputSelect = No standardization, NULL is OK for default.

DllExport struct CNFADriver * CNFAInit( const char * driver_name, const char * your_name, CNFACBType cb, int reqSPSPlay, int reqSPSRec, int reqChannelsPlay,
	int reqChannelsRec, int sugBufferSize, const char * outputSelect, const char * inputSelect, void * opaque );
	
DllExport int CNFAState( struct CNFADriver * cnfaobject ); //returns bitmask.  1 if mic recording, 2 if play back running, 3 if both running.
DllExport void CNFAClose( struct CNFADriver * cnfaobject );


//Called by various sound drivers.  Notice priority must be greater than 0.  Priority of 0 or less will not register.
//This is an internal function.  Applications shouldnot call it.
void RegCNFADriver( int priority, const char * name, CNFAInitFn * fn );

#if defined(_MSC_VER) && !defined(__clang__)
#define REGISTER_CNFA( cnfadriver, priority, name, function ) \
	void REGISTER##cnfadriver() { RegCNFADriver( priority, name, function ); }
#else
#define REGISTER_CNFA( cnfadriver, priority, name, function ) \
	void __attribute__((constructor)) REGISTER##cnfadriver() { RegCNFADriver( priority, name, function ); }
#endif

#if defined(WINDOWS) || defined(__WINDOWS__) || defined(_WINDOWS) \
                     || defined(_WIN32)      || defined(_WIN64) \
                     || defined(WIN32)       || defined(WIN64) \
                     || defined(__WIN32__)   || defined(__CYGWIN__) \
                     || defined(__MINGW32__) || defined(__MINGW64__) \
                     || defined(__TOS_WIN__)
#define CNFA_WINDOWS 1
#elif defined( ANDROID ) || defined( __android__ ) || defined(ANDROID)
#define CNFA_ANDROID 1
#elif defined(__NetBSD__) || defined(__NetBSD) || defined(__sun) || defined(sun)
#define CNFA_SUN 1
#elif defined(__linux) || defined(__linux__) || defined(linux) || defined(__LINUX__)
#define CNFA_LINUX 1
#define CNFA_PULSE 1
#endif

#if defined(PULSEAUDIO)
#define CNFA_PULSE 1
#endif

#ifdef __TINYC__
#ifndef TCC
#define TCC
#endif
#endif

#ifdef CNFA_IMPLEMENTATION
//Copyright <>< 2010-2020 Charles Lohr (And other authors as cited)
//CNFA is licensed under the MIT/x11, ColorChord or NewBSD Licenses. You choose.

#ifndef _CNFA_C
#define _CNFA_C

#include <string.h>
#include <stdio.h>
#include <stdlib.h>

#if defined(_MSC_VER)
#if CNFA_WINDOWS
#ifndef strdup
#define strdup _strdup
#endif
#endif 
#endif

static CNFAInitFn * CNFADrivers[MAX_CNFA_DRIVERS];
static char * CNFADriverNames[MAX_CNFA_DRIVERS];
static int CNFADriverPriorities[MAX_CNFA_DRIVERS];

void RegCNFADriver( int priority, const char * name, CNFAInitFn * fn )
{
	int j;

	if( priority <= 0 )
	{
		return;
	}

	printf("[CNFA] Registering Driver: %s\n", name);

	for( j = MAX_CNFA_DRIVERS-1; j >= 0; j-- )
	{
		//Cruise along, find location to insert
		if( j > 0 && ( !CNFADrivers[j-1] || CNFADriverPriorities[j-1] < priority ) )
		{
			CNFADrivers[j] = CNFADrivers[j-1];
			CNFADriverNames[j] = CNFADriverNames[j-1];
			CNFADriverPriorities[j] = CNFADriverPriorities[j-1];
		}
		else
		{
			CNFADrivers[j] = fn;
			CNFADriverNames[j] = strdup( name );
			CNFADriverPriorities[j] = priority;
			break;
		}
	}
}

struct CNFADriver * CNFAInit( const char * driver_name, const char * your_name, CNFACBType cb, int reqSPSPlay, int reqSPSRec,
	int reqChannelsPlay, int reqChannelsRec, int sugBufferSize, const char * outputSelect, const char * inputSelect, void * opaque)
{

#if CNFA_ANDROID
	//Android can't run static-time code.
	void REGISTERAndroidCNFA();
	REGISTERAndroidCNFA();
#endif

	int i;
	struct CNFADriver * ret = 0;
	int minprio = 0;
	CNFAInitFn * bestinit = 0;
	if( driver_name == 0 || strlen( driver_name ) == 0 )
	{
		//Search for a driver.
		for( i = 0; i < MAX_CNFA_DRIVERS; i++ )
		{
			if( CNFADrivers[i] == 0 )
			{
				break;
			}
			if( CNFADriverPriorities[i] > minprio )
			{
				minprio = CNFADriverPriorities[i];
				bestinit = CNFADrivers[i];
			}
		}
		if( bestinit )
		{
			ret = (struct CNFADriver *)bestinit( cb, your_name, reqSPSPlay, reqSPSRec, reqChannelsPlay, reqChannelsRec, sugBufferSize, outputSelect, inputSelect, opaque );
		}
		if( ret )
		{
			return ret;
		}
	}
	else
	{
		for( i = 0; i < MAX_CNFA_DRIVERS; i++ )
		{
			if( CNFADrivers[i] == 0 )
			{
				break;
			}
			if( strcmp( CNFADriverNames[i], driver_name ) == 0 )
			{
				return (struct CNFADriver *)CNFADrivers[i]( cb, your_name, reqSPSPlay, reqSPSRec, reqChannelsPlay, reqChannelsRec, sugBufferSize, outputSelect, inputSelect, opaque );
			}
		}
	}
	printf( "CNFA Driver not found.\n" );
	return 0;
}

int CNFAState( struct CNFADriver * cnfaobject )
{
	if( cnfaobject )
	{
		return cnfaobject->StateFn( cnfaobject );
	}
	return -1;
}

void CNFAClose( struct CNFADriver * cnfaobject )
{
	if( cnfaobject )
	{
		cnfaobject->CloseFn( cnfaobject );
	}
}

#endif



//Copyright 2015-2020 <>< Charles Lohr under the ColorChord License.

#include "os_generic.h"
#include <stdlib.h>

struct CNFADriverNull
{
	void (*CloseFn)( void * object );
	int (*StateFn)( void * object );
	CNFACBType callback;
	short channelsPlay;
	short channelsRec;
	int spsPlay;
	int spsRec;
	void * opaque;
};

void CloseCNFANull( void * object )
{
	free( object );
}

int CNFAStateNull( void * object )
{
	return 0;
}


void * InitCNFANull( CNFACBType cb, const char * your_name, int reqSPSPlay, int reqSPSRec, int reqChannelsPlay, int reqChannelsRec, int sugBufferSize, const char * outputSelect, const char * inputSelect, void * opaque )
{
	struct CNFADriverNull * r = (struct CNFADriverNull *)malloc( sizeof( struct CNFADriverNull ) );
	r->CloseFn = CloseCNFANull;
	r->StateFn = CNFAStateNull;
	r->callback = cb;
	r->spsPlay = reqSPSPlay;
	r->spsRec = reqSPSRec;
	r->opaque = opaque;
	r->channelsPlay = reqChannelsPlay;
	r->channelsRec = reqChannelsRec;
	return r;
}


REGISTER_CNFA( NullCNFA, 1, "NULL", InitCNFANull );


#if CNFA_WINDOWS
//Copyright 2015-2020 <>< Charles Lohr under the ColorChord License, MIT/x11 license or NewBSD Licenses.

#include <windows.h>
#include "os_generic.h"
#include <stdio.h>
#include <mmsystem.h>
#include <stdlib.h>

//Include -lwinmm, or, C:/windows/system32/winmm.dll

#if defined(_MSC_VER)
#if CNFA_WINDOWS
#ifndef strdup
#define strdup _strdup
#endif
#endif

#if defined(WIN32)
#pragma comment(lib,"winmm.lib")
#endif
#endif

#define BUFFS 3

struct CNFADriverWin
{
	//Standard header - must remain.
	void (*CloseFn)( void * object );
	int (*StateFn)( void * object );
	CNFACBType callback;
	short channelsPlay;
	short channelsRec;
	int spsPlay;
	int spsRec;
	void * opaque;

	char * sInputDev;
	char * sOutputDev;

	int buffer;
	int isEnding;
	int GOBUFFRec;
	int GOBUFFPlay;

	int recording;
	int playing;

	HWAVEIN hMyWaveIn;
	HWAVEOUT hMyWaveOut;
	WAVEHDR WavBuffIn[BUFFS];
	WAVEHDR WavBuffOut[BUFFS];
};


static struct CNFADriverWin * w;

void CloseCNFAWin( void * v )
{
	struct CNFADriverWin * r = (struct CNFADriverWin *)v;
	int i;

	if( r )
	{
		if( r->hMyWaveIn )
		{
			waveInStop(r->hMyWaveIn);
			waveInReset(r->hMyWaveIn);
			for ( i=0;i<BUFFS;i++)
			{
				waveInUnprepareHeader(r->hMyWaveIn,&(r->WavBuffIn[i]),sizeof(WAVEHDR));
				free ((r->WavBuffIn[i]).lpData);
			}
			waveInClose(r->hMyWaveIn);
		}

		if( r->hMyWaveOut )
		{
			waveOutPause(r->hMyWaveOut);
			waveOutReset(r->hMyWaveOut);

			for ( i=0;i<BUFFS;i++)
			{
				waveInUnprepareHeader(r->hMyWaveIn,&(r->WavBuffOut[i]),sizeof(WAVEHDR));
				free ((r->WavBuffOut[i]).lpData);
			}
			waveInClose(r->hMyWaveIn);
			waveOutClose(r->hMyWaveOut);
		}
		free( r );
	}
}

int CNFAStateWin( void * v )
{
	struct CNFADriverWin * soundobject = (struct CNFADriverWin *)v;

	return soundobject->recording | (soundobject->playing?2:0);
}

void CALLBACK HANDLEMIC(HWAVEIN hwi, UINT umsg, DWORD dwi, DWORD hdr, DWORD dwparm)
{
	int ob;
	unsigned int maxWave=0;

	if (w->isEnding) return;

	switch (umsg)
	{
	case MM_WIM_OPEN:
		printf( "Mic Open.\n" );
		w->recording = 1;
		break;

	case MM_WIM_DATA:
		ob = (w->GOBUFFRec+(BUFFS))%BUFFS;
		w->callback( (struct CNFADriver*)w, 0, (short*)(w->WavBuffIn[w->GOBUFFRec]).lpData, 0, w->buffer );
		waveInAddBuffer(w->hMyWaveIn,&(w->WavBuffIn[w->GOBUFFRec]),sizeof(WAVEHDR));
		w->GOBUFFRec = ( w->GOBUFFRec + 1 ) % BUFFS;
		break;
	}
}


void CALLBACK HANDLESINK(HWAVEIN hwi, UINT umsg, DWORD dwi, DWORD hdr, DWORD dwparm)
{
	unsigned int maxWave=0;

	if (w->isEnding) return;

	switch (umsg)
	{
	case MM_WOM_OPEN:
		printf( "Sink Open.\n" );
		w->playing = 1;
		break;

	case MM_WOM_DONE:
		w->callback( (struct CNFADriver*)w, (short*)(w->WavBuffOut[w->GOBUFFPlay]).lpData, 0, w->buffer, 0 );
		waveOutWrite( w->hMyWaveOut, &(w->WavBuffOut[w->GOBUFFPlay]),sizeof(WAVEHDR) );
		w->GOBUFFPlay = ( w->GOBUFFPlay + 1 ) % BUFFS;
		break;
	}
}


static struct CNFADriverWin * InitWinCNFA( struct CNFADriverWin * r )
{
	int i;
	WAVEFORMATEX wfmt;
	long dwdeviceR, dwdeviceP;
	memset( &wfmt, 0, sizeof(wfmt) );
	printf ("WFMT Size (debugging temp for TCC): %zu\n", sizeof(wfmt) );
	printf( "WFMT: %d %d %d\n", r->channelsRec, r->spsRec, r->spsRec * r->channelsRec );
	w = r;
	
	wfmt.wFormatTag = WAVE_FORMAT_PCM;
	wfmt.nChannels = r->channelsRec;
	wfmt.nAvgBytesPerSec = r->spsRec * r->channelsRec;
	wfmt.nBlockAlign = r->channelsRec * 2;
	wfmt.nSamplesPerSec = r->spsRec;
	wfmt.wBitsPerSample = 16;
	wfmt.cbSize = 0;

	dwdeviceR = r->sInputDev?atoi(r->sInputDev):WAVE_MAPPER;
	dwdeviceP = r->sOutputDev?atoi(r->sOutputDev):WAVE_MAPPER;

	if( r->channelsRec )
	{
		int p;
		printf( "In Wave Devs: %d; WAVE_MAPPER: %d; Selected Input: %ld\n", waveInGetNumDevs(), WAVE_MAPPER, dwdeviceR );
		p = waveInOpen(&r->hMyWaveIn, dwdeviceR, &wfmt, (intptr_t)(&HANDLEMIC), 0, CALLBACK_FUNCTION);
		if( p )
		{
			fprintf( stderr, "Error performing waveInOpen.  Received code: %d\n", p );
		}
		printf( "waveInOpen: %d\n", p );
		for ( i=0;i<BUFFS;i++)
		{
			memset( &(r->WavBuffIn[i]), 0, sizeof(r->WavBuffIn[i]) );
			(r->WavBuffIn[i]).dwBufferLength = r->buffer*2*r->channelsRec;
			(r->WavBuffIn[i]).dwLoops = 1;
			(r->WavBuffIn[i]).lpData=(char*) malloc(r->buffer*r->channelsRec*2);
			printf( "buffer gen size: %d: %p\n", r->buffer*r->channelsRec*2, (r->WavBuffIn[i]).lpData );
			p = waveInPrepareHeader(r->hMyWaveIn,&(r->WavBuffIn[i]),sizeof(WAVEHDR));
			printf( "WIPr: %d\n", p );
			waveInAddBuffer(r->hMyWaveIn,&(r->WavBuffIn[i]),sizeof(WAVEHDR));
			printf( "WIAr: %d\n", p );
		}
		p = waveInStart(r->hMyWaveIn);
		if( p )
		{
			fprintf( stderr, "Error performing waveInStart.  Received code %d\n", p );
		}
	}

	wfmt.nChannels = r->channelsPlay;
	wfmt.nAvgBytesPerSec = r->spsPlay * r->channelsPlay;
	wfmt.nBlockAlign = r->channelsPlay * 2;
	wfmt.nSamplesPerSec = r->spsPlay;

	if( r->channelsPlay )
	{
		int p;
		printf( "Out Wave Devs: %d; WAVE_MAPPER: %d; Selected Input: %ld\n", waveOutGetNumDevs(), WAVE_MAPPER, dwdeviceP );
		p = waveOutOpen( &r->hMyWaveOut, dwdeviceP, &wfmt, (intptr_t)(void*)(&HANDLESINK), (intptr_t)r, CALLBACK_FUNCTION);
		if( p )
		{
			fprintf( stderr, "Error performing waveOutOpen. Received code: %d\n", p );
		}
		printf( "waveOutOpen: %d\n", p );
		for ( i=0;i<BUFFS;i++)
		{
			int size;
			char * buf;
			memset( &(r->WavBuffOut[i]), 0, sizeof(r->WavBuffOut[i]) );
			(r->WavBuffOut[i]).dwBufferLength = r->buffer*2*r->channelsPlay;
			(r->WavBuffOut[i]).dwLoops = 1;
			size = r->buffer*r->channelsPlay*2;
			buf = (r->WavBuffOut[i]).lpData=(char*) malloc(size);
			memset( buf, 0, size );
			p = waveOutPrepareHeader(r->hMyWaveOut,&(r->WavBuffOut[i]),sizeof(WAVEHDR));
			waveOutWrite( r->hMyWaveOut, &(r->WavBuffOut[i]),sizeof(WAVEHDR));
		}
	}
	
	return r;
}



void * InitCNFAWin( CNFACBType cb, const char * your_name, int reqSPSPlay, int reqSPSRec, int reqChannelsPlay, int reqChannelsRec, int sugBufferSize, const char * outputSelect, const char * inputSelect, void * opaque )
{
	struct CNFADriverWin * r = (struct CNFADriverWin *)malloc( sizeof( struct CNFADriverWin ) );
	memset( r, 0, sizeof(*r) );
	r->CloseFn = CloseCNFAWin;
	r->StateFn = CNFAStateWin;
	r->callback = cb;
	r->opaque = opaque;
	r->spsPlay = reqSPSPlay;
	r->spsRec = reqSPSRec;
	r->channelsPlay = reqChannelsPlay;
	r->channelsRec = reqChannelsRec;
	r->buffer = sugBufferSize;
	r->sInputDev = inputSelect?strdup(inputSelect):0;
	r->sOutputDev = outputSelect?strdup(outputSelect):0;

	r->recording = 0;
	r->playing = 0;
	r->isEnding = 0;
	r->GOBUFFPlay = 0;
	r->GOBUFFRec = 0;

	return InitWinCNFA(r);
}

REGISTER_CNFA( WinCNFA, 10, "WIN", InitCNFAWin );


#include <ntverp.h> // This probably won't work on pre-NT systems
#if VER_PRODUCTBUILD >= 7601

//Needed libraries:  -lmmdevapi -lavrt -lole32
//Or DLLs: C:/windows/system32/avrt.dll C:/windows/system32/ole32.dll

#ifdef TCC
#define NO_WIN_HEADERS
#endif

#ifdef  NO_WIN_HEADERS
#ifndef _CNFA_WASAPI_UTILS_H
#define _CNFA_WASAPI_UTILS_H

//#include "ole2.h"

#ifndef REFPROPERTYKEY
#define REFPROPERTYKEY const PROPERTYKEY * __MIDL_CONST
#endif //REFPROPERTYKEY

// Necessary definitions
#define _ANONYMOUS_STRUCT
#define BEGIN_INTERFACE
#define END_INTERFACE
#define DEVICE_STATE_ACTIVE 0x00000001
#define AUDCLNT_STREAMFLAGS_CROSSPROCESS             0x00010000
#define AUDCLNT_STREAMFLAGS_LOOPBACK                 0x00020000
#define AUDCLNT_STREAMFLAGS_EVENTCALLBACK            0x00040000
#define AUDCLNT_STREAMFLAGS_NOPERSIST                0x00080000
#define AUDCLNT_STREAMFLAGS_RATEADJUST               0x00100000
#define AUDCLNT_STREAMFLAGS_PREVENT_LOOPBACK_CAPTURE 0x01000000
#define AUDCLNT_STREAMFLAGS_SRC_DEFAULT_QUALITY      0x08000000
#define AUDCLNT_STREAMFLAGS_AUTOCONVERTPCM           0x80000000
#define AUDCLNT_SESSIONFLAGS_EXPIREWHENUNOWNED       0x10000000
#define AUDCLNT_SESSIONFLAGS_DISPLAY_HIDE            0x20000000
#define AUDCLNT_SESSIONFLAGS_DISPLAY_HIDEWHENEXPIRED 0x40000000
enum _AUDCLNT_BUFFERFLAGS
{
    AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY	= 0x1,
    AUDCLNT_BUFFERFLAGS_SILENT	= 0x2,
    AUDCLNT_BUFFERFLAGS_TIMESTAMP_ERROR	= 0x4
} ;


#ifndef REFIID 
#define REFIID const IID * __MIDL_CONST
#endif

#ifndef PropVariantInit
#define PropVariantInit(pvar) memset ( (pvar), 0, sizeof(PROPVARIANT) )
#endif

#if defined (__TINYC__)
#define _COM_Outptr_
#define _In_
#define _Out_
#define _Outptr_
#define _In_opt_
#define _Out_opt_
#define __RPC__in
#define __RPC__out
#define interface struct
#define CONST_VTBL
#define _Outptr_result_buffer_(X)
#define _Inexpressible_(X)
#define REFPROPVARIANT const PROPVARIANT * __MIDL_CONST
typedef struct tagPROPVARIANT PROPVARIANT;
typedef struct tWAVEFORMATEX WAVEFORMATEX;
typedef IID GUID;
typedef void* HANDLE;

#define CLSCTX_INPROC_SERVER 0x1
#define CLSCTX_INPROC_HANDLER 0x2
#define CLSCTX_LOCAL_SERVER	0x4
#define CLSCTX_REMOTE_SERVER 0x10
#define STGM_READ 0x00000000L
#define CLSCTX_ALL  (CLSCTX_INPROC_SERVER| \
                    CLSCTX_INPROC_HANDLER| \
                    CLSCTX_LOCAL_SERVER| \
                    CLSCTX_REMOTE_SERVER)
typedef unsigned short VARTYPE;

typedef struct _tagpropertykey {
    GUID fmtid;
    DWORD pid;
} PROPERTYKEY;

#ifndef __wtypes_h__
typedef struct tagDEC {
    USHORT wReserved;
    BYTE scale;
    BYTE sign;
    ULONG Hi32;
    ULONGLONG Lo64;
} 	DECIMAL;

// Property varient struct, used for getting the device name info
typedef BYTE PROPVAR_PAD1;
typedef BYTE PROPVAR_PAD2;
typedef ULONG PROPVAR_PAD3;

struct tagPROPVARIANT {
  union {
    struct tag_inner_PROPVARIANT
        {
        VARTYPE vt;
        PROPVAR_PAD1 wReserved1;
        PROPVAR_PAD2 wReserved2;
        PROPVAR_PAD3 wReserved3;
        union 
            {
                double dblVal;   // Filler for the largest object we need to store
                LPWSTR pwszVal;  // This is the only parameter we actually use
            };
        } ;
        DECIMAL decVal;
    };
};

#endif

#define _Inout_updates_(dwCount)
#define FAR


typedef interface IUnknown IUnknown;
typedef  IUnknown *LPUNKNOWN;
#endif

#ifdef NO_WIN_HEADERS
#undef DEFINE_GUID
#define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
        EXTERN_C const GUID DECLSPEC_SELECTANY name \
                = { l, w1, w2, { b1, b2,  b3,  b4,  b5,  b6,  b7,  b8 } }
#undef DEFINE_PROPERTYKEY
#define DEFINE_PROPERTYKEY(name,l,w1,w2,b1,b2,b3,b4,b5,b6,b7,b8,pid) \
        EXTERN_C const PROPERTYKEY DECLSPEC_SELECTANY name \
            = { { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }, pid }

// stuff to be able to read device names
DEFINE_PROPERTYKEY(PKEY_Device_FriendlyName, 0xa45c254e, 0xdf1c, 0x4efd, 0x80, 0x20, 0x67, 0xd1, 0x46, 0xa8, 0x50, 0xe0, 14);

#ifndef WINOLEAPI
#define WINOLEAPI        EXTERN_C DECLSPEC_IMPORT HRESULT STDAPICALLTYPE
#define WINOLEAPI_(type) EXTERN_C DECLSPEC_IMPORT type STDAPICALLTYPE
#endif

// Define necessary functions
WINOLEAPI_(HANDLE) 
AvSetMmThreadCharacteristicsW(LPCWSTR TaskName, LPDWORD TaskIndex);

WINOLEAPI_(BOOL) 
AvRevertMmThreadCharacteristics(HANDLE AvrtHandle);

WINOLEAPI        CoInitialize(LPVOID pvReserved);
WINOLEAPI_(void) CoUninitialize();
WINOLEAPI_(void) CoTaskMemFree(LPVOID pv);

WINOLEAPI CoCreateInstance(
    REFCLSID    rclsid,
    LPUNKNOWN   pUnkOuter,
    DWORD       dwClsContext,
    REFIID      riid,
    LPVOID FAR* ppv);

// WINOLEAPI CoCreateInstanceEx(
//     REFCLSID      Clsid,
//     IUnknown     *punkOuter,
//     DWORD         dwClsCtx,
//     COSERVERINFO *pServerInfo,
//     DWORD         dwCount,
//     MULTI_QI     *pResults );

#endif //NO_WIN_HEADERS

// forward declarations
typedef struct IMMDevice IMMDevice;
typedef struct IMMDeviceCollection IMMDeviceCollection;
typedef struct IMMDeviceEnumerator IMMDeviceEnumerator;
typedef struct IMMNotificationClient IMMNotificationClient;
typedef struct IPropertyStore IPropertyStore;
typedef struct IAudioClient IAudioClient;
typedef struct IAudioCaptureClient IAudioCaptureClient;

// So the linker doesn't complain
extern const IID CLSID_MMDeviceEnumerator;
extern const IID IID_IMMDeviceEnumerator;
extern const IID IID_IAudioClient;
extern const IID CNFA_GUID;
extern const IID IID_IAudioCaptureClient;

typedef enum __MIDL___MIDL_itf_mmdeviceapi_0000_0000_0001
{
    eRender	= 0,
    eCapture	= ( eRender + 1 ) ,
    eAll	= ( eCapture + 1 ) ,
    EDataFlow_enum_count	= ( eAll + 1 ) 
} EDataFlow;

typedef enum __MIDL___MIDL_itf_mmdeviceapi_0000_0000_0002
{
    eConsole	= 0,
    eMultimedia	= ( eConsole + 1 ) ,
    eCommunications	= ( eMultimedia + 1 ) ,
    ERole_enum_count	= ( eCommunications + 1 ) 
} ERole;

typedef struct IMMDeviceEnumeratorVtbl
{
    BEGIN_INTERFACE
    
    HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
        IMMDeviceEnumerator * This,
        /* [in] */ REFIID riid,
        /* [annotation][iid_is][out] */ 
        _COM_Outptr_  void **ppvObject);
    
    ULONG ( STDMETHODCALLTYPE *AddRef )( 
        IMMDeviceEnumerator * This);
    
    ULONG ( STDMETHODCALLTYPE *Release )( 
        IMMDeviceEnumerator * This);
    
    /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *EnumAudioEndpoints )( 
        IMMDeviceEnumerator * This,
        /* [annotation][in] */ 
        _In_  EDataFlow dataFlow,
        /* [annotation][in] */ 
        _In_  DWORD dwStateMask,
        /* [annotation][out] */ 
        _Out_  IMMDeviceCollection **ppDevices);
    
    /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *GetDefaultAudioEndpoint )( 
        IMMDeviceEnumerator * This,
        /* [annotation][in] */ 
        _In_  EDataFlow dataFlow,
        /* [annotation][in] */ 
        _In_  ERole role,
        /* [annotation][out] */ 
        _Out_  IMMDevice **ppEndpoint);
    
    /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *GetDevice )( 
        IMMDeviceEnumerator * This,
        /* [annotation][in] */ 
        _In_  LPCWSTR pwstrId,
        /* [annotation][out] */ 
        _Out_  IMMDevice **ppDevice);
    
    /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *RegisterEndpointNotificationCallback )( 
        IMMDeviceEnumerator * This,
        /* [annotation][in] */ 
        _In_  IMMNotificationClient *pClient);
    
    /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *UnregisterEndpointNotificationCallback )( 
        IMMDeviceEnumerator * This,
        /* [annotation][in] */ 
        _In_  IMMNotificationClient *pClient);
    
    END_INTERFACE
} IMMDeviceEnumeratorVtbl;

interface IMMDeviceEnumerator
{
    CONST_VTBL struct IMMDeviceEnumeratorVtbl *lpVtbl;
};

typedef struct IMMDeviceCollectionVtbl
{
    BEGIN_INTERFACE
    
    HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
        IMMDeviceCollection * This,
        /* [in] */ REFIID riid,
        /* [annotation][iid_is][out] */ 
        _COM_Outptr_  void **ppvObject);
    
    ULONG ( STDMETHODCALLTYPE *AddRef )( 
        IMMDeviceCollection * This);
    
    ULONG ( STDMETHODCALLTYPE *Release )( 
        IMMDeviceCollection * This);
    
    /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *GetCount )( 
        IMMDeviceCollection * This,
        /* [annotation][out] */ 
        _Out_  UINT *pcDevices);
    
    /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Item )( 
        IMMDeviceCollection * This,
        /* [annotation][in] */ 
        _In_  UINT nDevice,
        /* [annotation][out] */ 
        _Out_  IMMDevice **ppDevice);
    
    END_INTERFACE
} IMMDeviceCollectionVtbl;

interface IMMDeviceCollection
{
    CONST_VTBL struct IMMDeviceCollectionVtbl *lpVtbl;
};

typedef struct IMMDeviceVtbl
{
    BEGIN_INTERFACE
    
    HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
        IMMDevice * This,
        /* [in] */ REFIID riid,
        /* [annotation][iid_is][out] */ 
        _COM_Outptr_  void **ppvObject);
    
    ULONG ( STDMETHODCALLTYPE *AddRef )( 
        IMMDevice * This);
    
    ULONG ( STDMETHODCALLTYPE *Release )( 
        IMMDevice * This);
    
    /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *Activate )( 
        IMMDevice * This,
        /* [annotation][in] */ 
        _In_  REFIID iid,
        /* [annotation][in] */ 
        _In_  DWORD dwClsCtx,
        /* [annotation][unique][in] */ 
        _In_opt_  PROPVARIANT *pActivationParams,
        /* [annotation][iid_is][out] */ 
        _Out_  void **ppInterface);
    
    /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *OpenPropertyStore )( 
        IMMDevice * This,
        /* [annotation][in] */ 
        _In_  DWORD stgmAccess,
        /* [annotation][out] */ 
        _Out_  IPropertyStore **ppProperties);
    
    /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *GetId )( 
        IMMDevice * This,
        /* [annotation][out] */ 
        _Outptr_  LPWSTR *ppstrId);
    
    /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *GetState )( 
        IMMDevice * This,
        /* [annotation][out] */ 
        _Out_  DWORD *pdwState);
    
    END_INTERFACE
} IMMDeviceVtbl;

interface IMMDevice
{
    CONST_VTBL struct IMMDeviceVtbl *lpVtbl;
};

typedef struct IMMNotificationClientVtbl
{
    BEGIN_INTERFACE
    
    HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
        IMMNotificationClient * This,
        /* [in] */ REFIID riid,
        /* [annotation][iid_is][out] */ 
        _COM_Outptr_  void **ppvObject);
    
    ULONG ( STDMETHODCALLTYPE *AddRef )( 
        IMMNotificationClient * This);
    
    ULONG ( STDMETHODCALLTYPE *Release )( 
        IMMNotificationClient * This);
    
    /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *OnDeviceStateChanged )( 
        IMMNotificationClient * This,
        /* [annotation][in] */ 
        _In_  LPCWSTR pwstrDeviceId,
        /* [annotation][in] */ 
        _In_  DWORD dwNewState);
    
    /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *OnDeviceAdded )( 
        IMMNotificationClient * This,
        /* [annotation][in] */ 
        _In_  LPCWSTR pwstrDeviceId);
    
    /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *OnDeviceRemoved )( 
        IMMNotificationClient * This,
        /* [annotation][in] */ 
        _In_  LPCWSTR pwstrDeviceId);
    
    /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *OnDefaultDeviceChanged )( 
        IMMNotificationClient * This,
        /* [annotation][in] */ 
        _In_  EDataFlow flow,
        /* [annotation][in] */ 
        _In_  ERole role,
        /* [annotation][in] */ 
        _In_  LPCWSTR pwstrDefaultDeviceId);
    
    /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *OnPropertyValueChanged )( 
        IMMNotificationClient * This,
        /* [annotation][in] */ 
        _In_  LPCWSTR pwstrDeviceId,
        /* [annotation][in] */ 
        _In_  const PROPERTYKEY key);
    
    END_INTERFACE
} IMMNotificationClientVtbl;

interface IMMNotificationClient
{
    CONST_VTBL struct IMMNotificationClientVtbl *lpVtbl;
};

typedef struct IPropertyStoreVtbl
{
    BEGIN_INTERFACE
    
    HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
        __RPC__in IPropertyStore * This,
        /* [in] */ __RPC__in REFIID riid,
        /* [annotation][iid_is][out] */ 
        _COM_Outptr_  void **ppvObject);
    
    ULONG ( STDMETHODCALLTYPE *AddRef )( 
        __RPC__in IPropertyStore * This);
    
    ULONG ( STDMETHODCALLTYPE *Release )( 
        __RPC__in IPropertyStore * This);
    
    HRESULT ( STDMETHODCALLTYPE *GetCount )( 
        __RPC__in IPropertyStore * This,
        /* [out] */ __RPC__out DWORD *cProps);
    
    HRESULT ( STDMETHODCALLTYPE *GetAt )( 
        __RPC__in IPropertyStore * This,
        /* [in] */ DWORD iProp,
        /* [out] */ __RPC__out PROPERTYKEY *pkey);
    
    HRESULT ( STDMETHODCALLTYPE *GetValue )( 
        __RPC__in IPropertyStore * This,
        /* [in] */ __RPC__in REFPROPERTYKEY key,
        /* [out] */ __RPC__out PROPVARIANT *pv);
    
    HRESULT ( STDMETHODCALLTYPE *SetValue )( 
        __RPC__in IPropertyStore * This,
        /* [in] */ __RPC__in REFPROPERTYKEY key,
        /* [in] */ __RPC__in REFPROPVARIANT propvar);
    
    HRESULT ( STDMETHODCALLTYPE *Commit )( 
        __RPC__in IPropertyStore * This);
    
    END_INTERFACE
} IPropertyStoreVtbl;

interface IPropertyStore
{
    CONST_VTBL struct IPropertyStoreVtbl *lpVtbl;
};

// ----- audioclient.h -----

typedef enum _AUDCLNT_SHAREMODE
{ 
    AUDCLNT_SHAREMODE_SHARED, 
    AUDCLNT_SHAREMODE_EXCLUSIVE 
} AUDCLNT_SHAREMODE;

typedef LONGLONG REFERENCE_TIME;

typedef struct IAudioClientVtbl
{
    BEGIN_INTERFACE
    
    HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
        IAudioClient * This,
        /* [in] */ REFIID riid,
        /* [annotation][iid_is][out] */ 
        _COM_Outptr_  void **ppvObject);
    
    ULONG ( STDMETHODCALLTYPE *AddRef )( 
        IAudioClient * This);
    
    ULONG ( STDMETHODCALLTYPE *Release )( 
        IAudioClient * This);
    
    HRESULT ( STDMETHODCALLTYPE *Initialize )( 
        IAudioClient * This,
        /* [annotation][in] */ 
        _In_  AUDCLNT_SHAREMODE ShareMode,
        /* [annotation][in] */ 
        _In_  DWORD StreamFlags,
        /* [annotation][in] */ 
        _In_  REFERENCE_TIME hnsBufferDuration,
        /* [annotation][in] */ 
        _In_  REFERENCE_TIME hnsPeriodicity,
        /* [annotation][in] */ 
        _In_  const WAVEFORMATEX *pFormat,
        /* [annotation][in] */ 
        _In_opt_  LPCGUID AudioSessionGuid);
    
    HRESULT ( STDMETHODCALLTYPE *GetBufferSize )( 
        IAudioClient * This,
        /* [annotation][out] */ 
        _Out_  UINT32 *pNumBufferFrames);
    
    HRESULT ( STDMETHODCALLTYPE *GetStreamLatency )( 
        IAudioClient * This,
        /* [annotation][out] */ 
        _Out_  REFERENCE_TIME *phnsLatency);
    
    HRESULT ( STDMETHODCALLTYPE *GetCurrentPadding )( 
        IAudioClient * This,
        /* [annotation][out] */ 
        _Out_  UINT32 *pNumPaddingFrames);
    
    HRESULT ( STDMETHODCALLTYPE *IsFormatSupported )( 
        IAudioClient * This,
        /* [annotation][in] */ 
        _In_  AUDCLNT_SHAREMODE ShareMode,
        /* [annotation][in] */ 
        _In_  const WAVEFORMATEX *pFormat,
        /* [unique][annotation][out] */ 
        _Out_opt_  WAVEFORMATEX **ppClosestMatch);
    
    HRESULT ( STDMETHODCALLTYPE *GetMixFormat )( 
        IAudioClient * This,
        /* [annotation][out] */ 
        _Out_  WAVEFORMATEX **ppDeviceFormat);
    
    HRESULT ( STDMETHODCALLTYPE *GetDevicePeriod )( 
        IAudioClient * This,
        /* [annotation][out] */ 
        _Out_opt_  REFERENCE_TIME *phnsDefaultDevicePeriod,
        /* [annotation][out] */ 
        _Out_opt_  REFERENCE_TIME *phnsMinimumDevicePeriod);
    
    HRESULT ( STDMETHODCALLTYPE *Start )( 
        IAudioClient * This);
    
    HRESULT ( STDMETHODCALLTYPE *Stop )( 
        IAudioClient * This);
    
    HRESULT ( STDMETHODCALLTYPE *Reset )( 
        IAudioClient * This);
    
    HRESULT ( STDMETHODCALLTYPE *SetEventHandle )( 
        IAudioClient * This,
        /* [in] */ HANDLE eventHandle);
    
    HRESULT ( STDMETHODCALLTYPE *GetService )( 
        IAudioClient * This,
        /* [annotation][in] */ 
        _In_  REFIID riid,
        /* [annotation][iid_is][out] */ 
        _Out_  void **ppv);
    
    END_INTERFACE
} IAudioClientVtbl;

interface IAudioClient
{
    CONST_VTBL struct IAudioClientVtbl *lpVtbl;
};

typedef struct IAudioCaptureClientVtbl
{
    BEGIN_INTERFACE
    
    HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
        IAudioCaptureClient * This,
        /* [in] */ REFIID riid,
        /* [annotation][iid_is][out] */ 
        _COM_Outptr_  void **ppvObject);
    
    ULONG ( STDMETHODCALLTYPE *AddRef )( 
        IAudioCaptureClient * This);
    
    ULONG ( STDMETHODCALLTYPE *Release )( 
        IAudioCaptureClient * This);
    
    HRESULT ( STDMETHODCALLTYPE *GetBuffer )( 
        IAudioCaptureClient * This,
        /* [annotation][out] */ 
        _Outptr_result_buffer_(_Inexpressible_("*pNumFramesToRead * pFormat->nBlockAlign"))  BYTE **ppData,
        /* [annotation][out] */ 
        _Out_  UINT32 *pNumFramesToRead,
        /* [annotation][out] */ 
        _Out_  DWORD *pdwFlags,
        /* [annotation][unique][out] */ 
        _Out_opt_  UINT64 *pu64DevicePosition,
        /* [annotation][unique][out] */ 
        _Out_opt_  UINT64 *pu64QPCPosition);
    
    HRESULT ( STDMETHODCALLTYPE *ReleaseBuffer )( 
        IAudioCaptureClient * This,
        /* [annotation][in] */ 
        _In_  UINT32 NumFramesRead);
    
    HRESULT ( STDMETHODCALLTYPE *GetNextPacketSize )( 
        IAudioCaptureClient * This,
        /* [annotation][out] */ 
        _Out_  UINT32 *pNumFramesInNextPacket);
    
    END_INTERFACE
} IAudioCaptureClientVtbl;

interface IAudioCaptureClient
{
    CONST_VTBL struct IAudioCaptureClientVtbl *lpVtbl;
};

typedef interface IMMEndpoint IMMEndpoint;

    typedef struct IMMEndpointVtbl
    {
        BEGIN_INTERFACE
        
        HRESULT ( STDMETHODCALLTYPE *QueryInterface )( 
            IMMEndpoint * This,
            /* [in] */ REFIID riid,
            /* [annotation][iid_is][out] */ 
            _COM_Outptr_  void **ppvObject);
        
        ULONG ( STDMETHODCALLTYPE *AddRef )( 
            IMMEndpoint * This);
        
        ULONG ( STDMETHODCALLTYPE *Release )( 
            IMMEndpoint * This);
        
        /* [helpstring][id] */ HRESULT ( STDMETHODCALLTYPE *GetDataFlow )( 
            IMMEndpoint * This,
            /* [annotation][out] */ 
            _Out_  EDataFlow *pDataFlow);
        
        END_INTERFACE
    } IMMEndpointVtbl;

    interface IMMEndpoint
    {
        CONST_VTBL struct IMMEndpointVtbl *lpVtbl;
    };

#define DEVICE_STATE_ACTIVE      0x00000001
#define DEVICE_STATE_DISABLED    0x00000002
#define DEVICE_STATE_NOTPRESENT  0x00000004
#define DEVICE_STATE_UNPLUGGED   0x00000008
#define DEVICE_STATEMASK_ALL     0x0000000f

#endif // _CNFA_WASAPI_UTILS_H
#else
#include <InitGuid.h>
#include <audioclient.h> // Render and capturing audio
#include <mmdeviceapi.h> // Audio device handling
#include <Functiondiscoverykeys_devpkey.h> // Property keys for audio devices
#include <avrt.h> // Thread management
#include "windows.h"
#endif

#include "os_generic.h"

#if defined(WIN32) && !defined( TCC )
#pragma comment(lib,"avrt.lib")
#pragma comment(lib,"ole32.lib")
//And maybe mmdevapi.lib
#endif

#define WASAPIPRINT(message) (printf("[CNFA][WASAPI]: %s\n", message))
#define WASAPIERROR(error, message) (printf("[CNFA][WASAPI][ERR]: %s HRESULT: 0x%lX\n", message, error))
#define PRINTGUID(guid) (printf("{%08lX-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X}", guid.Data1, guid.Data2, guid.Data3, guid.Data4[0], guid.Data4[1], guid.Data4[2], guid.Data4[3], guid.Data4[4], guid.Data4[5], guid.Data4[6], guid.Data4[7]))

#define WASAPI_EXTRA_DEBUG FALSE

// Forward declarations
void CloseCNFAWASAPI(void* stateObj);
int CNFAStateWASAPI(void* object);
static struct CNFADriverWASAPI* StartWASAPIDriver(struct CNFADriverWASAPI* initState);
static IMMDevice* WASAPIGetDefaultDevice(BOOL isCapture, BOOL isMultimedia);
static void WASAPIPrintAllDeviceLists();
static void WASAPIPrintDeviceList(EDataFlow dataFlow);
void* ProcessEventAudioIn(void* stateObj);
void* InitCNFAWASAPIDriver(
	CNFACBType callback, const char *session_name,
	int reqSampleRateOut, int reqSampleRateIn,
	int reqChannelsOut, int reqChannelsIn, int sugBufferSize,
	const char * inputDevice, const char * outputDevice,
	void * opaque
);

DEFINE_GUID(CLSID_MMDeviceEnumerator, 0xBCDE0395L, 0xE52F, 0x467C, 0x8E, 0x3D, 0xC4, 0x57, 0x92, 0x91, 0x69, 0x2E);
DEFINE_GUID(IID_IMMDeviceEnumerator, 0xA95664D2L, 0x9614, 0x4F35, 0xA7, 0x46, 0xDE, 0x8D, 0xB6, 0x36, 0x17, 0xE6);
DEFINE_GUID(IID_IMMEndpoint, 0x1BE09788L, 0x6894, 0x4089, 0x85, 0x86, 0x9A, 0x2A, 0x6C, 0x26, 0x5A, 0xC5);
DEFINE_GUID(IID_IAudioClient, 0x1CB9AD4CL, 0xDBFA, 0x4c32, 0xB1, 0x78, 0xC2, 0xF5, 0x68, 0xA7, 0x03, 0xB2);
DEFINE_GUID(IID_IAudioCaptureClient, 0xC8ADBD64L, 0xE71E, 0x48a0, 0xA4, 0xDE, 0x18, 0x5C, 0x39, 0x5C, 0xD3, 0x17);

// This is a fallback if the client application does not provide a GUID.
DEFINE_GUID(CNFA_GUID, 0x899081C7L, 0x9428, 0x4103, 0x87, 0x93, 0x26, 0x47, 0xE5, 0xEA, 0xA2, 0xB4);

struct CNFADriverWASAPI
{
	// Common CNFA items
    void (*CloseFn)(void* object);
	int (*StateFn)(void* object);
	CNFACBType Callback;
	short ChannelCountOut; // Not yet used.
	short ChannelCountIn; // How many cahnnels the input stream has per frame. E.g. stereo = 2.
	int SampleRateOut;
	int SampleRateIn;
	void* Opaque; // Not relevant to us

	// Adjustable WASAPI-specific items
	const char* SessionName; // The name to give our audio sessions. Otherwise, defaults to using embedded EXE name, Window title, or EXE file name directly.
	const GUID* SessionID; // In order to have different CNFA-based applications individually controllable from the volume mixer, this should be set differently for every client program, but constant across all runs/builds of that application.

	// Everything below here is for internal use only. Do not attempt to interact with these items.
	const char* InputDeviceID; // The device to use for getting input from. Can be a render device (operating in loopback), or a capture device.
	const char* OutputDeviceID; // Not yet used.
	IMMDeviceEnumerator* DeviceEnumerator; // The base object that allows us to look through the system's devices, and from there get everything else.
	IMMDevice* Device; // The device we are taking input from.
	IAudioClient* Client; // The base client we use for getting input.
	IAudioCaptureClient* CaptureClient; // The specific client we use for getting input.
	WAVEFORMATEX* MixFormat; // The format of the input stream.
	INT32 BytesPerFrame; // The number of bytes of one full frame of audio. AKA (channel count) * (sample bit depth), in Bytes.
	BOOL StreamReady; // Whether the input stream is ready for data retrieval.
	BOOL KeepGoing; // Whether to continue interacting with the streams, or shutdown the driver.
	og_thread_t ThreadOut; // Not yet used.
	og_thread_t ThreadIn; // The thread used to grab input data.
	HANDLE EventHandleOut; // Not yet used.
	HANDLE EventHandleIn; // The handle used to wait for more input data to be ready in the input thread.
	HANDLE TaskHandleOut; // The task used to request output thread priority changes.
	HANDLE TaskHandleIn; // The task used to request input thread priority changes.
};

// This is where the driver's current state is stored.
static struct CNFADriverWASAPI* WASAPIState;

// Stops streams, ends threads, and cleans up all resources used by the driver.
void CloseCNFAWASAPI(void* stateObj)
{
	struct CNFADriverWASAPI* state = (struct CNFADriverWASAPI*)stateObj;
	if(state != NULL)
	{
		// TODO: See if there are any other items that need cleanup.
		state->KeepGoing = FALSE;
		if (state->ThreadOut != NULL) { OGJoinThread(state->ThreadOut); }
		if (state->ThreadIn != NULL) { OGJoinThread(state->ThreadIn); }
		if (state->EventHandleOut != NULL) { CloseHandle(state->EventHandleOut); }
		if (state->EventHandleIn != NULL) { CloseHandle(state->EventHandleIn); }
		CoTaskMemFree(state->MixFormat);
		if (state->CaptureClient != NULL) { state->CaptureClient->lpVtbl->Release(state->CaptureClient); }
		if (state->Client != NULL) { state->Client->lpVtbl->Release(state->Client); }
		if (state->Device != NULL) { state->Device->lpVtbl->Release(state->Device); }
		if (state->DeviceEnumerator != NULL) { state->DeviceEnumerator->lpVtbl->Release(state->DeviceEnumerator); }
		free(stateObj);
		CoUninitialize();
		printf("[CNFA][WASAPI]: Cleanup completed. Goodbye.\n");
	}
}

// Gets the current state of the driver.
// 0 = No streams active
// 1 = Input stream active
// 2 = Output stream active
// 3 = Both streams active
int CNFAStateWASAPI(void* stateObj)
{
	struct CNFADriverWASAPI* state = (struct CNFADriverWASAPI*)stateObj;
	if(state != NULL)
	{
		if (state->StreamReady) { return 1; } // TODO: Output the correct status when output is implemented.
	}
	return 0;
}

// Reads the desired configuration, interfaces with WASAPI to get the current system information, and starts the input stream.
static struct CNFADriverWASAPI* StartWASAPIDriver(struct CNFADriverWASAPI* initState)
{
	WASAPIState = initState;
	WASAPIState->StreamReady = FALSE;
	WASAPIState->SessionID = &CNFA_GUID;

	HRESULT ErrorCode;
	#ifndef BUILD_DLL
	// A library should never call CoInitialize, as it needs to be done from the host program according to its threading model needs.
	// NOTE: If you are getting errors, and you are using CNFA as a DLL, you need to call CoInitialize yourself with an appropriate threading model for your needs!
	// When the host program is something like ColorChord on the other hand, it cannot be expected to call CoInitialize itself, so we do it on its behalf.
	//   This restricts the threading model of direct consumers of CNFA, but we can address that if it does ever become an issue.
	ErrorCode = CoInitialize(NULL);
	if (FAILED(ErrorCode)) { WASAPIERROR(ErrorCode, "COM INIT FAILED!"); return WASAPIState; }
	#endif

	if(WASAPI_EXTRA_DEBUG)
	{
		printf("[CNFA][WASAPI]: CLSID for MMDeviceEnumerator: ");
		PRINTGUID(CLSID_MMDeviceEnumerator);
		printf("\n[CNFA][WASAPI]: IID for IMMDeviceEnumerator: ");
		PRINTGUID(IID_IMMDeviceEnumerator);
		printf("\n[CNFA][WASAPI]: IID for IAudioClient: ");
		PRINTGUID(IID_IAudioClient);
		printf("\n[CNFA][WASAPI]: IID for IAudioCaptureClient: ");
		PRINTGUID(IID_IAudioCaptureClient);
		printf("\n[CNFA][WASAPI]: IID for IMMEndpoint: ");
		PRINTGUID(IID_IMMEndpoint);
		printf("\n");
	}

	ErrorCode = CoCreateInstance(&CLSID_MMDeviceEnumerator, NULL, CLSCTX_ALL, &IID_IMMDeviceEnumerator, (void**)&(WASAPIState->DeviceEnumerator));
	if (FAILED(ErrorCode)) { WASAPIERROR(ErrorCode, "Failed to get device enumerator. "); return WASAPIState; }

	WASAPIPrintAllDeviceLists();

	// We need to find the appropriate device to use.
	BYTE DeviceDirection = 2; // 0 = Render, 1 = Capture, 2 = Unknown

	if (WASAPIState->InputDeviceID == NULL)
	{
		WASAPIPRINT("No device specified, attempting to use system default multimedia capture device as input.");
		WASAPIState->Device = WASAPIGetDefaultDevice(TRUE, TRUE);
		DeviceDirection = 1;
	}
	else if (strcmp(WASAPIState->InputDeviceID, "defaultRender") == 0)
	{
		WASAPIPRINT("Attempting to use system default render device as input.");
		WASAPIState->Device = WASAPIGetDefaultDevice(FALSE, TRUE);
		DeviceDirection = 0;
	}
	else if (strncmp("defaultCapture", WASAPIState->InputDeviceID, strlen("defaultCapture")) == 0)
	{
		BOOL IsMultimedia = TRUE;
		if (strstr(WASAPIState->InputDeviceID, "Comm") != NULL) { IsMultimedia = FALSE; }
		printf("[CNFA][WASAPI]: Attempting to use system default %s capture device as input.\n", (IsMultimedia ? "multimedia" : "communications"));
		WASAPIState->Device = WASAPIGetDefaultDevice(TRUE, IsMultimedia);
		DeviceDirection = 1;
	}
	else // A specific device was selected by ID.
	{
		LPWSTR DeviceIDasLPWSTR;
		DeviceIDasLPWSTR = malloc((strlen(WASAPIState->InputDeviceID) + 1) * sizeof(WCHAR));
		mbstowcs(DeviceIDasLPWSTR, WASAPIState->InputDeviceID, strlen(WASAPIState->InputDeviceID) + 1);
		printf("[CNFA][WASAPI]: Attempting to find specified device \"%ls\".\n", DeviceIDasLPWSTR);

		ErrorCode = WASAPIState->DeviceEnumerator->lpVtbl->GetDevice(WASAPIState->DeviceEnumerator, DeviceIDasLPWSTR, &(WASAPIState->Device));
		if (FAILED(ErrorCode))
		{
			WASAPIERROR(ErrorCode, "Failed to get audio device from the given ID. Using default multimedia capture device instead.");
			WASAPIState->Device = WASAPIGetDefaultDevice(TRUE, TRUE);
			DeviceDirection = 1;
		}
		else
		{
			printf("[CNFA][WASAPI]: Found specified device.\n");
			DWORD DeviceState;
			ErrorCode = WASAPIState->Device->lpVtbl->GetState(WASAPIState->Device, &DeviceState);
			if (FAILED(ErrorCode)) { WASAPIERROR(ErrorCode, "Failed to get device state."); }

			if ((DeviceState & DEVICE_STATE_DISABLED) == DEVICE_STATE_DISABLED) { WASAPIERROR(E_FAIL, "The specified device is currently disabled."); }
			if ((DeviceState & DEVICE_STATE_NOTPRESENT) == DEVICE_STATE_NOTPRESENT) { WASAPIERROR(E_FAIL, "The specified device is not currently present."); }
			if ((DeviceState & DEVICE_STATE_UNPLUGGED) == DEVICE_STATE_UNPLUGGED) { WASAPIERROR(E_FAIL, "The specified device is currently unplugged."); }
		}
	}

	if (DeviceDirection == 2) // We still don't know what type of device we are trying to use. Query the endpoint to find out.
	{
		IMMEndpoint* Endpoint;
		ErrorCode = WASAPIState->Device->lpVtbl->QueryInterface(WASAPIState->Device, &IID_IMMEndpoint, (void**)&Endpoint);
		if (FAILED(ErrorCode)) { WASAPIERROR(ErrorCode, "Failed to get endpoint of device."); }

		EDataFlow DataFlow;
		ErrorCode = Endpoint->lpVtbl->GetDataFlow(Endpoint, &DataFlow);
		if (FAILED(ErrorCode)) { WASAPIERROR(ErrorCode, "Could not determine endpoint type."); }

		DeviceDirection = (DataFlow == eRender) ? 0 : 1;
		
		if (Endpoint != NULL) { Endpoint->lpVtbl->Release(Endpoint); }
	}

	// We should have a device now.
	char* DeviceDirectionDesc = (DeviceDirection == 0) ? "render" : ((DeviceDirection == 1) ? "capture" : "UNKNOWN");

	LPWSTR DeviceID;
	ErrorCode = WASAPIState->Device->lpVtbl->GetId(WASAPIState->Device, &DeviceID);
	if (FAILED(ErrorCode)) { WASAPIERROR(ErrorCode, "Failed to get audio device ID."); return WASAPIState; }
	else { printf("[CNFA][WASAPI]: Using device ID \"%ls\", which is a %s device.\n", DeviceID, DeviceDirectionDesc); }

	// Start an audio client and get info about the stream format.
	ErrorCode = WASAPIState->Device->lpVtbl->Activate(WASAPIState->Device, &IID_IAudioClient, CLSCTX_ALL, NULL, (void**)&(WASAPIState->Client));
	if (FAILED(ErrorCode)) { WASAPIERROR(ErrorCode, "Failed to get audio client. "); return WASAPIState; }

	ErrorCode = WASAPIState->Client->lpVtbl->GetMixFormat(WASAPIState->Client, &(WASAPIState->MixFormat));
	if (FAILED(ErrorCode)) { WASAPIERROR(ErrorCode, "Failed to get mix format. "); return WASAPIState; }
	printf("[CNFA][WASAPI]: Mix format is %d channel, %luHz sample rate, %db per sample.\n", WASAPIState->MixFormat->nChannels, WASAPIState->MixFormat->nSamplesPerSec, WASAPIState->MixFormat->wBitsPerSample);
	printf("[CNFA][WASAPI]: Mix format is format %d, %dB block-aligned, with %dB of extra data in this definition.\n", WASAPIState->MixFormat->wFormatTag, WASAPIState->MixFormat->nBlockAlign, WASAPIState->MixFormat->cbSize);

	// We'll request PCM, 16bpS data from the system. It should be able to do this conversion for us, as long as we are not in exclusive mode.
	// TODO: This isn't working, no matter what combination I try to ask it for. Figure this out, so we don't have to do the conversion ourselves.
	// Also, we probably don't handle channel counts > 2 with this current setup.
	//WASAPIState->MixFormat->wFormatTag = WAVE_FORMAT_PCM;
	//WASAPIState->MixFormat->wBitsPerSample = 16 * WASAPIState->MixFormat->nChannels;
	//WASAPIState->MixFormat->nBlockAlign = 2 * WASAPIState->MixFormat->nChannels;
	//WASAPIState->MixFormat->nAvgBytesPerSec = WASAPIState->MixFormat->nSamplesPerSec * WASAPIState->MixFormat->nBlockAlign;

	WASAPIState->ChannelCountIn = WASAPIState->MixFormat->nChannels;
	WASAPIState->SampleRateIn = WASAPIState->MixFormat->nSamplesPerSec;
	WASAPIState->BytesPerFrame = WASAPIState->MixFormat->nChannels * (WASAPIState->MixFormat->wBitsPerSample / 8);

	REFERENCE_TIME DefaultInterval, MinimumInterval;
	ErrorCode = WASAPIState->Client->lpVtbl->GetDevicePeriod(WASAPIState->Client, &DefaultInterval, &MinimumInterval);
	if (FAILED(ErrorCode)) { WASAPIERROR(ErrorCode, "Failed to get device timing info. "); return WASAPIState; }
	printf("[CNFA][WASAPI]: Default transaction period is %lld ticks, minimum is %lld ticks.\n", DefaultInterval, MinimumInterval);

	// Configure a capture client.
	UINT32 StreamFlags;
	if (DeviceDirection == 1) { StreamFlags = AUDCLNT_STREAMFLAGS_NOPERSIST | AUDCLNT_STREAMFLAGS_EVENTCALLBACK; }
	else if (DeviceDirection == 0) { StreamFlags = (AUDCLNT_STREAMFLAGS_LOOPBACK | AUDCLNT_STREAMFLAGS_EVENTCALLBACK); }
	else { WASAPIPRINT("[ERR] Device type was not determined!"); return WASAPIState; }

	// TODO: Allow the target application to influence the interval we choose. Super realtime apps may require MinimumInterval.
	ErrorCode = WASAPIState->Client->lpVtbl->Initialize(WASAPIState->Client, AUDCLNT_SHAREMODE_SHARED, StreamFlags, DefaultInterval, DefaultInterval, WASAPIState->MixFormat, WASAPIState->SessionID);
	if (FAILED(ErrorCode)) { WASAPIERROR(ErrorCode, "Could not init audio client."); return WASAPIState; }

	WASAPIState->EventHandleIn = CreateEvent(NULL, FALSE, FALSE, NULL);
	if (WASAPIState->EventHandleIn == NULL) { WASAPIERROR(E_FAIL, "Failed to make event handle."); return WASAPIState; }

	ErrorCode = WASAPIState->Client->lpVtbl->SetEventHandle(WASAPIState->Client, WASAPIState->EventHandleIn);
	if (FAILED(ErrorCode)) { WASAPIERROR(ErrorCode, "Failed to set event handler."); return WASAPIState; }

	UINT32 BufferFrameCount;
	ErrorCode = WASAPIState->Client->lpVtbl->GetBufferSize(WASAPIState->Client, &BufferFrameCount);
	if (FAILED(ErrorCode)) { WASAPIERROR(ErrorCode, "Could not get audio client buffer size."); return WASAPIState; }

	ErrorCode = WASAPIState->Client->lpVtbl->GetService(WASAPIState->Client, &IID_IAudioCaptureClient, (void**)&(WASAPIState->CaptureClient));
	if (FAILED(ErrorCode)) { WASAPIERROR(ErrorCode, "Could not get audio capture client."); return WASAPIState; }
	
	// Begin capturing audio. It will be received on a separate thread.
	ErrorCode = WASAPIState->Client->lpVtbl->Start(WASAPIState->Client);
	if (FAILED(ErrorCode)) { WASAPIERROR(ErrorCode, "Could not start audio client."); return WASAPIState; }
	WASAPIState->StreamReady = TRUE;

	WASAPIState->KeepGoing = TRUE;
	WASAPIState->ThreadIn = OGCreateThread(ProcessEventAudioIn, WASAPIState);

	return WASAPIState;
}

// Gets the default render or capture device.
// isCapture: If true, gets the default capture device, otherwise gets the default render device.
// isMultimedia: If true, gets the system default devide for "multimedia" use, otheriwse for "communication" use.
static IMMDevice* WASAPIGetDefaultDevice(BOOL isCapture, BOOL isMultimedia)
{
	HRESULT ErrorCode;
	IMMDevice* Device;
	ErrorCode = WASAPIState->DeviceEnumerator->lpVtbl->GetDefaultAudioEndpoint(WASAPIState->DeviceEnumerator, isCapture ? eCapture : eRender, isMultimedia ? eMultimedia : eCommunications, &Device);
	if (FAILED(ErrorCode))
	{
		WASAPIERROR(ErrorCode, "Failed to get default device.");
		return NULL;
	}
	return Device;
}

// Prints all available devices to the console.
static void WASAPIPrintAllDeviceLists()
{
	WASAPIPrintDeviceList(eRender);
	WASAPIPrintDeviceList(eCapture);
}

// Prints a list of all available devices of a specified data flow direction to the console.
static void WASAPIPrintDeviceList(EDataFlow dataFlow)
{
	printf("[CNFA][WASAPI]: %s Devices:\n", (dataFlow == eCapture ? "Capture" : "Render"));
	IMMDeviceCollection* Devices;
	HRESULT ErrorCode = WASAPIState->DeviceEnumerator->lpVtbl->EnumAudioEndpoints(WASAPIState->DeviceEnumerator, dataFlow, (WASAPI_EXTRA_DEBUG ? DEVICE_STATEMASK_ALL : DEVICE_STATE_ACTIVE), &Devices);
	if (FAILED(ErrorCode)) { WASAPIERROR(ErrorCode, "Failed to get audio endpoints."); return; }

	UINT32 DeviceCount;
	ErrorCode = Devices->lpVtbl->GetCount(Devices, &DeviceCount);
	if (FAILED(ErrorCode)) { WASAPIERROR(ErrorCode, "Failed to get audio endpoint count."); return; }

	for (UINT32 DeviceIndex = 0; DeviceIndex < DeviceCount; DeviceIndex++)
	{
		IMMDevice* Device;
		ErrorCode = Devices->lpVtbl->Item(Devices, DeviceIndex, &Device);
		if (FAILED(ErrorCode)) { WASAPIERROR(ErrorCode, "Failed to get audio device."); continue; }

		LPWSTR DeviceID;
		ErrorCode = Device->lpVtbl->GetId(Device, &DeviceID);
		if (FAILED(ErrorCode)) { WASAPIERROR(ErrorCode, "Failed to get audio device ID."); continue; }

		IPropertyStore* Properties;
		ErrorCode = Device->lpVtbl->OpenPropertyStore(Device, STGM_READ, &Properties);
		if (FAILED(ErrorCode)) { WASAPIERROR(ErrorCode, "Failed to get device properties."); continue; }
		
		PROPVARIANT Variant;
		PropVariantInit(&Variant);

		ErrorCode = Properties->lpVtbl->GetValue(Properties, &PKEY_Device_FriendlyName, &Variant);
		if (FAILED(ErrorCode)) { WASAPIERROR(ErrorCode, "Failed to get device friendly name."); }

		LPWSTR DeviceFriendlyName = L"[Name Retrieval Failed]";
		if (Variant.pwszVal != NULL) { DeviceFriendlyName = Variant.pwszVal; }

		printf("[CNFA][WASAPI]: [%d]: \"%ls\" = \"%ls\"\n", DeviceIndex, DeviceFriendlyName, DeviceID);

		CoTaskMemFree(DeviceID);
		DeviceID = NULL;
		PropVariantClear(&Variant);
		if (Properties != NULL) { Properties->lpVtbl->Release(Properties); }
		if (Device != NULL) { Device->lpVtbl->Release(Device); }
	}

	if (Devices != NULL) { Devices->lpVtbl->Release(Devices); }
}

// Runs on a thread. Waits for audio data to be ready from the system, then forwards it to the registered callback.
void* ProcessEventAudioIn(void* stateObj)
{
	struct CNFADriverWASAPI* state = (struct CNFADriverWASAPI*)stateObj;
	HRESULT ErrorCode;
	UINT32 PacketLength;

	// TODO: Set this based on our device period requested. If we are using 10ms or higher, just request "Audio", not "Pro Audio".
	DWORD TaskIndex = 0;
	state->TaskHandleIn = AvSetMmThreadCharacteristicsW(L"Pro Audio", &TaskIndex);
	if (state->TaskHandleIn == NULL) { WASAPIERROR(E_FAIL, "Failed to request thread priority elevation on input task."); }

	while (state->KeepGoing)
	{
		// Waits up to 500ms to get the next audio buffer from the system.
		// The timeout is used because if no audio sessions are active, WASAPI stops sending buffers after a few that indicate silence.
		// This means that if the client tries to exit, this loop would not complete, and therefore the thread would not exit, until the next buffer is received.
		// This is mostly an issue in loopback mode, where true silence is common, not so much on microphones.
		DWORD WaitResult = WaitForSingleObject(state->EventHandleIn, 500);
		if (WaitResult == WAIT_TIMEOUT) { continue; } // We are in a period of silence. Keep waiting for audio.
		else if (WaitResult != WAIT_OBJECT_0) { WASAPIERROR(E_FAIL, "Something went wrong while waiting for an audio event."); continue; }

		ErrorCode = state->CaptureClient->lpVtbl->GetNextPacketSize(state->CaptureClient, &PacketLength);
		if (FAILED(ErrorCode)) { WASAPIERROR(ErrorCode, "Failed to get audio packet size."); continue; }

		BYTE* DataBuffer;
		UINT32 FramesAvailable;
		DWORD BufferStatus;
		BOOL Released = FALSE;
		ErrorCode = state->CaptureClient->lpVtbl->GetBuffer(state->CaptureClient, &DataBuffer, &FramesAvailable, &BufferStatus, NULL, NULL);
		if (FAILED(ErrorCode)) { WASAPIERROR(ErrorCode, "Failed to get audio buffer."); continue; }

		// "The data in the packet is not correlated with the previous packet's device position; this is possibly due to a stream state transition or timing glitch."
		// There's no real way for us to notify the client about this...
		if ((BufferStatus & AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY) == AUDCLNT_BUFFERFLAGS_DATA_DISCONTINUITY)
		{
			WASAPIPRINT("A data discontinuity was detected.");
		}

		if ((BufferStatus & AUDCLNT_BUFFERFLAGS_SILENT) == AUDCLNT_BUFFERFLAGS_SILENT)
		{
			UINT32 Length = FramesAvailable * state->MixFormat->nChannels;
			if (Length == 0) { Length = state->MixFormat->nChannels; }
			INT16* AudioData = malloc(Length * 2);
			for (int i = 0; i < Length; i++) { AudioData[i] = 0; }

			ErrorCode = state->CaptureClient->lpVtbl->ReleaseBuffer(state->CaptureClient, FramesAvailable);
			if (FAILED(ErrorCode)) { WASAPIERROR(ErrorCode, "Failed to release audio buffer."); }
			else { Released = TRUE; }

			if (WASAPI_EXTRA_DEBUG) { printf("[CNFA][WASAPI]: SILENCE buffer received. Passing on %d samples.\n", Length); }

			WASAPIState->Callback((struct CNFADriver*)WASAPIState, 0, AudioData, 0, Length / state->MixFormat->nChannels );
			free(AudioData);
		}
		else
		{
			// TODO: This assumes that data is coming in at 32b float format. While this appears to be the format that WASAPI uses internally in all cases I've seen, I don't think it's guaranteed.
			// We should instead read the MixFormat information and properly handle the data in other cases.
			// Ideally, we could request 16b signed PCM data from WASAPI, so we don't even have to do any conversion. But I couldn't get this working yet.
			UINT32 Size = FramesAvailable * state->BytesPerFrame; // Size in bytes
			FLOAT* DataAsFloat = (FLOAT*)DataBuffer; // The raw input data, reinterpreted as floats.
			INT16* AudioData = malloc((FramesAvailable * state->MixFormat->nChannels) * 2); // The data we are passing to the consumer.
			for (INT32 i = 0; i < Size / 4; i++) { AudioData[i] = (INT16)(DataAsFloat[i] * 32767.5F); }

			ErrorCode = state->CaptureClient->lpVtbl->ReleaseBuffer(state->CaptureClient, FramesAvailable);
			if (FAILED(ErrorCode)) { WASAPIERROR(ErrorCode, "Failed to release audio buffer."); }
			else { Released = TRUE; }

			if (WASAPI_EXTRA_DEBUG) { printf("[CNFA][WASAPI]: Got %d bytes of audio data in %d frames. Fowarding to %p.\n", Size, FramesAvailable, (void*) WASAPIState->Callback); }

			WASAPIState->Callback((struct CNFADriver*)WASAPIState, 0, AudioData, 0, FramesAvailable );
			free(AudioData);
		}

		if (!Released)
		{
			ErrorCode = state->CaptureClient->lpVtbl->ReleaseBuffer(state->CaptureClient, FramesAvailable);
			if (FAILED(ErrorCode)) { WASAPIERROR(ErrorCode, "Failed to release audio buffer."); }
		}

	}

	ErrorCode = state->Client->lpVtbl->Stop(state->Client);
	if (FAILED(ErrorCode)) { WASAPIERROR(ErrorCode, "Failed to stop audio client."); }
	
	if(state->TaskHandleIn != NULL) { AvRevertMmThreadCharacteristics(state->TaskHandleIn); }

	state->StreamReady = FALSE;
	return 0;
}

// Begins preparation of the WASAPI driver.
// callback: The user application's function where audio data is placed when received from the system and/or audio data is retrieved from to give to the system.
// sessionName: How your session will appear to the end user if you play audio.
// reqSampleRateIn/Out: Sample rate you'd like to request. Ignored, as this is determined by the system. See note below.
// reqChannelsIn: Input channel count you'd like to request. Ignored, as this is determined by the system. See note below.
// reqChannelsOut: Output channel count you'd like to request. Ignored, as this is determined by the system. See note below.
// sugBufferSize: Buffer size you'd like to request. Ignored, as this is determined by the system. See note below.
// inputDevice: The device you want to receive audio from. Loopback is supported, so this can be either a capture or render device.
//              To get the default render device, specify "defaultRender"
//              To get the default multimedia capture device, specify "defaultCapture"
//              To get the default communications capture device, specify "defaultCaptureComm"
//              A device ID as presented by WASAPI can be specified, regardless of what type it is. If it is invalid, the default capture device is used as fallback.
//              If you do not wish to receive audio, specify null. NOT YET IMPLEMENTED
// outputDevice: The device you want to output audio to. OUTPUT IS NOT IMPLEMENTED.
// NOTES:
// Regarding format requests: Sample rate and channel count is determined by the system settings, and cannot be changed. Resampling/mixing will be required in your application if you cannot accept the current system mode. Make sure to check `WASAPIState` for the current system mode.
//                            Note also that both sample rate and channel count can vary between input and output!
// Currently audio output (playing) is not yet implemented.
void* InitCNFAWASAPIDriver(
	CNFACBType callback, const char *sessionName,
	int reqSampleRateOut, int reqSampleRateIn,
	int reqChannelsOut, int reqChannelsIn, int sugBufferSize,
	const char * outputDevice, const char * inputDevice,
	void * opaque)
{
	struct CNFADriverWASAPI * InitState = malloc(sizeof(struct CNFADriverWASAPI));
	memset(InitState, 0, sizeof(*InitState));
	InitState->CloseFn = CloseCNFAWASAPI;
	InitState->StateFn = CNFAStateWASAPI;
	InitState->Callback = callback;
	InitState->Opaque = opaque;
	// TODO: Waiting for CNFA to support directional sample rates.
	InitState->SampleRateIn = reqSampleRateIn; // Will be overridden by the actual system setting.
	InitState->SampleRateOut = reqSampleRateOut; // Will be overridden by the actual system setting.
	InitState->ChannelCountIn = reqChannelsIn; // Will be overridden by the actual system setting.
	InitState->ChannelCountOut = reqChannelsOut; // Will be overridden by the actual system setting.
	InitState->InputDeviceID = inputDevice;
	InitState->OutputDeviceID = outputDevice;

	InitState->SessionName = sessionName;

	WASAPIPRINT("WASAPI Init");

	return StartWASAPIDriver(InitState);
}

REGISTER_CNFA(cnfa_wasapi, 20, "WASAPI", InitCNFAWASAPIDriver);

#endif
#elif CNFA_ANDROID
//Copyright 2019-2020 <>< Charles Lohr under the ColorChord License, MIT/x11 license or NewBSD Licenses.
// This was originally to be used with rawdrawandroid

#include "os_generic.h"
#include <pthread.h> //Using android threads not os_generic threads.
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

//based on https://github.com/android/ndk-samples/blob/master/native-audio/app/src/main/cpp/native-audio-jni.c

// for native audio
#include <SLES/OpenSLES.h>
#include <SLES/OpenSLES_Android.h>

#include <android_native_app_glue.h>
#include <jni.h>
#include <native_activity.h>

struct CNFADriverAndroid
{
	//Standard header - must remain.
	void (*CloseFn)( void * object );
	int (*StateFn)( void * object );
	CNFACBType callback;
	short channelsPlay;
	short channelsRec;
	int spsPlay;
	int spsRec;
	void * opaque;

	int buffsz;

	SLObjectItf engineObject;
	SLEngineItf engineEngine;
	SLRecordItf recorderRecord;
	SLObjectItf recorderObject;

	SLPlayItf playerPlay;
	SLObjectItf playerObject;
	SLObjectItf outputMixObject;
 
	SLAndroidSimpleBufferQueueItf recorderBufferQueue;
	SLAndroidSimpleBufferQueueItf playerBufferQueue;
	//unsigned recorderSize;

	int recorderBufferSizeBytes;
	int playerBufferSizeBytes;
	short * recorderBuffer;
	short * playerBuffer;
};


void bqRecorderCallback(SLAndroidSimpleBufferQueueItf bq, void *context)
{
	struct CNFADriverAndroid * r = (struct CNFADriverAndroid*)context;
	r->callback( (struct CNFADriver*)r, 0, r->recorderBuffer, 0, r->buffsz/(sizeof(short)*r->channelsRec) );
	(*r->recorderBufferQueue)->Enqueue( r->recorderBufferQueue, r->recorderBuffer, r->recorderBufferSizeBytes/(r->channelsRec*sizeof(short)) );
}

void bqPlayerCallback(SLAndroidSimpleBufferQueueItf bq, void *context)
{
	struct CNFADriverAndroid * r = (struct CNFADriverAndroid*)context;
	r->callback( (struct CNFADriver*)r, r->playerBuffer, 0, r->buffsz/(sizeof(short)*r->channelsPlay), 0 );
	(*r->playerBufferQueue)->Enqueue( r->playerBufferQueue, r->playerBuffer, r->playerBufferSizeBytes/(r->channelsPlay*sizeof(short)));
}

static struct CNFADriverAndroid* InitAndroidDriver( struct CNFADriverAndroid * r )
{
	SLresult result;
	printf( "Starting InitAndroidDriver\n" );
	
	// create engine
	result = slCreateEngine(&r->engineObject, 0, NULL, 0, NULL, NULL);
	assert(SL_RESULT_SUCCESS == result);
	(void)result;

	// realize the engine
	result = (*r->engineObject)->Realize(r->engineObject, SL_BOOLEAN_FALSE);
	assert(SL_RESULT_SUCCESS == result);
	(void)result;

	// get the engine interface, which is needed in order to create other objects
	result = (*r->engineObject)->GetInterface(r->engineObject, SL_IID_ENGINE, &r->engineEngine);
	assert(SL_RESULT_SUCCESS == result);
	(void)result;


	///////////////////////////////////////////////////////////////////////////////////////////////////////
	if( r->channelsPlay )
	{
		printf("create output mix");

		SLDataFormat_PCM format_pcm ={
			SL_DATAFORMAT_PCM,
			r->channelsPlay,
			r->spsPlay*1000,
			SL_PCMSAMPLEFORMAT_FIXED_16,
			SL_PCMSAMPLEFORMAT_FIXED_16,
			(r->channelsPlay==1)?SL_SPEAKER_FRONT_CENTER:3,
			SL_BYTEORDER_LITTLEENDIAN,
		};
		SLDataLocator_AndroidSimpleBufferQueue loc_bq_play = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 2};
		SLDataSource source = {&loc_bq_play, &format_pcm};
		const SLInterfaceID ids[1] = {SL_IID_VOLUME};
		const SLboolean req[1] = {SL_BOOLEAN_TRUE};
		const SLInterfaceID id[1] = {SL_IID_ANDROIDSIMPLEBUFFERQUEUE};

		result = (*r->engineEngine)->CreateOutputMix(r->engineEngine, &r->outputMixObject, 0, ids, req);
		result = (*r->outputMixObject)->Realize(r->outputMixObject, SL_BOOLEAN_FALSE);

		SLDataLocator_OutputMix loc_outmix = { SL_DATALOCATOR_OUTPUTMIX, r->outputMixObject };
		SLDataSink sink;
		sink.pFormat = &format_pcm;
		sink.pLocator = &loc_outmix;

		// create audio player
		result = (*r->engineEngine)->CreateAudioPlayer(r->engineEngine, &r->playerObject, &source, &sink, 1, id, req);
		if (SL_RESULT_SUCCESS != result) {
			printf( "CreateAudioPlayer failed\n" );
			return JNI_FALSE;
		}


		// realize the audio player
		result = (*r->playerObject)->Realize(r->playerObject, SL_BOOLEAN_FALSE);
		if (SL_RESULT_SUCCESS != result) {
			printf( "AudioPlayer Realize failed: %d\n", result );
			return JNI_FALSE;
		}

		// get the player interface
		result = (*r->playerObject)->GetInterface(r->playerObject, SL_IID_PLAY, &r->playerPlay);
		assert(SL_RESULT_SUCCESS == result);
		(void)result;

		// get the buffer queue interface
		result = (*r->playerObject)->GetInterface(r->playerObject, SL_IID_ANDROIDSIMPLEBUFFERQUEUE, &r->playerBufferQueue);
		assert(SL_RESULT_SUCCESS == result);
		(void)result;

		// register callback on the buffer queue
		result = (*r->playerBufferQueue)->RegisterCallback(r->playerBufferQueue, bqPlayerCallback, r);
		assert(SL_RESULT_SUCCESS == result);
		(void)result;

		printf( "===================== Player init ok.\n" );
	}

	if( r->channelsRec )
	{
		// configure audio source
		SLDataLocator_IODevice loc_devI = {SL_DATALOCATOR_IODEVICE, SL_IODEVICE_AUDIOINPUT, SL_DEFAULTDEVICEID_AUDIOINPUT, NULL};
		SLDataSource audioSrc = {&loc_devI, NULL};

		// configure audio sink
		SLDataFormat_PCM format_pcm ={
			SL_DATAFORMAT_PCM,
			r->channelsRec, 
			r->spsRec*1000,
			SL_PCMSAMPLEFORMAT_FIXED_16,
			SL_PCMSAMPLEFORMAT_FIXED_16,
			(r->channelsRec==1)?SL_SPEAKER_FRONT_CENTER:3,
			SL_BYTEORDER_LITTLEENDIAN,
		};
		SLDataLocator_AndroidSimpleBufferQueue loc_bq = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, 2};
		SLDataSink audioSnk = {&loc_bq, &format_pcm};


		const SLInterfaceID id[1] = {SL_IID_ANDROIDSIMPLEBUFFERQUEUE};
		const SLboolean req[1] = {SL_BOOLEAN_TRUE};

		result = (*r->engineEngine)->CreateAudioRecorder(r->engineEngine, &r->recorderObject, &audioSrc, &audioSnk, 1, id, req);
		if (SL_RESULT_SUCCESS != result) {
			printf( "CreateAudioRecorder failed\n" );
			return JNI_FALSE;
		}

		// realize the audio recorder
		result = (*r->recorderObject)->Realize(r->recorderObject, SL_BOOLEAN_FALSE);
		if (SL_RESULT_SUCCESS != result) {
			printf( "AudioRecorder Realize failed: %d\n", result );
			return JNI_FALSE;
		}

		// get the record interface
		result = (*r->recorderObject)->GetInterface(r->recorderObject, SL_IID_RECORD, &r->recorderRecord);
		assert(SL_RESULT_SUCCESS == result);
		(void)result;

		// get the buffer queue interface
		result = (*r->recorderObject)->GetInterface(r->recorderObject, SL_IID_ANDROIDSIMPLEBUFFERQUEUE,	&r->recorderBufferQueue);
		assert(SL_RESULT_SUCCESS == result);
		(void)result;

		// register callback on the buffer queue
		result = (*r->recorderBufferQueue)->RegisterCallback(r->recorderBufferQueue, bqRecorderCallback, r);
		assert(SL_RESULT_SUCCESS == result);
		(void)result;
	}


	if( r->playerPlay )
	{
		result = (*r->playerPlay)->SetPlayState(r->playerPlay, SL_PLAYSTATE_STOPPED);
		assert(SL_RESULT_SUCCESS == result); (void)result;
		result = (*r->playerBufferQueue)->Clear(r->playerBufferQueue);
		assert(SL_RESULT_SUCCESS == result); (void)result;
		r->playerBuffer = malloc( r->playerBufferSizeBytes );
		memset( r->playerBuffer, 0, r->playerBufferSizeBytes );
		result = (*r->playerBufferQueue)->Enqueue(r->playerBufferQueue, r->playerBuffer, r->playerBufferSizeBytes );
		assert(SL_RESULT_SUCCESS == result); (void)result;
		result = (*r->playerPlay)->SetPlayState(r->playerPlay, SL_PLAYSTATE_PLAYING);
		assert(SL_RESULT_SUCCESS == result); (void)result;
	}


	if( r->recorderRecord )
	{
		result = (*r->recorderRecord)->SetRecordState(r->recorderRecord, SL_RECORDSTATE_STOPPED);
		assert(SL_RESULT_SUCCESS == result); (void)result;
		result = (*r->recorderBufferQueue)->Clear(r->recorderBufferQueue);
		assert(SL_RESULT_SUCCESS == result); (void)result;
		// the buffer is not valid for playback yet

		r->recorderBuffer = malloc( r->recorderBufferSizeBytes );

		// enqueue an empty buffer to be filled by the recorder
		// (for streaming recording, we would enqueue at least 2 empty buffers to start things off)
		result = (*r->recorderBufferQueue)->Enqueue(r->recorderBufferQueue, r->recorderBuffer, r->recorderBufferSizeBytes );
		// the most likely other result is SL_RESULT_BUFFER_INSUFFICIENT,
		// which for this code example would indicate a programming error
		assert(SL_RESULT_SUCCESS == result); (void)result;

		// start recording
		result = (*r->recorderRecord)->SetRecordState(r->recorderRecord, SL_RECORDSTATE_RECORDING);
		assert(SL_RESULT_SUCCESS == result); (void)result;
	}


	printf( "Complete Init Sound Android\n" );
	return r;
}

int CNFAStateAndroid( void * v )
{
	struct CNFADriverAndroid * soundobject = (struct CNFADriverAndroid *)v;
	return ((soundobject->recorderObject)?1:0) | ((soundobject->playerObject)?2:0);
}

void CloseCNFAAndroid( void * v )
{
	struct CNFADriverAndroid * r = (struct CNFADriverAndroid *)v;
    // destroy audio recorder object, and invalidate all associated interfaces
    if (r->recorderObject != NULL) {
        (*r->recorderObject)->Destroy(r->recorderObject);
        r->recorderObject = NULL;
        r->recorderRecord = NULL;
        r->recorderBufferQueue = NULL;
		if( r->recorderBuffer ) free( r->recorderBuffer );
    }


    if (r->playerObject != NULL) {
        (*r->playerObject)->Destroy(r->playerObject);
        r->playerObject = NULL;
        r->playerPlay = NULL;
        r->playerBufferQueue = NULL;
		if( r->playerBuffer ) free( r->playerBuffer );
    }


    // destroy engine object, and invalidate all associated interfaces
    if (r->engineObject != NULL) {
        (*r->engineObject)->Destroy(r->engineObject);
        r->engineObject = NULL;
        r->engineEngine = NULL;
    }

}


int AndroidHasPermissions(const char* perm_name);
void AndroidRequestAppPermissions(const char * perm);


void * InitCNFAAndroid( CNFACBType cb, const char * your_name, int reqSPSPlay, int reqSPSRec, int reqChannelsPlay, int reqChannelsRec, int sugBufferSize, const char * outputSelect, const char * inputSelect, void * opaque )
{
	struct CNFADriverAndroid * r = (struct CNFADriverAndroid *)malloc( sizeof( struct CNFADriverAndroid ) );
	memset( r, 0, sizeof( *r) );
	r->CloseFn = CloseCNFAAndroid;
	r->StateFn = CNFAStateAndroid;
	r->callback = cb;
	r->opaque = opaque;
	r->channelsPlay = reqChannelsPlay;
	r->channelsRec = reqChannelsRec;
	r->spsRec = reqSPSRec;
	r->spsPlay = reqSPSPlay;
	
	r->recorderBufferSizeBytes = sugBufferSize * 2 * r->channelsRec;
	r->playerBufferSizeBytes = sugBufferSize * 2 * r->channelsPlay;

	int hasperm = AndroidHasPermissions( "RECORD_AUDIO" );
	if( !hasperm )
	{
		AndroidRequestAppPermissions( "RECORD_AUDIO" );
	}
	
	r->buffsz = sugBufferSize;

	return InitAndroidDriver(r);
}

//Tricky: On Android, this can't actually run before main.  Have to manually execute it.

REGISTER_CNFA( AndroidCNFA, 10, "ANDROID", InitCNFAAndroid );


#elif CNFA_SUN
//Copyright 2015-2020 <>< Charles Lohr under the MIT/x11, NewBSD or ColorChord License.  You choose.

#include "os_generic.h"
#include <sys/audioio.h>
#include <sys/ioctl.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>

#define SUN_PRINT_PREFIX "[CNFA][Sun]: "

struct CNFADriverSun
{
	void (*CloseFn)( void * object );
	int (*StateFn)( void * object );
	CNFACBType callback;
	short channelsPlay;
	short channelsRec;
	int spsPlay;
	int spsRec;
	void * opaque;

	char * devRec;
	char * devPlay;

	short * samplesRec;
	short * samplesPlay;

	og_thread_t threadPlay;
	og_thread_t threadRec;
	int bufsize;
	int playback_handle;
	int record_handle;

	char playing;
	char recording;
};

int CNFAStateSun( void * v )
{
	struct CNFADriverSun * r = (struct CNFADriverSun *)v;
	return ((r->playing)?2:0) | ((r->recording)?1:0);
}

void CloseCNFASun( void * v )
{
	struct CNFADriverSun * r = (struct CNFADriverSun *)v;
	if( r )
	{
		if( r->threadPlay ) OGJoinThread( r->threadPlay );
		if( r->threadRec ) OGJoinThread( r->threadRec );

		OGUSleep(2000);

		if( r->playback_handle != -1 ) close (r->playback_handle);
		if( r->record_handle != -1 ) close (r->record_handle);

		OGUSleep(2000);

		free( r->devRec );
		free( r->devPlay );
		free( r->samplesRec );
		free( r->samplesPlay );
		free( r );
	}
}


void * RecThread( void * v )
{
	struct CNFADriverSun * r = (struct CNFADriverSun *)v;
	size_t nbytes = r->bufsize * (2 * r->channelsRec);
	do
	{
		int nread = read( r->record_handle, r->samplesRec, nbytes );
		if( nread < 0 )
		{
			fprintf( stderr, SUN_PRINT_PREFIX"Recording Failed\n" );
			break;
		}
		r->recording = 1;
		r->callback( (struct CNFADriver *)r, NULL, r->samplesRec, 0, (nread / 2) / r->channelsRec);
	} while( 1 );
	r->recording = 0;
	fprintf( stderr, SUN_PRINT_PREFIX"Recording Stopped\n" );
	return 0;
}

void * PlayThread( void * v )
{
	struct CNFADriverSun * r = (struct CNFADriverSun *)v;
	size_t nbytes = r->bufsize * (2 * r->channelsPlay);
	int err;

	r->callback( (struct CNFADriver *)r, r->samplesPlay, NULL, r->bufsize, 0 );
	err = write( r->playback_handle, r->samplesPlay, nbytes );

	while( err >= 0 )
	{
		r->callback( (struct CNFADriver *)r, r->samplesPlay, NULL, r->bufsize, 0 );
		err = write( r->playback_handle, r->samplesPlay, nbytes );
		r->playing = 1;
	}
	r->playing = 0;
	fprintf( stderr, SUN_PRINT_PREFIX"Playback Stopped\n" );
	return 0;
}

static struct CNFADriverSun * InitSun( struct CNFADriverSun * r )
{
	const char * devPlay = r->devPlay;
	const char * devRec = r->devRec;
	struct audio_info rinfo, pinfo;

	if( devRec == NULL || strcmp ( devRec, "default" ) == 0 )
	{
		devRec = "/dev/audio";
	}

	if( devPlay == NULL || strcmp ( devPlay , "default" ) == 0 )
	{
		devPlay = "/dev/audio";
	}

	printf( SUN_PRINT_PREFIX"Init -> devPlay: %s, channelsPlay: %d, spsPlay: %d, devRec: %s, channelsRec: %d, spsRec: %d\n", devPlay, r->channelsPlay, r->spsPlay, devRec, r->channelsRec, r->spsRec);

	if( r->channelsPlay && r->channelsRec && strcmp (devPlay, devRec) == 0 )
	{
		if ( (r->playback_handle = r->record_handle = open (devPlay, O_RDWR)) < 0 )
		{
			fprintf (stderr, SUN_PRINT_PREFIX"cannot open audio device (%s)\n", 
				 strerror (errno));
			goto fail;
		}
	}
	else
	{
		if( r->channelsPlay )
		{
			if ( (r->playback_handle = open (devPlay, O_WRONLY)) < 0 )
			{
				fprintf (stderr, SUN_PRINT_PREFIX"cannot open output audio device %s (%s)\n", 
					 r->devPlay, strerror (errno));
				goto fail;
			}
		}

		if( r->channelsRec )
		{
			if ( (r->record_handle = open (devRec, O_RDONLY)) < 0 )
			{
				fprintf (stderr, SUN_PRINT_PREFIX"cannot open input audio device %s (%s)\n", 
					 r->devRec, strerror (errno));
				goto fail;
			}
		}
	}

	if( r->playback_handle )
	{
		AUDIO_INITINFO(&pinfo);

		pinfo.play.precision = 16;
		pinfo.play.encoding = AUDIO_ENCODING_LINEAR;
		pinfo.play.sample_rate = r->spsPlay;
		pinfo.play.channels = r->channelsPlay;

		if ( ioctl(r->playback_handle, AUDIO_SETINFO, &pinfo) < 0 )
		{
			fprintf (stderr, SUN_PRINT_PREFIX"cannot set audio playback format (%s)\n",
				 strerror (errno));
			goto fail;
		}

		if ( ioctl(r->playback_handle, AUDIO_GETINFO, &pinfo) < 0 )
		{
			fprintf (stderr, SUN_PRINT_PREFIX"cannot get audio record format (%s)\n",
				 strerror (errno));
			goto fail;
		}

		r->spsPlay = pinfo.play.sample_rate;
		r->channelsPlay = pinfo.play.channels;

		if ( (r->samplesPlay = calloc(2 * r->channelsPlay, r->bufsize)) == NULL )
		{
			goto fail;
		}
	}

	if( r->record_handle )
	{
		AUDIO_INITINFO(&rinfo);

		rinfo.record.precision = 16;
		rinfo.record.encoding = AUDIO_ENCODING_LINEAR;
		rinfo.record.sample_rate = r->spsRec;
		rinfo.record.channels = r->channelsRec;

		if ( ioctl(r->record_handle, AUDIO_SETINFO, &rinfo) < 0 )
		{
			fprintf (stderr, SUN_PRINT_PREFIX"cannot set audio record format (%s)\n",
				 strerror (errno));
			goto fail;
		}

		if ( ioctl(r->record_handle, AUDIO_GETINFO, &rinfo) < 0 )
		{
			fprintf (stderr, SUN_PRINT_PREFIX"cannot get audio record format (%s)\n",
				 strerror (errno));
			goto fail;
		}

		r->spsRec = rinfo.record.sample_rate;
		r->channelsRec = rinfo.record.channels;

		if ( (r->samplesRec = calloc(2 * r->channelsRec, r->bufsize)) == NULL )
		{
			goto fail;
		}
	}

	if( r->playback_handle )
	{
		r->threadPlay = OGCreateThread( PlayThread, r );
	}

	if( r->record_handle )
	{
		r->threadRec = OGCreateThread( RecThread, r );
	}

	printf( SUN_PRINT_PREFIX"Init Out -> channelsPlay: %d, spsPlay: %d, channelsRec: %d, spsRec: %d\n", r->channelsPlay, r->spsPlay, r->channelsRec, r->spsRec);

	return r;

fail:
	if( r )
	{
		if( r->playback_handle != -1 ) close (r->playback_handle);
		if( r->record_handle != -1 ) close (r->record_handle);
		free( r->samplesPlay );
		free( r->samplesRec );
		free( r );
	}
	return 0;
}



void * InitSunDriver( CNFACBType cb, const char * your_name, int reqSPSPlay, int reqSPSRec, int reqChannelsPlay, int reqChannelsRec, int sugBufferSize, const char * outputSelect, const char * inputSelect, void * opaque )
{
	struct CNFADriverSun * r = (struct CNFADriverSun *)malloc( sizeof( struct CNFADriverSun ) );

	r->CloseFn = CloseCNFASun;
	r->StateFn = CNFAStateSun;
	r->callback = cb;
	r->opaque = opaque;
	r->spsPlay = reqSPSPlay;
	r->spsRec = reqSPSRec;
	r->channelsPlay = reqChannelsPlay;
	r->channelsRec = reqChannelsRec;

	r->devRec = (inputSelect)?strdup(inputSelect):0;
	r->devPlay = (outputSelect)?strdup(outputSelect):0;

	r->samplesPlay = NULL;
	r->samplesRec = NULL;

	r->playback_handle = -1;
	r->record_handle = -1;
	r->bufsize = sugBufferSize;

	return InitSun(r);
}

REGISTER_CNFA( SUN, 10, "Sun", InitSunDriver );


#elif CNFA_LINUX
//Copyright 2015-2020 <>< Charles Lohr under the MIT/x11, NewBSD or ColorChord License.  You choose.

#include "os_generic.h"
#include <alsa/asoundlib.h>
#include <string.h>

#define ALSA_PRINT_PREFIX "[CNFA][ALSA]: "

struct CNFADriverAlsa
{
	void (*CloseFn)( void * object );
	int (*StateFn)( void * object );
	CNFACBType callback;
	short channelsPlay;
	short channelsRec;
	int spsPlay;
	int spsRec;
	void * opaque;

	char * devRec;
	char * devPlay;

	snd_pcm_uframes_t bufsize;
	og_thread_t threadPlay;
	og_thread_t threadRec;
	snd_pcm_t *playback_handle;
	snd_pcm_t *record_handle;

	char playing;
	char recording;
};

int CNFAStateAlsa( void * v )
{
	struct CNFADriverAlsa * r = (struct CNFADriverAlsa *)v;
	return ((r->playing)?2:0) | ((r->recording)?1:0);
}

void CloseCNFAAlsa( void * v )
{
	struct CNFADriverAlsa * r = (struct CNFADriverAlsa *)v;
	if( r )
	{
		if( r->threadPlay ) OGJoinThread( r->threadPlay );
		if( r->threadRec ) OGJoinThread( r->threadRec );

		OGUSleep(2000);

		if( r->playback_handle ) snd_pcm_close (r->playback_handle);
		if( r->record_handle ) snd_pcm_close (r->record_handle);

		OGUSleep(2000);

		if( r->devRec ) free( r->devRec );
		if( r->devPlay ) free( r->devPlay );
		free( r );
	}
}


static int SetHWParams( snd_pcm_t * handle, int * samplerate, short * channels, snd_pcm_uframes_t * bufsize, struct CNFADriverAlsa * a )
{
	int err;
	int bufs;
	int dir;
	snd_pcm_hw_params_t *hw_params;
	if ((err = snd_pcm_hw_params_malloc (&hw_params)) < 0) {
		fprintf (stderr, ALSA_PRINT_PREFIX"cannot allocate hardware parameter structure (%s)\n",
			 snd_strerror (err));
		return -1;
	}

	if ((err = snd_pcm_hw_params_any (handle, hw_params)) < 0) {
		fprintf (stderr, ALSA_PRINT_PREFIX"cannot initialize hardware parameter structure (%s)\n",
			 snd_strerror (err));
		goto fail;
	}

	if ((err = snd_pcm_hw_params_set_access (handle, hw_params, SND_PCM_ACCESS_RW_INTERLEAVED)) < 0) {
		fprintf (stderr, ALSA_PRINT_PREFIX"cannot set access type (%s)\n",
			 snd_strerror (err));
		goto fail;
	}

	if ((err = snd_pcm_hw_params_set_format (handle, hw_params,  SND_PCM_FORMAT_S16_LE )) < 0) {
		fprintf (stderr, ALSA_PRINT_PREFIX"cannot set sample format (%s)\n",
			 snd_strerror (err));
		goto fail;
	}

	if ((err = snd_pcm_hw_params_set_rate_near (handle, hw_params, (unsigned int*)samplerate, 0)) < 0) {
		fprintf (stderr, ALSA_PRINT_PREFIX"cannot set sample rate (%s)\n",
			 snd_strerror (err));
		goto fail;
	}

	if ((err = snd_pcm_hw_params_set_channels (handle, hw_params, *channels)) < 0) {
		fprintf (stderr, ALSA_PRINT_PREFIX"cannot set channel count (%s)\n",
			 snd_strerror (err));
		goto fail;
	}

	dir = 0;
	if( (err = snd_pcm_hw_params_set_period_size_near(handle, hw_params, bufsize, &dir)) < 0 )
	{
		fprintf( stderr, ALSA_PRINT_PREFIX"cannot set period size. (%s)\n",
			snd_strerror(err) );
		goto fail;
	}

	//NOTE: This step is critical for low-latency sound.
	bufs = *bufsize*3;
	if( (err = snd_pcm_hw_params_set_buffer_size(handle, hw_params, bufs)) < 0 )
	{
		fprintf( stderr, ALSA_PRINT_PREFIX"cannot set snd_pcm_hw_params_set_buffer_size size. (%s)\n",
			snd_strerror(err) );
		goto fail;
	}


	if ((err = snd_pcm_hw_params (handle, hw_params)) < 0) {
		fprintf (stderr, ALSA_PRINT_PREFIX"cannot set parameters (%s)\n",
			 snd_strerror (err));
		goto fail;
	}

	snd_pcm_hw_params_free (hw_params);
	return 0;
fail:
	snd_pcm_hw_params_free (hw_params);
	return -2;
}


static int SetSWParams( struct CNFADriverAlsa * d, snd_pcm_t * handle, int isrec )
{
	snd_pcm_sw_params_t *sw_params;
	int err;
	//Time for software parameters:

	if( !isrec )
	{
		if ((err = snd_pcm_sw_params_malloc (&sw_params)) < 0) {
			fprintf (stderr, ALSA_PRINT_PREFIX"cannot allocate software parameters structure (%s)\n",
				 snd_strerror (err));
			goto failhard;
		}
		if ((err = snd_pcm_sw_params_current (handle, sw_params)) < 0) {
			fprintf (stderr, ALSA_PRINT_PREFIX"cannot initialize software parameters structure (%s) (%p)\n", 
				 snd_strerror (err), handle);
			goto fail;
		}

		int buffer_size = d->bufsize*3;
		int period_size = d->bufsize;
		printf( ALSA_PRINT_PREFIX"PERIOD: %d  BUFFER: %d\n", period_size, buffer_size );

		if ((err = snd_pcm_sw_params_set_avail_min (handle, sw_params, period_size )) < 0) {
			fprintf (stderr, ALSA_PRINT_PREFIX"cannot set minimum available count (%s)\n",
				 snd_strerror (err));
			goto fail;
		}
		//if ((err = snd_pcm_sw_params_set_stop_threshold(handle, sw_params, 512 )) < 0) {
		//	fprintf (stderr, ALSA_PRINT_PREFIX"cannot set minimum available count (%s)\n",
		//		 snd_strerror (err));
		//	goto fail;
		//}
		if ((err = snd_pcm_sw_params_set_start_threshold(handle, sw_params, buffer_size - period_size )) < 0) {
			fprintf (stderr, ALSA_PRINT_PREFIX"cannot set minimum available count (%s)\n",
				 snd_strerror (err));
			goto fail;
		}
		if ((err = snd_pcm_sw_params (handle, sw_params)) < 0) {
			fprintf (stderr, ALSA_PRINT_PREFIX"cannot set software parameters (%s)\n",
				 snd_strerror (err));
			goto fail;
		}

		

	}

	if ((err = snd_pcm_prepare (handle)) < 0) {
		fprintf (stderr, ALSA_PRINT_PREFIX"cannot prepare audio interface for use (%s)\n",
			 snd_strerror (err));
		goto fail;
	}

	return 0;
fail:
	if( !isrec )
	{
		snd_pcm_sw_params_free (sw_params);
	}
failhard:
	return -1;
}

void * RecThread( void * v )
{
	struct CNFADriverAlsa * r = (struct CNFADriverAlsa *)v;
	short samples[r->bufsize * r->channelsRec];
	snd_pcm_start(r->record_handle);
	do
	{
		int err = snd_pcm_readi( r->record_handle, samples, r->bufsize );	
		if( err < 0 )
		{
			fprintf( stderr, ALSA_PRINT_PREFIX"Warning: ALSA Recording Failed\n" );
			break;
		}
		if( err != r->bufsize )
		{
			fprintf( stderr, ALSA_PRINT_PREFIX"Warning: ALSA Recording Underflow\n" );
		}
		r->recording = 1;
		r->callback( (struct CNFADriver *)r, 0, samples, 0, err );
	} while( 1 );
	r->recording = 0;
	fprintf( stderr, ALSA_PRINT_PREFIX"ALSA Recording Stopped\n" );
	return 0;
}

void * PlayThread( void * v )
{
	struct CNFADriverAlsa * r = (struct CNFADriverAlsa *)v;
	short samples[r->bufsize * r->channelsPlay];
	int err;
	//int total_avail = snd_pcm_avail(r->playback_handle);

	snd_pcm_start(r->playback_handle);
	r->callback( (struct CNFADriver *)r, samples, 0, r->bufsize, 0 );
	err = snd_pcm_writei(r->playback_handle, samples, r->bufsize);

	while( err >= 0 )
	{
	//	int avail = snd_pcm_avail(r->playback_handle);
	//	printf( ALSA_PRINT_PREFIX"avail: %d\n", avail );
		r->callback( (struct CNFADriver *)r, samples, 0, r->bufsize, 0 );
		err = snd_pcm_writei(r->playback_handle, samples, r->bufsize);
		if( err != r->bufsize )
		{
			fprintf( stderr, ALSA_PRINT_PREFIX"Warning: ALSA Playback Overflow\n" );
		}
		r->playing = 1;
	}
	r->playing = 0;
	fprintf( stderr, ALSA_PRINT_PREFIX"Playback Stopped\n" );
	return 0;
}

static struct CNFADriverAlsa * InitALSA( struct CNFADriverAlsa * r )
{
	printf( ALSA_PRINT_PREFIX"initialized %p %p  (%d %d) %d %d\n", r->playback_handle, r->record_handle, r->spsPlay, r->spsRec, r->channelsPlay, r->channelsRec );

	int err;
	if( r->channelsPlay )
	{
		if ((err = snd_pcm_open (&r->playback_handle, r->devPlay?r->devPlay:"hw:0,0", SND_PCM_STREAM_PLAYBACK, 0)) < 0) {
			fprintf (stderr, ALSA_PRINT_PREFIX"cannot open output audio device (%s)\n", 
				 snd_strerror (err));
			goto fail;
		}
	}

	if( r->channelsRec )
	{
		if ((err = snd_pcm_open (&r->record_handle, r->devRec?r->devRec:"hw:0,0", SND_PCM_STREAM_CAPTURE, 0)) < 0) {
			fprintf (stderr, ALSA_PRINT_PREFIX"cannot open input audio device (%s)\n", 
				 snd_strerror (err));
			goto fail;
		}
	}

	if( r->playback_handle )
	{
		if( SetHWParams( r->playback_handle, &r->spsPlay, &r->channelsPlay, &r->bufsize, r ) < 0 ) 
			goto fail;
		if( SetSWParams( r, r->playback_handle, 0 ) < 0 )
			goto fail;
	}

	if( r->record_handle )
	{
		if( SetHWParams( r->record_handle, &r->spsRec, &r->channelsRec, &r->bufsize, r ) < 0 )
			goto fail;
		if( SetSWParams( r, r->record_handle, 1 ) < 0 )
			goto fail;
	}

#if 0
	if( r->playback_handle )
	{
		snd_async_handler_t *pcm_callback;
		//Handle automatically cleaned up when stream closed.
		err = snd_async_add_pcm_handler(&pcm_callback, r->playback_handle, playback_callback, r);
		if(err < 0)
		{
			printf(ALSA_PRINT_PREFIX"Playback callback handler error: %s\n", snd_strerror(err));
		}
	}

	if( r->record_handle )
	{
		snd_async_handler_t *pcm_callback;
		//Handle automatically cleaned up when stream closed.
		err = snd_async_add_pcm_handler(&pcm_callback, r->record_handle, record_callback, r);
		if(err < 0)
		{
			printf(ALSA_PRINT_PREFIX"Record callback handler error: %s\n", snd_strerror(err));
		}
	}
#endif

	if( r->playback_handle && r->record_handle )
	{
		err = snd_pcm_link ( r->playback_handle, r->record_handle );
		if(err < 0)
		{
			printf(ALSA_PRINT_PREFIX"snd_pcm_link error: %s\n", snd_strerror(err));
		}
	}

	if( r->playback_handle )
	{
		r->threadPlay = OGCreateThread( PlayThread, r );
	}

	if( r->record_handle )
	{
		r->threadRec = OGCreateThread( RecThread, r );
	}

	printf( ALSA_PRINT_PREFIX"Init Out -> %p %p  (%d %d) %d %d\n", r->playback_handle, r->record_handle, r->spsPlay, r->spsRec, r->channelsPlay, r->channelsRec );

	return r;

fail:
	if( r )
	{
		if( r->playback_handle ) snd_pcm_close (r->playback_handle);
		if( r->record_handle ) snd_pcm_close (r->record_handle);
		free( r );
	}
	fprintf( stderr, ALSA_PRINT_PREFIX"ALSA failed to start.\n" );
	return 0;
}



void * InitALSADriver( CNFACBType cb, const char * your_name, int reqSPSPlay, int reqSPSRec, int reqChannelsPlay, int reqChannelsRec, int sugBufferSize, const char * outputSelect, const char * inputSelect, void * opaque )
{
	struct CNFADriverAlsa * r = (struct CNFADriverAlsa *)malloc( sizeof( struct CNFADriverAlsa ) );

	r->CloseFn = CloseCNFAAlsa;
	r->StateFn = CNFAStateAlsa;
	r->callback = cb;
	r->opaque = opaque;
	r->spsPlay = reqSPSPlay;
	r->spsRec = reqSPSRec;
	r->channelsPlay = reqChannelsPlay;
	r->channelsRec = reqChannelsRec;

	r->devRec = (inputSelect)?strdup(inputSelect):0;
	r->devPlay = (outputSelect)?strdup(outputSelect):0;

	r->playback_handle = 0;
	r->record_handle = 0;
	r->bufsize = sugBufferSize;

	return InitALSA(r);
}

REGISTER_CNFA( ALSA, 10, "ALSA", InitALSADriver );


#if CNFA_PULSE
//Copyright 2015-2020 <>< Charles Lohr under the MIT/x11, NewBSD or ColorChord License.  You choose.

//This file is really rough.  Full duplex doesn't seem to work hardly at all.


#include "os_generic.h"
#include <stdlib.h>

#include <pulse/simple.h>
#include <pulse/pulseaudio.h>
#include <pulse/error.h>
#include <stdio.h>
#include <string.h>

#define PULSE_PRINT_PREFIX "[CNFA][Pulse]: "

#define BUFFERSETS 3


//from http://www.freedesktop.org/wiki/Software/PulseAudio/Documentation/Developer/Clients/Samples/AsyncPlayback/
//also http://maemo.org/api_refs/5.0/5.0-final/pulseaudio/pacat_8c-example.html


struct CNFADriverPulse
{
	void (*CloseFn)( void * object );
	int (*StateFn)( void * object );
	CNFACBType callback;
	short channelsPlay;
	short channelsRec;
	int spsPlay;
	int spsRec;
	void * opaque;

	char * sourceNamePlay;
	char * sourceNameRec;

	og_thread_t thread;
 	pa_stream *  	play;
 	pa_stream *  	rec;
	pa_context *  pa_ctx;
	pa_mainloop *pa_ml;
	int pa_ready;
	int buffer;
	//More fields may exist on a per-sound-driver basis
};




int CNFAStatePulse( void * v )
{
	struct CNFADriverPulse * soundobject = (struct CNFADriverPulse *)v;
	return ((soundobject->play)?2:0) | ((soundobject->rec)?1:0);
}

void CloseCNFAPulse( void * v )
{
	struct CNFADriverPulse * r = (struct CNFADriverPulse *)v;
	if( r )
	{
		OGCancelThread( r->thread );

		OGUSleep(2000);

		if( r->play )
		{
			pa_stream_unref (r->play);
			r->play = 0;
		}

		if( r->rec )
		{
			pa_stream_unref (r->rec);
			r->rec = 0;
		}

		OGUSleep(2000);

		if( r->sourceNamePlay ) free( r->sourceNamePlay );
		if( r->sourceNameRec ) free( r->sourceNameRec );
		free( r );
	}
}

static void * CNFAThread( void * v )
{
	struct CNFADriverPulse * r = (struct CNFADriverPulse*)v;
	while(1)
	{
		pa_mainloop_iterate( r->pa_ml, 1, NULL );
	}
	return 0;
}

static void stream_request_cb(pa_stream *s, size_t length, void *userdata)
{
	struct CNFADriverPulse * r = (struct CNFADriverPulse*)userdata;
	if( !r->play )
	{
		return;
	}
	short bufp[length*r->channelsPlay/sizeof(short)];
	r->callback( (struct CNFADriver*)r, bufp, 0, length/(sizeof(short)*r->channelsPlay), 0 );
	pa_stream_write(r->play, &bufp[0], length, NULL, 0LL, PA_SEEK_RELATIVE);
}


static void stream_record_cb(pa_stream *s, size_t length, void *userdata)
{
	struct CNFADriverPulse * r = (struct CNFADriverPulse*)userdata;

	uint16_t * bufr;

    if (pa_stream_peek(r->rec, (const void**)&bufr, &length) < 0) {
        fprintf(stderr, (PULSE_PRINT_PREFIX"pa_stream_peek() failed: %s\n"), pa_strerror(pa_context_errno(r->pa_ctx)));
        return;
    }

	short * buffer;
    buffer = (short*)pa_xmalloc(length);
    memcpy(buffer, bufr, length);
	pa_stream_drop(r->rec);
	r->callback( (struct CNFADriver*)r, 0, buffer, 0, length/(sizeof(short)*r->channelsRec) );
	pa_xfree( buffer );
}



static void stream_underflow_cb(pa_stream *s, void *userdata) {
  printf(PULSE_PRINT_PREFIX"underflow\n");
}


void pa_state_cb(pa_context *c, void *userdata) {
	pa_context_state_t state;
	int *pa_ready = (int*)userdata;
	state = pa_context_get_state(c);
	switch  (state) {
		// These are just here for reference
		case PA_CONTEXT_UNCONNECTED:
		case PA_CONTEXT_CONNECTING:
		case PA_CONTEXT_AUTHORIZING:
		case PA_CONTEXT_SETTING_NAME:
		default:
			break;
		case PA_CONTEXT_FAILED:
		case PA_CONTEXT_TERMINATED:
			*pa_ready = 2;
			break;
		case PA_CONTEXT_READY:
			*pa_ready = 1;
		break;
	}
}


void * InitCNFAPulse( CNFACBType cb, const char * your_name, int reqSPSPlay, int reqSPSRec, int reqChannelsPlay, int reqChannelsRec, int sugBufferSize, const char * outputSelect, const char * inputSelect, void * opaque )
{
	static pa_buffer_attr bufattr;
	static pa_sample_spec ss;
	int error;
	pa_mainloop_api *pa_mlapi;
	const char * title = your_name;

	struct CNFADriverPulse * r = (struct CNFADriverPulse *)malloc( sizeof( struct CNFADriverPulse ) );

	r->pa_ml = pa_mainloop_new();
	if( !r->pa_ml )
	{
		fprintf( stderr, PULSE_PRINT_PREFIX"Failed to initialize pa_mainloop_new()\n" );
		goto fail;
	}

	pa_mlapi = pa_mainloop_get_api(r->pa_ml);
	if( !pa_mlapi )
	{
		fprintf( stderr, PULSE_PRINT_PREFIX"Failed to initialize pa_mainloop_get_api()\n" );
		goto fail;
	}

	r->pa_ctx = pa_context_new(pa_mlapi, title );
	pa_context_connect(r->pa_ctx, NULL, PA_CONTEXT_NOFLAGS, NULL);

	//TODO: pa_context_set_state_callback

	r->CloseFn = CloseCNFAPulse;
	r->StateFn = CNFAStatePulse;
	r->callback = cb;
	r->opaque = opaque;
	r->spsPlay = reqSPSPlay;
	r->spsRec = reqSPSRec;
	r->channelsPlay = reqChannelsPlay;
	r->channelsRec = reqChannelsRec;
	r->sourceNamePlay = outputSelect?strdup(outputSelect):0;
	r->sourceNameRec = inputSelect?strdup(inputSelect):0;

	r->play = 0;
	r->rec = 0;
	r->buffer = sugBufferSize;

	printf (PULSE_PRINT_PREFIX"from: [O/I] %s/%s (%s) / (%d,%d)x(%d,%d) (%d)\n", r->sourceNamePlay, r->sourceNameRec, title, r->spsPlay, r->spsRec, r->channelsPlay, r->channelsRec, r->buffer );

	memset( &ss, 0, sizeof( ss ) );

	ss.format = PA_SAMPLE_S16NE;

	r->pa_ready = 0;
	pa_context_set_state_callback(r->pa_ctx, pa_state_cb, &r->pa_ready);

	while (r->pa_ready == 0)
	{
		pa_mainloop_iterate(r->pa_ml, 1, NULL);
	}

	int bufBytesPlay = r->buffer * sizeof(short) * r->channelsPlay;
	int bufBytesRec = r->buffer * sizeof(short) * r->channelsRec;

	if( r->channelsPlay )
	{
		ss.channels = r->channelsPlay;
		ss.rate = r->spsPlay;

		if (!(r->play = pa_stream_new(r->pa_ctx, "Play", &ss, NULL))) {
			error = -3; //XXX ??? TODO
			fprintf(stderr, PULSE_PRINT_PREFIX"pa_simple_new() failed: %s\n", pa_strerror(error));
			goto fail;
		}

		pa_stream_set_underflow_callback(r->play, stream_underflow_cb, NULL);
		pa_stream_set_write_callback(r->play, stream_request_cb, r );

		/* The absolute maximum number of bytes that can be stored in the buffer.
		 * If this value is exceeded then data will be lost. It is recommended to
		 * pass (uint32_t) -1 here which will cause the server to fill in the
		 * maximum possible value.*/
		bufattr.maxlength = bufBytesPlay*3;

		/* The target fill level of the playback buffer. The server will only send
		 * requests for more data as long as the buffer has less than this number of
		 * bytes of data. If you pass (uint32_t) -1 (which is recommended) here the
		 * server will choose the longest target buffer fill level possible to minimize
		 * the number of necessary wakeups and maximize drop-out safety. This can exceed
		 * 2s of buffering. For low-latency applications or applications where latency
		 * matters you should pass a proper value here. */
		bufattr.tlength = bufBytesPlay*3;

		/* Number of bytes that need to be in the buffer before playback will commence.
		 * Start of playback can be forced using pa_stream_trigger() even though the
		 * prebuffer size hasn't been reached. If a buffer underrun occurs, this
		 * prebuffering will be again enabled. If the playback shall never stop in case
		 * of a buffer underrun, this value should be set to 0. In that case the read
		 * index of the output buffer overtakes the write index, and hence the fill
		 * level of the buffer is negative. If you pass (uint32_t) -1 here (which is
		 * recommended) the server will choose the same value as tlength here. */
		bufattr.prebuf = (uint32_t)-1;

		/* Minimum free number of the bytes in the playback buffer before the server
		 * will request more data. It is recommended to fill in (uint32_t) -1 here. This
		 * value influences how much time the sound server has to move data from the
		 * per-stream server-side playback buffer to the hardware playback buffer. */
		bufattr.minreq = (uint32_t)-1;

		/* Maximum number of bytes that the server will push in one chunk for record
		 * streams. If you pass (uint32_t) -1 (which is recommended) here, the server
		 * will choose the longest fragment setting possible to minimize the number of
		 * necessary wakeups and maximize drop-out safety. This can exceed 2s of
		 * buffering. For low-latency applications or applications where latency matters
		 * you should pass a proper value here. */
		bufattr.fragsize = (uint32_t)-1;

		int ret = pa_stream_connect_playback(r->play, r->sourceNamePlay, &bufattr,
				                    // PA_STREAM_INTERPOLATE_TIMING
				                    // |PA_STREAM_ADJUST_LATENCY //Some servers don't like the adjust_latency flag.
				                    // |PA_STREAM_AUTO_TIMING_UPDATE, NULL, NULL);
					PA_STREAM_NOFLAGS, NULL, NULL );
		if( ret < 0 )
		{
			fprintf(stderr, PULSE_PRINT_PREFIX"(PLAY) pa_stream_connect_playback() failed: %s\n", pa_strerror(ret));
			goto fail;
		}

	}

	if( r->channelsRec )
	{
		ss.channels = r->channelsRec;
		ss.rate = r->spsRec;

		if (!(r->rec = pa_stream_new(r->pa_ctx, "Record", &ss, NULL))) {
			error = -3; //XXX ??? TODO
			fprintf(stderr, PULSE_PRINT_PREFIX"pa_simple_new() failed: %s\n", pa_strerror(error));
			goto fail;
		}

		pa_stream_set_read_callback(r->rec, stream_record_cb, r );

		bufattr.fragsize = bufBytesRec;
		bufattr.maxlength = (uint32_t)-1;//(uint32_t)-1; //XXX: Todo, should this be low?
		bufattr.minreq = bufBytesRec;
		bufattr.prebuf = (uint32_t)-1;
		bufattr.tlength = bufBytesRec*3;
		int ret = pa_stream_connect_record(r->rec, r->sourceNameRec, &bufattr, 
					                      // PA_STREAM_INTERPOLATE_TIMING
										  PA_STREAM_ADJUST_LATENCY  //Some servers don't like the adjust_latency flag.
										  // PA_STREAM_AUTO_TIMING_UPDATE
										  // PA_STREAM_NOFLAGS
				);
		if( ret < 0 )
		{
			fprintf(stderr, PULSE_PRINT_PREFIX"(REC) pa_stream_connect_playback() failed: %s\n", pa_strerror(ret));
			goto fail;
		}
	}

	printf( PULSE_PRINT_PREFIX"initialized.\n" );


	r->thread = OGCreateThread( CNFAThread, r );


	if( r->play )
	{
		stream_request_cb( r->play, bufBytesPlay, r );
	}

	return r;

fail:
	if( r )
	{
		if( r->play ) pa_xfree (r->play);
		if( r->rec ) pa_xfree (r->rec);
		free( r );
	}
	return 0;
}



REGISTER_CNFA( PulseCNFA, 11, "PULSE", InitCNFAPulse );

#endif
#elif defined(__APPLE__)
//Copyright 2015-2020 <>< Charles Lohr under the MIT/x11, NewBSD or ColorChord License.  You choose.

// TODO:
// - Test recording
// - Device selection
// - dylib build

#include "os_generic.h"
#include <stdlib.h>

#include <CoreAudio/CoreAudio.h>
#include <AudioToolbox/AudioQueue.h>
#include <stdio.h>
#include <string.h>

#define BUFFERSETS 3


// https://developer.apple.com/library/archive/documentation/MusicAudio/Conceptual/CoreAudioOverview/CoreAudioEssentials/CoreAudioEssentials.html


struct CNFADriverCoreAudio
{
	void (*CloseFn)( void * object );
	int (*StateFn)( void * object );
	CNFACBType callback;
	short channelsPlay;
	short channelsRec;
	int spsPlay;
	int spsRec;
	void * opaque;

	// CoreAudio-specific fields
	char * sourceNamePlay;
	char * sourceNameRec;

	AudioQueueRef   play;
	AudioQueueRef   rec;

	AudioQueueBufferRef playBuffers[BUFFERSETS];
	AudioQueueBufferRef recBuffers[BUFFERSETS];

	int buffer;
};

int CNFAStateCoreAudio( void * v )
{
	struct CNFADriverCoreAudio * soundobject = (struct CNFADriverCoreAudio *)v;
	return ((soundobject->play)?2:0) | ((soundobject->rec)?1:0);
}

void CloseCNFACoreAudio( void * v )
{
	struct CNFADriverCoreAudio * r = (struct CNFADriverCoreAudio *)v;
	if( r )
	{
		if( r->play )
		{
			AudioQueueDispose(r->play, true);
			r->play = 0;
		}

		if( r->rec )
		{
			AudioQueueDispose(r->rec, true);
			r->rec = 0;
		}

		if( r->sourceNamePlay ) free( r->sourceNamePlay );
		if( r->sourceNameRec ) free( r->sourceNameRec );
		free( r );
	}
}

static void CoreAudioOutputCallback(void *userdata, AudioQueueRef inAQ, AudioQueueBufferRef inBuffer)
{
	// Write our data to the input buffer
	struct CNFADriverCoreAudio * r = (struct CNFADriverCoreAudio*)userdata;
	if (!r->play)
	{
		return;
	}

	r->callback((struct CNFADriver*)r, (short*)inBuffer->mAudioData, NULL, inBuffer->mAudioDataBytesCapacity / sizeof(short) / r->channelsPlay, 0);
	// Assume the buffer was completely filled?
	inBuffer->mAudioDataByteSize = inBuffer->mAudioDataBytesCapacity;

	// I think this isn't necessary for non-compressed audio formats
	if (inBuffer->mPacketDescriptionCapacity > 0)
	{
		inBuffer->mPacketDescriptionCount = 1;
		inBuffer->mPacketDescriptions[0].mDataByteSize = inBuffer->mAudioDataBytesCapacity;
		inBuffer->mPacketDescriptions[0].mStartOffset = 0;
		inBuffer->mPacketDescriptions[0].mVariableFramesInPacket = 0;
	}

	// Actually send the buffer to be played!
	AudioQueueEnqueueBuffer(inAQ, inBuffer, 0, NULL);
}

static void CoreAudioInputCallback(void *userdata, AudioQueueRef inAQ, AudioQueueBufferRef inBuffer, const AudioTimeStamp *inStartTime, UInt32 inNumberPacketDescriptions, const AudioStreamPacketDescription *inPacketDescs)
{
	// Read our data from the output buffer
	struct CNFADriverCoreAudio * r = (struct CNFADriverCoreAudio*)userdata;
	r->callback((struct CNFADriver*)r, NULL, (short*)inBuffer->mAudioData, 0, inBuffer->mAudioDataByteSize / sizeof(short));
}

void * InitCNFACoreAudio( CNFACBType cb, const char * your_name, int reqSPSPlay, int reqSPSRec, int reqChannelsPlay, int reqChannelsRec, int sugBufferSize, const char * outputSelect, const char * inputSelect, void * opaque )
{
	const char * title = your_name;

	struct CNFADriverCoreAudio * r = (struct CNFADriverCoreAudio *)malloc( sizeof( struct CNFADriverCoreAudio ) );

	r->CloseFn = CloseCNFACoreAudio;
	r->StateFn = CNFAStateCoreAudio;
	r->callback = cb;
	r->opaque = opaque;
	r->spsPlay = reqSPSPlay;
	r->spsRec = reqSPSRec;
	r->channelsPlay = reqChannelsPlay;
	r->channelsRec = reqChannelsRec;
	r->sourceNamePlay = outputSelect?strdup(outputSelect):0;
	r->sourceNameRec = inputSelect?strdup(inputSelect):0;

	memset(r->playBuffers, 0, sizeof(r->playBuffers));
	memset(r->recBuffers, 0, sizeof(r->recBuffers));

	r->play = 0;
	r->rec = 0;
	r->buffer = sugBufferSize;

	printf ("CoreAudio: from: [O/I] %s/%s (%s) / (%d,%d)x(%d,%d) (%d)\n", r->sourceNamePlay, r->sourceNameRec, title, r->spsPlay, r->spsRec, r->channelsPlay, r->channelsRec, r->buffer );

	int bufBytesPlay = r->buffer * sizeof(short) * r->channelsPlay;
	int bufBytesRec = r->buffer * sizeof(short) * r->channelsRec;

	if( r->channelsPlay )
	{
		AudioStreamBasicDescription playDesc = {0};
		playDesc.mFormatID = kAudioFormatLinearPCM;
		playDesc.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked;
		playDesc.mSampleRate = r->spsPlay;
		playDesc.mBitsPerChannel = 8 * sizeof(short);
		playDesc.mChannelsPerFrame = r->channelsPlay;
		// Bytes per channel, multiplied by number of channels
		playDesc.mBytesPerFrame = r->channelsPlay * (playDesc.mBitsPerChannel / 8);
		// Always 1 for uncompressed audio
		playDesc.mFramesPerPacket = 1;
		playDesc.mBytesPerPacket = playDesc.mBytesPerFrame * playDesc.mFramesPerPacket;
		playDesc.mReserved = 0;

		OSStatus result = AudioQueueNewOutput(&playDesc, CoreAudioOutputCallback, (void*)r, NULL /* Default run loop*/, NULL /* Equivalent to kCFRunLoopCommonModes */, 0 /* flags, reserved*/, &r->play);

		if( 0 != result )
		{
			fprintf(stderr, __FILE__": (PLAY) AudioQueueNewOutput() failed: %s\n", strerror(result));
			goto fail;
		}

		for (int i = 0; i < BUFFERSETS; i++)
		{
			result = AudioQueueAllocateBuffer(r->play, bufBytesPlay, &r->playBuffers[i]);

			if (0 != result)
			{
				fprintf(stderr, __FILE__": (PLAY) AudioQueueNewOutput() failed: %s\n", strerror(result));
				goto fail;
			}

			// Prefill buffer
			CoreAudioOutputCallback(r, r->play, r->playBuffers[i]);
		}

		AudioQueueStart(r->play, NULL);
	}

	if( r->channelsRec )
	{
		AudioStreamBasicDescription recDesc = {0};
		recDesc.mFormatID = kAudioFormatLinearPCM;
		recDesc.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked;
		recDesc.mSampleRate = r->spsRec;
		recDesc.mBitsPerChannel = 8 * sizeof(short);
		recDesc.mChannelsPerFrame = r->channelsRec;
		// Bytes per channel, multiplied by number of channels
		recDesc.mBytesPerFrame = recDesc.mChannelsPerFrame * (recDesc.mBitsPerChannel / 8);
		// Always 1 for uncompressed audio
		recDesc.mFramesPerPacket = 1;
		recDesc.mBytesPerPacket = recDesc.mBytesPerFrame * recDesc.mFramesPerPacket;

		OSStatus result = AudioQueueNewInput(&recDesc, CoreAudioInputCallback, (void*)r, NULL, NULL, 0, &r->rec);

		if (0 != result)
		{
			fprintf(stderr, __FILE__": (RECORD) AudioQueueNewInput() failed: %s\n", strerror(result));
			goto fail;
		}

		for (int i = 0; i < BUFFERSETS; i++)
		{
			result = AudioQueueAllocateBuffer(r->rec, bufBytesRec, &r->recBuffers[i]);

			if (0 != result)
			{
				fprintf(stderr, __FILE__": (RECORD) AudioQueueNewOutput() failed: %s\n", strerror(result));
				goto fail;
			}

			// No buffer prefill for input
		}

		AudioQueueStart(r->rec, NULL);
	}

	printf( "CoreAudio initialized.\n" );

	return r;

fail:
	if( r )
	{
		if( r->play )
		{
			// Buffers are automatically freed with the queue
			AudioQueueDispose (r->play, true);
		}

		if( r->rec )
		{
			// Buffers are automatically freed with the queue
			AudioQueueDispose (r->rec, true);
		}
		free( r );
	}
	return 0;
}



REGISTER_CNFA( CoreAudioCNFA, 10, "COREAUDIO", InitCNFACoreAudio );

#if defined(PULSEAUDIO)
//Copyright 2015-2020 <>< Charles Lohr under the MIT/x11, NewBSD or ColorChord License.  You choose.

//This file is really rough.  Full duplex doesn't seem to work hardly at all.


#include "os_generic.h"
#include <stdlib.h>

#include <pulse/simple.h>
#include <pulse/pulseaudio.h>
#include <pulse/error.h>
#include <stdio.h>
#include <string.h>

#define PULSE_PRINT_PREFIX "[CNFA][Pulse]: "

#define BUFFERSETS 3


//from http://www.freedesktop.org/wiki/Software/PulseAudio/Documentation/Developer/Clients/Samples/AsyncPlayback/
//also http://maemo.org/api_refs/5.0/5.0-final/pulseaudio/pacat_8c-example.html


struct CNFADriverPulse
{
	void (*CloseFn)( void * object );
	int (*StateFn)( void * object );
	CNFACBType callback;
	short channelsPlay;
	short channelsRec;
	int spsPlay;
	int spsRec;
	void * opaque;

	char * sourceNamePlay;
	char * sourceNameRec;

	og_thread_t thread;
 	pa_stream *  	play;
 	pa_stream *  	rec;
	pa_context *  pa_ctx;
	pa_mainloop *pa_ml;
	int pa_ready;
	int buffer;
	//More fields may exist on a per-sound-driver basis
};




int CNFAStatePulse( void * v )
{
	struct CNFADriverPulse * soundobject = (struct CNFADriverPulse *)v;
	return ((soundobject->play)?2:0) | ((soundobject->rec)?1:0);
}

void CloseCNFAPulse( void * v )
{
	struct CNFADriverPulse * r = (struct CNFADriverPulse *)v;
	if( r )
	{
		OGCancelThread( r->thread );

		OGUSleep(2000);

		if( r->play )
		{
			pa_stream_unref (r->play);
			r->play = 0;
		}

		if( r->rec )
		{
			pa_stream_unref (r->rec);
			r->rec = 0;
		}

		OGUSleep(2000);

		if( r->sourceNamePlay ) free( r->sourceNamePlay );
		if( r->sourceNameRec ) free( r->sourceNameRec );
		free( r );
	}
}

static void * CNFAThread( void * v )
{
	struct CNFADriverPulse * r = (struct CNFADriverPulse*)v;
	while(1)
	{
		pa_mainloop_iterate( r->pa_ml, 1, NULL );
	}
	return 0;
}

static void stream_request_cb(pa_stream *s, size_t length, void *userdata)
{
	struct CNFADriverPulse * r = (struct CNFADriverPulse*)userdata;
	if( !r->play )
	{
		return;
	}
	short bufp[length*r->channelsPlay/sizeof(short)];
	r->callback( (struct CNFADriver*)r, bufp, 0, length/(sizeof(short)*r->channelsPlay), 0 );
	pa_stream_write(r->play, &bufp[0], length, NULL, 0LL, PA_SEEK_RELATIVE);
}


static void stream_record_cb(pa_stream *s, size_t length, void *userdata)
{
	struct CNFADriverPulse * r = (struct CNFADriverPulse*)userdata;

	uint16_t * bufr;

    if (pa_stream_peek(r->rec, (const void**)&bufr, &length) < 0) {
        fprintf(stderr, (PULSE_PRINT_PREFIX"pa_stream_peek() failed: %s\n"), pa_strerror(pa_context_errno(r->pa_ctx)));
        return;
    }

	short * buffer;
    buffer = (short*)pa_xmalloc(length);
    memcpy(buffer, bufr, length);
	pa_stream_drop(r->rec);
	r->callback( (struct CNFADriver*)r, 0, buffer, 0, length/(sizeof(short)*r->channelsRec) );
	pa_xfree( buffer );
}



static void stream_underflow_cb(pa_stream *s, void *userdata) {
  printf(PULSE_PRINT_PREFIX"underflow\n");
}


void pa_state_cb(pa_context *c, void *userdata) {
	pa_context_state_t state;
	int *pa_ready = (int*)userdata;
	state = pa_context_get_state(c);
	switch  (state) {
		// These are just here for reference
		case PA_CONTEXT_UNCONNECTED:
		case PA_CONTEXT_CONNECTING:
		case PA_CONTEXT_AUTHORIZING:
		case PA_CONTEXT_SETTING_NAME:
		default:
			break;
		case PA_CONTEXT_FAILED:
		case PA_CONTEXT_TERMINATED:
			*pa_ready = 2;
			break;
		case PA_CONTEXT_READY:
			*pa_ready = 1;
		break;
	}
}


void * InitCNFAPulse( CNFACBType cb, const char * your_name, int reqSPSPlay, int reqSPSRec, int reqChannelsPlay, int reqChannelsRec, int sugBufferSize, const char * outputSelect, const char * inputSelect, void * opaque )
{
	static pa_buffer_attr bufattr;
	static pa_sample_spec ss;
	int error;
	pa_mainloop_api *pa_mlapi;
	const char * title = your_name;

	struct CNFADriverPulse * r = (struct CNFADriverPulse *)malloc( sizeof( struct CNFADriverPulse ) );

	r->pa_ml = pa_mainloop_new();
	if( !r->pa_ml )
	{
		fprintf( stderr, PULSE_PRINT_PREFIX"Failed to initialize pa_mainloop_new()\n" );
		goto fail;
	}

	pa_mlapi = pa_mainloop_get_api(r->pa_ml);
	if( !pa_mlapi )
	{
		fprintf( stderr, PULSE_PRINT_PREFIX"Failed to initialize pa_mainloop_get_api()\n" );
		goto fail;
	}

	r->pa_ctx = pa_context_new(pa_mlapi, title );
	pa_context_connect(r->pa_ctx, NULL, PA_CONTEXT_NOFLAGS, NULL);

	//TODO: pa_context_set_state_callback

	r->CloseFn = CloseCNFAPulse;
	r->StateFn = CNFAStatePulse;
	r->callback = cb;
	r->opaque = opaque;
	r->spsPlay = reqSPSPlay;
	r->spsRec = reqSPSRec;
	r->channelsPlay = reqChannelsPlay;
	r->channelsRec = reqChannelsRec;
	r->sourceNamePlay = outputSelect?strdup(outputSelect):0;
	r->sourceNameRec = inputSelect?strdup(inputSelect):0;

	r->play = 0;
	r->rec = 0;
	r->buffer = sugBufferSize;

	printf (PULSE_PRINT_PREFIX"from: [O/I] %s/%s (%s) / (%d,%d)x(%d,%d) (%d)\n", r->sourceNamePlay, r->sourceNameRec, title, r->spsPlay, r->spsRec, r->channelsPlay, r->channelsRec, r->buffer );

	memset( &ss, 0, sizeof( ss ) );

	ss.format = PA_SAMPLE_S16NE;

	r->pa_ready = 0;
	pa_context_set_state_callback(r->pa_ctx, pa_state_cb, &r->pa_ready);

	while (r->pa_ready == 0)
	{
		pa_mainloop_iterate(r->pa_ml, 1, NULL);
	}

	int bufBytesPlay = r->buffer * sizeof(short) * r->channelsPlay;
	int bufBytesRec = r->buffer * sizeof(short) * r->channelsRec;

	if( r->channelsPlay )
	{
		ss.channels = r->channelsPlay;
		ss.rate = r->spsPlay;

		if (!(r->play = pa_stream_new(r->pa_ctx, "Play", &ss, NULL))) {
			error = -3; //XXX ??? TODO
			fprintf(stderr, PULSE_PRINT_PREFIX"pa_simple_new() failed: %s\n", pa_strerror(error));
			goto fail;
		}

		pa_stream_set_underflow_callback(r->play, stream_underflow_cb, NULL);
		pa_stream_set_write_callback(r->play, stream_request_cb, r );

		/* The absolute maximum number of bytes that can be stored in the buffer.
		 * If this value is exceeded then data will be lost. It is recommended to
		 * pass (uint32_t) -1 here which will cause the server to fill in the
		 * maximum possible value.*/
		bufattr.maxlength = bufBytesPlay*3;

		/* The target fill level of the playback buffer. The server will only send
		 * requests for more data as long as the buffer has less than this number of
		 * bytes of data. If you pass (uint32_t) -1 (which is recommended) here the
		 * server will choose the longest target buffer fill level possible to minimize
		 * the number of necessary wakeups and maximize drop-out safety. This can exceed
		 * 2s of buffering. For low-latency applications or applications where latency
		 * matters you should pass a proper value here. */
		bufattr.tlength = bufBytesPlay*3;

		/* Number of bytes that need to be in the buffer before playback will commence.
		 * Start of playback can be forced using pa_stream_trigger() even though the
		 * prebuffer size hasn't been reached. If a buffer underrun occurs, this
		 * prebuffering will be again enabled. If the playback shall never stop in case
		 * of a buffer underrun, this value should be set to 0. In that case the read
		 * index of the output buffer overtakes the write index, and hence the fill
		 * level of the buffer is negative. If you pass (uint32_t) -1 here (which is
		 * recommended) the server will choose the same value as tlength here. */
		bufattr.prebuf = (uint32_t)-1;

		/* Minimum free number of the bytes in the playback buffer before the server
		 * will request more data. It is recommended to fill in (uint32_t) -1 here. This
		 * value influences how much time the sound server has to move data from the
		 * per-stream server-side playback buffer to the hardware playback buffer. */
		bufattr.minreq = (uint32_t)-1;

		/* Maximum number of bytes that the server will push in one chunk for record
		 * streams. If you pass (uint32_t) -1 (which is recommended) here, the server
		 * will choose the longest fragment setting possible to minimize the number of
		 * necessary wakeups and maximize drop-out safety. This can exceed 2s of
		 * buffering. For low-latency applications or applications where latency matters
		 * you should pass a proper value here. */
		bufattr.fragsize = (uint32_t)-1;

		int ret = pa_stream_connect_playback(r->play, r->sourceNamePlay, &bufattr,
				                    // PA_STREAM_INTERPOLATE_TIMING
				                    // |PA_STREAM_ADJUST_LATENCY //Some servers don't like the adjust_latency flag.
				                    // |PA_STREAM_AUTO_TIMING_UPDATE, NULL, NULL);
					PA_STREAM_NOFLAGS, NULL, NULL );
		if( ret < 0 )
		{
			fprintf(stderr, PULSE_PRINT_PREFIX"(PLAY) pa_stream_connect_playback() failed: %s\n", pa_strerror(ret));
			goto fail;
		}

	}

	if( r->channelsRec )
	{
		ss.channels = r->channelsRec;
		ss.rate = r->spsRec;

		if (!(r->rec = pa_stream_new(r->pa_ctx, "Record", &ss, NULL))) {
			error = -3; //XXX ??? TODO
			fprintf(stderr, PULSE_PRINT_PREFIX"pa_simple_new() failed: %s\n", pa_strerror(error));
			goto fail;
		}

		pa_stream_set_read_callback(r->rec, stream_record_cb, r );

		bufattr.fragsize = bufBytesRec;
		bufattr.maxlength = (uint32_t)-1;//(uint32_t)-1; //XXX: Todo, should this be low?
		bufattr.minreq = bufBytesRec;
		bufattr.prebuf = (uint32_t)-1;
		bufattr.tlength = bufBytesRec*3;
		int ret = pa_stream_connect_record(r->rec, r->sourceNameRec, &bufattr, 
					                      // PA_STREAM_INTERPOLATE_TIMING
										  PA_STREAM_ADJUST_LATENCY  //Some servers don't like the adjust_latency flag.
										  // PA_STREAM_AUTO_TIMING_UPDATE
										  // PA_STREAM_NOFLAGS
				);
		if( ret < 0 )
		{
			fprintf(stderr, PULSE_PRINT_PREFIX"(REC) pa_stream_connect_playback() failed: %s\n", pa_strerror(ret));
			goto fail;
		}
	}

	printf( PULSE_PRINT_PREFIX"initialized.\n" );


	r->thread = OGCreateThread( CNFAThread, r );


	if( r->play )
	{
		stream_request_cb( r->play, bufBytesPlay, r );
	}

	return r;

fail:
	if( r )
	{
		if( r->play ) pa_xfree (r->play);
		if( r->rec ) pa_xfree (r->rec);
		free( r );
	}
	return 0;
}



REGISTER_CNFA( PulseCNFA, 11, "PULSE", InitCNFAPulse );

#endif
#endif
#endif


#ifdef __cplusplus
};
#endif



#endif