void CovarMtx::init(int nn){
Matrix::init(nn);
int n2=nn*nn;
getMem(cov, n2,"covar1"); zeroMem(cov, n2);
getMem(meani,n2,"covar2"); zeroMem(meani,n2);
getMem(meanj,n2,"covar2"); zeroMem(meanj,n2);
getMem(count,n2,"covar3"); zeroMem(count,n2);
}
void calcCovar(){
int nIter=100;
cMtx.init(nfiles);
for(int i=0; i<nfiles; i++){
for(int j=i; j<nfiles; j++){
verb("Covariations %i~%i: <%s>~<%s> ",i,j,tracks[i]->name,tracks[j]->name);
cMtx.calc(i,j);
}
}
char b[2048];
sprintf(b,"%s.cvr",confFile);
FILE *f=xopen(b,"wt");
cMtx.print(f);
Matrix *x = new Matrix(&cMtx);
getMem(eValues,nfiles+10,"eigenVal"); zeroMem(eValues,nfiles);
eVectors=eigenVectors(x,eValues,nIter,1.E-3);
fputs("eigenVectors\n",f);
eVectors->printMtx(f);
fputs("eigenValues\n",f);
for(int i=0; i<nfiles; i++)
fprintf(f,"%.5f; ",eValues[i]);
fprintf(f,"\n");
fclose(f);
del(x);
}
AlClipboard::~AlClipboard()
{
//destroy
logger->debug("AlClipboard::~AlClipboard():-- START\n");
//init
zeroMem();
}
int CSound::SetPrimaryBufferWaveFormat(WORD Channels, DWORD SamplesPerSec, WORD BitsPerSample)
{
if(CS_E_OK!=GetPrimaryBuffer(&m_pPrimaryBuffer, DSBCAPS_CTRLVOLUME | DSBCAPS_CTRLPAN | DSBCAPS_PRIMARYBUFFER)) return CS_E_NULL_PRIMARY;
WAVEFORMATEX wfx;
zeroMem( &wfx, sizeof(WAVEFORMATEX) );
wfx.wFormatTag = WAVE_FORMAT_PCM;
wfx.nChannels = Channels;
wfx.nSamplesPerSec = SamplesPerSec;
wfx.wBitsPerSample = BitsPerSample;
wfx.nBlockAlign = wfx.wBitsPerSample / 8 * wfx.nChannels;
wfx.nAvgBytesPerSec = wfx.nSamplesPerSec * wfx.nBlockAlign;
if(FAILED(m_pPrimaryBuffer->SetFormat(&wfx))) return CS_E_NOCANDO;
SAFE_RELEASE(m_pPrimaryBuffer);
return CS_E_OK;
}
int CSound::GetPrimaryBuffer(IDirectSoundBuffer** buffer, DWORD dwFlags)
{
if(!m_pSoundObject) return CS_E_NULL_OBJECT;
//プライマリバッファを取得してくる
DSBUFFERDESC dsbdesc;
zeroMem(&dsbdesc, sizeof(DSBUFFERDESC));
dsbdesc.dwSize = sizeof(DSBUFFERDESC);
dsbdesc.dwFlags = dwFlags;
dsbdesc.dwBufferBytes = 0;
dsbdesc.lpwfxFormat = NULL;
if(FAILED(m_pSoundObject->CreateSoundBuffer(&dsbdesc, buffer, NULL)))
{
_ASSERT(0);
return CS_E_NULL_PRIMARY;
}
return CS_E_OK;
}
//WAVEファイルをロードする
int WaveLoader::ReadWaveData(WAVEFORMATEX* wfx, void** pdata, QWORD dwFrom, QWORD dwSizeToRead, bool isLoopWave)
{
static MMCKINFO parent, child;
static char szBefore[MAX_PATH];
_ASSERT(m_FileInfo->name);
if(pdata!=NULL) SAFE_GLOBALFREE(*pdata);
//if(m_hmmio!=NULL && lstrcmp(m_FileInfo->name, szBefore)!=0){//ファイル名が指定されていたら開きなおす
// SAFE_MMIOCLOSE(m_hmmio);
//}
if( !isLoaded ){
lstrcpy(szBefore, m_FileInfo->name);
if( lstrcmp(m_FileInfo->name, CSL_LOAD_MEMORYIMAGE)==0 ){
// if(!m_hmmio){//最初の一回しかしない処理（ストリーミング用の処置）
MMIOINFO mmioinfo;
zeroMem(&mmioinfo, sizeof(MMIOINFO));
mmioinfo.pchBuffer = (HPSTR)m_FileInfo->pMemBuffer;
mmioinfo.fccIOProc = FOURCC_MEM;
mmioinfo.cchBuffer = m_FileInfo->fsize;
if(NULL == (m_hmmio = mmioOpen(NULL, &mmioinfo, MMIO_READ|MMIO_ALLOCBUF))){
return CSL_E_UNEXP;
}
}else{
if(NULL == (m_hmmio = mmioOpen((LPSTR)m_FileInfo->name, NULL, MMIO_READ|MMIO_ALLOCBUF))){
return CSL_E_UNEXP;
}
}
parent.fccType = mmioFOURCC('W', 'A', 'V', 'E');//waveファイルかどうか調べる
if(mmioDescend(m_hmmio, &parent, NULL, MMIO_FINDRIFF) != MMSYSERR_NOERROR){
SAFE_MMIOCLOSE(m_hmmio);
return CSL_E_UNEXP;
}
child.ckid = mmioFOURCC('f', 'm', 't', ' ');//fmtチャンクへ移動する
if(mmioDescend(m_hmmio, &child, &parent, MMIO_FINDCHUNK) != MMSYSERR_NOERROR){
SAFE_MMIOCLOSE(m_hmmio);
return CSL_E_UNEXP;
}
_ASSERT(wfx);
if(mmioRead(m_hmmio, (HPSTR)wfx, (LONG)child.cksize) != (LONG)child.cksize){//fmtチャンク(WAVEFORMATEX)読み取り
SAFE_MMIOCLOSE(m_hmmio);
return CSL_E_UNEXP;
}
_ASSERT((wfx->wFormatTag==WAVE_FORMAT_PCM));
mmioAscend(m_hmmio, &child, 0);//fmtチャンクから出る
child.ckid = mmioFOURCC('d', 'a', 't', 'a');//dataチャンクに移動
if(mmioDescend(m_hmmio, &child, &parent, MMIO_FINDCHUNK) != MMSYSERR_NOERROR) {
SAFE_MMIOCLOSE(m_hmmio);
return CSL_E_UNEXP;
}
m_dwDataLength = child.cksize;//WAVE領域のサイズ
m_dwOffsetToWaveData = mmioSeek(m_hmmio, 0, SEEK_CUR);//データまでの位置を保存しておく
}
if(pdata){
if(dwSizeToRead<=0){//ファイル全体を読み込む
(*pdata) = (LPBYTE)GlobalAlloc(GPTR, m_dwDataLength * sizeof(BYTE));
_ASSERT(*pdata);
if(mmioRead(m_hmmio, (HPSTR)*pdata, (LONG)m_dwDataLength) != (LONG)m_dwDataLength){
GlobalFree(*pdata);
SAFE_MMIOCLOSE(m_hmmio);
return CSL_E_UNEXP;
}
SAFE_MMIOCLOSE(m_hmmio); //必要なデータがそろったので､ファイルを閉じる
m_dwCurrentDecodedPos += dwSizeToRead;
}else{
//DWORD dwInnerFinPos = dwFrom + dwSizeToRead;
////領域サイズ以上だったら収まるように値を補正
//if(m_dwDataLength < dwInnerFinPos){
// dwSizeToRead -= dwInnerFinPos-m_dwDataLength;
//}
//開始位置が指定されていれば, データ領域からのオフセットをStartとする.
//指定されていなければ, それまで進んだカーソル位置から読み込みを開始する
if(dwFrom>=0) mmioSeek(m_hmmio, (LONG)(m_dwOffsetToWaveData + dwFrom), SEEK_SET);
//要求領域分のメモリ確保
(*pdata) = (LPBYTE)GlobalAlloc(GPTR, (SIZE_T)(dwSizeToRead * sizeof(BYTE)));
_ASSERT(*pdata);
//現在位置からリクエストサイズを読むとオーバーするようなら、ラップアラウンドする。
DWORD dwNowCursor = mmioSeek(m_hmmio, 0, SEEK_CUR) - m_dwOffsetToWaveData;
if(m_dwDataLength < (dwNowCursor + dwSizeToRead)){
if( !isLoopWave ){
if( dwNowCursor>=m_dwDataLength ){
fillMem((BYTE*)*pdata, dwSizeToRead, (m_wfx.wBitsPerSample==8) ? 128:0);
return CSL_E_OUTOFRANGE;
}
}
DWORD dwBeforeWrapAround = m_dwDataLength-dwNowCursor;
//とりあえず、最後まで読む
if(mmioRead(m_hmmio, (HPSTR)*pdata, (LONG)dwBeforeWrapAround) != (LONG)dwBeforeWrapAround){
GlobalFree(*pdata);
SAFE_MMIOCLOSE(m_hmmio);
return CSL_E_UNEXP;
}
m_dwCurrentDecodedPos += dwBeforeWrapAround;
if(isLoopWave){//残った部分を無音で埋めるかどうか
mmioSeek(m_hmmio, 0, SEEK_SET);
mmioSeek(m_hmmio, m_dwOffsetToWaveData, SEEK_CUR); //ポインタをWAVE領域始点に戻す
//ラップアラウンド分を読む
if(mmioRead(m_hmmio, (HPSTR)*pdata+dwBeforeWrapAround, (LONG)(dwSizeToRead - dwBeforeWrapAround)) != (LONG)(dwSizeToRead - dwBeforeWrapAround)){
GlobalFree(*pdata);
SAFE_MMIOCLOSE(m_hmmio);
return CSL_E_UNEXP;
}
m_dwCurrentDecodedPos = 0;
m_dwCurrentDecodedPos += dwSizeToRead - dwBeforeWrapAround;
}else{
fillMem((BYTE*)*pdata+dwBeforeWrapAround, dwSizeToRead - dwBeforeWrapAround, (m_wfx.wBitsPerSample==8) ? 128:0);
return CSL_N_FIN;
}
}else{ //ラップアラウンドしなかった場合
if(mmioRead(m_hmmio, (HPSTR)*pdata, (LONG)dwSizeToRead) != (LONG)dwSizeToRead){
GlobalFree(*pdata);
SAFE_MMIOCLOSE(m_hmmio);
return CSL_E_UNEXP;
}
m_dwCurrentDecodedPos += dwSizeToRead;
}//必要なデータはまだあるので、ファイルは閉じない
}
}
return CSL_E_OK;
}
glBufferImpl::glBufferImpl(GFXDevice& context, const BufferImplParams& params)
: glObject(glObjectType::TYPE_BUFFER, context),
GUIDWrapper(),
_context(context),
_alignedSize(params._dataSize),
_target(params._target),
_unsynced(params._unsynced),
_useExplicitFlush(_target == GL_ATOMIC_COUNTER_BUFFER ? false : params._explicitFlush),
_updateFrequency(params._frequency),
_elementSize(params._elementSize)
{
if (_target == GL_ATOMIC_COUNTER_BUFFER) {
_usage = GL_STREAM_READ;
} else {
_usage = _updateFrequency == BufferUpdateFrequency::ONCE
? GL_STATIC_DRAW
: _updateFrequency == BufferUpdateFrequency::OCASSIONAL
? GL_DYNAMIC_DRAW
: GL_STREAM_DRAW;
}
bool usePersistentMapping = false;
if (!Config::Profile::DISABLE_PERSISTENT_BUFFER) { // For debugging
if (params._storageType == BufferStorageType::IMMUTABLE) {
usePersistentMapping = true;
} else if (params._storageType == BufferStorageType::AUTO) {
usePersistentMapping = _alignedSize > g_persistentMapSizeThreshold; // Driver might be faster?
}
}
// Why do we need to map it?
if (_updateFrequency == BufferUpdateFrequency::ONCE) {
usePersistentMapping = false;
}
if (!usePersistentMapping) {
GLUtil::createAndAllocBuffer(_alignedSize, _usage, _handle, params._initialData, params._name);
} else {
gl::BufferStorageMask storageMask = GL_MAP_PERSISTENT_BIT;
gl::BufferAccessMask accessMask = GL_MAP_PERSISTENT_BIT;
switch (_updateFrequency) {
case BufferUpdateFrequency::ONCE:{
storageMask |= GL_MAP_READ_BIT;
accessMask |= GL_MAP_READ_BIT;
} break;
case BufferUpdateFrequency::OCASSIONAL:
case BufferUpdateFrequency::OFTEN: {
storageMask |= GL_MAP_WRITE_BIT;
accessMask |= GL_MAP_WRITE_BIT;
if (_useExplicitFlush) {
accessMask |= GL_MAP_FLUSH_EXPLICIT_BIT;
}
} break;
case BufferUpdateFrequency::COUNT: {
DIVIDE_UNEXPECTED_CALL("Unknown buffer update frequency!");
} break;
};
_mappedBuffer = GLUtil::createAndAllocPersistentBuffer(_alignedSize, storageMask, accessMask, _handle, params._initialData, params._name);
assert(_mappedBuffer != nullptr && "PersistentBuffer::Create error: Can't mapped persistent buffer!");
}
if (params._zeroMem) {
zeroMem(0, _alignedSize);
}
}
void VectorX::init(int nn){ n=nn; getMem(v,n,""); zeroMem(v,n);}
void CreateTexture(ID3D11Device* pDev, ID3D11DeviceContext* pCon)
{
m_pDev = pDev;
m_pCon = pCon;
const D3D11_TEXTURE2D_DESC texdesc = {
112, 66, 1, 1, DXGI_FORMAT_R8_UNORM,1,0,
D3D11_USAGE_DEFAULT,
D3D11_BIND_SHADER_RESOURCE, 0, 0};
D3D11_SUBRESOURCE_DATA texdata = {lcfont_bw112x66, 112, 0};
m_pDev->CreateTexture2D(&texdesc, &texdata, &pFont);
if (!pFont)
return ;
D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
ZeroMemory( &srvDesc, sizeof(srvDesc) );
srvDesc.Format = texdesc.Format;
srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
srvDesc.Texture2D.MostDetailedMip = 0;
srvDesc.Texture2D.MipLevels = texdesc.MipLevels;
m_pDev->CreateShaderResourceView(pFont, &srvDesc, &pFontShaderResource );
//font shader
m_inputlayout = 0;
m_pVS = 0;
m_pPS = 0;
const D3D11_INPUT_ELEMENT_DESC layout[] =
{
{ "IN_POS" , 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D11_INPUT_PER_VERTEX_DATA, 0 },
{ "IN_TEXCOORD", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 12, D3D11_INPUT_PER_VERTEX_DATA, 0 },
};
static const char* font_sh = "\
Texture2D fonttex : register( t0 );\
SamplerState Samp : register( s0 );\
struct VS_OUTPUT\
{\
float4 pos : SV_POSITION;\
float2 tex : TEXCOORD0;\
};\
\
float4 ps( VS_OUTPUT In ) : SV_TARGET\
{\
return fonttex.Sample(Samp, In.tex).rrrr;\
}\
VS_OUTPUT vs(float3 pos : IN_POS0, float2 tex : IN_TEXCOORD0)\
{\
VS_OUTPUT Out;\
Out.pos = float4(pos,1);\
Out.tex = tex;\
return Out;\
}";
compileShaderSrc(m_pDev, D3D11_VS, font_sh, (void**)&m_pVS, layout, sizeof(layout)/sizeof(D3D11_INPUT_ELEMENT_DESC), &m_inputlayout);
compileShaderSrc(m_pDev, D3D11_PS, font_sh, (void**)&m_pPS);
m_pVB = 0;
m_maxlen = 0;
D3D11_RASTERIZER_DESC rsDesc;
zeroMem( &rsDesc, sizeof( D3D11_RASTERIZER_DESC ) );
rsDesc.CullMode = D3D11_CULL_BACK;
rsDesc.FillMode = D3D11_FILL_SOLID;
rsDesc.DepthClipEnable = FALSE;
m_pDev->CreateRasterizerState(&rsDesc, &m_rstate);
D3D11_DEPTH_STENCIL_DESC dsDesc;
zeroMem( &dsDesc, sizeof( D3D11_DEPTH_STENCIL_DESC ) );
dsDesc.DepthEnable = FALSE;
dsDesc.DepthWriteMask = D3D11_DEPTH_WRITE_MASK_ALL;
dsDesc.DepthFunc = D3D11_COMPARISON_LESS;
dsDesc.StencilEnable = FALSE;
m_pDev->CreateDepthStencilState( &dsDesc, &m_pDS);
D3D11_BLEND_DESC BlendDesc;
zeroMem( &BlendDesc, sizeof( BlendDesc ) );
BlendDesc.AlphaToCoverageEnable = FALSE;
BlendDesc.IndependentBlendEnable = FALSE;
BlendDesc.RenderTarget[0].BlendEnable = TRUE;
BlendDesc.RenderTarget[0].SrcBlend = D3D11_BLEND_INV_DEST_COLOR;//D3D11_BLEND_SRC_ALPHA;
BlendDesc.RenderTarget[0].DestBlend = D3D11_BLEND_INV_SRC_COLOR;//D3D11_BLEND_INV_SRC_ALPHA;
BlendDesc.RenderTarget[0].BlendOp = D3D11_BLEND_OP_ADD;
BlendDesc.RenderTarget[0].SrcBlendAlpha = D3D11_BLEND_ONE;
BlendDesc.RenderTarget[0].DestBlendAlpha = D3D11_BLEND_ZERO;
BlendDesc.RenderTarget[0].BlendOpAlpha = D3D11_BLEND_OP_ADD;
BlendDesc.RenderTarget[0].RenderTargetWriteMask = D3D11_COLOR_WRITE_ENABLE_ALL;
m_pDev->CreateBlendState( &BlendDesc, &m_pBS );
}
AlClipboard::AlClipboard()
{
logger->debug("AlClipboard::AlClipboard():-- START\n");
zeroMem();
}
void ScaledAray::init(){
getMem0(array,profileLength+10, "ScaledAray::init #1");
getMem0(counts,profileLength+10, "ScaledAray::init #2");
zeroMem(counts,profileLength+10);
}
int CSound::LoadInternal(const char* szFileName, DSBUFFERDESC* pDsbdesc, void* pData, unsigned long dwDataSize){
CSoundLoader* pLoader;
char errmsg[512];
if(CS_E_OK!=this->GetLoaderInterface(&pLoader, szFileName, pData, dwDataSize)){
wsprintf(errmsg, "Sound::%sの読み取りインターフェイス取得に失敗.\nファイルが存在するかもしくは対応形式か確認して下さい.", szFileName);
::MessageBox(NULL, errmsg, "", MB_ICONEXCLAMATION|MB_OK|MB_TOPMOST);
//FatalAppExit(0, errmsg);
return CS_E_NOTFOUND;
}
if(CSL_E_OK != pLoader->QueryLoadFile(szFileName, pData, dwDataSize)){
wsprintf(errmsg, "Sound::%sの読み取りに失敗.", szFileName);
::MessageBox(NULL, errmsg, "", MB_ICONEXCLAMATION|MB_OK|MB_TOPMOST);
//FatalAppExit(0, errmsg);
return CS_E_UNEXP;
}
//初期化
this->AddRef();
this->UnInitialize();
m_Loader = pLoader;
if(!m_pPrimaryBuffer){ //プライマリバッファを取得する
if(CS_E_OK!=GetPrimaryBuffer(&m_pPrimaryBuffer, DSBCAPS_CTRLVOLUME | DSBCAPS_CTRLPAN | DSBCAPS_PRIMARYBUFFER)) return CS_E_NULL_PRIMARY;
}
DSBUFFERDESC dsbdesc;
zeroMem(&dsbdesc, sizeof(DSBUFFERDESC));
dsbdesc.dwSize = sizeof(DSBUFFERDESC);
//全体の長さとWFXの取得
DWORD dwDataLength = m_Loader->GetDecodedLength();
m_Loader->GetWaveFormatEx(&m_wfx);
if(dwDataLength >= CS_LIMITLOADONMEMORY){//展開したときのサイズが1MB以上だったらストリーミング再生]
//スレッド処理
this->CloseStreamThread();
m_hThreadMessageDispatchEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
m_hThread = CreateThread(NULL, 0, this->StreamThread, (void*)this, CREATE_SUSPENDED, &m_dwThreadId); //スレッド生成
// スレッド優先を変更
SetThreadPriority( m_hThread, THREAD_PRIORITY_NORMAL );
// スレッド開始
ResumeThread( m_hThread );
WaitForSingleObject(m_hThreadMessageDispatchEvent, INFINITE);// スレッドメッセージキューが作成されるのを待つ
m_isStreamFile = TRUE;
//セカンダリバッファ
{
SAFE_RELEASE(m_pSecondaryBuffer);
dsbdesc.dwFlags = DSBCAPS_GETCURRENTPOSITION2|DSBCAPS_CTRLPOSITIONNOTIFY|
DSBCAPS_GLOBALFOCUS|DSBCAPS_CTRLPAN|DSBCAPS_CTRLVOLUME|
DSBCAPS_CTRLFREQUENCY|DSBCAPS_LOCSOFTWARE;
if(pDsbdesc){
dsbdesc.dwFlags = pDsbdesc->dwFlags;
dsbdesc.guid3DAlgorithm = dsbdesc.guid3DAlgorithm;
}
dsbdesc.lpwfxFormat = &m_wfx;
DWORD dwSize = m_wfx.nAvgBytesPerSec * m_dwBufferLengthSec / m_dwNotificationNum;
dwSize -= dwSize % m_wfx.nBlockAlign;
dsbdesc.dwBufferBytes = dwSize * m_dwNotificationNum;
if(!CreateBuffer(&m_pSecondaryBuffer, &dsbdesc, NULL)) return CS_E_NOCANDO;
m_dwOneSplittedBufferSize = dwSize;//区切られたバッファの１つのサイズ（バッファ全体はこれ*m_dwNotificationNum
}
//通知インターフェイス
#if !ENABLE_SOUND_POLLING
{
SAFE_RELEASE(m_pSoundNotify);
if(FAILED(m_pSecondaryBuffer->QueryInterface(IID_IDirectSoundNotify, (void**)&m_pSoundNotify))){
return CS_E_NOCANDO;
}
SAFE_GLOBALFREE(m_pDsbnotify);
if(!(m_pDsbnotify = (DSBPOSITIONNOTIFY*)GlobalAlloc(GPTR, m_dwNotificationNum * sizeof(DSBPOSITIONNOTIFY)))){
return CS_E_UNEXP;
}
m_pNotifyHandle = CreateEvent(NULL, FALSE, FALSE, NULL); //通知ハンドルの作成
for(DWORD i=0; i<m_dwNotificationNum; i++){
//OutputDebugStringFormatted("[%2lu]:%lu\n", i, (m_dwOneSplittedBufferSize*i) + 1);
m_pDsbnotify[i].dwOffset = (m_dwOneSplittedBufferSize*i) + 1;// バッファを分割する。通知ポイントは、バッファの区切れ目から1バイト先。こうすることで、スペックの低いマシンでも249ms以内に次のバッファ区間を埋めればよいことになる。
m_pDsbnotify[i].hEventNotify = m_pNotifyHandle;
}
if(FAILED(m_pSoundNotify->SetNotificationPositions(m_dwNotificationNum, m_pDsbnotify))){
SAFE_GLOBALFREE(m_pDsbnotify);
SAFE_RELEASE(m_pSoundNotify);
SAFE_CLOSEHANDLE(m_pNotifyHandle);
return CS_E_NOCANDO;
}
}
#endif
}else{
m_isStreamFile = FALSE;
void* pdata = NULL;
if(CSL_E_OK != m_Loader->GetDecodedData(&pdata, 0, 0, FALSE)){
}
dsbdesc.dwFlags = DSBCAPS_CTRLPAN|DSBCAPS_CTRLVOLUME|
DSBCAPS_CTRLFREQUENCY|
DSBCAPS_GETCURRENTPOSITION2|DSBCAPS_CTRLPOSITIONNOTIFY|
DSBCAPS_GLOBALFOCUS;
if(pDsbdesc){
dsbdesc.dwFlags = pDsbdesc->dwFlags;
dsbdesc.guid3DAlgorithm = dsbdesc.guid3DAlgorithm;
}
dsbdesc.dwBufferBytes = dwDataLength;
dsbdesc.lpwfxFormat = &m_wfx;
SAFE_RELEASE(m_pSecondaryBuffer);
if(!CreateBuffer(&m_pSecondaryBuffer, &dsbdesc, NULL)) return CS_E_NOCANDO; //セカンダリバッファの作成
if(!WriteDataToBuffer(&m_pSecondaryBuffer, pdata, 0, dwDataLength)) return CS_E_NOCANDO; //データをバッファに書き込む
SAFE_GLOBALFREE(pdata);
}
SAFE_RELEASE(m_pPrimaryBuffer);
return CS_E_OK;
}
