//+-------------------------------------------------------------------------
//
// Microsoft Windows
//
// Copyright (c) 1998-1998 Microsoft Corporation
//
// File: fileio.cpp
//
//--------------------------------------------------------------------------
// FileIO.cpp
//
#include "aariff.h"
STDAPI AllocFileStream(LPCSTR szFileName, DWORD dwDesiredAccess, IStream **ppstream)
{
HANDLE hfile; // handle to open file
CFileStream * pstream; // IStream implementation
// in case of error...
*ppstream = NULL;
// open the file
if( dwDesiredAccess == GENERIC_READ )
{
hfile = CreateFile( szFileName, dwDesiredAccess, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
}
else if( dwDesiredAccess == GENERIC_WRITE )
{
hfile = CreateFile( szFileName, dwDesiredAccess, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL );
}
else
{
return E_INVALIDARG;
}
if( hfile == INVALID_HANDLE_VALUE )
{
//DisplayDebug( 5, "File open error: Can't open \"%s\", error code %d", szFileName, GetLastError() );
return E_FAIL; // to do: real error code
}
// create the Windows object
if ((pstream = new CFileStream(hfile)) == NULL)
return E_OUTOFMEMORY;
// return an IStream pointer
*ppstream = (IStream *) pstream;
return S_OK;
}
STDAPI AllocRIFFStream( IStream* pStream, IAARIFFStream** ppRiff )
{
if( ( *ppRiff = (IAARIFFStream*) new CRIFFStream( pStream ) ) == NULL )
{
return E_OUTOFMEMORY;
}
return S_OK;
}
/* MyRead, MyWrite, MySeek
*
* These are functionally identical to mmioRead, mmioWrite, and mmioSeek,
* except for the absence of the HMMIO parameter.
*/
long CRIFFStream::MyRead(void *pv, long cb)
{
ULONG cbRead;
if (FAILED(m_pStream->Read(pv, cb, &cbRead)))
return -1;
return cbRead;
}
long CRIFFStream::MyWrite(const void *pv, long cb)
{
ULONG cbWritten;
if (FAILED(m_pStream->Write(pv, cb, &cbWritten)))
return -1;
return cbWritten;
}
long CRIFFStream::MySeek(long lOffset, int iOrigin)
{
LARGE_INTEGER dlibSeekTo;
ULARGE_INTEGER dlibNewPos;
dlibSeekTo.HighPart = 0;
dlibSeekTo.LowPart = lOffset;
if (FAILED(m_pStream->Seek(dlibSeekTo, iOrigin, &dlibNewPos)))
return -1;
return dlibNewPos.LowPart;
}
UINT CRIFFStream::Descend(LPMMCKINFO lpck, LPMMCKINFO lpckParent, UINT wFlags)
{
FOURCC ckidFind; // chunk ID to find (or NULL)
FOURCC fccTypeFind; // form/list type to find (or NULL)
/* figure out what chunk id and form/list type to search for */
if (wFlags & MMIO_FINDCHUNK)
ckidFind = lpck->ckid, fccTypeFind = NULL;
else
if (wFlags & MMIO_FINDRIFF)
ckidFind = FOURCC_RIFF, fccTypeFind = lpck->fccType;
else
if (wFlags & MMIO_FINDLIST)
ckidFind = FOURCC_LIST, fccTypeFind = lpck->fccType;
else
ckidFind = fccTypeFind = NULL;
lpck->dwFlags = 0L;
for(;;)
{
UINT w;
/* read the chunk header */
if (MyRead(lpck, 2 * sizeof(DWORD)) !=
2 * sizeof(DWORD))
return MMIOERR_CHUNKNOTFOUND;
FixBytes( FBT_LONG, &lpck->cksize );
/* store the offset of the data part of the chunk */
if ((lpck->dwDataOffset = MySeek(0L, SEEK_CUR)) == -1)
return MMIOERR_CANNOTSEEK;
/* see if the chunk is within the parent chunk (if given) */
if ((lpckParent != NULL) &&
(lpck->dwDataOffset - 8L >=
lpckParent->dwDataOffset + lpckParent->cksize))
return MMIOERR_CHUNKNOTFOUND;
/* if the chunk if a 'RIFF' or 'LIST' chunk, read the
* form type or list type
*/
if ((lpck->ckid == FOURCC_RIFF) || (lpck->ckid == FOURCC_LIST))
{
if (MyRead(&lpck->fccType,
sizeof(DWORD)) != sizeof(DWORD))
return MMIOERR_CHUNKNOTFOUND;
}
else
lpck->fccType = NULL;
/* if this is the chunk we're looking for, stop looking */
if ( ((ckidFind == NULL) || (ckidFind == lpck->ckid)) &&
((fccTypeFind == NULL) || (fccTypeFind == lpck->fccType)) )
break;
/* ascend out of the chunk and try again */
if ((w = Ascend(lpck, 0)) != 0)
return w;
}
return 0;
}
UINT CRIFFStream::Ascend(LPMMCKINFO lpck, UINT /*wFlags*/)
{
if (lpck->dwFlags & MMIO_DIRTY)
{
/* <lpck> refers to a chunk created by CreateChunk();
* check that the chunk size that was written when
* CreateChunk() was called is the real chunk size;
* if not, fix it
*/
LONG lOffset; // current offset in file
LONG lActualSize; // actual size of chunk data
if ((lOffset = MySeek(0L, SEEK_CUR)) == -1)
return MMIOERR_CANNOTSEEK;
if ((lActualSize = lOffset - lpck->dwDataOffset) < 0)
return MMIOERR_CANNOTWRITE;
if (LOWORD(lActualSize) & 1)
{
/* chunk size is odd -- write a null pad byte */
if (MyWrite("\0", 1) != 1)
return MMIOERR_CANNOTWRITE;
}
if (lpck->cksize == (DWORD)lActualSize)
return 0;
/* fix the chunk header */
lpck->cksize = lActualSize;
if (MySeek(lpck->dwDataOffset - sizeof(DWORD), SEEK_SET) == -1)
return MMIOERR_CANNOTSEEK;
FixBytes( FBT_LONG, &lpck->cksize );
if (MyWrite(&lpck->cksize, sizeof(DWORD)) != sizeof(DWORD)) {
FixBytes( FBT_LONG, &lpck->cksize );
return MMIOERR_CANNOTWRITE;
}
FixBytes( FBT_LONG, &lpck->cksize );
}
/* seek to the end of the chunk, past the null pad byte
* (which is only there if chunk size is odd)
*/
if (MySeek(lpck->dwDataOffset + lpck->cksize + (lpck->cksize & 1L),
SEEK_SET) == -1)
return MMIOERR_CANNOTSEEK;
return 0;
}
UINT CRIFFStream::CreateChunk(LPMMCKINFO lpck, UINT wFlags)
{
int iBytes; // bytes to write
LONG lOffset; // current offset in file
/* store the offset of the data part of the chunk */
if ((lOffset = MySeek(0L, SEEK_CUR)) == -1)
return MMIOERR_CANNOTSEEK;
lpck->dwDataOffset = lOffset + 2 * sizeof(DWORD);
/* figure out if a form/list type needs to be written */
if (wFlags & MMIO_CREATERIFF)
lpck->ckid = FOURCC_RIFF, iBytes = 3 * sizeof(DWORD);
else
if (wFlags & MMIO_CREATELIST)
lpck->ckid = FOURCC_LIST, iBytes = 3 * sizeof(DWORD);
else
iBytes = 2 * sizeof(DWORD);
/* write the chunk header */
FixBytes( FBT_MMCKINFO, lpck );
if (MyWrite(lpck, (LONG) iBytes) != (LONG) iBytes) {
FixBytes( FBT_MMCKINFO, lpck );
return MMIOERR_CANNOTWRITE;
}
FixBytes( FBT_MMCKINFO, lpck );
lpck->dwFlags = MMIO_DIRTY;
return 0;
}