This is the VideoCaptureDevice implementation for windows.

media/video/capture/win/pin_base_win.cc

+// Copyright (c) 2011 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/pin_base_win.h"
+
+#include "base/logging.h"
+
+namespace media {
+
+// Implement IEnumPins.
+class TypeEnumerator : public IEnumMediaTypes,
+                       public base::RefCounted<TypeEnumerator> {
+ public:
+  explicit TypeEnumerator(PinBase* pin)
+      : pin_(pin),
+        index_(0),
+        ref_count_(0) {
+  }
+
+  ~TypeEnumerator() {
+  }
+
+  // Implement from IUnknown.
+  STDMETHOD(QueryInterface)(REFIID iid, void** object_ptr) {
+    if (iid == IID_IEnumMediaTypes || iid == IID_IUnknown) {
+      AddRef();
+      *object_ptr = static_cast<IEnumMediaTypes*>(this);
+      return S_OK;
+    }
+    return E_NOINTERFACE;
+  }
+
+  STDMETHOD_(ULONG, AddRef)() {
+    base::RefCounted<TypeEnumerator>::AddRef();
+    return ++ref_count_;
+  }
+
+  STDMETHOD_(ULONG, Release)() {
+    int ret = --ref_count_;
+    base::RefCounted<TypeEnumerator>::Release();
+    return ret;
+  }
+
+  // Implement IEnumMediaTypes.
+  STDMETHOD(Next)(ULONG count, AM_MEDIA_TYPE** types, ULONG* fetched) {
+    ULONG types_fetched = 0;
+
+    while (types_fetched < count) {
+      // Allocate AM_MEDIA_TYPE that we will store the media type in.
+      AM_MEDIA_TYPE* type = static_cast<AM_MEDIA_TYPE*> (CoTaskMemAlloc(

[tommi (sloooow) - chröme, 2011/06/23 14:05:56]

This should be reinterpret_cast.
Also, no space between > and (

Same elsewhere where CoTaskMemAlloc is called.

[Per K, 2011/06/27 11:47:50]

Done.

+        sizeof(AM_MEDIA_TYPE)));

[tommi (sloooow) - chröme, 2011/06/23 14:05:56]

indent

[Per K, 2011/06/27 11:47:50]

Done.

+      if (!type) {
+        FreeAllocatedMediaTypes(types_fetched, types);
+        return E_OUTOFMEMORY;
+      }
+      ZeroMemory(type, sizeof(AM_MEDIA_TYPE));
+
+      // Allocate a VIDEOINFOHEADER and connect it to the AM_MEDIA_TYPE.
+      type->cbFormat = sizeof(VIDEOINFOHEADER);
+      BYTE *format = static_cast<BYTE*> (CoTaskMemAlloc(

[tommi (sloooow) - chröme, 2011/06/23 14:05:56]

BYTE* format = ...
same as above for cast and space

[Per K, 2011/06/27 11:47:50]

Done.

+          sizeof(VIDEOINFOHEADER)));
+      if (!format) {
+        CoTaskMemFree(type);
+        FreeAllocatedMediaTypes(types_fetched, types);
+        return E_OUTOFMEMORY;
+      }
+      type->pbFormat = format;
+      // Get the media type from the pin.
+      if (pin_->GetValidMediaType(index_++, type)) {
+        types[types_fetched++] = type;
+      } else {
+        CoTaskMemFree(format);
+        CoTaskMemFree(type);
+        break;
+      }
+    }
+
+    if (fetched)
+      *fetched =  types_fetched;

[tommi (sloooow) - chröme, 2011/06/23 14:05:56]

fix space

[Per K, 2011/06/27 11:47:50]

Done.

+
+    return types_fetched == count ? S_OK : S_FALSE;
+  }
+
+  STDMETHOD(Skip)(ULONG count) {
+    index_ += count;
+    return S_OK;
+  }
+
+  STDMETHOD(Reset)() {
+    index_ = 0;
+    return S_OK;
+  }
+
+  STDMETHOD(Clone)(IEnumMediaTypes** clone) {
+    TypeEnumerator* type_enum = new TypeEnumerator(pin_);
+    if (!type_enum)
+      return E_OUTOFMEMORY;
+    type_enum->AddRef();
+    type_enum->index_ = index_;
+    *clone = type_enum;
+    return S_OK;
+  }
+
+ private:
+  void FreeAllocatedMediaTypes(int allocated, AM_MEDIA_TYPE** types) {

[tommi (sloooow) - chröme, 2011/06/23 14:05:56]

should allocated be of type ULONG? (and |i| in the loop as well)

[Per K, 2011/06/27 11:47:50]

Done.

+    for (int i = 0; i < allocated; ++i) {
+      CoTaskMemFree(types[i]->pbFormat);
+      CoTaskMemFree(types[i]);
+    }
+  }
+
+  scoped_refptr<PinBase> pin_;
+  int index_;
+  int ref_count_;

[tommi (sloooow) - chröme, 2011/06/23 14:05:56]

remove?

[Per K, 2011/06/27 11:47:50]

Done.

+};
+
+PinBase::PinBase(IBaseFilter* owner)
+    : owner_(owner),
+      connected_pin_(NULL) {
+}
+
+PinBase::~PinBase() {
+}
+
+/* Called on an output pin to and establish a

[tommi (sloooow) - chröme, 2011/06/23 14:05:56]

use // instead of /*
same throughout.

[Per K, 2011/06/27 11:47:50]

Done.

+   connection.
+*/
+STDMETHODIMP PinBase::Connect(IPin* receive_pin, const AM_MEDIA_TYPE* mt) {
+  if (!receive_pin || !mt)
+    return E_POINTER;
+
+  current_media_type_ = *mt;
+  connected_pin_ = receive_pin;
+  receive_pin->AddRef();
+  HRESULT hr = receive_pin->ReceiveConnection(this, mt);
+
+  return hr;
+}
+
+/* Called from an output pin on an input pin to and establish a
+   connection.
+*/
+STDMETHODIMP PinBase::ReceiveConnection(IPin* connector,
+                                        const AM_MEDIA_TYPE* mt) {
+  if (IsMediaTypeValid(mt)) {
+    connected_pin_ = connector;
+    current_media_type_ = current_media_type_;
+    connected_pin_->AddRef();
+    return S_OK;
+  }
+  return VFW_E_TYPE_NOT_ACCEPTED;
+}
+
+STDMETHODIMP PinBase::Disconnect() {
+  if (connected_pin_) {
+    int r = connected_pin_->Release();
+    connected_pin_ = NULL;
+    return S_OK;
+  }
+  return S_FALSE;
+}
+
+STDMETHODIMP PinBase::ConnectedTo(IPin** pin) {
+  *pin = connected_pin_;
+  if (connected_pin_ != NULL) {
+    int r = connected_pin_->AddRef();
+    return S_OK;
+  } else {

[tommi (sloooow) - chröme, 2011/06/23 14:05:56]

nit: no need for an else. just do as above.

[Per K, 2011/06/27 11:47:50]

Done.

+    return VFW_E_NOT_CONNECTED;
+  }
+}
+
+STDMETHODIMP PinBase::ConnectionMediaType(AM_MEDIA_TYPE* mt) {
+  if (!connected_pin_) {

[tommi (sloooow) - chröme, 2011/06/23 14:05:56]

nit: remove braces

[Per K, 2011/06/27 11:47:50]

Done.

+    return VFW_E_NOT_CONNECTED;
+  }
+  *mt = current_media_type_;
+  return S_OK;
+}
+
+STDMETHODIMP PinBase::QueryPinInfo(PIN_INFO* pInfo) {

[tommi (sloooow) - chröme, 2011/06/23 14:05:56]

remove hungarian

[Per K, 2011/06/27 11:47:50]

Done.

+  pInfo->dir = PINDIR_INPUT;
+  pInfo->pFilter = owner_;
+  if (owner_) {

[tommi (sloooow) - chröme, 2011/06/23 14:05:56]

nit: remove braces

[Per K, 2011/06/27 11:47:50]

Done.

+    owner_->AddRef();
+  }
+  pInfo->achName[0] = L'\0';
+
+  return S_OK;
+}
+
+STDMETHODIMP PinBase::QueryDirection(PIN_DIRECTION* pin_dir) {
+  *pin_dir = PINDIR_INPUT;
+  return S_OK;
+}
+
+STDMETHODIMP PinBase::QueryId(LPWSTR* Id) {
+  NOTREACHED();
+  return E_OUTOFMEMORY;
+}
+
+STDMETHODIMP PinBase::QueryAccept(const AM_MEDIA_TYPE* mt) {
+  return S_FALSE;
+}
+
+STDMETHODIMP PinBase::EnumMediaTypes(IEnumMediaTypes** types) {
+  *types = new TypeEnumerator(this);
+  (*types)->AddRef();
+  return S_OK;
+}
+
+STDMETHODIMP PinBase::QueryInternalConnections(IPin** pins, ULONG* count) {
+  return E_NOTIMPL;
+}
+
+STDMETHODIMP PinBase::EndOfStream() {
+  return S_OK;
+}
+
+STDMETHODIMP PinBase::BeginFlush() {
+  return S_OK;
+}
+
+STDMETHODIMP PinBase::EndFlush() {
+  return S_OK;
+}
+
+STDMETHODIMP PinBase::NewSegment(REFERENCE_TIME start, REFERENCE_TIME stop,
+                                 double rate) {
+  NOTREACHED();
+  return E_NOTIMPL;
+}
+
+// Inherited from IMemInputPin.
+STDMETHODIMP PinBase::GetAllocator(IMemAllocator** allocator) {
+  return VFW_E_NO_ALLOCATOR;
+}
+
+STDMETHODIMP PinBase::NotifyAllocator(IMemAllocator* allocator,
+                                      BOOL read_only) {
+  return S_OK;
+}
+
+STDMETHODIMP PinBase::GetAllocatorRequirements(ALLOCATOR_PROPERTIES* props) {
+  return E_NOTIMPL;
+}
+
+STDMETHODIMP PinBase::ReceiveMultiple(IMediaSample** samples,
+                                      long sample_count,
+                                      long* processed) {
+  NOTREACHED();
+  return VFW_E_INVALIDMEDIATYPE;
+}
+
+STDMETHODIMP PinBase::ReceiveCanBlock() {
+  return S_FALSE;
+}
+
+// Inherited from IUnknown.
+STDMETHODIMP PinBase::QueryInterface(REFIID id, void** object_ptr) {
+  if (id == IID_IPin || id == IID_IUnknown) {
+    AddRef();
+    *object_ptr = static_cast<IPin*>(this);
+  } else if (id == IID_IMemInputPin) {
+    AddRef();
+    *object_ptr = static_cast<IMemInputPin*>(this);
+  } else {
+    return E_NOINTERFACE;
+  }
+  return S_OK;
+}
+
+STDMETHODIMP_(ULONG) PinBase::AddRef() {
+  base::RefCounted<PinBase>::AddRef();
+  return owner_->AddRef();
+}
+
+STDMETHODIMP_(ULONG) PinBase::Release() {
+  int ret = owner_->Release();

[tommi (sloooow) - chröme, 2011/06/23 14:05:56]

this looks like it could be a circular reference.
Does the owner hold a reference to this object too?
If so, how do you guarantee that the objects are fully released?

[Per K, 2011/06/27 11:47:50]

This is to make sure the owner is not deleted before the pin. But the owner does
not reference count the pin and the pin itself does not reference count the
owner.

On 2011/06/23 14:05:56, tommi wrote:

+  base::RefCounted<PinBase>::Release();
+  return ret;
+}
+
+}  // namespace media