Handle Alpha channel in Canvas capture

content/renderer/media/canvas_capture_handler.cc

 // Copyright 2015 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 "content/renderer/media/canvas_capture_handler.h"
 
 #include <utility>
 
 #include "base/base64.h"
 #include "base/bind_helpers.h"
@@ skipping 21 matching lines @@
       : frame_rate_(frame_rate),
         canvas_handler_(canvas_handler) {}
 
  protected:
   void GetCurrentSupportedFormats(
       int max_requested_width,
       int max_requested_height,
       double max_requested_frame_rate,
       const VideoCaptureDeviceFormatsCB& callback) override {
     const blink::WebSize& size = canvas_handler_->GetSourceSize();
-    const media::VideoCaptureFormat format(gfx::Size(size.width, size.height),
-                                           frame_rate_,
-                                           media::PIXEL_FORMAT_I420);
     media::VideoCaptureFormats formats;
-    formats.push_back(format);
+    formats.push_back(
+        media::VideoCaptureFormat(gfx::Size(size.width, size.height),
+                                  frame_rate_, media::PIXEL_FORMAT_I420));
+    formats.push_back(
+        media::VideoCaptureFormat(gfx::Size(size.width, size.height),
+                                  frame_rate_, media::PIXEL_FORMAT_YV12A));
     callback.Run(formats);
   }
   void StartCapture(const media::VideoCaptureParams& params,
                     const VideoCaptureDeliverFrameCB& frame_callback,
                     const RunningCallback& running_callback) override {
     canvas_handler_->StartVideoCapture(params, frame_callback,
                                        running_callback);
   }
   void StopCapture() override {
     canvas_handler_->StopVideoCapture();
@@ skipping 102 matching lines @@
 
 void CanvasCaptureHandler::StopVideoCapture() {
   DVLOG(3) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
   ask_for_new_frame_ = false;
   io_task_runner_->DeleteSoon(FROM_HERE, delegate_.release());
 }
 
 void CanvasCaptureHandler::CreateNewFrame(const SkImage* image) {
   DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(image);
 
-  DCHECK(image);
   const gfx::Size size(image->width(), image->height());
   if (size != last_size) {
     temp_data_.resize(
         media::VideoFrame::AllocationSize(media::PIXEL_FORMAT_ARGB, size));
     row_bytes_ =
         media::VideoFrame::RowBytes(0, media::PIXEL_FORMAT_ARGB, size.width());
     image_info_ =
         SkImageInfo::Make(size.width(), size.height(), kBGRA_8888_SkColorType,
-                          kPremul_SkAlphaType);
+                          kUnpremul_SkAlphaType);
     last_size = size;
   }
 
-  image->readPixels(image_info_, &temp_data_[0], row_bytes_, 0, 0);
-  scoped_refptr<media::VideoFrame> video_frame =
-      frame_pool_.CreateFrame(media::PIXEL_FORMAT_I420, size, gfx::Rect(size),
-                              size, base::TimeTicks::Now() - base::TimeTicks());
+  if(!image->readPixels(image_info_, &temp_data_[0], row_bytes_, 0, 0)) {
+    DLOG(ERROR) << "Couldn't read SkImage pixels";
+    return;
+  }
+
+  const bool isOpaque = image->isOpaque();
+  scoped_refptr<media::VideoFrame> video_frame = frame_pool_.CreateFrame(
+      isOpaque ? media::PIXEL_FORMAT_I420 : media::PIXEL_FORMAT_YV12A, size,
+      gfx::Rect(size), size, base::TimeTicks::Now() - base::TimeTicks());
   DCHECK(video_frame);
 
+  // TODO(emircan): Use https://code.google.com/p/libyuv/issues/detail?id=572
+  // when it becomes available.
   libyuv::ARGBToI420(temp_data_.data(), row_bytes_,
                      video_frame->data(media::VideoFrame::kYPlane),
                      video_frame->stride(media::VideoFrame::kYPlane),
                      video_frame->data(media::VideoFrame::kUPlane),
                      video_frame->stride(media::VideoFrame::kUPlane),
                      video_frame->data(media::VideoFrame::kVPlane),
                      video_frame->stride(media::VideoFrame::kVPlane),
                      size.width(), size.height());
+  if (!isOpaque) {
+    for (int p = 0; p < size.GetArea(); ++p)
+      video_frame->data(media::VideoFrame::kAPlane)[p] = temp_data_[p * 4 + 3];
+  }
+
   io_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&CanvasCaptureHandler::CanvasCaptureHandlerDelegate::
                      SendNewFrameOnIOThread,
                  delegate_->GetWeakPtrForIOThread(), video_frame,
                  base::TimeTicks()));
 }
 
 void CanvasCaptureHandler::AddVideoCapturerSourceToVideoTrack(
     scoped_ptr<media::VideoCapturerSource> source,
@@ skipping 11 matching lines @@
 
   web_track->initialize(webkit_source);
   blink::WebMediaConstraints constraints;
   constraints.initialize();
   web_track->setExtraData(new MediaStreamVideoTrack(
       media_stream_source.release(), constraints,
       MediaStreamVideoSource::ConstraintsCallback(), true));
 }
 
 }  // namespace content