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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
winaudio.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：37k
源码类别：

Symbian

开发平台：

Visual C++

winaudio.cpp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: winaudio.cpp,v 1.4.8.2 2004/07/09 02:01:47 hubbe Exp $
  3.  * 
  4.  * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
  5.  * 
  6.  * The contents of this file, and the files included with this file,
  7.  * are subject to the current version of the RealNetworks Public
  8.  * Source License (the "RPSL") available at
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed
  10.  * the file under the current version of the RealNetworks Community
  11.  * Source License (the "RCSL") available at
  12.  * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
  13.  * will apply. You may also obtain the license terms directly from
  14.  * RealNetworks.  You may not use this file except in compliance with
  15.  * the RPSL or, if you have a valid RCSL with RealNetworks applicable
  16.  * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
  17.  * the rights, obligations and limitations governing use of the
  18.  * contents of the file.
  19.  * 
  20.  * Alternatively, the contents of this file may be used under the
  21.  * terms of the GNU General Public License Version 2 or later (the
  22.  * "GPL") in which case the provisions of the GPL are applicable
  23.  * instead of those above. If you wish to allow use of your version of
  24.  * this file only under the terms of the GPL, and not to allow others
  25.  * to use your version of this file under the terms of either the RPSL
  26.  * or RCSL, indicate your decision by deleting the provisions above
  27.  * and replace them with the notice and other provisions required by
  28.  * the GPL. If you do not delete the provisions above, a recipient may
  29.  * use your version of this file under the terms of any one of the
  30.  * RPSL, the RCSL or the GPL.
  31.  * 
  32.  * This file is part of the Helix DNA Technology. RealNetworks is the
  33.  * developer of the Original Code and owns the copyrights in the
  34.  * portions it created.
  35.  * 
  36.  * This file, and the files included with this file, is distributed
  37.  * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
  38.  * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
  39.  * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
  40.  * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
  41.  * ENJOYMENT OR NON-INFRINGEMENT.
  42.  * 
  43.  * Technology Compatibility Kit Test Suite(s) Location:
  44.  *    http://www.helixcommunity.org/content/tck
  45.  * 
  46.  * Contributor(s):
  47.  * 
  48.  * ***** END LICENSE BLOCK ***** */
  50. #include "hxtypes.h"
  52. #include "hlxclib/windows.h"
  53. #include <mmsystem.h>
  54. #include <tchar.h> 
  55. #include <stdio.h>
  57. #ifdef _TESTING
  58. #include <fcntl.h>
  59. #include <sys/types.h>
  60. #include <sys/stat.h>
  62. #if defined (_WINDOWS) || defined (_WIN32)
  64. #include <io.h>
  66. #endif
  68. #endif
  70. #include "hxresult.h"
  72. #include "hxcom.h"
  73. #include "hxausvc.h"
  74. #include "auderrs.h"
  75. #include "ihxpckts.h"
  76. #include "hxengin.h"
  78. #include "timeval.h"
  80. #include "hxaudev.h"
  81. #include "hxslist.h"
  82. #include "hxtick.h"
  84. //#include "hxaudses.h"
  86. #include "cbqueue.h"
  87. #include "cpqueue.h"
  88. #include "hxthread.h"
  90. #include "winaudio.h"
  92. #ifdef WIN32_PLATFORM_PSPC
  93. #define WM_NCCREATE WM_CREATE
  94. #define WM_NCDESTROY WM_DESTROY
  95. #endif
  97. struct IHXCallback;
  99. extern HINSTANCE g_hInstance;
  100. #define OFFSET_THIS 0
  102. #ifdef _TESTING
  103. int m_audfile = -1;
  104. #endif
  106. BOOL CAudioOutWindows::zm_bVolSupport = FALSE;
  107. BOOL CAudioOutWindows::zm_bLRVolSupport = FALSE;
  108. WORD CAudioOutWindows::zm_uMaxVolume = 100;
  109. BOOL CAudioOutWindows::zm_bMixerVolSupport = FALSE;
  110. BOOL CAudioOutWindows::zm_bMixerVolSupportChecked = FALSE;
  111. UINT CAudioOutWindows::zm_uDestroyMessage = 0;
  112. BOOL CAudioOutWindows::zm_bClosed = TRUE;
  113. CAudioOutWindows* zm_pCurrentAudioDevice = NULL;
  115. // BAD drivers which need to call waveOutSetVolume directly
  116. const UINT16 g_nBadDrivers = 1;
  117. const TCHAR* g_badDrivers[] = { _T("Crystal Audio System") };
  118. audioDevice CAudioOutWindows::zm_audioDevice = HXAUDIO_UNKNOWN;
  120. //CRITICAL_SECTION CAudioOutWindows::zm_AudioCritSection;
  122. #define MAX_REASONABLE_BUFFS 40
  124. #define PUSH_DOWN_TIME 400    /* push down 400 ms  */
  125. #define LIKELY_PUSH_COUNT 10
  127. CAudioOutWindows::CAudioOutWindows()
  128.     : m_hWave(NULL)
  129.     , m_unAllocedBufferCnt(0)
  130.     , m_unAllocedBuffSize(0)
  131.     , m_ppAllocedBuffers(NULL)
  132.     , m_pWaveHdrs(NULL)
  133.     , m_rAvailBuffers(MAX_REASONABLE_BUFFS)
  134.     , m_bInitialized(FALSE)
  135.     , m_bResetting(FALSE)
  136.     , m_bIsFirstPacket(TRUE)
  137.     , m_hWnd(NULL)
  138.     , m_bClassRegistered(FALSE)
  139.     , m_ulDevPosRollOver(0)
  140.     , m_ulLastDeviceBytesPlayed(0)
  141.     , m_ulLastDeviceSamplesPlayed(0)
  142.     , m_llDeviceBytesPlayed(0)
  143.     , m_llDeviceSamplesPlayed(0)
  144. #if defined(_WIN32)
  145.     , m_ulOriginalThreadId(0)
  146. #endif /*_WIN32*/
  147. {
  148.     zm_bClosed = TRUE;    
  149.     zm_pCurrentAudioDevice = this;
  151. #if defined(_WIN32) && !defined(_WINCE)
  152.     m_hMixer = NULL;  
  153.     memset(&m_VolumeControlDetails, 0 , sizeof(MIXERCONTROLDETAILS));
  154. #endif // _WIN32
  156.     // Create a unique message for destroying the audio window
  157.     if (!zm_uDestroyMessage)
  158.     {
  159. zm_uDestroyMessage = RegisterWindowMessage(_T("HX_DestroyAudioServicesInternal"));
  160.     }
  161.     
  162. #ifdef THREADS_SUPPORTED
  163.     HXMutex::MakeMutex(m_pMutex);
  164. #else
  165.     HXMutex::MakeStubMutex(m_pMutex);
  166. #endif
  167. }    
  170. CAudioOutWindows::~CAudioOutWindows()
  171. {
  172. //    OutputDebugString("BEFORE CALL TO:CAudioOutWindows::~CAudioOutWindowsrn");
  173.     // this gives us one last chance to recover packets that are still in the device
  174.     Reset();
  176.     // We might as well consider the device closed!
  177.     zm_bClosed = TRUE;
  179. #if defined(_WIN32) && !defined(_WINCE)
  181.     /* This sleep is added to fix a hang bug that ONLY happens on
  182.      * Darren's machine if you adjust audio volume. His machine
  183.      * has a really old audio driver
  184.      * 
  185.      * I have no clue what this bug is and how this Sleep(0)
  186.      * fixes it. Obviously, there was some race condition.
  187.      *
  188.      * Sound Driver Info:
  189.      *
  190.      * Version 2.03.0 Build 1
  191.      * Creative Sound Blaster 16 Driver (Windows NT)
  192.      * 
  193.      */
  194.     Sleep(0);
  196.     if(m_hMixer)
  197.     {
  198.         mixerClose(m_hMixer);
  199.     }
  200. #endif // _WIN32
  202.     _Imp_Close();
  204.     zm_pCurrentAudioDevice = NULL;
  205.     HX_DELETE(m_pMutex);
  206. }
  208. UINT16 CAudioOutWindows::_Imp_GetVolume()
  209. {
  210.     DWORD dwVol     = 0;                          
  211.     BOOL bSuccess   = FALSE;
  213. #if defined(_WIN32) && !defined(_WINCE)
  214.     if (!zm_bMixerVolSupportChecked)
  215.     {
  216. CheckForVolumeSupport();
  217.     }
  219.     if(zm_bMixerVolSupport)
  220.     {
  221. if (!m_hMixer)
  222. {
  223.     CheckForVolumeSupport();
  224. }
  226.         PMIXERCONTROLDETAILS_UNSIGNED pmxVolume;
  227.         UINT16 nItems = 1;
  228.         if(m_VolumeControlDetails.cMultipleItems)
  229.             nItems = (UINT16)m_VolumeControlDetails.cMultipleItems;
  230.         pmxVolume = new MIXERCONTROLDETAILS_UNSIGNED[nItems];
  231.         m_VolumeControlDetails.cbDetails = nItems * sizeof(MIXERCONTROLDETAILS_UNSIGNED);
  232.         m_VolumeControlDetails.paDetails = pmxVolume;
  233.         if(mixerGetControlDetails((HMIXEROBJ)m_hMixer, &m_VolumeControlDetails, 
  234.            MIXER_GETCONTROLDETAILSF_VALUE | MIXER_OBJECTF_HMIXER) == MMSYSERR_NOERROR)
  235.         {
  236.             dwVol = pmxVolume[0].dwValue;
  237.             bSuccess = TRUE;
  238.         }
  239.         delete[] pmxVolume;
  240.     }
  241. #endif
  243.     if (!bSuccess)
  244.     {
  245. if (!zm_bVolSupport)
  246. {
  247.     return 0;
  248. }
  250. MMRESULT hResult = waveOutGetVolume( m_hWave, &dwVol );
  252. if (hResult != MMSYSERR_NOERROR && m_hWave != NULL)
  253. {
  254.     hResult = waveOutGetVolume( NULL, &dwVol );
  255. }
  257. if (hResult != MMSYSERR_NOERROR)
  258. {
  259.     return 0;
  260. }
  261.     }
  263.     return ( (UINT16)((DWORD)LOWORD( dwVol ) * zm_uMaxVolume / 0xFFFF ) );
  264. }
  266. HX_RESULT CAudioOutWindows::_Imp_SetVolume
  267. ( 
  268.     const UINT16 uVolume
  269. )
  270. {
  271.     DWORD dwVol = 0;
  272.     BOOL bSuccess = FALSE;
  274.     if (uVolume > zm_uMaxVolume)
  275.     {
  276.         return HXR_OK;
  277.     }
  279. #if defined(_WINCE) && (_WIN32_WCE >= 400) && defined(_X86_)
  280. //Windows CE 4.2 Emulator (testing platform) does not seem to support waveOut
  281. //set volume functionality (on speakers). In some sense it does but only the
  282. //high volume value work, other values just mute the speakers
  283. dwVol = (DWORD) 0xFFFF;
  284. #else
  285.     dwVol = (DWORD)uVolume * 0xFFFF / zm_uMaxVolume;
  286. #endif
  288.     // Here we are avoiding rounding error
  289.     if(dwVol * zm_uMaxVolume / 0xFFFF < uVolume)
  290. dwVol += 0xFFFF / zm_uMaxVolume;
  292.     if (zm_audioDevice == HXAUDIO_BADDEVICE)
  293.     {
  294. goto noMixer;
  295.     }
  297. #if defined(_WIN32) && !defined(_WINCE)
  298.     if (!zm_bMixerVolSupportChecked)
  299.     {
  300. CheckForVolumeSupport();
  301.     }
  303.     if(zm_bMixerVolSupport)
  304.     {
  305. if (!m_hMixer)
  306. {
  307.     CheckForVolumeSupport();
  308. }
  309.         PMIXERCONTROLDETAILS_UNSIGNED pmxVolume;
  310.         UINT16 nItems = 1;
  311.         if(m_VolumeControlDetails.cMultipleItems)
  312.             nItems = (UINT16)m_VolumeControlDetails.cMultipleItems;
  313.         pmxVolume = new MIXERCONTROLDETAILS_UNSIGNED[nItems];
  314.         for(UINT16 nIndex = 0; nIndex < nItems; nIndex++)
  315.             pmxVolume[nIndex].dwValue = dwVol;
  316.         m_VolumeControlDetails.cbDetails = nItems * sizeof(MIXERCONTROLDETAILS_UNSIGNED);
  317.         m_VolumeControlDetails.paDetails = pmxVolume;
  318.         if(mixerSetControlDetails((HMIXEROBJ)m_hMixer, &m_VolumeControlDetails, 
  319.            MIXER_GETCONTROLDETAILSF_VALUE | MIXER_OBJECTF_HMIXER) == MMSYSERR_NOERROR)
  320. {
  321. bSuccess = TRUE;
  322.         }
  323.         delete[] pmxVolume;
  324.     }
  325. #endif
  327. noMixer:
  328.     if ( !bSuccess )
  329.     {
  330. DWORD dwLRVol = MAKELONG(dwVol, dwVol) ;
  331. // fix of bug 4965, in which the balance is thrown to one side.  My speculation is that the
  332. // driver incorrectly reports MONO here when stereo is in use.  To fix the bug, set both
  333. // channels equally.  john dempsey
  335. /* related information: 
  336. "If a devicedoes not support both left and right volume control, the low-order
  337.  word of the dwVolume argument specifies the volume level and the
  338.  high-order word is ignored." -- some DEC document on waveOutSetVolume.
  339. */
  341. HX_ASSERT(LOWORD(dwLRVol) == HIWORD(dwLRVol)) ;
  342. if (!zm_bVolSupport)
  343. {
  344.     return HXR_FAILED;
  345. }
  347. MMRESULT hResult    = waveOutSetVolume(m_hWave, dwLRVol);
  350. MMRESULT hResult2 = hResult;
  352. /* 
  353.  * always set the volume on NULL device. 
  354.  * Needed to attach volume control on win98 SE, Creative SB Live! Value sound card.
  355.  */
  356. if (m_hWave != NULL)
  357. {
  358.      hResult2 = waveOutSetVolume(NULL, dwLRVol);
  359. }
  361. if (hResult != MMSYSERR_NOERROR && hResult2 != MMSYSERR_NOERROR)
  362. {
  363.     return HXR_FAILED;
  364. }
  365.     }
  367.     return HXR_OK;
  368. }
  370. BOOL CAudioOutWindows::_Imp_SupportsVolume()
  371. {
  372.     MMRESULT wSuccess;
  373.     WAVEOUTCAPS auxcap; 
  375. #if defined(_WIN32) && !defined(_WINCE)
  376.     if (!zm_bMixerVolSupportChecked)
  377.     {
  378. CheckForVolumeSupport();
  379.     }
  380. #endif
  382. #if defined(_WIN32) || defined(_WINCE)
  384. // Gonna have to make VolSupport static  
  385.     if ( zm_bVolSupport )
  386.     {
  387.         return (zm_bVolSupport);
  388.     }
  390.     wSuccess = waveOutGetDevCaps( 0, &auxcap, sizeof(WAVEOUTCAPS) );
  392.     if ( MMSYSERR_NOERROR == wSuccess )
  393.     { 
  394.         if (auxcap.dwSupport & WAVECAPS_VOLUME)
  395. {
  396.     zm_bVolSupport=TRUE;
  397. }
  399. if (auxcap.dwSupport & WAVECAPS_LRVOLUME)
  400. {
  401. zm_bLRVolSupport = TRUE;
  402. }
  404. zm_uMaxVolume = 100;
  405. }                   
  406.     else
  407.     {
  408.         zm_bVolSupport = FALSE;
  409.         zm_bLRVolSupport = FALSE;
  410.     }
  412.     return zm_bVolSupport;
  413. #else
  414.     return FALSE;
  415. #endif /*_WIN32*/
  416. }
  418. HX_RESULT CAudioOutWindows:: _Imp_Open
  419. ( 
  420.     const HXAudioFormat* pFormat
  421. )
  422. {
  424.     HX_RESULT theErr = HXR_OK;
  425. #if defined(_WIN32)
  426.     LPWAVEFORMATEX wavePtr;
  427. #elif defined( _WINDOWS )
  428.     LPWAVEFORMAT wavePtr;
  429. #endif
  431.     theErr = Register();
  432.     if (theErr)
  433.     {
  434. return theErr;
  435.     }
  437. #ifdef _TESTING
  438.     m_audfile =  open("\auddev.raw", O_WRONLY | O_CREAT);
  439. #endif
  441.     m_WaveFormat.SetFormat(pFormat->ulSamplesPerSec, pFormat->uChannels, pFormat->uBitsPerSample);
  442.     // Get the Windows style wave format!
  443.     wavePtr = m_WaveFormat.GetWaveFormat();
  445.     // We ain't closed now
  446.     zm_bClosed = FALSE;
  448.     // Open the wave driver.
  449. #ifdef _WIN16
  450.     MMRESULT wRet = waveOutOpen( &m_hWave, WAVE_MAPPER, wavePtr,
  451. (UINT16)m_hWnd, (DWORD)this, CALLBACK_WINDOW);
  452. #else
  453.     MMRESULT wRet = waveOutOpen( &m_hWave, WAVE_MAPPER, wavePtr,
  454. (DWORD)m_hWnd, (DWORD)this, CALLBACK_WINDOW);
  455. #endif
  458.     // Okay, translate any error returns and get out if there was an error
  459.     switch (wRet)
  460.     {
  461. case MMSYSERR_NOERROR:     theErr = HXR_OK; break;
  462. case MMSYSERR_ALLOCATED:    theErr = HXR_AUDIO_DRIVER; break;
  463. case MMSYSERR_NOMEM:     theErr = HXR_OUTOFMEMORY; break;
  464. case MMSYSERR_BADDEVICEID:  theErr = HXR_AUDIO_DRIVER; break;
  465. case WAVERR_BADFORMAT:     theErr = HXR_AUDIO_DRIVER; break;
  466. case WAVERR_SYNC:     theErr = HXR_AUDIO_DRIVER; break;
  467. default:     theErr = HXR_OUTOFMEMORY; break;
  468.     }
  469. #if defined(_WIN32) && !defined(_WINCE)
  470. if ( !theErr )
  471. {
  472.     if (!zm_bMixerVolSupportChecked)
  473.     {
  474. CheckForVolumeSupport();
  475.     }
  476. }
  477. #endif
  480.     return theErr;
  481. }
  483. HX_RESULT CAudioOutWindows::_Imp_Close()
  484. {
  485. #ifdef _TESTING
  486. if ( m_audfile > 0 ) 
  487. close(m_audfile);
  488. m_audfile = -1;
  489. #endif
  491.  zm_bClosed = TRUE;
  492.     if (m_hWave) 
  493.     {
  494. // NOTE: Before we can close, we need to reset!
  495. Reset();
  497. m_pMutex->Lock();
  499. if (m_pWaveHdrs)
  500. {
  501.     UINT16 unWHIndex;
  503.     // Unprepare the individual headers
  504.     for (unWHIndex = 0; unWHIndex < m_unAllocedBufferCnt; ++unWHIndex)
  505.     {
  506.      CWaveHeader* pWaveHeader = &m_pWaveHdrs[unWHIndex];
  507. if (pWaveHeader->m_pPrepared)
  508. {
  509.     LPWAVEHDR lpwHeader = LPWAVEHDR(&pWaveHeader->m_WAVEHDR);
  510.     
  511.     // By now all headers should be marked as done because they
  512.     // are back from the audio device or prepared because we
  513.     // prepared them but never used them
  514.     HX_ASSERT(lpwHeader->dwFlags & WHDR_DONE ||
  515. lpwHeader->dwFlags & WHDR_PREPARED);
  517.     //OutputDebugString("BEFORE CALL TO:waveOutUnprepareHeaderrn");
  518.     HX_VERIFY(MMSYSERR_NOERROR == waveOutUnprepareHeader(m_hWave, 
  519. LPWAVEHDR(&pWaveHeader->m_WAVEHDR), sizeof(WAVEHDR)));
  520.     //OutputDebugString("AFTER CALL TO:waveOutUnprepareHeaderrn");
  521.     pWaveHeader->m_pPrepared = FALSE;
  522. }
  523.     }
  524. }
  526. if (m_ppAllocedBuffers)
  527. {
  528.     UINT16 unIndex;
  530.     for (unIndex = 0; unIndex < m_unAllocedBufferCnt; unIndex++)
  531.     {
  532. delete[] m_ppAllocedBuffers[unIndex];
  533.     }
  534.     delete[] m_ppAllocedBuffers;
  535.     m_ppAllocedBuffers = NULL;
  536. }
  538. m_rAvailBuffers.FlushQueue();
  539. m_UsedBuffersList.RemoveAll();
  541. m_unAllocedBufferCnt = 0;
  543. m_pMutex->Unlock();
  545. for (int i = 0; 
  546. i < 5 && (WAVERR_STILLPLAYING == waveOutClose( m_hWave )); ++i)
  547. {
  548.     waveOutReset( m_hWave );
  549. }
  550. m_hWave = NULL;
  552. if (m_pWaveHdrs)
  553. {
  554.     delete[] m_pWaveHdrs;
  555.     m_pWaveHdrs = NULL;
  556. }
  557.     }
  559.     UnRegister();
  560.     m_bIsFirstPacket = TRUE;
  561.     m_bInitialized = FALSE;
  563.     return HXR_OK;
  564. }
  566. HX_RESULT CAudioOutWindows::_Imp_Write
  567. ( 
  568.     const HXAudioData* pAudioOutHdr 
  569. )
  570. {
  571.     BOOL     bTemp;
  572.     CWaveHeader*    pWaveHeader;
  573.     MMRESULT     res;
  574.     ULONG32     ulBufLen = 0;
  575.     UCHAR*     pBuffer = 0;
  576.     if (pAudioOutHdr->pData)
  577.     {
  578. pBuffer  = pAudioOutHdr->pData->GetBuffer();
  579. ulBufLen = pAudioOutHdr->pData->GetSize();
  580.     }
  582.     if (!m_bInitialized)
  583.     {
  584. m_bInitialized = AllocateBuffers(MAX_REASONABLE_BUFFS,(UINT16)ulBufLen);
  585.     }
  586.     if (!m_bInitialized) return HXR_FAILED;
  588.     m_pMutex->Lock();
  589.     pWaveHeader = (CWaveHeader*)m_rAvailBuffers.DeQueuePtr(bTemp);
  590.     m_pMutex->Unlock();
  592.     if (!bTemp) 
  593.     {
  594. return HXR_WOULD_BLOCK;
  595.     }
  597. #ifdef _TESTING
  598.     if ( m_audfile > 0 )
  599.         write(m_audfile, pBuffer,ulBufLen); 
  600. #endif
  602.     UINT32 ulBytesToCopy = ulBufLen;
  603.     HX_ASSERT(ulBytesToCopy <= pWaveHeader->m_WAVEHDR.dwBufferLength);
  604.     if (ulBytesToCopy > pWaveHeader->m_WAVEHDR.dwBufferLength)
  605.         ulBytesToCopy = pWaveHeader->m_WAVEHDR.dwBufferLength;
  607.     pWaveHeader->m_bAvail = FALSE;
  608.         memcpy(pWaveHeader->m_WAVEHDR.lpData, pBuffer, HX_SAFESIZE_T(ulBytesToCopy)); /* Flawfinder: ignore */
  609.     pWaveHeader->m_ulTimeEnd = pAudioOutHdr->ulAudioTime;
  611.     /* This is needed for LIVE where audio packets may not start
  612.      * from timestamp 0
  613.      */
  614.     if (m_bIsFirstPacket)
  615.     {
  616. m_bIsFirstPacket = FALSE;
  617.     }
  619.     //OutputDebugString("BEFORE CALL TO:waveOutWritern");
  620.     res = waveOutWrite(m_hWave, LPWAVEHDR(&pWaveHeader->m_WAVEHDR), sizeof(WAVEHDR));
  622.     m_pMutex->Lock();
  623.     m_UsedBuffersList.AddTail(pWaveHeader);
  624.     m_pMutex->Unlock();
  625.     //OutputDebugString("AFTER CALL TO:waveOutWritern");
  627.     return HXR_OK;
  628. }
  630. HX_RESULT CAudioOutWindows::_Imp_Seek(ULONG32 ulSeekTime)
  631. {
  632.     return HXR_OK;
  633. }
  635. HX_RESULT CAudioOutWindows::_Imp_Pause()
  636. {
  637.     MMRESULT res;
  638.     if (m_hWave) 
  639.     {
  640. // OutputDebugString("BEFORE CALL TO:waveOutPausern");
  641.         res = waveOutPause(m_hWave);
  642. //OutputDebugString("AFTER CALL TO:waveOutPausern");
  643.     }
  644.     return HXR_OK;
  645. }
  647. HX_RESULT CAudioOutWindows::_Imp_Resume()
  648. {
  649.     MMRESULT res;
  650.     if (m_hWave) 
  651.     {
  652. // OutputDebugString("BEFORE CALL TO:waveOutRestartrn");
  653.         res = waveOutRestart(m_hWave);
  654. //OutputDebugString("AFTER CALL TO:waveOutRestartrn");
  655.     }
  657.     OnTimeSync();
  659.     return HXR_OK;
  660. }
  662. HX_RESULT CAudioOutWindows::_Imp_Reset()
  663. {
  664. //{FILE* f1 = ::fopen("c:\audio.txt", "a+"); ::fprintf(f1, "Reset: n");::fclose(f1);}
  665.     MMRESULT res;
  666.     m_bResetting = TRUE;
  667.     if (m_hWave) 
  668.     {
  669. // OutputDebugString("BEFORE CALL TO:waveOutResetrn");
  670. res = waveOutReset(m_hWave);
  671. // Need to be turned on after RC2000 XXXRA
  672. // commenting it out for safety reasons.
  673. //_Imp_Pause();
  674. //OutputDebugString("AFTER CALL TO:waveOutResetrn");
  675. m_bIsFirstPacket = TRUE;
  677. m_llDeviceBytesPlayed = 0;
  678. m_llDeviceSamplesPlayed = 0;
  680. m_ulLastDeviceBytesPlayed = 0;
  681. m_ulLastDeviceSamplesPlayed = 0;
  682. m_ulDevPosRollOver = 0;
  683.     }
  685.     // First return the unused buffers to the available queue
  686.     // Then pump out the wom_dones.
  687.     //
  688.     _NumberOfBlocksRemainingToPlay();
  690.     // Make sure we handle all the wave-done messages,
  691.     // but establish a time limit to cope with the 
  692.     // unpredictable nature of Windows. Wait for up
  693.     // to 1 second.
  695.     DWORD start = HX_GET_TICKCOUNT();
  696.     if (m_hWnd)
  697.     {
  698. do
  699. {
  700.     MSG msg;
  702.     // Yield, and try to pump WOM_DONE's to the Async Window!
  703.     while (PeekMessage(&msg, m_hWnd, MM_WOM_DONE, MM_WOM_DONE, PM_REMOVE))
  704.     {
  705. if(msg.message == WM_QUIT) 
  706. {   
  707.     // When peeking WM_QUIT message in the main thread of an application 
  708.     // we have to put it back into message queue to allow the application 
  709.     // to exit correctly. SB
  710.     PostQuitMessage(0);
  711.     break;
  712. }
  713. else
  714. {
  715.     DispatchMessage(&msg);
  716. }
  717.     }
  719.     if (CALCULATE_ELAPSED_TICKS(start, HX_GET_TICKCOUNT()) >= 1000)
  720.     {
  722. // Brute force, mark them as free... We probably 
  723. // could do something better here, like close and
  724. // reopen the wave device... but this is what the
  725. // old code did, so lets try it as well!
  727. ULONG32 lTmp;
  728. m_pMutex->Lock();
  729. for (lTmp = 0; m_pWaveHdrs && (lTmp < m_unAllocedBufferCnt); ++lTmp)
  730. {
  731.     CWaveHeader *pwhDone = &m_pWaveHdrs[lTmp];
  732.     if (pwhDone && pwhDone->m_bAvail == FALSE)
  733.     {
  734. pwhDone->m_bAvail = TRUE;
  735. m_rAvailBuffers.EnQueuePtr(pwhDone);
  736.     }
  737. }
  738. m_pMutex->Unlock();
  740. //OutputDebugString("Bail WOM_DONE vacuum, passed timeout!rn");
  741. break;
  742.     }
  744. }
  745. while (_NumberOfBlocksRemainingToPlay());
  746.     }
  747.     //OutputDebugString("END: WOM_DONE vacuum!rn");
  749.     m_bResetting = FALSE;
  750.     return HXR_OK;
  751. }
  753. HX_RESULT CAudioOutWindows::_Imp_Drain()
  754. {
  755.     return HXR_OK;
  756. }
  758. HX_RESULT CAudioOutWindows::_Imp_CheckFormat
  759. ( 
  760.     const HXAudioFormat* pFormat 
  761. )
  762. {
  763. #if defined(_WIN32)
  764.     LPWAVEFORMATEX wavePtr;
  765. #elif defined( _WINDOWS )
  766.     LPWAVEFORMAT wavePtr;
  767. #endif
  769.     m_WaveFormat.SetFormat(pFormat->ulSamplesPerSec, pFormat->uChannels, pFormat->uBitsPerSample);
  770.    
  771. // Get the Windows style wave format!
  772.     wavePtr = m_WaveFormat.GetWaveFormat();
  775.     MMRESULT wRet = waveOutOpen(&m_hWave,WAVE_MAPPER,wavePtr,
  776.         0, (DWORD)this,WAVE_FORMAT_QUERY);
  778.     switch (wRet)
  779.     {
  780. case MMSYSERR_NOERROR:     return( HXR_OK );
  781. case MMSYSERR_ALLOCATED:    return( HXR_AUDIO_DRIVER );
  782. case MMSYSERR_NOMEM:     return( HXR_OUTOFMEMORY );
  783. case MMSYSERR_BADDEVICEID:  return( HXR_AUDIO_DRIVER );
  784. case WAVERR_BADFORMAT:     return( HXR_AUDIO_DRIVER );
  785. case WAVERR_SYNC:     return( HXR_AUDIO_DRIVER );
  786. case MMSYSERR_NODRIVER:     return( HXR_AUDIO_DRIVER );
  787. default:     return( HXR_AUDIO_DRIVER );
  788.     }
  790. }
  792. BOOL CAudioOutWindows::AllocateBuffers(UINT16 unNumBuffers, UINT16 unBufSize)
  793. {
  794.     UCHAR**     ppWaveBuffers;
  795.     CWaveHeader*    pWaveHdrs;
  796.     MMRESULT     tRes;
  797.     UINT16     unWHIndex;
  800.     ppWaveBuffers = NULL;
  801.     pWaveHdrs = NULL;
  803.     // Allocate memory for wave block headers and for wave data.
  804.     if (!(pWaveHdrs = new CWaveHeader [unNumBuffers]))
  805.     {
  806.         goto OnError;
  807.     }
  809.     // This array holds the buffer pointers so we can free them later
  810.     // There NO other purpose for this array.
  811.     if (!(ppWaveBuffers = new UCHAR*[unNumBuffers]))
  812.     {
  813. goto OnError;
  814.     }
  815.     memset( ppWaveBuffers, 0, unNumBuffers * sizeof( UCHAR* ) );
  816.     
  817.     // Mark all wave block headers as available, and point them
  818.     // at their respective wave data blocks.
  819.     // AND enqueue them in the AvailableBuffers Queue.
  820.     // AND allocate their buffers!!!
  822.     for (unWHIndex = 0; unWHIndex < unNumBuffers; unWHIndex++) 
  823.     {
  824.         UCHAR* pBuff;
  826. // Try to allocate the individual audio buffers
  827.      pBuff = new UCHAR [unBufSize];
  828. if (!pBuff)
  829. {
  830.     goto OnError;
  831.      }
  832. ppWaveBuffers[unWHIndex] = pBuff;
  834. CWaveHeader* pWaveHeader = &pWaveHdrs[unWHIndex];
  836. // Init some header data before Preparing the header
  837. pWaveHeader->m_WAVEHDR.lpData = (char *)pBuff;
  838. pWaveHeader->m_WAVEHDR.dwUser = DWORD(pWaveHeader);
  839. pWaveHeader->m_WAVEHDR.dwFlags = 0L;
  840. pWaveHeader->m_WAVEHDR.dwBufferLength = unBufSize;
  841. pWaveHeader->m_WAVEHDR.dwLoops = 0L;
  842. pWaveHeader->m_bAvail = TRUE;
  843. pWaveHeader->m_pUser = this;
  845. m_pMutex->Lock();
  846. m_rAvailBuffers.EnQueuePtr(pWaveHeader);
  847. m_pMutex->Unlock();
  849. //OutputDebugString("BEFORE CALL TO:waveOutPrepareHeaderrn");
  850.         tRes = waveOutPrepareHeader(m_hWave, LPWAVEHDR(&pWaveHeader->m_WAVEHDR), sizeof(WAVEHDR));
  851. //OutputDebugString("AFTER CALL TO:waveOutPrepareHeaderrn");
  852. if (tRes != MMSYSERR_NOERROR)
  853. {
  854.     goto OnError;
  855. }
  856. else
  857. {
  858.     pWaveHeader->m_pPrepared = TRUE;
  859.      }
  860.     }
  861.     m_unAllocedBufferCnt = unNumBuffers;
  862.     m_unAllocedBuffSize = unBufSize;
  863.     m_pWaveHdrs = pWaveHdrs;
  864.     m_ppAllocedBuffers = ppWaveBuffers;
  866.     return TRUE;
  868. OnError:
  870.     if (pWaveHdrs)
  871.     {
  872. // Unprepare the individual headers
  873. for (unWHIndex = 0; unWHIndex < unNumBuffers; ++unWHIndex)
  874. {
  875.          CWaveHeader* pWaveHeader = &pWaveHdrs[unWHIndex];
  876.     if (pWaveHeader->m_pPrepared)
  877.     {
  878. //OutputDebugString("BEFORE CALL TO:waveOutUnprepareHeaderrn");
  879. tRes = waveOutUnprepareHeader(m_hWave, 
  880.     LPWAVEHDR(&pWaveHeader->m_WAVEHDR), sizeof(WAVEHDR));
  881. //OutputDebugString("AFTER CALL TO:waveOutUnprepareHeaderrn");
  882. pWaveHeader->m_pPrepared = FALSE;
  883.     }
  884. }
  886. delete[] pWaveHdrs;
  887. pWaveHdrs = NULL;
  888.     }
  889.     // ppWaveBuffers actually points at an array of pointers that need to be free'd
  890.     if (ppWaveBuffers)
  891.     {
  892. // Free the individual buffers
  893. for (unWHIndex = 0; unWHIndex < unNumBuffers; ++unWHIndex)
  894. {
  895.     UCHAR* pBuff;
  897.     pBuff = ppWaveBuffers[unWHIndex];
  898.     if (pBuff)
  899.     {
  900.      delete[] pBuff;
  901.     }
  902. }
  903. // Now free ppWaveBuffers itself
  904. delete[] ppWaveBuffers;
  905. ppWaveBuffers = NULL;
  906.     }
  907.     return FALSE;
  908. }
  910. /************************************************************************
  911.  *  Method:
  912.  *              CAudioOutWindows::_Imp_GetCurrentTime
  913.  *      Purpose:
  914.  *              Get the current time from the audio device.
  915.  *              We added this to support the clock available in the
  916.  *              Window's audio driver.
  917.  */
  918. HX_RESULT CAudioOutWindows::_Imp_GetCurrentTime
  919. ( 
  920.         ULONG32& ulCurrentTime
  921. )
  922. {
  923. ULONG32 ulDeviceTime = 0;
  924. ULONG32 ulDeviceBytesPlayed = 0;
  925. UINT32 ulDeviceSamplesPlayed = 0;
  927. WAVEFMTPTR pWFmt = m_WaveFormat.GetWaveFormat();
  929. // Set the time to the playback time of the
  930. // wave device since it's the most accurate.
  931. MMTIME mmTime;
  933. // we want MS if we can get them
  934. mmTime.wType = TIME_MS;
  936. MMRESULT res = waveOutGetPosition(m_hWave, &mmTime, sizeof(MMTIME));
  938. if (MMSYSERR_NOERROR == res)
  939. {
  940. // We must check the output format and convert to MS if possible
  941. switch (mmTime.wType)
  942. {
  943. case TIME_MS:
  944. {
  945. ulDeviceTime = mmTime.u.ms;
  947. #if defined(_WIN32)
  948. ULONG32 BitsPerSample = (pWFmt->nChannels * pWFmt->wBitsPerSample);
  949. #elif _WIN16
  950. ULONG32 BitsPerSample = (pWFmt->nAvgBytesPerSec * 8 / pWFmt->nSamplesPerSec);
  951. #endif
  952. ULONG32 BitsPerSecond = (BitsPerSample * pWFmt->nSamplesPerSec);
  953. ulDeviceBytesPlayed = (mmTime.u.ms * BitsPerSecond) / 8000;
  954. }
  955. break;
  956. case TIME_SAMPLES:
  957. {
  958. // Convert samples to MS
  959. ulDeviceSamplesPlayed = mmTime.u.sample;
  961. if (m_ulLastDeviceSamplesPlayed > ulDeviceSamplesPlayed &&
  962.     ((m_ulLastDeviceSamplesPlayed - ulDeviceSamplesPlayed) > MAX_TIMESTAMP_GAP))
  963. {
  964.     m_ulDevPosRollOver++;
  965. }
  966.  
  967. m_ulLastDeviceSamplesPlayed = ulDeviceSamplesPlayed;
  968. m_llDeviceSamplesPlayed = (INT64)ulDeviceSamplesPlayed + (INT64)m_ulDevPosRollOver * (INT64)MAX_UINT32;
  970. ulDeviceTime = (ULONG32)(((float)m_llDeviceSamplesPlayed/(float)pWFmt->nSamplesPerSec)*1000.f);
  972. #if defined(_WIN32)
  973. ULONG32 BitsPerSample = (pWFmt->nChannels * pWFmt->wBitsPerSample);
  974. #elif _WIN16
  975. ULONG32 BitsPerSample = (pWFmt->nAvgBytesPerSec * 8 / pWFmt->nSamplesPerSec);
  976. #endif
  977. ulDeviceBytesPlayed = (ULONG32)(mmTime.u.sample * 8.0f) / BitsPerSample;
  978. }
  979. break;
  980. case TIME_BYTES:
  981. {
  982. // Convert Bytes to MS
  983. ulDeviceBytesPlayed = mmTime.u.cb;
  985. if (m_ulLastDeviceBytesPlayed > ulDeviceBytesPlayed &&
  986.     ((m_ulLastDeviceBytesPlayed - ulDeviceBytesPlayed) > MAX_TIMESTAMP_GAP))
  987. {
  988.     m_ulDevPosRollOver++;
  989. }
  991. m_ulLastDeviceBytesPlayed = ulDeviceBytesPlayed;
  992. m_llDeviceBytesPlayed = (INT64)ulDeviceBytesPlayed + (INT64)m_ulDevPosRollOver * (INT64)MAX_UINT32;
  994. //{FILE* f1 = ::fopen("c:\audio.txt", "a+"); ::fprintf(f1, "ulDeviceBytesPlayed: %lun", ulDeviceBytesPlayed);::fclose(f1);}
  996. #if defined(_WIN32)
  997. ULONG32 BitsPerSample = (pWFmt->nChannels * pWFmt->wBitsPerSample);
  998. #elif _WIN16
  999. ULONG32 BitsPerSample = (pWFmt->nAvgBytesPerSec * 8 / pWFmt->nSamplesPerSec);
  1000. #endif
  1001. ULONG32 BitsPerSecond = (BitsPerSample * pWFmt->nSamplesPerSec);
  1002. ulDeviceTime = (ULONG32)((m_llDeviceBytesPlayed * 8000)/(INT64)BitsPerSecond); }
  1003. break;
  1004. }
  1005. // ?? ulCurrentTime = ulDeviceTime + m_StreamTimeOffset + m_CorrectionOffset;
  1006. ulCurrentTime = m_ulCurrentTime = ulDeviceTime;
  1007. }
  1008. else
  1009. {
  1010. ulCurrentTime = m_ulCurrentTime = 0;
  1011. }
  1013. //{FILE* f1 = ::fopen("c:\audio.txt", "a+"); ::fprintf(f1, "%lut%lun", HX_GET_TICKCOUNT(), m_ulCurrentTime);::fclose(f1);}
  1015. return HXR_OK;
  1016. }
  1018. /************************************************************************
  1019.  *  Method:
  1020.  *              CAudioOutWindows::WaveOutProc
  1021.  *      Purpose:
  1022.  *              This static member function is called when the wave 
  1023.  *              device is finished playing its audio buffer.  We use 
  1024.  *              it to tell audio services that we're ready for more.
  1025.  */
  1026. #if defined(_WIN32)
  1027. LRESULT __declspec(dllexport) CALLBACK 
  1028. #else
  1029. LRESULT CALLBACK __export 
  1030. #endif
  1031. CAudioOutWindows::WaveOutWndProc(HWND hWnd, // handle of window
  1032. UINT uMsg, // message identifier
  1033. WPARAM wParam, // first message parameter
  1034. LPARAM lParam)  // second message parameter)
  1035. {
  1036.     DWORD dwParam1 = lParam;
  1038.     CAudioOutWindows* pThis = 0;
  1040.     if (uMsg == WM_NCCREATE)
  1041.     {
  1042. CREATESTRUCT* lpCreate = 0;
  1044. // Set our this pointer, so our WndProc can find us again
  1045. lpCreate = (CREATESTRUCT FAR*) lParam;
  1046. pThis = (CAudioOutWindows*) lpCreate->lpCreateParams;
  1047. SetWindowLong(hWnd, OFFSET_THIS, (long) pThis);
  1048.     }
  1049.     else if (uMsg == WM_NCDESTROY)
  1050.     {
  1051. // remove our this pointer so if somebody calls this function
  1052. // again after the window is gone (and the object is gone
  1053. // too) we don't try to call a method from the pointer
  1054. SetWindowLong(hWnd, OFFSET_THIS, 0L);
  1055.     }
  1056.     else
  1057.     {
  1058. pThis = (CAudioOutWindows*) (LPHANDLE)GetWindowLong(hWnd, OFFSET_THIS);
  1059.     }
  1061.     if (!pThis)
  1062.     {
  1063. goto exit;
  1064.     }
  1066.     switch (uMsg)
  1067.     {
  1068.     case MM_WOM_DONE:
  1069.     HX_ASSERT(zm_bClosed || zm_pCurrentAudioDevice == pThis);
  1070.     if (!zm_bClosed && zm_pCurrentAudioDevice == pThis)
  1071.     {
  1072.     // Only do this on WOM_DONE, note there are other messages sent to this
  1073.     // callback function, like WOM_OPEN and WOM_CLOSE
  1074.     //DWORD dwTime1 = timeGetTime();
  1076.     //OutputDebugString("START:(uMsg == MM_WOM_DONE) in WaveOutThreadProcrn");
  1078.     pThis->m_pMutex->Lock();
  1080.     if (zm_bClosed)
  1081.     {
  1082. pThis->m_pMutex->Unlock();
  1083. goto exit;
  1084.     }
  1086.     WAVEHDR* pWAVEHDR;
  1087.     CWaveHeader* pWaveHeader;
  1088.     
  1089.     pWAVEHDR = (WAVEHDR*)dwParam1;
  1090.     pWaveHeader = (CWaveHeader*)pWAVEHDR->dwUser;
  1092.     /* We may have already removed it from the queue
  1093.      * while checking for _NumberOfBlocksRemainingToPlay
  1094.      */
  1095.     if ((pWAVEHDR->dwFlags & WHDR_DONE) &&
  1096.                                 !pThis->m_UsedBuffersList.IsEmpty() &&
  1097. pThis->m_UsedBuffersList.GetHead() == (void*) pWaveHeader)
  1098.     {
  1099. // put it back in the queue
  1100. pWaveHeader->m_bAvail = TRUE;
  1101. pThis->m_rAvailBuffers.EnQueuePtr(pWaveHeader);
  1103. /* This is assuming that we get WOM_DONEs sequentially
  1104.  * There seems to be a bug in WIN16 where it may return
  1105.  * WOM_DONEs out of order. Need to be fixed for that
  1106.  * XXX Rahul
  1107.  */
  1108. pThis->m_UsedBuffersList.RemoveHead();
  1109.     }
  1110.     pThis->m_pMutex->Unlock();
  1112.     if (pThis &&
  1113. !pThis->m_bResetting)
  1114.     {
  1115. //  Call the base class's  OnTimeSync to let it know that we're done playing
  1116. //  the current chunk of audio
  1117. //OutputDebugString("BEFORE:pThis->OnTimeSync()rn");
  1118. pThis->OnTimeSync();
  1119.     }
  1120.     }
  1121.     break;
  1123.     case MM_WOM_OPEN:
  1124.     break;
  1125.             
  1126.     case MM_WOM_CLOSE:   
  1127.     break;
  1128.     
  1129.     default:
  1130.     break;
  1131.     }
  1133.     if (uMsg == zm_uDestroyMessage)
  1134.     {
  1135. LRESULT result = (LRESULT)DestroyWindow(hWnd);
  1137. // free the memory used by this class now that our window is destroyed
  1138. UnregisterClass(WND_CLASS, g_hInstance);
  1139. return result;
  1140.     }
  1142. exit:
  1143.     return ( DefWindowProc(hWnd, uMsg, wParam, lParam) );    
  1144. }
  1149. UINT16 CAudioOutWindows::_NumberOfBlocksRemainingToPlay(void)
  1150. {
  1151.     m_pMutex->Lock();
  1153.     UINT16 unRemaining = m_UsedBuffersList.GetCount();
  1155.     /* There may be some buffers for which we have not receoved WOM_DONEs
  1156.      * but they have already been played
  1157.      */
  1158.     if (unRemaining > 0)
  1159.     {
  1160. LISTPOSITION ndxLastUsed = NULL;
  1161. LISTPOSITION ndxUsed = m_UsedBuffersList.GetHeadPosition();
  1162. while (ndxUsed != NULL)
  1163. {
  1164.     ndxLastUsed = ndxUsed;
  1165.     CWaveHeader* pWaveHeader = 
  1166.     (CWaveHeader*) m_UsedBuffersList.GetNext(ndxUsed);
  1167.     if (pWaveHeader->m_WAVEHDR.dwFlags & WHDR_DONE)
  1168.     {
  1169. if (unRemaining > 0)
  1170.     unRemaining--;
  1172. // put it back in the queue
  1173. pWaveHeader->m_bAvail = TRUE;
  1174. m_rAvailBuffers.EnQueuePtr(pWaveHeader);
  1175. m_UsedBuffersList.RemoveAt(ndxLastUsed);
  1176.     }
  1177.     else
  1178.     {
  1179. /* We assume that subsequent blocks are also not done playing */
  1180. break;
  1181.     }
  1182. }
  1183.     }
  1185.     m_pMutex->Unlock();
  1187.     return unRemaining;
  1188. }
  1190. #if defined(_WIN32) && !defined(_WINCE)
  1191. void
  1192. CAudioOutWindows::CheckForVolumeSupport()
  1193. {
  1194.     zm_bMixerVolSupportChecked = TRUE;
  1196.     if (!m_hWnd)
  1197.     {
  1198. Register();
  1199.     }
  1201.     // if there is more than 1 mixer, we need to find out which is the current one
  1202.     // we do this by determining the mixer being used by the current wave device
  1203.     int startIndex = 0;
  1204.     if (m_hWave != NULL && mixerGetNumDevs() > 1)
  1205.     {
  1206. UINT nId = -1;   
  1207. if ((mixerGetID((HMIXEROBJ)m_hWave, &nId, MIXER_OBJECTF_HWAVEOUT) == MMSYSERR_NOERROR) && nId != -1)
  1208. {
  1209.     startIndex = nId;
  1210. }
  1211.     }
  1213.     for(UINT index = startIndex; index < mixerGetNumDevs(); index++)
  1214.     {
  1215. if(mixerOpen(&m_hMixer, index, (DWORD)m_hWnd, 0, CALLBACK_WINDOW) 
  1216. == MMSYSERR_NOERROR)
  1217. {
  1218.     MIXERLINE mxLine;
  1219.     mxLine.cbStruct = sizeof(MIXERLINE);
  1220.     mxLine.dwComponentType = MIXERLINE_COMPONENTTYPE_SRC_WAVEOUT;
  1221.     if(mixerGetLineInfo((HMIXEROBJ)m_hMixer, &mxLine, 
  1222.        MIXER_GETLINEINFOF_COMPONENTTYPE | MIXER_OBJECTF_HMIXER) 
  1223.     == MMSYSERR_NOERROR)
  1224.     {
  1225. // use waveOutSetVolume for bad device(i.e. crystal audio)
  1226. if (zm_audioDevice == HXAUDIO_UNKNOWN && mxLine.Target.szPname)
  1227. {
  1228.     for (int i = 0; i < g_nBadDrivers; i++)
  1229.     {
  1230. if (_tcsstr(mxLine.Target.szPname, g_badDrivers[i]))
  1231. {
  1232.     zm_audioDevice = HXAUDIO_BADDEVICE;
  1233.     break;
  1234. }
  1235.     }
  1237.     if (zm_audioDevice == HXAUDIO_UNKNOWN)
  1238.     {
  1239. zm_audioDevice = HXAUDIO_GOODDEVICE;
  1240.     }
  1241. }
  1243. if (zm_audioDevice != HXAUDIO_BADDEVICE)
  1244. {
  1245.     MIXERCONTROL mxControl;
  1246.     mxControl.cbStruct = sizeof(MIXERCONTROL);
  1247.     MIXERLINECONTROLS mxLineControls;
  1248.     mxLineControls.cbStruct = sizeof(MIXERLINECONTROLS);
  1249.     mxLineControls.dwLineID = mxLine.dwLineID;
  1250.     mxLineControls.cControls = 1;
  1251.     mxLineControls.cbmxctrl = mxControl.cbStruct;
  1252.     mxLineControls.pamxctrl = &mxControl;
  1253.     mxLineControls.dwControlType = MIXERCONTROL_CONTROLTYPE_VOLUME | 
  1254.    MIXERCONTROL_CONTROLF_UNIFORM;
  1256.     if(mixerGetLineControls((HMIXEROBJ)m_hMixer, &mxLineControls, 
  1257.        MIXER_GETLINECONTROLSF_ONEBYTYPE | MIXER_OBJECTF_HMIXER) 
  1258.     == MMSYSERR_NOERROR)
  1259.     {
  1260. if(mxLineControls.cControls)
  1261. {
  1262.     zm_bVolSupport = TRUE;
  1263.     zm_bMixerVolSupport = TRUE;
  1264.     m_VolumeControlDetails.cbStruct = 
  1265. sizeof(MIXERCONTROLDETAILS); 
  1266.     m_VolumeControlDetails.dwControlID = 
  1267. mxControl.dwControlID; 
  1268.     m_VolumeControlDetails.cChannels = 1; 
  1269.     m_VolumeControlDetails.cMultipleItems = 
  1270. mxControl.cMultipleItems; 
  1271. }
  1272.     }   
  1273. }
  1274.     }
  1275.     break;
  1276. }
  1277.     }
  1278. }
  1279. #endif /*_WIN32*/
  1282. HX_RESULT
  1283. CAudioOutWindows::Register()
  1284. {
  1285.     WNDCLASS internalClass;
  1287. //    OutputDebugString("BEFORE CALL TO:Registerrn");
  1288.     if (m_hWnd)
  1289.     {
  1290. return HXR_OK;
  1291.     }
  1293. //m_hInst = hInst;
  1294. m_hInst = g_hInstance;
  1296. if (!m_hInst)
  1297. {
  1298. #ifdef _DEBUG
  1299. MessageBox(NULL, _T("Don't have a valid handle"), NULL, MB_OK);
  1300. #endif
  1301.   return HXR_OUTOFMEMORY;
  1302. }
  1305. // XXXKM - let's see if we can get the class info first; added this additional
  1306. // check due to a strange problem when registering a class that seems to already
  1307. // be registered.  For some reason, under some circumstance, RegisterClass returns
  1308. // NULL and GetLastError returns 0x57 (invalid parameter), however the class
  1309. // is already registered
  1310. if (!::GetClassInfo(m_hInst, WND_CLASS, &internalClass))
  1311. {
  1312. // First register our window class                                  
  1313. internalClass.style  = 0;
  1315. internalClass.lpfnWndProc  = CAudioOutWindows::WaveOutWndProc;
  1317. internalClass.cbClsExtra    = 0;
  1318. internalClass.cbWndExtra    = sizeof( this );
  1319. internalClass.hInstance     = m_hInst; // Use app's instance
  1320. internalClass.hIcon         = 0;
  1321. internalClass.hCursor       = 0;
  1322. internalClass.hbrBackground = 0;
  1323. internalClass.lpszMenuName  = NULL;
  1324. internalClass.lpszClassName = WND_CLASS;
  1326. #ifdef _WIN16
  1327. if (!RegisterClass( &internalClass ))
  1328. #else
  1329. if (!RegisterClass( &internalClass ) && GetLastError() != ERROR_CLASS_ALREADY_EXISTS)
  1330. #endif /* _WIN16 */    
  1331. {
  1332. #ifdef _DEBUG
  1333. MessageBox(NULL, _T("Could Not register class"), NULL, MB_OK);
  1334. #endif
  1335. return(HXR_OUTOFMEMORY);
  1336. }
  1337. m_bClassRegistered = TRUE;
  1338. }
  1340. //    OutputDebugString("BEFORE CALL TO:CreateWindowrn");
  1341.     // Now create an instance of the window
  1342.     m_hWnd = CreateWindow( WND_CLASS /*"AudioServicesInternal"*/, _T("Audio Services Internal Messages"), 
  1343. WS_OVERLAPPED, 0, 0, 0, 0, NULL, NULL, m_hInst, this);
  1345. #if defined(_WIN32)
  1346.     m_ulOriginalThreadId = GetCurrentThreadId();
  1347. #endif
  1349.     if (!m_hWnd)
  1350.     {
  1351. #ifdef _DEBUG
  1352. MessageBox(NULL, _T("Could Not create messageWindow"), NULL, MB_OK);
  1353. #endif
  1354. return HXR_OUTOFMEMORY;
  1355.     }
  1357.     return HXR_OK;
  1358. }
  1360. void
  1361. CAudioOutWindows::UnRegister()
  1362. {
  1363. //    OutputDebugString("BEFORE CALL TO:UnRegisterrn");
  1364.     // Ask the window to destroy itself
  1365.     if (m_hWnd) 
  1366.     {
  1367. #if defined(_WIN32)
  1368. if (m_ulOriginalThreadId == GetCurrentThreadId())
  1369. {
  1370.     SendMessage(m_hWnd, zm_uDestroyMessage, 0, 0);
  1371. }
  1372. else
  1373. {
  1374.     PostMessage(m_hWnd, zm_uDestroyMessage, 0, 0);
  1375.     Sleep(0);
  1376. }
  1377. #else
  1378. SendMessage(m_hWnd, zm_uDestroyMessage, 0, 0);
  1379. #endif
  1381. m_hWnd = NULL;
  1382.     }
  1384. /*
  1385.     // Ask the window to destroy itself
  1386.     if (m_hWnd && SendMessage(m_hWnd, zm_uDestroyMessage, 0, 0)) 
  1387.     {
  1388. m_hWnd = NULL;
  1389.     }
  1391.     // free the memory used by this class now that our window is destroyed
  1392.     UnregisterClass(WND_CLASS, g_hInstance);
  1394. */
  1395. }