/[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 1851 by schoenebeck, Sun Mar 1 22:08:32 2009 UTC revision 2547 by schoenebeck, Tue May 13 11:17:24 2014 UTC
# Line 2  Line 2 
2   *                                                                         *   *                                                                         *
3   *   libgig - C++ cross-platform Gigasampler format file access library    *   *   libgig - C++ cross-platform Gigasampler format file access library    *
4   *                                                                         *   *                                                                         *
5   *   Copyright (C) 2003-2009 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 454  namespace { Line 454  namespace {
454      }      }
455    
456      /**      /**
457         * Make a (semi) deep copy of the Sample object given by @a orig (without
458         * the actual waveform data) and assign it to this object.
459         *
460         * Discussion: copying .gig samples is a bit tricky. It requires three
461         * steps:
462         * 1. Copy sample's meta informations (done by CopyAssignMeta()) including
463         *    its new sample waveform data size.
464         * 2. Saving the file (done by File::Save()) so that it gains correct size
465         *    and layout for writing the actual wave form data directly to disc
466         *    in next step.
467         * 3. Copy the waveform data with disk streaming (done by CopyAssignWave()).
468         *
469         * @param orig - original Sample object to be copied from
470         */
471        void Sample::CopyAssignMeta(const Sample* orig) {
472            // handle base classes
473            DLS::Sample::CopyAssignCore(orig);
474            
475            // handle actual own attributes of this class
476            Manufacturer = orig->Manufacturer;
477            Product = orig->Product;
478            SamplePeriod = orig->SamplePeriod;
479            MIDIUnityNote = orig->MIDIUnityNote;
480            FineTune = orig->FineTune;
481            SMPTEFormat = orig->SMPTEFormat;
482            SMPTEOffset = orig->SMPTEOffset;
483            Loops = orig->Loops;
484            LoopID = orig->LoopID;
485            LoopType = orig->LoopType;
486            LoopStart = orig->LoopStart;
487            LoopEnd = orig->LoopEnd;
488            LoopSize = orig->LoopSize;
489            LoopFraction = orig->LoopFraction;
490            LoopPlayCount = orig->LoopPlayCount;
491            
492            // schedule resizing this sample to the given sample's size
493            Resize(orig->GetSize());
494        }
495    
496        /**
497         * Should be called after CopyAssignMeta() and File::Save() sequence.
498         * Read more about it in the discussion of CopyAssignMeta(). This method
499         * copies the actual waveform data by disk streaming.
500         *
501         * @e CAUTION: this method is currently not thread safe! During this
502         * operation the sample must not be used for other purposes by other
503         * threads!
504         *
505         * @param orig - original Sample object to be copied from
506         */
507        void Sample::CopyAssignWave(const Sample* orig) {
508            const int iReadAtOnce = 32*1024;
509            char* buf = new char[iReadAtOnce * orig->FrameSize];
510            Sample* pOrig = (Sample*) orig; //HACK: remove constness for now
511            unsigned long restorePos = pOrig->GetPos();
512            pOrig->SetPos(0);
513            SetPos(0);
514            for (unsigned long n = pOrig->Read(buf, iReadAtOnce); n;
515                               n = pOrig->Read(buf, iReadAtOnce))
516            {
517                Write(buf, n);
518            }
519            pOrig->SetPos(restorePos);
520            delete [] buf;
521        }
522    
523        /**
524       * Apply sample and its settings to the respective RIFF chunks. You have       * Apply sample and its settings to the respective RIFF chunks. You have
525       * to call File::Save() to make changes persistent.       * to call File::Save() to make changes persistent.
526       *       *
# Line 514  namespace { Line 581  namespace {
581          // update '3gix' chunk          // update '3gix' chunk
582          pData = (uint8_t*) pCk3gix->LoadChunkData();          pData = (uint8_t*) pCk3gix->LoadChunkData();
583          store16(&pData[0], iSampleGroup);          store16(&pData[0], iSampleGroup);
584    
585            // if the library user toggled the "Compressed" attribute from true to
586            // false, then the EWAV chunk associated with compressed samples needs
587            // to be deleted
588            RIFF::Chunk* ewav = pWaveList->GetSubChunk(CHUNK_ID_EWAV);
589            if (ewav && !Compressed) {
590                pWaveList->DeleteSubChunk(ewav);
591            }
592      }      }
593    
594      /// Scans compressed samples for mandatory informations (e.g. actual number of total sample points).      /// Scans compressed samples for mandatory informations (e.g. actual number of total sample points).
# Line 808  namespace { Line 883  namespace {
883      /**      /**
884       * Returns the current position in the sample (in sample points).       * Returns the current position in the sample (in sample points).
885       */       */
886      unsigned long Sample::GetPos() {      unsigned long Sample::GetPos() const {
887          if (Compressed) return SamplePos;          if (Compressed) return SamplePos;
888          else            return pCkData->GetPos() / FrameSize;          else            return pCkData->GetPos() / FrameSize;
889      }      }
# Line 910  namespace { Line 985  namespace {
985                                  }                                  }
986    
987                                  // reverse the sample frames for backward playback                                  // reverse the sample frames for backward playback
988                                  SwapMemoryArea(&pDst[swapareastart * this->FrameSize], (totalreadsamples - swapareastart) * this->FrameSize, this->FrameSize);                                  if (totalreadsamples > swapareastart) //FIXME: this if() is just a crash workaround for now (#102), but totalreadsamples <= swapareastart should never be the case, so there's probably still a bug above!
989                                        SwapMemoryArea(&pDst[swapareastart * this->FrameSize], (totalreadsamples - swapareastart) * this->FrameSize, this->FrameSize);
990                              }                              }
991                          } while (samplestoread && readsamples);                          } while (samplestoread && readsamples);
992                          break;                          break;
# Line 1432  namespace { Line 1508  namespace {
1508                                                          : vcf_res_ctrl_none;                                                          : vcf_res_ctrl_none;
1509              uint16_t eg3depth = _3ewa->ReadUint16();              uint16_t eg3depth = _3ewa->ReadUint16();
1510              EG3Depth = (eg3depth <= 1200) ? eg3depth /* positives */              EG3Depth = (eg3depth <= 1200) ? eg3depth /* positives */
1511                                          : (-1) * (int16_t) ((eg3depth ^ 0xffff) + 1); /* binary complementary for negatives */                                          : (-1) * (int16_t) ((eg3depth ^ 0xfff) + 1); /* binary complementary for negatives */
1512              _3ewa->ReadInt16(); // unknown              _3ewa->ReadInt16(); // unknown
1513              ChannelOffset = _3ewa->ReadUint8() / 4;              ChannelOffset = _3ewa->ReadUint8() / 4;
1514              uint8_t regoptions = _3ewa->ReadUint8();              uint8_t regoptions = _3ewa->ReadUint8();
# Line 1580  namespace { Line 1656  namespace {
1656       */       */
1657      DimensionRegion::DimensionRegion(RIFF::List* _3ewl, const DimensionRegion& src) : DLS::Sampler(_3ewl) {      DimensionRegion::DimensionRegion(RIFF::List* _3ewl, const DimensionRegion& src) : DLS::Sampler(_3ewl) {
1658          Instances++;          Instances++;
1659            //NOTE: I think we cannot call CopyAssign() here (in a constructor) as long as its a virtual method
1660          *this = src; // default memberwise shallow copy of all parameters          *this = src; // default memberwise shallow copy of all parameters
1661          pParentList = _3ewl; // restore the chunk pointer          pParentList = _3ewl; // restore the chunk pointer
1662    
# Line 1595  namespace { Line 1672  namespace {
1672                  pSampleLoops[k] = src.pSampleLoops[k];                  pSampleLoops[k] = src.pSampleLoops[k];
1673          }          }
1674      }      }
1675        
1676        /**
1677         * Make a (semi) deep copy of the DimensionRegion object given by @a orig
1678         * and assign it to this object.
1679         *
1680         * Note that all sample pointers referenced by @a orig are simply copied as
1681         * memory address. Thus the respective samples are shared, not duplicated!
1682         *
1683         * @param orig - original DimensionRegion object to be copied from
1684         */
1685        void DimensionRegion::CopyAssign(const DimensionRegion* orig) {
1686            CopyAssign(orig, NULL);
1687        }
1688    
1689        /**
1690         * Make a (semi) deep copy of the DimensionRegion object given by @a orig
1691         * and assign it to this object.
1692         *
1693         * @param orig - original DimensionRegion object to be copied from
1694         * @param mSamples - crosslink map between the foreign file's samples and
1695         *                   this file's samples
1696         */
1697        void DimensionRegion::CopyAssign(const DimensionRegion* orig, const std::map<Sample*,Sample*>* mSamples) {
1698            // delete all allocated data first
1699            if (VelocityTable) delete [] VelocityTable;
1700            if (pSampleLoops) delete [] pSampleLoops;
1701            
1702            // backup parent list pointer
1703            RIFF::List* p = pParentList;
1704            
1705            gig::Sample* pOriginalSample = pSample;
1706            gig::Region* pOriginalRegion = pRegion;
1707            
1708            //NOTE: copy code copied from assignment constructor above, see comment there as well
1709            
1710            *this = *orig; // default memberwise shallow copy of all parameters
1711            
1712            // restore members that shall not be altered
1713            pParentList = p; // restore the chunk pointer
1714            pRegion = pOriginalRegion;
1715            
1716            // only take the raw sample reference reference if the
1717            // two DimensionRegion objects are part of the same file
1718            if (pOriginalRegion->GetParent()->GetParent() != orig->pRegion->GetParent()->GetParent()) {
1719                pSample = pOriginalSample;
1720            }
1721            
1722            if (mSamples && mSamples->count(orig->pSample)) {
1723                pSample = mSamples->find(orig->pSample)->second;
1724            }
1725    
1726            // deep copy of owned structures
1727            if (orig->VelocityTable) {
1728                VelocityTable = new uint8_t[128];
1729                for (int k = 0 ; k < 128 ; k++)
1730                    VelocityTable[k] = orig->VelocityTable[k];
1731            }
1732            if (orig->pSampleLoops) {
1733                pSampleLoops = new DLS::sample_loop_t[orig->SampleLoops];
1734                for (int k = 0 ; k < orig->SampleLoops ; k++)
1735                    pSampleLoops[k] = orig->pSampleLoops[k];
1736            }
1737        }
1738    
1739      /**      /**
1740       * Updates the respective member variable and updates @c SampleAttenuation       * Updates the respective member variable and updates @c SampleAttenuation
# Line 1836  namespace { Line 1976  namespace {
1976          }          }
1977    
1978          const uint16_t eg3depth = (EG3Depth >= 0) ? EG3Depth          const uint16_t eg3depth = (EG3Depth >= 0) ? EG3Depth
1979                                                    : uint16_t(((-EG3Depth) - 1) ^ 0xffff); /* binary complementary for negatives */                                                    : uint16_t(((-EG3Depth) - 1) ^ 0xfff); /* binary complementary for negatives */
1980          pData[116] = eg3depth;          store16(&pData[116], eg3depth);
1981    
1982          // next 2 bytes unknown          // next 2 bytes unknown
1983    
# Line 1884  namespace { Line 2024  namespace {
2024                                        (VCFKeyboardTrackingBreakpoint & 0x7f); /* lower 7 bits */                                        (VCFKeyboardTrackingBreakpoint & 0x7f); /* lower 7 bits */
2025          pData[137] = vcfbreakpoint;          pData[137] = vcfbreakpoint;
2026    
2027          const uint8_t vcfvelocity = VCFVelocityDynamicRange % 5 |          const uint8_t vcfvelocity = VCFVelocityDynamicRange % 5 +
2028                                      VCFVelocityCurve * 5;                                      VCFVelocityCurve * 5;
2029          pData[138] = vcfvelocity;          pData[138] = vcfvelocity;
2030    
# Line 1949  namespace { Line 2089  namespace {
2089          return pRegion;          return pRegion;
2090      }      }
2091    
2092    // show error if some _lev_ctrl_* enum entry is not listed in the following function
2093    // (commented out for now, because "diagnostic push" not supported prior GCC 4.6)
2094    // TODO: uncomment and add a GCC version check (see also commented "#pragma GCC diagnostic pop" below)
2095    //#pragma GCC diagnostic push
2096    //#pragma GCC diagnostic error "-Wswitch"
2097    
2098      leverage_ctrl_t DimensionRegion::DecodeLeverageController(_lev_ctrl_t EncodedController) {      leverage_ctrl_t DimensionRegion::DecodeLeverageController(_lev_ctrl_t EncodedController) {
2099          leverage_ctrl_t decodedcontroller;          leverage_ctrl_t decodedcontroller;
2100          switch (EncodedController) {          switch (EncodedController) {
# Line 2060  namespace { Line 2206  namespace {
2206                  decodedcontroller.controller_number = 95;                  decodedcontroller.controller_number = 95;
2207                  break;                  break;
2208    
2209                // format extension (these controllers are so far only supported by
2210                // LinuxSampler & gigedit) they will *NOT* work with
2211                // Gigasampler/GigaStudio !
2212                case _lev_ctrl_CC3_EXT:
2213                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2214                    decodedcontroller.controller_number = 3;
2215                    break;
2216                case _lev_ctrl_CC6_EXT:
2217                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2218                    decodedcontroller.controller_number = 6;
2219                    break;
2220                case _lev_ctrl_CC7_EXT:
2221                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2222                    decodedcontroller.controller_number = 7;
2223                    break;
2224                case _lev_ctrl_CC8_EXT:
2225                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2226                    decodedcontroller.controller_number = 8;
2227                    break;
2228                case _lev_ctrl_CC9_EXT:
2229                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2230                    decodedcontroller.controller_number = 9;
2231                    break;
2232                case _lev_ctrl_CC10_EXT:
2233                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2234                    decodedcontroller.controller_number = 10;
2235                    break;
2236                case _lev_ctrl_CC11_EXT:
2237                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2238                    decodedcontroller.controller_number = 11;
2239                    break;
2240                case _lev_ctrl_CC14_EXT:
2241                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2242                    decodedcontroller.controller_number = 14;
2243                    break;
2244                case _lev_ctrl_CC15_EXT:
2245                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2246                    decodedcontroller.controller_number = 15;
2247                    break;
2248                case _lev_ctrl_CC20_EXT:
2249                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2250                    decodedcontroller.controller_number = 20;
2251                    break;
2252                case _lev_ctrl_CC21_EXT:
2253                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2254                    decodedcontroller.controller_number = 21;
2255                    break;
2256                case _lev_ctrl_CC22_EXT:
2257                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2258                    decodedcontroller.controller_number = 22;
2259                    break;
2260                case _lev_ctrl_CC23_EXT:
2261                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2262                    decodedcontroller.controller_number = 23;
2263                    break;
2264                case _lev_ctrl_CC24_EXT:
2265                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2266                    decodedcontroller.controller_number = 24;
2267                    break;
2268                case _lev_ctrl_CC25_EXT:
2269                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2270                    decodedcontroller.controller_number = 25;
2271                    break;
2272                case _lev_ctrl_CC26_EXT:
2273                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2274                    decodedcontroller.controller_number = 26;
2275                    break;
2276                case _lev_ctrl_CC27_EXT:
2277                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2278                    decodedcontroller.controller_number = 27;
2279                    break;
2280                case _lev_ctrl_CC28_EXT:
2281                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2282                    decodedcontroller.controller_number = 28;
2283                    break;
2284                case _lev_ctrl_CC29_EXT:
2285                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2286                    decodedcontroller.controller_number = 29;
2287                    break;
2288                case _lev_ctrl_CC30_EXT:
2289                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2290                    decodedcontroller.controller_number = 30;
2291                    break;
2292                case _lev_ctrl_CC31_EXT:
2293                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2294                    decodedcontroller.controller_number = 31;
2295                    break;
2296                case _lev_ctrl_CC68_EXT:
2297                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2298                    decodedcontroller.controller_number = 68;
2299                    break;
2300                case _lev_ctrl_CC69_EXT:
2301                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2302                    decodedcontroller.controller_number = 69;
2303                    break;
2304                case _lev_ctrl_CC70_EXT:
2305                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2306                    decodedcontroller.controller_number = 70;
2307                    break;
2308                case _lev_ctrl_CC71_EXT:
2309                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2310                    decodedcontroller.controller_number = 71;
2311                    break;
2312                case _lev_ctrl_CC72_EXT:
2313                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2314                    decodedcontroller.controller_number = 72;
2315                    break;
2316                case _lev_ctrl_CC73_EXT:
2317                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2318                    decodedcontroller.controller_number = 73;
2319                    break;
2320                case _lev_ctrl_CC74_EXT:
2321                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2322                    decodedcontroller.controller_number = 74;
2323                    break;
2324                case _lev_ctrl_CC75_EXT:
2325                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2326                    decodedcontroller.controller_number = 75;
2327                    break;
2328                case _lev_ctrl_CC76_EXT:
2329                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2330                    decodedcontroller.controller_number = 76;
2331                    break;
2332                case _lev_ctrl_CC77_EXT:
2333                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2334                    decodedcontroller.controller_number = 77;
2335                    break;
2336                case _lev_ctrl_CC78_EXT:
2337                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2338                    decodedcontroller.controller_number = 78;
2339                    break;
2340                case _lev_ctrl_CC79_EXT:
2341                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2342                    decodedcontroller.controller_number = 79;
2343                    break;
2344                case _lev_ctrl_CC84_EXT:
2345                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2346                    decodedcontroller.controller_number = 84;
2347                    break;
2348                case _lev_ctrl_CC85_EXT:
2349                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2350                    decodedcontroller.controller_number = 85;
2351                    break;
2352                case _lev_ctrl_CC86_EXT:
2353                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2354                    decodedcontroller.controller_number = 86;
2355                    break;
2356                case _lev_ctrl_CC87_EXT:
2357                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2358                    decodedcontroller.controller_number = 87;
2359                    break;
2360                case _lev_ctrl_CC89_EXT:
2361                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2362                    decodedcontroller.controller_number = 89;
2363                    break;
2364                case _lev_ctrl_CC90_EXT:
2365                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2366                    decodedcontroller.controller_number = 90;
2367                    break;
2368                case _lev_ctrl_CC96_EXT:
2369                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2370                    decodedcontroller.controller_number = 96;
2371                    break;
2372                case _lev_ctrl_CC97_EXT:
2373                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2374                    decodedcontroller.controller_number = 97;
2375                    break;
2376                case _lev_ctrl_CC102_EXT:
2377                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2378                    decodedcontroller.controller_number = 102;
2379                    break;
2380                case _lev_ctrl_CC103_EXT:
2381                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2382                    decodedcontroller.controller_number = 103;
2383                    break;
2384                case _lev_ctrl_CC104_EXT:
2385                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2386                    decodedcontroller.controller_number = 104;
2387                    break;
2388                case _lev_ctrl_CC105_EXT:
2389                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2390                    decodedcontroller.controller_number = 105;
2391                    break;
2392                case _lev_ctrl_CC106_EXT:
2393                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2394                    decodedcontroller.controller_number = 106;
2395                    break;
2396                case _lev_ctrl_CC107_EXT:
2397                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2398                    decodedcontroller.controller_number = 107;
2399                    break;
2400                case _lev_ctrl_CC108_EXT:
2401                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2402                    decodedcontroller.controller_number = 108;
2403                    break;
2404                case _lev_ctrl_CC109_EXT:
2405                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2406                    decodedcontroller.controller_number = 109;
2407                    break;
2408                case _lev_ctrl_CC110_EXT:
2409                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2410                    decodedcontroller.controller_number = 110;
2411                    break;
2412                case _lev_ctrl_CC111_EXT:
2413                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2414                    decodedcontroller.controller_number = 111;
2415                    break;
2416                case _lev_ctrl_CC112_EXT:
2417                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2418                    decodedcontroller.controller_number = 112;
2419                    break;
2420                case _lev_ctrl_CC113_EXT:
2421                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2422                    decodedcontroller.controller_number = 113;
2423                    break;
2424                case _lev_ctrl_CC114_EXT:
2425                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2426                    decodedcontroller.controller_number = 114;
2427                    break;
2428                case _lev_ctrl_CC115_EXT:
2429                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2430                    decodedcontroller.controller_number = 115;
2431                    break;
2432                case _lev_ctrl_CC116_EXT:
2433                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2434                    decodedcontroller.controller_number = 116;
2435                    break;
2436                case _lev_ctrl_CC117_EXT:
2437                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2438                    decodedcontroller.controller_number = 117;
2439                    break;
2440                case _lev_ctrl_CC118_EXT:
2441                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2442                    decodedcontroller.controller_number = 118;
2443                    break;
2444                case _lev_ctrl_CC119_EXT:
2445                    decodedcontroller.type = leverage_ctrl_t::type_controlchange;
2446                    decodedcontroller.controller_number = 119;
2447                    break;
2448    
2449              // unknown controller type              // unknown controller type
2450              default:              default:
2451                  throw gig::Exception("Unknown leverage controller type.");                  throw gig::Exception("Unknown leverage controller type.");
2452          }          }
2453          return decodedcontroller;          return decodedcontroller;
2454      }      }
2455        
2456    // see above (diagnostic push not supported prior GCC 4.6)
2457    //#pragma GCC diagnostic pop
2458    
2459      DimensionRegion::_lev_ctrl_t DimensionRegion::EncodeLeverageController(leverage_ctrl_t DecodedController) {      DimensionRegion::_lev_ctrl_t DimensionRegion::EncodeLeverageController(leverage_ctrl_t DecodedController) {
2460          _lev_ctrl_t encodedcontroller;          _lev_ctrl_t encodedcontroller;
# Line 2153  namespace { Line 2542  namespace {
2542                      case 95:                      case 95:
2543                          encodedcontroller = _lev_ctrl_effect5depth;                          encodedcontroller = _lev_ctrl_effect5depth;
2544                          break;                          break;
2545    
2546                        // format extension (these controllers are so far only
2547                        // supported by LinuxSampler & gigedit) they will *NOT*
2548                        // work with Gigasampler/GigaStudio !
2549                        case 3:
2550                            encodedcontroller = _lev_ctrl_CC3_EXT;
2551                            break;
2552                        case 6:
2553                            encodedcontroller = _lev_ctrl_CC6_EXT;
2554                            break;
2555                        case 7:
2556                            encodedcontroller = _lev_ctrl_CC7_EXT;
2557                            break;
2558                        case 8:
2559                            encodedcontroller = _lev_ctrl_CC8_EXT;
2560                            break;
2561                        case 9:
2562                            encodedcontroller = _lev_ctrl_CC9_EXT;
2563                            break;
2564                        case 10:
2565                            encodedcontroller = _lev_ctrl_CC10_EXT;
2566                            break;
2567                        case 11:
2568                            encodedcontroller = _lev_ctrl_CC11_EXT;
2569                            break;
2570                        case 14:
2571                            encodedcontroller = _lev_ctrl_CC14_EXT;
2572                            break;
2573                        case 15:
2574                            encodedcontroller = _lev_ctrl_CC15_EXT;
2575                            break;
2576                        case 20:
2577                            encodedcontroller = _lev_ctrl_CC20_EXT;
2578                            break;
2579                        case 21:
2580                            encodedcontroller = _lev_ctrl_CC21_EXT;
2581                            break;
2582                        case 22:
2583                            encodedcontroller = _lev_ctrl_CC22_EXT;
2584                            break;
2585                        case 23:
2586                            encodedcontroller = _lev_ctrl_CC23_EXT;
2587                            break;
2588                        case 24:
2589                            encodedcontroller = _lev_ctrl_CC24_EXT;
2590                            break;
2591                        case 25:
2592                            encodedcontroller = _lev_ctrl_CC25_EXT;
2593                            break;
2594                        case 26:
2595                            encodedcontroller = _lev_ctrl_CC26_EXT;
2596                            break;
2597                        case 27:
2598                            encodedcontroller = _lev_ctrl_CC27_EXT;
2599                            break;
2600                        case 28:
2601                            encodedcontroller = _lev_ctrl_CC28_EXT;
2602                            break;
2603                        case 29:
2604                            encodedcontroller = _lev_ctrl_CC29_EXT;
2605                            break;
2606                        case 30:
2607                            encodedcontroller = _lev_ctrl_CC30_EXT;
2608                            break;
2609                        case 31:
2610                            encodedcontroller = _lev_ctrl_CC31_EXT;
2611                            break;
2612                        case 68:
2613                            encodedcontroller = _lev_ctrl_CC68_EXT;
2614                            break;
2615                        case 69:
2616                            encodedcontroller = _lev_ctrl_CC69_EXT;
2617                            break;
2618                        case 70:
2619                            encodedcontroller = _lev_ctrl_CC70_EXT;
2620                            break;
2621                        case 71:
2622                            encodedcontroller = _lev_ctrl_CC71_EXT;
2623                            break;
2624                        case 72:
2625                            encodedcontroller = _lev_ctrl_CC72_EXT;
2626                            break;
2627                        case 73:
2628                            encodedcontroller = _lev_ctrl_CC73_EXT;
2629                            break;
2630                        case 74:
2631                            encodedcontroller = _lev_ctrl_CC74_EXT;
2632                            break;
2633                        case 75:
2634                            encodedcontroller = _lev_ctrl_CC75_EXT;
2635                            break;
2636                        case 76:
2637                            encodedcontroller = _lev_ctrl_CC76_EXT;
2638                            break;
2639                        case 77:
2640                            encodedcontroller = _lev_ctrl_CC77_EXT;
2641                            break;
2642                        case 78:
2643                            encodedcontroller = _lev_ctrl_CC78_EXT;
2644                            break;
2645                        case 79:
2646                            encodedcontroller = _lev_ctrl_CC79_EXT;
2647                            break;
2648                        case 84:
2649                            encodedcontroller = _lev_ctrl_CC84_EXT;
2650                            break;
2651                        case 85:
2652                            encodedcontroller = _lev_ctrl_CC85_EXT;
2653                            break;
2654                        case 86:
2655                            encodedcontroller = _lev_ctrl_CC86_EXT;
2656                            break;
2657                        case 87:
2658                            encodedcontroller = _lev_ctrl_CC87_EXT;
2659                            break;
2660                        case 89:
2661                            encodedcontroller = _lev_ctrl_CC89_EXT;
2662                            break;
2663                        case 90:
2664                            encodedcontroller = _lev_ctrl_CC90_EXT;
2665                            break;
2666                        case 96:
2667                            encodedcontroller = _lev_ctrl_CC96_EXT;
2668                            break;
2669                        case 97:
2670                            encodedcontroller = _lev_ctrl_CC97_EXT;
2671                            break;
2672                        case 102:
2673                            encodedcontroller = _lev_ctrl_CC102_EXT;
2674                            break;
2675                        case 103:
2676                            encodedcontroller = _lev_ctrl_CC103_EXT;
2677                            break;
2678                        case 104:
2679                            encodedcontroller = _lev_ctrl_CC104_EXT;
2680                            break;
2681                        case 105:
2682                            encodedcontroller = _lev_ctrl_CC105_EXT;
2683                            break;
2684                        case 106:
2685                            encodedcontroller = _lev_ctrl_CC106_EXT;
2686                            break;
2687                        case 107:
2688                            encodedcontroller = _lev_ctrl_CC107_EXT;
2689                            break;
2690                        case 108:
2691                            encodedcontroller = _lev_ctrl_CC108_EXT;
2692                            break;
2693                        case 109:
2694                            encodedcontroller = _lev_ctrl_CC109_EXT;
2695                            break;
2696                        case 110:
2697                            encodedcontroller = _lev_ctrl_CC110_EXT;
2698                            break;
2699                        case 111:
2700                            encodedcontroller = _lev_ctrl_CC111_EXT;
2701                            break;
2702                        case 112:
2703                            encodedcontroller = _lev_ctrl_CC112_EXT;
2704                            break;
2705                        case 113:
2706                            encodedcontroller = _lev_ctrl_CC113_EXT;
2707                            break;
2708                        case 114:
2709                            encodedcontroller = _lev_ctrl_CC114_EXT;
2710                            break;
2711                        case 115:
2712                            encodedcontroller = _lev_ctrl_CC115_EXT;
2713                            break;
2714                        case 116:
2715                            encodedcontroller = _lev_ctrl_CC116_EXT;
2716                            break;
2717                        case 117:
2718                            encodedcontroller = _lev_ctrl_CC117_EXT;
2719                            break;
2720                        case 118:
2721                            encodedcontroller = _lev_ctrl_CC118_EXT;
2722                            break;
2723                        case 119:
2724                            encodedcontroller = _lev_ctrl_CC119_EXT;
2725                            break;
2726    
2727                      default:                      default:
2728                          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");
2729                  }                  }
# Line 2630  namespace { Line 3201  namespace {
3201       *                        dimension bits limit is violated       *                        dimension bits limit is violated
3202       */       */
3203      void Region::AddDimension(dimension_def_t* pDimDef) {      void Region::AddDimension(dimension_def_t* pDimDef) {
3204            // some initial sanity checks of the given dimension definition
3205            if (pDimDef->zones < 2)
3206                throw gig::Exception("Could not add new dimension, amount of requested zones must always be at least two");
3207            if (pDimDef->bits < 1)
3208                throw gig::Exception("Could not add new dimension, amount of requested requested zone bits must always be at least one");
3209            if (pDimDef->dimension == dimension_samplechannel) {
3210                if (pDimDef->zones != 2)
3211                    throw gig::Exception("Could not add new 'sample channel' dimensions, the requested amount of zones must always be 2 for this dimension type");
3212                if (pDimDef->bits != 1)
3213                    throw gig::Exception("Could not add new 'sample channel' dimensions, the requested amount of zone bits must always be 1 for this dimension type");
3214            }
3215    
3216          // check if max. amount of dimensions reached          // check if max. amount of dimensions reached
3217          File* file = (File*) GetParent()->GetParent();          File* file = (File*) GetParent()->GetParent();
3218          const int iMaxDimensions = (file->pVersion && file->pVersion->major == 3) ? 8 : 5;          const int iMaxDimensions = (file->pVersion && file->pVersion->major == 3) ? 8 : 5;
# Line 2805  namespace { Line 3388  namespace {
3388          if (pDimDef->dimension == dimension_layer) Layers = 1;          if (pDimDef->dimension == dimension_layer) Layers = 1;
3389      }      }
3390    
3391        /**
3392         * Searches in the current Region for a dimension of the given dimension
3393         * type and returns the precise configuration of that dimension in this
3394         * Region.
3395         *
3396         * @param type - dimension type of the sought dimension
3397         * @returns dimension definition or NULL if there is no dimension with
3398         *          sought type in this Region.
3399         */
3400        dimension_def_t* Region::GetDimensionDefinition(dimension_t type) {
3401            for (int i = 0; i < Dimensions; ++i)
3402                if (pDimensionDefinitions[i].dimension == type)
3403                    return &pDimensionDefinitions[i];
3404            return NULL;
3405        }
3406    
3407      Region::~Region() {      Region::~Region() {
3408          for (int i = 0; i < 256; i++) {          for (int i = 0; i < 256; i++) {
3409              if (pDimensionRegions[i]) delete pDimensionRegions[i];              if (pDimensionRegions[i]) delete pDimensionRegions[i];
# Line 2924  namespace { Line 3523  namespace {
3523          }          }
3524          return NULL;          return NULL;
3525      }      }
3526        
3527        /**
3528         * Make a (semi) deep copy of the Region object given by @a orig
3529         * and assign it to this object.
3530         *
3531         * Note that all sample pointers referenced by @a orig are simply copied as
3532         * memory address. Thus the respective samples are shared, not duplicated!
3533         *
3534         * @param orig - original Region object to be copied from
3535         */
3536        void Region::CopyAssign(const Region* orig) {
3537            CopyAssign(orig, NULL);
3538        }
3539        
3540        /**
3541         * Make a (semi) deep copy of the Region object given by @a orig and
3542         * assign it to this object
3543         *
3544         * @param mSamples - crosslink map between the foreign file's samples and
3545         *                   this file's samples
3546         */
3547        void Region::CopyAssign(const Region* orig, const std::map<Sample*,Sample*>* mSamples) {
3548            // handle base classes
3549            DLS::Region::CopyAssign(orig);
3550            
3551            if (mSamples && mSamples->count((gig::Sample*)orig->pSample)) {
3552                pSample = mSamples->find((gig::Sample*)orig->pSample)->second;
3553            }
3554            
3555            // handle own member variables
3556            for (int i = Dimensions - 1; i >= 0; --i) {
3557                DeleteDimension(&pDimensionDefinitions[i]);
3558            }
3559            Layers = 0; // just to be sure
3560            for (int i = 0; i < orig->Dimensions; i++) {
3561                // we need to copy the dim definition here, to avoid the compiler
3562                // complaining about const-ness issue
3563                dimension_def_t def = orig->pDimensionDefinitions[i];
3564                AddDimension(&def);
3565            }
3566            for (int i = 0; i < 256; i++) {
3567                if (pDimensionRegions[i] && orig->pDimensionRegions[i]) {
3568                    pDimensionRegions[i]->CopyAssign(
3569                        orig->pDimensionRegions[i],
3570                        mSamples
3571                    );
3572                }
3573            }
3574            Layers = orig->Layers;
3575        }
3576    
3577    
3578  // *************** MidiRule ***************  // *************** MidiRule ***************
3579  // *  // *
3580    
3581  MidiRuleCtrlTrigger::MidiRuleCtrlTrigger(RIFF::Chunk* _3ewg) {      MidiRuleCtrlTrigger::MidiRuleCtrlTrigger(RIFF::Chunk* _3ewg) {
3582      _3ewg->SetPos(36);          _3ewg->SetPos(36);
3583      Triggers = _3ewg->ReadUint8();          Triggers = _3ewg->ReadUint8();
3584      _3ewg->SetPos(40);          _3ewg->SetPos(40);
3585      ControllerNumber = _3ewg->ReadUint8();          ControllerNumber = _3ewg->ReadUint8();
3586      _3ewg->SetPos(46);          _3ewg->SetPos(46);
3587      for (int i = 0 ; i < Triggers ; i++) {          for (int i = 0 ; i < Triggers ; i++) {
3588          pTriggers[i].TriggerPoint = _3ewg->ReadUint8();              pTriggers[i].TriggerPoint = _3ewg->ReadUint8();
3589          pTriggers[i].Descending = _3ewg->ReadUint8();              pTriggers[i].Descending = _3ewg->ReadUint8();
3590          pTriggers[i].VelSensitivity = _3ewg->ReadUint8();              pTriggers[i].VelSensitivity = _3ewg->ReadUint8();
3591          pTriggers[i].Key = _3ewg->ReadUint8();              pTriggers[i].Key = _3ewg->ReadUint8();
3592          pTriggers[i].NoteOff = _3ewg->ReadUint8();              pTriggers[i].NoteOff = _3ewg->ReadUint8();
3593          pTriggers[i].Velocity = _3ewg->ReadUint8();              pTriggers[i].Velocity = _3ewg->ReadUint8();
3594          pTriggers[i].OverridePedal = _3ewg->ReadUint8();              pTriggers[i].OverridePedal = _3ewg->ReadUint8();
3595          _3ewg->ReadUint8();              _3ewg->ReadUint8();
3596            }
3597        }
3598    
3599        MidiRuleCtrlTrigger::MidiRuleCtrlTrigger() :
3600            ControllerNumber(0),
3601            Triggers(0) {
3602        }
3603    
3604        void MidiRuleCtrlTrigger::UpdateChunks(uint8_t* pData) const {
3605            pData[32] = 4;
3606            pData[33] = 16;
3607            pData[36] = Triggers;
3608            pData[40] = ControllerNumber;
3609            for (int i = 0 ; i < Triggers ; i++) {
3610                pData[46 + i * 8] = pTriggers[i].TriggerPoint;
3611                pData[47 + i * 8] = pTriggers[i].Descending;
3612                pData[48 + i * 8] = pTriggers[i].VelSensitivity;
3613                pData[49 + i * 8] = pTriggers[i].Key;
3614                pData[50 + i * 8] = pTriggers[i].NoteOff;
3615                pData[51 + i * 8] = pTriggers[i].Velocity;
3616                pData[52 + i * 8] = pTriggers[i].OverridePedal;
3617            }
3618        }
3619    
3620        MidiRuleLegato::MidiRuleLegato(RIFF::Chunk* _3ewg) {
3621            _3ewg->SetPos(36);
3622            LegatoSamples = _3ewg->ReadUint8(); // always 12
3623            _3ewg->SetPos(40);
3624            BypassUseController = _3ewg->ReadUint8();
3625            BypassKey = _3ewg->ReadUint8();
3626            BypassController = _3ewg->ReadUint8();
3627            ThresholdTime = _3ewg->ReadUint16();
3628            _3ewg->ReadInt16();
3629            ReleaseTime = _3ewg->ReadUint16();
3630            _3ewg->ReadInt16();
3631            KeyRange.low = _3ewg->ReadUint8();
3632            KeyRange.high = _3ewg->ReadUint8();
3633            _3ewg->SetPos(64);
3634            ReleaseTriggerKey = _3ewg->ReadUint8();
3635            AltSustain1Key = _3ewg->ReadUint8();
3636            AltSustain2Key = _3ewg->ReadUint8();
3637        }
3638    
3639        MidiRuleLegato::MidiRuleLegato() :
3640            LegatoSamples(12),
3641            BypassUseController(false),
3642            BypassKey(0),
3643            BypassController(1),
3644            ThresholdTime(20),
3645            ReleaseTime(20),
3646            ReleaseTriggerKey(0),
3647            AltSustain1Key(0),
3648            AltSustain2Key(0)
3649        {
3650            KeyRange.low = KeyRange.high = 0;
3651        }
3652    
3653        void MidiRuleLegato::UpdateChunks(uint8_t* pData) const {
3654            pData[32] = 0;
3655            pData[33] = 16;
3656            pData[36] = LegatoSamples;
3657            pData[40] = BypassUseController;
3658            pData[41] = BypassKey;
3659            pData[42] = BypassController;
3660            store16(&pData[43], ThresholdTime);
3661            store16(&pData[47], ReleaseTime);
3662            pData[51] = KeyRange.low;
3663            pData[52] = KeyRange.high;
3664            pData[64] = ReleaseTriggerKey;
3665            pData[65] = AltSustain1Key;
3666            pData[66] = AltSustain2Key;
3667        }
3668    
3669        MidiRuleAlternator::MidiRuleAlternator(RIFF::Chunk* _3ewg) {
3670            _3ewg->SetPos(36);
3671            Articulations = _3ewg->ReadUint8();
3672            int flags = _3ewg->ReadUint8();
3673            Polyphonic = flags & 8;
3674            Chained = flags & 4;
3675            Selector = (flags & 2) ? selector_controller :
3676                (flags & 1) ? selector_key_switch : selector_none;
3677            Patterns = _3ewg->ReadUint8();
3678            _3ewg->ReadUint8(); // chosen row
3679            _3ewg->ReadUint8(); // unknown
3680            _3ewg->ReadUint8(); // unknown
3681            _3ewg->ReadUint8(); // unknown
3682            KeySwitchRange.low = _3ewg->ReadUint8();
3683            KeySwitchRange.high = _3ewg->ReadUint8();
3684            Controller = _3ewg->ReadUint8();
3685            PlayRange.low = _3ewg->ReadUint8();
3686            PlayRange.high = _3ewg->ReadUint8();
3687    
3688            int n = std::min(int(Articulations), 32);
3689            for (int i = 0 ; i < n ; i++) {
3690                _3ewg->ReadString(pArticulations[i], 32);
3691            }
3692            _3ewg->SetPos(1072);
3693            n = std::min(int(Patterns), 32);
3694            for (int i = 0 ; i < n ; i++) {
3695                _3ewg->ReadString(pPatterns[i].Name, 16);
3696                pPatterns[i].Size = _3ewg->ReadUint8();
3697                _3ewg->Read(&pPatterns[i][0], 1, 32);
3698            }
3699        }
3700    
3701        MidiRuleAlternator::MidiRuleAlternator() :
3702            Articulations(0),
3703            Patterns(0),
3704            Selector(selector_none),
3705            Controller(0),
3706            Polyphonic(false),
3707            Chained(false)
3708        {
3709            PlayRange.low = PlayRange.high = 0;
3710            KeySwitchRange.low = KeySwitchRange.high = 0;
3711      }      }
 }  
3712    
3713        void MidiRuleAlternator::UpdateChunks(uint8_t* pData) const {
3714            pData[32] = 3;
3715            pData[33] = 16;
3716            pData[36] = Articulations;
3717            pData[37] = (Polyphonic ? 8 : 0) | (Chained ? 4 : 0) |
3718                (Selector == selector_controller ? 2 :
3719                 (Selector == selector_key_switch ? 1 : 0));
3720            pData[38] = Patterns;
3721    
3722            pData[43] = KeySwitchRange.low;
3723            pData[44] = KeySwitchRange.high;
3724            pData[45] = Controller;
3725            pData[46] = PlayRange.low;
3726            pData[47] = PlayRange.high;
3727    
3728            char* str = reinterpret_cast<char*>(pData);
3729            int pos = 48;
3730            int n = std::min(int(Articulations), 32);
3731            for (int i = 0 ; i < n ; i++, pos += 32) {
3732                strncpy(&str[pos], pArticulations[i].c_str(), 32);
3733            }
3734    
3735            pos = 1072;
3736            n = std::min(int(Patterns), 32);
3737            for (int i = 0 ; i < n ; i++, pos += 49) {
3738                strncpy(&str[pos], pPatterns[i].Name.c_str(), 16);
3739                pData[pos + 16] = pPatterns[i].Size;
3740                memcpy(&pData[pos + 16], &(pPatterns[i][0]), 32);
3741            }
3742        }
3743    
3744  // *************** Instrument ***************  // *************** Instrument ***************
3745  // *  // *
# Line 2992  MidiRuleCtrlTrigger::MidiRuleCtrlTrigger Line 3785  MidiRuleCtrlTrigger::MidiRuleCtrlTrigger
3785                      uint8_t id1 = _3ewg->ReadUint8();                      uint8_t id1 = _3ewg->ReadUint8();
3786                      uint8_t id2 = _3ewg->ReadUint8();                      uint8_t id2 = _3ewg->ReadUint8();
3787    
3788                      if (id1 == 4 && id2 == 16) {                      if (id2 == 16) {
3789                          pMidiRules[i++] = new MidiRuleCtrlTrigger(_3ewg);                          if (id1 == 4) {
3790                                pMidiRules[i++] = new MidiRuleCtrlTrigger(_3ewg);
3791                            } else if (id1 == 0) {
3792                                pMidiRules[i++] = new MidiRuleLegato(_3ewg);
3793                            } else if (id1 == 3) {
3794                                pMidiRules[i++] = new MidiRuleAlternator(_3ewg);
3795                            } else {
3796                                pMidiRules[i++] = new MidiRuleUnknown;
3797                            }
3798                        }
3799                        else if (id1 != 0 || id2 != 0) {
3800                            pMidiRules[i++] = new MidiRuleUnknown;
3801                      }                      }
3802                      //TODO: all the other types of rules                      //TODO: all the other types of rules
3803    
# Line 3035  MidiRuleCtrlTrigger::MidiRuleCtrlTrigger Line 3839  MidiRuleCtrlTrigger::MidiRuleCtrlTrigger
3839      }      }
3840    
3841      Instrument::~Instrument() {      Instrument::~Instrument() {
3842            for (int i = 0 ; pMidiRules[i] ; i++) {
3843                delete pMidiRules[i];
3844            }
3845          delete[] pMidiRules;          delete[] pMidiRules;
3846      }      }
3847    
# Line 3082  MidiRuleCtrlTrigger::MidiRuleCtrlTrigger Line 3889  MidiRuleCtrlTrigger::MidiRuleCtrlTrigger
3889                                      DimensionKeyRange.low << 1;                                      DimensionKeyRange.low << 1;
3890          pData[10] = dimkeystart;          pData[10] = dimkeystart;
3891          pData[11] = DimensionKeyRange.high;          pData[11] = DimensionKeyRange.high;
3892    
3893            if (pMidiRules[0] == 0 && _3ewg->GetSize() >= 34) {
3894                pData[32] = 0;
3895                pData[33] = 0;
3896            } else {
3897                for (int i = 0 ; pMidiRules[i] ; i++) {
3898                    pMidiRules[i]->UpdateChunks(pData);
3899                }
3900            }
3901      }      }
3902    
3903      /**      /**
# Line 3164  MidiRuleCtrlTrigger::MidiRuleCtrlTrigger Line 3980  MidiRuleCtrlTrigger::MidiRuleCtrlTrigger
3980          return pMidiRules[i];          return pMidiRules[i];
3981      }      }
3982    
3983        /**
3984         * Adds the "controller trigger" MIDI rule to the instrument.
3985         *
3986         * @returns the new MIDI rule
3987         */
3988        MidiRuleCtrlTrigger* Instrument::AddMidiRuleCtrlTrigger() {
3989            delete pMidiRules[0];
3990            MidiRuleCtrlTrigger* r = new MidiRuleCtrlTrigger;
3991            pMidiRules[0] = r;
3992            pMidiRules[1] = 0;
3993            return r;
3994        }
3995    
3996        /**
3997         * Adds the legato MIDI rule to the instrument.
3998         *
3999         * @returns the new MIDI rule
4000         */
4001        MidiRuleLegato* Instrument::AddMidiRuleLegato() {
4002            delete pMidiRules[0];
4003            MidiRuleLegato* r = new MidiRuleLegato;
4004            pMidiRules[0] = r;
4005            pMidiRules[1] = 0;
4006            return r;
4007        }
4008    
4009        /**
4010         * Adds the alternator MIDI rule to the instrument.
4011         *
4012         * @returns the new MIDI rule
4013         */
4014        MidiRuleAlternator* Instrument::AddMidiRuleAlternator() {
4015            delete pMidiRules[0];
4016            MidiRuleAlternator* r = new MidiRuleAlternator;
4017            pMidiRules[0] = r;
4018            pMidiRules[1] = 0;
4019            return r;
4020        }
4021    
4022        /**
4023         * Deletes a MIDI rule from the instrument.
4024         *
4025         * @param i - MIDI rule number
4026         */
4027        void Instrument::DeleteMidiRule(int i) {
4028            delete pMidiRules[i];
4029            pMidiRules[i] = 0;
4030        }
4031    
4032        /**
4033         * Make a (semi) deep copy of the Instrument object given by @a orig
4034         * and assign it to this object.
4035         *
4036         * Note that all sample pointers referenced by @a orig are simply copied as
4037         * memory address. Thus the respective samples are shared, not duplicated!
4038         *
4039         * @param orig - original Instrument object to be copied from
4040         */
4041        void Instrument::CopyAssign(const Instrument* orig) {
4042            CopyAssign(orig, NULL);
4043        }
4044            
4045        /**
4046         * Make a (semi) deep copy of the Instrument object given by @a orig
4047         * and assign it to this object.
4048         *
4049         * @param orig - original Instrument object to be copied from
4050         * @param mSamples - crosslink map between the foreign file's samples and
4051         *                   this file's samples
4052         */
4053        void Instrument::CopyAssign(const Instrument* orig, const std::map<Sample*,Sample*>* mSamples) {
4054            // handle base class
4055            // (without copying DLS region stuff)
4056            DLS::Instrument::CopyAssignCore(orig);
4057            
4058            // handle own member variables
4059            Attenuation = orig->Attenuation;
4060            EffectSend = orig->EffectSend;
4061            FineTune = orig->FineTune;
4062            PitchbendRange = orig->PitchbendRange;
4063            PianoReleaseMode = orig->PianoReleaseMode;
4064            DimensionKeyRange = orig->DimensionKeyRange;
4065            
4066            // free old midi rules
4067            for (int i = 0 ; pMidiRules[i] ; i++) {
4068                delete pMidiRules[i];
4069            }
4070            //TODO: MIDI rule copying
4071            pMidiRules[0] = NULL;
4072            
4073            // delete all old regions
4074            while (Regions) DeleteRegion(GetFirstRegion());
4075            // create new regions and copy them from original
4076            {
4077                RegionList::const_iterator it = orig->pRegions->begin();
4078                for (int i = 0; i < orig->Regions; ++i, ++it) {
4079                    Region* dstRgn = AddRegion();
4080                    //NOTE: Region does semi-deep copy !
4081                    dstRgn->CopyAssign(
4082                        static_cast<gig::Region*>(*it),
4083                        mSamples
4084                    );
4085                }
4086            }
4087    
4088            UpdateRegionKeyTable();
4089        }
4090    
4091    
4092  // *************** Group ***************  // *************** Group ***************
4093  // *  // *
# Line 3365  MidiRuleCtrlTrigger::MidiRuleCtrlTrigger Line 4289  MidiRuleCtrlTrigger::MidiRuleCtrlTrigger
4289          SamplesIterator++;          SamplesIterator++;
4290          return static_cast<gig::Sample*>( (SamplesIterator != pSamples->end()) ? *SamplesIterator : NULL );          return static_cast<gig::Sample*>( (SamplesIterator != pSamples->end()) ? *SamplesIterator : NULL );
4291      }      }
4292        
4293        /**
4294         * Returns Sample object of @a index.
4295         *
4296         * @returns sample object or NULL if index is out of bounds
4297         */
4298        Sample* File::GetSample(uint index) {
4299            if (!pSamples) LoadSamples();
4300            if (!pSamples) return NULL;
4301            DLS::File::SampleList::iterator it = pSamples->begin();
4302            for (int i = 0; i < index; ++i) {
4303                ++it;
4304                if (it == pSamples->end()) return NULL;
4305            }
4306            if (it == pSamples->end()) return NULL;
4307            return static_cast<gig::Sample*>( *it );
4308        }
4309    
4310      /** @brief Add a new sample.      /** @brief Add a new sample.
4311       *       *
# Line 3562  MidiRuleCtrlTrigger::MidiRuleCtrlTrigger Line 4503  MidiRuleCtrlTrigger::MidiRuleCtrlTrigger
4503         pInstruments->push_back(pInstrument);         pInstruments->push_back(pInstrument);
4504         return pInstrument;         return pInstrument;
4505      }      }
4506        
4507        /** @brief Add a duplicate of an existing instrument.
4508         *
4509         * Duplicates the instrument definition given by @a orig and adds it
4510         * to this file. This allows in an instrument editor application to
4511         * easily create variations of an instrument, which will be stored in
4512         * the same .gig file, sharing i.e. the same samples.
4513         *
4514         * Note that all sample pointers referenced by @a orig are simply copied as
4515         * memory address. Thus the respective samples are shared, not duplicated!
4516         *
4517         * You have to call Save() to make this persistent to the file.
4518         *
4519         * @param orig - original instrument to be copied
4520         * @returns duplicated copy of the given instrument
4521         */
4522        Instrument* File::AddDuplicateInstrument(const Instrument* orig) {
4523            Instrument* instr = AddInstrument();
4524            instr->CopyAssign(orig);
4525            return instr;
4526        }
4527        
4528        /** @brief Add content of another existing file.
4529         *
4530         * Duplicates the samples, groups and instruments of the original file
4531         * given by @a pFile and adds them to @c this File. In case @c this File is
4532         * a new one that you haven't saved before, then you have to call
4533         * SetFileName() before calling AddContentOf(), because this method will
4534         * automatically save this file during operation, which is required for
4535         * writing the sample waveform data by disk streaming.
4536         *
4537         * @param pFile - original file whose's content shall be copied from
4538         */
4539        void File::AddContentOf(File* pFile) {
4540            static int iCallCount = -1;
4541            iCallCount++;
4542            std::map<Group*,Group*> mGroups;
4543            std::map<Sample*,Sample*> mSamples;
4544            
4545            // clone sample groups
4546            for (int i = 0; pFile->GetGroup(i); ++i) {
4547                Group* g = AddGroup();
4548                g->Name =
4549                    "COPY" + ToString(iCallCount) + "_" + pFile->GetGroup(i)->Name;
4550                mGroups[pFile->GetGroup(i)] = g;
4551            }
4552            
4553            // clone samples (not waveform data here yet)
4554            for (int i = 0; pFile->GetSample(i); ++i) {
4555                Sample* s = AddSample();
4556                s->CopyAssignMeta(pFile->GetSample(i));
4557                mGroups[pFile->GetSample(i)->GetGroup()]->AddSample(s);
4558                mSamples[pFile->GetSample(i)] = s;
4559            }
4560            
4561            //BUG: For some reason this method only works with this additional
4562            //     Save() call in between here.
4563            //
4564            // Important: The correct one of the 2 Save() methods has to be called
4565            // here, depending on whether the file is completely new or has been
4566            // saved to disk already, otherwise it will result in data corruption.
4567            if (pRIFF->IsNew())
4568                Save(GetFileName());
4569            else
4570                Save();
4571            
4572            // clone instruments
4573            // (passing the crosslink table here for the cloned samples)
4574            for (int i = 0; pFile->GetInstrument(i); ++i) {
4575                Instrument* instr = AddInstrument();
4576                instr->CopyAssign(pFile->GetInstrument(i), &mSamples);
4577            }
4578            
4579            // Mandatory: file needs to be saved to disk at this point, so this
4580            // file has the correct size and data layout for writing the samples'
4581            // waveform data to disk.
4582            Save();
4583            
4584            // clone samples' waveform data
4585            // (using direct read & write disk streaming)
4586            for (int i = 0; pFile->GetSample(i); ++i) {
4587                mSamples[pFile->GetSample(i)]->CopyAssignWave(pFile->GetSample(i));
4588            }
4589        }
4590    
4591      /** @brief Delete an instrument.      /** @brief Delete an instrument.
4592       *       *
# Line 3664  MidiRuleCtrlTrigger::MidiRuleCtrlTrigger Line 4689  MidiRuleCtrlTrigger::MidiRuleCtrlTrigger
4689          return NULL;          return NULL;
4690      }      }
4691    
4692        /**
4693         * Returns the group with the given group name.
4694         *
4695         * Note: group names don't have to be unique in the gig format! So there
4696         * can be multiple groups with the same name. This method will simply
4697         * return the first group found with the given name.
4698         *
4699         * @param name - name of the sought group
4700         * @returns sought group or NULL if there's no group with that name
4701         */
4702        Group* File::GetGroup(String name) {
4703            if (!pGroups) LoadGroups();
4704            GroupsIterator = pGroups->begin();
4705            for (uint i = 0; GroupsIterator != pGroups->end(); ++GroupsIterator, ++i)
4706                if ((*GroupsIterator)->Name == name) return *GroupsIterator;
4707            return NULL;
4708        }
4709    
4710      Group* File::AddGroup() {      Group* File::AddGroup() {
4711          if (!pGroups) LoadGroups();          if (!pGroups) LoadGroups();
4712          // there must always be at least one group          // there must always be at least one group
# Line 3774  MidiRuleCtrlTrigger::MidiRuleCtrlTrigger Line 4817  MidiRuleCtrlTrigger::MidiRuleCtrlTrigger
4817    
4818          // update group's chunks          // update group's chunks
4819          if (pGroups) {          if (pGroups) {
4820              std::list<Group*>::iterator iter = pGroups->begin();              // make sure '3gri' and '3gnl' list chunks exist
4821              std::list<Group*>::iterator end  = pGroups->end();              // (before updating the Group chunks)
4822              for (; iter != end; ++iter) {              RIFF::List* _3gri = pRIFF->GetSubList(LIST_TYPE_3GRI);
4823                  (*iter)->UpdateChunks();              if (!_3gri) {
4824                    _3gri = pRIFF->AddSubList(LIST_TYPE_3GRI);
4825                    pRIFF->MoveSubChunk(_3gri, pRIFF->GetSubChunk(CHUNK_ID_PTBL));
4826              }              }
4827                RIFF::List* _3gnl = _3gri->GetSubList(LIST_TYPE_3GNL);
4828                if (!_3gnl) _3gnl = _3gri->AddSubList(LIST_TYPE_3GNL);
4829    
4830              // v3: make sure the file has 128 3gnm chunks              // v3: make sure the file has 128 3gnm chunks
4831                // (before updating the Group chunks)
4832              if (pVersion && pVersion->major == 3) {              if (pVersion && pVersion->major == 3) {
                 RIFF::List* _3gnl = pRIFF->GetSubList(LIST_TYPE_3GRI)->GetSubList(LIST_TYPE_3GNL);  
4833                  RIFF::Chunk* _3gnm = _3gnl->GetFirstSubChunk();                  RIFF::Chunk* _3gnm = _3gnl->GetFirstSubChunk();
4834                  for (int i = 0 ; i < 128 ; i++) {                  for (int i = 0 ; i < 128 ; i++) {
4835                      if (i >= pGroups->size()) ::SaveString(CHUNK_ID_3GNM, _3gnm, _3gnl, "", "", true, 64);                      if (i >= pGroups->size()) ::SaveString(CHUNK_ID_3GNM, _3gnm, _3gnl, "", "", true, 64);
4836                      if (_3gnm) _3gnm = _3gnl->GetNextSubChunk();                      if (_3gnm) _3gnm = _3gnl->GetNextSubChunk();
4837                  }                  }
4838              }              }
4839    
4840                std::list<Group*>::iterator iter = pGroups->begin();
4841                std::list<Group*>::iterator end  = pGroups->end();
4842                for (; iter != end; ++iter) {
4843                    (*iter)->UpdateChunks();
4844                }
4845          }          }
4846    
4847          // update einf chunk          // update einf chunk
Legend:
Removed from v.1851  
changed lines
  Added in v.2547
  ViewVC Help
Powered by ViewVC