FakeVideoCaptureDevice: add support for capturing into Dma-Bufs using VGEM in CrOs

media/video/capture/fake_video_capture_device.cc

 // Copyright (c) 2012 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/video/capture/fake_video_capture_device.h"
 
 #include <string>
 
+#if defined(OS_CHROMEOS) && defined(USE_OZONE)
+#include <errno.h>
+#include <sys/fcntl.h>
+#include <sys/mman.h>
+#include <xf86drm.h>
+#endif
+
 #include "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "media/audio/fake_audio_input_stream.h"
 #include "media/base/video_frame.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPaint.h"
 
+#if defined(OS_CHROMEOS) && defined(USE_OZONE)
+#include "base/files/file_enumerator.h"
+#include "base/posix/eintr_wrapper.h"
+#include "base/strings/string_util.h"
+#endif
+
 namespace media {
 
 static const int kFakeCaptureBeepCycle = 10;  // Visual beep every 0.5s.
 
+#if defined(OS_CHROMEOS) && defined(USE_OZONE)
+static const char kVgemSysCardPath[] = "/sys/bus/platform/devices/vgem/drm/";
+static const char kVgemDevDriCardPathFormat[] = "/dev/dri/card%d";
+
+// Class to encapsulate opening the Vgem Fd and using it for mmap()ing and
+// munmap()ing an incoming PrimeFd representing a Dma-Buf.
+class FakeVideoCaptureDevice::VgemWrapper {
+ public:
+  VgemWrapper() {}
+  ~VgemWrapper() {}
+
+  // Finds out the /dev/dri/cardX associated with the Vgem, if any, and tries to
+  // open it. IsValid() tells if it has succeeded.
+  void Initialize();
+  bool IsValid() const { return vgem_fd_.is_valid(); }
+
+  // Tries to mmap() and incoming Dma-Buf PrimeFd into process space.
+  uint8* MmapPrimeFd(base::PlatformFile dma_buf_fd, size_t size);
+  // munmap()s the given |data_ptr| obtained from MmapPrimeFd().
+  void MunmapPointer(uint8* data_ptr, size_t size);
+
+ private:
+  base::ScopedFD vgem_fd_;
+};
+
+void FakeVideoCaptureDevice::VgemWrapper::Initialize() {
+  // VGEM fd is a /dev/dri device but we cannot know in advance which one, for
+  // that we inspect the /sys/.../vgem/.../cardX, if we find one such card, then
+  // VGEM is present in the system and we can reuse the index.
+  base::FileEnumerator file_iter(
+      base::FilePath::FromUTF8Unsafe(kVgemSysCardPath),
+      true,
+      base::FileEnumerator::FILES,

[dshwang, 2015/05/12 12:58:44]

false, base::FileEnumerator::DIRECTORIES,

I use this logic in https://codereview.chromium.org/1124063003/ as mcasas
advised.
How about getting vgem fd from drm_display_host_manager.cc, instead of opening
fd in ad-hoc way?

+      FILE_PATH_LITERAL("card*"));
+
+  while (!file_iter.Next().empty()) {
+    // Inspect the card%d files in the directory, if any. Extract the index.
+    DVLOG(1) << file_iter.GetInfo().GetName().BaseName().MaybeAsASCII();
+    std::string name(file_iter.GetInfo().GetName().BaseName().MaybeAsASCII());
+    base::TrimString(name, "card", &name);
+    errno = 0;
+    const int device_index = strtol(name.c_str(), NULL, 10);
+    DLOG_IF(ERROR, errno != 0) << "Error extracting integer from " << name;
+    if (errno  != 0)
+      return;
+
+    const base::FilePath vgem_path = base::FilePath(
+        base::StringPrintf(kVgemDevDriCardPathFormat, device_index));
+    DVLOG(1) << "possible Vgem fd is " << vgem_path.MaybeAsASCII();
+
+    vgem_fd_.reset(
+        HANDLE_EINTR(open(vgem_path.MaybeAsASCII().c_str(), O_RDWR)));
+    if (vgem_fd_.is_valid()) {
+      DVLOG(1) << "Opened Vgem file " << vgem_path.MaybeAsASCII();
+      return;
+    }
+    DLOG(ERROR) << "Failed to open vgem device driver file "
+                << vgem_path.MaybeAsASCII();
+  }
+}
+
+uint8* FakeVideoCaptureDevice::VgemWrapper::MmapPrimeFd(
+    base::PlatformFile dma_buf_fd,
+    size_t size) {
+  uint32_t foreign_imported_handle;
+  int result = drmPrimeFDToHandle(vgem_fd_.get(),
+                                  dma_buf_fd,
+                                  &foreign_imported_handle);
+  if (result) {
+    DLOG(ERROR) << "Error mapping PrimeFd to Handle";
+    return nullptr;
+  }
+
+  struct drm_mode_map_dumb mmap_arg = {};
+  mmap_arg.handle = foreign_imported_handle;
+  result = drmIoctl(vgem_fd_.get(),
+                    DRM_IOCTL_MODE_MAP_DUMB,
+                    &mmap_arg);
+  if (result || (mmap_arg.offset == 0u)) {
+    DLOG(ERROR) << "Error preparing Handle to be mmap()ed";
+    return nullptr;
+  }
+
+  void* data_ptr = mmap(NULL, size, (PROT_READ | PROT_WRITE), MAP_SHARED,
+                        vgem_fd_.get(), mmap_arg.offset);
+  if (data_ptr == MAP_FAILED) {
+    DLOG(ERROR) << "Error mmap()ing the dma-buf into userspace";
+    return nullptr;
+  }
+  return static_cast<uint8*>(data_ptr);
+}
+
+void FakeVideoCaptureDevice::VgemWrapper::MunmapPointer(
+    uint8* data_ptr, size_t size) {
+  munmap(data_ptr, size);
+}
+#endif
+
 void DrawPacman(bool use_argb,
                 uint8_t* const data,
                 int frame_count,
                 int frame_interval,
                 const gfx::Size& frame_size) {
   // |kN32_SkColorType| stands for the appropriiate RGBA/BGRA format.
   const SkColorType colorspace =
       use_argb ? kN32_SkColorType : kAlpha_8_SkColorType;
   const SkImageInfo info = SkImageInfo::Make(frame_size.width(),
                                              frame_size.height(),
@@ skipping 62 matching lines @@
   capture_format_.frame_rate = 30.0;
   if (params.requested_format.frame_size.width() > 1280)
       capture_format_.frame_size.SetSize(1920, 1080);
   else if (params.requested_format.frame_size.width() > 640)
       capture_format_.frame_size.SetSize(1280, 720);
   else if (params.requested_format.frame_size.width() > 320)
     capture_format_.frame_size.SetSize(640, 480);
   else
     capture_format_.frame_size.SetSize(320, 240);
 
+#if defined(OS_CHROMEOS) && defined(USE_OZONE)
+    vgem_wrapper_.reset(new VgemWrapper());
+    vgem_wrapper_->Initialize();
+#endif
+
   if (device_type_ == USING_OWN_BUFFERS ||
       device_type_ == USING_OWN_BUFFERS_TRIPLANAR) {
     fake_frame_.reset(new uint8[VideoFrame::AllocationSize(
         VideoFrame::I420, capture_format_.frame_size)]);
     BeepAndScheduleNextCapture(
         base::Bind(&FakeVideoCaptureDevice::CaptureUsingOwnBuffers,
                    weak_factory_.GetWeakPtr()));
   } else if (device_type_ == USING_CLIENT_BUFFERS_I420 ||
              device_type_ == USING_CLIENT_BUFFERS_GPU) {
     DVLOG(1) << "starting with " << (device_type_ == USING_CLIENT_BUFFERS_I420
@@ skipping 51 matching lines @@
 
 void FakeVideoCaptureDevice::CaptureUsingClientBuffers(
     VideoPixelFormat pixel_format) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   scoped_ptr<VideoCaptureDevice::Client::Buffer> capture_buffer(
       client_->ReserveOutputBuffer(pixel_format, capture_format_.frame_size));
   DLOG_IF(ERROR, !capture_buffer) << "Couldn't allocate Capture Buffer";
 
   if (capture_buffer.get()) {
-    uint8_t* const data_ptr = static_cast<uint8_t*>(capture_buffer->data());
-    DCHECK(data_ptr) << "Buffer has NO backing memory";
-    DCHECK_EQ(capture_buffer->GetType(), gfx::SHARED_MEMORY_BUFFER);
+    uint8_t* data_ptr = static_cast<uint8_t*>(capture_buffer->data());
+
+#if defined(OS_CHROMEOS) && defined(USE_OZONE)
+    if (!data_ptr && vgem_wrapper_->IsValid()) {
+      data_ptr = vgem_wrapper_->MmapPrimeFd(capture_buffer->AsPlatformFile(),
+                                            capture_buffer->size());
+    }
+#endif
+    DCHECK(data_ptr);
     memset(data_ptr, 0, capture_buffer->size());
 
     DrawPacman(
         (pixel_format == media::PIXEL_FORMAT_GPUMEMORYBUFFER), /* use_argb */
         data_ptr,
         frame_count_,
         kFakeCapturePeriodMs,
         capture_format_.frame_size);
 
     // Give the captured frame to the client.
     const VideoCaptureFormat format(capture_format_.frame_size,
                                     capture_format_.frame_rate,
                                     pixel_format);
     client_->OnIncomingCapturedBuffer(capture_buffer.Pass(), format,
                                       base::TimeTicks::Now());
+#if defined(OS_CHROMEOS) && defined(USE_OZONE)
+    if (vgem_wrapper_->IsValid())
+      vgem_wrapper_->MunmapPointer(data_ptr, capture_buffer->size());
+#endif
   }
 
   BeepAndScheduleNextCapture(
       base::Bind(&FakeVideoCaptureDevice::CaptureUsingClientBuffers,
                  weak_factory_.GetWeakPtr(), pixel_format));
 }
 
 void FakeVideoCaptureDevice::BeepAndScheduleNextCapture(
     const base::Closure& next_capture) {
   // Generate a synchronized beep sound every so many frames.
   if (frame_count_++ % kFakeCaptureBeepCycle == 0)
     FakeAudioInputStream::BeepOnce();
 
   // Reschedule next CaptureTask.
   base::MessageLoop::current()->PostDelayedTask(FROM_HERE, next_capture,
       base::TimeDelta::FromMilliseconds(kFakeCapturePeriodMs));
 }
 
 }  // namespace media