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

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

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

revision 1180 by persson, Sat May 12 12:39:25 2007 UTC revision 1247 by persson, Fri Jun 22 09:59:57 2007 UTC
# Line 278  namespace { Line 278  namespace {
278    
279    
280    
281    // *************** CRC ***************
282    // *
283    
284        const uint32_t* CRC::table(initTable());
285    
286        uint32_t* CRC::initTable() {
287            uint32_t* res = new uint32_t[256];
288    
289            for (int i = 0 ; i < 256 ; i++) {
290                uint32_t c = i;
291                for (int j = 0 ; j < 8 ; j++) {
292                    c = (c & 1) ? 0xedb88320 ^ (c >> 1) : c >> 1;
293                }
294                res[i] = c;
295            }
296            return res;
297        }
298    
299    
300    
301  // *************** Sample ***************  // *************** Sample ***************
302  // *  // *
303    
# Line 342  namespace { Line 362  namespace {
362              Manufacturer  = 0;              Manufacturer  = 0;
363              Product       = 0;              Product       = 0;
364              SamplePeriod  = uint32_t(1000000000.0 / SamplesPerSecond + 0.5);              SamplePeriod  = uint32_t(1000000000.0 / SamplesPerSecond + 0.5);
365              MIDIUnityNote = 64;              MIDIUnityNote = 60;
366              FineTune      = 0;              FineTune      = 0;
367                SMPTEFormat   = smpte_format_no_offset;
368              SMPTEOffset   = 0;              SMPTEOffset   = 0;
369              Loops         = 0;              Loops         = 0;
370              LoopID        = 0;              LoopID        = 0;
371                LoopType      = loop_type_normal;
372              LoopStart     = 0;              LoopStart     = 0;
373              LoopEnd       = 0;              LoopEnd       = 0;
374              LoopFraction  = 0;              LoopFraction  = 0;
# Line 402  namespace { Line 424  namespace {
424    
425          // make sure 'smpl' chunk exists          // make sure 'smpl' chunk exists
426          pCkSmpl = pWaveList->GetSubChunk(CHUNK_ID_SMPL);          pCkSmpl = pWaveList->GetSubChunk(CHUNK_ID_SMPL);
427          if (!pCkSmpl) pCkSmpl = pWaveList->AddSubChunk(CHUNK_ID_SMPL, 60);          if (!pCkSmpl) {
428                pCkSmpl = pWaveList->AddSubChunk(CHUNK_ID_SMPL, 60);
429                memset(pCkSmpl->LoadChunkData(), 0, 60);
430            }
431          // update 'smpl' chunk          // update 'smpl' chunk
432          uint8_t* pData = (uint8_t*) pCkSmpl->LoadChunkData();          uint8_t* pData = (uint8_t*) pCkSmpl->LoadChunkData();
433          SamplePeriod = uint32_t(1000000000.0 / SamplesPerSecond + 0.5);          SamplePeriod = uint32_t(1000000000.0 / SamplesPerSecond + 0.5);
# Line 1135  namespace { Line 1160  namespace {
1160       */       */
1161      unsigned long Sample::Write(void* pBuffer, unsigned long SampleCount) {      unsigned long Sample::Write(void* pBuffer, unsigned long SampleCount) {
1162          if (Compressed) throw gig::Exception("There is no support for writing compressed gig samples (yet)");          if (Compressed) throw gig::Exception("There is no support for writing compressed gig samples (yet)");
1163          return DLS::Sample::Write(pBuffer, SampleCount);  
1164            // if this is the first write in this sample, reset the
1165            // checksum calculator
1166            if (pCkData->GetPos() == 0) {
1167                crc.reset();
1168            }
1169            unsigned long res = DLS::Sample::Write(pBuffer, SampleCount);
1170            crc.update((unsigned char *)pBuffer, SampleCount * FrameSize);
1171    
1172            // if this is the last write, update the checksum chunk in the
1173            // file
1174            if (pCkData->GetPos() == pCkData->GetSize()) {
1175                File* pFile = static_cast<File*>(GetParent());
1176                pFile->SetSampleChecksum(this, crc.getValue());
1177            }
1178            return res;
1179      }      }
1180    
1181      /**      /**
# Line 1216  namespace { Line 1256  namespace {
1256    
1257          pSample = NULL;          pSample = NULL;
1258    
1259          memcpy(&Crossfade, &SamplerOptions, 4);          if (_3ewl->GetSubChunk(CHUNK_ID_WSMP)) memcpy(&Crossfade, &SamplerOptions, 4);
1260            else memset(&Crossfade, 0, 4);
1261    
1262          if (!pVelocityTables) pVelocityTables = new VelocityTableMap;          if (!pVelocityTables) pVelocityTables = new VelocityTableMap;
1263    
1264          RIFF::Chunk* _3ewa = _3ewl->GetSubChunk(CHUNK_ID_3EWA);          RIFF::Chunk* _3ewa = _3ewl->GetSubChunk(CHUNK_ID_3EWA);
# Line 1380  namespace { Line 1422  namespace {
1422              LFO1ControlDepth                = 0;              LFO1ControlDepth                = 0;
1423              LFO3ControlDepth                = 0;              LFO3ControlDepth                = 0;
1424              EG1Attack                       = 0.0;              EG1Attack                       = 0.0;
1425              EG1Decay1                       = 0.0;              EG1Decay1                       = 0.005;
1426              EG1Sustain                      = 0;              EG1Sustain                      = 1000;
1427              EG1Release                      = 0.0;              EG1Release                      = 0.3;
1428              EG1Controller.type              = eg1_ctrl_t::type_none;              EG1Controller.type              = eg1_ctrl_t::type_none;
1429              EG1Controller.controller_number = 0;              EG1Controller.controller_number = 0;
1430              EG1ControllerInvert             = false;              EG1ControllerInvert             = false;
# Line 1397  namespace { Line 1439  namespace {
1439              EG2ControllerReleaseInfluence   = 0;              EG2ControllerReleaseInfluence   = 0;
1440              LFO1Frequency                   = 1.0;              LFO1Frequency                   = 1.0;
1441              EG2Attack                       = 0.0;              EG2Attack                       = 0.0;
1442              EG2Decay1                       = 0.0;              EG2Decay1                       = 0.005;
1443              EG2Sustain                      = 0;              EG2Sustain                      = 1000;
1444              EG2Release                      = 0.0;              EG2Release                      = 0.3;
1445              LFO2ControlDepth                = 0;              LFO2ControlDepth                = 0;
1446              LFO2Frequency                   = 1.0;              LFO2Frequency                   = 1.0;
1447              LFO2InternalDepth               = 0;              LFO2InternalDepth               = 0;
1448              EG1Decay2                       = 0.0;              EG1Decay2                       = 0.0;
1449              EG1InfiniteSustain              = false;              EG1InfiniteSustain              = true;
1450              EG1PreAttack                    = 1000;              EG1PreAttack                    = 0;
1451              EG2Decay2                       = 0.0;              EG2Decay2                       = 0.0;
1452              EG2InfiniteSustain              = false;              EG2InfiniteSustain              = true;
1453              EG2PreAttack                    = 1000;              EG2PreAttack                    = 0;
1454              VelocityResponseCurve           = curve_type_nonlinear;              VelocityResponseCurve           = curve_type_nonlinear;
1455              VelocityResponseDepth           = 3;              VelocityResponseDepth           = 3;
1456              ReleaseVelocityResponseCurve    = curve_type_nonlinear;              ReleaseVelocityResponseCurve    = curve_type_nonlinear;
# Line 1451  namespace { Line 1493  namespace {
1493              VCFVelocityDynamicRange         = 0x04;              VCFVelocityDynamicRange         = 0x04;
1494              VCFVelocityCurve                = curve_type_linear;              VCFVelocityCurve                = curve_type_linear;
1495              VCFType                         = vcf_type_lowpass;              VCFType                         = vcf_type_lowpass;
1496              memset(DimensionUpperLimits, 0, 8);              memset(DimensionUpperLimits, 127, 8);
1497          }          }
1498    
1499          pVelocityAttenuationTable = GetVelocityTable(VelocityResponseCurve,          pVelocityAttenuationTable = GetVelocityTable(VelocityResponseCurve,
# Line 1500  namespace { Line 1542  namespace {
1542          // first update base class's chunk          // first update base class's chunk
1543          DLS::Sampler::UpdateChunks();          DLS::Sampler::UpdateChunks();
1544    
1545            RIFF::Chunk* wsmp = pParentList->GetSubChunk(CHUNK_ID_WSMP);
1546            uint8_t* pData = (uint8_t*) wsmp->LoadChunkData();
1547            pData[12] = Crossfade.in_start;
1548            pData[13] = Crossfade.in_end;
1549            pData[14] = Crossfade.out_start;
1550            pData[15] = Crossfade.out_end;
1551    
1552          // make sure '3ewa' chunk exists          // make sure '3ewa' chunk exists
1553          RIFF::Chunk* _3ewa = pParentList->GetSubChunk(CHUNK_ID_3EWA);          RIFF::Chunk* _3ewa = pParentList->GetSubChunk(CHUNK_ID_3EWA);
1554          if (!_3ewa)  _3ewa = pParentList->AddSubChunk(CHUNK_ID_3EWA, 140);          if (!_3ewa)  _3ewa = pParentList->AddSubChunk(CHUNK_ID_3EWA, 140);
1555          uint8_t* pData = (uint8_t*) _3ewa->LoadChunkData();          pData = (uint8_t*) _3ewa->LoadChunkData();
1556    
1557          // update '3ewa' chunk with DimensionRegion's current settings          // update '3ewa' chunk with DimensionRegion's current settings
1558    
1559          const uint32_t chunksize = _3ewa->GetSize();          const uint32_t chunksize = _3ewa->GetNewSize();
1560          store32(&pData[0], chunksize); // unknown, always chunk size?          store32(&pData[0], chunksize); // unknown, always chunk size?
1561    
1562          const int32_t lfo3freq = (int32_t) GIG_EXP_ENCODE(LFO3Frequency);          const int32_t lfo3freq = (int32_t) GIG_EXP_ENCODE(LFO3Frequency);
# Line 1991  namespace { Line 2040  namespace {
2040                      default:                      default:
2041                          throw gig::Exception("leverage controller number is not supported by the gig format");                          throw gig::Exception("leverage controller number is not supported by the gig format");
2042                  }                  }
2043                    break;
2044              default:              default:
2045                  throw gig::Exception("Unknown leverage controller type.");                  throw gig::Exception("Unknown leverage controller type.");
2046          }          }
# Line 2127  namespace { Line 2177  namespace {
2177              for (int i = 0; i < dimensionBits; i++) {              for (int i = 0; i < dimensionBits; i++) {
2178                  dimension_t dimension = static_cast<dimension_t>(_3lnk->ReadUint8());                  dimension_t dimension = static_cast<dimension_t>(_3lnk->ReadUint8());
2179                  uint8_t     bits      = _3lnk->ReadUint8();                  uint8_t     bits      = _3lnk->ReadUint8();
2180                  _3lnk->ReadUint8(); // probably the position of the dimension                  _3lnk->ReadUint8(); // bit position of the dimension (bits[0] + bits[1] + ... + bits[i-1])
2181                  _3lnk->ReadUint8(); // unknown                  _3lnk->ReadUint8(); // (1 << bit position of next dimension) - (1 << bit position of this dimension)
2182                  uint8_t     zones     = _3lnk->ReadUint8(); // new for v3: number of zones doesn't have to be == pow(2,bits)                  uint8_t     zones     = _3lnk->ReadUint8(); // new for v3: number of zones doesn't have to be == pow(2,bits)
2183                  if (dimension == dimension_none) { // inactive dimension                  if (dimension == dimension_none) { // inactive dimension
2184                      pDimensionDefinitions[i].dimension  = dimension_none;                      pDimensionDefinitions[i].dimension  = dimension_none;
# Line 2170  namespace { Line 2220  namespace {
2220              GetSample(); // load global region sample reference              GetSample(); // load global region sample reference
2221          } else {          } else {
2222              DimensionRegions = 0;              DimensionRegions = 0;
2223                for (int i = 0 ; i < 8 ; i++) {
2224                    pDimensionDefinitions[i].dimension  = dimension_none;
2225                    pDimensionDefinitions[i].bits       = 0;
2226                    pDimensionDefinitions[i].zones      = 0;
2227                }
2228          }          }
2229    
2230          // make sure there is at least one dimension region          // make sure there is at least one dimension region
# Line 2201  namespace { Line 2256  namespace {
2256          // first update base class's chunks          // first update base class's chunks
2257          DLS::Region::UpdateChunks();          DLS::Region::UpdateChunks();
2258    
2259            File* pFile = (File*) GetParent()->GetParent();
2260            bool version3 = pFile->pVersion && pFile->pVersion->major == 3;
2261    
2262          // update dimension region's chunks          // update dimension region's chunks
2263          for (int i = 0; i < DimensionRegions; i++) {          for (int i = 0; i < DimensionRegions; i++) {
2264              pDimensionRegions[i]->UpdateChunks();              DimensionRegion* d = pDimensionRegions[i];
2265    
2266                // make sure '3ewa' chunk exists (we need to this before
2267                // calling DimensionRegion::UpdateChunks, as
2268                // DimensionRegion doesn't know which file version it is)
2269                RIFF::Chunk* _3ewa = d->pParentList->GetSubChunk(CHUNK_ID_3EWA);
2270                if (!_3ewa) d->pParentList->AddSubChunk(CHUNK_ID_3EWA, version3 ? 148 : 140);
2271    
2272                d->UpdateChunks();
2273          }          }
2274    
2275          File* pFile = (File*) GetParent()->GetParent();          const int iMaxDimensions =  version3 ? 8 : 5;
2276          const int iMaxDimensions = (pFile->pVersion && pFile->pVersion->major == 3) ? 8 : 5;          const int iMaxDimensionRegions = version3 ? 256 : 32;
         const int iMaxDimensionRegions = (pFile->pVersion && pFile->pVersion->major == 3) ? 256 : 32;  
2277    
2278          // make sure '3lnk' chunk exists          // make sure '3lnk' chunk exists
2279          RIFF::Chunk* _3lnk = pCkRegion->GetSubChunk(CHUNK_ID_3LNK);          RIFF::Chunk* _3lnk = pCkRegion->GetSubChunk(CHUNK_ID_3LNK);
2280          if (!_3lnk) {          if (!_3lnk) {
2281              const int _3lnkChunkSize = (pFile->pVersion && pFile->pVersion->major == 3) ? 1092 : 172;              const int _3lnkChunkSize = version3 ? 1092 : 172;
2282              _3lnk = pCkRegion->AddSubChunk(CHUNK_ID_3LNK, _3lnkChunkSize);              _3lnk = pCkRegion->AddSubChunk(CHUNK_ID_3LNK, _3lnkChunkSize);
2283                memset(_3lnk->LoadChunkData(), 0, _3lnkChunkSize);
2284    
2285                // move 3prg to last position
2286                pCkRegion->MoveSubChunk(pCkRegion->GetSubList(LIST_TYPE_3PRG), 0);
2287          }          }
2288    
2289          // update dimension definitions in '3lnk' chunk          // update dimension definitions in '3lnk' chunk
2290          uint8_t* pData = (uint8_t*) _3lnk->LoadChunkData();          uint8_t* pData = (uint8_t*) _3lnk->LoadChunkData();
2291          store32(&pData[0], DimensionRegions);          store32(&pData[0], DimensionRegions);
2292            int shift = 0;
2293          for (int i = 0; i < iMaxDimensions; i++) {          for (int i = 0; i < iMaxDimensions; i++) {
2294              pData[4 + i * 8] = (uint8_t) pDimensionDefinitions[i].dimension;              pData[4 + i * 8] = (uint8_t) pDimensionDefinitions[i].dimension;
2295              pData[5 + i * 8] = pDimensionDefinitions[i].bits;              pData[5 + i * 8] = pDimensionDefinitions[i].bits;
2296              // next 2 bytes unknown              pData[6 + i * 8] = shift;
2297                pData[7 + i * 8] = (1 << (shift + pDimensionDefinitions[i].bits)) - (1 << shift);
2298              pData[8 + i * 8] = pDimensionDefinitions[i].zones;              pData[8 + i * 8] = pDimensionDefinitions[i].zones;
2299              // next 3 bytes unknown              // next 3 bytes unknown, always zero?
2300    
2301                shift += pDimensionDefinitions[i].bits;
2302          }          }
2303    
2304          // update wave pool table in '3lnk' chunk          // update wave pool table in '3lnk' chunk
2305          const int iWavePoolOffset = (pFile->pVersion && pFile->pVersion->major == 3) ? 68 : 44;          const int iWavePoolOffset = version3 ? 68 : 44;
2306          for (uint i = 0; i < iMaxDimensionRegions; i++) {          for (uint i = 0; i < iMaxDimensionRegions; i++) {
2307              int iWaveIndex = -1;              int iWaveIndex = -1;
2308              if (i < DimensionRegions) {              if (i < DimensionRegions) {
# Line 2381  namespace { Line 2454  namespace {
2454          // create new dimension region(s) for this new dimension          // create new dimension region(s) for this new dimension
2455          for (int i = 1 << iCurrentBits; i < 1 << iNewBits; i++) {          for (int i = 1 << iCurrentBits; i < 1 << iNewBits; i++) {
2456              //TODO: maybe we should copy existing dimension regions if possible instead of simply creating new ones with default values              //TODO: maybe we should copy existing dimension regions if possible instead of simply creating new ones with default values
2457              RIFF::List* pNewDimRgnListChunk = pCkRegion->AddSubList(LIST_TYPE_3EWL);              RIFF::List* _3prg = pCkRegion->GetSubList(LIST_TYPE_3PRG);
2458                RIFF::List* pNewDimRgnListChunk = _3prg->AddSubList(LIST_TYPE_3EWL);
2459              pDimensionRegions[i] = new DimensionRegion(pNewDimRgnListChunk);              pDimensionRegions[i] = new DimensionRegion(pNewDimRgnListChunk);
2460    
2461                // copy the upper limits for the other dimensions
2462                memcpy(pDimensionRegions[i]->DimensionUpperLimits,
2463                       pDimensionRegions[i & ((1 << iCurrentBits) - 1)]->DimensionUpperLimits, 8);
2464    
2465              DimensionRegions++;              DimensionRegions++;
2466          }          }
2467    
2468            // initialize the upper limits for this dimension
2469            for (int z = 0, j = 0 ; z < pDimDef->zones ; z++, j += 1 << iCurrentBits) {
2470                uint8_t upperLimit = (z + 1) * 128.0 / pDimDef->zones - 1;
2471                for (int i = 0 ; i < 1 << iCurrentBits ; i++) {
2472                    pDimensionRegions[j + i]->DimensionUpperLimits[Dimensions] = upperLimit;
2473                }
2474            }
2475    
2476          Dimensions++;          Dimensions++;
2477    
2478          // if this is a layer dimension, update 'Layers' attribute          // if this is a layer dimension, update 'Layers' attribute
# Line 2426  namespace { Line 2513  namespace {
2513          for (int i = iDimensionNr + 1; i < Dimensions; i++)          for (int i = iDimensionNr + 1; i < Dimensions; i++)
2514              iUpperBits += pDimensionDefinitions[i].bits;              iUpperBits += pDimensionDefinitions[i].bits;
2515    
2516            RIFF::List* _3prg = pCkRegion->GetSubList(LIST_TYPE_3PRG);
2517    
2518          // delete dimension regions which belong to the given dimension          // delete dimension regions which belong to the given dimension
2519          // (that is where the dimension's bit > 0)          // (that is where the dimension's bit > 0)
2520          for (int iUpperBit = 0; iUpperBit < 1 << iUpperBits; iUpperBit++) {          for (int iUpperBit = 0; iUpperBit < 1 << iUpperBits; iUpperBit++) {
# Line 2434  namespace { Line 2523  namespace {
2523                      int iToDelete = iUpperBit    << (pDimensionDefinitions[iDimensionNr].bits + iLowerBits) |                      int iToDelete = iUpperBit    << (pDimensionDefinitions[iDimensionNr].bits + iLowerBits) |
2524                                      iObsoleteBit << iLowerBits |                                      iObsoleteBit << iLowerBits |
2525                                      iLowerBit;                                      iLowerBit;
2526    
2527                        _3prg->DeleteSubChunk(pDimensionRegions[iToDelete]->pParentList);
2528                      delete pDimensionRegions[iToDelete];                      delete pDimensionRegions[iToDelete];
2529                      pDimensionRegions[iToDelete] = NULL;                      pDimensionRegions[iToDelete] = NULL;
2530                      DimensionRegions--;                      DimensionRegions--;
# Line 2454  namespace { Line 2545  namespace {
2545              }              }
2546          }          }
2547    
2548            // remove the this dimension from the upper limits arrays
2549            for (int j = 0 ; j < 256 && pDimensionRegions[j] ; j++) {
2550                DimensionRegion* d = pDimensionRegions[j];
2551                for (int i = iDimensionNr + 1; i < Dimensions; i++) {
2552                    d->DimensionUpperLimits[i - 1] = d->DimensionUpperLimits[i];
2553                }
2554                d->DimensionUpperLimits[Dimensions - 1] = 127;
2555            }
2556    
2557          // 'remove' dimension definition          // 'remove' dimension definition
2558          for (int i = iDimensionNr + 1; i < Dimensions; i++) {          for (int i = iDimensionNr + 1; i < Dimensions; i++) {
2559              pDimensionDefinitions[i - 1] = pDimensionDefinitions[i];              pDimensionDefinitions[i - 1] = pDimensionDefinitions[i];
# Line 2603  namespace { Line 2703  namespace {
2703    
2704          // Initialization          // Initialization
2705          for (int i = 0; i < 128; i++) RegionKeyTable[i] = NULL;          for (int i = 0; i < 128; i++) RegionKeyTable[i] = NULL;
2706            EffectSend = 0;
2707            Attenuation = 0;
2708            FineTune = 0;
2709            PitchbendRange = 0;
2710            PianoReleaseMode = false;
2711            DimensionKeyRange.low = 0;
2712            DimensionKeyRange.high = 0;
2713    
2714          // Loading          // Loading
2715          RIFF::List* lart = insList->GetSubList(LIST_TYPE_LART);          RIFF::List* lart = insList->GetSubList(LIST_TYPE_LART);
# Line 2790  namespace { Line 2897  namespace {
2897      void Group::UpdateChunks() {      void Group::UpdateChunks() {
2898          // make sure <3gri> and <3gnl> list chunks exist          // make sure <3gri> and <3gnl> list chunks exist
2899          RIFF::List* _3gri = pFile->pRIFF->GetSubList(LIST_TYPE_3GRI);          RIFF::List* _3gri = pFile->pRIFF->GetSubList(LIST_TYPE_3GRI);
2900          if (!_3gri) _3gri = pFile->pRIFF->AddSubList(LIST_TYPE_3GRI);          if (!_3gri) {
2901                _3gri = pFile->pRIFF->AddSubList(LIST_TYPE_3GRI);
2902                pFile->pRIFF->MoveSubChunk(_3gri, pFile->pRIFF->GetSubChunk(CHUNK_ID_PTBL));
2903            }
2904          RIFF::List* _3gnl = _3gri->GetSubList(LIST_TYPE_3GNL);          RIFF::List* _3gnl = _3gri->GetSubList(LIST_TYPE_3GNL);
2905          if (!_3gnl) _3gnl = pFile->pRIFF->AddSubList(LIST_TYPE_3GNL);          if (!_3gnl) _3gnl = _3gri->AddSubList(LIST_TYPE_3GNL);
2906          // now store the name of this group as <3gnm> chunk as subchunk of the <3gnl> list chunk          // now store the name of this group as <3gnm> chunk as subchunk of the <3gnl> list chunk
2907          ::SaveString(CHUNK_ID_3GNM, pNameChunk, _3gnl, Name, String("Unnamed Group"), true, 64);          ::SaveString(CHUNK_ID_3GNM, pNameChunk, _3gnl, Name, String("Unnamed Group"), true, 64);
2908      }      }
# Line 2868  namespace { Line 2978  namespace {
2978  // *************** File ***************  // *************** File ***************
2979  // *  // *
2980    
2981        // File version 2.0, 1998-06-28
2982        const DLS::version_t File::VERSION_2 = {
2983            0, 2, 19980628 & 0xffff, 19980628 >> 16
2984        };
2985    
2986        // File version 3.0, 2003-03-31
2987        const DLS::version_t File::VERSION_3 = {
2988            0, 3, 20030331 & 0xffff, 20030331 >> 16
2989        };
2990    
2991      const DLS::Info::FixedStringLength File::FixedStringLengths[] = {      const DLS::Info::FixedStringLength File::FixedStringLengths[] = {
2992          { CHUNK_ID_IARL, 256 },          { CHUNK_ID_IARL, 256 },
2993          { CHUNK_ID_IART, 128 },          { CHUNK_ID_IART, 128 },
# Line 2892  namespace { Line 3012  namespace {
3012      File::File() : DLS::File() {      File::File() : DLS::File() {
3013          pGroups = NULL;          pGroups = NULL;
3014          pInfo->FixedStringLengths = FixedStringLengths;          pInfo->FixedStringLengths = FixedStringLengths;
3015            pInfo->ArchivalLocation = String(256, ' ');
3016    
3017            // add some mandatory chunks to get the file chunks in right
3018            // order (INFO chunk will be moved to first position later)
3019            pRIFF->AddSubChunk(CHUNK_ID_VERS, 8);
3020            pRIFF->AddSubChunk(CHUNK_ID_COLH, 4);
3021            pRIFF->AddSubChunk(CHUNK_ID_DLID, 16);
3022    
3023            GenerateDLSID();
3024      }      }
3025    
3026      File::File(RIFF::File* pRIFF) : DLS::File(pRIFF) {      File::File(RIFF::File* pRIFF) : DLS::File(pRIFF) {
# Line 2938  namespace { Line 3067  namespace {
3067         // create new Sample object and its respective 'wave' list chunk         // create new Sample object and its respective 'wave' list chunk
3068         RIFF::List* wave = wvpl->AddSubList(LIST_TYPE_WAVE);         RIFF::List* wave = wvpl->AddSubList(LIST_TYPE_WAVE);
3069         Sample* pSample = new Sample(this, wave, 0 /*arbitrary value, we update offsets when we save*/);         Sample* pSample = new Sample(this, wave, 0 /*arbitrary value, we update offsets when we save*/);
3070    
3071           // add mandatory chunks to get the chunks in right order
3072           wave->AddSubChunk(CHUNK_ID_FMT, 16);
3073           wave->AddSubList(LIST_TYPE_INFO);
3074    
3075         pSamples->push_back(pSample);         pSamples->push_back(pSample);
3076         return pSample;         return pSample;
3077      }      }
# Line 3080  namespace { Line 3214  namespace {
3214         __ensureMandatoryChunksExist();         __ensureMandatoryChunksExist();
3215         RIFF::List* lstInstruments = pRIFF->GetSubList(LIST_TYPE_LINS);         RIFF::List* lstInstruments = pRIFF->GetSubList(LIST_TYPE_LINS);
3216         RIFF::List* lstInstr = lstInstruments->AddSubList(LIST_TYPE_INS);         RIFF::List* lstInstr = lstInstruments->AddSubList(LIST_TYPE_INS);
3217    
3218           // add mandatory chunks to get the chunks in right order
3219           lstInstr->AddSubList(LIST_TYPE_INFO);
3220           lstInstr->AddSubChunk(CHUNK_ID_DLID, 16);
3221    
3222         Instrument* pInstrument = new Instrument(this, lstInstr);         Instrument* pInstrument = new Instrument(this, lstInstr);
3223           pInstrument->GenerateDLSID();
3224    
3225           lstInstr->AddSubChunk(CHUNK_ID_INSH, 12);
3226    
3227           // this string is needed for the gig to be loadable in GSt:
3228           pInstrument->pInfo->Software = "Endless Wave";
3229    
3230         pInstruments->push_back(pInstrument);         pInstruments->push_back(pInstrument);
3231         return pInstrument;         return pInstrument;
3232      }      }
# Line 3131  namespace { Line 3277  namespace {
3277          }          }
3278      }      }
3279    
3280        /// Updates the 3crc chunk with the checksum of a sample. The
3281        /// update is done directly to disk, as this method is called
3282        /// after File::Save()
3283        void File::SetSampleChecksum(Sample* pSample, uint32_t crc) {
3284            RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
3285            if (!_3crc) return;
3286    
3287            // get the index of the sample
3288            int iWaveIndex = -1;
3289            File::SampleList::iterator iter = pSamples->begin();
3290            File::SampleList::iterator end  = pSamples->end();
3291            for (int index = 0; iter != end; ++iter, ++index) {
3292                if (*iter == pSample) {
3293                    iWaveIndex = index;
3294                    break;
3295                }
3296            }
3297            if (iWaveIndex < 0) throw gig::Exception("Could not update crc, could not find sample");
3298    
3299            // write the CRC-32 checksum to disk
3300            _3crc->SetPos(iWaveIndex * 8);
3301            uint32_t tmp = 1;
3302            _3crc->WriteUint32(&tmp); // unknown, always 1?
3303            _3crc->WriteUint32(&crc);
3304        }
3305    
3306      Group* File::GetFirstGroup() {      Group* File::GetFirstGroup() {
3307          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
3308          // there must always be at least one group          // there must always be at least one group
# Line 3248  namespace { Line 3420  namespace {
3420       * @throws Exception - on errors       * @throws Exception - on errors
3421       */       */
3422      void File::UpdateChunks() {      void File::UpdateChunks() {
3423            bool newFile = pRIFF->GetSubList(LIST_TYPE_INFO) == NULL;
3424    
3425            b64BitWavePoolOffsets = pVersion && pVersion->major == 3;
3426    
3427          // first update base class's chunks          // first update base class's chunks
3428          DLS::File::UpdateChunks();          DLS::File::UpdateChunks();
3429    
3430            if (newFile) {
3431                // INFO was added by Resource::UpdateChunks - make sure it
3432                // is placed first in file
3433                RIFF::Chunk* info = pRIFF->GetSubList(LIST_TYPE_INFO);
3434                RIFF::Chunk* first = pRIFF->GetFirstSubChunk();
3435                if (first != info) {
3436                    pRIFF->MoveSubChunk(info, first);
3437                }
3438            }
3439    
3440          // update group's chunks          // update group's chunks
3441          if (pGroups) {          if (pGroups) {
3442              std::list<Group*>::iterator iter = pGroups->begin();              std::list<Group*>::iterator iter = pGroups->begin();
# Line 3259  namespace { Line 3445  namespace {
3445                  (*iter)->UpdateChunks();                  (*iter)->UpdateChunks();
3446              }              }
3447          }          }
3448    
3449            // update einf chunk
3450    
3451            // The einf chunk contains statistics about the gig file, such
3452            // as the number of regions and samples used by each
3453            // instrument. It is divided in equally sized parts, where the
3454            // first part contains information about the whole gig file,
3455            // and the rest of the parts map to each instrument in the
3456            // file.
3457            //
3458            // At the end of each part there is a bit map of each sample
3459            // in the file, where a set bit means that the sample is used
3460            // by the file/instrument.
3461            //
3462            // Note that there are several fields with unknown use. These
3463            // are set to zero.
3464    
3465            int sublen = pSamples->size() / 8 + 49;
3466            int einfSize = (Instruments + 1) * sublen;
3467    
3468            RIFF::Chunk* einf = pRIFF->GetSubChunk(CHUNK_ID_EINF);
3469            if (einf) {
3470                if (einf->GetSize() != einfSize) {
3471                    einf->Resize(einfSize);
3472                    memset(einf->LoadChunkData(), 0, einfSize);
3473                }
3474            } else if (newFile) {
3475                einf = pRIFF->AddSubChunk(CHUNK_ID_EINF, einfSize);
3476            }
3477            if (einf) {
3478                uint8_t* pData = (uint8_t*) einf->LoadChunkData();
3479    
3480                std::map<gig::Sample*,int> sampleMap;
3481                int sampleIdx = 0;
3482                for (Sample* pSample = GetFirstSample(); pSample; pSample = GetNextSample()) {
3483                    sampleMap[pSample] = sampleIdx++;
3484                }
3485    
3486                int totnbusedsamples = 0;
3487                int totnbusedchannels = 0;
3488                int totnbregions = 0;
3489                int totnbdimregions = 0;
3490                int instrumentIdx = 0;
3491    
3492                memset(&pData[48], 0, sublen - 48);
3493    
3494                for (Instrument* instrument = GetFirstInstrument() ; instrument ;
3495                     instrument = GetNextInstrument()) {
3496                    int nbusedsamples = 0;
3497                    int nbusedchannels = 0;
3498                    int nbdimregions = 0;
3499    
3500                    memset(&pData[(instrumentIdx + 1) * sublen + 48], 0, sublen - 48);
3501    
3502                    for (Region* region = instrument->GetFirstRegion() ; region ;
3503                         region = instrument->GetNextRegion()) {
3504                        for (int i = 0 ; i < region->DimensionRegions ; i++) {
3505                            gig::DimensionRegion *d = region->pDimensionRegions[i];
3506                            if (d->pSample) {
3507                                int sampleIdx = sampleMap[d->pSample];
3508                                int byte = 48 + sampleIdx / 8;
3509                                int bit = 1 << (sampleIdx & 7);
3510                                if ((pData[(instrumentIdx + 1) * sublen + byte] & bit) == 0) {
3511                                    pData[(instrumentIdx + 1) * sublen + byte] |= bit;
3512                                    nbusedsamples++;
3513                                    nbusedchannels += d->pSample->Channels;
3514    
3515                                    if ((pData[byte] & bit) == 0) {
3516                                        pData[byte] |= bit;
3517                                        totnbusedsamples++;
3518                                        totnbusedchannels += d->pSample->Channels;
3519                                    }
3520                                }
3521                            }
3522                        }
3523                        nbdimregions += region->DimensionRegions;
3524                    }
3525                    // first 4 bytes unknown - sometimes 0, sometimes length of einf part
3526                    // store32(&pData[(instrumentIdx + 1) * sublen], sublen);
3527                    store32(&pData[(instrumentIdx + 1) * sublen + 4], nbusedchannels);
3528                    store32(&pData[(instrumentIdx + 1) * sublen + 8], nbusedsamples);
3529                    store32(&pData[(instrumentIdx + 1) * sublen + 12], 1);
3530                    store32(&pData[(instrumentIdx + 1) * sublen + 16], instrument->Regions);
3531                    store32(&pData[(instrumentIdx + 1) * sublen + 20], nbdimregions);
3532                    // next 12 bytes unknown
3533                    store32(&pData[(instrumentIdx + 1) * sublen + 36], instrumentIdx);
3534                    store32(&pData[(instrumentIdx + 1) * sublen + 40], pSamples->size());
3535                    // next 4 bytes unknown
3536    
3537                    totnbregions += instrument->Regions;
3538                    totnbdimregions += nbdimregions;
3539                    instrumentIdx++;
3540                }
3541                // first 4 bytes unknown - sometimes 0, sometimes length of einf part
3542                // store32(&pData[0], sublen);
3543                store32(&pData[4], totnbusedchannels);
3544                store32(&pData[8], totnbusedsamples);
3545                store32(&pData[12], Instruments);
3546                store32(&pData[16], totnbregions);
3547                store32(&pData[20], totnbdimregions);
3548                // next 12 bytes unknown
3549                // next 4 bytes unknown, always 0?
3550                store32(&pData[40], pSamples->size());
3551                // next 4 bytes unknown
3552            }
3553    
3554            // update 3crc chunk
3555    
3556            // The 3crc chunk contains CRC-32 checksums for the
3557            // samples. The actual checksum values will be filled in
3558            // later, by Sample::Write.
3559    
3560            RIFF::Chunk* _3crc = pRIFF->GetSubChunk(CHUNK_ID_3CRC);
3561            if (_3crc) {
3562                _3crc->Resize(pSamples->size() * 8);
3563            } else if (newFile) {
3564                _3crc = pRIFF->AddSubChunk(CHUNK_ID_3CRC, pSamples->size() * 8);
3565                _3crc->LoadChunkData();
3566            }
3567      }      }
3568    
3569    
Legend:
Removed from v.1180  
changed lines
  Added in v.1247
  ViewVC Help
Powered by ViewVC