/[svn]/libgig/trunk/src/RIFF.h
ViewVC logotype

Contents of /libgig/trunk/src/RIFF.h

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2543 - (show annotations) (download) (as text)
Sat May 10 02:06:58 2014 UTC (9 years, 10 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 16173 byte(s)
* Initial support for sample based instruments in KORG's file format (.KMP
  and .KSF files) -> Korg.h, Korg.cpp.
* Added new command line tool "korgdump" (and a man page for it).
* Added new command line tool "korg2gig" (and a man page for it), for
  converting KORG sounds to Giga format.
* riftree tool: Added more command line options for being able to also dump
  other kind of file formats similar but not equal to the RIFF format.
* gig.h/.cpp: Added new method File::GetGroup(String name) for retrieving
  group by name.
* RIFF.h/.cpp: Added support for loading RIFF-like files with a bit
  different layout than "real" RIFF files (used for KORG format support).
* RIFF.h/.cpp: Added new method Chunk::GetFile().
* RIFF.h/.cpp: Added new method Chunk::GetLayout().
* Bumped version (3.3.0.svn9).

1 /***************************************************************************
2 * *
3 * libgig - C++ cross-platform Gigasampler format file access library *
4 * *
5 * Copyright (C) 2003-2014 by Christian Schoenebeck *
6 * <cuse@users.sourceforge.net> *
7 * *
8 * This library is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
12 * *
13 * This library is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
17 * *
18 * You should have received a copy of the GNU General Public License *
19 * along with this library; if not, write to the Free Software *
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, *
21 * MA 02111-1307 USA *
22 ***************************************************************************/
23
24 #ifndef __RIFF_H__
25 #define __RIFF_H__
26
27 #ifdef WIN32
28 # define POSIX 0
29 #endif
30
31 #ifndef POSIX
32 # define POSIX 1
33 #endif
34
35 #ifndef DEBUG
36 # define DEBUG 0
37 #endif
38
39 #include <string>
40 #include <list>
41 #include <map>
42 #include <iostream>
43
44 #ifdef HAVE_CONFIG_H
45 # include <config.h>
46 #endif
47
48 #if POSIX
49 # include <sys/types.h>
50 # include <sys/stat.h>
51 # include <fcntl.h>
52 # include <unistd.h>
53 #endif // POSIX
54
55 #ifdef _MSC_VER
56 // Visual C++ 2008 doesn't have stdint.h
57 typedef __int8 int8_t;
58 typedef __int16 int16_t;
59 typedef __int32 int32_t;
60 typedef __int64 int64_t;
61 typedef unsigned __int8 uint8_t;
62 typedef unsigned __int16 uint16_t;
63 typedef unsigned __int32 uint32_t;
64 typedef unsigned __int64 uint64_t;
65 #else
66 #include <stdint.h>
67 #endif
68
69 #ifdef WIN32
70 # include <windows.h>
71 typedef unsigned int uint;
72 #endif // WIN32
73
74 #include <stdio.h>
75
76 #if WORDS_BIGENDIAN
77 # define CHUNK_ID_RIFF 0x52494646
78 # define CHUNK_ID_RIFX 0x52494658
79 # define CHUNK_ID_LIST 0x4C495354
80
81 # define LIST_TYPE_INFO 0x494E464F
82 # define CHUNK_ID_ICMT 0x49434D54
83 # define CHUNK_ID_ICOP 0x49434F50
84 # define CHUNK_ID_ICRD 0x49435244
85 # define CHUNK_ID_IENG 0x49454E47
86 # define CHUNK_ID_INAM 0x494E414D
87 # define CHUNK_ID_IPRD 0x49505244
88 # define CHUNK_ID_ISFT 0x49534654
89
90 # define CHUNK_ID_SMPL 0x736D706C
91
92 #else // little endian
93 # define CHUNK_ID_RIFF 0x46464952
94 # define CHUNK_ID_RIFX 0x58464952
95 # define CHUNK_ID_LIST 0x5453494C
96
97 # define LIST_TYPE_INFO 0x4F464E49
98 # define CHUNK_ID_ICMT 0x544D4349
99 # define CHUNK_ID_ICOP 0x504F4349
100 # define CHUNK_ID_ICRD 0x44524349
101 # define CHUNK_ID_IENG 0x474E4549
102 # define CHUNK_ID_INAM 0x4D414E49
103 # define CHUNK_ID_IPRD 0x44525049
104 # define CHUNK_ID_ISFT 0x54465349
105
106 # define CHUNK_ID_SMPL 0x6C706D73
107
108 #endif // WORDS_BIGENDIAN
109
110 #define CHUNK_HEADER_SIZE 8
111 #define LIST_HEADER_SIZE 12
112 #define RIFF_HEADER_SIZE 12
113
114
115 /**
116 * @brief RIFF specific classes and definitions
117 *
118 * The Resource Interchange File Format (RIFF) is a generic tree-structured
119 * meta-format which stores data in so called "chunks". It can be compared
120 * to XML, but in contrast to XML, RIFF is entirely binary encoded, that is
121 * not ASCII based. RIFF is used as basis for many file formats like AVI,
122 * WAV, DLS and of course the Gigasampler file format. ;-)
123 *
124 * RIFF chunks can be seen as containers for data. There are two distinct
125 * types of chunks:
126 *
127 * - @e ordinary @e chunks are the leafs of the data tree which encapsulate
128 * the actual data of the file (i.e. the sample data of a .wav file)
129 *
130 * - @e list @e chunks are the nodes of the data tree which hold an
131 * arbitrary amount of subchunks (can be both, list chunks and/or ordinary
132 * chunks)
133 */
134 namespace RIFF {
135
136 /* just symbol prototyping */
137 class Chunk;
138 class List;
139 class File;
140
141 typedef std::string String;
142
143 /** Whether file stream is open in read or in read/write mode. */
144 typedef enum {
145 stream_mode_read = 0,
146 stream_mode_read_write = 1,
147 stream_mode_closed = 2
148 } stream_mode_t;
149
150 /** Current state of the file stream. */
151 typedef enum {
152 stream_ready = 0,
153 stream_end_reached = 1,
154 stream_closed = 2
155 } stream_state_t;
156
157 /** File stream position dependent to these relations. */
158 typedef enum {
159 stream_start = 0,
160 stream_curpos = 1,
161 stream_backward = 2,
162 stream_end = 3
163 } stream_whence_t;
164
165 /** Alignment of data bytes in memory (system dependant). */
166 typedef enum {
167 endian_little = 0,
168 endian_big = 1,
169 endian_native = 2
170 } endian_t;
171
172 /** General chunk structure of a file. */
173 enum layout_t {
174 layout_standard = 0, ///< Standard RIFF file layout: First chunk in file is a List chunk which contains all other chunks and there are no chunks outside the scope of that very first (List) chunk.
175 layout_flat = 1 ///< Not a "real" RIFF file: First chunk in file is an ordinary data chunk, not a List chunk, and there might be other chunks after that first chunk.
176 };
177
178 /** @brief Ordinary RIFF Chunk
179 *
180 * Provides convenient methods to access data of ordinary RIFF chunks
181 * in general.
182 */
183 class Chunk {
184 public:
185 Chunk(File* pFile, unsigned long StartPos, List* Parent);
186 String GetChunkIDString();
187 uint32_t GetChunkID() { return ChunkID; } ///< Chunk ID in unsigned integer representation.
188 File* GetFile() { return pFile; } ///< Returns pointer to the chunk's File object.
189 List* GetParent() { return pParent; } ///< Returns pointer to the chunk's parent list chunk.
190 unsigned long GetSize() const { return CurrentChunkSize; } ///< Chunk size in bytes (without header, thus the chunk data body)
191 unsigned long GetNewSize() { return NewChunkSize; } ///< New chunk size if it was modified with Resize().
192 unsigned long GetPos() { return ulPos; } ///< Position within the chunk data body
193 unsigned long GetFilePos() { return ulStartPos + ulPos; } ///< Current, actual offset in file.
194 unsigned long SetPos(unsigned long Where, stream_whence_t Whence = stream_start);
195 unsigned long RemainingBytes();
196 stream_state_t GetState();
197 unsigned long Read(void* pData, unsigned long WordCount, unsigned long WordSize);
198 unsigned long ReadInt8(int8_t* pData, unsigned long WordCount = 1);
199 unsigned long ReadUint8(uint8_t* pData, unsigned long WordCount = 1);
200 unsigned long ReadInt16(int16_t* pData, unsigned long WordCount = 1);
201 unsigned long ReadUint16(uint16_t* pData, unsigned long WordCount = 1);
202 unsigned long ReadInt32(int32_t* pData, unsigned long WordCount = 1);
203 unsigned long ReadUint32(uint32_t* pData, unsigned long WordCount = 1);
204 int8_t ReadInt8();
205 uint8_t ReadUint8();
206 int16_t ReadInt16();
207 uint16_t ReadUint16();
208 int32_t ReadInt32();
209 uint32_t ReadUint32();
210 void ReadString(String& s, int size);
211 unsigned long Write(void* pData, unsigned long WordCount, unsigned long WordSize);
212 unsigned long WriteInt8(int8_t* pData, unsigned long WordCount = 1);
213 unsigned long WriteUint8(uint8_t* pData, unsigned long WordCount = 1);
214 unsigned long WriteInt16(int16_t* pData, unsigned long WordCount = 1);
215 unsigned long WriteUint16(uint16_t* pData, unsigned long WordCount = 1);
216 unsigned long WriteInt32(int32_t* pData, unsigned long WordCount = 1);
217 unsigned long WriteUint32(uint32_t* pData, unsigned long WordCount = 1);
218 void* LoadChunkData();
219 void ReleaseChunkData();
220 void Resize(int iNewSize);
221 virtual ~Chunk();
222 protected:
223 uint32_t ChunkID;
224 uint32_t CurrentChunkSize; /* in bytes */
225 uint32_t NewChunkSize; /* in bytes (if chunk was scheduled to be resized) */
226 List* pParent;
227 File* pFile;
228 unsigned long ulStartPos; /* actual position in file where chunk (without header) starts */
229 unsigned long ulPos; /* # of bytes from ulStartPos */
230 uint8_t* pChunkData;
231 unsigned long ulChunkDataSize;
232
233 Chunk(File* pFile);
234 Chunk(File* pFile, List* pParent, uint32_t uiChunkID, uint uiBodySize);
235 void ReadHeader(unsigned long fPos);
236 void WriteHeader(unsigned long fPos);
237 unsigned long ReadSceptical(void* pData, unsigned long WordCount, unsigned long WordSize);
238 inline void swapBytes_16(void* Word) {
239 uint8_t byteCache = *((uint8_t*) Word);
240 *((uint8_t*) Word) = *((uint8_t*) Word + 1);
241 *((uint8_t*) Word + 1) = byteCache;
242 }
243 inline void swapBytes_32(void* Word) {
244 uint8_t byteCache = *((uint8_t*) Word);
245 *((uint8_t*) Word) = *((uint8_t*) Word + 3);
246 *((uint8_t*) Word + 3) = byteCache;
247 byteCache = *((uint8_t*) Word + 1);
248 *((uint8_t*) Word + 1) = *((uint8_t*) Word + 2);
249 *((uint8_t*) Word + 2) = byteCache;
250 }
251 inline void swapBytes(void* Word, unsigned long WordSize) {
252 uint8_t byteCache;
253 unsigned long lo = 0, hi = WordSize - 1;
254 for (; lo < hi; hi--, lo++) {
255 byteCache = *((uint8_t*) Word + lo);
256 *((uint8_t*) Word + lo) = *((uint8_t*) Word + hi);
257 *((uint8_t*) Word + hi) = byteCache;
258 }
259 }
260 inline String convertToString(uint32_t word) {
261 String result;
262 for (int i = 0; i < 4; i++) {
263 uint8_t byte = *((uint8_t*)(&word) + i);
264 char c = byte;
265 result += c;
266 }
267 return result;
268 }
269 virtual unsigned long WriteChunk(unsigned long ulWritePos, unsigned long ulCurrentDataOffset);
270 virtual void __resetPos(); ///< Sets Chunk's read/write position to zero.
271
272 friend class List;
273 };
274
275 /** @brief RIFF List Chunk
276 *
277 * Provides convenient methods to access data of RIFF list chunks and
278 * their subchunks.
279 */
280 class List : public Chunk {
281 public:
282 List(File* pFile, unsigned long StartPos, List* Parent);
283 String GetListTypeString();
284 uint32_t GetListType() { return ListType; } ///< Returns unsigned integer representation of the list's ID
285 Chunk* GetSubChunk(uint32_t ChunkID);
286 List* GetSubList(uint32_t ListType);
287 Chunk* GetFirstSubChunk();
288 Chunk* GetNextSubChunk();
289 List* GetFirstSubList();
290 List* GetNextSubList();
291 unsigned int CountSubChunks();
292 unsigned int CountSubChunks(uint32_t ChunkID);
293 unsigned int CountSubLists();
294 unsigned int CountSubLists(uint32_t ListType);
295 Chunk* AddSubChunk(uint32_t uiChunkID, uint uiBodySize);
296 List* AddSubList(uint32_t uiListType);
297 void DeleteSubChunk(Chunk* pSubChunk);
298 void MoveSubChunk(Chunk* pSrc, Chunk* pDst);
299 virtual ~List();
300 protected:
301 typedef std::map<uint32_t, RIFF::Chunk*> ChunkMap;
302 typedef std::list<Chunk*> ChunkList;
303
304 uint32_t ListType;
305 ChunkList* pSubChunks;
306 ChunkMap* pSubChunksMap;
307 ChunkList::iterator ChunksIterator;
308 ChunkList::iterator ListIterator;
309
310 List(File* pFile);
311 List(File* pFile, List* pParent, uint32_t uiListID);
312 void ReadHeader(unsigned long fPos);
313 void WriteHeader(unsigned long fPos);
314 void LoadSubChunks();
315 void LoadSubChunksRecursively();
316 virtual unsigned long WriteChunk(unsigned long ulWritePos, unsigned long ulCurrentDataOffset);
317 virtual void __resetPos(); ///< Sets List Chunk's read/write position to zero and causes all sub chunks to do the same.
318 void DeleteChunkList();
319 };
320
321 /** @brief RIFF File
322 *
323 * Handles arbitrary RIFF files and provides together with its base
324 * classes convenient methods to walk through, read and modify the
325 * file's RIFF tree.
326 */
327 class File : public List {
328 public:
329 File(uint32_t FileType);
330 File(const String& path);
331 File(const String& path, uint32_t FileType, endian_t Endian, layout_t layout);
332 stream_mode_t GetMode();
333 bool SetMode(stream_mode_t NewMode);
334 void SetByteOrder(endian_t Endian);
335 String GetFileName();
336 void SetFileName(const String& path);
337 bool IsNew() const;
338 layout_t GetLayout() const;
339 virtual void Save();
340 virtual void Save(const String& path);
341 virtual ~File();
342 protected:
343 #if POSIX
344 int hFileRead; ///< handle / descriptor for reading from file
345 int hFileWrite; ///< handle / descriptor for writing to (some) file
346 #elif defined(WIN32)
347 HANDLE hFileRead; ///< handle / descriptor for reading from file
348 HANDLE hFileWrite; ///< handle / descriptor for writing to (some) file
349 #else
350 FILE* hFileRead; ///< handle / descriptor for reading from file
351 FILE* hFileWrite; ///< handle / descriptor for writing to (some) file
352 #endif // POSIX
353 String Filename;
354 bool bEndianNative;
355 bool bIsNewFile;
356 layout_t Layout; ///< An ordinary RIFF file is always set to layout_standard.
357
358 void LogAsResized(Chunk* pResizedChunk);
359 void UnlogResized(Chunk* pResizedChunk);
360 friend class Chunk;
361 friend class List;
362 private:
363 stream_mode_t Mode;
364 ChunkList ResizedChunks; ///< All chunks which have been resized (enlarged / shortened).
365
366 void __openExistingFile(const String& path, uint32_t* FileType = NULL);
367 unsigned long GetFileSize();
368 void ResizeFile(unsigned long ulNewSize);
369 #if POSIX
370 unsigned long __GetFileSize(int hFile);
371 #elif defined(WIN32)
372 unsigned long __GetFileSize(HANDLE hFile);
373 #else
374 unsigned long __GetFileSize(FILE* hFile);
375 #endif
376 void Cleanup();
377 };
378
379 /**
380 * Will be thrown whenever an error occurs while handling a RIFF file.
381 */
382 class Exception {
383 public:
384 String Message;
385
386 Exception(String Message) { Exception::Message = Message; }
387 void PrintMessage();
388 virtual ~Exception() {}
389 };
390
391 String libraryName();
392 String libraryVersion();
393
394 } // namespace RIFF
395 #endif // __RIFF_H__

  ViewVC Help
Powered by ViewVC