Home | History | Annotate | Download | only in filters 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef MEDIA_FILTERS_FRAME_PROCESSOR_BASE_H_
      6 #define MEDIA_FILTERS_FRAME_PROCESSOR_BASE_H_
      7 
      8 #include <map>
      9 
     10 #include "base/basictypes.h"
     11 #include "base/time/time.h"
     12 #include "media/base/media_export.h"
     13 #include "media/base/stream_parser.h"
     14 #include "media/filters/chunk_demuxer.h"
     15 
     16 namespace media {
     17 
     18 // Helper class to capture per-track details needed by a frame processor. Some
     19 // of this information may be duplicated in the short-term in the associated
     20 // ChunkDemuxerStream and SourceBufferStream for a track.
     21 // This parallels the MSE spec each of a SourceBuffer's Track Buffers at
     22 // http://www.w3.org/TR/media-source/#track-buffers.
     23 class MseTrackBuffer {
     24  public:
     25   explicit MseTrackBuffer(ChunkDemuxerStream* stream);
     26   ~MseTrackBuffer();
     27 
     28   // Get/set |last_decode_timestamp_|.
     29   base::TimeDelta last_decode_timestamp() const {
     30     return last_decode_timestamp_;
     31   }
     32   void set_last_decode_timestamp(base::TimeDelta timestamp) {
     33     last_decode_timestamp_ = timestamp;
     34   }
     35 
     36   // Get/set |last_frame_duration_|.
     37   base::TimeDelta last_frame_duration() const {
     38     return last_frame_duration_;
     39   }
     40   void set_last_frame_duration(base::TimeDelta duration) {
     41     last_frame_duration_ = duration;
     42   }
     43 
     44   // Gets |highest_presentation_timestamp_|.
     45   base::TimeDelta highest_presentation_timestamp() const {
     46     return highest_presentation_timestamp_;
     47   }
     48 
     49   // Get/set |needs_random_access_point_|.
     50   bool needs_random_access_point() const {
     51     return needs_random_access_point_;
     52   }
     53   void set_needs_random_access_point(bool needs_random_access_point) {
     54     needs_random_access_point_ = needs_random_access_point;
     55   }
     56 
     57   // Gets a pointer to this track's ChunkDemuxerStream.
     58   ChunkDemuxerStream* stream() const { return stream_; }
     59 
     60   // Unsets |last_decode_timestamp_|, unsets |last_frame_duration_|,
     61   // unsets |highest_presentation_timestamp_|, and sets
     62   // |needs_random_access_point_| to true.
     63   void Reset();
     64 
     65   // If |highest_presentation_timestamp_| is unset or |timestamp| is greater
     66   // than |highest_presentation_timestamp_|, sets
     67   // |highest_presentation_timestamp_| to |timestamp|. Note that bidirectional
     68   // prediction between coded frames can cause |timestamp| to not be
     69   // monotonically increasing even though the decode timestamps are
     70   // monotonically increasing.
     71   void SetHighestPresentationTimestampIfIncreased(base::TimeDelta timestamp);
     72 
     73  private:
     74   // The decode timestamp of the last coded frame appended in the current coded
     75   // frame group. Initially kNoTimestamp(), meaning "unset".
     76   base::TimeDelta last_decode_timestamp_;
     77 
     78   // The coded frame duration of the last coded frame appended in the current
     79   // coded frame group. Initially kNoTimestamp(), meaning "unset".
     80   base::TimeDelta last_frame_duration_;
     81 
     82   // The highest presentation timestamp encountered in a coded frame appended
     83   // in the current coded frame group. Initially kNoTimestamp(), meaning
     84   // "unset".
     85   base::TimeDelta highest_presentation_timestamp_;
     86 
     87   // Keeps track of whether the track buffer is waiting for a random access
     88   // point coded frame. Initially set to true to indicate that a random access
     89   // point coded frame is needed before anything can be added to the track
     90   // buffer.
     91   bool needs_random_access_point_;
     92 
     93   // Pointer to the stream associated with this track. The stream is not owned
     94   // by |this|.
     95   ChunkDemuxerStream* const stream_;
     96 
     97   DISALLOW_COPY_AND_ASSIGN(MseTrackBuffer);
     98 };
     99 
    100 // Abstract interface for helper class implementation of Media Source
    101 // Extension's coded frame processing algorithm.
    102 // TODO(wolenetz): Once the new FrameProcessor implementation stabilizes, remove
    103 // LegacyFrameProcessor and fold this interface into FrameProcessor. See
    104 // http://crbug.com/249422.
    105 class MEDIA_EXPORT FrameProcessorBase {
    106  public:
    107   // TODO(wolenetz/acolwell): Ensure that all TrackIds are coherent and unique
    108   // for each track buffer. For now, special track identifiers are used for each
    109   // of audio and video here, and text TrackIds are assumed to be non-negative.
    110   // See http://crbug.com/341581.
    111   enum {
    112     kAudioTrackId = -2,
    113     kVideoTrackId = -3
    114   };
    115 
    116   virtual ~FrameProcessorBase();
    117 
    118   // Get/set the current append mode, which if true means "sequence" and if
    119   // false means "segments".
    120   // See http://www.w3.org/TR/media-source/#widl-SourceBuffer-mode.
    121   bool sequence_mode() { return sequence_mode_; }
    122   virtual void SetSequenceMode(bool sequence_mode) = 0;
    123 
    124   // Processes buffers in |audio_buffers|, |video_buffers|, and |text_map|.
    125   // Returns true on success or false on failure which indicates decode error.
    126   // |append_window_start| and |append_window_end| correspond to the MSE spec's
    127   // similarly named source buffer attributes that are used in coded frame
    128   // processing.
    129   // |*new_media_segment| tracks whether the next buffers processed within the
    130   // append window represent the start of a new media segment. This method may
    131   // both use and update this flag.
    132   // Uses |*timestamp_offset| according to the coded frame processing algorithm,
    133   // including updating it as required in 'sequence' mode frame processing.
    134   virtual bool ProcessFrames(const StreamParser::BufferQueue& audio_buffers,
    135                              const StreamParser::BufferQueue& video_buffers,
    136                              const StreamParser::TextBufferQueueMap& text_map,
    137                              base::TimeDelta append_window_start,
    138                              base::TimeDelta append_window_end,
    139                              bool* new_media_segment,
    140                              base::TimeDelta* timestamp_offset) = 0;
    141 
    142   // Signals the frame processor to update its group start timestamp to be
    143   // |timestamp_offset| if it is in sequence append mode.
    144   void SetGroupStartTimestampIfInSequenceMode(base::TimeDelta timestamp_offset);
    145 
    146   // Adds a new track with unique track ID |id|.
    147   // If |id| has previously been added, returns false to indicate error.
    148   // Otherwise, returns true, indicating future ProcessFrames() will emit
    149   // frames for the track |id| to |stream|.
    150   bool AddTrack(StreamParser::TrackId id, ChunkDemuxerStream* stream);
    151 
    152   // Updates the internal mapping of TrackId to track buffer for the track
    153   // buffer formerly associated with |old_id| to be associated with |new_id|.
    154   // Returns false to indicate failure due to either no existing track buffer
    155   // for |old_id| or collision with previous track buffer already mapped to
    156   // |new_id|. Otherwise returns true.
    157   bool UpdateTrack(StreamParser::TrackId old_id, StreamParser::TrackId new_id);
    158 
    159   // Sets the need random access point flag on all track buffers to true.
    160   void SetAllTrackBuffersNeedRandomAccessPoint();
    161 
    162   // Resets state for the coded frame processing algorithm as described in steps
    163   // 2-5 of the MSE Reset Parser State algorithm described at
    164   // http://www.w3.org/TR/media-source/#sourcebuffer-reset-parser-state
    165   void Reset();
    166 
    167   // Must be called when the audio config is updated.  Used to manage when
    168   // the preroll buffer is cleared and the allowed "fudge" factor between
    169   // preroll buffers.
    170   void OnPossibleAudioConfigUpdate(const AudioDecoderConfig& config);
    171 
    172  protected:
    173   typedef std::map<StreamParser::TrackId, MseTrackBuffer*> TrackBufferMap;
    174 
    175   FrameProcessorBase();
    176 
    177   // If |track_buffers_| contains |id|, returns a pointer to the associated
    178   // MseTrackBuffer. Otherwise, returns NULL.
    179   MseTrackBuffer* FindTrack(StreamParser::TrackId id);
    180 
    181   // Signals all track buffers' streams that a new media segment is starting
    182   // with timestamp |segment_timestamp|.
    183   void NotifyNewMediaSegmentStarting(base::TimeDelta segment_timestamp);
    184 
    185   // Handles partial append window trimming of |buffer|.  Returns true if the
    186   // given |buffer| can be partially trimmed or have preroll added; otherwise,
    187   // returns false.
    188   //
    189   // If |buffer| overlaps |append_window_start|, the portion of |buffer| before
    190   // |append_window_start| will be marked for post-decode discard.  Further, if
    191   // |audio_preroll_buffer_| exists and abuts |buffer|, it will be set as
    192   // preroll on |buffer| and |audio_preroll_buffer_| will be cleared.  If the
    193   // preroll buffer does not abut |buffer|, it will be discarded, but not used.
    194   //
    195   // If |buffer| lies entirely before |append_window_start|, and thus would
    196   // normally be discarded, |audio_preroll_buffer_| will be set to |buffer| and
    197   // the method will return false.
    198   bool HandlePartialAppendWindowTrimming(
    199       base::TimeDelta append_window_start,
    200       base::TimeDelta append_window_end,
    201       const scoped_refptr<StreamParserBuffer>& buffer);
    202 
    203   // The AppendMode of the associated SourceBuffer.
    204   // See SetSequenceMode() for interpretation of |sequence_mode_|.
    205   // Per http://www.w3.org/TR/media-source/#widl-SourceBuffer-mode:
    206   // Controls how a sequence of media segments are handled. This is initially
    207   // set to false ("segments").
    208   bool sequence_mode_;
    209 
    210   // TrackId-indexed map of each track's stream.
    211   TrackBufferMap track_buffers_;
    212 
    213   // Tracks the MSE coded frame processing variable of same name.
    214   // Initially kNoTimestamp(), meaning "unset".
    215   // Note: LegacyFrameProcessor does not use this member; it's here to reduce
    216   // short-term plumbing of SetGroupStartTimestampIfInSequenceMode() until
    217   // LegacyFrameProcessor is removed.
    218   base::TimeDelta group_start_timestamp_;
    219 
    220  private:
    221   // The last audio buffer seen by the frame processor that was removed because
    222   // it was entirely before the start of the append window.
    223   scoped_refptr<StreamParserBuffer> audio_preroll_buffer_;
    224 
    225   // The AudioDecoderConfig associated with buffers handed to ProcessFrames().
    226   AudioDecoderConfig current_audio_config_;
    227   base::TimeDelta sample_duration_;
    228 
    229   DISALLOW_COPY_AND_ASSIGN(FrameProcessorBase);
    230 };
    231 
    232 }  // namespace media
    233 
    234 #endif  // MEDIA_FILTERS_FRAME_PROCESSOR_BASE_H_
    235