* Bring back rbuild build to be used until bug 6372 is fixed.
[reactos.git] / dll / directx / ksproxy / output_pin.cpp
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS WDM Streaming ActiveMovie Proxy
4 * FILE: dll/directx/ksproxy/output_pin.cpp
5 * PURPOSE: OutputPin of Proxy Filter
6 *
7 * PROGRAMMERS: Johannes Anderwald (janderwald@reactos.org)
8 */
9 #include "precomp.h"
10
11 class COutputPin : public IPin,
12 public IKsObject,
13 public IKsPropertySet,
14 public IStreamBuilder,
15 public IKsPinFactory,
16 public ISpecifyPropertyPages,
17 public IKsPinEx,
18 public IKsPinPipe,
19 public IKsControl,
20 public IKsAggregateControl,
21 public IQualityControl,
22 public IMediaSeeking,
23 public IAMBufferNegotiation,
24 public IAMStreamConfig,
25 public IMemAllocatorNotifyCallbackTemp
26
27 {
28 public:
29 typedef std::vector<IUnknown *>ProxyPluginVector;
30
31 STDMETHODIMP QueryInterface( REFIID InterfaceId, PVOID* Interface);
32
33 STDMETHODIMP_(ULONG) AddRef()
34 {
35 InterlockedIncrement(&m_Ref);
36 return m_Ref;
37 }
38 STDMETHODIMP_(ULONG) Release()
39 {
40 InterlockedDecrement(&m_Ref);
41 if (!m_Ref)
42 {
43 //delete this;
44 return 0;
45 }
46 return m_Ref;
47 }
48
49 //IKsPin
50 HRESULT STDMETHODCALLTYPE KsQueryMediums(PKSMULTIPLE_ITEM* MediumList);
51 HRESULT STDMETHODCALLTYPE KsQueryInterfaces(PKSMULTIPLE_ITEM* InterfaceList);
52 HRESULT STDMETHODCALLTYPE KsCreateSinkPinHandle(KSPIN_INTERFACE& Interface, KSPIN_MEDIUM& Medium);
53 HRESULT STDMETHODCALLTYPE KsGetCurrentCommunication(KSPIN_COMMUNICATION *Communication, KSPIN_INTERFACE *Interface, KSPIN_MEDIUM *Medium);
54 HRESULT STDMETHODCALLTYPE KsPropagateAcquire();
55 HRESULT STDMETHODCALLTYPE KsDeliver(IMediaSample* Sample, ULONG Flags);
56 HRESULT STDMETHODCALLTYPE KsMediaSamplesCompleted(PKSSTREAM_SEGMENT StreamSegment);
57 IMemAllocator * STDMETHODCALLTYPE KsPeekAllocator(KSPEEKOPERATION Operation);
58 HRESULT STDMETHODCALLTYPE KsReceiveAllocator(IMemAllocator *MemAllocator);
59 HRESULT STDMETHODCALLTYPE KsRenegotiateAllocator();
60 LONG STDMETHODCALLTYPE KsIncrementPendingIoCount();
61 LONG STDMETHODCALLTYPE KsDecrementPendingIoCount();
62 HRESULT STDMETHODCALLTYPE KsQualityNotify(ULONG Proportion, REFERENCE_TIME TimeDelta);
63 // IKsPinEx
64 VOID STDMETHODCALLTYPE KsNotifyError(IMediaSample* Sample, HRESULT hr);
65
66 //IKsPinPipe
67 HRESULT STDMETHODCALLTYPE KsGetPinFramingCache(PKSALLOCATOR_FRAMING_EX *FramingEx, PFRAMING_PROP FramingProp, FRAMING_CACHE_OPS Option);
68 HRESULT STDMETHODCALLTYPE KsSetPinFramingCache(PKSALLOCATOR_FRAMING_EX FramingEx, PFRAMING_PROP FramingProp, FRAMING_CACHE_OPS Option);
69 IPin* STDMETHODCALLTYPE KsGetConnectedPin();
70 IKsAllocatorEx* STDMETHODCALLTYPE KsGetPipe(KSPEEKOPERATION Operation);
71 HRESULT STDMETHODCALLTYPE KsSetPipe(IKsAllocatorEx *KsAllocator);
72 ULONG STDMETHODCALLTYPE KsGetPipeAllocatorFlag();
73 HRESULT STDMETHODCALLTYPE KsSetPipeAllocatorFlag(ULONG Flag);
74 GUID STDMETHODCALLTYPE KsGetPinBusCache();
75 HRESULT STDMETHODCALLTYPE KsSetPinBusCache(GUID Bus);
76 PWCHAR STDMETHODCALLTYPE KsGetPinName();
77 PWCHAR STDMETHODCALLTYPE KsGetFilterName();
78
79 //IPin methods
80 HRESULT STDMETHODCALLTYPE Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt);
81 HRESULT STDMETHODCALLTYPE ReceiveConnection(IPin *pConnector, const AM_MEDIA_TYPE *pmt);
82 HRESULT STDMETHODCALLTYPE Disconnect();
83 HRESULT STDMETHODCALLTYPE ConnectedTo(IPin **pPin);
84 HRESULT STDMETHODCALLTYPE ConnectionMediaType(AM_MEDIA_TYPE *pmt);
85 HRESULT STDMETHODCALLTYPE QueryPinInfo(PIN_INFO *pInfo);
86 HRESULT STDMETHODCALLTYPE QueryDirection(PIN_DIRECTION *pPinDir);
87 HRESULT STDMETHODCALLTYPE QueryId(LPWSTR *Id);
88 HRESULT STDMETHODCALLTYPE QueryAccept(const AM_MEDIA_TYPE *pmt);
89 HRESULT STDMETHODCALLTYPE EnumMediaTypes(IEnumMediaTypes **ppEnum);
90 HRESULT STDMETHODCALLTYPE QueryInternalConnections(IPin **apPin, ULONG *nPin);
91 HRESULT STDMETHODCALLTYPE EndOfStream();
92 HRESULT STDMETHODCALLTYPE BeginFlush();
93 HRESULT STDMETHODCALLTYPE EndFlush();
94 HRESULT STDMETHODCALLTYPE NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate);
95
96 // ISpecifyPropertyPages
97 HRESULT STDMETHODCALLTYPE GetPages(CAUUID *pPages);
98
99 //IKsObject methods
100 HANDLE STDMETHODCALLTYPE KsGetObjectHandle();
101
102 //IKsPropertySet
103 HRESULT STDMETHODCALLTYPE Set(REFGUID guidPropSet, DWORD dwPropID, LPVOID pInstanceData, DWORD cbInstanceData, LPVOID pPropData, DWORD cbPropData);
104 HRESULT STDMETHODCALLTYPE Get(REFGUID guidPropSet, DWORD dwPropID, LPVOID pInstanceData, DWORD cbInstanceData, LPVOID pPropData, DWORD cbPropData, DWORD *pcbReturned);
105 HRESULT STDMETHODCALLTYPE QuerySupported(REFGUID guidPropSet, DWORD dwPropID, DWORD *pTypeSupport);
106
107 //IKsControl
108 HRESULT STDMETHODCALLTYPE KsProperty(PKSPROPERTY Property, ULONG PropertyLength, LPVOID PropertyData, ULONG DataLength, ULONG* BytesReturned);
109 HRESULT STDMETHODCALLTYPE KsMethod(PKSMETHOD Method, ULONG MethodLength, LPVOID MethodData, ULONG DataLength, ULONG* BytesReturned);
110 HRESULT STDMETHODCALLTYPE KsEvent(PKSEVENT Event, ULONG EventLength, LPVOID EventData, ULONG DataLength, ULONG* BytesReturned);
111
112 //IStreamBuilder
113 HRESULT STDMETHODCALLTYPE Render(IPin *ppinOut, IGraphBuilder *pGraph);
114 HRESULT STDMETHODCALLTYPE Backout(IPin *ppinOut, IGraphBuilder *pGraph);
115
116 //IKsPinFactory
117 HRESULT STDMETHODCALLTYPE KsPinFactory(ULONG* PinFactory);
118
119 //IKsAggregateControl
120 HRESULT STDMETHODCALLTYPE KsAddAggregate(IN REFGUID AggregateClass);
121 HRESULT STDMETHODCALLTYPE KsRemoveAggregate(REFGUID AggregateClass);
122
123 //IQualityControl
124 HRESULT STDMETHODCALLTYPE Notify(IBaseFilter *pSelf, Quality q);
125 HRESULT STDMETHODCALLTYPE SetSink(IQualityControl *piqc);
126
127 //IMediaSeeking
128 HRESULT STDMETHODCALLTYPE GetCapabilities(DWORD *pCapabilities);
129 HRESULT STDMETHODCALLTYPE CheckCapabilities(DWORD *pCapabilities);
130 HRESULT STDMETHODCALLTYPE IsFormatSupported(const GUID *pFormat);
131 HRESULT STDMETHODCALLTYPE QueryPreferredFormat(GUID *pFormat);
132 HRESULT STDMETHODCALLTYPE GetTimeFormat(GUID *pFormat);
133 HRESULT STDMETHODCALLTYPE IsUsingTimeFormat(const GUID *pFormat);
134 HRESULT STDMETHODCALLTYPE SetTimeFormat(const GUID *pFormat);
135 HRESULT STDMETHODCALLTYPE GetDuration(LONGLONG *pDuration);
136 HRESULT STDMETHODCALLTYPE GetStopPosition(LONGLONG *pStop);
137 HRESULT STDMETHODCALLTYPE GetCurrentPosition(LONGLONG *pCurrent);
138 HRESULT STDMETHODCALLTYPE ConvertTimeFormat(LONGLONG *pTarget, const GUID *pTargetFormat, LONGLONG Source, const GUID *pSourceFormat);
139 HRESULT STDMETHODCALLTYPE SetPositions(LONGLONG *pCurrent, DWORD dwCurrentFlags, LONGLONG *pStop, DWORD dwStopFlags);
140 HRESULT STDMETHODCALLTYPE GetPositions(LONGLONG *pCurrent, LONGLONG *pStop);
141 HRESULT STDMETHODCALLTYPE GetAvailable(LONGLONG *pEarliest, LONGLONG *pLatest);
142 HRESULT STDMETHODCALLTYPE SetRate(double dRate);
143 HRESULT STDMETHODCALLTYPE GetRate(double *pdRate);
144 HRESULT STDMETHODCALLTYPE GetPreroll(LONGLONG *pllPreroll);
145
146 //IAMBufferNegotiation
147 HRESULT STDMETHODCALLTYPE SuggestAllocatorProperties(const ALLOCATOR_PROPERTIES *pprop);
148 HRESULT STDMETHODCALLTYPE GetAllocatorProperties(ALLOCATOR_PROPERTIES *pprop);
149
150 //IAMStreamConfig
151 HRESULT STDMETHODCALLTYPE SetFormat(AM_MEDIA_TYPE *pmt);
152 HRESULT STDMETHODCALLTYPE GetFormat(AM_MEDIA_TYPE **ppmt);
153 HRESULT STDMETHODCALLTYPE GetNumberOfCapabilities(int *piCount, int *piSize);
154 HRESULT STDMETHODCALLTYPE GetStreamCaps(int iIndex, AM_MEDIA_TYPE **ppmt, BYTE *pSCC);
155
156 //IMemAllocatorNotifyCallbackTemp
157 HRESULT STDMETHODCALLTYPE NotifyRelease();
158
159 //---------------------------------------------------------------
160 COutputPin(IBaseFilter * ParentFilter, LPCWSTR PinName, ULONG PinId, KSPIN_COMMUNICATION Communication);
161 virtual ~COutputPin();
162 HRESULT STDMETHODCALLTYPE CheckFormat(const AM_MEDIA_TYPE *pmt);
163 HRESULT STDMETHODCALLTYPE CreatePin(const AM_MEDIA_TYPE *pmt);
164 HRESULT STDMETHODCALLTYPE CreatePinHandle(PKSPIN_MEDIUM Medium, PKSPIN_INTERFACE Interface, const AM_MEDIA_TYPE *pmt);
165 HRESULT WINAPI IoProcessRoutine();
166 HRESULT WINAPI InitializeIOThread();
167 HRESULT STDMETHODCALLTYPE GetSupportedSets(LPGUID * pOutGuid, PULONG NumGuids);
168 HRESULT STDMETHODCALLTYPE LoadProxyPlugins(LPGUID pGuids, ULONG NumGuids);
169
170 friend DWORD WINAPI COutputPin_IoThreadStartup(LPVOID lpParameter);
171 friend HRESULT STDMETHODCALLTYPE COutputPin_SetState(IPin * Pin, KSSTATE State);
172
173 protected:
174 LONG m_Ref;
175 IBaseFilter * m_ParentFilter;
176 LPCWSTR m_PinName;
177 HANDLE m_hPin;
178 ULONG m_PinId;
179 IPin * m_Pin;
180 IKsAllocatorEx * m_KsAllocatorEx;
181 ULONG m_PipeAllocatorFlag;
182 BOOL m_bPinBusCacheInitialized;
183 GUID m_PinBusCache;
184 LPWSTR m_FilterName;
185 FRAMING_PROP m_FramingProp[4];
186 PKSALLOCATOR_FRAMING_EX m_FramingEx[4];
187
188 IMemAllocator * m_MemAllocator;
189 IMemInputPin * m_MemInputPin;
190 LONG m_IoCount;
191 KSPIN_COMMUNICATION m_Communication;
192 KSPIN_INTERFACE m_Interface;
193 KSPIN_MEDIUM m_Medium;
194 AM_MEDIA_TYPE m_MediaFormat;
195 ALLOCATOR_PROPERTIES m_Properties;
196 IKsInterfaceHandler * m_InterfaceHandler;
197
198 HANDLE m_hStartEvent;
199 HANDLE m_hBufferAvailable;
200 HANDLE m_hStopEvent;
201 BOOL m_StopInProgress;
202 BOOL m_IoThreadStarted;
203
204 KSSTATE m_State;
205 CRITICAL_SECTION m_Lock;
206
207 ProxyPluginVector m_Plugins;
208 };
209
210 COutputPin::~COutputPin()
211 {
212 }
213
214 COutputPin::COutputPin(
215 IBaseFilter * ParentFilter,
216 LPCWSTR PinName,
217 ULONG PinId,
218 KSPIN_COMMUNICATION Communication) : m_Ref(0),
219 m_ParentFilter(ParentFilter),
220 m_PinName(PinName),
221 m_hPin(INVALID_HANDLE_VALUE),
222 m_PinId(PinId),
223 m_Pin(0),
224 m_KsAllocatorEx(0),
225 m_PipeAllocatorFlag(0),
226 m_bPinBusCacheInitialized(0),
227 m_FilterName(0),
228 m_MemAllocator(0),
229 m_MemInputPin(0),
230 m_IoCount(0),
231 m_Communication(Communication),
232 m_InterfaceHandler(0),
233 m_hStartEvent(0),
234 m_hBufferAvailable(0),
235 m_hStopEvent(0),
236 m_StopInProgress(0),
237 m_IoThreadStarted(0),
238 m_State(KSSTATE_STOP),
239 m_Plugins()
240 {
241 HRESULT hr;
242 IKsObject * KsObjectParent;
243
244 hr = m_ParentFilter->QueryInterface(IID_IKsObject, (LPVOID*)&KsObjectParent);
245 assert(hr == S_OK);
246
247 ZeroMemory(m_FramingProp, sizeof(m_FramingProp));
248 ZeroMemory(m_FramingEx, sizeof(m_FramingEx));
249 ZeroMemory(&m_MediaFormat, sizeof(AM_MEDIA_TYPE));
250
251 hr = KsGetMediaType(0, &m_MediaFormat, KsObjectParent->KsGetObjectHandle(), m_PinId);
252
253 #ifdef KSPROXY_TRACE
254 WCHAR Buffer[100];
255 swprintf(Buffer, L"COutputPin::COutputPin Format %p pbFormat %lu\n", &m_MediaFormat, m_MediaFormat.cbFormat);
256 OutputDebugStringW(Buffer);
257 #endif
258
259 assert(hr == S_OK);
260
261 InitializeCriticalSection(&m_Lock);
262
263 KsObjectParent->Release();
264 };
265
266 HRESULT
267 STDMETHODCALLTYPE
268 COutputPin::QueryInterface(
269 IN REFIID refiid,
270 OUT PVOID* Output)
271 {
272 *Output = NULL;
273 if (IsEqualGUID(refiid, IID_IUnknown) ||
274 IsEqualGUID(refiid, IID_IPin))
275 {
276 #ifdef KSPROXY_TRACE
277 OutputDebugStringW(L"COutputPin::QueryInterface IID_IPin\n");
278 #endif
279 *Output = PVOID(this);
280 reinterpret_cast<IUnknown*>(*Output)->AddRef();
281 return NOERROR;
282 }
283 else if (IsEqualGUID(refiid, IID_IKsObject))
284 {
285 if (m_hPin == INVALID_HANDLE_VALUE)
286 {
287 HRESULT hr = CreatePin(&m_MediaFormat);
288 if (FAILED(hr))
289 return hr;
290 }
291 #ifdef KSPROXY_TRACE
292 OutputDebugStringW(L"COutputPin::QueryInterface IID_IKsObject\n");
293 #endif
294 *Output = (IKsObject*)(this);
295 reinterpret_cast<IKsObject*>(*Output)->AddRef();
296 return NOERROR;
297 }
298 else if (IsEqualGUID(refiid, IID_IKsPin) || IsEqualGUID(refiid, IID_IKsPinEx))
299 {
300 *Output = (IKsPinEx*)(this);
301 reinterpret_cast<IKsPinEx*>(*Output)->AddRef();
302 return NOERROR;
303 }
304 else if (IsEqualGUID(refiid, IID_IKsPinPipe))
305 {
306 *Output = (IKsPinPipe*)(this);
307 reinterpret_cast<IKsPinPipe*>(*Output)->AddRef();
308 return NOERROR;
309 }
310 else if (IsEqualGUID(refiid, IID_IKsAggregateControl))
311 {
312 *Output = (IKsAggregateControl*)(this);
313 reinterpret_cast<IKsAggregateControl*>(*Output)->AddRef();
314 return NOERROR;
315 }
316 else if (IsEqualGUID(refiid, IID_IQualityControl))
317 {
318 *Output = (IQualityControl*)(this);
319 reinterpret_cast<IQualityControl*>(*Output)->AddRef();
320 return NOERROR;
321 }
322 else if (IsEqualGUID(refiid, IID_IKsPropertySet))
323 {
324 if (m_hPin == INVALID_HANDLE_VALUE)
325 {
326 HRESULT hr = CreatePin(&m_MediaFormat);
327 if (FAILED(hr))
328 return hr;
329 }
330 #ifdef KSPROXY_TRACE
331 OutputDebugStringW(L"COutputPin::QueryInterface IID_IKsPropertySet\n");
332 #endif
333 *Output = (IKsPropertySet*)(this);
334 reinterpret_cast<IKsPropertySet*>(*Output)->AddRef();
335 return NOERROR;
336 }
337 else if (IsEqualGUID(refiid, IID_IKsControl))
338 {
339 #ifdef KSPROXY_TRACE
340 OutputDebugStringW(L"COutputPin::QueryInterface IID_IKsControl\n");
341 #endif
342 *Output = (IKsControl*)(this);
343 reinterpret_cast<IKsControl*>(*Output)->AddRef();
344 return NOERROR;
345 }
346 #if 0
347 else if (IsEqualGUID(refiid, IID_IStreamBuilder))
348 {
349 *Output = (IStreamBuilder*)(this);
350 reinterpret_cast<IStreamBuilder*>(*Output)->AddRef();
351 return NOERROR;
352 }
353 #endif
354 else if (IsEqualGUID(refiid, IID_IKsPinFactory))
355 {
356 #ifdef KSPROXY_TRACE
357 OutputDebugStringW(L"COutputPin::QueryInterface IID_IKsPinFactory\n");
358 #endif
359 *Output = (IKsPinFactory*)(this);
360 reinterpret_cast<IKsPinFactory*>(*Output)->AddRef();
361 return NOERROR;
362 }
363 else if (IsEqualGUID(refiid, IID_ISpecifyPropertyPages))
364 {
365 #ifdef KSPROXY_TRACE
366 OutputDebugStringW(L"COutputPin::QueryInterface IID_ISpecifyPropertyPages\n");
367 #endif
368 *Output = (ISpecifyPropertyPages*)(this);
369 reinterpret_cast<ISpecifyPropertyPages*>(*Output)->AddRef();
370 return NOERROR;
371 }
372 else if (IsEqualGUID(refiid, IID_IMediaSeeking))
373 {
374 *Output = (IMediaSeeking*)(this);
375 reinterpret_cast<IMediaSeeking*>(*Output)->AddRef();
376 return NOERROR;
377 }
378 else if (IsEqualGUID(refiid, IID_IAMBufferNegotiation))
379 {
380 *Output = (IAMBufferNegotiation*)(this);
381 reinterpret_cast<IAMBufferNegotiation*>(*Output)->AddRef();
382 return NOERROR;
383 }
384 else if (IsEqualGUID(refiid, IID_IAMStreamConfig))
385 {
386 *Output = (IAMStreamConfig*)(this);
387 reinterpret_cast<IAMStreamConfig*>(*Output)->AddRef();
388 return NOERROR;
389 }
390 else if (IsEqualGUID(refiid, IID_IMemAllocatorNotifyCallbackTemp))
391 {
392 *Output = (IMemAllocatorNotifyCallbackTemp*)(this);
393 reinterpret_cast<IMemAllocatorNotifyCallbackTemp*>(*Output)->AddRef();
394 return NOERROR;
395 }
396
397 #ifdef KSPROXY_TRACE
398 WCHAR Buffer[MAX_PATH];
399 LPOLESTR lpstr;
400 StringFromCLSID(refiid, &lpstr);
401 swprintf(Buffer, L"COutputPin::QueryInterface: NoInterface for %s PinId %u PinName %s\n", lpstr, m_PinId, m_PinName);
402 OutputDebugStringW(Buffer);
403 CoTaskMemFree(lpstr);
404 #endif
405
406 return E_NOINTERFACE;
407 }
408
409 //-------------------------------------------------------------------
410 // IAMBufferNegotiation interface
411 //
412 HRESULT
413 STDMETHODCALLTYPE
414 COutputPin::SuggestAllocatorProperties(
415 const ALLOCATOR_PROPERTIES *pprop)
416 {
417 #ifdef KSPROXY_TRACE
418 OutputDebugStringW(L"COutputPin::SuggestAllocatorProperties\n");
419 #endif
420
421 if (m_Pin)
422 {
423 // pin is already connected
424 return VFW_E_ALREADY_CONNECTED;
425 }
426
427 CopyMemory(&m_Properties, pprop, sizeof(ALLOCATOR_PROPERTIES));
428 return NOERROR;
429 }
430
431 HRESULT
432 STDMETHODCALLTYPE
433 COutputPin::GetAllocatorProperties(
434 ALLOCATOR_PROPERTIES *pprop)
435 {
436 #ifdef KSPROXY_TRACE
437 OutputDebugStringW(L"COutputPin::GetAllocatorProperties\n");
438 #endif
439
440 if (!m_Pin)
441 {
442 // you should call this method AFTER you connected
443 return E_UNEXPECTED;
444 }
445
446 if (!m_KsAllocatorEx)
447 {
448 // something went wrong while creating the allocator
449 return E_FAIL;
450 }
451
452 CopyMemory(pprop, &m_Properties, sizeof(ALLOCATOR_PROPERTIES));
453 return NOERROR;
454 }
455
456 //-------------------------------------------------------------------
457 // IAMStreamConfig interface
458 //
459 HRESULT
460 STDMETHODCALLTYPE
461 COutputPin::SetFormat(
462 AM_MEDIA_TYPE *pmt)
463 {
464 #ifdef KSPROXY_TRACE
465 OutputDebugStringW(L"COutputPin::SetFormat NotImplemented\n");
466 #endif
467 return E_NOTIMPL;
468 }
469
470 HRESULT
471 STDMETHODCALLTYPE
472 COutputPin::GetFormat(AM_MEDIA_TYPE **ppmt)
473 {
474 #ifdef KSPROXY_TRACE
475 OutputDebugStringW(L"COutputPin::GetFormat NotImplemented\n");
476 #endif
477 return E_NOTIMPL;
478 }
479
480 HRESULT
481 STDMETHODCALLTYPE
482 COutputPin::GetNumberOfCapabilities(
483 int *piCount,
484 int *piSize)
485 {
486 #ifdef KSPROXY_TRACE
487 OutputDebugStringW(L"COutputPin::GetNumberOfCapabilities NotImplemented\n");
488 #endif
489 return E_NOTIMPL;
490 }
491
492 HRESULT
493 STDMETHODCALLTYPE
494 COutputPin::GetStreamCaps(
495 int iIndex,
496 AM_MEDIA_TYPE **ppmt,
497 BYTE *pSCC)
498 {
499 #ifdef KSPROXY_TRACE
500 OutputDebugStringW(L"COutputPin::GetStreamCaps NotImplemented\n");
501 #endif
502 return E_NOTIMPL;
503 }
504
505 //-------------------------------------------------------------------
506 // IMemAllocatorNotifyCallbackTemp interface
507 //
508 HRESULT
509 STDMETHODCALLTYPE
510 COutputPin::NotifyRelease()
511 {
512 #ifdef KSPROXY_TRACE
513 OutputDebugStringW(L"COutputPin::NotifyRelease\n");
514 #endif
515
516 // notify thread of new available sample
517 SetEvent(m_hBufferAvailable);
518
519 return NOERROR;
520 }
521
522 //-------------------------------------------------------------------
523 // IMediaSeeking interface
524 //
525 HRESULT
526 STDMETHODCALLTYPE
527 COutputPin::GetCapabilities(
528 DWORD *pCapabilities)
529 {
530 IMediaSeeking * FilterMediaSeeking;
531 HRESULT hr;
532
533 hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
534 if (FAILED(hr))
535 return hr;
536
537 hr = FilterMediaSeeking->GetCapabilities(pCapabilities);
538
539 FilterMediaSeeking->Release();
540 return hr;
541 }
542
543 HRESULT
544 STDMETHODCALLTYPE
545 COutputPin::CheckCapabilities(
546 DWORD *pCapabilities)
547 {
548 IMediaSeeking * FilterMediaSeeking;
549 HRESULT hr;
550
551 hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
552 if (FAILED(hr))
553 return hr;
554
555 hr = FilterMediaSeeking->CheckCapabilities(pCapabilities);
556
557 FilterMediaSeeking->Release();
558 return hr;
559 }
560
561 HRESULT
562 STDMETHODCALLTYPE
563 COutputPin::IsFormatSupported(
564 const GUID *pFormat)
565 {
566 IMediaSeeking * FilterMediaSeeking;
567 HRESULT hr;
568
569 hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
570 if (FAILED(hr))
571 return hr;
572
573 hr = FilterMediaSeeking->IsFormatSupported(pFormat);
574
575 FilterMediaSeeking->Release();
576 return hr;
577 }
578
579 HRESULT
580 STDMETHODCALLTYPE
581 COutputPin::QueryPreferredFormat(
582 GUID *pFormat)
583 {
584 IMediaSeeking * FilterMediaSeeking;
585 HRESULT hr;
586
587 hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
588 if (FAILED(hr))
589 return hr;
590
591 hr = FilterMediaSeeking->QueryPreferredFormat(pFormat);
592
593 FilterMediaSeeking->Release();
594 return hr;
595 }
596
597 HRESULT
598 STDMETHODCALLTYPE
599 COutputPin::GetTimeFormat(
600 GUID *pFormat)
601 {
602 IMediaSeeking * FilterMediaSeeking;
603 HRESULT hr;
604
605 hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
606 if (FAILED(hr))
607 return hr;
608
609 hr = FilterMediaSeeking->GetTimeFormat(pFormat);
610
611 FilterMediaSeeking->Release();
612 return hr;
613 }
614
615 HRESULT
616 STDMETHODCALLTYPE
617 COutputPin::IsUsingTimeFormat(
618 const GUID *pFormat)
619 {
620 IMediaSeeking * FilterMediaSeeking;
621 HRESULT hr;
622
623 hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
624 if (FAILED(hr))
625 return hr;
626
627 hr = FilterMediaSeeking->IsUsingTimeFormat(pFormat);
628
629 FilterMediaSeeking->Release();
630 return hr;
631 }
632
633 HRESULT
634 STDMETHODCALLTYPE
635 COutputPin::SetTimeFormat(
636 const GUID *pFormat)
637 {
638 IMediaSeeking * FilterMediaSeeking;
639 HRESULT hr;
640
641 hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
642 if (FAILED(hr))
643 return hr;
644
645 hr = FilterMediaSeeking->SetTimeFormat(pFormat);
646
647 FilterMediaSeeking->Release();
648 return hr;
649 }
650
651 HRESULT
652 STDMETHODCALLTYPE
653 COutputPin::GetDuration(
654 LONGLONG *pDuration)
655 {
656 IMediaSeeking * FilterMediaSeeking;
657 HRESULT hr;
658
659 hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
660 if (FAILED(hr))
661 return hr;
662
663 hr = FilterMediaSeeking->GetDuration(pDuration);
664
665 FilterMediaSeeking->Release();
666 return hr;
667 }
668
669 HRESULT
670 STDMETHODCALLTYPE
671 COutputPin::GetStopPosition(
672 LONGLONG *pStop)
673 {
674 IMediaSeeking * FilterMediaSeeking;
675 HRESULT hr;
676
677 hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
678 if (FAILED(hr))
679 return hr;
680
681 hr = FilterMediaSeeking->GetStopPosition(pStop);
682
683 FilterMediaSeeking->Release();
684 return hr;
685 }
686
687
688 HRESULT
689 STDMETHODCALLTYPE
690 COutputPin::GetCurrentPosition(
691 LONGLONG *pCurrent)
692 {
693 IMediaSeeking * FilterMediaSeeking;
694 HRESULT hr;
695
696 hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
697 if (FAILED(hr))
698 return hr;
699
700 hr = FilterMediaSeeking->GetCurrentPosition(pCurrent);
701
702 FilterMediaSeeking->Release();
703 return hr;
704 }
705
706 HRESULT
707 STDMETHODCALLTYPE
708 COutputPin::ConvertTimeFormat(
709 LONGLONG *pTarget,
710 const GUID *pTargetFormat,
711 LONGLONG Source,
712 const GUID *pSourceFormat)
713 {
714 IMediaSeeking * FilterMediaSeeking;
715 HRESULT hr;
716
717 hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
718 if (FAILED(hr))
719 return hr;
720
721 hr = FilterMediaSeeking->ConvertTimeFormat(pTarget, pTargetFormat, Source, pSourceFormat);
722
723 FilterMediaSeeking->Release();
724 return hr;
725 }
726
727 HRESULT
728 STDMETHODCALLTYPE
729 COutputPin::SetPositions(
730 LONGLONG *pCurrent,
731 DWORD dwCurrentFlags,
732 LONGLONG *pStop,
733 DWORD dwStopFlags)
734 {
735 IMediaSeeking * FilterMediaSeeking;
736 HRESULT hr;
737
738 hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
739 if (FAILED(hr))
740 return hr;
741
742 hr = FilterMediaSeeking->SetPositions(pCurrent, dwCurrentFlags, pStop, dwStopFlags);
743
744 FilterMediaSeeking->Release();
745 return hr;
746 }
747
748 HRESULT
749 STDMETHODCALLTYPE
750 COutputPin::GetPositions(
751 LONGLONG *pCurrent,
752 LONGLONG *pStop)
753 {
754 IMediaSeeking * FilterMediaSeeking;
755 HRESULT hr;
756
757 hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
758 if (FAILED(hr))
759 return hr;
760
761 hr = FilterMediaSeeking->GetPositions(pCurrent, pStop);
762
763 FilterMediaSeeking->Release();
764 return hr;
765 }
766
767 HRESULT
768 STDMETHODCALLTYPE
769 COutputPin::GetAvailable(
770 LONGLONG *pEarliest,
771 LONGLONG *pLatest)
772 {
773 IMediaSeeking * FilterMediaSeeking;
774 HRESULT hr;
775
776 hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
777 if (FAILED(hr))
778 return hr;
779
780 hr = FilterMediaSeeking->GetAvailable(pEarliest, pLatest);
781
782 FilterMediaSeeking->Release();
783 return hr;
784 }
785
786 HRESULT
787 STDMETHODCALLTYPE
788 COutputPin::SetRate(
789 double dRate)
790 {
791 IMediaSeeking * FilterMediaSeeking;
792 HRESULT hr;
793
794 hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
795 if (FAILED(hr))
796 return hr;
797
798 hr = FilterMediaSeeking->SetRate(dRate);
799
800 FilterMediaSeeking->Release();
801 return hr;
802 }
803
804 HRESULT
805 STDMETHODCALLTYPE
806 COutputPin::GetRate(
807 double *pdRate)
808 {
809 IMediaSeeking * FilterMediaSeeking;
810 HRESULT hr;
811
812 hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
813 if (FAILED(hr))
814 return hr;
815
816 hr = FilterMediaSeeking->GetRate(pdRate);
817
818 FilterMediaSeeking->Release();
819 return hr;
820 }
821
822 HRESULT
823 STDMETHODCALLTYPE
824 COutputPin::GetPreroll(
825 LONGLONG *pllPreroll)
826 {
827 IMediaSeeking * FilterMediaSeeking;
828 HRESULT hr;
829
830 hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&FilterMediaSeeking);
831 if (FAILED(hr))
832 return hr;
833
834 hr = FilterMediaSeeking->GetPreroll(pllPreroll);
835
836 FilterMediaSeeking->Release();
837 return hr;
838 }
839
840 //-------------------------------------------------------------------
841 // IQualityControl interface
842 //
843 HRESULT
844 STDMETHODCALLTYPE
845 COutputPin::Notify(
846 IBaseFilter *pSelf,
847 Quality q)
848 {
849 #ifdef KSPROXY_TRACE
850 OutputDebugStringW(L"COutputPin::Notify NotImplemented\n");
851 #endif
852 return E_NOTIMPL;
853 }
854
855 HRESULT
856 STDMETHODCALLTYPE
857 COutputPin::SetSink(
858 IQualityControl *piqc)
859 {
860 #ifdef KSPROXY_TRACE
861 OutputDebugStringW(L"COutputPin::SetSink NotImplemented\n");
862 #endif
863 return E_NOTIMPL;
864 }
865
866
867 //-------------------------------------------------------------------
868 // IKsAggregateControl interface
869 //
870 HRESULT
871 STDMETHODCALLTYPE
872 COutputPin::KsAddAggregate(
873 IN REFGUID AggregateClass)
874 {
875 #ifdef KSPROXY_TRACE
876 OutputDebugStringW(L"COutputPin::KsAddAggregate NotImplemented\n");
877 #endif
878 return E_NOTIMPL;
879 }
880
881 HRESULT
882 STDMETHODCALLTYPE
883 COutputPin::KsRemoveAggregate(
884 REFGUID AggregateClass)
885 {
886 #ifdef KSPROXY_TRACE
887 OutputDebugStringW(L"COutputPin::KsRemoveAggregate NotImplemented\n");
888 #endif
889 return E_NOTIMPL;
890 }
891
892
893 //-------------------------------------------------------------------
894 // IKsPin
895 //
896
897 HRESULT
898 STDMETHODCALLTYPE
899 COutputPin::KsQueryMediums(
900 PKSMULTIPLE_ITEM* MediumList)
901 {
902 HRESULT hr;
903 HANDLE hFilter;
904 IKsObject * KsObjectParent;
905
906 hr = m_ParentFilter->QueryInterface(IID_IKsObject, (LPVOID*)&KsObjectParent);
907 if (FAILED(hr))
908 return E_NOINTERFACE;
909
910 hFilter = KsObjectParent->KsGetObjectHandle();
911
912 if (hFilter)
913 hr = KsGetMultiplePinFactoryItems(hFilter, m_PinId, KSPROPERTY_PIN_MEDIUMS, (PVOID*)MediumList);
914 else
915 hr = E_HANDLE;
916
917 KsObjectParent->Release();
918
919 return hr;
920 }
921
922 HRESULT
923 STDMETHODCALLTYPE
924 COutputPin::KsQueryInterfaces(
925 PKSMULTIPLE_ITEM* InterfaceList)
926 {
927 HRESULT hr;
928 HANDLE hFilter;
929 IKsObject * KsObjectParent;
930
931 hr = m_ParentFilter->QueryInterface(IID_IKsObject, (LPVOID*)&KsObjectParent);
932 if (FAILED(hr))
933 return hr;
934
935 hFilter = KsObjectParent->KsGetObjectHandle();
936
937 if (hFilter)
938 hr = KsGetMultiplePinFactoryItems(hFilter, m_PinId, KSPROPERTY_PIN_INTERFACES, (PVOID*)InterfaceList);
939 else
940 hr = E_HANDLE;
941
942 KsObjectParent->Release();
943
944 return hr;
945 }
946
947 HRESULT
948 STDMETHODCALLTYPE
949 COutputPin::KsCreateSinkPinHandle(
950 KSPIN_INTERFACE& Interface,
951 KSPIN_MEDIUM& Medium)
952 {
953 #ifdef KSPROXY_TRACE
954 OutputDebugStringW(L"COutputPin::KsCreateSinkPinHandle NotImplemented\n");
955 #endif
956 return E_NOTIMPL;
957 }
958
959 HRESULT
960 STDMETHODCALLTYPE
961 COutputPin::KsGetCurrentCommunication(
962 KSPIN_COMMUNICATION *Communication,
963 KSPIN_INTERFACE *Interface,
964 KSPIN_MEDIUM *Medium)
965 {
966 if (Communication)
967 {
968 *Communication = m_Communication;
969 }
970
971 if (Interface)
972 {
973 if (!m_hPin)
974 return VFW_E_NOT_CONNECTED;
975
976 CopyMemory(Interface, &m_Interface, sizeof(KSPIN_INTERFACE));
977 }
978
979 if (Medium)
980 {
981 if (!m_hPin)
982 return VFW_E_NOT_CONNECTED;
983
984 CopyMemory(Medium, &m_Medium, sizeof(KSPIN_MEDIUM));
985 }
986 return NOERROR;
987 }
988
989 HRESULT
990 STDMETHODCALLTYPE
991 COutputPin::KsPropagateAcquire()
992 {
993 KSPROPERTY Property;
994 KSSTATE State;
995 ULONG BytesReturned;
996 HRESULT hr;
997
998 #ifdef KSPROXY_TRACE
999 OutputDebugStringW(L"COutputPin::KsPropagateAcquire\n");
1000 #endif
1001
1002 assert(m_hPin != INVALID_HANDLE_VALUE);
1003
1004 Property.Set = KSPROPSETID_Connection;
1005 Property.Id = KSPROPERTY_CONNECTION_STATE;
1006 Property.Flags = KSPROPERTY_TYPE_SET;
1007
1008 State = KSSTATE_ACQUIRE;
1009
1010 hr = KsProperty(&Property, sizeof(KSPROPERTY), (LPVOID)&State, sizeof(KSSTATE), &BytesReturned);
1011 if (SUCCEEDED(hr))
1012 {
1013 m_State = State;
1014 }
1015
1016 //TODO
1017 //propagate to connected pin on the pipe
1018
1019 return hr;
1020 }
1021
1022 HRESULT
1023 STDMETHODCALLTYPE
1024 COutputPin::KsDeliver(
1025 IMediaSample* Sample,
1026 ULONG Flags)
1027 {
1028 return E_FAIL;
1029 }
1030
1031 HRESULT
1032 STDMETHODCALLTYPE
1033 COutputPin::KsMediaSamplesCompleted(PKSSTREAM_SEGMENT StreamSegment)
1034 {
1035 return NOERROR;
1036 }
1037
1038 IMemAllocator *
1039 STDMETHODCALLTYPE
1040 COutputPin::KsPeekAllocator(KSPEEKOPERATION Operation)
1041 {
1042 if (Operation == KsPeekOperation_AddRef)
1043 {
1044 // add reference on allocator
1045 m_MemAllocator->AddRef();
1046 }
1047
1048 return m_MemAllocator;
1049 }
1050
1051 HRESULT
1052 STDMETHODCALLTYPE
1053 COutputPin::KsReceiveAllocator(IMemAllocator *MemAllocator)
1054 {
1055 if (MemAllocator)
1056 {
1057 MemAllocator->AddRef();
1058 }
1059
1060 if (m_MemAllocator)
1061 {
1062 m_MemAllocator->Release();
1063 }
1064
1065 m_MemAllocator = MemAllocator;
1066 return NOERROR;
1067 }
1068
1069 HRESULT
1070 STDMETHODCALLTYPE
1071 COutputPin::KsRenegotiateAllocator()
1072 {
1073 return E_FAIL;
1074 }
1075
1076 LONG
1077 STDMETHODCALLTYPE
1078 COutputPin::KsIncrementPendingIoCount()
1079 {
1080 return InterlockedIncrement((volatile LONG*)&m_IoCount);
1081 }
1082
1083 LONG
1084 STDMETHODCALLTYPE
1085 COutputPin::KsDecrementPendingIoCount()
1086 {
1087 return InterlockedDecrement((volatile LONG*)&m_IoCount);
1088 }
1089
1090 HRESULT
1091 STDMETHODCALLTYPE
1092 COutputPin::KsQualityNotify(
1093 ULONG Proportion,
1094 REFERENCE_TIME TimeDelta)
1095 {
1096 #ifdef KSPROXY_TRACE
1097 OutputDebugStringW(L"COutputPin::KsQualityNotify NotImplemented\n");
1098 #endif
1099 return E_NOTIMPL;
1100 }
1101
1102 //-------------------------------------------------------------------
1103 // IKsPinEx
1104 //
1105
1106 VOID
1107 STDMETHODCALLTYPE
1108 COutputPin::KsNotifyError(
1109 IMediaSample* Sample,
1110 HRESULT hr)
1111 {
1112 #ifdef KSPROXY_TRACE
1113 OutputDebugStringW(L"COutputPin::KsNotifyError NotImplemented\n");
1114 #endif
1115 }
1116
1117
1118 //-------------------------------------------------------------------
1119 // IKsPinPipe
1120 //
1121
1122 HRESULT
1123 STDMETHODCALLTYPE
1124 COutputPin::KsGetPinFramingCache(
1125 PKSALLOCATOR_FRAMING_EX *FramingEx,
1126 PFRAMING_PROP FramingProp,
1127 FRAMING_CACHE_OPS Option)
1128 {
1129 if (Option > Framing_Cache_Write || Option < Framing_Cache_ReadLast)
1130 {
1131 // invalid argument
1132 return E_INVALIDARG;
1133 }
1134
1135 // get framing properties
1136 *FramingProp = m_FramingProp[Option];
1137 *FramingEx = m_FramingEx[Option];
1138
1139 return NOERROR;
1140 }
1141
1142 HRESULT
1143 STDMETHODCALLTYPE
1144 COutputPin::KsSetPinFramingCache(
1145 PKSALLOCATOR_FRAMING_EX FramingEx,
1146 PFRAMING_PROP FramingProp,
1147 FRAMING_CACHE_OPS Option)
1148 {
1149 ULONG Index;
1150 ULONG RefCount = 0;
1151
1152 if (m_FramingEx[Option])
1153 {
1154 for(Index = 1; Index < 4; Index++)
1155 {
1156 if (m_FramingEx[Index] == m_FramingEx[Option])
1157 RefCount++;
1158 }
1159
1160 if (RefCount == 1)
1161 {
1162 // existing framing is only used once
1163 CoTaskMemFree(m_FramingEx[Option]);
1164 }
1165 }
1166
1167 // store framing
1168 m_FramingEx[Option] = FramingEx;
1169 m_FramingProp[Option] = *FramingProp;
1170
1171 return S_OK;
1172 }
1173
1174 IPin*
1175 STDMETHODCALLTYPE
1176 COutputPin::KsGetConnectedPin()
1177 {
1178 return m_Pin;
1179 }
1180
1181 IKsAllocatorEx*
1182 STDMETHODCALLTYPE
1183 COutputPin::KsGetPipe(
1184 KSPEEKOPERATION Operation)
1185 {
1186 if (Operation == KsPeekOperation_AddRef)
1187 {
1188 if (m_KsAllocatorEx)
1189 m_KsAllocatorEx->AddRef();
1190 }
1191 return m_KsAllocatorEx;
1192 }
1193
1194 HRESULT
1195 STDMETHODCALLTYPE
1196 COutputPin::KsSetPipe(
1197 IKsAllocatorEx *KsAllocator)
1198 {
1199 if (KsAllocator)
1200 KsAllocator->AddRef();
1201
1202 if (m_KsAllocatorEx)
1203 m_KsAllocatorEx->Release();
1204
1205 m_KsAllocatorEx = KsAllocator;
1206 return NOERROR;
1207 }
1208
1209 ULONG
1210 STDMETHODCALLTYPE
1211 COutputPin::KsGetPipeAllocatorFlag()
1212 {
1213 return m_PipeAllocatorFlag;
1214 }
1215
1216
1217 HRESULT
1218 STDMETHODCALLTYPE
1219 COutputPin::KsSetPipeAllocatorFlag(
1220 ULONG Flag)
1221 {
1222 m_PipeAllocatorFlag = Flag;
1223 return NOERROR;
1224 }
1225
1226 GUID
1227 STDMETHODCALLTYPE
1228 COutputPin::KsGetPinBusCache()
1229 {
1230 if (!m_bPinBusCacheInitialized)
1231 {
1232 CopyMemory(&m_PinBusCache, &m_Medium.Set, sizeof(GUID));
1233 m_bPinBusCacheInitialized = TRUE;
1234 }
1235
1236 return m_PinBusCache;
1237 }
1238
1239 HRESULT
1240 STDMETHODCALLTYPE
1241 COutputPin::KsSetPinBusCache(
1242 GUID Bus)
1243 {
1244 CopyMemory(&m_PinBusCache, &Bus, sizeof(GUID));
1245 return NOERROR;
1246 }
1247
1248 PWCHAR
1249 STDMETHODCALLTYPE
1250 COutputPin::KsGetPinName()
1251 {
1252 return (PWCHAR)m_PinName;
1253 }
1254
1255
1256 PWCHAR
1257 STDMETHODCALLTYPE
1258 COutputPin::KsGetFilterName()
1259 {
1260 return m_FilterName;
1261 }
1262
1263 //-------------------------------------------------------------------
1264 // ISpecifyPropertyPages
1265 //
1266
1267 HRESULT
1268 STDMETHODCALLTYPE
1269 COutputPin::GetPages(CAUUID *pPages)
1270 {
1271 #ifdef KSPROXY_TRACE
1272 OutputDebugStringW(L"COutputPin::GetPages NotImplemented\n");
1273 #endif
1274
1275 if (!pPages)
1276 return E_POINTER;
1277
1278 pPages->cElems = 0;
1279 pPages->pElems = NULL;
1280
1281 return S_OK;
1282 }
1283
1284 //-------------------------------------------------------------------
1285 // IKsPinFactory
1286 //
1287
1288 HRESULT
1289 STDMETHODCALLTYPE
1290 COutputPin::KsPinFactory(
1291 ULONG* PinFactory)
1292 {
1293 #ifdef KSPROXY_TRACE
1294 OutputDebugStringW(L"COutputPin::KsPinFactory\n");
1295 #endif
1296
1297 *PinFactory = m_PinId;
1298 return S_OK;
1299 }
1300
1301
1302 //-------------------------------------------------------------------
1303 // IStreamBuilder
1304 //
1305
1306 HRESULT
1307 STDMETHODCALLTYPE
1308 COutputPin::Render(
1309 IPin *ppinOut,
1310 IGraphBuilder *pGraph)
1311 {
1312 #ifdef KSPROXY_TRACE
1313 OutputDebugStringW(L"COutputPin::Render\n");
1314 #endif
1315 return S_OK;
1316 }
1317
1318 HRESULT
1319 STDMETHODCALLTYPE
1320 COutputPin::Backout(
1321 IPin *ppinOut,
1322 IGraphBuilder *pGraph)
1323 {
1324 #ifdef KSPROXY_TRACE
1325 OutputDebugStringW(L"COutputPin::Backout\n");
1326 #endif
1327
1328 return S_OK;
1329 }
1330 //-------------------------------------------------------------------
1331 // IKsObject
1332 //
1333 HANDLE
1334 STDMETHODCALLTYPE
1335 COutputPin::KsGetObjectHandle()
1336 {
1337 #ifdef KSPROXY_TRACE
1338 OutputDebugStringW(L"COutputPin::KsGetObjectHandle\n");
1339 #endif
1340
1341 assert(m_hPin != INVALID_HANDLE_VALUE);
1342 return m_hPin;
1343 }
1344
1345 //-------------------------------------------------------------------
1346 // IKsControl
1347 //
1348 HRESULT
1349 STDMETHODCALLTYPE
1350 COutputPin::KsProperty(
1351 PKSPROPERTY Property,
1352 ULONG PropertyLength,
1353 LPVOID PropertyData,
1354 ULONG DataLength,
1355 ULONG* BytesReturned)
1356 {
1357 HRESULT hr;
1358
1359 assert(m_hPin != INVALID_HANDLE_VALUE);
1360
1361 hr = KsSynchronousDeviceControl(m_hPin, IOCTL_KS_PROPERTY, (PVOID)Property, PropertyLength, (PVOID)PropertyData, DataLength, BytesReturned);
1362 #ifdef KSPROXY_TRACE
1363 WCHAR Buffer[100];
1364 LPOLESTR pstr;
1365 StringFromCLSID(Property->Set, &pstr);
1366 swprintf(Buffer, L"COutputPin::KsProperty Set %s Id %lu Flags %x hr %x\n", pstr, Property->Id, Property->Flags, hr);
1367 OutputDebugStringW(Buffer);
1368 #endif
1369
1370 return hr;
1371 }
1372
1373 HRESULT
1374 STDMETHODCALLTYPE
1375 COutputPin::KsMethod(
1376 PKSMETHOD Method,
1377 ULONG MethodLength,
1378 LPVOID MethodData,
1379 ULONG DataLength,
1380 ULONG* BytesReturned)
1381 {
1382 assert(m_hPin != INVALID_HANDLE_VALUE);
1383 #ifdef KSPROXY_TRACE
1384 OutputDebugStringW(L"COutputPin::KsMethod\n");
1385 #endif
1386 return KsSynchronousDeviceControl(m_hPin, IOCTL_KS_METHOD, (PVOID)Method, MethodLength, (PVOID)MethodData, DataLength, BytesReturned);
1387 }
1388
1389 HRESULT
1390 STDMETHODCALLTYPE
1391 COutputPin::KsEvent(
1392 PKSEVENT Event,
1393 ULONG EventLength,
1394 LPVOID EventData,
1395 ULONG DataLength,
1396 ULONG* BytesReturned)
1397 {
1398 assert(m_hPin != INVALID_HANDLE_VALUE);
1399
1400 #ifdef KSPROXY_TRACE
1401 OutputDebugStringW(L"COutputPin::KsEvent\n");
1402 #endif
1403
1404 if (EventLength)
1405 return KsSynchronousDeviceControl(m_hPin, IOCTL_KS_ENABLE_EVENT, (PVOID)Event, EventLength, (PVOID)EventData, DataLength, BytesReturned);
1406 else
1407 return KsSynchronousDeviceControl(m_hPin, IOCTL_KS_DISABLE_EVENT, (PVOID)Event, EventLength, NULL, 0, BytesReturned);
1408 }
1409
1410
1411 //-------------------------------------------------------------------
1412 // IKsPropertySet
1413 //
1414 HRESULT
1415 STDMETHODCALLTYPE
1416 COutputPin::Set(
1417 REFGUID guidPropSet,
1418 DWORD dwPropID,
1419 LPVOID pInstanceData,
1420 DWORD cbInstanceData,
1421 LPVOID pPropData,
1422 DWORD cbPropData)
1423 {
1424 ULONG BytesReturned;
1425
1426 if (cbInstanceData)
1427 {
1428 PKSPROPERTY Property = (PKSPROPERTY)CoTaskMemAlloc(sizeof(KSPROPERTY) + cbInstanceData);
1429 if (!Property)
1430 return E_OUTOFMEMORY;
1431
1432 Property->Set = guidPropSet;
1433 Property->Id = dwPropID;
1434 Property->Flags = KSPROPERTY_TYPE_SET;
1435
1436 CopyMemory((Property+1), pInstanceData, cbInstanceData);
1437
1438 HRESULT hr = KsProperty(Property, sizeof(KSPROPERTY) + cbInstanceData, pPropData, cbPropData, &BytesReturned);
1439 CoTaskMemFree(Property);
1440 return hr;
1441 }
1442 else
1443 {
1444 KSPROPERTY Property;
1445
1446 Property.Set = guidPropSet;
1447 Property.Id = dwPropID;
1448 Property.Flags = KSPROPERTY_TYPE_SET;
1449
1450 HRESULT hr = KsProperty(&Property, sizeof(KSPROPERTY), pPropData, cbPropData, &BytesReturned);
1451 return hr;
1452 }
1453 }
1454
1455 HRESULT
1456 STDMETHODCALLTYPE
1457 COutputPin::Get(
1458 REFGUID guidPropSet,
1459 DWORD dwPropID,
1460 LPVOID pInstanceData,
1461 DWORD cbInstanceData,
1462 LPVOID pPropData,
1463 DWORD cbPropData,
1464 DWORD *pcbReturned)
1465 {
1466 ULONG BytesReturned;
1467
1468 if (cbInstanceData)
1469 {
1470 PKSPROPERTY Property = (PKSPROPERTY)CoTaskMemAlloc(sizeof(KSPROPERTY) + cbInstanceData);
1471 if (!Property)
1472 return E_OUTOFMEMORY;
1473
1474 Property->Set = guidPropSet;
1475 Property->Id = dwPropID;
1476 Property->Flags = KSPROPERTY_TYPE_GET;
1477
1478 CopyMemory((Property+1), pInstanceData, cbInstanceData);
1479
1480 HRESULT hr = KsProperty(Property, sizeof(KSPROPERTY) + cbInstanceData, pPropData, cbPropData, &BytesReturned);
1481 CoTaskMemFree(Property);
1482 return hr;
1483 }
1484 else
1485 {
1486 KSPROPERTY Property;
1487
1488 Property.Set = guidPropSet;
1489 Property.Id = dwPropID;
1490 Property.Flags = KSPROPERTY_TYPE_GET;
1491
1492 HRESULT hr = KsProperty(&Property, sizeof(KSPROPERTY), pPropData, cbPropData, &BytesReturned);
1493 return hr;
1494 }
1495 }
1496
1497 HRESULT
1498 STDMETHODCALLTYPE
1499 COutputPin::QuerySupported(
1500 REFGUID guidPropSet,
1501 DWORD dwPropID,
1502 DWORD *pTypeSupport)
1503 {
1504 KSPROPERTY Property;
1505 ULONG BytesReturned;
1506
1507 #ifdef KSPROXY_TRACE
1508 OutputDebugStringW(L"COutputPin::QuerySupported\n");
1509 #endif
1510
1511 Property.Set = guidPropSet;
1512 Property.Id = dwPropID;
1513 Property.Flags = KSPROPERTY_TYPE_SETSUPPORT;
1514
1515 return KsProperty(&Property, sizeof(KSPROPERTY), pTypeSupport, sizeof(DWORD), &BytesReturned);
1516 }
1517
1518
1519 //-------------------------------------------------------------------
1520 // IPin interface
1521 //
1522 HRESULT
1523 STDMETHODCALLTYPE
1524 COutputPin::Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
1525 {
1526 HRESULT hr;
1527 ALLOCATOR_PROPERTIES Properties;
1528 IMemAllocatorCallbackTemp *pMemCallback;
1529 LPGUID pGuid;
1530 ULONG NumGuids = 0;
1531
1532 #ifdef KSPROXY_TRACE
1533 WCHAR Buffer[200];
1534 OutputDebugStringW(L"COutputPin::Connect called\n");
1535 #endif
1536
1537 if (pmt)
1538 {
1539 hr = pReceivePin->QueryAccept(pmt);
1540 if (FAILED(hr))
1541 return hr;
1542 }
1543 else
1544 {
1545 // query accept
1546 hr = pReceivePin->QueryAccept(&m_MediaFormat);
1547 if (FAILED(hr))
1548 return hr;
1549
1550 pmt = &m_MediaFormat;
1551 }
1552
1553 if (m_hPin == INVALID_HANDLE_VALUE)
1554 {
1555 hr = CreatePin(pmt);
1556 if (FAILED(hr))
1557 {
1558 #ifdef KSPROXY_TRACE
1559 swprintf(Buffer, L"COutputPin::Connect CreatePin handle failed with %lx\n", hr);
1560 OutputDebugStringW(Buffer);
1561 #endif
1562 return hr;
1563 }
1564 }
1565
1566
1567 // query for IMemInput interface
1568 hr = pReceivePin->QueryInterface(IID_IMemInputPin, (void**)&m_MemInputPin);
1569 if (FAILED(hr))
1570 {
1571 #ifdef KSPROXY_TRACE
1572 OutputDebugStringW(L"COutputPin::Connect no IMemInputPin interface\n");
1573 #endif
1574
1575 return hr;
1576 }
1577
1578 // get input pin allocator properties
1579 ZeroMemory(&Properties, sizeof(ALLOCATOR_PROPERTIES));
1580 m_MemInputPin->GetAllocatorRequirements(&Properties);
1581
1582 //FIXME determine allocator properties
1583 Properties.cBuffers = 32;
1584 Properties.cbBuffer = 2048 * 188; //2048 frames * MPEG2 TS Payload size
1585 Properties.cbAlign = 4;
1586
1587 // get input pin allocator
1588 #if 0
1589 hr = m_MemInputPin->GetAllocator(&m_MemAllocator);
1590 if (SUCCEEDED(hr))
1591 {
1592 // set allocator properties
1593 hr = m_MemAllocator->SetProperties(&Properties, &m_Properties);
1594 if (FAILED(hr))
1595 m_MemAllocator->Release();
1596 }
1597 #endif
1598
1599 if (1)
1600 {
1601 hr = CKsAllocator_Constructor(NULL, IID_IMemAllocator, (void**)&m_MemAllocator);
1602 if (FAILED(hr))
1603 return hr;
1604
1605 // set allocator properties
1606 hr = m_MemAllocator->SetProperties(&Properties, &m_Properties);
1607 if (FAILED(hr))
1608 {
1609 #ifdef KSPROXY_TRACE
1610 swprintf(Buffer, L"COutputPin::Connect IMemAllocator::SetProperties failed with hr %lx\n", hr);
1611 OutputDebugStringW(Buffer);
1612 #endif
1613 m_MemAllocator->Release();
1614 m_MemInputPin->Release();
1615 return hr;
1616 }
1617 }
1618
1619 // commit property changes
1620 hr = m_MemAllocator->Commit();
1621 if (FAILED(hr))
1622 {
1623 #ifdef KSPROXY_TRACE
1624 swprintf(Buffer, L"COutputPin::Connect IMemAllocator::Commit failed with hr %lx\n", hr);
1625 OutputDebugStringW(Buffer);
1626 #endif
1627 m_MemAllocator->Release();
1628 m_MemInputPin->Release();
1629 return hr;
1630 }
1631
1632 // get callback interface
1633 hr = m_MemAllocator->QueryInterface(IID_IMemAllocatorCallbackTemp, (void**)&pMemCallback);
1634 if (FAILED(hr))
1635 {
1636 #ifdef KSPROXY_TRACE
1637 swprintf(Buffer, L"COutputPin::Connect No IMemAllocatorCallbackTemp interface hr %lx\n", hr);
1638 OutputDebugStringW(Buffer);
1639 #endif
1640 m_MemAllocator->Release();
1641 m_MemInputPin->Release();
1642 return hr;
1643 }
1644
1645 // set notification routine
1646 hr = pMemCallback->SetNotify((IMemAllocatorNotifyCallbackTemp*)this);
1647
1648 // release IMemAllocatorNotifyCallbackTemp interface
1649 pMemCallback->Release();
1650
1651 if (FAILED(hr))
1652 {
1653 #ifdef KSPROXY_TRACE
1654 swprintf(Buffer, L"COutputPin::Connect IMemAllocatorNotifyCallbackTemp::SetNotify failed hr %lx\n", hr);
1655 OutputDebugStringW(Buffer);
1656 #endif
1657 m_MemAllocator->Release();
1658 m_MemInputPin->Release();
1659 return hr;
1660 }
1661
1662 // now set allocator
1663 hr = m_MemInputPin->NotifyAllocator(m_MemAllocator, TRUE);
1664 if (FAILED(hr))
1665 {
1666 #ifdef KSPROXY_TRACE
1667 swprintf(Buffer, L"COutputPin::Connect IMemInputPin::NotifyAllocator failed with hr %lx\n", hr);
1668 OutputDebugStringW(Buffer);
1669 #endif
1670 m_MemAllocator->Release();
1671 m_MemInputPin->Release();
1672 return hr;
1673 }
1674
1675
1676 assert(m_hPin != INVALID_HANDLE_VALUE);
1677
1678 // get all supported sets
1679 if (m_Plugins.size() == 0)
1680 {
1681 if (GetSupportedSets(&pGuid, &NumGuids))
1682 {
1683 // load all proxy plugins
1684 if (FAILED(LoadProxyPlugins(pGuid, NumGuids)));
1685 {
1686 #ifdef KSPROXY_TRACE
1687 OutputDebugStringW(L"COutputPin::Connect LoadProxyPlugins failed\n");
1688 #endif
1689 }
1690 // free sets
1691 CoTaskMemFree(pGuid);
1692 }
1693 }
1694
1695 // receive connection;
1696 hr = pReceivePin->ReceiveConnection((IPin*)this, pmt);
1697 if (SUCCEEDED(hr))
1698 {
1699 // increment reference count
1700 pReceivePin->AddRef();
1701 m_Pin = pReceivePin;
1702 #ifdef KSPROXY_TRACE
1703 OutputDebugStringW(L"COutputPin::Connect success\n");
1704 #endif
1705 }
1706 else
1707 {
1708 m_MemInputPin->Release();
1709 m_MemAllocator->Release();
1710 }
1711
1712 return hr;
1713 }
1714
1715 HRESULT
1716 STDMETHODCALLTYPE
1717 COutputPin::ReceiveConnection(IPin *pConnector, const AM_MEDIA_TYPE *pmt)
1718 {
1719 return E_UNEXPECTED;
1720 }
1721 HRESULT
1722 STDMETHODCALLTYPE
1723 COutputPin::Disconnect( void)
1724 {
1725 #ifdef KSPROXY_TRACE
1726 OutputDebugStringW(L"COutputPin::Disconnect\n");
1727 #endif
1728
1729 if (!m_Pin)
1730 {
1731 // pin was not connected
1732 return S_FALSE;
1733 }
1734
1735 //FIXME
1736 //check if filter is active
1737
1738 m_Pin->Release();
1739 m_Pin = NULL;
1740 m_MemInputPin->Release();
1741 m_MemAllocator->Release();
1742
1743 CloseHandle(m_hPin);
1744 m_hPin = INVALID_HANDLE_VALUE;
1745
1746 #ifdef KSPROXY_TRACE
1747 OutputDebugStringW(L"COutputPin::Disconnect\n");
1748 #endif
1749 return S_OK;
1750 }
1751 HRESULT
1752 STDMETHODCALLTYPE
1753 COutputPin::ConnectedTo(IPin **pPin)
1754 {
1755 #ifdef KSPROXY_TRACE
1756 OutputDebugStringW(L"COutputPin::ConnectedTo\n");
1757 #endif
1758
1759 if (!pPin)
1760 return E_POINTER;
1761
1762 if (m_Pin)
1763 {
1764 // increment reference count
1765 m_Pin->AddRef();
1766 *pPin = m_Pin;
1767 return S_OK;
1768 }
1769
1770 *pPin = NULL;
1771 return VFW_E_NOT_CONNECTED;
1772 }
1773 HRESULT
1774 STDMETHODCALLTYPE
1775 COutputPin::ConnectionMediaType(AM_MEDIA_TYPE *pmt)
1776 {
1777 #ifdef KSPROXY_TRACE
1778 OutputDebugStringW(L"COutputPin::ConnectionMediaType called\n");
1779 #endif
1780
1781 return E_NOTIMPL;
1782 }
1783 HRESULT
1784 STDMETHODCALLTYPE
1785 COutputPin::QueryPinInfo(PIN_INFO *pInfo)
1786 {
1787 wcscpy(pInfo->achName, m_PinName);
1788 pInfo->dir = PINDIR_OUTPUT;
1789 pInfo->pFilter = m_ParentFilter;
1790 m_ParentFilter->AddRef();
1791
1792 return S_OK;
1793 }
1794 HRESULT
1795 STDMETHODCALLTYPE
1796 COutputPin::QueryDirection(PIN_DIRECTION *pPinDir)
1797 {
1798 if (pPinDir)
1799 {
1800 *pPinDir = PINDIR_OUTPUT;
1801 return S_OK;
1802 }
1803
1804 return E_POINTER;
1805 }
1806 HRESULT
1807 STDMETHODCALLTYPE
1808 COutputPin::QueryId(LPWSTR *Id)
1809 {
1810 *Id = (LPWSTR)CoTaskMemAlloc((wcslen(m_PinName)+1)*sizeof(WCHAR));
1811 if (!*Id)
1812 return E_OUTOFMEMORY;
1813
1814 wcscpy(*Id, m_PinName);
1815 return S_OK;
1816 }
1817 HRESULT
1818 STDMETHODCALLTYPE
1819 COutputPin::QueryAccept(const AM_MEDIA_TYPE *pmt)
1820 {
1821 #ifdef KSPROXY_TRACE
1822 OutputDebugStringW(L"COutputPin::QueryAccept called\n");
1823 #endif
1824
1825 return E_NOTIMPL;
1826 }
1827 HRESULT
1828 STDMETHODCALLTYPE
1829 COutputPin::EnumMediaTypes(IEnumMediaTypes **ppEnum)
1830 {
1831 HRESULT hr;
1832 ULONG MediaTypeCount = 0, Index;
1833 AM_MEDIA_TYPE * MediaTypes;
1834 HANDLE hFilter;
1835 IKsObject * KsObjectParent;
1836
1837 hr = m_ParentFilter->QueryInterface(IID_IKsObject, (LPVOID*)&KsObjectParent);
1838 if (FAILED(hr))
1839 return hr;
1840
1841 // get parent filter handle
1842 hFilter = KsObjectParent->KsGetObjectHandle();
1843
1844 // release IKsObject
1845 KsObjectParent->Release();
1846
1847 // query media type count
1848 hr = KsGetMediaTypeCount(hFilter, m_PinId, &MediaTypeCount);
1849 if (FAILED(hr) || !MediaTypeCount)
1850 {
1851 return hr;
1852 }
1853
1854 // allocate media types
1855 MediaTypes = (AM_MEDIA_TYPE*)CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE) * MediaTypeCount);
1856 if (!MediaTypes)
1857 {
1858 // not enough memory
1859 return E_OUTOFMEMORY;
1860 }
1861
1862 // zero media types
1863 ZeroMemory(MediaTypes, sizeof(AM_MEDIA_TYPE) * MediaTypeCount);
1864
1865 for(Index = 0; Index < MediaTypeCount; Index++)
1866 {
1867 // get media type
1868 hr = KsGetMediaType(Index, &MediaTypes[Index], hFilter, m_PinId);
1869 if (FAILED(hr))
1870 {
1871 // failed
1872 CoTaskMemFree(MediaTypes);
1873 return hr;
1874 }
1875 }
1876
1877 return CEnumMediaTypes_fnConstructor(MediaTypeCount, MediaTypes, IID_IEnumMediaTypes, (void**)ppEnum);
1878 }
1879 HRESULT
1880 STDMETHODCALLTYPE
1881 COutputPin::QueryInternalConnections(IPin **apPin, ULONG *nPin)
1882 {
1883 return E_NOTIMPL;
1884 }
1885 HRESULT
1886 STDMETHODCALLTYPE
1887 COutputPin::EndOfStream( void)
1888 {
1889 /* should be called only on input pins */
1890 return E_UNEXPECTED;
1891 }
1892 HRESULT
1893 STDMETHODCALLTYPE
1894 COutputPin::BeginFlush( void)
1895 {
1896 /* should be called only on input pins */
1897 return E_UNEXPECTED;
1898 }
1899 HRESULT
1900 STDMETHODCALLTYPE
1901 COutputPin::EndFlush( void)
1902 {
1903 /* should be called only on input pins */
1904 return E_UNEXPECTED;
1905 }
1906 HRESULT
1907 STDMETHODCALLTYPE
1908 COutputPin::NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
1909 {
1910 if (!m_Pin)
1911 {
1912 // we are not connected
1913 return VFW_E_NOT_CONNECTED;
1914 }
1915
1916 return m_Pin->NewSegment(tStart, tStop, dRate);
1917 }
1918
1919 //-------------------------------------------------------------------
1920 HRESULT
1921 STDMETHODCALLTYPE
1922 COutputPin::CheckFormat(
1923 const AM_MEDIA_TYPE *pmt)
1924 {
1925 PKSMULTIPLE_ITEM MultipleItem;
1926 PKSDATAFORMAT DataFormat;
1927 HRESULT hr;
1928 IKsObject * KsObjectParent;
1929 HANDLE hFilter;
1930
1931 if (!pmt)
1932 return E_POINTER;
1933
1934 // get IKsObject interface
1935 hr = m_ParentFilter->QueryInterface(IID_IKsObject, (LPVOID*)&KsObjectParent);
1936 if (FAILED(hr))
1937 return hr;
1938
1939 // get parent filter handle
1940 hFilter = KsObjectParent->KsGetObjectHandle();
1941
1942 // release IKsObject
1943 KsObjectParent->Release();
1944
1945 if (!hFilter)
1946 return E_HANDLE;
1947
1948
1949 hr = KsGetMultiplePinFactoryItems(hFilter, m_PinId, KSPROPERTY_PIN_DATARANGES, (PVOID*)&MultipleItem);
1950 if (FAILED(hr))
1951 return S_FALSE;
1952
1953 DataFormat = (PKSDATAFORMAT)(MultipleItem + 1);
1954 for(ULONG Index = 0; Index < MultipleItem->Count; Index++)
1955 {
1956 if (IsEqualGUID(pmt->majortype, DataFormat->MajorFormat) &&
1957 IsEqualGUID(pmt->subtype, DataFormat->SubFormat) &&
1958 IsEqualGUID(pmt->formattype, DataFormat->Specifier))
1959 {
1960 // format is supported
1961 CoTaskMemFree(MultipleItem);
1962 return S_OK;
1963 }
1964 DataFormat = (PKSDATAFORMAT)((ULONG_PTR)DataFormat + DataFormat->FormatSize);
1965 }
1966 //format is not supported
1967 CoTaskMemFree(MultipleItem);
1968 return S_FALSE;
1969 }
1970
1971 HRESULT
1972 STDMETHODCALLTYPE
1973 COutputPin::CreatePin(
1974 const AM_MEDIA_TYPE *pmt)
1975 {
1976 PKSMULTIPLE_ITEM MediumList;
1977 PKSMULTIPLE_ITEM InterfaceList;
1978 PKSPIN_MEDIUM Medium;
1979 PKSPIN_INTERFACE Interface;
1980 IKsInterfaceHandler * InterfaceHandler;
1981 HRESULT hr;
1982
1983 // query for pin medium
1984 hr = KsQueryMediums(&MediumList);
1985 if (FAILED(hr))
1986 {
1987 #ifdef KSPROXY_TRACE
1988 WCHAR Buffer[100];
1989 swprintf(Buffer, L"COutputPin::CreatePin KsQueryMediums failed %lx\n", hr);
1990 OutputDebugStringW(Buffer);
1991 #endif
1992 return hr;
1993 }
1994
1995 // query for pin interface
1996 hr = KsQueryInterfaces(&InterfaceList);
1997 if (FAILED(hr))
1998 {
1999 // failed
2000 #ifdef KSPROXY_TRACE
2001 WCHAR Buffer[100];
2002 swprintf(Buffer, L"COutputPin::CreatePin KsQueryInterfaces failed %lx\n", hr);
2003 OutputDebugStringW(Buffer);
2004 #endif
2005
2006 CoTaskMemFree(MediumList);
2007 return hr;
2008 }
2009
2010 if (MediumList->Count)
2011 {
2012 //use first available medium
2013 Medium = (PKSPIN_MEDIUM)(MediumList + 1);
2014 }
2015 else
2016 {
2017 // default to standard medium
2018 Medium = &StandardPinMedium;
2019 }
2020
2021 if (InterfaceList->Count)
2022 {
2023 //use first available interface
2024 Interface = (PKSPIN_INTERFACE)(InterfaceList + 1);
2025 }
2026 else
2027 {
2028 // default to standard interface
2029 Interface = &StandardPinInterface;
2030 }
2031
2032 if (m_Communication != KSPIN_COMMUNICATION_BRIDGE && m_Communication != KSPIN_COMMUNICATION_NONE)
2033 {
2034 // now create pin
2035 hr = CreatePinHandle(Medium, Interface, pmt);
2036 if (FAILED(hr))
2037 {
2038 #ifdef KSPROXY_TRACE
2039 WCHAR Buffer[100];
2040 swprintf(Buffer, L"COutputPin::CreatePinHandle failed with %lx\n", hr);
2041 OutputDebugStringW(Buffer);
2042 #endif
2043 return hr;
2044 }
2045
2046 if (!m_InterfaceHandler)
2047 {
2048 // now load the IKsInterfaceHandler plugin
2049 hr = CoCreateInstance(Interface->Set, NULL, CLSCTX_INPROC_SERVER, IID_IKsInterfaceHandler, (void**)&InterfaceHandler);
2050 if (FAILED(hr))
2051 {
2052 // failed to load interface handler plugin
2053 CoTaskMemFree(MediumList);
2054 CoTaskMemFree(InterfaceList);
2055
2056 #ifdef KSPROXY_TRACE
2057 WCHAR Buffer[100];
2058 swprintf(Buffer, L"COutputPin::CreatePin failed to create interface handler %lx\n", hr);
2059 OutputDebugStringW(Buffer);
2060 #endif
2061
2062 return hr;
2063 }
2064
2065 // now set the pin
2066 hr = InterfaceHandler->KsSetPin((IKsPin*)this);
2067 if (FAILED(hr))
2068 {
2069 // failed to initialize interface handler plugin
2070 #ifdef KSPROXY_TRACE
2071 WCHAR Buffer[100];
2072 swprintf(Buffer, L"COutputPin::CreatePin failed to initialize interface handler %lx\n", hr);
2073 OutputDebugStringW(Buffer);
2074 #endif
2075 InterfaceHandler->Release();
2076 CoTaskMemFree(MediumList);
2077 CoTaskMemFree(InterfaceList);
2078 return hr;
2079 }
2080
2081 // store interface handler
2082 m_InterfaceHandler = InterfaceHandler;
2083 }
2084 }
2085 else
2086 {
2087 #ifdef KSPROXY_TRACE
2088 WCHAR Buffer[100];
2089 swprintf(Buffer, L"COutputPin::CreatePin unexpected communication %u %s\n", m_Communication, m_PinName);
2090 OutputDebugStringW(Buffer);
2091 #endif
2092
2093 hr = E_FAIL;
2094 }
2095
2096 // free medium / interface / dataformat
2097 CoTaskMemFree(MediumList);
2098 CoTaskMemFree(InterfaceList);
2099
2100 #ifdef KSPROXY_TRACE
2101 WCHAR Buffer[100];
2102 swprintf(Buffer, L"COutputPin::CreatePin Result %lx\n", hr);
2103 OutputDebugStringW(Buffer);
2104 #endif
2105
2106 return hr;
2107 }
2108
2109 HRESULT
2110 STDMETHODCALLTYPE
2111 COutputPin::CreatePinHandle(
2112 PKSPIN_MEDIUM Medium,
2113 PKSPIN_INTERFACE Interface,
2114 const AM_MEDIA_TYPE *pmt)
2115 {
2116 PKSPIN_CONNECT PinConnect;
2117 PKSDATAFORMAT DataFormat;
2118 ULONG Length;
2119 HRESULT hr;
2120 HANDLE hFilter;
2121 IKsObject * KsObjectParent;
2122
2123 //KSALLOCATOR_FRAMING Framing;
2124 //KSPROPERTY Property;
2125 //ULONG BytesReturned;
2126
2127 OutputDebugStringW(L"COutputPin::CreatePinHandle\n");
2128
2129 if (m_hPin != INVALID_HANDLE_VALUE)
2130 {
2131 // pin already exists
2132 //CloseHandle(m_hPin);
2133 //m_hPin = INVALID_HANDLE_VALUE;
2134 OutputDebugStringW(L"COutputPin::CreatePinHandle pin already exists\n");
2135 return S_OK;
2136 }
2137
2138
2139 // calc format size
2140 Length = sizeof(KSPIN_CONNECT) + sizeof(KSDATAFORMAT) + pmt->cbFormat;
2141
2142 // allocate pin connect
2143 PinConnect = (PKSPIN_CONNECT)CoTaskMemAlloc(Length);
2144 if (!PinConnect)
2145 {
2146 // failed
2147 OutputDebugStringW(L"COutputPin::CreatePinHandle out of memory\n");
2148 return E_OUTOFMEMORY;
2149 }
2150 OutputDebugStringW(L"COutputPin::CreatePinHandle copy pinconnect\n");
2151 // setup request
2152 CopyMemory(&PinConnect->Interface, Interface, sizeof(KSPIN_INTERFACE));
2153 CopyMemory(&PinConnect->Medium, Medium, sizeof(KSPIN_MEDIUM));
2154 PinConnect->PinId = m_PinId;
2155 PinConnect->PinToHandle = NULL;
2156 PinConnect->Priority.PriorityClass = KSPRIORITY_NORMAL;
2157 PinConnect->Priority.PrioritySubClass = KSPRIORITY_NORMAL;
2158
2159 // get dataformat offset
2160 DataFormat = (PKSDATAFORMAT)(PinConnect + 1);
2161 OutputDebugStringW(L"COutputPin::CreatePinHandle copy format\n");
2162 // copy data format
2163 DataFormat->FormatSize = sizeof(KSDATAFORMAT) + pmt->cbFormat;
2164 DataFormat->Flags = 0;
2165 DataFormat->SampleSize = pmt->lSampleSize;
2166 DataFormat->Reserved = 0;
2167 CopyMemory(&DataFormat->MajorFormat, &pmt->majortype, sizeof(GUID));
2168 CopyMemory(&DataFormat->SubFormat, &pmt->subtype, sizeof(GUID));
2169 CopyMemory(&DataFormat->Specifier, &pmt->formattype, sizeof(GUID));
2170
2171 if (pmt->cbFormat)
2172 {
2173 // copy extended format
2174 WCHAR Buffer[100];
2175 swprintf(Buffer, L"COutputPin::CreatePinHandle copy format %p pbFormat %lu\n", pmt, pmt->cbFormat);
2176 OutputDebugStringW(Buffer);
2177 CopyMemory((DataFormat + 1), pmt->pbFormat, pmt->cbFormat);
2178 }
2179
2180 // get IKsObject interface
2181 hr = m_ParentFilter->QueryInterface(IID_IKsObject, (LPVOID*)&KsObjectParent);
2182 if (FAILED(hr))
2183 {
2184 OutputDebugStringW(L"COutputPin::CreatePinHandle no IID_IKsObject interface\n");
2185 return hr;
2186 }
2187
2188 // get parent filter handle
2189 hFilter = KsObjectParent->KsGetObjectHandle();
2190
2191 // release IKsObject
2192 KsObjectParent->Release();
2193
2194 if (!hFilter)
2195 {
2196 OutputDebugStringW(L"COutputPin::CreatePinHandle no filter handle\n");
2197 return E_HANDLE;
2198 }
2199
2200 OutputDebugStringW(L"COutputPin::CreatePinHandle before creating pin\n");
2201 // create pin
2202 DWORD dwError = KsCreatePin(hFilter, PinConnect, GENERIC_READ, &m_hPin);
2203
2204 if (dwError == ERROR_SUCCESS)
2205 {
2206 OutputDebugStringW(L"COutputPin::CreatePinHandle created pin\n");
2207
2208 // store current interface / medium
2209 CopyMemory(&m_Medium, Medium, sizeof(KSPIN_MEDIUM));
2210 CopyMemory(&m_Interface, Interface, sizeof(KSPIN_INTERFACE));
2211 CopyMemory(&m_MediaFormat, pmt, sizeof(AM_MEDIA_TYPE));
2212
2213 #ifdef KSPROXY_TRACE
2214 LPOLESTR pMajor, pSub, pFormat;
2215 StringFromIID(m_MediaFormat.majortype, &pMajor);
2216 StringFromIID(m_MediaFormat.subtype , &pSub);
2217 StringFromIID(m_MediaFormat.formattype, &pFormat);
2218 WCHAR Buffer[200];
2219 swprintf(Buffer, L"COutputPin::CreatePinHandle Major %s SubType %s Format %s pbFormat %p cbFormat %u\n", pMajor, pSub, pFormat, pmt->pbFormat, pmt->cbFormat);
2220 CoTaskMemFree(pMajor);
2221 CoTaskMemFree(pSub);
2222 CoTaskMemFree(pFormat);
2223 OutputDebugStringW(Buffer);
2224 #endif
2225
2226 if (pmt->cbFormat)
2227 {
2228 m_MediaFormat.pbFormat = (BYTE*)CoTaskMemAlloc(pmt->cbFormat);
2229 if (!m_MediaFormat.pbFormat)
2230 {
2231 CoTaskMemFree(PinConnect);
2232 m_MediaFormat.pbFormat = NULL;
2233 m_MediaFormat.cbFormat = 0;
2234 return E_OUTOFMEMORY;
2235 }
2236 CopyMemory(m_MediaFormat.pbFormat, pmt->pbFormat, pmt->cbFormat);
2237 }
2238 #if 0
2239 Property.Set = KSPROPSETID_Connection;
2240 Property.Id = KSPROPERTY_CONNECTION_ALLOCATORFRAMING;
2241 Property.Flags = KSPROPERTY_TYPE_GET;
2242
2243 ZeroMemory(&Framing, sizeof(KSALLOCATOR_FRAMING));
2244 hr = KsProperty(&Property, sizeof(KSPROPERTY), (PVOID)&Framing, sizeof(KSALLOCATOR_FRAMING), &BytesReturned);
2245 if (SUCCEEDED(hr))
2246 {
2247 m_Properties.cbAlign = (Framing.FileAlignment + 1);
2248 m_Properties.cbBuffer = Framing.FrameSize;
2249 m_Properties.cbPrefix = 0; //FIXME
2250 m_Properties.cBuffers = Framing.Frames;
2251 }
2252 hr = S_OK;
2253 #endif
2254
2255 if (FAILED(InitializeIOThread()))
2256 {
2257 OutputDebugStringW(L"COutputPin::CreatePinHandle failed to initialize i/o thread\n");
2258 }
2259
2260 //TODO
2261 // connect pin pipes
2262
2263 }
2264 else
2265 OutputDebugStringW(L"COutputPin::CreatePinHandle failed to create pin\n");
2266 // free pin connect
2267 CoTaskMemFree(PinConnect);
2268
2269 return hr;
2270 }
2271
2272 HRESULT
2273 STDMETHODCALLTYPE
2274 COutputPin::GetSupportedSets(
2275 LPGUID * pOutGuid,
2276 PULONG NumGuids)
2277 {
2278 KSPROPERTY Property;
2279 LPGUID pGuid;
2280 ULONG NumProperty = 0;
2281 ULONG NumMethods = 0;
2282 ULONG NumEvents = 0;
2283 ULONG Length;
2284 ULONG BytesReturned;
2285 HRESULT hr;
2286
2287 Property.Set = GUID_NULL;
2288 Property.Id = 0;
2289 Property.Flags = KSPROPERTY_TYPE_SETSUPPORT;
2290
2291 KsSynchronousDeviceControl(m_hPin, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), NULL, 0, &NumProperty);
2292 KsSynchronousDeviceControl(m_hPin, IOCTL_KS_METHOD, (PVOID)&Property, sizeof(KSPROPERTY), NULL, 0, &NumMethods);
2293 KsSynchronousDeviceControl(m_hPin, IOCTL_KS_ENABLE_EVENT, (PVOID)&Property, sizeof(KSPROPERTY), NULL, 0, &NumEvents);
2294
2295 Length = NumProperty + NumMethods + NumEvents;
2296
2297 assert(Length);
2298
2299 // allocate guid buffer
2300 pGuid = (LPGUID)CoTaskMemAlloc(Length);
2301 if (!pGuid)
2302 {
2303 // failed
2304 return E_OUTOFMEMORY;
2305 }
2306
2307 NumProperty /= sizeof(GUID);
2308 NumMethods /= sizeof(GUID);
2309 NumEvents /= sizeof(GUID);
2310
2311 // get all properties
2312 hr = KsSynchronousDeviceControl(m_hPin, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), (PVOID)pGuid, Length, &BytesReturned);
2313 if (FAILED(hr))
2314 {
2315 CoTaskMemFree(pGuid);
2316 return E_FAIL;
2317 }
2318 Length -= BytesReturned;
2319
2320 // get all methods
2321 if (Length && NumMethods)
2322 {
2323 hr = KsSynchronousDeviceControl(m_hPin, IOCTL_KS_METHOD, (PVOID)&Property, sizeof(KSPROPERTY), (PVOID)&pGuid[NumProperty], Length, &BytesReturned);
2324 if (FAILED(hr))
2325 {
2326 CoTaskMemFree(pGuid);
2327 return E_FAIL;
2328 }
2329 Length -= BytesReturned;
2330 }
2331
2332 // get all events
2333 if (Length && NumEvents)
2334 {
2335 hr = KsSynchronousDeviceControl(m_hPin, IOCTL_KS_ENABLE_EVENT, (PVOID)&Property, sizeof(KSPROPERTY), (PVOID)&pGuid[NumProperty+NumMethods], Length, &BytesReturned);
2336 if (FAILED(hr))
2337 {
2338 CoTaskMemFree(pGuid);
2339 return E_FAIL;
2340 }
2341 Length -= BytesReturned;
2342 }
2343
2344 #ifdef KSPROXY_TRACE
2345 WCHAR Buffer[200];
2346 swprintf(Buffer, L"NumProperty %lu NumMethods %lu NumEvents %lu\n", NumProperty, NumMethods, NumEvents);
2347 OutputDebugStringW(Buffer);
2348 #endif
2349
2350 *pOutGuid = pGuid;
2351 *NumGuids = NumProperty+NumEvents+NumMethods;
2352 return S_OK;
2353 }
2354
2355 HRESULT
2356 STDMETHODCALLTYPE
2357 COutputPin::LoadProxyPlugins(
2358 LPGUID pGuids,
2359 ULONG NumGuids)
2360 {
2361 ULONG Index;
2362 LPOLESTR pStr;
2363 HKEY hKey, hSubKey;
2364 HRESULT hr;
2365 IUnknown * pUnknown;
2366
2367 if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"SYSTEM\\CurrentControlSet\\Control\\MediaInterfaces", 0, KEY_READ, &hKey) != ERROR_SUCCESS)
2368 {
2369 OutputDebugStringW(L"CKsProxy::LoadProxyPlugins failed to open MediaInterfaces key\n");
2370 return E_FAIL;
2371 }
2372
2373 // enumerate all sets
2374 for(Index = 0; Index < NumGuids; Index++)
2375 {
2376 // convert to string
2377 hr = StringFromCLSID(pGuids[Index], &pStr);
2378 if (FAILED(hr))
2379 return E_FAIL;
2380
2381 // now try open class key
2382 if (RegOpenKeyExW(hKey, pStr, 0, KEY_READ, &hSubKey) != ERROR_SUCCESS)
2383 {
2384 // no plugin for that set exists
2385 CoTaskMemFree(pStr);
2386 continue;
2387 }
2388
2389 // try load plugin
2390 hr = CoCreateInstance(pGuids[Index], (IBaseFilter*)this, CLSCTX_INPROC_SERVER, IID_IUnknown, (void**)&pUnknown);
2391 if (SUCCEEDED(hr))
2392 {
2393 // store plugin
2394 m_Plugins.push_back(pUnknown);
2395 }
2396 // close key
2397 RegCloseKey(hSubKey);
2398 }
2399
2400 // close media interfaces key
2401 RegCloseKey(hKey);
2402 return S_OK;
2403 }
2404
2405
2406 HRESULT
2407 WINAPI
2408 COutputPin::IoProcessRoutine()
2409 {
2410 IMediaSample *Sample;
2411 LONG SampleCount;
2412 HRESULT hr;
2413 PKSSTREAM_SEGMENT * StreamSegment;
2414 HANDLE hEvent;
2415 IMediaSample ** Samples;
2416 LONG NumHandles;
2417 DWORD dwStatus;
2418
2419 #ifdef KSPROXY_TRACE
2420 WCHAR Buffer[200];
2421 #endif
2422
2423 NumHandles = m_Properties.cBuffers / 2;
2424
2425 if (!NumHandles)
2426 NumHandles = 8;
2427
2428 assert(NumHandles);
2429
2430 //allocate stream segment array
2431 StreamSegment = (PKSSTREAM_SEGMENT*)CoTaskMemAlloc(sizeof(PKSSTREAM_SEGMENT) * NumHandles);
2432 if (!StreamSegment)
2433 {
2434 OutputDebugStringW(L"COutputPin::IoProcessRoutine out of memory\n");
2435 return E_FAIL;
2436 }
2437
2438 // allocate handle array
2439 Samples = (IMediaSample**)CoTaskMemAlloc(sizeof(IMediaSample*) * NumHandles);
2440 if (!Samples)
2441 {
2442 OutputDebugStringW(L"COutputPin::IoProcessRoutine out of memory\n");
2443 return E_FAIL;
2444 }
2445
2446 // zero handles array
2447 ZeroMemory(StreamSegment, sizeof(PKSSTREAM_SEGMENT) * NumHandles);
2448 ZeroMemory(Samples, sizeof(IMediaSample*) * NumHandles);
2449
2450 // first wait for the start event to signal
2451 WaitForSingleObject(m_hStartEvent, INFINITE);
2452
2453 m_IoCount = 0;
2454
2455 assert(m_InterfaceHandler);
2456 do
2457 {
2458 if (m_StopInProgress)
2459 {
2460 // stop io thread
2461 break;
2462 }
2463
2464 assert(m_State == KSSTATE_RUN);
2465 assert(m_MemAllocator);
2466
2467 // get buffer
2468 hr = m_MemAllocator->GetBuffer(&Sample, NULL, NULL, AM_GBF_NOWAIT);
2469
2470 if (FAILED(hr))
2471 {
2472 WaitForSingleObject(m_hBufferAvailable, INFINITE);
2473 // now retry again
2474 continue;
2475 }
2476
2477 // fill buffer
2478 SampleCount = 1;
2479 Samples[m_IoCount] = Sample;
2480
2481 Sample->SetTime(NULL, NULL);
2482 hr = m_InterfaceHandler->KsProcessMediaSamples(NULL, /* FIXME */
2483 &Samples[m_IoCount],
2484 &SampleCount,
2485 KsIoOperation_Read,
2486 &StreamSegment[m_IoCount]);
2487 if (FAILED(hr) || !StreamSegment)
2488 {
2489 #ifdef KSPROXY_TRACE
2490 swprintf(Buffer, L"COutputPin::IoProcessRoutine KsProcessMediaSamples FAILED PinName %s hr %lx\n", m_PinName, hr);
2491 OutputDebugStringW(Buffer);
2492 #endif
2493 break;
2494 }
2495
2496 // interface handle should increment pending i/o count
2497 assert(m_IoCount >= 1);
2498
2499 swprintf(Buffer, L"COutputPin::IoProcessRoutine m_IoCount %lu NumHandles %lu\n", m_IoCount, NumHandles);
2500 OutputDebugStringW(Buffer);
2501
2502 if (m_IoCount != NumHandles)
2503 continue;
2504
2505 // get completion handle
2506 hEvent = StreamSegment[0]->CompletionEvent;
2507
2508 // wait for i/o completion
2509 dwStatus = WaitForSingleObject(hEvent, INFINITE);
2510
2511 swprintf(Buffer, L"COutputPin::IoProcessRoutine dwStatus %lx Error %lx NumHandles %lu\n", dwStatus, GetLastError(), NumHandles);
2512 OutputDebugStringW(Buffer);
2513
2514 // perform completion
2515 m_InterfaceHandler->KsCompleteIo(StreamSegment[0]);
2516
2517 // close completion event
2518 CloseHandle(hEvent);
2519
2520 if (SUCCEEDED(hr))
2521 {
2522 assert(m_MemInputPin);
2523
2524 // now deliver the sample
2525 hr = m_MemInputPin->Receive(Samples[0]);
2526
2527 #ifdef KSPROXY_TRACE
2528 swprintf(Buffer, L"COutputPin::IoProcessRoutine PinName %s IMemInputPin::Receive hr %lx Sample %p m_MemAllocator %p\n", m_PinName, hr, Sample, m_MemAllocator);
2529 OutputDebugStringW(Buffer);
2530 #endif
2531
2532 if (FAILED(hr))
2533 break;
2534
2535 Sample = NULL;
2536 }
2537
2538 //circular stream segment array
2539 RtlMoveMemory(StreamSegment, &StreamSegment[1], sizeof(PKSSTREAM_SEGMENT) * (NumHandles - 1));
2540 RtlMoveMemory(Samples, &Samples[1], sizeof(IMediaSample*) * (NumHandles - 1));
2541
2542 }while(TRUE);
2543
2544 // signal end of i/o thread
2545 SetEvent(m_hStopEvent);
2546
2547 m_IoThreadStarted = false;
2548
2549 return NOERROR;
2550 }
2551
2552 DWORD
2553 WINAPI
2554 COutputPin_IoThreadStartup(
2555 LPVOID lpParameter)
2556 {
2557 COutputPin * Pin = (COutputPin*)lpParameter;
2558 assert(Pin);
2559
2560 return Pin->IoProcessRoutine();
2561 }
2562
2563
2564 HRESULT
2565 WINAPI
2566 COutputPin::InitializeIOThread()
2567 {
2568 HANDLE hThread;
2569
2570 if (m_IoThreadStarted)
2571 return NOERROR;
2572
2573 if (!m_hStartEvent)
2574 m_hStartEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
2575
2576 if (!m_hStartEvent)
2577 return E_OUTOFMEMORY;
2578
2579 if (!m_hStopEvent)
2580 m_hStopEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
2581
2582 if (!m_hStopEvent)
2583 return E_OUTOFMEMORY;
2584
2585 if (!m_hBufferAvailable)
2586 m_hBufferAvailable = CreateEventW(NULL, FALSE, FALSE, NULL);
2587
2588 if (!m_hBufferAvailable)
2589 return E_OUTOFMEMORY;
2590
2591 m_StopInProgress = false;
2592 m_IoThreadStarted = true;
2593
2594 // now create the startup thread
2595 hThread = CreateThread(NULL, 0, COutputPin_IoThreadStartup, (LPVOID)this, 0, NULL);
2596 if (!hThread)
2597 return E_OUTOFMEMORY;
2598
2599
2600 // close thread handle
2601 CloseHandle(hThread);
2602 return NOERROR;
2603 }
2604
2605 HRESULT
2606 STDMETHODCALLTYPE
2607 COutputPin_SetState(
2608 IPin * Pin,
2609 KSSTATE State)
2610 {
2611 HRESULT hr = S_OK;
2612 KSPROPERTY Property;
2613 KSSTATE CurState;
2614 ULONG BytesReturned;
2615 COutputPin * pPin = (COutputPin*)Pin;
2616
2617 #ifdef KSPROXY_TRACE
2618 WCHAR Buffer[200];
2619 #endif
2620
2621 Property.Set = KSPROPSETID_Connection;
2622 Property.Id = KSPROPERTY_CONNECTION_STATE;
2623 Property.Flags = KSPROPERTY_TYPE_SET;
2624
2625 EnterCriticalSection(&pPin->m_Lock);
2626
2627 if (pPin->m_State <= State)
2628 {
2629 if (pPin->m_State == KSSTATE_STOP)
2630 {
2631 hr = pPin->InitializeIOThread();
2632 if (FAILED(hr))
2633 {
2634 // failed to initialize I/O thread
2635 #ifdef KSPROXY_TRACE
2636 OutputDebugStringW(L"Failed to initialize I/O Thread\n");
2637 #endif
2638 LeaveCriticalSection(&pPin->m_Lock);
2639 return hr;
2640 }
2641 CurState = KSSTATE_ACQUIRE;
2642 hr = pPin->KsProperty(&Property, sizeof(KSPROPERTY), &CurState, sizeof(KSSTATE), &BytesReturned);
2643
2644 #ifdef KSPROXY_TRACE
2645 swprintf(Buffer, L"COutputPin_SetState Setting State CurState: KSSTATE_STOP KSSTATE_ACQUIRE PinName %s hr %lx\n", pPin->m_PinName, hr);
2646 OutputDebugStringW(Buffer);
2647 #endif
2648
2649 if (FAILED(hr))
2650 {
2651 LeaveCriticalSection(&pPin->m_Lock);
2652 return hr;
2653 }
2654
2655 pPin->m_State = CurState;
2656
2657 if (pPin->m_State == State)
2658 {
2659 LeaveCriticalSection(&pPin->m_Lock);
2660 return hr;
2661 }
2662 }
2663 if (pPin->m_State == KSSTATE_ACQUIRE)
2664 {
2665 CurState = KSSTATE_PAUSE;
2666 hr = pPin->KsProperty(&Property, sizeof(KSPROPERTY), &CurState, sizeof(KSSTATE), &BytesReturned);
2667
2668 #ifdef KSPROXY_TRACE
2669 swprintf(Buffer, L"COutputPin_SetState Setting State CurState KSSTATE_ACQUIRE KSSTATE_PAUSE PinName %s hr %lx\n", pPin->m_PinName, hr);
2670 OutputDebugStringW(Buffer);
2671 #endif
2672
2673 if (FAILED(hr))
2674 {
2675 LeaveCriticalSection(&pPin->m_Lock);
2676 return hr;
2677 }
2678
2679 pPin->m_State = CurState;
2680
2681 if (pPin->m_State == State)
2682 {
2683 LeaveCriticalSection(&pPin->m_Lock);
2684 return hr;
2685 }
2686 }
2687 if (State == KSSTATE_RUN && pPin->m_State == KSSTATE_PAUSE)
2688 {
2689 CurState = KSSTATE_RUN;
2690 hr = pPin->KsProperty(&Property, sizeof(KSPROPERTY), &CurState, sizeof(KSSTATE), &BytesReturned);
2691
2692 #ifdef KSPROXY_TRACE
2693 swprintf(Buffer, L"COutputPin_SetState Setting State CurState: KSSTATE_PAUSE KSSTATE_RUN PinName %s hr %lx\n", pPin->m_PinName, hr);
2694 OutputDebugStringW(Buffer);
2695 #endif
2696
2697 if (SUCCEEDED(hr))
2698 {
2699 pPin->m_State = CurState;
2700 // signal start event
2701 SetEvent(pPin->m_hStartEvent);
2702 }
2703 }
2704
2705 LeaveCriticalSection(&pPin->m_Lock);
2706 return hr;
2707 }
2708 else
2709 {
2710 if (pPin->m_State == KSSTATE_RUN)
2711 {
2712 // setting pending stop flag
2713 pPin->m_StopInProgress = true;
2714
2715 // release any waiting threads
2716 SetEvent(pPin->m_hBufferAvailable);
2717
2718 // wait until i/o thread is done
2719 WaitForSingleObject(pPin->m_hStopEvent, INFINITE);
2720
2721 CurState = KSSTATE_PAUSE;
2722 hr = pPin->KsProperty(&Property, sizeof(KSPROPERTY), &CurState, sizeof(KSSTATE), &BytesReturned);
2723
2724 #ifdef KSPROXY_TRACE
2725 swprintf(Buffer, L"COutputPin_SetState Setting State CurState: KSSTATE_RUN KSSTATE_PAUSE PinName %s hr %lx\n", pPin->m_PinName, hr);
2726 OutputDebugStringW(Buffer);
2727 #endif
2728
2729 if (FAILED(hr))
2730 {
2731 LeaveCriticalSection(&pPin->m_Lock);
2732 return hr;
2733 }
2734
2735 pPin->m_State = CurState;
2736
2737 if (FAILED(hr))
2738 {
2739 LeaveCriticalSection(&pPin->m_Lock);
2740 return hr;
2741 }
2742 }
2743 if (pPin->m_State == KSSTATE_PAUSE)
2744 {
2745 CurState = KSSTATE_ACQUIRE;
2746 hr = pPin->KsProperty(&Property, sizeof(KSPROPERTY), &CurState, sizeof(KSSTATE), &BytesReturned);
2747
2748 #ifdef KSPROXY_TRACE
2749 swprintf(Buffer, L"COutputPin_SetState Setting State CurState: KSSTATE_PAUSE KSSTATE_ACQUIRE PinName %s hr %lx\n", pPin->m_PinName, hr);
2750 OutputDebugStringW(Buffer);
2751 #endif
2752
2753 if (FAILED(hr))
2754 {
2755 LeaveCriticalSection(&pPin->m_Lock);
2756 return hr;
2757 }
2758
2759 pPin->m_State = CurState;
2760
2761 if (pPin->m_State == State)
2762 {
2763 LeaveCriticalSection(&pPin->m_Lock);
2764 return hr;
2765 }
2766 }
2767
2768 CloseHandle(pPin->m_hStopEvent);
2769 CloseHandle(pPin->m_hStartEvent);
2770 CloseHandle(pPin->m_hBufferAvailable);
2771
2772 /* close event handles */
2773 pPin->m_hStopEvent = NULL;
2774 pPin->m_hStartEvent = NULL;
2775 pPin->m_hBufferAvailable = NULL;
2776
2777 CurState = KSSTATE_STOP;
2778 hr = pPin->KsProperty(&Property, sizeof(KSPROPERTY), &CurState, sizeof(KSSTATE), &BytesReturned);
2779
2780 #ifdef KSPROXY_TRACE
2781 swprintf(Buffer, L"COutputPin_SetState Setting State CurState: KSSTATE_ACQUIRE KSSTATE_STOP PinName %s hr %lx\n", pPin->m_PinName, hr);
2782 OutputDebugStringW(Buffer);
2783 #endif
2784
2785 if (SUCCEEDED(hr))
2786 {
2787 // store state
2788 pPin->m_State = CurState;
2789 }
2790
2791 // unset pending stop flag
2792 pPin->m_StopInProgress = false;
2793
2794 LeaveCriticalSection(&pPin->m_Lock);
2795 return hr;
2796 }
2797 }
2798
2799 HRESULT
2800 WINAPI
2801 COutputPin_Constructor(
2802 IBaseFilter * ParentFilter,
2803 LPCWSTR PinName,
2804 ULONG PinId,
2805 KSPIN_COMMUNICATION Communication,
2806 REFIID riid,
2807 LPVOID * ppv)
2808 {
2809 COutputPin * handler = new COutputPin(ParentFilter, PinName, PinId, Communication);
2810
2811 if (!handler)
2812 return E_OUTOFMEMORY;
2813
2814 if (FAILED(handler->QueryInterface(riid, ppv)))
2815 {
2816 /* not supported */
2817 delete handler;
2818 return E_NOINTERFACE;
2819 }
2820
2821 return S_OK;
2822 }