Thread: [OMPT-svn-commit] SF.net SVN: modplug:[1869] trunk/OpenMPT (Page 30)

SourceForge Headquarters 225 Broadway Suite 1600 San Diego, CA 92101 +1 (858) 422-6466

Revision: 1869
          http://sourceforge.net/p/modplug/code/1869
Author:   manxorist
Date:     2013-04-13 13:07:51 +0000 (Sat, 13 Apr 2013)
Log Message:
-----------
[Ref] Properly protect the state of gpSoundDevice with a new m_SoundDeviceMutex instead of overloading the responsability of AudioCriticalSection.
[Fix] This might or might not fix some asio or wasapi related deadlocks.
[Ref] Remove CMainFrame::m_IsPlaybackRunning and move it into ISoundDevice.
[Fix] Fix stupid potential crashes when stopping waveout devices.
[Ref] Change audio rendering callbacks to take an additional ISoundDevice& parameter.

Modified Paths:
--------------
    trunk/OpenMPT/mptrack/ExceptionHandler.cpp
    trunk/OpenMPT/mptrack/MainFrm.cpp
    trunk/OpenMPT/mptrack/Mainfrm.h
    trunk/OpenMPT/mptrack/Mpdlgs.cpp
    trunk/OpenMPT/sounddev/SoundDevice.cpp
    trunk/OpenMPT/sounddev/SoundDevice.h
    trunk/OpenMPT/sounddev/SoundDevices.h

Modified: trunk/OpenMPT/mptrack/ExceptionHandler.cpp
===================================================================

--- trunk/OpenMPT/mptrack/ExceptionHandler.cpp	2013-04-13 13:03:30 UTC (rev 1868)
+++ trunk/OpenMPT/mptrack/ExceptionHandler.cpp	2013-04-13 13:07:51 UTC (rev 1869)
@@ -117,15 +117,18 @@
 LONG ExceptionHandler::UnhandledExceptionFilter(_EXCEPTION_POINTERS *pExceptionInfo)
 //----------------------------------------------------------------------------------
 {
+	// Shut down audio device...
 	CMainFrame* pMainFrame = CMainFrame::GetMainFrame();
-
-	// Shut down audio device...
 	if(pMainFrame)
 	{
 		try
 		{
-			if(pMainFrame->gpSoundDevice) pMainFrame->gpSoundDevice->Reset();
-			pMainFrame->audioCloseDevice();
+			// do not take m_SoundDeviceMutex here, just try closing it, no matter what
+			if(pMainFrame->gpSoundDevice)
+			{
+				pMainFrame->gpSoundDevice->Reset();
+				pMainFrame->gpSoundDevice->Close();
+			}
 		} catch(...)
 		{
 		}

Modified: trunk/OpenMPT/mptrack/MainFrm.cpp
===================================================================
--- trunk/OpenMPT/mptrack/MainFrm.cpp	2013-04-13 13:03:30 UTC (rev 1868)
+++ trunk/OpenMPT/mptrack/MainFrm.cpp	2013-04-13 13:07:51 UTC (rev 1869)
@@ -184,7 +184,6 @@
 	m_dwNotifyThreadId = 0;
 	m_hNotifyWakeUp = NULL;
 	gpSoundDevice = NULL;
-	m_IsPlaybackRunning = false;
 
 	m_bModTreeHasFocus = false;	//rewbs.customKeys
 	m_pNoteMapHasFocus = nullptr;	//rewbs.customKeys
@@ -473,14 +472,16 @@
 	BeginWaitCursor();
 	if (IsPlaying()) PauseMod();
 	if (pMDIActive) pMDIActive->SavePosition(TRUE);
-	if (gpSoundDevice)
+
 	{
-		CriticalSection cs;
-		//gpSoundDevice->Reset();
-		//audioCloseDevice();
-		delete gpSoundDevice;
-		gpSoundDevice = NULL;
+		Util::lock_guard<Util::mutex> lock(m_SoundDeviceMutex);
+		if(gpSoundDevice)
+		{
+			delete gpSoundDevice;
+			gpSoundDevice = nullptr;
+		}
 	}
+
 	// Save Settings
 	RemoveControlBar(&m_wndStatusBar); // Remove statusbar so that its state won't get saved.
 	TrackerSettings::Instance().SaveSettings();
@@ -702,7 +703,7 @@
 	int64 currenttotalsamples = 0;
 	bool currenttotalsamplesValid = false;
 	{
-		CriticalSection cs;
+		Util::lock_guard<Util::mutex> lock(m_SoundDeviceMutex);
 		if(gpSoundDevice && gpSoundDevice->HasGetStreamPosition())
 		{
 			currenttotalsamples = gpSoundDevice->GetStreamPositionSamples(); 
@@ -748,45 +749,28 @@
 }
 
 
-void CMainFrame::SetAudioThreadActive(bool active)
-//------------------------------------------------
+void CMainFrame::FillAudioBufferLocked(const ISoundDevice &device, IFillAudioBuffer &callback)
+//--------------------------------------------------------------------------------------------
 {
-	if(active)
-	{
-		if(m_IsPlaybackRunning) return;
-		m_IsPlaybackRunning = true;
-		gpSoundDevice->Start();
-	} else
-	{
-		if(!m_IsPlaybackRunning) return;
-		gpSoundDevice->Stop();
-		m_IsPlaybackRunning = false;
-	}
-}
-
-
-void CMainFrame::FillAudioBufferLocked(IFillAudioBuffer &callback)
-//----------------------------------------------------------------
-{
 	CriticalSection cs;
 	callback.FillAudioBuffer();
 }
 
 
-ULONG CMainFrame::AudioRead(PVOID pvData, ULONG MaxSamples)
-//---------------------------------------------------------
+ULONG CMainFrame::AudioRead(const ISoundDevice &device, PVOID pvData, ULONG MaxSamples)
+//-------------------------------------------------------------------------------------
 {
 	OPENMPT_PROFILE_FUNCTION(Profiler::Audio);
 	return m_pSndFile->Read(pvData, MaxSamples);
 }
 
 
-void CMainFrame::AudioDone(ULONG SamplesWritten, ULONG SamplesLatency, bool endOfStream)
-//--------------------------------------------------------------------------------------
+void CMainFrame::AudioDone(const ISoundDevice &device, ULONG SamplesWritten, ULONG SamplesLatency, bool endOfStream)
+//------------------------------------------------------------------------------------------------------------------
 {
 	if(SamplesWritten > 0)
 	{
-		DoNotification(SamplesWritten, SamplesLatency, endOfStream);
+		DoNotification(SamplesWritten, SamplesLatency, endOfStream, device.HasGetStreamPosition());
 	}
 }
 
@@ -821,21 +805,24 @@
 		}
 		WaveFormat.SubFormat = guid_MEDIASUBTYPE_PCM;
 	}
-	UINT nDevType = SNDDEV_GET_TYPE(TrackerSettings::Instance().m_nWaveDevice);
-	if ((gpSoundDevice) && (gpSoundDevice->GetDeviceType() != nDevType))
 	{
-		delete gpSoundDevice;
-		gpSoundDevice = NULL;
+		Util::lock_guard<Util::mutex> lock(m_SoundDeviceMutex);
+		UINT nDevType = SNDDEV_GET_TYPE(TrackerSettings::Instance().m_nWaveDevice);
+		if(gpSoundDevice && (gpSoundDevice->GetDeviceType() != nDevType))
+		{
+			delete gpSoundDevice;
+			gpSoundDevice = NULL;
+		}
+		if(!gpSoundDevice) gpSoundDevice = CreateSoundDevice(nDevType);
+		if(!gpSoundDevice) return false;
+		gpSoundDevice->SetSource(this);
+		gpSoundDevice->Configure(m_hWnd, TrackerSettings::Instance().m_LatencyMS, TrackerSettings::Instance().m_UpdateIntervalMS,
+			((TrackerSettings::Instance().m_MixerSettings.MixerFlags & SOUNDSETUP_SECONDARY) ? 0 : SNDDEV_OPTIONS_EXCLUSIVE)
+			|
+			((TrackerSettings::Instance().m_MixerSettings.MixerFlags & SOUNDSETUP_NOBOOSTTHREADPRIORITY) ? 0 : SNDDEV_OPTIONS_BOOSTTHREADPRIORITY)
+			);
+		if (!gpSoundDevice->Open(SNDDEV_GET_NUMBER(TrackerSettings::Instance().m_nWaveDevice), &WaveFormat.Format)) return false;
 	}
-	if(!gpSoundDevice) gpSoundDevice = CreateSoundDevice(nDevType);
-	if(!gpSoundDevice) return false;
-	gpSoundDevice->SetSource(this);
-	gpSoundDevice->Configure(m_hWnd, TrackerSettings::Instance().m_LatencyMS, TrackerSettings::Instance().m_UpdateIntervalMS,
-		((TrackerSettings::Instance().m_MixerSettings.MixerFlags & SOUNDSETUP_SECONDARY) ? 0 : SNDDEV_OPTIONS_EXCLUSIVE)
-		|
-		((TrackerSettings::Instance().m_MixerSettings.MixerFlags & SOUNDSETUP_NOBOOSTTHREADPRIORITY) ? 0 : SNDDEV_OPTIONS_BOOSTTHREADPRIORITY)
-		);
-	if (!gpSoundDevice->Open(SNDDEV_GET_NUMBER(TrackerSettings::Instance().m_nWaveDevice), &WaveFormat.Format)) return false;
 	return true;
 }
 
@@ -843,7 +830,8 @@
 bool CMainFrame::IsAudioDeviceOpen() const
 //----------------------------------------
 {
-	 return gpSoundDevice && gpSoundDevice->IsOpen();
+	Util::lock_guard<Util::mutex> lock(m_SoundDeviceMutex);
+	return gpSoundDevice && gpSoundDevice->IsOpen();
 }
 
 
@@ -861,7 +849,10 @@
 		err = !audioTryOpeningDevice(TrackerSettings::Instance().m_MixerSettings.gnChannels,
 								TrackerSettings::Instance().m_MixerSettings.m_SampleFormat,
 								TrackerSettings::Instance().m_MixerSettings.gdwMixingFreq);
-		nFixedBitsPerSample = (gpSoundDevice) ? gpSoundDevice->HasFixedBitsPerSample() : 0;
+		{
+			Util::lock_guard<Util::mutex> lock(m_SoundDeviceMutex);
+			nFixedBitsPerSample = (gpSoundDevice) ? gpSoundDevice->HasFixedBitsPerSample() : 0;
+		}
 		if(err && (nFixedBitsPerSample && (nFixedBitsPerSample != TrackerSettings::Instance().m_MixerSettings.m_SampleFormat)))
 		{
 			if(nFixedBitsPerSample) TrackerSettings::Instance().m_MixerSettings.m_SampleFormat = (SampleFormat)nFixedBitsPerSample;
@@ -892,19 +883,18 @@
 void CMainFrame::audioCloseDevice()
 //---------------------------------
 {
-	if (gpSoundDevice)
+	Util::lock_guard<Util::mutex> lock(m_SoundDeviceMutex);
+	if(gpSoundDevice)
 	{
-		CriticalSection cs;
-
 		gpSoundDevice->Reset();
 		gpSoundDevice->Close();
+	}
 
-		// reset notify buffer as timestamps revert here
-		{
-			Util::lock_guard<Util::mutex> lock(m_NotificationBufferMutex);
-			m_NotifyBuffer.clear();
-			m_TotalSamplesRendered = 0;
-		}
+	// reset notify buffer as timestamps revert here
+	{
+		Util::lock_guard<Util::mutex> lock(m_NotificationBufferMutex);
+		m_NotifyBuffer.clear();
+		m_TotalSamplesRendered = 0;
 	}
 }
 
@@ -942,15 +932,15 @@
 }
 
 
-BOOL CMainFrame::DoNotification(DWORD dwSamplesRead, DWORD SamplesLatency, bool endOfStream)
-//------------------------------------------------------------------------------------------
+BOOL CMainFrame::DoNotification(DWORD dwSamplesRead, DWORD SamplesLatency, bool endOfStream, bool hasSoundDeviceGetStreamPosition)
+//--------------------------------------------------------------------------------------------------------------------------------
 {
 	OPENMPT_PROFILE_FUNCTION(Profiler::Notify);
 	int64 notificationtimestamp = 0;
 	{
 		Util::lock_guard<Util::mutex> lock(m_NotificationBufferMutex); // protect m_TotalSamplesRendered
 		m_TotalSamplesRendered += dwSamplesRead;
-		if(gpSoundDevice->HasGetStreamPosition())
+		if(hasSoundDeviceGetStreamPosition)
 		{
 			notificationtimestamp = m_TotalSamplesRendered;
 		} else
@@ -1263,7 +1253,10 @@
 {
 	if(!m_pSndFile) return false; // nothing to play
 	if(!IsAudioDeviceOpen()) return false;
-	SetAudioThreadActive(true);
+	{
+		Util::lock_guard<Util::mutex> lock(m_SoundDeviceMutex);
+		gpSoundDevice->Start();
+	}
 	return true;
 }
 
@@ -1272,7 +1265,10 @@
 //-----------------------------
 {
 	if(!IsAudioDeviceOpen()) return;
-	SetAudioThreadActive(false);
+	{
+		Util::lock_guard<Util::mutex> lock(m_SoundDeviceMutex);
+		gpSoundDevice->Stop();
+	}
 	audioCloseDevice();
 }
 
@@ -1281,7 +1277,10 @@
 //------------------------------
 {
 	if(!IsAudioDeviceOpen()) return false;
-	SetAudioThreadActive(false);
+	{
+		Util::lock_guard<Util::mutex> lock(m_SoundDeviceMutex);
+		gpSoundDevice->Stop();
+	}
 	return true;
 }
 

Modified: trunk/OpenMPT/mptrack/Mainfrm.h
===================================================================
--- trunk/OpenMPT/mptrack/Mainfrm.h	2013-04-13 13:03:30 UTC (rev 1868)
+++ trunk/OpenMPT/mptrack/Mainfrm.h	2013-04-13 13:07:51 UTC (rev 1869)
@@ -270,13 +270,13 @@
 public:
 
 	// Low-Level Audio
+	mutable Util::mutex m_SoundDeviceMutex;
 	ISoundDevice *gpSoundDevice;
 	HANDLE m_hNotifyWakeUp;
 	HANDLE m_hNotifyThread;
 	DWORD m_dwNotifyThreadId;
 	static LONG gnLVuMeter, gnRVuMeter;
 	static bool gnClipLeft, gnClipRight;
-	bool m_IsPlaybackRunning;
 
 	// Midi Input
 public:
@@ -321,19 +321,18 @@
 	static void CalcStereoVuMeters(int *, unsigned long, unsigned long);
 	static DWORD WINAPI NotifyThreadWrapper(LPVOID);
 	DWORD NotifyThread();
-	void SetAudioThreadActive(bool active=true);
 
 	// from ISoundSource
-	void FillAudioBufferLocked(IFillAudioBuffer &callback);
-	ULONG AudioRead(PVOID pData, ULONG MaxSamples);
-	void AudioDone(ULONG SamplesWritten, ULONG SamplesLatency, bool endOfStream);
+	void FillAudioBufferLocked(const ISoundDevice &device, IFillAudioBuffer &callback);
+	ULONG AudioRead(const ISoundDevice &device, PVOID pData, ULONG MaxSamples);
+	void AudioDone(const ISoundDevice &device, ULONG SamplesWritten, ULONG SamplesLatency, bool endOfStream);
 	
 	bool audioTryOpeningDevice(UINT channels, UINT bits, UINT samplespersec);
 	bool audioOpenDevice();
 	bool audioReopenDevice();
 	void audioCloseDevice();
 	bool IsAudioDeviceOpen() const;
-	BOOL DoNotification(DWORD dwSamplesRead, DWORD SamplesLatency, bool endOfStream);
+	BOOL DoNotification(DWORD dwSamplesRead, DWORD SamplesLatency, bool endOfStream, bool hasSoundDeviceGetStreamPosition);
 
 // Midi Input Functions
 public:
@@ -411,7 +410,6 @@
 	bool StartPlayback();
 	void StopPlayback();
 	bool PausePlayback();
-	bool IsPlaybackRunning() const { return m_IsPlaybackRunning; }
 	static bool IsValidSoundFile(CSoundFile &sndFile) { return sndFile.GetType() ? true : false; }
 	static bool IsValidSoundFile(CSoundFile *pSndFile) { return pSndFile && pSndFile->GetType(); }
 	void SetPlaybackSoundFile(CSoundFile *pSndFile);

Modified: trunk/OpenMPT/mptrack/Mpdlgs.cpp
===================================================================
--- trunk/OpenMPT/mptrack/Mpdlgs.cpp	2013-04-13 13:03:30 UTC (rev 1868)
+++ trunk/OpenMPT/mptrack/Mpdlgs.cpp	2013-04-13 13:07:51 UTC (rev 1869)
@@ -359,8 +359,11 @@
 		samplerates.push_back(nMixingRates[i]);
 	}
 
+	bool knowRates = false;
+	{
+	Util::lock_guard<Util::mutex> lock(CMainFrame::GetMainFrame()->m_SoundDeviceMutex);
 	ISoundDevice *dummy = nullptr;
-	bool justCreated = false, knowRates = false;
+	bool justCreated = false;
 	if(TrackerSettings::Instance().m_nWaveDevice == dev)
 	{
 		// If this is the currently active sound device, it might already be playing something, so we shouldn't create yet another instance of it.
@@ -381,6 +384,7 @@
 			delete dummy;
 		}
 	}
+	}
 
 	if(!knowRates)
 	{
@@ -481,19 +485,22 @@
 {
 	if (!m_EditStatistics) return;
 	CMainFrame *pMainFrm = CMainFrame::GetMainFrame();
-	if (pMainFrm && pMainFrm->gpSoundDevice && pMainFrm->IsPlaying())
 	{
-		CHAR s[256];
-		_snprintf(s, 255, "Buffers: %d\r\nUpdate interval: %4.1f ms\r\nLatency: %4.1f ms\r\nCurrent Latency: %4.1f ms",
-			pMainFrm->gpSoundDevice->GetNumBuffers(),
-			(float)pMainFrm->gpSoundDevice->GetRealUpdateIntervalMS(),
-			(float)pMainFrm->gpSoundDevice->GetRealLatencyMS(),
-			(float)pMainFrm->gpSoundDevice->GetCurrentRealLatencyMS()
-			);
-		m_EditStatistics.SetWindowText(s);
-	}	else
-	{
-		m_EditStatistics.SetWindowText("");
+		Util::lock_guard<Util::mutex> lock(pMainFrm->m_SoundDeviceMutex);
+		if(pMainFrm->gpSoundDevice && pMainFrm->IsPlaying())
+		{
+			CHAR s[256];
+			_snprintf(s, 255, "Buffers: %d\r\nUpdate interval: %4.1f ms\r\nLatency: %4.1f ms\r\nCurrent Latency: %4.1f ms",
+				pMainFrm->gpSoundDevice->GetNumBuffers(),
+				(float)pMainFrm->gpSoundDevice->GetRealUpdateIntervalMS(),
+				(float)pMainFrm->gpSoundDevice->GetRealLatencyMS(),
+				(float)pMainFrm->gpSoundDevice->GetCurrentRealLatencyMS()
+				);
+			m_EditStatistics.SetWindowText(s);
+		}	else
+		{
+			m_EditStatistics.SetWindowText("");
+		}
 	}
 }
 

Modified: trunk/OpenMPT/sounddev/SoundDevice.cpp
===================================================================
--- trunk/OpenMPT/sounddev/SoundDevice.cpp	2013-04-13 13:03:30 UTC (rev 1868)
+++ trunk/OpenMPT/sounddev/SoundDevice.cpp	2013-04-13 13:07:51 UTC (rev 1869)
@@ -33,8 +33,11 @@
 
 	m_RealLatencyMS = static_cast<float>(m_LatencyMS);
 	m_RealUpdateIntervalMS = static_cast<float>(m_UpdateIntervalMS);
+
+	m_IsPlaying = false;
 }
 
+
 ISoundDevice::~ISoundDevice()
 //---------------------------
 {
@@ -57,6 +60,40 @@
 }
 
 
+
+void ISoundDevice::Start()
+//------------------------
+{
+	if(!IsOpen()) return; 
+	if(!IsPlaying())
+	{
+		InternalStart();
+		m_IsPlaying = true;
+	}
+}
+
+
+void ISoundDevice::Stop()
+//-----------------------
+{
+	if(!IsOpen()) return;
+	if(IsPlaying())
+	{
+		InternalStop();
+		m_IsPlaying = false;
+	}
+}
+
+
+void ISoundDevice::Reset()
+//------------------------
+{
+	if(!IsOpen()) return;
+	Stop();
+	InternalReset();
+}
+
+
 CAudioThread::CAudioThread(CSoundDeviceWithThread &SoundDevice) : m_SoundDevice(SoundDevice)
 //-----------------------------------------------------------------------------------
 {
@@ -174,7 +211,7 @@
 		// increase resolution of multimedia timer
 		bool period_set = (timeBeginPeriod(1) == TIMERR_NOERROR);
 
-		m_SoundDevice.Start();
+		m_SoundDevice.StartFromSoundThread();
 
 		while(!idle && !terminate) 
 		{
@@ -202,7 +239,7 @@
 
 		}
 
-		m_SoundDevice.Stop();
+		m_SoundDevice.StopFromSoundThread();
 
 		if(period_set) timeEndPeriod(1);
 
@@ -241,7 +278,11 @@
 void CAudioThread::Activate()
 //---------------------------
 {
-	if(InterlockedExchangeAdd(&m_AudioThreadActive, 0)) return;
+	if(InterlockedExchangeAdd(&m_AudioThreadActive, 0))
+	{
+		ALWAYS_ASSERT(false);
+		return;
+	}
 	ResetEvent(m_hAudioThreadGoneIdle);
 	InterlockedExchange(&m_AudioThreadActive, 1);
 	SetEvent(m_hAudioWakeUp);
@@ -251,38 +292,40 @@
 void CAudioThread::Deactivate()
 //-----------------------------
 {
-	if(!InterlockedExchangeAdd(&m_AudioThreadActive, 0)) return;
+	if(!InterlockedExchangeAdd(&m_AudioThreadActive, 0))
+	{
+		ALWAYS_ASSERT(false);
+		return;
+	}
 	InterlockedExchange(&m_AudioThreadActive, 0);
 	WaitForSingleObject(m_hAudioThreadGoneIdle, INFINITE);
-
 }
 
 
 void CSoundDeviceWithThread::FillAudioBufferLocked()
 //--------------------------------------------------
 {
-	m_Source->FillAudioBufferLocked(*this);
+	m_Source->FillAudioBufferLocked(*this, *this);
 }
 
 
-void CSoundDeviceWithThread::Start()
-//----------------------------------
+void CSoundDeviceWithThread::InternalStart()
+//------------------------------------------
 {
 	m_AudioThread.Activate();
 }
 
 
-void CSoundDeviceWithThread::Stop()
-//---------------------------------
+void CSoundDeviceWithThread::InternalStop()
+//-----------------------------------------
 {
 	m_AudioThread.Deactivate();
 }
 
 
-void CSoundDeviceWithThread::Reset()
-//----------------------------------
+void CSoundDeviceWithThread::InternalReset()
+//------------------------------------------
 {
-	m_AudioThread.Deactivate();
 	ResetFromOutsideSoundThread();
 }
 
@@ -309,10 +352,8 @@
 CWaveDevice::~CWaveDevice()
 //-------------------------
 {
-	if (m_hWaveOut)
-	{
-		Close();
-	}
+	Reset();
+	Close();
 }
 
 
@@ -371,8 +412,10 @@
 BOOL CWaveDevice::Close()
 //-----------------------
 {
+	Reset();
 	if (m_hWaveOut)
 	{
+		ResetFromOutsideSoundThread(); // always reset so that waveOutClose does not fail if we did only P->Stop() (meaning waveOutPause()) before
 		while (m_nPreparedHeaders > 0)
 		{
 			m_nPreparedHeaders--;
@@ -380,7 +423,8 @@
 			GlobalFreePtr(m_WaveBuffers[m_nPreparedHeaders]);
 			m_WaveBuffers[m_nPreparedHeaders] = NULL;
 		}
-		waveOutClose(m_hWaveOut);
+		MMRESULT err = waveOutClose(m_hWaveOut);
+		ALWAYS_ASSERT(err == MMSYSERR_NOERROR);
 		m_hWaveOut = NULL;
 		Sleep(1); // Linux WINE-friendly
 	}
@@ -389,7 +433,7 @@
 
 
 void CWaveDevice::StartFromSoundThread()
-//-----------------------
+//--------------------------------------
 {
 	if(m_hWaveOut)
 	{
@@ -399,7 +443,7 @@
 
 
 void CWaveDevice::StopFromSoundThread()
-//----------------------
+//-------------------------------------
 {
 	if(m_hWaveOut)
 	{
@@ -409,7 +453,7 @@
 
 
 void CWaveDevice::ResetFromOutsideSoundThread()
-//-----------------------
+//---------------------------------------------
 {
 	if(m_hWaveOut)
 	{
@@ -441,7 +485,7 @@
 
 	while((ULONG)oldBuffersPending < m_nPreparedHeaders)
 	{
-		ULONG len = m_BytesPerSample * pSource->AudioRead(m_WaveBuffers[m_nWriteBuffer]->lpData, m_nWaveBufferSize/m_BytesPerSample);
+		ULONG len = m_BytesPerSample * pSource->AudioRead(*this, m_WaveBuffers[m_nWriteBuffer]->lpData, m_nWaveBufferSize/m_BytesPerSample);
 		if(len < m_nWaveBufferSize)
 		{
 			eos = true;
@@ -454,7 +498,7 @@
 		waveOutWrite(m_hWaveOut, m_WaveBuffers[m_nWriteBuffer], sizeof(WAVEHDR));
 		m_nWriteBuffer++;
 		m_nWriteBuffer %= m_nPreparedHeaders;
-		pSource->AudioDone(m_nWaveBufferSize/m_BytesPerSample, nLatency/m_BytesPerSample, eos);
+		pSource->AudioDone(*this, m_nWaveBufferSize/m_BytesPerSample, nLatency/m_BytesPerSample, eos);
 	}
 
 	if(wasempty) waveOutRestart(m_hWaveOut);
@@ -463,7 +507,7 @@
 
 
 int64 CWaveDevice::GetStreamPositionSamples() const
-//------------------------------------------------------
+//-------------------------------------------------
 {
 	if(!IsOpen()) return 0;
 	MMTIME mmtime;
@@ -481,7 +525,7 @@
 
 
 VOID CWaveDevice::WaveOutCallBack(HWAVEOUT, UINT uMsg, DWORD_PTR dwUser, DWORD_PTR, DWORD_PTR)
-//--------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------------------
 {
 	if ((uMsg == MM_WOM_DONE) && (dwUser))
 	{
@@ -588,10 +632,8 @@
 CDSoundDevice::~CDSoundDevice()
 //-----------------------------
 {
-	if (m_piDS)
-	{
-		Close();
-	}
+	Reset();
+	Close();
 }
 
 
@@ -714,7 +756,7 @@
 
 
 void CDSoundDevice::StartFromSoundThread()
-//-------------------------
+//----------------------------------------
 {
 	if(!m_pMixBuffer) return;
 	// done in FillAudioBuffer for now
@@ -722,21 +764,23 @@
 
 
 void CDSoundDevice::StopFromSoundThread()
-//------------------------
+//---------------------------------------
 {
-	if(!m_pMixBuffer) return;
-	if(m_bMixRunning)
+	if(m_pMixBuffer)
 	{
-		m_bMixRunning = FALSE;
 		m_pMixBuffer->Stop();
 	}
+	m_bMixRunning = FALSE;
 }
 
 
 void CDSoundDevice::ResetFromOutsideSoundThread()
-//-------------------------
+//-----------------------------------------------
 {
-	if (m_pMixBuffer) m_pMixBuffer->Stop();
+	if(m_pMixBuffer)
+	{
+		m_pMixBuffer->Stop();
+	}
 	m_bMixRunning = FALSE;
 }
 
@@ -815,8 +859,8 @@
 	{
 		DWORD nRead1=0, nRead2=0;
 
-		if ((lpBuf1) && (dwSize1)) nRead1 = m_BytesPerSample * pSource->AudioRead(lpBuf1, dwSize1/m_BytesPerSample);
-		if ((lpBuf2) && (dwSize2)) nRead2 = m_BytesPerSample * pSource->AudioRead(lpBuf2, dwSize2/m_BytesPerSample);
+		if ((lpBuf1) && (dwSize1)) nRead1 = m_BytesPerSample * pSource->AudioRead(*this, lpBuf1, dwSize1/m_BytesPerSample);
+		if ((lpBuf2) && (dwSize2)) nRead2 = m_BytesPerSample * pSource->AudioRead(*this, lpBuf2, dwSize2/m_BytesPerSample);
 		UnlockBuffer(lpBuf1, dwSize1, lpBuf2, dwSize2);
 		if(nRead1+nRead2 < dwSize1+dwSize2)
 		{
@@ -847,7 +891,7 @@
 			}
 			m_bMixRunning = TRUE; 
 		}
-		pSource->AudioDone((dwSize1+dwSize2)/m_BytesPerSample, m_dwLatency/m_BytesPerSample, eos);
+		pSource->AudioDone(*this, (dwSize1+dwSize2)/m_BytesPerSample, m_dwLatency/m_BytesPerSample, eos);
 	}
 }
 
@@ -968,11 +1012,8 @@
 CASIODevice::~CASIODevice()
 //-------------------------
 {
-	if (gpCurrentAsio == this)
-	{
-		gpCurrentAsio = NULL;
-	}
-	CloseDevice();
+	Reset();
+	Close();
 }
 
 
@@ -1127,11 +1168,9 @@
 }
 
 
-void CASIODevice::Start()
-//-----------------------
+void CASIODevice::InternalStart()
+//-------------------------------
 {
-	if (IsOpen())
-	{
 		ALWAYS_ASSERT(g_asio_startcount==0);
 		g_asio_startcount++;
 
@@ -1147,19 +1186,15 @@
 				CASIODevice::ReportASIOException("ASIO crash in start()\n");
 			}
 		}
-	}
 }
 
 
-void CASIODevice::Stop()
-//-----------------------
+void CASIODevice::InternalStop()
+//------------------------------
 {
-	if (IsOpen())
-	{
 		InterlockedExchange(&m_RenderSilence, 1);
 		g_asio_startcount--;
 		ALWAYS_ASSERT(g_asio_startcount==0);
-	}
 }
 
 
@@ -1196,11 +1231,9 @@
 }
 
 
-void CASIODevice::Reset()
-//-----------------------
+void CASIODevice::InternalReset()
+//-------------------------------
 {
-	if (IsOpen())
-	{
 		if(m_bMixRunning)
 		{
 			m_bMixRunning = FALSE;
@@ -1214,7 +1247,6 @@
 			g_asio_startcount = 0;
 			InterlockedExchange(&m_RenderSilence, 0);
 		}
-	}
 }
 
 
@@ -1278,7 +1310,7 @@
 			memset(m_FrameBuffer, 0, n*dwSampleSize);
 		} else
 		{
-			UINT readn = pSource->AudioRead(m_FrameBuffer, n);
+			UINT readn = pSource->AudioRead(*this, m_FrameBuffer, n);
 			if(readn < n)
 			{
 				eos = true;
@@ -1360,7 +1392,7 @@
 	if (m_bPostOutput) m_pAsioDrv->outputReady();
 	if(!rendersilence)
 	{
-		pSource->AudioDone(dwBufferOffset, m_nAsioBufferLen, eos);
+		pSource->AudioDone(*this, dwBufferOffset, m_nAsioBufferLen, eos);
 	}
 	return;
 }
@@ -1371,7 +1403,7 @@
 {
 	UNREFERENCED_PARAMETER(directProcess);
 	g_dwBuffer = doubleBufferIndex;
-	if (gpCurrentAsio && gpCurrentAsio->m_Source) gpCurrentAsio->m_Source->FillAudioBufferLocked(*gpCurrentAsio);
+	if (gpCurrentAsio && gpCurrentAsio->m_Source) gpCurrentAsio->m_Source->FillAudioBufferLocked(*gpCurrentAsio, *gpCurrentAsio);
 }
 
 
@@ -1759,10 +1791,8 @@
 CPortaudioDevice::~CPortaudioDevice()
 //-----------------------------------
 {
-	if(IsOpen())
-	{
-		Close();
-	}
+	Reset();
+	Close();
 }
 
 
@@ -1826,26 +1856,23 @@
 }
 
 
-void CPortaudioDevice::Reset()
-//----------------------------
+void CPortaudioDevice::InternalReset()
+//------------------------------------
 {
-	if(!IsOpen()) return;
 	Pa_AbortStream(m_Stream);
 }
 
 
-void CPortaudioDevice::Start()
-//----------------------------
+void CPortaudioDevice::InternalStart()
+//------------------------------------
 {
-	if(!IsOpen()) return;
 	Pa_StartStream(m_Stream);
 }
 
 
-void CPortaudioDevice::Stop()
-//---------------------------
+void CPortaudioDevice::InternalStop()
+//-----------------------------------
 {
-	if(!IsOpen()) return;
 	Pa_StopStream(m_Stream);
 }
 
@@ -1856,12 +1883,12 @@
 	ISoundSource *pSource = m_Source;
 	if(m_CurrentFrameCount == 0) return;
 	bool eos = false;
-	ULONG read = pSource->AudioRead(m_CurrentFrameBuffer, m_CurrentFrameCount);
+	ULONG read = pSource->AudioRead(*this, m_CurrentFrameBuffer, m_CurrentFrameCount);
 	if(read < m_CurrentFrameCount)
 	{
 		eos = true;
 	}
-	pSource->AudioDone(m_CurrentFrameCount, static_cast<ULONG>(m_CurrentRealLatencyMS * Pa_GetStreamInfo(m_Stream)->sampleRate / 1000.0f), eos);
+	pSource->AudioDone(*this, m_CurrentFrameCount, static_cast<ULONG>(m_CurrentRealLatencyMS * Pa_GetStreamInfo(m_Stream)->sampleRate / 1000.0f), eos);
 }
 
 
@@ -1929,7 +1956,7 @@
 	m_CurrentRealLatencyMS = static_cast<float>( timeInfo->outputBufferDacTime - timeInfo->currentTime ) * 1000.0f;
 	m_CurrentFrameBuffer = output;
 	m_CurrentFrameCount = frameCount;
-	m_Source->FillAudioBufferLocked(*this);
+	m_Source->FillAudioBufferLocked(*this, *this);
 	m_CurrentFrameCount = 0;
 	m_CurrentFrameBuffer = 0;
 	return paContinue;

Modified: trunk/OpenMPT/sounddev/SoundDevice.h
===================================================================
--- trunk/OpenMPT/sounddev/SoundDevice.h	2013-04-13 13:03:30 UTC (rev 1868)
+++ trunk/OpenMPT/sounddev/SoundDevice.h	2013-04-13 13:07:51 UTC (rev 1869)
@@ -13,6 +13,12 @@
 
 #include <vector>
 
+
+class ISoundDevice;
+class IFillAudioBuffer;
+class ISoundSource;
+
+
 ////////////////////////////////////////////////////////////////////////////////////
 //
 // ISoundSource: provides streaming audio data to a device
@@ -33,10 +39,10 @@
 //================
 {
 public:
-	virtual void FillAudioBufferLocked(IFillAudioBuffer &callback) = 0; // take any locks needed while rendering audio and then call FillAudioBuffer
-	virtual ULONG AudioRead(PVOID pData, ULONG MaxSamples) = 0; // returns number of valid samples read, the remaining space has to be filled with zeroes by the callee,
+	virtual void FillAudioBufferLocked(const ISoundDevice &device, IFillAudioBuffer &callback) = 0; // take any locks needed while rendering audio and then call FillAudioBuffer
+	virtual ULONG AudioRead(const ISoundDevice &device, PVOID pData, ULONG MaxSamples) = 0; // returns number of valid samples read, the remaining space has to be filled with zeroes by the callee,
 	                                                            // if return value != MaxSamples then end_of_stream = true
-	virtual void AudioDone(ULONG SamplesWritten, ULONG SamplesLatency, bool end_of_stream) = 0; // all in samples
+	virtual void AudioDone(const ISoundDevice &device, ULONG SamplesWritten, ULONG SamplesLatency, bool end_of_stream) = 0; // all in samples
 };
 
 
@@ -94,6 +100,8 @@
 	float m_RealLatencyMS;
 	float m_RealUpdateIntervalMS;
 
+	bool m_IsPlaying;
+
 protected:
 	virtual void FillAudioBuffer() = 0;
 
@@ -107,14 +115,20 @@
 	VOID Configure(HWND hwnd, UINT LatencyMS, UINT UpdateIntervalMS, DWORD fdwCfgOptions);
 	float GetRealLatencyMS() const  { return m_RealLatencyMS; }
 	float GetRealUpdateIntervalMS() const { return m_RealUpdateIntervalMS; }
+	bool IsPlaying() const { return m_IsPlaying; }
 
+protected:
+	virtual void InternalStart() = 0;
+	virtual void InternalStop() = 0;
+	virtual void InternalReset() = 0;
+
 public:
 	virtual UINT GetDeviceType() = 0;
 	virtual BOOL Open(UINT nDevice, LPWAVEFORMATEX pwfx) = 0;	// Open a device
 	virtual BOOL Close() = 0;				// Close the currently open device
-	virtual void Start() = 0;
-	virtual void Stop() = 0;
-	virtual void Reset() = 0;
+	void Start();
+	void Stop();
+	void Reset();
 	virtual UINT HasFixedBitsPerSample() { return 0; }
 	virtual bool IsOpen() const = 0;
 	virtual UINT GetNumBuffers() { return 0; }

Modified: trunk/OpenMPT/sounddev/SoundDevices.h
===================================================================
--- trunk/OpenMPT/sounddev/SoundDevices.h	2013-04-13 13:03:30 UTC (rev 1868)
+++ trunk/OpenMPT/sounddev/SoundDevices.h	2013-04-13 13:07:51 UTC (rev 1869)
@@ -62,9 +62,9 @@
 public:
 	CSoundDeviceWithThread() : m_AudioThread(*this) {}
 	virtual ~CSoundDeviceWithThread() {}
-	void Start();
-	void Stop();
-	void Reset();
+	void InternalStart();
+	void InternalStop();
+	void InternalReset();
 	virtual void StartFromSoundThread() = 0;
 	virtual void StopFromSoundThread() = 0;
 	virtual void ResetFromOutsideSoundThread() = 0;
@@ -205,9 +205,9 @@
 	BOOL Open(UINT nDevice, LPWAVEFORMATEX pwfx);
 	BOOL Close();
 	void FillAudioBuffer();
-	void Reset();
-	void Start();
-	void Stop();
+	void InternalReset();
+	void InternalStart();
+	void InternalStop();
 	bool IsOpen() const { return (m_pAsioDrv != NULL); }
 	UINT HasFixedBitsPerSample() { return m_nBitsPerSample; }
 	UINT GetNumBuffers() { return 2; }
@@ -280,9 +280,9 @@
 	BOOL Open(UINT nDevice, LPWAVEFORMATEX pwfx);
 	BOOL Close();
 	void FillAudioBuffer();
-	void Reset();
-	void Start();
-	void Stop();
+	void InternalReset();
+	void InternalStart();
+	void InternalStop();
 	bool IsOpen() const { return m_Stream ? true : false; }
 	UINT GetNumBuffers() { return 1; }
 	float GetCurrentRealLatencyMS();

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.





Thread: [OMPT-svn-commit] SF.net SVN: modplug:[1869] trunk/OpenMPT (Page 30)

A music tracker software for Windows.

modplug-svn-commit