[WIP] Proxy RtcVideoDecoder calls to a media::VideoDecoder.

media/mojo/services/mojo_video_decoder_service.cc

 // Copyright 2016 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 "media/mojo/services/mojo_video_decoder_service.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/logging.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/video_decoder.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
 #include "media/mojo/common/media_type_converters.h"
 #include "media/mojo/common/mojo_decoder_buffer_converter.h"
+#include "media/mojo/common/mojo_shared_buffer_video_frame.h"
 #include "media/mojo/services/mojo_media_client.h"
 #include "mojo/public/c/system/types.h"
 #include "mojo/public/cpp/system/buffer.h"
 #include "mojo/public/cpp/system/handle.h"
 
 namespace media {
 
 MojoVideoDecoderService::MojoVideoDecoderService(
     MojoMediaClient* mojo_media_client)
     : mojo_media_client_(mojo_media_client), weak_factory_(this) {
@@ skipping 39 matching lines @@
 
 void MojoVideoDecoderService::OnDecoderInitialized(
     const InitializeCallback& callback,
     bool success) {
   DVLOG(1) << __FUNCTION__;
   callback.Run(success);
 }
 
 void MojoVideoDecoderService::OnDecoderOutput(
     const scoped_refptr<VideoFrame>& frame) {
-  DVLOG(1) << __FUNCTION__;
+  VLOG(0) << __FUNCTION__;
   DCHECK(client_);
-  client_->OnVideoFrameDecoded(mojom::VideoFrame::From(frame));
+
+  const size_t y_plane_size =
+      frame->rows(VideoFrame::kYPlane) * frame->stride(VideoFrame::kYPlane);
+  const size_t u_plane_size =
+      frame->rows(VideoFrame::kUPlane) * frame->stride(VideoFrame::kUPlane);
+
+  // Allocate a mojo::SharedBufferHandle big enough to contain |frame|'s data.
+  size_t buffer_size =
+      VideoFrame::AllocationSize(frame->format(), frame->coded_size());
+  mojo::ScopedSharedBufferHandle shared_buffer =
+      mojo::SharedBufferHandle::Create(buffer_size);
+  DCHECK(shared_buffer.is_valid());
+  mojo::ScopedSharedBufferMapping shared_buffer_memory =
+      shared_buffer->Map(buffer_size);
+
+  // Copy data into the shared buffer.
+  size_t offset = 0;
+  static size_t planes[] = {VideoFrame::kYPlane, VideoFrame::kUPlane,
+                            VideoFrame::kVPlane};
+  for (size_t plane : planes) {
+    size_t plane_size = frame->rows(plane) * frame->stride(plane);
+    memcpy(reinterpret_cast<uint8_t*>(shared_buffer_memory.get()) + offset,
+           frame->data(plane), plane_size);
+    offset += plane_size;
+  }
+
+  // Create a MojoSharedBufferVideoFrame whose dimensions match |color_frame|.
+  scoped_refptr<VideoFrame> mojo_frame = MojoSharedBufferVideoFrame::Create(
+      frame->format(), frame->coded_size(), frame->visible_rect(),
+      frame->natural_size(), std::move(shared_buffer), buffer_size, 0,
+      y_plane_size, y_plane_size + u_plane_size,
+      frame->stride(VideoFrame::kYPlane), frame->stride(VideoFrame::kUPlane),
+      frame->stride(VideoFrame::kVPlane), frame->timestamp());
+
+  client_->OnVideoFrameDecoded(mojom::VideoFrame::From(mojo_frame));
 }
 
 void MojoVideoDecoderService::Decode(mojom::DecoderBufferPtr buffer,
                                      const DecodeCallback& callback) {
   DVLOG(1) << __FUNCTION__;
 
   if (!decoder_) {
     callback.Run(mojom::DecodeStatus::DECODE_ERROR);
     return;
   }
@@ skipping 29 matching lines @@
   decoder_->Reset(base::Bind(&MojoVideoDecoderService::OnDecoderReset,
                              weak_this_, callback));
 }
 
 void MojoVideoDecoderService::OnDecoderReset(const ResetCallback& callback) {
   DVLOG(1) << __FUNCTION__;
   callback.Run();
 }
 
 }  // namespace media