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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1330 - (hide annotations) (download) (as text)
Sun Sep 9 10:36:23 2007 UTC (16 years, 6 months ago) by persson
File MIME type: text/x-c++hdr
File size: 14134 byte(s)
* the configure script can now be used in Windows with MSYS

1 schoenebeck 2 /***************************************************************************
2     * *
3 schoenebeck 933 * libgig - C++ cross-platform Gigasampler format file access library *
4 schoenebeck 2 * *
5 schoenebeck 1050 * Copyright (C) 2003-2007 by Christian Schoenebeck *
6 schoenebeck 384 * <cuse@users.sourceforge.net> *
7 schoenebeck 2 * *
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 schoenebeck 1050 #ifdef WIN32
28     # define POSIX 0
29     #endif
30 schoenebeck 2
31 schoenebeck 1050 #ifndef POSIX
32     # define POSIX 1
33     #endif
34    
35     #ifndef DEBUG
36     # define DEBUG 0
37     #endif
38    
39 schoenebeck 2 #include <string>
40     #include <list>
41     #include <map>
42     #include <iostream>
43    
44 schoenebeck 11 #ifdef HAVE_CONFIG_H
45     # include <config.h>
46     #endif
47    
48 schoenebeck 2 #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     #include <stdint.h>
56    
57 schoenebeck 1050 #ifdef WIN32
58     # include <windows.h>
59     typedef unsigned int uint;
60     #endif // WIN32
61 schoenebeck 2
62     #include <stdio.h>
63    
64     #if WORDS_BIGENDIAN
65     # define CHUNK_ID_RIFF 0x52494646
66     # define CHUNK_ID_RIFX 0x52494658
67     # define CHUNK_ID_LIST 0x4C495354
68     #else // little endian
69     # define CHUNK_ID_RIFF 0x46464952
70     # define CHUNK_ID_RIFX 0x58464952
71     # define CHUNK_ID_LIST 0x5453494C
72     #endif // WORDS_BIGENDIAN
73    
74     #define CHUNK_HEADER_SIZE 8
75     #define LIST_HEADER_SIZE 12
76     #define RIFF_HEADER_SIZE 12
77    
78    
79 schoenebeck 1193 /**
80     * @brief RIFF specific classes and definitions
81     *
82     * The Resource Interchange File Format (RIFF) is a generic tree-structured
83     * meta-format which stores data in so called "chunks". It can be compared
84     * to XML, but in contrast to XML, RIFF is entirely binary encoded, that is
85     * not ASCII based. RIFF is used as basis for many file formats like AVI,
86     * WAV, DLS and of course the Gigasampler file format. ;-)
87     *
88     * RIFF chunks can be seen as containers for data. There are two distinct
89     * types of chunks:
90     *
91     * - @e ordinary @e chunks are the leafs of the data tree which encapsulate
92     * the actual data of the file (i.e. the sample data of a .wav file)
93     *
94     * - @e list @e chunks are the nodes of the data tree which hold an
95     * arbitrary amount of subchunks (can be both, list chunks and/or ordinary
96     * chunks)
97     */
98 schoenebeck 2 namespace RIFF {
99    
100     /* just symbol prototyping */
101     class Chunk;
102     class List;
103 schoenebeck 780 class File;
104 schoenebeck 2
105     typedef std::string String;
106    
107 schoenebeck 780 /** Whether file stream is open in read or in read/write mode. */
108     typedef enum {
109 schoenebeck 798 stream_mode_read = 0,
110     stream_mode_read_write = 1,
111     stream_mode_closed = 2
112 schoenebeck 780 } stream_mode_t;
113    
114 schoenebeck 2 /** Current state of the file stream. */
115     typedef enum {
116     stream_ready = 0,
117     stream_end_reached = 1,
118     stream_closed = 2
119     } stream_state_t;
120    
121     /** File stream position dependent to these relations. */
122     typedef enum {
123     stream_start = 0,
124     stream_curpos = 1,
125     stream_backward = 2,
126     stream_end = 3
127     } stream_whence_t;
128    
129 schoenebeck 1193 /** Alignment of data bytes in memory (system dependant). */
130 persson 1183 typedef enum {
131     endian_little = 0,
132     endian_big = 1,
133     endian_native = 2
134     } endian_t;
135    
136 schoenebeck 1193 /** @brief Ordinary RIFF Chunk
137     *
138     * Provides convenient methods to access data of ordinary RIFF chunks
139     * in general.
140     */
141 schoenebeck 2 class Chunk {
142     public:
143 schoenebeck 780 Chunk(File* pFile, unsigned long StartPos, List* Parent);
144 schoenebeck 2 String GetChunkIDString();
145 schoenebeck 11 uint32_t GetChunkID() { return ChunkID; }; ///< Chunk ID in unsigned integer representation.
146     List* GetParent() { return pParent; }; ///< Returns pointer to the chunk's parent list chunk.
147 schoenebeck 780 unsigned long GetSize() { return CurrentChunkSize; }; ///< Chunk size in bytes (without header, thus the chunk data body)
148     unsigned long GetNewSize() { return NewChunkSize; }; ///< New chunk size if it was modified with Resize().
149 schoenebeck 11 unsigned long GetPos() { return ulPos; }; ///< Position within the chunk data body
150 schoenebeck 2 unsigned long GetFilePos() { return ulStartPos + ulPos; }; ///< Current, actual offset in file.
151     unsigned long SetPos(unsigned long Where, stream_whence_t Whence = stream_start);
152     unsigned long RemainingBytes();
153     stream_state_t GetState();
154     unsigned long Read(void* pData, unsigned long WordCount, unsigned long WordSize);
155     unsigned long ReadInt8(int8_t* pData, unsigned long WordCount = 1);
156     unsigned long ReadUint8(uint8_t* pData, unsigned long WordCount = 1);
157     unsigned long ReadInt16(int16_t* pData, unsigned long WordCount = 1);
158     unsigned long ReadUint16(uint16_t* pData, unsigned long WordCount = 1);
159     unsigned long ReadInt32(int32_t* pData, unsigned long WordCount = 1);
160     unsigned long ReadUint32(uint32_t* pData, unsigned long WordCount = 1);
161     int8_t ReadInt8();
162     uint8_t ReadUint8();
163     int16_t ReadInt16();
164     uint16_t ReadUint16();
165     int32_t ReadInt32();
166     uint32_t ReadUint32();
167 schoenebeck 780 unsigned long Write(void* pData, unsigned long WordCount, unsigned long WordSize);
168     unsigned long WriteInt8(int8_t* pData, unsigned long WordCount = 1);
169     unsigned long WriteUint8(uint8_t* pData, unsigned long WordCount = 1);
170     unsigned long WriteInt16(int16_t* pData, unsigned long WordCount = 1);
171     unsigned long WriteUint16(uint16_t* pData, unsigned long WordCount = 1);
172     unsigned long WriteInt32(int32_t* pData, unsigned long WordCount = 1);
173     unsigned long WriteUint32(uint32_t* pData, unsigned long WordCount = 1);
174     void* LoadChunkData();
175     void ReleaseChunkData();
176     void Resize(int iNewSize);
177 schoenebeck 384 virtual ~Chunk();
178 schoenebeck 2 protected:
179     uint32_t ChunkID;
180 schoenebeck 780 uint32_t CurrentChunkSize; /* in bytes */
181     uint32_t NewChunkSize; /* in bytes (if chunk was scheduled to be resized) */
182 schoenebeck 2 List* pParent;
183 schoenebeck 780 File* pFile;
184 schoenebeck 2 unsigned long ulStartPos; /* actual position in file where chunk (without header) starts */
185     unsigned long ulPos; /* # of bytes from ulStartPos */
186     uint8_t* pChunkData;
187 schoenebeck 800 unsigned long ulChunkDataSize;
188 schoenebeck 2
189 schoenebeck 780 Chunk(File* pFile);
190     Chunk(File* pFile, List* pParent, uint32_t uiChunkID, uint uiBodySize);
191 schoenebeck 2 void ReadHeader(unsigned long fPos);
192 schoenebeck 780 void WriteHeader(unsigned long fPos);
193 schoenebeck 2 unsigned long ReadSceptical(void* pData, unsigned long WordCount, unsigned long WordSize);
194     inline void swapBytes_16(void* Word) {
195     uint8_t byteCache = *((uint8_t*) Word);
196     *((uint8_t*) Word) = *((uint8_t*) Word + 1);
197     *((uint8_t*) Word + 1) = byteCache;
198     }
199     inline void swapBytes_32(void* Word) {
200     uint8_t byteCache = *((uint8_t*) Word);
201     *((uint8_t*) Word) = *((uint8_t*) Word + 3);
202     *((uint8_t*) Word + 3) = byteCache;
203     byteCache = *((uint8_t*) Word + 1);
204     *((uint8_t*) Word + 1) = *((uint8_t*) Word + 2);
205     *((uint8_t*) Word + 2) = byteCache;
206     }
207     inline void swapBytes(void* Word, unsigned long WordSize) {
208     uint8_t byteCache;
209     unsigned long lo = 0, hi = WordSize - 1;
210     for (; lo < hi; hi--, lo++) {
211     byteCache = *((uint8_t*) Word + lo);
212     *((uint8_t*) Word + lo) = *((uint8_t*) Word + hi);
213     *((uint8_t*) Word + hi) = byteCache;
214     }
215     }
216     inline String convertToString(uint32_t word) {
217     String result;
218     for (int i = 0; i < 4; i++) {
219     uint8_t byte = *((uint8_t*)(&word) + i);
220     char c = byte;
221     result += c;
222     }
223     return result;
224     }
225 schoenebeck 780 virtual unsigned long WriteChunk(unsigned long ulWritePos, unsigned long ulCurrentDataOffset);
226     virtual void __resetPos(); ///< Sets Chunk's read/write position to zero.
227    
228     friend class List;
229 schoenebeck 2 };
230    
231 schoenebeck 1193 /** @brief RIFF List Chunk
232     *
233     * Provides convenient methods to access data of RIFF list chunks and
234     * their subchunks.
235     */
236 schoenebeck 2 class List : public Chunk {
237     public:
238 schoenebeck 780 List(File* pFile, unsigned long StartPos, List* Parent);
239 schoenebeck 2 String GetListTypeString();
240 schoenebeck 11 uint32_t GetListType() { return ListType; } ///< Returns unsigned integer representation of the list's ID
241     Chunk* GetSubChunk(uint32_t ChunkID);
242     List* GetSubList(uint32_t ListType);
243 schoenebeck 2 Chunk* GetFirstSubChunk();
244     Chunk* GetNextSubChunk();
245     List* GetFirstSubList();
246     List* GetNextSubList();
247     unsigned int CountSubChunks();
248     unsigned int CountSubChunks(uint32_t ChunkID);
249     unsigned int CountSubLists();
250     unsigned int CountSubLists(uint32_t ListType);
251 schoenebeck 780 Chunk* AddSubChunk(uint32_t uiChunkID, uint uiBodySize);
252     List* AddSubList(uint32_t uiListType);
253     void DeleteSubChunk(Chunk* pSubChunk);
254 persson 1102 void MoveSubChunk(Chunk* pSrc, Chunk* pDst);
255 schoenebeck 384 virtual ~List();
256 schoenebeck 2 protected:
257     typedef std::map<uint32_t, RIFF::Chunk*> ChunkMap;
258     typedef std::list<Chunk*> ChunkList;
259    
260     uint32_t ListType;
261     ChunkList* pSubChunks;
262     ChunkMap* pSubChunksMap;
263     ChunkList::iterator ChunksIterator;
264     ChunkList::iterator ListIterator;
265    
266 schoenebeck 780 List(File* pFile);
267     List(File* pFile, List* pParent, uint32_t uiListID);
268 schoenebeck 2 void ReadHeader(unsigned long fPos);
269 schoenebeck 780 void WriteHeader(unsigned long fPos);
270 schoenebeck 2 void LoadSubChunks();
271 schoenebeck 833 void LoadSubChunksRecursively();
272 schoenebeck 780 virtual unsigned long WriteChunk(unsigned long ulWritePos, unsigned long ulCurrentDataOffset);
273     virtual void __resetPos(); ///< Sets List Chunk's read/write position to zero and causes all sub chunks to do the same.
274 schoenebeck 2 };
275    
276 schoenebeck 1193 /** @brief RIFF File
277     *
278     * Handles arbitrary RIFF files and provides together with its base
279     * classes convenient methods to walk through, read and modify the
280     * file's RIFF tree.
281     */
282 schoenebeck 2 class File : public List {
283     public:
284 schoenebeck 798 File(uint32_t FileType);
285 schoenebeck 2 File(const String& path);
286 schoenebeck 780 stream_mode_t GetMode();
287     bool SetMode(stream_mode_t NewMode);
288 persson 1184 void SetByteOrder(endian_t Endian);
289 schoenebeck 780 String GetFileName();
290     virtual void Save();
291     virtual void Save(const String& path);
292 schoenebeck 384 virtual ~File();
293 schoenebeck 780 protected:
294     #if POSIX
295     int hFileRead; ///< handle / descriptor for reading from file
296     int hFileWrite; ///< handle / descriptor for writing to (some) file
297 schoenebeck 1050 #elif defined(WIN32)
298     HANDLE hFileRead; ///< handle / descriptor for reading from file
299     HANDLE hFileWrite; ///< handle / descriptor for writing to (some) file
300 schoenebeck 780 #else
301     FILE* hFileRead; ///< handle / descriptor for reading from file
302     FILE* hFileWrite; ///< handle / descriptor for writing to (some) file
303     #endif // POSIX
304     String Filename;
305     bool bEndianNative;
306    
307     void LogAsResized(Chunk* pResizedChunk);
308 schoenebeck 1095 void UnlogResized(Chunk* pResizedChunk);
309 schoenebeck 780 friend class Chunk;
310     friend class List;
311 schoenebeck 2 private:
312 schoenebeck 780 stream_mode_t Mode;
313     ChunkList ResizedChunks; ///< All chunks which have been resized (enlarged / shortened).
314    
315 schoenebeck 2 unsigned long GetFileSize();
316 schoenebeck 780 void ResizeFile(unsigned long ulNewSize);
317 schoenebeck 798 #if POSIX
318     unsigned long __GetFileSize(int hFile);
319 schoenebeck 1050 #elif defined(WIN32)
320     unsigned long __GetFileSize(HANDLE hFile);
321 schoenebeck 798 #else
322     unsigned long __GetFileSize(FILE* hFile);
323     #endif
324 schoenebeck 2 };
325    
326 schoenebeck 1193 /**
327     * Will be thrown whenever an error occurs while handling a RIFF file.
328     */
329 schoenebeck 2 class Exception {
330     public:
331     String Message;
332    
333     Exception(String Message) { Exception::Message = Message; };
334     void PrintMessage();
335     virtual ~Exception() {};
336     };
337    
338 schoenebeck 518 String libraryName();
339     String libraryVersion();
340    
341 schoenebeck 2 } // namespace RIFF
342     #endif // __RIFF_H__

  ViewVC Help
Powered by ViewVC