home *** CD-ROM | disk | FTP | other *** search
/ MacFormat 1995 January / macformat-020.iso / Shareware City / Developers / Synthesizer Source / Synthesizer Folder / SampleOscControl.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-01  |  76.1 KB  |  2,228 lines  |  [TEXT/KAHL]
  1. /* SampleOscControl.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 "SampleOscControl.h"
  31. #include "64BitMath.h"
  32. #include "Multisampler.h"
  33. #include "EnvelopeState.h"
  34. #include "Envelope.h"
  35. #include "LFOGenerator.h"
  36. #include "LFOListSpecifier.h"
  37. #include "SampleConsts.h"
  38. #include "Memory.h"
  39. #include "OscillatorSpecifier.h"
  40. #include "FastModulation.h"
  41. #include "ErrorDaemon.h"
  42.  
  43.  
  44. #if !MEMDEBUG && DEBUG
  45.     #undef PRNGCHK
  46.     #define PRNGCHK(x,y,z) ((void)0)
  47. #endif
  48.  
  49.  
  50. /* prototypes for fast playback routines */
  51. static void                        Sample_MonoOut_MonoSamp_8BitIn_NoTime(SampleStateRec* State,
  52.                                                 long SampleCount, largefixedsigned* RawBuffer);
  53. static void                        Sample_StereoOut_MonoSamp_8BitIn_NoTime(SampleStateRec* State,
  54.                                                 long SampleCount, largefixedsigned* RawBuffer);
  55. static void                        Sample_MonoOut_StereoSamp_8BitIn_NoTime(SampleStateRec* State,
  56.                                                 long SampleCount, largefixedsigned* RawBuffer);
  57. static void                        Sample_StereoOut_StereoSamp_8BitIn_NoTime(SampleStateRec* State,
  58.                                                 long SampleCount, largefixedsigned* RawBuffer);
  59.  
  60. static void                        Sample_MonoOut_MonoSamp_16BitIn_NoTime(SampleStateRec* State,
  61.                                                 long SampleCount, largefixedsigned* RawBuffer);
  62. static void                        Sample_StereoOut_MonoSamp_16BitIn_NoTime(SampleStateRec* State,
  63.                                                 long SampleCount, largefixedsigned* RawBuffer);
  64. static void                        Sample_MonoOut_StereoSamp_16BitIn_NoTime(SampleStateRec* State,
  65.                                                 long SampleCount, largefixedsigned* RawBuffer);
  66. static void                        Sample_StereoOut_StereoSamp_16BitIn_NoTime(SampleStateRec* State,
  67.                                                 long SampleCount, largefixedsigned* RawBuffer);
  68.  
  69. static void                        Sample_MonoOut_MonoSamp_8BitIn_YesTime(SampleStateRec* State,
  70.                                                 long SampleCount, largefixedsigned* RawBuffer);
  71. static void                        Sample_StereoOut_MonoSamp_8BitIn_YesTime(SampleStateRec* State,
  72.                                                 long SampleCount, largefixedsigned* RawBuffer);
  73. static void                        Sample_MonoOut_StereoSamp_8BitIn_YesTime(SampleStateRec* State,
  74.                                                 long SampleCount, largefixedsigned* RawBuffer);
  75. static void                        Sample_StereoOut_StereoSamp_8BitIn_YesTime(SampleStateRec* State,
  76.                                                 long SampleCount, largefixedsigned* RawBuffer);
  77.  
  78. static void                        Sample_MonoOut_MonoSamp_16BitIn_YesTime(SampleStateRec* State,
  79.                                                 long SampleCount, largefixedsigned* RawBuffer);
  80. static void                        Sample_StereoOut_MonoSamp_16BitIn_YesTime(SampleStateRec* State,
  81.                                                 long SampleCount, largefixedsigned* RawBuffer);
  82. static void                        Sample_MonoOut_StereoSamp_16BitIn_YesTime(SampleStateRec* State,
  83.                                                 long SampleCount, largefixedsigned* RawBuffer);
  84. static void                        Sample_StereoOut_StereoSamp_16BitIn_YesTime(SampleStateRec* State,
  85.                                                 long SampleCount, largefixedsigned* RawBuffer);
  86.  
  87. static void                        Sample_NoOutput(SampleStateRec* State,
  88.                                                 long SampleCount, largefixedsigned* RawBuffer);
  89.  
  90.  
  91. /* this is used for loop control */
  92. typedef enum
  93.     {
  94.         eRepeatingLoop1 EXECUTE(= -18734),
  95.         eRepeatingLoop2,
  96.         eRepeatingLoop3,
  97.         eNoLoop,
  98.         eSampleFinished
  99.     } LoopType;
  100.  
  101.  
  102. /* sample oscillator template information record */
  103. struct SampleTemplateRec
  104.     {
  105.         /* source information for the sample */
  106.         MultiSampleRec*                SampleSourceSelector;
  107.  
  108.         /* sampling rate for final output */
  109.         long                                    FinalOutputSamplingRate;
  110.         /* number of envelope updates per second */
  111.         float                                    EnvelopeTicksPerSecond;
  112.  
  113.         /* values for scaling the frequency of something.  if we were really serious about */
  114.         /* this, we'd traverse all of the oscillators with integral multiples or harmonic */
  115.         /* fractions of the pitch & set their differentials to the same precision as the */
  116.         /* worst oscillator so that they would all stay in sync as time progressed. */
  117.         float                                    FrequencyMultiplier;
  118.  
  119.         /* stereo status */
  120.         NumChannelsType                StereoPlayback;
  121.         /* time interpolation flag */
  122.         MyBoolean                            InterpolateThroughTime;
  123.         /* inter-wave interpolation flag */
  124.         MyBoolean                            InterpolateAcrossWaves; /* not used now -- for future use */
  125.         /* include in final output flag */
  126.         MyBoolean                            IncludeInFinalOutput;
  127.  
  128.         /* envelope templates */
  129.         EnvelopeRec*                    LoudnessEnvelopeTemplate;
  130.         LFOListSpecRec*                LoudnessLFOTemplate;
  131.  
  132.         /* miscellaneous control parameters */
  133.         float                                    StereoBias;
  134.         float                                    TimeDisplacement;
  135.         float                                    OverallOscillatorLoudness;
  136.  
  137.         /* error logging facility */
  138.         ErrorDaemonRec*                ErrorDaemon;
  139.  
  140.         /* link for list control */
  141.         SampleTemplateRec*        Next;
  142.     };
  143.  
  144.  
  145. /* sample oscillator state record */
  146. struct SampleStateRec
  147.     {
  148.         /* current sample position into the array */
  149.         LongLongRec                        SamplePosition; /* 32-bit fixed point */
  150.         /* current increment value for the sample position */
  151.         LongLongRec                        SamplePositionDifferential; /* 32-bit fixed point */
  152.         /* envelope tick countdown for pre-start time */
  153.         long                                    PreStartCountdown;
  154.  
  155.         /* function for generating a bunch of sample points */
  156.         void                                    (*SampleGenSamples)(SampleStateRec* State,
  157.                                                         long SampleCount, largefixedsigned* RawBuffer);
  158.  
  159.         /* number of frames in the sample */
  160.         long                                    NumFrames;
  161.         /* sample data pointer.  for mono, it is just an array.  for stereo, the */
  162.         /* samples are interleaved, left channel first */
  163.         void*                                    Data;
  164.         /* number of bits in the data for the sample */
  165.         NumBitsType                        NumBits;
  166.         /* stereo or mono sample */
  167.         NumChannelsType                NumChannels;
  168.  
  169.         /* control parameters for the sample */
  170.         float                                    NaturalFrequency;
  171.         long                                    SamplingRate;
  172.         long                                    OriginPoint;
  173.         long                                    Loop1Start;
  174.         long                                    Loop2Start;
  175.         long                                    Loop3Start;
  176.         long                                    Loop1End;
  177.         long                                    Loop2End;
  178.         long                                    Loop3End;
  179.         /* state information for the current position */
  180.         LoopType                            LoopState; /* which loop is running */
  181.         long                                    CurrentLoopLength; /* current loop length (end - start) */
  182.         long                                    CurrentLoopEnd; /* current loop/total end point */
  183.  
  184.         /* NOTE:  either OverallLoudness or Left/RightLoudness are used, but not both */
  185.         /* current overall loudness for oscillator */
  186.         FastFixedType                    OverallLoudness; /* 15-bit fixed point, 0..1 */
  187.         /* left channel loudness */
  188.         FastFixedType                    LeftLoudness; /* 15-bit fixed point, 0..1 */
  189.         /* right channel loudness */
  190.         FastFixedType                    RightLoudness; /* 15-bit fixed point, 0..1 */
  191.         /* panning position for splitting envelope generator into stereo channels */
  192.         /* 0 = left channel, 0.5 = middle, 1 = right channel */
  193.         FastFixedType                    Panning; /* 15-bit fixed point, 0..1 */
  194.         /* envelope that is generating the loudness information */
  195.         /* the envelope is TOTALLY responsible for the loudness */
  196.         EvalEnvelopeRec*            SampleLoudnessEnvelope;
  197.         /* LFO generators modifying the output of the loudness envelope generator */
  198.         LFOGenRec*                        LoudnessLFOGenerator;
  199.  
  200.         /* this flag is True if the sample data was defined at the specified pitch */
  201.         /* (and the sample vectors are thus valid) or False if there is no sample */
  202.         /* at this pitch (and the arrays are invalid) */
  203.         MyBoolean                            SampleWasDefined;
  204.  
  205.         /* this is only used for modulation:  when modulating, the amplitude of the */
  206.         /* wave for modulation should not be affected by the output volume, but only by */
  207.         /* the envelope controlling modulation.  therefore, for modulation only, the */
  208.         /* loudness envelope does not include the effect of global volume scaling, and */
  209.         /* we use this field to handle that instead. */
  210.         float                                    NoteLoudnessScaling;
  211.  
  212.         /* static information for the sample */
  213.         SampleTemplateRec            Template; /* a copy of the data */
  214.  
  215.         /* this flag is true if we are doing modulation */
  216.         MyBoolean                            DoingModulation;
  217.  
  218.         /* link for list control */
  219.         SampleStateRec*                Next;
  220.     };
  221.  
  222.  
  223.  
  224.  
  225. static SampleTemplateRec*                SampleTemplateFreeList = NIL;
  226. static SampleStateRec*                    SampleStateFreeList = NIL;
  227.  
  228.  
  229. /* get rid of all cached memory for state or template records */
  230. void                                    FlushSampleOscControl(void)
  231.     {
  232.         while (SampleTemplateFreeList != NIL)
  233.             {
  234.                 SampleTemplateRec*    Temp;
  235.  
  236.                 Temp = SampleTemplateFreeList;
  237.                 SampleTemplateFreeList = SampleTemplateFreeList->Next;
  238.                 ReleasePtr((char*)Temp);
  239.             }
  240.  
  241.         while (SampleStateFreeList != NIL)
  242.             {
  243.                 SampleStateRec*            Temp;
  244.  
  245.                 Temp = SampleStateFreeList;
  246.                 SampleStateFreeList = SampleStateFreeList->Next;
  247.                 ReleasePtr((char*)Temp);
  248.             }
  249.     }
  250.  
  251.  
  252. #if DEBUG
  253. static void                        CheckValidSampleTemplate(SampleTemplateRec* Object)
  254.     {
  255.         SampleTemplateRec*    Scan;
  256.  
  257.         Scan = SampleTemplateFreeList;
  258.         while (Scan != NIL)
  259.             {
  260.                 if (Scan == Object)
  261.                     {
  262.                         PRERR(ForceAbort,"CheckValidSampleTemplate:  template is on free list");
  263.                     }
  264.                 Scan = Scan->Next;
  265.             }
  266.     }
  267. #else
  268. #define CheckValidSampleTemplate(x) ((void)0)
  269. #endif
  270.  
  271.  
  272. #if DEBUG
  273. static void                        CheckValidSampleState(SampleStateRec* Object)
  274.     {
  275.         SampleStateRec*            Scan;
  276.  
  277.         Scan = SampleStateFreeList;
  278.         while (Scan != NIL)
  279.             {
  280.                 if (Scan == Object)
  281.                     {
  282.                         PRERR(ForceAbort,"CheckValidSampleState:  state is on free list");
  283.                     }
  284.                 Scan = Scan->Next;
  285.             }
  286.     }
  287. #else
  288. #define CheckValidSampleState(x) ((void)0)
  289. #endif
  290.  
  291.  
  292. /* perform one envelope update cycle */
  293. void                                    UpdateSampleEnvelopes(SampleStateRec* State)
  294.     {
  295.         FastFixedType                Temp;
  296.  
  297.         CheckPtrExistence(State);
  298.         CheckValidSampleState(State);
  299.  
  300.         /* this is for the benefit of resampling only -- envelope generators do their */
  301.         /* own pre-origin sequencing */
  302.         if (State->PreStartCountdown > 0)
  303.             {
  304.                 State->PreStartCountdown -= 1;
  305.             }
  306.  
  307.         Temp = LFOGenUpdateCycle(State->LoudnessLFOGenerator,EnvelopeUpdate(
  308.             State->SampleLoudnessEnvelope));
  309.         /* fast fixed has a very narrow range, so overflow can't be permitted: */
  310.         /* 15x15->30 bits, with 2 extra bits; we use one for sign and the other */
  311.         /* to permit the representation of 1 and -1. */
  312.         if (State->Template.StereoPlayback == eSampleMono)
  313.             {
  314.                 if (Temp < - Int2FastFixed(1))
  315.                     {
  316.                         ErrorDaemonReportClamping(State->Template.ErrorDaemon,
  317.                             - FastFixed2Float(Temp));
  318.                         Temp = - Int2FastFixed(1);
  319.                     }
  320.                 else if (Temp > Int2FastFixed(1))
  321.                     {
  322.                         ErrorDaemonReportClamping(State->Template.ErrorDaemon,
  323.                             FastFixed2Float(Temp));
  324.                         Temp = Int2FastFixed(1);
  325.                     }
  326.                 State->OverallLoudness = Temp;
  327.             }
  328.          else
  329.             {
  330.                 FastFixedType                LeftVolumeScaling;
  331.                 FastFixedType                RightVolumeScaling;
  332.                 FastFixedType                MaxVolScaling;
  333.                 FastFixedType                MaxTemp;
  334.  
  335.                 LeftVolumeScaling = FastFixedTimesFastFixedToFastFixed(Double2FastFixed(0.5),
  336.                     Int2FastFixed(1) - State->Panning);
  337.                 RightVolumeScaling = FastFixedTimesFastFixedToFastFixed(Double2FastFixed(0.5),
  338.                     Int2FastFixed(1) + State->Panning);
  339.  
  340.                 if (((LeftVolumeScaling >= 0) ? LeftVolumeScaling : (- LeftVolumeScaling))
  341.                     > ((RightVolumeScaling >= 0) ? RightVolumeScaling : (- RightVolumeScaling)))
  342.                     {
  343.                         MaxVolScaling = ((LeftVolumeScaling >= 0)
  344.                             ? LeftVolumeScaling : (- LeftVolumeScaling));
  345.                     }
  346.                  else
  347.                     {
  348.                         MaxVolScaling = ((RightVolumeScaling >= 0)
  349.                             ? RightVolumeScaling : (- RightVolumeScaling));
  350.                     }
  351.                 MaxTemp = Double2FastFixed((float)1 / FastFixed2Float(MaxVolScaling));
  352.                 if (Temp < - MaxTemp)
  353.                     {
  354.                         ErrorDaemonReportClamping(State->Template.ErrorDaemon,
  355.                             - FastFixed2Float(Temp) / FastFixed2Float(MaxTemp));
  356.                         Temp = - MaxTemp;
  357.                     }
  358.                 else if (Temp > MaxTemp)
  359.                     {
  360.                         ErrorDaemonReportClamping(State->Template.ErrorDaemon,
  361.                             FastFixed2Float(Temp) / FastFixed2Float(MaxTemp));
  362.                         Temp = MaxTemp;
  363.                     }
  364.  
  365.                 State->LeftLoudness = FastFixedTimesFastFixedToFastFixed(
  366.                     LeftVolumeScaling,Temp);
  367.                 State->RightLoudness = FastFixedTimesFastFixedToFastFixed(
  368.                     RightVolumeScaling,Temp);
  369.             }
  370.     }
  371.  
  372.  
  373. /* dispose of the sample state record */
  374. void                                    DisposeSampleState(SampleStateRec* State)
  375.     {
  376.         CheckPtrExistence(State);
  377.         CheckValidSampleState(State);
  378.  
  379.         DisposeEnvelopeStateRecord(State->SampleLoudnessEnvelope);
  380.         DisposeLFOGenerator(State->LoudnessLFOGenerator);
  381.  
  382.         State->Next = SampleStateFreeList;
  383.         SampleStateFreeList = State;
  384.     }
  385.  
  386.  
  387. /* dispose of the sample information template */
  388. void                                    DisposeSampleTemplate(SampleTemplateRec* Template)
  389.     {
  390.         CheckPtrExistence(Template);
  391.         CheckValidSampleTemplate(Template);
  392.  
  393.         DisposeMultisample(Template->SampleSourceSelector);
  394.  
  395.         Template->Next = SampleTemplateFreeList;
  396.         SampleTemplateFreeList = Template;
  397.     }
  398.  
  399.  
  400. /* create a new sample template */
  401. SampleTemplateRec*        NewSampleTemplate(struct OscillatorRec* Oscillator,
  402.                                                 float EnvelopeTicksPerSecond, long SamplingRate,
  403.                                                 MyBoolean Stereo, MyBoolean TimeInterp, MyBoolean WaveInterp,
  404.                                                 ErrorDaemonRec* ErrorDaemon)
  405.     {
  406.         SampleTemplateRec*    Template;
  407.  
  408.         CheckPtrExistence(ErrorDaemon);
  409.         CheckPtrExistence(Oscillator);
  410.         ERROR(OscillatorGetWhatKindItIs(Oscillator) != eOscillatorSampled,PRERR(ForceAbort,
  411.             "NewSampleTemplate:  oscillator is not a sample"));
  412.  
  413.         if (SampleTemplateFreeList != NIL)
  414.             {
  415.                 Template = SampleTemplateFreeList;
  416.                 SampleTemplateFreeList = SampleTemplateFreeList->Next;
  417.             }
  418.          else
  419.             {
  420.                 Template = (SampleTemplateRec*)AllocPtrCanFail(sizeof(SampleTemplateRec),
  421.                     "SampleTemplateRec");
  422.                 if (Template == NIL)
  423.                     {
  424.                         return NIL;
  425.                     }
  426.             }
  427.         EXECUTE(Template->Next = (SampleTemplateRec*)0x81818181;)
  428.  
  429.         Template->SampleSourceSelector = NewMultisampleSample(
  430.             OscillatorGetSampleIntervalList(Oscillator));
  431.         if (Template->SampleSourceSelector == NIL)
  432.             {
  433.              FailurePoint1:
  434.                 Template->Next = SampleTemplateFreeList;
  435.                 SampleTemplateFreeList = Template;
  436.                 return NIL;
  437.             }
  438.  
  439.         Template->FinalOutputSamplingRate = SamplingRate;
  440.         Template->EnvelopeTicksPerSecond = EnvelopeTicksPerSecond;
  441.  
  442.         /* it might be better to handle divisor and multiplier separately -- we would */
  443.         /* want to do that if we were trying to guarantee that all harmonic */
  444.         /* oscillators ran in lock-step */
  445.         Template->FrequencyMultiplier = OscillatorGetFrequencyMultiplier(Oscillator)
  446.             / OscillatorGetFrequencyDivisor(Oscillator);
  447.  
  448.         Template->StereoBias = OscillatorGetStereoBias(Oscillator);
  449.         Template->TimeDisplacement = OscillatorGetTimeDisplacement(Oscillator);
  450.         Template->OverallOscillatorLoudness = OscillatorGetOutputLoudness(Oscillator);
  451.  
  452.         if (Stereo)
  453.             {
  454.                 Template->StereoPlayback = eSampleStereo;
  455.             }
  456.          else
  457.             {
  458.                 Template->StereoPlayback = eSampleMono;
  459.             }
  460.         Template->InterpolateThroughTime = TimeInterp;
  461.         Template->InterpolateAcrossWaves = WaveInterp;
  462.         Template->IncludeInFinalOutput = IncludeOscillatorInFinalOutput(Oscillator);
  463.  
  464.         /* these are just references */
  465.         Template->LoudnessEnvelopeTemplate = OscillatorGetLoudnessEnvelope(Oscillator);
  466.         Template->LoudnessLFOTemplate = OscillatorGetLoudnessLFOList(Oscillator);
  467.  
  468.         /* another reference */
  469.         Template->ErrorDaemon = ErrorDaemon;
  470.  
  471.         return Template;
  472.     }
  473.  
  474.  
  475. /* create a new sample state object. */
  476. SampleStateRec*                NewSampleState(SampleTemplateRec* Template,
  477.                                                 float FreqForMultisampling, float Accent1, float Accent2,
  478.                                                 float Accent3, float Accent4, float Loudness, float HurryUp,
  479.                                                 long* PreOriginTimeOut, float StereoPosition,
  480.                                                 float InitialFrequency, float LoudnessLFOAmplitudeScaling,
  481.                                                 float LoudnessLFOFrequencyScaling, MyBoolean DoingModulation)
  482.     {
  483.         SampleStateRec*            State;
  484.         long                                MaxPreOrigin;
  485.         long                                OnePreOrigin;
  486.         double                            NaturalFreqTemp;
  487.  
  488.         CheckPtrExistence(Template);
  489.         CheckValidSampleTemplate(Template);
  490.  
  491.         if (SampleStateFreeList != NIL)
  492.             {
  493.                 State = SampleStateFreeList;
  494.                 SampleStateFreeList = SampleStateFreeList->Next;
  495.             }
  496.          else
  497.             {
  498.                 State = (SampleStateRec*)AllocPtrCanFail(sizeof(SampleStateRec),
  499.                     "SampleStateRec");
  500.                 if (State == NIL)
  501.                     {
  502.                      FailurePoint1:
  503.                         return NIL;
  504.                     }
  505.             }
  506.         EXECUTE(State->Next = (SampleStateRec*)0x81818181;)
  507.  
  508.         State->Template = *Template;
  509.  
  510.         MaxPreOrigin = 0;
  511.  
  512.         Double2LongLong(0,State->SamplePosition);
  513.         /* State->SamplePositionDifferential is specified in a separate call */
  514.  
  515.         State->NoteLoudnessScaling = Loudness * Template->OverallOscillatorLoudness;
  516.  
  517.         State->DoingModulation = DoingModulation;
  518.  
  519.         State->SampleWasDefined = GetMultisampleReferenceSample(
  520.             Template->SampleSourceSelector,FreqForMultisampling,&(State->Data),
  521.             &(State->NumFrames),&(State->NumBits),&(State->NumChannels),&(State->Loop1Start),
  522.             &(State->Loop1End),&(State->Loop2Start),&(State->Loop2End),&(State->Loop3Start),
  523.             &(State->Loop3End),&(State->OriginPoint),&NaturalFreqTemp,&(State->SamplingRate));
  524.  
  525.         if (State->SampleWasDefined && (State->NumFrames > 0))
  526.             {
  527.                 /* copy value over */
  528.                 State->NaturalFrequency = NaturalFreqTemp;
  529.  
  530.                 /* bounds checking */
  531.                 if (State->Loop1Start < 0)
  532.                     {
  533.                         State->Loop1Start = 0;
  534.                     }
  535.                 if (State->Loop1End > State->NumFrames - 1)
  536.                     {
  537.                         State->Loop1End = State->NumFrames - 1;
  538.                     }
  539.                 if (State->Loop1End < State->Loop1Start)
  540.                     {
  541.                         State->Loop1End = State->Loop1Start;
  542.                     }
  543.                 if (State->Loop2Start < 0)
  544.                     {
  545.                         State->Loop2Start = 0;
  546.                     }
  547.                 if (State->Loop2End > State->NumFrames - 1)
  548.                     {
  549.                         State->Loop2End = State->NumFrames - 1;
  550.                     }
  551.                 if (State->Loop2End < State->Loop2Start)
  552.                     {
  553.                         State->Loop2End = State->Loop2Start;
  554.                     }
  555.                 if (State->Loop3Start < 0)
  556.                     {
  557.                         State->Loop3Start = 0;
  558.                     }
  559.                 if (State->Loop3End > State->NumFrames - 1)
  560.                     {
  561.                         State->Loop3End = State->NumFrames - 1;
  562.                     }
  563.                 if (State->Loop3End < State->Loop3Start)
  564.                     {
  565.                         State->Loop3End = State->Loop3Start;
  566.                     }
  567.  
  568.                 /* set the initial state */
  569.                 if (State->Loop1Start != State->Loop1End)
  570.                     {
  571.                         State->LoopState = eRepeatingLoop1;
  572.                         State->CurrentLoopEnd = State->Loop1End;
  573.                         State->CurrentLoopLength = State->Loop1End - State->Loop1Start;
  574.                     }
  575.                 else if (State->Loop2Start != State->Loop2End)
  576.                     {
  577.                         State->LoopState = eRepeatingLoop2;
  578.                         State->CurrentLoopEnd = State->Loop2End;
  579.                         State->CurrentLoopLength = State->Loop2End - State->Loop2Start;
  580.                     }
  581.                 else if (State->Loop3Start != State->Loop3End)
  582.                     {
  583.                         State->LoopState = eRepeatingLoop3;
  584.                         State->CurrentLoopEnd = State->Loop3End;
  585.                         State->CurrentLoopLength = State->Loop3End - State->Loop3Start;
  586.                     }
  587.                 else
  588.                     {
  589.                         State->LoopState = eNoLoop;
  590.                         State->CurrentLoopEnd = State->NumFrames;
  591.                         State->CurrentLoopLength = 0;
  592.                     }
  593.  
  594.                 /* compute how much time to wait before starting sample playback.  this */
  595.                 /* is INDEPENDENT of the envelope starting points; the envelope generator setup */
  596.                 /* handles origin alignment on its own. */
  597.                 /* this number will assume the origin starts NOW.  the fixup routine will */
  598.                 /* add some number to this so that the origin is properly determined. */
  599.                 /* if the countdown is still negative, then the sample will sound like it */
  600.                 /* is starting late.  the user can fix this by increasing the scanning gap. */
  601.                 State->PreStartCountdown = - (
  602.                     ((((float)State->OriginPoint / (InitialFrequency
  603.                         * Template->FrequencyMultiplier / State->NaturalFrequency))
  604.                         / State->SamplingRate) - Template->TimeDisplacement)
  605.                     * Template->EnvelopeTicksPerSecond + 0.5);
  606.                 if (- State->PreStartCountdown > MaxPreOrigin)
  607.                     {
  608.                         MaxPreOrigin = - State->PreStartCountdown;
  609.                     }
  610.             }
  611.          else
  612.             {
  613.                 /* no playback */
  614.                 State->LoopState = eSampleFinished;
  615.             }
  616.  
  617.         /* Template->IncludeInFinalOutput: */
  618.         /*   the routine pointer is not used for modulation */
  619.         /* State->SampleWasDefined: */
  620.         /*   if there is no sample defined for the current pitch, then we don't */
  621.         /*   bother generating any data */
  622.         /* State->NumFrames > 0: */
  623.         /*   if there is no data in the sample, then don't access the array */
  624.         if (Template->IncludeInFinalOutput && State->SampleWasDefined && (State->NumFrames > 0))
  625.             {
  626.                 if (Template->StereoPlayback == eSampleStereo) /* this is output stereo */
  627.                     {
  628.                         if (State->NumBits == eSample16bit)
  629.                             {
  630.                                 if (State->NumChannels == eSampleStereo) /* this is sample data stereo */
  631.                                     {
  632.                                         if (Template->InterpolateThroughTime)
  633.                                             {
  634.                                                 State->SampleGenSamples = Sample_StereoOut_StereoSamp_16BitIn_YesTime;
  635.                                             }
  636.                                          else
  637.                                             {
  638.                                                 State->SampleGenSamples = Sample_StereoOut_StereoSamp_16BitIn_NoTime;
  639.                                             }
  640.                                     }
  641.                                  else /* sample data mono */
  642.                                     {
  643.                                         if (Template->InterpolateThroughTime)
  644.                                             {
  645.                                                 State->SampleGenSamples = Sample_StereoOut_MonoSamp_16BitIn_YesTime;
  646.                                             }
  647.                                          else
  648.                                             {
  649.                                                 State->SampleGenSamples = Sample_StereoOut_MonoSamp_16BitIn_NoTime;
  650.                                             }
  651.                                     }
  652.                             }
  653.                          else /* output 8-bit */
  654.                             {
  655.                                 if (State->NumChannels == eSampleStereo) /* this is sample data stereo */
  656.                                     {
  657.                                         if (Template->InterpolateThroughTime)
  658.                                             {
  659.                                                 State->SampleGenSamples = Sample_StereoOut_StereoSamp_8BitIn_YesTime;
  660.                                             }
  661.                                          else
  662.                                             {
  663.                                                 State->SampleGenSamples = Sample_StereoOut_StereoSamp_8BitIn_NoTime;
  664.                                             }
  665.                                     }
  666.                                  else /* mono sample data */
  667.                                     {
  668.                                         if (Template->InterpolateThroughTime)
  669.                                             {
  670.                                                 State->SampleGenSamples = Sample_StereoOut_MonoSamp_8BitIn_YesTime;
  671.                                             }
  672.                                          else
  673.                                             {
  674.                                                 State->SampleGenSamples = Sample_StereoOut_MonoSamp_8BitIn_NoTime;
  675.                                             }
  676.                                     }
  677.                             }
  678.                     }
  679.                  else /* output mono */
  680.                     {
  681.                         if (State->NumBits == eSample16bit)
  682.                             {
  683.                                 if (State->NumChannels == eSampleStereo) /* this is sample data stereo */
  684.                                     {
  685.                                         if (Template->InterpolateThroughTime)
  686.                                             {
  687.                                                 State->SampleGenSamples = Sample_MonoOut_StereoSamp_16BitIn_YesTime;
  688.                                             }
  689.                                          else
  690.                                             {
  691.                                                 State->SampleGenSamples = Sample_MonoOut_StereoSamp_16BitIn_NoTime;
  692.                                             }
  693.                                     }
  694.                                  else /* sample data mono */
  695.                                     {
  696.                                         if (Template->InterpolateThroughTime)
  697.                                             {
  698.                                                 State->SampleGenSamples = Sample_MonoOut_MonoSamp_16BitIn_YesTime;
  699.                                             }
  700.                                          else
  701.                                             {
  702.                                                 State->SampleGenSamples = Sample_MonoOut_MonoSamp_16BitIn_NoTime;
  703.                                             }
  704.                                     }
  705.                             }
  706.                          else /* 8-bit */
  707.                             {
  708.                                 if (State->NumChannels == eSampleStereo) /* this is sample data stereo */
  709.                                     {
  710.                                         if (Template->InterpolateThroughTime)
  711.                                             {
  712.                                                 State->SampleGenSamples = Sample_MonoOut_StereoSamp_8BitIn_YesTime;
  713.                                             }
  714.                                          else
  715.                                             {
  716.                                                 State->SampleGenSamples = Sample_MonoOut_StereoSamp_8BitIn_NoTime;
  717.                                             }
  718.                                     }
  719.                                  else /* sample data mono */
  720.                                     {
  721.                                         if (Template->InterpolateThroughTime)
  722.                                             {
  723.                                                 State->SampleGenSamples = Sample_MonoOut_MonoSamp_8BitIn_YesTime;
  724.                                             }
  725.                                          else
  726.                                             {
  727.                                                 State->SampleGenSamples = Sample_MonoOut_MonoSamp_8BitIn_NoTime;
  728.                                             }
  729.                                     }
  730.                             }
  731.                     }
  732.             }
  733.          else
  734.             {
  735.                 State->SampleGenSamples = Sample_NoOutput;
  736.             }
  737.  
  738.         /* State->OverallLoudness, State->LeftLoudness, State->RightLoudness */
  739.         /* are determined by the envelope update */
  740.         StereoPosition += Template->StereoBias;
  741.         if (StereoPosition < -1)
  742.             {
  743.                 StereoPosition = -1;
  744.             }
  745.         else if (StereoPosition > 1)
  746.             {
  747.                 StereoPosition = 1;
  748.             }
  749.         State->Panning = Double2FastFixed(StereoPosition);
  750.         State->SampleLoudnessEnvelope = NewEnvelopeStateRecord(
  751.             Template->LoudnessEnvelopeTemplate,Accent1,Accent2,Accent3,Accent4,
  752.             InitialFrequency,DoingModulation ? 1 : State->NoteLoudnessScaling,HurryUp,
  753.             Template->EnvelopeTicksPerSecond,&OnePreOrigin);
  754.         if (State->SampleLoudnessEnvelope == NIL)
  755.             {
  756.              FailurePoint2:
  757.                 State->Next = SampleStateFreeList;
  758.                 SampleStateFreeList = State;
  759.                 goto FailurePoint1;
  760.             }
  761.         if (OnePreOrigin > MaxPreOrigin)
  762.             {
  763.                 MaxPreOrigin = OnePreOrigin;
  764.             }
  765.         State->LoudnessLFOGenerator = NewLFOGenerator(Template->LoudnessLFOTemplate,
  766.             &OnePreOrigin,Accent1,Accent2,Accent3,Accent4,InitialFrequency,HurryUp,
  767.             Template->EnvelopeTicksPerSecond,LoudnessLFOAmplitudeScaling,
  768.             LoudnessLFOFrequencyScaling,eLFOArithDefault,
  769.             DoingModulation ? 1 : State->NoteLoudnessScaling,FreqForMultisampling);
  770.         /* I forgot what to pass in for the last 2 parameters */
  771.         if (State->LoudnessLFOGenerator == NIL)
  772.             {
  773.              FailurePoint3:
  774.                 DisposeEnvelopeStateRecord(State->SampleLoudnessEnvelope);
  775.                 goto FailurePoint2;
  776.             }
  777.         if (OnePreOrigin > MaxPreOrigin)
  778.             {
  779.                 MaxPreOrigin = OnePreOrigin;
  780.             }
  781.  
  782.         *PreOriginTimeOut = MaxPreOrigin;
  783.         return State;
  784.     }
  785.  
  786.  
  787. /* fix up pre-origin time for the sample state object */
  788. void                                    FixUpSampleStatePreOrigin(SampleStateRec* State,
  789.                                                 long ActualPreOrigin)
  790.     {
  791.         CheckPtrExistence(State);
  792.         CheckValidSampleState(State);
  793.  
  794.         EnvelopeStateFixUpInitialDelay(State->SampleLoudnessEnvelope,ActualPreOrigin);
  795.         LFOGeneratorFixEnvelopeOrigins(State->LoudnessLFOGenerator,ActualPreOrigin);
  796.  
  797.         State->PreStartCountdown += ActualPreOrigin;
  798.     }
  799.  
  800.  
  801. /* set a new frequency for a state object.  used for portamento */
  802. /* and modulation of frequency (vibrato) */
  803. void                                    SampleStateNewFrequency(SampleStateRec* State,
  804.                                                 float NewFrequencyHertz)
  805.     {
  806.         CheckPtrExistence(State);
  807.         CheckValidSampleState(State);
  808.  
  809.         Double2LongLong((NewFrequencyHertz * State->Template.FrequencyMultiplier
  810.             / State->NaturalFrequency) / State->Template.FinalOutputSamplingRate
  811.             * State->SamplingRate,State->SamplePositionDifferential);
  812.     }
  813.  
  814.  
  815. /* send a key-up signal to one of the oscillators */
  816. void                                    SampleKeyUpSustain1(SampleStateRec* State)
  817.     {
  818.         CheckPtrExistence(State);
  819.         CheckValidSampleState(State);
  820.  
  821.         LFOGeneratorKeyUpSustain1(State->LoudnessLFOGenerator);
  822.         EnvelopeKeyUpSustain1(State->SampleLoudnessEnvelope);
  823.  
  824.         if (State->LoopState == eRepeatingLoop1)
  825.             {
  826.                 if (State->Loop2Start != State->Loop2End)
  827.                     {
  828.                         State->LoopState = eRepeatingLoop2;
  829.                         State->CurrentLoopEnd = State->Loop2End;
  830.                         State->CurrentLoopLength = State->Loop2End - State->Loop2Start;
  831.                     }
  832.                 else if (State->Loop3Start != State->Loop3End)
  833.                     {
  834.                         State->LoopState = eRepeatingLoop3;
  835.                         State->CurrentLoopEnd = State->Loop3End;
  836.                         State->CurrentLoopLength = State->Loop3End - State->Loop3Start;
  837.                     }
  838.                 else
  839.                     {
  840.                         State->LoopState = eNoLoop;
  841.                         State->CurrentLoopEnd = State->NumFrames;
  842.                         State->CurrentLoopLength = 0;
  843.                     }
  844.             }
  845.     }
  846.  
  847.  
  848. /* send a key-up signal to one of the oscillators */
  849. void                                    SampleKeyUpSustain2(SampleStateRec* State)
  850.     {
  851.         CheckPtrExistence(State);
  852.         CheckValidSampleState(State);
  853.  
  854.         LFOGeneratorKeyUpSustain2(State->LoudnessLFOGenerator);
  855.         EnvelopeKeyUpSustain2(State->SampleLoudnessEnvelope);
  856.  
  857.         if (/*(State->LoopState == eRepeatingLoop1)*/
  858.             /*||*/ (State->LoopState == eRepeatingLoop2))
  859.             {
  860.                 if (State->Loop3Start != State->Loop3End)
  861.                     {
  862.                         State->LoopState = eRepeatingLoop3;
  863.                         State->CurrentLoopEnd = State->Loop3End;
  864.                         State->CurrentLoopLength = State->Loop3End - State->Loop3Start;
  865.                     }
  866.                 else
  867.                     {
  868.                         State->LoopState = eNoLoop;
  869.                         State->CurrentLoopEnd = State->NumFrames;
  870.                         State->CurrentLoopLength = 0;
  871.                     }
  872.             }
  873.     }
  874.  
  875.  
  876. /* send a key-up signal to one of the oscillators */
  877. void                                    SampleKeyUpSustain3(SampleStateRec* State)
  878.     {
  879.         CheckPtrExistence(State);
  880.         CheckValidSampleState(State);
  881.  
  882.         LFOGeneratorKeyUpSustain3(State->LoudnessLFOGenerator);
  883.         EnvelopeKeyUpSustain3(State->SampleLoudnessEnvelope);
  884.  
  885.         if (/*(State->LoopState == eRepeatingLoop1)*/
  886.             /*|| (State->LoopState == eRepeatingLoop2)*/
  887.             /*||*/ (State->LoopState == eRepeatingLoop3))
  888.             {
  889.                 State->LoopState = eNoLoop;
  890.                 State->CurrentLoopEnd = State->NumFrames;
  891.                 State->CurrentLoopLength = 0;
  892.             }
  893.     }
  894.  
  895.  
  896. /* restart a sample oscillator.  this is used for tie continuations */
  897. void                                    RestartSampleState(SampleStateRec* State,
  898.                                                 float NewFreqMultisampling, float NewAccent1, float NewAccent2,
  899.                                                 float NewAccent3, float NewAccent4, float NewLoudness,
  900.                                                 float NewHurryUp, MyBoolean RetriggerEnvelopes,
  901.                                                 float NewStereoPosition, float NewInitialFrequency,
  902.                                                 float NewLoudnessLFOAmplitudeScaling,
  903.                                                 float NewLoudnessLFOFrequencyScaling)
  904.     {
  905.         CheckPtrExistence(State);
  906.         CheckValidSampleState(State);
  907.  
  908.         NewStereoPosition += State->Template.StereoBias;
  909.         if (NewStereoPosition < -1)
  910.             {
  911.                 NewStereoPosition = -1;
  912.             }
  913.         else if (NewStereoPosition > 1)
  914.             {
  915.                 NewStereoPosition = 1;
  916.             }
  917.         State->Panning = Double2FastFixed(NewStereoPosition);
  918.  
  919.         State->NoteLoudnessScaling = NewLoudness * State->Template.OverallOscillatorLoudness;
  920.  
  921.         EnvelopeRetriggerFromOrigin(State->SampleLoudnessEnvelope,NewAccent1,NewAccent2,
  922.             NewAccent3,NewAccent4,NewInitialFrequency,State->DoingModulation ? 1
  923.             : State->NoteLoudnessScaling,NewHurryUp,
  924.             State->Template.EnvelopeTicksPerSecond,RetriggerEnvelopes);
  925.         LFOGeneratorRetriggerFromOrigin(State->LoudnessLFOGenerator,NewAccent1,
  926.             NewAccent2,NewAccent3,NewAccent4,NewInitialFrequency,NewHurryUp,
  927.             State->Template.EnvelopeTicksPerSecond,NewLoudnessLFOAmplitudeScaling,
  928.             NewLoudnessLFOFrequencyScaling,RetriggerEnvelopes);
  929.     }
  930.  
  931.  
  932. /* generate a sequence of samples (called for each envelope clock) */
  933. void                                    SampleGenSamples(SampleStateRec* State,
  934.                                                 long SampleCount, largefixedsigned* RawBuffer)
  935.     {
  936.         CheckPtrExistence(State);
  937.         CheckValidSampleState(State);
  938.  
  939.         if (State->PreStartCountdown > 0)
  940.             {
  941.                 return;
  942.             }
  943.         if (State->LoopState != eSampleFinished)
  944.             {
  945.                 (*State->SampleGenSamples)(State,SampleCount,RawBuffer);
  946.             }
  947.     }
  948.  
  949.  
  950. /* find out if the sample oscillator has finished */
  951. MyBoolean                            SampleIsItFinished(SampleStateRec* State)
  952.     {
  953.         CheckPtrExistence(State);
  954.         CheckValidSampleState(State);
  955.  
  956.         /* we are finished when one of the following conditions is met: */
  957.         /*  - output volume is zero AND loudness envelope is finished */
  958.         /*  - we have run off the end of the sample */
  959.         /*  - we are not generating any signal */
  960.         if (!State->SampleWasDefined)
  961.             {
  962.                 return True;
  963.             }
  964.         if (State->LoopState == eSampleFinished)
  965.             {
  966.                 return True;
  967.             }
  968.         if (IsEnvelopeAtEnd(State->SampleLoudnessEnvelope))
  969.             {
  970.                 if (State->Template.StereoPlayback == eSampleStereo)
  971.                     {
  972.                         if ((State->LeftLoudness == 0) && (State->RightLoudness == 0))
  973.                             {
  974.                                 return True;
  975.                             }
  976.                     }
  977.                  else
  978.                     {
  979.                         if (State->OverallLoudness == 0)
  980.                             {
  981.                                 return True;
  982.                             }
  983.                     }
  984.             }
  985.  
  986.         return False;
  987.     }
  988.  
  989.  
  990. /* generate a single sample (called for modulation chains) */
  991. /* OutputPlace should have 1 entry for mono output or 2 entries for stereo output */
  992. float                                    SampleGenOneSample(SampleStateRec* State,
  993.                                                 ModulationTypes* PhaseGenModulateHow,
  994.                                                 float* PhaseGenModulationScaling,
  995.                                                 float* PhaseGenModulationOrigin,
  996.                                                 float* PhaseGenOldValues,
  997.                                                 long* PhaseGenIndirectionTable,
  998.                                                 long NumberOfPhaseGenModulators,
  999.                                                 ModulationTypes* OutputModulateHow,
  1000.                                                 float* OutputModulationScaling,
  1001.                                                 float* OutputModulationOrigin,
  1002.                                                 float* OutputOldValues,
  1003.                                                 long* OutputIndirectionTable,
  1004.                                                 long NumberOfOutputModulators,
  1005.                                                 largefixedsigned* OutputPlace)
  1006.     {
  1007.         float                                ReturnValue;
  1008.         LongLongRec                    FrameIndex;
  1009.         signed long                    FinalLeft; /* 16-bit value */
  1010.         signed long                    FinalRight; /* 16-bit value */
  1011.  
  1012.         CheckPtrExistence(State);
  1013.         CheckValidSampleState(State);
  1014.  
  1015.         if (!State->SampleWasDefined || (State->LoopState == eSampleFinished)
  1016.             || (State->NumFrames == 0) || (State->PreStartCountdown > 0))
  1017.             {
  1018.                 /* modulate against zero */
  1019.                 if (State->Template.StereoPlayback == eSampleStereo)
  1020.                     {
  1021.                         OutputPlace[0] += double2largefixed(ApplyModulation(0,OutputModulateHow,
  1022.                             OutputModulationScaling,OutputModulationOrigin,OutputOldValues,
  1023.                             OutputIndirectionTable,NumberOfOutputModulators));
  1024.                         OutputPlace[1] += double2largefixed(ApplyModulation(0,OutputModulateHow,
  1025.                             OutputModulationScaling,OutputModulationOrigin,OutputOldValues,
  1026.                             OutputIndirectionTable,NumberOfOutputModulators));
  1027.                     }
  1028.                  else
  1029.                     {
  1030.                         OutputPlace[0] += double2largefixed(ApplyModulation(0,OutputModulateHow,
  1031.                             OutputModulationScaling,OutputModulationOrigin,OutputOldValues,
  1032.                             OutputIndirectionTable,NumberOfOutputModulators));
  1033.                     }
  1034.                 return 0;
  1035.             }
  1036.  
  1037.         /* generate the sample position */
  1038.         /* we need to normalize the sample position to make modulation characteristics */
  1039.         /* independent on sampling rate.  this is done by normalizing the sample so that */
  1040.         /* a displacement of 1 corresponds to 1 second of evaluation time. */
  1041.         Double2LongLong(ApplyModulation(LongLong2Double(State->SamplePosition)
  1042.             / State->SamplingRate,PhaseGenModulateHow,PhaseGenModulationScaling,
  1043.             PhaseGenModulationOrigin,PhaseGenOldValues,PhaseGenIndirectionTable,
  1044.             NumberOfPhaseGenModulators) * State->SamplingRate,FrameIndex);
  1045.         /* ugh, phase modulation of a sample is nasty. */
  1046.         if (LongLongHighHalf(FrameIndex) < 0)
  1047.             {
  1048.                 LongLongSetHighHalf(FrameIndex,0);
  1049.             }
  1050.         if (LongLongHighHalf(FrameIndex) > State->NumFrames - 1)
  1051.             {
  1052.                 LongLongSetHighHalf(FrameIndex,State->NumFrames - 1);
  1053.             }
  1054.  
  1055.         if (State->NumChannels == eSampleStereo)
  1056.             {
  1057.                 /* stereo sample */
  1058.                 if (State->NumBits == eSample16bit)
  1059.                     {
  1060.                         /* stereo sample, 16 bit */
  1061.                         if (State->Template.InterpolateThroughTime)
  1062.                             {
  1063.                                 signed short*                SampleData;
  1064.                                 FastFixedType                LeftWeight;
  1065.                                 long                                ArraySubscript;
  1066.                                 signed long                    LeftValue;
  1067.                                 signed long                    RightValue;
  1068.  
  1069.                                 /* stereo sample, 16 bit, interpolate */
  1070.                                 SampleData = (signed short*)State->Data;
  1071.                                 /* L+F(R-L) */
  1072.                                 LeftWeight = LongLongLowHalf(FrameIndex) >> (32 - FASTFIXEDPRECISION);
  1073.                                 ArraySubscript = LongLongHighHalf(FrameIndex);
  1074.                                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 0)]),
  1075.                                     sizeof(SampleData[2 * (ArraySubscript + 0)]));
  1076.                                 LeftValue = SampleData[2 * (ArraySubscript + 0)];
  1077.                                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1)]),
  1078.                                     sizeof(SampleData[2 * (ArraySubscript + 1)]));
  1079.                                 RightValue = SampleData[2 * (ArraySubscript + 1)];
  1080.                                 FinalLeft = LeftValue + ((LeftWeight * (RightValue - LeftValue)) >> 15);
  1081.                                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 0) + 1]),
  1082.                                     sizeof(SampleData[2 * (ArraySubscript + 0) + 1]));
  1083.                                 LeftValue = SampleData[2 * (ArraySubscript + 0) + 1];
  1084.                                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1) + 1]),
  1085.                                     sizeof(SampleData[2 * (ArraySubscript + 1) + 1]));
  1086.                                 RightValue = SampleData[2 * (ArraySubscript + 1) + 1];
  1087.                                 FinalRight = LeftValue + ((LeftWeight * (RightValue - LeftValue)) >> 15);
  1088.                             }
  1089.                          else
  1090.                             {
  1091.                                 signed short*                SampleData;
  1092.  
  1093.                                 /* stereo output, stereo sample, 16 bit, truncate */
  1094.                                 SampleData = (signed short*)State->Data;
  1095.                                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(
  1096.                                     FrameIndex) + 0]),sizeof(SampleData[2
  1097.                                     * LongLongHighHalf(FrameIndex) + 0]));
  1098.                                 FinalLeft = SampleData[2 * LongLongHighHalf(FrameIndex) + 0];
  1099.                                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(
  1100.                                     FrameIndex) + 1]),sizeof(SampleData[2
  1101.                                     * LongLongHighHalf(FrameIndex) + 1]));
  1102.                                 FinalRight = SampleData[2 * LongLongHighHalf(FrameIndex) + 1];
  1103.                             }
  1104.                     }
  1105.                  else
  1106.                     {
  1107.                         /* stereo sample, 8 bit */
  1108.                         if (State->Template.InterpolateThroughTime)
  1109.                             {
  1110.                                 signed char*                SampleData;
  1111.                                 FastFixedType                LeftWeight;
  1112.                                 long                                ArraySubscript;
  1113.                                 signed long                    LeftValue;
  1114.                                 signed long                    RightValue;
  1115.  
  1116.                                 /* stereo sample, 8 bit, interpolate */
  1117.                                 SampleData = (signed char*)State->Data;
  1118.                                 /* L+F(R-L) */
  1119.                                 LeftWeight = LongLongLowHalf(FrameIndex) >> (32 - FASTFIXEDPRECISION);
  1120.                                 ArraySubscript = LongLongHighHalf(FrameIndex);
  1121.                                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 0)]),
  1122.                                     sizeof(SampleData[2 * (ArraySubscript + 0)]));
  1123.                                 LeftValue = ((signed long)SampleData[2 * (ArraySubscript + 0)]) << 8; /* convert to 16-bit */
  1124.                                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1)]),
  1125.                                     sizeof(SampleData[2 * (ArraySubscript + 1)]));
  1126.                                 RightValue = ((signed long)SampleData[2 * (ArraySubscript + 1)]) << 8; /* to 16-bit */
  1127.                                 FinalLeft = LeftValue + ((LeftWeight * (RightValue - LeftValue)) >> 15);
  1128.                                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 0) + 1]),
  1129.                                     sizeof(SampleData[2 * (ArraySubscript + 0) + 1]));
  1130.                                 LeftValue = ((signed long)SampleData[2 * (ArraySubscript + 0) + 1]) << 8; /* convert to 16-bit */
  1131.                                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1) + 1]),
  1132.                                     sizeof(SampleData[2 * (ArraySubscript + 1) + 1]));
  1133.                                 RightValue = ((signed long)SampleData[2 * (ArraySubscript + 1) + 1]) << 8; /* to 16-bit */
  1134.                                 FinalRight = LeftValue + ((LeftWeight * (RightValue - LeftValue)) >> 15);
  1135.                             }
  1136.                          else
  1137.                             {
  1138.                                 signed char*                SampleData;
  1139.  
  1140.                                 /* stereo sample, 8 bit, truncate */
  1141.                                 SampleData = (signed char*)State->Data;
  1142.                                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(
  1143.                                     FrameIndex) + 0]),sizeof(SampleData[2
  1144.                                     * LongLongHighHalf(FrameIndex) + 0]));
  1145.                                 FinalLeft = SampleData[2 * LongLongHighHalf(FrameIndex) + 0];
  1146.                                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(
  1147.                                     FrameIndex) + 1]),sizeof(SampleData[2
  1148.                                     * LongLongHighHalf(FrameIndex) + 1]));
  1149.                                 FinalRight = SampleData[2 * LongLongHighHalf(FrameIndex) + 1];
  1150.                             }
  1151.                     }
  1152.             }
  1153.          else
  1154.             {
  1155.                 /* mono sample */
  1156.                 if (State->NumBits == eSample16bit)
  1157.                     {
  1158.                         /* mono sample, 16 bit */
  1159.                         if (State->Template.InterpolateThroughTime)
  1160.                             {
  1161.                                 signed short*                SampleData;
  1162.                                 FastFixedType                LeftWeight;
  1163.                                 long                                ArraySubscript;
  1164.                                 signed long                    LeftValue;
  1165.                                 signed long                    RightValue;
  1166.  
  1167.                                 /* mono sample, 16 bit, interpolate */
  1168.                                 SampleData = (signed short*)State->Data;
  1169.                                 /* L+F(R-L) */
  1170.                                 LeftWeight = LongLongLowHalf(FrameIndex) >> (32 - FASTFIXEDPRECISION);
  1171.                                 ArraySubscript = LongLongHighHalf(FrameIndex);
  1172.                                 PRNGCHK(SampleData,&(SampleData[ArraySubscript]),
  1173.                                     sizeof(SampleData[ArraySubscript]));
  1174.                                 LeftValue = SampleData[ArraySubscript];
  1175.                                 PRNGCHK(SampleData,&(SampleData[ArraySubscript + 1]),
  1176.                                     sizeof(SampleData[ArraySubscript + 1]));
  1177.                                 RightValue = SampleData[ArraySubscript + 1];
  1178.                                 FinalLeft = LeftValue + ((LeftWeight * (RightValue - LeftValue)) >> 15);
  1179.                                 FinalRight = FinalLeft;
  1180.                             }
  1181.                          else
  1182.                             {
  1183.                                 signed short*                SampleData;
  1184.  
  1185.                                 /* mono sample, 16 bit, truncate */
  1186.                                 SampleData = (signed short*)State->Data;
  1187.                                 PRNGCHK(SampleData,&(SampleData[LongLongHighHalf(
  1188.                                     FrameIndex)]),sizeof(SampleData[LongLongHighHalf(
  1189.                                     FrameIndex)]));
  1190.                                 FinalLeft = SampleData[LongLongHighHalf(FrameIndex)];
  1191.                                 FinalRight = FinalLeft;
  1192.                             }
  1193.                     }
  1194.                  else
  1195.                     {
  1196.                         /* mono sample, 8 bit */
  1197.                         if (State->Template.InterpolateThroughTime)
  1198.                             {
  1199.                                 signed char*                SampleData;
  1200.                                 FastFixedType                LeftWeight;
  1201.                                 long                                ArraySubscript;
  1202.                                 signed long                    LeftValue;
  1203.                                 signed long                    RightValue;
  1204.  
  1205.                                 /* mono sample, 8 bit, interpolate */
  1206.                                 SampleData = (signed char*)State->Data;
  1207.                                 /* L+F(R-L) */
  1208.                                 LeftWeight = LongLongLowHalf(FrameIndex) >> (32 - FASTFIXEDPRECISION);
  1209.                                 ArraySubscript = LongLongHighHalf(FrameIndex);
  1210.                                 PRNGCHK(SampleData,&(SampleData[ArraySubscript]),
  1211.                                     sizeof(SampleData[ArraySubscript]));
  1212.                                 LeftValue = ((signed long)SampleData[ArraySubscript]) << 8; /* convert to 16-bit */
  1213.                                 PRNGCHK(SampleData,&(SampleData[ArraySubscript + 1]),
  1214.                                     sizeof(SampleData[ArraySubscript + 1]));
  1215.                                 RightValue = ((signed long)SampleData[ArraySubscript + 1]) << 8; /* to 16-bit */
  1216.                                 FinalLeft = LeftValue + ((LeftWeight * (RightValue - LeftValue)) >> 15);
  1217.                                 FinalRight = FinalLeft;
  1218.                             }
  1219.                          else
  1220.                             {
  1221.                                 signed char*                SampleData;
  1222.  
  1223.                                 /* stereo output, mono sample, 8 bit, truncate */
  1224.                                 SampleData = (signed char*)State->Data;
  1225.                                 PRNGCHK(SampleData,&(SampleData[LongLongHighHalf(
  1226.                                     FrameIndex)]),sizeof(SampleData[LongLongHighHalf(
  1227.                                         FrameIndex)]));
  1228.                                 FinalLeft = SampleData[LongLongHighHalf(FrameIndex)];
  1229.                                 FinalRight = FinalLeft;
  1230.                             }
  1231.                     }
  1232.             }
  1233.  
  1234.         if (State->Template.StereoPlayback == eSampleStereo)
  1235.             {
  1236.                 ReturnValue = (((float)((FinalLeft + FinalRight) / 2)) / MAX16BIT)
  1237.                     * ((FastFixed2Float(State->LeftLoudness)
  1238.                     + FastFixed2Float(State->RightLoudness)) / 2);
  1239.                 if (State->Template.IncludeInFinalOutput)
  1240.                     {
  1241.                         OutputPlace[0] += double2largefixed(ApplyModulation(largefixed2single(
  1242.                             FastFixedTimes16BitTo24Bit((signed long)(State->LeftLoudness
  1243.                             * State->NoteLoudnessScaling),FinalLeft)),OutputModulateHow,
  1244.                             OutputModulationScaling,OutputModulationOrigin,OutputOldValues,
  1245.                             OutputIndirectionTable,NumberOfOutputModulators));;
  1246.                         OutputPlace[1] += double2largefixed(ApplyModulation(largefixed2single(
  1247.                             FastFixedTimes16BitTo24Bit((signed long)(State->RightLoudness
  1248.                             * State->NoteLoudnessScaling),FinalRight)),OutputModulateHow,
  1249.                             OutputModulationScaling,OutputModulationOrigin,OutputOldValues,
  1250.                             OutputIndirectionTable,NumberOfOutputModulators));
  1251.                     }
  1252.             }
  1253.          else
  1254.             {
  1255.                 ReturnValue = (((float)((FinalLeft + FinalRight) / 2)) / MAX16BIT)
  1256.                     * FastFixed2Float(State->OverallLoudness);
  1257.                 if (State->Template.IncludeInFinalOutput)
  1258.                     {
  1259.                         OutputPlace[0] += double2largefixed(ApplyModulation(largefixed2single(
  1260.                             FastFixedTimes16BitTo24Bit((signed long)(State->OverallLoudness
  1261.                             * State->NoteLoudnessScaling),((FinalLeft + FinalRight) / 2))),
  1262.                             OutputModulateHow,OutputModulationScaling,OutputModulationOrigin,
  1263.                             OutputOldValues,OutputIndirectionTable,NumberOfOutputModulators));
  1264.                     }
  1265.             }
  1266.  
  1267.         LongLongAdd(&State->SamplePosition,&State->SamplePositionDifferential);
  1268.      CheapDoLoop:
  1269.         if (LongLongHighHalf(State->SamplePosition) >= State->CurrentLoopEnd)
  1270.             {
  1271.                 if (State->LoopState != eNoLoop)
  1272.                     {
  1273.                         /* handle loop */
  1274.                         LongLongSetHighHalf(State->SamplePosition,LongLongHighHalf(
  1275.                             State->SamplePosition) - State->CurrentLoopLength);
  1276.                         goto CheapDoLoop;
  1277.                     }
  1278.                  else
  1279.                     {
  1280.                         /* end of sample -- terminate */
  1281.                         State->LoopState = eSampleFinished;
  1282.                         goto BreakLoopPoint;
  1283.                     }
  1284.             }
  1285.      BreakLoopPoint:
  1286.         ;
  1287.  
  1288.         return ReturnValue;
  1289.     }
  1290.  
  1291.  
  1292. static void                        Sample_MonoOut_MonoSamp_8BitIn_NoTime(SampleStateRec* State,
  1293.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1294.     {
  1295.         LongLongRec                    LocalSamplePosition;
  1296.         LongLongRec                    LocalSamplePositionDifferential;
  1297.         long                                LocalCurrentLoopEnd;
  1298.         FastFixedType                LocalOverallLoudness;
  1299.         signed char*                SampleData;
  1300.  
  1301.         LocalOverallLoudness = State->OverallLoudness;
  1302.         LocalSamplePosition = State->SamplePosition;
  1303.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1304.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1305.         SampleData = (signed char*)State->Data;
  1306.  
  1307.         while (SampleCount > 0)
  1308.             {
  1309.                 PRNGCHK(SampleData,&(SampleData[LongLongHighHalf(LocalSamplePosition)]),
  1310.                     sizeof(SampleData[LongLongHighHalf(LocalSamplePosition)]));
  1311.                 *(RawBuffer++) += FastFixedTimes8BitTo24Bit(LocalOverallLoudness,
  1312.                     SampleData[LongLongHighHalf(LocalSamplePosition)]);
  1313.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1314.              CheapDoLoop:
  1315.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1316.                     {
  1317.                         if (State->LoopState != eNoLoop)
  1318.                             {
  1319.                                 /* handle loop */
  1320.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1321.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1322.                                 goto CheapDoLoop;
  1323.                             }
  1324.                          else
  1325.                             {
  1326.                                 /* end of sample -- terminate */
  1327.                                 State->LoopState = eSampleFinished;
  1328.                                 goto BreakLoopPoint;
  1329.                             }
  1330.                     }
  1331.                 SampleCount -= 1;
  1332.             }
  1333.      BreakLoopPoint:
  1334.         ;
  1335.  
  1336.         State->SamplePosition = LocalSamplePosition;
  1337.     }
  1338.  
  1339.  
  1340. static void                        Sample_StereoOut_MonoSamp_8BitIn_NoTime(SampleStateRec* State,
  1341.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1342.     {
  1343.         LongLongRec                    LocalSamplePosition;
  1344.         LongLongRec                    LocalSamplePositionDifferential;
  1345.         long                                LocalCurrentLoopEnd;
  1346.         FastFixedType                LocalLeftLoudness;
  1347.         FastFixedType                LocalRightLoudness;
  1348.         signed char*                SampleData;
  1349.  
  1350.         LocalLeftLoudness = State->LeftLoudness;
  1351.         LocalRightLoudness = State->RightLoudness;
  1352.         LocalSamplePosition = State->SamplePosition;
  1353.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1354.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1355.         SampleData = (signed char*)State->Data;
  1356.  
  1357.         while (SampleCount > 0)
  1358.             {
  1359.                 signed long                    SamplePoint;
  1360.  
  1361.                 PRNGCHK(SampleData,&(SampleData[LongLongHighHalf(LocalSamplePosition)]),
  1362.                     sizeof(SampleData[LongLongHighHalf(LocalSamplePosition)]));
  1363.                 SamplePoint = SampleData[LongLongHighHalf(LocalSamplePosition)];
  1364.                 *(RawBuffer++) += FastFixedTimes8BitTo24Bit(LocalLeftLoudness,SamplePoint);
  1365.                 *(RawBuffer++) += FastFixedTimes8BitTo24Bit(LocalRightLoudness,SamplePoint);
  1366.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1367.              CheapDoLoop:
  1368.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1369.                     {
  1370.                         if (State->LoopState != eNoLoop)
  1371.                             {
  1372.                                 /* handle loop */
  1373.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1374.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1375.                                 goto CheapDoLoop;
  1376.                             }
  1377.                          else
  1378.                             {
  1379.                                 /* end of sample -- terminate */
  1380.                                 State->LoopState = eSampleFinished;
  1381.                                 goto BreakLoopPoint;
  1382.                             }
  1383.                     }
  1384.                 SampleCount -= 1;
  1385.             }
  1386.      BreakLoopPoint:
  1387.         ;
  1388.  
  1389.         State->SamplePosition = LocalSamplePosition;
  1390.     }
  1391.  
  1392.  
  1393. static void                        Sample_MonoOut_StereoSamp_8BitIn_NoTime(SampleStateRec* State,
  1394.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1395.     {
  1396.         LongLongRec                    LocalSamplePosition;
  1397.         LongLongRec                    LocalSamplePositionDifferential;
  1398.         long                                LocalCurrentLoopEnd;
  1399.         FastFixedType                LocalOverallLoudness;
  1400.         signed char*                SampleData;
  1401.  
  1402.         LocalOverallLoudness = State->OverallLoudness;
  1403.         LocalSamplePosition = State->SamplePosition;
  1404.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1405.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1406.         SampleData = (signed char*)State->Data;
  1407.  
  1408.         while (SampleCount > 0)
  1409.             {
  1410.                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]),
  1411.                     sizeof(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]));
  1412.                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]),
  1413.                     sizeof(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]));
  1414.                 *(RawBuffer++) += FastFixedTimes8BitTo24Bit(LocalOverallLoudness,
  1415.                     ((signed long)SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]
  1416.                     + (signed long)SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]) >> 1);
  1417.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1418.              CheapDoLoop:
  1419.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1420.                     {
  1421.                         if (State->LoopState != eNoLoop)
  1422.                             {
  1423.                                 /* handle loop */
  1424.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1425.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1426.                                 goto CheapDoLoop;
  1427.                             }
  1428.                          else
  1429.                             {
  1430.                                 /* end of sample -- terminate */
  1431.                                 State->LoopState = eSampleFinished;
  1432.                                 goto BreakLoopPoint;
  1433.                             }
  1434.                     }
  1435.                 SampleCount -= 1;
  1436.             }
  1437.      BreakLoopPoint:
  1438.         ;
  1439.  
  1440.         State->SamplePosition = LocalSamplePosition;
  1441.     }
  1442.  
  1443.  
  1444. static void                        Sample_StereoOut_StereoSamp_8BitIn_NoTime(SampleStateRec* State,
  1445.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1446.     {
  1447.         LongLongRec                    LocalSamplePosition;
  1448.         LongLongRec                    LocalSamplePositionDifferential;
  1449.         long                                LocalCurrentLoopEnd;
  1450.         FastFixedType                LocalLeftLoudness;
  1451.         FastFixedType                LocalRightLoudness;
  1452.         signed char*                SampleData;
  1453.  
  1454.         LocalLeftLoudness = State->LeftLoudness;
  1455.         LocalRightLoudness = State->RightLoudness;
  1456.         LocalSamplePosition = State->SamplePosition;
  1457.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1458.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1459.         SampleData = (signed char*)State->Data;
  1460.  
  1461.         while (SampleCount > 0)
  1462.             {
  1463.                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]),
  1464.                     sizeof(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]));
  1465.                 *(RawBuffer++) += FastFixedTimes8BitTo24Bit(LocalLeftLoudness,
  1466.                     (signed long)SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]);
  1467.                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]),
  1468.                     sizeof(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]));
  1469.                 *(RawBuffer++) += FastFixedTimes8BitTo24Bit(LocalRightLoudness,
  1470.                     (signed long)SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]);
  1471.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1472.              CheapDoLoop:
  1473.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1474.                     {
  1475.                         if (State->LoopState != eNoLoop)
  1476.                             {
  1477.                                 /* handle loop */
  1478.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1479.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1480.                                 goto CheapDoLoop;
  1481.                             }
  1482.                          else
  1483.                             {
  1484.                                 /* end of sample -- terminate */
  1485.                                 State->LoopState = eSampleFinished;
  1486.                                 goto BreakLoopPoint;
  1487.                             }
  1488.                     }
  1489.                 SampleCount -= 1;
  1490.             }
  1491.      BreakLoopPoint:
  1492.         ;
  1493.  
  1494.         State->SamplePosition = LocalSamplePosition;
  1495.     }
  1496.  
  1497.  
  1498. static void                        Sample_MonoOut_MonoSamp_16BitIn_NoTime(SampleStateRec* State,
  1499.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1500.     {
  1501.         LongLongRec                    LocalSamplePosition;
  1502.         LongLongRec                    LocalSamplePositionDifferential;
  1503.         long                                LocalCurrentLoopEnd;
  1504.         FastFixedType                LocalOverallLoudness;
  1505.         signed short*                SampleData;
  1506.  
  1507.         LocalOverallLoudness = State->OverallLoudness;
  1508.         LocalSamplePosition = State->SamplePosition;
  1509.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1510.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1511.         SampleData = (signed short*)State->Data;
  1512.  
  1513.         while (SampleCount > 0)
  1514.             {
  1515.                 PRNGCHK(SampleData,&(SampleData[LongLongHighHalf(LocalSamplePosition)]),
  1516.                     sizeof(SampleData[LongLongHighHalf(LocalSamplePosition)]));
  1517.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalOverallLoudness,
  1518.                     SampleData[LongLongHighHalf(LocalSamplePosition)]);
  1519.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1520.              CheapDoLoop:
  1521.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1522.                     {
  1523.                         if (State->LoopState != eNoLoop)
  1524.                             {
  1525.                                 /* handle loop */
  1526.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1527.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1528.                                 goto CheapDoLoop;
  1529.                             }
  1530.                          else
  1531.                             {
  1532.                                 /* end of sample -- terminate */
  1533.                                 State->LoopState = eSampleFinished;
  1534.                                 goto BreakLoopPoint;
  1535.                             }
  1536.                     }
  1537.                 SampleCount -= 1;
  1538.             }
  1539.      BreakLoopPoint:
  1540.         ;
  1541.  
  1542.         State->SamplePosition = LocalSamplePosition;
  1543.     }
  1544.  
  1545.  
  1546. static void                        Sample_StereoOut_MonoSamp_16BitIn_NoTime(SampleStateRec* State,
  1547.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1548.     {
  1549.         LongLongRec                    LocalSamplePosition;
  1550.         LongLongRec                    LocalSamplePositionDifferential;
  1551.         long                                LocalCurrentLoopEnd;
  1552.         FastFixedType                LocalLeftLoudness;
  1553.         FastFixedType                LocalRightLoudness;
  1554.         signed short*                SampleData;
  1555.  
  1556.         LocalLeftLoudness = State->LeftLoudness;
  1557.         LocalRightLoudness = State->RightLoudness;
  1558.         LocalSamplePosition = State->SamplePosition;
  1559.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1560.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1561.         SampleData = (signed short*)State->Data;
  1562.  
  1563.         while (SampleCount > 0)
  1564.             {
  1565.                 signed long                    SamplePoint;
  1566.  
  1567.                 PRNGCHK(SampleData,&(SampleData[LongLongHighHalf(LocalSamplePosition)]),
  1568.                     sizeof(SampleData[LongLongHighHalf(LocalSamplePosition)]));
  1569.                 SamplePoint = SampleData[LongLongHighHalf(LocalSamplePosition)];
  1570.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalLeftLoudness,SamplePoint);
  1571.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalRightLoudness,SamplePoint);
  1572.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1573.              CheapDoLoop:
  1574.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1575.                     {
  1576.                         if (State->LoopState != eNoLoop)
  1577.                             {
  1578.                                 /* handle loop */
  1579.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1580.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1581.                                 goto CheapDoLoop;
  1582.                             }
  1583.                          else
  1584.                             {
  1585.                                 /* end of sample -- terminate */
  1586.                                 State->LoopState = eSampleFinished;
  1587.                                 goto BreakLoopPoint;
  1588.                             }
  1589.                     }
  1590.                 SampleCount -= 1;
  1591.             }
  1592.      BreakLoopPoint:
  1593.         ;
  1594.  
  1595.         State->SamplePosition = LocalSamplePosition;
  1596.     }
  1597.  
  1598.  
  1599. static void                        Sample_MonoOut_StereoSamp_16BitIn_NoTime(SampleStateRec* State,
  1600.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1601.     {
  1602.         LongLongRec                    LocalSamplePosition;
  1603.         LongLongRec                    LocalSamplePositionDifferential;
  1604.         long                                LocalCurrentLoopEnd;
  1605.         FastFixedType                LocalOverallLoudness;
  1606.         signed short*                SampleData;
  1607.  
  1608.         LocalOverallLoudness = State->OverallLoudness;
  1609.         LocalSamplePosition = State->SamplePosition;
  1610.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1611.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1612.         SampleData = (signed short*)State->Data;
  1613.  
  1614.         while (SampleCount > 0)
  1615.             {
  1616.                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]),
  1617.                     sizeof(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]));
  1618.                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]),
  1619.                     sizeof(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]));
  1620.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalOverallLoudness,
  1621.                     ((signed long)SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]
  1622.                     + (signed long)SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]) >> 1);
  1623.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1624.              CheapDoLoop:
  1625.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1626.                     {
  1627.                         if (State->LoopState != eNoLoop)
  1628.                             {
  1629.                                 /* handle loop */
  1630.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1631.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1632.                                 goto CheapDoLoop;
  1633.                             }
  1634.                          else
  1635.                             {
  1636.                                 /* end of sample -- terminate */
  1637.                                 State->LoopState = eSampleFinished;
  1638.                                 goto BreakLoopPoint;
  1639.                             }
  1640.                     }
  1641.                 SampleCount -= 1;
  1642.             }
  1643.      BreakLoopPoint:
  1644.         ;
  1645.  
  1646.         State->SamplePosition = LocalSamplePosition;
  1647.     }
  1648.  
  1649.  
  1650. static void                        Sample_StereoOut_StereoSamp_16BitIn_NoTime(SampleStateRec* State,
  1651.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1652.     {
  1653.         LongLongRec                    LocalSamplePosition;
  1654.         LongLongRec                    LocalSamplePositionDifferential;
  1655.         long                                LocalCurrentLoopEnd;
  1656.         FastFixedType                LocalLeftLoudness;
  1657.         FastFixedType                LocalRightLoudness;
  1658.         signed short*                SampleData;
  1659.  
  1660.         LocalLeftLoudness = State->LeftLoudness;
  1661.         LocalRightLoudness = State->RightLoudness;
  1662.         LocalSamplePosition = State->SamplePosition;
  1663.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1664.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1665.         SampleData = (signed short*)State->Data;
  1666.  
  1667.         while (SampleCount > 0)
  1668.             {
  1669.                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]),
  1670.                     sizeof(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]));
  1671.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalLeftLoudness,
  1672.                     (signed long)SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 0]);
  1673.                 PRNGCHK(SampleData,&(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]),
  1674.                     sizeof(SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]));
  1675.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalRightLoudness,
  1676.                     (signed long)SampleData[2 * LongLongHighHalf(LocalSamplePosition) + 1]);
  1677.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1678.              CheapDoLoop:
  1679.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1680.                     {
  1681.                         if (State->LoopState != eNoLoop)
  1682.                             {
  1683.                                 /* handle loop */
  1684.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1685.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1686.                                 goto CheapDoLoop;
  1687.                             }
  1688.                          else
  1689.                             {
  1690.                                 /* end of sample -- terminate */
  1691.                                 State->LoopState = eSampleFinished;
  1692.                                 goto BreakLoopPoint;
  1693.                             }
  1694.                     }
  1695.                 SampleCount -= 1;
  1696.             }
  1697.      BreakLoopPoint:
  1698.         ;
  1699.  
  1700.         State->SamplePosition = LocalSamplePosition;
  1701.     }
  1702.  
  1703.  
  1704. static void                        Sample_MonoOut_MonoSamp_8BitIn_YesTime(SampleStateRec* State,
  1705.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1706.     {
  1707.         LongLongRec                    LocalSamplePosition;
  1708.         LongLongRec                    LocalSamplePositionDifferential;
  1709.         long                                LocalCurrentLoopEnd;
  1710.         FastFixedType                LocalOverallLoudness;
  1711.         signed char*                SampleData;
  1712.  
  1713.         LocalOverallLoudness = State->OverallLoudness;
  1714.         LocalSamplePosition = State->SamplePosition;
  1715.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1716.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1717.         SampleData = (signed char*)State->Data;
  1718.  
  1719.         while (SampleCount > 0)
  1720.             {
  1721.                 FastFixedType                LeftWeight;
  1722.                 long                                ArraySubscript;
  1723.                 signed long                    LeftValue;
  1724.                 signed long                    RightValue;
  1725.  
  1726.                 /* L+F(R-L) */
  1727.                 LeftWeight = LongLongLowHalf(LocalSamplePosition) >> (32 - FASTFIXEDPRECISION);
  1728.                 ArraySubscript = LongLongHighHalf(LocalSamplePosition);
  1729.                 PRNGCHK(SampleData,&(SampleData[ArraySubscript]),
  1730.                     sizeof(SampleData[ArraySubscript]));
  1731.                 LeftValue = ((signed long)SampleData[ArraySubscript]) << 8; /* convert to 16-bit */
  1732.                 PRNGCHK(SampleData,&(SampleData[ArraySubscript + 1]),
  1733.                     sizeof(SampleData[ArraySubscript + 1]));
  1734.                 RightValue = ((signed long)SampleData[ArraySubscript + 1]) << 8; /* to 16-bit */
  1735.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalOverallLoudness,LeftValue
  1736.                     + ((LeftWeight * (RightValue - LeftValue)) >> 15));
  1737.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1738.              CheapDoLoop:
  1739.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1740.                     {
  1741.                         if (State->LoopState != eNoLoop)
  1742.                             {
  1743.                                 /* handle loop */
  1744.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1745.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1746.                                 goto CheapDoLoop;
  1747.                             }
  1748.                          else
  1749.                             {
  1750.                                 /* end of sample -- terminate */
  1751.                                 State->LoopState = eSampleFinished;
  1752.                                 goto BreakLoopPoint;
  1753.                             }
  1754.                     }
  1755.                 SampleCount -= 1;
  1756.             }
  1757.      BreakLoopPoint:
  1758.         ;
  1759.  
  1760.         State->SamplePosition = LocalSamplePosition;
  1761.     }
  1762.  
  1763.  
  1764. static void                        Sample_StereoOut_MonoSamp_8BitIn_YesTime(SampleStateRec* State,
  1765.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1766.     {
  1767.         LongLongRec                    LocalSamplePosition;
  1768.         LongLongRec                    LocalSamplePositionDifferential;
  1769.         long                                LocalCurrentLoopEnd;
  1770.         FastFixedType                LocalLeftLoudness;
  1771.         FastFixedType                LocalRightLoudness;
  1772.         signed char*                SampleData;
  1773.  
  1774.         LocalLeftLoudness = State->LeftLoudness;
  1775.         LocalRightLoudness = State->RightLoudness;
  1776.         LocalSamplePosition = State->SamplePosition;
  1777.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1778.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1779.         SampleData = (signed char*)State->Data;
  1780.  
  1781.         while (SampleCount > 0)
  1782.             {
  1783.                 FastFixedType                LeftWeight;
  1784.                 long                                ArraySubscript;
  1785.                 signed long                    LeftValue;
  1786.                 signed long                    RightValue;
  1787.                 signed long                    CombinedValue;
  1788.  
  1789.                 /* L+F(R-L) */
  1790.                 LeftWeight = LongLongLowHalf(LocalSamplePosition) >> (32 - FASTFIXEDPRECISION);
  1791.                 ArraySubscript = LongLongHighHalf(LocalSamplePosition);
  1792.                 PRNGCHK(SampleData,&(SampleData[ArraySubscript]),
  1793.                     sizeof(SampleData[ArraySubscript]));
  1794.                 LeftValue = ((signed long)SampleData[ArraySubscript]) << 8; /* convert to 16-bit */
  1795.                 PRNGCHK(SampleData,&(SampleData[ArraySubscript + 1]),
  1796.                     sizeof(SampleData[ArraySubscript + 1]));
  1797.                 RightValue = ((signed long)SampleData[ArraySubscript + 1]) << 8; /* to 16-bit */
  1798.                 CombinedValue = LeftValue + ((LeftWeight * (RightValue - LeftValue)) >> 15);
  1799.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalLeftLoudness,CombinedValue);
  1800.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalRightLoudness,CombinedValue);
  1801.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1802.              CheapDoLoop:
  1803.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1804.                     {
  1805.                         if (State->LoopState != eNoLoop)
  1806.                             {
  1807.                                 /* handle loop */
  1808.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1809.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1810.                                 goto CheapDoLoop;
  1811.                             }
  1812.                          else
  1813.                             {
  1814.                                 /* end of sample -- terminate */
  1815.                                 State->LoopState = eSampleFinished;
  1816.                                 goto BreakLoopPoint;
  1817.                             }
  1818.                     }
  1819.                 SampleCount -= 1;
  1820.             }
  1821.      BreakLoopPoint:
  1822.         ;
  1823.  
  1824.         State->SamplePosition = LocalSamplePosition;
  1825.     }
  1826.  
  1827.  
  1828. static void                        Sample_MonoOut_StereoSamp_8BitIn_YesTime(SampleStateRec* State,
  1829.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1830.     {
  1831.         LongLongRec                    LocalSamplePosition;
  1832.         LongLongRec                    LocalSamplePositionDifferential;
  1833.         long                                LocalCurrentLoopEnd;
  1834.         FastFixedType                LocalOverallLoudness;
  1835.         signed char*                SampleData;
  1836.  
  1837.         LocalOverallLoudness = State->OverallLoudness;
  1838.         LocalSamplePosition = State->SamplePosition;
  1839.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1840.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1841.         SampleData = (signed char*)State->Data;
  1842.  
  1843.         while (SampleCount > 0)
  1844.             {
  1845.                 FastFixedType                LeftWeight;
  1846.                 long                                ArraySubscript;
  1847.                 signed long                    LeftValue;
  1848.                 signed long                    RightValue;
  1849.  
  1850.                 /* L+F(R-L) */
  1851.                 LeftWeight = LongLongLowHalf(LocalSamplePosition) >> (32 - FASTFIXEDPRECISION);
  1852.                 ArraySubscript = LongLongHighHalf(LocalSamplePosition);
  1853.                 PRNGCHK(SampleData,&(SampleData[2 * ArraySubscript + 0]),
  1854.                     sizeof(SampleData[2 * ArraySubscript + 0]));
  1855.                 PRNGCHK(SampleData,&(SampleData[2 * ArraySubscript + 1]),
  1856.                     sizeof(SampleData[2 * ArraySubscript + 1]));
  1857.                 LeftValue = ((signed long)SampleData[2 * ArraySubscript + 0]
  1858.                     + (signed long)SampleData[2 * ArraySubscript + 1]) << 7; /* convert to 16-bit */
  1859.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1) + 0]),
  1860.                     sizeof(SampleData[2 * (ArraySubscript + 1) + 0]));
  1861.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1) + 1]),
  1862.                     sizeof(SampleData[2 * (ArraySubscript + 1) + 1]));
  1863.                 RightValue = ((signed long)SampleData[2 * (ArraySubscript + 1) + 0]
  1864.                     + (signed long)SampleData[2 * (ArraySubscript + 1) + 1]) << 7; /* to 16-bit */
  1865.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalOverallLoudness,LeftValue
  1866.                     + ((LeftWeight * (RightValue - LeftValue)) >> 15));
  1867.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1868.              CheapDoLoop:
  1869.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1870.                     {
  1871.                         if (State->LoopState != eNoLoop)
  1872.                             {
  1873.                                 /* handle loop */
  1874.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1875.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1876.                                 goto CheapDoLoop;
  1877.                             }
  1878.                          else
  1879.                             {
  1880.                                 /* end of sample -- terminate */
  1881.                                 State->LoopState = eSampleFinished;
  1882.                                 goto BreakLoopPoint;
  1883.                             }
  1884.                     }
  1885.                 SampleCount -= 1;
  1886.             }
  1887.      BreakLoopPoint:
  1888.         ;
  1889.  
  1890.         State->SamplePosition = LocalSamplePosition;
  1891.     }
  1892.  
  1893.  
  1894. static void                        Sample_StereoOut_StereoSamp_8BitIn_YesTime(SampleStateRec* State,
  1895.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1896.     {
  1897.         LongLongRec                    LocalSamplePosition;
  1898.         LongLongRec                    LocalSamplePositionDifferential;
  1899.         long                                LocalCurrentLoopEnd;
  1900.         FastFixedType                LocalLeftLoudness;
  1901.         FastFixedType                LocalRightLoudness;
  1902.         signed char*                SampleData;
  1903.  
  1904.         LocalLeftLoudness = State->LeftLoudness;
  1905.         LocalRightLoudness = State->RightLoudness;
  1906.         LocalSamplePosition = State->SamplePosition;
  1907.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1908.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1909.         SampleData = (signed char*)State->Data;
  1910.  
  1911.         while (SampleCount > 0)
  1912.             {
  1913.                 FastFixedType                LeftWeight;
  1914.                 long                                ArraySubscript;
  1915.                 signed long                    LeftValue;
  1916.                 signed long                    RightValue;
  1917.  
  1918.                 /* L+F(R-L) */
  1919.                 LeftWeight = LongLongLowHalf(LocalSamplePosition) >> (32 - FASTFIXEDPRECISION);
  1920.                 ArraySubscript = LongLongHighHalf(LocalSamplePosition);
  1921.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 0)]),
  1922.                     sizeof(SampleData[2 * (ArraySubscript + 0)]));
  1923.                 LeftValue = ((signed long)SampleData[2 * (ArraySubscript + 0)]) << 8; /* convert to 16-bit */
  1924.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1)]),
  1925.                     sizeof(SampleData[2 * (ArraySubscript + 1)]));
  1926.                 RightValue = ((signed long)SampleData[2 * (ArraySubscript + 1)]) << 8; /* to 16-bit */
  1927.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalLeftLoudness,LeftValue
  1928.                     + ((LeftWeight * (RightValue - LeftValue)) >> 15));
  1929.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 0) + 1]),
  1930.                     sizeof(SampleData[2 * (ArraySubscript + 0) + 1]));
  1931.                 LeftValue = ((signed long)SampleData[2 * (ArraySubscript + 0) + 1]) << 8; /* convert to 16-bit */
  1932.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1) + 1]),
  1933.                     sizeof(SampleData[2 * (ArraySubscript + 1) + 1]));
  1934.                 RightValue = ((signed long)SampleData[2 * (ArraySubscript + 1) + 1]) << 8; /* to 16-bit */
  1935.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalRightLoudness,LeftValue
  1936.                     + ((LeftWeight * (RightValue - LeftValue)) >> 15));
  1937.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1938.              CheapDoLoop:
  1939.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  1940.                     {
  1941.                         if (State->LoopState != eNoLoop)
  1942.                             {
  1943.                                 /* handle loop */
  1944.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  1945.                                     LocalSamplePosition) - State->CurrentLoopLength);
  1946.                                 goto CheapDoLoop;
  1947.                             }
  1948.                          else
  1949.                             {
  1950.                                 /* end of sample -- terminate */
  1951.                                 State->LoopState = eSampleFinished;
  1952.                                 goto BreakLoopPoint;
  1953.                             }
  1954.                     }
  1955.                 SampleCount -= 1;
  1956.             }
  1957.      BreakLoopPoint:
  1958.         ;
  1959.  
  1960.         State->SamplePosition = LocalSamplePosition;
  1961.     }
  1962.  
  1963.  
  1964. static void                        Sample_MonoOut_MonoSamp_16BitIn_YesTime(SampleStateRec* State,
  1965.                                                 long SampleCount, largefixedsigned* RawBuffer)
  1966.     {
  1967.         LongLongRec                    LocalSamplePosition;
  1968.         LongLongRec                    LocalSamplePositionDifferential;
  1969.         long                                LocalCurrentLoopEnd;
  1970.         FastFixedType                LocalOverallLoudness;
  1971.         signed short*                SampleData;
  1972.  
  1973.         LocalOverallLoudness = State->OverallLoudness;
  1974.         LocalSamplePosition = State->SamplePosition;
  1975.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  1976.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  1977.         SampleData = (signed short*)State->Data;
  1978.  
  1979.         while (SampleCount > 0)
  1980.             {
  1981.                 FastFixedType                LeftWeight;
  1982.                 long                                ArraySubscript;
  1983.                 signed long                    LeftValue;
  1984.                 signed long                    RightValue;
  1985.  
  1986.                 /* L+F(R-L) */
  1987.                 LeftWeight = LongLongLowHalf(LocalSamplePosition) >> (32 - FASTFIXEDPRECISION);
  1988.                 ArraySubscript = LongLongHighHalf(LocalSamplePosition);
  1989.                 PRNGCHK(SampleData,&(SampleData[ArraySubscript]),
  1990.                     sizeof(SampleData[ArraySubscript]));
  1991.                 LeftValue = SampleData[ArraySubscript];
  1992.                 PRNGCHK(SampleData,&(SampleData[ArraySubscript + 1]),
  1993.                     sizeof(SampleData[ArraySubscript + 1]));
  1994.                 RightValue = SampleData[ArraySubscript + 1];
  1995.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalOverallLoudness,LeftValue
  1996.                     + ((LeftWeight * (RightValue - LeftValue)) >> 15));
  1997.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  1998.              CheapDoLoop:
  1999.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  2000.                     {
  2001.                         if (State->LoopState != eNoLoop)
  2002.                             {
  2003.                                 /* handle loop */
  2004.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  2005.                                     LocalSamplePosition) - State->CurrentLoopLength);
  2006.                                 goto CheapDoLoop;
  2007.                             }
  2008.                          else
  2009.                             {
  2010.                                 /* end of sample -- terminate */
  2011.                                 State->LoopState = eSampleFinished;
  2012.                                 goto BreakLoopPoint;
  2013.                             }
  2014.                     }
  2015.                 SampleCount -= 1;
  2016.             }
  2017.      BreakLoopPoint:
  2018.         ;
  2019.  
  2020.         State->SamplePosition = LocalSamplePosition;
  2021.     }
  2022.  
  2023.  
  2024. static void                        Sample_StereoOut_MonoSamp_16BitIn_YesTime(SampleStateRec* State,
  2025.                                                 long SampleCount, largefixedsigned* RawBuffer)
  2026.     {
  2027.         LongLongRec                    LocalSamplePosition;
  2028.         LongLongRec                    LocalSamplePositionDifferential;
  2029.         long                                LocalCurrentLoopEnd;
  2030.         FastFixedType                LocalLeftLoudness;
  2031.         FastFixedType                LocalRightLoudness;
  2032.         signed short*                SampleData;
  2033.  
  2034.         LocalLeftLoudness = State->LeftLoudness;
  2035.         LocalRightLoudness = State->RightLoudness;
  2036.         LocalSamplePosition = State->SamplePosition;
  2037.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  2038.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  2039.         SampleData = (signed short*)State->Data;
  2040.  
  2041.         while (SampleCount > 0)
  2042.             {
  2043.                 FastFixedType                LeftWeight;
  2044.                 long                                ArraySubscript;
  2045.                 signed long                    LeftValue;
  2046.                 signed long                    RightValue;
  2047.                 signed long                    CombinedValue;
  2048.  
  2049.                 /* L+F(R-L) */
  2050.                 LeftWeight = LongLongLowHalf(LocalSamplePosition) >> (32 - FASTFIXEDPRECISION);
  2051.                 ArraySubscript = LongLongHighHalf(LocalSamplePosition);
  2052.                 PRNGCHK(SampleData,&(SampleData[ArraySubscript]),
  2053.                     sizeof(SampleData[ArraySubscript]));
  2054.                 LeftValue = SampleData[ArraySubscript];
  2055.                 PRNGCHK(SampleData,&(SampleData[ArraySubscript + 1]),
  2056.                     sizeof(SampleData[ArraySubscript + 1]));
  2057.                 RightValue = SampleData[ArraySubscript + 1];
  2058.                 CombinedValue = LeftValue + ((LeftWeight * (RightValue - LeftValue)) >> 15);
  2059.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalLeftLoudness,CombinedValue);
  2060.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalRightLoudness,CombinedValue);
  2061.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  2062.              CheapDoLoop:
  2063.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  2064.                     {
  2065.                         if (State->LoopState != eNoLoop)
  2066.                             {
  2067.                                 /* handle loop */
  2068.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  2069.                                     LocalSamplePosition) - State->CurrentLoopLength);
  2070.                                 goto CheapDoLoop;
  2071.                             }
  2072.                          else
  2073.                             {
  2074.                                 /* end of sample -- terminate */
  2075.                                 State->LoopState = eSampleFinished;
  2076.                                 goto BreakLoopPoint;
  2077.                             }
  2078.                     }
  2079.                 SampleCount -= 1;
  2080.             }
  2081.      BreakLoopPoint:
  2082.         ;
  2083.  
  2084.         State->SamplePosition = LocalSamplePosition;
  2085.     }
  2086.  
  2087.  
  2088. static void                        Sample_MonoOut_StereoSamp_16BitIn_YesTime(SampleStateRec* State,
  2089.                                                 long SampleCount, largefixedsigned* RawBuffer)
  2090.     {
  2091.         LongLongRec                    LocalSamplePosition;
  2092.         LongLongRec                    LocalSamplePositionDifferential;
  2093.         long                                LocalCurrentLoopEnd;
  2094.         FastFixedType                LocalOverallLoudness;
  2095.         signed short*                SampleData;
  2096.  
  2097.         LocalOverallLoudness = State->OverallLoudness;
  2098.         LocalSamplePosition = State->SamplePosition;
  2099.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  2100.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  2101.         SampleData = (signed short*)State->Data;
  2102.  
  2103.         while (SampleCount > 0)
  2104.             {
  2105.                 FastFixedType                LeftWeight;
  2106.                 long                                ArraySubscript;
  2107.                 signed long                    LeftValue;
  2108.                 signed long                    RightValue;
  2109.  
  2110.                 /* L+F(R-L) */
  2111.                 LeftWeight = LongLongLowHalf(LocalSamplePosition) >> (32 - FASTFIXEDPRECISION);
  2112.                 ArraySubscript = LongLongHighHalf(LocalSamplePosition);
  2113.                 PRNGCHK(SampleData,&(SampleData[2 * ArraySubscript + 0]),
  2114.                     sizeof(SampleData[2 * ArraySubscript + 0]));
  2115.                 PRNGCHK(SampleData,&(SampleData[2 * ArraySubscript + 1]),
  2116.                     sizeof(SampleData[2 * ArraySubscript + 1]));
  2117.                 LeftValue = ((signed long)SampleData[2 * ArraySubscript + 0]
  2118.                     + (signed long)SampleData[2 * ArraySubscript + 1]) >> 1;
  2119.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1) + 0]),
  2120.                     sizeof(SampleData[2 * (ArraySubscript + 1) + 0]));
  2121.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1) + 1]),
  2122.                     sizeof(SampleData[2 * (ArraySubscript + 1) + 1]));
  2123.                 RightValue = ((signed long)SampleData[2 * (ArraySubscript + 1) + 0]
  2124.                     + (signed long)SampleData[2 * (ArraySubscript + 1) + 1]) >> 1;
  2125.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalOverallLoudness,LeftValue
  2126.                     + ((LeftWeight * (RightValue - LeftValue)) >> 15));
  2127.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  2128.              CheapDoLoop:
  2129.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  2130.                     {
  2131.                         if (State->LoopState != eNoLoop)
  2132.                             {
  2133.                                 /* handle loop */
  2134.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  2135.                                     LocalSamplePosition) - State->CurrentLoopLength);
  2136.                                 goto CheapDoLoop;
  2137.                             }
  2138.                          else
  2139.                             {
  2140.                                 /* end of sample -- terminate */
  2141.                                 State->LoopState = eSampleFinished;
  2142.                                 goto BreakLoopPoint;
  2143.                             }
  2144.                     }
  2145.                 SampleCount -= 1;
  2146.             }
  2147.      BreakLoopPoint:
  2148.         ;
  2149.  
  2150.         State->SamplePosition = LocalSamplePosition;
  2151.     }
  2152.  
  2153.  
  2154. static void                        Sample_StereoOut_StereoSamp_16BitIn_YesTime(SampleStateRec* State,
  2155.                                                 long SampleCount, largefixedsigned* RawBuffer)
  2156.     {
  2157.         LongLongRec                    LocalSamplePosition;
  2158.         LongLongRec                    LocalSamplePositionDifferential;
  2159.         long                                LocalCurrentLoopEnd;
  2160.         FastFixedType                LocalLeftLoudness;
  2161.         FastFixedType                LocalRightLoudness;
  2162.         signed short*                SampleData;
  2163.  
  2164.         LocalLeftLoudness = State->LeftLoudness;
  2165.         LocalRightLoudness = State->RightLoudness;
  2166.         LocalSamplePosition = State->SamplePosition;
  2167.         LocalSamplePositionDifferential = State->SamplePositionDifferential;
  2168.         LocalCurrentLoopEnd = State->CurrentLoopEnd;
  2169.         SampleData = (signed short*)State->Data;
  2170.  
  2171.         while (SampleCount > 0)
  2172.             {
  2173.                 FastFixedType                LeftWeight;
  2174.                 long                                ArraySubscript;
  2175.                 signed long                    LeftValue;
  2176.                 signed long                    RightValue;
  2177.  
  2178.                 /* L+F(R-L) */
  2179.                 LeftWeight = LongLongLowHalf(LocalSamplePosition) >> (32 - FASTFIXEDPRECISION);
  2180.                 ArraySubscript = LongLongHighHalf(LocalSamplePosition);
  2181.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 0)]),
  2182.                     sizeof(SampleData[2 * (ArraySubscript + 0)]));
  2183.                 LeftValue = SampleData[2 * (ArraySubscript + 0)];
  2184.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1)]),
  2185.                     sizeof(SampleData[2 * (ArraySubscript + 1)]));
  2186.                 RightValue = SampleData[2 * (ArraySubscript + 1)];
  2187.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalLeftLoudness,LeftValue
  2188.                     + ((LeftWeight * (RightValue - LeftValue)) >> 15));
  2189.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 0) + 1]),
  2190.                     sizeof(SampleData[2 * (ArraySubscript + 0) + 1]));
  2191.                 LeftValue = SampleData[2 * (ArraySubscript + 0) + 1];
  2192.                 PRNGCHK(SampleData,&(SampleData[2 * (ArraySubscript + 1) + 1]),
  2193.                     sizeof(SampleData[2 * (ArraySubscript + 1) + 1]));
  2194.                 RightValue = SampleData[2 * (ArraySubscript + 1) + 1];
  2195.                 *(RawBuffer++) += FastFixedTimes16BitTo24Bit(LocalRightLoudness,LeftValue
  2196.                     + ((LeftWeight * (RightValue - LeftValue)) >> 15));
  2197.                 LongLongAdd(&LocalSamplePosition,&LocalSamplePositionDifferential);
  2198.              CheapDoLoop:
  2199.                 if (LongLongHighHalf(LocalSamplePosition) >= LocalCurrentLoopEnd)
  2200.                     {
  2201.                         if (State->LoopState != eNoLoop)
  2202.                             {
  2203.                                 /* handle loop */
  2204.                                 LongLongSetHighHalf(LocalSamplePosition,LongLongHighHalf(
  2205.                                     LocalSamplePosition) - State->CurrentLoopLength);
  2206.                                 goto CheapDoLoop;
  2207.                             }
  2208.                          else
  2209.                             {
  2210.                                 /* end of sample -- terminate */
  2211.                                 State->LoopState = eSampleFinished;
  2212.                                 goto BreakLoopPoint;
  2213.                             }
  2214.                     }
  2215.                 SampleCount -= 1;
  2216.             }
  2217.      BreakLoopPoint:
  2218.         ;
  2219.  
  2220.         State->SamplePosition = LocalSamplePosition;
  2221.     }
  2222.  
  2223.  
  2224. static void                        Sample_NoOutput(SampleStateRec* State,
  2225.                                                 long SampleCount, largefixedsigned* RawBuffer)
  2226.     {
  2227.     }
  2228.