DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Implementation

Mercurial (d96ee8115c5a)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-*/
/* 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/. */

#ifndef MOZILLA_TRACKUNIONSTREAM_H_
#define MOZILLA_TRACKUNIONSTREAM_H_

#include "MediaStreamGraph.h"
#include "nsAutoPtr.h"
#include <algorithm>

namespace mozilla {

/**
 * See MediaStreamGraph::CreateTrackUnionStream.
 */
class TrackUnionStream : public ProcessedMediaStream {
 public:
  explicit TrackUnionStream();

  virtual TrackUnionStream* AsTrackUnionStream() override { return this; }
  friend class DOMMediaStream;

  void RemoveInput(MediaInputPort* aPort) override;
  void ProcessInput(GraphTime aFrom, GraphTime aTo, uint32_t aFlags) override;

  void SetTrackEnabledImpl(TrackID aTrackID, DisabledTrackMode aMode) override;

  MediaStream* GetInputStreamFor(TrackID aTrackID) override;
  TrackID GetInputTrackIDFor(TrackID aTrackID) override;

  friend class MediaStreamGraphImpl;

 protected:
  // Only non-ended tracks are allowed to persist in this map.
  struct TrackMapEntry {
    // mEndOfConsumedInputTicks is the end of the input ticks that we've
    // consumed. 0 if we haven't consumed any yet.
    StreamTime mEndOfConsumedInputTicks;
    // mEndOfLastInputIntervalInInputStream is the timestamp for the end of the
    // previous interval which was unblocked for both the input and output
    // stream, in the input stream's timeline, or -1 if there wasn't one.
    StreamTime mEndOfLastInputIntervalInInputStream;
    // mEndOfLastInputIntervalInOutputStream is the timestamp for the end of the
    // previous interval which was unblocked for both the input and output
    // stream, in the output stream's timeline, or -1 if there wasn't one.
    StreamTime mEndOfLastInputIntervalInOutputStream;
    MediaInputPort* mInputPort;
    // We keep track IDs instead of track pointers because
    // tracks can be removed without us being notified (e.g.
    // when a finished track is forgotten.) When we need a Track*,
    // we call StreamTracks::FindTrack, which will return null if
    // the track has been deleted.
    TrackID mInputTrackID;
    TrackID mOutputTrackID;
    nsAutoPtr<MediaSegment> mSegment;
    // These are direct track listeners that have been added to this
    // TrackUnionStream-track and forwarded to the input track. We will update
    // these when this track's disabled status changes.
    nsTArray<RefPtr<DirectMediaStreamTrackListener>> mOwnedDirectListeners;
  };

  // Add the track to this stream, retaining its TrackID if it has never
  // been previously used in this stream, allocating a new TrackID otherwise.
  uint32_t AddTrack(MediaInputPort* aPort, StreamTracks::Track* aTrack,
                    GraphTime aFrom);
  void EndTrack(uint32_t aIndex);
  void CopyTrackData(StreamTracks::Track* aInputTrack, uint32_t aMapIndex,
                     GraphTime aFrom, GraphTime aTo,
                     bool* aOutputTrackFinished);

  void AddDirectTrackListenerImpl(
      already_AddRefed<DirectMediaStreamTrackListener> aListener,
      TrackID aTrackID) override;
  void RemoveDirectTrackListenerImpl(DirectMediaStreamTrackListener* aListener,
                                     TrackID aTrackID) override;
  void RemoveAllDirectListenersImpl() override;

  nsTArray<TrackMapEntry> mTrackMap;

  // The next available TrackID, starting at 1 and progressing upwards.
  // All TrackIDs in [1, mNextAvailableTrackID) have implicitly been used.
  TrackID mNextAvailableTrackID;

  // Sorted array of used TrackIDs that require manual tracking.
  nsTArray<TrackID> mUsedTracks;

  // Direct track listeners that have not been forwarded to their input stream
  // yet. We'll forward these as their inputs become available.
  nsTArray<TrackBound<DirectMediaStreamTrackListener>>
      mPendingDirectTrackListeners;
};

}  // namespace mozilla

#endif /* MOZILLA_MEDIASTREAMGRAPH_H_ */