sbuffer.cpp

好游戏的客户端原码

*/				
					// Play吝捞搁 家府甫 促澜 家府绰 Play 窍瘤 富巴
					m_Current = m_Current==0 ? m_nBuffers-1 : m_Current-1;
					Buffer = NULL;
					nBufferIdx = MAX_DUPLE_COUNT;
				}
			}
			else 
			{
				Buffer=NULL;
				nBufferIdx = MAX_DUPLE_COUNT;
			}
		}
		
		if(Buffer && (Status & DSBSTATUS_BUFFERLOST))
			if(FAILED(Buffer->Restore()))
			{
				Buffer = NULL;
				nBufferIdx = MAX_DUPLE_COUNT;
			}
	}

	return Buffer;
}

HRESULT CSBuffer::EnableStreaming( int size, int blocks )
{
	if( m_3d ) return DSERR_ACCESSDENIED;
	m_Streamed=TRUE;
	m_sSize=size;
	m_sBlocks=blocks;
	return DS_OK;
}

HRESULT CSBuffer::Enable3d( void )
{
	if( m_Streamed ) return DSERR_ACCESSDENIED;
	m_3d=TRUE;
	return DS_OK;
}

HRESULT CSBuffer::LoadFromRes( CSound* pDS, const char *Filename, int Num )
{
	if( Filename == NULL ) return DSERR_INVALIDPARAM;
	
	HRSRC hResInfo;
	HGLOBAL hResData;

	void *pvRes;
	
	if((( hResInfo = FindResource(NULL, Filename, "WAV")) == NULL ) ) return DSERR_GENERIC;
	if(( hResData = LoadResource(NULL, hResInfo)) == NULL) return DSERR_GENERIC;
	if(( pvRes = LockResource(hResData)) == NULL) return DSERR_GENERIC;
	
	return CSBuffer::Extract( pDS, 0, (char*)pvRes, Num);
}

HRESULT CSBuffer::PlayExtended( DWORD dwFlags, int Pan, int Volume, DWORD freq )
{
	HRESULT rval;
	LPDIRECTSOUNDBUFFER Buffer = NULL;

	if( m_pDS==NULL ) return DSERR_UNINITIALIZED;
	if( m_pDS->GetSoundOn( ) ) return DS_OK;
	
	Buffer=GetFreeBuffer();
	if(Buffer==NULL) return DSERR_ALLOCATED;
	
	rval=Buffer->SetPan(Pan);
	if(FAILED(rval)) return rval;
	
	rval=Buffer->SetVolume(Volume);
	if(FAILED(rval)) return rval;
	
	rval=Buffer->SetFrequency(freq);
	if(FAILED(rval)) return rval;
	
	if(m_Streamed)
	{
		m_sLoop=dwFlags;
		dwFlags=DSBPLAY_LOOPING;
	}
	m_dwLastUseTime = timeGetTime();	
	rval=Buffer->Play(0, 0, dwFlags);
	if(FAILED(rval)) return rval;

	return DS_OK;
}


HRESULT CSBuffer::PlayExtended( float x, float y, float z, DWORD dwFlags )
{
	HRESULT rval;
	LPDIRECTSOUNDBUFFER Buffer = NULL;
	
	if(m_pDS==NULL) return DSERR_UNINITIALIZED;
	if(m_pDS->GetSoundOn()) return DS_OK;
	if(m_lp3dBuffer==NULL) return DSERR_UNINITIALIZED;
	
	Buffer=GetFreeBuffer();
	if(Buffer==NULL) return DSERR_ALLOCATED;
	if(m_lp3dBuffer[m_Current]==NULL) return DSERR_UNINITIALIZED;
	
	rval=m_lp3dBuffer[m_Current]->SetPosition( x, y, z, DS3D_IMMEDIATE );
	if(FAILED(rval)) return rval;

	m_dwLastUseTime = timeGetTime();
	rval = Buffer->Play(0, 0, dwFlags);
	if(FAILED(rval)) return rval;

	return DS_OK;
}

HRESULT CSBuffer::Stop(VOID)
{
	HRESULT rval;
	
	if( m_pDS==NULL || m_lpDSB==NULL ) return DSERR_UNINITIALIZED;
	
	for(int i=0; i<m_nBuffers; i++)
	{
		if( m_lpDSB[i] )
		{
			rval=m_lpDSB[i]->Stop();
			if( rval!=DS_OK ) return rval;
	
			rval=m_lpDSB[i]->SetCurrentPosition(0);
			if( rval!=DS_OK ) return rval;
		}
	}
	return DS_OK;
}

HRESULT CSBuffer::Stop(INT nBufferIdx)
{
	HRESULT rval;
	
	if( m_pDS==NULL || m_lpDSB==NULL ) return DSERR_UNINITIALIZED;
	
	if( m_lpDSB[nBufferIdx] )
	{
		rval=m_lpDSB[nBufferIdx]->Stop();
		if( rval!=DS_OK ) return rval;
		
		rval=m_lpDSB[nBufferIdx]->SetCurrentPosition(0);
		if( rval!=DS_OK ) return rval;
	}
	return DS_OK;
}

void CSBuffer::SetVolume(LONG Volume)
{
	if(m_lpDSB!=NULL)
	{
		for(int i=0; i<m_nBuffers; i++)
			if( m_lpDSB[i] )
				m_lpDSB[i]->SetVolume(Volume);
	}
}

void CSBuffer::SetVolume(INT nBufferIdx,LONG Volume)
{
	if(m_lpDSB!=NULL)
	{
		if( m_lpDSB[nBufferIdx] )
			m_lpDSB[nBufferIdx]->SetVolume(Volume);
	}
}


void CSBuffer::SetPan(LONG Pan)
{	
	if(m_lpDSB!=NULL)
	{
		for(int i=0; i<m_nBuffers; i++)
			if(m_lpDSB[i])
				m_lpDSB[i]->SetPan(Pan);
	}
}

void CSBuffer::SetPan(INT nBufferIdx,LONG Pan)
{	
	if(m_lpDSB!=NULL)
	{
		if(m_lpDSB[nBufferIdx])
			m_lpDSB[nBufferIdx]->SetPan(Pan);
	}
}

// Play 登绊 乐绰 百荐甫 备茄促.
DWORD CSBuffer::Playing(VOID)
{
	DWORD ctr=0, Status;
	if(m_lpDSB)
		for( int i=0; i<m_nBuffers; i++ )
			if(m_lpDSB[i])
				if( SUCCEEDED( m_lpDSB[i]->GetStatus(&Status) ) )
					if( Status & DSBSTATUS_PLAYING )
						ctr++;
					
	return ctr;
}

HRESULT CSBuffer::SetCone( float x, float y, float z, DWORD InsideAngle, DWORD OutsideAngle, long OutsideVolume )
{
	HRESULT rval;
	if(m_pDS==NULL) return DSERR_UNINITIALIZED;
	if(m_lp3dBuffer==NULL) return DSERR_UNINITIALIZED;
	if(m_pDS->Get3dListener()==NULL) return DSERR_UNINITIALIZED;
	
	for( int i=0; i<m_nBuffers; i++ )
	{
		if(m_lp3dBuffer[i])
		{
			rval=m_lp3dBuffer[i]->SetConeOrientation( x, y, z, DS3D_DEFERRED );
			if(FAILED(rval)) return rval;
			
			rval=m_lp3dBuffer[i]->SetConeAngles( InsideAngle, OutsideAngle, DS3D_DEFERRED );
			if(FAILED(rval)) return rval;
			
			rval=m_lp3dBuffer[i]->SetConeOutsideVolume( OutsideVolume, DS3D_DEFERRED );
			if(FAILED(rval)) return rval;
		}
	}
	
	rval=m_pDS->Get3dListener()->CommitDeferredSettings();
	return rval;
}


HRESULT CSBuffer::Set3dProperties( DWORD Mode, float MinDistance, float MaxDistance, float VelX, float VelY, float VelZ )
{
	HRESULT rval;
	if(m_pDS==NULL) return DSERR_UNINITIALIZED;
	if(m_lp3dBuffer==NULL) return DSERR_UNINITIALIZED;
	if(m_pDS->Get3dListener()==NULL) return DSERR_UNINITIALIZED;
	
	for( int i=0; i<m_nBuffers; i++ )
	{
		if(m_lp3dBuffer[i])
		{
			rval=m_lp3dBuffer[i]->SetMode( Mode, DS3D_DEFERRED );
			if(FAILED(rval)) return rval;
			
			rval=m_lp3dBuffer[i]->SetMinDistance( MinDistance, DS3D_DEFERRED );
			if(FAILED(rval)) return rval;
			
			rval=m_lp3dBuffer[i]->SetMaxDistance( MaxDistance, DS3D_DEFERRED );
			if(FAILED(rval)) return rval;
			
			rval=m_lp3dBuffer[i]->SetVelocity( VelX, VelY, VelZ, DS3D_DEFERRED );
			if(FAILED(rval)) return rval;
		}
	}	
	rval=m_pDS->Get3dListener()->CommitDeferredSettings();
	return rval;
}


HRESULT CSBuffer::FillStreamBuffer(int nr)
{
	LPVOID pData;
	DWORD  dwDataSize;
	HRESULT rval;
	DWORD numread;

	if(!m_Streamed) return DSERR_UNINITIALIZED;
	if(m_lpDSB==NULL) return DSERR_UNINITIALIZED;
	if(m_sFile==NULL) return DSERR_UNINITIALIZED;

	rval = m_lpDSB[0]->Lock(nr*m_sSize, m_sSize, &pData, &dwDataSize, 0, 0, 0);
	if(FAILED(rval)) return rval;


	numread=fread( pData, 1, dwDataSize, m_sFile );

	if( numread<dwDataSize )
	{
		if(m_sLoop)
		{
			fseek( m_sFile, -(long)m_sWaveLength, SEEK_CUR );
			fread( (char*)pData+numread, 1, dwDataSize-numread, m_sFile );
		}
		else
		{
			BYTE fill=128;
			if( numread>0 )	fill=*((BYTE*)pData+numread-1);
			FillMemory( (BYTE*)pData+numread, dwDataSize-numread, fill );

			if( m_sDone==255 )
			{
				m_sDone=nr;
				m_sStop=FALSE;
			}
		}
	}
	m_lpDSB[0]->Unlock(pData,dwDataSize,0,0);
	return DS_OK;
}

HRESULT CSBuffer::UpdateStream( BOOL FillAll )
{
	HRESULT rval;
	if(!m_Streamed) return DSERR_UNINITIALIZED;
	if(m_lpDSB==NULL) return DSERR_UNINITIALIZED;
	
	DWORD pos;
	rval=m_lpDSB[0]->GetCurrentPosition( NULL, &pos );
	if(FAILED(rval)) return rval;
	pos/=m_sSize;

	if( m_sDone<255 )
	{
		if( m_sDone!=pos )
		{
			if( m_sStop )
			{
				Stop();
				return 1;
			}
		}
		else m_sStop=TRUE;
	}

	do
	{
		if(pos!=m_sCurrent)
		{
			rval=FillStreamBuffer(m_sCurrent);
			if(FAILED(rval)) return rval;

			char str[255];
			sprintf( str, "PlayPos:%i\tFillPos:%i\tEndPos:%i\n", pos, m_sCurrent, m_sDone );
			OutputDebugString( str );

			m_sCurrent++;
			if( m_sCurrent>=m_sBlocks ) m_sCurrent=0;
		}
	}
	while( FillAll && pos!=m_sCurrent );
	
	return DS_OK;
}

DWORD CSBuffer::GetLastUsedTime(VOID)
{
	return 	m_dwLastUseTime;
}

VOID CSBuffer::Pause(INT nBufferIdx)
{
	if(m_lpDSB[nBufferIdx])
		m_lpDSB[nBufferIdx]->Stop();
}

VOID CSBuffer::Continue(INT nBufferIdx)
{
	if(m_lpDSB[nBufferIdx])
		m_lpDSB[nBufferIdx]->Play(0, 0, 0);
}