source-engine/public/tier2/riff.h

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $Workfile:     $
// $Date:         $
//
//-----------------------------------------------------------------------------
// $Log: $
//
// $NoKeywords: $
//=============================================================================//

#ifndef RIFF_H
#define RIFF_H
#pragma once

#include "commonmacros.h"


//-----------------------------------------------------------------------------
// Purpose: This is a simple abstraction that the RIFF classes use to read from
//			files/memory
//-----------------------------------------------------------------------------
class IFileReadBinary
{
public:
	virtual intp open( const char *pFileName ) = 0;
	virtual int read( void *pOutput, int size, intp file ) = 0;
	virtual void close( intp file ) = 0;
	virtual void seek( intp file, int pos ) = 0;
	virtual unsigned int tell( intp file ) = 0;
	virtual unsigned int size( intp file ) = 0;
};


//-----------------------------------------------------------------------------
// Purpose: Used to read/parse a RIFF format file
//-----------------------------------------------------------------------------
class InFileRIFF
{
public:
	InFileRIFF( const char *pFileName, IFileReadBinary &io );
	~InFileRIFF( void );

	unsigned int RIFFName( void ) { return m_riffName; }
	unsigned int RIFFSize( void ) { return m_riffSize; }

	int		ReadInt( void );
	int		ReadData( void *pOutput, int dataSize );
	int		PositionGet( void );
	void	PositionSet( int position );
	bool	IsValid( void ) { return m_file != 0; }

private:
	const InFileRIFF & operator=( const InFileRIFF & );

	IFileReadBinary		&m_io;
	intp				m_file;
	unsigned int		m_riffName;
	unsigned int		m_riffSize;
};


//-----------------------------------------------------------------------------
// Purpose: Used to iterate over an InFileRIFF
//-----------------------------------------------------------------------------
class IterateRIFF
{
public:
	IterateRIFF( InFileRIFF &riff, int size );
	IterateRIFF( IterateRIFF &parent );

	bool			ChunkAvailable( void );
	bool			ChunkNext( void );

	unsigned int	ChunkName( void );
	unsigned int	ChunkSize( void );
	int				ChunkRead( void *pOutput );
	int				ChunkReadPartial( void *pOutput, int dataSize );
	int				ChunkReadInt( void );
	int				ChunkFilePosition( void ) { return m_chunkPosition; }

private:
	const IterateRIFF & operator=( const IterateRIFF & );

	void	ChunkSetup( void );
	void	ChunkClear( void );

	InFileRIFF			&m_riff;
	int					m_start;
	int					m_size;

	unsigned int		m_chunkName;
	int					m_chunkSize;
	int					m_chunkPosition;
};

class IFileWriteBinary
{
public:
	virtual int create( const char *pFileName ) = 0;
	virtual int write( void *pData, int size, int file ) = 0;
	virtual void close( int file ) = 0;
	virtual void seek( int file, int pos ) = 0;
	virtual unsigned int tell( int file ) = 0;
};
//-----------------------------------------------------------------------------
// Purpose: Used to write a RIFF format file
//-----------------------------------------------------------------------------
class OutFileRIFF
{
public:
	OutFileRIFF( const char *pFileName, IFileWriteBinary &io );
	~OutFileRIFF( void );

	bool	WriteInt( int number );
	bool 	WriteData( void *pOutput, int dataSize );
	int		PositionGet( void );
	void	PositionSet( int position );
	bool	IsValid( void ) { return m_file != 0; }
	
	void    HasLISETData( int position );

private:
	const OutFileRIFF & operator=( const OutFileRIFF & );

	IFileWriteBinary	&m_io;
	intp				m_file;
	unsigned int		m_riffName;
	unsigned int		m_riffSize;
	unsigned int		m_nNamePos;

	// hack to make liset work correctly
	bool				m_bUseIncorrectLISETLength;
	int					m_nLISETSize;


};

//-----------------------------------------------------------------------------
// Purpose: Used to iterate over an InFileRIFF
//-----------------------------------------------------------------------------
class IterateOutputRIFF
{
public:
	IterateOutputRIFF( OutFileRIFF &riff );
	IterateOutputRIFF( IterateOutputRIFF &parent );

	void			ChunkStart( unsigned int chunkname );
	void			ChunkFinish( void );

	void			ChunkWrite( unsigned int chunkname, void *pOutput, int size );
	void			ChunkWriteInt( int number );
	void			ChunkWriteData( void *pOutput, int size );

	int				ChunkFilePosition( void ) { return m_chunkPosition; }

	unsigned int	ChunkGetPosition( void );
	void			ChunkSetPosition( int position );

	void			CopyChunkData( IterateRIFF& input );

	void			SetLISETData( int position );

private:

	const IterateOutputRIFF & operator=( const IterateOutputRIFF & );

	OutFileRIFF			&m_riff;
	int					m_start;
	int					m_size;

	unsigned int		m_chunkName;
	int					m_chunkSize;
	int					m_chunkPosition;
	int					m_chunkStart;
};

#define RIFF_ID					MAKEID('R','I','F','F')
#define RIFF_WAVE				MAKEID('W','A','V','E')
#define WAVE_FMT				MAKEID('f','m','t',' ')
#define WAVE_DATA				MAKEID('d','a','t','a')
#define WAVE_FACT				MAKEID('f','a','c','t')
#define WAVE_CUE				MAKEID('c','u','e',' ')
#define WAVE_SAMPLER			MAKEID('s','m','p','l')
#define WAVE_VALVEDATA			MAKEID('V','D','A','T')
#define WAVE_PADD				MAKEID('P','A','D','D')
#define WAVE_LIST				MAKEID('L','I','S','T') 

#ifndef WAVE_FORMAT_PCM
#define WAVE_FORMAT_PCM			0x0001
#endif
#ifndef WAVE_FORMAT_ADPCM
#define WAVE_FORMAT_ADPCM		0x0002
#endif
#define WAVE_FORMAT_XBOX_ADPCM	0x0069
#ifndef WAVE_FORMAT_XMA
#define WAVE_FORMAT_XMA			0x0165
#endif

#endif // RIFF_H