1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
|
//========= 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 int open( const char *pFileName ) = 0;
virtual int read( void *pOutput, 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;
virtual unsigned int size( int 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;
int 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;
int 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
|