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

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

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

revision 1155 by schoenebeck, Wed Apr 11 18:11:09 2007 UTC revision 1179 by persson, Sat May 12 11:25:04 2007 UTC
# Line 142  namespace DLS { Line 142  namespace DLS {
142          const int iEntrySize = 12; // 12 bytes per connection block          const int iEntrySize = 12; // 12 bytes per connection block
143          pArticulationCk->Resize(HeaderSize + Connections * iEntrySize);          pArticulationCk->Resize(HeaderSize + Connections * iEntrySize);
144          uint8_t* pData = (uint8_t*) pArticulationCk->LoadChunkData();          uint8_t* pData = (uint8_t*) pArticulationCk->LoadChunkData();
145          memcpy(&pData[0], &HeaderSize, 2);          store16(&pData[0], HeaderSize);
146          memcpy(&pData[2], &Connections, 2);          store16(&pData[2], Connections);
147          for (uint32_t i = 0; i < Connections; i++) {          for (uint32_t i = 0; i < Connections; i++) {
148              Connection::conn_block_t c = pConnections[i].ToConnBlock();              Connection::conn_block_t c = pConnections[i].ToConnBlock();
149              memcpy(&pData[HeaderSize + i * iEntrySize],     &c.source, 2);              store16(&pData[HeaderSize + i * iEntrySize],     c.source);
150              memcpy(&pData[HeaderSize + i * iEntrySize + 2], &c.control, 2);              store16(&pData[HeaderSize + i * iEntrySize + 2], c.control);
151              memcpy(&pData[HeaderSize + i * iEntrySize + 4], &c.destination, 2);              store16(&pData[HeaderSize + i * iEntrySize + 4], c.destination);
152              memcpy(&pData[HeaderSize + i * iEntrySize + 6], &c.transform, 2);              store16(&pData[HeaderSize + i * iEntrySize + 6], c.transform);
153              memcpy(&pData[HeaderSize + i * iEntrySize + 8], &c.scale, 4);              store32(&pData[HeaderSize + i * iEntrySize + 8], c.scale);
154          }          }
155      }      }
156    
# Line 463  namespace DLS { Line 463  namespace DLS {
463          }          }
464          uint8_t* pData = (uint8_t*) wsmp->LoadChunkData();          uint8_t* pData = (uint8_t*) wsmp->LoadChunkData();
465          // update headers size          // update headers size
466          memcpy(&pData[0], &uiHeaderSize, 4);          store32(&pData[0], uiHeaderSize);
467          // update respective sampler options bits          // update respective sampler options bits
468          SamplerOptions = (NoSampleDepthTruncation) ? SamplerOptions | F_WSMP_NO_TRUNCATION          SamplerOptions = (NoSampleDepthTruncation) ? SamplerOptions | F_WSMP_NO_TRUNCATION
469                                                     : SamplerOptions & (~F_WSMP_NO_TRUNCATION);                                                     : SamplerOptions & (~F_WSMP_NO_TRUNCATION);
470          SamplerOptions = (NoSampleCompression) ? SamplerOptions | F_WSMP_NO_COMPRESSION          SamplerOptions = (NoSampleCompression) ? SamplerOptions | F_WSMP_NO_COMPRESSION
471                                                 : SamplerOptions & (~F_WSMP_NO_COMPRESSION);                                                 : SamplerOptions & (~F_WSMP_NO_COMPRESSION);
472          memcpy(&pData[4], &UnityNote, 2);          store16(&pData[4], UnityNote);
473          memcpy(&pData[6], &FineTune, 2);          store16(&pData[6], FineTune);
474          memcpy(&pData[8], &Gain, 4);          store32(&pData[8], Gain);
475          memcpy(&pData[12], &SamplerOptions, 4);          store32(&pData[12], SamplerOptions);
476          memcpy(&pData[16], &SampleLoops, 4);          store32(&pData[16], SampleLoops);
477          // update loop definitions          // update loop definitions
478          for (uint32_t i = 0; i < SampleLoops; i++) {          for (uint32_t i = 0; i < SampleLoops; i++) {
479              //FIXME: this does not handle extended loop structs correctly              //FIXME: this does not handle extended loop structs correctly
480              memcpy(&pData[uiHeaderSize + i * 16], pSampleLoops + i, 4 * 4);              store32(&pData[uiHeaderSize + i * 16], pSampleLoops[i].Size);
481                store32(&pData[uiHeaderSize + i * 16 + 4], pSampleLoops[i].LoopType);
482                store32(&pData[uiHeaderSize + i * 16 + 8], pSampleLoops[i].LoopStart);
483                store32(&pData[uiHeaderSize + i * 16 + 12], pSampleLoops[i].LoopLength);
484          }          }
485      }      }
486    
# Line 759  namespace DLS { Line 762  namespace DLS {
762          if (!pCkFormat) pCkFormat = pWaveList->AddSubChunk(CHUNK_ID_FMT, 16); // assumes PCM format          if (!pCkFormat) pCkFormat = pWaveList->AddSubChunk(CHUNK_ID_FMT, 16); // assumes PCM format
763          uint8_t* pData = (uint8_t*) pCkFormat->LoadChunkData();          uint8_t* pData = (uint8_t*) pCkFormat->LoadChunkData();
764          // update 'fmt' chunk          // update 'fmt' chunk
765          memcpy(&pData[0], &FormatTag, 2);          store16(&pData[0], FormatTag);
766          memcpy(&pData[2], &Channels,  2);          store16(&pData[2], Channels);
767          memcpy(&pData[4], &SamplesPerSecond, 4);          store32(&pData[4], SamplesPerSecond);
768          memcpy(&pData[8], &AverageBytesPerSecond, 4);          store32(&pData[8], AverageBytesPerSecond);
769          memcpy(&pData[12], &BlockAlign, 2);          store16(&pData[12], BlockAlign);
770          memcpy(&pData[14], &BitDepth, 2); // assuming PCM format          store16(&pData[14], BitDepth); // assuming PCM format
771      }      }
772    
773    
# Line 862  namespace DLS { Line 865  namespace DLS {
865                                  ? FormatOptionFlags | F_RGN_OPTION_SELFNONEXCLUSIVE                                  ? FormatOptionFlags | F_RGN_OPTION_SELFNONEXCLUSIVE
866                                  : FormatOptionFlags & (~F_RGN_OPTION_SELFNONEXCLUSIVE);                                  : FormatOptionFlags & (~F_RGN_OPTION_SELFNONEXCLUSIVE);
867          // update 'rgnh' chunk          // update 'rgnh' chunk
868          memcpy(&pData[0], &KeyRange, 2 * 2);          store16(&pData[0], KeyRange.low);
869          memcpy(&pData[4], &VelocityRange, 2 * 2);          store16(&pData[2], KeyRange.high);
870          memcpy(&pData[8], &FormatOptionFlags, 2);          store16(&pData[4], VelocityRange.low);
871          memcpy(&pData[10], &KeyGroup, 2);          store16(&pData[6], VelocityRange.high);
872          if (rgnh->GetSize() >= 14) memcpy(&pData[12], &Layer, 2);          store16(&pData[8], FormatOptionFlags);
873            store16(&pData[10], KeyGroup);
874            if (rgnh->GetSize() >= 14) store16(&pData[12], Layer);
875    
876          // update chunks of base classes as well (but skip Resource,          // update chunks of base classes as well (but skip Resource,
877          // as a rgn doesn't seem to have dlid and INFO chunks)          // as a rgn doesn't seem to have dlid and INFO chunks)
# Line 899  namespace DLS { Line 904  namespace DLS {
904          if (index < 0) throw Exception("Could not save Region, could not find Region's sample");          if (index < 0) throw Exception("Could not save Region, could not find Region's sample");
905          WavePoolTableIndex = index;          WavePoolTableIndex = index;
906          // update 'wlnk' chunk          // update 'wlnk' chunk
907          memcpy(&pData[0], &WaveLinkOptionFlags, 2);          store16(&pData[0], WaveLinkOptionFlags);
908          memcpy(&pData[2], &PhaseGroup, 2);          store16(&pData[2], PhaseGroup);
909          memcpy(&pData[4], &Channel, 4);          store32(&pData[4], Channel);
910          memcpy(&pData[8], &WavePoolTableIndex, 4);          store32(&pData[8], WavePoolTableIndex);
911      }      }
912    
913    
# Line 1024  namespace DLS { Line 1029  namespace DLS {
1029          locale.bank       = MIDI_BANK_ENCODE(MIDIBankCoarse, MIDIBankFine);          locale.bank       = MIDI_BANK_ENCODE(MIDIBankCoarse, MIDIBankFine);
1030          locale.bank       = (IsDrum) ? locale.bank | DRUM_TYPE_MASK : locale.bank & (~DRUM_TYPE_MASK);          locale.bank       = (IsDrum) ? locale.bank | DRUM_TYPE_MASK : locale.bank & (~DRUM_TYPE_MASK);
1031          MIDIBank          = MIDI_BANK_MERGE(MIDIBankCoarse, MIDIBankFine); // just a sync, when we're at it          MIDIBank          = MIDI_BANK_MERGE(MIDIBankCoarse, MIDIBankFine); // just a sync, when we're at it
1032          memcpy(&pData[0], &Regions, 4);          store32(&pData[0], Regions);
1033          memcpy(&pData[4], &locale, 2 * 4);          store32(&pData[4], locale.bank);
1034            store32(&pData[8], locale.instrument);
1035          // update Region's chunks          // update Region's chunks
1036          if (!pRegions) return;          if (!pRegions) return;
1037          RegionList::iterator iter = pRegions->begin();          RegionList::iterator iter = pRegions->begin();
# Line 1321  namespace DLS { Line 1327  namespace DLS {
1327              RIFF::Chunk* ckVersion    = pRIFF->GetSubChunk(CHUNK_ID_VERS);              RIFF::Chunk* ckVersion    = pRIFF->GetSubChunk(CHUNK_ID_VERS);
1328              if (!ckVersion) ckVersion = pRIFF->AddSubChunk(CHUNK_ID_VERS, 8);              if (!ckVersion) ckVersion = pRIFF->AddSubChunk(CHUNK_ID_VERS, 8);
1329              uint8_t* pData = (uint8_t*) ckVersion->LoadChunkData();              uint8_t* pData = (uint8_t*) ckVersion->LoadChunkData();
1330              memcpy(pData, pVersion, 2 * 4);              store16(&pData[0], pVersion->minor);
1331                store16(&pData[2], pVersion->major);
1332                store16(&pData[4], pVersion->build);
1333                store16(&pData[6], pVersion->release);
1334          }          }
1335    
1336          // update 'colh' chunk          // update 'colh' chunk
# Line 1329  namespace DLS { Line 1338  namespace DLS {
1338          RIFF::Chunk* colh = pRIFF->GetSubChunk(CHUNK_ID_COLH);          RIFF::Chunk* colh = pRIFF->GetSubChunk(CHUNK_ID_COLH);
1339          if (!colh)   colh = pRIFF->AddSubChunk(CHUNK_ID_COLH, 4);          if (!colh)   colh = pRIFF->AddSubChunk(CHUNK_ID_COLH, 4);
1340          uint8_t* pData = (uint8_t*) colh->LoadChunkData();          uint8_t* pData = (uint8_t*) colh->LoadChunkData();
1341          memcpy(pData, &Instruments, 4);          store32(pData, Instruments);
1342    
1343          // update instrument's chunks          // update instrument's chunks
1344          if (pInstruments) {          if (pInstruments) {
# Line 1349  namespace DLS { Line 1358  namespace DLS {
1358          ptbl->Resize(iPtblSize);          ptbl->Resize(iPtblSize);
1359          pData = (uint8_t*) ptbl->LoadChunkData();          pData = (uint8_t*) ptbl->LoadChunkData();
1360          WavePoolCount = iSamples;          WavePoolCount = iSamples;
1361          memcpy(&pData[4], &WavePoolCount, 4);          store32(&pData[4], WavePoolCount);
1362          // we actually update the sample offsets in the pool table when we Save()          // we actually update the sample offsets in the pool table when we Save()
1363          memset(&pData[WavePoolHeaderSize], 0, iPtblSize - WavePoolHeaderSize);          memset(&pData[WavePoolHeaderSize], 0, iPtblSize - WavePoolHeaderSize);
1364    
# Line 1438  namespace DLS { Line 1447  namespace DLS {
1447          unsigned long ulOriginalPos = ptbl->GetPos();          unsigned long ulOriginalPos = ptbl->GetPos();
1448          // update headers          // update headers
1449          ptbl->SetPos(0);          ptbl->SetPos(0);
1450          ptbl->WriteUint32(&WavePoolHeaderSize);          uint32_t tmp = WavePoolHeaderSize;
1451          ptbl->WriteUint32(&WavePoolCount);          ptbl->WriteUint32(&tmp);
1452            tmp = WavePoolCount;
1453            ptbl->WriteUint32(&tmp);
1454          // update offsets          // update offsets
1455          ptbl->SetPos(WavePoolHeaderSize);          ptbl->SetPos(WavePoolHeaderSize);
1456          if (b64BitWavePoolOffsets) {          if (b64BitWavePoolOffsets) {
1457              for (int i = 0 ; i < WavePoolCount ; i++) {              for (int i = 0 ; i < WavePoolCount ; i++) {
1458                  ptbl->WriteUint32(&pWavePoolTableHi[i]);                  tmp = pWavePoolTableHi[i];
1459                  ptbl->WriteUint32(&pWavePoolTable[i]);                  ptbl->WriteUint32(&tmp);
1460                    tmp = pWavePoolTable[i];
1461                    ptbl->WriteUint32(&tmp);
1462              }              }
1463          } else { // conventional 32 bit offsets          } else { // conventional 32 bit offsets
1464              for (int i = 0 ; i < WavePoolCount ; i++)              for (int i = 0 ; i < WavePoolCount ; i++) {
1465                  ptbl->WriteUint32(&pWavePoolTable[i]);                  tmp = pWavePoolTable[i];
1466                    ptbl->WriteUint32(&tmp);
1467                }
1468          }          }
1469          // restore 'ptbl' chunk's original read/write position          // restore 'ptbl' chunk's original read/write position
1470          ptbl->SetPos(ulOriginalPos);          ptbl->SetPos(ulOriginalPos);

Legend:
Removed from v.1155  
changed lines
  Added in v.1179

  ViewVC Help
Powered by ViewVC