home *** CD-ROM | disk | FTP | other *** search
/ Game Audio Programming / GameAudioProgramming.iso / Game_Audio / audio_sdk / src / AudioLib / Extensions.cpp < prev    next >
C/C++ Source or Header  |  2002-09-02  |  14KB  |  685 lines
  1. /***********************************************************\
  2. Copyright (C) James Boer, 2002. 
  3. All rights reserved worldwide.
  4.  
  5. This software is provided "as is" without express or implied
  6. warranties. You may freely copy and compile this source into
  7. applications you distribute provided that the copyright text
  8. below is included in the resulting source code, for example:
  9. "Portions Copyright (C) James Boer, 2002"
  10. \***********************************************************/
  11. #include "Extensions.h"
  12. #include "AudioMgr.h"
  13.  
  14. using namespace Audio;
  15.  
  16.  
  17. EAXListener::EAXListener()
  18. {
  19.     m_pPropertySet = 0;
  20. }
  21.  
  22.  
  23.  
  24. bool EAXListener::OnLoad(IUnknown* pUnknown)
  25. {
  26.     if(!DXAudioMgr()->GetInit()->m_bUseEAX)
  27.         return true;
  28.     if(!pUnknown)
  29.         return false;
  30.     HRESULT hr = pUnknown->QueryInterface(IID_IKsPropertySet, (void**)&m_pPropertySet);
  31.     if(FAILED(hr))
  32.         return false;
  33.  
  34.     uint32 nSupport = 0;
  35.     hr = m_pPropertySet->QuerySupport(
  36.         DSPROPSETID_EAX20_ListenerProperties,
  37.         DSPROPERTY_EAXLISTENER_ALLPARAMETERS,
  38.         &nSupport);
  39.     if((nSupport != (KSPROPERTY_SUPPORT_GET | 
  40.         KSPROPERTY_SUPPORT_SET)))
  41.     {
  42.         SAFE_RELEASE(m_pPropertySet);
  43.         return false;
  44.     }
  45.  
  46.     EAXListenerProps props;
  47.     hr = m_pPropertySet->Set(
  48.         DSPROPSETID_EAX20_ListenerProperties,
  49.         DSPROPERTY_EAXLISTENER_ALLPARAMETERS,
  50.         0,
  51.         0,
  52.         (void*)&props,
  53.         sizeof(EAXListenerProps));
  54.     if(FAILED(hr))
  55.     {
  56.         SAFE_RELEASE(m_pPropertySet);
  57.         return false;
  58.     }
  59.     return true;
  60. }
  61.  
  62. bool EAXListener::OnUnload()
  63. {
  64.     SAFE_RELEASE(m_pPropertySet);
  65.     return true;
  66. }
  67.  
  68. void EAXListener::Term()
  69. {
  70.     SAFE_RELEASE(m_pPropertySet);
  71. }
  72.  
  73. void EAXListener::SetRoom(int32 iRoom)
  74. {
  75.     if(!m_pPropertySet) return;
  76.     m_pPropertySet->Set(
  77.         DSPROPSETID_EAX20_ListenerProperties,
  78.         DSPROPERTY_EAXLISTENER_ROOM,
  79.         0,
  80.         0,
  81.         &iRoom,
  82.         sizeof(int32));
  83. }
  84.  
  85. void EAXListener::SetRoomHF(int32 iRoomHF)
  86. {
  87.     if(!m_pPropertySet) return;
  88.     m_pPropertySet->Set(
  89.         DSPROPSETID_EAX20_ListenerProperties,
  90.         DSPROPERTY_EAXLISTENER_ROOMHF,
  91.         0,
  92.         0,
  93.         &iRoomHF,
  94.         sizeof(int32));
  95. }
  96.  
  97. void EAXListener::SetRoomRolloffFactor(float fRoomRolloffFactor)
  98. {
  99.     if(!m_pPropertySet) return;
  100.     m_pPropertySet->Set(
  101.         DSPROPSETID_EAX20_ListenerProperties,
  102.         DSPROPERTY_EAXLISTENER_ROOMROLLOFFFACTOR,
  103.         0,
  104.         0,
  105.         &fRoomRolloffFactor,
  106.         sizeof(float));
  107. }
  108.  
  109. void EAXListener::SetDecayTime(float fDecayTime)
  110. {
  111.     if(!m_pPropertySet) return;
  112.     m_pPropertySet->Set(
  113.         DSPROPSETID_EAX20_ListenerProperties,
  114.         DSPROPERTY_EAXLISTENER_DECAYTIME,
  115.         0,
  116.         0,
  117.         &fDecayTime,
  118.         sizeof(float));
  119. }
  120.  
  121. void EAXListener::SetDecayHFRatio(float fDecayHFRatio)
  122. {
  123.     if(!m_pPropertySet) return;
  124.     m_pPropertySet->Set(
  125.         DSPROPSETID_EAX20_ListenerProperties,
  126.         DSPROPERTY_EAXLISTENER_DECAYHFRATIO,
  127.         0,
  128.         0,
  129.         &fDecayHFRatio,
  130.         sizeof(float));
  131. }
  132.  
  133. void EAXListener::SetReflections(int32 iReflections)
  134. {
  135.     if(!m_pPropertySet) return;
  136.     m_pPropertySet->Set(
  137.         DSPROPSETID_EAX20_ListenerProperties,
  138.         DSPROPERTY_EAXLISTENER_REFLECTIONS,
  139.         0,
  140.         0,
  141.         &iReflections,
  142.         sizeof(int32));
  143. }
  144.  
  145. void EAXListener::SetReflectionsDelay(float fReflectionsDelay)
  146. {
  147.     if(!m_pPropertySet) return;
  148.     m_pPropertySet->Set(
  149.         DSPROPSETID_EAX20_ListenerProperties,
  150.         DSPROPERTY_EAXLISTENER_REFLECTIONSDELAY,
  151.         0,
  152.         0,
  153.         &fReflectionsDelay,
  154.         sizeof(float));
  155. }
  156.  
  157. void EAXListener::SetReverb(int32 iReverb)
  158. {
  159.     if(!m_pPropertySet) return;
  160.     m_pPropertySet->Set(
  161.         DSPROPSETID_EAX20_ListenerProperties,
  162.         DSPROPERTY_EAXLISTENER_REVERB,
  163.         0,
  164.         0,
  165.         &iReverb,
  166.         sizeof(int32));
  167. }
  168.  
  169. void EAXListener::SetReverbDelay(float fReverbDelay)
  170. {
  171.     if(!m_pPropertySet) return;
  172.     m_pPropertySet->Set(
  173.         DSPROPSETID_EAX20_ListenerProperties,
  174.         DSPROPERTY_EAXLISTENER_REVERBDELAY,
  175.         0,
  176.         0,
  177.         &fReverbDelay,
  178.         sizeof(float));
  179. }
  180.  
  181. void EAXListener::SetEnvironment(uint32 nEnvironment)
  182. {
  183.     if(!m_pPropertySet) return;
  184.     m_pPropertySet->Set(
  185.         DSPROPSETID_EAX20_ListenerProperties,
  186.         DSPROPERTY_EAXLISTENER_ENVIRONMENT,
  187.         0,
  188.         0,
  189.         &nEnvironment,
  190.         sizeof(uint32));
  191. }
  192.  
  193. void EAXListener::SetEnvironmentSize(float fEnvironmentSize)
  194. {
  195.     if(!m_pPropertySet) return;
  196.     m_pPropertySet->Set(
  197.         DSPROPSETID_EAX20_ListenerProperties,
  198.         DSPROPERTY_EAXLISTENER_ENVIRONMENTSIZE,
  199.         0,
  200.         0,
  201.         &fEnvironmentSize,
  202.         sizeof(float));
  203. }
  204.  
  205. void EAXListener::SetEnvironmentDiffusion(float fEnvironmentDiffusion)
  206. {
  207.     if(!m_pPropertySet) return;
  208.     m_pPropertySet->Set(
  209.         DSPROPSETID_EAX20_ListenerProperties,
  210.         DSPROPERTY_EAXLISTENER_ENVIRONMENTDIFFUSION,
  211.         0,
  212.         0,
  213.         &fEnvironmentDiffusion,
  214.         sizeof(float));
  215. }
  216.  
  217. void EAXListener::SetAirAbsorptionHF(float fAirAbsorptionHF)
  218. {
  219.     if(!m_pPropertySet) return;
  220.     m_pPropertySet->Set(
  221.         DSPROPSETID_EAX20_ListenerProperties,
  222.         DSPROPERTY_EAXLISTENER_AIRABSORPTIONHF,
  223.         0,
  224.         0,
  225.         &fAirAbsorptionHF,
  226.         sizeof(float));
  227. }
  228.  
  229. void EAXListener::SetFlags(uint32 nFlags)
  230. {
  231.     if(!m_pPropertySet) return;
  232.     m_pPropertySet->Set(
  233.         DSPROPSETID_EAX20_ListenerProperties,
  234.         DSPROPERTY_EAXLISTENER_FLAGS,
  235.         0,
  236.         0,
  237.         &nFlags,
  238.         sizeof(uint32));
  239. }
  240.  
  241. void EAXListener::SetProperties(const EAXListenerProps& props)
  242. {
  243.     if(!m_pPropertySet) return;
  244.     m_pPropertySet->Set(
  245.         DSPROPSETID_EAX20_ListenerProperties,
  246.         DSPROPERTY_EAXLISTENER_ALLPARAMETERS,
  247.         0,
  248.         0,
  249.         (void*)&props,
  250.         sizeof(EAXListenerProps));
  251. }
  252.  
  253. void EAXListener::GetProperties(EAXListenerProps& props)
  254. {
  255.     if(!m_pPropertySet) return;
  256.     uint32 nSize;
  257.     m_pPropertySet->Get(
  258.         DSPROPSETID_EAX20_ListenerProperties,
  259.         DSPROPERTY_EAXLISTENER_ALLPARAMETERS,
  260.         0,
  261.         0,
  262.         &props,
  263.         sizeof(EAXListenerProps),
  264.         &nSize);
  265. }
  266.  
  267.  
  268.  
  269.  
  270. EAXBuffer::EAXBuffer()
  271. {
  272.     Clear();
  273. }
  274.  
  275.  
  276. void EAXBuffer::Clear()
  277. {
  278.     m_pPropertySet = 0;
  279.     m_Props.Clear();
  280. };
  281.  
  282.  
  283. bool EAXBuffer::OnLoad(IUnknown* pUnknown)
  284. {
  285.     if(!pUnknown)
  286.         return false;
  287.     HRESULT hr = pUnknown->QueryInterface(IID_IKsPropertySet, (void**)&m_pPropertySet);
  288.     if(FAILED(hr))
  289.         return false;
  290.  
  291.     uint32 nSupport = 0;
  292.     hr = m_pPropertySet->QuerySupport(
  293.         DSPROPSETID_EAX20_BufferProperties,
  294.         DSPROPERTY_EAXBUFFER_ALLPARAMETERS,
  295.         &nSupport);
  296.     if((nSupport != (KSPROPERTY_SUPPORT_GET | 
  297.         KSPROPERTY_SUPPORT_SET)))
  298.     {
  299.         SAFE_RELEASE(m_pPropertySet);
  300.         return false;
  301.     }
  302.  
  303.     hr = m_pPropertySet->Set(
  304.         DSPROPSETID_EAX20_BufferProperties,
  305.         DSPROPERTY_EAXBUFFER_ALLPARAMETERS,
  306.         0,
  307.         0,
  308.         (void*)(&m_Props),
  309.         sizeof(EAXBufferProps));
  310.     if(FAILED(hr))
  311.     {
  312.         SAFE_RELEASE(m_pPropertySet);
  313.         return false;
  314.     }
  315.     return true;
  316. }
  317.  
  318. bool EAXBuffer::OnUnload()
  319. {
  320.     if(!m_pPropertySet)
  321.         return false;
  322.  
  323.     uint32 nSize;
  324.     m_pPropertySet->Get(
  325.         DSPROPSETID_EAX20_BufferProperties,
  326.         DSPROPERTY_EAXBUFFER_ALLPARAMETERS,
  327.         0,
  328.         0,
  329.         &m_Props,
  330.         sizeof(EAXBufferProps),
  331.         &nSize);
  332.  
  333.     SAFE_RELEASE(m_pPropertySet);
  334.     return true;
  335. }
  336.  
  337. void EAXBuffer::Term()
  338. {
  339.     SAFE_RELEASE(m_pPropertySet);
  340. }
  341.  
  342. void EAXBuffer::SetDirect(int32 iDirect)
  343. {
  344.     m_Props.lDirect = iDirect;
  345.     if(!m_pPropertySet) return;
  346.     m_pPropertySet->Set(
  347.         DSPROPSETID_EAX20_BufferProperties,
  348.         DSPROPERTY_EAXBUFFER_DIRECT,
  349.         0,
  350.         0,
  351.         &iDirect,
  352.         sizeof(int32));
  353. }
  354.  
  355. void EAXBuffer::SetDirectHF(int32 iDirectHF)
  356. {
  357.     m_Props.lDirectHF = iDirectHF;
  358.     if(!m_pPropertySet) return;
  359.     m_pPropertySet->Set(
  360.         DSPROPSETID_EAX20_BufferProperties,
  361.         DSPROPERTY_EAXBUFFER_DIRECTHF,
  362.         0,
  363.         0,
  364.         &iDirectHF,
  365.         sizeof(int32));
  366. }
  367.  
  368. void EAXBuffer::SetRoom(int32 iRoom)
  369. {
  370.     m_Props.lRoom = iRoom;
  371.     if(!m_pPropertySet) return;
  372.     m_pPropertySet->Set(
  373.         DSPROPSETID_EAX20_BufferProperties,
  374.         DSPROPERTY_EAXBUFFER_ROOM,
  375.         0,
  376.         0,
  377.         &iRoom,
  378.         sizeof(int32));
  379. }
  380.  
  381. void EAXBuffer::SetRoomHF(int32 iRoomHF)
  382. {
  383.     m_Props.lRoomHF = iRoomHF;
  384.     if(!m_pPropertySet) return;
  385.     m_pPropertySet->Set(
  386.         DSPROPSETID_EAX20_BufferProperties,
  387.         DSPROPERTY_EAXBUFFER_ROOMHF,
  388.         0,
  389.         0,
  390.         &iRoomHF,
  391.         sizeof(int32));
  392. }
  393.  
  394. void EAXBuffer::SetRoomRolloffFactor(float fRoomRolloffFactor)
  395. {
  396.     m_Props.flRoomRolloffFactor = fRoomRolloffFactor;
  397.     if(!m_pPropertySet) return;
  398.     m_pPropertySet->Set(
  399.         DSPROPSETID_EAX20_BufferProperties,
  400.         DSPROPERTY_EAXBUFFER_ROOMROLLOFFFACTOR,
  401.         0,
  402.         0,
  403.         &fRoomRolloffFactor,
  404.         sizeof(float));
  405. }
  406.  
  407. void EAXBuffer::SetObstruction(int32 iObstruction)
  408. {
  409.     m_Props.lObstruction = iObstruction;
  410.     if(!m_pPropertySet) return;
  411.     m_pPropertySet->Set(
  412.         DSPROPSETID_EAX20_BufferProperties,
  413.         DSPROPERTY_EAXBUFFER_OBSTRUCTION,
  414.         0,
  415.         0,
  416.         &iObstruction,
  417.         sizeof(int32));
  418. }
  419.  
  420. void EAXBuffer::SetObstructionLFRatio(float fObstructionLFRatio)
  421. {
  422.     m_Props.flObstructionLFRatio = fObstructionLFRatio;
  423.     if(!m_pPropertySet) return;
  424.     m_pPropertySet->Set(
  425.         DSPROPSETID_EAX20_BufferProperties,
  426.         DSPROPERTY_EAXBUFFER_OBSTRUCTIONLFRATIO,
  427.         0,
  428.         0,
  429.         &fObstructionLFRatio,
  430.         sizeof(float));
  431. }
  432.  
  433. void EAXBuffer::SetOcclusion(int32 iOcclusion)
  434. {
  435.     m_Props.lOcclusion = iOcclusion;
  436.     if(!m_pPropertySet) return;
  437.     m_pPropertySet->Set(
  438.         DSPROPSETID_EAX20_BufferProperties,
  439.         DSPROPERTY_EAXBUFFER_OCCLUSION,
  440.         0,
  441.         0,
  442.         &iOcclusion,
  443.         sizeof(int32));
  444. }
  445.  
  446. void EAXBuffer::SetOcclusionLFRatio(float fOcclusionLFRatio)
  447. {
  448.     m_Props.flOcclusionLFRatio = fOcclusionLFRatio;
  449.     if(!m_pPropertySet) return;
  450.     m_pPropertySet->Set(
  451.         DSPROPSETID_EAX20_BufferProperties,
  452.         DSPROPERTY_EAXBUFFER_OCCLUSIONLFRATIO,
  453.         0,
  454.         0,
  455.         &fOcclusionLFRatio,
  456.         sizeof(float));
  457. }
  458.  
  459. void EAXBuffer::SetOcclusionRoomRatio(float fOcclusionRoomRatio)
  460. {
  461.     m_Props.flOcclusionRoomRatio = fOcclusionRoomRatio;
  462.     if(!m_pPropertySet) return;
  463.     m_pPropertySet->Set(
  464.         DSPROPSETID_EAX20_BufferProperties,
  465.         DSPROPERTY_EAXBUFFER_OCCLUSIONROOMRATIO,
  466.         0,
  467.         0,
  468.         &fOcclusionRoomRatio,
  469.         sizeof(float));
  470. }
  471.  
  472. void EAXBuffer::SetOutsideVolumeHF(int32 iOutsideVolumeHF)
  473. {
  474.     m_Props.lOutsideVolumeHF = iOutsideVolumeHF;
  475.     if(!m_pPropertySet) return;
  476.     m_pPropertySet->Set(
  477.         DSPROPSETID_EAX20_BufferProperties,
  478.         DSPROPERTY_EAXBUFFER_OUTSIDEVOLUMEHF,
  479.         0,
  480.         0,
  481.         &iOutsideVolumeHF,
  482.         sizeof(int32));
  483. }
  484.  
  485. void EAXBuffer::SetAirAbsorptionFactor(float fAirAbsorptionFactor)
  486. {
  487.     m_Props.flAirAbsorptionFactor = fAirAbsorptionFactor;
  488.     if(!m_pPropertySet) return;
  489.     m_pPropertySet->Set(
  490.         DSPROPSETID_EAX20_BufferProperties,
  491.         DSPROPERTY_EAXBUFFER_AIRABSORPTIONFACTOR,
  492.         0,
  493.         0,
  494.         &fAirAbsorptionFactor,
  495.         sizeof(float));
  496. }
  497.  
  498. void EAXBuffer::SetFlags(uint32 nFlags)
  499. {
  500.     m_Props.dwFlags = nFlags;
  501.     if(!m_pPropertySet) return;
  502.     m_pPropertySet->Set(
  503.         DSPROPSETID_EAX20_BufferProperties,
  504.         DSPROPERTY_EAXBUFFER_FLAGS,
  505.         0,
  506.         0,
  507.         &nFlags,
  508.         sizeof(uint32));
  509. }
  510.  
  511. void EAXBuffer::SetProperties(const EAXBufferProps& props)
  512. {
  513.     m_Props = props;
  514.     if(!m_pPropertySet) return;
  515.     m_pPropertySet->Set(
  516.         DSPROPSETID_EAX20_BufferProperties,
  517.         DSPROPERTY_EAXBUFFER_ALLPARAMETERS,
  518.         0,
  519.         0,
  520.         (void*)(&props),
  521.         sizeof(EAXBufferProps));
  522. }
  523.  
  524. void EAXBuffer::GetProperties(EAXBufferProps& props)
  525. {
  526.     uint32 nSize;
  527.     if(m_pPropertySet)
  528.     {
  529.         m_pPropertySet->Get(
  530.             DSPROPSETID_EAX20_BufferProperties,
  531.             DSPROPERTY_EAXBUFFER_ALLPARAMETERS,
  532.             0,
  533.             0,
  534.             &m_Props,
  535.             sizeof(EAXBufferProps),
  536.             &nSize);
  537.     }
  538.     props = m_Props;
  539. }
  540.  
  541.  
  542.  
  543. ZoomFx::ZoomFx()
  544. {
  545.     Clear();
  546. }
  547.  
  548. void ZoomFx::Clear()
  549. {
  550.     m_pPropertySet = 0;
  551.     m_Props.Clear();
  552. }
  553.  
  554. bool ZoomFx::OnLoad(IUnknown* pUnknown)
  555. {
  556.     if(!DXAudioMgr()->GetInit()->m_bUseZoomFX)
  557.         return true;
  558.     if(!pUnknown)
  559.         return false;
  560.     HRESULT hr = pUnknown->QueryInterface(IID_IKsPropertySet, (void**)&m_pPropertySet);
  561.     if(FAILED(hr))
  562.         return false;
  563.  
  564.     uint32 nSupport = 0;
  565.     hr = m_pPropertySet->QuerySupport(
  566.         DSPROPSETID_ZOOMFX_BufferProperties,
  567.         DSPROPERTY_ZOOMFXBUFFER_ALL,
  568.         &nSupport);
  569.     if((nSupport != (KSPROPERTY_SUPPORT_GET | 
  570.         KSPROPERTY_SUPPORT_SET)))
  571.     {
  572.         SAFE_RELEASE(m_pPropertySet);
  573.         return false;
  574.     }
  575.  
  576.     ZoomFXProps props;
  577.     hr = m_pPropertySet->Set(
  578.         DSPROPSETID_ZOOMFX_BufferProperties,
  579.         DSPROPERTY_ZOOMFXBUFFER_ALL,
  580.         0,
  581.         0,
  582.         (void*)&props,
  583.         sizeof(ZoomFXProps));
  584.     if(FAILED(hr))
  585.     {
  586.         SAFE_RELEASE(m_pPropertySet);
  587.         return false;
  588.     }
  589.     return true;
  590. }
  591.  
  592. bool ZoomFx::OnUnload()
  593. {
  594.     if(!m_pPropertySet)
  595.         return false;
  596.  
  597.     uint32 nSize;
  598.     m_pPropertySet->Get(
  599.         DSPROPSETID_ZOOMFX_BufferProperties,
  600.         DSPROPERTY_ZOOMFXBUFFER_ALL,
  601.         0,
  602.         0,
  603.         &m_Props,
  604.         sizeof(ZoomFXProps),
  605.         &nSize);
  606.  
  607.     SAFE_RELEASE(m_pPropertySet);
  608.     return true;
  609. }
  610.  
  611. void ZoomFx::Term()
  612. {
  613.     SAFE_RELEASE(m_pPropertySet);
  614. }
  615.  
  616.  
  617. void ZoomFx::SetBox(const ZoomFXBox& box)
  618. {
  619.     m_Props.box = box;
  620.     if(!m_pPropertySet) return;
  621.     m_pPropertySet->Set(
  622.         DSPROPSETID_ZOOMFX_BufferProperties,
  623.         DSPROPERTY_ZOOMFXBUFFER_BOX,
  624.         0,
  625.         0,
  626.         (void*)&box,
  627.         sizeof(ZoomFXBox));
  628. }
  629.  
  630. void ZoomFx::SetOrientation(const ZoomFXOrientation& orientation)
  631. {
  632.     m_Props.orientation = orientation;
  633.     if(!m_pPropertySet) return;
  634.     m_pPropertySet->Set(
  635.         DSPROPSETID_ZOOMFX_BufferProperties,
  636.         DSPROPERTY_ZOOMFXBUFFER_ORIENTATION,
  637.         0,
  638.         0,
  639.         (void*)&orientation,
  640.         sizeof(ZoomFXOrientation));
  641. }
  642.  
  643. void ZoomFx::SetMacroFX(uint32 nMacroFX)
  644. {
  645.     m_Props.lMacroFx = nMacroFX;
  646.     if(!m_pPropertySet) return;
  647.     m_pPropertySet->Set(
  648.         DSPROPSETID_ZOOMFX_BufferProperties,
  649.         DSPROPERTY_ZOOMFXBUFFER_MACROFX_EFFECT,
  650.         0,
  651.         0,
  652.         &nMacroFX,
  653.         sizeof(uint32));
  654. }
  655.  
  656. void ZoomFx::SetProperties(const ZoomFXProps& props)
  657. {
  658.     m_Props = props;
  659.     if(!m_pPropertySet) return;
  660.     m_pPropertySet->Set(
  661.         DSPROPSETID_ZOOMFX_BufferProperties,
  662.         DSPROPERTY_ZOOMFXBUFFER_ALL,
  663.         0,
  664.         0,
  665.         (void*)&props,
  666.         sizeof(ZoomFXProps));
  667. }
  668.  
  669. void ZoomFx::GetProperties(ZoomFXProps& props)
  670. {
  671.     props = m_Props;
  672.     if(!m_pPropertySet) return;
  673.     uint32 nSize;
  674.     m_pPropertySet->Get(
  675.         DSPROPSETID_ZOOMFX_BufferProperties,
  676.         DSPROPERTY_ZOOMFXBUFFER_ALL,
  677.         0,
  678.         0,
  679.         &m_Props,
  680.         sizeof(ZoomFXProps),
  681.         &nSize);
  682. }
  683.  
  684.  
  685.