Flush sample buffers when reading new segments in Media Source BMFF parser.

media/mp4/mp4_stream_parser.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/mp4/mp4_stream_parser.h"
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/time.h"
 #include "media/base/audio_decoder_config.h"
@@ skipping 74 matching lines @@
       DCHECK_EQ(kEmittingSamples, state_);
       result = EnqueueSample(&audio_buffers, &video_buffers, &err);
       if (result) {
         int64 max_clear = runs_.GetMaxClearOffset() + moof_head_;
         DCHECK(max_clear <= queue_.tail());
         err = !(ReadMDATsUntil(max_clear) && queue_.Trim(max_clear));
       }
     }
   } while (result && !err);
 
+  if (!err)
+    err = !SendAndFlushSamples(&audio_buffers, &video_buffers);
+
   if (err) {
-    DLOG(ERROR) << "Unknown error while parsing MP4";
+    DLOG(ERROR) << "Error while parsing MP4";
     queue_.Reset();
     moov_.reset();
     ChangeState(kError);
     return false;
   }
 
-  if (!audio_buffers.empty() &&
-      (audio_cb_.is_null() || !audio_cb_.Run(audio_buffers)))
-    return false;
-  if (!video_buffers.empty() &&
-      (video_cb_.is_null() || !video_cb_.Run(video_buffers)))
-    return false;
-
   return true;
 }
 
 bool MP4StreamParser::ParseBox(bool* err) {
   const uint8* buf;
   int size;
   queue_.Peek(&buf, &size);
   if (!size) return false;
 
   scoped_ptr<BoxReader> reader(BoxReader::ReadTopLevelBox(buf, size, err));
@@ skipping 104 matching lines @@
   RCHECK(runs_.Init(*moov_, moof));
   new_segment_cb_.Run(runs_.GetMinDecodeTimestamp());
   ChangeState(kEmittingSamples);
   return true;
 }
 
 bool MP4StreamParser::EnqueueSample(BufferQueue* audio_buffers,
                                     BufferQueue* video_buffers,
                                     bool* err) {
   if (!runs_.RunValid()) {
+    // Flush any buffers we've gotten in this chunk so that buffers don't
+    // cross NewSegment() calls
+    *err = !SendAndFlushSamples(audio_buffers, video_buffers);
+    if (*err) return false;
     ChangeState(kParsingBoxes);
     return true;
   }
 
   if (!runs_.SampleValid()) {
     runs_.AdvanceRun();
     return true;
   }
 
   DCHECK(!(*err));
@@ skipping 60 matching lines @@
   if (audio) {
     audio_buffers->push_back(stream_buf);
   } else {
     video_buffers->push_back(stream_buf);
   }
 
   runs_.AdvanceSample();
   return true;
 }
 
+bool MP4StreamParser::SendAndFlushSamples(BufferQueue* audio_buffers,
+                                          BufferQueue* video_buffers) {
+  if (!audio_buffers->empty()) {
+    if (audio_cb_.is_null() || !audio_cb_.Run(*audio_buffers))
+      return false;
+    audio_buffers->clear();
+  }
+  if (!video_buffers->empty()) {
+    if (video_cb_.is_null() || !video_cb_.Run(*video_buffers))
+      return false;
+    video_buffers->clear();
+  }
+  return true;
+}
+
 bool MP4StreamParser::ReadMDATsUntil(const int64 tgt_offset) {
   DCHECK(tgt_offset <= queue_.tail());
 
   while (mdat_tail_ < tgt_offset) {
     const uint8* buf;
     int size;
     queue_.PeekAt(mdat_tail_, &buf, &size);
 
     FourCC type;
     int box_sz;
@@ skipping 12 matching lines @@
   return true;
 }
 
 void MP4StreamParser::ChangeState(State new_state) {
   DVLOG(2) << "Changing state: " << new_state;
   state_ = new_state;
 }
 
 }  // namespace mp4
 }  // namespace media