7db52344d3de5b7f0498d5f89ce6f4ee955ea17e
[reactos.git] / reactos / dll / directx / ksproxy / allocator.cpp
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS WDM Streaming ActiveMovie Proxy
4 * FILE: dll/directx/ksproxy/allocator.cpp
5 * PURPOSE: IKsAllocator interface
6 *
7 * PROGRAMMERS: Johannes Anderwald (janderwald@reactos.org)
8 */
9 #include "precomp.h"
10
11 const GUID IID_IKsAllocatorEx = {0x091bb63a, 0x603f, 0x11d1, {0xb0, 0x67, 0x00, 0xa0, 0xc9, 0x06, 0x28, 0x02}};
12 const GUID IID_IKsAllocator = {0x8da64899, 0xc0d9, 0x11d0, {0x84, 0x13, 0x00, 0x00, 0xf8, 0x22, 0xfe, 0x8a}};
13
14 class CKsAllocator : public IKsAllocatorEx,
15 public IMemAllocatorCallbackTemp
16 {
17 public:
18 typedef std::stack<IMediaSample *>MediaSampleStack;
19
20 STDMETHODIMP QueryInterface( REFIID InterfaceId, PVOID* Interface);
21
22 STDMETHODIMP_(ULONG) AddRef()
23 {
24 InterlockedIncrement(&m_Ref);
25 return m_Ref;
26 }
27 STDMETHODIMP_(ULONG) Release()
28 {
29 InterlockedDecrement(&m_Ref);
30
31 if (!m_Ref)
32 {
33 delete this;
34 return 0;
35 }
36 return m_Ref;
37 }
38 //IKsAllocator
39 HANDLE STDMETHODCALLTYPE KsGetAllocatorHandle();
40 KSALLOCATORMODE STDMETHODCALLTYPE KsGetAllocatorMode();
41 HRESULT STDMETHODCALLTYPE KsGetAllocatorStatus(PKSSTREAMALLOCATOR_STATUS AllocatorStatus);
42 VOID STDMETHODCALLTYPE KsSetAllocatorMode(KSALLOCATORMODE Mode);
43
44 //IKsAllocatorEx
45 PALLOCATOR_PROPERTIES_EX STDMETHODCALLTYPE KsGetProperties();
46 VOID STDMETHODCALLTYPE KsSetProperties(PALLOCATOR_PROPERTIES_EX Properties);
47 VOID STDMETHODCALLTYPE KsSetAllocatorHandle(HANDLE AllocatorHandle);
48 HANDLE STDMETHODCALLTYPE KsCreateAllocatorAndGetHandle(IKsPin* KsPin);
49
50 //IMemAllocator
51 HRESULT STDMETHODCALLTYPE SetProperties(ALLOCATOR_PROPERTIES *pRequest, ALLOCATOR_PROPERTIES *pActual);
52 HRESULT STDMETHODCALLTYPE GetProperties(ALLOCATOR_PROPERTIES *pProps);
53 HRESULT STDMETHODCALLTYPE Commit();
54 HRESULT STDMETHODCALLTYPE Decommit();
55 HRESULT STDMETHODCALLTYPE GetBuffer(IMediaSample **ppBuffer, REFERENCE_TIME *pStartTime, REFERENCE_TIME *pEndTime, DWORD dwFlags);
56 HRESULT STDMETHODCALLTYPE ReleaseBuffer(IMediaSample *pBuffer);
57
58 //IMemAllocatorCallbackTemp
59 HRESULT STDMETHODCALLTYPE SetNotify(IMemAllocatorNotifyCallbackTemp *pNotify);
60 HRESULT STDMETHODCALLTYPE GetFreeCount(LONG *plBuffersFree);
61
62
63 CKsAllocator();
64 virtual ~CKsAllocator(){}
65 VOID STDMETHODCALLTYPE FreeMediaSamples();
66 protected:
67 LONG m_Ref;
68 HANDLE m_hAllocator;
69 KSALLOCATORMODE m_Mode;
70 ALLOCATOR_PROPERTIES_EX m_Properties;
71 IMemAllocatorNotifyCallbackTemp *m_Notify;
72 ULONG m_Allocated;
73 LONG m_cbBuffer;
74 LONG m_cBuffers;
75 LONG m_cbAlign;
76 LONG m_cbPrefix;
77 BOOL m_Commited;
78 CRITICAL_SECTION m_CriticalSection;
79 MediaSampleStack m_FreeList;
80 LPVOID m_Buffer;
81 BOOL m_FreeSamples;
82 };
83
84
85 HRESULT
86 STDMETHODCALLTYPE
87 CKsAllocator::QueryInterface(
88 IN REFIID refiid,
89 OUT PVOID* Output)
90 {
91 if (IsEqualGUID(refiid, IID_IUnknown) ||
92 IsEqualGUID(refiid, IID_IKsAllocator) ||
93 IsEqualGUID(refiid, IID_IKsAllocatorEx))
94 {
95 *Output = PVOID(this);
96 reinterpret_cast<IUnknown*>(*Output)->AddRef();
97 return NOERROR;
98 }
99 if (IsEqualGUID(refiid, IID_IMemAllocator) ||
100 IsEqualGUID(refiid, IID_IMemAllocatorCallbackTemp))
101 {
102 *Output = (IMemAllocatorCallbackTemp*)(this);
103 reinterpret_cast<IMemAllocatorCallbackTemp*>(*Output)->AddRef();
104 return NOERROR;
105 }
106
107 return E_NOINTERFACE;
108 }
109
110 CKsAllocator::CKsAllocator() : m_Ref(0),
111 m_hAllocator(0),
112 m_Mode(KsAllocatorMode_User),
113 m_Notify(0),
114 m_Allocated(0),
115 m_cbBuffer(0),
116 m_cBuffers(0),
117 m_cbAlign(0),
118 m_cbPrefix(0),
119 m_Commited(FALSE),
120 m_FreeList(),
121 m_Buffer(0),
122 m_FreeSamples(FALSE)
123 {
124 InitializeCriticalSection(&m_CriticalSection);
125
126 }
127
128 //-------------------------------------------------------------------
129 // IMemAllocator
130 //
131 HRESULT
132 STDMETHODCALLTYPE
133 CKsAllocator::SetProperties(
134 ALLOCATOR_PROPERTIES *pRequest,
135 ALLOCATOR_PROPERTIES *pActual)
136 {
137 SYSTEM_INFO SystemInfo;
138
139 EnterCriticalSection(&m_CriticalSection);
140 OutputDebugStringW(L"CKsAllocator::SetProperties\n");
141
142 if (!pRequest || !pActual)
143 return E_POINTER;
144
145 // zero output properties
146 ZeroMemory(pActual, sizeof(ALLOCATOR_PROPERTIES));
147
148 // get system info
149 GetSystemInfo(&SystemInfo);
150
151 if (!pRequest->cbAlign || (pRequest->cbAlign - 1) & SystemInfo.dwAllocationGranularity)
152 {
153 // bad alignment
154 LeaveCriticalSection(&m_CriticalSection);
155 return VFW_E_BADALIGN;
156 }
157
158 if (m_Mode == KsAllocatorMode_Kernel)
159 {
160 // u can't change a kernel allocator
161 LeaveCriticalSection(&m_CriticalSection);
162 return VFW_E_ALREADY_COMMITTED;
163 }
164
165 if (m_Commited)
166 {
167 // need to decommit first
168 LeaveCriticalSection(&m_CriticalSection);
169 return VFW_E_ALREADY_COMMITTED;
170 }
171
172 if (m_Allocated != m_FreeList.size())
173 {
174 // outstanding buffers
175 LeaveCriticalSection(&m_CriticalSection);
176 return VFW_E_BUFFERS_OUTSTANDING;
177 }
178
179 pActual->cbAlign = m_cbAlign = pRequest->cbAlign;
180 pActual->cbBuffer = m_cbBuffer = pRequest->cbBuffer;
181 pActual->cbPrefix = m_cbPrefix = pRequest->cbPrefix;
182 pActual->cBuffers = m_cBuffers = pRequest->cBuffers;
183
184 LeaveCriticalSection(&m_CriticalSection);
185 return NOERROR;
186 }
187
188 HRESULT
189 STDMETHODCALLTYPE
190 CKsAllocator::GetProperties(
191 ALLOCATOR_PROPERTIES *pProps)
192 {
193 if (!pProps)
194 return E_POINTER;
195
196 pProps->cbBuffer = m_cbBuffer;
197 pProps->cBuffers = m_cBuffers;
198 pProps->cbAlign = m_cbAlign;
199 pProps->cbPrefix = m_cbPrefix;
200
201 return NOERROR;
202 }
203
204 HRESULT
205 STDMETHODCALLTYPE
206 CKsAllocator::Commit()
207 {
208 LONG Index;
209 PUCHAR CurrentBuffer;
210 IMediaSample * Sample;
211 HRESULT hr;
212
213 //TODO integer overflow checks
214 EnterCriticalSection(&m_CriticalSection);
215
216 OutputDebugStringW(L"CKsAllocator::Commit\n");
217
218 if (m_Mode == KsAllocatorMode_Kernel)
219 {
220 /* no-op for kernel allocator */
221 LeaveCriticalSection(&m_CriticalSection);
222 return NOERROR;
223 }
224
225 if (m_Commited)
226 {
227 // already commited
228 LeaveCriticalSection(&m_CriticalSection);
229 return NOERROR;
230 }
231
232 if (m_cbBuffer < 0 || m_cBuffers < 0 || m_cbPrefix < 0)
233 {
234 // invalid parameter
235 LeaveCriticalSection(&m_CriticalSection);
236 return E_OUTOFMEMORY;
237 }
238
239 LONG Size = m_cbBuffer + m_cbPrefix;
240
241 if (m_cbAlign > 1)
242 {
243 //check alignment
244 LONG Mod = Size % m_cbAlign;
245 if (Mod)
246 {
247 // calculate aligned size
248 Size += m_cbAlign - Mod;
249 }
250 }
251
252 LONG TotalSize = Size * m_cBuffers;
253
254 assert(TotalSize);
255 assert(m_cBuffers);
256 assert(Size);
257
258 // now allocate buffer
259 m_Buffer = VirtualAlloc(NULL, TotalSize, MEM_COMMIT, PAGE_READWRITE);
260 if (!m_Buffer)
261 {
262 LeaveCriticalSection(&m_CriticalSection);
263 return E_OUTOFMEMORY;
264 }
265
266 ZeroMemory(m_Buffer, TotalSize);
267
268 CurrentBuffer = (PUCHAR)m_Buffer;
269
270 for (Index = 0; Index < m_cBuffers; Index++)
271 {
272 // construct media sample
273 hr = CMediaSample_Constructor((IMemAllocator*)this, CurrentBuffer + m_cbPrefix, m_cbBuffer, IID_IMediaSample, (void**)&Sample);
274 if (FAILED(hr))
275 {
276 LeaveCriticalSection(&m_CriticalSection);
277 return E_OUTOFMEMORY;
278 }
279
280 // add to free list
281 m_FreeList.push(Sample);
282 m_Allocated++;
283
284 //next sample buffer
285 CurrentBuffer += Size;
286 }
287
288 // we are now commited
289 m_Commited = true;
290
291 LeaveCriticalSection(&m_CriticalSection);
292 return S_OK;
293 }
294
295 HRESULT
296 STDMETHODCALLTYPE
297 CKsAllocator::Decommit()
298 {
299 EnterCriticalSection(&m_CriticalSection);
300
301 OutputDebugStringW(L"CKsAllocator::Decommit\n");
302
303 if (m_Mode == KsAllocatorMode_Kernel)
304 {
305 /* no-op for kernel allocator */
306 LeaveCriticalSection(&m_CriticalSection);
307 return NOERROR;
308 }
309
310 m_Commited = false;
311
312 if (m_Allocated != m_FreeList.size())
313 {
314 // outstanding buffers
315 m_FreeSamples = true;
316 LeaveCriticalSection(&m_CriticalSection);
317 return NOERROR;
318 }
319 else
320 {
321 // no outstanding buffers
322 // free to free them
323 FreeMediaSamples();
324 }
325
326 LeaveCriticalSection(&m_CriticalSection);
327 return NOERROR;
328 }
329
330
331 HRESULT
332 STDMETHODCALLTYPE
333 CKsAllocator::GetBuffer(
334 IMediaSample **ppBuffer,
335 REFERENCE_TIME *pStartTime,
336 REFERENCE_TIME *pEndTime,
337 DWORD dwFlags)
338 {
339 IMediaSample * Sample = NULL;
340 OutputDebugStringW(L"CKsAllocator::GetBuffer\n");
341
342 do
343 {
344 EnterCriticalSection(&m_CriticalSection);
345
346 if (!m_FreeList.empty())
347 {
348 Sample = m_FreeList.top();
349 m_FreeList.pop();
350 }
351
352 LeaveCriticalSection(&m_CriticalSection);
353
354 if (dwFlags & AM_GBF_NOWAIT)
355 {
356 // never wait untill a buffer becomes available
357 break;
358 }
359 }
360 while(Sample == NULL);
361
362 if (!Sample)
363 {
364 // no sample acquired
365 return VFW_E_TIMEOUT;
366 }
367
368 // store result
369 *ppBuffer = Sample;
370
371 // done
372 return NOERROR;
373 }
374
375 HRESULT
376 STDMETHODCALLTYPE
377 CKsAllocator::ReleaseBuffer(
378 IMediaSample *pBuffer)
379 {
380 EnterCriticalSection(&m_CriticalSection);
381
382 OutputDebugStringW(L"CKsAllocator::ReleaseBuffer\n");
383
384 // media sample always 1 ref count in free list
385 pBuffer->AddRef();
386
387 // add the sample to the free list
388 m_FreeList.push(pBuffer);
389
390 if (m_FreeSamples)
391 {
392 // pending de-commit
393 if (m_FreeList.size () == m_Allocated)
394 {
395 FreeMediaSamples();
396 }
397 }
398
399 if (m_Notify)
400 {
401 //notify caller of an available buffer
402 m_Notify->NotifyRelease();
403 }
404
405 LeaveCriticalSection(&m_CriticalSection);
406 return S_OK;
407 }
408
409 //-------------------------------------------------------------------
410 // IMemAllocatorCallbackTemp
411 //
412 HRESULT
413 STDMETHODCALLTYPE
414 CKsAllocator::SetNotify(
415 IMemAllocatorNotifyCallbackTemp *pNotify)
416 {
417 EnterCriticalSection(&m_CriticalSection);
418 OutputDebugStringW(L"CKsAllocator::SetNotify\n");
419
420 if (pNotify)
421 pNotify->AddRef();
422
423 if (m_Notify)
424 m_Notify->Release();
425
426 m_Notify = pNotify;
427
428 LeaveCriticalSection(&m_CriticalSection);
429 return NOERROR;
430 }
431
432 HRESULT
433 STDMETHODCALLTYPE
434 CKsAllocator::GetFreeCount(
435 LONG *plBuffersFree)
436 {
437 *plBuffersFree = m_Allocated - m_FreeList.size();
438 return S_OK;
439 }
440
441 //-------------------------------------------------------------------
442 // IKsAllocator
443 //
444 HANDLE
445 STDMETHODCALLTYPE
446 CKsAllocator::KsGetAllocatorHandle()
447 {
448 return m_hAllocator;
449 }
450
451 KSALLOCATORMODE
452 STDMETHODCALLTYPE
453 CKsAllocator::KsGetAllocatorMode()
454 {
455 return m_Mode;
456 }
457
458 HRESULT
459 STDMETHODCALLTYPE
460 CKsAllocator::KsGetAllocatorStatus(
461 PKSSTREAMALLOCATOR_STATUS AllocatorStatus)
462 {
463 return NOERROR;
464 }
465 VOID
466 STDMETHODCALLTYPE
467 CKsAllocator::KsSetAllocatorMode(
468 KSALLOCATORMODE Mode)
469 {
470 m_Mode = Mode;
471 }
472
473 //-------------------------------------------------------------------
474 // IKsAllocatorEx
475 //
476 PALLOCATOR_PROPERTIES_EX
477 STDMETHODCALLTYPE
478 CKsAllocator::KsGetProperties()
479 {
480 return &m_Properties;
481 }
482
483 VOID
484 STDMETHODCALLTYPE
485 CKsAllocator::KsSetProperties(
486 PALLOCATOR_PROPERTIES_EX Properties)
487 {
488 CopyMemory(&m_Properties, Properties, sizeof(ALLOCATOR_PROPERTIES_EX));
489 }
490
491 VOID
492 STDMETHODCALLTYPE
493 CKsAllocator::KsSetAllocatorHandle(
494 HANDLE AllocatorHandle)
495 {
496 m_hAllocator = AllocatorHandle;
497 }
498
499
500 HANDLE
501 STDMETHODCALLTYPE
502 CKsAllocator::KsCreateAllocatorAndGetHandle(
503 IKsPin* KsPin)
504 {
505 HRESULT hr;
506 IKsObject * pObject;
507 KSALLOCATOR_FRAMING AllocatorFraming;
508 HANDLE hPin;
509
510 OutputDebugStringW(L"CKsAllocator::KsCreateAllocatorAndGetHandle\n");
511
512 if (m_hAllocator)
513 {
514 CloseHandle(m_hAllocator);
515 m_hAllocator = NULL;
516 }
517
518 // get pin IKsObject interface
519 hr = KsPin->QueryInterface(IID_IKsObject, (void**)&pObject);
520 if (FAILED(hr))
521 return NULL;
522
523 // get pin handle
524 hPin = pObject->KsGetObjectHandle();
525
526 //release IKsObject interface
527 pObject->Release();
528
529 if (!hPin || hPin == INVALID_HANDLE_VALUE)
530 return NULL;
531
532 //setup allocator framing
533 AllocatorFraming.Frames = m_Properties.cBuffers;
534 AllocatorFraming.FrameSize = m_Properties.cbBuffer;
535 AllocatorFraming.FileAlignment = (m_Properties.cbAlign -1);
536 AllocatorFraming.OptionsFlags = KSALLOCATOR_OPTIONF_SYSTEM_MEMORY;
537 AllocatorFraming.PoolType = (m_Properties.LogicalMemoryType == KS_MemoryTypeKernelPaged);
538
539 DWORD dwError = KsCreateAllocator(hPin, &AllocatorFraming, &m_hAllocator);
540 if (dwError)
541 return NULL;
542
543 return m_hAllocator;
544 }
545
546 //-------------------------------------------------------------------
547 VOID
548 STDMETHODCALLTYPE
549 CKsAllocator::FreeMediaSamples()
550 {
551 ULONG Index;
552
553 for(Index = 0; Index < m_FreeList.size(); Index++)
554 {
555 IMediaSample * Sample = m_FreeList.top();
556 m_FreeList.pop();
557 delete Sample;
558 }
559
560 m_FreeSamples = false;
561 m_Allocated = 0;
562
563 if (m_Buffer)
564 {
565 // release buffer
566 VirtualFree(m_Buffer, 0, MEM_RELEASE);
567
568 m_Buffer = NULL;
569 }
570 }
571
572 HRESULT
573 WINAPI
574 CKsAllocator_Constructor(
575 IUnknown * pUnkOuter,
576 REFIID riid,
577 LPVOID * ppv)
578 {
579 OutputDebugStringW(L"CKsAllocator_Constructor\n");
580
581 CKsAllocator * handler = new CKsAllocator();
582
583 if (!handler)
584 return E_OUTOFMEMORY;
585
586 if (FAILED(handler->QueryInterface(riid, ppv)))
587 {
588 /* not supported */
589 delete handler;
590 return E_NOINTERFACE;
591 }
592
593 return NOERROR;
594 }