MSE: Relax the 'media segment must begin with keyframe' requirement

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 168 matching lines @@
  private:
   // Called by the |stream_parser_| when a new initialization segment is
   // encountered.
   // Returns true on a successful call. Returns false if an error occurred while
   // processing decoder configurations.
   bool OnNewConfigs(bool allow_audio, bool allow_video,
                     const AudioDecoderConfig& audio_config,
                     const VideoDecoderConfig& video_config,
                     const StreamParser::TextTrackConfigMap& text_configs);
 
-  // Called by the |stream_parser_| at the beginning of a new media segment.
-  void OnNewMediaSegment();
+  // Called by the |stream_parser_| at the start of a new media segment.
+  void OnStartOfMediaSegment();
 
   // Called by the |stream_parser_| at the end of a media segment.
   void OnEndOfMediaSegment();
 
   // Called by the |stream_parser_| when new buffers have been parsed.
   // It processes the new buffers using |frame_processor_|, which includes
   // appending the processed frames to associated demuxer streams for each
   // frame's track.
   // Returns true on a successful call. Returns false if an error occurred while
   // processing the buffers.
@@ skipping 17 matching lines @@
   // 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(), 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
-  // when the "append window" filtering causes discontinuities in the
-  // appended data.
-  // TODO(wolenetz/acolwell): Investigate if we need this, or if coded frame
-  // processing's discontinuity logic is enough. See http://crbug.com/351489.
-  bool new_media_segment_;
-
   // Keeps track of whether a media segment is being parsed.
   bool parsing_media_segment_;
 
   // The object used to parse appended data.
   scoped_ptr<StreamParser> stream_parser_;
 
   ChunkDemuxerStream* audio_;  // Not owned by |this|.
   ChunkDemuxerStream* video_;  // Not owned by |this|.
 
   typedef std::map<StreamParser::TrackId, ChunkDemuxerStream*> TextStreamMap;
@@ skipping 18 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(SourceState);
 };
 
 SourceState::SourceState(scoped_ptr<StreamParser> stream_parser,
                          scoped_ptr<FrameProcessor> frame_processor,
                          const CreateDemuxerStreamCB& create_demuxer_stream_cb,
                          const scoped_refptr<MediaLog>& media_log)
     : create_demuxer_stream_cb_(create_demuxer_stream_cb),
       timestamp_offset_during_append_(NULL),
-      new_media_segment_(false),
       parsing_media_segment_(false),
       stream_parser_(stream_parser.release()),
       audio_(NULL),
       video_(NULL),
       frame_processor_(frame_processor.release()),
       media_log_(media_log),
       auto_update_timestamp_offset_(false) {
   DCHECK(!create_demuxer_stream_cb_.is_null());
   DCHECK(frame_processor_);
 }
@@ skipping 12 matching lines @@
     const NewTextTrackCB& new_text_track_cb) {
   new_text_track_cb_ = new_text_track_cb;
   init_cb_ = init_cb;
 
   stream_parser_->Init(
       base::Bind(&SourceState::OnSourceInitDone, base::Unretained(this)),
       base::Bind(&SourceState::OnNewConfigs, base::Unretained(this),
                  allow_audio, allow_video),
       base::Bind(&SourceState::OnNewBuffers, base::Unretained(this)),
       new_text_track_cb_.is_null(), encrypted_media_init_data_cb,
-      base::Bind(&SourceState::OnNewMediaSegment, base::Unretained(this)),
+      base::Bind(&SourceState::OnStartOfMediaSegment, base::Unretained(this)),
       base::Bind(&SourceState::OnEndOfMediaSegment, base::Unretained(this)),
       media_log_);
 }
 
 void SourceState::SetSequenceMode(bool sequence_mode) {
   DCHECK(!parsing_media_segment_);
 
   frame_processor_->SetSequenceMode(sequence_mode);
 }
 
@@ skipping 492 matching lines @@
 
   frame_processor_->SetAllTrackBuffersNeedRandomAccessPoint();
 
   DVLOG(1) << "OnNewConfigs() : " << (success ? "success" : "failed");
   if (success)
     init_segment_received_cb_.Run();
 
   return success;
 }
 
-void SourceState::OnNewMediaSegment() {
-  DVLOG(2) << "OnNewMediaSegment()";
+void SourceState::OnStartOfMediaSegment() {
+  DVLOG(2) << "OnStartOfMediaSegment()";
   parsing_media_segment_ = true;
-  new_media_segment_ = true;
 }
 
 void SourceState::OnEndOfMediaSegment() {
   DVLOG(2) << "OnEndOfMediaSegment()";
   parsing_media_segment_ = false;
-  new_media_segment_ = false;
 }
 
 bool SourceState::OnNewBuffers(
     const StreamParser::BufferQueue& audio_buffers,
     const StreamParser::BufferQueue& video_buffers,
     const StreamParser::TextBufferQueueMap& text_map) {
   DVLOG(2) << "OnNewBuffers()";
   DCHECK(timestamp_offset_during_append_);
   DCHECK(parsing_media_segment_);
 
@@ skipping 14 matching lines @@
     } else if (have_video_buffers) {
       new_timestamp_offset += EndTimestamp(video_buffers);
     }
   }
 
   if (!frame_processor_->ProcessFrames(audio_buffers,
                                        video_buffers,
                                        text_map,
                                        append_window_start_during_append_,
                                        append_window_end_during_append_,
-                                       &new_media_segment_,
                                        timestamp_offset_during_append_)) {
     return false;
   }
 
   // Only update the timestamp offset if the frame processor hasn't already.
   if (auto_update_timestamp_offset_ &&
       timestamp_offset_before_processing == *timestamp_offset_during_append_) {
     *timestamp_offset_during_append_ = new_timestamp_offset;
   }
 
@@ skipping 132 matching lines @@
 }
 
 TimeDelta ChunkDemuxerStream::GetBufferedDuration() const {
   return stream_->GetBufferedDuration();
 }
 
 size_t ChunkDemuxerStream::GetBufferedSize() const {
   return stream_->GetBufferedSize();
 }
 
-void ChunkDemuxerStream::OnNewMediaSegment(DecodeTimestamp start_timestamp) {
-  DVLOG(2) << "ChunkDemuxerStream::OnNewMediaSegment("
+void ChunkDemuxerStream::OnStartOfCodedFrameGroup(
+    DecodeTimestamp start_timestamp) {
+  DVLOG(2) << "ChunkDemuxerStream::OnStartOfCodedFrameGroup("
            << start_timestamp.InSecondsF() << ")";
   base::AutoLock auto_lock(lock_);
-  stream_->OnNewMediaSegment(start_timestamp);
+  stream_->OnStartOfCodedFrameGroup(start_timestamp);
 }
 
 bool ChunkDemuxerStream::UpdateAudioConfig(
     const AudioDecoderConfig& config,
     const scoped_refptr<MediaLog>& media_log) {
   DCHECK(config.IsValidConfig());
   DCHECK_EQ(type_, AUDIO);
   base::AutoLock auto_lock(lock_);
   if (!stream_) {
     DCHECK_EQ(state_, UNINITIALIZED);
@@ skipping 924 matching lines @@
 }
 
 void ChunkDemuxer::ShutdownAllStreams() {
   for (SourceStateMap::iterator itr = source_state_map_.begin();
        itr != source_state_map_.end(); ++itr) {
     itr->second->Shutdown();
   }
 }
 
 }  // namespace media