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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1095 - (hide annotations) (download) (as text)
Mon Mar 12 18:16:55 2007 UTC (17 years ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 13151 byte(s)
* fixed RIFF::Chunk destructor which did not unregister previously
  resized chunks, leading to a "zero size chunk" exception when
  File::Save() was called

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 "../win32/libgig_private.h" // like config.h, automatically generated by Dev-C++
59     # include <windows.h>
60     typedef unsigned int uint;
61     typedef unsigned char uint8_t;
62     typedef unsigned short uint16_t;
63     typedef unsigned int uint32_t;
64     # define PACKAGE "libgig"
65     # define VERSION VER_STRING // VER_STRING defined in libgig_private.h
66     #endif // WIN32
67 schoenebeck 2
68     #include <stdio.h>
69    
70     #if WORDS_BIGENDIAN
71     # define CHUNK_ID_RIFF 0x52494646
72     # define CHUNK_ID_RIFX 0x52494658
73     # define CHUNK_ID_LIST 0x4C495354
74     #else // little endian
75     # define CHUNK_ID_RIFF 0x46464952
76     # define CHUNK_ID_RIFX 0x58464952
77     # define CHUNK_ID_LIST 0x5453494C
78     #endif // WORDS_BIGENDIAN
79    
80     #define CHUNK_HEADER_SIZE 8
81     #define LIST_HEADER_SIZE 12
82     #define RIFF_HEADER_SIZE 12
83    
84    
85     /** RIFF specific classes and definitions */
86     namespace RIFF {
87    
88     /* just symbol prototyping */
89     class Chunk;
90     class List;
91 schoenebeck 780 class File;
92 schoenebeck 2
93     typedef std::string String;
94    
95 schoenebeck 780 /** Whether file stream is open in read or in read/write mode. */
96     typedef enum {
97 schoenebeck 798 stream_mode_read = 0,
98     stream_mode_read_write = 1,
99     stream_mode_closed = 2
100 schoenebeck 780 } stream_mode_t;
101    
102 schoenebeck 2 /** Current state of the file stream. */
103     typedef enum {
104     stream_ready = 0,
105     stream_end_reached = 1,
106     stream_closed = 2
107     } stream_state_t;
108    
109     /** File stream position dependent to these relations. */
110     typedef enum {
111     stream_start = 0,
112     stream_curpos = 1,
113     stream_backward = 2,
114     stream_end = 3
115     } stream_whence_t;
116    
117     /** Provides convenient methods to access data of RIFF chunks in general. */
118     class Chunk {
119     public:
120 schoenebeck 780 Chunk(File* pFile, unsigned long StartPos, List* Parent);
121 schoenebeck 2 String GetChunkIDString();
122 schoenebeck 11 uint32_t GetChunkID() { return ChunkID; }; ///< Chunk ID in unsigned integer representation.
123     List* GetParent() { return pParent; }; ///< Returns pointer to the chunk's parent list chunk.
124 schoenebeck 780 unsigned long GetSize() { return CurrentChunkSize; }; ///< Chunk size in bytes (without header, thus the chunk data body)
125     unsigned long GetNewSize() { return NewChunkSize; }; ///< New chunk size if it was modified with Resize().
126 schoenebeck 11 unsigned long GetPos() { return ulPos; }; ///< Position within the chunk data body
127 schoenebeck 2 unsigned long GetFilePos() { return ulStartPos + ulPos; }; ///< Current, actual offset in file.
128     unsigned long SetPos(unsigned long Where, stream_whence_t Whence = stream_start);
129     unsigned long RemainingBytes();
130     stream_state_t GetState();
131     unsigned long Read(void* pData, unsigned long WordCount, unsigned long WordSize);
132     unsigned long ReadInt8(int8_t* pData, unsigned long WordCount = 1);
133     unsigned long ReadUint8(uint8_t* pData, unsigned long WordCount = 1);
134     unsigned long ReadInt16(int16_t* pData, unsigned long WordCount = 1);
135     unsigned long ReadUint16(uint16_t* pData, unsigned long WordCount = 1);
136     unsigned long ReadInt32(int32_t* pData, unsigned long WordCount = 1);
137     unsigned long ReadUint32(uint32_t* pData, unsigned long WordCount = 1);
138     int8_t ReadInt8();
139     uint8_t ReadUint8();
140     int16_t ReadInt16();
141     uint16_t ReadUint16();
142     int32_t ReadInt32();
143     uint32_t ReadUint32();
144 schoenebeck 780 unsigned long Write(void* pData, unsigned long WordCount, unsigned long WordSize);
145     unsigned long WriteInt8(int8_t* pData, unsigned long WordCount = 1);
146     unsigned long WriteUint8(uint8_t* pData, unsigned long WordCount = 1);
147     unsigned long WriteInt16(int16_t* pData, unsigned long WordCount = 1);
148     unsigned long WriteUint16(uint16_t* pData, unsigned long WordCount = 1);
149     unsigned long WriteInt32(int32_t* pData, unsigned long WordCount = 1);
150     unsigned long WriteUint32(uint32_t* pData, unsigned long WordCount = 1);
151     void* LoadChunkData();
152     void ReleaseChunkData();
153     void Resize(int iNewSize);
154 schoenebeck 384 virtual ~Chunk();
155 schoenebeck 2 protected:
156     uint32_t ChunkID;
157 schoenebeck 780 uint32_t CurrentChunkSize; /* in bytes */
158     uint32_t NewChunkSize; /* in bytes (if chunk was scheduled to be resized) */
159 schoenebeck 2 List* pParent;
160 schoenebeck 780 File* pFile;
161 schoenebeck 2 unsigned long ulStartPos; /* actual position in file where chunk (without header) starts */
162     unsigned long ulPos; /* # of bytes from ulStartPos */
163     uint8_t* pChunkData;
164 schoenebeck 800 unsigned long ulChunkDataSize;
165 schoenebeck 2
166 schoenebeck 780 Chunk(File* pFile);
167     Chunk(File* pFile, List* pParent, uint32_t uiChunkID, uint uiBodySize);
168 schoenebeck 2 void ReadHeader(unsigned long fPos);
169 schoenebeck 780 void WriteHeader(unsigned long fPos);
170 schoenebeck 2 unsigned long ReadSceptical(void* pData, unsigned long WordCount, unsigned long WordSize);
171     inline void swapBytes_16(void* Word) {
172     uint8_t byteCache = *((uint8_t*) Word);
173     *((uint8_t*) Word) = *((uint8_t*) Word + 1);
174     *((uint8_t*) Word + 1) = byteCache;
175     }
176     inline void swapBytes_32(void* Word) {
177     uint8_t byteCache = *((uint8_t*) Word);
178     *((uint8_t*) Word) = *((uint8_t*) Word + 3);
179     *((uint8_t*) Word + 3) = byteCache;
180     byteCache = *((uint8_t*) Word + 1);
181     *((uint8_t*) Word + 1) = *((uint8_t*) Word + 2);
182     *((uint8_t*) Word + 2) = byteCache;
183     }
184     inline void swapBytes(void* Word, unsigned long WordSize) {
185     uint8_t byteCache;
186     unsigned long lo = 0, hi = WordSize - 1;
187     for (; lo < hi; hi--, lo++) {
188     byteCache = *((uint8_t*) Word + lo);
189     *((uint8_t*) Word + lo) = *((uint8_t*) Word + hi);
190     *((uint8_t*) Word + hi) = byteCache;
191     }
192     }
193     inline String convertToString(uint32_t word) {
194     String result;
195     for (int i = 0; i < 4; i++) {
196     uint8_t byte = *((uint8_t*)(&word) + i);
197     char c = byte;
198     result += c;
199     }
200     return result;
201     }
202 schoenebeck 780 virtual unsigned long WriteChunk(unsigned long ulWritePos, unsigned long ulCurrentDataOffset);
203     virtual void __resetPos(); ///< Sets Chunk's read/write position to zero.
204    
205     friend class List;
206 schoenebeck 2 };
207    
208     /** Provides convenient methods to access data of RIFF list chunks and their subchunks. */
209     class List : public Chunk {
210     public:
211 schoenebeck 780 List(File* pFile, unsigned long StartPos, List* Parent);
212 schoenebeck 2 String GetListTypeString();
213 schoenebeck 11 uint32_t GetListType() { return ListType; } ///< Returns unsigned integer representation of the list's ID
214     Chunk* GetSubChunk(uint32_t ChunkID);
215     List* GetSubList(uint32_t ListType);
216 schoenebeck 2 Chunk* GetFirstSubChunk();
217     Chunk* GetNextSubChunk();
218     List* GetFirstSubList();
219     List* GetNextSubList();
220     unsigned int CountSubChunks();
221     unsigned int CountSubChunks(uint32_t ChunkID);
222     unsigned int CountSubLists();
223     unsigned int CountSubLists(uint32_t ListType);
224 schoenebeck 780 Chunk* AddSubChunk(uint32_t uiChunkID, uint uiBodySize);
225     List* AddSubList(uint32_t uiListType);
226     void DeleteSubChunk(Chunk* pSubChunk);
227 schoenebeck 384 virtual ~List();
228 schoenebeck 2 protected:
229     typedef std::map<uint32_t, RIFF::Chunk*> ChunkMap;
230     typedef std::list<Chunk*> ChunkList;
231    
232     uint32_t ListType;
233     ChunkList* pSubChunks;
234     ChunkMap* pSubChunksMap;
235     ChunkList::iterator ChunksIterator;
236     ChunkList::iterator ListIterator;
237    
238 schoenebeck 780 List(File* pFile);
239     List(File* pFile, List* pParent, uint32_t uiListID);
240 schoenebeck 2 void ReadHeader(unsigned long fPos);
241 schoenebeck 780 void WriteHeader(unsigned long fPos);
242 schoenebeck 2 void LoadSubChunks();
243 schoenebeck 833 void LoadSubChunksRecursively();
244 schoenebeck 780 virtual unsigned long WriteChunk(unsigned long ulWritePos, unsigned long ulCurrentDataOffset);
245     virtual void __resetPos(); ///< Sets List Chunk's read/write position to zero and causes all sub chunks to do the same.
246 schoenebeck 2 };
247    
248     /** Parses arbitrary RIFF files and provides together with it's base classes convenient methods to walk through the RIFF tree. */
249     class File : public List {
250     public:
251 schoenebeck 798 File(uint32_t FileType);
252 schoenebeck 2 File(const String& path);
253 schoenebeck 780 stream_mode_t GetMode();
254     bool SetMode(stream_mode_t NewMode);
255     String GetFileName();
256     virtual void Save();
257     virtual void Save(const String& path);
258 schoenebeck 384 virtual ~File();
259 schoenebeck 780 protected:
260     #if POSIX
261     int hFileRead; ///< handle / descriptor for reading from file
262     int hFileWrite; ///< handle / descriptor for writing to (some) file
263 schoenebeck 1050 #elif defined(WIN32)
264     HANDLE hFileRead; ///< handle / descriptor for reading from file
265     HANDLE hFileWrite; ///< handle / descriptor for writing to (some) file
266 schoenebeck 780 #else
267     FILE* hFileRead; ///< handle / descriptor for reading from file
268     FILE* hFileWrite; ///< handle / descriptor for writing to (some) file
269     #endif // POSIX
270     String Filename;
271     bool bEndianNative;
272    
273     void LogAsResized(Chunk* pResizedChunk);
274 schoenebeck 1095 void UnlogResized(Chunk* pResizedChunk);
275 schoenebeck 780 friend class Chunk;
276     friend class List;
277 schoenebeck 2 private:
278 schoenebeck 780 stream_mode_t Mode;
279     ChunkList ResizedChunks; ///< All chunks which have been resized (enlarged / shortened).
280    
281 schoenebeck 2 unsigned long GetFileSize();
282 schoenebeck 780 void ResizeFile(unsigned long ulNewSize);
283 schoenebeck 798 #if POSIX
284     unsigned long __GetFileSize(int hFile);
285 schoenebeck 1050 #elif defined(WIN32)
286     unsigned long __GetFileSize(HANDLE hFile);
287 schoenebeck 798 #else
288     unsigned long __GetFileSize(FILE* hFile);
289     #endif
290 schoenebeck 2 };
291    
292     /** Will be thrown whenever an error occurs while parsing a RIFF file. */
293     class Exception {
294     public:
295     String Message;
296    
297     Exception(String Message) { Exception::Message = Message; };
298     void PrintMessage();
299     virtual ~Exception() {};
300     };
301    
302 schoenebeck 518 String libraryName();
303     String libraryVersion();
304    
305 schoenebeck 2 } // namespace RIFF
306     #endif // __RIFF_H__

  ViewVC Help
Powered by ViewVC