LCOV - app.info - content/media/nsBuiltinDecoderReader.h

LCOV - code coverage report
| Current view: | directory - content/media - nsBuiltinDecoderReader.h (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 97 | 0 | 0.0 %
| Date: | 2012-07-07 | Functions: | 40 | 0 | 0.0 %

           1                 : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
           2                 : /* vim:set ts=2 sw=2 sts=2 et cindent: */
           3                 : /* ***** BEGIN LICENSE BLOCK *****
           4                 :  * Version: ML 1.1/GPL 2.0/LGPL 2.1
           5                 :  *
           6                 :  * The contents of this file are subject to the Mozilla Public License Version
           7                 :  * 1.1 (the "License"); you may not use this file except in compliance with
           8                 :  * the License. You may obtain a copy of the License at
           9                 :  * http://www.mozilla.org/MPL/
          10                 :  *
          11                 :  * Software distributed under the License is distributed on an "AS IS" basis,
          12                 :  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
          13                 :  * for the specific language governing rights and limitations under the
          14                 :  * License.
          15                 :  *
          16                 :  * The Original Code is Mozilla code.
          17                 :  *
          18                 :  * The Initial Developer of the Original Code is the Mozilla Foundation.
          19                 :  * Portions created by the Initial Developer are Copyright (C) 2010
          20                 :  * the Initial Developer. All Rights Reserved.
          21                 :  *
          22                 :  * Contributor(s):
          23                 :  *  Chris Double <chris.double@double.co.nz>
          24                 :  *  Chris Pearce <chris@pearce.org.nz>
          25                 :  *
          26                 :  * Alternatively, the contents of this file may be used under the terms of
          27                 :  * either the GNU General Public License Version 2 or later (the "GPL"), or
          28                 :  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
          29                 :  * in which case the provisions of the GPL or the LGPL are applicable instead
          30                 :  * of those above. If you wish to allow use of your version of this file only
          31                 :  * under the terms of either the GPL or the LGPL, and not to allow others to
          32                 :  * use your version of this file under the terms of the MPL, indicate your
          33                 :  * decision by deleting the provisions above and replace them with the notice
          34                 :  * and other provisions required by the GPL or the LGPL. If you do not delete
          35                 :  * the provisions above, a recipient may use your version of this file under
          36                 :  * the terms of any one of the MPL, the GPL or the LGPL.
          37                 :  *
          38                 :  * ***** END LICENSE BLOCK ***** */
          39                 : #if !defined(nsBuiltinDecoderReader_h_)
          40                 : #define nsBuiltinDecoderReader_h_
          41                 :
          42                 : #include <nsDeque.h>
          43                 : #include "ImageLayers.h"
          44                 : #include "nsSize.h"
          45                 : #include "mozilla/ReentrantMonitor.h"
          46                 :
          47                 : // Stores info relevant to presenting media frames.
          48                 : class nsVideoInfo {
          49                 : public:
          50               0 :   nsVideoInfo()
          51                 :     : mAudioRate(0),
          52                 :       mAudioChannels(0),
          53                 :       mDisplay(0,0),
          54                 :       mStereoMode(mozilla::layers::STEREO_MODE_MONO),
          55                 :       mHasAudio(false),
          56               0 :       mHasVideo(false)
          57               0 :   {}
          58                 :
          59                 :   // Returns true if it's safe to use aPicture as the picture to be
          60                 :   // extracted inside a frame of size aFrame, and scaled up to and displayed
          61                 :   // at a size of aDisplay. You should validate the frame, picture, and
          62                 :   // display regions before using them to display video frames.
          63                 :   static bool ValidateVideoRegion(const nsIntSize& aFrame,
          64                 :                                     const nsIntRect& aPicture,
          65                 :                                     const nsIntSize& aDisplay);
          66                 :
          67                 :   // Sample rate.
          68                 :   PRUint32 mAudioRate;
          69                 :
          70                 :   // Number of audio channels.
          71                 :   PRUint32 mAudioChannels;
          72                 :
          73                 :   // Size in pixels at which the video is rendered. This is after it has
          74                 :   // been scaled by its aspect ratio.
          75                 :   nsIntSize mDisplay;
          76                 :
          77                 :   // Indicates the frame layout for single track stereo videos.
          78                 :   mozilla::layers::StereoMode mStereoMode;
          79                 :
          80                 :   // True if we have an active audio bitstream.
          81                 :   bool mHasAudio;
          82                 :
          83                 :   // True if we have an active video bitstream.
          84                 :   bool mHasVideo;
          85                 : };
          86                 :
          87                 : #ifdef MOZ_TREMOR
          88                 : #include <ogg/os_types.h>
          89                 : typedef ogg_int32_t VorbisPCMValue;
          90                 : typedef short AudioDataValue;
          91                 :
          92                 : #define MOZ_AUDIO_DATA_FORMAT (nsAudioStream::FORMAT_S16_LE)
          93                 : #define MOZ_CLIP_TO_15(x) ((x)<-32768?-32768:(x)<=32767?(x):32767)
          94                 : // Convert the output of vorbis_synthesis_pcmout to a AudioDataValue
          95                 : #define MOZ_CONVERT_VORBIS_SAMPLE(x) \
          96                 :  (static_cast<AudioDataValue>(MOZ_CLIP_TO_15((x)>>9)))
          97                 : // Convert a AudioDataValue to a float for the Audio API
          98                 : #define MOZ_CONVERT_AUDIO_SAMPLE(x) ((x)*(1.F/32768))
          99                 : #define MOZ_SAMPLE_TYPE_S16LE 1
         100                 :
         101                 : #else /*MOZ_VORBIS*/
         102                 :
         103                 : typedef float VorbisPCMValue;
         104                 : typedef float AudioDataValue;
         105                 :
         106                 : #define MOZ_AUDIO_DATA_FORMAT (nsAudioStream::FORMAT_FLOAT32)
         107                 : #define MOZ_CONVERT_VORBIS_SAMPLE(x) (x)
         108                 : #define MOZ_CONVERT_AUDIO_SAMPLE(x) (x)
         109                 : #define MOZ_SAMPLE_TYPE_FLOAT32 1
         110                 :
         111                 : #endif
         112                 :
         113                 : // Holds chunk a decoded audio frames.
         114                 : class AudioData {
         115                 : public:
         116               0 :   AudioData(PRInt64 aOffset,
         117                 :             PRInt64 aTime,
         118                 :             PRInt64 aDuration,
         119                 :             PRUint32 aFrames,
         120                 :             AudioDataValue* aData,
         121                 :             PRUint32 aChannels)
         122                 :   : mOffset(aOffset),
         123                 :     mTime(aTime),
         124                 :     mDuration(aDuration),
         125                 :     mFrames(aFrames),
         126                 :     mChannels(aChannels),
         127               0 :     mAudioData(aData)
         128                 :   {
         129               0 :     MOZ_COUNT_CTOR(AudioData);
         130               0 :   }
         131                 :
         132               0 :   ~AudioData()
         133               0 :   {
         134               0 :     MOZ_COUNT_DTOR(AudioData);
         135               0 :   }
         136                 :
         137                 :   // Approximate byte offset of the end of the page on which this chunk
         138                 :   // ends.
         139                 :   const PRInt64 mOffset;
         140                 :
         141                 :   PRInt64 mTime; // Start time of data in usecs.
         142                 :   const PRInt64 mDuration; // In usecs.
         143                 :   const PRUint32 mFrames;
         144                 :   const PRUint32 mChannels;
         145                 :   nsAutoArrayPtr<AudioDataValue> mAudioData;
         146                 : };
         147                 :
         148                 : // Holds a decoded video frame, in YCbCr format. These are queued in the reader.
         149                 : class VideoData {
         150                 : public:
         151                 :   typedef mozilla::layers::ImageContainer ImageContainer;
         152                 :   typedef mozilla::layers::Image Image;
         153                 :
         154                 :   // YCbCr data obtained from decoding the video. The index's are:
         155                 :   //   0 = Y
         156                 :   //   1 = Cb
         157                 :   //   2 = Cr
         158                 :   struct YCbCrBuffer {
         159                 :     struct Plane {
         160                 :       PRUint8* mData;
         161                 :       PRUint32 mWidth;
         162                 :       PRUint32 mHeight;
         163                 :       PRUint32 mStride;
         164                 :     };
         165                 :
         166                 :     Plane mPlanes[3];
         167                 :   };
         168                 :
         169                 :   // Constructs a VideoData object. Makes a copy of YCbCr data in aBuffer.
         170                 :   // aTimecode is a codec specific number representing the timestamp of
         171                 :   // the frame of video data. Returns nsnull if an error occurs. This may
         172                 :   // indicate that memory couldn't be allocated to create the VideoData
         173                 :   // object, or it may indicate some problem with the input data (e.g.
         174                 :   // negative stride).
         175                 :   static VideoData* Create(nsVideoInfo& aInfo,
         176                 :                            ImageContainer* aContainer,
         177                 :                            PRInt64 aOffset,
         178                 :                            PRInt64 aTime,
         179                 :                            PRInt64 aEndTime,
         180                 :                            const YCbCrBuffer &aBuffer,
         181                 :                            bool aKeyframe,
         182                 :                            PRInt64 aTimecode,
         183                 :                            nsIntRect aPicture);
         184                 :
         185                 :   // Constructs a duplicate VideoData object. This intrinsically tells the
         186                 :   // player that it does not need to update the displayed frame when this
         187                 :   // frame is played; this frame is identical to the previous.
         188                 :   static VideoData* CreateDuplicate(PRInt64 aOffset,
         189                 :                                     PRInt64 aTime,
         190                 :                                     PRInt64 aEndTime,
         191                 :                                     PRInt64 aTimecode)
         192                 :   {
         193                 :     return new VideoData(aOffset, aTime, aEndTime, aTimecode);
         194                 :   }
         195                 :
         196               0 :   ~VideoData()
         197               0 :   {
         198               0 :     MOZ_COUNT_DTOR(VideoData);
         199               0 :   }
         200                 :
         201                 :   // Dimensions at which to display the video frame. The picture region
         202                 :   // will be scaled to this size. This is should be the picture region's
         203                 :   // dimensions scaled with respect to its aspect ratio.
         204                 :   nsIntSize mDisplay;
         205                 :
         206                 :   // Approximate byte offset of the end of the frame in the media.
         207                 :   PRInt64 mOffset;
         208                 :
         209                 :   // Start time of frame in microseconds.
         210                 :   PRInt64 mTime;
         211                 :
         212                 :   // End time of frame in microseconds.
         213                 :   PRInt64 mEndTime;
         214                 :
         215                 :   // Codec specific internal time code. For Ogg based codecs this is the
         216                 :   // granulepos.
         217                 :   PRInt64 mTimecode;
         218                 :
         219                 :   // This frame's image.
         220                 :   nsRefPtr<Image> mImage;
         221                 :
         222                 :   // When true, denotes that this frame is identical to the frame that
         223                 :   // came before; it's a duplicate. mBuffer will be empty.
         224                 :   bool mDuplicate;
         225                 :   bool mKeyframe;
         226                 :
         227                 : public:
         228                 :   VideoData(PRInt64 aOffset, PRInt64 aTime, PRInt64 aEndTime, PRInt64 aTimecode)
         229                 :     : mOffset(aOffset),
         230                 :       mTime(aTime),
         231                 :       mEndTime(aEndTime),
         232                 :       mTimecode(aTimecode),
         233                 :       mDuplicate(true),
         234                 :       mKeyframe(false)
         235                 :   {
         236                 :     MOZ_COUNT_CTOR(VideoData);
         237                 :     NS_ASSERTION(aEndTime >= aTime, "Frame must start before it ends.");
         238                 :   }
         239                 :
         240               0 :   VideoData(PRInt64 aOffset,
         241                 :             PRInt64 aTime,
         242                 :             PRInt64 aEndTime,
         243                 :             bool aKeyframe,
         244                 :             PRInt64 aTimecode,
         245                 :             nsIntSize aDisplay)
         246                 :     : mDisplay(aDisplay),
         247                 :       mOffset(aOffset),
         248                 :       mTime(aTime),
         249                 :       mEndTime(aEndTime),
         250                 :       mTimecode(aTimecode),
         251                 :       mDuplicate(false),
         252               0 :       mKeyframe(aKeyframe)
         253                 :   {
         254               0 :     MOZ_COUNT_CTOR(VideoData);
         255               0 :     NS_ASSERTION(aEndTime >= aTime, "Frame must start before it ends.");
         256               0 :   }
         257                 :
         258                 : };
         259                 :
         260                 : // Thread and type safe wrapper around nsDeque.
         261                 : template <class T>
         262               0 : class MediaQueueDeallocator : public nsDequeFunctor {
         263               0 :   virtual void* operator() (void* anObject) {
         264               0 :     delete static_cast<T*>(anObject);
         265               0 :     return nsnull;
         266                 :   }
         267                 : };
         268                 :
         269                 : template <class T> class MediaQueue : private nsDeque {
         270                 :  public:
         271                 :    typedef mozilla::ReentrantMonitorAutoEnter ReentrantMonitorAutoEnter;
         272                 :    typedef mozilla::ReentrantMonitor ReentrantMonitor;
         273                 :
         274               0 :    MediaQueue()
         275                 :      : nsDeque(new MediaQueueDeallocator<T>()),
         276                 :        mReentrantMonitor("mediaqueue"),
         277               0 :        mEndOfStream(0)
         278               0 :    {}
         279                 :
         280               0 :   ~MediaQueue() {
         281               0 :     Reset();
         282               0 :   }
         283                 :
         284               0 :   inline PRInt32 GetSize() {
         285               0 :     ReentrantMonitorAutoEnter mon(mReentrantMonitor);
         286               0 :     return nsDeque::GetSize();
         287                 :   }
         288                 :
         289                 :   inline void Push(T* aItem) {
         290                 :     ReentrantMonitorAutoEnter mon(mReentrantMonitor);
         291                 :     nsDeque::Push(aItem);
         292                 :   }
         293                 :
         294               0 :   inline void PushFront(T* aItem) {
         295               0 :     ReentrantMonitorAutoEnter mon(mReentrantMonitor);
         296               0 :     nsDeque::PushFront(aItem);
         297               0 :   }
         298                 :
         299                 :   inline T* Pop() {
         300                 :     ReentrantMonitorAutoEnter mon(mReentrantMonitor);
         301                 :     return static_cast<T*>(nsDeque::Pop());
         302                 :   }
         303                 :
         304               0 :   inline T* PopFront() {
         305               0 :     ReentrantMonitorAutoEnter mon(mReentrantMonitor);
         306               0 :     return static_cast<T*>(nsDeque::PopFront());
         307                 :   }
         308                 :
         309               0 :   inline T* Peek() {
         310               0 :     ReentrantMonitorAutoEnter mon(mReentrantMonitor);
         311               0 :     return static_cast<T*>(nsDeque::Peek());
         312                 :   }
         313                 :
         314               0 :   inline T* PeekFront() {
         315               0 :     ReentrantMonitorAutoEnter mon(mReentrantMonitor);
         316               0 :     return static_cast<T*>(nsDeque::PeekFront());
         317                 :   }
         318                 :
         319                 :   inline void Empty() {
         320                 :     ReentrantMonitorAutoEnter mon(mReentrantMonitor);
         321                 :     nsDeque::Empty();
         322                 :   }
         323                 :
         324                 :   inline void Erase() {
         325                 :     ReentrantMonitorAutoEnter mon(mReentrantMonitor);
         326                 :     nsDeque::Erase();
         327                 :   }
         328                 :
         329               0 :   void Reset() {
         330               0 :     ReentrantMonitorAutoEnter mon(mReentrantMonitor);
         331               0 :     while (GetSize() > 0) {
         332               0 :       T* x = PopFront();
         333               0 :       delete x;
         334                 :     }
         335               0 :     mEndOfStream = false;
         336               0 :   }
         337                 :
         338               0 :   bool AtEndOfStream() {
         339               0 :     ReentrantMonitorAutoEnter mon(mReentrantMonitor);
         340               0 :     return GetSize() == 0 && mEndOfStream;
         341                 :   }
         342                 :
         343                 :   // Returns true if the media queue has had it last item added to it.
         344                 :   // This happens when the media stream has been completely decoded. Note this
         345                 :   // does not mean that the corresponding stream has finished playback.
         346               0 :   bool IsFinished() {
         347               0 :     ReentrantMonitorAutoEnter mon(mReentrantMonitor);
         348               0 :     return mEndOfStream;
         349                 :   }
         350                 :
         351                 :   // Informs the media queue that it won't be receiving any more items.
         352                 :   void Finish() {
         353                 :     ReentrantMonitorAutoEnter mon(mReentrantMonitor);
         354                 :     mEndOfStream = true;
         355                 :   }
         356                 :
         357                 :   // Returns the approximate number of microseconds of items in the queue.
         358               0 :   PRInt64 Duration() {
         359               0 :     ReentrantMonitorAutoEnter mon(mReentrantMonitor);
         360               0 :     if (GetSize() < 2) {
         361               0 :       return 0;
         362                 :     }
         363               0 :     T* last = Peek();
         364               0 :     T* first = PeekFront();
         365               0 :     return last->mTime - first->mTime;
         366                 :   }
         367                 :
         368               0 :   void LockedForEach(nsDequeFunctor& aFunctor) const {
         369               0 :     ReentrantMonitorAutoEnter mon(mReentrantMonitor);
         370               0 :     ForEach(aFunctor);
         371               0 :   }
         372                 :
         373                 : private:
         374                 :   mutable ReentrantMonitor mReentrantMonitor;
         375                 :
         376                 :   // True when we've decoded the last frame of data in the
         377                 :   // bitstream for which we're queueing frame data.
         378                 :   bool mEndOfStream;
         379                 : };
         380                 :
         381                 : // Encapsulates the decoding and reading of media data. Reading can only be
         382                 : // done on the decode thread. Never hold the decoder monitor when
         383                 : // calling into this class. Unless otherwise specified, methods and fields of
         384                 : // this class can only be accessed on the decode thread.
         385                 : class nsBuiltinDecoderReader : public nsRunnable {
         386                 : public:
         387                 :   typedef mozilla::ReentrantMonitor ReentrantMonitor;
         388                 :   typedef mozilla::ReentrantMonitorAutoEnter ReentrantMonitorAutoEnter;
         389                 :   typedef mozilla::VideoFrameContainer VideoFrameContainer;
         390                 :
         391                 :   nsBuiltinDecoderReader(nsBuiltinDecoder* aDecoder);
         392                 :   ~nsBuiltinDecoderReader();
         393                 :
         394                 :   // Initializes the reader, returns NS_OK on success, or NS_ERROR_FAILURE
         395                 :   // on failure.
         396                 :   virtual nsresult Init(nsBuiltinDecoderReader* aCloneDonor) = 0;
         397                 :
         398                 :   // Resets all state related to decoding, emptying all buffers etc.
         399                 :   virtual nsresult ResetDecode();
         400                 :
         401                 :   // Decodes an unspecified amount of audio data, enqueuing the audio data
         402                 :   // in mAudioQueue. Returns true when there's more audio to decode,
         403                 :   // false if the audio is finished, end of file has been reached,
         404                 :   // or an un-recoverable read error has occured.
         405                 :   virtual bool DecodeAudioData() = 0;
         406                 :
         407                 :   // Reads and decodes one video frame. Packets with a timestamp less
         408                 :   // than aTimeThreshold will be decoded (unless they're not keyframes
         409                 :   // and aKeyframeSkip is true), but will not be added to the queue.
         410                 :   virtual bool DecodeVideoFrame(bool &aKeyframeSkip,
         411                 :                                   PRInt64 aTimeThreshold) = 0;
         412                 :
         413                 :   virtual bool HasAudio() = 0;
         414                 :   virtual bool HasVideo() = 0;
         415                 :
         416                 :   // Read header data for all bitstreams in the file. Fills mInfo with
         417                 :   // the data required to present the media. Returns NS_OK on success,
         418                 :   // or NS_ERROR_FAILURE on failure.
         419                 :   virtual nsresult ReadMetadata(nsVideoInfo* aInfo) = 0;
         420                 :
         421                 :   // Stores the presentation time of the first frame we'd be able to play if
         422                 :   // we started playback at the current position. Returns the first video
         423                 :   // frame, if we have video.
         424                 :   VideoData* FindStartTime(PRInt64& aOutStartTime);
         425                 :
         426                 :   // Moves the decode head to aTime microseconds. aStartTime and aEndTime
         427                 :   // denote the start and end times of the media in usecs, and aCurrentTime
         428                 :   // is the current playback position in microseconds.
         429                 :   virtual nsresult Seek(PRInt64 aTime,
         430                 :                         PRInt64 aStartTime,
         431                 :                         PRInt64 aEndTime,
         432                 :                         PRInt64 aCurrentTime) = 0;
         433                 :
         434                 :   // Queue of audio frames. This queue is threadsafe, and is accessed from
         435                 :   // the audio, decoder, state machine, and main threads.
         436                 :   MediaQueue<AudioData> mAudioQueue;
         437                 :
         438                 :   // Queue of video frames. This queue is threadsafe, and is accessed from
         439                 :   // the decoder, state machine, and main threads.
         440                 :   MediaQueue<VideoData> mVideoQueue;
         441                 :
         442                 :   // Populates aBuffered with the time ranges which are buffered. aStartTime
         443                 :   // must be the presentation time of the first frame in the media, e.g.
         444                 :   // the media time corresponding to playback time/position 0. This function
         445                 :   // should only be called on the main thread.
         446                 :   virtual nsresult GetBuffered(nsTimeRanges* aBuffered,
         447                 :                                PRInt64 aStartTime) = 0;
         448                 :
         449                 :   class VideoQueueMemoryFunctor : public nsDequeFunctor {
         450                 :   public:
         451               0 :     VideoQueueMemoryFunctor() : mResult(0) {}
         452                 :
         453               0 :     virtual void* operator()(void* anObject) {
         454               0 :       const VideoData* v = static_cast<const VideoData*>(anObject);
         455               0 :       if (!v->mImage) {
         456               0 :         return nsnull;
         457                 :       }
         458               0 :       NS_ASSERTION(v->mImage->GetFormat() == mozilla::layers::Image::PLANAR_YCBCR,
         459                 :                    "Wrong format?");
         460               0 :       mozilla::layers::PlanarYCbCrImage* vi = static_cast<mozilla::layers::PlanarYCbCrImage*>(v->mImage.get());
         461                 :
         462               0 :       mResult += vi->GetDataSize();
         463               0 :       return nsnull;
         464                 :     }
         465                 :
         466                 :     PRInt64 mResult;
         467                 :   };
         468                 :
         469               0 :   PRInt64 VideoQueueMemoryInUse() {
         470               0 :     VideoQueueMemoryFunctor functor;
         471               0 :     mVideoQueue.LockedForEach(functor);
         472               0 :     return functor.mResult;
         473                 :   }
         474                 :
         475                 :   class AudioQueueMemoryFunctor : public nsDequeFunctor {
         476                 :   public:
         477               0 :     AudioQueueMemoryFunctor() : mResult(0) {}
         478                 :
         479               0 :     virtual void* operator()(void* anObject) {
         480               0 :       const AudioData* audioData = static_cast<const AudioData*>(anObject);
         481               0 :       mResult += audioData->mFrames * audioData->mChannels * sizeof(AudioDataValue);
         482               0 :       return nsnull;
         483                 :     }
         484                 :
         485                 :     PRInt64 mResult;
         486                 :   };
         487                 :
         488               0 :   PRInt64 AudioQueueMemoryInUse() {
         489               0 :     AudioQueueMemoryFunctor functor;
         490               0 :     mAudioQueue.LockedForEach(functor);
         491               0 :     return functor.mResult;
         492                 :   }
         493                 :
         494                 :   // Only used by nsWebMReader for now, so stub here rather than in every
         495                 :   // reader than inherits from nsBuiltinDecoderReader.
         496               0 :   virtual void NotifyDataArrived(const char* aBuffer, PRUint32 aLength, PRInt64 aOffset) {}
         497                 :
         498                 : protected:
         499                 :
         500                 :   // Pumps the decode until we reach frames required to play at time aTarget
         501                 :   // (usecs).
         502                 :   nsresult DecodeToTarget(PRInt64 aTarget);
         503                 :
         504                 :   // Reader decode function. Matches DecodeVideoFrame() and
         505                 :   // DecodeAudioData().
         506                 :   typedef bool (nsBuiltinDecoderReader::*DecodeFn)();
         507                 :
         508                 :   // Calls aDecodeFn on *this until aQueue has an item, whereupon
         509                 :   // we return the first item.
         510                 :   template<class Data>
         511               0 :   Data* DecodeToFirstData(DecodeFn aDecodeFn,
         512                 :                           MediaQueue<Data>& aQueue);
         513                 :
         514                 :   // Wrapper so that DecodeVideoFrame(bool&,PRInt64) can be called from
         515                 :   // DecodeToFirstData().
         516               0 :   bool DecodeVideoFrame() {
         517               0 :     bool f = false;
         518               0 :     return DecodeVideoFrame(f, 0);
         519                 :   }
         520                 :
         521                 :   // Reference to the owning decoder object.
         522                 :   nsBuiltinDecoder* mDecoder;
         523                 :
         524                 :   // Stores presentation info required for playback.
         525                 :   nsVideoInfo mInfo;
         526                 : };
         527                 :
         528                 : #endif

Generated by: LCOV version 1.7