path: root/Src/Plugins/Output/out_wave/out_wave.cpp

#include "out_wave.h"
#include "api.h"
#include "resource.h"
#include "waveout.h"
#include "../winamp/wa_ipc.h"
#include "../nu/AutoWide.h"

#ifdef HAVE_SSRC
#include "ssrc\ssrc.h"
static Resampler_base * pSSRC;
#endif

static bool gapless_stop;
static WaveOut * pWO;
static __int64 total_written;
static int pos_delta;
static UINT canwrite_hack;

// wasabi based services for localisation support
api_service *WASABI_API_SVC = 0;
api_language *WASABI_API_LNG = 0;
api_application *WASABI_API_APP = 0;
HINSTANCE WASABI_API_LNG_HINST = 0, WASABI_API_ORIG_HINST = 0;

void _init();

//cfg_prebuf now in ms !
UINT cfg_dev = 0, cfg_buf_ms = 2000, cfg_prebuf = 200, cfg_trackhack = 200;
bool cfg_volume = 1, cfg_altvol = 0, cfg_resetvol = 0;
static int fmt_sr, fmt_bps, fmt_nch;

static int volume = 255, pan = 0;


#ifdef HAVE_SSRC
UINT cfg_dither = 1, cfg_resample_freq = 48000, cfg_resample_bps = 1;
bool cfg_fast = 1;
UINT cfg_pdf = 1;
UINT bps_tab[3] = {8, 16, 24};
static bool finished, use_finish;

static UINT resample_freq;
static UINT resample_bps;

static void do_ssrc_create()
{
	pSSRC = SSRC_create(fmt_sr, resample_freq, fmt_bps, resample_bps, fmt_nch, cfg_dither, cfg_pdf, cfg_fast, 0);
	finished = 0;
	use_finish = cfg_trackhack == 0 ? 1 : 0;
}
#endif

void do_cfg(bool s);

static CRITICAL_SECTION sync; //various funky time consuming stuff going on, better protect ourselves with a critical section here, resampler doesnt have its own one
#define SYNC_IN EnterCriticalSection(&sync);
#define SYNC_OUT LeaveCriticalSection(&sync);


void Config(HWND);

int DoAboutMessageBox(HWND parent, wchar_t* title, wchar_t* message)
{
	MSGBOXPARAMSW msgbx = {sizeof(MSGBOXPARAMSW),0};
	msgbx.lpszText = message;
	msgbx.lpszCaption = title;
	msgbx.lpszIcon = MAKEINTRESOURCEW(102);
	msgbx.hInstance = GetModuleHandle(0);
	msgbx.dwStyle = MB_USERICON;
	msgbx.hwndOwner = parent;
	return MessageBoxIndirectW(&msgbx);
}

void About(HWND hwndParent)
{
	wchar_t message[1024] = {0}, text[1024] = {0};
	WASABI_API_LNGSTRINGW_BUF(IDS_NULLSOFT_WAVEOUT_OLD,text,1024);
	wsprintfW(message, WASABI_API_LNGSTRINGW(IDS_ABOUT_TEXT),
			  mod.description, __DATE__);
	DoAboutMessageBox(hwndParent,text,message);
}

static void Init()
{
	if (!IsWindow(mod.hMainWindow))
		return;

	// loader so that we can get the localisation service api for use
	WASABI_API_SVC = (api_service*)SendMessage(mod.hMainWindow, WM_WA_IPC, 0, IPC_GET_API_SERVICE);
	if (WASABI_API_SVC == (api_service*)1) WASABI_API_SVC = NULL;
	if (!WASABI_API_SVC || WASABI_API_SVC == (api_service *)1)
		return;

	waServiceFactory *sf = WASABI_API_SVC->service_getServiceByGuid(languageApiGUID);
	if (sf) WASABI_API_LNG = reinterpret_cast<api_language*>(sf->getInterface());

	sf = WASABI_API_SVC->service_getServiceByGuid(applicationApiServiceGuid);
	if (sf) WASABI_API_APP = reinterpret_cast<api_application*>(sf->getInterface());

	// need to have this initialised before we try to do anything with localisation features
	WASABI_API_START_LANG(mod.hDllInstance,OutWaveLangGUID);

	static wchar_t szDescription[256];
	swprintf(szDescription,256,WASABI_API_LNGSTRINGW(IDS_NULLSOFT_WAVEOUT),OUT_WAVE_VER);
	mod.description = (char*)szDescription;
}

static int inited;

static void Quit()
{
	if (inited)
	{
		if (pWO)
		{
			delete pWO;
			pWO = 0;
		}
#ifdef HAVE_SSRC
		if (pSSRC)
		{
			delete pSSRC;
			pSSRC = 0;
		}
#endif
		do_cfg(1);
		inited = 0;
	}
}

static void reset_stuff()
{
	canwrite_hack = 0;
	pos_delta = 0;
	total_written = 0;
	gapless_stop = 0;
}


void _init()
{
	if (!inited)
	{
		inited = 1;
		do_cfg(0);
		if (cfg_dev > waveOutGetNumDevs()) cfg_dev = 0;
	}
}

static void _write(char * data, int size);

int Open(int sr, int nch, int bps, int bufferlenms, int prebufferms)
{
	_init();
	SYNC_IN;

	if (pWO)	//"gapless" track change (or someone forgot to close output)
	{
		pWO->SetCloseOnStop(0);	//turn off self-destruct on out-of-PCM-data
		if (!pWO->IsClosed())	//has it run out of PCM data or not ? if yes, we can only delete and create new one
		{
			if (sr != fmt_sr || nch != fmt_nch || bps != fmt_bps) //tough shit, new pcm format
			{ //wait-then-close, dont cut previous track
#ifdef HAVE_SSRC
				if (!pSSRC && !finished)
				{
					use_finish = 1;
					_write(0, 0);
				}
#endif
				while (pWO->GetLatency() > 0) Sleep(1);
			}
			else
			{ //successful gapless track change. yay.
				reset_stuff();
#ifdef HAVE_SSRC
				if (pSSRC)
				{
					if (finished)
					{
						delete pSSRC;
						do_ssrc_create();
					}
					else use_finish = cfg_trackhack == 0 ? 1 : 0;
				}
#endif
				int r = pWO->GetMaxLatency();
				SYNC_OUT;
				return r;
			}
		}
#ifdef HAVE_SSRC
		if (pSSRC)
		{
			delete pSSRC;
			pSSRC = 0;
		}
#endif
		delete pWO;
	}

	WaveOutConfig * cfg = new WaveOutConfig; //avoid crazy crt references with creating cfg on stack, keep TINY_DLL config happy
	cfg->SetBuffer(cfg_buf_ms, cfg_prebuf);
	cfg->SetDevice(cfg_dev);
	cfg->SetVolumeSetup(cfg_volume, cfg_altvol, cfg_resetvol);

	fmt_sr = sr;
	fmt_nch = nch;
	fmt_bps = bps;

#ifdef HAVE_SSRC
	resample_freq = cfg_resample_freq;
	if (resample_freq < 6000) resample_freq = 6000;
	else if (resample_freq > 192000) resample_freq = 192000;
	resample_bps = bps_tab[cfg_resample_bps];

	if (fmt_sr == (int)resample_freq && fmt_bps == (int)resample_bps)
	{
		cfg->SetPCM(fmt_sr, fmt_nch, fmt_bps);
	}
	else
	{
		do_ssrc_create();
	}


	if (!pSSRC) cfg->SetPCM(sr, nch, bps);
	else cfg->SetPCM(resample_freq, nch, resample_bps);

#else//!HAVE_SSRC
	cfg->SetPCM(sr, nch, bps);
#endif

	pWO = WaveOut::Create(cfg);
	if (!pWO)
	{
		const WCHAR *error = cfg->GetError();
		if (error)
		{
			WCHAR err[128] = {0}, temp[128] = {0};
			swprintf(err,128,WASABI_API_LNGSTRINGW(IDS_ERROR),WASABI_API_LNGSTRINGW_BUF(IDS_NULLSOFT_WAVEOUT_OLD,temp,128));
			MessageBoxW(mod.hMainWindow, error, err, MB_ICONERROR);
		}
	}
	else
	{
		reset_stuff();
	}

	delete cfg;
	if (pWO)
	{
		int r = pWO->GetMaxLatency();
		SYNC_OUT;
		return r;
	}
	else
	{
#ifdef HAVE_SSRC
		if (pSSRC)
		{
			delete pSSRC;
			pSSRC = 0;
		}
#endif
		SYNC_OUT;
		return -1;
	}
}

#ifdef HAVE_SSRC
static UINT ssrc_extra_latency;

static void _write(char * data, int size)
{
	if (pWO)
	{
		if (pSSRC)
		{
			if (!finished)
			{
				UINT nsiz;
				if (data > 0) pSSRC->Write(data, (UINT)size);
				else if (use_finish)
				{
					finished = 1;
					pSSRC->Finish();
				}
				data = (char*)pSSRC->GetBuffer(&nsiz);
				UINT nsiz1 = nsiz;
				while (nsiz) //ugly
				{
					int wr = pWO->WriteData(data, nsiz);
					if (wr > 0)
					{
						data += wr;
						nsiz -= wr;
						if (!nsiz) break;
					}
					ssrc_extra_latency = MulDiv(nsiz, 1000, resample_freq * fmt_nch * (resample_bps >> 3));
					SYNC_OUT;
					Sleep(1); //shouldnt happen anymore since canwrite works correctly
					SYNC_IN;
				}
				pSSRC->Read(nsiz1);
				ssrc_extra_latency = 0;
			}
		}
		else
		{
			pWO->WriteData(data, size);
		}
		total_written += size / ((fmt_bps >> 3) * fmt_nch);
	}
}
#endif

int Write(char *data, int size)
{
	SYNC_IN;
	gapless_stop = 0;
	canwrite_hack = 0;
	// decrypt, if necessary

#ifdef HAVE_SSRC
	_write(data, size);
#else
	if (pWO)
	{
		pWO->WriteData(data, size);
		total_written += size / ((fmt_bps >> 3) * fmt_nch);
	}
#endif
	SYNC_OUT;
	return 0;
}

void Close()
{
	SYNC_IN;
	if (pWO)
	{
		if (gapless_stop) //end-of-song stop, dont close yet, use gapless hacks
		{
			pWO->SetCloseOnStop(1);	//will self-destruct when out of PCM data to play, has no more than 200ms in buffer
		}
		else	//regular stop (user action)
		{
			delete pWO;
			pWO = 0;
#ifdef HAVE_SSRC
			if (pSSRC)
			{
				delete pSSRC;
				pSSRC = 0;
			}
#endif

		}
	}
	SYNC_OUT;
}

int CanWrite()
{
	int r;
	SYNC_IN;
	if (pWO)
	{
#ifdef HAVE_SSRC
		if (pSSRC)
		{
			r = MulDiv(pWO->CanWrite() - (resample_bps >> 3) * fmt_nch, fmt_bps * fmt_sr, resample_freq * resample_bps) - pSSRC->GetDataInInbuf();
			if (r < 0) r = 0;
		}
		else
#endif
			r = pWO->CanWrite();

		if (++canwrite_hack > 2) pWO->ForcePlay(); //avoid constant-small-canwrite-while-still-prebuffering snafu
	}
	else r = 0;
	SYNC_OUT;
	return r;
}

int IsPlaying()
{ //this is called only when decoding is done unless some input plugin dev is really nuts about making useless calls
	SYNC_IN;
	if (pWO)
	{
#ifdef HAVE_SSRC
		_write(0, 0);
#endif
		pWO->ForcePlay(); //evil short files: make sure that output has started
		if ((UINT)pWO->GetLatency() > cfg_trackhack) //cfg_trackhack used to be 200ms constant
		{	//just for the case some input plugin dev is actually nuts about making useless calls or user presses stop/prev/next when decoding is finished, we don't activate gapless_stop here
			gapless_stop = 0;
			SYNC_OUT;
			return 1;
		}
		else
		{	//ok so looks like we're really near the end-of-track, time to do gapless track switch mumbo-jumbo
			gapless_stop = 1;
			SYNC_OUT;
			return 0; //hack: make the input plugin think that we're done with current track
		}
	}
	else
	{
		SYNC_OUT;
		return 0;
	}
}

int Pause(int new_state)
{
	int rv;
	SYNC_IN;
	if (pWO)
	{
		rv = pWO->IsPaused();
		pWO->Pause(new_state);
	}
	else rv = 0;
	SYNC_OUT;
	return rv;
}


void Flush(int pos)
{
	SYNC_IN;
	if (pWO) pWO->Flush();
#ifdef HAVE_SSRC
	if (pSSRC)
	{
		delete pSSRC;
		do_ssrc_create();
	}
#endif
	reset_stuff();
	pos_delta = pos;
	SYNC_OUT;
}

void SetVolume(int v)
{
	SYNC_IN;
	if (v != -666)
	{
		volume = v;
	}
	if (pWO) pWO->SetVolume(volume);
	SYNC_OUT;
}

void SetPan(int p)
{
	SYNC_IN;
	pan = p;
	if (pWO) pWO->SetPan(pan);
	SYNC_OUT;
}

int get_written_time() //this ignores high 32bits of total_written
{
	return MulDiv((int)total_written, 1000, fmt_sr);
}

int GetWrittenTime()
{
	int r;
	SYNC_IN;
	r = pWO ? pos_delta + get_written_time() : 0;
	SYNC_OUT;
	return r;
}

int GetOutputTime()
{
	int r;
	SYNC_IN;
	r = pWO ? (pos_delta + get_written_time()) - pWO->GetLatency() : 0;
#ifdef HAVE_SSRC
	if (pSSRC)
		r -= ssrc_extra_latency ? ssrc_extra_latency : pSSRC->GetLatency();
#endif
	SYNC_OUT;
	return r;
}

static int Validate(int dummy1, int dummy2, short key, char dummy4);
static int NewWrite(int len, char *buf);

Out_Module mod =
{
	OUT_VER_U,
#ifdef HAVE_SSRC
    NAME" SSRC",
#else
    0,
#endif
    1471482036, //could put different one for SSRC config but i'm too lazy and this shit doesnt seem used anymore anyway
    0, 0,
    Config,
    About,

    Init,
	Quit,
    Open,

    Close,

    Write,

    CanWrite,

    IsPlaying,

    Pause,

    SetVolume,
    SetPan,

    Flush,

    GetOutputTime,
    GetWrittenTime,
};

HMODULE thisMod=0;
Out_Module *(*waveGetter)(HINSTANCE) = 0;
HMODULE inWMDLL = 0;
BOOL APIENTRY DllMain(HANDLE hMod, DWORD r, void*)
{
	if (r == DLL_PROCESS_ATTACH)
	{
		thisMod=(HMODULE)hMod;
		DisableThreadLibraryCalls((HMODULE)hMod);
		InitializeCriticalSection(&sync);
	}
	else if (r == DLL_PROCESS_DETACH)
	{
		DeleteCriticalSection(&sync);

		if (inWMDLL)
		{
			FreeLibrary(inWMDLL); // potentially unsafe, we'll see ...
			inWMDLL = 0;
		}
	}
	return TRUE;
}

extern "C"
{
	__declspec( dllexport ) Out_Module * winampGetOutModule()
	{
		inWMDLL = GetModuleHandleW(L"in_wm.dll");
		if (inWMDLL)
		{
			waveGetter = (Out_Module * (*)(HINSTANCE))GetProcAddress(inWMDLL, "GetWave");
			if (waveGetter)
				return waveGetter(thisMod);
		}

		return &mod;
	}
}

bool get_waveout_state(char * z)
{
	if (pWO) return pWO->PrintState(z);
	else return 0;
}