tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

HLSDemuxer.h (4135B)

      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 #if !defined(HLSDemuxer_h_)
      8 #  define HLSDemuxer_h_
      9 
     10 #  include "MediaCodec.h"
     11 #  include "MediaDataDemuxer.h"
     12 #  include "MediaDecoder.h"
     13 #  include "VideoUtils.h"
     14 #  include "mozilla/Maybe.h"
     15 #  include "mozilla/Mutex.h"
     16 #  include "mozilla/TaskQueue.h"
     17 #  include "mozilla/java/GeckoHLSDemuxerWrapperWrappers.h"
     18 #  include "mozilla/java/GeckoHLSSampleWrappers.h"
     19 
     20 namespace mozilla {
     21 
     22 class AbstractThread;
     23 class MediaResult;
     24 class HLSTrackDemuxer;
     25 
     26 DDLoggedTypeDeclNameAndBase(HLSDemuxer, MediaDataDemuxer);
     27 DDLoggedTypeNameAndBase(HLSTrackDemuxer, MediaTrackDemuxer);
     28 
     29 class HLSDemuxer final : public MediaDataDemuxer,
     30                         public DecoderDoctorLifeLogger<HLSDemuxer> {
     31  class HLSDemuxerCallbacksSupport;
     32 
     33 public:
     34  explicit HLSDemuxer(int aPlayerId);
     35 
     36  RefPtr<InitPromise> Init() override;
     37 
     38  uint32_t GetNumberTracks(TrackInfo::TrackType aType) const override;
     39 
     40  already_AddRefed<MediaTrackDemuxer> GetTrackDemuxer(
     41      TrackInfo::TrackType aType, uint32_t aTrackNumber) override;
     42 
     43  bool IsSeekable() const override;
     44 
     45  UniquePtr<EncryptionInfo> GetCrypto() override;
     46 
     47  bool ShouldComputeStartTime() const override { return true; }
     48 
     49  void NotifyDataArrived() override;
     50 
     51  TaskQueue* GetTaskQueue() const { return mTaskQueue; }
     52  void OnInitialized(bool aHasAudio, bool aHasVideo);
     53  void OnError(int aErrorCode);
     54 
     55 private:
     56  media::TimeUnit GetNextKeyFrameTime();
     57 
     58  bool OnTaskQueue() const;
     59  ~HLSDemuxer();
     60  friend class HLSTrackDemuxer;
     61 
     62  const RefPtr<TaskQueue> mTaskQueue;
     63  RefPtr<HLSTrackDemuxer> mAudioDemuxer;
     64  RefPtr<HLSTrackDemuxer> mVideoDemuxer;
     65 
     66  MozPromiseHolder<InitPromise> mInitPromise;
     67  RefPtr<HLSDemuxerCallbacksSupport> mCallbackSupport;
     68 
     69  java::GeckoHLSDemuxerWrapper::Callbacks::GlobalRef mJavaCallbacks;
     70  java::GeckoHLSDemuxerWrapper::GlobalRef mHLSDemuxerWrapper;
     71 };
     72 
     73 class HLSTrackDemuxer : public MediaTrackDemuxer,
     74                        public DecoderDoctorLifeLogger<HLSTrackDemuxer> {
     75 public:
     76  HLSTrackDemuxer(HLSDemuxer* aParent, TrackInfo::TrackType aType,
     77                  UniquePtr<TrackInfo> aTrackInfo);
     78  ~HLSTrackDemuxer();
     79  UniquePtr<TrackInfo> GetInfo() const override;
     80 
     81  RefPtr<SeekPromise> Seek(const media::TimeUnit& aTime) override;
     82 
     83  RefPtr<SamplesPromise> GetSamples(int32_t aNumSamples = 1) override;
     84 
     85  void UpdateMediaInfo(int index);
     86 
     87  void Reset() override;
     88 
     89  nsresult GetNextRandomAccessPoint(media::TimeUnit* aTime) override;
     90 
     91  RefPtr<SkipAccessPointPromise> SkipToNextRandomAccessPoint(
     92      const media::TimeUnit& aTimeThreshold) override;
     93 
     94  media::TimeIntervals GetBuffered() override;
     95 
     96  void BreakCycles() override;
     97 
     98  bool GetSamplesMayBlock() const override { return false; }
     99 
    100  bool IsTrackValid() const {
    101    MutexAutoLock lock(mMutex);
    102    return mTrackInfo->IsValid();
    103  }
    104 
    105 private:
    106  // Update the timestamp of the next keyframe if there's one.
    107  void UpdateNextKeyFrameTime();
    108 
    109  // Runs on HLSDemuxer's task queue.
    110  RefPtr<SeekPromise> DoSeek(const media::TimeUnit& aTime);
    111  RefPtr<SamplesPromise> DoGetSamples(int32_t aNumSamples);
    112  RefPtr<SkipAccessPointPromise> DoSkipToNextRandomAccessPoint(
    113      const media::TimeUnit& aTimeThreshold);
    114 
    115  CryptoSample ExtractCryptoSample(
    116      size_t aSampleSize,
    117      java::sdk::MediaCodec::CryptoInfo::LocalRef aCryptoInfo);
    118  RefPtr<MediaRawData> ConvertToMediaRawData(
    119      java::GeckoHLSSample::LocalRef aSample);
    120 
    121  RefPtr<HLSDemuxer> mParent;
    122  TrackInfo::TrackType mType;
    123  Maybe<media::TimeUnit> mNextKeyframeTime;
    124  int32_t mLastFormatIndex = -1;
    125  // Queued samples extracted by the demuxer, but not yet returned.
    126  RefPtr<MediaRawData> mQueuedSample;
    127 
    128  // Mutex to protect members below across multiple threads.
    129  mutable Mutex mMutex MOZ_UNANNOTATED;
    130  UniquePtr<TrackInfo> mTrackInfo;
    131 };
    132 
    133 }  // namespace mozilla
    134 
    135 #endif