Video capture implementation using the Media Foundation API.

media/video/capture/win/video_capture_device_mf_win.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/win/video_capture_device_mf_win.h"
+
+#include <mferror.h>
+
+#include "base/lazy_instance.h"
+#include "base/memory/ref_counted.h"
+#include "base/synchronization/waitable_event.h"
+#include "base/sys_string_conversions.h"
+#include "base/win/scoped_co_mem.h"
+#include "media/video/capture/win/capability_list_win.h"
+
+using base::win::ScopedCoMem;
+using base::win::ScopedComPtr;
+
+namespace {
+
+using media::CapabilityList;

[darin (slow to review), 2012/11/29 00:28:05]

nit: i recommend putting the anonymous namespace within the media namespace so
you won't need these using directives.

[tommi (sloooow) - chröme, 2012/11/29 11:02:58]

Done.

+using media::VideoCaptureCapability;
+using media::VideoCaptureCapabilityWin;
+
+class MFInitializerSingleton {
+ public:
+  MFInitializerSingleton() { MFStartup(MF_VERSION, MFSTARTUP_LITE); }
+  ~MFInitializerSingleton() { MFShutdown(); }
+};
+
+static base::LazyInstance<MFInitializerSingleton> g_mf_initialize =
+    LAZY_INSTANCE_INITIALIZER;
+
+void EnsureMFInit() {
+  g_mf_initialize.Get();
+}
+
+bool PrepareVideoCaptureAttributes(IMFAttributes** attributes, int count) {
+  EnsureMFInit();
+
+  if (FAILED(MFCreateAttributes(attributes, count)))
+    return false;
+
+  return SUCCEEDED((*attributes)->SetGUID(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE,
+      MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_GUID));
+}
+
+bool EnumerateVideoDevices(IMFActivate*** devices,
+                           UINT32* count) {
+  ScopedComPtr<IMFAttributes> attributes;
+  if (!PrepareVideoCaptureAttributes(attributes.Receive(), 1))
+    return false;
+
+  return SUCCEEDED(MFEnumDeviceSources(attributes, devices, count));
+}
+
+bool CreateVideoCaptureDevice(const char* sym_link, IMFMediaSource** source) {
+  ScopedComPtr<IMFAttributes> attributes;
+  if (!PrepareVideoCaptureAttributes(attributes.Receive(), 2))
+    return false;
+
+  attributes->SetString(MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK,
+                        base::SysUTF8ToWide(sym_link).c_str());
+
+  return SUCCEEDED(MFCreateDeviceSource(attributes, source));
+}
+
+bool FormatFromGuid(const GUID& guid, VideoCaptureCapability::Format* format) {
+  struct {
+    const GUID& guid;
+    const VideoCaptureCapability::Format format;
+  } static const kFormatMap[] = {
+    { MFVideoFormat_I420, VideoCaptureCapability::kI420 },
+    { MFVideoFormat_YUY2, VideoCaptureCapability::kYUY2 },
+    { MFVideoFormat_UYVY, VideoCaptureCapability::kUYVY },
+    { MFVideoFormat_RGB24, VideoCaptureCapability::kRGB24 },
+    { MFVideoFormat_ARGB32, VideoCaptureCapability::kARGB },
+    { MFVideoFormat_MJPG, VideoCaptureCapability::kMJPEG },
+    { MFVideoFormat_YV12, VideoCaptureCapability::kYV12 },
+  };
+
+  for (int i = 0; i < arraysize(kFormatMap); ++i) {
+    if (kFormatMap[i].guid == guid) {
+      *format = kFormatMap[i].format;
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool GetFrameSize(IMFMediaType* type, int* width, int* height) {
+  UINT32 width32, height32;
+  if (FAILED(MFGetAttributeSize(type, MF_MT_FRAME_SIZE, &width32, &height32)))
+    return false;
+  *width = width32;
+  *height = height32;
+  return true;
+}
+
+bool GetFrameRate(IMFMediaType* type, int* frame_rate) {
+  UINT32 numerator, denominator;
+  if (FAILED(MFGetAttributeRatio(type, MF_MT_FRAME_RATE, &numerator,
+                                 &denominator))) {
+    return false;
+  }
+  *frame_rate = numerator / denominator;
+  return true;
+}
+
+bool FillCapabilitiesFromType(IMFMediaType* type,
+                              VideoCaptureCapability* capability) {
+  GUID type_guid;
+  if (FAILED(type->GetGUID(MF_MT_SUBTYPE, &type_guid)) ||
+      !FormatFromGuid(type_guid, &capability->color) ||
+      !GetFrameSize(type, &capability->width, &capability->height) ||
+      !GetFrameRate(type, &capability->frame_rate)) {
+    return false;
+  }
+
+  capability->expected_capture_delay = 0;  // Currently not used.
+  capability->interlaced = false;  // Currently not used.
+
+  return true;
+}
+
+HRESULT FillCapabilities(IMFSourceReader* source,
+                         CapabilityList* capabilities) {
+  DWORD stream_index = 0;
+  ScopedComPtr<IMFMediaType> type;
+  HRESULT hr;
+  while (SUCCEEDED(hr = source->GetNativeMediaType(
+      MF_SOURCE_READER_FIRST_VIDEO_STREAM, stream_index, type.Receive()))) {
+    VideoCaptureCapabilityWin capability(stream_index++);
+    if (FillCapabilitiesFromType(type, &capability))
+      capabilities->Add(capability);
+    type.Release();
+  }
+
+  if (SUCCEEDED(hr) && capabilities->empty())
+    hr = HRESULT_FROM_WIN32(ERROR_EMPTY);
+
+  return (hr == MF_E_NO_MORE_TYPES) ? S_OK : hr;
+}
+
+}  // namespace
+
+namespace media {
+
+class MFReaderCallback
+    : public base::RefCountedThreadSafe<MFReaderCallback>,
+      public IMFSourceReaderCallback {
+ public:
+  MFReaderCallback(VideoCaptureDeviceMFWin* observer)
+      : observer_(observer), wait_event_(NULL) {
+  }
+
+  void SetSignalOnFlush(base::WaitableEvent* event) {
+    wait_event_ = event;
+  }
+
+  STDMETHOD(QueryInterface)(REFIID riid, void** object) {
+    if (riid != IID_IUnknown && riid != IID_IMFSourceReaderCallback)
+      return E_NOINTERFACE;
+    *object = static_cast<IMFSourceReaderCallback*>(this);
+    AddRef();
+    return S_OK;
+  }
+
+  STDMETHOD_(ULONG, AddRef)() {
+    base::RefCountedThreadSafe<MFReaderCallback>::AddRef();
+    return 1U;
+  }
+
+  STDMETHOD_(ULONG, Release)() {
+    base::RefCountedThreadSafe<MFReaderCallback>::Release();
+    return 1U;
+  }
+
+  STDMETHOD(OnReadSample)(HRESULT status, DWORD stream_index,
+      DWORD stream_flags, LONGLONG time_stamp, IMFSample* sample) {
+    base::Time stamp(base::Time::Now());
+    if (!sample) {
+      observer_->OnIncomingCapturedFrame(NULL, 0, stamp);
+      return S_OK;
+    }
+
+    DWORD count = 0;
+    sample->GetBufferCount(&count);
+
+    for (DWORD i = 0; i < count; ++i) {
+      ScopedComPtr<IMFMediaBuffer> buffer;
+      sample->GetBufferByIndex(i, buffer.Receive());
+      if (buffer) {
+        DWORD length = 0, max_length = 0;
+        BYTE* data = NULL;
+        buffer->Lock(&data, &max_length, &length);
+        observer_->OnIncomingCapturedFrame(data, length, stamp);

[darin (slow to review), 2012/11/29 00:28:05]

is it possible for the observer_ to destroy |this| within
OnIncomingCapturedFrame?

[tommi (sloooow) - chröme, 2012/11/29 11:02:58]

This particular OnIncomingCapturedFrame is basically an extension of another
OnIncomingCapturedFrame.  In this particular case, the implementation is private
to this object file and |this| cannot be deleted during the call because a
reference is held by the caller of OnReadSample.

However, extending the question to the other OnIncomingCapturedFrame which
belongs to the cross platform VideoCapture interface (see implementation at the
bottom of this file), I guess that's a question that mflodman can provide better
background to. But from what I can see, that is never done, but the API itself
doesn't prevent it.

+        buffer->Unlock();
+      }
+    }
+    return S_OK;
+  }
+
+  STDMETHOD(OnFlush)(DWORD stream_index) {
+    if (wait_event_) {
+      wait_event_->Signal();
+      wait_event_ = NULL;
+    }
+    return S_OK;
+  }
+
+  STDMETHOD(OnEvent)(DWORD stream_index, IMFMediaEvent* event) {
+    NOTIMPLEMENTED();
+    return S_OK;
+  }
+
+ private:
+  friend class base::RefCountedThreadSafe<MFReaderCallback>;
+  ~MFReaderCallback() {}
+
+  VideoCaptureDeviceMFWin* observer_;
+  base::WaitableEvent* wait_event_;
+};
+
+// static
+void VideoCaptureDeviceMFWin::GetDeviceNames(Names* device_names) {
+  ScopedCoMem<IMFActivate*> devices;
+  UINT32 count;
+  if (!EnumerateVideoDevices(&devices, &count))
+    return;
+
+  HRESULT hr;
+  for (UINT32 i = 0; i < count; ++i) {
+    UINT32 name_size, id_size;
+    ScopedCoMem<wchar_t> name, id;
+    if (SUCCEEDED(hr = devices[i]->GetAllocatedString(
+            MF_DEVSOURCE_ATTRIBUTE_FRIENDLY_NAME, &name, &name_size)) &&
+        SUCCEEDED(hr = devices[i]->GetAllocatedString(
+            MF_DEVSOURCE_ATTRIBUTE_SOURCE_TYPE_VIDCAP_SYMBOLIC_LINK, &id,
+            &id_size))) {
+      std::wstring name_w(name, name_size), id_w(id, id_size);
+      Name device;
+      device.device_name = base::SysWideToUTF8(name_w);
+      device.unique_id = base::SysWideToUTF8(id_w);
+      device_names->push_back(device);
+    } else {
+      DLOG(WARNING) << "GetAllocatedString failed: " << std::hex << hr;
+    }
+    devices[i]->Release();
+  }
+}
+
+VideoCaptureDeviceMFWin::VideoCaptureDeviceMFWin(const Name& device_name)
+    : name_(device_name), observer_(NULL), capture_(0) {
+  DetachFromThread();
+}
+
+VideoCaptureDeviceMFWin::~VideoCaptureDeviceMFWin() {
+  DCHECK(CalledOnValidThread());
+}
+
+bool VideoCaptureDeviceMFWin::Init() {
+  DCHECK(CalledOnValidThread());
+  DCHECK(!reader_);
+
+  ScopedComPtr<IMFMediaSource> source;
+  if (!CreateVideoCaptureDevice(name_.unique_id.c_str(), source.Receive()))
+    return false;
+
+  ScopedComPtr<IMFAttributes> attributes;
+  MFCreateAttributes(attributes.Receive(), 1);
+  DCHECK(attributes);
+
+  callback_ = new MFReaderCallback(this);
+  attributes->SetUnknown(MF_SOURCE_READER_ASYNC_CALLBACK, callback_.get());
+
+  return SUCCEEDED(MFCreateSourceReaderFromMediaSource(source, attributes,
+                                                       reader_.Receive()));
+}
+
+void VideoCaptureDeviceMFWin::Allocate(
+    int width,
+    int height,
+    int frame_rate,
+    VideoCaptureDevice::EventHandler* observer) {
+  DCHECK(CalledOnValidThread());
+
+  base::AutoLock lock(lock_);
+
+  if (observer_) {
+    DCHECK_EQ(observer, observer_);
+    return;
+  }
+
+  observer_ = observer;
+  DCHECK_EQ(capture_, false);
+
+  CapabilityList capabilities;
+  HRESULT hr = S_OK;
+  if (!reader_ || FAILED(hr = FillCapabilities(reader_, &capabilities))) {
+    OnError(hr);
+    return;
+  }
+
+  const VideoCaptureCapabilityWin& found_capability =
+      capabilities.GetBestMatchedCapability(width, height, frame_rate);
+
+  ScopedComPtr<IMFMediaType> type;
+  if (FAILED(hr = reader_->GetNativeMediaType(
+          MF_SOURCE_READER_FIRST_VIDEO_STREAM, found_capability.stream_index,
+          type.Receive())) ||
+      FAILED(hr = reader_->SetCurrentMediaType(
+          MF_SOURCE_READER_FIRST_VIDEO_STREAM, NULL, type))) {
+    OnError(hr);
+    return;
+  }
+
+  observer_->OnFrameInfo(found_capability);
+}
+
+void VideoCaptureDeviceMFWin::Start() {
+  DCHECK(CalledOnValidThread());
+
+  base::AutoLock lock(lock_);
+  if (!capture_) {
+    capture_ = true;
+    HRESULT hr;
+    if (FAILED(hr = reader_->ReadSample(MF_SOURCE_READER_FIRST_VIDEO_STREAM, 0,
+                                        NULL, NULL, NULL, NULL))) {
+      OnError(hr);
+      capture_ = false;
+    }
+  }
+}
+
+void VideoCaptureDeviceMFWin::Stop() {
+  DCHECK(CalledOnValidThread());
+  base::WaitableEvent flushed(false, false);
+  bool wait = false;
+  {
+    base::AutoLock lock(lock_);
+    if (capture_) {
+      capture_ = false;
+      callback_->SetSignalOnFlush(&flushed);
+      HRESULT hr = reader_->Flush(MF_SOURCE_READER_ALL_STREAMS);
+      wait = SUCCEEDED(hr);
+      if (!wait) {
+        callback_->SetSignalOnFlush(NULL);
+        OnError(hr);
+      }
+    }
+  }
+
+  if (wait)
+    flushed.Wait();
+}
+
+void VideoCaptureDeviceMFWin::DeAllocate() {
+  DCHECK(CalledOnValidThread());
+
+  Stop();
+
+  base::AutoLock lock(lock_);
+  observer_ = NULL;
+}
+
+const VideoCaptureDevice::Name& VideoCaptureDeviceMFWin::device_name() {
+  DCHECK(CalledOnValidThread());
+  return name_;
+}
+
+void VideoCaptureDeviceMFWin::OnIncomingCapturedFrame(
+    const uint8* data,
+    int length,
+    const base::Time& time_stamp) {
+  base::AutoLock lock(lock_);
+  if (data && observer_)
+    observer_->OnIncomingCapturedFrame(data, length, time_stamp);
+
+  if (capture_) {
+    HRESULT hr = reader_->ReadSample(MF_SOURCE_READER_FIRST_VIDEO_STREAM, 0,
+                                     NULL, NULL, NULL, NULL);
+    if (FAILED(hr)) {
+      // If running the *VideoCap* unit tests on repeat, this can sometimes
+      // fail with HRESULT_FROM_WINHRESULT_FROM_WIN32(ERROR_INVALID_FUNCTION).
+      // It's not clear to me why this is, but it is possible that it has
+      // something to do with this bug:
+      // http://support.microsoft.com/kb/979567
+      OnError(hr);
+    }
+  }
+}
+
+void VideoCaptureDeviceMFWin::OnError(HRESULT hr) {
+  DLOG(ERROR) << "VideoCaptureDeviceMFWin: " << std::hex << hr;
+  if (observer_)
+    observer_->OnError();
+}
+
+}  // namespace media