Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(1156)

Side by Side Diff: media/video/capture/win/pin_base_win.cc

Issue 7229013: This is the VideoCaptureDevice implementation for windows. (Closed) Base URL: http://src.chromium.org/svn/trunk/src/
Patch Set: Fixed code review issues found by Scherkus and Tommi. Created 9 years, 5 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
(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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698