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 23 matching lines @@
 
  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::PIXEL_FORMAT_YV12A);
     media::VideoCaptureFormats formats;
     formats.push_back(format);
     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);
   }
@@ skipping 114 matching lines @@
 
   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),
+      frame_pool_.CreateFrame(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());
+  // Copy alpha channel directly.
+  for (int p = 0; p < size.GetArea(); ++p)
+    video_frame->data(media::VideoFrame::kAPlane)[p] = temp_data_[p * 4 + 3];

[mcasas, 2016/02/25 22:06:25]

Hmm it looks like this deinterlaced could lower 
the performance significantly. I'd love to use 
libyuv::CopyPlane() [1]  but here it doesn't 
match due to the 4*.. + 3 extra calculation. I 
wonder if we could go back to |image| and use 
its readYUV8Planes() [2]? Ah but it doesn't
support Alpha either! :(

Could we at least skip this process overall if
we see somehow that the alpha plane is not
used? We don't expect that every single canvas
would make use of it, right?

[1]
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/libyuv...
[2]
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/skia/i...

[emircan, 2016/02/26 01:33:07]

Unfortunately, there isn't a libyuv method I can directly use for now. I talked
with owners and they agreed to work on one . You can see updates on
https://code.google.com/p/libyuv/issues/detail?id=572. readYUV8Planes() also
doesn't have alpha, and works much slower than libyuv :(

Regarding alpha plane check, I started using SkImage::isOpaque().

+
   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