[RICHED20_WINETEST]
[reactos.git] / reactos / 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 STDMETHODIMP QueryInterface( REFIID InterfaceId, PVOID* Interface);
30
31 STDMETHODIMP_(ULONG) AddRef()
32 {
33 InterlockedIncrement(&m_Ref);
34 return m_Ref;
35 }
36 STDMETHODIMP_(ULONG) Release()
37 {
38 InterlockedDecrement(&m_Ref);
39 if (!m_Ref)
40 {
41 //delete this;
42 return 0;
43 }
44 return m_Ref;
45 }
46
47 //IKsPin
48 HRESULT STDMETHODCALLTYPE KsQueryMediums(PKSMULTIPLE_ITEM* MediumList);
49 HRESULT STDMETHODCALLTYPE KsQueryInterfaces(PKSMULTIPLE_ITEM* InterfaceList);
50 HRESULT STDMETHODCALLTYPE KsCreateSinkPinHandle(KSPIN_INTERFACE& Interface, KSPIN_MEDIUM& Medium);
51 HRESULT STDMETHODCALLTYPE KsGetCurrentCommunication(KSPIN_COMMUNICATION *Communication, KSPIN_INTERFACE *Interface, KSPIN_MEDIUM *Medium);
52 HRESULT STDMETHODCALLTYPE KsPropagateAcquire();
53 HRESULT STDMETHODCALLTYPE KsDeliver(IMediaSample* Sample, ULONG Flags);
54 HRESULT STDMETHODCALLTYPE KsMediaSamplesCompleted(PKSSTREAM_SEGMENT StreamSegment);
55 IMemAllocator * STDMETHODCALLTYPE KsPeekAllocator(KSPEEKOPERATION Operation);
56 HRESULT STDMETHODCALLTYPE KsReceiveAllocator(IMemAllocator *MemAllocator);
57 HRESULT STDMETHODCALLTYPE KsRenegotiateAllocator();
58 LONG STDMETHODCALLTYPE KsIncrementPendingIoCount();
59 LONG STDMETHODCALLTYPE KsDecrementPendingIoCount();
60 HRESULT STDMETHODCALLTYPE KsQualityNotify(ULONG Proportion, REFERENCE_TIME TimeDelta);
61 // IKsPinEx
62 VOID STDMETHODCALLTYPE KsNotifyError(IMediaSample* Sample, HRESULT hr);
63
64 //IKsPinPipe
65 HRESULT STDMETHODCALLTYPE KsGetPinFramingCache(PKSALLOCATOR_FRAMING_EX *FramingEx, PFRAMING_PROP FramingProp, FRAMING_CACHE_OPS Option);
66 HRESULT STDMETHODCALLTYPE KsSetPinFramingCache(PKSALLOCATOR_FRAMING_EX FramingEx, PFRAMING_PROP FramingProp, FRAMING_CACHE_OPS Option);
67 IPin* STDMETHODCALLTYPE KsGetConnectedPin();
68 IKsAllocatorEx* STDMETHODCALLTYPE KsGetPipe(KSPEEKOPERATION Operation);
69 HRESULT STDMETHODCALLTYPE KsSetPipe(IKsAllocatorEx *KsAllocator);
70 ULONG STDMETHODCALLTYPE KsGetPipeAllocatorFlag();
71 HRESULT STDMETHODCALLTYPE KsSetPipeAllocatorFlag(ULONG Flag);
72 GUID STDMETHODCALLTYPE KsGetPinBusCache();
73 HRESULT STDMETHODCALLTYPE KsSetPinBusCache(GUID Bus);
74 PWCHAR STDMETHODCALLTYPE KsGetPinName();
75 PWCHAR STDMETHODCALLTYPE KsGetFilterName();
76
77 //IPin methods
78 HRESULT STDMETHODCALLTYPE Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt);
79 HRESULT STDMETHODCALLTYPE ReceiveConnection(IPin *pConnector, const AM_MEDIA_TYPE *pmt);
80 HRESULT STDMETHODCALLTYPE Disconnect();
81 HRESULT STDMETHODCALLTYPE ConnectedTo(IPin **pPin);
82 HRESULT STDMETHODCALLTYPE ConnectionMediaType(AM_MEDIA_TYPE *pmt);
83 HRESULT STDMETHODCALLTYPE QueryPinInfo(PIN_INFO *pInfo);
84 HRESULT STDMETHODCALLTYPE QueryDirection(PIN_DIRECTION *pPinDir);
85 HRESULT STDMETHODCALLTYPE QueryId(LPWSTR *Id);
86 HRESULT STDMETHODCALLTYPE QueryAccept(const AM_MEDIA_TYPE *pmt);
87 HRESULT STDMETHODCALLTYPE EnumMediaTypes(IEnumMediaTypes **ppEnum);
88 HRESULT STDMETHODCALLTYPE QueryInternalConnections(IPin **apPin, ULONG *nPin);
89 HRESULT STDMETHODCALLTYPE EndOfStream();
90 HRESULT STDMETHODCALLTYPE BeginFlush();
91 HRESULT STDMETHODCALLTYPE EndFlush();
92 HRESULT STDMETHODCALLTYPE NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate);
93
94 // ISpecifyPropertyPages
95 HRESULT STDMETHODCALLTYPE GetPages(CAUUID *pPages);
96
97 //IKsObject methods
98 HANDLE STDMETHODCALLTYPE KsGetObjectHandle();
99
100 //IKsPropertySet
101 HRESULT STDMETHODCALLTYPE Set(REFGUID guidPropSet, DWORD dwPropID, LPVOID pInstanceData, DWORD cbInstanceData, LPVOID pPropData, DWORD cbPropData);
102 HRESULT STDMETHODCALLTYPE Get(REFGUID guidPropSet, DWORD dwPropID, LPVOID pInstanceData, DWORD cbInstanceData, LPVOID pPropData, DWORD cbPropData, DWORD *pcbReturned);
103 HRESULT STDMETHODCALLTYPE QuerySupported(REFGUID guidPropSet, DWORD dwPropID, DWORD *pTypeSupport);
104
105 //IKsControl
106 HRESULT STDMETHODCALLTYPE KsProperty(PKSPROPERTY Property, ULONG PropertyLength, LPVOID PropertyData, ULONG DataLength, ULONG* BytesReturned);
107 HRESULT STDMETHODCALLTYPE KsMethod(PKSMETHOD Method, ULONG MethodLength, LPVOID MethodData, ULONG DataLength, ULONG* BytesReturned);
108 HRESULT STDMETHODCALLTYPE KsEvent(PKSEVENT Event, ULONG EventLength, LPVOID EventData, ULONG DataLength, ULONG* BytesReturned);
109
110 //IStreamBuilder
111 HRESULT STDMETHODCALLTYPE Render(IPin *ppinOut, IGraphBuilder *pGraph);
112 HRESULT STDMETHODCALLTYPE Backout(IPin *ppinOut, IGraphBuilder *pGraph);
113
114 //IKsPinFactory
115 HRESULT STDMETHODCALLTYPE KsPinFactory(ULONG* PinFactory);
116
117 //IKsAggregateControl
118 HRESULT STDMETHODCALLTYPE KsAddAggregate(IN REFGUID AggregateClass);
119 HRESULT STDMETHODCALLTYPE KsRemoveAggregate(REFGUID AggregateClass);
120
121 //IQualityControl
122 HRESULT STDMETHODCALLTYPE Notify(IBaseFilter *pSelf, Quality q);
123 HRESULT STDMETHODCALLTYPE SetSink(IQualityControl *piqc);
124
125 //IMediaSeeking
126 HRESULT STDMETHODCALLTYPE GetCapabilities(DWORD *pCapabilities);
127 HRESULT STDMETHODCALLTYPE CheckCapabilities(DWORD *pCapabilities);
128 HRESULT STDMETHODCALLTYPE IsFormatSupported(const GUID *pFormat);
129 HRESULT STDMETHODCALLTYPE QueryPreferredFormat(GUID *pFormat);
130 HRESULT STDMETHODCALLTYPE GetTimeFormat(GUID *pFormat);
131 HRESULT STDMETHODCALLTYPE IsUsingTimeFormat(const GUID *pFormat);
132 HRESULT STDMETHODCALLTYPE SetTimeFormat(const GUID *pFormat);
133 HRESULT STDMETHODCALLTYPE GetDuration(LONGLONG *pDuration);
134 HRESULT STDMETHODCALLTYPE GetStopPosition(LONGLONG *pStop);
135 HRESULT STDMETHODCALLTYPE GetCurrentPosition(LONGLONG *pCurrent);
136 HRESULT STDMETHODCALLTYPE ConvertTimeFormat(LONGLONG *pTarget, const GUID *pTargetFormat, LONGLONG Source, const GUID *pSourceFormat);
137 HRESULT STDMETHODCALLTYPE SetPositions(LONGLONG *pCurrent, DWORD dwCurrentFlags, LONGLONG *pStop, DWORD dwStopFlags);
138 HRESULT STDMETHODCALLTYPE GetPositions(LONGLONG *pCurrent, LONGLONG *pStop);
139 HRESULT STDMETHODCALLTYPE GetAvailable(LONGLONG *pEarliest, LONGLONG *pLatest);
140 HRESULT STDMETHODCALLTYPE SetRate(double dRate);
141 HRESULT STDMETHODCALLTYPE GetRate(double *pdRate);
142 HRESULT STDMETHODCALLTYPE GetPreroll(LONGLONG *pllPreroll);
143
144 //IAMBufferNegotiation
145 HRESULT STDMETHODCALLTYPE SuggestAllocatorProperties(const ALLOCATOR_PROPERTIES *pprop);
146 HRESULT STDMETHODCALLTYPE GetAllocatorProperties(ALLOCATOR_PROPERTIES *pprop);
147
148 //IAMStreamConfig
149 HRESULT STDMETHODCALLTYPE SetFormat(AM_MEDIA_TYPE *pmt);
150 HRESULT STDMETHODCALLTYPE GetFormat(AM_MEDIA_TYPE **ppmt);
151 HRESULT STDMETHODCALLTYPE GetNumberOfCapabilities(int *piCount, int *piSize);
152 HRESULT STDMETHODCALLTYPE GetStreamCaps(int iIndex, AM_MEDIA_TYPE **ppmt, BYTE *pSCC);
153
154 //IMemAllocatorNotifyCallbackTemp
155 HRESULT STDMETHODCALLTYPE NotifyRelease();
156
157 //---------------------------------------------------------------
158 COutputPin(IBaseFilter * ParentFilter, LPCWSTR PinName, ULONG PinId, KSPIN_COMMUNICATION Communication);
159 virtual ~COutputPin();
160 HRESULT STDMETHODCALLTYPE CheckFormat(const AM_MEDIA_TYPE *pmt);
161 HRESULT STDMETHODCALLTYPE CreatePin(const AM_MEDIA_TYPE *pmt);
162 HRESULT STDMETHODCALLTYPE CreatePinHandle(PKSPIN_MEDIUM Medium, PKSPIN_INTERFACE Interface, const AM_MEDIA_TYPE *pmt);
163 HRESULT WINAPI IoProcessRoutine();
164 HRESULT WINAPI InitializeIOThread();
165
166 friend DWORD WINAPI COutputPin_IoThreadStartup(LPVOID lpParameter);
167 friend HRESULT STDMETHODCALLTYPE COutputPin_SetState(IPin * Pin, KSSTATE State);
168
169 protected:
170 LONG m_Ref;
171 IBaseFilter * m_ParentFilter;
172 LPCWSTR m_PinName;
173 HANDLE m_hPin;
174 ULONG m_PinId;
175 IKsObject * m_KsObjectParent;
176 IPin * m_Pin;
177 IKsAllocatorEx * m_KsAllocatorEx;
178 ULONG m_PipeAllocatorFlag;
179 BOOL m_bPinBusCacheInitialized;
180 GUID m_PinBusCache;
181 LPWSTR m_FilterName;
182 FRAMING_PROP m_FramingProp[4];
183 PKSALLOCATOR_FRAMING_EX m_FramingEx[4];
184
185 IMemAllocator * m_MemAllocator;
186 IMemInputPin * m_MemInputPin;
187 LONG m_IoCount;
188 KSPIN_COMMUNICATION m_Communication;
189 KSPIN_INTERFACE m_Interface;
190 KSPIN_MEDIUM m_Medium;
191 AM_MEDIA_TYPE m_MediaFormat;
192
193 IMediaSeeking * m_FilterMediaSeeking;
194 ALLOCATOR_PROPERTIES m_Properties;
195 IKsInterfaceHandler * m_InterfaceHandler;
196
197 HANDLE m_hStartEvent;
198 HANDLE m_hBufferAvailable;
199 HANDLE m_hStopEvent;
200 BOOL m_StopInProgress;
201 BOOL m_IoThreadStarted;
202
203 KSSTATE m_State;
204 };
205
206 COutputPin::~COutputPin()
207 {
208 if (m_KsObjectParent)
209 m_KsObjectParent->Release();
210 }
211
212 COutputPin::COutputPin(
213 IBaseFilter * ParentFilter,
214 LPCWSTR PinName,
215 ULONG PinId,
216 KSPIN_COMMUNICATION Communication) : m_Ref(0),
217 m_ParentFilter(ParentFilter),
218 m_PinName(PinName),
219 m_hPin(INVALID_HANDLE_VALUE),
220 m_PinId(PinId),
221 m_KsObjectParent(0),
222 m_Pin(0),
223 m_KsAllocatorEx(0),
224 m_PipeAllocatorFlag(0),
225 m_bPinBusCacheInitialized(0),
226 m_FilterName(0),
227 m_MemAllocator(0),
228 m_MemInputPin(0),
229 m_IoCount(0),
230 m_Communication(Communication),
231 m_FilterMediaSeeking(0),
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 {
240 HRESULT hr;
241
242 hr = m_ParentFilter->QueryInterface(IID_IKsObject, (LPVOID*)&m_KsObjectParent);
243 assert(hr == S_OK);
244
245 hr = m_ParentFilter->QueryInterface(IID_IMediaSeeking, (LPVOID*)&m_FilterMediaSeeking);
246 assert(hr == S_OK);
247
248 ZeroMemory(m_FramingProp, sizeof(m_FramingProp));
249 ZeroMemory(m_FramingEx, sizeof(m_FramingEx));
250
251 hr = KsGetMediaType(0, &m_MediaFormat, m_KsObjectParent->KsGetObjectHandle(), m_PinId);
252 assert(hr == S_OK);
253 };
254
255 HRESULT
256 STDMETHODCALLTYPE
257 COutputPin::QueryInterface(
258 IN REFIID refiid,
259 OUT PVOID* Output)
260 {
261 *Output = NULL;
262 if (IsEqualGUID(refiid, IID_IUnknown) ||
263 IsEqualGUID(refiid, IID_IPin))
264 {
265 OutputDebugStringW(L"COutputPin::QueryInterface IID_IPin\n");
266 *Output = PVOID(this);
267 reinterpret_cast<IUnknown*>(*Output)->AddRef();
268 return NOERROR;
269 }
270 else if (IsEqualGUID(refiid, IID_IKsObject))
271 {
272 if (m_hPin == INVALID_HANDLE_VALUE)
273 {
274 HRESULT hr = CreatePin(&m_MediaFormat);
275 if (FAILED(hr))
276 return hr;
277 }
278
279 OutputDebugStringW(L"COutputPin::QueryInterface IID_IKsObject\n");
280 *Output = (IKsObject*)(this);
281 reinterpret_cast<IKsObject*>(*Output)->AddRef();
282 return NOERROR;
283 }
284 else if (IsEqualGUID(refiid, IID_IKsPin) || IsEqualGUID(refiid, IID_IKsPinEx))
285 {
286 *Output = (IKsPinEx*)(this);
287 reinterpret_cast<IKsPinEx*>(*Output)->AddRef();
288 return NOERROR;
289 }
290 else if (IsEqualGUID(refiid, IID_IKsPinPipe))
291 {
292 *Output = (IKsPinPipe*)(this);
293 reinterpret_cast<IKsPinPipe*>(*Output)->AddRef();
294 return NOERROR;
295 }
296 else if (IsEqualGUID(refiid, IID_IKsAggregateControl))
297 {
298 *Output = (IKsAggregateControl*)(this);
299 reinterpret_cast<IKsAggregateControl*>(*Output)->AddRef();
300 return NOERROR;
301 }
302 else if (IsEqualGUID(refiid, IID_IQualityControl))
303 {
304 *Output = (IQualityControl*)(this);
305 reinterpret_cast<IQualityControl*>(*Output)->AddRef();
306 return NOERROR;
307 }
308 else if (IsEqualGUID(refiid, IID_IKsPropertySet))
309 {
310 if (m_hPin == INVALID_HANDLE_VALUE)
311 {
312 HRESULT hr = CreatePin(&m_MediaFormat);
313 if (FAILED(hr))
314 return hr;
315 }
316 OutputDebugStringW(L"COutputPin::QueryInterface IID_IKsPropertySet\n");
317 *Output = (IKsPropertySet*)(this);
318 reinterpret_cast<IKsPropertySet*>(*Output)->AddRef();
319 return NOERROR;
320 }
321 else if (IsEqualGUID(refiid, IID_IKsControl))
322 {
323 OutputDebugStringW(L"COutputPin::QueryInterface IID_IKsControl\n");
324 *Output = (IKsControl*)(this);
325 reinterpret_cast<IKsControl*>(*Output)->AddRef();
326 return NOERROR;
327 }
328 #if 0
329 else if (IsEqualGUID(refiid, IID_IStreamBuilder))
330 {
331 *Output = (IStreamBuilder*)(this);
332 reinterpret_cast<IStreamBuilder*>(*Output)->AddRef();
333 return NOERROR;
334 }
335 #endif
336 else if (IsEqualGUID(refiid, IID_IKsPinFactory))
337 {
338 OutputDebugStringW(L"COutputPin::QueryInterface IID_IKsPinFactory\n");
339 *Output = (IKsPinFactory*)(this);
340 reinterpret_cast<IKsPinFactory*>(*Output)->AddRef();
341 return NOERROR;
342 }
343 else if (IsEqualGUID(refiid, IID_ISpecifyPropertyPages))
344 {
345 OutputDebugStringW(L"COutputPin::QueryInterface IID_ISpecifyPropertyPages\n");
346 *Output = (ISpecifyPropertyPages*)(this);
347 reinterpret_cast<ISpecifyPropertyPages*>(*Output)->AddRef();
348 return NOERROR;
349 }
350 else if (IsEqualGUID(refiid, IID_IMediaSeeking))
351 {
352 *Output = (IMediaSeeking*)(this);
353 reinterpret_cast<IMediaSeeking*>(*Output)->AddRef();
354 return NOERROR;
355 }
356 else if (IsEqualGUID(refiid, IID_IAMBufferNegotiation))
357 {
358 *Output = (IAMBufferNegotiation*)(this);
359 reinterpret_cast<IAMBufferNegotiation*>(*Output)->AddRef();
360 return NOERROR;
361 }
362 else if (IsEqualGUID(refiid, IID_IAMStreamConfig))
363 {
364 *Output = (IAMStreamConfig*)(this);
365 reinterpret_cast<IAMStreamConfig*>(*Output)->AddRef();
366 return NOERROR;
367 }
368 else if (IsEqualGUID(refiid, IID_IMemAllocatorNotifyCallbackTemp))
369 {
370 *Output = (IMemAllocatorNotifyCallbackTemp*)(this);
371 reinterpret_cast<IMemAllocatorNotifyCallbackTemp*>(*Output)->AddRef();
372 return NOERROR;
373 }
374
375 WCHAR Buffer[MAX_PATH];
376 LPOLESTR lpstr;
377 StringFromCLSID(refiid, &lpstr);
378 swprintf(Buffer, L"COutputPin::QueryInterface: NoInterface for %s PinId %u PinName %s\n", lpstr, m_PinId, m_PinName);
379 OutputDebugStringW(Buffer);
380 CoTaskMemFree(lpstr);
381
382 return E_NOINTERFACE;
383 }
384
385 //-------------------------------------------------------------------
386 // IAMBufferNegotiation interface
387 //
388 HRESULT
389 STDMETHODCALLTYPE
390 COutputPin::SuggestAllocatorProperties(
391 const ALLOCATOR_PROPERTIES *pprop)
392 {
393 OutputDebugStringW(L"COutputPin::SuggestAllocatorProperties\n");
394
395 if (m_Pin)
396 {
397 // pin is already connected
398 return VFW_E_ALREADY_CONNECTED;
399 }
400
401 CopyMemory(&m_Properties, pprop, sizeof(ALLOCATOR_PROPERTIES));
402 return NOERROR;
403 }
404
405 HRESULT
406 STDMETHODCALLTYPE
407 COutputPin::GetAllocatorProperties(
408 ALLOCATOR_PROPERTIES *pprop)
409 {
410 OutputDebugStringW(L"COutputPin::GetAllocatorProperties\n");
411
412 if (!m_Pin)
413 {
414 // you should call this method AFTER you connected
415 return E_UNEXPECTED;
416 }
417
418 if (!m_KsAllocatorEx)
419 {
420 // something went wrong while creating the allocator
421 return E_FAIL;
422 }
423
424 CopyMemory(pprop, &m_Properties, sizeof(ALLOCATOR_PROPERTIES));
425 return NOERROR;
426 }
427
428 //-------------------------------------------------------------------
429 // IAMStreamConfig interface
430 //
431 HRESULT
432 STDMETHODCALLTYPE
433 COutputPin::SetFormat(
434 AM_MEDIA_TYPE *pmt)
435 {
436 OutputDebugStringW(L"COutputPin::SetFormat NotImplemented\n");
437 return E_NOTIMPL;
438 }
439
440 HRESULT
441 STDMETHODCALLTYPE
442 COutputPin::GetFormat(AM_MEDIA_TYPE **ppmt)
443 {
444 OutputDebugStringW(L"COutputPin::GetFormat NotImplemented\n");
445 return E_NOTIMPL;
446 }
447
448 HRESULT
449 STDMETHODCALLTYPE
450 COutputPin::GetNumberOfCapabilities(
451 int *piCount,
452 int *piSize)
453 {
454 OutputDebugStringW(L"COutputPin::GetNumberOfCapabilities NotImplemented\n");
455 return E_NOTIMPL;
456 }
457
458 HRESULT
459 STDMETHODCALLTYPE
460 COutputPin::GetStreamCaps(
461 int iIndex,
462 AM_MEDIA_TYPE **ppmt,
463 BYTE *pSCC)
464 {
465 OutputDebugStringW(L"COutputPin::GetStreamCaps NotImplemented\n");
466 return E_NOTIMPL;
467 }
468
469 //-------------------------------------------------------------------
470 // IMemAllocatorNotifyCallbackTemp interface
471 //
472 HRESULT
473 STDMETHODCALLTYPE
474 COutputPin::NotifyRelease()
475 {
476 OutputDebugStringW(L"COutputPin::NotifyRelease\n");
477
478 // notify thread of new available sample
479 SetEvent(m_hBufferAvailable);
480
481 return NOERROR;
482 }
483
484 //-------------------------------------------------------------------
485 // IMediaSeeking interface
486 //
487 HRESULT
488 STDMETHODCALLTYPE
489 COutputPin::GetCapabilities(
490 DWORD *pCapabilities)
491 {
492 return m_FilterMediaSeeking->GetCapabilities(pCapabilities);
493 }
494
495 HRESULT
496 STDMETHODCALLTYPE
497 COutputPin::CheckCapabilities(
498 DWORD *pCapabilities)
499 {
500 return m_FilterMediaSeeking->CheckCapabilities(pCapabilities);
501 }
502
503 HRESULT
504 STDMETHODCALLTYPE
505 COutputPin::IsFormatSupported(
506 const GUID *pFormat)
507 {
508 return m_FilterMediaSeeking->IsFormatSupported(pFormat);
509 }
510
511 HRESULT
512 STDMETHODCALLTYPE
513 COutputPin::QueryPreferredFormat(
514 GUID *pFormat)
515 {
516 return m_FilterMediaSeeking->QueryPreferredFormat(pFormat);
517 }
518
519 HRESULT
520 STDMETHODCALLTYPE
521 COutputPin::GetTimeFormat(
522 GUID *pFormat)
523 {
524 return m_FilterMediaSeeking->GetTimeFormat(pFormat);
525 }
526
527 HRESULT
528 STDMETHODCALLTYPE
529 COutputPin::IsUsingTimeFormat(
530 const GUID *pFormat)
531 {
532 return m_FilterMediaSeeking->IsUsingTimeFormat(pFormat);
533 }
534
535 HRESULT
536 STDMETHODCALLTYPE
537 COutputPin::SetTimeFormat(
538 const GUID *pFormat)
539 {
540 return m_FilterMediaSeeking->SetTimeFormat(pFormat);
541 }
542
543 HRESULT
544 STDMETHODCALLTYPE
545 COutputPin::GetDuration(
546 LONGLONG *pDuration)
547 {
548 return m_FilterMediaSeeking->GetDuration(pDuration);
549 }
550
551 HRESULT
552 STDMETHODCALLTYPE
553 COutputPin::GetStopPosition(
554 LONGLONG *pStop)
555 {
556 return m_FilterMediaSeeking->GetStopPosition(pStop);
557 }
558
559
560 HRESULT
561 STDMETHODCALLTYPE
562 COutputPin::GetCurrentPosition(
563 LONGLONG *pCurrent)
564 {
565 return m_FilterMediaSeeking->GetCurrentPosition(pCurrent);
566 }
567
568 HRESULT
569 STDMETHODCALLTYPE
570 COutputPin::ConvertTimeFormat(
571 LONGLONG *pTarget,
572 const GUID *pTargetFormat,
573 LONGLONG Source,
574 const GUID *pSourceFormat)
575 {
576 return m_FilterMediaSeeking->ConvertTimeFormat(pTarget, pTargetFormat, Source, pSourceFormat);
577 }
578
579 HRESULT
580 STDMETHODCALLTYPE
581 COutputPin::SetPositions(
582 LONGLONG *pCurrent,
583 DWORD dwCurrentFlags,
584 LONGLONG *pStop,
585 DWORD dwStopFlags)
586 {
587 return m_FilterMediaSeeking->SetPositions(pCurrent, dwCurrentFlags, pStop, dwStopFlags);
588 }
589
590 HRESULT
591 STDMETHODCALLTYPE
592 COutputPin::GetPositions(
593 LONGLONG *pCurrent,
594 LONGLONG *pStop)
595 {
596 return m_FilterMediaSeeking->GetPositions(pCurrent, pStop);
597 }
598
599 HRESULT
600 STDMETHODCALLTYPE
601 COutputPin::GetAvailable(
602 LONGLONG *pEarliest,
603 LONGLONG *pLatest)
604 {
605 return m_FilterMediaSeeking->GetAvailable(pEarliest, pLatest);
606 }
607
608 HRESULT
609 STDMETHODCALLTYPE
610 COutputPin::SetRate(
611 double dRate)
612 {
613 return m_FilterMediaSeeking->SetRate(dRate);
614 }
615
616 HRESULT
617 STDMETHODCALLTYPE
618 COutputPin::GetRate(
619 double *pdRate)
620 {
621 return m_FilterMediaSeeking->GetRate(pdRate);
622 }
623
624 HRESULT
625 STDMETHODCALLTYPE
626 COutputPin::GetPreroll(
627 LONGLONG *pllPreroll)
628 {
629 return m_FilterMediaSeeking->GetPreroll(pllPreroll);
630 }
631
632 //-------------------------------------------------------------------
633 // IQualityControl interface
634 //
635 HRESULT
636 STDMETHODCALLTYPE
637 COutputPin::Notify(
638 IBaseFilter *pSelf,
639 Quality q)
640 {
641 OutputDebugStringW(L"COutputPin::Notify NotImplemented\n");
642 return E_NOTIMPL;
643 }
644
645 HRESULT
646 STDMETHODCALLTYPE
647 COutputPin::SetSink(
648 IQualityControl *piqc)
649 {
650 OutputDebugStringW(L"COutputPin::SetSink NotImplemented\n");
651 return E_NOTIMPL;
652 }
653
654
655 //-------------------------------------------------------------------
656 // IKsAggregateControl interface
657 //
658 HRESULT
659 STDMETHODCALLTYPE
660 COutputPin::KsAddAggregate(
661 IN REFGUID AggregateClass)
662 {
663 OutputDebugStringW(L"COutputPin::KsAddAggregate NotImplemented\n");
664 return E_NOTIMPL;
665 }
666
667 HRESULT
668 STDMETHODCALLTYPE
669 COutputPin::KsRemoveAggregate(
670 REFGUID AggregateClass)
671 {
672 OutputDebugStringW(L"COutputPin::KsRemoveAggregate NotImplemented\n");
673 return E_NOTIMPL;
674 }
675
676
677 //-------------------------------------------------------------------
678 // IKsPin
679 //
680
681 HRESULT
682 STDMETHODCALLTYPE
683 COutputPin::KsQueryMediums(
684 PKSMULTIPLE_ITEM* MediumList)
685 {
686 HANDLE hFilter = m_KsObjectParent->KsGetObjectHandle();
687 return KsGetMultiplePinFactoryItems(hFilter, m_PinId, KSPROPERTY_PIN_MEDIUMS, (PVOID*)MediumList);
688 }
689
690 HRESULT
691 STDMETHODCALLTYPE
692 COutputPin::KsQueryInterfaces(
693 PKSMULTIPLE_ITEM* InterfaceList)
694 {
695 HANDLE hFilter = m_KsObjectParent->KsGetObjectHandle();
696
697 return KsGetMultiplePinFactoryItems(hFilter, m_PinId, KSPROPERTY_PIN_INTERFACES, (PVOID*)InterfaceList);
698 }
699
700 HRESULT
701 STDMETHODCALLTYPE
702 COutputPin::KsCreateSinkPinHandle(
703 KSPIN_INTERFACE& Interface,
704 KSPIN_MEDIUM& Medium)
705 {
706 OutputDebugStringW(L"COutputPin::KsCreateSinkPinHandle NotImplemented\n");
707 return E_NOTIMPL;
708 }
709
710 HRESULT
711 STDMETHODCALLTYPE
712 COutputPin::KsGetCurrentCommunication(
713 KSPIN_COMMUNICATION *Communication,
714 KSPIN_INTERFACE *Interface,
715 KSPIN_MEDIUM *Medium)
716 {
717 if (Communication)
718 {
719 *Communication = m_Communication;
720 }
721
722 if (Interface)
723 {
724 if (!m_hPin)
725 return VFW_E_NOT_CONNECTED;
726
727 CopyMemory(Interface, &m_Interface, sizeof(KSPIN_INTERFACE));
728 }
729
730 if (Medium)
731 {
732 if (!m_hPin)
733 return VFW_E_NOT_CONNECTED;
734
735 CopyMemory(Medium, &m_Medium, sizeof(KSPIN_MEDIUM));
736 }
737 return NOERROR;
738 }
739
740 HRESULT
741 STDMETHODCALLTYPE
742 COutputPin::KsPropagateAcquire()
743 {
744 KSPROPERTY Property;
745 KSSTATE State;
746 ULONG BytesReturned;
747 HRESULT hr;
748
749 OutputDebugStringW(L"COutputPin::KsPropagateAcquire\n");
750
751 assert(m_hPin != INVALID_HANDLE_VALUE);
752
753 Property.Set = KSPROPSETID_Connection;
754 Property.Id = KSPROPERTY_CONNECTION_STATE;
755 Property.Flags = KSPROPERTY_TYPE_SET;
756
757 State = KSSTATE_ACQUIRE;
758
759 hr = KsProperty(&Property, sizeof(KSPROPERTY), (LPVOID)&State, sizeof(KSSTATE), &BytesReturned);
760
761 //TODO
762 //propagate to connected pin on the pipe
763
764 return hr;
765 }
766
767 HRESULT
768 STDMETHODCALLTYPE
769 COutputPin::KsDeliver(
770 IMediaSample* Sample,
771 ULONG Flags)
772 {
773 return E_FAIL;
774 }
775
776 HRESULT
777 STDMETHODCALLTYPE
778 COutputPin::KsMediaSamplesCompleted(PKSSTREAM_SEGMENT StreamSegment)
779 {
780 return NOERROR;
781 }
782
783 IMemAllocator *
784 STDMETHODCALLTYPE
785 COutputPin::KsPeekAllocator(KSPEEKOPERATION Operation)
786 {
787 if (Operation == KsPeekOperation_AddRef)
788 {
789 // add reference on allocator
790 m_MemAllocator->AddRef();
791 }
792
793 return m_MemAllocator;
794 }
795
796 HRESULT
797 STDMETHODCALLTYPE
798 COutputPin::KsReceiveAllocator(IMemAllocator *MemAllocator)
799 {
800 if (MemAllocator)
801 {
802 MemAllocator->AddRef();
803 }
804
805 if (m_MemAllocator)
806 {
807 m_MemAllocator->Release();
808 }
809
810 m_MemAllocator = MemAllocator;
811 return NOERROR;
812 }
813
814 HRESULT
815 STDMETHODCALLTYPE
816 COutputPin::KsRenegotiateAllocator()
817 {
818 return E_FAIL;
819 }
820
821 LONG
822 STDMETHODCALLTYPE
823 COutputPin::KsIncrementPendingIoCount()
824 {
825 return InterlockedIncrement((volatile LONG*)&m_IoCount);
826 }
827
828 LONG
829 STDMETHODCALLTYPE
830 COutputPin::KsDecrementPendingIoCount()
831 {
832 return InterlockedDecrement((volatile LONG*)&m_IoCount);
833 }
834
835 HRESULT
836 STDMETHODCALLTYPE
837 COutputPin::KsQualityNotify(
838 ULONG Proportion,
839 REFERENCE_TIME TimeDelta)
840 {
841 OutputDebugStringW(L"COutputPin::KsQualityNotify NotImplemented\n");
842 return E_NOTIMPL;
843 }
844
845 //-------------------------------------------------------------------
846 // IKsPinEx
847 //
848
849 VOID
850 STDMETHODCALLTYPE
851 COutputPin::KsNotifyError(
852 IMediaSample* Sample,
853 HRESULT hr)
854 {
855 OutputDebugStringW(L"COutputPin::KsNotifyError NotImplemented\n");
856 }
857
858
859 //-------------------------------------------------------------------
860 // IKsPinPipe
861 //
862
863 HRESULT
864 STDMETHODCALLTYPE
865 COutputPin::KsGetPinFramingCache(
866 PKSALLOCATOR_FRAMING_EX *FramingEx,
867 PFRAMING_PROP FramingProp,
868 FRAMING_CACHE_OPS Option)
869 {
870 if (Option > Framing_Cache_Write || Option < Framing_Cache_ReadLast)
871 {
872 // invalid argument
873 return E_INVALIDARG;
874 }
875
876 // get framing properties
877 *FramingProp = m_FramingProp[Option];
878 *FramingEx = m_FramingEx[Option];
879
880 return NOERROR;
881 }
882
883 HRESULT
884 STDMETHODCALLTYPE
885 COutputPin::KsSetPinFramingCache(
886 PKSALLOCATOR_FRAMING_EX FramingEx,
887 PFRAMING_PROP FramingProp,
888 FRAMING_CACHE_OPS Option)
889 {
890 ULONG Index;
891 ULONG RefCount = 0;
892
893 if (m_FramingEx[Option])
894 {
895 for(Index = 1; Index < 4; Index++)
896 {
897 if (m_FramingEx[Index] == m_FramingEx[Option])
898 RefCount++;
899 }
900
901 if (RefCount == 1)
902 {
903 // existing framing is only used once
904 CoTaskMemFree(m_FramingEx[Option]);
905 }
906 }
907
908 // store framing
909 m_FramingEx[Option] = FramingEx;
910 m_FramingProp[Option] = *FramingProp;
911
912 return S_OK;
913 }
914
915 IPin*
916 STDMETHODCALLTYPE
917 COutputPin::KsGetConnectedPin()
918 {
919 return m_Pin;
920 }
921
922 IKsAllocatorEx*
923 STDMETHODCALLTYPE
924 COutputPin::KsGetPipe(
925 KSPEEKOPERATION Operation)
926 {
927 if (Operation == KsPeekOperation_AddRef)
928 {
929 if (m_KsAllocatorEx)
930 m_KsAllocatorEx->AddRef();
931 }
932 return m_KsAllocatorEx;
933 }
934
935 HRESULT
936 STDMETHODCALLTYPE
937 COutputPin::KsSetPipe(
938 IKsAllocatorEx *KsAllocator)
939 {
940 if (KsAllocator)
941 KsAllocator->AddRef();
942
943 if (m_KsAllocatorEx)
944 m_KsAllocatorEx->Release();
945
946 m_KsAllocatorEx = KsAllocator;
947 return NOERROR;
948 }
949
950 ULONG
951 STDMETHODCALLTYPE
952 COutputPin::KsGetPipeAllocatorFlag()
953 {
954 return m_PipeAllocatorFlag;
955 }
956
957
958 HRESULT
959 STDMETHODCALLTYPE
960 COutputPin::KsSetPipeAllocatorFlag(
961 ULONG Flag)
962 {
963 m_PipeAllocatorFlag = Flag;
964 return NOERROR;
965 }
966
967 GUID
968 STDMETHODCALLTYPE
969 COutputPin::KsGetPinBusCache()
970 {
971 if (!m_bPinBusCacheInitialized)
972 {
973 CopyMemory(&m_PinBusCache, &m_Medium.Set, sizeof(GUID));
974 m_bPinBusCacheInitialized = TRUE;
975 }
976
977 return m_PinBusCache;
978 }
979
980 HRESULT
981 STDMETHODCALLTYPE
982 COutputPin::KsSetPinBusCache(
983 GUID Bus)
984 {
985 CopyMemory(&m_PinBusCache, &Bus, sizeof(GUID));
986 return NOERROR;
987 }
988
989 PWCHAR
990 STDMETHODCALLTYPE
991 COutputPin::KsGetPinName()
992 {
993 return (PWCHAR)m_PinName;
994 }
995
996
997 PWCHAR
998 STDMETHODCALLTYPE
999 COutputPin::KsGetFilterName()
1000 {
1001 return m_FilterName;
1002 }
1003
1004 //-------------------------------------------------------------------
1005 // ISpecifyPropertyPages
1006 //
1007
1008 HRESULT
1009 STDMETHODCALLTYPE
1010 COutputPin::GetPages(CAUUID *pPages)
1011 {
1012 OutputDebugStringW(L"COutputPin::GetPages NotImplemented\n");
1013
1014 if (!pPages)
1015 return E_POINTER;
1016
1017 pPages->cElems = 0;
1018 pPages->pElems = NULL;
1019
1020 return S_OK;
1021 }
1022
1023 //-------------------------------------------------------------------
1024 // IKsPinFactory
1025 //
1026
1027 HRESULT
1028 STDMETHODCALLTYPE
1029 COutputPin::KsPinFactory(
1030 ULONG* PinFactory)
1031 {
1032 OutputDebugStringW(L"COutputPin::KsPinFactory\n");
1033 *PinFactory = m_PinId;
1034 return S_OK;
1035 }
1036
1037
1038 //-------------------------------------------------------------------
1039 // IStreamBuilder
1040 //
1041
1042 HRESULT
1043 STDMETHODCALLTYPE
1044 COutputPin::Render(
1045 IPin *ppinOut,
1046 IGraphBuilder *pGraph)
1047 {
1048 OutputDebugStringW(L"COutputPin::Render\n");
1049 return S_OK;
1050 }
1051
1052 HRESULT
1053 STDMETHODCALLTYPE
1054 COutputPin::Backout(
1055 IPin *ppinOut,
1056 IGraphBuilder *pGraph)
1057 {
1058 OutputDebugStringW(L"COutputPin::Backout\n");
1059 return S_OK;
1060 }
1061 //-------------------------------------------------------------------
1062 // IKsObject
1063 //
1064 HANDLE
1065 STDMETHODCALLTYPE
1066 COutputPin::KsGetObjectHandle()
1067 {
1068 OutputDebugStringW(L"COutputPin::KsGetObjectHandle\n");
1069 assert(m_hPin != INVALID_HANDLE_VALUE);
1070 return m_hPin;
1071 }
1072
1073 //-------------------------------------------------------------------
1074 // IKsControl
1075 //
1076 HRESULT
1077 STDMETHODCALLTYPE
1078 COutputPin::KsProperty(
1079 PKSPROPERTY Property,
1080 ULONG PropertyLength,
1081 LPVOID PropertyData,
1082 ULONG DataLength,
1083 ULONG* BytesReturned)
1084 {
1085 HRESULT hr;
1086 WCHAR Buffer[100];
1087 LPOLESTR pstr;
1088
1089 assert(m_hPin != INVALID_HANDLE_VALUE);
1090
1091 hr = KsSynchronousDeviceControl(m_hPin, IOCTL_KS_PROPERTY, (PVOID)Property, PropertyLength, (PVOID)PropertyData, DataLength, BytesReturned);
1092
1093 StringFromCLSID(Property->Set, &pstr);
1094 swprintf(Buffer, L"COutputPin::KsProperty Set %s Id %lu Flags %x hr %x\n", pstr, Property->Id, Property->Flags, hr);
1095 OutputDebugStringW(Buffer);
1096
1097 return hr;
1098 }
1099
1100 HRESULT
1101 STDMETHODCALLTYPE
1102 COutputPin::KsMethod(
1103 PKSMETHOD Method,
1104 ULONG MethodLength,
1105 LPVOID MethodData,
1106 ULONG DataLength,
1107 ULONG* BytesReturned)
1108 {
1109 assert(m_hPin != INVALID_HANDLE_VALUE);
1110 OutputDebugStringW(L"COutputPin::KsMethod\n");
1111 return KsSynchronousDeviceControl(m_hPin, IOCTL_KS_METHOD, (PVOID)Method, MethodLength, (PVOID)MethodData, DataLength, BytesReturned);
1112 }
1113
1114 HRESULT
1115 STDMETHODCALLTYPE
1116 COutputPin::KsEvent(
1117 PKSEVENT Event,
1118 ULONG EventLength,
1119 LPVOID EventData,
1120 ULONG DataLength,
1121 ULONG* BytesReturned)
1122 {
1123 assert(m_hPin != INVALID_HANDLE_VALUE);
1124
1125 OutputDebugStringW(L"COutputPin::KsEvent\n");
1126
1127 if (EventLength)
1128 return KsSynchronousDeviceControl(m_hPin, IOCTL_KS_ENABLE_EVENT, (PVOID)Event, EventLength, (PVOID)EventData, DataLength, BytesReturned);
1129 else
1130 return KsSynchronousDeviceControl(m_hPin, IOCTL_KS_DISABLE_EVENT, (PVOID)Event, EventLength, NULL, 0, BytesReturned);
1131 }
1132
1133
1134 //-------------------------------------------------------------------
1135 // IKsPropertySet
1136 //
1137 HRESULT
1138 STDMETHODCALLTYPE
1139 COutputPin::Set(
1140 REFGUID guidPropSet,
1141 DWORD dwPropID,
1142 LPVOID pInstanceData,
1143 DWORD cbInstanceData,
1144 LPVOID pPropData,
1145 DWORD cbPropData)
1146 {
1147 ULONG BytesReturned;
1148
1149 if (cbInstanceData)
1150 {
1151 PKSPROPERTY Property = (PKSPROPERTY)CoTaskMemAlloc(sizeof(KSPROPERTY) + cbInstanceData);
1152 if (!Property)
1153 return E_OUTOFMEMORY;
1154
1155 Property->Set = guidPropSet;
1156 Property->Id = dwPropID;
1157 Property->Flags = KSPROPERTY_TYPE_SET;
1158
1159 CopyMemory((Property+1), pInstanceData, cbInstanceData);
1160
1161 HRESULT hr = KsProperty(Property, sizeof(KSPROPERTY) + cbInstanceData, pPropData, cbPropData, &BytesReturned);
1162 CoTaskMemFree(Property);
1163 return hr;
1164 }
1165 else
1166 {
1167 KSPROPERTY Property;
1168
1169 Property.Set = guidPropSet;
1170 Property.Id = dwPropID;
1171 Property.Flags = KSPROPERTY_TYPE_SET;
1172
1173 HRESULT hr = KsProperty(&Property, sizeof(KSPROPERTY), pPropData, cbPropData, &BytesReturned);
1174 return hr;
1175 }
1176 }
1177
1178 HRESULT
1179 STDMETHODCALLTYPE
1180 COutputPin::Get(
1181 REFGUID guidPropSet,
1182 DWORD dwPropID,
1183 LPVOID pInstanceData,
1184 DWORD cbInstanceData,
1185 LPVOID pPropData,
1186 DWORD cbPropData,
1187 DWORD *pcbReturned)
1188 {
1189 ULONG BytesReturned;
1190
1191 if (cbInstanceData)
1192 {
1193 PKSPROPERTY Property = (PKSPROPERTY)CoTaskMemAlloc(sizeof(KSPROPERTY) + cbInstanceData);
1194 if (!Property)
1195 return E_OUTOFMEMORY;
1196
1197 Property->Set = guidPropSet;
1198 Property->Id = dwPropID;
1199 Property->Flags = KSPROPERTY_TYPE_GET;
1200
1201 CopyMemory((Property+1), pInstanceData, cbInstanceData);
1202
1203 HRESULT hr = KsProperty(Property, sizeof(KSPROPERTY) + cbInstanceData, pPropData, cbPropData, &BytesReturned);
1204 CoTaskMemFree(Property);
1205 return hr;
1206 }
1207 else
1208 {
1209 KSPROPERTY Property;
1210
1211 Property.Set = guidPropSet;
1212 Property.Id = dwPropID;
1213 Property.Flags = KSPROPERTY_TYPE_GET;
1214
1215 HRESULT hr = KsProperty(&Property, sizeof(KSPROPERTY), pPropData, cbPropData, &BytesReturned);
1216 return hr;
1217 }
1218 }
1219
1220 HRESULT
1221 STDMETHODCALLTYPE
1222 COutputPin::QuerySupported(
1223 REFGUID guidPropSet,
1224 DWORD dwPropID,
1225 DWORD *pTypeSupport)
1226 {
1227 KSPROPERTY Property;
1228 ULONG BytesReturned;
1229
1230 OutputDebugStringW(L"COutputPin::QuerySupported\n");
1231
1232 Property.Set = guidPropSet;
1233 Property.Id = dwPropID;
1234 Property.Flags = KSPROPERTY_TYPE_SETSUPPORT;
1235
1236 return KsProperty(&Property, sizeof(KSPROPERTY), pTypeSupport, sizeof(DWORD), &BytesReturned);
1237 }
1238
1239
1240 //-------------------------------------------------------------------
1241 // IPin interface
1242 //
1243 HRESULT
1244 STDMETHODCALLTYPE
1245 COutputPin::Connect(IPin *pReceivePin, const AM_MEDIA_TYPE *pmt)
1246 {
1247 HRESULT hr;
1248 ALLOCATOR_PROPERTIES Properties;
1249 IMemAllocatorCallbackTemp *pMemCallback;
1250 WCHAR Buffer[200];
1251
1252 OutputDebugStringW(L"COutputPin::Connect called\n");
1253 if (pmt)
1254 {
1255 hr = pReceivePin->QueryAccept(pmt);
1256 if (FAILED(hr))
1257 return hr;
1258 }
1259 else
1260 {
1261 // query accept
1262 hr = pReceivePin->QueryAccept(&m_MediaFormat);
1263 if (FAILED(hr))
1264 return hr;
1265
1266 pmt = &m_MediaFormat;
1267 }
1268
1269 // query for IMemInput interface
1270 hr = pReceivePin->QueryInterface(IID_IMemInputPin, (void**)&m_MemInputPin);
1271 if (FAILED(hr))
1272 {
1273 OutputDebugStringW(L"COutputPin::Connect no IMemInputPin interface\n");
1274 DebugBreak();
1275 return hr;
1276 }
1277
1278 // get input pin allocator properties
1279 ZeroMemory(&Properties, sizeof(ALLOCATOR_PROPERTIES));
1280 m_MemInputPin->GetAllocatorRequirements(&Properties);
1281
1282 //FIXME determine allocator properties
1283 Properties.cBuffers = 16;
1284 Properties.cbBuffer = 2048 * 188; //2048 frames * MPEG2 TS Payload size
1285 Properties.cbAlign = 4;
1286
1287 // get input pin allocator
1288 hr = m_MemInputPin->GetAllocator(&m_MemAllocator);
1289 if (SUCCEEDED(hr))
1290 {
1291 // set allocator properties
1292 hr = m_MemAllocator->SetProperties(&Properties, &m_Properties);
1293 if (FAILED(hr))
1294 m_MemAllocator->Release();
1295 }
1296
1297 if (FAILED(hr))
1298 {
1299 hr = CKsAllocator_Constructor(NULL, IID_IMemAllocator, (void**)&m_MemAllocator);
1300 if (FAILED(hr))
1301 return hr;
1302
1303 // set allocator properties
1304 hr = m_MemAllocator->SetProperties(&Properties, &m_Properties);
1305 if (FAILED(hr))
1306 {
1307 swprintf(Buffer, L"COutputPin::Connect IMemAllocator::SetProperties failed with hr %lx\n", hr);
1308 OutputDebugStringW(Buffer);
1309 m_MemAllocator->Release();
1310 m_MemInputPin->Release();
1311 return hr;
1312 }
1313 }
1314
1315 // commit property changes
1316 hr = m_MemAllocator->Commit();
1317 if (FAILED(hr))
1318 {
1319 swprintf(Buffer, L"COutputPin::Connect IMemAllocator::Commit failed with hr %lx\n", hr);
1320 OutputDebugStringW(Buffer);
1321 m_MemAllocator->Release();
1322 m_MemInputPin->Release();
1323 return hr;
1324 }
1325
1326 // get callback interface
1327 hr = m_MemAllocator->QueryInterface(IID_IMemAllocatorCallbackTemp, (void**)&pMemCallback);
1328 if (FAILED(hr))
1329 {
1330 swprintf(Buffer, L"COutputPin::Connect No IMemAllocatorCallbackTemp interface hr %lx\n", hr);
1331 OutputDebugStringW(Buffer);
1332 m_MemAllocator->Release();
1333 m_MemInputPin->Release();
1334 return hr;
1335 }
1336
1337 // set notification routine
1338 hr = pMemCallback->SetNotify((IMemAllocatorNotifyCallbackTemp*)this);
1339
1340 // release IMemAllocatorNotifyCallbackTemp interface
1341 pMemCallback->Release();
1342
1343 if (FAILED(hr))
1344 {
1345 swprintf(Buffer, L"COutputPin::Connect IMemAllocatorNotifyCallbackTemp::SetNotify failed hr %lx\n", hr);
1346 OutputDebugStringW(Buffer);
1347 m_MemAllocator->Release();
1348 m_MemInputPin->Release();
1349 return hr;
1350 }
1351
1352 // now set allocator
1353 hr = m_MemInputPin->NotifyAllocator(m_MemAllocator, TRUE);
1354 if (FAILED(hr))
1355 {
1356 swprintf(Buffer, L"COutputPin::Connect IMemInputPin::NotifyAllocator failed with hr %lx\n", hr);
1357 OutputDebugStringW(Buffer);
1358 m_MemAllocator->Release();
1359 m_MemInputPin->Release();
1360 return hr;
1361 }
1362
1363 if (!m_hPin)
1364 {
1365 //FIXME create pin handle
1366 assert(0);
1367 }
1368
1369 // receive connection;
1370 hr = pReceivePin->ReceiveConnection((IPin*)this, pmt);
1371 if (SUCCEEDED(hr))
1372 {
1373 // increment reference count
1374 pReceivePin->AddRef();
1375 m_Pin = pReceivePin;
1376 OutputDebugStringW(L"COutputPin::Connect success\n");
1377 }
1378 else
1379 {
1380 m_MemInputPin->Release();
1381 m_MemAllocator->Release();
1382 }
1383
1384 return hr;
1385 }
1386
1387 HRESULT
1388 STDMETHODCALLTYPE
1389 COutputPin::ReceiveConnection(IPin *pConnector, const AM_MEDIA_TYPE *pmt)
1390 {
1391 return E_UNEXPECTED;
1392 }
1393 HRESULT
1394 STDMETHODCALLTYPE
1395 COutputPin::Disconnect( void)
1396 {
1397 OutputDebugStringW(L"COutputPin::Disconnect\n");
1398
1399 if (!m_Pin)
1400 {
1401 // pin was not connected
1402 return S_FALSE;
1403 }
1404
1405 //FIXME
1406 //check if filter is active
1407
1408 m_Pin->Release();
1409 m_Pin = NULL;
1410 m_MemInputPin->Release();
1411 m_MemAllocator->Release();
1412
1413 OutputDebugStringW(L"COutputPin::Disconnect\n");
1414 return S_OK;
1415 }
1416 HRESULT
1417 STDMETHODCALLTYPE
1418 COutputPin::ConnectedTo(IPin **pPin)
1419 {
1420 OutputDebugStringW(L"COutputPin::ConnectedTo\n");
1421
1422 if (!pPin)
1423 return E_POINTER;
1424
1425 if (m_Pin)
1426 {
1427 // increment reference count
1428 m_Pin->AddRef();
1429 *pPin = m_Pin;
1430 return S_OK;
1431 }
1432
1433 *pPin = NULL;
1434 return VFW_E_NOT_CONNECTED;
1435 }
1436 HRESULT
1437 STDMETHODCALLTYPE
1438 COutputPin::ConnectionMediaType(AM_MEDIA_TYPE *pmt)
1439 {
1440 OutputDebugStringW(L"COutputPin::ConnectionMediaType called\n");
1441 return E_NOTIMPL;
1442 }
1443 HRESULT
1444 STDMETHODCALLTYPE
1445 COutputPin::QueryPinInfo(PIN_INFO *pInfo)
1446 {
1447 OutputDebugStringW(L"COutputPin::QueryPinInfo\n");
1448
1449 wcscpy(pInfo->achName, m_PinName);
1450 pInfo->dir = PINDIR_OUTPUT;
1451 pInfo->pFilter = m_ParentFilter;
1452 m_ParentFilter->AddRef();
1453
1454 return S_OK;
1455 }
1456 HRESULT
1457 STDMETHODCALLTYPE
1458 COutputPin::QueryDirection(PIN_DIRECTION *pPinDir)
1459 {
1460 OutputDebugStringW(L"COutputPin::QueryDirection\n");
1461
1462 if (pPinDir)
1463 {
1464 *pPinDir = PINDIR_OUTPUT;
1465 return S_OK;
1466 }
1467
1468 return E_POINTER;
1469 }
1470 HRESULT
1471 STDMETHODCALLTYPE
1472 COutputPin::QueryId(LPWSTR *Id)
1473 {
1474 OutputDebugStringW(L"COutputPin::QueryId\n");
1475
1476 *Id = (LPWSTR)CoTaskMemAlloc((wcslen(m_PinName)+1)*sizeof(WCHAR));
1477 if (!*Id)
1478 return E_OUTOFMEMORY;
1479
1480 wcscpy(*Id, m_PinName);
1481 return S_OK;
1482 }
1483 HRESULT
1484 STDMETHODCALLTYPE
1485 COutputPin::QueryAccept(const AM_MEDIA_TYPE *pmt)
1486 {
1487 OutputDebugStringW(L"COutputPin::QueryAccept called\n");
1488 return E_NOTIMPL;
1489 }
1490 HRESULT
1491 STDMETHODCALLTYPE
1492 COutputPin::EnumMediaTypes(IEnumMediaTypes **ppEnum)
1493 {
1494 HRESULT hr;
1495 ULONG MediaTypeCount = 0, Index;
1496 AM_MEDIA_TYPE * MediaTypes;
1497 HANDLE hFilter;
1498
1499 OutputDebugStringW(L"COutputPin::EnumMediaTypes called\n");
1500
1501 if (!m_KsObjectParent)
1502 {
1503 // no interface
1504 return E_NOINTERFACE;
1505 }
1506
1507 // get parent filter handle
1508 hFilter = m_KsObjectParent->KsGetObjectHandle();
1509
1510 // query media type count
1511 hr = KsGetMediaTypeCount(hFilter, m_PinId, &MediaTypeCount);
1512 if (FAILED(hr) || !MediaTypeCount)
1513 {
1514 OutputDebugStringW(L"COutputPin::EnumMediaTypes failed1\n");
1515 return hr;
1516 }
1517
1518 // allocate media types
1519 MediaTypes = (AM_MEDIA_TYPE*)CoTaskMemAlloc(sizeof(AM_MEDIA_TYPE) * MediaTypeCount);
1520 if (!MediaTypes)
1521 {
1522 // not enough memory
1523 OutputDebugStringW(L"COutputPin::EnumMediaTypes CoTaskMemAlloc\n");
1524 return E_OUTOFMEMORY;
1525 }
1526
1527 // zero media types
1528 ZeroMemory(MediaTypes, sizeof(AM_MEDIA_TYPE) * MediaTypeCount);
1529
1530 for(Index = 0; Index < MediaTypeCount; Index++)
1531 {
1532 // get media type
1533 hr = KsGetMediaType(Index, &MediaTypes[Index], hFilter, m_PinId);
1534 if (FAILED(hr))
1535 {
1536 // failed
1537 CoTaskMemFree(MediaTypes);
1538 OutputDebugStringW(L"COutputPin::EnumMediaTypes failed\n");
1539 return hr;
1540 }
1541 }
1542
1543 return CEnumMediaTypes_fnConstructor(MediaTypeCount, MediaTypes, IID_IEnumMediaTypes, (void**)ppEnum);
1544 }
1545 HRESULT
1546 STDMETHODCALLTYPE
1547 COutputPin::QueryInternalConnections(IPin **apPin, ULONG *nPin)
1548 {
1549 OutputDebugStringW(L"COutputPin::QueryInternalConnections called\n");
1550 return E_NOTIMPL;
1551 }
1552 HRESULT
1553 STDMETHODCALLTYPE
1554 COutputPin::EndOfStream( void)
1555 {
1556 /* should be called only on input pins */
1557 return E_UNEXPECTED;
1558 }
1559 HRESULT
1560 STDMETHODCALLTYPE
1561 COutputPin::BeginFlush( void)
1562 {
1563 /* should be called only on input pins */
1564 return E_UNEXPECTED;
1565 }
1566 HRESULT
1567 STDMETHODCALLTYPE
1568 COutputPin::EndFlush( void)
1569 {
1570 /* should be called only on input pins */
1571 return E_UNEXPECTED;
1572 }
1573 HRESULT
1574 STDMETHODCALLTYPE
1575 COutputPin::NewSegment(REFERENCE_TIME tStart, REFERENCE_TIME tStop, double dRate)
1576 {
1577 if (!m_Pin)
1578 {
1579 // we are not connected
1580 return VFW_E_NOT_CONNECTED;
1581 }
1582
1583 return m_Pin->NewSegment(tStart, tStop, dRate);
1584 }
1585
1586 //-------------------------------------------------------------------
1587 HRESULT
1588 STDMETHODCALLTYPE
1589 COutputPin::CheckFormat(
1590 const AM_MEDIA_TYPE *pmt)
1591 {
1592 PKSMULTIPLE_ITEM MultipleItem;
1593 PKSDATAFORMAT DataFormat;
1594 HRESULT hr;
1595
1596 if (!pmt)
1597 return E_POINTER;
1598
1599 HANDLE hFilter = m_KsObjectParent->KsGetObjectHandle();
1600 assert(hFilter != NULL);
1601
1602 hr = KsGetMultiplePinFactoryItems(hFilter, m_PinId, KSPROPERTY_PIN_DATARANGES, (PVOID*)&MultipleItem);
1603 if (FAILED(hr))
1604 return S_FALSE;
1605
1606 DataFormat = (PKSDATAFORMAT)(MultipleItem + 1);
1607 for(ULONG Index = 0; Index < MultipleItem->Count; Index++)
1608 {
1609 if (IsEqualGUID(pmt->majortype, DataFormat->MajorFormat) &&
1610 IsEqualGUID(pmt->subtype, DataFormat->SubFormat) &&
1611 IsEqualGUID(pmt->formattype, DataFormat->Specifier))
1612 {
1613 // format is supported
1614 CoTaskMemFree(MultipleItem);
1615 OutputDebugStringW(L"COutputPin::CheckFormat format OK\n");
1616 return S_OK;
1617 }
1618 DataFormat = (PKSDATAFORMAT)((ULONG_PTR)DataFormat + DataFormat->FormatSize);
1619 }
1620 //format is not supported
1621 CoTaskMemFree(MultipleItem);
1622 return S_FALSE;
1623 }
1624
1625 HRESULT
1626 STDMETHODCALLTYPE
1627 COutputPin::CreatePin(
1628 const AM_MEDIA_TYPE *pmt)
1629 {
1630 PKSMULTIPLE_ITEM MediumList;
1631 PKSMULTIPLE_ITEM InterfaceList;
1632 PKSPIN_MEDIUM Medium;
1633 PKSPIN_INTERFACE Interface;
1634 IKsInterfaceHandler * InterfaceHandler;
1635 HRESULT hr;
1636
1637 // query for pin medium
1638 hr = KsQueryMediums(&MediumList);
1639 if (FAILED(hr))
1640 return hr;
1641
1642 // query for pin interface
1643 hr = KsQueryInterfaces(&InterfaceList);
1644 if (FAILED(hr))
1645 {
1646 // failed
1647 CoTaskMemFree(MediumList);
1648 return hr;
1649 }
1650
1651 if (MediumList->Count)
1652 {
1653 //use first available medium
1654 Medium = (PKSPIN_MEDIUM)(MediumList + 1);
1655 }
1656 else
1657 {
1658 // default to standard medium
1659 Medium = &StandardPinMedium;
1660 }
1661
1662 if (InterfaceList->Count)
1663 {
1664 //use first available interface
1665 Interface = (PKSPIN_INTERFACE)(InterfaceList + 1);
1666 }
1667 else
1668 {
1669 // default to standard interface
1670 Interface = &StandardPinInterface;
1671 }
1672
1673 if (m_Communication != KSPIN_COMMUNICATION_BRIDGE && m_Communication != KSPIN_COMMUNICATION_NONE)
1674 {
1675 // now create pin
1676 hr = CreatePinHandle(Medium, Interface, pmt);
1677 if (FAILED(hr))
1678 {
1679 m_InterfaceHandler->Release();
1680 m_InterfaceHandler = InterfaceHandler;
1681 }
1682
1683 if (!m_InterfaceHandler)
1684 {
1685 // now load the IKsInterfaceHandler plugin
1686 hr = CoCreateInstance(Interface->Set, NULL, CLSCTX_INPROC_SERVER, IID_IKsInterfaceHandler, (void**)&InterfaceHandler);
1687 if (FAILED(hr))
1688 {
1689 // failed to load interface handler plugin
1690 OutputDebugStringW(L"COutputPin::CreatePin failed to load InterfaceHandlerPlugin\n");
1691 CoTaskMemFree(MediumList);
1692 CoTaskMemFree(InterfaceList);
1693
1694 return hr;
1695 }
1696
1697 // now set the pin
1698 hr = InterfaceHandler->KsSetPin((IKsPin*)this);
1699 if (FAILED(hr))
1700 {
1701 // failed to load interface handler plugin
1702 OutputDebugStringW(L"COutputPin::CreatePin failed to initialize InterfaceHandlerPlugin\n");
1703 InterfaceHandler->Release();
1704 CoTaskMemFree(MediumList);
1705 CoTaskMemFree(InterfaceList);
1706 return hr;
1707 }
1708
1709 // store interface handler
1710 m_InterfaceHandler = InterfaceHandler;
1711 }
1712 }
1713 else
1714 {
1715 WCHAR Buffer[100];
1716 swprintf(Buffer, L"COutputPin::CreatePin unexpected communication %u %s\n", m_Communication, m_PinName);
1717 OutputDebugStringW(Buffer);
1718 DebugBreak();
1719 hr = E_FAIL;
1720 }
1721
1722 // free medium / interface / dataformat
1723 CoTaskMemFree(MediumList);
1724 CoTaskMemFree(InterfaceList);
1725
1726 return hr;
1727 }
1728
1729 HRESULT
1730 STDMETHODCALLTYPE
1731 COutputPin::CreatePinHandle(
1732 PKSPIN_MEDIUM Medium,
1733 PKSPIN_INTERFACE Interface,
1734 const AM_MEDIA_TYPE *pmt)
1735 {
1736 PKSPIN_CONNECT PinConnect;
1737 PKSDATAFORMAT DataFormat;
1738 ULONG Length;
1739 HRESULT hr;
1740 //KSALLOCATOR_FRAMING Framing;
1741 //KSPROPERTY Property;
1742 //ULONG BytesReturned;
1743
1744 if (m_hPin != INVALID_HANDLE_VALUE)
1745 {
1746 // pin already exists
1747 //CloseHandle(m_hPin);
1748 //m_hPin = INVALID_HANDLE_VALUE;
1749 return S_OK;
1750 }
1751
1752
1753 // calc format size
1754 Length = sizeof(KSPIN_CONNECT) + sizeof(KSDATAFORMAT) + pmt->cbFormat;
1755
1756 // allocate pin connect
1757 PinConnect = (PKSPIN_CONNECT)CoTaskMemAlloc(Length);
1758 if (!PinConnect)
1759 {
1760 // failed
1761 return E_OUTOFMEMORY;
1762 }
1763
1764 // setup request
1765 CopyMemory(&PinConnect->Interface, Interface, sizeof(KSPIN_INTERFACE));
1766 CopyMemory(&PinConnect->Medium, Medium, sizeof(KSPIN_MEDIUM));
1767 PinConnect->PinId = m_PinId;
1768 PinConnect->PinToHandle = NULL;
1769 PinConnect->Priority.PriorityClass = KSPRIORITY_NORMAL;
1770 PinConnect->Priority.PrioritySubClass = KSPRIORITY_NORMAL;
1771
1772 // get dataformat offset
1773 DataFormat = (PKSDATAFORMAT)(PinConnect + 1);
1774
1775 // copy data format
1776 DataFormat->FormatSize = sizeof(KSDATAFORMAT) + pmt->cbFormat;
1777 DataFormat->Flags = 0;
1778 DataFormat->SampleSize = pmt->lSampleSize;
1779 DataFormat->Reserved = 0;
1780 CopyMemory(&DataFormat->MajorFormat, &pmt->majortype, sizeof(GUID));
1781 CopyMemory(&DataFormat->SubFormat, &pmt->subtype, sizeof(GUID));
1782 CopyMemory(&DataFormat->Specifier, &pmt->formattype, sizeof(GUID));
1783
1784 if (pmt->cbFormat)
1785 {
1786 // copy extended format
1787 CopyMemory((DataFormat + 1), pmt->pbFormat, pmt->cbFormat);
1788 }
1789
1790 HANDLE hFilter = m_KsObjectParent->KsGetObjectHandle();
1791 assert(hFilter != NULL);
1792
1793 // create pin
1794 hr = KsCreatePin(hFilter, PinConnect, GENERIC_READ, &m_hPin);
1795
1796 if (SUCCEEDED(hr))
1797 {
1798 // store current interface / medium
1799 CopyMemory(&m_Medium, Medium, sizeof(KSPIN_MEDIUM));
1800 CopyMemory(&m_Interface, Interface, sizeof(KSPIN_INTERFACE));
1801 CopyMemory(&m_MediaFormat, pmt, sizeof(AM_MEDIA_TYPE));
1802
1803 LPOLESTR pMajor, pSub, pFormat;
1804 StringFromIID(m_MediaFormat.majortype, &pMajor);
1805 StringFromIID(m_MediaFormat.subtype , &pSub);
1806 StringFromIID(m_MediaFormat.formattype, &pFormat);
1807 WCHAR Buffer[200];
1808 swprintf(Buffer, L"COutputPin::CreatePinHandle Major %s SubType %s Format %s pbFormat %p cbFormat %u\n", pMajor, pSub, pFormat, pmt->pbFormat, pmt->cbFormat);
1809 CoTaskMemFree(pMajor);
1810 CoTaskMemFree(pSub);
1811 CoTaskMemFree(pFormat);
1812 OutputDebugStringW(Buffer);
1813
1814 if (pmt->cbFormat)
1815 {
1816 m_MediaFormat.pbFormat = (BYTE*)CoTaskMemAlloc(pmt->cbFormat);
1817 if (!m_MediaFormat.pbFormat)
1818 {
1819 CoTaskMemFree(PinConnect);
1820 m_MediaFormat.pbFormat = NULL;
1821 m_MediaFormat.cbFormat = 0;
1822 return E_OUTOFMEMORY;
1823 }
1824 CopyMemory(m_MediaFormat.pbFormat, pmt->pbFormat, pmt->cbFormat);
1825 }
1826 #if 0
1827 Property.Set = KSPROPSETID_Connection;
1828 Property.Id = KSPROPERTY_CONNECTION_ALLOCATORFRAMING;
1829 Property.Flags = KSPROPERTY_TYPE_GET;
1830
1831 ZeroMemory(&Framing, sizeof(KSALLOCATOR_FRAMING));
1832 hr = KsProperty(&Property, sizeof(KSPROPERTY), (PVOID)&Framing, sizeof(KSALLOCATOR_FRAMING), &BytesReturned);
1833 if (SUCCEEDED(hr))
1834 {
1835 m_Properties.cbAlign = (Framing.FileAlignment + 1);
1836 m_Properties.cbBuffer = Framing.FrameSize;
1837 m_Properties.cbPrefix = 0; //FIXME
1838 m_Properties.cBuffers = Framing.Frames;
1839 }
1840 hr = S_OK;
1841 #endif
1842
1843 if (FAILED(InitializeIOThread()))
1844 {
1845 OutputDebugStringW(L"COutputPin::CreatePinHandle failed to initialize i/o thread\n");
1846 DebugBreak();
1847 }
1848
1849 //TODO
1850 // connect pin pipes
1851
1852 }
1853 // free pin connect
1854 CoTaskMemFree(PinConnect);
1855
1856 return hr;
1857 }
1858
1859 HRESULT
1860 WINAPI
1861 COutputPin::IoProcessRoutine()
1862 {
1863 IMediaSample *Sample;
1864 LONG SampleCount;
1865 HRESULT hr;
1866 PKSSTREAM_SEGMENT StreamSegment;
1867 HANDLE hEvent;
1868 WCHAR Buffer[100];
1869 IMediaSample * Samples[1];
1870
1871 // first wait for the start event to signal
1872 WaitForSingleObject(m_hStartEvent, INFINITE);
1873
1874 assert(m_InterfaceHandler);
1875 REFERENCE_TIME Start = 0;
1876 REFERENCE_TIME Stop = 1;
1877 do
1878 {
1879 if (m_StopInProgress)
1880 {
1881 // stop io thread
1882 break;
1883 }
1884
1885 // get buffer
1886 hr = m_MemAllocator->GetBuffer(&Sample, NULL, NULL, AM_GBF_NOWAIT);
1887
1888 if (FAILED(hr))
1889 {
1890 m_Pin->BeginFlush();
1891 OutputDebugStringW(L"Beginning flushing...\n");
1892 WaitForSingleObject(m_hBufferAvailable, INFINITE);
1893 m_Pin->EndFlush();
1894 // now retry again
1895 continue;
1896 }
1897
1898 // fill buffer
1899 SampleCount = 1;
1900 Samples[0] = Sample;
1901
1902
1903 Sample->SetTime(&Start, &Stop);
1904 hr = m_InterfaceHandler->KsProcessMediaSamples(NULL, /* FIXME */
1905 Samples,
1906 &SampleCount,
1907 KsIoOperation_Read,
1908 &StreamSegment);
1909 if (FAILED(hr) || !StreamSegment)
1910 {
1911 swprintf(Buffer, L"COutputPin::IoProcessRoutine KsProcessMediaSamples PinName %s hr %lx StreamSegment %p\n", m_PinName, hr, StreamSegment);
1912 OutputDebugStringW(Buffer);
1913 break;
1914 }
1915
1916 // get completion event
1917 hEvent = StreamSegment->CompletionEvent;
1918
1919 // wait for i/o completion
1920 WaitForSingleObject(hEvent, INFINITE);
1921
1922 // perform completion
1923 m_InterfaceHandler->KsCompleteIo(StreamSegment);
1924
1925 // close completion event
1926 CloseHandle(hEvent);
1927
1928 if (SUCCEEDED(hr))
1929 {
1930 Sample->GetTime(&Start, &Stop);
1931 Start = Stop;
1932 Stop++;
1933
1934 // now deliver the sample
1935 hr = m_MemInputPin->Receive(Sample);
1936
1937 swprintf(Buffer, L"COutputPin::IoProcessRoutine IMemInputPin::Receive hr %lx Start %I64u Stop %I64u\n", hr, Start, Stop);
1938 OutputDebugStringW(Buffer);
1939 }
1940 }while(TRUE);
1941
1942 // signal end of i/o thread
1943 SetEvent(m_hStopEvent);
1944
1945 m_IoThreadStarted = false;
1946
1947 return NOERROR;
1948 }
1949
1950 DWORD
1951 WINAPI
1952 COutputPin_IoThreadStartup(
1953 LPVOID lpParameter)
1954 {
1955 COutputPin * Pin = (COutputPin*)lpParameter;
1956 assert(Pin);
1957
1958 return Pin->IoProcessRoutine();
1959 }
1960
1961
1962 HRESULT
1963 WINAPI
1964 COutputPin::InitializeIOThread()
1965 {
1966 HANDLE hThread;
1967
1968 if (m_IoThreadStarted)
1969 return NOERROR;
1970
1971 if (!m_hStartEvent)
1972 m_hStartEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
1973 else
1974 ResetEvent(m_hStartEvent);
1975
1976 if (!m_hStartEvent)
1977 return E_OUTOFMEMORY;
1978
1979 if (!m_hStopEvent)
1980 m_hStopEvent = CreateEventW(NULL, FALSE, FALSE, NULL);
1981 else
1982 ResetEvent(m_hStopEvent);
1983
1984 if (!m_hStopEvent)
1985 return E_OUTOFMEMORY;
1986
1987 if (!m_hBufferAvailable)
1988 m_hBufferAvailable = CreateEventW(NULL, FALSE, FALSE, NULL);
1989 else
1990 ResetEvent(m_hBufferAvailable);
1991
1992 if (!m_hBufferAvailable)
1993 return E_OUTOFMEMORY;
1994
1995 m_StopInProgress = false;
1996 m_IoThreadStarted = true;
1997
1998 // now create the startup thread
1999 hThread = CreateThread(NULL, 0, COutputPin_IoThreadStartup, (LPVOID)this, 0, NULL);
2000 if (!hThread)
2001 return E_OUTOFMEMORY;
2002
2003
2004 // close thread handle
2005 CloseHandle(hThread);
2006 return NOERROR;
2007 }
2008
2009 HRESULT
2010 STDMETHODCALLTYPE
2011 COutputPin_SetState(
2012 IPin * Pin,
2013 KSSTATE State)
2014 {
2015 HRESULT hr = S_OK;
2016 KSPROPERTY Property;
2017 KSSTATE CurState;
2018 WCHAR Buffer[100];
2019 ULONG BytesReturned;
2020
2021 COutputPin * pPin = (COutputPin*)Pin;
2022
2023
2024 Property.Set = KSPROPSETID_Connection;
2025 Property.Id = KSPROPERTY_CONNECTION_STATE;
2026 Property.Flags = KSPROPERTY_TYPE_SET;
2027
2028
2029 if (pPin->m_State < State)
2030 {
2031 if (pPin->m_State == KSSTATE_STOP)
2032 {
2033 CurState = KSSTATE_ACQUIRE;
2034 hr = pPin->KsProperty(&Property, sizeof(KSPROPERTY), &CurState, sizeof(KSSTATE), &BytesReturned);
2035
2036 swprintf(Buffer, L"COutputPin_SetState Setting State KSSTATE_ACQUIRE PinName %s hr %lx\n", pPin->m_PinName, hr);
2037 OutputDebugStringW(Buffer);
2038 if (FAILED(hr))
2039 return hr;
2040
2041 pPin->m_State = CurState;
2042
2043 if (pPin->m_State == State)
2044 return hr;
2045 }
2046 if (pPin->m_State == KSSTATE_ACQUIRE)
2047 {
2048 CurState = KSSTATE_PAUSE;
2049 hr = pPin->KsProperty(&Property, sizeof(KSPROPERTY), &CurState, sizeof(KSSTATE), &BytesReturned);
2050
2051 swprintf(Buffer, L"COutputPin_SetState Setting State KSSTATE_PAUSE PinName %s hr %lx\n", pPin->m_PinName, hr);
2052 OutputDebugStringW(Buffer);
2053 if (FAILED(hr))
2054 return hr;
2055
2056 pPin->m_State = CurState;
2057
2058 if (pPin->m_State == State)
2059 return hr;
2060 }
2061
2062 CurState = KSSTATE_RUN;
2063 hr = pPin->KsProperty(&Property, sizeof(KSPROPERTY), &CurState, sizeof(KSSTATE), &BytesReturned);
2064
2065 swprintf(Buffer, L"COutputPin_SetState Setting State KSSTATE_RUN PinName %s hr %lx\n", pPin->m_PinName, hr);
2066 OutputDebugStringW(Buffer);
2067 if (FAILED(hr))
2068 return hr;
2069
2070 // signal start event
2071 SetEvent(pPin->m_hStartEvent);
2072
2073
2074 pPin->m_State = CurState;
2075 return hr;
2076 }
2077 else
2078 {
2079 if (pPin->m_State == KSSTATE_RUN)
2080 {
2081 CurState = KSSTATE_PAUSE;
2082 hr = pPin->KsProperty(&Property, sizeof(KSPROPERTY), &CurState, sizeof(KSSTATE), &BytesReturned);
2083
2084 swprintf(Buffer, L"COutputPin_SetState Setting State KSSTATE_PAUSE PinName %u hr %lx\n", pPin->m_PinName, hr);
2085 OutputDebugStringW(Buffer);
2086 if (FAILED(hr))
2087 return hr;
2088
2089 pPin->m_State = CurState;
2090
2091 if (pPin->m_State == State)
2092 return hr;
2093 }
2094 if (pPin->m_State == KSSTATE_PAUSE)
2095 {
2096 CurState = KSSTATE_ACQUIRE;
2097 hr = pPin->KsProperty(&Property, sizeof(KSPROPERTY), &CurState, sizeof(KSSTATE), &BytesReturned);
2098
2099 swprintf(Buffer, L"COutputPin_SetState Setting State KSSTATE_ACQUIRE PinName %u hr %lx\n", pPin->m_PinName, hr);
2100 OutputDebugStringW(Buffer);
2101 if (FAILED(hr))
2102 return hr;
2103
2104 pPin->m_State = CurState;
2105
2106 if (pPin->m_State == State)
2107 return hr;
2108 }
2109
2110 // setting pending stop flag
2111 pPin->m_StopInProgress = true;
2112
2113 CurState = KSSTATE_STOP;
2114 hr = pPin->KsProperty(&Property, sizeof(KSPROPERTY), &CurState, sizeof(KSSTATE), &BytesReturned);
2115
2116 swprintf(Buffer, L"COutputPin_SetState Setting State KSSTATE_STOP PinName %s hr %lx\n", pPin->m_PinName, hr);
2117 OutputDebugStringW(Buffer);
2118 if (FAILED(hr))
2119 return hr;
2120
2121 // wait until i/o thread is done
2122 WaitForSingleObject(pPin->m_hStopEvent, INFINITE);
2123
2124 pPin->m_State = CurState;
2125 return hr;
2126 }
2127 }
2128
2129
2130 HRESULT
2131 WINAPI
2132 COutputPin_Constructor(
2133 IBaseFilter * ParentFilter,
2134 LPCWSTR PinName,
2135 ULONG PinId,
2136 KSPIN_COMMUNICATION Communication,
2137 REFIID riid,
2138 LPVOID * ppv)
2139 {
2140 COutputPin * handler = new COutputPin(ParentFilter, PinName, PinId, Communication);
2141
2142 if (!handler)
2143 return E_OUTOFMEMORY;
2144
2145 if (FAILED(handler->QueryInterface(riid, ppv)))
2146 {
2147 /* not supported */
2148 delete handler;
2149 return E_NOINTERFACE;
2150 }
2151
2152 return S_OK;
2153 }