Add support for incremental cluster parsing.

media/filters/chunk_demuxer.cc

 // Copyright (c) 2011 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.
 
 // Implements a Demuxer that can switch among different data sources mid-stream.
 // Uses FFmpegDemuxer under the covers, so see the caveats at the top of
 // ffmpeg_demuxer.h.
 
 #include "media/filters/chunk_demuxer.h"
 
@@ skipping 112 matching lines @@
   VLOG(1) << "Flush()";
   base::AutoLock auto_lock(lock_);
   buffers_.clear();
   received_end_of_stream_ = false;
   last_buffer_timestamp_ = kNoTimestamp;
 }
 
 bool ChunkDemuxerStream::CanAddBuffers(const BufferQueue& buffers) const {
   base::AutoLock auto_lock(lock_);
 
-  // If we haven't seen any buffers yet than anything can be added.
+  // If we haven't seen any buffers yet, then anything can be added.
   if (last_buffer_timestamp_ == kNoTimestamp)
     return true;
 
   if (buffers.empty())
     return true;
 
   return (buffers.front()->GetTimestamp() > last_buffer_timestamp_);
 }
 
 void ChunkDemuxerStream::AddBuffers(const BufferQueue& buffers) {
@@ skipping 283 matching lines @@
   PipelineStatusCB cb;
   {
     base::AutoLock auto_lock(lock_);
 
     byte_queue_.Push(data, length);
 
     const uint8* cur = NULL;
     int cur_size = 0;
     int bytes_parsed = 0;
     int result = -1;
-    bool parsed_a_cluster = false;
+    bool can_complete_seek = false;
 
     byte_queue_.Peek(&cur, &cur_size);
 
     do {
       switch(state_) {
         case INITIALIZING:
           result = ParseInfoAndTracks_Locked(cur, cur_size);
           if (result < 0) {
             VLOG(1) << "AppendData(): parsing info & tracks failed";
             ReportError_Locked(DEMUXER_ERROR_COULD_NOT_OPEN);
             return true;
           }
           break;
 
-        case INITIALIZED:
-          result = ParseCluster_Locked(cur, cur_size);
+        case INITIALIZED: {
+          bool buffers_added = false;
+          result = ParseCluster_Locked(cur, cur_size, &buffers_added);
           if (result < 0) {
             VLOG(1) << "AppendData(): parsing data failed";
             ReportError_Locked(PIPELINE_ERROR_DECODE);
             return true;
           }
 
-          parsed_a_cluster = (result > 0);
-          break;
+          can_complete_seek |= (result > 0 && buffers_added);
+        } break;
 
         case WAITING_FOR_INIT:
         case ENDED:
         case PARSE_ERROR:
         case SHUTDOWN:
           VLOG(1) << "AppendData(): called in unexpected state " << state_;
           return false;
       }
 
       if (result > 0) {
         cur += result;
         cur_size -= result;
         bytes_parsed += result;
       }
     } while (result > 0 && cur_size > 0);
 
     byte_queue_.Pop(bytes_parsed);
 
-    if (parsed_a_cluster && seek_waits_for_data_) {
+    if (can_complete_seek && seek_waits_for_data_) {
       seek_waits_for_data_ = false;
 
       if (!seek_cb_.is_null())
         std::swap(cb, seek_cb_);
     }
 
     base::TimeDelta tmp;
     if (audio_.get() && audio_->GetLastBufferTimestamp(&tmp) &&
         tmp > buffered_ts) {
       buffered_ts = tmp;
@@ skipping 232 matching lines @@
         !video_.get()) {
       video_ = new ChunkDemuxerStream(DemuxerStream::VIDEO, stream);
       no_supported_streams = false;
       continue;
     }
   }
 
   return !no_supported_streams;
 }
 
-int ChunkDemuxer::ParseCluster_Locked(const uint8* data, int size) {
+int ChunkDemuxer::ParseCluster_Locked(const uint8* data, int size,
+                                      bool* buffers_added) {
   lock_.AssertAcquired();
   if (!cluster_parser_.get())
     return -1;
 
-  int id;
-  int64 element_size;
-  int result = WebMParseElementHeader(data, size, &id, &element_size);
-
-  if (result <= 0)
-    return result;
-
-  if (id == kWebMIdCues) {
-    if (size < (result + element_size)) {
-      // We don't have the whole element yet. Signal we need more data.
-      return 0;
-    }
-    // Skip the element.
-    return result + element_size;
-  } else if (id != kWebMIdCluster) {
-    VLOG(1) << "Unexpected ID 0x" << std::hex << id;
-    return -1;
-  }
-
   int bytes_parsed = cluster_parser_->Parse(data, size);
 
   if (bytes_parsed <= 0)
     return bytes_parsed;
 
-  // Make sure we can add the buffers to both streams before we actutally
-  // add them. This allows us to accept all of the data or none of it.
-  if ((audio_.get() &&
-       !audio_->CanAddBuffers(cluster_parser_->audio_buffers())) ||
-      (video_.get() &&
-       !video_->CanAddBuffers(cluster_parser_->video_buffers()))) {
-    return -1;
+  if (!cluster_parser_->audio_buffers().empty() ||
+      !cluster_parser_->video_buffers().empty()) {
+    // Make sure we can add the buffers to both streams before we actually
+    // add them. This allows us to accept all of the data or none of it.
+    if ((audio_.get() &&
+         !audio_->CanAddBuffers(cluster_parser_->audio_buffers())) ||
+        (video_.get() &&
+         !video_->CanAddBuffers(cluster_parser_->video_buffers()))) {
+      return -1;
+    }
+
+    if (audio_.get())
+      audio_->AddBuffers(cluster_parser_->audio_buffers());
+
+    if (video_.get())
+      video_->AddBuffers(cluster_parser_->video_buffers());
+
+    *buffers_added = true;
   }
 
-  if (audio_.get())
-    audio_->AddBuffers(cluster_parser_->audio_buffers());
-
-  if (video_.get())
-    video_->AddBuffers(cluster_parser_->video_buffers());
-
   // TODO(acolwell) : make this more representative of what is actually
   // buffered.
   buffered_bytes_ += bytes_parsed;
 
   return bytes_parsed;
 }
 
 void ChunkDemuxer::ReportError_Locked(PipelineStatus error) {
   lock_.AssertAcquired();
   DCHECK_NE(error, PIPELINE_OK);
@@ skipping 19 matching lines @@
     base::AutoUnlock auto_unlock(lock_);
     if (cb.is_null()) {
       host()->SetError(error);
       return;
     }
     cb.Run(error);
   }
 }
 
 }  // namespace media