OLD | NEW |
---|---|
(Empty) | |
1 // Copyright (c) 2011 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))); | |
tommi (sloooow) - chröme
2011/06/27 13:20:37
indent
Per K
2011/06/28 10:14:07
Done.
| |
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 if (!type_enum) | |
97 return E_OUTOFMEMORY; | |
98 type_enum->AddRef(); | |
99 type_enum->index_ = index_; | |
100 *clone = type_enum; | |
101 return S_OK; | |
102 } | |
103 | |
104 private: | |
105 void FreeAllocatedMediaTypes(ULONG allocated, AM_MEDIA_TYPE** types) { | |
106 for (ULONG i = 0; i < allocated; ++i) { | |
107 CoTaskMemFree(types[i]->pbFormat); | |
108 CoTaskMemFree(types[i]); | |
109 } | |
110 } | |
111 | |
112 scoped_refptr<PinBase> pin_; | |
113 int index_; | |
114 }; | |
115 | |
116 PinBase::PinBase(IBaseFilter* owner) | |
117 : owner_(owner) { | |
118 } | |
119 | |
120 PinBase::~PinBase() { | |
121 } | |
122 | |
123 // Called on an output pin to and establish a | |
124 // connection. | |
125 STDMETHODIMP PinBase::Connect(IPin* receive_pin, const AM_MEDIA_TYPE* mt) { | |
126 if (!receive_pin || !mt) | |
127 return E_POINTER; | |
128 | |
129 current_media_type_ = *mt; | |
130 receive_pin->AddRef(); | |
131 connected_pin_.Attach(receive_pin); | |
132 HRESULT hr = receive_pin->ReceiveConnection(this, mt); | |
133 | |
134 return hr; | |
135 } | |
136 | |
137 // Called from an output pin on an input pin to and establish a | |
138 // connection. | |
139 STDMETHODIMP PinBase::ReceiveConnection(IPin* connector, | |
140 const AM_MEDIA_TYPE* mt) { | |
141 if (IsMediaTypeValid(mt)) { | |
142 current_media_type_ = current_media_type_; | |
143 connector->AddRef(); | |
144 connected_pin_.Attach(connector); | |
145 return S_OK; | |
146 } | |
147 return VFW_E_TYPE_NOT_ACCEPTED; | |
148 } | |
149 | |
150 STDMETHODIMP PinBase::Disconnect() { | |
151 if (connected_pin_) { | |
152 connected_pin_.Release(); | |
153 return S_OK; | |
154 } | |
155 return S_FALSE; | |
156 } | |
157 | |
158 STDMETHODIMP PinBase::ConnectedTo(IPin** pin) { | |
159 *pin = connected_pin_; | |
160 if (connected_pin_ != NULL) { | |
161 connected_pin_.get()->AddRef(); | |
162 return S_OK; | |
163 } | |
164 return VFW_E_NOT_CONNECTED; | |
165 } | |
166 | |
167 STDMETHODIMP PinBase::ConnectionMediaType(AM_MEDIA_TYPE* mt) { | |
168 if (!connected_pin_) | |
169 return VFW_E_NOT_CONNECTED; | |
170 *mt = current_media_type_; | |
171 return S_OK; | |
172 } | |
173 | |
174 STDMETHODIMP PinBase::QueryPinInfo(PIN_INFO* info) { | |
175 DCHECK(info); | |
176 info->dir = PINDIR_INPUT; | |
177 info->pFilter = owner_; | |
178 if (owner_) | |
179 owner_->AddRef(); | |
180 info->achName[0] = L'\0'; | |
181 | |
182 return S_OK; | |
183 } | |
184 | |
185 STDMETHODIMP PinBase::QueryDirection(PIN_DIRECTION* pin_dir) { | |
186 *pin_dir = PINDIR_INPUT; | |
187 return S_OK; | |
188 } | |
189 | |
190 STDMETHODIMP PinBase::QueryId(LPWSTR* id) { | |
191 NOTREACHED(); | |
192 return E_OUTOFMEMORY; | |
193 } | |
194 | |
195 STDMETHODIMP PinBase::QueryAccept(const AM_MEDIA_TYPE* mt) { | |
196 return S_FALSE; | |
197 } | |
198 | |
199 STDMETHODIMP PinBase::EnumMediaTypes(IEnumMediaTypes** types) { | |
200 *types = new TypeEnumerator(this); | |
201 (*types)->AddRef(); | |
202 return S_OK; | |
203 } | |
204 | |
205 STDMETHODIMP PinBase::QueryInternalConnections(IPin** pins, ULONG* count) { | |
206 return E_NOTIMPL; | |
207 } | |
208 | |
209 STDMETHODIMP PinBase::EndOfStream() { | |
210 return S_OK; | |
211 } | |
212 | |
213 STDMETHODIMP PinBase::BeginFlush() { | |
214 return S_OK; | |
215 } | |
216 | |
217 STDMETHODIMP PinBase::EndFlush() { | |
218 return S_OK; | |
219 } | |
220 | |
221 STDMETHODIMP PinBase::NewSegment(REFERENCE_TIME start, | |
222 REFERENCE_TIME stop, | |
223 double rate) { | |
224 NOTREACHED(); | |
225 return E_NOTIMPL; | |
226 } | |
227 | |
228 // Inherited from IMemInputPin. | |
229 STDMETHODIMP PinBase::GetAllocator(IMemAllocator** allocator) { | |
230 return VFW_E_NO_ALLOCATOR; | |
231 } | |
232 | |
233 STDMETHODIMP PinBase::NotifyAllocator(IMemAllocator* allocator, | |
234 BOOL read_only) { | |
235 return S_OK; | |
236 } | |
237 | |
238 STDMETHODIMP PinBase::GetAllocatorRequirements( | |
239 ALLOCATOR_PROPERTIES* properties) { | |
240 return E_NOTIMPL; | |
241 } | |
242 | |
243 STDMETHODIMP PinBase::ReceiveMultiple(IMediaSample** samples, | |
244 long sample_count, | |
245 long* processed) { | |
246 NOTREACHED(); | |
247 return VFW_E_INVALIDMEDIATYPE; | |
248 } | |
249 | |
250 STDMETHODIMP PinBase::ReceiveCanBlock() { | |
251 return S_FALSE; | |
252 } | |
253 | |
254 // Inherited from IUnknown. | |
255 STDMETHODIMP PinBase::QueryInterface(REFIID id, void** object_ptr) { | |
256 if (id == IID_IPin || id == IID_IUnknown) { | |
257 AddRef(); | |
258 *object_ptr = static_cast<IPin*>(this); | |
259 } else if (id == IID_IMemInputPin) { | |
260 AddRef(); | |
261 *object_ptr = static_cast<IMemInputPin*>(this); | |
262 } else { | |
263 return E_NOINTERFACE; | |
264 } | |
265 return S_OK; | |
266 } | |
267 | |
268 STDMETHODIMP_(ULONG) PinBase::AddRef() { | |
269 base::RefCounted<PinBase>::AddRef(); | |
270 return owner_->AddRef(); | |
tommi (sloooow) - chröme
2011/06/27 13:20:37
as discussed in person this is now done a bit diff
Per K
2011/06/28 10:14:07
Done.
| |
271 } | |
272 | |
273 STDMETHODIMP_(ULONG) PinBase::Release() { | |
274 int ret = owner_->Release(); | |
275 base::RefCounted<PinBase>::Release(); | |
276 return ret; | |
277 } | |
278 | |
279 } // namespace media | |
OLD | NEW |