Line data    Source code

       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             : /* This Source Code Form is subject to the terms of the Mozilla Public
       4             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       5             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
       6             : 
       7             : #ifndef mozilla_H264Converter_h
       8             : #define mozilla_H264Converter_h
       9             : 
      10             : #include "PlatformDecoderModule.h"
      11             : #include "mozilla/Maybe.h"
      12             : 
      13             : namespace mozilla {
      14             : 
      15             : class DecoderDoctorDiagnostics;
      16             : 
      17             : // H264Converter is a MediaDataDecoder wrapper used to ensure that
      18             : // only AVCC or AnnexB is fed to the underlying MediaDataDecoder.
      19             : // The H264Converter allows playback of content where the SPS NAL may not be
      20             : // provided in the init segment (e.g. AVC3 or Annex B)
      21             : // H264Converter will monitor the input data, and will delay creation of the
      22             : // MediaDataDecoder until a SPS and PPS NALs have been extracted.
      23             : 
      24             : class H264Converter : public MediaDataDecoder
      25             : {
      26             : public:
      27             : 
      28             :   H264Converter(PlatformDecoderModule* aPDM,
      29             :                 const CreateDecoderParams& aParams);
      30             :   virtual ~H264Converter();
      31             : 
      32             :   RefPtr<InitPromise> Init() override;
      33             :   RefPtr<DecodePromise> Decode(MediaRawData* aSample) override;
      34             :   RefPtr<DecodePromise> Drain() override;
      35             :   RefPtr<FlushPromise> Flush() override;
      36             :   RefPtr<ShutdownPromise> Shutdown() override;
      37             :   bool IsHardwareAccelerated(nsACString& aFailureReason) const override;
      38           0 :   const char* GetDescriptionName() const override
      39             :   {
      40           0 :     if (mDecoder) {
      41           0 :       return mDecoder->GetDescriptionName();
      42             :     }
      43           0 :     return "H264Converter decoder (pending)";
      44             :   }
      45             :   void SetSeekThreshold(const media::TimeUnit& aTime) override;
      46           0 :   bool SupportDecoderRecycling() const override
      47             :   {
      48           0 :     if (mDecoder) {
      49           0 :       return mDecoder->SupportDecoderRecycling();
      50             :     }
      51           0 :     return false;
      52             :   }
      53             : 
      54           0 :   ConversionRequired NeedsConversion() const override
      55             :   {
      56           0 :     if (mDecoder) {
      57           0 :       return mDecoder->NeedsConversion();
      58             :     }
      59             :     // Default so no conversion is performed.
      60           0 :     return ConversionRequired::kNeedAVCC;
      61             :   }
      62           0 :   nsresult GetLastError() const { return mLastError; }
      63             : 
      64             : private:
      65             :   // Will create the required MediaDataDecoder if need AVCC and we have a SPS NAL.
      66             :   // Returns NS_ERROR_FAILURE if error is permanent and can't be recovered and
      67             :   // will set mError accordingly.
      68             :   nsresult CreateDecoder(const VideoInfo& aConfig,
      69             :                          DecoderDoctorDiagnostics* aDiagnostics);
      70             :   nsresult CreateDecoderAndInit(MediaRawData* aSample);
      71             :   nsresult CheckForSPSChange(MediaRawData* aSample);
      72             :   void UpdateConfigFromExtraData(MediaByteBuffer* aExtraData);
      73             : 
      74             :   bool CanRecycleDecoder() const;
      75             : 
      76             :   void DecodeFirstSample(MediaRawData* aSample);
      77             :   void DrainThenFlushDecoder(MediaRawData* aPendingSample);
      78             :   void FlushThenShutdownDecoder(MediaRawData* aPendingSample);
      79             :   RefPtr<ShutdownPromise> ShutdownDecoder();
      80             : 
      81             :   RefPtr<PlatformDecoderModule> mPDM;
      82             :   const VideoInfo mOriginalConfig;
      83             :   VideoInfo mCurrentConfig;
      84             :   // Current out of band extra data (as found in metadata's VideoInfo).
      85             :   RefPtr<MediaByteBuffer> mOriginalExtraData;
      86             :   RefPtr<layers::KnowsCompositor> mKnowsCompositor;
      87             :   RefPtr<layers::ImageContainer> mImageContainer;
      88             :   const RefPtr<TaskQueue> mTaskQueue;
      89             :   RefPtr<MediaDataDecoder> mDecoder;
      90             :   MozPromiseRequestHolder<InitPromise> mInitPromiseRequest;
      91             :   MozPromiseRequestHolder<DecodePromise> mDecodePromiseRequest;
      92             :   MozPromiseHolder<DecodePromise> mDecodePromise;
      93             :   MozPromiseRequestHolder<FlushPromise> mFlushRequest;
      94             :   MediaDataDecoder::DecodedData mPendingFrames;
      95             :   MozPromiseRequestHolder<DecodePromise> mDrainRequest;
      96             :   MozPromiseRequestHolder<ShutdownPromise> mShutdownRequest;
      97             :   RefPtr<ShutdownPromise> mShutdownPromise;
      98             :   MozPromiseHolder<FlushPromise> mFlushPromise;
      99             : 
     100             :   RefPtr<GMPCrashHelper> mGMPCrashHelper;
     101             :   Maybe<bool> mNeedAVCC;
     102             :   nsresult mLastError;
     103             :   bool mNeedKeyframe = true;
     104             :   const TrackInfo::TrackType mType;
     105             :   MediaEventProducer<TrackInfo::TrackType>* const mOnWaitingForKeyEvent;
     106             :   const CreateDecoderParams::OptionSet mDecoderOptions;
     107             :   Maybe<bool> mCanRecycleDecoder;
     108             : };
     109             : 
     110             : } // namespace mozilla
     111             : 
     112             : #endif // mozilla_H264Converter_h