Home | History | Annotate | Download | only in layers 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "cc/layers/video_frame_provider_client_impl.h"
      6 
      7 #include "base/debug/trace_event.h"
      8 #include "cc/base/math_util.h"
      9 #include "cc/layers/video_layer_impl.h"
     10 #include "media/base/video_frame.h"
     11 
     12 namespace cc {
     13 
     14 // static
     15 scoped_refptr<VideoFrameProviderClientImpl>
     16     VideoFrameProviderClientImpl::Create(
     17         VideoFrameProvider* provider) {
     18   return make_scoped_refptr(
     19       new VideoFrameProviderClientImpl(provider));
     20 }
     21 
     22 VideoFrameProviderClientImpl::~VideoFrameProviderClientImpl() {}
     23 
     24 VideoFrameProviderClientImpl::VideoFrameProviderClientImpl(
     25     VideoFrameProvider* provider)
     26     : active_video_layer_(NULL), provider_(provider) {
     27   // This only happens during a commit on the compositor thread while the main
     28   // thread is blocked. That makes this a thread-safe call to set the video
     29   // frame provider client that does not require a lock. The same is true of
     30   // the call to Stop().
     31   provider_->SetVideoFrameProviderClient(this);
     32 
     33   // This matrix is the default transformation for stream textures, and flips
     34   // on the Y axis.
     35   stream_texture_matrix_ = gfx::Transform(
     36       1.0, 0.0, 0.0, 0.0,
     37       0.0, -1.0, 0.0, 1.0,
     38       0.0, 0.0, 1.0, 0.0,
     39       0.0, 0.0, 0.0, 1.0);
     40 }
     41 
     42 void VideoFrameProviderClientImpl::Stop() {
     43   if (!provider_)
     44     return;
     45   provider_->SetVideoFrameProviderClient(NULL);
     46   provider_ = NULL;
     47 }
     48 
     49 scoped_refptr<media::VideoFrame>
     50 VideoFrameProviderClientImpl::AcquireLockAndCurrentFrame() {
     51   provider_lock_.Acquire();  // Balanced by call to ReleaseLock().
     52   if (!provider_)
     53     return NULL;
     54 
     55   return provider_->GetCurrentFrame();
     56 }
     57 
     58 void VideoFrameProviderClientImpl::PutCurrentFrame(
     59     const scoped_refptr<media::VideoFrame>& frame) {
     60   provider_lock_.AssertAcquired();
     61   provider_->PutCurrentFrame(frame);
     62 }
     63 
     64 void VideoFrameProviderClientImpl::ReleaseLock() {
     65   provider_lock_.AssertAcquired();
     66   provider_lock_.Release();
     67 }
     68 
     69 void VideoFrameProviderClientImpl::StopUsingProvider() {
     70   // Block the provider from shutting down until this client is done
     71   // using the frame.
     72   base::AutoLock locker(provider_lock_);
     73   provider_ = NULL;
     74 }
     75 
     76 void VideoFrameProviderClientImpl::DidReceiveFrame() {
     77   TRACE_EVENT1("cc",
     78                "VideoFrameProviderClientImpl::DidReceiveFrame",
     79                "active_video_layer",
     80                !!active_video_layer_);
     81   if (active_video_layer_)
     82     active_video_layer_->SetNeedsRedraw();
     83 }
     84 
     85 void VideoFrameProviderClientImpl::DidUpdateMatrix(const float* matrix) {
     86   stream_texture_matrix_ = gfx::Transform(
     87       matrix[0], matrix[4], matrix[8], matrix[12],
     88       matrix[1], matrix[5], matrix[9], matrix[13],
     89       matrix[2], matrix[6], matrix[10], matrix[14],
     90       matrix[3], matrix[7], matrix[11], matrix[15]);
     91   if (active_video_layer_)
     92     active_video_layer_->SetNeedsRedraw();
     93 }
     94 
     95 }  // namespace cc
     96