/[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 2912 by schoenebeck, Tue May 17 14:30:10 2016 UTC revision 2922 by schoenebeck, Wed May 18 18:04:49 2016 UTC
# Line 125  namespace RIFF { Line 125  namespace RIFF {
125              read(pFile->hFileRead, &ChunkID, 4);              read(pFile->hFileRead, &ChunkID, 4);
126              read(pFile->hFileRead, &ullCurrentChunkSize, pFile->FileOffsetSize);              read(pFile->hFileRead, &ullCurrentChunkSize, pFile->FileOffsetSize);
127          #elif defined(WIN32)          #elif defined(WIN32)
128          if (SetFilePointerEx(pFile->hFileRead, filePos, NULL/*new pos pointer*/, FILE_BEGIN)) {          LARGE_INTEGER liFilePos;
129            liFilePos.QuadPart = filePos;
130            if (SetFilePointerEx(pFile->hFileRead, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN)) {
131              DWORD dwBytesRead;              DWORD dwBytesRead;
132              ReadFile(pFile->hFileRead, &ChunkID, 4, &dwBytesRead, NULL);              ReadFile(pFile->hFileRead, &ChunkID, 4, &dwBytesRead, NULL);
133              ReadFile(pFile->hFileRead, &ullCurrentChunkSize, pFile->FileOffsetSize, &dwBytesRead, NULL);              ReadFile(pFile->hFileRead, &ullCurrentChunkSize, pFile->FileOffsetSize, &dwBytesRead, NULL);
# Line 184  namespace RIFF { Line 186  namespace RIFF {
186              write(pFile->hFileWrite, &ullNewChunkSize, pFile->FileOffsetSize);              write(pFile->hFileWrite, &ullNewChunkSize, pFile->FileOffsetSize);
187          }          }
188          #elif defined(WIN32)          #elif defined(WIN32)
189          if (SetFilePointerEx(pFile->hFileWrite, filePos, NULL/*new pos pointer*/, FILE_BEGIN)) {          LARGE_INTEGER liFilePos;
190            liFilePos.QuadPart = filePos;
191            if (SetFilePointerEx(pFile->hFileWrite, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN)) {
192              DWORD dwBytesWritten;              DWORD dwBytesWritten;
193              WriteFile(pFile->hFileWrite, &uiNewChunkID, 4, &dwBytesWritten, NULL);              WriteFile(pFile->hFileWrite, &uiNewChunkID, 4, &dwBytesWritten, NULL);
194              WriteFile(pFile->hFileWrite, &ullNewChunkSize, pFile->FileOffsetSize, &dwBytesWritten, NULL);              WriteFile(pFile->hFileWrite, &ullNewChunkSize, pFile->FileOffsetSize, &dwBytesWritten, NULL);
# Line 329  namespace RIFF { Line 333  namespace RIFF {
333          }          }
334          readWords /= WordSize;          readWords /= WordSize;
335          #elif defined(WIN32)          #elif defined(WIN32)
336          if (!SetFilePointerEx(pFile->hFileRead, ullStartPos + ullPos, NULL/*new pos pointer*/, FILE_BEGIN))          LARGE_INTEGER liFilePos;
337            liFilePos.QuadPart = ullStartPos + ullPos;
338            if (!SetFilePointerEx(pFile->hFileRead, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN))
339              return 0;              return 0;
340          DWORD readWords;          DWORD readWords;
341          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)          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)
# Line 413  namespace RIFF { Line 419  namespace RIFF {
419          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");
420          writtenWords /= WordSize;          writtenWords /= WordSize;
421          #elif defined(WIN32)          #elif defined(WIN32)
422          if (!SetFilePointerEx(pFile->hFileWrite, ullStartPos + ullPos, NULL/*new pos pointer*/, FILE_BEGIN)) {          LARGE_INTEGER liFilePos;
423            liFilePos.QuadPart = ullStartPos + ullPos;
424            if (!SetFilePointerEx(pFile->hFileWrite, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN)) {
425              throw Exception("Could not seek to position " + ToString(ullPos) +              throw Exception("Could not seek to position " + ToString(ullPos) +
426                              " in chunk (" + ToString(ullStartPos + ullPos) + " in file)");                              " in chunk (" + ToString(ullStartPos + ullPos) + " in file)");
427          }          }
# Line 803  namespace RIFF { Line 811  namespace RIFF {
811              #if POSIX              #if POSIX
812              if (lseek(pFile->hFileRead, ullStartPos, SEEK_SET) == -1) return NULL;              if (lseek(pFile->hFileRead, ullStartPos, SEEK_SET) == -1) return NULL;
813              #elif defined(WIN32)              #elif defined(WIN32)
814              if (!SetFilePointerEx(pFile->hFileRead, ullStartPos, NULL/*new pos pointer*/, FILE_BEGIN)) return NULL;              LARGE_INTEGER liFilePos;
815                liFilePos.QuadPart = ullStartPos;
816                if (!SetFilePointerEx(pFile->hFileRead, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN)) return NULL;
817              #else              #else
818              if (fseeko(pFile->hFileRead, ullStartPos, SEEK_SET)) return NULL;              if (fseeko(pFile->hFileRead, ullStartPos, SEEK_SET)) return NULL;
819              #endif // POSIX              #endif // POSIX
# Line 864  namespace RIFF { Line 874  namespace RIFF {
874       * boundary!       * boundary!
875       *       *
876       * @param NewSize - new chunk body size in bytes (must be greater than zero)       * @param NewSize - new chunk body size in bytes (must be greater than zero)
877       * @throws RIFF::Exception  if \a NewSize is less than 1 or Unrealistic large       * @throws RIFF::Exception  if \a NewSize is less than 1 or unrealistic large
878       * @see File::Save()       * @see File::Save()
879       */       */
880      void Chunk::Resize(file_offset_t NewSize) {      void Chunk::Resize(file_offset_t NewSize) {
# Line 907  namespace RIFF { Line 917  namespace RIFF {
917                  throw Exception("Writing Chunk data (from RAM) failed");                  throw Exception("Writing Chunk data (from RAM) failed");
918              }              }
919              #elif defined(WIN32)              #elif defined(WIN32)
920              SetFilePointerEx(pFile->hFileWrite, ullWritePos, NULL/*new pos pointer*/, FILE_BEGIN);              LARGE_INTEGER liFilePos;
921                liFilePos.QuadPart = ullWritePos;
922                SetFilePointerEx(pFile->hFileWrite, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN);
923              DWORD dwBytesWritten;              DWORD dwBytesWritten;
924              WriteFile(pFile->hFileWrite, pChunkData, ullNewChunkSize, &dwBytesWritten, NULL); //FIXME: won't save chunks larger than 2GB !              WriteFile(pFile->hFileWrite, pChunkData, ullNewChunkSize, &dwBytesWritten, NULL); //FIXME: won't save chunks larger than 2GB !
925              if (dwBytesWritten != ullNewChunkSize) {              if (dwBytesWritten != ullNewChunkSize) {
# Line 936  namespace RIFF { Line 948  namespace RIFF {
948                  lseek(pFile->hFileWrite, ullWritePos + ullOffset, SEEK_SET);                  lseek(pFile->hFileWrite, ullWritePos + ullOffset, SEEK_SET);
949                  iBytesMoved = write(pFile->hFileWrite, pCopyBuffer, iBytesMoved);                  iBytesMoved = write(pFile->hFileWrite, pCopyBuffer, iBytesMoved);
950                  #elif defined(WIN32)                  #elif defined(WIN32)
951                  SetFilePointerEx(pFile->hFileRead, ullStartPos + ullCurrentDataOffset + ullOffset, NULL/*new pos pointer*/, FILE_BEGIN);                  LARGE_INTEGER liFilePos;
952                    liFilePos.QuadPart = ullStartPos + ullCurrentDataOffset + ullOffset;
953                    SetFilePointerEx(pFile->hFileRead, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN);
954                  ReadFile(pFile->hFileRead, pCopyBuffer, iBytesMoved, &iBytesMoved, NULL);                  ReadFile(pFile->hFileRead, pCopyBuffer, iBytesMoved, &iBytesMoved, NULL);
955                  SetFilePointerEx(pFile->hFileWrite, ullWritePos + ullOffset, NULL/*new pos pointer*/, FILE_BEGIN);                  liFilePos.QuadPart = ullWritePos + ullOffset;
956                    SetFilePointerEx(pFile->hFileWrite, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN);
957                  WriteFile(pFile->hFileWrite, pCopyBuffer, iBytesMoved, &iBytesMoved, NULL);                  WriteFile(pFile->hFileWrite, pCopyBuffer, iBytesMoved, &iBytesMoved, NULL);
958                  #else                  #else
959                  fseeko(pFile->hFileRead, ullStartPos + ullCurrentDataOffset + ullOffset, SEEK_SET);                  fseeko(pFile->hFileRead, ullStartPos + ullCurrentDataOffset + ullOffset, SEEK_SET);
# Line 968  namespace RIFF { Line 983  namespace RIFF {
983              lseek(pFile->hFileWrite, ullStartPos + ullNewChunkSize, SEEK_SET);              lseek(pFile->hFileWrite, ullStartPos + ullNewChunkSize, SEEK_SET);
984              write(pFile->hFileWrite, &cPadByte, 1);              write(pFile->hFileWrite, &cPadByte, 1);
985              #elif defined(WIN32)              #elif defined(WIN32)
986              SetFilePointerEx(pFile->hFileWrite, ullStartPos + ullNewChunkSize, NULL/*new pos pointer*/, FILE_BEGIN);              LARGE_INTEGER liFilePos;
987                liFilePos.QuadPart = ullStartPos + ullNewChunkSize;
988                SetFilePointerEx(pFile->hFileWrite, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN);
989              DWORD dwBytesWritten;              DWORD dwBytesWritten;
990              WriteFile(pFile->hFileWrite, &cPadByte, 1, &dwBytesWritten, NULL);              WriteFile(pFile->hFileWrite, &cPadByte, 1, &dwBytesWritten, NULL);
991              #else              #else
# Line 1062  namespace RIFF { Line 1079  namespace RIFF {
1079      /**      /**
1080       *  Returns sublist chunk with list type <i>\a ListType</i> within this       *  Returns sublist chunk with list type <i>\a ListType</i> within this
1081       *  chunk list. Use this method if you expect only one sublist chunk of       *  chunk list. Use this method if you expect only one sublist chunk of
1082       *  that type in the list. It there are more than one, it's undetermined       *  that type in the list. If there are more than one, it's undetermined
1083       *  which one of them will be returned! If there are no sublists with       *  which one of them will be returned! If there are no sublists with
1084       *  that desired list type, NULL will be returned.       *  that desired list type, NULL will be returned.
1085       *       *
# Line 1088  namespace RIFF { Line 1105  namespace RIFF {
1105      }      }
1106    
1107      /**      /**
1108       *  Returns the first subchunk within the list. You have to call this       *  Returns the first subchunk within the list (which may be an ordinary
1109         *  chunk as well as a list chunk). You have to call this
1110       *  method before you can call GetNextSubChunk(). Recall it when you want       *  method before you can call GetNextSubChunk(). Recall it when you want
1111       *  to start from the beginning of the list again.       *  to start from the beginning of the list again.
1112       *       *
# Line 1105  namespace RIFF { Line 1123  namespace RIFF {
1123      }      }
1124    
1125      /**      /**
1126       *  Returns the next subchunk within the list. You have to call       *  Returns the next subchunk within the list (which may be an ordinary
1127         *  chunk as well as a list chunk). You have to call
1128       *  GetFirstSubChunk() before you can use this method!       *  GetFirstSubChunk() before you can use this method!
1129       *       *
1130       *  @returns  pointer to the next subchunk within the list or NULL if       *  @returns  pointer to the next subchunk within the list or NULL if
# Line 1167  namespace RIFF { Line 1186  namespace RIFF {
1186      }      }
1187    
1188      /**      /**
1189       *  Returns number of subchunks within the list.       *  Returns number of subchunks within the list (including list chunks).
1190       */       */
1191      unsigned int List::CountSubChunks() {      size_t List::CountSubChunks() {
1192          if (!pSubChunks) LoadSubChunks();          if (!pSubChunks) LoadSubChunks();
1193          return pSubChunks->size();          return pSubChunks->size();
1194      }      }
# Line 1178  namespace RIFF { Line 1197  namespace RIFF {
1197       *  Returns number of subchunks within the list with chunk ID       *  Returns number of subchunks within the list with chunk ID
1198       *  <i>\a ChunkId</i>.       *  <i>\a ChunkId</i>.
1199       */       */
1200      unsigned int List::CountSubChunks(uint32_t ChunkID) {      size_t List::CountSubChunks(uint32_t ChunkID) {
1201          unsigned int result = 0;          size_t result = 0;
1202          if (!pSubChunks) LoadSubChunks();          if (!pSubChunks) LoadSubChunks();
1203          ChunkList::iterator iter = pSubChunks->begin();          ChunkList::iterator iter = pSubChunks->begin();
1204          ChunkList::iterator end  = pSubChunks->end();          ChunkList::iterator end  = pSubChunks->end();
# Line 1195  namespace RIFF { Line 1214  namespace RIFF {
1214      /**      /**
1215       *  Returns number of sublists within the list.       *  Returns number of sublists within the list.
1216       */       */
1217      unsigned int List::CountSubLists() {      size_t List::CountSubLists() {
1218          return CountSubChunks(CHUNK_ID_LIST);          return CountSubChunks(CHUNK_ID_LIST);
1219      }      }
1220    
# Line 1203  namespace RIFF { Line 1222  namespace RIFF {
1222       *  Returns number of sublists within the list with list type       *  Returns number of sublists within the list with list type
1223       *  <i>\a ListType</i>       *  <i>\a ListType</i>
1224       */       */
1225      unsigned int List::CountSubLists(uint32_t ListType) {      size_t List::CountSubLists(uint32_t ListType) {
1226          unsigned int result = 0;          size_t result = 0;
1227          if (!pSubChunks) LoadSubChunks();          if (!pSubChunks) LoadSubChunks();
1228          ChunkList::iterator iter = pSubChunks->begin();          ChunkList::iterator iter = pSubChunks->begin();
1229          ChunkList::iterator end  = pSubChunks->end();          ChunkList::iterator end  = pSubChunks->end();
# Line 1366  namespace RIFF { Line 1385  namespace RIFF {
1385          lseek(pFile->hFileRead, filePos + CHUNK_HEADER_SIZE(pFile->FileOffsetSize), SEEK_SET);          lseek(pFile->hFileRead, filePos + CHUNK_HEADER_SIZE(pFile->FileOffsetSize), SEEK_SET);
1386          read(pFile->hFileRead, &ListType, 4);          read(pFile->hFileRead, &ListType, 4);
1387          #elif defined(WIN32)          #elif defined(WIN32)
1388          SetFilePointerEx(pFile->hFileRead, filePos + CHUNK_HEADER_SIZE(pFile->FileOffsetSize), NULL/*new pos pointer*/, FILE_BEGIN);          LARGE_INTEGER liFilePos;
1389            liFilePos.QuadPart = filePos + CHUNK_HEADER_SIZE(pFile->FileOffsetSize);
1390            SetFilePointerEx(pFile->hFileRead, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN);
1391          DWORD dwBytesRead;          DWORD dwBytesRead;
1392          ReadFile(pFile->hFileRead, &ListType, 4, &dwBytesRead, NULL);          ReadFile(pFile->hFileRead, &ListType, 4, &dwBytesRead, NULL);
1393          #else          #else
# Line 1390  namespace RIFF { Line 1411  namespace RIFF {
1411          lseek(pFile->hFileWrite, filePos + CHUNK_HEADER_SIZE(pFile->FileOffsetSize), SEEK_SET);          lseek(pFile->hFileWrite, filePos + CHUNK_HEADER_SIZE(pFile->FileOffsetSize), SEEK_SET);
1412          write(pFile->hFileWrite, &ListType, 4);          write(pFile->hFileWrite, &ListType, 4);
1413          #elif defined(WIN32)          #elif defined(WIN32)
1414          SetFilePointerEx(pFile->hFileWrite, filePos + CHUNK_HEADER_SIZE(pFile->FileOffsetSize), NULL/*new pos pointer*/, FILE_BEGIN);          LARGE_INTEGER liFilePos;
1415            liFilePos.QuadPart = filePos + CHUNK_HEADER_SIZE(pFile->FileOffsetSize);
1416            SetFilePointerEx(pFile->hFileWrite, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN);
1417          DWORD dwBytesWritten;          DWORD dwBytesWritten;
1418          WriteFile(pFile->hFileWrite, &ListType, 4, &dwBytesWritten, NULL);          WriteFile(pFile->hFileWrite, &ListType, 4, &dwBytesWritten, NULL);
1419          #else          #else
# Line 1474  namespace RIFF { Line 1497  namespace RIFF {
1497    
1498          // write all subchunks (including sub list chunks) recursively          // write all subchunks (including sub list chunks) recursively
1499          if (pSubChunks) {          if (pSubChunks) {
1500              int i = 0;              size_t i = 0;
1501              const int n = pSubChunks->size();              const size_t n = pSubChunks->size();
1502              for (ChunkList::iterator iter = pSubChunks->begin(), end = pSubChunks->end(); iter != end; ++iter, ++i) {              for (ChunkList::iterator iter = pSubChunks->begin(), end = pSubChunks->end(); iter != end; ++iter, ++i) {
1503                  // divide local progress into subprogress for loading current Instrument                  // divide local progress into subprogress for loading current Instrument
1504                  progress_t subprogress;                  progress_t subprogress;
# Line 1887  namespace RIFF { Line 1910  namespace RIFF {
1910              #if defined(WIN32)              #if defined(WIN32)
1911              DWORD iBytesMoved = 1; // we have to pass it via pointer to the Windows API, thus the correct size must be ensured              DWORD iBytesMoved = 1; // we have to pass it via pointer to the Windows API, thus the correct size must be ensured
1912              #else              #else
1913              int iBytesMoved = 1;              ssize_t iBytesMoved = 1;
1914              #endif              #endif
1915              for (file_offset_t ullPos = workingFileSize, iNotif = 0; iBytesMoved > 0; ++iNotif) {              for (file_offset_t ullPos = workingFileSize, iNotif = 0; iBytesMoved > 0; ++iNotif) {
1916                  iBytesMoved = (ullPos < 4096) ? ullPos : 4096;                  iBytesMoved = (ullPos < 4096) ? ullPos : 4096;
# Line 1898  namespace RIFF { Line 1921  namespace RIFF {
1921                  lseek(hFileWrite, ullPos + positiveSizeDiff, SEEK_SET);                  lseek(hFileWrite, ullPos + positiveSizeDiff, SEEK_SET);
1922                  iBytesMoved = write(hFileWrite, pCopyBuffer, iBytesMoved);                  iBytesMoved = write(hFileWrite, pCopyBuffer, iBytesMoved);
1923                  #elif defined(WIN32)                  #elif defined(WIN32)
1924                  SetFilePointerEx(hFileRead, ullPos, NULL/*new pos pointer*/, FILE_BEGIN);                  LARGE_INTEGER liFilePos;
1925                    liFilePos.QuadPart = ullPos;
1926                    SetFilePointerEx(hFileRead, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN);
1927                  ReadFile(hFileRead, pCopyBuffer, iBytesMoved, &iBytesMoved, NULL);                  ReadFile(hFileRead, pCopyBuffer, iBytesMoved, &iBytesMoved, NULL);
1928                  SetFilePointerEx(hFileWrite, ullPos + positiveSizeDiff, NULL/*new pos pointer*/, FILE_BEGIN);                  liFilePos.QuadPart = ullPos + positiveSizeDiff;
1929                    SetFilePointerEx(hFileWrite, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN);
1930                  WriteFile(hFileWrite, pCopyBuffer, iBytesMoved, &iBytesMoved, NULL);                  WriteFile(hFileWrite, pCopyBuffer, iBytesMoved, &iBytesMoved, NULL);
1931                  #else                  #else
1932                  fseeko(hFileRead, ullPos, SEEK_SET);                  fseeko(hFileRead, ullPos, SEEK_SET);
# Line 2040  namespace RIFF { Line 2066  namespace RIFF {
2066          if (ftruncate(hFileWrite, ullNewSize) < 0)          if (ftruncate(hFileWrite, ullNewSize) < 0)
2067              throw Exception("Could not resize file \"" + Filename + "\"");              throw Exception("Could not resize file \"" + Filename + "\"");
2068          #elif defined(WIN32)          #elif defined(WIN32)
2069            LARGE_INTEGER liFilePos;
2070            liFilePos.QuadPart = ullNewSize;
2071          if (          if (
2072              !SetFilePointerEx(hFileWrite, ullNewSize, NULL/*new pos pointer*/, FILE_BEGIN) ||              !SetFilePointerEx(hFileWrite, liFilePos, NULL/*new pos pointer*/, FILE_BEGIN) ||
2073              !SetEndOfFile(hFileWrite)              !SetEndOfFile(hFileWrite)
2074          ) throw Exception("Could not resize file \"" + Filename + "\"");          ) throw Exception("Could not resize file \"" + Filename + "\"");
2075          #else          #else
# Line 2203  namespace RIFF { Line 2231  namespace RIFF {
2231      }      }
2232      #elif defined(WIN32)      #elif defined(WIN32)
2233      file_offset_t File::__GetFileSize(HANDLE hFile) const {      file_offset_t File::__GetFileSize(HANDLE hFile) const {
2234          PLARGE_INTEGER size;          LARGE_INTEGER size;
2235          if (!GetFileSizeEx(hFile, &size))          if (!GetFileSizeEx(hFile, &size))
2236              throw Exception("Windows FS error: could not determine file size");              throw Exception("Windows FS error: could not determine file size");
2237          return size;          return size.QuadPart;
2238      }      }
2239      #else // standard C functions      #else // standard C functions
2240      file_offset_t File::__GetFileSize(FILE* hFile) const {      file_offset_t File::__GetFileSize(FILE* hFile) const {
Legend:
Removed from v.2912  
changed lines
  Added in v.2922
  ViewVC Help
Powered by ViewVC