libgig  4.0.0
RIFF.h
Go to the documentation of this file.
1 /***************************************************************************
2  * *
3  * libgig - C++ cross-platform Gigasampler format file access library *
4  * *
5  * Copyright (C) 2003-2015 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 <set>
43 #include <iostream>
44 
45 #ifdef HAVE_CONFIG_H
46 # include <config.h>
47 #endif
48 
49 #if POSIX
50 # include <sys/types.h>
51 # include <sys/stat.h>
52 # include <fcntl.h>
53 # include <unistd.h>
54 #endif // POSIX
55 
56 #ifdef _MSC_VER
57 // Visual C++ 2008 doesn't have stdint.h
58 typedef __int8 int8_t;
59 typedef __int16 int16_t;
60 typedef __int32 int32_t;
61 typedef __int64 int64_t;
62 typedef unsigned __int8 uint8_t;
63 typedef unsigned __int16 uint16_t;
64 typedef unsigned __int32 uint32_t;
65 typedef unsigned __int64 uint64_t;
66 #else
67 #include <stdint.h>
68 #endif
69 
70 #ifdef WIN32
71 # include <windows.h>
72  typedef unsigned int uint;
73 #endif // WIN32
74 
75 #include <stdio.h>
76 
77 #if WORDS_BIGENDIAN
78 # define CHUNK_ID_RIFF 0x52494646
79 # define CHUNK_ID_RIFX 0x52494658
80 # define CHUNK_ID_LIST 0x4C495354
81 
82 # define LIST_TYPE_INFO 0x494E464F
83 # define CHUNK_ID_ICMT 0x49434D54
84 # define CHUNK_ID_ICOP 0x49434F50
85 # define CHUNK_ID_ICRD 0x49435244
86 # define CHUNK_ID_IENG 0x49454E47
87 # define CHUNK_ID_INAM 0x494E414D
88 # define CHUNK_ID_IPRD 0x49505244
89 # define CHUNK_ID_ISFT 0x49534654
90 
91 # define CHUNK_ID_SMPL 0x736D706C
92 
93 #else // little endian
94 # define CHUNK_ID_RIFF 0x46464952
95 # define CHUNK_ID_RIFX 0x58464952
96 # define CHUNK_ID_LIST 0x5453494C
97 
98 # define LIST_TYPE_INFO 0x4F464E49
99 # define CHUNK_ID_ICMT 0x544D4349
100 # define CHUNK_ID_ICOP 0x504F4349
101 # define CHUNK_ID_ICRD 0x44524349
102 # define CHUNK_ID_IENG 0x474E4549
103 # define CHUNK_ID_INAM 0x4D414E49
104 # define CHUNK_ID_IPRD 0x44525049
105 # define CHUNK_ID_ISFT 0x54465349
106 
107 # define CHUNK_ID_SMPL 0x6C706D73
108 
109 #endif // WORDS_BIGENDIAN
110 
111 #define CHUNK_HEADER_SIZE 8
112 #define LIST_HEADER_SIZE 12
113 #define RIFF_HEADER_SIZE 12
114 
115 
135 namespace RIFF {
136 
137  /* just symbol prototyping */
138  class Chunk;
139  class List;
140  class File;
141 
142  typedef std::string String;
143 
145  typedef enum {
149  } stream_mode_t;
150 
152  typedef enum {
156  } stream_state_t;
157 
159  typedef enum {
164  } stream_whence_t;
165 
167  typedef enum {
171  } endian_t;
172 
174  enum layout_t {
177  };
178 
191  struct progress_t {
192  void (*callback)(progress_t*);
193  float factor;
194  void* custom;
195  float __range_min;
196  float __range_max;
197  progress_t();
198  };
199 
205  class Chunk {
206  public:
207  Chunk(File* pFile, unsigned long StartPos, List* Parent);
208  String GetChunkIDString();
209  uint32_t GetChunkID() { return ChunkID; }
210  File* GetFile() { return pFile; }
211  List* GetParent() { return pParent; }
212  unsigned long GetSize() const { return CurrentChunkSize; }
213  unsigned long GetNewSize() { return NewChunkSize; }
214  unsigned long GetPos() { return ulPos; }
215  unsigned long GetFilePos() { return ulStartPos + ulPos; }
216  unsigned long SetPos(unsigned long Where, stream_whence_t Whence = stream_start);
217  unsigned long RemainingBytes();
218  stream_state_t GetState();
219  unsigned long Read(void* pData, unsigned long WordCount, unsigned long WordSize);
220  unsigned long ReadInt8(int8_t* pData, unsigned long WordCount = 1);
221  unsigned long ReadUint8(uint8_t* pData, unsigned long WordCount = 1);
222  unsigned long ReadInt16(int16_t* pData, unsigned long WordCount = 1);
223  unsigned long ReadUint16(uint16_t* pData, unsigned long WordCount = 1);
224  unsigned long ReadInt32(int32_t* pData, unsigned long WordCount = 1);
225  unsigned long ReadUint32(uint32_t* pData, unsigned long WordCount = 1);
226  int8_t ReadInt8();
227  uint8_t ReadUint8();
228  int16_t ReadInt16();
229  uint16_t ReadUint16();
230  int32_t ReadInt32();
231  uint32_t ReadUint32();
232  void ReadString(String& s, int size);
233  unsigned long Write(void* pData, unsigned long WordCount, unsigned long WordSize);
234  unsigned long WriteInt8(int8_t* pData, unsigned long WordCount = 1);
235  unsigned long WriteUint8(uint8_t* pData, unsigned long WordCount = 1);
236  unsigned long WriteInt16(int16_t* pData, unsigned long WordCount = 1);
237  unsigned long WriteUint16(uint16_t* pData, unsigned long WordCount = 1);
238  unsigned long WriteInt32(int32_t* pData, unsigned long WordCount = 1);
239  unsigned long WriteUint32(uint32_t* pData, unsigned long WordCount = 1);
240  void* LoadChunkData();
241  void ReleaseChunkData();
242  void Resize(int iNewSize);
243  virtual ~Chunk();
244  protected:
245  uint32_t ChunkID;
246  uint32_t CurrentChunkSize; /* in bytes */
247  uint32_t NewChunkSize; /* in bytes (if chunk was scheduled to be resized) */
250  unsigned long ulStartPos; /* actual position in file where chunk (without header) starts */
251  unsigned long ulPos; /* # of bytes from ulStartPos */
252  uint8_t* pChunkData;
253  unsigned long ulChunkDataSize;
254 
255  Chunk(File* pFile);
256  Chunk(File* pFile, List* pParent, uint32_t uiChunkID, uint uiBodySize);
257  void ReadHeader(unsigned long fPos);
258  void WriteHeader(unsigned long fPos);
259  unsigned long ReadSceptical(void* pData, unsigned long WordCount, unsigned long WordSize);
260  inline void swapBytes_16(void* Word) {
261  uint8_t byteCache = *((uint8_t*) Word);
262  *((uint8_t*) Word) = *((uint8_t*) Word + 1);
263  *((uint8_t*) Word + 1) = byteCache;
264  }
265  inline void swapBytes_32(void* Word) {
266  uint8_t byteCache = *((uint8_t*) Word);
267  *((uint8_t*) Word) = *((uint8_t*) Word + 3);
268  *((uint8_t*) Word + 3) = byteCache;
269  byteCache = *((uint8_t*) Word + 1);
270  *((uint8_t*) Word + 1) = *((uint8_t*) Word + 2);
271  *((uint8_t*) Word + 2) = byteCache;
272  }
273  inline void swapBytes(void* Word, unsigned long WordSize) {
274  uint8_t byteCache;
275  unsigned long lo = 0, hi = WordSize - 1;
276  for (; lo < hi; hi--, lo++) {
277  byteCache = *((uint8_t*) Word + lo);
278  *((uint8_t*) Word + lo) = *((uint8_t*) Word + hi);
279  *((uint8_t*) Word + hi) = byteCache;
280  }
281  }
282  inline String convertToString(uint32_t word) {
283  String result;
284  for (int i = 0; i < 4; i++) {
285  uint8_t byte = *((uint8_t*)(&word) + i);
286  char c = byte;
287  result += c;
288  }
289  return result;
290  }
291  virtual unsigned long WriteChunk(unsigned long ulWritePos, unsigned long ulCurrentDataOffset, progress_t* pProgress = NULL);
292  virtual void __resetPos();
293 
294  friend class List;
295  };
296 
302  class List : public Chunk {
303  public:
304  List(File* pFile, unsigned long StartPos, List* Parent);
305  String GetListTypeString();
306  uint32_t GetListType() { return ListType; }
307  Chunk* GetSubChunk(uint32_t ChunkID);
308  List* GetSubList(uint32_t ListType);
309  Chunk* GetFirstSubChunk();
310  Chunk* GetNextSubChunk();
311  List* GetFirstSubList();
312  List* GetNextSubList();
313  unsigned int CountSubChunks();
314  unsigned int CountSubChunks(uint32_t ChunkID);
315  unsigned int CountSubLists();
316  unsigned int CountSubLists(uint32_t ListType);
317  Chunk* AddSubChunk(uint32_t uiChunkID, uint uiBodySize);
318  List* AddSubList(uint32_t uiListType);
319  void DeleteSubChunk(Chunk* pSubChunk);
320  void MoveSubChunk(Chunk* pSrc, Chunk* pDst); // read API doc comments !!!
321  void MoveSubChunk(Chunk* pSrc, List* pNewParent);
322  virtual ~List();
323  protected:
324  typedef std::map<uint32_t, RIFF::Chunk*> ChunkMap;
325  typedef std::list<Chunk*> ChunkList;
326  typedef std::set<Chunk*> ChunkSet;
327 
328  uint32_t ListType;
329  ChunkList* pSubChunks;
330  ChunkMap* pSubChunksMap;
331  ChunkList::iterator ChunksIterator;
332  ChunkList::iterator ListIterator;
333 
334  List(File* pFile);
335  List(File* pFile, List* pParent, uint32_t uiListID);
336  void ReadHeader(unsigned long fPos);
337  void WriteHeader(unsigned long fPos);
338  void LoadSubChunks(progress_t* pProgress = NULL);
339  void LoadSubChunksRecursively(progress_t* pProgress = NULL);
340  virtual unsigned long WriteChunk(unsigned long ulWritePos, unsigned long ulCurrentDataOffset, progress_t* pProgress = NULL);
341  virtual void __resetPos();
342  void DeleteChunkList();
343  };
344 
351  class File : public List {
352  public:
353  File(uint32_t FileType);
354  File(const String& path);
355  File(const String& path, uint32_t FileType, endian_t Endian, layout_t layout);
356  stream_mode_t GetMode();
357  bool SetMode(stream_mode_t NewMode);
358  void SetByteOrder(endian_t Endian);
359  String GetFileName();
360  void SetFileName(const String& path);
361  bool IsNew() const;
362  layout_t GetLayout() const;
363  virtual void Save(progress_t* pProgress = NULL);
364  virtual void Save(const String& path, progress_t* pProgress = NULL);
365  virtual ~File();
366  protected:
367  #if POSIX
368  int hFileRead;
370  #elif defined(WIN32)
371  HANDLE hFileRead;
372  HANDLE hFileWrite;
373  #else
374  FILE* hFileRead;
375  FILE* hFileWrite;
376  #endif // POSIX
377  String Filename;
381 
382  void LogAsResized(Chunk* pResizedChunk);
383  void UnlogResized(Chunk* pResizedChunk);
384  friend class Chunk;
385  friend class List;
386  private:
387  stream_mode_t Mode;
388  ChunkSet ResizedChunks;
389 
390  void __openExistingFile(const String& path, uint32_t* FileType = NULL);
391  unsigned long GetFileSize();
392  void ResizeFile(unsigned long ulNewSize);
393  #if POSIX
394  unsigned long __GetFileSize(int hFile);
395  #elif defined(WIN32)
396  unsigned long __GetFileSize(HANDLE hFile);
397  #else
398  unsigned long __GetFileSize(FILE* hFile);
399  #endif
400  void Cleanup();
401  };
402 
406  class Exception {
407  public:
408  String Message;
409 
410  Exception(String Message) { Exception::Message = Message; }
411  void PrintMessage();
412  virtual ~Exception() {}
413  };
414 
415  String libraryName();
416  String libraryVersion();
417 
418 } // namespace RIFF
419 #endif // __RIFF_H__
bool bEndianNative
Definition: RIFF.h:378
void swapBytes_16(void *Word)
Definition: RIFF.h:260
List * pParent
Definition: RIFF.h:248
stream_whence_t
File stream position dependent to these relations.
Definition: RIFF.h:159
String libraryName()
Returns the name of this C++ library.
Definition: RIFF.cpp:2079
uint32_t GetChunkID()
Chunk ID in unsigned integer representation.
Definition: RIFF.h:209
layout_t Layout
An ordinary RIFF file is always set to layout_standard.
Definition: RIFF.h:380
void(* callback)(progress_t *)
Callback function pointer which has to be assigned to a function for progress notification.
Definition: RIFF.h:192
void swapBytes(void *Word, unsigned long WordSize)
Definition: RIFF.h:273
stream_state_t
Current state of the file stream.
Definition: RIFF.h:152
bool bIsNewFile
Definition: RIFF.h:379
String libraryVersion()
Returns version of this C++ library.
Definition: RIFF.cpp:2087
int hFileWrite
handle / descriptor for writing to (some) file
Definition: RIFF.h:369
String Filename
Definition: RIFF.h:377
Exception(String Message)
Definition: RIFF.h:410
stream_mode_t
Whether file stream is open in read or in read/write mode.
Definition: RIFF.h:145
std::list< Chunk * > ChunkList
Definition: RIFF.h:325
std::string String
Definition: RIFF.h:140
unsigned long GetPos()
Position within the chunk data body.
Definition: RIFF.h:214
std::set< Chunk * > ChunkSet
Definition: RIFF.h:326
RIFF List Chunk.
Definition: RIFF.h:302
File * pFile
Definition: RIFF.h:249
ChunkList::iterator ListIterator
Definition: RIFF.h:332
String Message
Definition: RIFF.h:408
float __range_min
Only for internal usage, do not modify!
Definition: RIFF.h:195
unsigned long ulPos
Definition: RIFF.h:251
layout_t
General chunk structure of a file.
Definition: RIFF.h:174
Ordinary RIFF Chunk.
Definition: RIFF.h:205
uint32_t GetListType()
Returns unsigned integer representation of the list&#39;s ID.
Definition: RIFF.h:306
unsigned long GetFilePos()
Current, actual offset in file.
Definition: RIFF.h:215
ChunkList::iterator ChunksIterator
Definition: RIFF.h:331
File * GetFile()
Returns pointer to the chunk&#39;s File object.
Definition: RIFF.h:210
unsigned long ulStartPos
Definition: RIFF.h:250
void * custom
This pointer can be used for arbitrary data.
Definition: RIFF.h:194
Used for indicating the progress of a certain task.
Definition: RIFF.h:191
ChunkList * pSubChunks
Definition: RIFF.h:329
List * GetParent()
Returns pointer to the chunk&#39;s parent list chunk.
Definition: RIFF.h:211
void swapBytes_32(void *Word)
Definition: RIFF.h:265
int hFileRead
handle / descriptor for reading from file
Definition: RIFF.h:368
Not a "real" RIFF file: First chunk in file is an ordinary data chunk, not a List chunk...
Definition: RIFF.h:176
ChunkMap * pSubChunksMap
Definition: RIFF.h:330
uint8_t * pChunkData
Definition: RIFF.h:252
uint32_t CurrentChunkSize
Definition: RIFF.h:246
endian_t
Alignment of data bytes in memory (system dependant).
Definition: RIFF.h:167
Standard RIFF file layout: First chunk in file is a List chunk which contains all other chunks and th...
Definition: RIFF.h:175
unsigned long ulChunkDataSize
Definition: RIFF.h:253
RIFF File.
Definition: RIFF.h:351
RIFF specific classes and definitions.
Definition: RIFF.h:135
unsigned long GetSize() const
Chunk size in bytes (without header, thus the chunk data body)
Definition: RIFF.h:212
float factor
Reflects current progress as value between 0.0 and 1.0.
Definition: RIFF.h:193
String convertToString(uint32_t word)
Definition: RIFF.h:282
virtual ~Exception()
Definition: RIFF.h:412
float __range_max
Only for internal usage, do not modify!
Definition: RIFF.h:196
Will be thrown whenever an error occurs while handling a RIFF file.
Definition: RIFF.h:406
unsigned long GetNewSize()
New chunk size if it was modified with Resize().
Definition: RIFF.h:213
uint32_t NewChunkSize
Definition: RIFF.h:247
uint32_t ChunkID
Definition: RIFF.h:245
std::map< uint32_t, RIFF::Chunk * > ChunkMap
Definition: RIFF.h:324
uint32_t ListType
Definition: RIFF.h:328