Fix black video frames when seeking (which also fixes flashing poster issue).

webkit/glue/webmediaplayer_impl.cc

 // Copyright (c) 2010 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 "webkit/glue/webmediaplayer_impl.h"
 
 #include <limits>
 
 #include "base/callback.h"
 #include "base/command_line.h"
@@ skipping 190 matching lines @@
   }
 }
 
 void WebMediaPlayerImpl::Proxy::NetworkEventTask() {
   DCHECK(MessageLoop::current() == render_loop_);
   if (webmediaplayer_) {
     webmediaplayer_->OnNetworkEvent();
   }
 }
 
+void WebMediaPlayerImpl::Proxy::CopyBitmapToCanvas(const SkBitmap& bitmap,
+                                                   skia::PlatformCanvas* canvas,
+                                                   const gfx::Rect& dest_rect) {
+  DCHECK(MessageLoop::current() == render_loop_);
+  if (video_renderer_)
+    video_renderer_->CopyBitmapToCanvas(bitmap, canvas, dest_rect);
+}
+
+void WebMediaPlayerImpl::Proxy::GetCurrentBitmap(SkBitmap* bitmap) {
+  DCHECK(MessageLoop::current() == render_loop_);
+  if (video_renderer_)
+    video_renderer_->GetCurrentBitmap(bitmap);
+}
+
 void WebMediaPlayerImpl::Proxy::GetCurrentFrame(
     scoped_refptr<media::VideoFrame>* frame_out) {
   if (video_renderer_)
     video_renderer_->GetCurrentFrame(frame_out);
 }
 
 void WebMediaPlayerImpl::Proxy::PutCurrentFrame(
     scoped_refptr<media::VideoFrame> frame) {
   if (video_renderer_)
     video_renderer_->PutCurrentFrame(frame);
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // WebMediaPlayerImpl implementation
 
 WebMediaPlayerImpl::WebMediaPlayerImpl(
     WebKit::WebMediaPlayerClient* client,
     media::FilterCollection* collection)
     : network_state_(WebKit::WebMediaPlayer::Empty),
       ready_state_(WebKit::WebMediaPlayer::HaveNothing),
       main_loop_(NULL),
       filter_collection_(collection),
       pipeline_(NULL),
       pipeline_thread_("PipelineThread"),
       paused_(true),
+      seeking_(false),
       playback_rate_(0.0f),
       client_(client),
       proxy_(NULL),
       pipeline_stopped_(false, false) {
   // Saves the current message loop.
   DCHECK(!main_loop_);
   main_loop_ = MessageLoop::current();
 }
 
 bool WebMediaPlayerImpl::Initialize(
@@ skipping 115 matching lines @@
   // cause extra pre-rolling and will break servers without range request
   // support.
   //
   // We still have to notify WebKit that time has changed otherwise
   // HTMLMediaElement gets into an inconsistent state.
   if (pipeline_->GetCurrentTime().ToInternalValue() == 0 && seconds == 0) {
     GetClient()->timeChanged();
     return;
   }
 
-  // Drop our ready state if the media file isn't fully loaded.
-  if (!pipeline_->IsLoaded()) {
-    SetReadyState(WebKit::WebMediaPlayer::HaveMetadata);
-  }
-
   // Try to preserve as much accuracy as possible.
   float microseconds = seconds * base::Time::kMicrosecondsPerSecond;
   base::TimeDelta seek_time =
       base::TimeDelta::FromMicroseconds(static_cast<int64>(microseconds));
 
   // Update our paused time.
   if (paused_) {
     paused_time_ = seek_time;
   }
 
+  seeking_ = true;
+
+  // If available, take a copy of the current video frame to display while
+  // seeking.
+  proxy_->GetCurrentBitmap(&cached_bitmap_);
+
   // Kick off the asynchronous seek!
   pipeline_->Seek(
       seek_time,
       NewCallback(proxy_.get(),
                   &WebMediaPlayerImpl::Proxy::PipelineSeekCallback));
 }
 
 void WebMediaPlayerImpl::setEndTime(float seconds) {
   DCHECK(MessageLoop::current() == main_loop_);
 
@@ skipping 73 matching lines @@
 
   return pipeline_->GetPlaybackRate() == 0.0f;
 }
 
 bool WebMediaPlayerImpl::seeking() const {
   DCHECK(MessageLoop::current() == main_loop_);
 
   if (ready_state_ == WebKit::WebMediaPlayer::HaveNothing)
     return false;
 
-  return ready_state_ == WebKit::WebMediaPlayer::HaveMetadata;
+  return seeking_;
 }
 
 float WebMediaPlayerImpl::duration() const {
   DCHECK(MessageLoop::current() == main_loop_);
 
   base::TimeDelta duration = pipeline_->GetMediaDuration();
   if (duration.InMicroseconds() == media::Limits::kMaxTimeInMicroseconds)
     return std::numeric_limits<float>::infinity();
   return static_cast<float>(duration.InSecondsF());
 }
@@ skipping 66 matching lines @@
 
   proxy_->SetSize(gfx::Rect(0, 0, size.width, size.height));
 }
 
 void WebMediaPlayerImpl::paint(WebCanvas* canvas,
                                const WebRect& rect) {
   DCHECK(MessageLoop::current() == main_loop_);
   DCHECK(proxy_);
 
 #if WEBKIT_USING_SKIA
-  proxy_->Paint(canvas, rect);
+  if (seeking_ && !cached_bitmap_.empty()) {
+    proxy_->CopyBitmapToCanvas(cached_bitmap_, canvas, rect);
+  } else {
+    proxy_->Paint(canvas, rect);
+  }
 #elif WEBKIT_USING_CG
   // Get the current scaling in X and Y.
   CGAffineTransform mat = CGContextGetCTM(canvas);
   float scale_x = sqrt(mat.a * mat.a + mat.b * mat.b);
   float scale_y = sqrt(mat.c * mat.c + mat.d * mat.d);
   float inverse_scale_x = SkScalarNearlyZero(scale_x) ? 0.0f : 1.0f / scale_x;
   float inverse_scale_y = SkScalarNearlyZero(scale_y) ? 0.0f : 1.0f / scale_y;
   int scaled_width = static_cast<int>(rect.width * fabs(scale_x));
   int scaled_height = static_cast<int>(rect.height * fabs(scale_y));
 
   // Make sure we don't create a huge canvas.
   // TODO(hclam): Respect the aspect ratio.
   if (scaled_width > static_cast<int>(media::Limits::kMaxCanvas))
     scaled_width = media::Limits::kMaxCanvas;
   if (scaled_height > static_cast<int>(media::Limits::kMaxCanvas))
     scaled_height = media::Limits::kMaxCanvas;
 
   // If there is no preexisting platform canvas, or if the size has
   // changed, recreate the canvas.  This is to avoid recreating the bitmap
   // buffer over and over for each frame of video.
   if (!skia_canvas_.get() ||
       skia_canvas_->getDevice()->width() != scaled_width ||
       skia_canvas_->getDevice()->height() != scaled_height) {
     skia_canvas_.reset(
         new skia::PlatformCanvas(scaled_width, scaled_height, true));
   }
 
   // Draw to our temporary skia canvas.
   gfx::Rect normalized_rect(scaled_width, scaled_height);
-  proxy_->Paint(skia_canvas_.get(), normalized_rect);
+  if (seeking_ && !cached_bitmap_.empty()) {
+    proxy_->CopyBitmapToCanvas(
+        cached_bitmap_, skia_canvas_.get(), normalized_rect);
+  } else {
+    proxy_->Paint(skia_canvas_.get(), normalized_rect);
+  }
 
   // The mac coordinate system is flipped vertical from the normal skia
   // coordinates.  During painting of the frame, flip the coordinates
   // system and, for simplicity, also translate the clip rectangle to
   // start at 0,0.
   CGContextSaveGState(canvas);
   CGContextTranslateCTM(canvas, rect.x, rect.height + rect.y);
   CGContextScaleCTM(canvas, inverse_scale_x, -inverse_scale_y);
 
   // We need a local variable CGRect version for DrawToContext.
@@ skipping 23 matching lines @@
   DCHECK(MessageLoop::current() == main_loop_);
 
   // TODO(hclam): If the pipeline is performing streaming, we say that this is
   // a live stream. But instead it should be a StoredStream if we have proper
   // caching.
   if (pipeline_->IsStreaming())
     return WebKit::WebMediaPlayer::LiveStream;
   return WebKit::WebMediaPlayer::Unknown;
 }
 
 WebKit::WebVideoFrame* WebMediaPlayerImpl::getCurrentFrame() {

[scherkus (not reviewing), 2010/12/17 18:50:40]

watch out for these two methods.. they're using the accelerated rendering case

   scoped_refptr<media::VideoFrame> video_frame;
   proxy_->GetCurrentFrame(&video_frame);
   if (video_frame.get())
     return new WebVideoFrameImpl(video_frame);
   return NULL;
 }
 
 void WebMediaPlayerImpl::putCurrentFrame(
     WebKit::WebVideoFrame* web_video_frame) {
   if (web_video_frame) {
@@ skipping 47 matching lines @@
 
 void WebMediaPlayerImpl::OnPipelineSeek() {
   DCHECK(MessageLoop::current() == main_loop_);
   if (pipeline_->GetError() == media::PIPELINE_OK) {
     // Update our paused time.
     if (paused_) {
       paused_time_ = pipeline_->GetCurrentTime();
     }
 
     SetReadyState(WebKit::WebMediaPlayer::HaveEnoughData);
+    seeking_ = false;
     GetClient()->timeChanged();
   }
 }
 
 void WebMediaPlayerImpl::OnPipelineEnded() {
   DCHECK(MessageLoop::current() == main_loop_);
   if (pipeline_->GetError() == media::PIPELINE_OK) {
     GetClient()->timeChanged();
   }
 }
@@ skipping 90 matching lines @@
   pipeline_stopped_.Signal();
 }
 
 WebKit::WebMediaPlayerClient* WebMediaPlayerImpl::GetClient() {
   DCHECK(MessageLoop::current() == main_loop_);
   DCHECK(client_);
   return client_;
 }
 
 }  // namespace webkit_glue