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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2543 - (hide 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 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 persson 1102 void MoveSubChunk(Chunk* pSrc, Chunk* pDst);
299 schoenebeck 384 virtual ~List();
300 schoenebeck 2 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 schoenebeck 780 List(File* pFile);
311     List(File* pFile, List* pParent, uint32_t uiListID);
312 schoenebeck 2 void ReadHeader(unsigned long fPos);
313 schoenebeck 780 void WriteHeader(unsigned long fPos);
314 schoenebeck 2 void LoadSubChunks();
315 schoenebeck 833 void LoadSubChunksRecursively();
316 schoenebeck 780 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 persson 1869 void DeleteChunkList();
319 schoenebeck 2 };
320    
321 schoenebeck 1193 /** @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 schoenebeck 2 class File : public List {
328     public:
329 schoenebeck 798 File(uint32_t FileType);
330 schoenebeck 2 File(const String& path);
331 schoenebeck 2543 File(const String& path, uint32_t FileType, endian_t Endian, layout_t layout);
332 schoenebeck 780 stream_mode_t GetMode();
333     bool SetMode(stream_mode_t NewMode);
334 persson 1184 void SetByteOrder(endian_t Endian);
335 schoenebeck 780 String GetFileName();
336 schoenebeck 2482 void SetFileName(const String& path);
337     bool IsNew() const;
338 schoenebeck 2543 layout_t GetLayout() const;
339 schoenebeck 780 virtual void Save();
340     virtual void Save(const String& path);
341 schoenebeck 384 virtual ~File();
342 schoenebeck 780 protected:
343     #if POSIX
344     int hFileRead; ///< handle / descriptor for reading from file
345     int hFileWrite; ///< handle / descriptor for writing to (some) file
346 schoenebeck 1050 #elif defined(WIN32)
347     HANDLE hFileRead; ///< handle / descriptor for reading from file
348     HANDLE hFileWrite; ///< handle / descriptor for writing to (some) file
349 schoenebeck 780 #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 schoenebeck 2482 bool bIsNewFile;
356 schoenebeck 2543 layout_t Layout; ///< An ordinary RIFF file is always set to layout_standard.
357 schoenebeck 780
358     void LogAsResized(Chunk* pResizedChunk);
359 schoenebeck 1095 void UnlogResized(Chunk* pResizedChunk);
360 schoenebeck 780 friend class Chunk;
361     friend class List;
362 schoenebeck 2 private:
363 schoenebeck 780 stream_mode_t Mode;
364 schoenebeck 1953 ChunkList ResizedChunks; ///< All chunks which have been resized (enlarged / shortened).
365 schoenebeck 780
366 schoenebeck 2543 void __openExistingFile(const String& path, uint32_t* FileType = NULL);
367 schoenebeck 2 unsigned long GetFileSize();
368 schoenebeck 780 void ResizeFile(unsigned long ulNewSize);
369 schoenebeck 798 #if POSIX
370     unsigned long __GetFileSize(int hFile);
371 schoenebeck 1050 #elif defined(WIN32)
372     unsigned long __GetFileSize(HANDLE hFile);
373 schoenebeck 798 #else
374     unsigned long __GetFileSize(FILE* hFile);
375     #endif
376 persson 2155 void Cleanup();
377 schoenebeck 2 };
378    
379 schoenebeck 1193 /**
380     * Will be thrown whenever an error occurs while handling a RIFF file.
381     */
382 schoenebeck 2 class Exception {
383     public:
384     String Message;
385    
386 persson 1713 Exception(String Message) { Exception::Message = Message; }
387 schoenebeck 2 void PrintMessage();
388 persson 1713 virtual ~Exception() {}
389 schoenebeck 2 };
390    
391 schoenebeck 518 String libraryName();
392     String libraryVersion();
393    
394 schoenebeck 2 } // namespace RIFF
395     #endif // __RIFF_H__

  ViewVC Help
Powered by ViewVC