.h文件 #ifdef TARGET_OS_IPHONE #import 
     
       #else #import 
      
        #endif TARGET_OS_IPHONE #import 
       
         #import 
        
          #include 
         
           #include 
          
            #define NUM_QUEUE_BUFFERS 3 #define kNumAQBufs 6 // number of audio queue buffers we allocate #define kAQBufSize 32 * 1024 // number of bytes in each audio queue buffer #define kAQMaxPacketDescs 512 // number of packet descriptions in our array @interface xxxxx : NSObject { /*-----------------USED FOR HTTP STREAM------------------*/ NSURL *url; BOOL isPlaying; @public AudioFileStreamID audioFileStream; // the audio file stream parser AudioStreamPacketDescription packetDescsQueue[kAQMaxPacketDescs]; // packet descriptions for enqueuing audio CFReadStreamRef stream; unsigned int fillBufferIndex; // the index of the audioQueueBuffer that is being filled size_t bytesFilled; // how many bytes have been filled size_t packetsFilled; // how many packets have been filled bool inuse[kNumAQBufs]; // flags to indicate that a buffer is still in use bool started; // flag to indicate that the queue has been started bool failed; // flag to indicate an error occurred bool discontinuous; // flag to trigger bug-avoidance pthread_mutex_t mutex; // a mutex to protect the inuse flags pthread_cond_t cond; // a condition varable for handling the inuse flags pthread_mutex_t mutex2; // a mutex to protect the AudioQueue buffer /*-------------------USED FOR LOCAL FILE--------------------*/ AudioFileID audioFile; AudioStreamBasicDescription dataFormat; AudioStreamPacketDescription *packetDescs; UInt64 packetIndex; UInt32 numPacketsToRead; BOOL repeat; BOOL trackClosed; /*--------------------USED FOR PUBLIC------------------------*/ BOOL trackEnded; AudioQueueRef queue; AudioQueueBufferRef buffers[NUM_QUEUE_BUFFERS]; } @property BOOL isPlaying; @property BOOL trackClosed; - (id) initWithURL:(NSURL*) newURL; - (id) initWithPath:(NSString*) path; - (void) setGain:(Float32)gain; - (void) setRepeat:(BOOL)yn; - (void) setPlayingWhenAutoLock; - (void) play; - (void) playURL; - (void) pause; - (void) stopURL; - (void) close; extern NSString *xxxTrackFinishedPlayingNotification; @end .m文件 #import "xxxxx.h" #import 
           
             static UInt32 kxxxBufferSizeBytes = 0x10000; // 64k static BOOL kxxxTrackActive = NO; NSString *xxxTrackFinishedPlayingNotification = @"xxxTrackFinishedPlayingNotification"; #pragma mark - #pragma mark CFReadStream Callback Function Prototypes void ReadStreamCallBack(CFReadStreamRef stream, CFStreamEventType eventType, void* dataIn); #pragma mark - #pragma mark Audio Callback Function Prototypes void MyAudioQueueOutputCallback(void* inClientData, AudioQueueRef inAQ, AudioQueueBufferRef inBuffer); void MyAudioQueueIsRunningCallback(void *inUserData, AudioQueueRef inAQ, AudioQueuePropertyID inID); void MyPropertyListenerProc(void *inClientData, AudioFileStreamID inAudioFileStream, AudioFileStreamPropertyID inPropertyID, UInt32 *ioFlags); void MyPacketsProc(void *inClientData, UInt32 inNumberBytes, UInt32 inNumberPackets, const void *inInputData, AudioStreamPacketDescription *inPacketDescriptions); OSStatus MyEnqueueBuffer(xxxxx* myData); #ifdef TARGET_OS_IPHONE void MyAudioSessionInterruptionListener(void *inClientData, UInt32 inInterruptionState); #endif #pragma mark - #pragma mark Audio Callback Function Implementations // // MyPropertyListenerProc // // Receives notification when the AudioFileStream has audio packets to be // played. In response, this function creates the AudioQueue, getting it // ready to begin playback (playback won't begin until audio packets are // sent to the queue in MyEnqueueBuffer). // // This function is adapted from Apple's example in AudioFileStreamExample with // kAudioQueueProperty_IsRunning listening added. // void MyPropertyListenerProc(void *inClientData, AudioFileStreamID inAudioFileStream, AudioFileStreamPropertyID inPropertyID, UInt32 *ioFlags) { // this is called by audio file stream when it finds property values xxxxx* myData = (xxxxx*)inClientData; OSStatus err = noErr; switch (inPropertyID) { case kAudioFileStreamProperty_ReadyToProducePackets : { myData->discontinuous = true; // the file stream parser is now ready to produce audio packets. // get the stream format. AudioStreamBasicDescription asbd; UInt32 asbdSize = sizeof(asbd); err = AudioFileStreamGetProperty(inAudioFileStream, kAudioFileStreamProperty_DataFormat, &asbdSize, &asbd); if (err) { NSLog(@"get kAudioFileStreamProperty_DataFormat"); myData->failed = true; break; } // create the audio queue err = AudioQueueNewOutput(&asbd, MyAudioQueueOutputCallback, myData, NULL, NULL, 0, &myData->queue); if (err) { NSLog(@"AudioQueueNewOutput"); myData->failed = true; break; } // listen to the "isRunning" property err = AudioQueueAddPropertyListener(myData->queue, kAudioQueueProperty_IsRunning, MyAudioQueueIsRunningCallback, myData); if (err) { NSLog(@"AudioQueueAddPropertyListener"); myData->failed = true; break; } // allocate audio queue buffers for (unsigned int i = 0; i < kNumAQBufs; ++i) { err = AudioQueueAllocateBuffer(myData->queue, kAQBufSize, &myData->buffers); if (err) { NSLog(@"AudioQueueAllocateBuffer"); myData->failed = true; break; } } // get the cookie size UInt32 cookieSize; Boolean writable; err = AudioFileStreamGetPropertyInfo(inAudioFileStream, kAudioFileStreamProperty_MagicCookieData, &cookieSize, &writable); if (err) { NSLog(@"info kAudioFileStreamProperty_MagicCookieData"); break; } // get the cookie data void* cookieData = calloc(1, cookieSize); err = AudioFileStreamGetProperty(inAudioFileStream, kAudioFileStreamProperty_MagicCookieData, &cookieSize, cookieData); if (err) { NSLog(@"get kAudioFileStreamProperty_MagicCookieData"); free(cookieData); break; } // set the cookie on the queue. err = AudioQueueSetProperty(myData->queue, kAudioQueueProperty_MagicCookie, cookieData, cookieSize); free(cookieData); if (err) { NSLog(@"set kAudioQueueProperty_MagicCookie"); break; } break; } } }
           
          
         
        
       
      
     

 

// // MyPacketsProc // // When the AudioStream has packets to be played, this function gets an // idle audio buffer and copies the audio packets into it. The calls to // MyEnqueueBuffer won't return until there are buffers available (or the // playback has been stopped). // // This function is adapted from Apple's example in AudioFileStreamExample with // CBR functionality added. // void MyPacketsProc(void *inClientData, UInt32 inNumberBytes, UInt32 inNumberPackets, const void *inInputData, AudioStreamPacketDescription *inPacketDescriptions) {
   // this is called by audio file stream when it finds packets of audio xxxxx* myData = (xxxxx*)inClientData; // we have successfully read the first packests from the audio stream, so // clear the "discontinuous" flag myData->discontinuous = false; // the following code assumes we're streaming VBR data. for CBR data, the second branch is used. if (inPacketDescriptions) {
   for (int i = 0; i < inNumberPackets; ++i) {
   SInt64 packetOffset = inPacketDescriptions.mStartOffset; SInt64 packetSize   = inPacketDescriptions.mDataByteSize; // If the audio was terminated before this point, then // exit. if (myData->trackEnded) {
   return; } // if the space remaining in the buffer is not enough for this packet, then enqueue the buffer. size_t bufSpaceRemaining = kAQBufSize - myData->bytesFilled; if (bufSpaceRemaining < packetSize) {
   MyEnqueueBuffer(myData); } pthread_mutex_lock(&myData->mutex2); // If the audio was terminated while waiting for a buffer, then // exit. if (myData->trackEnded) {
   pthread_mutex_unlock(&myData->mutex2); return; } // copy data to the audio queue buffer AudioQueueBufferRef fillBuf = myData->buffers[myData->fillBufferIndex]; memcpy((char*)fillBuf->mAudioData + myData->bytesFilled, (const char*)inInputData + packetOffset, packetSize); pthread_mutex_unlock(&myData->mutex2); // fill out packet description myData->packetDescsQueue[myData->packetsFilled] = inPacketDescriptions; myData->packetDescsQueue[myData->packetsFilled].mStartOffset = myData->bytesFilled; // keep track of bytes filled and packets filled myData->bytesFilled += packetSize; myData->packetsFilled += 1; // if that was the last free packet description, then enqueue the buffer. size_t packetsDescsRemaining = kAQMaxPacketDescs - myData->packetsFilled; if (packetsDescsRemaining == 0) {
   MyEnqueueBuffer(myData); } } } else {
   size_t offset = 0; while (inNumberBytes) {
   // if the space remaining in the buffer is not enough for this packet, then enqueue the buffer. size_t bufSpaceRemaining = kAQBufSize - myData->bytesFilled; if (bufSpaceRemaining < inNumberBytes) {
   MyEnqueueBuffer(myData); } pthread_mutex_lock(&myData->mutex2); // If the audio was terminated while waiting for a buffer, then // exit. if (myData->trackEnded) {
   pthread_mutex_unlock(&myData->mutex2); return; } // copy data to the audio queue buffer AudioQueueBufferRef fillBuf = myData->buffers[myData->fillBufferIndex]; bufSpaceRemaining = kAQBufSize - myData->bytesFilled; size_t copySize; if (bufSpaceRemaining < inNumberBytes) {
   copySize = bufSpaceRemaining; } else {
   copySize = inNumberBytes; } memcpy((char*)fillBuf->mAudioData + myData->bytesFilled, (const char*)(inInputData + offset), copySize); pthread_mutex_unlock(&myData->mutex2); // keep track of bytes filled and packets filled myData->bytesFilled += copySize; myData->packetsFilled = 0; inNumberBytes -= copySize; offset += copySize; } } } // // MyEnqueueBuffer // // Called from MyPacketsProc and connectionDidFinishLoading to pass filled audio // bufffers (filled by MyPacketsProc) to the AudioQueue for playback. This // function does not return until a buffer is idle for further filling or // the AudioQueue is stopped. // // This function is adapted from Apple's example in AudioFileStreamExample with // CBR functionality added. // OSStatus MyEnqueueBuffer(xxxxx* myData) {
   OSStatus err = noErr; myData->inuse[myData->fillBufferIndex] = true; // set in use flag // enqueue buffer AudioQueueBufferRef fillBuf = myData->buffers[myData->fillBufferIndex]; fillBuf->mAudioDataByteSize = myData->bytesFilled; if (myData->packetsFilled) {
   err = AudioQueueEnqueueBuffer(myData->queue, fillBuf, myData->packetsFilled, myData->packetDescsQueue); } else {
   err = AudioQueueEnqueueBuffer(myData->queue, fillBuf, 0, NULL); } if (err) { NSLog(@"AudioQueueEnqueueBuffer"); myData->failed = true; return err; } if (!myData->started) { // start the queue if it has not been started already err = AudioQueueStart(myData->queue, NULL); if (err) { NSLog(@"AudioQueueStart"); myData->failed = true; return err; } myData->started = true; } // go to next buffer if (++myData->fillBufferIndex >= kNumAQBufs) myData->fillBufferIndex = 0; myData->bytesFilled = 0; // reset bytes filled myData->packetsFilled = 0; // reset packets filled // wait until next buffer is not in use pthread_mutex_lock(&myData->mutex); while (myData->inuse[myData->fillBufferIndex] && !myData->trackEnded) {
   pthread_cond_wait(&myData->cond, &myData->mutex); } pthread_mutex_unlock(&myData->mutex); return err; } // // MyFindQueueBuffer // // Returns the index of the specified buffer in the audioQueueBuffer array. // // This function is unchanged from Apple's example in AudioFileStreamExample. // int MyFindQueueBuffer(xxxxx* myData, AudioQueueBufferRef inBuffer) {
   for (unsigned int i = 0; i < kNumAQBufs; ++i) {
   if (inBuffer == myData->buffers) return i; } return -1; } // // MyAudioQueueOutputCallback // // Called from the AudioQueue when playback of specific buffers completes. This // function signals from the AudioQueue thread to the AudioStream thread that // the buffer is idle and available for copying data. // // This function is unchanged from Apple's example in AudioFileStreamExample. // void MyAudioQueueOutputCallback(void* inClientData, AudioQueueRef inAQ, AudioQueueBufferRef inBuffer) {
   // this is called by the audio queue when it has finished decoding our data. // The buffer is now free to be reused. xxxxx* myData = (xxxxx*)inClientData; unsigned int bufIndex = MyFindQueueBuffer(myData, inBuffer); // signal waiting thread that the buffer is free. pthread_mutex_lock(&myData->mutex); myData->inuse[bufIndex] = false; pthread_cond_signal(&myData->cond); pthread_mutex_unlock(&myData->mutex); } // // MyAudioQueueIsRunningCallback // // Called from the AudioQueue when playback is started or stopped. This // information is used to toggle the observable "isPlaying" property and // set the "finished" flag. // void MyAudioQueueIsRunningCallback(void *inUserData, AudioQueueRef inAQ, AudioQueuePropertyID inID) {
   xxxxx *myData = (xxxxx *)inUserData; NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; if (myData.isPlaying) {
   myData->trackEnded = true; myData.isPlaying = false; #ifdef TARGET_OS_IPHONE AudioSessionSetActive(false); #endif } else {
   myData.isPlaying = true; if (myData->trackEnded) {
   myData.isPlaying = false; } // // Note about this bug avoidance quirk: // // On cleanup of the AudioQueue thread, on rare occasions, there would // be a crash in CFSetContainsValue as a CFRunLoopObserver was getting // removed from the CFRunLoop. // // After lots of testing, it appeared that the audio thread was // attempting to remove CFRunLoop observers from the CFRunLoop after the // thread had already deallocated the run loop. // // By creating an NSRunLoop for the AudioQueue thread, it changes the // thread destruction order and seems to avoid this crash bug -- or // at least I haven't had it since (nasty hard to reproduce error!) // [NSRunLoop currentRunLoop]; } [pool release]; } #ifdef TARGET_OS_IPHONE // // MyAudioSessionInterruptionListener // // Invoked if the audio session is interrupted (like when the phone rings) // void MyAudioSessionInterruptionListener(void *inClientData, UInt32 inInterruptionState) {
   } #endif