Home | History | Annotate | Download | only in win 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "media/video/capture/win/pin_base_win.h"
      6 
      7 #include "base/logging.h"
      8 
      9 namespace media {
     10 
     11 // Implement IEnumPins.
     12 class TypeEnumerator
     13     : public IEnumMediaTypes,
     14       public base::RefCounted<TypeEnumerator> {
     15  public:
     16   explicit TypeEnumerator(PinBase* pin)
     17       : pin_(pin),
     18         index_(0) {
     19   }
     20 
     21   ~TypeEnumerator() {
     22   }
     23 
     24   // Implement from IUnknown.
     25   STDMETHOD(QueryInterface)(REFIID iid, void** object_ptr) {
     26     if (iid == IID_IEnumMediaTypes || iid == IID_IUnknown) {
     27       AddRef();
     28       *object_ptr = static_cast<IEnumMediaTypes*>(this);
     29       return S_OK;
     30     }
     31     return E_NOINTERFACE;
     32   }
     33 
     34   STDMETHOD_(ULONG, AddRef)() {
     35     base::RefCounted<TypeEnumerator>::AddRef();
     36     return 1;
     37   }
     38 
     39   STDMETHOD_(ULONG, Release)() {
     40     base::RefCounted<TypeEnumerator>::Release();
     41     return 1;
     42   }
     43 
     44   // Implement IEnumMediaTypes.
     45   STDMETHOD(Next)(ULONG count, AM_MEDIA_TYPE** types, ULONG* fetched) {
     46     ULONG types_fetched = 0;
     47 
     48     while (types_fetched < count) {
     49       // Allocate AM_MEDIA_TYPE that we will store the media type in.
     50       AM_MEDIA_TYPE* type = reinterpret_cast<AM_MEDIA_TYPE*>(CoTaskMemAlloc(
     51           sizeof(AM_MEDIA_TYPE)));
     52       if (!type) {
     53         FreeAllocatedMediaTypes(types_fetched, types);
     54         return E_OUTOFMEMORY;
     55       }
     56       ZeroMemory(type, sizeof(AM_MEDIA_TYPE));
     57 
     58       // Allocate a VIDEOINFOHEADER and connect it to the AM_MEDIA_TYPE.
     59       type->cbFormat = sizeof(VIDEOINFOHEADER);
     60       BYTE *format = reinterpret_cast<BYTE*>(CoTaskMemAlloc(
     61           sizeof(VIDEOINFOHEADER)));
     62       if (!format) {
     63         CoTaskMemFree(type);
     64         FreeAllocatedMediaTypes(types_fetched, types);
     65         return E_OUTOFMEMORY;
     66       }
     67       type->pbFormat = format;
     68       // Get the media type from the pin.
     69       if (pin_->GetValidMediaType(index_++, type)) {
     70         types[types_fetched++] = type;
     71       } else {
     72         CoTaskMemFree(format);
     73         CoTaskMemFree(type);
     74         break;
     75       }
     76     }
     77 
     78     if (fetched)
     79       *fetched = types_fetched;
     80 
     81     return types_fetched == count ? S_OK : S_FALSE;
     82   }
     83 
     84   STDMETHOD(Skip)(ULONG count) {
     85     index_ += count;
     86     return S_OK;
     87   }
     88 
     89   STDMETHOD(Reset)() {
     90     index_ = 0;
     91     return S_OK;
     92   }
     93 
     94   STDMETHOD(Clone)(IEnumMediaTypes** clone) {
     95     TypeEnumerator* type_enum = new TypeEnumerator(pin_);
     96     type_enum->AddRef();
     97     type_enum->index_ = index_;
     98     *clone = type_enum;
     99     return S_OK;
    100   }
    101 
    102  private:
    103   void FreeAllocatedMediaTypes(ULONG allocated, AM_MEDIA_TYPE** types) {
    104     for (ULONG i = 0; i < allocated; ++i) {
    105       CoTaskMemFree(types[i]->pbFormat);
    106       CoTaskMemFree(types[i]);
    107     }
    108   }
    109 
    110   scoped_refptr<PinBase> pin_;
    111   int index_;
    112 };
    113 
    114 PinBase::PinBase(IBaseFilter* owner)
    115     : owner_(owner) {
    116   memset(&current_media_type_, 0, sizeof(current_media_type_));
    117 }
    118 
    119 PinBase::~PinBase() {
    120 }
    121 
    122 void PinBase::SetOwner(IBaseFilter* owner) {
    123   owner_ = owner;
    124 }
    125 
    126 // Called on an output pin to and establish a
    127 //   connection.
    128 STDMETHODIMP PinBase::Connect(IPin* receive_pin,
    129                               const AM_MEDIA_TYPE* media_type) {
    130   if (!receive_pin || !media_type)
    131     return E_POINTER;
    132 
    133   current_media_type_ = *media_type;
    134   receive_pin->AddRef();
    135   connected_pin_.Attach(receive_pin);
    136   HRESULT hr = receive_pin->ReceiveConnection(this, media_type);
    137 
    138   return hr;
    139 }
    140 
    141 // Called from an output pin on an input pin to and establish a
    142 // connection.
    143 STDMETHODIMP PinBase::ReceiveConnection(IPin* connector,
    144                                         const AM_MEDIA_TYPE* media_type) {
    145   if (!IsMediaTypeValid(media_type))
    146     return VFW_E_TYPE_NOT_ACCEPTED;
    147 
    148   current_media_type_ = *media_type;
    149   connector->AddRef();
    150   connected_pin_.Attach(connector);
    151   return S_OK;
    152 }
    153 
    154 STDMETHODIMP PinBase::Disconnect() {
    155   if (!connected_pin_)
    156     return S_FALSE;
    157 
    158   connected_pin_.Release();
    159   return S_OK;
    160 }
    161 
    162 STDMETHODIMP PinBase::ConnectedTo(IPin** pin) {
    163   *pin = connected_pin_;
    164   if (!connected_pin_)
    165     return VFW_E_NOT_CONNECTED;
    166 
    167   connected_pin_.get()->AddRef();
    168   return S_OK;
    169 }
    170 
    171 STDMETHODIMP PinBase::ConnectionMediaType(AM_MEDIA_TYPE* media_type) {
    172   if (!connected_pin_)
    173     return VFW_E_NOT_CONNECTED;
    174   *media_type = current_media_type_;
    175   return S_OK;
    176 }
    177 
    178 STDMETHODIMP PinBase::QueryPinInfo(PIN_INFO* info) {
    179   info->dir = PINDIR_INPUT;
    180   info->pFilter = owner_;
    181   if (owner_)
    182     owner_->AddRef();
    183   info->achName[0] = L'\0';
    184 
    185   return S_OK;
    186 }
    187 
    188 STDMETHODIMP PinBase::QueryDirection(PIN_DIRECTION* pin_dir) {
    189   *pin_dir = PINDIR_INPUT;
    190   return S_OK;
    191 }
    192 
    193 STDMETHODIMP PinBase::QueryId(LPWSTR* id) {
    194   NOTREACHED();
    195   return E_OUTOFMEMORY;
    196 }
    197 
    198 STDMETHODIMP PinBase::QueryAccept(const AM_MEDIA_TYPE* media_type) {
    199   return S_FALSE;
    200 }
    201 
    202 STDMETHODIMP PinBase::EnumMediaTypes(IEnumMediaTypes** types) {
    203   *types = new TypeEnumerator(this);
    204   (*types)->AddRef();
    205   return S_OK;
    206 }
    207 
    208 STDMETHODIMP PinBase::QueryInternalConnections(IPin** pins, ULONG* no_pins) {
    209   return E_NOTIMPL;
    210 }
    211 
    212 STDMETHODIMP PinBase::EndOfStream() {
    213   return S_OK;
    214 }
    215 
    216 STDMETHODIMP PinBase::BeginFlush() {
    217   return S_OK;
    218 }
    219 
    220 STDMETHODIMP PinBase::EndFlush() {
    221   return S_OK;
    222 }
    223 
    224 STDMETHODIMP PinBase::NewSegment(REFERENCE_TIME start,
    225                                  REFERENCE_TIME stop,
    226                                  double rate) {
    227   NOTREACHED();
    228   return E_NOTIMPL;
    229 }
    230 
    231 // Inherited from IMemInputPin.
    232 STDMETHODIMP PinBase::GetAllocator(IMemAllocator** allocator) {
    233   return VFW_E_NO_ALLOCATOR;
    234 }
    235 
    236 STDMETHODIMP PinBase::NotifyAllocator(IMemAllocator* allocator,
    237                                       BOOL read_only) {
    238   return S_OK;
    239 }
    240 
    241 STDMETHODIMP PinBase::GetAllocatorRequirements(
    242     ALLOCATOR_PROPERTIES* properties) {
    243   return E_NOTIMPL;
    244 }
    245 
    246 STDMETHODIMP PinBase::ReceiveMultiple(IMediaSample** samples,
    247                                       long sample_count,
    248                                       long* processed) {
    249   DCHECK(samples);
    250 
    251   HRESULT hr = S_OK;
    252   *processed = 0;
    253   while (sample_count--) {
    254     hr = Receive(samples[*processed]);
    255     // S_FALSE means don't send any more.
    256     if (hr != S_OK)
    257       break;
    258     ++(*processed);
    259   }
    260   return hr;
    261 }
    262 
    263 STDMETHODIMP PinBase::ReceiveCanBlock() {
    264   return S_FALSE;
    265 }
    266 
    267 // Inherited from IUnknown.
    268 STDMETHODIMP PinBase::QueryInterface(REFIID id, void** object_ptr) {
    269   if (id == IID_IPin || id == IID_IUnknown) {
    270     *object_ptr = static_cast<IPin*>(this);
    271   } else if (id == IID_IMemInputPin) {
    272     *object_ptr = static_cast<IMemInputPin*>(this);
    273   } else {
    274     return E_NOINTERFACE;
    275   }
    276   AddRef();
    277   return S_OK;
    278 }
    279 
    280 STDMETHODIMP_(ULONG) PinBase::AddRef() {
    281   base::RefCounted<PinBase>::AddRef();
    282   return 1;
    283 }
    284 
    285 STDMETHODIMP_(ULONG) PinBase::Release() {
    286   base::RefCounted<PinBase>::Release();
    287   return 1;
    288 }
    289 
    290 }  // namespace media
    291