media/filters/frame_processor.h

   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_H_
   6 #define MEDIA_FILTERS_FRAME_PROCESSOR_H_
   7
   8 #include <map>
   9
  10 #include "base/basictypes.h"
  11 #include "base/callback_forward.h"
  12 #include "base/time/time.h"
  13 #include "media/base/media_export.h"
  14 #include "media/base/stream_parser.h"
  15 #include "media/filters/chunk_demuxer.h"
  16
  17 namespace media {
  18
  19 class MseTrackBuffer;
  20
  21 // Helper class that implements Media Source Extension's coded frame processing
  22 // algorithm.
  23 class MEDIA_EXPORT FrameProcessor {
  24  public:
  25   typedef base::Callback<void(base::TimeDelta)> UpdateDurationCB;
  26
  27   // TODO(wolenetz/acolwell): Ensure that all TrackIds are coherent and unique
  28   // for each track buffer. For now, special track identifiers are used for each
  29   // of audio and video here, and text TrackIds are assumed to be non-negative.
  30   // See http://crbug.com/341581.
  31   enum {
  32     kAudioTrackId = -2,
  33     kVideoTrackId = -3
  34   };
  35
  36   explicit FrameProcessor(const UpdateDurationCB& update_duration_cb);
  37   ~FrameProcessor();
  38
  39   // Get/set the current append mode, which if true means "sequence" and if
  40   // false means "segments".
  41   // See http://www.w3.org/TR/media-source/#widl-SourceBuffer-mode.
  42   bool sequence_mode() { return sequence_mode_; }
  43   void SetSequenceMode(bool sequence_mode);
  44
  45   // Processes buffers in |audio_buffers|, |video_buffers|, and |text_map|.
  46   // Returns true on success or false on failure which indicates decode error.
  47   // |append_window_start| and |append_window_end| correspond to the MSE spec's
  48   // similarly named source buffer attributes that are used in coded frame
  49   // processing.
  50   // |*new_media_segment| tracks whether the next buffers processed within the
  51   // append window represent the start of a new media segment. This method may
  52   // both use and update this flag.
  53   // Uses |*timestamp_offset| according to the coded frame processing algorithm,
  54   // including updating it as required in 'sequence' mode frame processing.
  55   bool ProcessFrames(const StreamParser::BufferQueue& audio_buffers,
  56                      const StreamParser::BufferQueue& video_buffers,
  57                      const StreamParser::TextBufferQueueMap& text_map,
  58                      base::TimeDelta append_window_start,
  59                      base::TimeDelta append_window_end,
  60                      bool* new_media_segment,
  61                      base::TimeDelta* timestamp_offset);
  62
  63   // Signals the frame processor to update its group start timestamp to be
  64   // |timestamp_offset| if it is in sequence append mode.
  65   void SetGroupStartTimestampIfInSequenceMode(base::TimeDelta timestamp_offset);
  66
  67   // Adds a new track with unique track ID |id|.
  68   // If |id| has previously been added, returns false to indicate error.
  69   // Otherwise, returns true, indicating future ProcessFrames() will emit
  70   // frames for the track |id| to |stream|.
  71   bool AddTrack(StreamParser::TrackId id, ChunkDemuxerStream* stream);
  72
  73   // Updates the internal mapping of TrackId to track buffer for the track
  74   // buffer formerly associated with |old_id| to be associated with |new_id|.
  75   // Returns false to indicate failure due to either no existing track buffer
  76   // for |old_id| or collision with previous track buffer already mapped to
  77   // |new_id|. Otherwise returns true.
  78   bool UpdateTrack(StreamParser::TrackId old_id, StreamParser::TrackId new_id);
  79
  80   // Sets the need random access point flag on all track buffers to true.
  81   void SetAllTrackBuffersNeedRandomAccessPoint();
  82
  83   // Resets state for the coded frame processing algorithm as described in steps
  84   // 2-5 of the MSE Reset Parser State algorithm described at
  85   // http://www.w3.org/TR/media-source/#sourcebuffer-reset-parser-state
  86   void Reset();
  87
  88   // Must be called when the audio config is updated.  Used to manage when
  89   // the preroll buffer is cleared and the allowed "fudge" factor between
  90   // preroll buffers.
  91   void OnPossibleAudioConfigUpdate(const AudioDecoderConfig& config);
  92
  93  private:
  94   typedef std::map<StreamParser::TrackId, MseTrackBuffer*> TrackBufferMap;
  95
  96   // If |track_buffers_| contains |id|, returns a pointer to the associated
  97   // MseTrackBuffer. Otherwise, returns NULL.
  98   MseTrackBuffer* FindTrack(StreamParser::TrackId id);
  99
 100   // Signals all track buffers' streams that a new media segment is starting
 101   // with decode timestamp |segment_timestamp|.
 102   void NotifyNewMediaSegmentStarting(DecodeTimestamp segment_timestamp);
 103
 104   // Helper that signals each track buffer to append any processed, but not yet
 105   // appended, frames to its stream. Returns true on success, or false if one or
 106   // more of the appends failed.
 107   bool FlushProcessedFrames();
 108
 109   // Handles partial append window trimming of |buffer|.  Returns true if the
 110   // given |buffer| can be partially trimmed or have preroll added; otherwise,
 111   // returns false.
 112   //
 113   // If |buffer| overlaps |append_window_start|, the portion of |buffer| before
 114   // |append_window_start| will be marked for post-decode discard.  Further, if
 115   // |audio_preroll_buffer_| exists and abuts |buffer|, it will be set as
 116   // preroll on |buffer| and |audio_preroll_buffer_| will be cleared.  If the
 117   // preroll buffer does not abut |buffer|, it will be discarded unused.
 118   //
 119   // Likewise, if |buffer| overlaps |append_window_end|, the portion of |buffer|
 120   // after |append_window_end| will be marked for post-decode discard.
 121   //
 122   // If |buffer| lies entirely before |append_window_start|, and thus would
 123   // normally be discarded, |audio_preroll_buffer_| will be set to |buffer| and
 124   // the method will return false.
 125   bool HandlePartialAppendWindowTrimming(
 126       base::TimeDelta append_window_start,
 127       base::TimeDelta append_window_end,
 128       const scoped_refptr<StreamParserBuffer>& buffer);
 129
 130   // Helper that processes one frame with the coded frame processing algorithm.
 131   // Returns false on error or true on success.
 132   bool ProcessFrame(const scoped_refptr<StreamParserBuffer>& frame,
 133                     base::TimeDelta append_window_start,
 134                     base::TimeDelta append_window_end,
 135                     base::TimeDelta* timestamp_offset,
 136                     bool* new_media_segment);
 137
 138   // TrackId-indexed map of each track's stream.
 139   TrackBufferMap track_buffers_;
 140
 141   // The last audio buffer seen by the frame processor that was removed because
 142   // it was entirely before the start of the append window.
 143   scoped_refptr<StreamParserBuffer> audio_preroll_buffer_;
 144
 145   // The AudioDecoderConfig associated with buffers handed to ProcessFrames().
 146   AudioDecoderConfig current_audio_config_;
 147   base::TimeDelta sample_duration_;
 148
 149   // The AppendMode of the associated SourceBuffer.
 150   // See SetSequenceMode() for interpretation of |sequence_mode_|.
 151   // Per http://www.w3.org/TR/media-source/#widl-SourceBuffer-mode:
 152   // Controls how a sequence of media segments are handled. This is initially
 153   // set to false ("segments").
 154   bool sequence_mode_;
 155
 156   // Tracks the MSE coded frame processing variable of same name.
 157   // Initially kNoTimestamp(), meaning "unset".
 158   base::TimeDelta group_start_timestamp_;
 159
 160   // Tracks the MSE coded frame processing variable of same name. It stores the
 161   // highest coded frame end timestamp across all coded frames in the current
 162   // coded frame group. It is set to 0 when the SourceBuffer object is created
 163   // and gets updated by ProcessFrames().
 164   base::TimeDelta group_end_timestamp_;
 165
 166   UpdateDurationCB update_duration_cb_;
 167
 168   DISALLOW_COPY_AND_ASSIGN(FrameProcessor);
 169 };
 170
 171 }  // namespace media
 172
 173 #endif  // MEDIA_FILTERS_FRAME_PROCESSOR_H_