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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 780 by schoenebeck, Sun Sep 25 13:40:37 2005 UTC revision 2685 by schoenebeck, Sat Jan 3 21:44:42 2015 UTC
# Line 1  Line 1 
1  /***************************************************************************  /***************************************************************************
2   *                                                                         *   *                                                                         *
3   *   libgig - C++ cross-platform Gigasampler format file loader library    *   *   libgig - C++ cross-platform Gigasampler format file access library    *
4   *                                                                         *   *                                                                         *
5   *   Copyright (C) 2003-2005 by Christian Schoenebeck                      *   *   Copyright (C) 2003-2014 by Christian Schoenebeck                      *
6   *                              <cuse@users.sourceforge.net>               *   *                              <cuse@users.sourceforge.net>               *
7   *                                                                         *   *                                                                         *
8   *   This library is free software; you can redistribute it and/or modify  *   *   This library is free software; you can redistribute it and/or modify  *
# Line 21  Line 21 
21   *   MA  02111-1307  USA                                                   *   *   MA  02111-1307  USA                                                   *
22   ***************************************************************************/   ***************************************************************************/
23    
24    #include <algorithm>
25    #include <set>
26  #include <string.h>  #include <string.h>
 #include <sstream>  
27    
28  #include "RIFF.h"  #include "RIFF.h"
29    
30    #include "helper.h"
31    
32    #if POSIX
33    # include <errno.h>
34    #endif
35    
36  namespace RIFF {  namespace RIFF {
37    
38  // *************** Helper Functions **************  // *************** Internal functions **************
39  // *  // *
40    
41      template<class T> inline String ToString(T o) {      /// Returns a human readable path of the given chunk.
42          std::stringstream ss;      static String __resolveChunkPath(Chunk* pCk) {
43          ss << o;          String sPath;
44          return ss.str();          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    
# Line 49  namespace RIFF { Line 76  namespace RIFF {
76          ulPos      = 0;          ulPos      = 0;
77          pParent    = NULL;          pParent    = NULL;
78          pChunkData = NULL;          pChunkData = NULL;
79            CurrentChunkSize = 0;
80            NewChunkSize = 0;
81            ulChunkDataSize = 0;
82            ChunkID    = CHUNK_ID_RIFF;
83          this->pFile = pFile;          this->pFile = pFile;
84      }      }
85    
# Line 61  namespace RIFF { Line 92  namespace RIFF {
92          pParent       = Parent;          pParent       = Parent;
93          ulPos         = 0;          ulPos         = 0;
94          pChunkData    = NULL;          pChunkData    = NULL;
95            CurrentChunkSize = 0;
96            NewChunkSize = 0;
97            ulChunkDataSize = 0;
98          ReadHeader(StartPos);          ReadHeader(StartPos);
99      }      }
100    
# Line 71  namespace RIFF { Line 105  namespace RIFF {
105          ulPos            = 0;          ulPos            = 0;
106          pChunkData       = NULL;          pChunkData       = NULL;
107          ChunkID          = uiChunkID;          ChunkID          = uiChunkID;
108            ulChunkDataSize  = 0;
109          CurrentChunkSize = 0;          CurrentChunkSize = 0;
110          NewChunkSize     = uiBodySize;          NewChunkSize     = uiBodySize;
111      }      }
112    
113      Chunk::~Chunk() {      Chunk::~Chunk() {
114            if (pFile) pFile->UnlogResized(this);
115          if (pChunkData) delete[] pChunkData;          if (pChunkData) delete[] pChunkData;
116      }      }
117    
# Line 83  namespace RIFF { Line 119  namespace RIFF {
119          #if DEBUG          #if DEBUG
120          std::cout << "Chunk::Readheader(" << fPos << ") ";          std::cout << "Chunk::Readheader(" << fPos << ") ";
121          #endif // DEBUG          #endif // DEBUG
122            ChunkID = 0;
123            NewChunkSize = CurrentChunkSize = 0;
124          #if POSIX          #if POSIX
125          if (lseek(pFile->hFileRead, fPos, SEEK_SET) != -1) {          if (lseek(pFile->hFileRead, fPos, SEEK_SET) != -1) {
126              read(pFile->hFileRead, &ChunkID, 4);              read(pFile->hFileRead, &ChunkID, 4);
127              read(pFile->hFileRead, &CurrentChunkSize, 4);              read(pFile->hFileRead, &CurrentChunkSize, 4);
128            #elif defined(WIN32)
129            if (SetFilePointer(pFile->hFileRead, fPos, NULL/*32 bit*/, FILE_BEGIN) != INVALID_SET_FILE_POINTER) {
130                DWORD dwBytesRead;
131                ReadFile(pFile->hFileRead, &ChunkID, 4, &dwBytesRead, NULL);
132                ReadFile(pFile->hFileRead, &CurrentChunkSize, 4, &dwBytesRead, NULL);
133          #else          #else
134          if (!fseek(pFile->hFileRead, fPos, SEEK_SET)) {          if (!fseek(pFile->hFileRead, fPos, SEEK_SET)) {
135              fread(&ChunkID, 4, 1, pFile->hFileRead);              fread(&ChunkID, 4, 1, pFile->hFileRead);
# Line 94  namespace RIFF { Line 137  namespace RIFF {
137          #endif // POSIX          #endif // POSIX
138              #if WORDS_BIGENDIAN              #if WORDS_BIGENDIAN
139              if (ChunkID == CHUNK_ID_RIFF) {              if (ChunkID == CHUNK_ID_RIFF) {
140                  bEndianNative = false;                  pFile->bEndianNative = false;
141              }              }
142              #else // little endian              #else // little endian
143              if (ChunkID == CHUNK_ID_RIFX) {              if (ChunkID == CHUNK_ID_RIFX) {
# Line 108  namespace RIFF { Line 151  namespace RIFF {
151              }              }
152              #if DEBUG              #if DEBUG
153              std::cout << "ckID=" << convertToString(ChunkID) << " ";              std::cout << "ckID=" << convertToString(ChunkID) << " ";
154              std::cout << "ckSize=" << ChunkSize << " ";              std::cout << "ckSize=" << CurrentChunkSize << " ";
155              std::cout << "bEndianNative=" << bEndianNative << std::endl;              std::cout << "bEndianNative=" << pFile->bEndianNative << std::endl;
156              #endif // DEBUG              #endif // DEBUG
157              NewChunkSize = CurrentChunkSize;              NewChunkSize = CurrentChunkSize;
158          }          }
# Line 135  namespace RIFF { Line 178  namespace RIFF {
178              write(pFile->hFileWrite, &uiNewChunkID, 4);              write(pFile->hFileWrite, &uiNewChunkID, 4);
179              write(pFile->hFileWrite, &uiNewChunkSize, 4);              write(pFile->hFileWrite, &uiNewChunkSize, 4);
180          }          }
181            #elif defined(WIN32)
182            if (SetFilePointer(pFile->hFileWrite, fPos, NULL/*32 bit*/, FILE_BEGIN) != INVALID_SET_FILE_POINTER) {
183                DWORD dwBytesWritten;
184                WriteFile(pFile->hFileWrite, &uiNewChunkID, 4, &dwBytesWritten, NULL);
185                WriteFile(pFile->hFileWrite, &uiNewChunkSize, 4, &dwBytesWritten, NULL);
186            }
187          #else          #else
188          if (!fseek(pFile->hFileWrite, fPos, SEEK_SET)) {          if (!fseek(pFile->hFileWrite, fPos, SEEK_SET)) {
189              fwrite(&uiNewChunkID, 4, 1, pFile->hFileWrite);              fwrite(&uiNewChunkID, 4, 1, pFile->hFileWrite);
# Line 199  namespace RIFF { Line 248  namespace RIFF {
248         #if DEBUG         #if DEBUG
249         std::cout << "Chunk::Remainingbytes()=" << CurrentChunkSize - ulPos << std::endl;         std::cout << "Chunk::Remainingbytes()=" << CurrentChunkSize - ulPos << std::endl;
250         #endif // DEBUG         #endif // DEBUG
251          return CurrentChunkSize - ulPos;          return (CurrentChunkSize > ulPos) ? CurrentChunkSize - ulPos : 0;
252      }      }
253    
254      /**      /**
# Line 210  namespace RIFF { Line 259  namespace RIFF {
259       *  - RIFF::stream_closed :       *  - RIFF::stream_closed :
260       *    the data stream was closed somehow, no more reading possible       *    the data stream was closed somehow, no more reading possible
261       *  - RIFF::stream_end_reached :       *  - RIFF::stream_end_reached :
262       *    alreaady reached the end of the chunk data, no more reading       *    already reached the end of the chunk data, no more reading
263       *    possible without SetPos()       *    possible without SetPos()
264       */       */
265      stream_state_t Chunk::GetState() {      stream_state_t Chunk::GetState() {
# Line 218  namespace RIFF { Line 267  namespace RIFF {
267        std::cout << "Chunk::GetState()" << std::endl;        std::cout << "Chunk::GetState()" << std::endl;
268        #endif // DEBUG        #endif // DEBUG
269          #if POSIX          #if POSIX
270          if (pFile->hFileRead == 0)    return stream_closed;          if (pFile->hFileRead == 0) return stream_closed;
271            #elif defined (WIN32)
272            if (pFile->hFileRead == INVALID_HANDLE_VALUE)
273                return stream_closed;
274          #else          #else
275          if (pFile->hFileRead == NULL) return stream_closed;          if (pFile->hFileRead == NULL) return stream_closed;
276          #endif // POSIX          #endif // POSIX
# Line 245  namespace RIFF { Line 297  namespace RIFF {
297         #if DEBUG         #if DEBUG
298         std::cout << "Chunk::Read(void*,ulong,ulong)" << std::endl;         std::cout << "Chunk::Read(void*,ulong,ulong)" << std::endl;
299         #endif // DEBUG         #endif // DEBUG
300            //if (ulStartPos == 0) return 0; // is only 0 if this is a new chunk, so nothing to read (yet)
301          if (ulPos >= CurrentChunkSize) return 0;          if (ulPos >= CurrentChunkSize) return 0;
302          if (ulPos + WordCount * WordSize >= CurrentChunkSize) WordCount = (CurrentChunkSize - ulPos) / WordSize;          if (ulPos + WordCount * WordSize >= CurrentChunkSize) WordCount = (CurrentChunkSize - ulPos) / WordSize;
303          #if POSIX          #if POSIX
304          if (lseek(pFile->hFileRead, ulStartPos + ulPos, SEEK_SET) < 0) return 0;          if (lseek(pFile->hFileRead, ulStartPos + ulPos, SEEK_SET) < 0) return 0;
305          unsigned long readWords = read(pFile->hFileRead, pData, WordCount * WordSize);          ssize_t readWords = read(pFile->hFileRead, pData, WordCount * WordSize);
306            if (readWords < 1) {
307                #if DEBUG
308                std::cerr << "POSIX read() failed: " << strerror(errno) << std::endl << std::flush;
309                #endif // DEBUG
310                return 0;
311            }
312            readWords /= WordSize;
313            #elif defined(WIN32)
314            if (SetFilePointer(pFile->hFileRead, ulStartPos + ulPos, NULL/*32 bit*/, FILE_BEGIN) == INVALID_SET_FILE_POINTER) return 0;
315            DWORD readWords;
316            ReadFile(pFile->hFileRead, pData, WordCount * WordSize, &readWords, NULL);
317          if (readWords < 1) return 0;          if (readWords < 1) return 0;
318          readWords /= WordSize;          readWords /= WordSize;
319          #else // standard C functions          #else // standard C functions
320          if (fseek(pFile->hFileRead, ulStartPos + ulPos, SEEK_SET)) return 0;          if (fseek(pFile->hFileRead, ulStartPos + ulPos, SEEK_SET)) return 0;
321          unsigned long readWords = fread(pData, WordSize, WordCount, pFile->hFileRead);          size_t readWords = fread(pData, WordSize, WordCount, pFile->hFileRead);
322          #endif // POSIX          #endif // POSIX
323          if (!pFile->bEndianNative && WordSize != 1) {          if (!pFile->bEndianNative && WordSize != 1) {
324              switch (WordSize) {              switch (WordSize) {
# Line 293  namespace RIFF { Line 357  namespace RIFF {
357       *  @see Resize()       *  @see Resize()
358       */       */
359      unsigned long Chunk::Write(void* pData, unsigned long WordCount, unsigned long WordSize) {      unsigned long Chunk::Write(void* pData, unsigned long WordCount, unsigned long WordSize) {
360          if (pFile->Mode == stream_mode_read)          if (pFile->Mode != stream_mode_read_write)
361              throw Exception("Writing chunk data in read-only file access mode was attempted");              throw Exception("Cannot write data to chunk, file has to be opened in read+write mode first");
362          if (ulPos >= CurrentChunkSize || ulPos + WordCount * WordSize >= CurrentChunkSize)          if (ulPos >= CurrentChunkSize || ulPos + WordCount * WordSize > CurrentChunkSize)
363              throw Exception("End of chunk reached while trying to write data");              throw Exception("End of chunk reached while trying to write data");
364          if (!pFile->bEndianNative && WordSize != 1) {          if (!pFile->bEndianNative && WordSize != 1) {
365              switch (WordSize) {              switch (WordSize) {
# Line 321  namespace RIFF { Line 385  namespace RIFF {
385          unsigned long writtenWords = write(pFile->hFileWrite, pData, WordCount * WordSize);          unsigned long writtenWords = write(pFile->hFileWrite, pData, WordCount * WordSize);
386          if (writtenWords < 1) throw Exception("POSIX IO Error while trying to write chunk data");          if (writtenWords < 1) throw Exception("POSIX IO Error while trying to write chunk data");
387          writtenWords /= WordSize;          writtenWords /= WordSize;
388            #elif defined(WIN32)
389            if (SetFilePointer(pFile->hFileWrite, ulStartPos + ulPos, NULL/*32 bit*/, FILE_BEGIN) == INVALID_SET_FILE_POINTER) {
390                throw Exception("Could not seek to position " + ToString(ulPos) +
391                                " in chunk (" + ToString(ulStartPos + ulPos) + " in file)");
392            }
393            DWORD writtenWords;
394            WriteFile(pFile->hFileWrite, pData, WordCount * WordSize, &writtenWords, NULL);
395            if (writtenWords < 1) throw Exception("Windows IO Error while trying to write chunk data");
396            writtenWords /= WordSize;
397          #else // standard C functions          #else // standard C functions
398          if (fseek(pFile->hFileWrite, ulStartPos + ulPos, SEEK_SET)) {          if (fseek(pFile->hFileWrite, ulStartPos + ulPos, SEEK_SET)) {
399              throw Exception("Could not seek to position " + ToString(ulPos) +              throw Exception("Could not seek to position " + ToString(ulPos) +
# Line 543  namespace RIFF { Line 616  namespace RIFF {
616      }      }
617    
618      /**      /**
619         * Reads a null-padded string of size characters and copies it
620         * into the string \a s. The position within the chunk will
621         * automatically be incremented.
622         *
623         * @param s                 destination string
624         * @param size              number of characters to read
625         * @throws RIFF::Exception  if an error occured or less than
626         *                          \a size characters could be read!
627         */
628        void Chunk::ReadString(String& s, int size) {
629            char* buf = new char[size];
630            ReadSceptical(buf, 1, size);
631            s.assign(buf, std::find(buf, buf + size, '\0'));
632            delete[] buf;
633        }
634    
635        /**
636       * Writes \a WordCount number of 32 Bit unsigned integer words from the       * Writes \a WordCount number of 32 Bit unsigned integer words from the
637       * buffer pointed by \a pData to the chunk's body, directly to the       * buffer pointed by \a pData to the chunk's body, directly to the
638       * actual "physical" file. The position within the chunk will       * actual "physical" file. The position within the chunk will
# Line 667  namespace RIFF { Line 757  namespace RIFF {
757       *       *
758       * <b>Caution:</b> the buffer pointer will be invalidated once       * <b>Caution:</b> the buffer pointer will be invalidated once
759       * File::Save() was called. You have to call LoadChunkData() again to       * File::Save() was called. You have to call LoadChunkData() again to
760       * get a new pointer whenever File::Save() was called.       * get a new, valid pointer whenever File::Save() was called.
761         *
762         * You can call LoadChunkData() again if you previously scheduled to
763         * enlarge this chunk with a Resize() call. In that case the buffer will
764         * be enlarged to the new, scheduled chunk size and you can already
765         * place the new chunk data to the buffer and finally call File::Save()
766         * to enlarge the chunk physically and write the new data in one rush.
767         * This approach is definitely recommended if you have to enlarge and
768         * write new data to a lot of chunks.
769       *       *
770       * @returns a pointer to the data in RAM on success, NULL otherwise       * @returns a pointer to the data in RAM on success, NULL otherwise
771         * @throws Exception if data buffer could not be enlarged
772       * @see ReleaseChunkData()       * @see ReleaseChunkData()
773       */       */
774      void* Chunk::LoadChunkData() {      void* Chunk::LoadChunkData() {
775          if (!pChunkData) {          if (!pChunkData && pFile->Filename != "" /*&& ulStartPos != 0*/) {
776              #if POSIX              #if POSIX
777              if (lseek(pFile->hFileRead, ulStartPos, SEEK_SET) == -1) return NULL;              if (lseek(pFile->hFileRead, ulStartPos, SEEK_SET) == -1) return NULL;
778              pChunkData = new uint8_t[GetSize()];              #elif defined(WIN32)
779              if (!pChunkData) return NULL;              if (SetFilePointer(pFile->hFileRead, ulStartPos, NULL/*32 bit*/, FILE_BEGIN) == INVALID_SET_FILE_POINTER) return NULL;
             unsigned long readWords = read(pFile->hFileRead, pChunkData, GetSize());  
780              #else              #else
781              if (fseek(pFile->hFileRead, ulStartPos, SEEK_SET)) return NULL;              if (fseek(pFile->hFileRead, ulStartPos, SEEK_SET)) return NULL;
782              pChunkData = new uint8_t[GetSize()];              #endif // POSIX
783                unsigned long ulBufferSize = (CurrentChunkSize > NewChunkSize) ? CurrentChunkSize : NewChunkSize;
784                pChunkData = new uint8_t[ulBufferSize];
785              if (!pChunkData) return NULL;              if (!pChunkData) return NULL;
786                memset(pChunkData, 0, ulBufferSize);
787                #if POSIX
788                unsigned long readWords = read(pFile->hFileRead, pChunkData, GetSize());
789                #elif defined(WIN32)
790                DWORD readWords;
791                ReadFile(pFile->hFileRead, pChunkData, GetSize(), &readWords, NULL);
792                #else
793              unsigned long readWords = fread(pChunkData, 1, GetSize(), pFile->hFileRead);              unsigned long readWords = fread(pChunkData, 1, GetSize(), pFile->hFileRead);
794              #endif // POSIX              #endif // POSIX
795              if (readWords != GetSize()) {              if (readWords != GetSize()) {
796                  delete[] pChunkData;                  delete[] pChunkData;
797                  return (pChunkData = NULL);                  return (pChunkData = NULL);
798              }              }
799                ulChunkDataSize = ulBufferSize;
800            } else if (NewChunkSize > ulChunkDataSize) {
801                uint8_t* pNewBuffer = new uint8_t[NewChunkSize];
802                if (!pNewBuffer) throw Exception("Could not enlarge chunk data buffer to " + ToString(NewChunkSize) + " bytes");
803                memset(pNewBuffer, 0 , NewChunkSize);
804                memcpy(pNewBuffer, pChunkData, ulChunkDataSize);
805                delete[] pChunkData;
806                pChunkData      = pNewBuffer;
807                ulChunkDataSize = NewChunkSize;
808          }          }
809          return pChunkData;          return pChunkData;
810      }      }
# Line 718  namespace RIFF { Line 834  namespace RIFF {
834       *       *
835       * <b>Caution:</b> You cannot directly write to enlarged chunks before       * <b>Caution:</b> You cannot directly write to enlarged chunks before
836       * calling File::Save() as this might exceed the current chunk's body       * calling File::Save() as this might exceed the current chunk's body
837       * boundary.       * boundary!
838       *       *
839       * @param iNewSize - new chunk body size in bytes (must be greater than zero)       * @param iNewSize - new chunk body size in bytes (must be greater than zero)
840       * @throws RIFF::Exception  if \a iNewSize is less than 1       * @throws RIFF::Exception  if \a iNewSize is less than 1
841       * @see File::Save()       * @see File::Save()
842       */       */
843      void Chunk::Resize(int iNewSize) {      void Chunk::Resize(int iNewSize) {
844          if (iNewSize <= 0) throw Exception("Chunk size must be at least one byte");          if (iNewSize <= 0)
845                throw Exception("There is at least one empty chunk (zero size): " + __resolveChunkPath(this));
846            if (NewChunkSize == iNewSize) return;
847          NewChunkSize = iNewSize;          NewChunkSize = iNewSize;
848          pFile->LogAsResized(this);          pFile->LogAsResized(this);
849      }      }
# Line 738  namespace RIFF { Line 856  namespace RIFF {
856       *                     chunk should be written to       *                     chunk should be written to
857       * @param ulCurrentDataOffset - offset of current (old) data within       * @param ulCurrentDataOffset - offset of current (old) data within
858       *                              the file       *                              the file
859         * @param pProgress - optional: callback function for progress notification
860       * @returns new write position in the "physical" file, that is       * @returns new write position in the "physical" file, that is
861       *          \a ulWritePos incremented by this chunk's new size       *          \a ulWritePos incremented by this chunk's new size
862       *          (including its header size of course)       *          (including its header size of course)
863       */       */
864      unsigned long Chunk::WriteChunk(unsigned long ulWritePos, unsigned long ulCurrentDataOffset) {      unsigned long Chunk::WriteChunk(unsigned long ulWritePos, unsigned long ulCurrentDataOffset, progress_t* pProgress) {
865          unsigned long ulOriginalPos = ulWritePos;          const unsigned long ulOriginalPos = ulWritePos;
866          ulWritePos += CHUNK_HEADER_SIZE;          ulWritePos += CHUNK_HEADER_SIZE;
867    
868            if (pFile->Mode != stream_mode_read_write)
869                throw Exception("Cannot write list chunk, file has to be opened in read+write mode");
870    
871          // if the whole chunk body was loaded into RAM          // if the whole chunk body was loaded into RAM
872          if (pChunkData) {          if (pChunkData) {
873              // in case the chunk size was changed, reallocate the data in RAM with the chunk's new size              // make sure chunk data buffer in RAM is at least as large as the new chunk size
874              if (NewChunkSize != CurrentChunkSize) {              LoadChunkData();
                 uint8_t* pNewBuffer = new uint8_t[NewChunkSize];  
                 if (NewChunkSize > CurrentChunkSize) {  
                     memcpy(pNewBuffer, pChunkData, CurrentChunkSize);  
                     memset(pNewBuffer + CurrentChunkSize, 0, NewChunkSize - CurrentChunkSize);  
                 } else {  
                     memcpy(pNewBuffer, pChunkData, NewChunkSize);  
                 }  
                 delete[] pChunkData;  
                 pChunkData = pNewBuffer;  
             }  
   
875              // write chunk data from RAM persistently to the file              // write chunk data from RAM persistently to the file
876              #if POSIX              #if POSIX
877              lseek(pFile->hFileWrite, ulWritePos, SEEK_SET);              lseek(pFile->hFileWrite, ulWritePos, SEEK_SET);
878              if (write(pFile->hFileWrite, pChunkData, NewChunkSize) != NewChunkSize) {              if (write(pFile->hFileWrite, pChunkData, NewChunkSize) != NewChunkSize) {
879                  throw Exception("Writing Chunk data (from RAM) failed");                  throw Exception("Writing Chunk data (from RAM) failed");
880              }              }
881                #elif defined(WIN32)
882                SetFilePointer(pFile->hFileWrite, ulWritePos, NULL/*32 bit*/, FILE_BEGIN);
883                DWORD dwBytesWritten;
884                WriteFile(pFile->hFileWrite, pChunkData, NewChunkSize, &dwBytesWritten, NULL);
885                if (dwBytesWritten != NewChunkSize) {
886                    throw Exception("Writing Chunk data (from RAM) failed");
887                }
888              #else              #else
889              fseek(pFile->hFileWrite, ulWritePos, SEEK_SET);              fseek(pFile->hFileWrite, ulWritePos, SEEK_SET);
890              if (fwrite(pChunkData, 1, NewChunkSize, pFile->hFileWrite) != NewChunkSize) {              if (fwrite(pChunkData, 1, NewChunkSize, pFile->hFileWrite) != NewChunkSize) {
# Line 777  namespace RIFF { Line 895  namespace RIFF {
895              // move chunk data from the end of the file to the appropriate position              // move chunk data from the end of the file to the appropriate position
896              int8_t* pCopyBuffer = new int8_t[4096];              int8_t* pCopyBuffer = new int8_t[4096];
897              unsigned long ulToMove = (NewChunkSize < CurrentChunkSize) ? NewChunkSize : CurrentChunkSize;              unsigned long ulToMove = (NewChunkSize < CurrentChunkSize) ? NewChunkSize : CurrentChunkSize;
898                #if defined(WIN32)
899                DWORD iBytesMoved = 1; // we have to pass it via pointer to the Windows API, thus the correct size must be ensured
900                #else
901              int iBytesMoved = 1;              int iBytesMoved = 1;
902              for (unsigned long ulOffset = 0; iBytesMoved > 0; ulOffset += iBytesMoved, ulToMove -= iBytesMoved) {              #endif
903                for (unsigned long ulOffset = 0; ulToMove > 0 && iBytesMoved > 0; ulOffset += iBytesMoved, ulToMove -= iBytesMoved) {
904                  iBytesMoved = (ulToMove < 4096) ? ulToMove : 4096;                  iBytesMoved = (ulToMove < 4096) ? ulToMove : 4096;
905                  #if POSIX                  #if POSIX
906                  lseek(pFile->hFileRead, ulStartPos + ulCurrentDataOffset + ulOffset, SEEK_SET);                  lseek(pFile->hFileRead, ulStartPos + ulCurrentDataOffset + ulOffset, SEEK_SET);
907                  iBytesMoved = read(pFile->hFileRead, pCopyBuffer, iBytesMoved);                  iBytesMoved = read(pFile->hFileRead, pCopyBuffer, iBytesMoved);
908                  lseek(pFile->hFileWrite, ulWritePos + ulOffset, SEEK_SET);                  lseek(pFile->hFileWrite, ulWritePos + ulOffset, SEEK_SET);
909                  iBytesMoved = write(pFile->hFileWrite, pCopyBuffer, iBytesMoved);                  iBytesMoved = write(pFile->hFileWrite, pCopyBuffer, iBytesMoved);
910                    #elif defined(WIN32)
911                    SetFilePointer(pFile->hFileRead, ulStartPos + ulCurrentDataOffset + ulOffset, NULL/*32 bit*/, FILE_BEGIN);
912                    ReadFile(pFile->hFileRead, pCopyBuffer, iBytesMoved, &iBytesMoved, NULL);
913                    SetFilePointer(pFile->hFileWrite, ulWritePos + ulOffset, NULL/*32 bit*/, FILE_BEGIN);
914                    WriteFile(pFile->hFileWrite, pCopyBuffer, iBytesMoved, &iBytesMoved, NULL);
915                  #else                  #else
916                  fseek(pFile->hFileRead, ulStartPos + ulCurrentDataOffset + ulOffset, SEEK_SET);                  fseek(pFile->hFileRead, ulStartPos + ulCurrentDataOffset + ulOffset, SEEK_SET);
917                  iBytesMoved = fread(pCopyBuffer, 1, iBytesMoved, pFile->hFileRead);                  iBytesMoved = fread(pCopyBuffer, 1, iBytesMoved, pFile->hFileRead);
# Line 800  namespace RIFF { Line 927  namespace RIFF {
927          CurrentChunkSize = NewChunkSize;          CurrentChunkSize = NewChunkSize;
928          WriteHeader(ulOriginalPos);          WriteHeader(ulOriginalPos);
929    
930            __notify_progress(pProgress, 1.0); // notify done
931    
932          // update chunk's position pointers          // update chunk's position pointers
933          ulStartPos = ulOriginalPos + CHUNK_HEADER_SIZE;          ulStartPos = ulOriginalPos + CHUNK_HEADER_SIZE;
934          ulPos      = 0;          ulPos      = 0;
935    
936          // add pad byte if needed          // add pad byte if needed
937          if ((ulStartPos + NewChunkSize) % 2 != 0) {          if ((ulStartPos + NewChunkSize) % 2 != 0) {
938              char cPadByte = 0;              const char cPadByte = 0;
939              #if POSIX              #if POSIX
940                lseek(pFile->hFileWrite, ulStartPos + NewChunkSize, SEEK_SET);
941              write(pFile->hFileWrite, &cPadByte, 1);              write(pFile->hFileWrite, &cPadByte, 1);
942                #elif defined(WIN32)
943                SetFilePointer(pFile->hFileWrite, ulStartPos + NewChunkSize, NULL/*32 bit*/, FILE_BEGIN);
944                DWORD dwBytesWritten;
945                WriteFile(pFile->hFileWrite, &cPadByte, 1, &dwBytesWritten, NULL);
946              #else              #else
947                fseek(pFile->hFileWrite, ulStartPos + NewChunkSize, SEEK_SET);
948              fwrite(&cPadByte, 1, 1, pFile->hFileWrite);              fwrite(&cPadByte, 1, 1, pFile->hFileWrite);
949              #endif              #endif
950              return ulStartPos + NewChunkSize + 1;              return ulStartPos + NewChunkSize + 1;
# Line 857  namespace RIFF { Line 992  namespace RIFF {
992        #if DEBUG        #if DEBUG
993        std::cout << "List::~List()" << std::endl;        std::cout << "List::~List()" << std::endl;
994        #endif // DEBUG        #endif // DEBUG
995            DeleteChunkList();
996        }
997    
998        void List::DeleteChunkList() {
999          if (pSubChunks) {          if (pSubChunks) {
1000              ChunkList::iterator iter = pSubChunks->begin();              ChunkList::iterator iter = pSubChunks->begin();
1001              ChunkList::iterator end  = pSubChunks->end();              ChunkList::iterator end  = pSubChunks->end();
# Line 865  namespace RIFF { Line 1004  namespace RIFF {
1004                  iter++;                  iter++;
1005              }              }
1006              delete pSubChunks;              delete pSubChunks;
1007                pSubChunks = NULL;
1008            }
1009            if (pSubChunksMap) {
1010                delete pSubChunksMap;
1011                pSubChunksMap = NULL;
1012          }          }
         if (pSubChunksMap) delete pSubChunksMap;  
1013      }      }
1014    
1015      /**      /**
# Line 1063  namespace RIFF { Line 1206  namespace RIFF {
1206      Chunk* List::AddSubChunk(uint32_t uiChunkID, uint uiBodySize) {      Chunk* List::AddSubChunk(uint32_t uiChunkID, uint uiBodySize) {
1207          if (uiBodySize == 0) throw Exception("Chunk body size must be at least 1 byte");          if (uiBodySize == 0) throw Exception("Chunk body size must be at least 1 byte");
1208          if (!pSubChunks) LoadSubChunks();          if (!pSubChunks) LoadSubChunks();
1209          Chunk* pNewChunk = new Chunk(pFile, this, uiChunkID, uiBodySize);          Chunk* pNewChunk = new Chunk(pFile, this, uiChunkID, 0);
1210          pSubChunks->push_back(pNewChunk);          pSubChunks->push_back(pNewChunk);
1211          (*pSubChunksMap)[uiChunkID] = pNewChunk;          (*pSubChunksMap)[uiChunkID] = pNewChunk;
1212          pFile->ResizedChunks.push_back(pNewChunk);          pNewChunk->Resize(uiBodySize);
1213            NewChunkSize += CHUNK_HEADER_SIZE;
1214            pFile->LogAsResized(this);
1215          return pNewChunk;          return pNewChunk;
1216      }      }
1217    
1218        /** @brief Moves a sub chunk witin this list.
1219         *
1220         * Moves a sub chunk from one position in this list to another
1221         * position in the same list. The pSrc chunk is placed before the
1222         * pDst chunk.
1223         *
1224         * @param pSrc - sub chunk to be moved
1225         * @param pDst - the position to move to. pSrc will be placed
1226         *               before pDst. If pDst is 0, pSrc will be placed
1227         *               last in list.
1228         */
1229        void List::MoveSubChunk(Chunk* pSrc, Chunk* pDst) {
1230            if (!pSubChunks) LoadSubChunks();
1231            pSubChunks->remove(pSrc);
1232            ChunkList::iterator iter = find(pSubChunks->begin(), pSubChunks->end(), pDst);
1233            pSubChunks->insert(iter, pSrc);
1234        }
1235    
1236        /** @brief Moves a sub chunk from this list to another list.
1237         *
1238         * Moves a sub chunk from this list list to the end of another
1239         * list.
1240         *
1241         * @param pSrc - sub chunk to be moved
1242         * @param pDst - destination list where the chunk shall be moved to
1243         */
1244        void List::MoveSubChunk(Chunk* pSrc, List* pNewParent) {
1245            if (pNewParent == this || !pNewParent) return;
1246            if (!pSubChunks) LoadSubChunks();
1247            if (!pNewParent->pSubChunks) pNewParent->LoadSubChunks();
1248            pSubChunks->remove(pSrc);
1249            pNewParent->pSubChunks->push_back(pSrc);
1250            // update chunk id map of this List
1251            if ((*pSubChunksMap)[pSrc->GetChunkID()] == pSrc) {
1252                pSubChunksMap->erase(pSrc->GetChunkID());
1253                // try to find another chunk of the same chunk ID
1254                ChunkList::iterator iter = pSubChunks->begin();
1255                ChunkList::iterator end  = pSubChunks->end();
1256                for (; iter != end; ++iter) {
1257                    if ((*iter)->GetChunkID() == pSrc->GetChunkID()) {
1258                        (*pSubChunksMap)[pSrc->GetChunkID()] = *iter;
1259                        break; // we're done, stop search
1260                    }
1261                }
1262            }
1263            // update chunk id map of other list
1264            if (!(*pNewParent->pSubChunksMap)[pSrc->GetChunkID()])
1265                (*pNewParent->pSubChunksMap)[pSrc->GetChunkID()] = pSrc;
1266        }
1267    
1268      /** @brief Creates a new list sub chunk.      /** @brief Creates a new list sub chunk.
1269       *       *
1270       * Creates and adds a new list sub chunk to this list chunk. Note that       * Creates and adds a new list sub chunk to this list chunk. Note that
# Line 1084  namespace RIFF { Line 1279  namespace RIFF {
1279          List* pNewListChunk = new List(pFile, this, uiListType);          List* pNewListChunk = new List(pFile, this, uiListType);
1280          pSubChunks->push_back(pNewListChunk);          pSubChunks->push_back(pNewListChunk);
1281          (*pSubChunksMap)[CHUNK_ID_LIST] = pNewListChunk;          (*pSubChunksMap)[CHUNK_ID_LIST] = pNewListChunk;
1282            NewChunkSize += LIST_HEADER_SIZE;
1283            pFile->LogAsResized(this);
1284          return pNewListChunk;          return pNewListChunk;
1285      }      }
1286    
# Line 1091  namespace RIFF { Line 1288  namespace RIFF {
1288       *       *
1289       * Removes the sub chunk given by \a pSubChunk from this list and frees       * Removes the sub chunk given by \a pSubChunk from this list and frees
1290       * it completely from RAM. The given chunk can either be a normal sub       * it completely from RAM. The given chunk can either be a normal sub
1291       * chunk or a list sub chunk. You should call File::Save() to make this       * chunk or a list sub chunk. In case the given chunk is a list chunk,
1292       * change persistent at any time.       * all its subchunks (if any) will be removed recursively as well. You
1293         * should call File::Save() to make this change persistent at any time.
1294       *       *
1295       * @param pSubChunk - sub chunk or sub list chunk to be removed       * @param pSubChunk - sub chunk or sub list chunk to be removed
1296       */       */
# Line 1119  namespace RIFF { Line 1317  namespace RIFF {
1317        std::cout << "List::Readheader(ulong) ";        std::cout << "List::Readheader(ulong) ";
1318        #endif // DEBUG        #endif // DEBUG
1319          Chunk::ReadHeader(fPos);          Chunk::ReadHeader(fPos);
1320            if (CurrentChunkSize < 4) return;
1321          NewChunkSize = CurrentChunkSize -= 4;          NewChunkSize = CurrentChunkSize -= 4;
1322          #if POSIX          #if POSIX
1323          lseek(pFile->hFileRead, fPos + CHUNK_HEADER_SIZE, SEEK_SET);          lseek(pFile->hFileRead, fPos + CHUNK_HEADER_SIZE, SEEK_SET);
1324          read(pFile->hFileRead, &ListType, 4);          read(pFile->hFileRead, &ListType, 4);
1325            #elif defined(WIN32)
1326            SetFilePointer(pFile->hFileRead, fPos + CHUNK_HEADER_SIZE, NULL/*32 bit*/, FILE_BEGIN);
1327            DWORD dwBytesRead;
1328            ReadFile(pFile->hFileRead, &ListType, 4, &dwBytesRead, NULL);
1329          #else          #else
1330          fseek(pFile->hFileRead, fPos + CHUNK_HEADER_SIZE, SEEK_SET);          fseek(pFile->hFileRead, fPos + CHUNK_HEADER_SIZE, SEEK_SET);
1331          fread(&ListType, 4, 1, pFile->hFileRead);          fread(&ListType, 4, 1, pFile->hFileRead);
# Line 1143  namespace RIFF { Line 1346  namespace RIFF {
1346          #if POSIX          #if POSIX
1347          lseek(pFile->hFileWrite, fPos + CHUNK_HEADER_SIZE, SEEK_SET);          lseek(pFile->hFileWrite, fPos + CHUNK_HEADER_SIZE, SEEK_SET);
1348          write(pFile->hFileWrite, &ListType, 4);          write(pFile->hFileWrite, &ListType, 4);
1349            #elif defined(WIN32)
1350            SetFilePointer(pFile->hFileWrite, fPos + CHUNK_HEADER_SIZE, NULL/*32 bit*/, FILE_BEGIN);
1351            DWORD dwBytesWritten;
1352            WriteFile(pFile->hFileWrite, &ListType, 4, &dwBytesWritten, NULL);
1353          #else          #else
1354          fseek(pFile->hFileWrite, fPos + CHUNK_HEADER_SIZE, SEEK_SET);          fseek(pFile->hFileWrite, fPos + CHUNK_HEADER_SIZE, SEEK_SET);
1355          fwrite(&ListType, 4, 1, pFile->hFileWrite);          fwrite(&ListType, 4, 1, pFile->hFileWrite);
1356          #endif // POSIX          #endif // POSIX
1357      }      }
1358    
1359      void List::LoadSubChunks() {      void List::LoadSubChunks(progress_t* pProgress) {
1360         #if DEBUG         #if DEBUG
1361         std::cout << "List::LoadSubChunks()";         std::cout << "List::LoadSubChunks()";
1362         #endif // DEBUG         #endif // DEBUG
1363          if (!pSubChunks) {          if (!pSubChunks) {
1364              pSubChunks    = new ChunkList();              pSubChunks    = new ChunkList();
1365              pSubChunksMap = new ChunkMap();              pSubChunksMap = new ChunkMap();
1366                #if defined(WIN32)
1367                if (pFile->hFileRead == INVALID_HANDLE_VALUE) return;
1368                #else
1369              if (!pFile->hFileRead) return;              if (!pFile->hFileRead) return;
1370                #endif
1371              unsigned long uiOriginalPos = GetPos();              unsigned long uiOriginalPos = GetPos();
1372              SetPos(0); // jump to beginning of list chunk body              SetPos(0); // jump to beginning of list chunk body
1373              while (RemainingBytes() >= CHUNK_HEADER_SIZE) {              while (RemainingBytes() >= CHUNK_HEADER_SIZE) {
# Line 1180  namespace RIFF { Line 1391  namespace RIFF {
1391              }              }
1392              SetPos(uiOriginalPos); // restore position before this call              SetPos(uiOriginalPos); // restore position before this call
1393          }          }
1394            __notify_progress(pProgress, 1.0); // notify done
1395        }
1396    
1397        void List::LoadSubChunksRecursively(progress_t* pProgress) {
1398            const int n = CountSubLists();
1399            int i = 0;
1400            for (List* pList = GetFirstSubList(); pList; pList = GetNextSubList(), ++i) {
1401                // divide local progress into subprogress
1402                progress_t subprogress;
1403                __divide_progress(pProgress, &subprogress, n, i);
1404                // do the actual work
1405                pList->LoadSubChunksRecursively(&subprogress);
1406            }
1407            __notify_progress(pProgress, 1.0); // notify done
1408      }      }
1409    
1410      /** @brief Write list chunk persistently e.g. to disk.      /** @brief Write list chunk persistently e.g. to disk.
# Line 1192  namespace RIFF { Line 1417  namespace RIFF {
1417       *                     list chunk should be written to       *                     list chunk should be written to
1418       * @param ulCurrentDataOffset - offset of current (old) data within       * @param ulCurrentDataOffset - offset of current (old) data within
1419       *                              the file       *                              the file
1420         * @param pProgress - optional: callback function for progress notification
1421       * @returns new write position in the "physical" file, that is       * @returns new write position in the "physical" file, that is
1422       *          \a ulWritePos incremented by this list chunk's new size       *          \a ulWritePos incremented by this list chunk's new size
1423       *          (including its header size of course)       *          (including its header size of course)
1424       */       */
1425      unsigned long List::WriteChunk(unsigned long ulWritePos, unsigned long ulCurrentDataOffset) {      unsigned long List::WriteChunk(unsigned long ulWritePos, unsigned long ulCurrentDataOffset, progress_t* pProgress) {
1426          unsigned long ulOriginalPos = ulWritePos;          const unsigned long ulOriginalPos = ulWritePos;
1427          ulWritePos += LIST_HEADER_SIZE;          ulWritePos += LIST_HEADER_SIZE;
1428    
1429            if (pFile->Mode != stream_mode_read_write)
1430                throw Exception("Cannot write list chunk, file has to be opened in read+write mode");
1431    
1432          // write all subchunks (including sub list chunks) recursively          // write all subchunks (including sub list chunks) recursively
1433          if (pSubChunks) {          if (pSubChunks) {
1434              for (ChunkList::iterator iter = pSubChunks->begin(), end = pSubChunks->end(); iter != end; ++iter) {              int i = 0;
1435                  ulWritePos = (*iter)->WriteChunk(ulWritePos, ulCurrentDataOffset);              const int n = pSubChunks->size();
1436                for (ChunkList::iterator iter = pSubChunks->begin(), end = pSubChunks->end(); iter != end; ++iter, ++i) {
1437                    // divide local progress into subprogress for loading current Instrument
1438                    progress_t subprogress;
1439                    __divide_progress(pProgress, &subprogress, n, i);
1440                    // do the actual work
1441                    ulWritePos = (*iter)->WriteChunk(ulWritePos, ulCurrentDataOffset, &subprogress);
1442              }              }
1443          }          }
1444    
# Line 1211  namespace RIFF { Line 1446  namespace RIFF {
1446          CurrentChunkSize = NewChunkSize = ulWritePos - ulOriginalPos - LIST_HEADER_SIZE;          CurrentChunkSize = NewChunkSize = ulWritePos - ulOriginalPos - LIST_HEADER_SIZE;
1447          WriteHeader(ulOriginalPos);          WriteHeader(ulOriginalPos);
1448    
1449            // offset of this list chunk in new written file may have changed
1450            ulStartPos = ulOriginalPos + LIST_HEADER_SIZE;
1451    
1452             __notify_progress(pProgress, 1.0); // notify done
1453    
1454          return ulWritePos;          return ulWritePos;
1455      }      }
1456    
# Line 1235  namespace RIFF { Line 1475  namespace RIFF {
1475  // *************** File ***************  // *************** File ***************
1476  // *  // *
1477    
1478    //HACK: to avoid breaking DLL compatibility to older versions of libgig we roll the new std::set<Chunk*> into the old std::list<Chunk*> container, should be replaced on member variable level soon though
1479    #define _GET_RESIZED_CHUNKS() \
1480            (reinterpret_cast<std::set<Chunk*>*>(ResizedChunks.front()))
1481    
1482      /** @brief Create new RIFF file.      /** @brief Create new RIFF file.
1483       *       *
1484       * Use this constructor if you want to create a new RIFF file completely       * Use this constructor if you want to create a new RIFF file completely
1485       * "from scratch". Note: there must be no empty chunks or empty list       * "from scratch". Note: there must be no empty chunks or empty list
1486       * chunks when trying to make the new RIFF file persistent with Save()!       * chunks when trying to make the new RIFF file persistent with Save()!
1487       *       *
1488       * @see AddSubChunk(), AddSubList()       * Note: by default, the RIFF file will be saved in native endian
1489       */       * format; that is, as a RIFF file on little-endian machines and
1490      File::File() : List(this) {       * as a RIFX file on big-endian. To change this behaviour, call
1491         * SetByteOrder() before calling Save().
1492         *
1493         * @param FileType - four-byte identifier of the RIFF file type
1494         * @see AddSubChunk(), AddSubList(), SetByteOrder()
1495         */
1496        File::File(uint32_t FileType)
1497            : List(this), bIsNewFile(true), Layout(layout_standard)
1498        {
1499            //HACK: see _GET_RESIZED_CHUNKS() comment
1500            ResizedChunks.push_back(reinterpret_cast<Chunk*>(new std::set<Chunk*>));
1501            #if defined(WIN32)
1502            hFileRead = hFileWrite = INVALID_HANDLE_VALUE;
1503            #else
1504          hFileRead = hFileWrite = 0;          hFileRead = hFileWrite = 0;
1505            #endif
1506            Mode = stream_mode_closed;
1507          bEndianNative = true;          bEndianNative = true;
1508          ulStartPos = RIFF_HEADER_SIZE;          ulStartPos = RIFF_HEADER_SIZE;
1509            ListType = FileType;
1510      }      }
1511    
1512      /** @brief Load existing RIFF file.      /** @brief Load existing RIFF file.
# Line 1257  namespace RIFF { Line 1517  namespace RIFF {
1517       * @throws RIFF::Exception if error occured while trying to load the       * @throws RIFF::Exception if error occured while trying to load the
1518       *                         given RIFF file       *                         given RIFF file
1519       */       */
1520      File::File(const String& path) : List(this), Filename(path) {      File::File(const String& path)
1521        #if DEBUG          : List(this), Filename(path), bIsNewFile(false), Layout(layout_standard)
1522        std::cout << "File::File("<<path<<")" << std::endl;      {
1523        #endif // DEBUG         #if DEBUG
1524           std::cout << "File::File("<<path<<")" << std::endl;
1525           #endif // DEBUG
1526          bEndianNative = true;          bEndianNative = true;
1527            try {
1528                __openExistingFile(path);
1529                if (ChunkID != CHUNK_ID_RIFF && ChunkID != CHUNK_ID_RIFX) {
1530                    throw RIFF::Exception("Not a RIFF file");
1531                }
1532            }
1533            catch (...) {
1534                Cleanup();
1535                throw;
1536            }
1537        }
1538    
1539        /** @brief Load existing RIFF-like file.
1540         *
1541         * Loads an existing file, which is not a "real" RIFF file, but similar to
1542         * an ordinary RIFF file.
1543         *
1544         * A "real" RIFF file contains at top level a List chunk either with chunk
1545         * ID "RIFF" or "RIFX". The simple constructor above expects this to be
1546         * case, and if it finds the toplevel List chunk to have another chunk ID
1547         * than one of those two expected ones, it would throw an Exception and
1548         * would refuse to load the file accordingly.
1549         *
1550         * Since there are however a lot of file formats which use the same simple
1551         * principles of the RIFF format, with another toplevel List chunk ID
1552         * though, you can use this alternative constructor here to be able to load
1553         * and handle those files in the same way as you would do with "real" RIFF
1554         * files.
1555         *
1556         * @param path - path and file name of the RIFF-alike file to be opened
1557         * @param FileType - expected toplevel List chunk ID (this is the very
1558         *                   first chunk found in the file)
1559         * @param Endian - whether the file uses little endian or big endian layout
1560         * @param layout - general file structure type
1561         * @throws RIFF::Exception if error occured while trying to load the
1562         *                         given RIFF-alike file
1563         */
1564        File::File(const String& path, uint32_t FileType, endian_t Endian, layout_t layout)
1565            : List(this), Filename(path), bIsNewFile(false), Layout(layout)
1566        {
1567            SetByteOrder(Endian);
1568            try {
1569                __openExistingFile(path, &FileType);
1570            }
1571            catch (...) {
1572                Cleanup();
1573                throw;
1574            }
1575        }
1576    
1577        /**
1578         * Opens an already existing RIFF file or RIFF-alike file. This method
1579         * shall only be called once (in a File class constructor).
1580         *
1581         * @param path - path and file name of the RIFF file or RIFF-alike file to
1582         *               be opened
1583         * @param FileType - (optional) expected chunk ID of first chunk in file
1584         * @throws RIFF::Exception if error occured while trying to load the
1585         *                         given RIFF file or RIFF-alike file
1586         */
1587        void File::__openExistingFile(const String& path, uint32_t* FileType) {
1588            //HACK: see _GET_RESIZED_CHUNKS() comment
1589            ResizedChunks.push_back(reinterpret_cast<Chunk*>(new std::set<Chunk*>));
1590          #if POSIX          #if POSIX
1591          hFileRead = hFileWrite = open(path.c_str(), O_RDONLY | O_NONBLOCK);          hFileRead = hFileWrite = open(path.c_str(), O_RDONLY | O_NONBLOCK);
1592          if (hFileRead <= 0) {          if (hFileRead == -1) {
1593              hFileRead = hFileWrite = 0;              hFileRead = hFileWrite = 0;
1594                String sError = strerror(errno);
1595                throw RIFF::Exception("Can't open \"" + path + "\": " + sError);
1596            }
1597            #elif defined(WIN32)
1598            hFileRead = hFileWrite = CreateFile(
1599                                         path.c_str(), GENERIC_READ,
1600                                         FILE_SHARE_READ | FILE_SHARE_WRITE,
1601                                         NULL, OPEN_EXISTING,
1602                                         FILE_ATTRIBUTE_NORMAL |
1603                                         FILE_FLAG_RANDOM_ACCESS, NULL
1604                                     );
1605            if (hFileRead == INVALID_HANDLE_VALUE) {
1606                hFileRead = hFileWrite = INVALID_HANDLE_VALUE;
1607              throw RIFF::Exception("Can't open \"" + path + "\"");              throw RIFF::Exception("Can't open \"" + path + "\"");
1608          }          }
1609          #else          #else
1610          hFileRead = hFileWrite = fopen(path.c_str(), "rb");          hFileRead = hFileWrite = fopen(path.c_str(), "rb");
1611          if (!hFile) throw RIFF::Exception("Can't open \"" + path + "\"");          if (!hFileRead) throw RIFF::Exception("Can't open \"" + path + "\"");
1612          #endif // POSIX          #endif // POSIX
1613          ulStartPos = RIFF_HEADER_SIZE;          Mode = stream_mode_read;
1614          ReadHeader(0);          switch (Layout) {
1615          if (ChunkID != CHUNK_ID_RIFF) {              case layout_standard: // this is a normal RIFF file
1616              throw RIFF::Exception("Not a RIFF file");                  ulStartPos = RIFF_HEADER_SIZE;
1617                    ReadHeader(0);
1618                    if (FileType && ChunkID != *FileType)
1619                        throw RIFF::Exception("Invalid file container ID");
1620                    break;
1621                case layout_flat: // non-standard RIFF-alike file
1622                    ulStartPos = 0;
1623                    NewChunkSize = CurrentChunkSize = GetFileSize();
1624                    if (FileType) {
1625                        uint32_t ckid;
1626                        if (Read(&ckid, 4, 1) != 4) {
1627                            throw RIFF::Exception("Invalid file header ID (premature end of header)");
1628                        } else if (ckid != *FileType) {
1629                            String s = " (expected '" + convertToString(*FileType) + "' but got '" + convertToString(ckid) + "')";
1630                            throw RIFF::Exception("Invalid file header ID" + s);
1631                        }
1632                        SetPos(0); // reset to first byte of file
1633                    }
1634                    LoadSubChunks();
1635                    break;
1636          }          }
1637      }      }
1638    
1639      String File::GetFileName() {      String File::GetFileName() {
1640          return Filename;          return Filename;
1641      }      }
1642        
1643        void File::SetFileName(const String& path) {
1644            Filename = path;
1645        }
1646    
1647      stream_mode_t File::GetMode() {      stream_mode_t File::GetMode() {
1648          return Mode;          return Mode;
1649      }      }
1650    
1651        layout_t File::GetLayout() const {
1652            return Layout;
1653        }
1654    
1655      /** @brief Change file access mode.      /** @brief Change file access mode.
1656       *       *
1657       * Changes files access mode either to read-only mode or to read/write       * Changes files access mode either to read-only mode or to read/write
# Line 1304  namespace RIFF { Line 1669  namespace RIFF {
1669                      #if POSIX                      #if POSIX
1670                      if (hFileRead) close(hFileRead);                      if (hFileRead) close(hFileRead);
1671                      hFileRead = hFileWrite = open(Filename.c_str(), O_RDONLY | O_NONBLOCK);                      hFileRead = hFileWrite = open(Filename.c_str(), O_RDONLY | O_NONBLOCK);
1672                      if (hFileRead < 0) {                      if (hFileRead == -1) {
1673                          hFileRead = hFileWrite = 0;                          hFileRead = hFileWrite = 0;
1674                            String sError = strerror(errno);
1675                            throw Exception("Could not (re)open file \"" + Filename + "\" in read mode: " + sError);
1676                        }
1677                        #elif defined(WIN32)
1678                        if (hFileRead != INVALID_HANDLE_VALUE) CloseHandle(hFileRead);
1679                        hFileRead = hFileWrite = CreateFile(
1680                                                     Filename.c_str(), GENERIC_READ,
1681                                                     FILE_SHARE_READ | FILE_SHARE_WRITE,
1682                                                     NULL, OPEN_EXISTING,
1683                                                     FILE_ATTRIBUTE_NORMAL |
1684                                                     FILE_FLAG_RANDOM_ACCESS,
1685                                                     NULL
1686                                                 );
1687                        if (hFileRead == INVALID_HANDLE_VALUE) {
1688                            hFileRead = hFileWrite = INVALID_HANDLE_VALUE;
1689                          throw Exception("Could not (re)open file \"" + Filename + "\" in read mode");                          throw Exception("Could not (re)open file \"" + Filename + "\" in read mode");
1690                      }                      }
1691                      #else                      #else
1692                      if (hFileRead) fclose(hFileRead);                      if (hFileRead) fclose(hFileRead);
1693                      hFileRead = hFileWrite = fopen(path.c_str(), "rb");                      hFileRead = hFileWrite = fopen(Filename.c_str(), "rb");
1694                      if (!hFileRead) throw Exception("Could not (re)open file \"" + Filename + "\" in read mode");                      if (!hFileRead) throw Exception("Could not (re)open file \"" + Filename + "\" in read mode");
1695                      #endif                      #endif
1696                      __resetPos(); // reset read/write position of ALL 'Chunk' objects                      __resetPos(); // reset read/write position of ALL 'Chunk' objects
1697                      return true;                      break;
1698                  case stream_mode_read_write:                  case stream_mode_read_write:
1699                      #if POSIX                      #if POSIX
1700                      if (hFileRead) close(hFileRead);                      if (hFileRead) close(hFileRead);
1701                      hFileRead = hFileWrite = open(Filename.c_str(), O_RDWR | O_NONBLOCK);                      hFileRead = hFileWrite = open(Filename.c_str(), O_RDWR | O_NONBLOCK);
1702                      if (hFileRead < 0) {                      if (hFileRead == -1) {
1703                          hFileRead = hFileWrite = open(Filename.c_str(), O_RDONLY | O_NONBLOCK);                          hFileRead = hFileWrite = open(Filename.c_str(), O_RDONLY | O_NONBLOCK);
1704                          throw Exception("Could not open file \"" + Filename + "\" in read+write mode");                          String sError = strerror(errno);
1705                            throw Exception("Could not open file \"" + Filename + "\" in read+write mode: " + sError);
1706                        }
1707                        #elif defined(WIN32)
1708                        if (hFileRead != INVALID_HANDLE_VALUE) CloseHandle(hFileRead);
1709                        hFileRead = hFileWrite = CreateFile(
1710                                                     Filename.c_str(),
1711                                                     GENERIC_READ | GENERIC_WRITE,
1712                                                     FILE_SHARE_READ,
1713                                                     NULL, OPEN_ALWAYS,
1714                                                     FILE_ATTRIBUTE_NORMAL |
1715                                                     FILE_FLAG_RANDOM_ACCESS,
1716                                                     NULL
1717                                                 );
1718                        if (hFileRead == INVALID_HANDLE_VALUE) {
1719                            hFileRead = hFileWrite = CreateFile(
1720                                                         Filename.c_str(), GENERIC_READ,
1721                                                         FILE_SHARE_READ | FILE_SHARE_WRITE,
1722                                                         NULL, OPEN_EXISTING,
1723                                                         FILE_ATTRIBUTE_NORMAL |
1724                                                         FILE_FLAG_RANDOM_ACCESS,
1725                                                         NULL
1726                                                     );
1727                            throw Exception("Could not (re)open file \"" + Filename + "\" in read+write mode");
1728                      }                      }
1729                      #else                      #else
1730                      if (hFileRead) fclose(hFileRead);                      if (hFileRead) fclose(hFileRead);
1731                      hFileRead = hFileWrite = fopen(path.c_str(), "r+b");                      hFileRead = hFileWrite = fopen(Filename.c_str(), "r+b");
1732                      if (!hFileRead) {                      if (!hFileRead) {
1733                          hFileRead = hFileWrite = fopen(path.c_str(), "rb");                          hFileRead = hFileWrite = fopen(Filename.c_str(), "rb");
1734                          throw Exception("Could not open file \"" + Filename + "\" in read+write mode");                          throw Exception("Could not open file \"" + Filename + "\" in read+write mode");
1735                      }                      }
1736                      #endif                      #endif
1737                      __resetPos(); // reset read/write position of ALL 'Chunk' objects                      __resetPos(); // reset read/write position of ALL 'Chunk' objects
1738                      return true;                      break;
1739                    case stream_mode_closed:
1740                        #if POSIX
1741                        if (hFileRead)  close(hFileRead);
1742                        if (hFileWrite) close(hFileWrite);
1743                        #elif defined(WIN32)
1744                        if (hFileRead  != INVALID_HANDLE_VALUE) CloseHandle(hFileRead);
1745                        if (hFileWrite != INVALID_HANDLE_VALUE) CloseHandle(hFileWrite);
1746                        #else
1747                        if (hFileRead)  fclose(hFileRead);
1748                        if (hFileWrite) fclose(hFileWrite);
1749                        #endif
1750                        hFileRead = hFileWrite = 0;
1751                        break;
1752                  default:                  default:
1753                      throw Exception("Unknown file access mode");                      throw Exception("Unknown file access mode");
1754              }              }
1755                Mode = NewMode;
1756                return true;
1757          }          }
1758          return false;          return false;
1759      }      }
1760    
1761        /** @brief Set the byte order to be used when saving.
1762         *
1763         * Set the byte order to be used in the file. A value of
1764         * endian_little will create a RIFF file, endian_big a RIFX file
1765         * and endian_native will create a RIFF file on little-endian
1766         * machines and RIFX on big-endian machines.
1767         *
1768         * @param Endian - endianess to use when file is saved.
1769         */
1770        void File::SetByteOrder(endian_t Endian) {
1771            #if WORDS_BIGENDIAN
1772            bEndianNative = Endian != endian_little;
1773            #else
1774            bEndianNative = Endian != endian_big;
1775            #endif
1776        }
1777    
1778      /** @brief Save changes to same file.      /** @brief Save changes to same file.
1779       *       *
1780       * Make all changes of all chunks persistent by writing them to the       * Make all changes of all chunks persistent by writing them to the
# Line 1347  namespace RIFF { Line 1782  namespace RIFF {
1782       * than it will have at the end of the saving process, in case chunks       * than it will have at the end of the saving process, in case chunks
1783       * were grown.       * were grown.
1784       *       *
1785         * @param pProgress - optional: callback function for progress notification
1786       * @throws RIFF::Exception if there is an empty chunk or empty list       * @throws RIFF::Exception if there is an empty chunk or empty list
1787       *                         chunk or any kind of IO error occured       *                         chunk or any kind of IO error occured
1788       */       */
1789      void File::Save() {      void File::Save(progress_t* pProgress) {
1790            //TODO: implementation for the case where first chunk is not a global container (List chunk) is not implemented yet (i.e. Korg files)
1791            if (Layout == layout_flat)
1792                throw Exception("Saving a RIFF file with layout_flat is not implemented yet");
1793    
1794            // make sure the RIFF tree is built (from the original file)
1795            {
1796                // divide progress into subprogress
1797                progress_t subprogress;
1798                __divide_progress(pProgress, &subprogress, 3.f, 0.f); // arbitrarily subdivided into 1/3 of total progress
1799                // do the actual work
1800                LoadSubChunksRecursively(&subprogress);
1801                // notify subprogress done
1802                __notify_progress(&subprogress, 1.f);
1803            }
1804    
1805          // reopen file in write mode          // reopen file in write mode
1806          bool bModeWasChanged = SetMode(stream_mode_read_write);          SetMode(stream_mode_read_write);
1807    
1808          // to be able to save the whole file without loading everything into          // to be able to save the whole file without loading everything into
1809          // RAM and without having to store the data in a temporary file, we          // RAM and without having to store the data in a temporary file, we
# Line 1363  namespace RIFF { Line 1814  namespace RIFF {
1814    
1815          // first we sum up all positive chunk size changes (and skip all negative ones)          // first we sum up all positive chunk size changes (and skip all negative ones)
1816          unsigned long ulPositiveSizeDiff = 0;          unsigned long ulPositiveSizeDiff = 0;
1817          for (ChunkList::iterator iter = ResizedChunks.begin(), end = ResizedChunks.end(); iter != end; ++iter) {          std::set<Chunk*>* resizedChunks = _GET_RESIZED_CHUNKS();
1818              if ((*iter)->GetNewSize() == 0) throw Exception("There is at least one empty chunk (zero size)");          for (std::set<Chunk*>::const_iterator iter = resizedChunks->begin(), end = resizedChunks->end(); iter != end; ++iter) {
1819              unsigned long ulDiff = (*iter)->GetNewSize() - (*iter)->GetSize() + 1L; // +1 in case we have to add a pad byte              if ((*iter)->GetNewSize() == 0) {
1820              if (ulDiff > 0) ulPositiveSizeDiff += ulDiff;                  throw Exception("There is at least one empty chunk (zero size): " + __resolveChunkPath(*iter));
1821                }
1822                unsigned long newSizePadded = (*iter)->GetNewSize() + (*iter)->GetNewSize() % 2;
1823                unsigned long oldSizePadded = (*iter)->GetSize() + (*iter)->GetSize() % 2;
1824                if (newSizePadded > oldSizePadded) ulPositiveSizeDiff += newSizePadded - oldSizePadded;
1825          }          }
1826    
1827          unsigned long ulWorkingFileSize = GetFileSize();          unsigned long ulWorkingFileSize = GetFileSize();
1828    
1829          // if there are positive size changes...          // if there are positive size changes...
1830          if (ulPositiveSizeDiff > 0) {          if (ulPositiveSizeDiff > 0) {
1831                // divide progress into subprogress
1832                progress_t subprogress;
1833                __divide_progress(pProgress, &subprogress, 3.f, 1.f); // arbitrarily subdivided into 1/3 of total progress
1834    
1835              // ... we enlarge this file first ...              // ... we enlarge this file first ...
1836              ulWorkingFileSize += ulPositiveSizeDiff;              ulWorkingFileSize += ulPositiveSizeDiff;
1837              ResizeFile(ulWorkingFileSize);              ResizeFile(ulWorkingFileSize);
1838              // ... and move current data by the same amount towards end of file.              // ... and move current data by the same amount towards end of file.
1839              int8_t* pCopyBuffer = new int8_t[4096];              int8_t* pCopyBuffer = new int8_t[4096];
1840              const unsigned long ulFileSize = GetSize() + RIFF_HEADER_SIZE;              const unsigned long ulFileSize = GetSize() + RIFF_HEADER_SIZE;
1841                #if defined(WIN32)
1842                DWORD iBytesMoved = 1; // we have to pass it via pointer to the Windows API, thus the correct size must be ensured
1843                #else
1844              int iBytesMoved = 1;              int iBytesMoved = 1;
1845              for (unsigned long ulPos = 0; iBytesMoved > 0; ulPos += iBytesMoved) {              #endif
1846                  const unsigned long ulToMove = ulFileSize - ulPos;              for (unsigned long ulPos = ulFileSize, iNotif = 0; iBytesMoved > 0; ++iNotif) {
1847                  iBytesMoved = (ulToMove < 4096) ? ulToMove : 4096;                  iBytesMoved = (ulPos < 4096) ? ulPos : 4096;
1848                    ulPos -= iBytesMoved;
1849                  #if POSIX                  #if POSIX
1850                  lseek(hFileRead, ulPos, SEEK_SET);                  lseek(hFileRead, ulPos, SEEK_SET);
1851                  iBytesMoved = read(hFileRead, pCopyBuffer, iBytesMoved);                  iBytesMoved = read(hFileRead, pCopyBuffer, iBytesMoved);
1852                  lseek(hFileWrite, ulPos + ulPositiveSizeDiff, SEEK_SET);                  lseek(hFileWrite, ulPos + ulPositiveSizeDiff, SEEK_SET);
1853                  iBytesMoved = write(hFileWrite, pCopyBuffer, iBytesMoved);                  iBytesMoved = write(hFileWrite, pCopyBuffer, iBytesMoved);
1854                    #elif defined(WIN32)
1855                    SetFilePointer(hFileRead, ulPos, NULL/*32 bit*/, FILE_BEGIN);
1856                    ReadFile(hFileRead, pCopyBuffer, iBytesMoved, &iBytesMoved, NULL);
1857                    SetFilePointer(hFileWrite, ulPos + ulPositiveSizeDiff, NULL/*32 bit*/, FILE_BEGIN);
1858                    WriteFile(hFileWrite, pCopyBuffer, iBytesMoved, &iBytesMoved, NULL);
1859                  #else                  #else
1860                  fseek(hFileRead, ulPos, SEEK_SET);                  fseek(hFileRead, ulPos, SEEK_SET);
1861                  iBytesMoved = fread(pCopyBuffer, 1, iBytesMoved, hFileRead);                  iBytesMoved = fread(pCopyBuffer, 1, iBytesMoved, hFileRead);
1862                  fseek(hFileWrite, ulPos + ulPositiveSizeDiff, SEEK_SET);                  fseek(hFileWrite, ulPos + ulPositiveSizeDiff, SEEK_SET);
1863                  iBytesMoved = fwrite(pCopyBuffer, 1, iBytesMoved, hFileWrite);                  iBytesMoved = fwrite(pCopyBuffer, 1, iBytesMoved, hFileWrite);
1864                  #endif                  #endif
1865                    if (!(iNotif % 8) && iBytesMoved > 0)
1866                        __notify_progress(&subprogress, float(ulFileSize - ulPos) / float(ulFileSize));
1867              }              }
1868              delete[] pCopyBuffer;              delete[] pCopyBuffer;
1869              if (iBytesMoved < 0) throw Exception("Could not modify file while trying to enlarge it");              if (iBytesMoved < 0) throw Exception("Could not modify file while trying to enlarge it");
1870    
1871                __notify_progress(&subprogress, 1.f); // notify subprogress done
1872          }          }
1873    
1874          // rebuild / rewrite complete RIFF tree          // rebuild / rewrite complete RIFF tree ...
1875          unsigned long ulTotalSize = WriteChunk(0, ulPositiveSizeDiff);  
1876            // divide progress into subprogress
1877            progress_t subprogress;
1878            __divide_progress(pProgress, &subprogress, 3.f, 2.f); // arbitrarily subdivided into 1/3 of total progress
1879            // do the actual work
1880            unsigned long ulTotalSize  = WriteChunk(0, ulPositiveSizeDiff, &subprogress);
1881            unsigned long ulActualSize = __GetFileSize(hFileWrite);
1882            // notify subprogress done
1883            __notify_progress(&subprogress, 1.f);
1884    
1885          // resize file to the final size          // resize file to the final size
1886          if (ulTotalSize < ulWorkingFileSize) ResizeFile(ulTotalSize);          if (ulTotalSize < ulActualSize) ResizeFile(ulTotalSize);
1887    
1888          // forget all resized chunks          // forget all resized chunks
1889          ResizedChunks.clear();          resizedChunks->clear();
1890    
1891          // reopen file in read mode          __notify_progress(pProgress, 1.0); // notify done
         if (bModeWasChanged) SetMode(stream_mode_read);  
1892      }      }
1893    
1894      /** @brief Save changes to another file.      /** @brief Save changes to another file.
# Line 1417  namespace RIFF { Line 1896  namespace RIFF {
1896       * Make all changes of all chunks persistent by writing them to another       * Make all changes of all chunks persistent by writing them to another
1897       * file. <b>Caution:</b> this method is optimized for writing to       * file. <b>Caution:</b> this method is optimized for writing to
1898       * <b>another</b> file, do not use it to save the changes to the same       * <b>another</b> file, do not use it to save the changes to the same
1899       * file! Use File::Save() in that case instead!       * file! Use File::Save() in that case instead! Ignoring this might
1900         * result in a corrupted file, especially in case chunks were resized!
1901       *       *
1902       * After calling this method, this File object will be associated with       * After calling this method, this File object will be associated with
1903       * the new file (given by \a path) afterwards.       * the new file (given by \a path) afterwards.
1904       *       *
1905       * @param path - path and file name where everything should be written to       * @param path - path and file name where everything should be written to
1906         * @param pProgress - optional: callback function for progress notification
1907       */       */
1908      void File::Save(const String& path) {      void File::Save(const String& path, progress_t* pProgress) {
1909            //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
1910    
1911            //TODO: implementation for the case where first chunk is not a global container (List chunk) is not implemented yet (i.e. Korg files)
1912            if (Layout == layout_flat)
1913                throw Exception("Saving a RIFF file with layout_flat is not implemented yet");
1914    
1915            // make sure the RIFF tree is built (from the original file)
1916            {
1917                // divide progress into subprogress
1918                progress_t subprogress;
1919                __divide_progress(pProgress, &subprogress, 2.f, 0.f); // arbitrarily subdivided into 1/2 of total progress
1920                // do the actual work
1921                LoadSubChunksRecursively(&subprogress);
1922                // notify subprogress done
1923                __notify_progress(&subprogress, 1.f);
1924            }
1925    
1926            if (!bIsNewFile) SetMode(stream_mode_read);
1927          // open the other (new) file for writing and truncate it to zero size          // open the other (new) file for writing and truncate it to zero size
1928          #if POSIX          #if POSIX
1929          hFileWrite = open(path.c_str(), O_RDWR | O_CREAT | O_TRUNC);          hFileWrite = open(path.c_str(), O_RDWR | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP);
1930          if (hFileWrite < 0) {          if (hFileWrite == -1) {
1931                hFileWrite = hFileRead;
1932                String sError = strerror(errno);
1933                throw Exception("Could not open file \"" + path + "\" for writing: " + sError);
1934            }
1935            #elif defined(WIN32)
1936            hFileWrite = CreateFile(
1937                             path.c_str(), GENERIC_WRITE, FILE_SHARE_READ,
1938                             NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL |
1939                             FILE_FLAG_RANDOM_ACCESS, NULL
1940                         );
1941            if (hFileWrite == INVALID_HANDLE_VALUE) {
1942              hFileWrite = hFileRead;              hFileWrite = hFileRead;
1943              throw Exception("Could not open file \"" + path + "\" for writing");              throw Exception("Could not open file \"" + path + "\" for writing");
1944          }          }
# Line 1439  namespace RIFF { Line 1949  namespace RIFF {
1949              throw Exception("Could not open file \"" + path + "\" for writing");              throw Exception("Could not open file \"" + path + "\" for writing");
1950          }          }
1951          #endif // POSIX          #endif // POSIX
1952            Mode = stream_mode_read_write;
1953    
1954          // write complete RIFF tree to the other (new) file          // write complete RIFF tree to the other (new) file
1955          WriteChunk(0, 0);          unsigned long ulTotalSize;
1956            {
1957                // divide progress into subprogress
1958                progress_t subprogress;
1959                __divide_progress(pProgress, &subprogress, 2.f, 1.f); // arbitrarily subdivided into 1/2 of total progress
1960                // do the actual work
1961                ulTotalSize = WriteChunk(0, 0, &subprogress);
1962                // notify subprogress done
1963                __notify_progress(&subprogress, 1.f);
1964            }
1965            unsigned long ulActualSize = __GetFileSize(hFileWrite);
1966    
1967            // resize file to the final size (if the file was originally larger)
1968            if (ulTotalSize < ulActualSize) ResizeFile(ulTotalSize);
1969    
1970          // forget all resized chunks          // forget all resized chunks
1971          ResizedChunks.clear();          _GET_RESIZED_CHUNKS()->clear();
1972    
1973            #if POSIX
1974            if (hFileWrite) close(hFileWrite);
1975            #elif defined(WIN32)
1976            if (hFileWrite != INVALID_HANDLE_VALUE) CloseHandle(hFileWrite);
1977            #else
1978            if (hFileWrite) fclose(hFileWrite);
1979            #endif
1980            hFileWrite = hFileRead;
1981    
1982          // associate new file with this File object from now on          // associate new file with this File object from now on
1983          Filename = path;          Filename = path;
1984          stream_mode_t oldMode = Mode;          bIsNewFile = false;
1985          Mode = (stream_mode_t) -1; // Just set it to an undefined mode ...          Mode = (stream_mode_t) -1;       // Just set it to an undefined mode ...
1986          SetMode(oldMode);          // ... so SetMode() has to reopen the file handles.          SetMode(stream_mode_read_write); // ... so SetMode() has to reopen the file handles.
1987    
1988            __notify_progress(pProgress, 1.0); // notify done
1989      }      }
1990    
1991      void File::ResizeFile(unsigned long ulNewSize) {      void File::ResizeFile(unsigned long ulNewSize) {
1992          #if POSIX          #if POSIX
1993          if (ftruncate(hFileWrite, ulNewSize) < 0)          if (ftruncate(hFileWrite, ulNewSize) < 0)
1994              throw Exception("Could not resize file \"" + Filename + "\"");              throw Exception("Could not resize file \"" + Filename + "\"");
1995            #elif defined(WIN32)
1996            if (
1997                SetFilePointer(hFileWrite, ulNewSize, NULL/*32 bit*/, FILE_BEGIN) == INVALID_SET_FILE_POINTER ||
1998                !SetEndOfFile(hFileWrite)
1999            ) throw Exception("Could not resize file \"" + Filename + "\"");
2000          #else          #else
2001          # error Sorry, this version of libgig only supports POSIX systems yet.          # error Sorry, this version of libgig only supports POSIX and Windows systems yet.
2002          # error Reason: portable implementation of RIFF::File::ResizeFile() is missing!          # error Reason: portable implementation of RIFF::File::ResizeFile() is missing (yet)!
2003          #endif          #endif
2004      }      }
2005    
# Line 1467  namespace RIFF { Line 2007  namespace RIFF {
2007         #if DEBUG         #if DEBUG
2008         std::cout << "File::~File()" << std::endl;         std::cout << "File::~File()" << std::endl;
2009         #endif // DEBUG         #endif // DEBUG
2010            Cleanup();
2011        }
2012        
2013        /**
2014         * Returns @c true if this file has been created new from scratch and
2015         * has not been stored to disk yet.
2016         */
2017        bool File::IsNew() const {
2018            return bIsNewFile;
2019        }
2020    
2021        void File::Cleanup() {
2022          #if POSIX          #if POSIX
2023          if (hFileRead) close(hFileRead);          if (hFileRead) close(hFileRead);
2024            #elif defined(WIN32)
2025            if (hFileRead != INVALID_HANDLE_VALUE) CloseHandle(hFileRead);
2026          #else          #else
2027          if (hFileRead) fclose(hFileRead);          if (hFileRead) fclose(hFileRead);
2028          #endif // POSIX          #endif // POSIX
2029            DeleteChunkList();
2030            pFile = NULL;
2031            //HACK: see _GET_RESIZED_CHUNKS() comment
2032            delete _GET_RESIZED_CHUNKS();
2033      }      }
2034    
2035      void File::LogAsResized(Chunk* pResizedChunk) {      void File::LogAsResized(Chunk* pResizedChunk) {
2036          ResizedChunks.push_back(pResizedChunk);          _GET_RESIZED_CHUNKS()->insert(pResizedChunk);
2037        }
2038    
2039        void File::UnlogResized(Chunk* pResizedChunk) {
2040            _GET_RESIZED_CHUNKS()->erase(pResizedChunk);
2041      }      }
2042    
2043      unsigned long File::GetFileSize() {      unsigned long File::GetFileSize() {
2044          #if POSIX          return __GetFileSize(hFileRead);
2045        }
2046    
2047        #if POSIX
2048        unsigned long File::__GetFileSize(int hFile) {
2049          struct stat filestat;          struct stat filestat;
2050          fstat(hFileRead, &filestat);          fstat(hFile, &filestat);
2051          long size = filestat.st_size;          long size = filestat.st_size;
         #else // standard C functions  
         long curpos = ftell(hFileRead);  
         fseek(hFileRead, 0, SEEK_END);  
         long size = ftell(hFileRead);  
         fseek(hFileRead, curpos, SEEK_SET);  
         #endif // POSIX  
2052          return size;          return size;
2053      }      }
2054        #elif defined(WIN32)
2055        unsigned long File::__GetFileSize(HANDLE hFile) {
2056            DWORD dwSize = ::GetFileSize(hFile, NULL /*32bit*/);
2057            if (dwSize == INVALID_FILE_SIZE)
2058                throw Exception("Windows FS error: could not determine file size");
2059            return dwSize;
2060        }
2061        #else // standard C functions
2062        unsigned long File::__GetFileSize(FILE* hFile) {
2063            long curpos = ftell(hFile);
2064            fseek(hFile, 0, SEEK_END);
2065            long size = ftell(hFile);
2066            fseek(hFile, curpos, SEEK_SET);
2067            return size;
2068        }
2069        #endif
2070    
2071    
2072  // *************** Exception ***************  // *************** Exception ***************
Legend:
Removed from v.780  
changed lines
  Added in v.2685
  ViewVC Help
Powered by ViewVC