开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > Windows CE > 查看源码
output.cpp
资源名称：SMDK2440.rar　[点击查看]
上传用户：qiulin1960
上传日期：2013-10-16
资源大小：2844k
文件大小：16k
源码类别：

Windows CE

开发平台：

Windows_Unix

output.cpp：源码内容
  1. // -----------------------------------------------------------------------------
  2. //
  3. //      THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
  4. //      ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
  5. //      THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
  6. //      PARTICULAR PURPOSE.
  7. //      Copyright (c) 1995-2000 Microsoft Corporation.  All rights reserved.
  8. //
  9. // -----------------------------------------------------------------------------
  10. #include "wavemain.h"
  12. HRESULT OutputStreamContext::Open(DeviceContext *pDeviceContext, LPWAVEOPENDESC lpWOD, DWORD dwFlags)
  13. {
  14.     HRESULT Result;
  16.     Result = WaveStreamContext::Open(pDeviceContext, lpWOD, dwFlags);
  18.     if (Result==MMSYSERR_NOERROR)
  19.     {
  20.         // Note: Output streams should be initialized in the run state.
  21.         Run();
  22.     }
  24.     return Result;
  25. }
  27. DWORD OutputStreamContext::Reset()
  28. {
  29.     HRESULT Result;
  31.     Result = WaveStreamContext::Reset();
  33.     if (Result==MMSYSERR_NOERROR)
  34.     {
  35.         // Note: Output streams should be reset to the run state.
  36.         Run();
  37.     }
  39.     return Result;
  40. };
  42. // Init m_DeltaT with (SampleRate/HWSampleRate) calculated in 24.8 fixed point form
  43. // Note that we need to hold the result in a 64-bit value until we're done shifting,
  44. // since the result of the multiply will overflow 32 bits for sample rates greater than
  45. // or equal to the hardware's sample rate.
  46. DWORD OutputStreamContext::SetRate(DWORD dwMultiplier)
  47. {
  48.     m_dwMultiplier = dwMultiplier;
  50.     UINT64 Delta = (m_WaveFormat.nSamplesPerSec * m_dwMultiplier) >> 16;
  51.     Delta = (Delta * INVSAMPLERATE) >> 24;  // Convert to 24.8 format
  52.     m_DeltaT = (DWORD)Delta;
  53.     return MMSYSERR_NOERROR;
  54. }
  56. // Originally, this code used to be in each renderer, and each one would call GetNextBuffer as needed.
  57. // Pulling this code out of each low level renderer allows the inner loop to be in a leaf routine (ie no
  58. // subroutine calls out of that routine), which helps the compiler optimize the inner loop.
  59. PBYTE WaveStreamContext::Render(PBYTE pBuffer, PBYTE pBufferEnd, PBYTE pBufferLast)
  60. {
  61.     if (!m_bRunning || !m_lpCurrData)
  62.     {
  63.         return pBuffer;
  64.     }
  66.     while (pBuffer < pBufferEnd)
  67.     {
  68.         while (m_lpCurrData>=m_lpCurrDataEnd)
  69.         {
  70.             if (!GetNextBuffer())
  71.             {
  72.                 return pBuffer;
  73.             }
  74.         }
  76.         pBuffer = Render2(pBuffer,pBufferEnd,pBufferLast);
  77.     }
  79.     return pBuffer;
  80. }
  82. PBYTE OutputStreamContextM8::Render2(PBYTE pBuffer, PBYTE pBufferEnd, PBYTE pBufferLast)
  83. {
  84.     LONG CurrT = m_CurrT;
  85.     LONG DeltaT = m_DeltaT;
  86.     LONG CurrSamp0 = m_CurrSamp[0];
  87.     LONG PrevSamp0 = m_PrevSamp[0];
  88.     PBYTE pCurrData = m_lpCurrData;
  89.     PBYTE pCurrDataEnd = m_lpCurrDataEnd;
  90.     LONG fxpGain = m_fxpGain;
  92.     while (pBuffer < pBufferEnd)
  93.     {
  94.         while (CurrT >= 0x100)
  95.         {
  96.             if (pCurrData>=pCurrDataEnd)
  97.             {
  98.                 goto Exit;
  99.             }
  101.             CurrT -= 0x100;
  103.             PrevSamp0 = CurrSamp0;
  105.             PPCM_SAMPLE pSampleSrc = (PPCM_SAMPLE)pCurrData;
  106.             CurrSamp0 = (LONG)pSampleSrc->m8.sample;
  107.             CurrSamp0 = (CurrSamp0 - 128) << 8;
  108.             pCurrData+=1;
  109.         }
  111.         LONG OutSamp0;
  112.         OutSamp0 = PrevSamp0 + (((CurrSamp0 - PrevSamp0) * CurrT) >> 8);
  113.         OutSamp0 = (OutSamp0 * fxpGain) >> VOLSHIFT;
  114.         CurrT += DeltaT;
  116. #if (OUTCHANNELS==2)
  117.         LONG OutSamp1;
  118.         OutSamp1=OutSamp0;
  119.         if (pBuffer < pBufferLast)
  120.         {
  121.             OutSamp0 += ((HWSAMPLE *)pBuffer)[0];
  122.             OutSamp1 += ((HWSAMPLE *)pBuffer)[1];
  123. #if USE_MIX_SATURATE
  124.             // Handle saturation
  125.             if (OutSamp0>AUDIO_SAMPLE_MAX)
  126.             {
  127.                 OutSamp0=AUDIO_SAMPLE_MAX;
  128.             }
  129.             else if (OutSamp0<AUDIO_SAMPLE_MIN)
  130.             {
  131.                 OutSamp0=AUDIO_SAMPLE_MIN;
  132.             }
  133.             if (OutSamp1>AUDIO_SAMPLE_MAX)
  134.             {
  135.                 OutSamp1=AUDIO_SAMPLE_MAX;
  136.             }
  137.             else if (OutSamp1<AUDIO_SAMPLE_MIN)
  138.             {
  139.                 OutSamp1=AUDIO_SAMPLE_MIN;
  140.             }
  141. #endif
  142.         }
  143.         ((HWSAMPLE *)pBuffer)[0] = (HWSAMPLE)OutSamp0;
  144.         ((HWSAMPLE *)pBuffer)[1] = (HWSAMPLE)OutSamp1;
  145.         pBuffer += 2*sizeof(HWSAMPLE);
  146. #else
  147.         if (pBuffer < pBufferLast)
  148.         {
  149.             OutSamp0 += ((HWSAMPLE *)pBuffer)[0];
  150. #if USE_MIX_SATURATE
  151.             // Handle saturation
  152.             if (OutSamp0>AUDIO_SAMPLE_MAX)
  153.             {
  154.                 OutSamp0=AUDIO_SAMPLE_MAX;
  155.             }
  156.             else if (OutSamp0<AUDIO_SAMPLE_MIN)
  157.             {
  158.                 OutSamp0=AUDIO_SAMPLE_MIN;
  159.             }
  160. #endif
  161.         }
  162.         ((HWSAMPLE *)pBuffer)[0] = (HWSAMPLE)OutSamp0;
  163.         pBuffer += sizeof(HWSAMPLE);
  164. #endif
  165.     }
  167.     Exit:
  169.     m_dwByteCount += (pCurrData - m_lpCurrData);
  170.     m_lpCurrData = pCurrData;
  171.     m_CurrT = CurrT;
  172.     m_PrevSamp[0] = PrevSamp0;
  173.     m_CurrSamp[0] = CurrSamp0;
  174.     return pBuffer;
  175. }
  177. PBYTE OutputStreamContextM16::Render2(PBYTE pBuffer, PBYTE pBufferEnd, PBYTE pBufferLast)
  178. {
  179.     LONG CurrT = m_CurrT;
  180.     LONG DeltaT = m_DeltaT;
  181.     LONG CurrSamp0 = m_CurrSamp[0];
  182.     LONG PrevSamp0 = m_PrevSamp[0];
  183.     PBYTE pCurrData = m_lpCurrData;
  184.     PBYTE pCurrDataEnd = m_lpCurrDataEnd;
  185.     LONG fxpGain = m_fxpGain;
  186.     LONG OutSamp0;
  188.     while (pBuffer < pBufferEnd)
  189.     {
  190.         while (CurrT >= 0x100)
  191.         {
  192.             if (pCurrData>=pCurrDataEnd)
  193.             {
  194.                 goto Exit;
  195.             }
  197.             CurrT -= 0x100;
  199.             PrevSamp0 = CurrSamp0;
  201.             PPCM_SAMPLE pSampleSrc = (PPCM_SAMPLE)pCurrData;
  202.             CurrSamp0 = (LONG)pSampleSrc->m16.sample;
  203.             pCurrData+=2;
  204.         }
  206.         OutSamp0 = PrevSamp0 + (((CurrSamp0 - PrevSamp0) * CurrT) >> 8);
  207.         OutSamp0 = (OutSamp0 * fxpGain) >> VOLSHIFT;
  208.         CurrT += DeltaT;
  209.         // DEBUGMSG(1, (TEXT("PrevSamp0=0x%x, CurrSamp0=0x%x, CurrT=0x%x, OutSamp0=0x%xrn"), PrevSamp0,CurrSamp0,CurrT,OutSamp0));
  211. #if (OUTCHANNELS==2)
  212.         LONG OutSamp1;
  213.         OutSamp1=OutSamp0;
  214.         if (pBuffer < pBufferLast)
  215.         {
  216.             OutSamp0 += ((HWSAMPLE *)pBuffer)[0];
  217.             OutSamp1 += ((HWSAMPLE *)pBuffer)[1];
  218. #if USE_MIX_SATURATE
  219.             // Handle saturation
  220.             if (OutSamp0>AUDIO_SAMPLE_MAX)
  221.             {
  222.                 OutSamp0=AUDIO_SAMPLE_MAX;
  223.             }
  224.             else if (OutSamp0<AUDIO_SAMPLE_MIN)
  225.             {
  226.                 OutSamp0=AUDIO_SAMPLE_MIN;
  227.             }
  228.             if (OutSamp1>AUDIO_SAMPLE_MAX)
  229.             {
  230.                 OutSamp1=AUDIO_SAMPLE_MAX;
  231.             }
  232.             else if (OutSamp1<AUDIO_SAMPLE_MIN)
  233.             {
  234.                 OutSamp1=AUDIO_SAMPLE_MIN;
  235.             }
  236. #endif
  237.         }
  238.         ((HWSAMPLE *)pBuffer)[0] = (HWSAMPLE)OutSamp0;
  239.         ((HWSAMPLE *)pBuffer)[1] = (HWSAMPLE)OutSamp1;
  240.         pBuffer += 2*sizeof(HWSAMPLE);
  241. #else
  242.         if (pBuffer < pBufferLast)
  243.         {
  244.             OutSamp0 += ((HWSAMPLE *)pBuffer)[0];
  245. #if USE_MIX_SATURATE
  246.             // Handle saturation
  247.             if (OutSamp0>AUDIO_SAMPLE_MAX)
  248.             {
  249.                 OutSamp0=AUDIO_SAMPLE_MAX;
  250.             }
  251.             else if (OutSamp0<AUDIO_SAMPLE_MIN)
  252.             {
  253.                 OutSamp0=AUDIO_SAMPLE_MIN;
  254.             }
  255. #endif
  256.         }
  257.         ((HWSAMPLE *)pBuffer)[0] = (HWSAMPLE)OutSamp0;
  258.         pBuffer += sizeof(HWSAMPLE);
  259. #endif
  260.     }
  262.     Exit:
  263.     m_dwByteCount += (pCurrData - m_lpCurrData);
  264.     m_lpCurrData = pCurrData;
  265.     m_CurrT = CurrT;
  266.     m_PrevSamp[0] = PrevSamp0;
  267.     m_CurrSamp[0] = CurrSamp0;
  268.     return pBuffer;
  269. }
  271. #if (OUTCHANNELS==2)
  272. PBYTE OutputStreamContextS8::Render2(PBYTE pBuffer, PBYTE pBufferEnd, PBYTE pBufferLast)
  273. {
  274.     LONG CurrT = m_CurrT;
  275.     LONG DeltaT = m_DeltaT;
  276.     LONG CurrSamp0 = m_CurrSamp[0];
  277.     LONG CurrSamp1 = m_CurrSamp[1];
  278.     LONG PrevSamp0 = m_PrevSamp[0];
  279.     LONG PrevSamp1 = m_PrevSamp[1];
  280.     PBYTE pCurrData = m_lpCurrData;
  281.     PBYTE pCurrDataEnd = m_lpCurrDataEnd;
  282.     LONG fxpGain = m_fxpGain;
  283.     LONG OutSamp0;
  284.     LONG OutSamp1;
  286.     while (pBuffer < pBufferEnd)
  287.     {
  288.         while (CurrT >= 0x100)
  289.         {
  290.             if (pCurrData>=pCurrDataEnd)
  291.             {
  292.                 goto Exit;
  293.             }
  295.             CurrT -= 0x100;
  297.             PrevSamp0 = CurrSamp0;
  298.             PrevSamp1 = CurrSamp1;
  300.             PPCM_SAMPLE pSampleSrc = (PPCM_SAMPLE)pCurrData;
  301.             CurrSamp0 =  (LONG)pSampleSrc->s8.sample_left;
  302.             CurrSamp0 = (CurrSamp0 - 128) << 8;
  303.             CurrSamp1 = (LONG)pSampleSrc->s8.sample_right;
  304.             CurrSamp1 = (CurrSamp1 - 128) << 8;
  305.             pCurrData+=2;
  306.         }
  308.         OutSamp0 = PrevSamp0 + (((CurrSamp0 - PrevSamp0) * CurrT) >> 8);
  309.         OutSamp0 = (OutSamp0 * fxpGain) >> VOLSHIFT;
  311.         OutSamp1 = PrevSamp1 + (((CurrSamp1 - PrevSamp1) * CurrT) >> 8);
  312.         OutSamp1 = (OutSamp1 * fxpGain) >> VOLSHIFT;
  313.         CurrT += DeltaT;
  314.         // DEBUGMSG(1, (TEXT("PrevSamp0=0x%x, CurrSamp0=0x%x, CurrT=0x%x, OutSamp0=0x%xrn"), PrevSamp0,CurrSamp0,CurrT,OutSamp0));
  316.         if (pBuffer < pBufferLast)
  317.         {
  318.             OutSamp0 += ((HWSAMPLE *)pBuffer)[0];
  319.             OutSamp1 += ((HWSAMPLE *)pBuffer)[1];
  320. #if USE_MIX_SATURATE
  321.             // Handle saturation
  322.             if (OutSamp0>AUDIO_SAMPLE_MAX)
  323.             {
  324.                 OutSamp0=AUDIO_SAMPLE_MAX;
  325.             }
  326.             else if (OutSamp0<AUDIO_SAMPLE_MIN)
  327.             {
  328.                 OutSamp0=AUDIO_SAMPLE_MIN;
  329.             }
  330.             if (OutSamp1>AUDIO_SAMPLE_MAX)
  331.             {
  332.                 OutSamp1=AUDIO_SAMPLE_MAX;
  333.             }
  334.             else if (OutSamp1<AUDIO_SAMPLE_MIN)
  335.             {
  336.                 OutSamp1=AUDIO_SAMPLE_MIN;
  337.             }
  338. #endif
  339.         }
  340.         ((HWSAMPLE *)pBuffer)[0] = (HWSAMPLE)OutSamp0;
  341.         ((HWSAMPLE *)pBuffer)[1] = (HWSAMPLE)OutSamp1;
  343.         pBuffer += 2*sizeof(HWSAMPLE);
  345.     }
  347.     Exit:
  348.     m_dwByteCount += (pCurrData - m_lpCurrData);
  349.     m_lpCurrData = pCurrData;
  350.     m_CurrT = CurrT;
  351.     m_PrevSamp[0] = PrevSamp0;
  352.     m_PrevSamp[1] = PrevSamp1;
  353.     m_CurrSamp[0] = CurrSamp0;
  354.     m_CurrSamp[1] = CurrSamp1;
  355.     return pBuffer;
  356. }
  358. PBYTE OutputStreamContextS16::Render2(PBYTE pBuffer, PBYTE pBufferEnd, PBYTE pBufferLast)
  359. {
  360.     LONG CurrT = m_CurrT;
  361.     LONG DeltaT = m_DeltaT;
  362.     LONG CurrSamp0 = m_CurrSamp[0];
  363.     LONG CurrSamp1 = m_CurrSamp[1];
  364.     LONG PrevSamp0 = m_PrevSamp[0];
  365.     LONG PrevSamp1 = m_PrevSamp[1];
  366.     PBYTE pCurrData = m_lpCurrData;
  367.     PBYTE pCurrDataEnd = m_lpCurrDataEnd;
  368.     LONG fxpGain = m_fxpGain;
  369.     LONG OutSamp0;
  370.     LONG OutSamp1;
  372.     while (pBuffer < pBufferEnd)
  373.     {
  374.         while (CurrT >= 0x100)
  375.         {
  376.             if (pCurrData>=pCurrDataEnd)
  377.             {
  378.                 goto Exit;
  379.             }
  381.             CurrT -= 0x100;
  383.             PrevSamp0 = CurrSamp0;
  384.             PrevSamp1 = CurrSamp1;
  386.             PPCM_SAMPLE pSampleSrc = (PPCM_SAMPLE)pCurrData;
  387.             CurrSamp0 = (LONG)pSampleSrc->s16.sample_left;
  388.             CurrSamp1 = (LONG)pSampleSrc->s16.sample_right;
  389.             pCurrData+=4;
  390.         }
  392.         OutSamp0 = PrevSamp0 + (((CurrSamp0 - PrevSamp0) * CurrT) >> 8);
  393.         OutSamp0 = (OutSamp0 * fxpGain) >> VOLSHIFT;
  394.         OutSamp1 = PrevSamp1 + (((CurrSamp1 - PrevSamp1) * CurrT) >> 8);
  395.         OutSamp1 = (OutSamp1 * fxpGain) >> VOLSHIFT;
  396.         CurrT += DeltaT;
  397.         // DEBUGMSG(1, (TEXT("PrevSamp0=0x%x, CurrSamp0=0x%x, CurrT=0x%x, OutSamp0=0x%xrn"), PrevSamp0,CurrSamp0,CurrT,OutSamp0));
  399.         if (pBuffer < pBufferLast)
  400.         {
  401.             OutSamp0 += ((HWSAMPLE *)pBuffer)[0];
  402.             OutSamp1 += ((HWSAMPLE *)pBuffer)[1];
  403. #if USE_MIX_SATURATE
  404.             // Handle saturation
  405.             if (OutSamp0>AUDIO_SAMPLE_MAX)
  406.             {
  407.                 OutSamp0=AUDIO_SAMPLE_MAX;
  408.             }
  409.             else if (OutSamp0<AUDIO_SAMPLE_MIN)
  410.             {
  411.                 OutSamp0=AUDIO_SAMPLE_MIN;
  412.             }
  413.             if (OutSamp1>AUDIO_SAMPLE_MAX)
  414.             {
  415.                 OutSamp1=AUDIO_SAMPLE_MAX;
  416.             }
  417.             else if (OutSamp1<AUDIO_SAMPLE_MIN)
  418.             {
  419.                 OutSamp1=AUDIO_SAMPLE_MIN;
  420.             }
  421. #endif
  422.         }
  423.         ((HWSAMPLE *)pBuffer)[0] = (HWSAMPLE)OutSamp0;
  424.         ((HWSAMPLE *)pBuffer)[1] = (HWSAMPLE)OutSamp1;
  426.         pBuffer += 2*sizeof(HWSAMPLE);
  427.     }
  429.     Exit:
  430.     m_dwByteCount += (pCurrData - m_lpCurrData);
  431.     m_lpCurrData = pCurrData;
  432.     m_CurrT = CurrT;
  433.     m_PrevSamp[0] = PrevSamp0;
  434.     m_PrevSamp[1] = PrevSamp1;
  435.     m_CurrSamp[0] = CurrSamp0;
  436.     m_CurrSamp[1] = CurrSamp1;
  437.     return pBuffer;
  438. }
  440. #else
  442. PBYTE OutputStreamContextS8::Render2(PBYTE pBuffer, PBYTE pBufferEnd, PBYTE pBufferLast)
  443. {
  444.     LONG CurrT = m_CurrT;
  445.     LONG DeltaT = m_DeltaT;
  446.     LONG CurrSamp0 = m_CurrSamp[0];
  447.     LONG PrevSamp0 = m_PrevSamp[0];
  448.     PBYTE pCurrData = m_lpCurrData;
  449.     PBYTE pCurrDataEnd = m_lpCurrDataEnd;
  450.     LONG fxpGain = m_fxpGain;
  451.     LONG OutSamp0;
  453.     while (pBuffer < pBufferEnd)
  454.     {
  455.         while (CurrT >= 0x100)
  456.         {
  457.             if (pCurrData>=pCurrDataEnd)
  458.             {
  459.                 goto Exit;
  460.             }
  462.             CurrT -= 0x100;
  464.             PrevSamp0 = CurrSamp0;
  466.             PPCM_SAMPLE pSampleSrc = (PPCM_SAMPLE)pCurrData;
  467.             CurrSamp0 =  (LONG)pSampleSrc->s8.sample_left;
  468.             CurrSamp0 += (LONG)pSampleSrc->s8.sample_right;
  469.             CurrSamp0 = (CurrSamp0 - 256) << 7;
  470.             pCurrData+=2;
  471.         }
  473.         OutSamp0 = PrevSamp0 + (((CurrSamp0 - PrevSamp0) * CurrT) >> 8);
  474.         OutSamp0 = (OutSamp0 * fxpGain) >> VOLSHIFT;
  475.         CurrT += DeltaT;
  476.         // DEBUGMSG(1, (TEXT("PrevSamp0=0x%x, CurrSamp0=0x%x, CurrT=0x%x, OutSamp0=0x%xrn"), PrevSamp0,CurrSamp0,CurrT,OutSamp0));
  478.         if (pBuffer < pBufferLast)
  479.         {
  480.             OutSamp0 += *(HWSAMPLE *)pBuffer;
  481. #if USE_MIX_SATURATE
  482.             // Handle saturation
  483.             if (OutSamp0>AUDIO_SAMPLE_MAX)
  484.             {
  485.                 OutSamp0=AUDIO_SAMPLE_MAX;
  486.             }
  487.             else if (OutSamp0<AUDIO_SAMPLE_MIN)
  488.             {
  489.                 OutSamp0=AUDIO_SAMPLE_MIN;
  490.             }
  491. #endif
  492.         }
  493.         *(HWSAMPLE *)pBuffer = (HWSAMPLE)OutSamp0;
  495.         pBuffer += sizeof(HWSAMPLE);
  496.     }
  498.     Exit:
  499.     m_dwByteCount += (pCurrData - m_lpCurrData);
  500.     m_lpCurrData = pCurrData;
  501.     m_CurrT = CurrT;
  502.     m_PrevSamp[0] = PrevSamp0;
  503.     m_CurrSamp[0] = CurrSamp0;
  504.     return pBuffer;
  505. }
  507. PBYTE OutputStreamContextS16::Render2(PBYTE pBuffer, PBYTE pBufferEnd, PBYTE pBufferLast)
  508. {
  509.     LONG CurrT = m_CurrT;
  510.     LONG DeltaT = m_DeltaT;
  511.     LONG CurrSamp0 = m_CurrSamp[0];
  512.     LONG PrevSamp0 = m_PrevSamp[0];
  513.     PBYTE pCurrData = m_lpCurrData;
  514.     PBYTE pCurrDataEnd = m_lpCurrDataEnd;
  515.     LONG fxpGain = m_fxpGain;
  516.     LONG OutSamp0;
  518.     while (pBuffer < pBufferEnd)
  519.     {
  520.         while (CurrT >= 0x100)
  521.         {
  522.             if (pCurrData>=pCurrDataEnd)
  523.             {
  524.                 goto Exit;
  525.             }
  527.             CurrT -= 0x100;
  529.             PrevSamp0 = CurrSamp0;
  531.             PPCM_SAMPLE pSampleSrc = (PPCM_SAMPLE)pCurrData;
  532.             CurrSamp0 =  (LONG)pSampleSrc->s16.sample_left;
  533.             CurrSamp0 += (LONG)pSampleSrc->s16.sample_right;
  534.             CurrSamp0 = CurrSamp0>>1;
  535.             pCurrData+=4;
  536.         }
  538.         OutSamp0 = PrevSamp0 + (((CurrSamp0 - PrevSamp0) * CurrT) >> 8);
  539.         OutSamp0 = (OutSamp0 * fxpGain) >> VOLSHIFT;
  540.         CurrT += DeltaT;
  541.         // DEBUGMSG(1, (TEXT("PrevSamp0=0x%x, CurrSamp0=0x%x, CurrT=0x%x, OutSamp0=0x%xrn"), PrevSamp0,CurrSamp0,CurrT,OutSamp0));
  543.         if (pBuffer < pBufferLast)
  544.         {
  545.             OutSamp0 += *(HWSAMPLE *)pBuffer;
  546. #if USE_MIX_SATURATE
  547.             // Handle saturation
  548.             if (OutSamp0>AUDIO_SAMPLE_MAX)
  549.             {
  550.                 OutSamp0=AUDIO_SAMPLE_MAX;
  551.             }
  552.             else if (OutSamp0<AUDIO_SAMPLE_MIN)
  553.             {
  554.                 OutSamp0=AUDIO_SAMPLE_MIN;
  555.             }
  556. #endif
  557.         }
  558.         *(HWSAMPLE *)pBuffer = (HWSAMPLE)OutSamp0;
  560.         pBuffer += sizeof(HWSAMPLE);
  562.     }
  564.     Exit:
  565.     m_dwByteCount += (pCurrData - m_lpCurrData);
  566.     m_lpCurrData = pCurrData;
  567.     m_CurrT = CurrT;
  568.     m_PrevSamp[0] = PrevSamp0;
  569.     m_CurrSamp[0] = CurrSamp0;
  570.     return pBuffer;
  571. }
  572. #endif