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

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

Symbian

开发平台：

Visual C++

macaudio.cp：源码内容
  1. /* ***** BEGIN LICENSE BLOCK *****
  2.  * Source last modified: $Id: macaudio.cp,v 1.5.32.1 2004/07/09 02:01:22 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. //
  51. // macaudio.cp
  52. // 
  54. #include <stdio.h>
  55. #include "macaudio.h"
  56. #include "USound.h"
  57. #ifndef _MAC_MACHO
  58. #include <AIFF.h>
  59. #include <fixmath.h>
  60. #endif
  62. #include "hxtypes.h"
  63. #include "hxerrors.h"
  64. #include "hxcom.h"
  65. #include "hxausvc.h"
  66. #include "auderrs.h"
  68. #include "hxaudev.h"
  69. #include "hxslist.h"
  70. #include "hxtick.h"
  71. #include "chxpckts.h"
  73. #ifdef THREADS_SUPPORTED
  74. #include "hxthread.h"
  75. #endif
  77. #include "hxmm.h"
  79. //#define LOG_MULTIPLE_DEFERRED_TASKS 1
  81. BOOL  gSoundCallbackTime = FALSE;
  83. #if defined( _CARBON ) || defined( _MAC_UNIX )
  84. DeferredTaskUPP CAudioOutMac::gDeferredTask = NewDeferredTaskUPP(CAudioOutMac::DeferredTaskCallback);
  85. #else
  86. DeferredTaskUPP CAudioOutMac::gDeferredTask = NewDeferredTaskProc(CAudioOutMac::DeferredTaskCallback);
  87. #endif
  89. #ifdef THREADS_SUPPORTED
  90. HXMutex* CAudioOutMac::zm_pMutex = NULL;
  91. #endif
  93. CAudioOutMac*       gActiveAudioDevice = NULL;     
  96. #if defined( _CARBON ) || defined( _MAC_UNIX )
  98. typedef pascal Handle (*MacAudioNewHandleSysProcPtr)(Size);
  99. CFragConnectionID gAudioInterfaceLibConnID = kInvalidID;
  100. MacAudioNewHandleSysProcPtr gMacAudioNewHandleSysProc = nil;
  101. bool gMacAudioTriedToInitialize = false;
  103. void MacAudioInitInterfaceLibProcPtrs()
  104. {
  105. if (gMacAudioTriedToInitialize) return;
  106. gMacAudioTriedToInitialize = true;
  108. if (gAudioInterfaceLibConnID == kInvalidID)
  109. {
  110. GetSharedLibrary("pInterfaceLib", kCompiledCFragArch, kReferenceCFrag,
  111. &gAudioInterfaceLibConnID, nil, nil);
  112. }
  114. if (gAudioInterfaceLibConnID != kInvalidID)
  115. {
  116. OSErr err = noErr;
  118. err = FindSymbol(gAudioInterfaceLibConnID, "pNewHandleSys", (Ptr*)&gMacAudioNewHandleSysProc, nil);
  119. }
  120. }
  122. #endif
  124. /*--------------------------------------------------------------------------
  125. | CMacWaveFormat
  126. |
  127. | Default ctor.
  128. --------------------------------------------------------------------------*/
  129. CMacWaveFormat::CMacWaveFormat (void)
  131. { /* begin CMacWaveFormat */
  133. SetFormatDflt ();
  135. } /* end CMacWaveFormat */
  137. /*--------------------------------------------------------------------------
  138. | ~CMacWaveFormat
  139. |
  140. | dtor.
  141. --------------------------------------------------------------------------*/
  142. CMacWaveFormat::~CMacWaveFormat (void)
  144. { /* begin ~CMacWaveFormat */
  146. } /* end ~CMacWaveFormat */
  148. /*--------------------------------------------------------------------------
  149. | SetUpSound
  150. |
  151. | Formats a sound handle.
  152. --------------------------------------------------------------------------*/
  153. OSErr CMacWaveFormat::SetUpSound (
  155. SndListHandle sndHandle,
  156. long numBytes,
  157. short *headerLen,
  158. long *headerOffset)
  160. { /* begin SetUpSound */
  162. OSErr e = noErr;
  163. long response;
  165. if (sampleSize > 8) {
  166. if (USound::CheckSMVersion () < 3) {
  167.     if ((::Gestalt(gestaltSoundAttr, &response) == noErr)
  168.      && ((response & (1L << gestalt16BitSoundIO)) == 0))
  169. return (noHardwareErr);
  170. } /* if */
  172. else {
  173.     if ((::Gestalt(gestaltSoundAttr, &response) == noErr)
  174.      && ((response & (1L << gestalt16BitAudioSupport)) == 0))
  175. return (noHardwareErr);
  176. } /* else */
  177. } /* if */
  179. if (noErr != (e = ::SetupSndHeader (sndHandle,
  180.    numChannels,
  181.    sampleRate,
  182.    sampleSize,
  183.    compressionType,
  184.    baseFrequency,
  185.    numBytes,
  186.    headerLen)))
  187. goto CleanUp;
  188.    
  189. if (noErr != (e = USound::GetSoundHeaderOffset (sndHandle, headerOffset)))
  190. goto CleanUp;
  192. CleanUp:
  194. return (e);
  196. } /* end SetUpSound */
  198. /*--------------------------------------------------------------------------
  199. | SetHeaderLength [static]
  200. |
  201. | Formats a sound header for a given byte count.
  202. --------------------------------------------------------------------------*/
  204. OSErr CMacWaveFormat::SetHeaderLength (
  206. SoundHeaderPtr pSoundHeader,
  207. long numBytes)
  209. { /* begin SetHeaderLength */
  211. switch (pSoundHeader->encode) {
  212. case stdSH:  /*standard sound header*/
  213. pSoundHeader->length = numBytes;
  214. break;
  216. case extSH:  /*extended sound header*/
  217. {
  218.                                 ExtSoundHeaderPtr eh = (ExtSoundHeaderPtr) pSoundHeader;
  219. eh->numFrames = numBytes / (eh->numChannels * (eh->sampleSize / 8));
  220.                                 }
  221. break;
  223. case cmpSH: /*compressed sound header*/
  224. {
  225.                                 CmpSoundHeaderPtr ch = (CmpSoundHeaderPtr) pSoundHeader;
  226. ch->numFrames = numBytes / (ch->numChannels * (ch->sampleSize / 8));
  227.                                 }
  228. break;
  230. default:
  231. return badFormat;
  232. } /* switch */
  234. return noErr;
  236. } /* SetHeaderLength */
  238. /*--------------------------------------------------------------------------
  239. | SetFormatDflt
  240. |
  241. | Sets up the default Sound header information.
  242. --------------------------------------------------------------------------*/
  243. void CMacWaveFormat::SetFormatDflt (void)
  245. { /* begin SetFormatDflt */
  247. //mwf.wf.nAvgBytesPerSec = 22050;
  248. //mwf.wf.nBlockAlign = 2;
  250. numChannels = 1; //mwf.wf.nChannels = 1;
  251. sampleRate = Long2Fix (8000); //mwf.wf.nSamplesPerSec = 8000;
  252. //sampleRate = rate11025hz; //mwf.wf.nSamplesPerSec = 11025;
  253. sampleSize = 16; //mwf.wBitsPerSample = 16;
  254. compressionType = NoneType; //mwf.wf.wFormatTag = WAVE_FORMAT_PCM;
  255. baseFrequency = kMiddleC;
  257. } /* end SetFormatDflt */
  259. /*--------------------------------------------------------------------------
  260. | SetFormatDflt
  261. |
  262. | Sets up the default Sound header information.
  263. --------------------------------------------------------------------------*/
  264. void CMacWaveFormat::SetFormat (
  266. ULONG32 inSampleRate,
  267. UINT16  channels,
  268. UINT16  bitsPerSample)
  270. { 
  272. numChannels = channels;
  273. sampleRate = inSampleRate << 16L;
  274. sampleSize = bitsPerSample;
  275. compressionType = NoneType;
  276. baseFrequency = kMiddleC;
  278. }
  280. /*--------------------------------------------------------------------------
  281. | CWaveHeader
  282. --------------------------------------------------------------------------*/
  284. CWaveHeader::CWaveHeader (void)
  286. : soundA5 (0)
  287. , state (kFreeState)
  288. , waveOut (NULL)
  289. , mMaxPlay (0)
  290. , sndHandle (nil)
  291. , mHeaderLen (0)
  292. , mSoundHeader (nil)
  294. { /* begin CWaveHeader */
  296. soundA5 = SetCurrentA5 ();
  298. } /* end CWaveHeader */
  300. /*--------------------------------------------------------------------------
  301. | ~CWaveHeader
  302. --------------------------------------------------------------------------*/
  303. CWaveHeader::~CWaveHeader (void)
  305. { /* begin ~CWaveHeader */
  307. if (sndHandle) ::DisposeHandle ((Handle) sndHandle);
  308. sndHandle = nil;
  310. } /* end ~CWaveHeader */
  312. /*--------------------------------------------------------------------------
  313. | CWaveHeader
  314. --------------------------------------------------------------------------*/
  315. const Size CWaveHeader::kSndHeaderSize = 512;
  316. UINT16 CWaveHeader::WAVE_BLOCKSIZE = 4096;
  318. OSErr CWaveHeader::Allocate (
  320. UINT16 inMaxPlay,
  321. float   sampleRate,
  322. UINT16  channels,
  323. UINT16  bitsPerSample)
  325. { /* begin Allocate */
  327. OSErr e = badFormat;
  329. long offset;
  331. if (!waveOut)
  332. goto CleanUp;
  334. OSErr theError;
  335. sndHandle = (SndListHandle) ::TempNewHandle (kSndHeaderSize + inMaxPlay, &theError);
  336. if (!sndHandle)
  337. goto CleanUp;
  339.         check_noerr (theError);
  340. waveOut->wf.SetFormat ((long)sampleRate,channels,bitsPerSample);
  342. if (noErr != (e = waveOut->wf.SetUpSound (sndHandle, inMaxPlay, &mHeaderLen, &offset)))
  343. goto CleanUp;
  345. ::SetHandleSize ((Handle) sndHandle, mHeaderLen + inMaxPlay);
  346. if (noErr != (e = MemError ()))
  347. goto CleanUp;
  349. mMaxPlay = inMaxPlay;
  351. ::MoveHHi ((Handle) sndHandle);
  352. ::HLock ((Handle) sndHandle);
  353. mSoundHeader = (SoundHeaderPtr) ((*(Handle) sndHandle) + offset);
  355. CleanUp:
  357. return (e);
  359. } /* end Allocate */
  361. /*--------------------------------------------------------------------------
  362. | Release
  363. --------------------------------------------------------------------------*/
  365. void CWaveHeader::Release (short releaseCode, BOOL bSendTimeSync /*= TRUE*/)
  367. { /* begin Release */
  369.     if (kFreeState != state) 
  370.     {
  371. state = kFreeState;
  372. if ((CWaveHeader::kResetRelease != releaseCode) &&
  373. (CWaveHeader::kAbortRelease != releaseCode)) //cz 5/7/96
  374. if (waveOut) waveOut->DonePlaying (cbPlaying, timeEnd,releaseCode == kCallBackRelease, bSendTimeSync);
  375.     } /* if */
  379.     if (kAbortRelease == releaseCode) 
  380.     {
  381.         
  382. if (sndHandle) 
  383. {
  384.     ::DisposeHandle ((Handle) sndHandle);
  385.     sndHandle=NULL;
  386. }
  388. sndHandle = nil;
  389. mMaxPlay = 0;
  390. mSoundHeader = nil;
  391.     } /* if */
  393. } /* end Release */
  397. /*--------------------------------------------------------------------------
  398. | PlayBuffer
  399. --------------------------------------------------------------------------*/
  401. OSErr CWaveHeader::PlayBuffer (
  403. char *pData,
  404. UINT16 cbPlayingArg,
  405. ULONG32 timeEndArg)
  407. { /* begin PlayBuffer */
  409. OSErr e = noErr;
  411. SndCommand cmd;
  414. if (!waveOut)
  415. return (badFormat);
  417. if (kFreeState != state)
  418. return (badFormat);
  420. if (!sndHandle) 
  421. return (nilHandleErr);
  423. if (cbPlayingArg > mMaxPlay)
  424. return (memFullErr);
  426. if (noErr != (e = waveOut->wf.SetHeaderLength (mSoundHeader, cbPlayingArg)))
  427. goto CleanUp;
  429. if(pData != NULL)
  430. ::BlockMove (pData, (*(Handle) sndHandle) + mHeaderLen, cbPlayingArg);
  432. cmd.cmd = bufferCmd;
  433. cmd.param1 = 0;
  434. cmd.param2 = (long) mSoundHeader;
  435. if (noErr != (e = ::SndDoCommand (waveOut->chan, &cmd, TRUE))) goto CleanUp;
  437. state = kQueuedState;
  438. cbPlaying = cbPlayingArg;
  439. timeEnd = timeEndArg;
  441. waveOut->StartedPlaying (cbPlaying);
  443. cmd.cmd = callBackCmd;
  444. cmd.param1 = kCallBackRelease;
  445. cmd.param2 = (long) this;
  446. if (noErr != (e = ::SndDoCommand (waveOut->chan, &cmd, TRUE))) goto CleanUp;
  448. waveOut->m_bAudioCallbacksAreAlive = TRUE;
  450. CleanUp:
  452. return (e);
  454. } /* end PlayBuffer */
  456. /*--------------------------------------------------------------------------
  457. | NewChannel
  458. --------------------------------------------------------------------------*/
  459. SndChannelPtr CWaveHeader::NewChannel (void)
  461. { /* begin NewChannel */
  463. SndChannelPtr chan = nil;
  464. #if defined( _CARBON ) || defined( _MAC_UNIX )
  465. SndCallBackUPP userProc = NewSndCallBackUPP (Callback);
  466. #else
  467. SndCallBackUPP userProc = NewSndCallBackProc (Callback);
  468. #endif
  470. // if (noErr != ::SndNewChannel (&chan, sampledSynth, initStereo + initNoDrop + initNoInterp, userProc))
  471. if (noErr != ::SndNewChannel (&chan, sampledSynth, initStereo, userProc))
  472. chan = nil;
  474. return chan;
  476. } /* end NewChannel */
  478. /*--------------------------------------------------------------------------
  479. | DisposeChannel
  480. --------------------------------------------------------------------------*/
  481. OSErr CWaveHeader::DisposeChannel (
  483. SndChannelPtr chan)
  485. { /* begin DisposeChannel */
  486. OSErr e;
  488. if(chan)
  489. {
  490. SndCallBackUPP userProc = chan->callBack;
  491. #if defined( _CARBON ) || defined( _MAC_UNIX )
  492. if (userProc) DisposeSndCallBackUPP (userProc);
  493. #else
  494. if (userProc) DisposeRoutineDescriptor (userProc);
  495. #endif
  497. e = ::SndDisposeChannel (chan, TRUE);
  499. }
  500. return e;
  502. } /* end DisposeChannel */
  504. /*--------------------------------------------------------------------------
  505. | Callback
  506. --------------------------------------------------------------------------*/
  508. pascal void CWaveHeader::Callback (
  510. SndChannelPtr chan,
  511. SndCommand *cmd)
  513. { /* begin Callback */
  515. #ifndef _MAC_UNIX
  516. HXMM_INTERRUPTON();
  517. #endif
  519. //    if (HXMM_RAHUL_CHECK())
  520. //    {
  521. //        DebugStr("pCWaveHeader Deferred Task ENTER;g");
  522. //    }
  523.     
  524. DeferredTask* dtrec = NULL;
  525. CWaveHeader*    wh    = NULL;
  526.                 SndCommand*   newCommand;
  527.                 
  528. if (cmd)
  529. {
  530. wh = (CWaveHeader *) cmd->param2;
  532. if ( wh )
  533. {
  534.     CAudioOutMac* theWaveOut = wh->waveOut;
  535.     
  536.     if ( theWaveOut )
  537.     {
  538. CMacWaveFormat wf = theWaveOut->wf;
  540. UINT32 ulBytesPerSecond = 
  541. wf.numChannels *
  542. ( (ULONG32)wf.sampleRate >> 16 ) *
  543. ( wf.sampleSize / 8 );
  545. theWaveOut->m_millisecondsIntoClip +=
  546. (double)wh->cbPlaying * 1000.0 / (double)ulBytesPerSecond;
  547.     }
  548. }
  550. dtrec=wh->waveOut->mDeferredTaskRec;
  551. }
  553. if (!dtrec)
  554. {
  555. goto CleanUp;
  556. }
  558. newCommand=new SndCommand;
  559. HX_ASSERT(newCommand);
  561. if (!newCommand)
  562. {
  563. delete dtrec;
  564. goto CleanUp;
  565. }
  567. if (cmd)
  568. {
  569. *newCommand=*cmd;
  570. }
  571. else
  572. {
  573. delete newCommand;
  574. delete dtrec;
  575. goto CleanUp;
  576. }
  578. wh->waveOut->AddToThePendingList(newCommand);
  580. if (!wh->waveOut->m_bDeferredTaskPending)
  581. {
  582.     wh->waveOut->m_bDeferredTaskPending = TRUE;
  583.     
  584.     short err = 0;
  585.     
  586.     if ( wh->waveOut->m_bIsQuitting )
  587.     {
  588. err = -1; // just so it's nonzero
  589.     }
  590.     else
  591.     {
  592. err = DTInstall(dtrec);
  593.     }
  594.     if ( err != noErr )
  595.     {
  596. wh->waveOut->m_bDeferredTaskPending = FALSE;
  597. wh->waveOut->m_bAudioCallbacksAreAlive = FALSE;
  598. delete dtrec;
  599. delete newCommand;
  600. goto CleanUp;
  601.     }
  602. }
  604. /*
  605. if (wh) {
  606. long saveA5 = SetA5 (wh->soundA5);
  607. wh->Release (cmd->param1);
  608. SetA5 (saveA5);
  609. } 
  610. */
  613. CleanUp:
  615. #ifndef _MAC_UNIX
  616. HXMM_INTERRUPTOFF();
  617. #endif
  619. //    if (HXMM_RAHUL_CHECK())
  620. //    {
  621. //        DebugStr("pCWaveHeader Deferred Task LEAVE;g");
  622. //    }
  623. return;
  625. } /* end Callback */
  628. pascal void CAudioOutMac::DeferredTaskCallback(long param)
  629. {
  630.     if (!param)
  631.     {
  632.         return;
  633.     }
  634.     
  635. #ifndef _MAC_UNIX
  636. HXMM_INTERRUPTON();
  637. #endif
  639. CAudioOutMac* pAudioOut = (CAudioOutMac*) param;
  641. pAudioOut->m_bAudioCallbacksAreAlive = FALSE;
  643. #ifdef THREADS_SUPPORTED
  644. if (zm_pMutex)
  645. {
  646.     zm_pMutex->Lock();
  647. }
  648. #endif
  650. #if defined(_DEBUG) && defined(LOG_MULTIPLE_DEFERRED_TASKS)
  651.     if ( !pAudioOut->m_bAudioCallbacksAreAlive )
  652.     {
  653. DebugStr( "pDeferredTaskCallback -- m_bAudioCallbacksAreAlive not true!;g" );
  654.     }
  656. #endif
  657. while (gActiveAudioDevice &&
  658.        pAudioOut->m_pPendingCallbackList && 
  659.       !pAudioOut->m_pPendingCallbackList->IsEmpty())
  660. {
  661. SndCommand* cmd = (SndCommand*) pAudioOut->m_pPendingCallbackList->RemoveHead();
  662. BOOL bIsEmpty = pAudioOut->m_pPendingCallbackList->IsEmpty();
  664. #ifdef THREADS_SUPPORTED
  665. // we used to deadlock here; we'd grab the audio mutex before the core mutex,
  666. // which is not how the rest of this class operates
  667. if (zm_pMutex)
  668. {
  669.     zm_pMutex->Unlock();
  670. }
  671. #endif
  672. /* Send time sync for ONLY the last pending audio callback */
  673. pAudioOut->ProcessCmd(cmd, bIsEmpty);
  675.       delete cmd;
  676. #ifdef THREADS_SUPPORTED
  677. if (zm_pMutex)
  678. {
  679.     zm_pMutex->Lock();
  680. }
  681. #endif
  682. }
  684. /* It is possible that on a timesync, a renderer may issue a hyper navigate request.
  685.  * This may result in leaving the currently active page (thereby unloading 
  686.  * the embedded player and the core. We would have destructed the CMacAudio class
  687.  * in this case.
  688.  */ 
  689. if (!gActiveAudioDevice)
  690. {
  691.     goto cleanup;
  692. }
  694. pAudioOut->m_bDeferredTaskPending = FALSE;
  696. cleanup:
  698. #ifdef THREADS_SUPPORTED
  699. if (zm_pMutex)
  700. {
  701.     zm_pMutex->Unlock();
  702. }
  703. #endif
  705. #ifndef _MAC_UNIX
  706. HXMM_INTERRUPTOFF();
  707. #endif
  708. }
  710. void
  711. CAudioOutMac::ProcessCmd(SndCommand* cmd, BOOL bSendTimeSync /*= TRUE*/)
  712. {
  713. CWaveHeader *wh = (CWaveHeader *) cmd->param2;
  714. if (wh)
  715. {
  716. wh->Release(cmd->param1, bSendTimeSync);
  717. }
  718. }
  721. /*--------------------------------------------------------------------------
  722. | CAudioOutMac
  723. --------------------------------------------------------------------------*/
  724. UINT16 CAudioOutMac::NUM_WAVEHDRS = 12; // was 30
  726. CAudioOutMac::CAudioOutMac ()
  727. : chan (nil)
  728. , mlpWaveHdrs (NULL)
  729. , mcbPlaying (0)
  730. , mPaused (TRUE)
  731. , m_uNumBlocksInDevice(0)
  732. , m_bFirstPacket(TRUE)
  733. , m_ulTimeOfFirstPacket(0L)
  734. , m_pPendingCallbackList(NULL)
  735. , m_bDeferredTaskPending(FALSE)
  736. , m_bAudioCallbacksAreAlive(FALSE)
  737. , m_bIsQuitting(FALSE)
  738. , m_millisecondsIntoClip(0.0)
  739. , m_pCallback(NULL)
  740. , m_pInterruptState(NULL)
  741. { /* begin CAudioOutMac */
  742. mDeferredTaskRec=(DeferredTask*)NewPtrClear(sizeof(DeferredTask));
  744. mDeferredTaskRec->qType=dtQType;
  745. mDeferredTaskRec->dtAddr=CAudioOutMac::gDeferredTask;
  746.     mDeferredTaskRec->dtParam= (long) this;
  747.     
  748. // Gestalt-based code that remembers potential deferred tasks for emergency removal
  750. #ifndef _MAC_UNIX
  751. Handle dtGestaltHandle = nil;
  752. OSErr err = Gestalt( kLetInterruptsFinishBeforeQuittingGestalt, (long*)&dtGestaltHandle );
  753. if ( err != noErr )
  754. {
  755. #if defined( _CARBON )
  756.     MacAudioInitInterfaceLibProcPtrs();
  757.     if (gMacAudioNewHandleSysProc)
  758.     {
  759. dtGestaltHandle = (*gMacAudioNewHandleSysProc)( 0 );
  760.     }
  761.     if (!dtGestaltHandle)
  762.     {
  763. dtGestaltHandle = NewHandle( 0 );
  764.     }
  765. #else
  766.     dtGestaltHandle = NewHandleSys( 0 );
  767. #endif
  768.     if ( dtGestaltHandle )
  769.     {
  770. NewGestaltValue( kLetInterruptsFinishBeforeQuittingGestalt, (long)dtGestaltHandle );
  771.     }
  772. }
  774. if ( dtGestaltHandle )
  775. {
  776.     GestaltDeferredStruct gds;
  777.     gds.quitting = &m_bIsQuitting;
  778.     gds.pending = &m_bAudioCallbacksAreAlive;
  779.     GetCurrentProcess(&(gds.psn));
  780.     PtrAndHand( &gds, dtGestaltHandle, sizeof(gds) );
  781. }
  782. #endif
  785. #ifdef THREADS_SUPPORTED
  786. if (!zm_pMutex)
  787. {
  788.     HXMutex::MakeMutex(zm_pMutex);
  789. }
  790. #endif
  791.     gActiveAudioDevice = this;
  792. } /* end CAudioOutMac */
  795. /*--------------------------------------------------------------------------
  796. | ~CAudioOutMac
  797. --------------------------------------------------------------------------*/
  798. CAudioOutMac::~CAudioOutMac ()
  800. { /* begin ~CAudioOutMac */ 
  802. Abort ();
  804. #if defined(_DEBUG) && defined(LOG_MULTIPLE_DEFERRED_TASKS)
  805. BOOL bWaitedForPending = FALSE;
  806. if ( m_bAudioCallbacksAreAlive )
  807. {
  808.     DebugStr( "pCAudioOutMac dtor -- m_bAudioCallbacksAreAlive still true!;g" );
  809.     bWaitedForPending = TRUE;
  810. }
  811. #endif
  812.     
  813.     m_bIsQuitting = TRUE;
  814.     // sit-n-spin awaiting interrupts to finish.
  815.     for ( int i = 0; i < 10; i++ )
  816.     {
  817. unsigned long dummyTix;
  818. Delay( 6, &dummyTix );
  819. if ( !m_bAudioCallbacksAreAlive )
  820. {
  821.     i = 10;
  822. }
  823.     }
  824.     
  825. #if defined(_DEBUG) && defined(LOG_MULTIPLE_DEFERRED_TASKS)
  826. if ( bWaitedForPending )
  827. {
  828.     if ( m_bAudioCallbacksAreAlive )
  829.     {
  830. DebugStr( "ptasks STILL pending! This is gonna hurt...;g" );
  831.     }
  832.     else
  833.     {
  834. DebugStr( "pSuccessfully purged pending callbacks;g" );
  835.     }
  836. }
  837. #endif
  839. if (mDeferredTaskRec)
  840. {
  843. // first ensure that the Gestalt handle doesn't think it's
  844. // here any more.
  846. #ifndef _MAC_UNIX
  847. Handle dtGestaltHandle = nil;
  848. Gestalt( kLetInterruptsFinishBeforeQuittingGestalt, (long*)&dtGestaltHandle );
  849. if ( dtGestaltHandle )
  850. {
  851.     // XXXNH: only look at tasks for this process
  852.     ProcessSerialNumber psn;
  853.     GetCurrentProcess(&psn);
  855.     // zip through and if an entry equals this deferred task,
  856.     // simply zero it out. We won't worry about shuffling
  857.     // the handle size at this juncture.
  858.     long hSize = GetHandleSize( dtGestaltHandle );
  859.     GestaltDeferredStruct* currentPtr = (GestaltDeferredStruct*)*dtGestaltHandle;
  860.     for ( int i = 0; i < hSize / sizeof(GestaltDeferredStruct); i++ )
  861.     {
  862.         unsigned char bSameProcess = FALSE;
  863.         SameProcess(&(currentPtr[i].psn), &psn, &bSameProcess);
  864.         
  865. if (bSameProcess && 
  866.     currentPtr[i].quitting == &m_bIsQuitting && 
  867.     currentPtr[i].pending == &m_bAudioCallbacksAreAlive )
  868. {
  869.     currentPtr[i].quitting = NULL;
  870.     currentPtr[i].pending = NULL;
  871. }
  872.     }    
  873. }
  874. #endif
  878. ::DisposePtr ((Ptr)mDeferredTaskRec);
  879. }    
  881. CleanupPendingLists();
  883. HX_DELETE(m_pPendingCallbackList);
  885. gActiveAudioDevice = NULL;
  887. HX_RELEASE(m_pScheduler);
  888. HX_RELEASE(m_pInterruptState);
  889. } /* end ~CAudioOutMac */
  891. UINT16 CAudioOutMac::m_uzVolume = 50;
  893. HX_RESULT   
  894. CAudioOutMac::_Imp_Open( const HXAudioFormat* pFormat )
  895. {
  897.     /*
  898.     ** Open the sound channel.
  899.     */
  901.     NUM_WAVEHDRS = 45; //params->numBufs;
  903.     CWaveHeader::WAVE_BLOCKSIZE = pFormat->uMaxBlockSize;
  905.     if (chan) CWaveHeader::DisposeChannel (chan);
  906.     m_bAudioCallbacksAreAlive = FALSE;
  909.     chan = CWaveHeader::NewChannel ();
  910.     if (!chan) 
  911. return (HX_AUDIO_DRIVER_ERROR);
  913. if (!m_pPendingCallbackList)
  914. {
  915.     m_pPendingCallbackList = new CHXSimpleList;
  916. }
  918.     ULONG32 nSampleRate = pFormat->ulSamplesPerSec;
  919.     ULONG32 nBlockSize = pFormat->uMaxBlockSize;
  921. #if powerc && FORCE_RATE_CONVERSION
  922. // if we are on a PowerPC we will do our own sample rate conversion
  923. // since the Apple version gives us a lot of pops and aliasing
  924.     ULONG32 sysSampleRate = ::USound::GetSystemSampleRate(chan);
  926. // Note: we currently have to HACK 11227 and 22254 sample rates on
  927. // old macs to 11025 and 22050
  929.     switch(sysSampleRate)
  930.     {
  931. case 11227:
  932.     sysSampleRate = 11025;
  933.     break;
  935. case 22254:
  936.     sysSampleRate = 22050;
  937.     break;
  938.     }
  940. // we only have a problem if the sample rate is <= 32000 Hz. (sigh!)
  941.     if(nSampleRate <= 32000)
  942.     {
  943. if(sysSampleRate > 0 && nSampleRate != sysSampleRate)
  944. {
  945.     UINT16 bytesPerSample = pFormat->wBitsPerSample > 8 ? 2 : 1;
  946.     UINT16 frameSize = bytesPerSample * pFormat->wChannels;
  947.     ULONG32 bytesPerSecond = (ULONG32) (nSampleRate * frameSize);
  949.     float bufDuration = (float)pFormat->uMaxBlockSize/(float)bytesPerSecond;
  951.     // calculate the bytesPerSecond of the system sample rate
  953.     bytesPerSecond = (ULONG32) (sysSampleRate * frameSize);
  955.     // update the buffer size to handle the new sample rate
  956.     nBlockSize = bytesPerSecond * bufDuration;
  958.     // round the buffersize to a framesize
  959.     nBlockSize = ((nBlockSize/frameSize) * frameSize) + frameSize;
  960.     nSampleRate = sysSampleRate;
  961.     //pFormat->ulSamplesPerSec = sysSampleRate;
  962. }
  963.     }
  965. #ifndef MAC_RELEASE
  966. #if 0
  967. char s[256];
  968. ::sprintf(s,"sample rate %ld",sysSampleRate);
  969. ::c2pstr(s);
  970. DebugStr((UCHAR *)s);
  971. #endif
  972. #endif // MAC_RELEASE
  973. #endif // powerc && FORCE_RATE_CONVERSION
  976. //    SetVolume(pFormat->volume);
  977.     _Imp_SetVolume(m_uzVolume);
  978.     
  979. /*
  980. ** Allocate memory for wave block headers and for wave data.
  981. */
  983.     if (NULL == mlpWaveHdrs) 
  984.     {
  985. if (NULL == (mlpWaveHdrs = new CWaveHeader [NUM_WAVEHDRS])) 
  986.     return (HX_MEMORY_ERROR);
  988. for (short iwh = 0; iwh < NUM_WAVEHDRS; iwh++) 
  989. {
  990.     CWaveHeader *pwh = GetWaveHeader (iwh);
  991.     if (pwh) 
  992.     {
  993. pwh->SetOutput (this);
  994. switch (pwh->Allocate (nBlockSize, nSampleRate,
  995. pFormat->uChannels,pFormat->uBitsPerSample)) 
  996. {
  997.     case noErr:
  998. break;
  1000.     case memFullErr:
  1001. return (HX_MEMORY_ERROR);
  1003.     default:
  1004. return (HX_AUDIO_DRIVER_ERROR);
  1005. } 
  1006.     } 
  1007. } 
  1008.     } 
  1010. /*
  1011. ** Indicate that no audio blocks are currently playing.
  1012. */
  1013.     mcbPlaying = 0;
  1014.     mPaused = FALSE;
  1015.     
  1016.     if (!m_pScheduler && m_pContext)
  1017.     {
  1018. m_pContext->QueryInterface(IID_IHXScheduler, (void**) &m_pScheduler);
  1019. m_pContext->QueryInterface(IID_IHXInterruptState, (void**) &m_pInterruptState);
  1020.     }
  1021.     
  1022.     return (HX_NO_ERROR);
  1023. }
  1025. HX_RESULT   
  1026. CAudioOutMac::_Imp_Close( void )
  1027. {
  1028.     Abort();
  1029.     return HXR_OK;
  1030. }
  1032. HX_RESULT   
  1033. CAudioOutMac::_Imp_Pause( void )
  1034. {
  1035.     mPaused = TRUE;
  1036.     
  1037.     if (OkToPauseResume(FALSE))
  1038.     {
  1039. // Stop playback
  1040. if (chan != NULL) 
  1041. DoImmediate (pauseCmd);
  1042.     }
  1043.     
  1044.     return HXR_OK;
  1045. }
  1047. HX_RESULT   
  1048. CAudioOutMac::_Imp_Resume( void )
  1049. {
  1050.     mPaused = FALSE;
  1052.     if (OkToPauseResume(TRUE))
  1053.     {
  1054. if (chan != NULL) 
  1055. {
  1056. DoImmediate (resumeCmd);
  1057. }
  1059. this->OnTimeSync();
  1060.     }
  1061.     
  1062.     return HXR_OK;    
  1063. }
  1065. HX_RESULT   
  1066. CAudioOutMac::_Imp_Write( const HXAudioData* pAudioOutHdr )
  1067. {
  1068.     HX_RESULT err = HX_NO_ERROR;
  1069.         
  1070. //    CWaveHeader *pwh = GetWaveHeader(0);;
  1071.     CWaveHeader *pwh=NULL;
  1073.     Boolean found = FALSE;
  1074.     void* pBuffer = NULL;
  1076.     for (short iwh = 0; iwh < NUM_WAVEHDRS && !found; iwh++) 
  1077.     {
  1078. pwh = GetWaveHeader(iwh);
  1079. found = pwh && pwh->Available ();
  1080.     }
  1082.     if (found)
  1083.     {
  1084. pBuffer = pwh->get_buffer();
  1085.     }
  1086.     else
  1087.     {
  1088. return playError;
  1089.     }
  1091.     if(pwh == 0)
  1092.     {
  1093. return (playError);
  1094.     }
  1096.     char* pData = 0;
  1097.     pData = (char*)pAudioOutHdr->pData->GetBuffer();
  1098.     ULONG32 nLen = pAudioOutHdr->pData->GetSize();
  1099.     if (pBuffer)
  1100.     {
  1101.      memcpy(pBuffer, pData, nLen);
  1102.     
  1103. if (noErr != pwh->PlayBuffer ((char*)pBuffer, nLen, pAudioOutHdr->ulAudioTime))
  1104.     err = (playError);
  1105.     }
  1107. if (!err)
  1108. {
  1109. m_uNumBlocksInDevice++;
  1110. if(m_bFirstPacket)
  1111. {
  1112. m_bFirstPacket = FALSE;
  1113. m_ulTimeOfFirstPacket = pAudioOutHdr->ulAudioTime;
  1114. }
  1115. }
  1117.     return err;
  1118. }
  1120. HX_RESULT   
  1121. CAudioOutMac::_Imp_Reset( void )
  1122. {
  1123.     // Stop playback
  1124.     if (chan != NULL) {
  1125. DoImmediate (pauseCmd);
  1126. DoImmediate (flushCmd);
  1127. DoImmediate (quietCmd);
  1128.     } /* if */
  1130.     m_ulCurrentTime = 0;
  1131.     m_bFirstPacket = TRUE;
  1132.     
  1133.     // Mark blocks as available.
  1134.     ReleaseBlocks (CWaveHeader::kResetRelease);
  1135.     m_uNumBlocksInDevice = 0;
  1136.     
  1137.     CleanupPendingLists();
  1139.     return HX_NO_ERROR;
  1140. }
  1141. HX_RESULT  
  1142. CAudioOutMac::_Imp_Drain( void )
  1143. {
  1144.     return HX_NO_ERROR;
  1145. }
  1147. BOOL 
  1148. CAudioOutMac::_Imp_SupportsVolume( void )
  1149. {
  1150.     return TRUE;
  1151. }
  1153. UINT16   
  1154. CAudioOutMac::_Imp_GetVolume()
  1155. {
  1156. #if 0
  1157.     unsigned long volume=0;
  1158.     SndCommand theCmd;
  1160.     theCmd.cmd = getVolumeCmd;
  1161.     theCmd.param1 = 0;
  1162.     theCmd.param2 = volume;
  1164. // queue volume command in channel
  1165.     ::SndDoImmediate(chan,&theCmd);
  1167.     return  (UINT16) volume;
  1169. #endif
  1170.     return m_uzVolume;
  1171. }
  1173. HX_RESULT   
  1174. CAudioOutMac::_Imp_SetVolume( const UINT16 uVolume )
  1175. {
  1176.     SndCommand theCmd;
  1177.     unsigned long volume;
  1178.     unsigned long leftVolume, rightVolume;
  1180. //    if(uVolume < 0) uVolume = 0;
  1181.     
  1182.     if(chan)
  1183.     {
  1184. #if defined( _CARBON ) || defined( _MAC_UNIX )
  1185. leftVolume = rightVolume = (long) uVolume * 5; //uVolume is between 0 and 100
  1186. volume = (rightVolume << 16) + leftVolume;
  1187. theCmd.cmd = volumeCmd;
  1188. theCmd.param1 = 0;
  1189. theCmd.param2 = volume;
  1191. // queue volume command in channel
  1192. ::SndDoImmediate(chan,&theCmd);
  1193. #else
  1194. #if OLDROUTINENAMES && !GENERATINGCFM
  1195. if (USound::CheckSMVersion () < 3)
  1196. ::SetSoundVol (uVolume);
  1197. #else
  1198. leftVolume = rightVolume = (long) uVolume * 5; //uVolume is between 0 and 100
  1199. volume = (rightVolume << 16) + leftVolume;
  1200. theCmd.cmd = volumeCmd;
  1201. theCmd.param1 = 0;
  1202. theCmd.param2 = volume;
  1204. // queue volume command in channel
  1205. ::SndDoImmediate(chan,&theCmd);
  1206. #endif
  1207. #endif
  1208.     }
  1209.     
  1210.     m_uzVolume = uVolume;
  1212.     return HXR_OK;
  1213. }
  1215. HX_RESULT   
  1216. CAudioOutMac::_Imp_CheckFormat( const HXAudioFormat* pFormat)
  1217. {
  1218.     return HX_NO_ERROR;
  1219. }
  1221. HX_RESULT 
  1222. CAudioOutMac::_Imp_Seek(ULONG32 ulSeekTime)
  1223. {
  1224.     m_ulCurrentTime = 0;
  1225.     return HX_NO_ERROR;
  1226. }
  1228. /*---------------------------------------------------------------------------
  1229. | ReleaseBlocks
  1230. |
  1231. | Frees the blocks manually
  1232. --------------------------------------------------------------------------*/
  1233. void CAudioOutMac::ReleaseBlocks (
  1235. short releaseCode)
  1237. { /* begin ReleaseBlocks */
  1239. // Mark blocks as available.
  1240. for (short iwh = 0; iwh < NUM_WAVEHDRS; iwh++) {
  1241. CWaveHeader *pwh = GetWaveHeader (iwh);
  1243. // if (pwh && !pwh->Available ())
  1244. if (pwh)
  1245. pwh->Release (releaseCode);
  1246. } /* for */
  1248. m_millisecondsIntoClip = 0.0;
  1249. } /* end ReleaseBlocks */
  1251. /*---------------------------------------------------------------------------
  1252. | DoImmediate
  1253. |
  1254. | Executes a sound command
  1255. --------------------------------------------------------------------------*/
  1256. OSErr CAudioOutMac::DoImmediate (
  1258. short cmd,
  1259. short param1/*= 0*/,
  1260. long param2/*= 0L*/)
  1262. { /* begin DoImmediate */
  1264. SndCommand sndCmd;
  1266. sndCmd.cmd = cmd;
  1267. sndCmd.param1 = param1;
  1268. sndCmd.param2 = param2;
  1270. return ::SndDoImmediate (chan, &sndCmd);
  1272. } /* end DoImmediate */
  1274. /*---------------------------------------------------------------------------
  1275. | Abort
  1276. |
  1277. | Halts playback and shuts down
  1278. --------------------------------------------------------------------------*/
  1279. void CAudioOutMac::Abort (void)
  1281. { /* begin Abort */
  1283. // Stop playback
  1284. if (chan != NULL) {
  1285. // Kludge around usual SM unreliability