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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
macaudio.cp
资源名称：helix.src.0812.rar　[点击查看]
上传用户：zhongxx05
上传日期：2007-06-06
资源大小：33641k
文件大小：36k
源码类别：

Symbian

开发平台：

C/C++

macaudio.cp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK ***** 
  2.  * Version: RCSL 1.0/RPSL 1.0 
  3.  *  
  4.  * Portions Copyright (c) 1995-2002 RealNetworks, Inc. All Rights Reserved. 
  5.  *      
  6.  * The contents of this file, and the files included with this file, are 
  7.  * subject to the current version of the RealNetworks Public Source License 
  8.  * Version 1.0 (the "RPSL") available at 
  9.  * http://www.helixcommunity.org/content/rpsl unless you have licensed 
  10.  * the file under the RealNetworks Community Source License Version 1.0 
  11.  * (the "RCSL") available at http://www.helixcommunity.org/content/rcsl, 
  12.  * in which case the RCSL will apply. You may also obtain the license terms 
  13.  * directly from RealNetworks.  You may not use this file except in 
  14.  * compliance with the RPSL or, if you have a valid RCSL with RealNetworks 
  15.  * applicable to this file, the RCSL.  Please see the applicable RPSL or 
  16.  * RCSL for the rights, obligations and limitations governing use of the 
  17.  * contents of the file.  
  18.  *  
  19.  * This file is part of the Helix DNA Technology. RealNetworks is the 
  20.  * developer of the Original Code and owns the copyrights in the portions 
  21.  * it created. 
  22.  *  
  23.  * This file, and the files included with this file, is distributed and made 
  24.  * available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER 
  25.  * EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS ALL SUCH WARRANTIES, 
  26.  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS 
  27.  * FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. 
  28.  * 
  29.  * Technology Compatibility Kit Test Suite(s) Location: 
  30.  *    http://www.helixcommunity.org/content/tck 
  31.  * 
  32.  * Contributor(s): 
  33.  *  
  34.  * ***** END LICENSE BLOCK ***** */ 
  36. //
  37. // macaudio.cp
  38. // 
  40. #include <stdio.h>
  41. #include "macaudio.h"
  42. #include "USound.h"
  43. #ifndef _MAC_MACHO
  44. #include <AIFF.h>
  45. #include <fixmath.h>
  46. #endif
  48. #include "hxtypes.h"
  49. #include "hxerrors.h"
  50. #include "hxcom.h"
  51. #include "hxausvc.h"
  52. #include "auderrs.h"
  54. #include "hxaudev.h"
  55. #include "hxslist.h"
  56. #include "hxtick.h"
  57. #include "chxpckts.h"
  59. #ifdef THREADS_SUPPORTED
  60. #include "hxthread.h"
  61. #endif
  63. #include "hxmm.h"
  65. //#define LOG_MULTIPLE_DEFERRED_TASKS 1
  67. BOOL  gSoundCallbackTime = FALSE;
  69. #if defined( _CARBON ) || defined( _MAC_UNIX )
  70. DeferredTaskUPP CAudioOutMac::gDeferredTask = NewDeferredTaskUPP(CAudioOutMac::DeferredTaskCallback);
  71. #else
  72. DeferredTaskUPP CAudioOutMac::gDeferredTask = NewDeferredTaskProc(CAudioOutMac::DeferredTaskCallback);
  73. #endif
  75. #ifdef THREADS_SUPPORTED
  76. HXMutex* CAudioOutMac::zm_pMutex = NULL;
  77. #endif
  79. CAudioOutMac*       gActiveAudioDevice = NULL;     
  82. #if defined( _CARBON ) || defined( _MAC_UNIX )
  84. typedef pascal Handle (*MacAudioNewHandleSysProcPtr)(Size);
  85. CFragConnectionID gAudioInterfaceLibConnID = kInvalidID;
  86. MacAudioNewHandleSysProcPtr gMacAudioNewHandleSysProc = nil;
  87. bool gMacAudioTriedToInitialize = false;
  89. void MacAudioInitInterfaceLibProcPtrs()
  90. {
  91. if (gMacAudioTriedToInitialize) return;
  92. gMacAudioTriedToInitialize = true;
  94. if (gAudioInterfaceLibConnID == kInvalidID)
  95. {
  96. GetSharedLibrary("pInterfaceLib", kCompiledCFragArch, kReferenceCFrag,
  97. &gAudioInterfaceLibConnID, nil, nil);
  98. }
  100. if (gAudioInterfaceLibConnID != kInvalidID)
  101. {
  102. OSErr err = noErr;
  104. err = FindSymbol(gAudioInterfaceLibConnID, "pNewHandleSys", (Ptr*)&gMacAudioNewHandleSysProc, nil);
  105. }
  106. }
  108. #endif
  110. /*--------------------------------------------------------------------------
  111. | CMacWaveFormat
  112. |
  113. | Default ctor.
  114. --------------------------------------------------------------------------*/
  115. CMacWaveFormat::CMacWaveFormat (void)
  117. { /* begin CMacWaveFormat */
  119. SetFormatDflt ();
  121. } /* end CMacWaveFormat */
  123. /*--------------------------------------------------------------------------
  124. | ~CMacWaveFormat
  125. |
  126. | dtor.
  127. --------------------------------------------------------------------------*/
  128. CMacWaveFormat::~CMacWaveFormat (void)
  130. { /* begin ~CMacWaveFormat */
  132. } /* end ~CMacWaveFormat */
  134. /*--------------------------------------------------------------------------
  135. | SetUpSound
  136. |
  137. | Formats a sound handle.
  138. --------------------------------------------------------------------------*/
  139. OSErr CMacWaveFormat::SetUpSound (
  141. SndListHandle sndHandle,
  142. long numBytes,
  143. short *headerLen,
  144. long *headerOffset)
  146. { /* begin SetUpSound */
  148. OSErr e = noErr;
  149. long response;
  151. if (sampleSize > 8) {
  152. if (USound::CheckSMVersion () < 3) {
  153.     if ((::Gestalt(gestaltSoundAttr, &response) == noErr)
  154.      && ((response & (1L << gestalt16BitSoundIO)) == 0))
  155. return (noHardwareErr);
  156. } /* if */
  158. else {
  159.     if ((::Gestalt(gestaltSoundAttr, &response) == noErr)
  160.      && ((response & (1L << gestalt16BitAudioSupport)) == 0))
  161. return (noHardwareErr);
  162. } /* else */
  163. } /* if */
  165. if (noErr != (e = ::SetupSndHeader (sndHandle,
  166.    numChannels,
  167.    sampleRate,
  168.    sampleSize,
  169.    compressionType,
  170.    baseFrequency,
  171.    numBytes,
  172.    headerLen)))
  173. goto CleanUp;
  174.    
  175. if (noErr != (e = USound::GetSoundHeaderOffset (sndHandle, headerOffset)))
  176. goto CleanUp;
  178. CleanUp:
  180. return (e);
  182. } /* end SetUpSound */
  184. /*--------------------------------------------------------------------------
  185. | SetHeaderLength [static]
  186. |
  187. | Formats a sound header for a given byte count.
  188. --------------------------------------------------------------------------*/
  190. OSErr CMacWaveFormat::SetHeaderLength (
  192. SoundHeaderPtr pSoundHeader,
  193. long numBytes)
  195. { /* begin SetHeaderLength */
  197. switch (pSoundHeader->encode) {
  198. case stdSH:  /*standard sound header*/
  199. pSoundHeader->length = numBytes;
  200. break;
  202. case extSH:  /*extended sound header*/
  203. {
  204.                                 ExtSoundHeaderPtr eh = (ExtSoundHeaderPtr) pSoundHeader;
  205. eh->numFrames = numBytes / (eh->numChannels * (eh->sampleSize / 8));
  206.                                 }
  207. break;
  209. case cmpSH: /*compressed sound header*/
  210. {
  211.                                 CmpSoundHeaderPtr ch = (CmpSoundHeaderPtr) pSoundHeader;
  212. ch->numFrames = numBytes / (ch->numChannels * (ch->sampleSize / 8));
  213.                                 }
  214. break;
  216. default:
  217. return badFormat;
  218. } /* switch */
  220. return noErr;
  222. } /* SetHeaderLength */
  224. /*--------------------------------------------------------------------------
  225. | SetFormatDflt
  226. |
  227. | Sets up the default Sound header information.
  228. --------------------------------------------------------------------------*/
  229. void CMacWaveFormat::SetFormatDflt (void)
  231. { /* begin SetFormatDflt */
  233. //mwf.wf.nAvgBytesPerSec = 22050;
  234. //mwf.wf.nBlockAlign = 2;
  236. numChannels = 1; //mwf.wf.nChannels = 1;
  237. sampleRate = Long2Fix (8000); //mwf.wf.nSamplesPerSec = 8000;
  238. //sampleRate = rate11025hz; //mwf.wf.nSamplesPerSec = 11025;
  239. sampleSize = 16; //mwf.wBitsPerSample = 16;
  240. compressionType = NoneType; //mwf.wf.wFormatTag = WAVE_FORMAT_PCM;
  241. baseFrequency = kMiddleC;
  243. } /* end SetFormatDflt */
  245. /*--------------------------------------------------------------------------
  246. | SetFormatDflt
  247. |
  248. | Sets up the default Sound header information.
  249. --------------------------------------------------------------------------*/
  250. void CMacWaveFormat::SetFormat (
  252. ULONG32 inSampleRate,
  253. UINT16  channels,
  254. UINT16  bitsPerSample)
  256. { 
  258. numChannels = channels;
  259. sampleRate = inSampleRate << 16L;
  260. sampleSize = bitsPerSample;
  261. compressionType = NoneType;
  262. baseFrequency = kMiddleC;
  264. }
  266. /*--------------------------------------------------------------------------
  267. | CWaveHeader
  268. --------------------------------------------------------------------------*/
  270. CWaveHeader::CWaveHeader (void)
  272. : soundA5 (0)
  273. , state (kFreeState)
  274. , waveOut (NULL)
  275. , mMaxPlay (0)
  276. , sndHandle (nil)
  277. , mHeaderLen (0)
  278. , mSoundHeader (nil)
  280. { /* begin CWaveHeader */
  282. soundA5 = SetCurrentA5 ();
  284. } /* end CWaveHeader */
  286. /*--------------------------------------------------------------------------
  287. | ~CWaveHeader
  288. --------------------------------------------------------------------------*/
  289. CWaveHeader::~CWaveHeader (void)
  291. { /* begin ~CWaveHeader */
  293. if (sndHandle) ::DisposeHandle ((Handle) sndHandle);
  294. sndHandle = nil;
  296. } /* end ~CWaveHeader */
  298. /*--------------------------------------------------------------------------
  299. | CWaveHeader
  300. --------------------------------------------------------------------------*/
  301. const Size CWaveHeader::kSndHeaderSize = 512;
  302. UINT16 CWaveHeader::WAVE_BLOCKSIZE = 4096;
  304. OSErr CWaveHeader::Allocate (
  306. UINT16 inMaxPlay,
  307. float   sampleRate,
  308. UINT16  channels,
  309. UINT16  bitsPerSample)
  311. { /* begin Allocate */
  313. OSErr e = badFormat;
  315. long offset;
  317. if (!waveOut)
  318. goto CleanUp;
  320. OSErr theError;
  321. sndHandle = (SndListHandle) ::TempNewHandle (kSndHeaderSize + inMaxPlay, &theError);
  322. if (!sndHandle)
  323. goto CleanUp;
  325.         check_noerr (theError);
  326. waveOut->wf.SetFormat ((long)sampleRate,channels,bitsPerSample);
  328. if (noErr != (e = waveOut->wf.SetUpSound (sndHandle, inMaxPlay, &mHeaderLen, &offset)))
  329. goto CleanUp;
  331. ::SetHandleSize ((Handle) sndHandle, mHeaderLen + inMaxPlay);
  332. if (noErr != (e = MemError ()))
  333. goto CleanUp;
  335. mMaxPlay = inMaxPlay;
  337. ::MoveHHi ((Handle) sndHandle);
  338. ::HLock ((Handle) sndHandle);
  339. mSoundHeader = (SoundHeaderPtr) ((*(Handle) sndHandle) + offset);
  341. CleanUp:
  343. return (e);
  345. } /* end Allocate */
  347. /*--------------------------------------------------------------------------
  348. | Release
  349. --------------------------------------------------------------------------*/
  351. void CWaveHeader::Release (short releaseCode, BOOL bSendTimeSync /*= TRUE*/)
  353. { /* begin Release */
  355.     if (kFreeState != state) 
  356.     {
  357. state = kFreeState;
  358. if ((CWaveHeader::kResetRelease != releaseCode) &&
  359. (CWaveHeader::kAbortRelease != releaseCode)) //cz 5/7/96
  360. if (waveOut) waveOut->DonePlaying (cbPlaying, timeEnd,releaseCode == kCallBackRelease, bSendTimeSync);
  361.     } /* if */
  365.     if (kAbortRelease == releaseCode) 
  366.     {
  367.         
  368. if (sndHandle) 
  369. {
  370.     ::DisposeHandle ((Handle) sndHandle);
  371.     sndHandle=NULL;
  372. }
  374. sndHandle = nil;
  375. mMaxPlay = 0;
  376. mSoundHeader = nil;
  377.     } /* if */
  379. } /* end Release */
  383. /*--------------------------------------------------------------------------
  384. | PlayBuffer
  385. --------------------------------------------------------------------------*/
  387. OSErr CWaveHeader::PlayBuffer (
  389. char *pData,
  390. UINT16 cbPlayingArg,
  391. ULONG32 timeEndArg)
  393. { /* begin PlayBuffer */
  395. OSErr e = noErr;
  397. SndCommand cmd;
  400. if (!waveOut)
  401. return (badFormat);
  403. if (kFreeState != state)
  404. return (badFormat);
  406. if (!sndHandle) 
  407. return (nilHandleErr);
  409. if (cbPlayingArg > mMaxPlay)
  410. return (memFullErr);
  412. if (noErr != (e = waveOut->wf.SetHeaderLength (mSoundHeader, cbPlayingArg)))
  413. goto CleanUp;
  415. if(pData != NULL)
  416. ::BlockMove (pData, (*(Handle) sndHandle) + mHeaderLen, cbPlayingArg);
  418. cmd.cmd = bufferCmd;
  419. cmd.param1 = 0;
  420. cmd.param2 = (long) mSoundHeader;
  421. if (noErr != (e = ::SndDoCommand (waveOut->chan, &cmd, TRUE))) goto CleanUp;
  423. state = kQueuedState;
  424. cbPlaying = cbPlayingArg;
  425. timeEnd = timeEndArg;
  427. waveOut->StartedPlaying (cbPlaying);
  429. cmd.cmd = callBackCmd;
  430. cmd.param1 = kCallBackRelease;
  431. cmd.param2 = (long) this;
  432. if (noErr != (e = ::SndDoCommand (waveOut->chan, &cmd, TRUE))) goto CleanUp;
  434. waveOut->m_bAudioCallbacksAreAlive = TRUE;
  436. CleanUp:
  438. return (e);
  440. } /* end PlayBuffer */
  442. /*--------------------------------------------------------------------------
  443. | NewChannel
  444. --------------------------------------------------------------------------*/
  445. SndChannelPtr CWaveHeader::NewChannel (void)
  447. { /* begin NewChannel */
  449. SndChannelPtr chan = nil;
  450. #if defined( _CARBON ) || defined( _MAC_UNIX )
  451. SndCallBackUPP userProc = NewSndCallBackUPP (Callback);
  452. #else
  453. SndCallBackUPP userProc = NewSndCallBackProc (Callback);
  454. #endif
  456. // if (noErr != ::SndNewChannel (&chan, sampledSynth, initStereo + initNoDrop + initNoInterp, userProc))
  457. if (noErr != ::SndNewChannel (&chan, sampledSynth, initStereo, userProc))
  458. chan = nil;
  460. return chan;
  462. } /* end NewChannel */
  464. /*--------------------------------------------------------------------------
  465. | DisposeChannel
  466. --------------------------------------------------------------------------*/
  467. OSErr CWaveHeader::DisposeChannel (
  469. SndChannelPtr chan)
  471. { /* begin DisposeChannel */
  472. OSErr e;
  474. if(chan)
  475. {
  476. SndCallBackUPP userProc = chan->callBack;
  477. #if defined( _CARBON ) || defined( _MAC_UNIX )
  478. if (userProc) DisposeSndCallBackUPP (userProc);
  479. #else
  480. if (userProc) DisposeRoutineDescriptor (userProc);
  481. #endif
  483. e = ::SndDisposeChannel (chan, TRUE);
  485. }
  486. return e;
  488. } /* end DisposeChannel */
  490. /*--------------------------------------------------------------------------
  491. | Callback
  492. --------------------------------------------------------------------------*/
  494. pascal void CWaveHeader::Callback (
  496. SndChannelPtr chan,
  497. SndCommand *cmd)
  499. { /* begin Callback */
  501. #ifndef _MAC_UNIX
  502. HXMM_INTERRUPTON();
  503. #endif
  505. //    if (HXMM_RAHUL_CHECK())
  506. //    {
  507. //        DebugStr("pCWaveHeader Deferred Task ENTER;g");
  508. //    }
  509.     
  510. DeferredTask* dtrec = NULL;
  511. CWaveHeader*    wh    = NULL;
  512.                 SndCommand*   newCommand;
  513.                 
  514. if (cmd)
  515. {
  516. wh = (CWaveHeader *) cmd->param2;
  518. if ( wh )
  519. {
  520.     CAudioOutMac* theWaveOut = wh->waveOut;
  521.     
  522.     if ( theWaveOut )
  523.     {
  524. CMacWaveFormat wf = theWaveOut->wf;
  526. UINT32 ulBytesPerSecond = 
  527. wf.numChannels *
  528. ( (ULONG32)wf.sampleRate >> 16 ) *
  529. ( wf.sampleSize / 8 );
  531. theWaveOut->m_millisecondsIntoClip +=
  532. (double)wh->cbPlaying * 1000.0 / (double)ulBytesPerSecond;
  533.     }
  534. }
  536. dtrec=wh->waveOut->mDeferredTaskRec;
  537. }
  539. if (!dtrec)
  540. {
  541. goto CleanUp;
  542. }
  544. newCommand=new SndCommand;
  545. HX_ASSERT(newCommand);
  547. if (!newCommand)
  548. {
  549. delete dtrec;
  550. goto CleanUp;
  551. }
  553. if (cmd)
  554. {
  555. *newCommand=*cmd;
  556. }
  557. else
  558. {
  559. delete newCommand;
  560. delete dtrec;
  561. goto CleanUp;
  562. }
  564. wh->waveOut->AddToThePendingList(newCommand);
  566. if (!wh->waveOut->m_bDeferredTaskPending)
  567. {
  568.     wh->waveOut->m_bDeferredTaskPending = TRUE;
  569.     
  570.     short err = 0;
  571.     
  572.     if ( wh->waveOut->m_bIsQuitting )
  573.     {
  574. err = -1; // just so it's nonzero
  575.     }
  576.     else
  577.     {
  578. err = DTInstall(dtrec);
  579.     }
  580.     if ( err != noErr )
  581.     {
  582. wh->waveOut->m_bDeferredTaskPending = FALSE;
  583. wh->waveOut->m_bAudioCallbacksAreAlive = FALSE;
  584. delete dtrec;
  585. delete newCommand;
  586. goto CleanUp;
  587.     }
  588. }
  590. /*
  591. if (wh) {
  592. long saveA5 = SetA5 (wh->soundA5);
  593. wh->Release (cmd->param1);
  594. SetA5 (saveA5);
  595. } 
  596. */
  599. CleanUp:
  601. #ifndef _MAC_UNIX
  602. HXMM_INTERRUPTOFF();
  603. #endif
  605. //    if (HXMM_RAHUL_CHECK())
  606. //    {
  607. //        DebugStr("pCWaveHeader Deferred Task LEAVE;g");
  608. //    }
  609. return;
  611. } /* end Callback */
  614. pascal void CAudioOutMac::DeferredTaskCallback(long param)
  615. {
  616.     if (!param)
  617.     {
  618.         return;
  619.     }
  620.     
  621. #ifndef _MAC_UNIX
  622. HXMM_INTERRUPTON();
  623. #endif
  625. CAudioOutMac* pAudioOut = (CAudioOutMac*) param;
  627. pAudioOut->m_bAudioCallbacksAreAlive = FALSE;
  629. #ifdef THREADS_SUPPORTED
  630. if (zm_pMutex)
  631. {
  632.     zm_pMutex->Lock();
  633. }
  634. #endif
  636. #if defined(_DEBUG) && defined(LOG_MULTIPLE_DEFERRED_TASKS)
  637.     if ( !pAudioOut->m_bAudioCallbacksAreAlive )
  638.     {
  639. DebugStr( "pDeferredTaskCallback -- m_bAudioCallbacksAreAlive not true!;g" );
  640.     }
  642. #endif
  643. while (gActiveAudioDevice &&
  644.        pAudioOut->m_pPendingCallbackList && 
  645.       !pAudioOut->m_pPendingCallbackList->IsEmpty())
  646. {
  647. SndCommand* cmd = (SndCommand*) pAudioOut->m_pPendingCallbackList->RemoveHead();
  648. BOOL bIsEmpty = pAudioOut->m_pPendingCallbackList->IsEmpty();
  650. #ifdef THREADS_SUPPORTED
  651. // we used to deadlock here; we'd grab the audio mutex before the core mutex,
  652. // which is not how the rest of this class operates
  653. if (zm_pMutex)
  654. {
  655.     zm_pMutex->Unlock();
  656. }
  657. #endif
  658. /* Send time sync for ONLY the last pending audio callback */
  659. pAudioOut->ProcessCmd(cmd, bIsEmpty);
  661.       delete cmd;
  662. #ifdef THREADS_SUPPORTED
  663. if (zm_pMutex)
  664. {
  665.     zm_pMutex->Lock();
  666. }
  667. #endif
  668. }
  670. /* It is possible that on a timesync, a renderer may issue a hyper navigate request.
  671.  * This may result in leaving the currently active page (thereby unloading 
  672.  * the embedded player and the core. We would have destructed the CMacAudio class
  673.  * in this case.
  674.  */ 
  675. if (!gActiveAudioDevice)
  676. {
  677.     goto cleanup;
  678. }
  680. pAudioOut->m_bDeferredTaskPending = FALSE;
  682. cleanup:
  684. #ifdef THREADS_SUPPORTED
  685. if (zm_pMutex)
  686. {
  687.     zm_pMutex->Unlock();
  688. }
  689. #endif
  691. #ifndef _MAC_UNIX
  692. HXMM_INTERRUPTOFF();
  693. #endif
  694. }
  696. void
  697. CAudioOutMac::ProcessCmd(SndCommand* cmd, BOOL bSendTimeSync /*= TRUE*/)
  698. {
  699. CWaveHeader *wh = (CWaveHeader *) cmd->param2;
  700. if (wh)
  701. {
  702. wh->Release(cmd->param1, bSendTimeSync);
  703. }
  704. }
  707. /*--------------------------------------------------------------------------
  708. | CAudioOutMac
  709. --------------------------------------------------------------------------*/
  710. UINT16 CAudioOutMac::NUM_WAVEHDRS = 12; // was 30
  712. CAudioOutMac::CAudioOutMac ()
  713. : chan (nil)
  714. , mlpWaveHdrs (NULL)
  715. , mcbPlaying (0)
  716. , mPaused (TRUE)
  717. , m_uNumBlocksInDevice(0)
  718. , m_bFirstPacket(TRUE)
  719. , m_ulTimeOfFirstPacket(0L)
  720. , m_pPendingCallbackList(NULL)
  721. , m_bDeferredTaskPending(FALSE)
  722. , m_bAudioCallbacksAreAlive(FALSE)
  723. , m_bIsQuitting(FALSE)
  724. , m_millisecondsIntoClip(0.0)
  725. , m_pCallback(NULL)
  726. , m_pInterruptState(NULL)
  727. { /* begin CAudioOutMac */
  728. mDeferredTaskRec=(DeferredTask*)NewPtrClear(sizeof(DeferredTask));
  730. mDeferredTaskRec->qType=dtQType;
  731. mDeferredTaskRec->dtAddr=CAudioOutMac::gDeferredTask;
  732.     mDeferredTaskRec->dtParam= (long) this;
  733.     
  734. // Gestalt-based code that remembers potential deferred tasks for emergency removal
  736. #ifndef _MAC_UNIX
  737. Handle dtGestaltHandle = nil;
  738. OSErr err = Gestalt( kLetInterruptsFinishBeforeQuittingGestalt, (long*)&dtGestaltHandle );
  739. if ( err != noErr )
  740. {
  741. #if defined( _CARBON )
  742.     MacAudioInitInterfaceLibProcPtrs();
  743.     if (gMacAudioNewHandleSysProc)
  744.     {
  745. dtGestaltHandle = (*gMacAudioNewHandleSysProc)( 0 );
  746.     }
  747.     if (!dtGestaltHandle)
  748.     {
  749. dtGestaltHandle = NewHandle( 0 );
  750.     }
  751. #else
  752.     dtGestaltHandle = NewHandleSys( 0 );
  753. #endif
  754.     if ( dtGestaltHandle )
  755.     {
  756. NewGestaltValue( kLetInterruptsFinishBeforeQuittingGestalt, (long)dtGestaltHandle );
  757.     }
  758. }
  760. if ( dtGestaltHandle )
  761. {
  762.     GestaltDeferredStruct gds;
  763.     gds.quitting = &m_bIsQuitting;
  764.     gds.pending = &m_bAudioCallbacksAreAlive;
  765.     GetCurrentProcess(&(gds.psn));
  766.     PtrAndHand( &gds, dtGestaltHandle, sizeof(gds) );
  767. }
  768. #endif
  771. #ifdef THREADS_SUPPORTED
  772. if (!zm_pMutex)
  773. {
  774.     HXMutex::MakeMutex(zm_pMutex);
  775. }
  776. #endif
  777.     gActiveAudioDevice = this;
  778. } /* end CAudioOutMac */
  781. /*--------------------------------------------------------------------------
  782. | ~CAudioOutMac
  783. --------------------------------------------------------------------------*/
  784. CAudioOutMac::~CAudioOutMac ()
  786. { /* begin ~CAudioOutMac */ 
  788. Abort ();
  790. #if defined(_DEBUG) && defined(LOG_MULTIPLE_DEFERRED_TASKS)
  791. BOOL bWaitedForPending = FALSE;
  792. if ( m_bAudioCallbacksAreAlive )
  793. {
  794.     DebugStr( "pCAudioOutMac dtor -- m_bAudioCallbacksAreAlive still true!;g" );
  795.     bWaitedForPending = TRUE;
  796. }
  797. #endif
  798.     
  799.     m_bIsQuitting = TRUE;
  800.     // sit-n-spin awaiting interrupts to finish.
  801.     for ( int i = 0; i < 10; i++ )
  802.     {
  803. unsigned long dummyTix;
  804. Delay( 6, &dummyTix );
  805. if ( !m_bAudioCallbacksAreAlive )
  806. {
  807.     i = 10;
  808. }
  809.     }
  810.     
  811. #if defined(_DEBUG) && defined(LOG_MULTIPLE_DEFERRED_TASKS)
  812. if ( bWaitedForPending )
  813. {
  814.     if ( m_bAudioCallbacksAreAlive )
  815.     {
  816. DebugStr( "ptasks STILL pending! This is gonna hurt...;g" );
  817.     }
  818.     else
  819.     {
  820. DebugStr( "pSuccessfully purged pending callbacks;g" );
  821.     }
  822. }
  823. #endif
  825. if (mDeferredTaskRec)
  826. {
  829. // first ensure that the Gestalt handle doesn't think it's
  830. // here any more.
  832. #ifndef _MAC_UNIX
  833. Handle dtGestaltHandle = nil;
  834. Gestalt( kLetInterruptsFinishBeforeQuittingGestalt, (long*)&dtGestaltHandle );
  835. if ( dtGestaltHandle )
  836. {
  837.     // XXXNH: only look at tasks for this process
  838.     ProcessSerialNumber psn;
  839.     GetCurrentProcess(&psn);
  841.     // zip through and if an entry equals this deferred task,
  842.     // simply zero it out. We won't worry about shuffling
  843.     // the handle size at this juncture.
  844.     long hSize = GetHandleSize( dtGestaltHandle );
  845.     GestaltDeferredStruct* currentPtr = (GestaltDeferredStruct*)*dtGestaltHandle;
  846.     for ( int i = 0; i < hSize / sizeof(GestaltDeferredStruct); i++ )
  847.     {
  848.         unsigned char bSameProcess = FALSE;
  849.         SameProcess(&(currentPtr[i].psn), &psn, &bSameProcess);
  850.         
  851. if (bSameProcess && 
  852.     currentPtr[i].quitting == &m_bIsQuitting && 
  853.     currentPtr[i].pending == &m_bAudioCallbacksAreAlive )
  854. {
  855.     currentPtr[i].quitting = NULL;
  856.     currentPtr[i].pending = NULL;
  857. }
  858.     }    
  859. }
  860. #endif
  864. ::DisposePtr ((Ptr)mDeferredTaskRec);
  865. }    
  867. CleanupPendingLists();
  869. HX_DELETE(m_pPendingCallbackList);
  871. gActiveAudioDevice = NULL;
  873. HX_RELEASE(m_pScheduler);
  874. HX_RELEASE(m_pInterruptState);
  875. } /* end ~CAudioOutMac */
  877. UINT16 CAudioOutMac::m_uzVolume = 50;
  879. HX_RESULT   
  880. CAudioOutMac::_Imp_Open( const HXAudioFormat* pFormat )
  881. {
  883.     /*
  884.     ** Open the sound channel.
  885.     */
  887.     NUM_WAVEHDRS = 45; //params->numBufs;
  889.     CWaveHeader::WAVE_BLOCKSIZE = pFormat->uMaxBlockSize;
  891.     if (chan) CWaveHeader::DisposeChannel (chan);
  892.     m_bAudioCallbacksAreAlive = FALSE;
  895.     chan = CWaveHeader::NewChannel ();
  896.     if (!chan) 
  897. return (HX_AUDIO_DRIVER_ERROR);
  899. if (!m_pPendingCallbackList)
  900. {
  901.     m_pPendingCallbackList = new CHXSimpleList;
  902. }
  904.     ULONG32 nSampleRate = pFormat->ulSamplesPerSec;
  905.     ULONG32 nBlockSize = pFormat->uMaxBlockSize;
  907. #if powerc && FORCE_RATE_CONVERSION
  908. // if we are on a PowerPC we will do our own sample rate conversion
  909. // since the Apple version gives us a lot of pops and aliasing
  910.     ULONG32 sysSampleRate = ::USound::GetSystemSampleRate(chan);
  912. // Note: we currently have to HACK 11227 and 22254 sample rates on
  913. // old macs to 11025 and 22050
  915.     switch(sysSampleRate)
  916.     {
  917. case 11227:
  918.     sysSampleRate = 11025;
  919.     break;
  921. case 22254:
  922.     sysSampleRate = 22050;
  923.     break;
  924.     }
  926. // we only have a problem if the sample rate is <= 32000 Hz. (sigh!)
  927.     if(nSampleRate <= 32000)
  928.     {
  929. if(sysSampleRate > 0 && nSampleRate != sysSampleRate)
  930. {
  931.     UINT16 bytesPerSample = pFormat->wBitsPerSample > 8 ? 2 : 1;
  932.     UINT16 frameSize = bytesPerSample * pFormat->wChannels;
  933.     ULONG32 bytesPerSecond = (ULONG32) (nSampleRate * frameSize);
  935.     float bufDuration = (float)pFormat->uMaxBlockSize/(float)bytesPerSecond;
  937.     // calculate the bytesPerSecond of the system sample rate
  939.     bytesPerSecond = (ULONG32) (sysSampleRate * frameSize);
  941.     // update the buffer size to handle the new sample rate
  942.     nBlockSize = bytesPerSecond * bufDuration;
  944.     // round the buffersize to a framesize
  945.     nBlockSize = ((nBlockSize/frameSize) * frameSize) + frameSize;
  946.     nSampleRate = sysSampleRate;
  947.     //pFormat->ulSamplesPerSec = sysSampleRate;
  948. }
  949.     }
  951. #ifndef MAC_RELEASE
  952. #if 0
  953. char s[256];
  954. ::sprintf(s,"sample rate %ld",sysSampleRate);
  955. ::c2pstr(s);
  956. DebugStr((UCHAR *)s);
  957. #endif
  958. #endif // MAC_RELEASE
  959. #endif // powerc && FORCE_RATE_CONVERSION
  962. //    SetVolume(pFormat->volume);
  963.     _Imp_SetVolume(m_uzVolume);
  964.     
  965. /*
  966. ** Allocate memory for wave block headers and for wave data.
  967. */
  969.     if (NULL == mlpWaveHdrs) 
  970.     {
  971. if (NULL == (mlpWaveHdrs = new CWaveHeader [NUM_WAVEHDRS])) 
  972.     return (HX_MEMORY_ERROR);
  974. for (short iwh = 0; iwh < NUM_WAVEHDRS; iwh++) 
  975. {
  976.     CWaveHeader *pwh = GetWaveHeader (iwh);
  977.     if (pwh) 
  978.     {
  979. pwh->SetOutput (this);
  980. switch (pwh->Allocate (nBlockSize, nSampleRate,
  981. pFormat->uChannels,pFormat->uBitsPerSample)) 
  982. {
  983.     case noErr:
  984. break;
  986.     case memFullErr:
  987. return (HX_MEMORY_ERROR);
  989.     default:
  990. return (HX_AUDIO_DRIVER_ERROR);
  991. } 
  992.     } 
  993. } 
  994.     } 
  996. /*
  997. ** Indicate that no audio blocks are currently playing.
  998. */
  999.     mcbPlaying = 0;
  1000.     mPaused = FALSE;
  1001.     
  1002.     if (!m_pScheduler && m_pContext)
  1003.     {
  1004. m_pContext->QueryInterface(IID_IHXScheduler, (void**) &m_pScheduler);
  1005. m_pContext->QueryInterface(IID_IHXInterruptState, (void**) &m_pInterruptState);
  1006.     }
  1007.     
  1008.     return (HX_NO_ERROR);
  1009. }
  1011. HX_RESULT   
  1012. CAudioOutMac::_Imp_Close( void )
  1013. {
  1014.     Abort();
  1015.     return HXR_OK;
  1016. }
  1018. HX_RESULT   
  1019. CAudioOutMac::_Imp_Pause( void )
  1020. {
  1021.     mPaused = TRUE;
  1022.     
  1023.     if (OkToPauseResume(FALSE))
  1024.     {
  1025. // Stop playback
  1026. if (chan != NULL) 
  1027. DoImmediate (pauseCmd);
  1028.     }
  1029.     
  1030.     return HXR_OK;
  1031. }
  1033. HX_RESULT   
  1034. CAudioOutMac::_Imp_Resume( void )
  1035. {
  1036.     mPaused = FALSE;
  1038.     if (OkToPauseResume(TRUE))
  1039.     {
  1040. if (chan != NULL) 
  1041. {
  1042. DoImmediate (resumeCmd);
  1043. }
  1045. this->OnTimeSync();
  1046.     }
  1047.     
  1048.     return HXR_OK;    
  1049. }
  1051. HX_RESULT   
  1052. CAudioOutMac::_Imp_Write( const HXAudioData* pAudioOutHdr )
  1053. {
  1054.     HX_RESULT err = HX_NO_ERROR;
  1055.         
  1056. //    CWaveHeader *pwh = GetWaveHeader(0);;
  1057.     CWaveHeader *pwh=NULL;
  1059.     Boolean found = FALSE;
  1060.     void* pBuffer = NULL;
  1062.     for (short iwh = 0; iwh < NUM_WAVEHDRS && !found; iwh++) 
  1063.     {
  1064. pwh = GetWaveHeader(iwh);
  1065. found = pwh && pwh->Available ();
  1066.     }
  1068.     if (found)
  1069.     {
  1070. pBuffer = pwh->get_buffer();
  1071.     }
  1072.     else
  1073.     {
  1074. return playError;
  1075.     }
  1077.     if(pwh == 0)
  1078.     {
  1079. return (playError);
  1080.     }
  1082.     char* pData = 0;
  1083.     pData = (char*)pAudioOutHdr->pData->GetBuffer();
  1084.     ULONG32 nLen = pAudioOutHdr->pData->GetSize();
  1085.     if (pBuffer)
  1086.     {
  1087.      memcpy(pBuffer, pData, nLen);
  1088.     
  1089. if (noErr != pwh->PlayBuffer ((char*)pBuffer, nLen, pAudioOutHdr->ulAudioTime))
  1090.     err = (playError);
  1091.     }
  1093. if (!err)
  1094. {
  1095. m_uNumBlocksInDevice++;
  1096. if(m_bFirstPacket)
  1097. {
  1098. m_bFirstPacket = FALSE;
  1099. m_ulTimeOfFirstPacket = pAudioOutHdr->ulAudioTime;
  1100. }
  1101. }
  1103.     return err;
  1104. }
  1106. HX_RESULT   
  1107. CAudioOutMac::_Imp_Reset( void )
  1108. {
  1109.     // Stop playback
  1110.     if (chan != NULL) {
  1111. DoImmediate (pauseCmd);
  1112. DoImmediate (flushCmd);
  1113. DoImmediate (quietCmd);
  1114.     } /* if */
  1116.     m_ulCurrentTime = 0;
  1117.     m_bFirstPacket = TRUE;
  1118.     
  1119.     // Mark blocks as available.
  1120.     ReleaseBlocks (CWaveHeader::kResetRelease);
  1121.     m_uNumBlocksInDevice = 0;
  1122.     
  1123.     CleanupPendingLists();
  1125.     return HX_NO_ERROR;
  1126. }
  1127. HX_RESULT  
  1128. CAudioOutMac::_Imp_Drain( void )
  1129. {
  1130.     return HX_NO_ERROR;
  1131. }
  1133. BOOL 
  1134. CAudioOutMac::_Imp_SupportsVolume( void )
  1135. {
  1136.     return TRUE;
  1137. }
  1139. UINT16   
  1140. CAudioOutMac::_Imp_GetVolume()
  1141. {
  1142. #if 0
  1143.     unsigned long volume=0;
  1144.     SndCommand theCmd;
  1146.     theCmd.cmd = getVolumeCmd;
  1147.     theCmd.param1 = 0;
  1148.     theCmd.param2 = volume;
  1150. // queue volume command in channel
  1151.     ::SndDoImmediate(chan,&theCmd);
  1153.     return  (UINT16) volume;
  1155. #endif
  1156.     return m_uzVolume;
  1157. }
  1159. HX_RESULT   
  1160. CAudioOutMac::_Imp_SetVolume( const UINT16 uVolume )
  1161. {
  1162.     SndCommand theCmd;
  1163.     unsigned long volume;
  1164.     unsigned long leftVolume, rightVolume;
  1166. //    if(uVolume < 0) uVolume = 0;
  1167.     
  1168.     if(chan)
  1169.     {
  1170. #if defined( _CARBON ) || defined( _MAC_UNIX )
  1171. leftVolume = rightVolume = (long) uVolume * 5; //uVolume is between 0 and 100
  1172. volume = (rightVolume << 16) + leftVolume;
  1173. theCmd.cmd = volumeCmd;
  1174. theCmd.param1 = 0;
  1175. theCmd.param2 = volume;
  1177. // queue volume command in channel
  1178. ::SndDoImmediate(chan,&theCmd);
  1179. #else
  1180. #if OLDROUTINENAMES && !GENERATINGCFM
  1181. if (USound::CheckSMVersion () < 3)
  1182. ::SetSoundVol (uVolume);
  1183. #else
  1184. leftVolume = rightVolume = (long) uVolume * 5; //uVolume is between 0 and 100
  1185. volume = (rightVolume << 16) + leftVolume;
  1186. theCmd.cmd = volumeCmd;
  1187. theCmd.param1 = 0;
  1188. theCmd.param2 = volume;
  1190. // queue volume command in channel
  1191. ::SndDoImmediate(chan,&theCmd);
  1192. #endif
  1193. #endif
  1194.     }
  1195.     
  1196.     m_uzVolume = uVolume;
  1198.     return HXR_OK;
  1199. }
  1201. HX_RESULT   
  1202. CAudioOutMac::_Imp_CheckFormat( const HXAudioFormat* pFormat)
  1203. {
  1204.     return HX_NO_ERROR;
  1205. }
  1207. HX_RESULT 
  1208. CAudioOutMac::_Imp_Seek(ULONG32 ulSeekTime)
  1209. {
  1210.     m_ulCurrentTime = 0;
  1211.     return HX_NO_ERROR;
  1212. }
  1214. /*---------------------------------------------------------------------------
  1215. | ReleaseBlocks
  1216. |
  1217. | Frees the blocks manually
  1218. --------------------------------------------------------------------------*/
  1219. void CAudioOutMac::ReleaseBlocks (
  1221. short releaseCode)
  1223. { /* begin ReleaseBlocks */
  1225. // Mark blocks as available.
  1226. for (short iwh = 0; iwh < NUM_WAVEHDRS; iwh++) {
  1227. CWaveHeader *pwh = GetWaveHeader (iwh);
  1229. // if (pwh && !pwh->Available ())
  1230. if (pwh)
  1231. pwh->Release (releaseCode);
  1232. } /* for */
  1234. m_millisecondsIntoClip = 0.0;
  1235. } /* end ReleaseBlocks */
  1237. /*---------------------------------------------------------------------------
  1238. | DoImmediate
  1239. |
  1240. | Executes a sound command
  1241. --------------------------------------------------------------------------*/
  1242. OSErr CAudioOutMac::DoImmediate (
  1244. short cmd,
  1245. short param1/*= 0*/,
  1246. long param2/*= 0L*/)
  1248. { /* begin DoImmediate */
  1250. SndCommand sndCmd;
  1252. sndCmd.cmd = cmd;
  1253. sndCmd.param1 = param1;
  1254. sndCmd.param2 = param2;
  1256. return ::SndDoImmediate (chan, &sndCmd);
  1258. } /* end DoImmediate */
  1260. /*---------------------------------------------------------------------------
  1261. | Abort
  1262. |
  1263. | Halts playback and shuts down
  1264. --------------------------------------------------------------------------*/
  1265. void CAudioOutMac::Abort (void)
  1267. { /* begin Abort */
  1269. // Stop playback
  1270. if (chan != NULL) {
  1271. // Kludge around usual SM unreliability