Handle end of stream for media...

media/filters/video_thread.cc

 // Copyright (c) 2009 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/base/buffers.h"
 #include "media/base/filter_host.h"
 #include "media/filters/video_thread.h"
 
 namespace media {
 
@@ skipping 145 matching lines @@
 
     // Advance |current_frame_| and try to determine |next_frame|.
     scoped_refptr<VideoFrame> next_frame;
     {
       AutoLock auto_lock(lock_);
       DCHECK(!frames_.empty());
       DCHECK_EQ(current_frame_, frames_.front());
       frames_.pop_front();
       ScheduleRead();
       while (frames_.empty()) {
+

[scherkus (not reviewing), 2009/06/04 20:11:08]

remove empty line

[Alpha Left Google, 2009/06/04 20:13:34]

Done.

         frame_available_.Wait();
 
         // We have the lock again, check the actual state to see if we're trying
         // to stop.
         if (state_ == STOPPED) {
           return;
         }
       }
       current_frame_ = frames_.front();
       if (frames_.size() >= 2) {
@@ skipping 45 matching lines @@
 
 void VideoThread::GetCurrentFrame(scoped_refptr<media::VideoFrame>* frame_out) {
   AutoLock auto_lock(lock_);
   // Either we have initialized or we have the current frame.
   DCHECK(state_ != INITIALIZED || current_frame_);
   *frame_out = current_frame_;
 }
 
 void VideoThread::OnReadComplete(VideoFrame* frame) {
   AutoLock auto_lock(lock_);
-  frames_.push_back(frame);
-  DCHECK_LE(frames_.size(), kMaxFrames);
+  // If this is an end of stream frame, don't enqueue it since it has no data.
+  if (!frame->IsEndOfStream()) {
+    frames_.push_back(frame);
+    DCHECK_LE(frames_.size(), kMaxFrames);
+    frame_available_.Signal();
+  }
 
   // Check for our initialization condition.
-  if (state_ == INITIALIZING && frames_.size() == kMaxFrames) {
-    state_ = INITIALIZED;
-    current_frame_ = frames_.front();
-    host_->InitializationComplete();
+  if (state_ == INITIALIZING &&
+      (frames_.size() == kMaxFrames || frame->IsEndOfStream())) {
+    if (frames_.empty()) {
+      // We should have initialized but there's no decoded frames in the queue.
+      // Raise an error.
+      host_->Error(PIPELINE_ERROR_NO_DATA);
+    } else {
+      state_ = INITIALIZED;
+      current_frame_ = frames_.front();
+      host_->InitializationComplete();
+    }
   }
-
-  frame_available_.Signal();
 }
 
 void VideoThread::ScheduleRead() {
   host_->PostTask(
       NewRunnableMethod(decoder_.get(), &VideoDecoder::Read,
       NewCallback(this, &VideoThread::OnReadComplete)));
 }
 
 bool VideoThread::WaitForInitialized() {
   // This loop essentially handles preroll.  We wait until we've been fully
   // initialized so we can call OnFrameAvailable() to provide subclasses with
   // the first frame.
   AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, INITIALIZING);
   while (state_ == INITIALIZING) {
     frame_available_.Wait();
     if (state_ == STOPPED) {
       return false;
     }
   }
   DCHECK_EQ(state_, INITIALIZED);
   DCHECK(current_frame_);
   return true;
 }
 
 }  // namespace media