Add live mode detection in WebM MediaSource parser.

media/filters/chunk_demuxer.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/filters/chunk_demuxer.h"
 
 #include <algorithm>
 #include <limits>
 #include <list>
 
@@ skipping 75 matching lines @@
 // Contains state belonging to a source id.
 class SourceState {
  public:
   // Callback signature used to create ChunkDemuxerStreams.
   typedef base::Callback<ChunkDemuxerStream*(
       DemuxerStream::Type)> CreateDemuxerStreamCB;
 
   typedef base::Callback<void(
       ChunkDemuxerStream*, const TextTrackConfig&)> NewTextTrackCB;
 
-  // First parameter - Indicates initialization success. Set to true if
-  //                   initialization was successful. False if an error
-  //                   occurred.
-  // Second parameter - Indicates the stream duration. Only contains a valid
-  //                    value if the first parameter is true.
-  // Third parameter - Indicates the source Time associated with
+  // success - True if initialization was successful, false otherwise.
+  // duration - Stream duration. Only valid if |success| is true.
+  // timeline_offset - Indicates the source Time associated with
   //                   presentation timestamp 0. A null Time is returned if
   //                   no mapping to Time exists. Only contains a
-  //                   valid value if the first parameter is true.
-  typedef base::Callback<void(bool, TimeDelta, base::Time)> InitCB;
+  //                   valid value if |success| is true.
+  // live_mode - True when the stream is a live stream.
+  typedef base::Callback<void(bool success,
+                              TimeDelta duration,
+                              base::Time timeline_offset,
+                              bool live_mode)> InitCB;
 
   SourceState(
       scoped_ptr<StreamParser> stream_parser,
       scoped_ptr<FrameProcessorBase> frame_processor, const LogCB& log_cb,
       const CreateDemuxerStreamCB& create_demuxer_stream_cb);
 
   ~SourceState();
 
   void Init(const InitCB& init_cb,
             bool allow_audio,
@@ skipping 72 matching lines @@
   // frame's track.
   // Returns true on a successful call. Returns false if an error occurred while
   // processing the buffers.
   bool OnNewBuffers(const StreamParser::BufferQueue& audio_buffers,
                     const StreamParser::BufferQueue& video_buffers,
                     const StreamParser::TextBufferQueueMap& text_map);
 
   void OnSourceInitDone(bool success,
                         TimeDelta duration,
                         base::Time timeline_offset,
-                        bool auto_update_timestamp_offset);
+                        bool auto_update_timestamp_offset,
+                        bool live_mode);
 
   CreateDemuxerStreamCB create_demuxer_stream_cb_;
   NewTextTrackCB new_text_track_cb_;
 
   // During Append(), if OnNewBuffers() coded frame processing updates the
   // timestamp offset then |*timestamp_offset_during_append_| is also updated
   // so Append()'s caller can know the new offset. This pointer is only non-NULL
   // during the lifetime of an Append() call.
   TimeDelta* timestamp_offset_during_append_;
 
@@ skipping 487 matching lines @@
       timestamp_offset_before_processing == *timestamp_offset_during_append_) {
     *timestamp_offset_during_append_ = new_timestamp_offset;
   }
 
   return true;
 }
 
 void SourceState::OnSourceInitDone(bool success,
                                    TimeDelta duration,
                                    base::Time timeline_offset,
-                                   bool auto_update_timestamp_offset) {
+                                   bool auto_update_timestamp_offset,
+                                   bool live_mode) {
   auto_update_timestamp_offset_ = auto_update_timestamp_offset;
   base::ResetAndReturn(&init_cb_).Run(
-      success, duration, timeline_offset);
+      success, duration, timeline_offset, live_mode);
 }
 
 ChunkDemuxerStream::ChunkDemuxerStream(Type type, bool splice_frames_enabled)
     : type_(type),
       state_(UNINITIALIZED),
       splice_frames_enabled_(splice_frames_enabled) {}
 
 void ChunkDemuxerStream::StartReturningData() {
   DVLOG(1) << "ChunkDemuxerStream::StartReturningData()";
   base::AutoLock auto_lock(lock_);
@@ skipping 263 matching lines @@
                            bool splice_frames_enabled)
     : state_(WAITING_FOR_INIT),
       cancel_next_seek_(false),
       host_(NULL),
       open_cb_(open_cb),
       need_key_cb_(need_key_cb),
       enable_text_(false),
       log_cb_(log_cb),
       duration_(kNoTimestamp()),
       user_specified_duration_(-1),
+      live_mode_(false),
       splice_frames_enabled_(splice_frames_enabled) {
   DCHECK(!open_cb_.is_null());
   DCHECK(!need_key_cb_.is_null());
 }
 
 void ChunkDemuxer::Initialize(
     DemuxerHost* host,
     const PipelineStatusCB& cb,
     bool enable_text_tracks) {
   DVLOG(1) << "Init()";
@@ skipping 70 matching lines @@
 }
 
 TimeDelta ChunkDemuxer::GetStartTime() const {
   return TimeDelta();
 }
 
 base::Time ChunkDemuxer::GetTimelineOffset() const {
   return timeline_offset_;
 }
 
+bool ChunkDemuxer::IsLiveMode() const {
+  return live_mode_;
+}
+
 void ChunkDemuxer::StartWaitingForSeek(TimeDelta seek_time) {
   DVLOG(1) << "StartWaitingForSeek()";
   base::AutoLock auto_lock(lock_);
   DCHECK(state_ == INITIALIZED || state_ == ENDED || state_ == SHUTDOWN ||
          state_ == PARSE_ERROR) << state_;
   DCHECK(seek_cb_.is_null());
 
   if (state_ == SHUTDOWN || state_ == PARSE_ERROR)
     return;
 
@@ skipping 397 matching lines @@
   lock_.AssertAcquired();
   for (SourceStateMap::const_iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     if (itr->second->IsSeekWaitingForData())
       return true;
   }
 
   return false;
 }
 
-void ChunkDemuxer::OnSourceInitDone(bool success, TimeDelta duration,
-                                    base::Time timeline_offset) {
+void ChunkDemuxer::OnSourceInitDone(bool success,
+                                    TimeDelta duration,
+                                    base::Time timeline_offset,
+                                    bool live_mode) {
   DVLOG(1) << "OnSourceInitDone(" << success << ", "
            << duration.InSecondsF() << ")";
   lock_.AssertAcquired();
   DCHECK_EQ(state_, INITIALIZING);
   if (!success || (!audio_ && !video_)) {
     ReportError_Locked(DEMUXER_ERROR_COULD_NOT_OPEN);
     return;
   }
 
   if (duration != TimeDelta() && duration_ == kNoTimestamp())
     UpdateDuration(duration);
 
   if (!timeline_offset.is_null()) {
     if (!timeline_offset_.is_null() &&
         timeline_offset != timeline_offset_) {
       MEDIA_LOG(log_cb_)
           << "Timeline offset is not the same across all SourceBuffers.";
       ReportError_Locked(DEMUXER_ERROR_COULD_NOT_OPEN);
       return;
     }
 
     timeline_offset_ = timeline_offset;
   }
 
+  live_mode_ |= live_mode;
+
   // Wait until all streams have initialized.
   if ((!source_id_audio_.empty() && !audio_) ||
-      (!source_id_video_.empty() && !video_))
+      (!source_id_video_.empty() && !video_)) {
     return;
+  }
 
   SeekAllSources(GetStartTime());
   StartReturningData();
 
   if (duration_ == kNoTimestamp())
     duration_ = kInfiniteDuration();
 
   // The demuxer is now initialized after the |start_timestamp_| was set.
   ChangeState_Locked(INITIALIZED);
   base::ResetAndReturn(&init_cb_).Run(PIPELINE_OK);
@@ skipping 128 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (SourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media