Passing Native Texture backed Video Frame from Renderer to GPU process

content/common/gpu/client/gpu_video_encode_accelerator_host.cc

 // Copyright 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/common/gpu/client/gpu_video_encode_accelerator_host.h"
 
 #include "base/logging.h"
 #include "content/common/gpu/client/gpu_channel_host.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/gpu/media/gpu_video_accelerator_util.h"
@@ skipping 99 matching lines @@
   return true;
 }
 
 void GpuVideoEncodeAcceleratorHost::Encode(
     const scoped_refptr<media::VideoFrame>& frame,
     bool force_keyframe) {
   DCHECK(CalledOnValidThread());
   if (!channel_)
     return;
 
-  if (!base::SharedMemory::IsHandleValid(frame->shared_memory_handle())) {
-    NOTIFY_ERROR(kPlatformFailureError)
-        << "Encode(): cannot encode frame not backed by shared memory";
-    return;
-  }
-  base::SharedMemoryHandle handle =
-      channel_->ShareToGpuProcess(frame->shared_memory_handle());
-  if (!base::SharedMemory::IsHandleValid(handle)) {
-    NOTIFY_ERROR(kPlatformFailureError)
-        << "Encode(): failed to duplicate buffer handle for GPU process";
-    return;
+  AcceleratedVideoEncoderMsg_Encode_Params params;
+  params.frame_id = next_frame_id_;
+  params.force_keyframe = force_keyframe;
+  params.storage_type = frame->storage_type();
+  params.pixel_format = frame->format();
+
+  if (frame->storage_type() == media::VideoFrame::STORAGE_SHMEM) {
+    if (!base::SharedMemory::IsHandleValid(frame->shared_memory_handle())) {
+      NOTIFY_ERROR(kPlatformFailureError) << "EncodeSharedMemory(): cannot "
+                                             "encode frame with invalid shared "
+                                             "memory handle";
+      return;
+    }
+    params.buffer_handle =
+        channel_->ShareToGpuProcess(frame->shared_memory_handle());
+    if (!base::SharedMemory::IsHandleValid(params.buffer_handle)) {
+      NOTIFY_ERROR(kPlatformFailureError) << "EncodeSharedMemory(): failed to "
+                                             "duplicate buffer handle for GPU "
+                                             "process";
+      return;
+    }
+    // We assume that planar frame data passed here is packed and contiguous.
+    params.buffer_size = 0;
+    const size_t plane_count = media::VideoFrame::NumPlanes(frame->format());
+    for (size_t i = 0; i < plane_count; ++i) {
+      // Cast DCHECK parameters to void* to avoid printing uint8* as a string.
+      DCHECK_EQ(reinterpret_cast<void*>(frame->data(i)),
+                reinterpret_cast<void*>((frame->data(0) + params.buffer_size)))
+          << "plane=" << i;
+      params.buffer_size += frame->stride(i) * frame->rows(i);
+    }
+    params.buffer_offset = frame->shared_memory_offset();
   }
 
-  // We assume that planar frame data passed here is packed and contiguous.
-  const size_t plane_count = media::VideoFrame::NumPlanes(frame->format());
-  size_t frame_size = 0;
-  for (size_t i = 0; i < plane_count; ++i) {
-    // Cast DCHECK parameters to void* to avoid printing uint8* as a string.
-    DCHECK_EQ(reinterpret_cast<void*>(frame->data(i)),
-              reinterpret_cast<void*>((frame->data(0) + frame_size)))
-        << "plane=" << i;
-    frame_size += frame->stride(i) * frame->rows(i);
-  }
-
-  Send(new AcceleratedVideoEncoderMsg_Encode(
-      encoder_route_id_, next_frame_id_, handle, frame->shared_memory_offset(),
-      frame_size, force_keyframe));
+  Send(new AcceleratedVideoEncoderMsg_Encode(encoder_route_id_, params));
   frame_map_[next_frame_id_] = frame;
 
   // Mask against 30 bits, to avoid (undefined) wraparound on signed integer.
   next_frame_id_ = (next_frame_id_ + 1) & 0x3FFFFFFF;
 }
 
 void GpuVideoEncodeAcceleratorHost::UseOutputBitstreamBuffer(
     const media::BitstreamBuffer& buffer) {
   DCHECK(CalledOnValidThread());
   if (!channel_)
@@ skipping 111 matching lines @@
   weak_this_factory_.InvalidateWeakPtrs();
 
   // Client::NotifyError() may Destroy() |this|, so calling it needs to be the
   // last thing done on this stack!
   media::VideoEncodeAccelerator::Client* client = NULL;
   std::swap(client_, client);
   client->NotifyError(error);
 }
 
 }  // namespace content