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

Contents of /libgig/trunk/src/RIFF.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3901 - (show annotations) (download)
Wed May 12 17:35:38 2021 UTC (2 years, 10 months ago) by schoenebeck
File size: 100175 byte(s)
* src/RIFF.cpp: Fix clang sanatizer warning in Chunk::LoadChunkData().

* Bumped version (4.3.0.svn2).

1 /***************************************************************************
2 * *
3 * libgig - C++ cross-platform Gigasampler format file access library *
4 * *
5 * Copyright (C) 2003-2021 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 #include <algorithm>
25 #include <set>
26 #include <string.h>
27
28 #include "RIFF.h"
29
30 #include "helper.h"
31
32 #if POSIX
33 # include <errno.h>
34 #endif
35
36 namespace RIFF {
37
38 // *************** Internal functions **************
39 // *
40
41 /// Returns a human readable path of the given chunk.
42 static String __resolveChunkPath(Chunk* pCk) {
43 String sPath;
44 for (Chunk* pChunk = pCk; pChunk; pChunk = pChunk->GetParent()) {
45 if (pChunk->GetChunkID() == CHUNK_ID_LIST) {
46 List* pList = (List*) pChunk;
47 sPath = "->'" + pList->GetListTypeString() + "'" + sPath;
48 } else {
49 sPath = "->'" + pChunk->GetChunkIDString() + "'" + sPath;
50 }
51 }
52 return sPath;
53 }
54
55
56
57 // *************** progress_t ***************
58 // *
59
60 progress_t::progress_t() {
61 callback = NULL;
62 custom = NULL;
63 __range_min = 0.0f;
64 __range_max = 1.0f;
65 }
66
67 /**
68 * Divides this progress task into the requested amount of equal weighted
69 * sub-progress tasks and returns a vector with those subprogress tasks.
70 *
71 * @param iSubtasks - total amount sub tasks this task should be subdivided
72 * @returns subtasks
73 */
74 std::vector<progress_t> progress_t::subdivide(int iSubtasks) {
75 std::vector<progress_t> v;
76 for (int i = 0; i < iSubtasks; ++i) {
77 progress_t p;
78 __divide_progress(this, &p, iSubtasks, i);
79 v.push_back(p);
80 }
81 return v;
82 }
83
84 /**
85 * Divides this progress task into the requested amount of sub-progress
86 * tasks, where each one of those new sub-progress tasks is created with its
87 * requested individual weight / portion, and finally returns a vector
88 * with those new subprogress tasks.
89 *
90 * The amount of subprogresses to be created is determined by this method
91 * by calling @c vSubTaskPortions.size() .
92 *
93 * Example: consider you wanted to create 3 subprogresses where the 1st
94 * subtask should be assigned 10% of the new 3 subprogresses' overall
95 * progress, the 2nd subtask should be assigned 50% of the new 3
96 * subprogresses' overall progress, and the 3rd subtask should be assigned
97 * 40%, then you might call this method like this:
98 * @code
99 * std::vector<progress_t> subprogresses = progress.subdivide({0.1, 0.5, 0.4});
100 * @endcode
101 *
102 * @param vSubTaskPortions - amount and individual weight of subtasks to be
103 * created
104 * @returns subtasks
105 */
106 std::vector<progress_t> progress_t::subdivide(std::vector<float> vSubTaskPortions) {
107 float fTotal = 0.f; // usually 1.0, but we sum the portions up below to be sure
108 for (int i = 0; i < vSubTaskPortions.size(); ++i)
109 fTotal += vSubTaskPortions[i];
110
111 float fLow = 0.f, fHigh = 0.f;
112 std::vector<progress_t> v;
113 for (int i = 0; i < vSubTaskPortions.size(); ++i) {
114 fLow = fHigh;
115 fHigh = vSubTaskPortions[i];
116 progress_t p;
117 __divide_progress(this, &p, fTotal, fLow, fHigh);
118 v.push_back(p);
119 }
120 return v;
121 }
122
123
124
125 // *************** Chunk **************
126 // *
127
128 Chunk::Chunk(File* pFile) {
129 #if DEBUG_RIFF
130 std::cout << "Chunk::Chunk(File* pFile)" << std::endl;
131 #endif // DEBUG_RIFF
132 ullPos = 0;
133 pParent = NULL;
134 pChunkData = NULL;
135 ullCurrentChunkSize = 0;
136 ullNewChunkSize = 0;
137 ullChunkDataSize = 0;
138 ChunkID = CHUNK_ID_RIFF;
139 this->pFile = pFile;
140 }
141
142 Chunk::Chunk(File* pFile, file_offset_t StartPos, List* Parent) {
143 #if DEBUG_RIFF
144 std::cout << "Chunk::Chunk(File*,file_offset_t,List*),StartPos=" << StartPos << std::endl;
145 #endif // DEBUG_RIFF
146 this->pFile = pFile;
147 ullStartPos = StartPos + CHUNK_HEADER_SIZE(pFile->FileOffsetSize);
148 pParent = Parent;
149 ullPos = 0;
150 pChunkData = NULL;
151 ullCurrentChunkSize = 0;
152 ullNewChunkSize = 0;
153 ullChunkDataSize = 0;
154 ReadHeader(StartPos);
155 }
156
157 Chunk::Chunk(File* pFile, List* pParent, uint32_t uiChunkID, file_offset_t ullBodySize) {
158 this->pFile = pFile;
159 ullStartPos = 0; // arbitrary usually, since it will be updated when we write the chunk
160 this->pParent = pParent;
161 ullPos = 0;
162 pChunkData = NULL;
163 ChunkID = uiChunkID;
164 ullChunkDataSize = 0;
165 ullCurrentChunkSize = 0;
166 ullNewChunkSize = ullBodySize;
167 }
168
169 Chunk::~Chunk() {
170 if (pChunkData) delete[] pChunkData;
171 }
172
173 void Chunk::ReadHeader(file_offset_t filePos) {
174 #if DEBUG_RIFF
175 std::cout << "Chunk::Readheader(" << filePos << ") ";
176 #endif // DEBUG_RIFF
177 ChunkID = 0;
178 ullNewChunkSize = ullCurrentChunkSize = 0;
179 #if POSIX
180 if (lseek(pFile->hFileRead, filePos, SEEK_SET) != -1) {
181 read(pFile->hFileRead, &ChunkID, 4);
182 read(pFile->hFileRead, &ullCurrentChunkSize, pFile->FileOffsetSize);
183 #elif defined(WIN32)
184 LARGE_INTEGER liFilePos;
185 liFilePos.QuadPart = filePos;
186 if (SetFilePointerEx(pFile->hFileRead, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN)) {
187 DWORD dwBytesRead;
188 ReadFile(pFile->hFileRead, &ChunkID, 4, &dwBytesRead, NULL);
189 ReadFile(pFile->hFileRead, &ullCurrentChunkSize, pFile->FileOffsetSize, &dwBytesRead, NULL);
190 #else
191 if (!fseeko(pFile->hFileRead, filePos, SEEK_SET)) {
192 fread(&ChunkID, 4, 1, pFile->hFileRead);
193 fread(&ullCurrentChunkSize, pFile->FileOffsetSize, 1, pFile->hFileRead);
194 #endif // POSIX
195 #if WORDS_BIGENDIAN
196 if (ChunkID == CHUNK_ID_RIFF) {
197 pFile->bEndianNative = false;
198 }
199 #else // little endian
200 if (ChunkID == CHUNK_ID_RIFX) {
201 pFile->bEndianNative = false;
202 ChunkID = CHUNK_ID_RIFF;
203 }
204 #endif // WORDS_BIGENDIAN
205 if (!pFile->bEndianNative) {
206 //swapBytes_32(&ChunkID);
207 if (pFile->FileOffsetSize == 4)
208 swapBytes_32(&ullCurrentChunkSize);
209 else
210 swapBytes_64(&ullCurrentChunkSize);
211 }
212 #if DEBUG_RIFF
213 std::cout << "ckID=" << convertToString(ChunkID) << " ";
214 std::cout << "ckSize=" << ullCurrentChunkSize << " ";
215 std::cout << "bEndianNative=" << pFile->bEndianNative << std::endl;
216 #endif // DEBUG_RIFF
217 ullNewChunkSize = ullCurrentChunkSize;
218 }
219 }
220
221 void Chunk::WriteHeader(file_offset_t filePos) {
222 uint32_t uiNewChunkID = ChunkID;
223 if (ChunkID == CHUNK_ID_RIFF) {
224 #if WORDS_BIGENDIAN
225 if (pFile->bEndianNative) uiNewChunkID = CHUNK_ID_RIFX;
226 #else // little endian
227 if (!pFile->bEndianNative) uiNewChunkID = CHUNK_ID_RIFX;
228 #endif // WORDS_BIGENDIAN
229 }
230
231 uint64_t ullNewChunkSize = this->ullNewChunkSize;
232 if (!pFile->bEndianNative) {
233 if (pFile->FileOffsetSize == 4)
234 swapBytes_32(&ullNewChunkSize);
235 else
236 swapBytes_64(&ullNewChunkSize);
237 }
238
239 #if POSIX
240 if (lseek(pFile->hFileWrite, filePos, SEEK_SET) != -1) {
241 write(pFile->hFileWrite, &uiNewChunkID, 4);
242 write(pFile->hFileWrite, &ullNewChunkSize, pFile->FileOffsetSize);
243 }
244 #elif defined(WIN32)
245 LARGE_INTEGER liFilePos;
246 liFilePos.QuadPart = filePos;
247 if (SetFilePointerEx(pFile->hFileWrite, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN)) {
248 DWORD dwBytesWritten;
249 WriteFile(pFile->hFileWrite, &uiNewChunkID, 4, &dwBytesWritten, NULL);
250 WriteFile(pFile->hFileWrite, &ullNewChunkSize, pFile->FileOffsetSize, &dwBytesWritten, NULL);
251 }
252 #else
253 if (!fseeko(pFile->hFileWrite, filePos, SEEK_SET)) {
254 fwrite(&uiNewChunkID, 4, 1, pFile->hFileWrite);
255 fwrite(&ullNewChunkSize, pFile->FileOffsetSize, 1, pFile->hFileWrite);
256 }
257 #endif // POSIX
258 }
259
260 /**
261 * Returns the String representation of the chunk's ID (e.g. "RIFF",
262 * "LIST").
263 */
264 String Chunk::GetChunkIDString() const {
265 return convertToString(ChunkID);
266 }
267
268 /**
269 * Sets the position within the chunk body, thus within the data portion
270 * of the chunk (in bytes).
271 *
272 * <b>Caution:</b> the position will be reset to zero whenever
273 * File::Save() was called.
274 *
275 * @param Where - position offset (in bytes)
276 * @param Whence - optional: defines to what <i>\a Where</i> relates to,
277 * if omitted \a Where relates to beginning of the chunk
278 * data
279 */
280 file_offset_t Chunk::SetPos(file_offset_t Where, stream_whence_t Whence) {
281 #if DEBUG_RIFF
282 std::cout << "Chunk::SetPos(file_offset_t,stream_whence_t)" << std::endl;
283 #endif // DEBUG_RIFF
284 switch (Whence) {
285 case stream_curpos:
286 ullPos += Where;
287 break;
288 case stream_end:
289 ullPos = ullCurrentChunkSize - 1 - Where;
290 break;
291 case stream_backward:
292 ullPos -= Where;
293 break;
294 case stream_start: default:
295 ullPos = Where;
296 break;
297 }
298 if (ullPos > ullCurrentChunkSize) ullPos = ullCurrentChunkSize;
299 return ullPos;
300 }
301
302 /**
303 * Returns the number of bytes left to read in the chunk body.
304 * When reading data from the chunk using the Read*() Methods, the
305 * position within the chunk data (that is the chunk body) will be
306 * incremented by the number of read bytes and RemainingBytes() returns
307 * how much data is left to read from the current position to the end
308 * of the chunk data.
309 *
310 * @returns number of bytes left to read
311 */
312 file_offset_t Chunk::RemainingBytes() const {
313 #if DEBUG_RIFF
314 std::cout << "Chunk::Remainingbytes()=" << ullCurrentChunkSize - ullPos << std::endl;
315 #endif // DEBUG_RIFF
316 return (ullCurrentChunkSize > ullPos) ? ullCurrentChunkSize - ullPos : 0;
317 }
318
319 /**
320 * Returns the actual total size in bytes (including header) of this Chunk
321 * if being stored to a file.
322 *
323 * @param fileOffsetSize - RIFF file offset size (in bytes) assumed when
324 * being saved to a file
325 */
326 file_offset_t Chunk::RequiredPhysicalSize(int fileOffsetSize) {
327 return CHUNK_HEADER_SIZE(fileOffsetSize) + // RIFF chunk header
328 ullNewChunkSize + // chunks's actual data body
329 ullNewChunkSize % 2; // optional pad byte
330 }
331
332 /**
333 * Returns the current state of the chunk object.
334 * Following values are possible:
335 * - RIFF::stream_ready :
336 * chunk data can be read (this is the usual case)
337 * - RIFF::stream_closed :
338 * the data stream was closed somehow, no more reading possible
339 * - RIFF::stream_end_reached :
340 * already reached the end of the chunk data, no more reading
341 * possible without SetPos()
342 */
343 stream_state_t Chunk::GetState() const {
344 #if DEBUG_RIFF
345 std::cout << "Chunk::GetState()" << std::endl;
346 #endif // DEBUG_RIFF
347 #if POSIX
348 if (pFile->hFileRead == 0) return stream_closed;
349 #elif defined (WIN32)
350 if (pFile->hFileRead == INVALID_HANDLE_VALUE)
351 return stream_closed;
352 #else
353 if (pFile->hFileRead == NULL) return stream_closed;
354 #endif // POSIX
355 if (ullPos < ullCurrentChunkSize) return stream_ready;
356 else return stream_end_reached;
357 }
358
359 /**
360 * Reads \a WordCount number of data words with given \a WordSize and
361 * copies it into a buffer pointed by \a pData. The buffer has to be
362 * allocated and be sure to provide the correct \a WordSize, as this
363 * will be important and taken into account for eventual endian
364 * correction (swapping of bytes due to different native byte order of
365 * a system). The position within the chunk will automatically be
366 * incremented.
367 *
368 * @param pData destination buffer
369 * @param WordCount number of data words to read
370 * @param WordSize size of each data word to read
371 * @returns number of successfully read data words or 0 if end
372 * of file reached or error occurred
373 */
374 file_offset_t Chunk::Read(void* pData, file_offset_t WordCount, file_offset_t WordSize) {
375 #if DEBUG_RIFF
376 std::cout << "Chunk::Read(void*,file_offset_t,file_offset_t)" << std::endl;
377 #endif // DEBUG_RIFF
378 //if (ulStartPos == 0) return 0; // is only 0 if this is a new chunk, so nothing to read (yet)
379 if (ullPos >= ullCurrentChunkSize) return 0;
380 if (ullPos + WordCount * WordSize >= ullCurrentChunkSize) WordCount = (ullCurrentChunkSize - ullPos) / WordSize;
381 #if POSIX
382 if (lseek(pFile->hFileRead, ullStartPos + ullPos, SEEK_SET) < 0) return 0;
383 ssize_t readWords = read(pFile->hFileRead, pData, WordCount * WordSize);
384 if (readWords < 1) {
385 #if DEBUG_RIFF
386 std::cerr << "POSIX read() failed: " << strerror(errno) << std::endl << std::flush;
387 #endif // DEBUG_RIFF
388 return 0;
389 }
390 readWords /= WordSize;
391 #elif defined(WIN32)
392 LARGE_INTEGER liFilePos;
393 liFilePos.QuadPart = ullStartPos + ullPos;
394 if (!SetFilePointerEx(pFile->hFileRead, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN))
395 return 0;
396 DWORD readWords;
397 ReadFile(pFile->hFileRead, pData, WordCount * WordSize, &readWords, NULL); //FIXME: does not work for reading buffers larger than 2GB (even though this should rarely be the case in practice)
398 if (readWords < 1) return 0;
399 readWords /= WordSize;
400 #else // standard C functions
401 if (fseeko(pFile->hFileRead, ullStartPos + ullPos, SEEK_SET)) return 0;
402 file_offset_t readWords = fread(pData, WordSize, WordCount, pFile->hFileRead);
403 #endif // POSIX
404 if (!pFile->bEndianNative && WordSize != 1) {
405 switch (WordSize) {
406 case 2:
407 for (file_offset_t iWord = 0; iWord < readWords; iWord++)
408 swapBytes_16((uint16_t*) pData + iWord);
409 break;
410 case 4:
411 for (file_offset_t iWord = 0; iWord < readWords; iWord++)
412 swapBytes_32((uint32_t*) pData + iWord);
413 break;
414 case 8:
415 for (file_offset_t iWord = 0; iWord < readWords; iWord++)
416 swapBytes_64((uint64_t*) pData + iWord);
417 break;
418 default:
419 for (file_offset_t iWord = 0; iWord < readWords; iWord++)
420 swapBytes((uint8_t*) pData + iWord * WordSize, WordSize);
421 break;
422 }
423 }
424 SetPos(readWords * WordSize, stream_curpos);
425 return readWords;
426 }
427
428 /**
429 * Writes \a WordCount number of data words with given \a WordSize from
430 * the buffer pointed by \a pData. Be sure to provide the correct
431 * \a WordSize, as this will be important and taken into account for
432 * eventual endian correction (swapping of bytes due to different
433 * native byte order of a system). The position within the chunk will
434 * automatically be incremented.
435 *
436 * @param pData source buffer (containing the data)
437 * @param WordCount number of data words to write
438 * @param WordSize size of each data word to write
439 * @returns number of successfully written data words
440 * @throws RIFF::Exception if write operation would exceed current
441 * chunk size or any IO error occurred
442 * @see Resize()
443 */
444 file_offset_t Chunk::Write(void* pData, file_offset_t WordCount, file_offset_t WordSize) {
445 if (pFile->Mode != stream_mode_read_write)
446 throw Exception("Cannot write data to chunk, file has to be opened in read+write mode first");
447 if (ullPos >= ullCurrentChunkSize || ullPos + WordCount * WordSize > ullCurrentChunkSize)
448 throw Exception("End of chunk reached while trying to write data");
449 if (!pFile->bEndianNative && WordSize != 1) {
450 switch (WordSize) {
451 case 2:
452 for (file_offset_t iWord = 0; iWord < WordCount; iWord++)
453 swapBytes_16((uint16_t*) pData + iWord);
454 break;
455 case 4:
456 for (file_offset_t iWord = 0; iWord < WordCount; iWord++)
457 swapBytes_32((uint32_t*) pData + iWord);
458 break;
459 case 8:
460 for (file_offset_t iWord = 0; iWord < WordCount; iWord++)
461 swapBytes_64((uint64_t*) pData + iWord);
462 break;
463 default:
464 for (file_offset_t iWord = 0; iWord < WordCount; iWord++)
465 swapBytes((uint8_t*) pData + iWord * WordSize, WordSize);
466 break;
467 }
468 }
469 #if POSIX
470 if (lseek(pFile->hFileWrite, ullStartPos + ullPos, SEEK_SET) < 0) {
471 throw Exception("Could not seek to position " + ToString(ullPos) +
472 " in chunk (" + ToString(ullStartPos + ullPos) + " in file)");
473 }
474 ssize_t writtenWords = write(pFile->hFileWrite, pData, WordCount * WordSize);
475 if (writtenWords < 1) throw Exception("POSIX IO Error while trying to write chunk data");
476 writtenWords /= WordSize;
477 #elif defined(WIN32)
478 LARGE_INTEGER liFilePos;
479 liFilePos.QuadPart = ullStartPos + ullPos;
480 if (!SetFilePointerEx(pFile->hFileWrite, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN)) {
481 throw Exception("Could not seek to position " + ToString(ullPos) +
482 " in chunk (" + ToString(ullStartPos + ullPos) + " in file)");
483 }
484 DWORD writtenWords;
485 WriteFile(pFile->hFileWrite, pData, WordCount * WordSize, &writtenWords, NULL); //FIXME: does not work for writing buffers larger than 2GB (even though this should rarely be the case in practice)
486 if (writtenWords < 1) throw Exception("Windows IO Error while trying to write chunk data");
487 writtenWords /= WordSize;
488 #else // standard C functions
489 if (fseeko(pFile->hFileWrite, ullStartPos + ullPos, SEEK_SET)) {
490 throw Exception("Could not seek to position " + ToString(ullPos) +
491 " in chunk (" + ToString(ullStartPos + ullPos) + " in file)");
492 }
493 file_offset_t writtenWords = fwrite(pData, WordSize, WordCount, pFile->hFileWrite);
494 #endif // POSIX
495 SetPos(writtenWords * WordSize, stream_curpos);
496 return writtenWords;
497 }
498
499 /** Just an internal wrapper for the main <i>Read()</i> method with additional Exception throwing on errors. */
500 file_offset_t Chunk::ReadSceptical(void* pData, file_offset_t WordCount, file_offset_t WordSize) {
501 file_offset_t readWords = Read(pData, WordCount, WordSize);
502 if (readWords != WordCount) throw RIFF::Exception("End of chunk data reached.");
503 return readWords;
504 }
505
506 /**
507 * Reads \a WordCount number of 8 Bit signed integer words and copies it
508 * into the buffer pointed by \a pData. The buffer has to be allocated.
509 * The position within the chunk will automatically be incremented.
510 *
511 * @param pData destination buffer
512 * @param WordCount number of 8 Bit signed integers to read
513 * @returns number of read integers
514 * @throws RIFF::Exception if an error occurred or less than
515 * \a WordCount integers could be read!
516 */
517 file_offset_t Chunk::ReadInt8(int8_t* pData, file_offset_t WordCount) {
518 #if DEBUG_RIFF
519 std::cout << "Chunk::ReadInt8(int8_t*,file_offset_t)" << std::endl;
520 #endif // DEBUG_RIFF
521 return ReadSceptical(pData, WordCount, 1);
522 }
523
524 /**
525 * Writes \a WordCount number of 8 Bit signed integer words from the
526 * buffer pointed by \a pData to the chunk's body, directly to the
527 * actual "physical" file. The position within the chunk will
528 * automatically be incremented. Note: you cannot write beyond the
529 * boundaries of the chunk, to append data to the chunk call Resize()
530 * before.
531 *
532 * @param pData source buffer (containing the data)
533 * @param WordCount number of 8 Bit signed integers to write
534 * @returns number of written integers
535 * @throws RIFF::Exception if an IO error occurred
536 * @see Resize()
537 */
538 file_offset_t Chunk::WriteInt8(int8_t* pData, file_offset_t WordCount) {
539 return Write(pData, WordCount, 1);
540 }
541
542 /**
543 * Reads \a WordCount number of 8 Bit unsigned integer words and copies
544 * it into the buffer pointed by \a pData. The buffer has to be
545 * allocated. The position within the chunk will automatically be
546 * incremented.
547 *
548 * @param pData destination buffer
549 * @param WordCount number of 8 Bit unsigned integers to read
550 * @returns number of read integers
551 * @throws RIFF::Exception if an error occurred or less than
552 * \a WordCount integers could be read!
553 */
554 file_offset_t Chunk::ReadUint8(uint8_t* pData, file_offset_t WordCount) {
555 #if DEBUG_RIFF
556 std::cout << "Chunk::ReadUint8(uint8_t*,file_offset_t)" << std::endl;
557 #endif // DEBUG_RIFF
558 return ReadSceptical(pData, WordCount, 1);
559 }
560
561 /**
562 * Writes \a WordCount number of 8 Bit unsigned integer words from the
563 * buffer pointed by \a pData to the chunk's body, directly to the
564 * actual "physical" file. The position within the chunk will
565 * automatically be incremented. Note: you cannot write beyond the
566 * boundaries of the chunk, to append data to the chunk call Resize()
567 * before.
568 *
569 * @param pData source buffer (containing the data)
570 * @param WordCount number of 8 Bit unsigned integers to write
571 * @returns number of written integers
572 * @throws RIFF::Exception if an IO error occurred
573 * @see Resize()
574 */
575 file_offset_t Chunk::WriteUint8(uint8_t* pData, file_offset_t WordCount) {
576 return Write(pData, WordCount, 1);
577 }
578
579 /**
580 * Reads \a WordCount number of 16 Bit signed integer words and copies
581 * it into the buffer pointed by \a pData. The buffer has to be
582 * allocated. Endian correction will automatically be done if needed.
583 * The position within the chunk will automatically be incremented.
584 *
585 * @param pData destination buffer
586 * @param WordCount number of 16 Bit signed integers to read
587 * @returns number of read integers
588 * @throws RIFF::Exception if an error occurred or less than
589 * \a WordCount integers could be read!
590 */
591 file_offset_t Chunk::ReadInt16(int16_t* pData, file_offset_t WordCount) {
592 #if DEBUG_RIFF
593 std::cout << "Chunk::ReadInt16(int16_t*,file_offset_t)" << std::endl;
594 #endif // DEBUG_RIFF
595 return ReadSceptical(pData, WordCount, 2);
596 }
597
598 /**
599 * Writes \a WordCount number of 16 Bit signed integer words from the
600 * buffer pointed by \a pData to the chunk's body, directly to the
601 * actual "physical" file. The position within the chunk will
602 * automatically be incremented. Note: you cannot write beyond the
603 * boundaries of the chunk, to append data to the chunk call Resize()
604 * before.
605 *
606 * @param pData source buffer (containing the data)
607 * @param WordCount number of 16 Bit signed integers to write
608 * @returns number of written integers
609 * @throws RIFF::Exception if an IO error occurred
610 * @see Resize()
611 */
612 file_offset_t Chunk::WriteInt16(int16_t* pData, file_offset_t WordCount) {
613 return Write(pData, WordCount, 2);
614 }
615
616 /**
617 * Reads \a WordCount number of 16 Bit unsigned integer words and copies
618 * it into the buffer pointed by \a pData. The buffer has to be
619 * allocated. Endian correction will automatically be done if needed.
620 * The position within the chunk will automatically be incremented.
621 *
622 * @param pData destination buffer
623 * @param WordCount number of 8 Bit unsigned integers to read
624 * @returns number of read integers
625 * @throws RIFF::Exception if an error occurred or less than
626 * \a WordCount integers could be read!
627 */
628 file_offset_t Chunk::ReadUint16(uint16_t* pData, file_offset_t WordCount) {
629 #if DEBUG_RIFF
630 std::cout << "Chunk::ReadUint16(uint16_t*,file_offset_t)" << std::endl;
631 #endif // DEBUG_RIFF
632 return ReadSceptical(pData, WordCount, 2);
633 }
634
635 /**
636 * Writes \a WordCount number of 16 Bit unsigned integer words from the
637 * buffer pointed by \a pData to the chunk's body, directly to the
638 * actual "physical" file. The position within the chunk will
639 * automatically be incremented. Note: you cannot write beyond the
640 * boundaries of the chunk, to append data to the chunk call Resize()
641 * before.
642 *
643 * @param pData source buffer (containing the data)
644 * @param WordCount number of 16 Bit unsigned integers to write
645 * @returns number of written integers
646 * @throws RIFF::Exception if an IO error occurred
647 * @see Resize()
648 */
649 file_offset_t Chunk::WriteUint16(uint16_t* pData, file_offset_t WordCount) {
650 return Write(pData, WordCount, 2);
651 }
652
653 /**
654 * Reads \a WordCount number of 32 Bit signed integer words and copies
655 * it into the buffer pointed by \a pData. The buffer has to be
656 * allocated. Endian correction will automatically be done if needed.
657 * The position within the chunk will automatically be incremented.
658 *
659 * @param pData destination buffer
660 * @param WordCount number of 32 Bit signed integers to read
661 * @returns number of read integers
662 * @throws RIFF::Exception if an error occurred or less than
663 * \a WordCount integers could be read!
664 */
665 file_offset_t Chunk::ReadInt32(int32_t* pData, file_offset_t WordCount) {
666 #if DEBUG_RIFF
667 std::cout << "Chunk::ReadInt32(int32_t*,file_offset_t)" << std::endl;
668 #endif // DEBUG_RIFF
669 return ReadSceptical(pData, WordCount, 4);
670 }
671
672 /**
673 * Writes \a WordCount number of 32 Bit signed integer words from the
674 * buffer pointed by \a pData to the chunk's body, directly to the
675 * actual "physical" file. The position within the chunk will
676 * automatically be incremented. Note: you cannot write beyond the
677 * boundaries of the chunk, to append data to the chunk call Resize()
678 * before.
679 *
680 * @param pData source buffer (containing the data)
681 * @param WordCount number of 32 Bit signed integers to write
682 * @returns number of written integers
683 * @throws RIFF::Exception if an IO error occurred
684 * @see Resize()
685 */
686 file_offset_t Chunk::WriteInt32(int32_t* pData, file_offset_t WordCount) {
687 return Write(pData, WordCount, 4);
688 }
689
690 /**
691 * Reads \a WordCount number of 32 Bit unsigned integer words and copies
692 * it into the buffer pointed by \a pData. The buffer has to be
693 * allocated. Endian correction will automatically be done if needed.
694 * The position within the chunk will automatically be incremented.
695 *
696 * @param pData destination buffer
697 * @param WordCount number of 32 Bit unsigned integers to read
698 * @returns number of read integers
699 * @throws RIFF::Exception if an error occurred or less than
700 * \a WordCount integers could be read!
701 */
702 file_offset_t Chunk::ReadUint32(uint32_t* pData, file_offset_t WordCount) {
703 #if DEBUG_RIFF
704 std::cout << "Chunk::ReadUint32(uint32_t*,file_offset_t)" << std::endl;
705 #endif // DEBUG_RIFF
706 return ReadSceptical(pData, WordCount, 4);
707 }
708
709 /**
710 * Reads a null-padded string of size characters and copies it
711 * into the string \a s. The position within the chunk will
712 * automatically be incremented.
713 *
714 * @param s destination string
715 * @param size number of characters to read
716 * @throws RIFF::Exception if an error occurred or less than
717 * \a size characters could be read!
718 */
719 void Chunk::ReadString(String& s, int size) {
720 char* buf = new char[size];
721 ReadSceptical(buf, 1, size);
722 s.assign(buf, std::find(buf, buf + size, '\0'));
723 delete[] buf;
724 }
725
726 /**
727 * Writes \a WordCount number of 32 Bit unsigned integer words from the
728 * buffer pointed by \a pData to the chunk's body, directly to the
729 * actual "physical" file. The position within the chunk will
730 * automatically be incremented. Note: you cannot write beyond the
731 * boundaries of the chunk, to append data to the chunk call Resize()
732 * before.
733 *
734 * @param pData source buffer (containing the data)
735 * @param WordCount number of 32 Bit unsigned integers to write
736 * @returns number of written integers
737 * @throws RIFF::Exception if an IO error occurred
738 * @see Resize()
739 */
740 file_offset_t Chunk::WriteUint32(uint32_t* pData, file_offset_t WordCount) {
741 return Write(pData, WordCount, 4);
742 }
743
744 /**
745 * Reads one 8 Bit signed integer word and increments the position within
746 * the chunk.
747 *
748 * @returns read integer word
749 * @throws RIFF::Exception if an error occurred
750 */
751 int8_t Chunk::ReadInt8() {
752 #if DEBUG_RIFF
753 std::cout << "Chunk::ReadInt8()" << std::endl;
754 #endif // DEBUG_RIFF
755 int8_t word;
756 ReadSceptical(&word,1,1);
757 return word;
758 }
759
760 /**
761 * Reads one 8 Bit unsigned integer word and increments the position
762 * within the chunk.
763 *
764 * @returns read integer word
765 * @throws RIFF::Exception if an error occurred
766 */
767 uint8_t Chunk::ReadUint8() {
768 #if DEBUG_RIFF
769 std::cout << "Chunk::ReadUint8()" << std::endl;
770 #endif // DEBUG_RIFF
771 uint8_t word;
772 ReadSceptical(&word,1,1);
773 return word;
774 }
775
776 /**
777 * Reads one 16 Bit signed integer word and increments the position
778 * within the chunk. Endian correction will automatically be done if
779 * needed.
780 *
781 * @returns read integer word
782 * @throws RIFF::Exception if an error occurred
783 */
784 int16_t Chunk::ReadInt16() {
785 #if DEBUG_RIFF
786 std::cout << "Chunk::ReadInt16()" << std::endl;
787 #endif // DEBUG_RIFF
788 int16_t word;
789 ReadSceptical(&word,1,2);
790 return word;
791 }
792
793 /**
794 * Reads one 16 Bit unsigned integer word and increments the position
795 * within the chunk. Endian correction will automatically be done if
796 * needed.
797 *
798 * @returns read integer word
799 * @throws RIFF::Exception if an error occurred
800 */
801 uint16_t Chunk::ReadUint16() {
802 #if DEBUG_RIFF
803 std::cout << "Chunk::ReadUint16()" << std::endl;
804 #endif // DEBUG_RIFF
805 uint16_t word;
806 ReadSceptical(&word,1,2);
807 return word;
808 }
809
810 /**
811 * Reads one 32 Bit signed integer word and increments the position
812 * within the chunk. Endian correction will automatically be done if
813 * needed.
814 *
815 * @returns read integer word
816 * @throws RIFF::Exception if an error occurred
817 */
818 int32_t Chunk::ReadInt32() {
819 #if DEBUG_RIFF
820 std::cout << "Chunk::ReadInt32()" << std::endl;
821 #endif // DEBUG_RIFF
822 int32_t word;
823 ReadSceptical(&word,1,4);
824 return word;
825 }
826
827 /**
828 * Reads one 32 Bit unsigned integer word and increments the position
829 * within the chunk. Endian correction will automatically be done if
830 * needed.
831 *
832 * @returns read integer word
833 * @throws RIFF::Exception if an error occurred
834 */
835 uint32_t Chunk::ReadUint32() {
836 #if DEBUG_RIFF
837 std::cout << "Chunk::ReadUint32()" << std::endl;
838 #endif // DEBUG_RIFF
839 uint32_t word;
840 ReadSceptical(&word,1,4);
841 return word;
842 }
843
844 /** @brief Load chunk body into RAM.
845 *
846 * Loads the whole chunk body into memory. You can modify the data in
847 * RAM and save the data by calling File::Save() afterwards.
848 *
849 * <b>Caution:</b> the buffer pointer will be invalidated once
850 * File::Save() was called. You have to call LoadChunkData() again to
851 * get a new, valid pointer whenever File::Save() was called.
852 *
853 * You can call LoadChunkData() again if you previously scheduled to
854 * enlarge this chunk with a Resize() call. In that case the buffer will
855 * be enlarged to the new, scheduled chunk size and you can already
856 * place the new chunk data to the buffer and finally call File::Save()
857 * to enlarge the chunk physically and write the new data in one rush.
858 * This approach is definitely recommended if you have to enlarge and
859 * write new data to a lot of chunks.
860 *
861 * @returns a pointer to the data in RAM on success, NULL otherwise
862 * @throws Exception if data buffer could not be enlarged
863 * @see ReleaseChunkData()
864 */
865 void* Chunk::LoadChunkData() {
866 if (!pChunkData && pFile->Filename != "" /*&& ulStartPos != 0*/) {
867 #if POSIX
868 if (lseek(pFile->hFileRead, ullStartPos, SEEK_SET) == -1) return NULL;
869 #elif defined(WIN32)
870 LARGE_INTEGER liFilePos;
871 liFilePos.QuadPart = ullStartPos;
872 if (!SetFilePointerEx(pFile->hFileRead, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN)) return NULL;
873 #else
874 if (fseeko(pFile->hFileRead, ullStartPos, SEEK_SET)) return NULL;
875 #endif // POSIX
876 file_offset_t ullBufferSize = (ullCurrentChunkSize > ullNewChunkSize) ? ullCurrentChunkSize : ullNewChunkSize;
877 pChunkData = new uint8_t[ullBufferSize];
878 if (!pChunkData) return NULL;
879 memset(pChunkData, 0, ullBufferSize);
880 #if POSIX
881 file_offset_t readWords = read(pFile->hFileRead, pChunkData, GetSize());
882 #elif defined(WIN32)
883 DWORD readWords;
884 ReadFile(pFile->hFileRead, pChunkData, GetSize(), &readWords, NULL); //FIXME: won't load chunks larger than 2GB !
885 #else
886 file_offset_t readWords = fread(pChunkData, 1, GetSize(), pFile->hFileRead);
887 #endif // POSIX
888 if (readWords != GetSize()) {
889 delete[] pChunkData;
890 return (pChunkData = NULL);
891 }
892 ullChunkDataSize = ullBufferSize;
893 } else if (ullNewChunkSize > ullChunkDataSize) {
894 uint8_t* pNewBuffer = new uint8_t[ullNewChunkSize];
895 if (!pNewBuffer) throw Exception("Could not enlarge chunk data buffer to " + ToString(ullNewChunkSize) + " bytes");
896 memset(pNewBuffer, 0 , ullNewChunkSize);
897 if (pChunkData) {
898 memcpy(pNewBuffer, pChunkData, ullChunkDataSize);
899 delete[] pChunkData;
900 }
901 pChunkData = pNewBuffer;
902 ullChunkDataSize = ullNewChunkSize;
903 }
904 return pChunkData;
905 }
906
907 /** @brief Free loaded chunk body from RAM.
908 *
909 * Frees loaded chunk body data from memory (RAM). You should call
910 * File::Save() before calling this method if you modified the data to
911 * make the changes persistent.
912 */
913 void Chunk::ReleaseChunkData() {
914 if (pChunkData) {
915 delete[] pChunkData;
916 pChunkData = NULL;
917 }
918 }
919
920 /** @brief Resize chunk.
921 *
922 * Resizes this chunk's body, that is the actual size of data possible
923 * to be written to this chunk. This call will return immediately and
924 * just schedule the resize operation. You should call File::Save() to
925 * actually perform the resize operation(s) "physically" to the file.
926 * As this can take a while on large files, it is recommended to call
927 * Resize() first on all chunks which have to be resized and finally to
928 * call File::Save() to perform all those resize operations in one rush.
929 *
930 * <b>Caution:</b> You cannot directly write to enlarged chunks before
931 * calling File::Save() as this might exceed the current chunk's body
932 * boundary!
933 *
934 * @param NewSize - new chunk body size in bytes (must be greater than zero)
935 * @throws RIFF::Exception if \a NewSize is less than 1 or unrealistic large
936 * @see File::Save()
937 */
938 void Chunk::Resize(file_offset_t NewSize) {
939 if (NewSize == 0)
940 throw Exception("There is at least one empty chunk (zero size): " + __resolveChunkPath(this));
941 if ((NewSize >> 48) != 0)
942 throw Exception("Unrealistic high chunk size detected: " + __resolveChunkPath(this));
943 if (ullNewChunkSize == NewSize) return;
944 ullNewChunkSize = NewSize;
945 }
946
947 /** @brief Write chunk persistently e.g. to disk.
948 *
949 * Stores the chunk persistently to its actual "physical" file.
950 *
951 * @param ullWritePos - position within the "physical" file where this
952 * chunk should be written to
953 * @param ullCurrentDataOffset - offset of current (old) data within
954 * the file
955 * @param pProgress - optional: callback function for progress notification
956 * @returns new write position in the "physical" file, that is
957 * \a ullWritePos incremented by this chunk's new size
958 * (including its header size of course)
959 */
960 file_offset_t Chunk::WriteChunk(file_offset_t ullWritePos, file_offset_t ullCurrentDataOffset, progress_t* pProgress) {
961 const file_offset_t ullOriginalPos = ullWritePos;
962 ullWritePos += CHUNK_HEADER_SIZE(pFile->FileOffsetSize);
963
964 if (pFile->Mode != stream_mode_read_write)
965 throw Exception("Cannot write list chunk, file has to be opened in read+write mode");
966
967 // if the whole chunk body was loaded into RAM
968 if (pChunkData) {
969 // make sure chunk data buffer in RAM is at least as large as the new chunk size
970 LoadChunkData();
971 // write chunk data from RAM persistently to the file
972 #if POSIX
973 lseek(pFile->hFileWrite, ullWritePos, SEEK_SET);
974 if (write(pFile->hFileWrite, pChunkData, ullNewChunkSize) != ullNewChunkSize) {
975 throw Exception("Writing Chunk data (from RAM) failed");
976 }
977 #elif defined(WIN32)
978 LARGE_INTEGER liFilePos;
979 liFilePos.QuadPart = ullWritePos;
980 SetFilePointerEx(pFile->hFileWrite, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN);
981 DWORD dwBytesWritten;
982 WriteFile(pFile->hFileWrite, pChunkData, ullNewChunkSize, &dwBytesWritten, NULL); //FIXME: won't save chunks larger than 2GB !
983 if (dwBytesWritten != ullNewChunkSize) {
984 throw Exception("Writing Chunk data (from RAM) failed");
985 }
986 #else
987 fseeko(pFile->hFileWrite, ullWritePos, SEEK_SET);
988 if (fwrite(pChunkData, 1, ullNewChunkSize, pFile->hFileWrite) != ullNewChunkSize) {
989 throw Exception("Writing Chunk data (from RAM) failed");
990 }
991 #endif // POSIX
992 } else {
993 // move chunk data from the end of the file to the appropriate position
994 int8_t* pCopyBuffer = new int8_t[4096];
995 file_offset_t ullToMove = (ullNewChunkSize < ullCurrentChunkSize) ? ullNewChunkSize : ullCurrentChunkSize;
996 #if defined(WIN32)
997 DWORD iBytesMoved = 1; // we have to pass it via pointer to the Windows API, thus the correct size must be ensured
998 #else
999 int iBytesMoved = 1;
1000 #endif
1001 for (file_offset_t ullOffset = 0; ullToMove > 0 && iBytesMoved > 0; ullOffset += iBytesMoved, ullToMove -= iBytesMoved) {
1002 iBytesMoved = (ullToMove < 4096) ? int(ullToMove) : 4096;
1003 #if POSIX
1004 lseek(pFile->hFileRead, ullStartPos + ullCurrentDataOffset + ullOffset, SEEK_SET);
1005 iBytesMoved = (int) read(pFile->hFileRead, pCopyBuffer, (size_t) iBytesMoved);
1006 lseek(pFile->hFileWrite, ullWritePos + ullOffset, SEEK_SET);
1007 iBytesMoved = (int) write(pFile->hFileWrite, pCopyBuffer, (size_t) iBytesMoved);
1008 #elif defined(WIN32)
1009 LARGE_INTEGER liFilePos;
1010 liFilePos.QuadPart = ullStartPos + ullCurrentDataOffset + ullOffset;
1011 SetFilePointerEx(pFile->hFileRead, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN);
1012 ReadFile(pFile->hFileRead, pCopyBuffer, iBytesMoved, &iBytesMoved, NULL);
1013 liFilePos.QuadPart = ullWritePos + ullOffset;
1014 SetFilePointerEx(pFile->hFileWrite, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN);
1015 WriteFile(pFile->hFileWrite, pCopyBuffer, iBytesMoved, &iBytesMoved, NULL);
1016 #else
1017 fseeko(pFile->hFileRead, ullStartPos + ullCurrentDataOffset + ullOffset, SEEK_SET);
1018 iBytesMoved = fread(pCopyBuffer, 1, iBytesMoved, pFile->hFileRead);
1019 fseeko(pFile->hFileWrite, ullWritePos + ullOffset, SEEK_SET);
1020 iBytesMoved = fwrite(pCopyBuffer, 1, iBytesMoved, pFile->hFileWrite);
1021 #endif
1022 }
1023 delete[] pCopyBuffer;
1024 if (iBytesMoved < 0) throw Exception("Writing Chunk data (from file) failed");
1025 }
1026
1027 // update this chunk's header
1028 ullCurrentChunkSize = ullNewChunkSize;
1029 WriteHeader(ullOriginalPos);
1030
1031 if (pProgress)
1032 __notify_progress(pProgress, 1.0); // notify done
1033
1034 // update chunk's position pointers
1035 ullStartPos = ullOriginalPos + CHUNK_HEADER_SIZE(pFile->FileOffsetSize);
1036 ullPos = 0;
1037
1038 // add pad byte if needed
1039 if ((ullStartPos + ullNewChunkSize) % 2 != 0) {
1040 const char cPadByte = 0;
1041 #if POSIX
1042 lseek(pFile->hFileWrite, ullStartPos + ullNewChunkSize, SEEK_SET);
1043 write(pFile->hFileWrite, &cPadByte, 1);
1044 #elif defined(WIN32)
1045 LARGE_INTEGER liFilePos;
1046 liFilePos.QuadPart = ullStartPos + ullNewChunkSize;
1047 SetFilePointerEx(pFile->hFileWrite, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN);
1048 DWORD dwBytesWritten;
1049 WriteFile(pFile->hFileWrite, &cPadByte, 1, &dwBytesWritten, NULL);
1050 #else
1051 fseeko(pFile->hFileWrite, ullStartPos + ullNewChunkSize, SEEK_SET);
1052 fwrite(&cPadByte, 1, 1, pFile->hFileWrite);
1053 #endif
1054 return ullStartPos + ullNewChunkSize + 1;
1055 }
1056
1057 return ullStartPos + ullNewChunkSize;
1058 }
1059
1060 void Chunk::__resetPos() {
1061 ullPos = 0;
1062 }
1063
1064
1065
1066 // *************** List ***************
1067 // *
1068
1069 List::List(File* pFile) : Chunk(pFile) {
1070 #if DEBUG_RIFF
1071 std::cout << "List::List(File* pFile)" << std::endl;
1072 #endif // DEBUG_RIFF
1073 pSubChunks = NULL;
1074 pSubChunksMap = NULL;
1075 }
1076
1077 List::List(File* pFile, file_offset_t StartPos, List* Parent)
1078 : Chunk(pFile, StartPos, Parent) {
1079 #if DEBUG_RIFF
1080 std::cout << "List::List(File*,file_offset_t,List*)" << std::endl;
1081 #endif // DEBUG_RIFF
1082 pSubChunks = NULL;
1083 pSubChunksMap = NULL;
1084 ReadHeader(StartPos);
1085 ullStartPos = StartPos + LIST_HEADER_SIZE(pFile->FileOffsetSize);
1086 }
1087
1088 List::List(File* pFile, List* pParent, uint32_t uiListID)
1089 : Chunk(pFile, pParent, CHUNK_ID_LIST, 0) {
1090 pSubChunks = NULL;
1091 pSubChunksMap = NULL;
1092 ListType = uiListID;
1093 }
1094
1095 List::~List() {
1096 #if DEBUG_RIFF
1097 std::cout << "List::~List()" << std::endl;
1098 #endif // DEBUG_RIFF
1099 DeleteChunkList();
1100 }
1101
1102 void List::DeleteChunkList() {
1103 if (pSubChunks) {
1104 ChunkList::iterator iter = pSubChunks->begin();
1105 ChunkList::iterator end = pSubChunks->end();
1106 while (iter != end) {
1107 delete *iter;
1108 iter++;
1109 }
1110 delete pSubChunks;
1111 pSubChunks = NULL;
1112 }
1113 if (pSubChunksMap) {
1114 delete pSubChunksMap;
1115 pSubChunksMap = NULL;
1116 }
1117 }
1118
1119 /**
1120 * Returns subchunk with chunk ID <i>\a ChunkID</i> within this chunk
1121 * list. Use this method if you expect only one subchunk of that type in
1122 * the list. It there are more than one, it's undetermined which one of
1123 * them will be returned! If there are no subchunks with that desired
1124 * chunk ID, NULL will be returned.
1125 *
1126 * @param ChunkID - chunk ID of the sought subchunk
1127 * @returns pointer to the subchunk or NULL if there is none of
1128 * that ID
1129 */
1130 Chunk* List::GetSubChunk(uint32_t ChunkID) {
1131 #if DEBUG_RIFF
1132 std::cout << "List::GetSubChunk(uint32_t)" << std::endl;
1133 #endif // DEBUG_RIFF
1134 if (!pSubChunksMap) LoadSubChunks();
1135 return (*pSubChunksMap)[ChunkID];
1136 }
1137
1138 /**
1139 * Returns sublist chunk with list type <i>\a ListType</i> within this
1140 * chunk list. Use this method if you expect only one sublist chunk of
1141 * that type in the list. If there are more than one, it's undetermined
1142 * which one of them will be returned! If there are no sublists with
1143 * that desired list type, NULL will be returned.
1144 *
1145 * @param ListType - list type of the sought sublist
1146 * @returns pointer to the sublist or NULL if there is none of
1147 * that type
1148 */
1149 List* List::GetSubList(uint32_t ListType) {
1150 #if DEBUG_RIFF
1151 std::cout << "List::GetSubList(uint32_t)" << std::endl;
1152 #endif // DEBUG_RIFF
1153 if (!pSubChunks) LoadSubChunks();
1154 ChunkList::iterator iter = pSubChunks->begin();
1155 ChunkList::iterator end = pSubChunks->end();
1156 while (iter != end) {
1157 if ((*iter)->GetChunkID() == CHUNK_ID_LIST) {
1158 List* l = (List*) *iter;
1159 if (l->GetListType() == ListType) return l;
1160 }
1161 iter++;
1162 }
1163 return NULL;
1164 }
1165
1166 /**
1167 * Returns the first subchunk within the list (which may be an ordinary
1168 * chunk as well as a list chunk). You have to call this
1169 * method before you can call GetNextSubChunk(). Recall it when you want
1170 * to start from the beginning of the list again.
1171 *
1172 * @returns pointer to the first subchunk within the list, NULL
1173 * otherwise
1174 */
1175 Chunk* List::GetFirstSubChunk() {
1176 #if DEBUG_RIFF
1177 std::cout << "List::GetFirstSubChunk()" << std::endl;
1178 #endif // DEBUG_RIFF
1179 if (!pSubChunks) LoadSubChunks();
1180 ChunksIterator = pSubChunks->begin();
1181 return (ChunksIterator != pSubChunks->end()) ? *ChunksIterator : NULL;
1182 }
1183
1184 /**
1185 * Returns the next subchunk within the list (which may be an ordinary
1186 * chunk as well as a list chunk). You have to call
1187 * GetFirstSubChunk() before you can use this method!
1188 *
1189 * @returns pointer to the next subchunk within the list or NULL if
1190 * end of list is reached
1191 */
1192 Chunk* List::GetNextSubChunk() {
1193 #if DEBUG_RIFF
1194 std::cout << "List::GetNextSubChunk()" << std::endl;
1195 #endif // DEBUG_RIFF
1196 if (!pSubChunks) return NULL;
1197 ChunksIterator++;
1198 return (ChunksIterator != pSubChunks->end()) ? *ChunksIterator : NULL;
1199 }
1200
1201 /**
1202 * Returns the first sublist within the list (that is a subchunk with
1203 * chunk ID "LIST"). You have to call this method before you can call
1204 * GetNextSubList(). Recall it when you want to start from the beginning
1205 * of the list again.
1206 *
1207 * @returns pointer to the first sublist within the list, NULL
1208 * otherwise
1209 */
1210 List* List::GetFirstSubList() {
1211 #if DEBUG_RIFF
1212 std::cout << "List::GetFirstSubList()" << std::endl;
1213 #endif // DEBUG_RIFF
1214 if (!pSubChunks) LoadSubChunks();
1215 ListIterator = pSubChunks->begin();
1216 ChunkList::iterator end = pSubChunks->end();
1217 while (ListIterator != end) {
1218 if ((*ListIterator)->GetChunkID() == CHUNK_ID_LIST) return (List*) *ListIterator;
1219 ListIterator++;
1220 }
1221 return NULL;
1222 }
1223
1224 /**
1225 * Returns the next sublist (that is a subchunk with chunk ID "LIST")
1226 * within the list. You have to call GetFirstSubList() before you can
1227 * use this method!
1228 *
1229 * @returns pointer to the next sublist within the list, NULL if
1230 * end of list is reached
1231 */
1232 List* List::GetNextSubList() {
1233 #if DEBUG_RIFF
1234 std::cout << "List::GetNextSubList()" << std::endl;
1235 #endif // DEBUG_RIFF
1236 if (!pSubChunks) return NULL;
1237 if (ListIterator == pSubChunks->end()) return NULL;
1238 ListIterator++;
1239 ChunkList::iterator end = pSubChunks->end();
1240 while (ListIterator != end) {
1241 if ((*ListIterator)->GetChunkID() == CHUNK_ID_LIST) return (List*) *ListIterator;
1242 ListIterator++;
1243 }
1244 return NULL;
1245 }
1246
1247 /**
1248 * Returns number of subchunks within the list (including list chunks).
1249 */
1250 size_t List::CountSubChunks() {
1251 if (!pSubChunks) LoadSubChunks();
1252 return pSubChunks->size();
1253 }
1254
1255 /**
1256 * Returns number of subchunks within the list with chunk ID
1257 * <i>\a ChunkId</i>.
1258 */
1259 size_t List::CountSubChunks(uint32_t ChunkID) {
1260 size_t result = 0;
1261 if (!pSubChunks) LoadSubChunks();
1262 ChunkList::iterator iter = pSubChunks->begin();
1263 ChunkList::iterator end = pSubChunks->end();
1264 while (iter != end) {
1265 if ((*iter)->GetChunkID() == ChunkID) {
1266 result++;
1267 }
1268 iter++;
1269 }
1270 return result;
1271 }
1272
1273 /**
1274 * Returns number of sublists within the list.
1275 */
1276 size_t List::CountSubLists() {
1277 return CountSubChunks(CHUNK_ID_LIST);
1278 }
1279
1280 /**
1281 * Returns number of sublists within the list with list type
1282 * <i>\a ListType</i>
1283 */
1284 size_t List::CountSubLists(uint32_t ListType) {
1285 size_t result = 0;
1286 if (!pSubChunks) LoadSubChunks();
1287 ChunkList::iterator iter = pSubChunks->begin();
1288 ChunkList::iterator end = pSubChunks->end();
1289 while (iter != end) {
1290 if ((*iter)->GetChunkID() == CHUNK_ID_LIST) {
1291 List* l = (List*) *iter;
1292 if (l->GetListType() == ListType) result++;
1293 }
1294 iter++;
1295 }
1296 return result;
1297 }
1298
1299 /** @brief Creates a new sub chunk.
1300 *
1301 * Creates and adds a new sub chunk to this list chunk. Note that the
1302 * chunk's body size given by \a ullBodySize must be greater than zero.
1303 * You have to call File::Save() to make this change persistent to the
1304 * actual file and <b>before</b> performing any data write operations
1305 * on the new chunk!
1306 *
1307 * @param uiChunkID - chunk ID of the new chunk
1308 * @param ullBodySize - size of the new chunk's body, that is its actual
1309 * data size (without header)
1310 * @throws RIFF::Exception if \a ullBodySize equals zero
1311 */
1312 Chunk* List::AddSubChunk(uint32_t uiChunkID, file_offset_t ullBodySize) {
1313 if (ullBodySize == 0) throw Exception("Chunk body size must be at least 1 byte");
1314 if (!pSubChunks) LoadSubChunks();
1315 Chunk* pNewChunk = new Chunk(pFile, this, uiChunkID, 0);
1316 pSubChunks->push_back(pNewChunk);
1317 (*pSubChunksMap)[uiChunkID] = pNewChunk;
1318 pNewChunk->Resize(ullBodySize);
1319 ullNewChunkSize += CHUNK_HEADER_SIZE(pFile->FileOffsetSize);
1320 return pNewChunk;
1321 }
1322
1323 /** @brief Moves a sub chunk witin this list.
1324 *
1325 * Moves a sub chunk from one position in this list to another
1326 * position in the same list. The pSrc chunk is placed before the
1327 * pDst chunk.
1328 *
1329 * @param pSrc - sub chunk to be moved
1330 * @param pDst - the position to move to. pSrc will be placed
1331 * before pDst. If pDst is 0, pSrc will be placed
1332 * last in list.
1333 */
1334 void List::MoveSubChunk(Chunk* pSrc, Chunk* pDst) {
1335 if (!pSubChunks) LoadSubChunks();
1336 pSubChunks->remove(pSrc);
1337 ChunkList::iterator iter = find(pSubChunks->begin(), pSubChunks->end(), pDst);
1338 pSubChunks->insert(iter, pSrc);
1339 }
1340
1341 /** @brief Moves a sub chunk from this list to another list.
1342 *
1343 * Moves a sub chunk from this list list to the end of another
1344 * list.
1345 *
1346 * @param pSrc - sub chunk to be moved
1347 * @param pDst - destination list where the chunk shall be moved to
1348 */
1349 void List::MoveSubChunk(Chunk* pSrc, List* pNewParent) {
1350 if (pNewParent == this || !pNewParent) return;
1351 if (!pSubChunks) LoadSubChunks();
1352 if (!pNewParent->pSubChunks) pNewParent->LoadSubChunks();
1353 pSubChunks->remove(pSrc);
1354 pNewParent->pSubChunks->push_back(pSrc);
1355 // update chunk id map of this List
1356 if ((*pSubChunksMap)[pSrc->GetChunkID()] == pSrc) {
1357 pSubChunksMap->erase(pSrc->GetChunkID());
1358 // try to find another chunk of the same chunk ID
1359 ChunkList::iterator iter = pSubChunks->begin();
1360 ChunkList::iterator end = pSubChunks->end();
1361 for (; iter != end; ++iter) {
1362 if ((*iter)->GetChunkID() == pSrc->GetChunkID()) {
1363 (*pSubChunksMap)[pSrc->GetChunkID()] = *iter;
1364 break; // we're done, stop search
1365 }
1366 }
1367 }
1368 // update chunk id map of other list
1369 if (!(*pNewParent->pSubChunksMap)[pSrc->GetChunkID()])
1370 (*pNewParent->pSubChunksMap)[pSrc->GetChunkID()] = pSrc;
1371 }
1372
1373 /** @brief Creates a new list sub chunk.
1374 *
1375 * Creates and adds a new list sub chunk to this list chunk. Note that
1376 * you have to add sub chunks / sub list chunks to the new created chunk
1377 * <b>before</b> trying to make this change persisten to the actual
1378 * file with File::Save()!
1379 *
1380 * @param uiListType - list ID of the new list chunk
1381 */
1382 List* List::AddSubList(uint32_t uiListType) {
1383 if (!pSubChunks) LoadSubChunks();
1384 List* pNewListChunk = new List(pFile, this, uiListType);
1385 pSubChunks->push_back(pNewListChunk);
1386 (*pSubChunksMap)[CHUNK_ID_LIST] = pNewListChunk;
1387 ullNewChunkSize += LIST_HEADER_SIZE(pFile->FileOffsetSize);
1388 return pNewListChunk;
1389 }
1390
1391 /** @brief Removes a sub chunk.
1392 *
1393 * Removes the sub chunk given by \a pSubChunk from this list and frees
1394 * it completely from RAM. The given chunk can either be a normal sub
1395 * chunk or a list sub chunk. In case the given chunk is a list chunk,
1396 * all its subchunks (if any) will be removed recursively as well. You
1397 * should call File::Save() to make this change persistent at any time.
1398 *
1399 * @param pSubChunk - sub chunk or sub list chunk to be removed
1400 */
1401 void List::DeleteSubChunk(Chunk* pSubChunk) {
1402 if (!pSubChunks) LoadSubChunks();
1403 pSubChunks->remove(pSubChunk);
1404 if ((*pSubChunksMap)[pSubChunk->GetChunkID()] == pSubChunk) {
1405 pSubChunksMap->erase(pSubChunk->GetChunkID());
1406 // try to find another chunk of the same chunk ID
1407 ChunkList::iterator iter = pSubChunks->begin();
1408 ChunkList::iterator end = pSubChunks->end();
1409 for (; iter != end; ++iter) {
1410 if ((*iter)->GetChunkID() == pSubChunk->GetChunkID()) {
1411 (*pSubChunksMap)[pSubChunk->GetChunkID()] = *iter;
1412 break; // we're done, stop search
1413 }
1414 }
1415 }
1416 delete pSubChunk;
1417 }
1418
1419 /**
1420 * Returns the actual total size in bytes (including List chunk header and
1421 * all subchunks) of this List Chunk if being stored to a file.
1422 *
1423 * @param fileOffsetSize - RIFF file offset size (in bytes) assumed when
1424 * being saved to a file
1425 */
1426 file_offset_t List::RequiredPhysicalSize(int fileOffsetSize) {
1427 if (!pSubChunks) LoadSubChunks();
1428 file_offset_t size = LIST_HEADER_SIZE(fileOffsetSize);
1429 ChunkList::iterator iter = pSubChunks->begin();
1430 ChunkList::iterator end = pSubChunks->end();
1431 for (; iter != end; ++iter)
1432 size += (*iter)->RequiredPhysicalSize(fileOffsetSize);
1433 return size;
1434 }
1435
1436 void List::ReadHeader(file_offset_t filePos) {
1437 #if DEBUG_RIFF
1438 std::cout << "List::Readheader(file_offset_t) ";
1439 #endif // DEBUG_RIFF
1440 Chunk::ReadHeader(filePos);
1441 if (ullCurrentChunkSize < 4) return;
1442 ullNewChunkSize = ullCurrentChunkSize -= 4;
1443 #if POSIX
1444 lseek(pFile->hFileRead, filePos + CHUNK_HEADER_SIZE(pFile->FileOffsetSize), SEEK_SET);
1445 read(pFile->hFileRead, &ListType, 4);
1446 #elif defined(WIN32)
1447 LARGE_INTEGER liFilePos;
1448 liFilePos.QuadPart = filePos + CHUNK_HEADER_SIZE(pFile->FileOffsetSize);
1449 SetFilePointerEx(pFile->hFileRead, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN);
1450 DWORD dwBytesRead;
1451 ReadFile(pFile->hFileRead, &ListType, 4, &dwBytesRead, NULL);
1452 #else
1453 fseeko(pFile->hFileRead, filePos + CHUNK_HEADER_SIZE(pFile->FileOffsetSize), SEEK_SET);
1454 fread(&ListType, 4, 1, pFile->hFileRead);
1455 #endif // POSIX
1456 #if DEBUG_RIFF
1457 std::cout << "listType=" << convertToString(ListType) << std::endl;
1458 #endif // DEBUG_RIFF
1459 if (!pFile->bEndianNative) {
1460 //swapBytes_32(&ListType);
1461 }
1462 }
1463
1464 void List::WriteHeader(file_offset_t filePos) {
1465 // the four list type bytes officially belong the chunk's body in the RIFF format
1466 ullNewChunkSize += 4;
1467 Chunk::WriteHeader(filePos);
1468 ullNewChunkSize -= 4; // just revert the +4 incrementation
1469 #if POSIX
1470 lseek(pFile->hFileWrite, filePos + CHUNK_HEADER_SIZE(pFile->FileOffsetSize), SEEK_SET);
1471 write(pFile->hFileWrite, &ListType, 4);
1472 #elif defined(WIN32)
1473 LARGE_INTEGER liFilePos;
1474 liFilePos.QuadPart = filePos + CHUNK_HEADER_SIZE(pFile->FileOffsetSize);
1475 SetFilePointerEx(pFile->hFileWrite, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN);
1476 DWORD dwBytesWritten;
1477 WriteFile(pFile->hFileWrite, &ListType, 4, &dwBytesWritten, NULL);
1478 #else
1479 fseeko(pFile->hFileWrite, filePos + CHUNK_HEADER_SIZE(pFile->FileOffsetSize), SEEK_SET);
1480 fwrite(&ListType, 4, 1, pFile->hFileWrite);
1481 #endif // POSIX
1482 }
1483
1484 void List::LoadSubChunks(progress_t* pProgress) {
1485 #if DEBUG_RIFF
1486 std::cout << "List::LoadSubChunks()";
1487 #endif // DEBUG_RIFF
1488 if (!pSubChunks) {
1489 pSubChunks = new ChunkList();
1490 pSubChunksMap = new ChunkMap();
1491 #if defined(WIN32)
1492 if (pFile->hFileRead == INVALID_HANDLE_VALUE) return;
1493 #else
1494 if (!pFile->hFileRead) return;
1495 #endif
1496 file_offset_t ullOriginalPos = GetPos();
1497 SetPos(0); // jump to beginning of list chunk body
1498 while (RemainingBytes() >= CHUNK_HEADER_SIZE(pFile->FileOffsetSize)) {
1499 Chunk* ck;
1500 uint32_t ckid;
1501 Read(&ckid, 4, 1);
1502 #if DEBUG_RIFF
1503 std::cout << " ckid=" << convertToString(ckid) << std::endl;
1504 #endif // DEBUG_RIFF
1505 if (ckid == CHUNK_ID_LIST) {
1506 ck = new RIFF::List(pFile, ullStartPos + ullPos - 4, this);
1507 SetPos(ck->GetSize() + LIST_HEADER_SIZE(pFile->FileOffsetSize) - 4, RIFF::stream_curpos);
1508 }
1509 else { // simple chunk
1510 ck = new RIFF::Chunk(pFile, ullStartPos + ullPos - 4, this);
1511 SetPos(ck->GetSize() + CHUNK_HEADER_SIZE(pFile->FileOffsetSize) - 4, RIFF::stream_curpos);
1512 }
1513 pSubChunks->push_back(ck);
1514 (*pSubChunksMap)[ckid] = ck;
1515 if (GetPos() % 2 != 0) SetPos(1, RIFF::stream_curpos); // jump over pad byte
1516 }
1517 SetPos(ullOriginalPos); // restore position before this call
1518 }
1519 if (pProgress)
1520 __notify_progress(pProgress, 1.0); // notify done
1521 }
1522
1523 void List::LoadSubChunksRecursively(progress_t* pProgress) {
1524 const int n = (int) CountSubLists();
1525 int i = 0;
1526 for (List* pList = GetFirstSubList(); pList; pList = GetNextSubList(), ++i) {
1527 if (pProgress) {
1528 // divide local progress into subprogress
1529 progress_t subprogress;
1530 __divide_progress(pProgress, &subprogress, n, i);
1531 // do the actual work
1532 pList->LoadSubChunksRecursively(&subprogress);
1533 } else
1534 pList->LoadSubChunksRecursively(NULL);
1535 }
1536 if (pProgress)
1537 __notify_progress(pProgress, 1.0); // notify done
1538 }
1539
1540 /** @brief Write list chunk persistently e.g. to disk.
1541 *
1542 * Stores the list chunk persistently to its actual "physical" file. All
1543 * subchunks (including sub list chunks) will be stored recursively as
1544 * well.
1545 *
1546 * @param ullWritePos - position within the "physical" file where this
1547 * list chunk should be written to
1548 * @param ullCurrentDataOffset - offset of current (old) data within
1549 * the file
1550 * @param pProgress - optional: callback function for progress notification
1551 * @returns new write position in the "physical" file, that is
1552 * \a ullWritePos incremented by this list chunk's new size
1553 * (including its header size of course)
1554 */
1555 file_offset_t List::WriteChunk(file_offset_t ullWritePos, file_offset_t ullCurrentDataOffset, progress_t* pProgress) {
1556 const file_offset_t ullOriginalPos = ullWritePos;
1557 ullWritePos += LIST_HEADER_SIZE(pFile->FileOffsetSize);
1558
1559 if (pFile->Mode != stream_mode_read_write)
1560 throw Exception("Cannot write list chunk, file has to be opened in read+write mode");
1561
1562 // write all subchunks (including sub list chunks) recursively
1563 if (pSubChunks) {
1564 size_t i = 0;
1565 const size_t n = pSubChunks->size();
1566 for (ChunkList::iterator iter = pSubChunks->begin(), end = pSubChunks->end(); iter != end; ++iter, ++i) {
1567 if (pProgress) {
1568 // divide local progress into subprogress for loading current Instrument
1569 progress_t subprogress;
1570 __divide_progress(pProgress, &subprogress, n, i);
1571 // do the actual work
1572 ullWritePos = (*iter)->WriteChunk(ullWritePos, ullCurrentDataOffset, &subprogress);
1573 } else
1574 ullWritePos = (*iter)->WriteChunk(ullWritePos, ullCurrentDataOffset, NULL);
1575 }
1576 }
1577
1578 // update this list chunk's header
1579 ullCurrentChunkSize = ullNewChunkSize = ullWritePos - ullOriginalPos - LIST_HEADER_SIZE(pFile->FileOffsetSize);
1580 WriteHeader(ullOriginalPos);
1581
1582 // offset of this list chunk in new written file may have changed
1583 ullStartPos = ullOriginalPos + LIST_HEADER_SIZE(pFile->FileOffsetSize);
1584
1585 if (pProgress)
1586 __notify_progress(pProgress, 1.0); // notify done
1587
1588 return ullWritePos;
1589 }
1590
1591 void List::__resetPos() {
1592 Chunk::__resetPos();
1593 if (pSubChunks) {
1594 for (ChunkList::iterator iter = pSubChunks->begin(), end = pSubChunks->end(); iter != end; ++iter) {
1595 (*iter)->__resetPos();
1596 }
1597 }
1598 }
1599
1600 /**
1601 * Returns string representation of the lists's id
1602 */
1603 String List::GetListTypeString() const {
1604 return convertToString(ListType);
1605 }
1606
1607
1608
1609 // *************** File ***************
1610 // *
1611
1612 /** @brief Create new RIFF file.
1613 *
1614 * Use this constructor if you want to create a new RIFF file completely
1615 * "from scratch". Note: there must be no empty chunks or empty list
1616 * chunks when trying to make the new RIFF file persistent with Save()!
1617 *
1618 * Note: by default, the RIFF file will be saved in native endian
1619 * format; that is, as a RIFF file on little-endian machines and
1620 * as a RIFX file on big-endian. To change this behaviour, call
1621 * SetByteOrder() before calling Save().
1622 *
1623 * @param FileType - four-byte identifier of the RIFF file type
1624 * @see AddSubChunk(), AddSubList(), SetByteOrder()
1625 */
1626 File::File(uint32_t FileType)
1627 : List(this), bIsNewFile(true), Layout(layout_standard),
1628 FileOffsetPreference(offset_size_auto)
1629 {
1630 #if defined(WIN32)
1631 hFileRead = hFileWrite = INVALID_HANDLE_VALUE;
1632 #else
1633 hFileRead = hFileWrite = 0;
1634 #endif
1635 Mode = stream_mode_closed;
1636 bEndianNative = true;
1637 ListType = FileType;
1638 FileOffsetSize = 4;
1639 ullStartPos = RIFF_HEADER_SIZE(FileOffsetSize);
1640 }
1641
1642 /** @brief Load existing RIFF file.
1643 *
1644 * Loads an existing RIFF file with all its chunks.
1645 *
1646 * @param path - path and file name of the RIFF file to open
1647 * @throws RIFF::Exception if error occurred while trying to load the
1648 * given RIFF file
1649 */
1650 File::File(const String& path)
1651 : List(this), Filename(path), bIsNewFile(false), Layout(layout_standard),
1652 FileOffsetPreference(offset_size_auto)
1653 {
1654 #if DEBUG_RIFF
1655 std::cout << "File::File("<<path<<")" << std::endl;
1656 #endif // DEBUG_RIFF
1657 bEndianNative = true;
1658 FileOffsetSize = 4;
1659 try {
1660 __openExistingFile(path);
1661 if (ChunkID != CHUNK_ID_RIFF && ChunkID != CHUNK_ID_RIFX) {
1662 throw RIFF::Exception("Not a RIFF file");
1663 }
1664 }
1665 catch (...) {
1666 Cleanup();
1667 throw;
1668 }
1669 }
1670
1671 /** @brief Load existing RIFF-like file.
1672 *
1673 * Loads an existing file, which is not a "real" RIFF file, but similar to
1674 * an ordinary RIFF file.
1675 *
1676 * A "real" RIFF file contains at top level a List chunk either with chunk
1677 * ID "RIFF" or "RIFX". The simple constructor above expects this to be
1678 * case, and if it finds the toplevel List chunk to have another chunk ID
1679 * than one of those two expected ones, it would throw an Exception and
1680 * would refuse to load the file accordingly.
1681 *
1682 * Since there are however a lot of file formats which use the same simple
1683 * principles of the RIFF format, with another toplevel List chunk ID
1684 * though, you can use this alternative constructor here to be able to load
1685 * and handle those files in the same way as you would do with "real" RIFF
1686 * files.
1687 *
1688 * @param path - path and file name of the RIFF-alike file to be opened
1689 * @param FileType - expected toplevel List chunk ID (this is the very
1690 * first chunk found in the file)
1691 * @param Endian - whether the file uses little endian or big endian layout
1692 * @param layout - general file structure type
1693 * @param fileOffsetSize - (optional) preference how to deal with large files
1694 * @throws RIFF::Exception if error occurred while trying to load the
1695 * given RIFF-alike file
1696 */
1697 File::File(const String& path, uint32_t FileType, endian_t Endian, layout_t layout, offset_size_t fileOffsetSize)
1698 : List(this), Filename(path), bIsNewFile(false), Layout(layout),
1699 FileOffsetPreference(fileOffsetSize)
1700 {
1701 SetByteOrder(Endian);
1702 if (fileOffsetSize < offset_size_auto || fileOffsetSize > offset_size_64bit)
1703 throw Exception("Invalid RIFF::offset_size_t");
1704 FileOffsetSize = 4;
1705 try {
1706 __openExistingFile(path, &FileType);
1707 }
1708 catch (...) {
1709 Cleanup();
1710 throw;
1711 }
1712 }
1713
1714 /**
1715 * Opens an already existing RIFF file or RIFF-alike file. This method
1716 * shall only be called once (in a File class constructor).
1717 *
1718 * @param path - path and file name of the RIFF file or RIFF-alike file to
1719 * be opened
1720 * @param FileType - (optional) expected chunk ID of first chunk in file
1721 * @throws RIFF::Exception if error occurred while trying to load the
1722 * given RIFF file or RIFF-alike file
1723 */
1724 void File::__openExistingFile(const String& path, uint32_t* FileType) {
1725 #if POSIX
1726 hFileRead = hFileWrite = open(path.c_str(), O_RDONLY | O_NONBLOCK);
1727 if (hFileRead == -1) {
1728 hFileRead = hFileWrite = 0;
1729 String sError = strerror(errno);
1730 throw RIFF::Exception("Can't open \"" + path + "\": " + sError);
1731 }
1732 #elif defined(WIN32)
1733 hFileRead = hFileWrite = CreateFile(
1734 path.c_str(), GENERIC_READ,
1735 FILE_SHARE_READ | FILE_SHARE_WRITE,
1736 NULL, OPEN_EXISTING,
1737 FILE_ATTRIBUTE_NORMAL |
1738 FILE_FLAG_RANDOM_ACCESS, NULL
1739 );
1740 if (hFileRead == INVALID_HANDLE_VALUE) {
1741 hFileRead = hFileWrite = INVALID_HANDLE_VALUE;
1742 throw RIFF::Exception("Can't open \"" + path + "\"");
1743 }
1744 #else
1745 hFileRead = hFileWrite = fopen(path.c_str(), "rb");
1746 if (!hFileRead) throw RIFF::Exception("Can't open \"" + path + "\"");
1747 #endif // POSIX
1748 Mode = stream_mode_read;
1749
1750 // determine RIFF file offset size to be used (in RIFF chunk headers)
1751 // according to the current file offset preference
1752 FileOffsetSize = FileOffsetSizeFor(GetCurrentFileSize());
1753
1754 switch (Layout) {
1755 case layout_standard: // this is a normal RIFF file
1756 ullStartPos = RIFF_HEADER_SIZE(FileOffsetSize);
1757 ReadHeader(0);
1758 if (FileType && ChunkID != *FileType)
1759 throw RIFF::Exception("Invalid file container ID");
1760 break;
1761 case layout_flat: // non-standard RIFF-alike file
1762 ullStartPos = 0;
1763 ullNewChunkSize = ullCurrentChunkSize = GetCurrentFileSize();
1764 if (FileType) {
1765 uint32_t ckid;
1766 if (Read(&ckid, 4, 1) != 4) {
1767 throw RIFF::Exception("Invalid file header ID (premature end of header)");
1768 } else if (ckid != *FileType) {
1769 String s = " (expected '" + convertToString(*FileType) + "' but got '" + convertToString(ckid) + "')";
1770 throw RIFF::Exception("Invalid file header ID" + s);
1771 }
1772 SetPos(0); // reset to first byte of file
1773 }
1774 LoadSubChunks();
1775 break;
1776 }
1777 }
1778
1779 String File::GetFileName() const {
1780 return Filename;
1781 }
1782
1783 void File::SetFileName(const String& path) {
1784 Filename = path;
1785 }
1786
1787 stream_mode_t File::GetMode() const {
1788 return Mode;
1789 }
1790
1791 layout_t File::GetLayout() const {
1792 return Layout;
1793 }
1794
1795 /** @brief Change file access mode.
1796 *
1797 * Changes files access mode either to read-only mode or to read/write
1798 * mode.
1799 *
1800 * @param NewMode - new file access mode
1801 * @returns true if mode was changed, false if current mode already
1802 * equals new mode
1803 * @throws RIFF::Exception if new file access mode is unknown
1804 */
1805 bool File::SetMode(stream_mode_t NewMode) {
1806 if (NewMode != Mode) {
1807 switch (NewMode) {
1808 case stream_mode_read:
1809 #if POSIX
1810 if (hFileRead) close(hFileRead);
1811 hFileRead = hFileWrite = open(Filename.c_str(), O_RDONLY | O_NONBLOCK);
1812 if (hFileRead == -1) {
1813 hFileRead = hFileWrite = 0;
1814 String sError = strerror(errno);
1815 throw Exception("Could not (re)open file \"" + Filename + "\" in read mode: " + sError);
1816 }
1817 #elif defined(WIN32)
1818 if (hFileRead != INVALID_HANDLE_VALUE) CloseHandle(hFileRead);
1819 hFileRead = hFileWrite = CreateFile(
1820 Filename.c_str(), GENERIC_READ,
1821 FILE_SHARE_READ | FILE_SHARE_WRITE,
1822 NULL, OPEN_EXISTING,
1823 FILE_ATTRIBUTE_NORMAL |
1824 FILE_FLAG_RANDOM_ACCESS,
1825 NULL
1826 );
1827 if (hFileRead == INVALID_HANDLE_VALUE) {
1828 hFileRead = hFileWrite = INVALID_HANDLE_VALUE;
1829 throw Exception("Could not (re)open file \"" + Filename + "\" in read mode");
1830 }
1831 #else
1832 if (hFileRead) fclose(hFileRead);
1833 hFileRead = hFileWrite = fopen(Filename.c_str(), "rb");
1834 if (!hFileRead) throw Exception("Could not (re)open file \"" + Filename + "\" in read mode");
1835 #endif
1836 __resetPos(); // reset read/write position of ALL 'Chunk' objects
1837 break;
1838 case stream_mode_read_write:
1839 #if POSIX
1840 if (hFileRead) close(hFileRead);
1841 hFileRead = hFileWrite = open(Filename.c_str(), O_RDWR | O_NONBLOCK);
1842 if (hFileRead == -1) {
1843 hFileRead = hFileWrite = open(Filename.c_str(), O_RDONLY | O_NONBLOCK);
1844 String sError = strerror(errno);
1845 throw Exception("Could not open file \"" + Filename + "\" in read+write mode: " + sError);
1846 }
1847 #elif defined(WIN32)
1848 if (hFileRead != INVALID_HANDLE_VALUE) CloseHandle(hFileRead);
1849 hFileRead = hFileWrite = CreateFile(
1850 Filename.c_str(),
1851 GENERIC_READ | GENERIC_WRITE,
1852 FILE_SHARE_READ,
1853 NULL, OPEN_ALWAYS,
1854 FILE_ATTRIBUTE_NORMAL |
1855 FILE_FLAG_RANDOM_ACCESS,
1856 NULL
1857 );
1858 if (hFileRead == INVALID_HANDLE_VALUE) {
1859 hFileRead = hFileWrite = CreateFile(
1860 Filename.c_str(), GENERIC_READ,
1861 FILE_SHARE_READ | FILE_SHARE_WRITE,
1862 NULL, OPEN_EXISTING,
1863 FILE_ATTRIBUTE_NORMAL |
1864 FILE_FLAG_RANDOM_ACCESS,
1865 NULL
1866 );
1867 throw Exception("Could not (re)open file \"" + Filename + "\" in read+write mode");
1868 }
1869 #else
1870 if (hFileRead) fclose(hFileRead);
1871 hFileRead = hFileWrite = fopen(Filename.c_str(), "r+b");
1872 if (!hFileRead) {
1873 hFileRead = hFileWrite = fopen(Filename.c_str(), "rb");
1874 throw Exception("Could not open file \"" + Filename + "\" in read+write mode");
1875 }
1876 #endif
1877 __resetPos(); // reset read/write position of ALL 'Chunk' objects
1878 break;
1879 case stream_mode_closed:
1880 #if POSIX
1881 if (hFileRead) close(hFileRead);
1882 if (hFileWrite) close(hFileWrite);
1883 hFileRead = hFileWrite = 0;
1884 #elif defined(WIN32)
1885 if (hFileRead != INVALID_HANDLE_VALUE) CloseHandle(hFileRead);
1886 if (hFileWrite != INVALID_HANDLE_VALUE) CloseHandle(hFileWrite);
1887 hFileRead = hFileWrite = INVALID_HANDLE_VALUE;
1888 #else
1889 if (hFileRead) fclose(hFileRead);
1890 if (hFileWrite) fclose(hFileWrite);
1891 hFileRead = hFileWrite = NULL;
1892 #endif
1893 break;
1894 default:
1895 throw Exception("Unknown file access mode");
1896 }
1897 Mode = NewMode;
1898 return true;
1899 }
1900 return false;
1901 }
1902
1903 /** @brief Set the byte order to be used when saving.
1904 *
1905 * Set the byte order to be used in the file. A value of
1906 * endian_little will create a RIFF file, endian_big a RIFX file
1907 * and endian_native will create a RIFF file on little-endian
1908 * machines and RIFX on big-endian machines.
1909 *
1910 * @param Endian - endianess to use when file is saved.
1911 */
1912 void File::SetByteOrder(endian_t Endian) {
1913 #if WORDS_BIGENDIAN
1914 bEndianNative = Endian != endian_little;
1915 #else
1916 bEndianNative = Endian != endian_big;
1917 #endif
1918 }
1919
1920 /** @brief Save changes to same file.
1921 *
1922 * Make all changes of all chunks persistent by writing them to the
1923 * actual (same) file.
1924 *
1925 * @param pProgress - optional: callback function for progress notification
1926 * @throws RIFF::Exception if there is an empty chunk or empty list
1927 * chunk or any kind of IO error occurred
1928 */
1929 void File::Save(progress_t* pProgress) {
1930 //TODO: implementation for the case where first chunk is not a global container (List chunk) is not implemented yet (i.e. Korg files)
1931 if (Layout == layout_flat)
1932 throw Exception("Saving a RIFF file with layout_flat is not implemented yet");
1933
1934 // make sure the RIFF tree is built (from the original file)
1935 if (pProgress) {
1936 // divide progress into subprogress
1937 progress_t subprogress;
1938 __divide_progress(pProgress, &subprogress, 3.f, 0.f); // arbitrarily subdivided into 1/3 of total progress
1939 // do the actual work
1940 LoadSubChunksRecursively(&subprogress);
1941 // notify subprogress done
1942 __notify_progress(&subprogress, 1.f);
1943 } else
1944 LoadSubChunksRecursively(NULL);
1945
1946 // reopen file in write mode
1947 SetMode(stream_mode_read_write);
1948
1949 // get the current file size as it is now still physically stored on disk
1950 const file_offset_t workingFileSize = GetCurrentFileSize();
1951
1952 // get the overall file size required to save this file
1953 const file_offset_t newFileSize = GetRequiredFileSize(FileOffsetPreference);
1954
1955 // determine whether this file will yield in a large file (>=4GB) and
1956 // the RIFF file offset size to be used accordingly for all chunks
1957 FileOffsetSize = FileOffsetSizeFor(newFileSize);
1958
1959 // to be able to save the whole file without loading everything into
1960 // RAM and without having to store the data in a temporary file, we
1961 // enlarge the file with the overall positive file size change,
1962 // then move current data towards the end of the file by the calculated
1963 // positive file size difference and finally update / rewrite the file
1964 // by copying the old data back to the right position at the beginning
1965 // of the file
1966
1967 // if there are positive size changes...
1968 file_offset_t positiveSizeDiff = 0;
1969 if (newFileSize > workingFileSize) {
1970 positiveSizeDiff = newFileSize - workingFileSize;
1971
1972 // divide progress into subprogress
1973 progress_t subprogress;
1974 if (pProgress)
1975 __divide_progress(pProgress, &subprogress, 3.f, 1.f); // arbitrarily subdivided into 1/3 of total progress
1976
1977 // ... we enlarge this file first ...
1978 ResizeFile(newFileSize);
1979
1980 // ... and move current data by the same amount towards end of file.
1981 int8_t* pCopyBuffer = new int8_t[4096];
1982 #if defined(WIN32)
1983 DWORD iBytesMoved = 1; // we have to pass it via pointer to the Windows API, thus the correct size must be ensured
1984 #else
1985 ssize_t iBytesMoved = 1;
1986 #endif
1987 for (file_offset_t ullPos = workingFileSize, iNotif = 0; iBytesMoved > 0; ++iNotif) {
1988 iBytesMoved = (ullPos < 4096) ? ullPos : 4096;
1989 ullPos -= iBytesMoved;
1990 #if POSIX
1991 lseek(hFileRead, ullPos, SEEK_SET);
1992 iBytesMoved = read(hFileRead, pCopyBuffer, iBytesMoved);
1993 lseek(hFileWrite, ullPos + positiveSizeDiff, SEEK_SET);
1994 iBytesMoved = write(hFileWrite, pCopyBuffer, iBytesMoved);
1995 #elif defined(WIN32)
1996 LARGE_INTEGER liFilePos;
1997 liFilePos.QuadPart = ullPos;
1998 SetFilePointerEx(hFileRead, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN);
1999 ReadFile(hFileRead, pCopyBuffer, iBytesMoved, &iBytesMoved, NULL);
2000 liFilePos.QuadPart = ullPos + positiveSizeDiff;
2001 SetFilePointerEx(hFileWrite, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN);
2002 WriteFile(hFileWrite, pCopyBuffer, iBytesMoved, &iBytesMoved, NULL);
2003 #else
2004 fseeko(hFileRead, ullPos, SEEK_SET);
2005 iBytesMoved = fread(pCopyBuffer, 1, iBytesMoved, hFileRead);
2006 fseeko(hFileWrite, ullPos + positiveSizeDiff, SEEK_SET);
2007 iBytesMoved = fwrite(pCopyBuffer, 1, iBytesMoved, hFileWrite);
2008 #endif
2009 if (pProgress && !(iNotif % 8) && iBytesMoved > 0)
2010 __notify_progress(&subprogress, float(workingFileSize - ullPos) / float(workingFileSize));
2011 }
2012 delete[] pCopyBuffer;
2013 if (iBytesMoved < 0) throw Exception("Could not modify file while trying to enlarge it");
2014
2015 if (pProgress)
2016 __notify_progress(&subprogress, 1.f); // notify subprogress done
2017 }
2018
2019 // rebuild / rewrite complete RIFF tree ...
2020
2021 // divide progress into subprogress
2022 progress_t subprogress;
2023 if (pProgress)
2024 __divide_progress(pProgress, &subprogress, 3.f, 2.f); // arbitrarily subdivided into 1/3 of total progress
2025 // do the actual work
2026 const file_offset_t finalSize = WriteChunk(0, positiveSizeDiff, pProgress ? &subprogress : NULL);
2027 const file_offset_t finalActualSize = __GetFileSize(hFileWrite);
2028 // notify subprogress done
2029 if (pProgress)
2030 __notify_progress(&subprogress, 1.f);
2031
2032 // resize file to the final size
2033 if (finalSize < finalActualSize) ResizeFile(finalSize);
2034
2035 if (pProgress)
2036 __notify_progress(pProgress, 1.0); // notify done
2037 }
2038
2039 /** @brief Save changes to another file.
2040 *
2041 * Make all changes of all chunks persistent by writing them to another
2042 * file. <b>Caution:</b> this method is optimized for writing to
2043 * <b>another</b> file, do not use it to save the changes to the same
2044 * file! Use File::Save() in that case instead! Ignoring this might
2045 * result in a corrupted file, especially in case chunks were resized!
2046 *
2047 * After calling this method, this File object will be associated with
2048 * the new file (given by \a path) afterwards.
2049 *
2050 * @param path - path and file name where everything should be written to
2051 * @param pProgress - optional: callback function for progress notification
2052 */
2053 void File::Save(const String& path, progress_t* pProgress) {
2054 //TODO: we should make a check here if somebody tries to write to the same file and automatically call the other Save() method in that case
2055
2056 //TODO: implementation for the case where first chunk is not a global container (List chunk) is not implemented yet (i.e. Korg files)
2057 if (Layout == layout_flat)
2058 throw Exception("Saving a RIFF file with layout_flat is not implemented yet");
2059
2060 // make sure the RIFF tree is built (from the original file)
2061 if (pProgress) {
2062 // divide progress into subprogress
2063 progress_t subprogress;
2064 __divide_progress(pProgress, &subprogress, 2.f, 0.f); // arbitrarily subdivided into 1/2 of total progress
2065 // do the actual work
2066 LoadSubChunksRecursively(&subprogress);
2067 // notify subprogress done
2068 __notify_progress(&subprogress, 1.f);
2069 } else
2070 LoadSubChunksRecursively(NULL);
2071
2072 if (!bIsNewFile) SetMode(stream_mode_read);
2073 // open the other (new) file for writing and truncate it to zero size
2074 #if POSIX
2075 hFileWrite = open(path.c_str(), O_RDWR | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP);
2076 if (hFileWrite == -1) {
2077 hFileWrite = hFileRead;
2078 String sError = strerror(errno);
2079 throw Exception("Could not open file \"" + path + "\" for writing: " + sError);
2080 }
2081 #elif defined(WIN32)
2082 hFileWrite = CreateFile(
2083 path.c_str(), GENERIC_WRITE, FILE_SHARE_READ,
2084 NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL |
2085 FILE_FLAG_RANDOM_ACCESS, NULL
2086 );
2087 if (hFileWrite == INVALID_HANDLE_VALUE) {
2088 hFileWrite = hFileRead;
2089 throw Exception("Could not open file \"" + path + "\" for writing");
2090 }
2091 #else
2092 hFileWrite = fopen(path.c_str(), "w+b");
2093 if (!hFileWrite) {
2094 hFileWrite = hFileRead;
2095 throw Exception("Could not open file \"" + path + "\" for writing");
2096 }
2097 #endif // POSIX
2098 Mode = stream_mode_read_write;
2099
2100 // get the overall file size required to save this file
2101 const file_offset_t newFileSize = GetRequiredFileSize(FileOffsetPreference);
2102
2103 // determine whether this file will yield in a large file (>=4GB) and
2104 // the RIFF file offset size to be used accordingly for all chunks
2105 FileOffsetSize = FileOffsetSizeFor(newFileSize);
2106
2107 // write complete RIFF tree to the other (new) file
2108 file_offset_t ullTotalSize;
2109 if (pProgress) {
2110 // divide progress into subprogress
2111 progress_t subprogress;
2112 __divide_progress(pProgress, &subprogress, 2.f, 1.f); // arbitrarily subdivided into 1/2 of total progress
2113 // do the actual work
2114 ullTotalSize = WriteChunk(0, 0, &subprogress);
2115 // notify subprogress done
2116 __notify_progress(&subprogress, 1.f);
2117 } else
2118 ullTotalSize = WriteChunk(0, 0, NULL);
2119
2120 file_offset_t ullActualSize = __GetFileSize(hFileWrite);
2121
2122 // resize file to the final size (if the file was originally larger)
2123 if (ullActualSize > ullTotalSize) ResizeFile(ullTotalSize);
2124
2125 #if POSIX
2126 if (hFileWrite) close(hFileWrite);
2127 #elif defined(WIN32)
2128 if (hFileWrite != INVALID_HANDLE_VALUE) CloseHandle(hFileWrite);
2129 #else
2130 if (hFileWrite) fclose(hFileWrite);
2131 #endif
2132 hFileWrite = hFileRead;
2133
2134 // associate new file with this File object from now on
2135 Filename = path;
2136 bIsNewFile = false;
2137 Mode = (stream_mode_t) -1; // Just set it to an undefined mode ...
2138 SetMode(stream_mode_read_write); // ... so SetMode() has to reopen the file handles.
2139
2140 if (pProgress)
2141 __notify_progress(pProgress, 1.0); // notify done
2142 }
2143
2144 void File::ResizeFile(file_offset_t ullNewSize) {
2145 #if POSIX
2146 if (ftruncate(hFileWrite, ullNewSize) < 0)
2147 throw Exception("Could not resize file \"" + Filename + "\"");
2148 #elif defined(WIN32)
2149 LARGE_INTEGER liFilePos;
2150 liFilePos.QuadPart = ullNewSize;
2151 if (
2152 !SetFilePointerEx(hFileWrite, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN) ||
2153 !SetEndOfFile(hFileWrite)
2154 ) throw Exception("Could not resize file \"" + Filename + "\"");
2155 #else
2156 # error Sorry, this version of libgig only supports POSIX and Windows systems yet.
2157 # error Reason: portable implementation of RIFF::File::ResizeFile() is missing (yet)!
2158 #endif
2159 }
2160
2161 File::~File() {
2162 #if DEBUG_RIFF
2163 std::cout << "File::~File()" << std::endl;
2164 #endif // DEBUG_RIFF
2165 Cleanup();
2166 }
2167
2168 /**
2169 * Returns @c true if this file has been created new from scratch and
2170 * has not been stored to disk yet.
2171 */
2172 bool File::IsNew() const {
2173 return bIsNewFile;
2174 }
2175
2176 void File::Cleanup() {
2177 #if POSIX
2178 if (hFileRead) close(hFileRead);
2179 #elif defined(WIN32)
2180 if (hFileRead != INVALID_HANDLE_VALUE) CloseHandle(hFileRead);
2181 #else
2182 if (hFileRead) fclose(hFileRead);
2183 #endif // POSIX
2184 DeleteChunkList();
2185 pFile = NULL;
2186 }
2187
2188 /**
2189 * Returns the current size of this file (in bytes) as it is currently
2190 * yet stored on disk. If this file does not yet exist on disk (i.e. when
2191 * this RIFF File has just been created from scratch and Save() has not
2192 * been called yet) then this method returns 0.
2193 */
2194 file_offset_t File::GetCurrentFileSize() const {
2195 file_offset_t size = 0;
2196 try {
2197 size = __GetFileSize(hFileRead);
2198 } catch (...) {
2199 size = 0;
2200 }
2201 return size;
2202 }
2203
2204 /**
2205 * Returns the required size (in bytes) for this RIFF File to be saved to
2206 * disk. The precise size of the final file on disk depends on the RIFF
2207 * file offset size actually used internally in all headers of the RIFF
2208 * chunks. By default libgig handles the required file offset size
2209 * automatically for you; that means it is using 32 bit offsets for files
2210 * smaller than 4 GB and 64 bit offsets for files equal or larger than
2211 * 4 GB. You may however also override this default behavior by passing the
2212 * respective option to the RIFF File constructor to force one particular
2213 * offset size. In the latter case this method will return the file size
2214 * for the requested forced file offset size that will be used when calling
2215 * Save() later on.
2216 *
2217 * You may also use the overridden method below to get the file size for
2218 * an arbitrary other file offset size instead.
2219 *
2220 * @see offset_size_t
2221 * @see GetFileOffsetSize()
2222 */
2223 file_offset_t File::GetRequiredFileSize() {
2224 return GetRequiredFileSize(FileOffsetPreference);
2225 }
2226
2227 /**
2228 * Returns the rquired size (in bytes) for this RIFF file to be saved to
2229 * disk, assuming the passed @a fileOffsestSize would be used for the
2230 * Save() operation.
2231 *
2232 * This overridden method essentialy behaves like the above method, with
2233 * the difference that you must provide a specific RIFF @a fileOffsetSize
2234 * for calculating the theoretical final file size.
2235 *
2236 * @see GetFileOffsetSize()
2237 */
2238 file_offset_t File::GetRequiredFileSize(offset_size_t fileOffsetSize) {
2239 switch (fileOffsetSize) {
2240 case offset_size_auto: {
2241 file_offset_t fileSize = GetRequiredFileSize(offset_size_32bit);
2242 if (fileSize >> 32)
2243 return GetRequiredFileSize(offset_size_64bit);
2244 else
2245 return fileSize;
2246 }
2247 case offset_size_32bit: break;
2248 case offset_size_64bit: break;
2249 default: throw Exception("Internal error: Invalid RIFF::offset_size_t");
2250 }
2251 return RequiredPhysicalSize(FileOffsetSize);
2252 }
2253
2254 int File::FileOffsetSizeFor(file_offset_t fileSize) const {
2255 switch (FileOffsetPreference) {
2256 case offset_size_auto:
2257 return (fileSize >> 32) ? 8 : 4;
2258 case offset_size_32bit:
2259 return 4;
2260 case offset_size_64bit:
2261 return 8;
2262 default:
2263 throw Exception("Internal error: Invalid RIFF::offset_size_t");
2264 }
2265 }
2266
2267 /**
2268 * Returns the current size (in bytes) of file offsets stored in the
2269 * headers of all chunks of this file.
2270 *
2271 * Most RIFF files are using 32 bit file offsets internally, which limits
2272 * them to a maximum file size of less than 4 GB though. In contrast to the
2273 * common standard, this RIFF File class implementation supports handling of
2274 * RIFF files equal or larger than 4 GB. In such cases 64 bit file offsets
2275 * have to be used in all headers of all RIFF Chunks when being stored to a
2276 * physical file. libgig by default automatically selects the correct file
2277 * offset size for you. You may however also force one particular file
2278 * offset size by supplying the respective option to the RIFF::File
2279 * constructor.
2280 *
2281 * This method can be used to check which RIFF file offset size is currently
2282 * being used for this RIFF File.
2283 *
2284 * @returns current RIFF file offset size used (in bytes)
2285 * @see offset_size_t
2286 */
2287 int File::GetFileOffsetSize() const {
2288 return FileOffsetSize;
2289 }
2290
2291 /**
2292 * Returns the required size (in bytes) of file offsets stored in the
2293 * headers of all chunks of this file if the current RIFF tree would be
2294 * saved to disk by calling Save().
2295 *
2296 * See GetFileOffsetSize() for mor details about RIFF file offsets.
2297 *
2298 * @returns RIFF file offset size required (in bytes) if being saved
2299 * @see offset_size_t
2300 */
2301 int File::GetRequiredFileOffsetSize() {
2302 return FileOffsetSizeFor(GetCurrentFileSize());
2303 }
2304
2305 #if POSIX
2306 file_offset_t File::__GetFileSize(int hFile) const {
2307 struct stat filestat;
2308 if (fstat(hFile, &filestat) == -1)
2309 throw Exception("POSIX FS error: could not determine file size");
2310 return filestat.st_size;
2311 }
2312 #elif defined(WIN32)
2313 file_offset_t File::__GetFileSize(HANDLE hFile) const {
2314 LARGE_INTEGER size;
2315 if (!GetFileSizeEx(hFile, &size))
2316 throw Exception("Windows FS error: could not determine file size");
2317 return size.QuadPart;
2318 }
2319 #else // standard C functions
2320 file_offset_t File::__GetFileSize(FILE* hFile) const {
2321 off_t curpos = ftello(hFile);
2322 if (fseeko(hFile, 0, SEEK_END) == -1)
2323 throw Exception("FS error: could not determine file size");
2324 off_t size = ftello(hFile);
2325 fseeko(hFile, curpos, SEEK_SET);
2326 return size;
2327 }
2328 #endif
2329
2330
2331 // *************** Exception ***************
2332 // *
2333
2334 Exception::Exception() {
2335 }
2336
2337 Exception::Exception(String format, ...) {
2338 va_list arg;
2339 va_start(arg, format);
2340 Message = assemble(format, arg);
2341 va_end(arg);
2342 }
2343
2344 Exception::Exception(String format, va_list arg) {
2345 Message = assemble(format, arg);
2346 }
2347
2348 void Exception::PrintMessage() {
2349 std::cout << "RIFF::Exception: " << Message << std::endl;
2350 }
2351
2352 String Exception::assemble(String format, va_list arg) {
2353 char* buf = NULL;
2354 vasprintf(&buf, format.c_str(), arg);
2355 String s = buf;
2356 free(buf);
2357 return s;
2358 }
2359
2360
2361 // *************** functions ***************
2362 // *
2363
2364 /**
2365 * Returns the name of this C++ library. This is usually "libgig" of
2366 * course. This call is equivalent to DLS::libraryName() and
2367 * gig::libraryName().
2368 */
2369 String libraryName() {
2370 return PACKAGE;
2371 }
2372
2373 /**
2374 * Returns version of this C++ library. This call is equivalent to
2375 * DLS::libraryVersion() and gig::libraryVersion().
2376 */
2377 String libraryVersion() {
2378 return VERSION;
2379 }
2380
2381 } // namespace RIFF

  ViewVC Help
Powered by ViewVC