steve
/
winamp
mirror of https://github.com/WinampDesktop/winamp.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
winamp/Src/Plugins/Output/out_ds/ds2.cpp

1372 lines
27 KiB
C++
Raw Normal View History

Initial community commit
2024-09-24 12:54:57 +00:00
//#define USE_LOG
//^^ for debug logging to c:\ds2.txt
#include "ds2.h"
#include <dsound.h>
#include <math.h>
#include <ks.h>
#include "ksmedia.h"
#include "../winamp/wa_ipc.h"
extern Out_Module mod;
static const int kMaxChannelsToMask = 8;
static const unsigned int kChannelsToMask[kMaxChannelsToMask + 1] =
{
0,
// 1 = Mono
SPEAKER_FRONT_CENTER,
// 2 = Stereo
SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT,
// 3 = Stereo + Center
SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER,
// 4 = Quad
SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT |
SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT,
// 5 = 5.0
SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT | SPEAKER_FRONT_CENTER |
SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT,
// 6 = 5.1
SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT |
SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY |
SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT,
// 7 = 6.1
SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT |
SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY |
SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT |
SPEAKER_BACK_CENTER,
// 8 = 7.1
SPEAKER_FRONT_LEFT | SPEAKER_FRONT_RIGHT |
SPEAKER_FRONT_CENTER | SPEAKER_LOW_FREQUENCY |
SPEAKER_BACK_LEFT | SPEAKER_BACK_RIGHT |
SPEAKER_SIDE_LEFT | SPEAKER_SIDE_RIGHT
// Add additional masks for 7.2 and beyond.
};
DS2::tDirectSoundCreate DS2::pDirectSoundCreate = 0;
#ifdef DS2_HAVE_DEVICES
DS2::tDirectSoundEnumerate DS2::pDirectSoundEnumerate = 0;
#endif
static UINT refresh_timer = 10;
static const GUID NULL_GUID;
HRESULT DS2::myDirectSoundCreate(const GUID* g, IDirectSound** out)
{
HRESULT r;
try
{
r = DS2::pDirectSoundCreate((!g || *g == NULL_GUID) ? (const GUID*)0 : g, out, 0);
}
catch (...)
{
*out = 0;
r = DSERR_GENERIC;
}
return r;
}
#define ftest(X) (!!(flags & FLAG_##X))
#define fset(X) flags|=FLAG_##X
#define funset(X) flags&=~FLAG_##X
#define fsetc(X,Y) {if (Y) fset(X); else funset(X);}
static HINSTANCE hdsound;
static bool g_delayed_deinit = 1;
static __int64 g_total_time;
static HANDLE g_hEvent;
static CriticalSection g_sync;
static bool g_quitting, g_quitting_waiting;
#define SYNCFUNC T_SYNC SYNC(g_sync);
void DS2::SYNC_IN() { g_sync.Enter(); }
void DS2::SYNC_OUT() { g_sync.Leave(); }
static DWORD last_rel_time;
static DWORD coop_mode;
IDirectSound* DS2::pDS = 0;
static IDirectSoundBuffer* pPrimary;
static UINT prim_bps, prim_nch, prim_sr;
static GUID cur_dev;
static DS2* ds2s = nullptr;
static HANDLE g_hThread;
static bool create_primary = 0;
#ifdef USE_LOG
static void _log_write(char* msg, DS2* foo)
{
char tmp[512];
SYSTEMTIME st;
GetSystemTime(&st);
wsprintf(tmp, "DS2: %02u:%02u.%03u %08x %s\n", st.wMinute, st.wSecond, st.wMilliseconds, foo, msg);
#if 1
static HANDLE hLog;
if (!hLog) hLog = CreateFile("c:\\ds2.txt", GENERIC_WRITE, 0, 0, CREATE_ALWAYS, 0, 0);
DWORD bw = 0;
WriteFile(hLog, tmp, strlen(tmp), &bw, 0);
#else
OutputDebugString(tmp);//bleh flood, getting holes in the log, blame micro$oft
#endif
}
#define log_write(x) _log_write(x,this)
#else
#define _log_write(x,y)
#define log_write(x)
#endif
static int calc_silence(float _db, int bps)//_db is in -0.1db
{
return (int)(pow(10.0, _db / (-20.0)) * pow(2.0, (double)bps));
}
void DS2::test_silence(char* buf, int len, int* first, int* last)
{
int bps = fmt_bps >> 3;
if (bps > 4 || bps < 1)
{
if (first) *first = 0;
if (last) *last = (len - fmt_nch * bps);
return;
}
int ptr = 0;
while (ptr < len)
{
int p = ptr;
UINT n;
for (n = 0; n < fmt_nch; n++)
{
int s;
void* _p = buf + p;
switch (bps)
{
case 1:
s = (UINT) * (BYTE*)_p - 0x80;
break;
case 2:
s = *(short*)_p;
break;
case 3:
{
long poo = 0;
memcpy(&poo, _p, 3);
if (poo & 0x800000) poo |= 0xFF000000;
s = poo;
}
break;
case 4:
s = *(long*)_p;
break;
}
if (s < 0) s = -s;
if (s > silence_delta)
{
if (first && *first < 0) *first = ptr;
if (last) *last = ptr;
}
p += bps;
}
ptr = p;
}
}
DS2::DS2(DS2config* cfg) : BlockList(cfg->bps == 8 ? 0x80 : 0)
#ifdef DS2_HAVE_FADES
, VolCtrl(cfg->volmode, cfg->logvol_min, cfg->logfades)
#endif
{
#ifdef _DEBUG
srand(GetTickCount());
serial = rand();
sync_n = 0;
#endif
next = ds2s;
ds2s = this;
wait = 0;
flags = 0;
LockCount = 0;
Underruns = 0;
fsetc(USE_CPU_MNGMNT, cfg->use_cpu_management);
refresh_timer = cfg->refresh;
if (refresh_timer < 1) refresh_timer = 1;
else if (refresh_timer > 100) refresh_timer = 100;
pDSB = 0;
myDS = 0;
}
DS2::~DS2()
{
log_write("~DS2");
SYNC_IN();
ds_kill();
SYNC_OUT();
}
DS2* DS2::Create(DS2config* cfg)
{
Init();
if (!hdsound) return 0;
_log_write("Create", 0);
SYNC_IN();
DS2* r = new DS2(cfg);
if (!r->Open(cfg))
{
delete r;
r = 0;
}
else SetEvent(g_hEvent);//wake update thread up
SYNC_OUT();
return r;
}
void DS2::ds_kill()
{
if (wait)
{
delete wait;
wait = 0;
}
if (pDSB)
{
if (ftest(PLAYING) && !ftest(PAUSED)) pDSB->Stop();
pDSB->Release();
pDSB = 0;
last_rel_time = GetTickCount();
}
if (myDS)
{
myDS->Release();
myDS = 0;
}
do_reset_vars();
//UGLY moved from destructor
DS2* foo = ds2s;
DS2** foo2 = &ds2s;
while (foo)
{
if (foo == this) { *foo2 = next; break; }
foo2 = &foo->next; foo = *foo2;
}
}
int DS2::WriteData(void* _data, UINT size, bool* killswitch)
{//note: calling code may or may not care about CanWrite() (but if they do, we wont sleep)
if (ftest(PAUSED)) return 0;
log_write("entering writedata");
char* data = (char*)_data;
size = _align_var(size);//avoid evil shit
SYNC_IN();
if (silence_delta >= 0)//no need to sync this
{
if (ftest(STARTSIL))
{
int first = -1;
test_silence(data, size, &first, 0);
if (first >= 0)
{
size -= first;
data += first;
funset(STARTSIL);
}
else
{
log_write("block was silent, leaving writedata");
SYNC_OUT();
return 1;
}
}
int last = -1;
test_silence(data, size, 0, &last);
if (last != -1)
{
log_write("WriteData / last_nonsil update");
last_nonsil = last + data_written + BlockList.DataSize();
}
}
log_write("WriteData");
BlockList.AddBlock(data, size);
if (data_buffered < clear_size) SetEvent(g_hEvent);
else while (!*killswitch && CanWrite() < 0)
{
SYNC_OUT();
Sleep(1);
log_write("WriteData");
SYNC_IN();
}
SYNC_OUT();
log_write("writedata done");
return 1;
}
int DS2::WriteDataNow(void* data, UINT size)
{
log_write("WriteDataNow");
SYNC_IN();
int cw = CanWrite();
int rv = 0;
if (cw > 0)
{
if (size > (UINT)cw) size = (UINT)cw;
if (ForceWriteData(data, size)) rv = size;
}
SYNC_OUT();
return rv;
}
int DS2::ForceWriteData(void* data, UINT size)
{
log_write("ForceWriteData");
SYNC_IN();
bool killswitch = 1;
int r = WriteData(data, size, &killswitch);
SYNC_OUT();
return r;
}
DWORD WINAPI DS2::ThreadFunc(void* zzz)
{
_log_write("ThreadFunc", 0);
SYNC_IN();
while (1)
{
DS2* foo = ds2s;
while (foo)
{
foo->flags &= ~FLAG_UPDATED;
foo = foo->next;
}
foo = ds2s;
while (foo)
{
if (!(foo->flags & FLAG_UPDATED) && foo->Update())
{//one *or more* of instances got deleted
foo = ds2s;
}
else
{
foo->flags |= FLAG_UPDATED;
foo = foo->next;
}
}
DWORD t = ds2s ? refresh_timer : (pDS ? 1000 : -1);
SYNC_OUT();
WaitForSingleObject(g_hEvent, t);
//use g_hEvent to wake thread up when something's going on
_log_write("ThreadFunc", 0);
SYNC_IN();
if (g_quitting) break;
if (!ds2s && pDS)
{
if (pPrimary) { pPrimary->Release(); pPrimary = 0; }
if (!g_delayed_deinit || GetTickCount() - last_rel_time > 3000)
{
pDS->Release();
pDS = 0;
}
}
}
while (ds2s) delete ds2s;
if (pPrimary) { pPrimary->Release(); pPrimary = 0; }
if (pDS) { pDS->Release(); pDS = 0; }
SYNC_OUT();
return 0;
}
//static void __cdecl __quit() {DS2::Quit(0);}
bool DS2::InitDLL()
{
if (!hdsound)
{
hdsound = LoadLibraryW(L"dsound.dll");
if (!hdsound) return false;//ouch
pDirectSoundCreate = (tDirectSoundCreate)GetProcAddress((HMODULE)hdsound, "DirectSoundCreate");
if (!pDirectSoundCreate) { FreeLibrary(hdsound); hdsound = 0; return false; }
#ifdef DS2_HAVE_DEVICES
pDirectSoundEnumerate = (tDirectSoundEnumerate)GetProcAddress((HMODULE)hdsound, "DirectSoundEnumerateW");
if (!pDirectSoundEnumerate) { pDirectSoundCreate = 0; FreeLibrary(hdsound); hdsound = 0; return false; }
#endif
}
return true;
}
void DS2::Init()
{
SYNC_IN();
InitDLL();
if (g_hThread || !hdsound) { SYNC_OUT(); return; }
pDS = 0;
ds2s = 0;
g_quitting = 0;
g_quitting_waiting = 0;
g_hEvent = CreateEvent(0, 0, 0, 0);
DWORD id;
g_hThread = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)ThreadFunc, 0, 0, &id);
if (!g_hThread)
{
return;
}
else
{
SetThreadPriority(g_hThread, THREAD_PRIORITY_TIME_CRITICAL);
}
SYNC_OUT();
}
void DS2::Quit(bool wait)
{
if (!g_hThread) return;
g_quitting_waiting = 1;
if (wait) while (ds2s) Sleep(3);
g_quitting = 1;
SetEvent(g_hEvent);
WaitForSingleObject(g_hThread, INFINITE);
CloseHandle(g_hThread);
g_hThread = 0;
CloseHandle(g_hEvent);
g_hEvent = 0;
if (hdsound)
{
FreeLibrary(hdsound);
pDirectSoundCreate = 0;
#ifdef DS2_HAVE_DEVICES
pDirectSoundEnumerate = 0;
#endif
hdsound = 0;
}
}
void DS2::ds_stop()
{
log_write("ds_stop");
if (ftest(PLAYING))
{
if (pDSB)
{
pDSB->Stop();
pDSB->SetCurrentPosition(0);
}
}
do_reset_vars();
}
void DS2::update_pos()//AKA update P.O.S.
{
//called from Update(), no need for shit condition tests
DWORD play_pos, play_pos_w;
try
{
pDSB->GetCurrentPosition(&play_pos, &play_pos_w);
}
catch (...)
{
return;
}
#ifdef USE_LOG
char moo[256];
wsprintf(moo, "update_pos: %u %u (%u)", play_pos, play_pos_w, buf_size);
log_write(moo);
#endif
UINT write_pos = (UINT)(data_written % buf_size);
data_buffered = write_pos > play_pos ? write_pos - play_pos : write_pos + buf_size - play_pos;
#ifdef DS2_HAVE_FADES
VolCtrl.SetTime(GetCurPos());
VolCtrl.Apply(pDSB);
#endif
}
bool DS2::Update()//inside sync already
{
log_write("Update");
if (g_quitting_waiting && (!ftest(PLAYING) || ftest(PAUSED) || !pDSB))
{
delete this;
return 1;
}
if (!pDSB || ftest(PAUSED))
{
return 0;
}
{
UINT min_refresh = bytes2ms(clear_size) >> 1;
if (refresh_timer > min_refresh) refresh_timer = min_refresh;
}
if (ftest(PLAYING)) update_pos();
#ifdef USE_LOG
{
char foo[256];
wsprintf(foo, "Update: %u(%u)+%u / %u(%u)", (int)data_written, (int)data_written % buf_size, BlockList.DataSize(), (int)GetCurPos(), (int)GetCurPos() % buf_size);
log_write(foo);
}
#endif
if (!ftest(PLAYING) && data_written + BlockList.DataSize() >= (int)prebuf && !wait)
{
log_write("done prebuffering");
fset(NEED_PLAY_NOW);
}
DoLock();
if (wait)
{
#ifdef DS2_HAVE_FADES
if (wait->GetLatency() <= waitfade)
{
wait->FadeAndForget(waitfade);
wait = 0;
if (!ftest(PLAYING)) fset(NEED_PLAY_NOW);
}
#else
if (wait->GetLatency() <= 0)
{
delete wait;
wait = 0;
if (!ftest(PLAYING)) fset(NEED_PLAY_NOW);
}
#endif
}
if (ftest(NEED_PLAY_NOW) && data_buffered > 0/* && !(ftest(PLAYING)*/)
{
log_write("starting playback");
if (!ftest(PAUSED))
{
HRESULT res = pDSB->Play(0, 0, DSBPLAY_LOOPING);
if (FAILED(res))
{
if (res == DSERR_BUFFERLOST) pDSB->Restore();
return 0;
}
pos_delta = GetOutputTime(); pos_delta2 = data_written;
}
PostMessage(mod.hMainWindow, WM_WA_IPC, 0, IPC_OUTPUT_STARTED);
fset(PLAYING);
}
funset(NEED_PLAY_NOW);
if (ftest(PLAYING))
{
{
DWORD foo = 0;
pDSB->GetStatus(&foo);
if (foo & DSBSTATUS_BUFFERLOST)
pDSB->Restore();
if (foo != (DSBSTATUS_PLAYING | DSBSTATUS_LOOPING))
pDSB->Play(0, 0, DSBPLAY_LOOPING);
}
#ifdef DS2_HAVE_FADES
if (!VolCtrl.Fading())
{
if (ftest(FADEPAUSING)) { Pause(1); funset(FADEPAUSING); }
if (ftest(DIE_ON_STOP) || g_quitting_waiting)
{
delete this;
return 1;
}
}
#endif
if (data_buffered <= silence_buffered)
{
log_write("underrun");
ds_stop();
if (ftest(DIE_ON_STOP) || g_quitting_waiting)
{
delete this;
return 1;
}
else if (ftest(CLOSE_ON_STOP))
{
log_write("closeonstop");
ds_kill();
}
#ifdef DS2_HAVE_FADES
else if (ftest(FADEPAUSING)) { Pause(1); funset(FADEPAUSING); }
#endif
else Underruns++;
}
}
return 0;
}
int DS2::Open(DS2config* cfg)
{
log_write("Open");
// SYNCFUNC; //inside sync already
HRESULT hr;
g_delayed_deinit = cfg->delayed_shutdown;
if (cfg->sil_db > 0) { silence_delta = calc_silence(cfg->sil_db, (int)cfg->bps); fset(STARTSIL); }
else silence_delta = -1;
create_primary = cfg->create_primary;
UINT _p_bps = 0, _p_nch = 0, _p_sr = 0;
if (cfg->prim_override)
{
_p_bps = cfg->_p_bps;
_p_nch = cfg->_p_nch;
_p_sr = cfg->_p_sr;
}
if (cfg->guid != cur_dev && pDS)
{
pDS->Release();
pDS = 0;
}
if (!pDS)
{
log_write("Creating IDirectSound");
cur_dev = cfg->guid;
hr = myDirectSoundCreate(&cur_dev, &pDS);
if (!pDS)
{
#ifdef DS2_HAVE_DEVICES
cfg->SetErrorCodeMsgA(DsDevEnumGuid(cur_dev) ? WASABI_API_LNGSTRINGW(IDS_BAD_DS_DRIVER) : WASABI_API_LNGSTRINGW(IDS_DEVICE_NOT_FOUND_SELECT_ANOTHER), hr);
#else
cfg->SetErrorCodeMsg(WASABI_API_LNGSTRING(IDS_BAD_DS_DRIVER), hr);
#endif
return 0;
}
coop_mode = 0;
}
fmt_sr = (int)cfg->sr;
fmt_nch = (WORD)cfg->nch;
fmt_bps = (UINT)cfg->bps;
if ((signed)fmt_sr <= 0 || (signed)fmt_bps <= 0 || (signed)fmt_nch <= 0) return 0;
fmt_mul = fmt_sr * (fmt_bps >> 3) * fmt_nch;
if (!_p_bps) _p_bps = fmt_bps;
if (!_p_nch) _p_nch = fmt_nch;
if (!_p_sr) _p_sr = fmt_sr;
WAVEFORMATEX wfx =
{
WAVE_FORMAT_PCM,
(WORD)fmt_nch,
fmt_sr,
fmt_mul,
(WORD)(fmt_nch * (fmt_bps >> 3)),
(WORD)fmt_bps,
0
};
{
static DWORD coop_tab[3] = { DSSCL_NORMAL,DSSCL_PRIORITY,DSSCL_EXCLUSIVE };
DWORD new_coop = coop_tab[cfg->coop];
if (pPrimary && !create_primary)
{
pPrimary->Release();
pPrimary = 0;
}
if (coop_mode != new_coop)
{
if (FAILED(hr = pDS->SetCooperativeLevel(cfg->wnd, coop_mode = new_coop)))
{
pDS->Release(); pDS = 0;
cfg->SetErrorCodeMsgA(WASABI_API_LNGSTRINGW(IDS_ERROR_SETTING_DS_COOPERATIVE_LEVEL), hr);
return 0;
}
}
if (create_primary && !pPrimary)
{
DSBUFFERDESC desc =
{
sizeof(DSBUFFERDESC),
DSBCAPS_PRIMARYBUFFER,
0,
0,
0
};
pDS->CreateSoundBuffer(&desc, &pPrimary, 0);
prim_nch = prim_bps = prim_sr = 0;
}
if (pPrimary && (_p_bps != prim_bps || _p_nch != prim_nch || _p_sr != prim_sr))
{
WAVEFORMATEX wfx1 =
{
WAVE_FORMAT_PCM,
(WORD)_p_nch,
_p_sr,
_p_sr * (_p_bps >> 3) * _p_nch,
(WORD)(_p_nch * (_p_bps >> 3)),
(WORD)_p_bps,
0
};
pPrimary->SetFormat(&wfx1);
prim_bps = _p_bps;
prim_nch = _p_nch;
prim_sr = _p_sr;
}
}
UINT new_buf_ms = cfg->ms;
if (new_buf_ms < 100) new_buf_ms = 100;// <= DO NOT TOUCH
else if (new_buf_ms > 100000) new_buf_ms = 100000;
log_write("Done with IDirectSound, creating buffer");
buf_size = _align_var(ms2bytes(new_buf_ms));
prebuf = ms2bytes(cfg->preb);
if (prebuf > buf_size) prebuf = buf_size;
else if (prebuf < 0) prebuf = 0;
DSBUFFERDESC desc =
{
sizeof(DSBUFFERDESC),
DSBCAPS_GETCURRENTPOSITION2 |
DSBCAPS_STICKYFOCUS |
DSBCAPS_GLOBALFOCUS |
DSBCAPS_CTRLPAN | DSBCAPS_CTRLVOLUME
#ifdef DS2_HAVE_PITCH
| (cfg->have_pitch ? DSBCAPS_CTRLFREQUENCY : 0)
#endif
,
buf_size,
0,
&wfx
};
switch (cfg->mixing)
{
case DS2config::MIXING_FORCE_HARDWARE:
desc.dwFlags |= DSBCAPS_LOCHARDWARE;
break;
case DS2config::MIXING_FORCE_SOFTWARE:
desc.dwFlags |= DSBCAPS_LOCSOFTWARE;
break;
}
// TODO:If an attempt is made to create a buffer with the DSBCAPS_LOCHARDWARE flag on a system where hardware acceleration is not available, the method fails with either DSERR_CONTROLUNAVAIL or DSERR_INVALIDCALL, depending on the operating system.
do
{
WAVEFORMATEXTENSIBLE wfxe = { 0 };
wfxe.Format = wfx;
wfxe.Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
wfxe.Format.cbSize = sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
wfxe.Format.nChannels = fmt_nch;
wfxe.Format.nBlockAlign = (wfxe.Format.nChannels *
wfxe.Format.wBitsPerSample) / 8;
wfxe.Format.nAvgBytesPerSec = wfxe.Format.nBlockAlign *
wfxe.Format.nSamplesPerSec;
wfxe.Samples.wReserved = 0;
if (fmt_nch > kMaxChannelsToMask) {
wfxe.dwChannelMask = kChannelsToMask[kMaxChannelsToMask];
}
else {
wfxe.dwChannelMask = kChannelsToMask[fmt_nch];
}
wfxe.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
wfxe.Samples.wValidBitsPerSample = wfxe.Format.wBitsPerSample;
desc.lpwfxFormat = &wfxe.Format;
hr = pDS->CreateSoundBuffer(&desc, &pDSB, 0);
if (SUCCEEDED(hr))
{
hr = 0;
break;
}
} while (0);
if (FAILED(hr) || !pDSB)
{
cfg->SetErrorCodeMsgA(WASABI_API_LNGSTRINGW(IDS_ERROR_CREATING_DS_BUFFER), hr);
return 0;
}
pDS->AddRef();
myDS = pDS;
{
DSBCAPS caps;
memset(&caps, 0, sizeof(caps));
caps.dwSize = sizeof(caps);
pDSB->GetCaps(&caps);
if (caps.dwFlags & DSBCAPS_LOCSOFTWARE) fset(SWMIXED);
}
clear_size = ms2bytes(200);
if (clear_size > buf_size >> 2) clear_size = buf_size >> 2;
clear_size = _align_var(clear_size);
if (prebuf < clear_size + (clear_size >> 1)) prebuf = clear_size + (clear_size >> 1);
VolCtrl.Apply(pDSB);
reset_vars();
//pDSB->SetVolume(DSBVOLUME_MAX);
log_write("Open : done");
return 1;
}
void DS2::reset_vars()
{
pos_delta = 0; pos_delta2 = 0;
flags &= ~(FLAG_NEED_PLAY_NOW | FLAG_PLAYING);
data_buffered = 0;
data_written = 0;
silence_buffered = 0;
last_nonsil = -1;
BlockList.Reset();
VolCtrl.Reset();
}
void DS2::do_reset_vars()
{
g_total_time += GetOutputTime();
reset_vars();
}
bool DS2::DoLock()
{
void* p1 = 0, * p2 = 0;
DWORD s1 = 0, s2 = 0;
UINT LockSize = (UINT)BlockList.DataSize();
if (LockSize > 0 && silence_buffered)
{
data_written -= silence_buffered;
__int64 min = GetSafeWrite();
if (data_written < min) data_written = min;
silence_buffered = 0;
}
UINT MaxData = buf_size;
int FooScale = ftest(SWMIXED) ? 6 : 4;
MaxData = _align_var(MaxData - (MaxData >> FooScale));
UINT MaxLock = MaxData > data_buffered ? MaxData - data_buffered : 0;
if (!MaxLock) return 0;
if (
((ftest(PLAYING)) || ftest(NEED_PLAY_NOW))
&& data_buffered + LockSize < clear_size)
//underrun warning, put extra silence
LockSize = clear_size - data_buffered;
if (LockSize > MaxLock) LockSize = MaxLock;
if (LockSize == 0) return 0;//final check for useless locks
if (data_buffered > clear_size && LockSize<buf_size >> FooScale) return 0;
log_write("locking");//lock away!
while (1)
{
HRESULT hr = pDSB->Lock((UINT)(data_written % (__int64)buf_size), LockSize, &p1, &s1, &p2, &s2, 0);
if (SUCCEEDED(hr))
{
LockCount++;
UINT written;
written = (UINT)BlockList.DumpBlocks(p1, s1);
if (p2 && s2) written += (UINT)BlockList.DumpBlocks(p2, s2);
//note: we fill with silence when not enough data
UINT total = s1 + s2;
data_written = data_written + total;
data_buffered += total;
if (written > 0) silence_buffered = total - written;
else silence_buffered += total;
pDSB->Unlock(p1, s1, p2, s2);
break;
}
else if (hr == DSERR_BUFFERLOST) {
if (FAILED(pDSB->Restore())) break;
}
else break;
}
return 1;
}
int DS2::CanWrite()//result can be negative !
{
log_write("CanWrite");
SYNC_IN();
if (ftest(PAUSED)) { SYNC_OUT(); return 0; }
int rv;
int m = buf_size - (int)(data_buffered + BlockList.DataSize());
if (ftest(USE_CPU_MNGMNT) && ftest(PLAYING))// && data_written<buf_size && GetCurPos()<buf_size)
{
__int64 t = ((GetCurPos() - pos_delta) << 2) - (data_written - pos_delta2 + BlockList.DataSize());
rv = t > m ? m : (int)t;
}
else
{
rv = m;
}
if (wait) rv -= ms2bytes(wait->GetLatency());
#ifdef USE_LOG
char moo[256];
wsprintf(moo, "CanWrite : %i", rv);
log_write(moo);
#endif
SYNC_OUT();
return _align_var(rv);
}
void DS2::Pause(int new_state)
{
SYNC_IN();
#ifdef USE_LOG
log_write("Pause");
if (ftest(PAUSED)) log_write("is_paused");
if (new_state) log_write("new_state");
#endif
if (new_state && !ftest(PAUSED))
{//pause
log_write("pausing");
if (ftest(PLAYING) && pDSB)
{
pDSB->Stop();
#ifdef USE_LOG
char foo[256];
wsprintf(foo, "stopping buffer - %u", GetCurPos());
log_write(foo);
#endif
}
fset(PAUSED);
}
else if (!new_state)
{
if (ftest(PAUSED))
{//unpause
log_write("unpausing");
if (ftest(PLAYING)) fset(NEED_PLAY_NOW);
#ifdef DS2_HAVE_FADES
if (ftest(FADEPAUSE))
{
VolCtrl.SetTime(GetCurPos());
VolCtrl.SetFadeVol(ms2bytes(fadepause_time), fadepause_orgvol);
}
#endif
log_write("unpausing");
}
#ifdef DS2_HAVE_FADES
else if (ftest(FADEPAUSING))//abort fadeout
{
VolCtrl.SetTime(GetCurPos());
VolCtrl.SetFadeVol(VolCtrl.RelFade(ms2bytes(fadepause_time), fadepause_orgvol), fadepause_orgvol);
}
funset(FADEPAUSE);
funset(FADEPAUSING);
#endif
funset(PAUSED);
}
if (wait)
{
log_write("wait pause too");
wait->Pause(new_state);
}
log_write("pause done");
SYNC_OUT();
}
void DS2::SetVolume(double v)
{
SYNC_IN();
if (!ftest(DIE_ON_STOP) && pDSB)
{
VolCtrl.SetVolume(v);
VolCtrl.Apply(pDSB);
}
if (wait) wait->SetVolume(v);
SYNC_OUT();
}
void DS2::SetPan(double p)
{
SYNC_IN();
if (!ftest(DIE_ON_STOP) && pDSB)
{
VolCtrl.SetPan(p);
VolCtrl.Apply(pDSB);
}
if (wait) wait->SetPan(p);
SYNC_OUT();
}
UINT DS2::GetLatency()
{
SYNC_IN();
UINT bDataSize = (UINT)BlockList.DataSize();
int bytes;
if (bDataSize) bytes = data_buffered + (UINT)BlockList.DataSize();
else bytes = data_buffered - silence_buffered;
if (bytes < 0) bytes = 0;
UINT rv = bytes2ms((UINT)bytes);
if (wait) rv += wait->GetLatency();
#ifdef USE_LOG
{
char foo[128];
wsprintf(foo, "GetLatency: %u (%u %u)", rv, data_written - GetCurPos(), BlockList.DataSize());
log_write(foo);
}
#endif
SYNC_OUT();
return rv;
}
#ifdef DS2_HAVE_FADES
void DS2::Fade(UINT time, double destvol)
{
SYNC_IN();
VolCtrl.SetFadeVol(ms2bytes(time), destvol);
SYNC_OUT();
}
void DS2::FadeAndForget(UINT time)
{
SYNC_IN();
if (!pDSB || time == 0 || ftest(PAUSED) || (!data_written && !BlockList.DataSize()))
{
delete this;
}
else
{
fset(DIE_ON_STOP);
if (!ftest(PLAYING)) fset(NEED_PLAY_NOW);
__int64 fadetime = ms2bytes(time);
__int64 max = data_written + BlockList.DataSize() - GetCurPos();
if (max < 0) max = 0;
if (fadetime > max) fadetime = max;
VolCtrl.SetFadeVol(fadetime, 0);
}
SYNC_OUT();
}
void DS2::FadeX(UINT time, double dest)
{
SYNC_IN();
if (ftest(PAUSED) && ftest(FADEPAUSE))
{
fadepause_orgvol = dest;
}
VolCtrl.SetFadeVol(VolCtrl.RelFade(ms2bytes(time), dest), dest);
SYNC_OUT();
}
void DS2::FadePause(UINT time)
{
SYNC_IN();
if (!time)
{
Pause(1);
}
else
{
if (wait)
{
wait->FadeAndForget(time);
wait = 0;
}
if (!ftest(PLAYING))
{
fset(PAUSED);
}
else
{
fadepause_time = time;
fset(FADEPAUSE);
fset(FADEPAUSING);
fadepause_orgvol = VolCtrl.GetDestVol();
VolCtrl.SetFadeVol(ms2bytes(time), 0);
}
}
SYNC_OUT();
}
#endif
UINT DS2::InstanceCount()
{
_log_write("InstanceCount", 0);
SYNC_IN();
UINT rv = 0;
DS2* p = ds2s;
while (p) { rv++; p = p->next; }
SYNC_OUT();
return rv;
}
__int64 DS2::GetSafeWrite()
{
return GetCurPos() + clear_size + ms2bytes(refresh_timer);
}
void DS2::KillEndGap()
{
SYNC_IN();
if (silence_delta >= 0 && last_nonsil >= 0)
{
__int64 cp = GetSafeWrite();
if (cp < data_written)
{
__int64 dest = last_nonsil < cp ? cp : last_nonsil;
if (dest > data_written)
{//need to take data from blocklist
UINT s = (UINT)BlockList.DataSize();
char* temp0r = (char*)malloc(s);
BlockList.DumpBlocks(temp0r, s);
BlockList.Reset();
BlockList.AddBlock(temp0r, (UINT)(dest - data_written));
free(temp0r);
}
else
{
BlockList.Reset();
data_written = dest;
}
}
last_nonsil = -1;
fset(STARTSIL);
}
SYNC_OUT();
}
void DS2::Flush()
{
log_write("Flush");
SYNC_IN();
ds_stop();
SYNC_OUT();
}
void DS2::ForcePlay()
{
SYNC_IN();
if (!ftest(PAUSED) && !ftest(PLAYING) && !wait && data_buffered + BlockList.DataSize() > 0)
{
log_write("forceplay");
fset(NEED_PLAY_NOW);
}
SYNC_OUT();
}
void DS2::WaitFor(DS2* prev, UINT fade)
{
SYNC_IN();
if (wait) delete wait;
wait = prev;
#ifdef DS2_HAVE_FADES
waitfade = fade;
#endif
wait->flags |= FLAG_WAITED;
wait->ForcePlay();
SYNC_OUT();
}
void DS2::StartNewStream()
{
SYNC_IN();
if (last_nonsil > data_written + (UINT)BlockList.DataSize()) last_nonsil = data_written + (UINT)BlockList.DataSize();
pos_delta = GetCurPos(); pos_delta2 = data_written;
SYNC_OUT();
}
void DS2::SetCloseOnStop(bool b)
{
SYNC_IN();
log_write("setcloseonstop");
fsetc(CLOSE_ON_STOP, b);
if (b && !ftest(PLAYING)) ds_kill();
SYNC_OUT();
}
bool DS2::IsClosed()
{
SYNC_IN();
bool rv = pDSB ? 0 : 1;
SYNC_OUT();
return rv;
}
void DS2::GetRealtimeStat(DS2_REALTIME_STAT* stat)
{
log_write("GetRealtimeStat");
SYNC_IN();
__int64 curpos = GetCurPos();
stat->sr = fmt_sr;
stat->bps = fmt_bps;
stat->nch = fmt_nch;
stat->buf_size_bytes = buf_size;
stat->buf_size_ms = bytes2ms(buf_size);
stat->pos_play = (UINT)(curpos % buf_size);
stat->pos_write = (UINT)(data_written % buf_size);
stat->latency = data_buffered + (UINT)BlockList.DataSize();
if (stat->latency < 0) stat->latency = 0;
stat->latency_ms = bytes2ms(stat->latency);
stat->lock_count = LockCount;
stat->underruns = Underruns;
stat->bytes_async = BlockList.DataSize();
stat->bytes_written = data_written + BlockList.DataSize();
stat->bytes_played = curpos;
stat->have_primary_buffer = pPrimary ? true : false;
stat->current_device = cur_dev;
stat->vol_left = VolCtrl.Stat_GetVolLeft();
stat->vol_right = VolCtrl.Stat_GetVolRight();
if (pDSB)
{
DSBCAPS caps;
memset(&caps, 0, sizeof(caps));
caps.dwSize = sizeof(caps);
pDSB->GetCaps(&caps);
stat->dscaps_flags = caps.dwFlags;
}
else stat->dscaps_flags = 0;
if (pPrimary)
{
DSBCAPS caps;
memset(&caps, 0, sizeof(caps));
caps.dwSize = sizeof(caps);
pPrimary->GetCaps(&caps);
stat->dscaps_flags_primary = caps.dwFlags;
}
else stat->dscaps_flags_primary = 0;
stat->paused = !!ftest(PAUSED);
SYNC_OUT();
}
bool DS2::GetRealtimeStatStatic(DS2_REALTIME_STAT* stat)
{
bool rv = 0;
SYNC_IN();
if (ds2s) { ds2s->GetRealtimeStat(stat); rv = 1; }
SYNC_OUT();
return rv;
}
void DS2::SetTotalTime(__int64 z)
{
_log_write("SetTotalTime", 0);
SYNC_IN();
g_total_time = z;
SYNC_OUT();
}
__int64 DS2::GetTotalTime()
{
_log_write("GetTotalTime", 0);
SYNC_IN();
__int64 r = g_total_time;
DS2* p = ds2s;
while (p)
{
r += p->GetOutputTime();
p = p->next;
}
SYNC_OUT();
return r;
}
__int64 DS2::GetOutputTime()
{
if (!fmt_bps || !fmt_nch || !fmt_sr) return 0;
SYNC_IN();//need __int64, cant do bytes2ms
__int64 r = (GetCurPos()) / ((fmt_bps >> 3) * fmt_nch) * 1000 / fmt_sr;
SYNC_OUT();
return r;
}
#ifdef DS2_HAVE_PITCH
void DS2::SetPitch(double p)
{
SYNC_IN();
DWORD f = (DWORD)(p * (double)fmt_sr);
if (f < DSBFREQUENCY_MIN) f = DSBFREQUENCY_MIN;
else if (f > DSBFREQUENCY_MAX) f = DSBFREQUENCY_MAX;
if (pDSB) pDSB->SetFrequency(f);
SYNC_OUT();
}
#endif
#ifdef DS2_HAVE_DEVICES
GUID DS2::GetCurDev() { return cur_dev; }
#endif