Effects Pepper Plugin and MediaStream Glue.

content/renderer/media/video_destination_handler.cc

Index: content/renderer/media/video_destination_handler.cc
===================================================================
--- content/renderer/media/video_destination_handler.cc	(revision 0)
+++ content/renderer/media/video_destination_handler.cc	(revision 0)
@@ -0,0 +1,151 @@
+// Copyright (c) 2013 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/video_destination_handler.h"
+
+#include <string>
+
+#include "base/logging.h"
+#include "content/renderer/media/media_stream_dependency_factory.h"
+#include "content/renderer/media/media_stream_registry_interface.h"
+#include "content/renderer/render_thread_impl.h"
+#include "third_party/WebKit/Source/WebKit/chromium/public/WebMediaStreamRegistry.h"
+#include "webkit/plugins/ppapi/ppb_image_data_impl.h"
+
+using cricket::CaptureState;
+using cricket::VideoFormat;
+using webkit::ppapi::PPB_ImageData_Impl;
+
+static const cricket::FourCC kEffectColorFormat = cricket::FOURCC_BGRA;
+
+namespace content {
+
+PpFrameWriter::PpFrameWriter()
+    : started_(false) {}
+
+PpFrameWriter::~PpFrameWriter() {}
+
+CaptureState PpFrameWriter::Start(const VideoFormat& capture_format) {
+  if (started_) {
+    LOG(ERROR) << "PpFrameWriter::Start - "
+               << "Got a StartCapture when already started!";
+    return cricket::CS_FAILED;
+  }
+  started_ = true;
+  return cricket::CS_STARTING;
+}
+
+void PpFrameWriter::Stop() {
+  started_ = false;
+  SignalStateChange(this, cricket::CS_STOPPED);
+}
+
+bool PpFrameWriter::IsRunning() {
+  return started_;
+}
+
+bool PpFrameWriter::GetPreferredFourccs(std::vector<uint32>* fourccs) {
+  if (!fourccs) {
+    LOG(ERROR) << "PpFrameWriter::GetPreferredFourccs - "
+               << "fourccs is NULL.";
+    return false;
+  }
+  // The effects plugin output BGRA.
+  fourccs->push_back(kEffectColorFormat);
+  return true;
+}
+
+bool PpFrameWriter::GetBestCaptureFormat(const VideoFormat& desired,
+                                         VideoFormat* best_format) {
+  if (!best_format) {
+    LOG(ERROR) << "PpFrameWriter::GetBestCaptureFormat - "
+               << "best_format is NULL.";
+    return false;
+  }
+
+  // Use the desired format as the best format.
+  best_format->width = desired.width;
+  best_format->height = desired.height;
+  best_format->fourcc = kEffectColorFormat;
+  best_format->interval = desired.interval;
+  return true;
+}
+
+bool PpFrameWriter::IsScreencast() const {
+  return false;
+}
+
+void PpFrameWriter::PutFrame(PPB_ImageData_Impl* image_data,
+                             int64 time_stamp_ns) {
+  ASSERT(image_data != NULL);
+  webkit::ppapi::ImageDataAutoMapper mapper(image_data);
+  if (!mapper.is_valid()) {
+    LOG(ERROR) << "PpFrameWriter::PutFrame - "
+               << "The image could not be mapped and is unusable.";
+    return;
+  }
+  const SkBitmap* bitmap = image_data->GetMappedBitmap();
+  ASSERT(bitmap != NULL);
+
+  cricket::CapturedFrame frame;
+  frame.elapsed_time = 0;
+  frame.time_stamp = time_stamp_ns;
+  frame.pixel_height = 1;
+  frame.pixel_width = 1;
+  frame.width = bitmap->width();
+  frame.height = bitmap->height();
+  if (image_data->format() == PP_IMAGEDATAFORMAT_BGRA_PREMUL) {
+    frame.fourcc = cricket::FOURCC_BGRA;
+  } else {
+    LOG(ERROR) << "PpFrameWriter::PutFrame - Got RGBA which is not supported.";

[wjia(left Chromium), 2013/05/03 02:00:38]

Is this technically impossible or just it just can't happen? I think converting
RGBA to BGRA is not a big task.

[Ronghua Wu (Left Chromium), 2013/05/03 05:37:28]

RGBA is not supported by the libjingle video frame, but as you said we can also
do the converting here. However effects plugin should output BGRA according to
the current design. So I thought just put an assert here. 

If later the plugin outputs different format, we can add the converting support
to libjingle then here we can just do frame.fourcc = XXXX; and let the libjingle
does the converting.

+    ASSERT(false);
+    return;
+  }
+  frame.data_size = bitmap->getSize();
+  frame.data = bitmap->getPixels();
+
+  // This signals to libJingle that a new VideoFrame is available.
+  // libJingle have no assumptions on what thread this signal come from.
+  SignalFrameCaptured(this, &frame);
+}
+
+VideoDestinationHandler::VideoDestinationHandler(
+    MediaStreamDependencyFactory* factory,
+    MediaStreamRegistryInterface* registry)
+    : factory_(factory),
+      registry_(registry) {
+  ASSERT(factory_ != NULL);
+}
+
+bool VideoDestinationHandler::Open(
+    const std::string& url, FrameWriterInterface** frame_writer) {
+  WebKit::WebMediaStream stream;
+  if (registry_) {
+    stream = registry_->GetMediaStream(url);
+  } else {
+    stream =
+        WebKit::WebMediaStreamRegistry::lookupMediaStreamDescriptor(GURL(url));
+  }
+  if (stream.isNull() || !stream.extraData()) {
+    LOG(ERROR) << "VideoDestinationHandler::Open - invalid url: " << url;
+    return false;
+  }
+
+  // Create a new native video track and add it to |stream|.
+  std::string track_id = talk_base::ToString(talk_base::CreateRandomId64());
+  PpFrameWriter* capturer = new PpFrameWriter();
+  if (!factory_->AddNativeVideoMediaTrack(track_id, &stream, capturer)) {
+    delete capturer;
+    return false;
+  }
+
+  *frame_writer = capturer;
+  return true;
+}
+
+VideoDestinationHandler::~VideoDestinationHandler() {
+}
+
+}  // namespace content
+
Property changes on: content/renderer/media/video_destination_handler.cc
___________________________________________________________________
Added: svn:eol-style
   + LF