Handle Alpha channel in Canvas capture

content/renderer/media/webrtc/webrtc_video_capturer_adapter.cc

 // Copyright 2014 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/webrtc/webrtc_video_capturer_adapter.h"
 
 #include "base/bind.h"
 #include "base/memory/aligned_memory.h"
 #include "base/trace_event/trace_event.h"
 #include "content/renderer/media/webrtc/webrtc_video_frame_adapter.h"
 #include "media/base/timestamp_constants.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_frame_pool.h"
+#include "media/base/video_util.h"
 #include "third_party/libyuv/include/libyuv/convert_from.h"
 #include "third_party/libyuv/include/libyuv/scale.h"
 #include "third_party/webrtc/common_video/include/video_frame_buffer.h"
 #include "third_party/webrtc/common_video/rotation.h"
 #include "third_party/webrtc/media/base/videoframefactory.h"
 #include "third_party/webrtc/media/engine/webrtcvideoframe.h"
 
 namespace content {
 namespace {
 
@@ skipping 63 matching lines @@
 
     // Create a centered cropped visible rect that preservers aspect ratio for
     // cropped natural size.
     gfx::Rect visible_rect = frame_->visible_rect();
     visible_rect.ClampToCenteredSize(gfx::Size(
         visible_rect.width() * cropped_input_width / input_frame->width,
         visible_rect.height() * cropped_input_height / input_frame->height));
 
     const gfx::Size output_size(output_width, output_height);
     scoped_refptr<media::VideoFrame> video_frame =
-        media::VideoFrame::WrapVideoFrame(frame_, visible_rect, output_size);
+        media::VideoFrame::WrapVideoFrame(frame_, frame_->format(),
+                                          visible_rect, output_size);
     if (!video_frame)
       return nullptr;
     video_frame->AddDestructionObserver(
         base::Bind(&ReleaseOriginalFrame, frame_));
 
     // If no scaling is needed, return a wrapped version of |frame_| directly.
     if (video_frame->natural_size() == video_frame->visible_rect().size()) {
       return new cricket::WebRtcVideoFrame(
           new rtc::RefCountedObject<WebRtcVideoFrameAdapter>(video_frame),
           timestamp_ns, webrtc::kVideoRotation_0);
@@ skipping 101 matching lines @@
   // just use what is provided.
   // Use the desired format as the best format.
   best_format->width = desired.width;
   best_format->height = desired.height;
   best_format->fourcc = cricket::FOURCC_I420;
   best_format->interval = desired.interval;
   return true;
 }
 
 void WebRtcVideoCapturerAdapter::OnFrameCaptured(
-    const scoped_refptr<media::VideoFrame>& frame) {
+    const scoped_refptr<media::VideoFrame>& video_frame) {
   DCHECK(thread_checker_.CalledOnValidThread());
   TRACE_EVENT0("video", "WebRtcVideoCapturerAdapter::OnFrameCaptured");
-  if (!(frame->IsMappable() && (frame->format() == media::PIXEL_FORMAT_I420 ||
-                                frame->format() == media::PIXEL_FORMAT_YV12))) {
+  if (!(video_frame->IsMappable() &&
+        (video_frame->format() == media::PIXEL_FORMAT_I420 ||
+         video_frame->format() == media::PIXEL_FORMAT_YV12 ||
+         video_frame->format() == media::PIXEL_FORMAT_YV12A))) {
     // Since connecting sources and sinks do not check the format, we need to
     // just ignore formats that we can not handle.
     NOTREACHED();
     return;
   }
+  scoped_refptr<media::VideoFrame> frame = video_frame;
+  // Drop alpha channel since we do not support it yet.
+  if (frame->format() == media::PIXEL_FORMAT_YV12A)
+    frame = media::WrapAsI420VideoFrame(video_frame);
 
   // Inject the frame via the VideoFrameFactory of base class.
   MediaVideoFrameFactory* media_video_frame_factory =
       reinterpret_cast<MediaVideoFrameFactory*>(frame_factory());
   media_video_frame_factory->SetFrame(frame);
 
   // This signals to libJingle that a new VideoFrame is available.
   SignalFrameCaptured(this, media_video_frame_factory->GetCapturedFrame());
 
   media_video_frame_factory->ReleaseFrame();  // Release the frame ASAP.
 }
 
 }  // namespace content