ImageCapture.grabFrame()/<video>.captureStream(), use ABGR pixel format for Android

content/renderer/media/html_video_element_capturer_source.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/html_video_element_capturer_source.h"
 
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 129 matching lines @@
       0xFF /* alpha */, SkXfermode::kSrc_Mode);
   DCHECK_NE(kUnknown_SkColorType, canvas->imageInfo().colorType());
   DCHECK_EQ(canvas->imageInfo().width(), resolution.width);
   DCHECK_EQ(canvas->imageInfo().height(), resolution.height);
 
   const SkBitmap bitmap = skia::ReadPixels(canvas);
   DCHECK_NE(kUnknown_SkColorType, bitmap.colorType());
   DCHECK(!bitmap.drawsNothing());
   DCHECK(bitmap.getPixels());
   if (bitmap.colorType() != kN32_SkColorType) {
-    DLOG(ERROR) << "Only supported capture format is ARGB";
+    DLOG(ERROR) << "Only supported color type is kN32_SkColorType (ARGB/ABGR)";
     return;
   }
 
   scoped_refptr<media::VideoFrame> frame = frame_pool_.CreateFrame(
       media::PIXEL_FORMAT_I420, resolution, gfx::Rect(resolution), resolution,
       base::TimeTicks::Now() - base::TimeTicks());
   DCHECK(frame);
 
+  const uint32 source_pixel_format =
+      (kN32_SkColorType == kRGBA_8888_SkColorType) ? libyuv::FOURCC_ABGR
+                                                   : libyuv::FOURCC_ARGB;
+
   if (libyuv::ConvertToI420(static_cast<uint8*>(bitmap.getPixels()),
                             bitmap.getSize(),
                             frame->data(media::VideoFrame::kYPlane),
                             frame->stride(media::VideoFrame::kYPlane),
                             frame->data(media::VideoFrame::kUPlane),
                             frame->stride(media::VideoFrame::kUPlane),
                             frame->data(media::VideoFrame::kVPlane),
                             frame->stride(media::VideoFrame::kVPlane),
                             0 /* crop_x */,
                             0 /* crop_y */,
                             bitmap.info().width(),
                             bitmap.info().height(),
                             frame->coded_size().width(),
                             frame->coded_size().height(),
                             libyuv::kRotate0,
-                            libyuv::FOURCC_ARGB) == 0) {
+                            source_pixel_format) == 0) {
     // Success!
     io_task_runner_->PostTask(
         FROM_HERE, base::Bind(new_frame_callback_, frame, current_time));
   }
 
   // Calculate the time in the future where the next frame should be created.
   const base::TimeDelta frame_interval =
       base::TimeDelta::FromMicroseconds(1E6 / capture_frame_rate_);
   if (next_capture_time_.is_null()) {
     next_capture_time_ = current_time + frame_interval;
   } else {
     next_capture_time_ += frame_interval;
     // Don't accumulate any debt if we are lagging behind - just post next frame
     // immediately and continue as normal.
     if (next_capture_time_ < current_time)
       next_capture_time_ = current_time;
   }
   // Schedule next capture.
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&HtmlVideoElementCapturerSource::sendNewFrame,
                             weak_factory_.GetWeakPtr()),
       next_capture_time_ - current_time);
 }
 
 }  // namespace content