The Tor Browser: content/media/omx/OMXCodecWrapper.h@97036ab72558 (annotated)

content/media/omx/OMXCodecWrapper.h@97036ab72558 (annotated)

content/media/omx/OMXCodecWrapper.h

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-*/
 /* 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/. */
 #ifndef OMXCodecWrapper_h_
 #define OMXCodecWrapper_h_
 #include <gui/Surface.h>
 #include <stagefright/foundation/ABuffer.h>
 #include <stagefright/foundation/AMessage.h>
 #include <stagefright/MediaCodec.h>
 #include "AudioSegment.h"
 #include "GonkNativeWindow.h"
 #include "GonkNativeWindowClient.h"
 #include <speex/speex_resampler.h>
 namespace android {
 class OMXAudioEncoder;
 class OMXVideoEncoder;
 /**
  * This class (and its subclasses) wraps the video and audio codec from
  * MediaCodec API in libstagefright. Currently only AVC/H.264 video encoder and
  * AAC audio encoder are supported.
  *
  * OMXCodecWrapper has static creator functions that returns actual codec
  * instances for different types of codec supported and serves as superclass to
  * provide a function to read encoded data as byte array from codec. Two
  * subclasses, OMXAudioEncoder and OMXVideoEncoder, respectively provides
  * functions for encoding data from audio and video track.
  *
  * A typical usage is as follows:
  * - Call one of the creator function Create...() to get either a
  *   OMXAudioEncoder or OMXVideoEncoder object.
  * - Configure codec by providing characteristics of input raw data, such as
  *   video frame width and height, using Configure().
  * - Send raw data (and notify end of stream) with Encode().
  * - Get encoded data through GetNextEncodedFrame().
  * - Repeat previous 2 steps until end of stream.
  * - Destroy the object.
  *
  * The lifecycle of underlying OMX codec is binded with construction and
  * destruction of OMXCodecWrapper and subclass objects. For some types of
  * codecs, such as HW accelerated AVC/H.264 encoder, there can be only one
  * instance system-wise at a time, attempting to create another instance will
  * fail.
  */
 class OMXCodecWrapper
 {
 public:
   // Codec types.
   enum CodecType {
     AAC_ENC, // AAC encoder.
     AMR_NB_ENC, // AMR_NB encoder.
     AVC_ENC, // AVC/H.264 encoder.
     TYPE_COUNT
   };
   // Input and output flags.
   enum {
     // For Encode() and Encode, it indicates the end of input stream;
     // For GetNextEncodedFrame(), it indicates the end of output
     // stream.
     BUFFER_EOS = MediaCodec::BUFFER_FLAG_EOS,
     // For GetNextEncodedFrame(). It indicates the output buffer is an I-frame.
     BUFFER_SYNC_FRAME = MediaCodec::BUFFER_FLAG_SYNCFRAME,
     // For GetNextEncodedFrame(). It indicates that the output buffer contains
     // codec specific configuration info. (SPS & PPS for AVC/H.264;
     // DecoderSpecificInfo for AAC)
     BUFFER_CODEC_CONFIG = MediaCodec::BUFFER_FLAG_CODECCONFIG,
   };
   // Hard-coded values for AAC DecoderConfigDescriptor in libstagefright.
   // See MPEG4Writer::Track::writeMp4aEsdsBox()
   // Exposed for the need of MP4 container writer.
   enum {
     kAACBitrate = 96000,      // kbps
     kAACFrameSize = 768,      // bytes
     kAACFrameDuration = 1024, // How many samples per AAC frame.
   };
   /** Create a AAC audio encoder. Returns nullptr when failed. */
   static OMXAudioEncoder* CreateAACEncoder();
   /** Create a AMR audio encoder. Returns nullptr when failed. */
   static OMXAudioEncoder* CreateAMRNBEncoder();
   /** Create a AVC/H.264 video encoder. Returns nullptr when failed. */
   static OMXVideoEncoder* CreateAVCEncoder();
   virtual ~OMXCodecWrapper();
   /**
    * Get the next available encoded data from MediaCodec. The data will be
    * copied into aOutputBuf array, with its timestamp (in microseconds) in
    * aOutputTimestamp.
    * Wait at most aTimeout microseconds to dequeue a output buffer.
    */
   nsresult GetNextEncodedFrame(nsTArray<uint8_t>* aOutputBuf,
                                int64_t* aOutputTimestamp, int* aOutputFlags,
                                int64_t aTimeOut);
   /*
    * Get the codec type
    */
   int GetCodecType() { return mCodecType; }
 protected:
   /**
    * See whether the object has been initialized successfully and is ready to
    * use.
    */
   virtual bool IsValid() { return mCodec != nullptr; }
   /**
    * Construct codec specific configuration blob with given data aData generated
    * by media codec and append it into aOutputBuf. Needed by MP4 container
    * writer for generating decoder config box, or WebRTC for generating RTP
    * packets. Returns OK if succeed.
    */
   virtual status_t AppendDecoderConfig(nsTArray<uint8_t>* aOutputBuf,
                                        ABuffer* aData) = 0;
   /**
    * Append encoded frame data generated by media codec (stored in aData and
    * is aSize bytes long) into aOutputBuf. Subclasses can override this function
    * to process the data for specific container writer.
    */
   virtual void AppendFrame(nsTArray<uint8_t>* aOutputBuf,
                            const uint8_t* aData, size_t aSize)
   {
     aOutputBuf->AppendElements(aData, aSize);
   }
 private:
   // Hide these. User should always use creator functions to get a media codec.
   OMXCodecWrapper() MOZ_DELETE;
   OMXCodecWrapper(const OMXCodecWrapper&) MOZ_DELETE;
   OMXCodecWrapper& operator=(const OMXCodecWrapper&) MOZ_DELETE;
   /**
    * Create a media codec of given type. It will be a AVC/H.264 video encoder if
    * aCodecType is CODEC_AVC_ENC, or AAC audio encoder if aCodecType is
    * CODEC_AAC_ENC.
    */
   OMXCodecWrapper(CodecType aCodecType);
   // For subclasses to access hidden constructor and implementation details.
   friend class OMXAudioEncoder;
   friend class OMXVideoEncoder;
   /**
    * Start the media codec.
    */
   status_t Start();
   /**
    * Stop the media codec.
    */
   status_t Stop();
   // The actual codec instance provided by libstagefright.
   sp<MediaCodec> mCodec;
   // A dedicate message loop with its own thread used by MediaCodec.
   sp<ALooper> mLooper;
   Vector<sp<ABuffer> > mInputBufs;  // MediaCodec buffers to hold input data.
   Vector<sp<ABuffer> > mOutputBufs; // MediaCodec buffers to hold output data.
   int mCodecType;
   bool mStarted; // Has MediaCodec been started?
   bool mAMRCSDProvided;
 };
 /**
  * Audio encoder.
  */
 class OMXAudioEncoder MOZ_FINAL : public OMXCodecWrapper
 {
 public:
   /**
    * Configure audio codec parameters and start media codec. It must be called
    * before calling Encode() and GetNextEncodedFrame().
    * aReSamplingRate = 0 means no resampler required
    */
   nsresult Configure(int aChannelCount, int aInputSampleRate, int aEncodedSampleRate);
   /**
    * Encode 16-bit PCM audio samples stored in aSegment. To notify end of
    * stream, set aInputFlags to BUFFER_EOS. Since encoder has limited buffers,
    * this function might not be able to encode all chunks in one call, however
    * it will remove chunks it consumes from aSegment.
    */
   nsresult Encode(mozilla::AudioSegment& aSegment, int aInputFlags = 0);
   ~OMXAudioEncoder();
 protected:
   virtual status_t AppendDecoderConfig(nsTArray<uint8_t>* aOutputBuf,
                                        ABuffer* aData) MOZ_OVERRIDE;
 private:
   // Hide these. User should always use creator functions to get a media codec.
   OMXAudioEncoder() MOZ_DELETE;
   OMXAudioEncoder(const OMXAudioEncoder&) MOZ_DELETE;
   OMXAudioEncoder& operator=(const OMXAudioEncoder&) MOZ_DELETE;
   /**
    * Create a audio codec. It will be a AAC encoder if aCodecType is
    * CODEC_AAC_ENC.
    */
   OMXAudioEncoder(CodecType aCodecType)
     : OMXCodecWrapper(aCodecType)
     , mResampler(nullptr)
     , mChannels(0)
     , mTimestamp(0)
     , mSampleDuration(0)
     , mResamplingRatio(0) {}
   // For creator function to access hidden constructor.
   friend class OMXCodecWrapper;
   /**
    * If the input sample rate does not divide 48kHz evenly, the input data are
    * resampled.
    */
   SpeexResamplerState* mResampler;
   // Number of audio channels.
   size_t mChannels;
   float mResamplingRatio;
   // The total duration of audio samples that have been encoded in microseconds.
   int64_t mTimestamp;
   // Time per audio sample in microseconds.
   int64_t mSampleDuration;
 };
 /**
  * Video encoder.
  */
 class OMXVideoEncoder MOZ_FINAL : public OMXCodecWrapper
 {
   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(OMXVideoEncoder)
 public:
   // Types of output blob format.
   enum BlobFormat {
     AVC_MP4, // MP4 file config descripter (defined in ISO/IEC 14496-15 5.2.4.1.1)
     AVC_NAL  // NAL (Network Abstract Layer) (defined in ITU-T H.264 7.4.1)
   };
   /**
    * Configure video codec parameters and start media codec. It must be called
    * before calling Encode() and GetNextEncodedFrame().
    * aBlobFormat specifies output blob format provided by encoder. It can be
    * AVC_MP4 or AVC_NAL.
    */
   nsresult Configure(int aWidth, int aHeight, int aFrameRate,
                      BlobFormat aBlobFormat = BlobFormat::AVC_MP4);
   /**
    * Encode a aWidth pixels wide and aHeight pixels tall video frame of
    * semi-planar YUV420 format stored in the buffer of aImage. aTimestamp gives
    * the frame timestamp/presentation time (in microseconds). To notify end of
    * stream, set aInputFlags to BUFFER_EOS.
    */
   nsresult Encode(const mozilla::layers::Image* aImage, int aWidth, int aHeight,
                   int64_t aTimestamp, int aInputFlags = 0);
 #if ANDROID_VERSION >= 18
   /** Set encoding bitrate (in kbps). */
   nsresult SetBitrate(int32_t aKbps);
 #endif
   /**
    * Get current AVC codec config blob. The output format depends on the
    * aBlobFormat argument given when Configure() was called.
    */
   nsresult GetCodecConfig(nsTArray<uint8_t>* aOutputBuf);
 protected:
   virtual status_t AppendDecoderConfig(nsTArray<uint8_t>* aOutputBuf,
                                        ABuffer* aData) MOZ_OVERRIDE;
   // If configured to output MP4 format blob, AVC/H.264 encoder has to replace
   // NAL unit start code with the unit length as specified in
   // ISO/IEC 14496-15 5.2.3.
   virtual void AppendFrame(nsTArray<uint8_t>* aOutputBuf,
                            const uint8_t* aData, size_t aSize) MOZ_OVERRIDE;
 private:
   // Hide these. User should always use creator functions to get a media codec.
   OMXVideoEncoder() MOZ_DELETE;
   OMXVideoEncoder(const OMXVideoEncoder&) MOZ_DELETE;
   OMXVideoEncoder& operator=(const OMXVideoEncoder&) MOZ_DELETE;
   /**
    * Create a video codec. It will be a AVC/H.264 encoder if aCodecType is
    * CODEC_AVC_ENC.
    */
   OMXVideoEncoder(CodecType aCodecType)
     : OMXCodecWrapper(aCodecType)
     , mWidth(0)
     , mHeight(0)
     , mBlobFormat(BlobFormat::AVC_MP4)
     , mHasConfigBlob(false)
   {}
   // For creator function to access hidden constructor.
   friend class OMXCodecWrapper;
   int mWidth;
   int mHeight;
   BlobFormat mBlobFormat;
   bool mHasConfigBlob;
 };
 } // namespace android
 #endif // OMXCodecWrapper_h_

The Tor Browser / annotate

content/media/omx/OMXCodecWrapper.h@97036ab72558 (annotated)

content/media/omx/OMXCodecWrapper.h