The Tor Browser: content/media/apple/AppleMP3Reader.cpp@44a2da4a2ab2 (annotated)

content/media/apple/AppleMP3Reader.cpp@44a2da4a2ab2 (annotated)

content/media/apple/AppleMP3Reader.cpp

Fri, 16 Jan 2015 04:50:19 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Fri, 16 Jan 2015 04:50:19 +0100
branch: TOR_BUG_9701
changeset 13: 44a2da4a2ab2
permissions: -rw-r--r--

Replace accessor implementation with direct member state manipulation, by
request https://trac.torproject.org/projects/tor/ticket/9701#comment:32

 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "AppleMP3Reader.h"
 #include "nsISeekableStream.h"
 #include "MediaDecoder.h"
 // Number of bytes we will read and pass to the audio parser in each
 // |DecodeAudioData| call.
 #define AUDIO_READ_BYTES 4096
 // Maximum number of audio frames we will accept from the audio decoder in one
 // go.  Carefully select this to work well with both the mp3 1152 max frames
 // per block and power-of-2 allocation sizes.  Since we must pre-allocate the
 // buffer we cannot use AudioCompactor without paying for an additional
 // allocation and copy.  Therefore, choosing a value that divides exactly into
 // 1152 is most memory efficient.
 #define MAX_AUDIO_FRAMES 128
 namespace mozilla {
 #ifdef PR_LOGGING
 extern PRLogModuleInfo* gMediaDecoderLog;
 #define LOGE(...) PR_LOG(gMediaDecoderLog, PR_LOG_ERROR, (__VA_ARGS__))
 #define LOGW(...) PR_LOG(gMediaDecoderLog, PR_LOG_WARNING, (__VA_ARGS__))
 #define LOGD(...) PR_LOG(gMediaDecoderLog, PR_LOG_DEBUG, (__VA_ARGS__))
 #else
 #define LOGE(...)
 #define LOGW(...)
 #define LOGD(...)
 #endif
 #define PROPERTY_ID_FORMAT "%c%c%c%c"
 #define PROPERTY_ID_PRINT(x) ((x) >> 24), \
                              ((x) >> 16) & 0xff, \
                              ((x) >> 8) & 0xff, \
                              (x) & 0xff
 AppleMP3Reader::AppleMP3Reader(AbstractMediaDecoder *aDecoder)
   : MediaDecoderReader(aDecoder)
   , mStreamReady(false)
   , mAudioFramesPerCompressedPacket(0)
   , mCurrentAudioFrame(0)
   , mAudioChannels(0)
   , mAudioSampleRate(0)
   , mAudioFileStream(nullptr)
   , mAudioConverter(nullptr)
   , mMP3FrameParser(mDecoder->GetResource()->GetLength())
 {
   MOZ_ASSERT(NS_IsMainThread(), "Should be on main thread");
 }
 AppleMP3Reader::~AppleMP3Reader()
 {
   MOZ_ASSERT(NS_IsMainThread(), "Should be on main thread");
 }
 /*
  * The Apple audio decoding APIs are very callback-happy. When the parser has
  * some metadata, it will call back to here.
  */
 static void _AudioMetadataCallback(void *aThis,
                                    AudioFileStreamID aFileStream,
                                    AudioFileStreamPropertyID aPropertyID,
                                    UInt32 *aFlags)
 {
   ((AppleMP3Reader*)aThis)->AudioMetadataCallback(aFileStream, aPropertyID,
                                                   aFlags);
 }
 /*
  * Similar to above, this is called when the parser has enough data to parse
  * one or more samples.
  */
 static void _AudioSampleCallback(void *aThis,
                                  UInt32 aNumBytes, UInt32 aNumPackets,
                                  const void *aData,
                                  AudioStreamPacketDescription *aPackets)
 {
   ((AppleMP3Reader*)aThis)->AudioSampleCallback(aNumBytes, aNumPackets,
                                                 aData, aPackets);
 }
 /*
  * If we're not at end of stream, read |aNumBytes| from the media resource,
  * put it in |aData|, and return true.
  * Otherwise, put as much data as is left into |aData|, set |aNumBytes| to the
  * amount of data we have left, and return false.
  */
 nsresult
 AppleMP3Reader::Read(uint32_t *aNumBytes, char *aData)
 {
   MediaResource *resource = mDecoder->GetResource();
   // Loop until we have all the data asked for, or we've reached EOS
   uint32_t totalBytes = 0;
   uint32_t numBytes;
   do {
     uint32_t bytesWanted = *aNumBytes - totalBytes;
     nsresult rv = resource->Read(aData + totalBytes, bytesWanted, &numBytes);
     totalBytes += numBytes;
     if (NS_FAILED(rv)) {
       *aNumBytes = 0;
       return NS_ERROR_FAILURE;
     }
   } while(totalBytes < *aNumBytes && numBytes);
   *aNumBytes = totalBytes;
   // We will have read some data in the last iteration iff we filled the buffer.
   // XXX Maybe return a better value than NS_ERROR_FAILURE?
   return numBytes ? NS_OK : NS_ERROR_FAILURE;
 }
 nsresult
 AppleMP3Reader::Init(MediaDecoderReader* aCloneDonor)
 {
   AudioFileTypeID fileType = kAudioFileMP3Type;
   OSStatus rv = AudioFileStreamOpen(this,
                                     _AudioMetadataCallback,
                                     _AudioSampleCallback,
                                     fileType,
                                     &mAudioFileStream);
   if (rv) {
     return NS_ERROR_FAILURE;
   }
   return NS_OK;
 }
 struct PassthroughUserData {
   AppleMP3Reader *mReader;
   UInt32 mNumPackets;
   UInt32 mDataSize;
   const void *mData;
   AudioStreamPacketDescription *mPacketDesc;
   bool mDone;
 };
 // Error value we pass through the decoder to signal that nothing has gone wrong
 // during decoding, but more data is needed.
 const UInt32 kNeedMoreData = 'MOAR';
 /*
  * This function is called from |AudioConverterFillComplexBuffer|, which is
  * called from |AudioSampleCallback| below, which in turn is called by
  * |AudioFileStreamParseBytes|, which is called by |DecodeAudioData|.
  *
  * Mercifully, this is all synchronous.
  *
  * This callback is run when the AudioConverter (decoder) wants more MP3 packets
  * to decode.
  */
 /* static */ OSStatus
 AppleMP3Reader::PassthroughInputDataCallback(AudioConverterRef aAudioConverter,
                                              UInt32 *aNumDataPackets /* in/out */,
                                              AudioBufferList *aData /* in/out */,
                                              AudioStreamPacketDescription **aPacketDesc,
                                              void *aUserData)
 {
   PassthroughUserData *userData = (PassthroughUserData *)aUserData;
   if (userData->mDone) {
     // We make sure this callback is run _once_, with all the data we received
     // from |AudioFileStreamParseBytes|. When we return an error, the decoder
     // simply passes the return value on to the calling method,
     // |AudioSampleCallback|; and flushes all of the audio frames it had
     // buffered. It does not change the decoder's state.
     LOGD("requested too much data; returning\n");
     *aNumDataPackets = 0;
     return kNeedMoreData;
   }
   userData->mDone = true;
   LOGD("AudioConverter wants %u packets of audio data\n", *aNumDataPackets);
   *aNumDataPackets = userData->mNumPackets;
   *aPacketDesc = userData->mPacketDesc;
   aData->mBuffers[0].mNumberChannels = userData->mReader->mAudioChannels;
   aData->mBuffers[0].mDataByteSize = userData->mDataSize;
   aData->mBuffers[0].mData = const_cast<void *>(userData->mData);
   return 0;
 }
 /*
  * This callback is called when |AudioFileStreamParseBytes| has enough data to
  * extract one or more MP3 packets.
  */
 void
 AppleMP3Reader::AudioSampleCallback(UInt32 aNumBytes,
                                     UInt32 aNumPackets,
                                     const void *aData,
                                     AudioStreamPacketDescription *aPackets)
 {
   LOGD("got %u bytes, %u packets\n", aNumBytes, aNumPackets);
   // 1 frame per packet * num channels * 32-bit float
   uint32_t decodedSize = MAX_AUDIO_FRAMES * mAudioChannels *
                          sizeof(AudioDataValue);
   // descriptions for _decompressed_ audio packets. ignored.
   nsAutoArrayPtr<AudioStreamPacketDescription>
     packets(new AudioStreamPacketDescription[MAX_AUDIO_FRAMES]);
   // This API insists on having MP3 packets spoon-fed to it from a callback.
   // This structure exists only to pass our state and the result of the parser
   // on to the callback above.
   PassthroughUserData userData = { this, aNumPackets, aNumBytes, aData, aPackets, false };
   do {
     // Decompressed audio buffer
     nsAutoArrayPtr<uint8_t> decoded(new uint8_t[decodedSize]);
     AudioBufferList decBuffer;
     decBuffer.mNumberBuffers = 1;
     decBuffer.mBuffers[0].mNumberChannels = mAudioChannels;
     decBuffer.mBuffers[0].mDataByteSize = decodedSize;
     decBuffer.mBuffers[0].mData = decoded.get();
     // in: the max number of packets we can handle from the decoder.
     // out: the number of packets the decoder is actually returning.
     UInt32 numFrames = MAX_AUDIO_FRAMES;
     OSStatus rv = AudioConverterFillComplexBuffer(mAudioConverter,
                                                   PassthroughInputDataCallback,
                                                   &userData,
                                                   &numFrames /* in/out */,
                                                   &decBuffer,
                                                   packets.get());
     if (rv && rv != kNeedMoreData) {
       LOGE("Error decoding audio stream: %x\n", rv);
       break;
     }
     // If we decoded zero frames then AudiOConverterFillComplexBuffer is out
     // of data to provide.  We drained its internal buffer completely on the
     // last pass.
     if (numFrames == 0 && rv == kNeedMoreData) {
       LOGD("FillComplexBuffer out of data exactly\n");
       break;
     }
     int64_t time = FramesToUsecs(mCurrentAudioFrame, mAudioSampleRate).value();
     int64_t duration = FramesToUsecs(numFrames, mAudioSampleRate).value();
     LOGD("pushed audio at time %lfs; duration %lfs\n",
          (double)time / USECS_PER_S, (double)duration / USECS_PER_S);
     AudioData *audio = new AudioData(mDecoder->GetResource()->Tell(),
                                      time, duration, numFrames,
                                      reinterpret_cast<AudioDataValue *>(decoded.forget()),
                                      mAudioChannels);
     mAudioQueue.Push(audio);
     mCurrentAudioFrame += numFrames;
     if (rv == kNeedMoreData) {
       // No error; we just need more data.
       LOGD("FillComplexBuffer out of data\n");
       break;
     }
   } while (true);
 }
 bool
 AppleMP3Reader::DecodeAudioData()
 {
   MOZ_ASSERT(mDecoder->OnDecodeThread(), "Should be on decode thread");
   // Read AUDIO_READ_BYTES if we can
   char bytes[AUDIO_READ_BYTES];
   uint32_t numBytes = AUDIO_READ_BYTES;
   nsresult readrv = Read(&numBytes, bytes);
   // This function calls |AudioSampleCallback| above, synchronously, when it
   // finds compressed MP3 frame.
   OSStatus rv = AudioFileStreamParseBytes(mAudioFileStream,
                                           numBytes,
                                           bytes,
 /* flags */);
   if (NS_FAILED(readrv)) {
     mAudioQueue.Finish();
     return false;
   }
   // DataUnavailable just means there wasn't enough data to demux anything.
   // We should have more to push into the demuxer next time we're called.
   if (rv && rv != kAudioFileStreamError_DataUnavailable) {
     LOGE("AudioFileStreamParseBytes returned unknown error %x", rv);
     return false;
   }
   return true;
 }
 bool
 AppleMP3Reader::DecodeVideoFrame(bool &aKeyframeSkip,
                                  int64_t aTimeThreshold)
 {
   MOZ_ASSERT(mDecoder->OnDecodeThread(), "Should be on decode thread");
   return false;
 }
 bool
 AppleMP3Reader::HasAudio()
 {
   MOZ_ASSERT(mDecoder->OnDecodeThread(), "Should be on decode thread");
   return mStreamReady;
 }
 bool
 AppleMP3Reader::HasVideo()
 {
   MOZ_ASSERT(mDecoder->OnDecodeThread(), "Should be on decode thread");
   return false;
 }
 /*
  * Query the MP3 parser for a piece of metadata.
  */
 static nsresult
 GetProperty(AudioFileStreamID aAudioFileStream,
             AudioFileStreamPropertyID aPropertyID, void *aData)
 {
   UInt32 size;
   Boolean writeable;
   OSStatus rv = AudioFileStreamGetPropertyInfo(aAudioFileStream, aPropertyID,
                                                &size, &writeable);
   if (rv) {
     LOGW("Couldn't get property " PROPERTY_ID_FORMAT "\n",
          PROPERTY_ID_PRINT(aPropertyID));
     return NS_ERROR_FAILURE;
   }
   rv = AudioFileStreamGetProperty(aAudioFileStream, aPropertyID,
                                   &size, aData);
   return NS_OK;
 }
 nsresult
 AppleMP3Reader::ReadMetadata(MediaInfo* aInfo,
                              MetadataTags** aTags)
 {
   MOZ_ASSERT(mDecoder->OnDecodeThread(), "Should be on decode thread");
   *aTags = nullptr;
   /*
    * Feed bytes into the parser until we have all the metadata we need to
    * set up the decoder. When the parser has enough data, it will
    * synchronously call back to |AudioMetadataCallback| below.
    */
   OSStatus rv;
   nsresult readrv;
   uint32_t offset = 0;
   do {
     char bytes[AUDIO_READ_BYTES];
     uint32_t numBytes = AUDIO_READ_BYTES;
     readrv = Read(&numBytes, bytes);
     rv = AudioFileStreamParseBytes(mAudioFileStream,
                                    numBytes,
                                    bytes,
 /* flags */);
     mMP3FrameParser.Parse(bytes, numBytes, offset);
     offset += numBytes;
     // We have to do our decoder setup from the callback. When it's done it will
     // set mStreamReady.
   } while (!mStreamReady && !rv && NS_SUCCEEDED(readrv));
   if (rv) {
     LOGE("Error decoding audio stream metadata\n");
     return NS_ERROR_FAILURE;
   }
   if (!mAudioConverter) {
     LOGE("Failed to setup the AudioToolbox audio decoder\n");
     return NS_ERROR_FAILURE;
   }
   if (!mMP3FrameParser.IsMP3()) {
     LOGE("Frame parser failed to parse MP3 stream\n");
     return NS_ERROR_FAILURE;
   }
   aInfo->mAudio.mRate = mAudioSampleRate;
   aInfo->mAudio.mChannels = mAudioChannels;
   aInfo->mAudio.mHasAudio = mStreamReady;
   {
     ReentrantMonitorAutoEnter mon(mDecoder->GetReentrantMonitor());
     mDuration = mMP3FrameParser.GetDuration();
     mDecoder->SetMediaDuration(mDuration);
   }
   return NS_OK;
 }
 void
 AppleMP3Reader::AudioMetadataCallback(AudioFileStreamID aFileStream,
                                       AudioFileStreamPropertyID aPropertyID,
                                       UInt32 *aFlags)
 {
   if (aPropertyID == kAudioFileStreamProperty_ReadyToProducePackets) {
     /*
      * The parser is ready to send us packets of MP3 audio.
      *
      * We need to set the decoder up here, because if
      * |AudioFileStreamParseBytes| has enough audio data, then it will call
      * |AudioSampleCallback| before we get back to |ReadMetadata|.
      */
     SetupDecoder();
     mStreamReady = true;
   }
 }
 void
 AppleMP3Reader::SetupDecoder()
 {
   // Get input format description from demuxer
   AudioStreamBasicDescription inputFormat, outputFormat;
   GetProperty(mAudioFileStream, kAudioFileStreamProperty_DataFormat, &inputFormat);
   memset(&outputFormat, 0, sizeof(outputFormat));
   // Set output format
 #if defined(MOZ_SAMPLE_TYPE_FLOAT32)
   outputFormat.mBitsPerChannel = 32;
   outputFormat.mFormatFlags =
     kLinearPCMFormatFlagIsFloat |
 ;
 #else
 #error Unknown audio sample type
 #endif
   mAudioSampleRate = outputFormat.mSampleRate = inputFormat.mSampleRate;
   mAudioChannels
     = outputFormat.mChannelsPerFrame = inputFormat.mChannelsPerFrame;
   mAudioFramesPerCompressedPacket = inputFormat.mFramesPerPacket;
   outputFormat.mFormatID = kAudioFormatLinearPCM;
   // Set up the decoder so it gives us one sample per frame; this way, it will
   // pass us all the samples it has in one go. Also makes it much easier to
   // deinterlace.
   outputFormat.mFramesPerPacket = 1;
   outputFormat.mBytesPerPacket = outputFormat.mBytesPerFrame
     = outputFormat.mChannelsPerFrame * outputFormat.mBitsPerChannel / 8;
   OSStatus rv = AudioConverterNew(&inputFormat,
                                   &outputFormat,
                                   &mAudioConverter);
   if (rv) {
     LOGE("Error constructing audio format converter: %x\n", rv);
     mAudioConverter = nullptr;
     return;
   }
 }
 nsresult
 AppleMP3Reader::Seek(int64_t aTime,
                      int64_t aStartTime,
                      int64_t aEndTime,
                      int64_t aCurrentTime)
 {
   MOZ_ASSERT(mDecoder->OnDecodeThread(), "Should be on decode thread");
   NS_ASSERTION(aStartTime < aEndTime,
                "Seeking should happen over a positive range");
   // Find the exact frame/packet that contains |aTime|.
   mCurrentAudioFrame = aTime * mAudioSampleRate / USECS_PER_S;
   SInt64 packet = mCurrentAudioFrame / mAudioFramesPerCompressedPacket;
   // |AudioFileStreamSeek| will pass back through |byteOffset| the byte offset
   // into the stream it expects next time it reads.
   SInt64 byteOffset;
   UInt32 flags = 0;
   OSStatus rv = AudioFileStreamSeek(mAudioFileStream,
                                     packet,
                                     &byteOffset,
                                     &flags);
   if (rv) {
     LOGE("Couldn't seek demuxer. Error code %x\n", rv);
     return NS_ERROR_FAILURE;
   }
   LOGD("computed byte offset = %lld; estimated = %s\n",
        byteOffset,
        (flags & kAudioFileStreamSeekFlag_OffsetIsEstimated) ? "YES" : "NO");
   mDecoder->GetResource()->Seek(nsISeekableStream::NS_SEEK_SET, byteOffset);
   ResetDecode();
   return NS_OK;
 }
 void
 AppleMP3Reader::NotifyDataArrived(const char* aBuffer,
                                   uint32_t aLength,
                                   int64_t aOffset)
 {
   MOZ_ASSERT(NS_IsMainThread());
   if (!mMP3FrameParser.NeedsData()) {
     return;
   }
   mMP3FrameParser.Parse(aBuffer, aLength, aOffset);
   uint64_t duration = mMP3FrameParser.GetDuration();
   if (duration != mDuration) {
     LOGD("Updating media duration to %lluus\n", duration);
     mDuration = duration;
     ReentrantMonitorAutoEnter mon(mDecoder->GetReentrantMonitor());
     mDecoder->UpdateEstimatedMediaDuration(duration);
   }
 }
 } // namespace mozilla

The Tor Browser / annotate

content/media/apple/AppleMP3Reader.cpp@44a2da4a2ab2 (annotated)

content/media/apple/AppleMP3Reader.cpp