The Tor Browser: content/media/webm/WebMReader.h@6474c204b198 (annotated)

content/media/webm/WebMReader.h@6474c204b198 (annotated)

content/media/webm/WebMReader.h

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim:set ts=2 sw=2 sts=2 et cindent: */
 /* 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/. */
 #if !defined(WebMReader_h_)
 #define WebMReader_h_
 #include <stdint.h>
 #include "nsDeque.h"
 #include "MediaDecoderReader.h"
 #include "nsAutoRef.h"
 #include "nestegg/nestegg.h"
 #define VPX_DONT_DEFINE_STDINT_TYPES
 #include "vpx/vpx_codec.h"
 #ifdef MOZ_TREMOR
 #include "tremor/ivorbiscodec.h"
 #else
 #include "vorbis/codec.h"
 #endif
 #ifdef MOZ_OPUS
 #include "OpusParser.h"
 #endif
 namespace mozilla {
 class WebMBufferedState;
 // Holds a nestegg_packet, and its file offset. This is needed so we
 // know the offset in the file we've played up to, in order to calculate
 // whether it's likely we can play through to the end without needing
 // to stop to buffer, given the current download rate.
 class NesteggPacketHolder {
 public:
   NesteggPacketHolder(nestegg_packet* aPacket, int64_t aOffset)
     : mPacket(aPacket), mOffset(aOffset)
   {
     MOZ_COUNT_CTOR(NesteggPacketHolder);
   }
   ~NesteggPacketHolder() {
     MOZ_COUNT_DTOR(NesteggPacketHolder);
     nestegg_free_packet(mPacket);
   }
   nestegg_packet* mPacket;
   // Offset in bytes. This is the offset of the end of the Block
   // which contains the packet.
   int64_t mOffset;
 private:
   // Copy constructor and assignment operator not implemented. Don't use them!
   NesteggPacketHolder(const NesteggPacketHolder &aOther);
   NesteggPacketHolder& operator= (NesteggPacketHolder const& aOther);
 };
 // Thread and type safe wrapper around nsDeque.
 class PacketQueueDeallocator : public nsDequeFunctor {
   virtual void* operator() (void* anObject) {
     delete static_cast<NesteggPacketHolder*>(anObject);
     return nullptr;
   }
 };
 // Typesafe queue for holding nestegg packets. It has
 // ownership of the items in the queue and will free them
 // when destroyed.
 class WebMPacketQueue : private nsDeque {
  public:
    WebMPacketQueue()
      : nsDeque(new PacketQueueDeallocator())
    {}
   ~WebMPacketQueue() {
     Reset();
   }
   inline int32_t GetSize() {
     return nsDeque::GetSize();
   }
   inline void Push(NesteggPacketHolder* aItem) {
     NS_ASSERTION(aItem, "NULL pushed to WebMPacketQueue");
     nsDeque::Push(aItem);
   }
   inline void PushFront(NesteggPacketHolder* aItem) {
     NS_ASSERTION(aItem, "NULL pushed to WebMPacketQueue");
     nsDeque::PushFront(aItem);
   }
   inline NesteggPacketHolder* PopFront() {
     return static_cast<NesteggPacketHolder*>(nsDeque::PopFront());
   }
   void Reset() {
     while (GetSize() > 0) {
       delete PopFront();
     }
   }
 };
 class WebMReader : public MediaDecoderReader
 {
 public:
   WebMReader(AbstractMediaDecoder* aDecoder);
   ~WebMReader();
   virtual nsresult Init(MediaDecoderReader* aCloneDonor);
   virtual nsresult ResetDecode();
   virtual bool DecodeAudioData();
   // If the Theora granulepos has not been captured, it may read several packets
   // until one with a granulepos has been captured, to ensure that all packets
   // read have valid time info.
   virtual bool DecodeVideoFrame(bool &aKeyframeSkip,
                                   int64_t aTimeThreshold);
   virtual bool HasAudio()
   {
     NS_ASSERTION(mDecoder->OnDecodeThread(), "Should be on decode thread.");
     return mHasAudio;
   }
   virtual bool HasVideo()
   {
     NS_ASSERTION(mDecoder->OnDecodeThread(), "Should be on decode thread.");
     return mHasVideo;
   }
   virtual nsresult ReadMetadata(MediaInfo* aInfo,
                                 MetadataTags** aTags);
   virtual nsresult Seek(int64_t aTime, int64_t aStartTime, int64_t aEndTime, int64_t aCurrentTime);
   virtual nsresult GetBuffered(dom::TimeRanges* aBuffered, int64_t aStartTime);
   virtual void NotifyDataArrived(const char* aBuffer, uint32_t aLength, int64_t aOffset);
 protected:
   // Value passed to NextPacket to determine if we are reading a video or an
   // audio packet.
   enum TrackType {
     VIDEO = 0,
     AUDIO = 1
   };
   // Read a packet from the nestegg file. Returns nullptr if all packets for
   // the particular track have been read. Pass VIDEO or AUDIO to indicate the
   // type of the packet we want to read.
   nsReturnRef<NesteggPacketHolder> NextPacket(TrackType aTrackType);
   // Pushes a packet to the front of the video packet queue.
   virtual void PushVideoPacket(NesteggPacketHolder* aItem);
   // Returns an initialized ogg packet with data obtained from the WebM container.
   ogg_packet InitOggPacket(unsigned char* aData,
                            size_t aLength,
                            bool aBOS,
                            bool aEOS,
                            int64_t aGranulepos);
 #ifdef MOZ_OPUS
   // Setup opus decoder
   bool InitOpusDecoder();
 #endif
   // Decode a nestegg packet of audio data. Push the audio data on the
   // audio queue. Returns true when there's more audio to decode,
   // false if the audio is finished, end of file has been reached,
   // or an un-recoverable read error has occured. The reader's monitor
   // must be held during this call. The caller is responsible for freeing
   // aPacket.
   bool DecodeAudioPacket(nestegg_packet* aPacket, int64_t aOffset);
   // Release context and set to null. Called when an error occurs during
   // reading metadata or destruction of the reader itself.
   void Cleanup();
 private:
   // libnestegg context for webm container. Access on state machine thread
   // or decoder thread only.
   nestegg* mContext;
   // VP8 decoder state
   vpx_codec_ctx_t mVPX;
   // Vorbis decoder state
   vorbis_info mVorbisInfo;
   vorbis_comment mVorbisComment;
   vorbis_dsp_state mVorbisDsp;
   vorbis_block mVorbisBlock;
   uint32_t mPacketCount;
   uint32_t mChannels;
 #ifdef MOZ_OPUS
   // Opus decoder state
   nsAutoPtr<OpusParser> mOpusParser;
   OpusMSDecoder *mOpusDecoder;
   int mSkip;        // Number of samples left to trim before playback.
   uint64_t mSeekPreroll; // Number of nanoseconds that must be discarded after seeking.
 #endif
   // Queue of video and audio packets that have been read but not decoded. These
   // must only be accessed from the state machine thread.
   WebMPacketQueue mVideoPackets;
   WebMPacketQueue mAudioPackets;
   // Index of video and audio track to play
   uint32_t mVideoTrack;
   uint32_t mAudioTrack;
   // Time in microseconds of the start of the first audio frame we've decoded.
   int64_t mAudioStartUsec;
   // Number of audio frames we've decoded since decoding began at mAudioStartMs.
   uint64_t mAudioFrames;
   // Number of microseconds that must be discarded from the start of the Stream.
   uint64_t mCodecDelay;
   // Parser state and computed offset-time mappings.  Shared by multiple
   // readers when decoder has been cloned.  Main thread only.
   nsRefPtr<WebMBufferedState> mBufferedState;
   // Size of the frame initially present in the stream. The picture region
   // is defined as a ratio relative to this.
   nsIntSize mInitialFrame;
   // Picture region, as relative to the initial frame size.
   nsIntRect mPicture;
   // Codec ID of audio track
   int mAudioCodec;
   // Codec ID of video track
   int mVideoCodec;
   // Booleans to indicate if we have audio and/or video data
   bool mHasVideo;
   bool mHasAudio;
 };
 } // namespace mozilla
 #endif

The Tor Browser / annotate

content/media/webm/WebMReader.h@6474c204b198 (annotated)

content/media/webm/WebMReader.h