home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 January / macformat-020.iso / Shareware City / Developers / Synthesizer Source / Synthesizer Folder / ModulationOscControl.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-01  |  81.7 KB  |  2,112 lines  |  [TEXT/KAHL]
  1. /* ModulationOscControl.c */
  2. /*****************************************************************************/
  3. /*                                                                           */
  4. /*    Synthesizer:  Digital Music Synthesis on General Purpose Computers     */
  5. /*    Copyright (C) 1994  Thomas R. Lawrence                                 */
  6. /*                                                                           */
  7. /*    This program is free software; you can redistribute it and/or modify   */
  8. /*    it under the terms of the GNU General Public License as published by   */
  9. /*    the Free Software Foundation; either version 2 of the License, or      */
  10. /*    (at your option) any later version.                                    */
  11. /*                                                                           */
  12. /*    This program is distributed in the hope that it will be useful,        */
  13. /*    but WITHOUT ANY WARRANTY; without even the implied warranty of         */
  14. /*    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the          */
  15. /*    GNU General Public License for more details.                           */
  16. /*                                                                           */
  17. /*    You should have received a copy of the GNU General Public License      */
  18. /*    along with this program; if not, write to the Free Software            */
  19. /*    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.              */
  20. /*                                                                           */
  21. /*    Thomas R. Lawrence can be reached at tomlaw@world.std.com.             */
  22. /*                                                                           */
  23. /*****************************************************************************/
  24.  
  25. #include "MiscInfo.h"
  26. #include "Audit.h"
  27. #include "Debug.h"
  28. #include "Definitions.h"
  29.  
  30. #include "ModulationOscControl.h"
  31. #include "ModulationSpecifier.h"
  32. #include "WaveTableOscControl.h"
  33. #include "SampleOscControl.h"
  34. #include "FastModulation.h"
  35. #include "OscillatorSpecifier.h"
  36. #include "Array.h"
  37. #include "Memory.h"
  38. #include "LFOListSpecifier.h"
  39. #include "LFOGenerator.h"
  40. #include "EnvelopeState.h"
  41. #include "Envelope.h"
  42. #include "ErrorDaemon.h"
  43.  
  44.  
  45. typedef struct
  46.     {
  47.         OscillatorTypes                        OscillatorType;
  48.         union
  49.             {
  50.                 WaveTableTemplateRec*            WaveTableTemplate;
  51.                 SampleTemplateRec*                SampleTemplate;
  52.             } u;
  53.     } TemplateElemRec;
  54.  
  55.  
  56. struct ModOscTemplateRec
  57.     {
  58.         long                                            NumberOfOscillators;
  59.  
  60.         /* this is an array of records, NumberOfOscillators elements long */
  61.         TemplateElemRec*                    TemplateArray;
  62.  
  63.         /* this is an array of integers, one for each template */
  64.         long*                                            PhaseGenNumElements;
  65.         /* these are arrays of arrays.  there is one array for each template, and */
  66.         /* that array has PhaseGenNumElements[i] elements in it */
  67.         ModulationTypes**                    PhaseGenModulateHow;
  68.         long**                                        PhaseGenIndirectionTable;
  69.         EnvelopeRec***                        PhaseGenScalingFactorEnvelope;
  70.         LFOListSpecRec***                    PhaseGenScalingFactorLFOList;
  71.         EnvelopeRec***                        PhaseGenOriginAdjustEnvelope;
  72.         LFOListSpecRec***                    PhaseGenOriginAdjustLFOList;
  73.  
  74.         /* this is an array of integers, one for each template */
  75.         long*                                            OutputNumElements;
  76.         /* these are arrays of arrays.  there is one array for each template, and */
  77.         /* that array has OutputNumElements[i] elements in it */
  78.         ModulationTypes**                    OutputModulateHow;
  79.         long**                                        OutputIndirectionTable;
  80.         EnvelopeRec***                        OutputScalingFactorEnvelope;
  81.         LFOListSpecRec***                    OutputScalingFactorLFOList;
  82.         EnvelopeRec***                        OutputOriginAdjustEnvelope;
  83.         LFOListSpecRec***                    OutputOriginAdjustLFOList;
  84.  
  85.         /* this flag indicates whether we are doing stereo playback or not */
  86.         MyBoolean                                    StereoPlayback;
  87.  
  88.         /* envelope update rate */
  89.         float                                            TicksPerSecond;
  90.  
  91.         /* list link */
  92.         ModOscTemplateRec*                Next;
  93.     };
  94.  
  95.  
  96. typedef struct
  97.     {
  98.         OscillatorTypes                        OscillatorType;
  99.         union
  100.             {
  101.                 WaveTableStateRec*                WaveTableState;
  102.                 SampleStateRec*                        SampleState;
  103.             } u;
  104.     } StateElemRec;
  105.  
  106.  
  107. struct ModOscStateRec
  108.     {
  109.         /* array of state objects, one for each oscillator (Template.NumberOfOscillators) */
  110.         StateElemRec*                            StateArray;
  111.  
  112.         /* this is an array of fast fixeds, one for each oscillator.  it remembers the */
  113.         /* previous output values of all oscillators for the purposes of feedback. */
  114.         float*                                        OldValues;
  115.  
  116.         /* this is like OldValues, except that the oscillator values from the current */
  117.         /* stage of execution are put in here.  this is to avoid changing the OldValues */
  118.         /* array while a synthesis step is in progress, so that modulation with feedback */
  119.         /* is order independent.  at the end of the cycle, this and OldValues are */
  120.         /* swapped.  (we don't want to allocate an array each cycle, so we keep this one */
  121.         /* around to save time.) */
  122.         float*                                        BuildOldValues;
  123.  
  124.         /* a copy of the template information.  do NOT dispose any of the pointers in it */
  125.         ModOscTemplateRec                    Template;
  126.  
  127.         /* workspace for each envelope iteration of phase gen modulation parameters */
  128.         float**                                        PhaseGenModulationScaling;
  129.         float**                                        PhaseGenModulationOrigin;
  130.         EvalEnvelopeRec***                PhaseGenScalingFactorEnvelope;
  131.         LFOGenRec***                            PhaseGenScalingFactorLFO;
  132.         EvalEnvelopeRec***                PhaseGenOriginAdjustEnvelope;
  133.         LFOGenRec***                            PhaseGenOriginAdjustLFO;
  134.  
  135.         /* workspace for each envelope iteration of output modulation parameters */
  136.         float**                                        OutputModulationScaling;
  137.         float**                                        OutputModulationOrigin;
  138.         EvalEnvelopeRec***                OutputScalingFactorEnvelope;
  139.         LFOGenRec***                            OutputScalingFactorLFO;
  140.         EvalEnvelopeRec***                OutputOriginAdjustEnvelope;
  141.         LFOGenRec***                            OutputOriginAdjustLFO;
  142.  
  143.         /* list thing */
  144.         ModOscStateRec*                        Next;
  145.     };
  146.  
  147.  
  148.  
  149.  
  150. static ModOscTemplateRec*                TemplateFreeList = NIL;
  151. static ModOscStateRec*                    StateFreeList = NIL;
  152.  
  153.  
  154. /* get rid of all cached memory for state or template records */
  155. void                                    FlushModOscControl(void)
  156.     {
  157.         while (TemplateFreeList != NIL)
  158.             {
  159.                 ModOscTemplateRec*    Temp;
  160.  
  161.                 Temp = TemplateFreeList;
  162.                 TemplateFreeList = TemplateFreeList->Next;
  163.                 ReleasePtr((char*)Temp);
  164.             }
  165.  
  166.         while (StateFreeList != NIL)
  167.             {
  168.                 ModOscStateRec*            Temp;
  169.  
  170.                 Temp = StateFreeList;
  171.                 StateFreeList = StateFreeList->Next;
  172.                 ReleasePtr((char*)Temp);
  173.             }
  174.     }
  175.  
  176.  
  177. #if DEBUG
  178. static void                        ValidateTemplate(ModOscTemplateRec* Template)
  179.     {
  180.         ModOscTemplateRec*    Scan;
  181.  
  182.         CheckPtrExistence(Template);
  183.         Scan = TemplateFreeList;
  184.         while (Scan != NIL)
  185.             {
  186.                 if (Scan == Template)
  187.                     {
  188.                         PRERR(ForceAbort,"ValidateTemplate:  template is on free list");
  189.                     }
  190.                 Scan = Scan->Next;
  191.             }
  192.     }
  193. #else
  194. #define ValidateTemplate(x) ((void)0)
  195. #endif
  196.  
  197.  
  198. #if DEBUG
  199. static void                        ValidateState(ModOscStateRec* State)
  200.     {
  201.         ModOscStateRec*            Scan;
  202.  
  203.         CheckPtrExistence(State);
  204.         Scan = StateFreeList;
  205.         while (Scan != NIL)
  206.             {
  207.                 if (Scan == State)
  208.                     {
  209.                         PRERR(ForceAbort,"ValidateState:  state is on free list");
  210.                     }
  211.                 Scan = Scan->Next;
  212.             }
  213.     }
  214. #else
  215. #define ValidateState(x) ((void)0)
  216. #endif
  217.  
  218.  
  219. /* perform one envelope update cycle */
  220. void                                    UpdateModOscEnvelopes(ModOscStateRec* State)
  221.     {
  222.         long                                Scan;
  223.  
  224.         CheckPtrExistence(State);
  225.         ValidateState(State);
  226.  
  227.         for (Scan = 0; Scan < State->Template.NumberOfOscillators; Scan += 1)
  228.             {
  229.                 long                                Index;
  230.  
  231.                 PRNGCHK(State->StateArray,&(State->StateArray[Scan]),
  232.                     sizeof(State->StateArray[Scan]));
  233.                 ERROR((State->StateArray[Scan].OscillatorType != eOscillatorSampled)
  234.                     && (State->StateArray[Scan].OscillatorType != eOscillatorWaveTable),
  235.                     PRERR(ForceAbort,"UpdateModOscEnvelopes:  bad oscillator type"));
  236.                 if (State->StateArray[Scan].OscillatorType == eOscillatorSampled)
  237.                     {
  238.                         UpdateSampleEnvelopes(State->StateArray[Scan].u.SampleState);
  239.                     }
  240.                  else
  241.                     {
  242.                         UpdateWaveTableEnvelopes(State->StateArray[Scan].u.WaveTableState);
  243.                     }
  244.                 for (Index = 0; Index < State->Template.PhaseGenNumElements[Scan]; Index += 1)
  245.                     {
  246.                         PRNGCHK(State->PhaseGenModulationScaling,
  247.                             &(State->PhaseGenModulationScaling[Scan]),
  248.                             sizeof(State->PhaseGenModulationScaling[Scan]));
  249.                         PRNGCHK(State->PhaseGenModulationScaling[Scan],
  250.                             &(State->PhaseGenModulationScaling[Scan][Index]),
  251.                             sizeof(State->PhaseGenModulationScaling[Scan][Index]));
  252.                         PRNGCHK(State->PhaseGenScalingFactorLFO,
  253.                             &(State->PhaseGenScalingFactorLFO[Scan]),
  254.                             sizeof(State->PhaseGenScalingFactorLFO[Scan]));
  255.                         PRNGCHK(State->PhaseGenScalingFactorLFO[Scan],
  256.                             &(State->PhaseGenScalingFactorLFO[Scan][Index]),
  257.                             sizeof(State->PhaseGenScalingFactorLFO[Scan][Index]));
  258.                         PRNGCHK(State->PhaseGenScalingFactorEnvelope,
  259.                             &(State->PhaseGenScalingFactorEnvelope[Scan]),
  260.                             sizeof(State->PhaseGenScalingFactorEnvelope[Scan]));
  261.                         PRNGCHK(State->PhaseGenScalingFactorEnvelope[Scan],
  262.                             &(State->PhaseGenScalingFactorEnvelope[Scan][Index]),
  263.                             sizeof(State->PhaseGenScalingFactorEnvelope[Scan][Index]));
  264.                         State->PhaseGenModulationScaling[Scan][Index]
  265.                             = FastFixed2Float(LFOGenUpdateCycle(
  266.                                 State->PhaseGenScalingFactorLFO[Scan][Index],
  267.                                 EnvelopeUpdate(State->PhaseGenScalingFactorEnvelope[Scan][Index])));
  268.                         PRNGCHK(State->PhaseGenModulationOrigin,
  269.                             &(State->PhaseGenModulationOrigin[Scan]),
  270.                             sizeof(State->PhaseGenModulationOrigin[Scan]));
  271.                         PRNGCHK(State->PhaseGenModulationOrigin[Scan],
  272.                             &(State->PhaseGenModulationOrigin[Scan][Index]),
  273.                             sizeof(State->PhaseGenModulationOrigin[Scan][Index]));
  274.                         PRNGCHK(State->PhaseGenOriginAdjustLFO,
  275.                             &(State->PhaseGenOriginAdjustLFO[Scan]),
  276.                             sizeof(State->PhaseGenOriginAdjustLFO[Scan]));
  277.                         PRNGCHK(State->PhaseGenOriginAdjustLFO[Scan],
  278.                             &(State->PhaseGenOriginAdjustLFO[Scan][Index]),
  279.                             sizeof(State->PhaseGenOriginAdjustLFO[Scan][Index]));
  280.                         PRNGCHK(State->PhaseGenOriginAdjustEnvelope,
  281.                             &(State->PhaseGenOriginAdjustEnvelope[Scan]),
  282.                             sizeof(State->PhaseGenOriginAdjustEnvelope[Scan]));
  283.                         PRNGCHK(State->PhaseGenOriginAdjustEnvelope[Scan],
  284.                             &(State->PhaseGenOriginAdjustEnvelope[Scan][Index]),
  285.                             sizeof(State->PhaseGenOriginAdjustEnvelope[Scan][Index]));
  286.                         State->PhaseGenModulationOrigin[Scan][Index]
  287.                             = FastFixed2Float(LFOGenUpdateCycle(
  288.                                 State->PhaseGenOriginAdjustLFO[Scan][Index],
  289.                                 EnvelopeUpdate(State->PhaseGenOriginAdjustEnvelope[Scan][Index])));
  290.                     }
  291.                 for (Index = 0; Index < State->Template.OutputNumElements[Scan]; Index += 1)
  292.                     {
  293.                         PRNGCHK(State->OutputModulationScaling,
  294.                             &(State->OutputModulationScaling[Scan]),
  295.                             sizeof(State->OutputModulationScaling[Scan]));
  296.                         PRNGCHK(State->OutputModulationScaling[Scan],
  297.                             &(State->OutputModulationScaling[Scan][Index]),
  298.                             sizeof(State->OutputModulationScaling[Scan][Index]));
  299.                         PRNGCHK(State->OutputScalingFactorLFO,
  300.                             &(State->OutputScalingFactorLFO[Scan]),
  301.                             sizeof(State->OutputScalingFactorLFO[Scan]));
  302.                         PRNGCHK(State->OutputScalingFactorLFO[Scan],
  303.                             &(State->OutputScalingFactorLFO[Scan][Index]),
  304.                             sizeof(State->OutputScalingFactorLFO[Scan][Index]));
  305.                         PRNGCHK(State->OutputScalingFactorEnvelope,
  306.                             &(State->OutputScalingFactorEnvelope[Scan]),
  307.                             sizeof(State->OutputScalingFactorEnvelope[Scan]));
  308.                         PRNGCHK(State->OutputScalingFactorEnvelope[Scan],
  309.                             &(State->OutputScalingFactorEnvelope[Scan][Index]),
  310.                             sizeof(State->OutputScalingFactorEnvelope[Scan][Index]));
  311.                         State->OutputModulationScaling[Scan][Index]
  312.                             = FastFixed2Float(LFOGenUpdateCycle(
  313.                                 State->OutputScalingFactorLFO[Scan][Index],
  314.                                 EnvelopeUpdate(State->OutputScalingFactorEnvelope[Scan][Index])));
  315.                         PRNGCHK(State->OutputModulationOrigin,
  316.                             &(State->OutputModulationOrigin[Scan]),
  317.                             sizeof(State->OutputModulationOrigin[Scan]));
  318.                         PRNGCHK(State->OutputModulationOrigin[Scan],
  319.                             &(State->OutputModulationOrigin[Scan][Index]),
  320.                             sizeof(State->OutputModulationOrigin[Scan][Index]));
  321.                         PRNGCHK(State->OutputOriginAdjustLFO,
  322.                             &(State->OutputOriginAdjustLFO[Scan]),
  323.                             sizeof(State->OutputOriginAdjustLFO[Scan]));
  324.                         PRNGCHK(State->OutputOriginAdjustLFO[Scan],
  325.                             &(State->OutputOriginAdjustLFO[Scan][Index]),
  326.                             sizeof(State->OutputOriginAdjustLFO[Scan][Index]));
  327.                         PRNGCHK(State->OutputOriginAdjustEnvelope,
  328.                             &(State->OutputOriginAdjustEnvelope[Scan]),
  329.                             sizeof(State->OutputOriginAdjustEnvelope[Scan]));
  330.                         PRNGCHK(State->OutputOriginAdjustEnvelope[Scan],
  331.                             &(State->OutputOriginAdjustEnvelope[Scan][Index]),
  332.                             sizeof(State->OutputOriginAdjustEnvelope[Scan][Index]));
  333.                         State->OutputModulationOrigin[Scan][Index]
  334.                             = FastFixed2Float(LFOGenUpdateCycle(
  335.                                 State->OutputOriginAdjustLFO[Scan][Index],
  336.                                 EnvelopeUpdate(State->OutputOriginAdjustEnvelope[Scan][Index])));
  337.                     }
  338.             }
  339.     }
  340.  
  341.  
  342. /* dispose of the modulation oscillator state record */
  343. void                                    DisposeModOscState(ModOscStateRec* State)
  344.     {
  345.         long                                Scan;
  346.  
  347.         CheckPtrExistence(State);
  348.         ValidateState(State);
  349.  
  350.         for (Scan = 0; Scan < State->Template.NumberOfOscillators; Scan += 1)
  351.             {
  352.                 long                                Index;
  353.  
  354.                 PRNGCHK(State->StateArray,&(State->StateArray[Scan]),
  355.                     sizeof(State->StateArray[Scan]));
  356.                 ERROR((State->StateArray[Scan].OscillatorType != eOscillatorSampled)
  357.                     && (State->StateArray[Scan].OscillatorType != eOscillatorWaveTable),
  358.                     PRERR(ForceAbort,"DisposeModOscState:  bad oscillator type"));
  359.                 if (State->StateArray[Scan].OscillatorType == eOscillatorSampled)
  360.                     {
  361.                         DisposeSampleState(State->StateArray[Scan].u.SampleState);
  362.                     }
  363.                  else
  364.                     {
  365.                         DisposeWaveTableState(State->StateArray[Scan].u.WaveTableState);
  366.                     }
  367.                 for (Index = 0; Index < State->Template.PhaseGenNumElements[Scan]; Index += 1)
  368.                     {
  369.                         DisposeEnvelopeStateRecord(State->PhaseGenScalingFactorEnvelope[Scan][Index]);
  370.                         DisposeEnvelopeStateRecord(State->PhaseGenOriginAdjustEnvelope[Scan][Index]);
  371.                         DisposeLFOGenerator(State->PhaseGenScalingFactorLFO[Scan][Index]);
  372.                         DisposeLFOGenerator(State->PhaseGenOriginAdjustLFO[Scan][Index]);
  373.                     }
  374.                 for (Index = 0; Index < State->Template.OutputNumElements[Scan]; Index += 1)
  375.                     {
  376.                         DisposeEnvelopeStateRecord(State->OutputScalingFactorEnvelope[Scan][Index]);
  377.                         DisposeEnvelopeStateRecord(State->OutputOriginAdjustEnvelope[Scan][Index]);
  378.                         DisposeLFOGenerator(State->OutputScalingFactorLFO[Scan][Index]);
  379.                         DisposeLFOGenerator(State->OutputOriginAdjustLFO[Scan][Index]);
  380.                     }
  381.                 ReleasePtr((char*)State->PhaseGenModulationScaling[Scan]);
  382.                 ReleasePtr((char*)State->PhaseGenModulationOrigin[Scan]);
  383.                 ReleasePtr((char*)State->OutputModulationScaling[Scan]);
  384.                 ReleasePtr((char*)State->OutputModulationOrigin[Scan]);
  385.                 ReleasePtr((char*)State->PhaseGenScalingFactorEnvelope[Scan]);
  386.                 ReleasePtr((char*)State->PhaseGenScalingFactorLFO[Scan]);
  387.                 ReleasePtr((char*)State->PhaseGenOriginAdjustEnvelope[Scan]);
  388.                 ReleasePtr((char*)State->PhaseGenOriginAdjustLFO[Scan]);
  389.                 ReleasePtr((char*)State->OutputScalingFactorEnvelope[Scan]);
  390.                 ReleasePtr((char*)State->OutputScalingFactorLFO[Scan]);
  391.                 ReleasePtr((char*)State->OutputOriginAdjustEnvelope[Scan]);
  392.                 ReleasePtr((char*)State->OutputOriginAdjustLFO[Scan]);
  393.             }
  394.         ReleasePtr((char*)State->StateArray);
  395.         ReleasePtr((char*)State->PhaseGenModulationScaling);
  396.         ReleasePtr((char*)State->PhaseGenModulationOrigin);
  397.         ReleasePtr((char*)State->PhaseGenScalingFactorEnvelope);
  398.         ReleasePtr((char*)State->PhaseGenScalingFactorLFO);
  399.         ReleasePtr((char*)State->PhaseGenOriginAdjustEnvelope);
  400.         ReleasePtr((char*)State->PhaseGenOriginAdjustLFO);
  401.         ReleasePtr((char*)State->OutputModulationScaling);
  402.         ReleasePtr((char*)State->OutputModulationOrigin);
  403.         ReleasePtr((char*)State->OutputScalingFactorEnvelope);
  404.         ReleasePtr((char*)State->OutputScalingFactorLFO);
  405.         ReleasePtr((char*)State->OutputOriginAdjustEnvelope);
  406.         ReleasePtr((char*)State->OutputOriginAdjustLFO);
  407.  
  408.         ReleasePtr((char*)State->OldValues);
  409.         ReleasePtr((char*)State->BuildOldValues);
  410.  
  411.         State->Next = StateFreeList;
  412.         StateFreeList = State;
  413.     }
  414.  
  415.  
  416. /* dispose of the modulation oscillator information template */
  417. void                                    DisposeModOscTemplate(ModOscTemplateRec* Template)
  418.     {
  419.         long                                Scan;
  420.  
  421.         CheckPtrExistence(Template);
  422.         ValidateTemplate(Template);
  423.  
  424.         for (Scan = 0; Scan < Template->NumberOfOscillators; Scan += 1)
  425.             {
  426.                 PRNGCHK(Template->TemplateArray,&(Template->TemplateArray[Scan]),
  427.                     sizeof(Template->TemplateArray[Scan]));
  428.                 ERROR((Template->TemplateArray[Scan].OscillatorType != eOscillatorSampled)
  429.                     && (Template->TemplateArray[Scan].OscillatorType != eOscillatorWaveTable),
  430.                     PRERR(ForceAbort,"DisposeModOscTemplate:  bad oscillator type"));
  431.                 if (Template->TemplateArray[Scan].OscillatorType == eOscillatorSampled)
  432.                     {
  433.                         DisposeSampleTemplate(Template->TemplateArray[Scan].u.SampleTemplate);
  434.                     }
  435.                  else
  436.                     {
  437.                         DisposeWaveTableTemplate(Template->TemplateArray[Scan].u.WaveTableTemplate);
  438.                     }
  439.             }
  440.         ReleasePtr((char*)Template->TemplateArray);
  441.  
  442.         for (Scan = 0; Scan < Template->NumberOfOscillators; Scan += 1)
  443.             {
  444.                 PRNGCHK(Template->PhaseGenModulateHow,&(Template->PhaseGenModulateHow[Scan]),
  445.                     sizeof(Template->PhaseGenModulateHow[Scan]));
  446.                 ReleasePtr((char*)(Template->PhaseGenModulateHow[Scan]));
  447.                 PRNGCHK(Template->PhaseGenScalingFactorEnvelope,
  448.                     &(Template->PhaseGenScalingFactorEnvelope[Scan]),
  449.                     sizeof(Template->PhaseGenScalingFactorEnvelope[Scan]));
  450.                 ReleasePtr((char*)(Template->PhaseGenScalingFactorEnvelope[Scan]));
  451.                 PRNGCHK(Template->PhaseGenScalingFactorLFOList,
  452.                     &(Template->PhaseGenScalingFactorLFOList[Scan]),
  453.                     sizeof(Template->PhaseGenScalingFactorLFOList[Scan]));
  454.                 ReleasePtr((char*)(Template->PhaseGenScalingFactorLFOList[Scan]));
  455.                 PRNGCHK(Template->PhaseGenOriginAdjustEnvelope,
  456.                     &(Template->PhaseGenOriginAdjustEnvelope[Scan]),
  457.                     sizeof(Template->PhaseGenOriginAdjustEnvelope[Scan]));
  458.                 ReleasePtr((char*)(Template->PhaseGenOriginAdjustEnvelope[Scan]));
  459.                 PRNGCHK(Template->PhaseGenOriginAdjustLFOList,
  460.                     &(Template->PhaseGenOriginAdjustLFOList[Scan]),
  461.                     sizeof(Template->PhaseGenOriginAdjustLFOList[Scan]));
  462.                 ReleasePtr((char*)(Template->PhaseGenOriginAdjustLFOList[Scan]));
  463.                 PRNGCHK(Template->OutputModulateHow,&(Template->OutputModulateHow[Scan]),
  464.                     sizeof(Template->OutputModulateHow[Scan]));
  465.                 ReleasePtr((char*)(Template->OutputModulateHow[Scan]));
  466.                 PRNGCHK(Template->OutputScalingFactorEnvelope,&(Template->OutputScalingFactorEnvelope[
  467.                     Scan]),sizeof(Template->OutputScalingFactorEnvelope[Scan]));
  468.                 ReleasePtr((char*)(Template->OutputScalingFactorEnvelope[Scan]));
  469.                 PRNGCHK(Template->OutputScalingFactorLFOList,&(Template->OutputScalingFactorLFOList[
  470.                     Scan]),sizeof(Template->OutputScalingFactorLFOList[Scan]));
  471.                 ReleasePtr((char*)(Template->OutputScalingFactorLFOList[Scan]));
  472.                 PRNGCHK(Template->OutputOriginAdjustEnvelope,&(Template->OutputOriginAdjustEnvelope[
  473.                     Scan]),sizeof(Template->OutputOriginAdjustEnvelope[Scan]));
  474.                 ReleasePtr((char*)(Template->OutputOriginAdjustEnvelope[Scan]));
  475.                 PRNGCHK(Template->OutputOriginAdjustLFOList,&(Template->OutputOriginAdjustLFOList[
  476.                     Scan]),sizeof(Template->OutputOriginAdjustLFOList[Scan]));
  477.                 ReleasePtr((char*)(Template->OutputOriginAdjustLFOList[Scan]));
  478.                 PRNGCHK(Template->PhaseGenIndirectionTable,&(Template->PhaseGenIndirectionTable[
  479.                     Scan]),sizeof(Template->PhaseGenIndirectionTable[Scan]));
  480.                 ReleasePtr((char*)(Template->PhaseGenIndirectionTable[Scan]));
  481.                 PRNGCHK(Template->OutputIndirectionTable,&(Template->OutputIndirectionTable[
  482.                     Scan]),sizeof(Template->OutputIndirectionTable[Scan]));
  483.                 ReleasePtr((char*)(Template->OutputIndirectionTable[Scan]));
  484.             }
  485.         ReleasePtr((char*)(Template->PhaseGenModulateHow));
  486.         ReleasePtr((char*)(Template->PhaseGenScalingFactorEnvelope));
  487.         ReleasePtr((char*)(Template->PhaseGenScalingFactorLFOList));
  488.         ReleasePtr((char*)(Template->PhaseGenOriginAdjustEnvelope));
  489.         ReleasePtr((char*)(Template->PhaseGenOriginAdjustLFOList));
  490.         ReleasePtr((char*)(Template->OutputModulateHow));
  491.         ReleasePtr((char*)(Template->OutputScalingFactorEnvelope));
  492.         ReleasePtr((char*)(Template->OutputScalingFactorLFOList));
  493.         ReleasePtr((char*)(Template->OutputOriginAdjustEnvelope));
  494.         ReleasePtr((char*)(Template->OutputOriginAdjustLFOList));
  495.         ReleasePtr((char*)Template->PhaseGenNumElements);
  496.         ReleasePtr((char*)Template->OutputNumElements);
  497.         ReleasePtr((char*)Template->PhaseGenIndirectionTable);
  498.         ReleasePtr((char*)Template->OutputIndirectionTable);
  499.  
  500.         Template->Next = TemplateFreeList;
  501.         TemplateFreeList = Template;
  502.     }
  503.  
  504.  
  505. /* create a new modulation oscillator template */
  506. ModOscTemplateRec*        NewModOscTemplate(struct ArrayRec* OscillatorList,
  507.                                                 float EnvelopeTicksPerSecond, long SamplingRate,
  508.                                                 MyBoolean Stereo, MyBoolean TimeInterp, MyBoolean WaveInterp,
  509.                                                 ErrorDaemonRec* ErrorDaemon)
  510.     {
  511.         ModOscTemplateRec*    Template;
  512.         long                                Scan;
  513.         long                                Limit;
  514.  
  515.         CheckPtrExistence(ErrorDaemon);
  516.         CheckPtrExistence(OscillatorList);
  517.         ERROR(ArrayGetLength(OscillatorList) == 0,PRERR(ForceAbort,
  518.             "NewModOscTemplate:  oscillator list is empty"));
  519.  
  520.         if (TemplateFreeList != NIL)
  521.             {
  522.                 Template = TemplateFreeList;
  523.                 TemplateFreeList = TemplateFreeList->Next;
  524.             }
  525.          else
  526.             {
  527.                 Template = (ModOscTemplateRec*)AllocPtrCanFail(sizeof(ModOscTemplateRec),
  528.                     "ModOscTemplateRec");
  529.                 if (Template == NIL)
  530.                     {
  531.                         return NIL;
  532.                     }
  533.             }
  534.         EXECUTE(Template->Next = (ModOscTemplateRec*)0x81818181;)
  535.  
  536.         Template->NumberOfOscillators = ArrayGetLength(OscillatorList);
  537.  
  538.         Template->StereoPlayback = Stereo;
  539.         Template->TicksPerSecond = EnvelopeTicksPerSecond;
  540.  
  541.         Template->TemplateArray = (TemplateElemRec*)AllocPtrCanFail(sizeof(TemplateElemRec)
  542.             * Template->NumberOfOscillators,"TemplateElemRec[]");
  543.         if (Template->TemplateArray == NIL)
  544.             {
  545.              FailurePoint1:
  546.                 Template->Next = TemplateFreeList;
  547.                 TemplateFreeList = Template;
  548.                 return NIL;
  549.             }
  550.         Template->PhaseGenNumElements = (long*)AllocPtrCanFail(sizeof(long)
  551.             * Template->NumberOfOscillators,"PhaseGenNumElements[]");
  552.         if (Template->PhaseGenNumElements == NIL)
  553.             {
  554.              FailurePoint2:
  555.                 ReleasePtr((char*)Template->TemplateArray);
  556.                 goto FailurePoint1;
  557.             }
  558.         Template->PhaseGenModulateHow = (ModulationTypes**)AllocPtrCanFail(
  559.             sizeof(ModulationTypes*) * Template->NumberOfOscillators,
  560.             "PhaseGenModulateHow[][]");
  561.         if (Template->PhaseGenModulateHow == NIL)
  562.             {
  563.              FailurePoint3:
  564.                 ReleasePtr((char*)Template->PhaseGenNumElements);
  565.                 goto FailurePoint2;
  566.             }
  567.         Template->PhaseGenScalingFactorEnvelope = (EnvelopeRec***)AllocPtrCanFail(
  568.             sizeof(EnvelopeRec**) * Template->NumberOfOscillators,
  569.             "PhaseGenScalingFactorEnvelope[][]");
  570.         if (Template->PhaseGenScalingFactorEnvelope == NIL)
  571.             {
  572.              FailurePoint4:
  573.                 ReleasePtr((char*)Template->PhaseGenModulateHow);
  574.                 goto FailurePoint3;
  575.             }
  576.         Template->PhaseGenScalingFactorLFOList = (LFOListSpecRec***)AllocPtrCanFail(
  577.             sizeof(LFOListSpecRec**) * Template->NumberOfOscillators,
  578.             "PhaseGenScalingFactorLFOList[][]");
  579.         if (Template->PhaseGenScalingFactorLFOList == NIL)
  580.             {
  581.              FailurePoint5:
  582.                 ReleasePtr((char*)Template->PhaseGenScalingFactorEnvelope);
  583.                 goto FailurePoint4;
  584.             }
  585.         Template->PhaseGenOriginAdjustEnvelope = (EnvelopeRec***)AllocPtrCanFail(
  586.             sizeof(EnvelopeRec**) * Template->NumberOfOscillators,
  587.             "PhaseGenOriginAdjustEnvelope[][]");
  588.         if (Template->PhaseGenOriginAdjustEnvelope == NIL)
  589.             {
  590.              FailurePoint6:
  591.                 ReleasePtr((char*)Template->PhaseGenScalingFactorLFOList);
  592.                 goto FailurePoint5;
  593.             }
  594.         Template->PhaseGenOriginAdjustLFOList = (LFOListSpecRec***)AllocPtrCanFail(
  595.             sizeof(LFOListSpecRec**) * Template->NumberOfOscillators,
  596.             "PhaseGenOriginAdjustLFOList[][]");
  597.         if (Template->PhaseGenOriginAdjustLFOList == NIL)
  598.             {
  599.              FailurePoint7:
  600.                 ReleasePtr((char*)Template->PhaseGenOriginAdjustEnvelope);
  601.                 goto FailurePoint6;
  602.             }
  603.         Template->OutputNumElements = (long*)AllocPtrCanFail(sizeof(long)
  604.             * Template->NumberOfOscillators,"OutputNumElements[]");
  605.         if (Template->OutputNumElements == NIL)
  606.             {
  607.              FailurePoint8:
  608.                 ReleasePtr((char*)Template->PhaseGenOriginAdjustLFOList);
  609.                 goto FailurePoint7;
  610.             }
  611.         Template->OutputModulateHow = (ModulationTypes**)AllocPtrCanFail(
  612.             sizeof(ModulationTypes*) * Template->NumberOfOscillators,"OutputModulateHow[][]");
  613.         if (Template->OutputModulateHow == NIL)
  614.             {
  615.              FailurePoint9:
  616.                 ReleasePtr((char*)Template->OutputNumElements);
  617.                 goto FailurePoint8;
  618.             }
  619.         Template->OutputScalingFactorEnvelope = (EnvelopeRec***)AllocPtrCanFail(
  620.             sizeof(EnvelopeRec**) * Template->NumberOfOscillators,
  621.             "OutputScalingFactorEnvelope[][]");
  622.         if (Template->OutputScalingFactorEnvelope == NIL)
  623.             {
  624.              FailurePoint10:
  625.                 ReleasePtr((char*)Template->OutputModulateHow);
  626.                 goto FailurePoint9;
  627.             }
  628.         Template->OutputScalingFactorLFOList = (LFOListSpecRec***)AllocPtrCanFail(
  629.             sizeof(LFOListSpecRec**) * Template->NumberOfOscillators,
  630.             "OutputScalingFactorLFOList[][]");
  631.         if (Template->OutputScalingFactorLFOList == NIL)
  632.             {
  633.              FailurePoint11:
  634.                 ReleasePtr((char*)Template->OutputScalingFactorEnvelope);
  635.                 goto FailurePoint10;
  636.             }
  637.         Template->OutputOriginAdjustEnvelope = (EnvelopeRec***)AllocPtrCanFail(
  638.             sizeof(EnvelopeRec**) * Template->NumberOfOscillators,
  639.             "OutputOriginAdjustEnvelope[][]");
  640.         if (Template->OutputOriginAdjustEnvelope == NIL)
  641.             {
  642.              FailurePoint12:
  643.                 ReleasePtr((char*)Template->OutputScalingFactorLFOList);
  644.                 goto FailurePoint11;
  645.             }
  646.         Template->OutputOriginAdjustLFOList = (LFOListSpecRec***)AllocPtrCanFail(
  647.             sizeof(LFOListSpecRec**) * Template->NumberOfOscillators,
  648.             "OutputOriginAdjustLFOList[][]");
  649.         if (Template->OutputOriginAdjustLFOList == NIL)
  650.             {
  651.              FailurePoint13:
  652.                 ReleasePtr((char*)Template->OutputOriginAdjustEnvelope);
  653.                 goto FailurePoint12;
  654.             }
  655.         Template->PhaseGenIndirectionTable = (long**)AllocPtrCanFail(sizeof(long*)
  656.             * Template->NumberOfOscillators,"PhaseGenIndirectionTable[][]");
  657.         if (Template->PhaseGenIndirectionTable == NIL)
  658.             {
  659.              FailurePoint14:
  660.                 ReleasePtr((char*)Template->OutputOriginAdjustLFOList);
  661.                 goto FailurePoint13;
  662.             }
  663.         Template->OutputIndirectionTable = (long**)AllocPtrCanFail(sizeof(long*)
  664.             * Template->NumberOfOscillators,"OutputIndirectionTable[][]");
  665.         if (Template->OutputIndirectionTable == NIL)
  666.             {
  667.              FailurePoint15:
  668.                 ReleasePtr((char*)Template->PhaseGenIndirectionTable);
  669.                 goto FailurePoint14;
  670.             }
  671.  
  672.         Limit = ArrayGetLength(OscillatorList);
  673.         for (Scan = 0; Scan < Limit; Scan += 1)
  674.             {
  675.                 OscillatorRec*            Oscillator;
  676.                 ModulationSpecRec*    ModulationSourceList;
  677.                 long                                Count;
  678.                 long                                Index;
  679.                 long                                TotalNumModulators;
  680.  
  681.                 Oscillator = (OscillatorRec*)ArrayGetElement(OscillatorList,Scan);
  682.                 CheckPtrExistence(Oscillator);
  683.  
  684.                 switch (OscillatorGetWhatKindItIs(Oscillator))
  685.                     {
  686.                         default:
  687.                             EXECUTE(PRERR(ForceAbort,"NewModOscTemplate:  bad oscillator type"));
  688.                             break;
  689.                         case eOscillatorSampled:
  690.                             PRNGCHK(Template->TemplateArray,&(Template->TemplateArray[Scan]),
  691.                                 sizeof(Template->TemplateArray[Scan]));
  692.                             Template->TemplateArray[Scan].OscillatorType = eOscillatorSampled;
  693.                             Template->TemplateArray[Scan].u.SampleTemplate = NewSampleTemplate(
  694.                                 Oscillator,EnvelopeTicksPerSecond,SamplingRate,Stereo,TimeInterp,
  695.                                 WaveInterp,ErrorDaemon);
  696.                             if (Template->TemplateArray[Scan].u.SampleTemplate == NIL)
  697.                                 {
  698.                                  FailurePoint16a:
  699.                                     for (Index = 0; Index < Scan; Index += 1)
  700.                                         {
  701.                                             PRNGCHK(Template->TemplateArray,&(Template->TemplateArray[Index]),
  702.                                                 sizeof(Template->TemplateArray[Index]));
  703.                                             switch (Template->TemplateArray[Index].OscillatorType)
  704.                                                 {
  705.                                                     default:
  706.                                                         EXECUTE(PRERR(ForceAbort,"NewModOscTemplate:  bad oscillator type"));
  707.                                                         break;
  708.                                                     case eOscillatorSampled:
  709.                                                         DisposeSampleTemplate(Template->TemplateArray[Index]
  710.                                                             .u.SampleTemplate);
  711.                                                         break;
  712.                                                     case eOscillatorWaveTable:
  713.                                                         DisposeWaveTableTemplate(Template->TemplateArray[Index]
  714.                                                             .u.WaveTableTemplate);
  715.                                                         break;
  716.                                                 }
  717.                                             PRNGCHK(Template->PhaseGenModulateHow,
  718.                                                 &(Template->PhaseGenModulateHow[Index]),
  719.                                                 sizeof(Template->PhaseGenModulateHow[Index]));
  720.                                             ReleasePtr((char*)(Template->PhaseGenModulateHow[Index]));
  721.                                             PRNGCHK(Template->PhaseGenScalingFactorEnvelope,
  722.                                                 &(Template->PhaseGenScalingFactorEnvelope[Index]),
  723.                                                 sizeof(Template->PhaseGenScalingFactorEnvelope[Index]));
  724.                                             ReleasePtr((char*)(Template->PhaseGenScalingFactorEnvelope[Index]));
  725.                                             PRNGCHK(Template->PhaseGenScalingFactorLFOList,
  726.                                                 &(Template->PhaseGenScalingFactorLFOList[Index]),
  727.                                                 sizeof(Template->PhaseGenScalingFactorLFOList[Index]));
  728.                                             ReleasePtr((char*)(Template->PhaseGenScalingFactorLFOList[Index]));
  729.                                             PRNGCHK(Template->PhaseGenOriginAdjustEnvelope,
  730.                                                 &(Template->PhaseGenOriginAdjustEnvelope[Index]),
  731.                                                 sizeof(Template->PhaseGenOriginAdjustEnvelope[Index]));
  732.                                             ReleasePtr((char*)(Template->PhaseGenOriginAdjustEnvelope[Index]));
  733.                                             PRNGCHK(Template->PhaseGenOriginAdjustLFOList,
  734.                                                 &(Template->PhaseGenOriginAdjustLFOList[Index]),
  735.                                                 sizeof(Template->PhaseGenOriginAdjustLFOList[Index]));
  736.                                             ReleasePtr((char*)(Template->PhaseGenOriginAdjustLFOList[Index]));
  737.                                             PRNGCHK(Template->OutputModulateHow,
  738.                                                 &(Template->OutputModulateHow[Index]),
  739.                                                 sizeof(Template->OutputModulateHow[Index]));
  740.                                             ReleasePtr((char*)(Template->OutputModulateHow[Index]));
  741.                                             PRNGCHK(Template->OutputScalingFactorEnvelope,
  742.                                                 &(Template->OutputScalingFactorEnvelope[Index]),
  743.                                                 sizeof(Template->OutputScalingFactorEnvelope[Index]));
  744.                                             ReleasePtr((char*)(Template->OutputScalingFactorEnvelope[Index]));
  745.                                             PRNGCHK(Template->OutputScalingFactorLFOList,
  746.                                                 &(Template->OutputScalingFactorLFOList[Index]),
  747.                                                 sizeof(Template->OutputScalingFactorLFOList[Index]));
  748.                                             ReleasePtr((char*)(Template->OutputScalingFactorLFOList[Index]));
  749.                                             PRNGCHK(Template->OutputOriginAdjustEnvelope,
  750.                                                 &(Template->OutputOriginAdjustEnvelope[Index]),
  751.                                                 sizeof(Template->OutputOriginAdjustEnvelope[Index]));
  752.                                             ReleasePtr((char*)(Template->OutputOriginAdjustEnvelope[Index]));
  753.                                             PRNGCHK(Template->OutputOriginAdjustLFOList,
  754.                                                 &(Template->OutputOriginAdjustLFOList[Index]),
  755.                                                 sizeof(Template->OutputOriginAdjustLFOList[Index]));
  756.                                             ReleasePtr((char*)(Template->OutputOriginAdjustLFOList[Index]));
  757.                                         }
  758.                                     goto FailurePoint15;
  759.                                 }
  760.                             break;
  761.                         case eOscillatorWaveTable:
  762.                             PRNGCHK(Template->TemplateArray,&(Template->TemplateArray[Scan]),
  763.                                 sizeof(Template->TemplateArray[Scan]));
  764.                             Template->TemplateArray[Scan].OscillatorType = eOscillatorWaveTable;
  765.                             Template->TemplateArray[Scan].u.WaveTableTemplate = NewWaveTableTemplate(
  766.                                 Oscillator,EnvelopeTicksPerSecond,SamplingRate,Stereo,TimeInterp,
  767.                                 WaveInterp,ErrorDaemon);
  768.                             if (Template->TemplateArray[Scan].u.WaveTableTemplate == NIL)
  769.                                 {
  770.                                     goto FailurePoint16a;
  771.                                 }
  772.                             break;
  773.                     }
  774.  
  775.                 ModulationSourceList = OscillatorGetModulatorInputList(Oscillator);
  776.                 TotalNumModulators = GetModulationSpecNumEntries(ModulationSourceList);
  777.  
  778.                 /* count the number of phase generator modulators */
  779.                 Count = 0;
  780.                 for (Index = 0; Index < TotalNumModulators; Index += 1)
  781.                     {
  782.                         switch (GetModulationDestType(ModulationSourceList,Index))
  783.                             {
  784.                                 default:
  785.                                     EXECUTE(PRERR(ForceAbort,
  786.                                         "NewModOscTemplate:  bad modulation target type"));
  787.                                     break;
  788.                                 case eModulatePhaseGen:
  789.                                     Count += 1;
  790.                                     break;
  791.                                 case eModulateOutput:
  792.                                     break;
  793.                             }
  794.                     }
  795.                 PRNGCHK(Template->PhaseGenNumElements,&(Template->PhaseGenNumElements[Scan]),
  796.                     sizeof(Template->PhaseGenNumElements[Scan]));
  797.                 Template->PhaseGenNumElements[Scan] = Count;
  798.  
  799.                 PRNGCHK(Template->PhaseGenModulateHow,&(Template->PhaseGenModulateHow[Scan]),
  800.                     sizeof(Template->PhaseGenModulateHow[Scan]));
  801.                 Template->PhaseGenModulateHow[Scan] = (ModulationTypes*)AllocPtrCanFail(
  802.                     sizeof(ModulationTypes) * Count,"PhaseGenModulateHow[]");
  803.                 if (Template->PhaseGenModulateHow[Scan] == NIL)
  804.                     {
  805.                      FailurePoint16b:
  806.                         PRNGCHK(Template->TemplateArray,&(Template->TemplateArray[Scan]),
  807.                             sizeof(Template->TemplateArray[Scan]));
  808.                         switch (Template->TemplateArray[Scan].OscillatorType)
  809.                             {
  810.                                 default:
  811.                                     EXECUTE(PRERR(ForceAbort,"NewModOscTemplate:  bad oscillator type"));
  812.                                     break;
  813.                                 case eOscillatorSampled:
  814.                                     DisposeSampleTemplate(Template->TemplateArray[Scan].u.SampleTemplate);
  815.                                     break;
  816.                                 case eOscillatorWaveTable:
  817.                                     DisposeWaveTableTemplate(Template->TemplateArray[Scan].u.WaveTableTemplate);
  818.                                     break;
  819.                             }
  820.                         goto FailurePoint16a;
  821.                     }
  822.                 PRNGCHK(Template->PhaseGenScalingFactorEnvelope,
  823.                     &(Template->PhaseGenScalingFactorEnvelope[Scan]),
  824.                     sizeof(Template->PhaseGenScalingFactorEnvelope[Scan]));
  825.                 Template->PhaseGenScalingFactorEnvelope[Scan] = (EnvelopeRec**)AllocPtrCanFail(
  826.                     sizeof(EnvelopeRec*) * Count,"PhaseGenScalingFactorEnvelope[]");
  827.                 if (Template->PhaseGenScalingFactorEnvelope[Scan] == NIL)
  828.                     {
  829.                      FailurePoint16c:
  830.                         ReleasePtr((char*)(Template->PhaseGenModulateHow[Scan]));
  831.                         goto FailurePoint16b;
  832.                     }
  833.                 PRNGCHK(Template->PhaseGenScalingFactorLFOList,
  834.                     &(Template->PhaseGenScalingFactorLFOList[Scan]),
  835.                     sizeof(Template->PhaseGenScalingFactorLFOList[Scan]));
  836.                 Template->PhaseGenScalingFactorLFOList[Scan] = (LFOListSpecRec**)AllocPtrCanFail(
  837.                     sizeof(LFOListSpecRec*) * Count,"PhaseGenScalingFactorLFOList[]");
  838.                 if (Template->PhaseGenScalingFactorLFOList[Scan] == NIL)
  839.                     {
  840.                      FailurePoint16d:
  841.                         ReleasePtr((char*)(Template->PhaseGenScalingFactorEnvelope[Scan]));
  842.                         goto FailurePoint16c;
  843.                     }
  844.                 PRNGCHK(Template->PhaseGenOriginAdjustEnvelope,
  845.                     &(Template->PhaseGenOriginAdjustEnvelope[Scan]),
  846.                         sizeof(Template->PhaseGenOriginAdjustEnvelope[Scan]));
  847.                 Template->PhaseGenOriginAdjustEnvelope[Scan] = (EnvelopeRec**)AllocPtrCanFail(
  848.                     sizeof(EnvelopeRec*) * Count,"PhaseGenOriginAdjustEnvelope[]");
  849.                 if (Template->PhaseGenOriginAdjustEnvelope[Scan] == NIL)
  850.                     {
  851.                      FailurePoint16e:
  852.                         ReleasePtr((char*)(Template->PhaseGenScalingFactorLFOList[Scan]));
  853.                         goto FailurePoint16d;
  854.                     }
  855.                 PRNGCHK(Template->PhaseGenOriginAdjustLFOList,
  856.                     &(Template->PhaseGenOriginAdjustLFOList[Scan]),
  857.                         sizeof(Template->PhaseGenOriginAdjustLFOList[Scan]));
  858.                 Template->PhaseGenOriginAdjustLFOList[Scan] = (LFOListSpecRec**)AllocPtrCanFail(
  859.                     sizeof(LFOListSpecRec*) * Count,"PhaseGenOriginAdjustLFOList[]");
  860.                 if (Template->PhaseGenOriginAdjustLFOList[Scan] == NIL)
  861.                     {
  862.                      FailurePoint16f:
  863.                         ReleasePtr((char*)(Template->PhaseGenOriginAdjustEnvelope[Scan]));
  864.                         goto FailurePoint16e;
  865.                     }
  866.                 PRNGCHK(Template->PhaseGenIndirectionTable,
  867.                     &(Template->PhaseGenIndirectionTable[Scan]),
  868.                     sizeof(Template->PhaseGenIndirectionTable[Scan]));
  869.                 Template->PhaseGenIndirectionTable[Scan] = (long*)AllocPtrCanFail(
  870.                     sizeof(long) * Count,"PhaseGenIndirectionTable[]");
  871.                 if (Template->PhaseGenIndirectionTable[Scan] == NIL)
  872.                     {
  873.                      FailurePoint16g:
  874.                         ReleasePtr((char*)Template->PhaseGenOriginAdjustLFOList[Scan]);
  875.                         goto FailurePoint16f;
  876.                     }
  877.  
  878.                 /* build phase generator modulation structures */
  879.                 Count = 0;
  880.                 for (Index = 0; Index < TotalNumModulators; Index += 1)
  881.                     {
  882.                         long                                Position;
  883.  
  884.                         switch (GetModulationDestType(ModulationSourceList,Index))
  885.                             {
  886.                                 default:
  887.                                     EXECUTE(PRERR(ForceAbort,
  888.                                         "NewModOscTemplate:  bad modulation target type"));
  889.                                     break;
  890.                                 case eModulatePhaseGen:
  891.                                     PRNGCHK(Template->PhaseGenModulateHow,
  892.                                         &(Template->PhaseGenModulateHow[Scan]),
  893.                                         sizeof(Template->PhaseGenModulateHow[Scan]));
  894.                                     PRNGCHK(Template->PhaseGenModulateHow[Scan],
  895.                                         &(Template->PhaseGenModulateHow[Scan][Count]),
  896.                                         sizeof(Template->PhaseGenModulateHow[Scan][Count]));
  897.                                     Template->PhaseGenModulateHow[Scan][Count] = GetModulationOpType(
  898.                                         ModulationSourceList,Index);
  899.                                     PRNGCHK(Template->PhaseGenScalingFactorEnvelope,
  900.                                         &(Template->PhaseGenScalingFactorEnvelope[Scan]),
  901.                                         sizeof(Template->PhaseGenScalingFactorEnvelope[Scan]));
  902.                                     PRNGCHK(Template->PhaseGenScalingFactorEnvelope[Scan],
  903.                                         &(Template->PhaseGenScalingFactorEnvelope[Scan][Count]),
  904.                                         sizeof(Template->PhaseGenScalingFactorEnvelope[Scan][Count]));
  905.                                     Template->PhaseGenScalingFactorEnvelope[Scan][Count]
  906.                                         = GetModulationScalingFactorEnvelope(ModulationSourceList,Index);
  907.                                     PRNGCHK(Template->PhaseGenScalingFactorLFOList,
  908.                                         &(Template->PhaseGenScalingFactorLFOList[Scan]),
  909.                                         sizeof(Template->PhaseGenScalingFactorLFOList[Scan]));
  910.                                     PRNGCHK(Template->PhaseGenScalingFactorLFOList[Scan],
  911.                                         &(Template->PhaseGenScalingFactorLFOList[Scan][Count]),
  912.                                         sizeof(Template->PhaseGenScalingFactorLFOList[Scan][Count]));
  913.                                     Template->PhaseGenScalingFactorLFOList[Scan][Count]
  914.                                         = GetModulationScalingFactorLFOList(ModulationSourceList,Index);
  915.                                     PRNGCHK(Template->PhaseGenOriginAdjustEnvelope,
  916.                                         &(Template->PhaseGenOriginAdjustEnvelope[Scan]),
  917.                                         sizeof(Template->PhaseGenOriginAdjustEnvelope[Scan]));
  918.                                     PRNGCHK(Template->PhaseGenOriginAdjustEnvelope[Scan],
  919.                                         &(Template->PhaseGenOriginAdjustEnvelope[Scan][Count]),
  920.                                         sizeof(Template->PhaseGenOriginAdjustEnvelope[Scan][Count]));
  921.                                     Template->PhaseGenOriginAdjustEnvelope[Scan][Count]
  922.                                         = GetModulationOriginAdjustEnvelope(ModulationSourceList,Index);
  923.                                     PRNGCHK(Template->PhaseGenOriginAdjustLFOList,
  924.                                         &(Template->PhaseGenOriginAdjustLFOList[Scan]),
  925.                                         sizeof(Template->PhaseGenOriginAdjustLFOList[Scan]));
  926.                                     PRNGCHK(Template->PhaseGenOriginAdjustLFOList[Scan],
  927.                                         &(Template->PhaseGenOriginAdjustLFOList[Scan][Count]),
  928.                                         sizeof(Template->PhaseGenOriginAdjustLFOList[Scan][Count]));
  929.                                     Template->PhaseGenOriginAdjustLFOList[Scan][Count]
  930.                                         = GetModulationOriginAdjustLFOList(ModulationSourceList,Index);
  931.                                     Position = ArrayFindElement(OscillatorList,
  932.                                         GetModulationOscillatorRef(ModulationSourceList,Index));
  933.                                     ERROR(Position == -1,PRERR(ForceAbort,
  934.                                         "NewModOscTemplate:  reference to oscillator not in list"));
  935.                                     PRNGCHK(Template->PhaseGenIndirectionTable,
  936.                                         &(Template->PhaseGenIndirectionTable[Scan]),
  937.                                         sizeof(Template->PhaseGenIndirectionTable[Scan]));
  938.                                     PRNGCHK(Template->PhaseGenIndirectionTable[Scan],
  939.                                         &(Template->PhaseGenIndirectionTable[Scan][Count]),
  940.                                         sizeof(Template->PhaseGenIndirectionTable[Scan][Count]));
  941.                                     Template->PhaseGenIndirectionTable[Scan][Count] = Position;
  942.                                     Count += 1;
  943.                                     break;
  944.                                 case eModulateOutput:
  945.                                     break;
  946.                             }
  947.                     }
  948.  
  949.                 /* count the number of output modulators */
  950.                 Count = 0;
  951.                 for (Index = 0; Index < TotalNumModulators; Index += 1)
  952.                     {
  953.                         switch (GetModulationDestType(ModulationSourceList,Index))
  954.                             {
  955.                                 default:
  956.                                     EXECUTE(PRERR(ForceAbort,
  957.                                         "NewModOscTemplate:  bad modulation target type"));
  958.                                     break;
  959.                                 case eModulatePhaseGen:
  960.                                     break;
  961.                                 case eModulateOutput:
  962.                                     Count += 1;
  963.                                     break;
  964.                             }
  965.                     }
  966.                 PRNGCHK(Template->OutputNumElements,&(Template->OutputNumElements[Scan]),
  967.                     sizeof(Template->OutputNumElements[Scan]));
  968.                 Template->OutputNumElements[Scan] = Count;
  969.  
  970.                 PRNGCHK(Template->OutputModulateHow,&(Template->OutputModulateHow[Scan]),
  971.                     sizeof(Template->OutputModulateHow[Scan]));
  972.                 Template->OutputModulateHow[Scan] = (ModulationTypes*)AllocPtrCanFail(
  973.                     sizeof(ModulationTypes) * Count,"OutputModulateHow[]");
  974.                 if (Template->OutputModulateHow[Scan] == NIL)
  975.                     {
  976.                      FailurePoint16h:
  977.                         ReleasePtr((char*)(Template->PhaseGenIndirectionTable[Scan]));
  978.                         goto FailurePoint16g;
  979.                     }
  980.                 PRNGCHK(Template->OutputScalingFactorEnvelope,
  981.                     &(Template->OutputScalingFactorEnvelope[Scan]),
  982.                     sizeof(Template->OutputScalingFactorEnvelope[Scan]));
  983.                 Template->OutputScalingFactorEnvelope[Scan] = (EnvelopeRec**)AllocPtrCanFail(
  984.                     sizeof(EnvelopeRec*) * Count,"OutputScalingFactorEnvelope[]");
  985.                 if (Template->OutputScalingFactorEnvelope[Scan] == NIL)
  986.                     {
  987.                      FailurePoint16i:
  988.                         ReleasePtr((char*)(Template->OutputModulateHow[Scan]));
  989.                         goto FailurePoint16h;
  990.                     }
  991.                 PRNGCHK(Template->OutputScalingFactorLFOList,
  992.                     &(Template->OutputScalingFactorLFOList[Scan]),
  993.                     sizeof(Template->OutputScalingFactorLFOList[Scan]));
  994.                 Template->OutputScalingFactorLFOList[Scan] = (LFOListSpecRec**)AllocPtrCanFail(
  995.                     sizeof(LFOListSpecRec*) * Count,"OutputScalingFactorLFOList[]");
  996.                 if (Template->OutputScalingFactorLFOList[Scan] == NIL)
  997.                     {
  998.                      FailurePoint16j:
  999.                         ReleasePtr((char*)(Template->OutputScalingFactorEnvelope[Scan]));
  1000.                         goto FailurePoint16i;
  1001.                     }
  1002.                 PRNGCHK(Template->OutputOriginAdjustEnvelope,
  1003.                     &(Template->OutputOriginAdjustEnvelope[Scan]),
  1004.                     sizeof(Template->OutputOriginAdjustEnvelope[Scan]));
  1005.                 Template->OutputOriginAdjustEnvelope[Scan] = (EnvelopeRec**)AllocPtrCanFail(
  1006.                     sizeof(EnvelopeRec*) * Count,"OutputOriginAdjustEnvelope[]");
  1007.                 if (Template->OutputOriginAdjustEnvelope[Scan] == NIL)
  1008.                     {
  1009.                      FailurePoint16k:
  1010.                         ReleasePtr((char*)(Template->OutputScalingFactorLFOList[Scan]));
  1011.                         goto FailurePoint16j;
  1012.                     }
  1013.                 PRNGCHK(Template->OutputOriginAdjustLFOList,
  1014.                     &(Template->OutputOriginAdjustLFOList[Scan]),
  1015.                     sizeof(Template->OutputOriginAdjustLFOList[Scan]));
  1016.                 Template->OutputOriginAdjustLFOList[Scan] = (LFOListSpecRec**)AllocPtrCanFail(
  1017.                     sizeof(LFOListSpecRec*) * Count,"OutputOriginAdjustLFOList[]");
  1018.                 if (Template->OutputOriginAdjustLFOList[Scan] == NIL)
  1019.                     {
  1020.                      FailurePoint16l:
  1021.                         ReleasePtr((char*)(Template->OutputOriginAdjustEnvelope[Scan]));
  1022.                         goto FailurePoint16k;
  1023.                     }
  1024.  
  1025.                 PRNGCHK(Template->OutputIndirectionTable,
  1026.                     &(Template->OutputIndirectionTable[Scan]),
  1027.                     sizeof(Template->OutputIndirectionTable[Scan]));
  1028.                 Template->OutputIndirectionTable[Scan] = (long*)AllocPtrCanFail(
  1029.                     sizeof(long) * Count,"OutputIndirectionTable[]");
  1030.                 if (Template->OutputIndirectionTable[Scan] == NIL)
  1031.                     {
  1032.                      FailurePoint16m:
  1033.                         ReleasePtr((char*)(Template->OutputOriginAdjustLFOList[Scan]));
  1034.                         goto FailurePoint16l;
  1035.                     }
  1036.  
  1037.                 /* build output modulation structures */
  1038.                 Count = 0;
  1039.                 for (Index = 0; Index < TotalNumModulators; Index += 1)
  1040.                     {
  1041.                         long                                Position;
  1042.  
  1043.                         switch (GetModulationDestType(ModulationSourceList,Index))
  1044.                             {
  1045.                                 default:
  1046.                                     EXECUTE(PRERR(ForceAbort,
  1047.                                         "NewModOscTemplate:  bad modulation target type"));
  1048.                                     break;
  1049.                                 case eModulatePhaseGen:
  1050.                                     break;
  1051.                                 case eModulateOutput:
  1052.                                     PRNGCHK(Template->OutputModulateHow,
  1053.                                         &(Template->OutputModulateHow[Scan]),
  1054.                                         sizeof(Template->OutputModulateHow[Scan]));
  1055.                                     PRNGCHK(Template->OutputModulateHow[Scan],
  1056.                                         &(Template->OutputModulateHow[Scan][Count]),
  1057.                                         sizeof(Template->OutputModulateHow[Scan][Count]));
  1058.                                     Template->OutputModulateHow[Scan][Count] = GetModulationOpType(
  1059.                                         ModulationSourceList,Index);
  1060.                                     PRNGCHK(Template->OutputScalingFactorEnvelope,
  1061.                                         &(Template->OutputScalingFactorEnvelope[Scan]),
  1062.                                         sizeof(Template->OutputScalingFactorEnvelope[Scan]));
  1063.                                     PRNGCHK(Template->OutputScalingFactorEnvelope[Scan],
  1064.                                         &(Template->OutputScalingFactorEnvelope[Scan][Count]),
  1065.                                         sizeof(Template->OutputScalingFactorEnvelope[Scan][Count]));
  1066.                                     Template->OutputScalingFactorEnvelope[Scan][Count]
  1067.                                         = GetModulationScalingFactorEnvelope(ModulationSourceList,Index);
  1068.                                     PRNGCHK(Template->OutputScalingFactorLFOList,
  1069.                                         &(Template->OutputScalingFactorLFOList[Scan]),
  1070.                                         sizeof(Template->OutputScalingFactorLFOList[Scan]));
  1071.                                     PRNGCHK(Template->OutputScalingFactorLFOList[Scan],
  1072.                                         &(Template->OutputScalingFactorLFOList[Scan][Count]),
  1073.                                         sizeof(Template->OutputScalingFactorLFOList[Scan][Count]));
  1074.                                     Template->OutputScalingFactorLFOList[Scan][Count]
  1075.                                         = GetModulationScalingFactorLFOList(ModulationSourceList,Index);
  1076.                                     PRNGCHK(Template->OutputOriginAdjustEnvelope,
  1077.                                         &(Template->OutputOriginAdjustEnvelope[Scan]),
  1078.                                         sizeof(Template->OutputOriginAdjustEnvelope[Scan]));
  1079.                                     PRNGCHK(Template->OutputOriginAdjustEnvelope[Scan],
  1080.                                         &(Template->OutputOriginAdjustEnvelope[Scan][Count]),
  1081.                                         sizeof(Template->OutputOriginAdjustEnvelope[Scan][Count]));
  1082.                                     Template->OutputOriginAdjustEnvelope[Scan][Count]
  1083.                                         = GetModulationOriginAdjustEnvelope(ModulationSourceList,Index);
  1084.                                     PRNGCHK(Template->OutputOriginAdjustLFOList,
  1085.                                         &(Template->OutputOriginAdjustLFOList[Scan]),
  1086.                                         sizeof(Template->OutputOriginAdjustLFOList[Scan]));
  1087.                                     PRNGCHK(Template->OutputOriginAdjustLFOList[Scan],
  1088.                                         &(Template->OutputOriginAdjustLFOList[Scan][Count]),
  1089.                                         sizeof(Template->OutputOriginAdjustLFOList[Scan][Count]));
  1090.                                     Template->OutputOriginAdjustLFOList[Scan][Count]
  1091.                                         = GetModulationOriginAdjustLFOList(ModulationSourceList,Index);
  1092.                                     Position = ArrayFindElement(OscillatorList,
  1093.                                         GetModulationOscillatorRef(ModulationSourceList,Index));
  1094.                                     ERROR(Position == -1,PRERR(ForceAbort,
  1095.                                         "NewModOscTemplate:  reference to oscillator not in list"));
  1096.                                     PRNGCHK(Template->OutputIndirectionTable,
  1097.                                         &(Template->OutputIndirectionTable[Scan]),
  1098.                                         sizeof(Template->OutputIndirectionTable[Scan]));
  1099.                                     PRNGCHK(Template->OutputIndirectionTable[Scan],
  1100.                                         &(Template->OutputIndirectionTable[Scan][Count]),
  1101.                                         sizeof(Template->OutputIndirectionTable[Scan][Count]));
  1102.                                     Template->OutputIndirectionTable[Scan][Count] = Position;
  1103.                                     Count += 1;
  1104.                                     break;
  1105.                             }
  1106.                     }
  1107.  
  1108.                 PRNGCHK(Template->OutputNumElements,&(Template->OutputNumElements[Scan]),
  1109.                     sizeof(Template->OutputNumElements[Scan]));
  1110.                 PRNGCHK(Template->PhaseGenNumElements,&(Template->PhaseGenNumElements[Scan]),
  1111.                     sizeof(Template->PhaseGenNumElements[Scan]));
  1112.                 ERROR(Template->OutputNumElements[Scan] + Template->PhaseGenNumElements[Scan]
  1113.                     != TotalNumModulators,PRERR(ForceAbort,
  1114.                     "NewModOscTemplate:  modulator count inconsistency"));
  1115.             }
  1116.  
  1117.         return Template;
  1118.     }
  1119.  
  1120.  
  1121. /* create a new modulation oscillator state object. */
  1122. ModOscStateRec*                NewModOscState(ModOscTemplateRec* Template,
  1123.                                                 float FreqForMultisampling, float Accent1, float Accent2,
  1124.                                                 float Accent3, float Accent4, float Loudness, float HurryUp,
  1125.                                                 long* PreOriginTimeOut, float StereoPosition,
  1126.                                                 float InitialFrequency, float LoudnessLFOAmplitudeScaling,
  1127.                                                 float LoudnessLFOFrequencyScaling, MyBoolean DoingModulation)
  1128.     {
  1129.         long                                Scan;
  1130.         ModOscStateRec*            State;
  1131.         long                                MaxOrigin;
  1132.  
  1133.         CheckPtrExistence(Template);
  1134.         ValidateTemplate(Template);
  1135.  
  1136.         if (StateFreeList != NIL)
  1137.             {
  1138.                 State = StateFreeList;
  1139.                 StateFreeList = StateFreeList->Next;
  1140.             }
  1141.          else
  1142.             {
  1143.                 State = (ModOscStateRec*)AllocPtrCanFail(sizeof(ModOscStateRec),"ModOscStateRec");
  1144.                 if (State == NIL)
  1145.                     {
  1146.                         return NIL;
  1147.                     }
  1148.             }
  1149.         EXECUTE(State->Next = (ModOscStateRec*)0x81818181;)
  1150.  
  1151.         State->StateArray = (StateElemRec*)AllocPtrCanFail(sizeof(StateElemRec)
  1152.             * Template->NumberOfOscillators,"StateArray");
  1153.         if (State->StateArray == NIL)
  1154.             {
  1155.              FailurePoint1:
  1156.                 State->Next = StateFreeList;
  1157.                 StateFreeList = State;
  1158.                 return NIL;
  1159.             }
  1160.         State->OldValues = (float*)AllocPtrCanFail(sizeof(float)
  1161.             * Template->NumberOfOscillators,"OldValues");
  1162.         if (State->OldValues == NIL)
  1163.             {
  1164.              FailurePoint2:
  1165.                 ReleasePtr((char*)State->StateArray);
  1166.                 goto FailurePoint1;
  1167.             }
  1168.         State->BuildOldValues = (float*)AllocPtrCanFail(sizeof(float)
  1169.             * Template->NumberOfOscillators,"BuildOldValues");
  1170.         if (State->BuildOldValues == NIL)
  1171.             {
  1172.              FailurePoint3:
  1173.                 ReleasePtr((char*)State->OldValues);
  1174.                 goto FailurePoint2;
  1175.             }
  1176.         State->PhaseGenModulationScaling = (float**)AllocPtrCanFail(sizeof(float*)
  1177.             * Template->NumberOfOscillators,"PhaseGenModulationScaling[]");
  1178.         if (State->PhaseGenModulationScaling == NIL)
  1179.             {
  1180.              FailurePoint4:
  1181.                 ReleasePtr((char*)State->BuildOldValues);
  1182.                 goto FailurePoint3;
  1183.             }
  1184.         State->PhaseGenModulationOrigin = (float**)AllocPtrCanFail(sizeof(float*)
  1185.             * Template->NumberOfOscillators,"PhaseGenModulationOrigin[]");
  1186.         if (State->PhaseGenModulationOrigin == NIL)
  1187.             {
  1188.              FailurePoint5:
  1189.                 ReleasePtr((char*)State->PhaseGenModulationScaling);
  1190.                 goto FailurePoint4;
  1191.             }
  1192.         State->PhaseGenScalingFactorEnvelope = (EvalEnvelopeRec***)AllocPtrCanFail(
  1193.             sizeof(EvalEnvelopeRec**) * Template->NumberOfOscillators,
  1194.             "PhaseGenScalingFactorEnvelope[]");
  1195.         if (State->PhaseGenScalingFactorEnvelope == NIL)
  1196.             {
  1197.              FailurePoint6:
  1198.                 ReleasePtr((char*)State->PhaseGenModulationOrigin);
  1199.                 goto FailurePoint5;
  1200.             }
  1201.         State->PhaseGenScalingFactorLFO = (LFOGenRec***)AllocPtrCanFail(
  1202.             sizeof(LFOGenRec**) * Template->NumberOfOscillators,"PhaseGenScalingFactorLFO[]");
  1203.         if (State->PhaseGenScalingFactorLFO == NIL)
  1204.             {
  1205.              FailurePoint7:
  1206.                 ReleasePtr((char*)State->PhaseGenScalingFactorEnvelope);
  1207.                 goto FailurePoint6;
  1208.             }
  1209.         State->PhaseGenOriginAdjustEnvelope = (EvalEnvelopeRec***)AllocPtrCanFail(
  1210.             sizeof(EvalEnvelopeRec**) * Template->NumberOfOscillators,
  1211.             "PhaseGenOriginAdjustEnvelope[]");
  1212.         if (State->PhaseGenOriginAdjustEnvelope == NIL)
  1213.             {
  1214.              FailurePoint8:
  1215.                 ReleasePtr((char*)State->PhaseGenScalingFactorLFO);
  1216.                 goto FailurePoint7;
  1217.             }
  1218.         State->PhaseGenOriginAdjustLFO = (LFOGenRec***)AllocPtrCanFail(
  1219.             sizeof(LFOGenRec**) * Template->NumberOfOscillators,"PhaseGenOriginAdjustLFO[]");
  1220.         if (State->PhaseGenOriginAdjustLFO == NIL)
  1221.             {
  1222.              FailurePoint9:
  1223.                 ReleasePtr((char*)State->PhaseGenOriginAdjustEnvelope);
  1224.                 goto FailurePoint8;
  1225.             }
  1226.         State->OutputModulationScaling = (float**)AllocPtrCanFail(sizeof(float*)
  1227.             * Template->NumberOfOscillators,"OutputModulationScaling[]");
  1228.         if (State->OutputModulationScaling == NIL)
  1229.             {
  1230.              FailurePoint10:
  1231.                 ReleasePtr((char*)State->PhaseGenOriginAdjustLFO);
  1232.                 goto FailurePoint9;
  1233.             }
  1234.         State->OutputModulationOrigin = (float**)AllocPtrCanFail(sizeof(float*)
  1235.             * Template->NumberOfOscillators,"OutputModulationOrigin[]");
  1236.         if (State->OutputModulationOrigin == NIL)
  1237.             {
  1238.              FailurePoint11:
  1239.                 ReleasePtr((char*)State->OutputModulationScaling);
  1240.                 goto FailurePoint10;
  1241.             }
  1242.         State->OutputScalingFactorEnvelope = (EvalEnvelopeRec***)AllocPtrCanFail(
  1243.             sizeof(EvalEnvelopeRec**) * Template->NumberOfOscillators,
  1244.             "OutputScalingFactorEnvelope[]");
  1245.         if (State->OutputScalingFactorEnvelope == NIL)
  1246.             {
  1247.              FailurePoint12:
  1248.                 ReleasePtr((char*)State->OutputModulationOrigin);
  1249.                 goto FailurePoint11;
  1250.             }
  1251.         State->OutputScalingFactorLFO = (LFOGenRec***)AllocPtrCanFail(sizeof(LFOGenRec**)
  1252.             * Template->NumberOfOscillators,"OutputScalingFactorLFO[]");
  1253.         if (State->OutputScalingFactorLFO == NIL)
  1254.             {
  1255.              FailurePoint13:
  1256.                 ReleasePtr((char*)State->OutputScalingFactorEnvelope);
  1257.                 goto FailurePoint12;
  1258.             }
  1259.         State->OutputOriginAdjustEnvelope = (EvalEnvelopeRec***)AllocPtrCanFail(
  1260.             sizeof(EvalEnvelopeRec**) * Template->NumberOfOscillators,
  1261.             "OutputOriginAdjustEnvelope[]");
  1262.         if (State->OutputOriginAdjustEnvelope == NIL)
  1263.             {
  1264.              FailurePoint14:
  1265.                 ReleasePtr((char*)State->OutputScalingFactorLFO);
  1266.                 goto FailurePoint13;
  1267.             }
  1268.         State->OutputOriginAdjustLFO = (LFOGenRec***)AllocPtrCanFail(sizeof(LFOGenRec**)
  1269.             * Template->NumberOfOscillators,"OutputOriginAdjustLFO[]");
  1270.         if (State->OutputOriginAdjustLFO == NIL)
  1271.             {
  1272.              FailurePoint15:
  1273.                 ReleasePtr((char*)State->OutputOriginAdjustEnvelope);
  1274.                 goto FailurePoint14;
  1275.             }
  1276.  
  1277.         MaxOrigin = 0;
  1278.         for (Scan = 0; Scan < Template->NumberOfOscillators; Scan += 1)
  1279.             {
  1280.                 long                                TempOrigin;
  1281.                 long                                Index;
  1282.  
  1283.                 PRNGCHK(State->StateArray,&(State->StateArray[Scan]),
  1284.                     sizeof(State->StateArray[Scan]));
  1285.                 PRNGCHK(Template->TemplateArray,&(Template->TemplateArray[Scan]),
  1286.                     sizeof(Template->TemplateArray[Scan]));
  1287.                 State->StateArray[Scan].OscillatorType
  1288.                     = Template->TemplateArray[Scan].OscillatorType;
  1289.                 switch (State->StateArray[Scan].OscillatorType)
  1290.                     {
  1291.                         default:
  1292.                             EXECUTE(PRERR(ForceAbort,"NewModOscState:  bad oscillator type"));
  1293.                             break;
  1294.                         case eOscillatorSampled:
  1295.                             State->StateArray[Scan].u.SampleState = NewSampleState(
  1296.                                 Template->TemplateArray[Scan].u.SampleTemplate,FreqForMultisampling,
  1297.                                 Accent1,Accent2,Accent3,Accent4,Loudness,HurryUp,&TempOrigin,
  1298.                                 StereoPosition,InitialFrequency,LoudnessLFOAmplitudeScaling,
  1299.                                 LoudnessLFOFrequencyScaling,True/*doing modulation*/);
  1300.                             if (State->StateArray[Scan].u.SampleState == NIL)
  1301.                                 {
  1302.                                  FailurePoint16a:
  1303.                                     for (Index = 0; Index < Scan; Index += 1)
  1304.                                         {
  1305.                                             long                                Dumper;
  1306.  
  1307.                                             switch (State->StateArray[Index].OscillatorType)
  1308.                                                 {
  1309.                                                     default:
  1310.                                                         EXECUTE(PRERR(ForceAbort,"NewModOscState:  bad oscillator type"));
  1311.                                                         break;
  1312.                                                     case eOscillatorSampled:
  1313.                                                         DisposeSampleState(State->StateArray[Index].u.SampleState);
  1314.                                                         break;
  1315.                                                     case eOscillatorWaveTable:
  1316.                                                         DisposeWaveTableState(State->StateArray[Index].u.WaveTableState);
  1317.                                                         break;
  1318.                                                 }
  1319.                                             for (Dumper = 0; Dumper < Template->PhaseGenNumElements[Index]; Dumper += 1)
  1320.                                                 {
  1321.                                                     DisposeEnvelopeStateRecord(State->PhaseGenScalingFactorEnvelope[Index][Dumper]);
  1322.                                                     DisposeLFOGenerator(State->PhaseGenScalingFactorLFO[Index][Dumper]);
  1323.                                                     DisposeEnvelopeStateRecord(State->PhaseGenOriginAdjustEnvelope[Index][Dumper]);
  1324.                                                     DisposeLFOGenerator(State->PhaseGenOriginAdjustLFO[Index][Dumper]);
  1325.                                                 }
  1326.                                             for (Dumper = 0; Dumper < Template->OutputNumElements[Index]; Dumper += 1)
  1327.                                                 {
  1328.                                                     DisposeEnvelopeStateRecord(State->OutputScalingFactorEnvelope[Index][Dumper]);
  1329.                                                     DisposeLFOGenerator(State->OutputScalingFactorLFO[Index][Dumper]);
  1330.                                                     DisposeEnvelopeStateRecord(State->OutputOriginAdjustEnvelope[Index][Dumper]);
  1331.                                                     DisposeLFOGenerator(State->OutputOriginAdjustLFO[Index][Dumper]);
  1332.                                                 }
  1333.                                             ReleasePtr((char*)State->PhaseGenModulationScaling[Index]);
  1334.                                             ReleasePtr((char*)State->PhaseGenModulationOrigin[Index]);
  1335.                                             ReleasePtr((char*)State->PhaseGenScalingFactorEnvelope[Index]);
  1336.                                             ReleasePtr((char*)State->PhaseGenScalingFactorLFO[Index]);
  1337.                                             ReleasePtr((char*)State->PhaseGenOriginAdjustEnvelope[Index]);
  1338.                                             ReleasePtr((char*)State->PhaseGenOriginAdjustLFO[Index]);
  1339.                                             ReleasePtr((char*)State->OutputModulationScaling[Index]);
  1340.                                             ReleasePtr((char*)State->OutputModulationOrigin[Index]);
  1341.                                             ReleasePtr((char*)State->OutputScalingFactorEnvelope[Index]);
  1342.                                             ReleasePtr((char*)State->OutputScalingFactorLFO[Index]);
  1343.                                             ReleasePtr((char*)State->OutputOriginAdjustEnvelope[Index]);
  1344.                                             ReleasePtr((char*)State->OutputOriginAdjustLFO);
  1345.                                         }
  1346.                                     ReleasePtr((char*)State->OutputOriginAdjustLFO);
  1347.                                     goto FailurePoint15;
  1348.                                 }
  1349.                             break;
  1350.                         case eOscillatorWaveTable:
  1351.                             State->StateArray[Scan].u.WaveTableState = NewWaveTableState(
  1352.                                 Template->TemplateArray[Scan].u.WaveTableTemplate,FreqForMultisampling,
  1353.                                 Accent1,Accent2,Accent3,Accent4,Loudness,HurryUp,&TempOrigin,
  1354.                                 StereoPosition,InitialFrequency,LoudnessLFOAmplitudeScaling,
  1355.                                 LoudnessLFOFrequencyScaling,True/*doing modulation*/);
  1356.                             if (State->StateArray[Scan].u.WaveTableState == NIL)
  1357.                                 {
  1358.                                     goto FailurePoint16a;
  1359.                                 }
  1360.                             break;
  1361.                     }
  1362.  
  1363.                 if (TempOrigin > MaxOrigin)
  1364.                     {
  1365.                         MaxOrigin = TempOrigin;
  1366.                     }
  1367.  
  1368.                 PRNGCHK(State->OldValues,&(State->OldValues[Scan]),sizeof(State->OldValues[Scan]));
  1369.                 State->OldValues[Scan] = 0;
  1370.  
  1371.                 State->PhaseGenScalingFactorEnvelope[Scan] = (EvalEnvelopeRec**)
  1372.                     AllocPtrCanFail(sizeof(EvalEnvelopeRec*) * Template->PhaseGenNumElements[Scan],
  1373.                     "PhaseGenScalingFactorEnvelope[][]");
  1374.                 if (State->PhaseGenScalingFactorEnvelope[Scan] == NIL)
  1375.                     {
  1376.                      FailurePoint16b:
  1377.                         switch (State->StateArray[Scan].OscillatorType)
  1378.                             {
  1379.                                 default:
  1380.                                     EXECUTE(PRERR(ForceAbort,"NewModOscState:  bad oscillator type"));
  1381.                                     break;
  1382.                                 case eOscillatorSampled:
  1383.                                     DisposeSampleState(State->StateArray[Scan].u.SampleState);
  1384.                                     break;
  1385.                                 case eOscillatorWaveTable:
  1386.                                     DisposeWaveTableState(State->StateArray[Scan].u.WaveTableState);
  1387.                                     break;
  1388.                             }
  1389.                         goto FailurePoint16a;
  1390.                     }
  1391.                 for (Index = 0; Index < Template->PhaseGenNumElements[Scan]; Index += 1)
  1392.                     {
  1393.                         State->PhaseGenScalingFactorEnvelope[Scan][Index] = NewEnvelopeStateRecord(
  1394.                             Template->PhaseGenScalingFactorEnvelope[Scan][Index],Accent1,Accent2,
  1395.                             Accent3,Accent4,InitialFrequency,1,HurryUp,Template->TicksPerSecond,
  1396.                             &TempOrigin);
  1397.                         if (State->PhaseGenScalingFactorEnvelope[Scan][Index] == NIL)
  1398.                             {
  1399.                                 long                                Dumper;
  1400.  
  1401.                              FailurePoint16c:
  1402.                                 for (Dumper = 0; Dumper < Index; Dumper += 1)
  1403.                                     {
  1404.                                         DisposeEnvelopeStateRecord(
  1405.                                             State->PhaseGenScalingFactorEnvelope[Scan][Dumper]);
  1406.                                     }
  1407.                                 ReleasePtr((char*)State->PhaseGenScalingFactorEnvelope[Scan]);
  1408.                                 goto FailurePoint16b;
  1409.                             }
  1410.                         if (TempOrigin > MaxOrigin)
  1411.                             {
  1412.                                 MaxOrigin = TempOrigin;
  1413.                             }
  1414.                     }
  1415.  
  1416.                 State->PhaseGenScalingFactorLFO[Scan] = (LFOGenRec**)AllocPtrCanFail(
  1417.                     sizeof(LFOGenRec*) * Template->PhaseGenNumElements[Scan],
  1418.                     "PhaseGenScalingFactorLFO[][]");
  1419.                 if (State->PhaseGenScalingFactorLFO[Scan] == NIL)
  1420.                     {
  1421.                      FailurePoint16d:
  1422.                         Index = Template->PhaseGenNumElements[Scan]; /* fudge up index for previous */
  1423.                         goto FailurePoint16c;
  1424.                     }
  1425.                 for (Index = 0; Index < Template->PhaseGenNumElements[Scan]; Index += 1)
  1426.                     {
  1427.                         State->PhaseGenScalingFactorLFO[Scan][Index] = NewLFOGenerator(
  1428.                             Template->PhaseGenScalingFactorLFOList[Scan][Index],&TempOrigin,
  1429.                             Accent1,Accent2,Accent3,Accent4,InitialFrequency,HurryUp,
  1430.                             Template->TicksPerSecond,1,1,eLFOArithDefault,1,FreqForMultisampling);
  1431.                         if (State->PhaseGenScalingFactorLFO[Scan][Index] == NIL)
  1432.                             {
  1433.                                 long                                Dumper;
  1434.  
  1435.                              FailurePoint16e:
  1436.                                 for (Dumper = 0; Dumper < Index; Dumper += 1)
  1437.                                     {
  1438.                                         DisposeLFOGenerator(State->PhaseGenScalingFactorLFO[Scan][Dumper]);
  1439.                                     }
  1440.                                 ReleasePtr((char*)State->PhaseGenScalingFactorLFO[Scan]);
  1441.                                 goto FailurePoint16d;
  1442.                             }
  1443.                         if (TempOrigin > MaxOrigin)
  1444.                             {
  1445.                                 MaxOrigin = TempOrigin;
  1446.                             }
  1447.                     }
  1448.  
  1449.                 State->PhaseGenOriginAdjustEnvelope[Scan] = (EvalEnvelopeRec**)
  1450.                     AllocPtrCanFail(sizeof(EvalEnvelopeRec*) * Template->PhaseGenNumElements[Scan],
  1451.                     "PhaseGenOriginAdjustEnvelope[][]");
  1452.                 if (State->PhaseGenOriginAdjustEnvelope[Scan] == NIL)
  1453.                     {
  1454.                      FailurePoint16f:
  1455.                         Index = Template->PhaseGenNumElements[Scan]; /* fudge up index for previous */
  1456.                         goto FailurePoint16e;
  1457.                     }
  1458.                 for (Index = 0; Index < Template->PhaseGenNumElements[Scan]; Index += 1)
  1459.                     {
  1460.                         State->PhaseGenOriginAdjustEnvelope[Scan][Index] = NewEnvelopeStateRecord(
  1461.                             Template->PhaseGenOriginAdjustEnvelope[Scan][Index],Accent1,Accent2,
  1462.                             Accent3,Accent4,InitialFrequency,1,HurryUp,Template->TicksPerSecond,
  1463.                             &TempOrigin);
  1464.                         if (State->PhaseGenOriginAdjustEnvelope[Scan][Index] == NIL)
  1465.                             {
  1466.                                 long                                Dumper;
  1467.  
  1468.                              FailurePoint16g:
  1469.                                 for (Dumper = 0; Dumper < Index; Dumper += 1)
  1470.                                     {
  1471.                                         DisposeEnvelopeStateRecord(
  1472.                                             State->PhaseGenOriginAdjustEnvelope[Scan][Dumper]);
  1473.                                     }
  1474.                                 ReleasePtr((char*)State->PhaseGenOriginAdjustEnvelope[Scan]);
  1475.                                 goto FailurePoint16f;
  1476.                             }
  1477.                         if (TempOrigin > MaxOrigin)
  1478.                             {
  1479.                                 MaxOrigin = TempOrigin;
  1480.                             }
  1481.                     }
  1482.  
  1483.                 State->PhaseGenOriginAdjustLFO[Scan] = (LFOGenRec**)AllocPtrCanFail(
  1484.                     sizeof(LFOGenRec*) * Template->PhaseGenNumElements[Scan],
  1485.                     "PhaseGenOriginAdjustLFO[][]");
  1486.                 if (State->PhaseGenOriginAdjustLFO[Scan] == NIL)
  1487.                     {
  1488.                      FailurePoint16h:
  1489.                         Index = Template->PhaseGenNumElements[Scan]; /* fudge up index for previous */
  1490.                         goto FailurePoint16g;
  1491.                     }
  1492.                 for (Index = 0; Index < Template->PhaseGenNumElements[Scan]; Index += 1)
  1493.                     {
  1494.                         State->PhaseGenOriginAdjustLFO[Scan][Index] = NewLFOGenerator(
  1495.                             Template->PhaseGenOriginAdjustLFOList[Scan][Index],&TempOrigin,
  1496.                             Accent1,Accent2,Accent3,Accent4,InitialFrequency,HurryUp,
  1497.                             Template->TicksPerSecond,1,1,eLFOArithDefault,1,FreqForMultisampling);
  1498.                         if (State->PhaseGenOriginAdjustLFO[Scan][Index] == NIL)
  1499.                             {
  1500.                                 long                                Dumper;
  1501.  
  1502.                              FailurePoint16i:
  1503.                                 for (Dumper = 0; Dumper < Index; Dumper += 1)
  1504.                                     {
  1505.                                         DisposeLFOGenerator(State->PhaseGenOriginAdjustLFO[Scan][Dumper]);
  1506.                                     }
  1507.                                 ReleasePtr((char*)State->PhaseGenOriginAdjustLFO[Scan]);
  1508.                                 goto FailurePoint16h;
  1509.                             }
  1510.                         if (TempOrigin > MaxOrigin)
  1511.                             {
  1512.                                 MaxOrigin = TempOrigin;
  1513.                             }
  1514.                     }
  1515.  
  1516.                 State->OutputScalingFactorEnvelope[Scan] = (EvalEnvelopeRec**)
  1517.                     AllocPtrCanFail(sizeof(EvalEnvelopeRec*) * Template->OutputNumElements[Scan],
  1518.                     "OutputScalingFactorEnvelope[][]");
  1519.                 if (State->OutputScalingFactorEnvelope[Scan] == NIL)
  1520.                     {
  1521.                      FailurePoint16j:
  1522.                         Index = Template->PhaseGenNumElements[Scan]; /* fudge up index for previous */
  1523.                         goto FailurePoint16i;
  1524.                     }
  1525.                 for (Index = 0; Index < Template->OutputNumElements[Scan]; Index += 1)
  1526.                     {
  1527.                         State->OutputScalingFactorEnvelope[Scan][Index] = NewEnvelopeStateRecord(
  1528.                             Template->OutputScalingFactorEnvelope[Scan][Index],Accent1,Accent2,
  1529.                             Accent3,Accent4,InitialFrequency,1,HurryUp,Template->TicksPerSecond,
  1530.                             &TempOrigin);
  1531.                         if (State->OutputScalingFactorEnvelope[Scan][Index] == NIL)
  1532.                             {
  1533.                                 long                                Dumper;
  1534.  
  1535.                              FailurePoint16k:
  1536.                                 for (Dumper = 0; Dumper < Index; Dumper += 1)
  1537.                                     {
  1538.                                         DisposeEnvelopeStateRecord(
  1539.                                             State->OutputScalingFactorEnvelope[Scan][Dumper]);
  1540.                                     }
  1541.                                 ReleasePtr((char*)State->OutputScalingFactorEnvelope[Scan]);
  1542.                                 goto FailurePoint16j;
  1543.                             }
  1544.                         if (TempOrigin > MaxOrigin)
  1545.                             {
  1546.                                 MaxOrigin = TempOrigin;
  1547.                             }
  1548.                     }
  1549.  
  1550.                 State->OutputScalingFactorLFO[Scan] = (LFOGenRec**)AllocPtrCanFail(
  1551.                     sizeof(LFOGenRec*) * Template->OutputNumElements[Scan],
  1552.                     "OutputScalingFactorLFO[][]");
  1553.                 if (State->OutputScalingFactorLFO[Scan] == NIL)
  1554.                     {
  1555.                      FailurePoint16l:
  1556.                         Index = Template->OutputNumElements[Scan]; /* fudge up index for previous */
  1557.                         goto FailurePoint16k;
  1558.                     }
  1559.                 for (Index = 0; Index < Template->OutputNumElements[Scan]; Index += 1)
  1560.                     {
  1561.                         State->OutputScalingFactorLFO[Scan][Index] = NewLFOGenerator(
  1562.                             Template->OutputScalingFactorLFOList[Scan][Index],&TempOrigin,
  1563.                             Accent1,Accent2,Accent3,Accent4,InitialFrequency,HurryUp,
  1564.                             Template->TicksPerSecond,1,1,eLFOArithDefault,1,FreqForMultisampling);
  1565.                         if (State->OutputScalingFactorLFO[Scan][Index] == NIL)
  1566.                             {
  1567.                                 long                                Dumper;
  1568.  
  1569.                              FailurePoint16m:
  1570.                                 for (Dumper = 0; Dumper < Index; Dumper += 1)
  1571.                                     {
  1572.                                         DisposeLFOGenerator(State->OutputScalingFactorLFO[Scan][Dumper]);
  1573.                                     }
  1574.                                 ReleasePtr((char*)State->OutputScalingFactorLFO[Scan]);
  1575.                                 goto FailurePoint16l;
  1576.                             }
  1577.                         if (TempOrigin > MaxOrigin)
  1578.                             {
  1579.                                 MaxOrigin = TempOrigin;
  1580.                             }
  1581.                     }
  1582.  
  1583.                 State->OutputOriginAdjustEnvelope[Scan] = (EvalEnvelopeRec**)
  1584.                     AllocPtrCanFail(sizeof(EvalEnvelopeRec*) * Template->OutputNumElements[Scan],
  1585.                     "OutputOriginAdjustEnvelope[][]");
  1586.                 if (State->OutputOriginAdjustEnvelope[Scan] == NIL)
  1587.                     {
  1588.                      FailurePoint16n:
  1589.                         Index = Template->OutputNumElements[Scan]; /* fudge up index for previous */
  1590.                         goto FailurePoint16m;
  1591.                     }
  1592.                 for (Index = 0; Index < Template->OutputNumElements[Scan]; Index += 1)
  1593.                     {
  1594.                         State->OutputOriginAdjustEnvelope[Scan][Index] = NewEnvelopeStateRecord(
  1595.                             Template->OutputOriginAdjustEnvelope[Scan][Index],Accent1,Accent2,
  1596.                             Accent3,Accent4,InitialFrequency,1,HurryUp,Template->TicksPerSecond,
  1597.                             &TempOrigin);
  1598.                         if (State->OutputOriginAdjustEnvelope[Scan][Index] == NIL)
  1599.                             {
  1600.                                 long                                Dumper;
  1601.  
  1602.                              FailurePoint16o:
  1603.                                 for (Dumper = 0; Dumper < Index; Dumper += 1)
  1604.                                     {
  1605.                                         DisposeEnvelopeStateRecord(
  1606.                                             State->OutputOriginAdjustEnvelope[Scan][Dumper]);
  1607.                                     }
  1608.                                 ReleasePtr((char*)State->OutputOriginAdjustEnvelope[Scan]);
  1609.                                 goto FailurePoint16n;
  1610.                             }
  1611.                         if (TempOrigin > MaxOrigin)
  1612.                             {
  1613.                                 MaxOrigin = TempOrigin;
  1614.                             }
  1615.                     }
  1616.  
  1617.                 State->OutputOriginAdjustLFO[Scan] = (LFOGenRec**)AllocPtrCanFail(
  1618.                     sizeof(LFOGenRec*) * Template->OutputNumElements[Scan],
  1619.                     "OutputOriginAdjustLFO[][]");
  1620.                 if (State->OutputOriginAdjustLFO[Scan] == NIL)
  1621.                     {
  1622.                      FailurePoint16p:
  1623.                         Index = Template->OutputNumElements[Scan]; /* fudge up index for previous */
  1624.                         goto FailurePoint16o;
  1625.                     }
  1626.                 for (Index = 0; Index < Template->OutputNumElements[Scan]; Index += 1)
  1627.                     {
  1628.                         State->OutputOriginAdjustLFO[Scan][Index] = NewLFOGenerator(
  1629.                             Template->OutputOriginAdjustLFOList[Scan][Index],&TempOrigin,
  1630.                             Accent1,Accent2,Accent3,Accent4,InitialFrequency,HurryUp,
  1631.                             Template->TicksPerSecond,1,1,eLFOArithDefault,1,FreqForMultisampling);
  1632.                         if (State->OutputOriginAdjustLFO[Scan][Index] == NIL)
  1633.                             {
  1634.                                 long                                Dumper;
  1635.  
  1636.                              FailurePoint16q:
  1637.                                 for (Dumper = 0; Dumper < Index; Dumper += 1)
  1638.                                     {
  1639.                                         DisposeLFOGenerator(State->OutputOriginAdjustLFO[Scan][Dumper]);
  1640.                                     }
  1641.                                 ReleasePtr((char*)State->OutputOriginAdjustLFO[Scan]);
  1642.                                 goto FailurePoint16p;
  1643.                             }
  1644.                         if (TempOrigin > MaxOrigin)
  1645.                             {
  1646.                                 MaxOrigin = TempOrigin;
  1647.                             }
  1648.                     }
  1649.  
  1650.                 State->PhaseGenModulationScaling[Scan] = (float*)AllocPtrCanFail(
  1651.                     sizeof(float) * Template->PhaseGenNumElements[Scan],
  1652.                     "PhaseGenModulationScaling[][]");
  1653.                 if (State->PhaseGenModulationScaling[Scan] == NIL)
  1654.                     {
  1655.                      FailurePoint16r:
  1656.                         Index = Template->OutputNumElements[Scan]; /* fudge up index for previous */
  1657.                         goto FailurePoint16q;
  1658.                     }
  1659.  
  1660.                 State->PhaseGenModulationOrigin[Scan] = (float*)AllocPtrCanFail(
  1661.                     sizeof(float) * Template->PhaseGenNumElements[Scan],
  1662.                     "PhaseGenModulationOrigin[][]");
  1663.                 if (State->PhaseGenModulationOrigin[Scan] == NIL)
  1664.                     {
  1665.                      FailurePoint16s:
  1666.                         ReleasePtr((char*)State->PhaseGenModulationScaling[Scan]);
  1667.                         goto FailurePoint16r;
  1668.                     }
  1669.  
  1670.                 State->OutputModulationScaling[Scan] = (float*)AllocPtrCanFail(
  1671.                     sizeof(float) * Template->OutputNumElements[Scan],"OutputModulationScaling[][]");
  1672.                 if (State->OutputModulationScaling[Scan] == NIL)
  1673.                     {
  1674.                      FailurePoint16t:
  1675.                         ReleasePtr((char*)State->PhaseGenModulationOrigin[Scan]);
  1676.                         goto FailurePoint16s;
  1677.                     }
  1678.  
  1679.                 State->OutputModulationOrigin[Scan] = (float*)AllocPtrCanFail(
  1680.                     sizeof(float) * Template->OutputNumElements[Scan],"OutputModulationOrigin[][]");
  1681.                 if (State->OutputModulationOrigin[Scan] == NIL)
  1682.                     {
  1683.                      FailurePoint16u:
  1684.                         ReleasePtr((char*)State->OutputModulationScaling[Scan]);
  1685.                         goto FailurePoint16t;
  1686.                     }
  1687.             }
  1688.  
  1689.         State->Template = *Template;
  1690.         *PreOriginTimeOut = MaxOrigin;
  1691.  
  1692.         return State;
  1693.     }
  1694.  
  1695.  
  1696. /* fix up pre-origin time for the modulation oscillator state object */
  1697. void                                    FixUpModOscStatePreOrigin(ModOscStateRec* State,
  1698.                                                 long ActualPreOrigin)
  1699.     {
  1700.         long                                Scan;
  1701.  
  1702.         CheckPtrExistence(State);
  1703.         ValidateState(State);
  1704.  
  1705.         for (Scan = 0; Scan < State->Template.NumberOfOscillators; Scan += 1)
  1706.             {
  1707.                 long                                Index;
  1708.  
  1709.                 PRNGCHK(State->StateArray,&(State->StateArray[Scan]),
  1710.                     sizeof(State->StateArray[Scan]));
  1711.                 switch (State->StateArray[Scan].OscillatorType)
  1712.                     {
  1713.                         default:
  1714.                             EXECUTE(PRERR(ForceAbort,"FixUpModOscStatePreOrigin:  bad oscillator type"));
  1715.                             break;
  1716.                         case eOscillatorSampled:
  1717.                             FixUpSampleStatePreOrigin(State->StateArray[Scan].u.SampleState,
  1718.                                 ActualPreOrigin);
  1719.                             break;
  1720.                         case eOscillatorWaveTable:
  1721.                             FixUpWaveTableStatePreOrigin(State->StateArray[Scan].u.WaveTableState,
  1722.                                 ActualPreOrigin);
  1723.                             break;
  1724.                     }
  1725.  
  1726.                 for (Index = 0; Index < State->Template.PhaseGenNumElements[Scan]; Index += 1)
  1727.                     {
  1728.                         EnvelopeStateFixUpInitialDelay(State->PhaseGenScalingFactorEnvelope[
  1729.                             Scan][Index],ActualPreOrigin);
  1730.                         LFOGeneratorFixEnvelopeOrigins(State->PhaseGenScalingFactorLFO[Scan][Index],
  1731.                             ActualPreOrigin);
  1732.                         EnvelopeStateFixUpInitialDelay(State->PhaseGenOriginAdjustEnvelope[
  1733.                             Scan][Index],ActualPreOrigin);
  1734.                         LFOGeneratorFixEnvelopeOrigins(State->PhaseGenOriginAdjustLFO[Scan][Index],
  1735.                             ActualPreOrigin);
  1736.                     }
  1737.  
  1738.                 for (Index = 0; Index < State->Template.OutputNumElements[Scan]; Index += 1)
  1739.                     {
  1740.                         EnvelopeStateFixUpInitialDelay(State->OutputScalingFactorEnvelope[
  1741.                             Scan][Index],ActualPreOrigin);
  1742.                         LFOGeneratorFixEnvelopeOrigins(State->OutputScalingFactorLFO[Scan][Index],
  1743.                             ActualPreOrigin);
  1744.                         EnvelopeStateFixUpInitialDelay(State->OutputOriginAdjustEnvelope[
  1745.                             Scan][Index],ActualPreOrigin);
  1746.                         LFOGeneratorFixEnvelopeOrigins(State->OutputOriginAdjustLFO[Scan][Index],
  1747.                             ActualPreOrigin);
  1748.                     }
  1749.             }
  1750.     }
  1751.  
  1752.  
  1753. /* set a new frequency for a modulation oscillator state object.  used for */
  1754. /* portamento and modulation of frequency (vibrato) */
  1755. void                                    ModOscStateNewFrequency(ModOscStateRec* State,
  1756.                                                 float NewFrequencyHertz)
  1757.     {
  1758.         long                                Scan;
  1759.  
  1760.         CheckPtrExistence(State);
  1761.         ValidateState(State);
  1762.  
  1763.         for (Scan = 0; Scan < State->Template.NumberOfOscillators; Scan += 1)
  1764.             {
  1765.                 PRNGCHK(State->StateArray,&(State->StateArray[Scan]),
  1766.                     sizeof(State->StateArray[Scan]));
  1767.                 switch (State->StateArray[Scan].OscillatorType)
  1768.                     {
  1769.                         default:
  1770.                             EXECUTE(PRERR(ForceAbort,"ModOscStateNewFrequency:  bad oscillator type"));
  1771.                             break;
  1772.                         case eOscillatorSampled:
  1773.                             SampleStateNewFrequency(State->StateArray[Scan].u.SampleState,
  1774.                                 NewFrequencyHertz);
  1775.                             break;
  1776.                         case eOscillatorWaveTable:
  1777.                             WaveTableStateNewFrequency(State->StateArray[Scan].u.WaveTableState,
  1778.                                 NewFrequencyHertz);
  1779.                             break;
  1780.                     }
  1781.             }
  1782.     }
  1783.  
  1784.  
  1785. /* send a key-up signal to one of the oscillators */
  1786. void                                    ModOscKeyUpSustain1(ModOscStateRec* State)
  1787.     {
  1788.         long                                Scan;
  1789.  
  1790.         CheckPtrExistence(State);
  1791.         ValidateState(State);
  1792.  
  1793.         for (Scan = 0; Scan < State->Template.NumberOfOscillators; Scan += 1)
  1794.             {
  1795.                 long                                Index;
  1796.  
  1797.                 PRNGCHK(State->StateArray,&(State->StateArray[Scan]),
  1798.                     sizeof(State->StateArray[Scan]));
  1799.                 switch (State->StateArray[Scan].OscillatorType)
  1800.                     {
  1801.                         default:
  1802.                             EXECUTE(PRERR(ForceAbort,"ModOscKeyUpSustain1:  bad oscillator type"));
  1803.                             break;
  1804.                         case eOscillatorSampled:
  1805.                             SampleKeyUpSustain1(State->StateArray[Scan].u.SampleState);
  1806.                             break;
  1807.                         case eOscillatorWaveTable:
  1808.                             WaveTableKeyUpSustain1(State->StateArray[Scan].u.WaveTableState);
  1809.                             break;
  1810.                     }
  1811.  
  1812.                 for (Index = 0; Index < State->Template.PhaseGenNumElements[Scan]; Index += 1)
  1813.                     {
  1814.                         EnvelopeKeyUpSustain1(State->PhaseGenScalingFactorEnvelope[Scan][Index]);
  1815.                         LFOGeneratorKeyUpSustain1(State->PhaseGenScalingFactorLFO[Scan][Index]);
  1816.                         EnvelopeKeyUpSustain1(State->PhaseGenOriginAdjustEnvelope[Scan][Index]);
  1817.                         LFOGeneratorKeyUpSustain1(State->PhaseGenOriginAdjustLFO[Scan][Index]);
  1818.                     }
  1819.  
  1820.                 for (Index = 0; Index < State->Template.OutputNumElements[Scan]; Index += 1)
  1821.                     {
  1822.                         EnvelopeKeyUpSustain1(State->OutputScalingFactorEnvelope[Scan][Index]);
  1823.                         LFOGeneratorKeyUpSustain1(State->OutputScalingFactorLFO[Scan][Index]);
  1824.                         EnvelopeKeyUpSustain1(State->OutputOriginAdjustEnvelope[Scan][Index]);
  1825.                         LFOGeneratorKeyUpSustain1(State->OutputOriginAdjustLFO[Scan][Index]);
  1826.                     }
  1827.             }
  1828.     }
  1829.  
  1830.  
  1831. /* send a key-up signal to one of the oscillators */
  1832. void                                    ModOscKeyUpSustain2(ModOscStateRec* State)
  1833.     {
  1834.         long                                Scan;
  1835.  
  1836.         CheckPtrExistence(State);
  1837.         ValidateState(State);
  1838.  
  1839.         for (Scan = 0; Scan < State->Template.NumberOfOscillators; Scan += 1)
  1840.             {
  1841.                 long                                Index;
  1842.  
  1843.                 PRNGCHK(State->StateArray,&(State->StateArray[Scan]),
  1844.                     sizeof(State->StateArray[Scan]));
  1845.                 switch (State->StateArray[Scan].OscillatorType)
  1846.                     {
  1847.                         default:
  1848.                             EXECUTE(PRERR(ForceAbort,"ModOscKeyUpSustain2:  bad oscillator type"));
  1849.                             break;
  1850.                         case eOscillatorSampled:
  1851.                             SampleKeyUpSustain2(State->StateArray[Scan].u.SampleState);
  1852.                             break;
  1853.                         case eOscillatorWaveTable:
  1854.                             WaveTableKeyUpSustain2(State->StateArray[Scan].u.WaveTableState);
  1855.                             break;
  1856.                     }
  1857.  
  1858.                 for (Index = 0; Index < State->Template.PhaseGenNumElements[Scan]; Index += 1)
  1859.                     {
  1860.                         EnvelopeKeyUpSustain2(State->PhaseGenScalingFactorEnvelope[Scan][Index]);
  1861.                         LFOGeneratorKeyUpSustain2(State->PhaseGenScalingFactorLFO[Scan][Index]);
  1862.                         EnvelopeKeyUpSustain2(State->PhaseGenOriginAdjustEnvelope[Scan][Index]);
  1863.                         LFOGeneratorKeyUpSustain2(State->PhaseGenOriginAdjustLFO[Scan][Index]);
  1864.                     }
  1865.  
  1866.                 for (Index = 0; Index < State->Template.OutputNumElements[Scan]; Index += 1)
  1867.                     {
  1868.                         EnvelopeKeyUpSustain2(State->OutputScalingFactorEnvelope[Scan][Index]);
  1869.                         LFOGeneratorKeyUpSustain2(State->OutputScalingFactorLFO[Scan][Index]);
  1870.                         EnvelopeKeyUpSustain2(State->OutputOriginAdjustEnvelope[Scan][Index]);
  1871.                         LFOGeneratorKeyUpSustain2(State->OutputOriginAdjustLFO[Scan][Index]);
  1872.                     }
  1873.             }
  1874.     }
  1875.  
  1876.  
  1877. /* send a key-up signal to one of the oscillators */
  1878. void                                    ModOscKeyUpSustain3(ModOscStateRec* State)
  1879.     {
  1880.         long                                Scan;
  1881.  
  1882.         CheckPtrExistence(State);
  1883.         ValidateState(State);
  1884.  
  1885.         for (Scan = 0; Scan < State->Template.NumberOfOscillators; Scan += 1)
  1886.             {
  1887.                 long                                Index;
  1888.  
  1889.                 PRNGCHK(State->StateArray,&(State->StateArray[Scan]),
  1890.                     sizeof(State->StateArray[Scan]));
  1891.                 switch (State->StateArray[Scan].OscillatorType)
  1892.                     {
  1893.                         default:
  1894.                             EXECUTE(PRERR(ForceAbort,"ModOscKeyUpSustain3:  bad oscillator type"));
  1895.                             break;
  1896.                         case eOscillatorSampled:
  1897.                             SampleKeyUpSustain3(State->StateArray[Scan].u.SampleState);
  1898.                             break;
  1899.                         case eOscillatorWaveTable:
  1900.                             WaveTableKeyUpSustain3(State->StateArray[Scan].u.WaveTableState);
  1901.                             break;
  1902.                     }
  1903.  
  1904.                 for (Index = 0; Index < State->Template.PhaseGenNumElements[Scan]; Index += 1)
  1905.                     {
  1906.                         EnvelopeKeyUpSustain3(State->PhaseGenScalingFactorEnvelope[Scan][Index]);
  1907.                         LFOGeneratorKeyUpSustain3(State->PhaseGenScalingFactorLFO[Scan][Index]);
  1908.                         EnvelopeKeyUpSustain3(State->PhaseGenOriginAdjustEnvelope[Scan][Index]);
  1909.                         LFOGeneratorKeyUpSustain3(State->PhaseGenOriginAdjustLFO[Scan][Index]);
  1910.                     }
  1911.  
  1912.                 for (Index = 0; Index < State->Template.OutputNumElements[Scan]; Index += 1)
  1913.                     {
  1914.                         EnvelopeKeyUpSustain3(State->OutputScalingFactorEnvelope[Scan][Index]);
  1915.                         LFOGeneratorKeyUpSustain3(State->OutputScalingFactorLFO[Scan][Index]);
  1916.                         EnvelopeKeyUpSustain3(State->OutputOriginAdjustEnvelope[Scan][Index]);
  1917.                         LFOGeneratorKeyUpSustain3(State->OutputOriginAdjustLFO[Scan][Index]);
  1918.                     }
  1919.             }
  1920.     }
  1921.  
  1922.  
  1923. /* restart a modulation oscillator oscillator.  this is used for tie continuations */
  1924. void                                    RestartModOscState(ModOscStateRec* State,
  1925.                                                 float NewFreqMultisampling, float NewAccent1, float NewAccent2,
  1926.                                                 float NewAccent3, float NewAccent4, float NewLoudness,
  1927.                                                 float NewHurryUp, MyBoolean RetriggerEnvelopes,
  1928.                                                 float NewStereoPosition, float NewInitialFrequency,
  1929.                                                 float NewLoudnessLFOAmplitudeScaling,
  1930.                                                 float NewLoudnessLFOFrequencyScaling)
  1931.     {
  1932.         long                                Scan;
  1933.  
  1934.         CheckPtrExistence(State);
  1935.         ValidateState(State);
  1936.  
  1937.         for (Scan = 0; Scan < State->Template.NumberOfOscillators; Scan += 1)
  1938.             {
  1939.                 long                                Index;
  1940.  
  1941.                 PRNGCHK(State->StateArray,&(State->StateArray[Scan]),
  1942.                     sizeof(State->StateArray[Scan]));
  1943.                 switch (State->StateArray[Scan].OscillatorType)
  1944.                     {
  1945.                         default:
  1946.                             EXECUTE(PRERR(ForceAbort,"RestartModOscState:  bad oscillator type"));
  1947.                             break;
  1948.                         case eOscillatorSampled:
  1949.                             RestartSampleState(State->StateArray[Scan].u.SampleState,
  1950.                                 NewFreqMultisampling,NewAccent1,NewAccent2,NewAccent3,NewAccent4,
  1951.                                 NewLoudness,NewHurryUp,RetriggerEnvelopes,NewStereoPosition,
  1952.                                 NewInitialFrequency,NewLoudnessLFOAmplitudeScaling,
  1953.                                 NewLoudnessLFOFrequencyScaling);
  1954.                             break;
  1955.                         case eOscillatorWaveTable:
  1956.                             RestartWaveTableState(State->StateArray[Scan].u.WaveTableState,
  1957.                                 NewFreqMultisampling,NewAccent1,NewAccent2,NewAccent3,NewAccent4,
  1958.                                 NewLoudness,NewHurryUp,RetriggerEnvelopes,NewStereoPosition,
  1959.                                 NewInitialFrequency,NewLoudnessLFOAmplitudeScaling,
  1960.                                 NewLoudnessLFOFrequencyScaling);
  1961.                             break;
  1962.                     }
  1963.  
  1964.                 for (Index = 0; Index < State->Template.PhaseGenNumElements[Scan]; Index += 1)
  1965.                     {
  1966.                         EnvelopeRetriggerFromOrigin(State->PhaseGenScalingFactorEnvelope[Scan][Index],
  1967.                             NewAccent1,NewAccent2,NewAccent3,NewAccent4,NewInitialFrequency,
  1968.                             1,NewHurryUp,State->Template.TicksPerSecond,RetriggerEnvelopes);
  1969.                         LFOGeneratorRetriggerFromOrigin(State->PhaseGenScalingFactorLFO[Scan][Index],
  1970.                             NewAccent1,NewAccent2,NewAccent3,NewAccent4,NewInitialFrequency,
  1971.                             NewHurryUp,State->Template.TicksPerSecond,1,1,RetriggerEnvelopes);
  1972.                         EnvelopeRetriggerFromOrigin(State->PhaseGenOriginAdjustEnvelope[Scan][Index],
  1973.                             NewAccent1,NewAccent2,NewAccent3,NewAccent4,NewInitialFrequency,
  1974.                             1,NewHurryUp,State->Template.TicksPerSecond,RetriggerEnvelopes);
  1975.                         LFOGeneratorRetriggerFromOrigin(State->PhaseGenOriginAdjustLFO[Scan][Index],
  1976.                             NewAccent1,NewAccent2,NewAccent3,NewAccent4,NewInitialFrequency,
  1977.                             NewHurryUp,State->Template.TicksPerSecond,1,1,RetriggerEnvelopes);
  1978.                     }
  1979.  
  1980.                 for (Index = 0; Index < State->Template.OutputNumElements[Scan]; Index += 1)
  1981.                     {
  1982.                         EnvelopeRetriggerFromOrigin(State->OutputScalingFactorEnvelope[Scan][Index],
  1983.                             NewAccent1,NewAccent2,NewAccent3,NewAccent4,NewInitialFrequency,
  1984.                             1,NewHurryUp,State->Template.TicksPerSecond,RetriggerEnvelopes);
  1985.                         LFOGeneratorRetriggerFromOrigin(State->OutputScalingFactorLFO[Scan][Index],
  1986.                             NewAccent1,NewAccent2,NewAccent3,NewAccent4,NewInitialFrequency,
  1987.                             NewHurryUp,State->Template.TicksPerSecond,1,1,RetriggerEnvelopes);
  1988.                         EnvelopeRetriggerFromOrigin(State->OutputOriginAdjustEnvelope[Scan][Index],
  1989.                             NewAccent1,NewAccent2,NewAccent3,NewAccent4,NewInitialFrequency,
  1990.                             1,NewHurryUp,State->Template.TicksPerSecond,RetriggerEnvelopes);
  1991.                         LFOGeneratorRetriggerFromOrigin(State->OutputOriginAdjustLFO[Scan][Index],
  1992.                             NewAccent1,NewAccent2,NewAccent3,NewAccent4,NewInitialFrequency,
  1993.                             NewHurryUp,State->Template.TicksPerSecond,1,1,RetriggerEnvelopes);
  1994.                     }
  1995.             }
  1996.     }
  1997.  
  1998.  
  1999. /* generate a sequence of samples (called for each envelope clock) */
  2000. void                                    ModOscGenSamples(ModOscStateRec* State,
  2001.                                                 long SampleCount, largefixedsigned* RawBuffer)
  2002.     {
  2003.         CheckPtrExistence(State);
  2004.         ValidateState(State);
  2005.  
  2006.         if (State->Template.StereoPlayback)
  2007.             {
  2008.                 PRNGCHK(RawBuffer,RawBuffer,SampleCount * 2 * sizeof(largefixedsigned));
  2009.             }
  2010.          else
  2011.             {
  2012.                 PRNGCHK(RawBuffer,RawBuffer,SampleCount * sizeof(largefixedsigned));
  2013.             }
  2014.         while (SampleCount > 0)
  2015.             {
  2016.                 long                                Scan;
  2017.                 float*                            Temp;
  2018.  
  2019.                 for (Scan = 0; Scan < State->Template.NumberOfOscillators; Scan += 1)
  2020.                     {
  2021.                         PRNGCHK(State->StateArray,&(State->StateArray[Scan]),
  2022.                             sizeof(State->StateArray[Scan]));
  2023.                         PRNGCHK(State->BuildOldValues,&(State->BuildOldValues[Scan]),
  2024.                             sizeof(State->BuildOldValues[Scan]));
  2025.                         switch (State->StateArray[Scan].OscillatorType)
  2026.                             {
  2027.                                 default:
  2028.                                     EXECUTE(PRERR(ForceAbort,"ModOscGenSamples:  bad oscillator type"));
  2029.                                     break;
  2030.                                 case eOscillatorSampled:
  2031.                                     State->BuildOldValues[Scan] = SampleGenOneSample(
  2032.                                         State->StateArray[Scan].u.SampleState,
  2033.                                         State->Template.PhaseGenModulateHow[Scan],
  2034.                                         State->PhaseGenModulationScaling[Scan],
  2035.                                         State->PhaseGenModulationOrigin[Scan],
  2036.                                         State->OldValues,
  2037.                                         State->Template.PhaseGenIndirectionTable[Scan],
  2038.                                         State->Template.PhaseGenNumElements[Scan],
  2039.                                         State->Template.OutputModulateHow[Scan],
  2040.                                         State->OutputModulationScaling[Scan],
  2041.                                         State->OutputModulationOrigin[Scan],
  2042.                                         State->OldValues,
  2043.                                         State->Template.OutputIndirectionTable[Scan],
  2044.                                         State->Template.OutputNumElements[Scan],
  2045.                                         RawBuffer);
  2046.                                     break;
  2047.                                 case eOscillatorWaveTable:
  2048.                                     State->BuildOldValues[Scan] = WaveTableGenOneSample(
  2049.                                         State->StateArray[Scan].u.WaveTableState,
  2050.                                         State->Template.PhaseGenModulateHow[Scan],
  2051.                                         State->PhaseGenModulationScaling[Scan],
  2052.                                         State->PhaseGenModulationOrigin[Scan],
  2053.                                         State->OldValues,
  2054.                                         State->Template.PhaseGenIndirectionTable[Scan],
  2055.                                         State->Template.PhaseGenNumElements[Scan],
  2056.                                         State->Template.OutputModulateHow[Scan],
  2057.                                         State->OutputModulationScaling[Scan],
  2058.                                         State->OutputModulationOrigin[Scan],
  2059.                                         State->OldValues,
  2060.                                         State->Template.OutputIndirectionTable[Scan],
  2061.                                         State->Template.OutputNumElements[Scan],
  2062.                                         RawBuffer);
  2063.                                     break;
  2064.                             }
  2065.                     }
  2066.                 if (State->Template.StereoPlayback)
  2067.                     {
  2068.                         RawBuffer += 2;
  2069.                     }
  2070.                  else
  2071.                     {
  2072.                         RawBuffer += 1;
  2073.                     }
  2074.                 SampleCount -= 1;
  2075.                 Temp = State->BuildOldValues;
  2076.                 State->BuildOldValues = State->OldValues;
  2077.                 State->OldValues = Temp;
  2078.             }
  2079.     }
  2080.  
  2081.  
  2082. /* find out if the modulation oscillator has finished */
  2083. MyBoolean                            ModOscIsItFinished(ModOscStateRec* State)
  2084.     {
  2085.         long                                Scan;
  2086.  
  2087.         CheckPtrExistence(State);
  2088.         ValidateState(State);
  2089.  
  2090.         for (Scan = 0; Scan < State->Template.NumberOfOscillators; Scan += 1)
  2091.             {
  2092.                 PRNGCHK(State->StateArray,&(State->StateArray[Scan]),
  2093.                     sizeof(State->StateArray[Scan]));
  2094.                 if (State->StateArray[Scan].OscillatorType == eOscillatorSampled)
  2095.                     {
  2096.                         if (!SampleIsItFinished(State->StateArray[Scan].u.SampleState))
  2097.                             {
  2098.                                 return False; /* someone is still running */
  2099.                             }
  2100.                     }
  2101.                  else
  2102.                     {
  2103.                         if (!WaveTableIsItFinished(State->StateArray[Scan].u.WaveTableState))
  2104.                             {
  2105.                                 return False; /* someone is still running */
  2106.                             }
  2107.                     }
  2108.             }
  2109.  
  2110.         return True; /* nobody is still running */
  2111.     }
  2112.