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

media/formats/mp4/mp4_stream_parser.cc

 // Copyright 2014 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/formats/mp4/mp4_stream_parser.h"
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/time/time.h"
 #include "media/base/audio_decoder_config.h"
@@ skipping 29 matching lines @@
 }
 
 MP4StreamParser::~MP4StreamParser() {}
 
 void MP4StreamParser::Init(
     const InitCB& init_cb,
     const NewConfigCB& config_cb,
     const NewBuffersCB& new_buffers_cb,
     bool /* ignore_text_tracks */,
     const EncryptedMediaInitDataCB& encrypted_media_init_data_cb,
-    const NewMediaSegmentCB& new_segment_cb,
+    const base::Closure& start_of_segment_cb,
     const base::Closure& end_of_segment_cb,
     const scoped_refptr<MediaLog>& media_log) {
   DCHECK_EQ(state_, kWaitingForInit);
   DCHECK(init_cb_.is_null());
   DCHECK(!init_cb.is_null());
   DCHECK(!config_cb.is_null());
   DCHECK(!new_buffers_cb.is_null());
   DCHECK(!encrypted_media_init_data_cb.is_null());
   DCHECK(!end_of_segment_cb.is_null());
 
   ChangeState(kParsingBoxes);
   init_cb_ = init_cb;
   config_cb_ = config_cb;
   new_buffers_cb_ = new_buffers_cb;
   encrypted_media_init_data_cb_ = encrypted_media_init_data_cb;
-  new_segment_cb_ = new_segment_cb;
+  start_of_segment_cb_ = start_of_segment_cb;
   end_of_segment_cb_ = end_of_segment_cb;
   media_log_ = media_log;
 }
 
 void MP4StreamParser::Reset() {
   queue_.Reset();
   runs_.reset();
   moof_head_ = 0;
   mdat_tail_ = 0;
 }
@@ skipping 277 matching lines @@
   MovieFragment moof;
   RCHECK(moof.Parse(reader));
   if (!runs_)
     runs_.reset(new TrackRunIterator(moov_.get(), media_log_));
   RCHECK(runs_->Init(moof));
   RCHECK(ComputeHighestEndOffset(moof));
 
   if (!moof.pssh.empty())
     OnEncryptedMediaInitData(moof.pssh);
 
-  new_segment_cb_.Run();
+  start_of_segment_cb_.Run();
   ChangeState(kWaitingForSampleData);
   return true;
 }
 
 void MP4StreamParser::OnEncryptedMediaInitData(
     const std::vector<ProtectionSystemSpecificHeader>& headers) {
   // TODO(strobe): ensure that the value of init_data (all PSSH headers
   // concatenated in arbitrary order) matches the EME spec.
   // See https://www.w3.org/Bugs/Public/show_bug.cgi?id=17673.
   size_t total_size = 0;
@@ skipping 27 matching lines @@
   return true;
 }
 
 bool MP4StreamParser::EnqueueSample(BufferQueue* audio_buffers,
                                     BufferQueue* video_buffers,
                                     bool* err) {
   DCHECK_EQ(state_, kEmittingSamples);
 
   if (!runs_->IsRunValid()) {
     // Flush any buffers we've gotten in this chunk so that buffers don't
-    // cross NewSegment() calls
+    // cross |start_of_segment_cb_| calls
     *err = !SendAndFlushSamples(audio_buffers, video_buffers);
     if (*err)
       return false;
 
     // Remain in kEmittingSamples state, discarding data, until the end of
     // the current 'mdat' box has been appended to the queue.
     if (!queue_.Trim(mdat_tail_))
       return false;
 
     ChangeState(kParsingBoxes);
@@ skipping 198 matching lines @@
       runs.AdvanceSample();
     }
     runs.AdvanceRun();
   }
 
   return true;
 }
 
 }  // namespace mp4
 }  // namespace media