author Timothy Guan-tin Chien <>
Mon, 07 Jan 2019 16:00:55 +0000
changeset 506594 2046aa36055220d9187f968fca3ab070d2de7665
parent 503396 0ceae9db9ec0be18daa1a279511ad305723185d4
child 511623 5f4630838d46dd81dadb13220a4af0da9e23a619
permissions -rw-r--r--
Bug 1516292 - Use isSameNode() to compare mozFullScreenElement and the video host element. r=edgar, a=RyanVM This does what's done in bug 1505547 but in a different way. For some reason, access in the function can trigger an assertion. is a Proxy so it cannot be compared, but all its methods are proxied. Differential Revision:

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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 */

#if !defined(MediaDataDemuxer_h)
#define MediaDataDemuxer_h

#include "DecoderDoctorLogger.h"
#include "mozilla/MozPromise.h"
#include "mozilla/UniquePtr.h"

#include "MediaData.h"
#include "MediaInfo.h"
#include "MediaResult.h"
#include "TimeUnits.h"
#include "nsISupportsImpl.h"
#include "mozilla/RefPtr.h"
#include "nsTArray.h"

namespace mozilla {

class MediaTrackDemuxer;
class TrackMetadataHolder;


// Allows reading the media data: to retrieve the metadata and demux samples.
// MediaDataDemuxer isn't designed to be thread safe.
// When used by the MediaFormatDecoder, care is taken to ensure that the demuxer
// will never be called from more than one thread at once.
class MediaDataDemuxer : public DecoderDoctorLifeLogger<MediaDataDemuxer> {

  typedef MozPromise<MediaResult, MediaResult, /* IsExclusive = */ true>

  // Initializes the demuxer. Other methods cannot be called unless
  // initialization has completed and succeeded.
  // Typically a demuxer will wait to parse the metadata before resolving the
  // promise. The promise must not be resolved until sufficient data is
  // supplied. For example, an incomplete metadata would cause the promise to be
  // rejected should no more data be coming, while the demuxer would wait
  // otherwise.
  virtual RefPtr<InitPromise> Init() = 0;

  // Returns the number of tracks of aType type available. A value of
  // 0 indicates that no such type is available.
  virtual uint32_t GetNumberTracks(TrackInfo::TrackType aType) const = 0;

  // Returns the MediaTrackDemuxer associated with aTrackNumber aType track.
  // aTrackNumber is not to be confused with the Track ID.
  // aTrackNumber must be constrained between  0 and  GetNumberTracks(aType) - 1
  // The actual Track ID is to be retrieved by calling
  // MediaTrackDemuxer::TrackInfo.
  virtual already_AddRefed<MediaTrackDemuxer> GetTrackDemuxer(
      TrackInfo::TrackType aType, uint32_t aTrackNumber) = 0;

  // Returns true if the underlying resource allows seeking.
  virtual bool IsSeekable() const = 0;

  // Returns true if the underlying resource can only seek within buffered
  // ranges.
  virtual bool IsSeekableOnlyInBufferedRanges() const { return false; }

  // Returns the media's crypto information, or nullptr if media isn't
  // encrypted.
  virtual UniquePtr<EncryptionInfo> GetCrypto() { return nullptr; }

  // Notifies the demuxer that the underlying resource has received more data
  // since the demuxer was initialized.
  // The demuxer can use this mechanism to inform all track demuxers that new
  // data is available and to refresh its buffered range.
  virtual void NotifyDataArrived() {}

  // Notifies the demuxer that the underlying resource has had data removed
  // since the demuxer was initialized.
  // The demuxer can use this mechanism to inform all track demuxers to update
  // its buffered range.
  // This will be called should the demuxer be used with MediaSource.
  virtual void NotifyDataRemoved() {}

  // Indicate to MediaFormatReader if it should compute the start time
  // of the demuxed data. If true (default) the first sample returned will be
  // used as reference time base.
  virtual bool ShouldComputeStartTime() const { return true; }

  virtual ~MediaDataDemuxer() {}

class MediaTrackDemuxer : public DecoderDoctorLifeLogger<MediaTrackDemuxer> {

  class SamplesHolder {
    nsTArray<RefPtr<MediaRawData>> mSamples;

    ~SamplesHolder() {}

  class SkipFailureHolder {
    SkipFailureHolder(const MediaResult& aFailure, uint32_t aSkipped)
        : mFailure(aFailure), mSkipped(aSkipped) {}
    MediaResult mFailure;
    uint32_t mSkipped;

  typedef MozPromise<media::TimeUnit, MediaResult, /* IsExclusive = */ true>
  typedef MozPromise<RefPtr<SamplesHolder>, MediaResult,
                     /* IsExclusive = */ true>
  typedef MozPromise<uint32_t, SkipFailureHolder, /* IsExclusive = */ true>

  // Returns the TrackInfo (a.k.a Track Description) for this track.
  // The TrackInfo returned will be:
  // TrackInfo::kVideoTrack -> VideoInfo.
  // TrackInfo::kAudioTrack -> AudioInfo.
  // respectively.
  virtual UniquePtr<TrackInfo> GetInfo() const = 0;

  // Seeks to aTime. Upon success, SeekPromise will be resolved with the
  // actual time seeked to. Typically the random access point time
  virtual RefPtr<SeekPromise> Seek(const media::TimeUnit& aTime) = 0;

  // Returns the next aNumSamples sample(s) available.
  // If only a lesser amount of samples is available, only those will be
  // returned.
  // A aNumSamples value of -1 indicates to return all remaining samples.
  // A video sample is typically made of a single video frame while an audio
  // sample will contains multiple audio frames.
  virtual RefPtr<SamplesPromise> GetSamples(int32_t aNumSamples = 1) = 0;

  // Returns true if a call to GetSamples() may block while waiting on the
  // underlying resource to return the data.
  // This is used by the MediaFormatReader to determine if buffering heuristics
  // should be used.
  virtual bool GetSamplesMayBlock() const { return true; }

  // Cancel all pending actions (Seek, GetSamples) and reset current state
  // All pending promises are to be rejected with CANCEL.
  // The next call to GetSamples would return the first sample available in the
  // track.
  virtual void Reset() = 0;

  // Returns timestamp of next random access point or an error if the demuxer
  // can't report this.
  virtual nsresult GetNextRandomAccessPoint(media::TimeUnit* aTime) {

  // Returns timestamp of previous random access point or an error if the
  // demuxer can't report this.
  virtual nsresult GetPreviousRandomAccessPoint(media::TimeUnit* aTime) {

  // Skip frames until the next Random Access Point located after
  // aTimeThreshold.
  // The first frame returned by the next call to GetSamples() will be the
  // first random access point found after aTimeThreshold.
  // Upon success, returns the number of frames skipped.
  virtual RefPtr<SkipAccessPointPromise> SkipToNextRandomAccessPoint(
      const media::TimeUnit& aTimeThreshold) = 0;

  // Gets the resource's offset used for the last Seek() or GetSample().
  // A negative value indicates that this functionality isn't supported.
  virtual int64_t GetResourceOffset() const { return -1; }

  virtual TrackInfo::TrackType GetType() const { return GetInfo()->GetType(); }

  virtual media::TimeIntervals GetBuffered() = 0;

  // By default, it is assumed that the entire resource can be evicted once
  // all samples have been demuxed.
  virtual int64_t GetEvictionOffset(const media::TimeUnit& aTime) {
    return INT64_MAX;

  // If the MediaTrackDemuxer and MediaDataDemuxer hold cross references.
  // BreakCycles must be overridden.
  virtual void BreakCycles() {}

  virtual ~MediaTrackDemuxer() {}

}  // namespace mozilla

#endif  // MediaDataDemuxer_h