archive
/
windows-server-2003
mirror of https://github.com/selfrender/Windows-Server-2003
2
0
Fork 0
Code Issues Projects Releases Wiki Activity
Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
4 Commits
1 Branch
0 Tags
1.5 GiB
 
 
 
 
 
 
Tree: 5c6fe3db62
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '5c6fe3db62'
${ noResults }
windows-server-2003/multimedia/directx/dinput/dx7/dll/diriff.c

615 lines
18 KiB
Raw Blame History

/****************************************************************************
MODULE: RIFF.CPP
Tab settings: Every 4 spaces
Copyright 1996, Microsoft Corporation, All Rights Reserved.
PURPOSE: Classes for reading and writing RIFF files
CLASSES:
CRIFFFile Encapsulates common RIFF file functionality
Author(s): Name:
---------- ----------------
DMS Daniel M. Sangster
Revision History:
-----------------
Version Date Author Comments
1.0 25-Jul-96 DMS Created
COMMENTS:
****************************************************************************/
#include "dinputpr.h"
#define sqfl sqflDev
/*
* This function converts MMIO errors to HRESULTS
*/
HRESULT INLINE hresMMIO(UINT mmioErr)
{
switch(mmioErr)
{
case 0x0: return S_OK;
case MMIOERR_FILENOTFOUND: return hresLe(ERROR_FILE_NOT_FOUND);/* file not found */
case MMIOERR_OUTOFMEMORY: return hresLe(ERROR_OUTOFMEMORY); /* out of memory */
case MMIOERR_CANNOTOPEN: return hresLe(ERROR_OPEN_FAILED); /* cannot open */
case MMIOERR_CANNOTCLOSE: return S_FALSE; /* cannot close */
case MMIOERR_CANNOTREAD: return hresLe(ERROR_READ_FAULT); /* cannot read */
case MMIOERR_CANNOTWRITE: return hresLe(ERROR_WRITE_FAULT); /* cannot write */
case MMIOERR_CANNOTSEEK: return hresLe(ERROR_SEEK); /* cannot seek */
case MMIOERR_CANNOTEXPAND: return hresLe(ERROR_SEEK); /* cannot expand file */
case MMIOERR_CHUNKNOTFOUND: return hresLe(ERROR_SECTOR_NOT_FOUND); /* chunk not found */
case MMIOERR_UNBUFFERED: return E_FAIL;
case MMIOERR_PATHNOTFOUND: return hresLe(ERROR_PATH_NOT_FOUND);/* path incorrect */
case MMIOERR_ACCESSDENIED: return hresLe(ERROR_ACCESS_DENIED); /* file was protected */
case MMIOERR_SHARINGVIOLATION: return hresLe(ERROR_SHARING_VIOLATION); /* file in use */
case MMIOERR_NETWORKERROR: return hresLe(ERROR_UNEXP_NET_ERR); /* network not responding */
case MMIOERR_TOOMANYOPENFILES: return hresLe(ERROR_TOO_MANY_OPEN_FILES); /* no more file handles */
case MMIOERR_INVALIDFILE: return hresLe(ERROR_BAD_FORMAT); /* default error file error */
default: return E_FAIL;
}
}
HRESULT INLINE RIFF_Ascend(HMMIO hmmio, LPMMCKINFO lpmmckinfo)
{
return hresMMIO( mmioAscend(hmmio, lpmmckinfo, 0) );
}
HRESULT INLINE RIFF_Descend(HMMIO hmmio, LPMMCKINFO lpmmckinfo, LPMMCKINFO lpmmckinfoParent, UINT nFlags)
{
return hresMMIO(mmioDescend(hmmio, lpmmckinfo, lpmmckinfoParent, nFlags));
}
HRESULT INLINE RIFF_CreateChunk(HMMIO hmmio, LPMMCKINFO lpmmckinfo, UINT nFlags)
{
// set cksize to zero to overcome a bug in release version of mmioAscend
// which does not correctly write back the size of the chunk
lpmmckinfo->cksize = 0;
return hresMMIO(mmioCreateChunk(hmmio, lpmmckinfo, nFlags));
}
HRESULT INLINE RIFF_Read(HMMIO hmmio, LPVOID pBuf, LONG nCount)
{
return (nCount == mmioRead(hmmio, (char*)pBuf, nCount)) ? S_OK: hresLe(ERROR_READ_FAULT);
}
HRESULT INLINE RIFF_Write(HMMIO hmmio, const LPVOID pBuf, LONG nCount)
{
return ( nCount == mmioWrite(hmmio, (char*)pBuf, nCount)) ? S_OK : hresLe(ERROR_WRITE_FAULT);
}
HRESULT RIFF_Close(HMMIO hmmio, UINT nFlags)
{
return hresMMIO(mmioClose(hmmio, nFlags));
}
/*
* Opens a RIFF file for read / write
* Reads/Writes a GUID that servers as our signature
*/
HRESULT RIFF_Open
(
LPCSTR lpszFilename,
UINT nOpenFlags,
PHANDLE phmmio,
LPMMCKINFO lpmmck,
PDWORD pdwEffectSz
)
{
HRESULT hres = S_OK;
MMIOINFO mmInfo;
HMMIO hmmio;
ZeroX(mmInfo);
// go ahead and open the file, if we can
hmmio = mmioOpenA((LPSTR)lpszFilename, &mmInfo, nOpenFlags);
if(mmInfo.wErrorRet)
{
hres = hresMMIO(mmInfo.wErrorRet);
AssertF(FAILED(hres));
}
// if( nOpenFlags & ( MMIO_READ | MMIO_ALLOCBUF) )
if( nOpenFlags == ( MMIO_READ | MMIO_ALLOCBUF) )
{
if(SUCCEEDED(hres))
{
// locate and descend into FORC RIFF chunk
lpmmck->fccType = FCC_FORCE_EFFECT_RIFF;
hres = RIFF_Descend(hmmio, lpmmck, NULL, MMIO_FINDRIFF);
}
if(SUCCEEDED(hres))
{
GUID GUIDVersion;
//read the guid
hres = RIFF_Read(hmmio, &GUIDVersion, sizeof(GUID));
if(SUCCEEDED(hres))
{
if(IsEqualGUID(&GUIDVersion, &GUID_INTERNALFILEEFFECT))
{
} else
{
hres = hresLe(ERROR_BAD_FORMAT);
}
}
}
}
//else if( nOpenFlags & ( MMIO_WRITE | MMIO_ALLOCBUF) )
else if( nOpenFlags & ( MMIO_WRITE) )
{
// create the FORC RIFF chunk
lpmmck->fccType = FCC_FORCE_EFFECT_RIFF;
hres = RIFF_CreateChunk(hmmio, lpmmck, MMIO_CREATERIFF);
if(SUCCEEDED(hres))
{
//write the version GUID
hres = RIFF_Write(hmmio, (PV)&GUID_INTERNALFILEEFFECT, sizeof(GUID));
}
} else
{
hres = E_FAIL;
}
*phmmio = hmmio;
return hres;
}
/*****************************************************************************
*
* internal
* RIFF_ReadEffect
*
* Reads a single Effect from a RIFF file
*
* The callee bears the responsibility to free the TypeSpecificParameterBlock
* for the effect.
*
*
*****************************************************************************/
#ifdef _M_IA64
//This is hack to read 32 bit files on ia64, since someone decided to write
//pointers to file.
//Copied from dinput.h and modified.
typedef struct DIEFFECT_FILE32 {
DWORD dwSize; /* sizeof(DIEFFECT) */
DWORD dwFlags; /* DIEFF_* */
DWORD dwDuration; /* Microseconds */
DWORD dwSamplePeriod; /* Microseconds */
DWORD dwGain;
DWORD dwTriggerButton; /* or DIEB_NOTRIGGER */
DWORD dwTriggerRepeatInterval; /* Microseconds */
DWORD cAxes; /* Number of axes */
/*Make sure size is same on both 1386 and ia64.
LPDWORD rgdwAxes;
LPLONG rglDirection;
LPDIENVELOPE lpEnvelope;
*/ DWORD rgdwAxes; /* Array of axes */
DWORD rglDirection; /* Array of directions */
DWORD lpEnvelope; /* Optional */
DWORD cbTypeSpecificParams; /* Size of params */
/*Make sure size is same on both 1386 and ia64.
LPVOID lpvTypeSpecificParams;
*/ DWORD lpvTypeSpecificParams; /* Pointer to params */
//#if(DIRECTINPUT_VERSION >= 0x0600)//Out since file format does not change.
DWORD dwStartDelay; /* Microseconds */
//#endif /* DIRECTINPUT_VERSION >= 0x0600 *///Out since file format does not change.
} DIEFFECT_FILE32, *LPDIEFFECT_FILE32;
#endif /*_M_IA64*/
HRESULT
RIFF_ReadEffect
(
HMMIO hmmio,
LPDIFILEEFFECT lpDiFileEf
)
{
HRESULT hres = E_FAIL;
MMCKINFO mmckinfoEffectLIST;
MMCKINFO mmckinfoDataCHUNK;
LPDIEFFECT peff = (LPDIEFFECT)lpDiFileEf->lpDiEffect;
// descend into the effect list
mmckinfoEffectLIST.fccType = FCC_EFFECT_LIST;
hres = RIFF_Descend(hmmio, &mmckinfoEffectLIST, NULL, MMIO_FINDLIST);
if(SUCCEEDED(hres))
{
//read the name
hres = RIFF_Read(hmmio, lpDiFileEf->szFriendlyName, MAX_SIZE_SNAME);
}
if(SUCCEEDED(hres))
{
#ifdef _M_IA64
DIEFFECT_FILE32 eff32;
//read the effect structure
hres = RIFF_Read(hmmio, &eff32, sizeof(eff32));
AssertF( eff32.dwSize == sizeof(eff32) );
if( eff32.dwSize != sizeof(eff32) )
{
hres = ERROR_BAD_FORMAT;
}
else
{
peff->dwSize=sizeof(*peff);
peff->dwFlags=eff32.dwFlags;
peff->dwDuration=eff32.dwDuration;
peff->dwSamplePeriod=eff32.dwSamplePeriod;
peff->dwGain=eff32.dwGain;
peff->dwTriggerButton=eff32.dwTriggerButton;
peff->dwTriggerRepeatInterval=eff32.dwTriggerRepeatInterval;
peff->cAxes=eff32.cAxes;
peff->cbTypeSpecificParams=eff32.cbTypeSpecificParams;
peff->lpvTypeSpecificParams=(LPVOID)(DWORD_PTR)eff32.lpvTypeSpecificParams;
peff->dwStartDelay=eff32.dwStartDelay;
}
#else /*_M_IA64*/
// Reading the effect structure will zap out the following,
// so we make a copy before the read.
LPDIENVELOPE lpEnvelope = peff->lpEnvelope;
LPDWORD rgdwAxes = peff->rgdwAxes;
LPLONG rglDirection= peff->rglDirection;
//read the effect structure
hres = RIFF_Read(hmmio, peff, sizeof(DIEFFECT));
AssertF( peff->dwSize == sizeof(DIEFFECT) );
if( peff->dwSize != sizeof(DIEFFECT) )
{
hres = ERROR_BAD_FORMAT;
}
else
{
if(peff->lpEnvelope) peff->lpEnvelope = lpEnvelope;
if(peff->rgdwAxes) peff->rgdwAxes = rgdwAxes;
if(peff->rglDirection) peff->rglDirection = rglDirection;
}
#endif /*_M_IA64*/
if(SUCCEEDED(hres))
{
AssertF(peff->cAxes < DIEFFECT_MAXAXES);
if(peff->cAxes >= DIEFFECT_MAXAXES)
{
hres = ERROR_BAD_FORMAT;
}
}
}
if(SUCCEEDED(hres))
{
// read the Effect GUID
hres = RIFF_Read(hmmio, &lpDiFileEf->GuidEffect, sizeof(GUID));
}
if(SUCCEEDED(hres))
{
UINT nRepeatCount;
//read in the repeat count
hres = RIFF_Read(hmmio, &nRepeatCount, sizeof(nRepeatCount));
}
if(SUCCEEDED(hres) && peff->rgdwAxes)
{
// descend the data chunk
mmckinfoDataCHUNK.ckid = FCC_DATA_CHUNK;
hres = RIFF_Descend(hmmio, &mmckinfoDataCHUNK, NULL, MMIO_FINDCHUNK);
if(SUCCEEDED(hres))
{
//read the axes
hres = RIFF_Read(hmmio, peff->rgdwAxes, cbX(*peff->rgdwAxes)*(peff->cAxes));
hres = RIFF_Ascend(hmmio, &mmckinfoDataCHUNK);
}
}
if(SUCCEEDED(hres) && peff->rglDirection)
{
//descend the data chunk
mmckinfoDataCHUNK.ckid = FCC_DATA_CHUNK;
hres = RIFF_Descend(hmmio, &mmckinfoDataCHUNK, NULL, MMIO_FINDCHUNK);
if(SUCCEEDED(hres))
{
//read the direction
hres = RIFF_Read(hmmio, peff->rglDirection, cbX(*peff->rglDirection)*(peff->cAxes));
hres = RIFF_Ascend(hmmio, &mmckinfoDataCHUNK);
}
}
if(SUCCEEDED(hres) && peff->lpEnvelope )
{
//descend the data chunk
mmckinfoDataCHUNK.ckid = FCC_DATA_CHUNK;
hres = RIFF_Descend(hmmio, &mmckinfoDataCHUNK, NULL, MMIO_FINDCHUNK);
if(SUCCEEDED(hres))
{
hres = RIFF_Read(hmmio, peff->lpEnvelope, sizeof(DIENVELOPE));
hres = RIFF_Ascend(hmmio, &mmckinfoDataCHUNK);
}
}
if(SUCCEEDED(hres) && (peff->cbTypeSpecificParams > 0))
{
// get the param structure, if any
hres = AllocCbPpv( peff->cbTypeSpecificParams, &peff->lpvTypeSpecificParams );
if( SUCCEEDED( hres ) )
{
//descend the data chunk
mmckinfoDataCHUNK.ckid = FCC_DATA_CHUNK;
hres = RIFF_Descend(hmmio, &mmckinfoDataCHUNK, NULL, MMIO_FINDCHUNK);
if(SUCCEEDED(hres))
{
hres = RIFF_Read(hmmio, peff->lpvTypeSpecificParams, peff->cbTypeSpecificParams);
hres = RIFF_Ascend(hmmio, &mmckinfoDataCHUNK);
}
}
}
if(SUCCEEDED(hres))
{
// ascend the effect chunk
hres = RIFF_Ascend(hmmio, &mmckinfoEffectLIST);
}
return hres;
}
/*
* RIFF_WriteEffect
*
* Writes a single Effect structure to a RIFF file
*
* The effect structure is quite complex. It contains pointers
* to a number of other structures. This function checks for
* valid data before it writes out the effect structure
*/
HRESULT RIFF_WriteEffect
(HMMIO hmmio,
LPDIFILEEFFECT lpDiFileEf
)
{
HRESULT hres = E_FAIL;
LPDIEFFECT peff = (LPDIEFFECT)lpDiFileEf->lpDiEffect;
MMCKINFO mmckinfoEffectLIST;
MMCKINFO mmckinfoDataCHUNK;
LPDWORD rgdwAxes = NULL;
LPLONG rglDirection = NULL;
LPDIENVELOPE lpEnvelope = NULL;
LPVOID lpvTypeSpecPar = NULL;
EnterProcI(RIFF_WriteEffect, (_ "xx", hmmio, lpDiFileEf));
// create the effect LIST
mmckinfoEffectLIST.fccType = FCC_EFFECT_LIST;
hres = RIFF_CreateChunk(hmmio, &mmckinfoEffectLIST, MMIO_CREATELIST);
//save the effect ptrs and write flags to the file, instead of ptrs
if (peff->rgdwAxes)
{
rgdwAxes = peff->rgdwAxes;
peff->rgdwAxes = (LPDWORD)DIEP_AXES;
}
if (peff->rglDirection)
{
rglDirection = peff->rglDirection;
peff->rglDirection = (LPLONG)DIEP_DIRECTION;
}
if (peff->lpEnvelope)
{
lpEnvelope = peff->lpEnvelope;
peff->lpEnvelope = (LPDIENVELOPE)DIEP_ENVELOPE;
}
if ((peff->cbTypeSpecificParams > 0) && (peff->lpvTypeSpecificParams != NULL))
{
lpvTypeSpecPar = peff->lpvTypeSpecificParams;
peff->lpvTypeSpecificParams = (LPVOID)DIEP_TYPESPECIFICPARAMS;
}
if(SUCCEEDED(hres))
{
hres = hresFullValidReadStrA(lpDiFileEf->szFriendlyName, MAX_JOYSTRING,1);
if(SUCCEEDED(hres))
{
//write the name, only MAX_SIZE_SNAME characters
hres = RIFF_Write(hmmio, lpDiFileEf->szFriendlyName, MAX_SIZE_SNAME);
}
}
if(SUCCEEDED(hres))
{
hres = (peff && IsBadReadPtr(peff, cbX(DIEFFECT_DX5))) ? E_POINTER : S_OK;
if(SUCCEEDED(hres))
{
hres = (peff && IsBadReadPtr(peff, peff->dwSize)) ? E_POINTER : S_OK;
}
if(SUCCEEDED(hres))
{
//write the effect structure
#ifdef _M_IA64
DIEFFECT_FILE32 eff32;
ZeroMemory(&eff32,sizeof(eff32));
eff32.dwSize=sizeof(eff32);
eff32.dwFlags=peff->dwFlags;
eff32.dwDuration=peff->dwDuration;
eff32.dwSamplePeriod=peff->dwSamplePeriod;
eff32.dwGain=peff->dwGain;
eff32.dwTriggerButton=peff->dwTriggerButton;
eff32.dwTriggerRepeatInterval=peff->dwTriggerRepeatInterval;
eff32.cAxes=peff->cAxes;
eff32.cbTypeSpecificParams=peff->cbTypeSpecificParams;
eff32.lpvTypeSpecificParams=(DWORD)(DWORD_PTR)peff->lpvTypeSpecificParams;
eff32.dwStartDelay=peff->dwStartDelay;
hres = RIFF_Write(hmmio, &eff32, eff32.dwSize);
#else /*_M_IA64*/
hres = RIFF_Write(hmmio, peff, peff->dwSize);
#endif /*_M_IA64*/
}
}
//restore the ptrs
if (rgdwAxes != NULL)
{
peff->rgdwAxes = rgdwAxes;
}
if (rglDirection != NULL)
{
peff->rglDirection = rglDirection;
}
if (lpEnvelope != NULL)
{
peff->lpEnvelope = lpEnvelope;
}
if (lpvTypeSpecPar != NULL)
{
peff->lpvTypeSpecificParams = lpvTypeSpecPar;
}
if(SUCCEEDED(hres))
{
// write the Effect GUID
hres = RIFF_Write(hmmio, &lpDiFileEf->GuidEffect, sizeof(GUID));
}
//write 1 as the repeat count
if(SUCCEEDED(hres))
{
UINT nRepeatCount = 1;
hres = RIFF_Write(hmmio, &nRepeatCount, sizeof(DWORD));
}
if(SUCCEEDED(hres) && rgdwAxes )
{
hres = (IsBadReadPtr(rgdwAxes, (*rgdwAxes)*cbX(peff->cAxes))) ? E_POINTER : S_OK;
if(SUCCEEDED(hres))
{
// create the data CHUNK
mmckinfoDataCHUNK.ckid = FCC_DATA_CHUNK;
hres = RIFF_CreateChunk(hmmio, &mmckinfoDataCHUNK, 0);
//write the axes
if(SUCCEEDED(hres))
{
hres = RIFF_Write(hmmio, rgdwAxes, sizeof(*rgdwAxes)*(peff->cAxes));
hres = RIFF_Ascend(hmmio, &mmckinfoDataCHUNK);
}
}
}
if(SUCCEEDED(hres) && rglDirection)
{
hres = (IsBadReadPtr(rglDirection, cbX(*rglDirection)*(peff->cAxes))) ? E_POINTER : S_OK;
if(SUCCEEDED(hres))
{
// create the data CHUNK
mmckinfoDataCHUNK.ckid = FCC_DATA_CHUNK;
hres = RIFF_CreateChunk(hmmio, &mmckinfoDataCHUNK, 0);
if(SUCCEEDED(hres))
{
//write the direction
hres = RIFF_Write(hmmio, rglDirection, sizeof(*rglDirection)*(peff->cAxes));
hres = RIFF_Ascend(hmmio, &mmckinfoDataCHUNK);
}
}
}
//write the envelope, if one is present
if(SUCCEEDED(hres) &&
(lpEnvelope != NULL) )
{
hres = (IsBadReadPtr(lpEnvelope, cbX(*lpEnvelope))) ? E_POINTER : S_OK;
if(SUCCEEDED(hres))
{
// create the data CHUNK
mmckinfoDataCHUNK.ckid = FCC_DATA_CHUNK;
hres = RIFF_CreateChunk(hmmio, &mmckinfoDataCHUNK, 0);
//write the envelope
if(SUCCEEDED(hres))
{
hres = RIFF_Write(hmmio, lpEnvelope, lpEnvelope->dwSize);
hres = RIFF_Ascend(hmmio, &mmckinfoDataCHUNK);
}
}
}
//write the type-specific
if(SUCCEEDED(hres) &&
(peff->cbTypeSpecificParams > 0) &&
(peff->lpvTypeSpecificParams != NULL) )
{
hres = (IsBadReadPtr(lpvTypeSpecPar, peff->cbTypeSpecificParams)) ? E_POINTER : S_OK;
if(SUCCEEDED(hres))
{
// create the data CHUNK
mmckinfoDataCHUNK.ckid = FCC_DATA_CHUNK;
hres = RIFF_CreateChunk(hmmio, &mmckinfoDataCHUNK, 0);
//write the params
if(SUCCEEDED(hres))
{
hres = RIFF_Write(hmmio, lpvTypeSpecPar, peff->cbTypeSpecificParams);
hres = RIFF_Ascend(hmmio, &mmckinfoDataCHUNK);
}
}
}
if(SUCCEEDED(hres))
{
// ascend the effect chunk
hres = RIFF_Ascend(hmmio, &mmckinfoEffectLIST);
}
ExitOleProc();
return hres;
}