sound.cpp

c++程序

// Sound.cpp: Implementierung der Klasse CSound.
//
//////////////////////////////////////////////////////////////////////

#include "stdafx.h"
#include "Sound.h"

//////////////////////////////////////////////////////////////////////
// Konstruktion/Destruktion
//////////////////////////////////////////////////////////////////////

CSound::CSound()
{
	///////////////////////////////////////////////////////////////////////////////
	// Setup Direct Sound. Gets a pointer to the direct sound interface, and sets
	// up the two sound buffers
	///////////////////////////////////////////////////////////////////////////////
}

CSound::~CSound()
{
	///////////////////////////////////////////////////////////////////////////////
	// Shutdown Direct Sound. Releases the two sound buffers and the Direct Sound
	// interface
	///////////////////////////////////////////////////////////////////////////////

/*	if(pGrunt)
		{
		pGrunt->Release();
		pGrunt = NULL;
		}
		
	if(pDirectSoundAPI)
		{
		pDirectSoundAPI->Release();
		pDirectSoundAPI = NULL;
		}*/
}



/*
///////////////////////////////////////////////////////////////////////////////
// Creates a Direct Sound buffer from a wave file.
// This code adapted from the book "Win32 Game developers guide with DirectX 3"
///////////////////////////////////////////////////////////////////////////////
BOOL bSetupBufferFromWave(LPDIRECTSOUNDBUFFER& pDSBuffer, char *szWaveFile)
	{
	HMMIO	hmfr;
	MMCKINFO parent,child;
	WAVEFORMATEX wfmtx;

	// Open the wave file with the Multimedia I/O routines
	hmfr = mmioOpen(szWaveFile,NULL, MMIO_READ | MMIO_ALLOCBUF);
	if(hmfr == NULL)
		{
		MessageBox(NULL,"Could not Open Wave File",NULL,MB_OK);
		return FALSE;
		}

	parent.ckid = (FOURCC)0;
	parent.cksize = 0;
	parent.fccType = (FOURCC)0;
	parent.dwDataOffset = 0;
	parent.dwFlags = 0;
	child = parent;

	parent.fccType = mmioFOURCC('W','A','V','E');
	if(mmioDescend(hmfr,&parent,NULL,MMIO_FINDRIFF))
		{
		mmioClose(hmfr,0);
		MessageBox(NULL,"Could not Descend into Wave File",NULL,MB_OK);
		return FALSE;
		}

	child.ckid = mmioFOURCC('f','m','t',' ');
	if(mmioDescend(hmfr,&child,&parent,0))
		{
		mmioClose(hmfr,0);
		MessageBox(NULL,"Could not Descend into format of Wave File",NULL,MB_OK);
		return FALSE;
		}

	// Read the wave format
	if(mmioRead(hmfr, (char *)&wfmtx, sizeof(wfmtx)) != sizeof(wfmtx))
		{
		mmioClose(hmfr,0);
		MessageBox(NULL,"Error reading Wave Format",NULL,MB_OK);
		return FALSE;
		}

	// Double check to make sure this is a wave file
	if(wfmtx.wFormatTag != WAVE_FORMAT_PCM)
		{
		mmioClose(hmfr,0);
		MessageBox(NULL,"Not a valid Wave Format",NULL,MB_OK);
		return FALSE;
		}
		
	if(mmioAscend(hmfr, &child, 0))
		{
		mmioClose(hmfr,0);
		MessageBox(NULL,"Unable to Ascend",NULL,MB_OK);
		return FALSE;
		}
		
	// Read the chunk right into the structure
	child.ckid = mmioFOURCC('d','a','t','a');
	if(mmioDescend(hmfr,&child, &parent, MMIO_FINDCHUNK))
		{
		mmioClose(hmfr,0);
		MessageBox(NULL,"Wave file has no data",NULL,MB_OK);
		return FALSE;
		}

	// Allocate space and read in the data
	BYTE *pBuffer= new BYTE[child.cksize];
	if((DWORD)mmioRead(hmfr, (char *)pBuffer, child.cksize) != child.cksize)
		{
		mmioClose(hmfr,0);
		MessageBox(NULL,"Could not read Wave Data",NULL,MB_OK);
		return FALSE;
		}

	// Close the wave file
	mmioClose(hmfr,0);


	// Create Direct Sound Buffer
	DSBUFFERDESC dsbdesc;
	PCMWAVEFORMAT pcmwf;
	
	memset(&pcmwf, 0, sizeof(PCMWAVEFORMAT));
	pcmwf.wf.wFormatTag = WAVE_FORMAT_PCM;
	pcmwf.wf.nChannels	= wfmtx.nChannels;
	pcmwf.wf.nSamplesPerSec	= wfmtx.nSamplesPerSec;
	pcmwf.wf.nBlockAlign = wfmtx.nBlockAlign;
	pcmwf.wf.nAvgBytesPerSec = wfmtx.nAvgBytesPerSec;
	pcmwf.wBitsPerSample = wfmtx.wBitsPerSample;
	

	memset(&dsbdesc, 0, sizeof(DSBUFFERDESC));
	dsbdesc.dwSize = sizeof(DSBUFFERDESC);
	dsbdesc.dwFlags = DSBCAPS_CTRLDEFAULT;
	dsbdesc.dwBufferBytes = child.cksize;			
	dsbdesc.lpwfxFormat = (LPWAVEFORMATEX)&pcmwf;

	if(pDirectSoundAPI->CreateSoundBuffer(&dsbdesc, &pDSBuffer, NULL) != DS_OK)
		{
		MessageBox(NULL,"Could not Create Sound Buffer.",NULL,MB_OK);
		delete [] pBuffer;
		}


	// Fill buffer with the wave file data
	LPVOID written1, written2;
	DWORD length1,length2;
	if(pDSBuffer->Lock(0, child.cksize, &written1, &length1, &written2, &length2, 0) == DSERR_BUFFERLOST)
		{
		pDSBuffer->Restore();
		pDSBuffer->Lock(0, child.cksize, &written1, &length1, &written2, &length2, 0);
		}

	CopyMemory(written1, pBuffer, length1);

	if(written2 != NULL)
		CopyMemory(written2, pBuffer+length1, length2);

	pDSBuffer->Unlock(written1, length1, written2, length2);

	// Free the temporary buffer
	delete [] pBuffer;

	return TRUE;
	}




BOOL bInitializeDirectSound(HWND hWnd)
	{
	// If Direct sound fails, just return - no sound effects will be heard
	if(DirectSoundCreate(NULL,&pDirectSoundAPI,NULL) != DS_OK)
		return FALSE;

	pDirectSoundAPI->SetCooperativeLevel(hWnd, DSSCL_NORMAL);

	// Create buffer for grunt sound
	if(!bSetupBufferFromWave(pGrunt,szGruntFile))
		{
		MessageBox(NULL,"Grunt failed",NULL,MB_OK);
		return FALSE;
		}

	return TRUE;
	}








///////////////////////////////////////////////////////////////////////////////
// Play the Grunt sound. Pretty simple...
///////////////////////////////////////////////////////////////////////////////
void DSGrunt(void)
	{
	if(pGrunt)
		pGrunt->Play(0,0,0);
	}
*/