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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2584 - (hide annotations) (download) (as text)
Sat May 31 20:54:39 2014 UTC (9 years, 9 months ago) by schoenebeck
File MIME type: text/x-c++hdr
File size: 16272 byte(s)
* gig.h/.cpp: GIG FORMAT EXTENSION: added support for real-time
  instrument scripts.
* RIFF.h/.cpp: added 2nd alternative method for List::MoveSubChunk(),
  the old 1st one allows to move a subchunk within the current List
  whereas the new 2nd one allows to move the subchunk from the
  current list to another list.
* Bumped version (3.3.0.svn13).

1 schoenebeck 2 /***************************************************************************
2     * *
3 schoenebeck 933 * libgig - C++ cross-platform Gigasampler format file access library *
4 schoenebeck 2 * *
5 schoenebeck 2543 * Copyright (C) 2003-2014 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 persson 1869 #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 schoenebeck 2 #include <stdint.h>
67 persson 1869 #endif
68 schoenebeck 2
69 schoenebeck 1050 #ifdef WIN32
70     # include <windows.h>
71     typedef unsigned int uint;
72     #endif // WIN32
73 schoenebeck 2
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 persson 2044
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 schoenebeck 2 #else // little endian
93     # define CHUNK_ID_RIFF 0x46464952
94     # define CHUNK_ID_RIFX 0x58464952
95     # define CHUNK_ID_LIST 0x5453494C
96 persson 2044
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 schoenebeck 2 #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 schoenebeck 1193 /**
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 schoenebeck 2 namespace RIFF {
135    
136     /* just symbol prototyping */
137     class Chunk;
138     class List;
139 schoenebeck 780 class File;
140 schoenebeck 2
141     typedef std::string String;
142    
143 schoenebeck 780 /** Whether file stream is open in read or in read/write mode. */
144     typedef enum {
145 schoenebeck 798 stream_mode_read = 0,
146     stream_mode_read_write = 1,
147     stream_mode_closed = 2
148 schoenebeck 780 } stream_mode_t;
149    
150 schoenebeck 2 /** 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 schoenebeck 1193 /** Alignment of data bytes in memory (system dependant). */
166 persson 1183 typedef enum {
167     endian_little = 0,
168     endian_big = 1,
169     endian_native = 2
170     } endian_t;
171    
172 schoenebeck 2543 /** 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 schoenebeck 1193 /** @brief Ordinary RIFF Chunk
179     *
180     * Provides convenient methods to access data of ordinary RIFF chunks
181     * in general.
182     */
183 schoenebeck 2 class Chunk {
184     public:
185 schoenebeck 780 Chunk(File* pFile, unsigned long StartPos, List* Parent);
186 schoenebeck 2 String GetChunkIDString();
187 persson 1713 uint32_t GetChunkID() { return ChunkID; } ///< Chunk ID in unsigned integer representation.
188 schoenebeck 2543 File* GetFile() { return pFile; } ///< Returns pointer to the chunk's File object.
189 persson 1713 List* GetParent() { return pParent; } ///< Returns pointer to the chunk's parent list chunk.
190 schoenebeck 2482 unsigned long GetSize() const { return CurrentChunkSize; } ///< Chunk size in bytes (without header, thus the chunk data body)
191 persson 1713 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 schoenebeck 2 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 persson 2450 void ReadString(String& s, int size);
211 schoenebeck 780 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 schoenebeck 384 virtual ~Chunk();
222 schoenebeck 2 protected:
223     uint32_t ChunkID;
224 schoenebeck 780 uint32_t CurrentChunkSize; /* in bytes */
225     uint32_t NewChunkSize; /* in bytes (if chunk was scheduled to be resized) */
226 schoenebeck 2 List* pParent;
227 schoenebeck 780 File* pFile;
228 schoenebeck 2 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 schoenebeck 800 unsigned long ulChunkDataSize;
232 schoenebeck 2
233 schoenebeck 780 Chunk(File* pFile);
234     Chunk(File* pFile, List* pParent, uint32_t uiChunkID, uint uiBodySize);
235 schoenebeck 2 void ReadHeader(unsigned long fPos);
236 schoenebeck 780 void WriteHeader(unsigned long fPos);
237 schoenebeck 2 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 schoenebeck 780 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 schoenebeck 2 };
274    
275 schoenebeck 1193 /** @brief RIFF List Chunk
276     *
277     * Provides convenient methods to access data of RIFF list chunks and
278     * their subchunks.
279     */
280 schoenebeck 2 class List : public Chunk {
281     public:
282 schoenebeck 780 List(File* pFile, unsigned long StartPos, List* Parent);
283 schoenebeck 2 String GetListTypeString();
284 schoenebeck 11 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 schoenebeck 2 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 schoenebeck 780 Chunk* AddSubChunk(uint32_t uiChunkID, uint uiBodySize);
296     List* AddSubList(uint32_t uiListType);
297     void DeleteSubChunk(Chunk* pSubChunk);
298 schoenebeck 2584 void MoveSubChunk(Chunk* pSrc, Chunk* pDst); // read API doc comments !!!
299     void MoveSubChunk(Chunk* pSrc, List* pNewParent);
300 schoenebeck 384 virtual ~List();
301 schoenebeck 2 protected:
302     typedef std::map<uint32_t, RIFF::Chunk*> ChunkMap;
303     typedef std::list<Chunk*> ChunkList;
304    
305     uint32_t ListType;
306     ChunkList* pSubChunks;
307     ChunkMap* pSubChunksMap;
308     ChunkList::iterator ChunksIterator;
309     ChunkList::iterator ListIterator;
310    
311 schoenebeck 780 List(File* pFile);
312     List(File* pFile, List* pParent, uint32_t uiListID);
313 schoenebeck 2 void ReadHeader(unsigned long fPos);
314 schoenebeck 780 void WriteHeader(unsigned long fPos);
315 schoenebeck 2 void LoadSubChunks();
316 schoenebeck 833 void LoadSubChunksRecursively();
317 schoenebeck 780 virtual unsigned long WriteChunk(unsigned long ulWritePos, unsigned long ulCurrentDataOffset);
318     virtual void __resetPos(); ///< Sets List Chunk's read/write position to zero and causes all sub chunks to do the same.
319 persson 1869 void DeleteChunkList();
320 schoenebeck 2 };
321    
322 schoenebeck 1193 /** @brief RIFF File
323     *
324     * Handles arbitrary RIFF files and provides together with its base
325     * classes convenient methods to walk through, read and modify the
326     * file's RIFF tree.
327     */
328 schoenebeck 2 class File : public List {
329     public:
330 schoenebeck 798 File(uint32_t FileType);
331 schoenebeck 2 File(const String& path);
332 schoenebeck 2543 File(const String& path, uint32_t FileType, endian_t Endian, layout_t layout);
333 schoenebeck 780 stream_mode_t GetMode();
334     bool SetMode(stream_mode_t NewMode);
335 persson 1184 void SetByteOrder(endian_t Endian);
336 schoenebeck 780 String GetFileName();
337 schoenebeck 2482 void SetFileName(const String& path);
338     bool IsNew() const;
339 schoenebeck 2543 layout_t GetLayout() const;
340 schoenebeck 780 virtual void Save();
341     virtual void Save(const String& path);
342 schoenebeck 384 virtual ~File();
343 schoenebeck 780 protected:
344     #if POSIX
345     int hFileRead; ///< handle / descriptor for reading from file
346     int hFileWrite; ///< handle / descriptor for writing to (some) file
347 schoenebeck 1050 #elif defined(WIN32)
348     HANDLE hFileRead; ///< handle / descriptor for reading from file
349     HANDLE hFileWrite; ///< handle / descriptor for writing to (some) file
350 schoenebeck 780 #else
351     FILE* hFileRead; ///< handle / descriptor for reading from file
352     FILE* hFileWrite; ///< handle / descriptor for writing to (some) file
353     #endif // POSIX
354     String Filename;
355     bool bEndianNative;
356 schoenebeck 2482 bool bIsNewFile;
357 schoenebeck 2543 layout_t Layout; ///< An ordinary RIFF file is always set to layout_standard.
358 schoenebeck 780
359     void LogAsResized(Chunk* pResizedChunk);
360 schoenebeck 1095 void UnlogResized(Chunk* pResizedChunk);
361 schoenebeck 780 friend class Chunk;
362     friend class List;
363 schoenebeck 2 private:
364 schoenebeck 780 stream_mode_t Mode;
365 schoenebeck 1953 ChunkList ResizedChunks; ///< All chunks which have been resized (enlarged / shortened).
366 schoenebeck 780
367 schoenebeck 2543 void __openExistingFile(const String& path, uint32_t* FileType = NULL);
368 schoenebeck 2 unsigned long GetFileSize();
369 schoenebeck 780 void ResizeFile(unsigned long ulNewSize);
370 schoenebeck 798 #if POSIX
371     unsigned long __GetFileSize(int hFile);
372 schoenebeck 1050 #elif defined(WIN32)
373     unsigned long __GetFileSize(HANDLE hFile);
374 schoenebeck 798 #else
375     unsigned long __GetFileSize(FILE* hFile);
376     #endif
377 persson 2155 void Cleanup();
378 schoenebeck 2 };
379    
380 schoenebeck 1193 /**
381     * Will be thrown whenever an error occurs while handling a RIFF file.
382     */
383 schoenebeck 2 class Exception {
384     public:
385     String Message;
386    
387 persson 1713 Exception(String Message) { Exception::Message = Message; }
388 schoenebeck 2 void PrintMessage();
389 persson 1713 virtual ~Exception() {}
390 schoenebeck 2 };
391    
392 schoenebeck 518 String libraryName();
393     String libraryVersion();
394    
395 schoenebeck 2 } // namespace RIFF
396     #endif // __RIFF_H__

  ViewVC Help
Powered by ViewVC