MSE: Notify Blink SourceBuffer on init segment received

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 93 matching lines @@
             bool allow_audio,
             bool allow_video,
             const StreamParser::NeedKeyCB& need_key_cb,
             const NewTextTrackCB& new_text_track_cb);
 
   // Appends new data to the StreamParser.
   // Returns true if the data was successfully appended. Returns false if an
   // error occurred. |*timestamp_offset| is used and possibly updated by the
   // append. |append_window_start| and |append_window_end| correspond to the MSE
   // spec's similarly named source buffer attributes that are used in coded
-  // frame processing.
-  bool Append(const uint8* data, size_t length,
-              TimeDelta append_window_start,
-              TimeDelta append_window_end,
-              TimeDelta* timestamp_offset);
+  // frame processing. |init_segment_received_cb| is run for each new fully
+  // parsed initialization segment.
+  bool Append(
+      const uint8* data,
+      size_t length,
+      TimeDelta append_window_start,
+      TimeDelta append_window_end,
+      TimeDelta* timestamp_offset,
+      const ChunkDemuxer::InitSegmentReceivedCB& init_segment_received_cb);

[acolwell GONE FROM CHROMIUM, 2014/09/09 22:36:37]

nit: typedef this above so you don't have to mention ChunkDemuxer in all the
other locations below?

[wolenetz, 2014/09/10 00:43:46]

Done.

 
   // Aborts the current append sequence and resets the parser.
   void Abort(TimeDelta append_window_start,
              TimeDelta append_window_end,
              TimeDelta* timestamp_offset);
 
   // Calls Remove(|start|, |end|, |duration|) on all
   // ChunkDemuxerStreams managed by this object.
   void Remove(TimeDelta start, TimeDelta end, TimeDelta duration);
 
@@ skipping 63 matching lines @@
 
   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_;
 
+  // During Append(), OnNewConfigs() will trigger the initialization segment
+  // received algorithm. This callback is only non-NULL during the lifetime of
+  // an Append() call. Note, the MSE spec explicitly disallows this algorithm
+  // during an Abort(), since Abort() is allowed only to emit coded frames, and
+  // only if the parser is PARSING_MEDIA_SEGMENT (not an INIT segment).
+  ChunkDemuxer::InitSegmentReceivedCB init_segment_received_cb_during_append_;
+
   // During Append(), coded frame processing triggered by OnNewBuffers()
   // requires these two attributes. These are only valid during the lifetime of
   // an Append() call.
   TimeDelta append_window_start_during_append_;
   TimeDelta append_window_end_during_append_;
 
   // Set to true if the next buffers appended within the append window
   // represent the start of a new media segment. This flag being set
   // triggers a call to |new_segment_cb_| when the new buffers are
   // appended. The flag is set on actual media segment boundaries and
@@ skipping 80 matching lines @@
   frame_processor_->SetSequenceMode(sequence_mode);
 }
 
 void SourceState::SetGroupStartTimestampIfInSequenceMode(
     base::TimeDelta timestamp_offset) {
   DCHECK(!parsing_media_segment_);
 
   frame_processor_->SetGroupStartTimestampIfInSequenceMode(timestamp_offset);
 }
 
-bool SourceState::Append(const uint8* data, size_t length,
-                         TimeDelta append_window_start,
-                         TimeDelta append_window_end,
-                         TimeDelta* timestamp_offset) {
+bool SourceState::Append(
+    const uint8* data,
+    size_t length,
+    TimeDelta append_window_start,
+    TimeDelta append_window_end,
+    TimeDelta* timestamp_offset,
+    const ChunkDemuxer::InitSegmentReceivedCB& init_segment_received_cb) {
   DCHECK(timestamp_offset);
   DCHECK(!timestamp_offset_during_append_);
+  DCHECK(init_segment_received_cb_during_append_.is_null());
+  DCHECK(!init_segment_received_cb.is_null());
   append_window_start_during_append_ = append_window_start;
   append_window_end_during_append_ = append_window_end;
   timestamp_offset_during_append_ = timestamp_offset;
+  init_segment_received_cb_during_append_ = init_segment_received_cb;
 
   // TODO(wolenetz/acolwell): Curry and pass a NewBuffersCB here bound with
   // append window and timestamp offset pointer. See http://crbug.com/351454.
   bool err = stream_parser_->Parse(data, length);
   timestamp_offset_during_append_ = NULL;
+  init_segment_received_cb_during_append_.Reset();
   return err;
 }
 
 void SourceState::Abort(TimeDelta append_window_start,
                         TimeDelta append_window_end,
                         base::TimeDelta* timestamp_offset) {
   DCHECK(timestamp_offset);
   DCHECK(!timestamp_offset_during_append_);
   timestamp_offset_during_append_ = timestamp_offset;
   append_window_start_during_append_ = append_window_start;
@@ skipping 332 matching lines @@
                              << " does not match old one.";
           break;
         }
       }
     }
   }
 
   frame_processor_->SetAllTrackBuffersNeedRandomAccessPoint();
 
   DVLOG(1) << "OnNewConfigs() : " << (success ? "success" : "failed");
+  if (success) {
+    // BIG TODO: add parameters to init segment received algo...
+    init_segment_received_cb_during_append_.Run();
+  }
+
   return success;
 }
 
 void SourceState::OnNewMediaSegment() {
   DVLOG(2) << "OnNewMediaSegment()";
   parsing_media_segment_ = true;
   new_media_segment_ = true;
 }
 
 void SourceState::OnEndOfMediaSegment() {
@@ skipping 544 matching lines @@
 Ranges<TimeDelta> ChunkDemuxer::GetBufferedRanges(const std::string& id) const {
   base::AutoLock auto_lock(lock_);
   DCHECK(!id.empty());
 
   SourceStateMap::const_iterator itr = source_state_map_.find(id);
 
   DCHECK(itr != source_state_map_.end());
   return itr->second->GetBufferedRanges(duration_, state_ == ENDED);
 }
 
-void ChunkDemuxer::AppendData(const std::string& id,
-                              const uint8* data, size_t length,
-                              TimeDelta append_window_start,
-                              TimeDelta append_window_end,
-                              TimeDelta* timestamp_offset) {
+void ChunkDemuxer::AppendData(
+    const std::string& id,
+    const uint8* data,
+    size_t length,
+    TimeDelta append_window_start,
+    TimeDelta append_window_end,
+    TimeDelta* timestamp_offset,
+    const InitSegmentReceivedCB& init_segment_received_cb) {
   DVLOG(1) << "AppendData(" << id << ", " << length << ")";
 
   DCHECK(!id.empty());
   DCHECK(timestamp_offset);
+  DCHECK(!init_segment_received_cb.is_null());
 
   Ranges<TimeDelta> ranges;
 
   {
     base::AutoLock auto_lock(lock_);
     DCHECK_NE(state_, ENDED);
 
     // Capture if any of the SourceBuffers are waiting for data before we start
     // parsing.
     bool old_waiting_for_data = IsSeekWaitingForData_Locked();
 
     if (length == 0u)
       return;
 
     DCHECK(data);
 
     switch (state_) {
       case INITIALIZING:
         DCHECK(IsValidId(id));
         if (!source_state_map_[id]->Append(data, length,
                                            append_window_start,
                                            append_window_end,
-                                           timestamp_offset)) {
+                                           timestamp_offset,
+                                           init_segment_received_cb)) {
           ReportError_Locked(DEMUXER_ERROR_COULD_NOT_OPEN);
           return;
         }
         break;
 
       case INITIALIZED: {
         DCHECK(IsValidId(id));
         if (!source_state_map_[id]->Append(data, length,
                                            append_window_start,
                                            append_window_end,
-                                           timestamp_offset)) {
+                                           timestamp_offset,
+                                           init_segment_received_cb)) {
           ReportError_Locked(PIPELINE_ERROR_DECODE);
           return;
         }
       } break;
 
       case PARSE_ERROR:
         DVLOG(1) << "AppendData(): Ignoring data after a parse error.";
         return;
 
       case WAITING_FOR_INIT:
@@ skipping 467 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (SourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media