ReactOS 0.4.15-dev-8241-g63935f8
pin_wavecyclic.cpp File Reference
#include "private.hpp"
#include <debug.h>
Include dependency graph for pin_wavecyclic.cpp:

Go to the source code of this file.

Classes

class  CPortPinWaveCyclic
 
struct  LOOPEDSTREAMING_EVENT_CONTEXT
 
struct  ENDOFSTREAM_EVENT_CONTEXT
 
struct  SETPIN_CONTEXT
 

Macros

#define NDEBUG
 

Typedefs

typedef struct LOOPEDSTREAMING_EVENT_CONTEXTPLOOPEDSTREAMING_EVENT_CONTEXT
 
typedef struct ENDOFSTREAM_EVENT_CONTEXTPENDOFSTREAM_EVENT_CONTEXT
 
typedef struct SETPIN_CONTEXTPSETPIN_CONTEXT
 

Functions

NTSTATUS NTAPI PinWaveCyclicState (IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data)
 
NTSTATUS NTAPI PinWaveCyclicDataFormat (IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data)
 
NTSTATUS NTAPI PinWaveCyclicAudioPosition (IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data)
 
NTSTATUS NTAPI PinWaveCyclicAllocatorFraming (IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data)
 
NTSTATUS NTAPI PinWaveCyclicAddEndOfStreamEvent (IN PIRP Irp, IN PKSEVENTDATA EventData, IN PKSEVENT_ENTRY EventEntry)
 
NTSTATUS NTAPI PinWaveCyclicAddLoopedStreamEvent (IN PIRP Irp, IN PKSEVENTDATA EventData, IN PKSEVENT_ENTRY EventEntry)
 
NTSTATUS NTAPI PinWaveCyclicDRMHandler (IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data)
 
 DEFINE_KSPROPERTY_CONNECTIONSET (PinWaveCyclicConnectionSet, PinWaveCyclicState, PinWaveCyclicDataFormat, PinWaveCyclicAllocatorFraming)
 
 DEFINE_KSPROPERTY_AUDIOSET (PinWaveCyclicAudioSet, PinWaveCyclicAudioPosition)
 
 DEFINE_KSPROPERTY_DRMSET (PinWaveCyclicDRMSet, PinWaveCyclicDRMHandler)
 
VOID CALLBACK PinSetStateWorkerRoutine (IN PDEVICE_OBJECT DeviceObject, IN PVOID Context)
 
NTSTATUS NewPortPinWaveCyclic (OUT IPortPinWaveCyclic **OutPin)
 

Variables

KSEVENT_ITEM PinWaveCyclicConnectionEventSet
 
KSEVENT_ITEM PinWaveCyclicStreamingEventSet
 
KSPROPERTY_SET PinWaveCyclicPropertySet []
 
KSEVENT_SET PinWaveCyclicEventSet []
 

Macro Definition Documentation

◆ NDEBUG

#define NDEBUG

Definition at line 11 of file pin_wavecyclic.cpp.

Typedef Documentation

◆ PENDOFSTREAM_EVENT_CONTEXT

◆ PLOOPEDSTREAMING_EVENT_CONTEXT

◆ PSETPIN_CONTEXT

Function Documentation

◆ DEFINE_KSPROPERTY_AUDIOSET()

DEFINE_KSPROPERTY_AUDIOSET ( PinWaveCyclicAudioSet  ,
PinWaveCyclicAudioPosition   
)

◆ DEFINE_KSPROPERTY_CONNECTIONSET()

DEFINE_KSPROPERTY_CONNECTIONSET ( PinWaveCyclicConnectionSet  ,
PinWaveCyclicState  ,
PinWaveCyclicDataFormat  ,
PinWaveCyclicAllocatorFraming   
)

◆ DEFINE_KSPROPERTY_DRMSET()

DEFINE_KSPROPERTY_DRMSET ( PinWaveCyclicDRMSet  ,
PinWaveCyclicDRMHandler   
)

◆ NewPortPinWaveCyclic()

NTSTATUS NewPortPinWaveCyclic ( OUT IPortPinWaveCyclic **  OutPin)

Definition at line 1374 of file pin_wavecyclic.cpp.

1376{
1378
1380 if (!This)
1382
1383 This->AddRef();
1384
1385 // store result
1386 *OutPin = (IPortPinWaveCyclic*)This;
1387
1388 return STATUS_SUCCESS;
1389}
#define NULL
Definition: types.h:112
#define NonPagedPool
Definition: env_spec_w32.h:307
#define TAG_PORTCLASS
Definition: private.hpp:24
#define STATUS_SUCCESS
Definition: shellext.h:65
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158

◆ PinSetStateWorkerRoutine()

VOID CALLBACK PinSetStateWorkerRoutine ( IN PDEVICE_OBJECT  DeviceObject,
IN PVOID  Context 
)

Definition at line 404 of file pin_wavecyclic.cpp.

407{
408 PSETPIN_CONTEXT PinWorkContext = (PSETPIN_CONTEXT)Context;
410
411 // try set stream
412 Status = PinWorkContext->Pin->m_Stream->SetState(PinWorkContext->NewState);
413
414 DPRINT1("Setting state %u %x\n", PinWorkContext->NewState, Status);
415 if (NT_SUCCESS(Status))
416 {
417 // store new state
418 PinWorkContext->Pin->m_State = PinWorkContext->NewState;
419
420 if (PinWorkContext->Pin->m_ConnectDetails->Interface.Id == KSINTERFACE_STANDARD_LOOPED_STREAMING && PinWorkContext->Pin->m_State == KSSTATE_STOP)
421 {
422 /* FIXME complete pending irps with successful state */
423 PinWorkContext->Pin->m_IrpQueue->CancelBuffers();
424 }
425 //HACK
426 //PinWorkContext->Pin->m_IrpQueue->CancelBuffers();
427 }
428
429 // store result
430 PinWorkContext->Irp->IoStatus.Information = sizeof(KSSTATE);
431 PinWorkContext->Irp->IoStatus.Status = Status;
432
433 // complete irp
434 IoCompleteRequest(PinWorkContext->Irp, IO_NO_INCREMENT);
435
436 // free work item
437 IoFreeWorkItem(PinWorkContext->WorkItem);
438
439 // free work context
440 FreeItem(PinWorkContext, TAG_PORTCLASS);
441
442}
LONG NTSTATUS
Definition: precomp.h:26
#define DPRINT1
Definition: precomp.h:8
PMINIPORTWAVECYCLICSTREAM m_Stream
PKSPIN_CONNECT m_ConnectDetails
IIrpQueue * m_IrpQueue
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
Status
Definition: gdiplustypes.h:25
VOID NTAPI IoFreeWorkItem(IN PIO_WORKITEM IoWorkItem)
Definition: iowork.c:64
KSSTATE
Definition: ks.h:1214
@ KSSTATE_STOP
Definition: ks.h:1215
@ KSINTERFACE_STANDARD_LOOPED_STREAMING
Definition: ks.h:284
VOID FreeItem(IN PVOID Item)
Definition: misc.c:37
#define IoCompleteRequest
Definition: irp.c:1240
struct SETPIN_CONTEXT * PSETPIN_CONTEXT
ULONG Id
Definition: dmksctrl.h:77
KSPIN_INTERFACE Interface
Definition: ks.h:2601
CPortPinWaveCyclic * Pin
PIO_WORKITEM WorkItem
IO_STATUS_BLOCK IoStatus
#define IO_NO_INCREMENT
Definition: iotypes.h:598

◆ PinWaveCyclicAddEndOfStreamEvent()

NTSTATUS NTAPI PinWaveCyclicAddEndOfStreamEvent ( IN PIRP  Irp,
IN PKSEVENTDATA  EventData,
IN PKSEVENT_ENTRY  EventEntry 
)

Definition at line 233 of file pin_wavecyclic.cpp.

237{
241
242 // get sub device descriptor
243 Descriptor = (PSUBDEVICE_DESCRIPTOR)KSPROPERTY_ITEM_IRP_STORAGE(Irp);
244
245 // sanity check
247 PC_ASSERT(Descriptor->PortPin);
249
250 // cast to pin impl
251 Pin = (CPortPinWaveCyclic*)Descriptor->PortPin;
252
253 // get extra size
254 Entry = (PENDOFSTREAM_EVENT_CONTEXT)(EventEntry + 1);
255
256 // not a looped event
257 Entry->bLoopedStreaming = FALSE;
258
259 // insert item
260 (void)ExInterlockedInsertTailList(&Pin->m_EventList, &EventEntry->ListEntry, &Pin->m_EventListLock);
261
262 // done
263 return STATUS_SUCCESS;
264}
struct SUBDEVICE_DESCRIPTOR * PSUBDEVICE_DESCRIPTOR
_In_ PIRP Irp
Definition: csq.h:116
#define FALSE
Definition: types.h:117
#define DISPATCH_LEVEL
Definition: env_spec_w32.h:696
IN PDCB IN VBO IN ULONG IN BOOLEAN Pin
Definition: fatprocs.h:427
PLIST_ENTRY NTAPI ExInterlockedInsertTailList(IN OUT PLIST_ENTRY ListHead, IN OUT PLIST_ENTRY ListEntry, IN OUT PKSPIN_LOCK Lock)
Definition: interlocked.c:140
#define PC_ASSERT_IRQL(x)
Definition: private.hpp:30
#define PC_ASSERT(exp)
Definition: private.hpp:26
base of all file and directory entries
Definition: entries.h:83
_Must_inspect_result_ _In_ WDFIORESLIST _In_ PIO_RESOURCE_DESCRIPTOR Descriptor
Definition: wdfresource.h:342

◆ PinWaveCyclicAddLoopedStreamEvent()

NTSTATUS NTAPI PinWaveCyclicAddLoopedStreamEvent ( IN PIRP  Irp,
IN PKSEVENTDATA  EventData,
IN PKSEVENT_ENTRY  EventEntry 
)

Definition at line 268 of file pin_wavecyclic.cpp.

272{
277
278 // get sub device descriptor
279 Descriptor = (PSUBDEVICE_DESCRIPTOR)KSEVENT_ITEM_IRP_STORAGE(Irp);
280
281 // sanity check
283 PC_ASSERT(Descriptor->PortPin);
285
286 // cast to pin impl
287 Pin = (CPortPinWaveCyclic*)Descriptor->PortPin;
288
289 // cast to looped event
291
292 // get extra size
293 Entry = (PLOOPEDSTREAMING_EVENT_CONTEXT)(EventEntry + 1);
294
295 Entry->bLoopedStreaming = TRUE;
296 Entry->Position = Data->Position;
297
298 DPRINT1("Added event\n");
299
300 // insert item
301 (void)ExInterlockedInsertTailList(&Pin->m_EventList, &EventEntry->ListEntry, &Pin->m_EventListLock);
302
303 // done
304 return STATUS_SUCCESS;
305}
#define TRUE
Definition: types.h:120
struct LOOPEDSTREAMING_EVENT_CONTEXT * PLOOPEDSTREAMING_EVENT_CONTEXT

◆ PinWaveCyclicAllocatorFraming()

NTSTATUS NTAPI PinWaveCyclicAllocatorFraming ( IN PIRP  Irp,
IN PKSIDENTIFIER  Request,
IN OUT PVOID  Data 
)

Definition at line 309 of file pin_wavecyclic.cpp.

313{
316
317 // get sub device descriptor
318 Descriptor = (PSUBDEVICE_DESCRIPTOR)KSEVENT_ITEM_IRP_STORAGE(Irp);
319
320 // sanity check
322 PC_ASSERT(Descriptor->PortPin);
324
325 // cast to pin impl
326 Pin = (CPortPinWaveCyclic*)Descriptor->PortPin;
327
329 {
330 // copy pin framing
331 RtlMoveMemory(Data, &Pin->m_AllocatorFraming, sizeof(KSALLOCATOR_FRAMING));
332
333 Irp->IoStatus.Information = sizeof(KSALLOCATOR_FRAMING);
334 return STATUS_SUCCESS;
335 }
336
337 // not supported
339}
#define KSPROPERTY_TYPE_GET
Definition: dmksctrl.h:42
if(dx< 0)
Definition: linetemp.h:194
#define STATUS_NOT_SUPPORTED
Definition: ntstatus.h:423
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:264
_In_ WDFREQUEST Request
Definition: wdfdevice.h:547

◆ PinWaveCyclicAudioPosition()

NTSTATUS NTAPI PinWaveCyclicAudioPosition ( IN PIRP  Irp,
IN PKSIDENTIFIER  Request,
IN OUT PVOID  Data 
)

Definition at line 343 of file pin_wavecyclic.cpp.

347{
351
352 // get sub device descriptor
353 Descriptor = (PSUBDEVICE_DESCRIPTOR)KSPROPERTY_ITEM_IRP_STORAGE(Irp);
354
355 // sanity check
357 PC_ASSERT(Descriptor->PortPin);
359
360 // cast to pin impl
361 Pin = (CPortPinWaveCyclic*)Descriptor->PortPin;
362
363 //sanity check
364 PC_ASSERT(Pin->m_Stream);
365
366 if (Request->Flags & KSPROPERTY_TYPE_GET)
367 {
368 // FIXME non multithreading-safe
369 // copy audio position
370
372
373 if (Pin->m_ConnectDetails->Interface.Id == KSINTERFACE_STANDARD_STREAMING)
374 {
375 RtlMoveMemory(Data, &Pin->m_Position, sizeof(KSAUDIO_POSITION));
376 DPRINT("Play %lu Record %lu\n", Pin->m_Position.PlayOffset, Pin->m_Position.WriteOffset);
377 }
378 else if (Pin->m_ConnectDetails->Interface.Id == KSINTERFACE_STANDARD_LOOPED_STREAMING)
379 {
380 Position->PlayOffset = Pin->m_Position.PlayOffset;
381 Position->WriteOffset = (ULONGLONG)Pin->m_IrpQueue->GetCurrentIrpOffset();
382 DPRINT("Play %lu Write %lu\n", Position->PlayOffset, Position->WriteOffset);
383 }
384
385 Irp->IoStatus.Information = sizeof(KSAUDIO_POSITION);
386 return STATUS_SUCCESS;
387 }
388
389 // not supported
391}
@ KSINTERFACE_STANDARD_STREAMING
Definition: ks.h:283
struct KSAUDIO_POSITION * PKSAUDIO_POSITION
#define DPRINT
Definition: sndvol32.h:73
static COORD Position
Definition: mouse.c:34
uint64_t ULONGLONG
Definition: typedefs.h:67

◆ PinWaveCyclicDataFormat()

NTSTATUS NTAPI PinWaveCyclicDataFormat ( IN PIRP  Irp,
IN PKSIDENTIFIER  Request,
IN OUT PVOID  Data 
)

Definition at line 518 of file pin_wavecyclic.cpp.

522{
526 PIO_STACK_LOCATION IoStack;
527
528 // get current irp stack location
530
531 // get sub device descriptor
532 Descriptor = (PSUBDEVICE_DESCRIPTOR)KSPROPERTY_ITEM_IRP_STORAGE(Irp);
533
534 // sanity check
536 PC_ASSERT(Descriptor->PortPin);
537
538 // cast to pin impl
539 Pin = (CPortPinWaveCyclic*)Descriptor->PortPin;
540
541 //sanity check
542 PC_ASSERT(Pin->m_Stream);
543 PC_ASSERT(Pin->m_Format);
544
545 if (Request->Flags & KSPROPERTY_TYPE_SET)
546 {
547 // try to change data format
548 PKSDATAFORMAT NewDataFormat, DataFormat = (PKSDATAFORMAT)Irp->UserBuffer;
549 ULONG Size = min(Pin->m_Format->FormatSize, DataFormat->FormatSize);
550
551 if (RtlCompareMemory(DataFormat, Pin->m_Format, Size) == Size)
552 {
553 // format is identical
554 Irp->IoStatus.Information = DataFormat->FormatSize;
555 return STATUS_SUCCESS;
556 }
557
558 // new change request
559 PC_ASSERT(Pin->m_State != KSSTATE_RUN);
560 // FIXME queue a work item when Irql != PASSIVE_LEVEL
562
563 // allocate new data format
564 NewDataFormat = (PKSDATAFORMAT)AllocateItem(NonPagedPool, DataFormat->FormatSize, TAG_PORTCLASS);
565 if (!NewDataFormat)
566 {
567 // not enough memory
568 return STATUS_NO_MEMORY;
569 }
570
571 // copy new data format
572 RtlMoveMemory(NewDataFormat, DataFormat, DataFormat->FormatSize);
573
574 // set new format
575 Status = Pin->m_Stream->SetFormat(NewDataFormat);
576 if (NT_SUCCESS(Status))
577 {
578 // free old format
579 FreeItem(Pin->m_Format, TAG_PORTCLASS);
580
581 // store new format
582 Pin->m_Format = NewDataFormat;
583 Irp->IoStatus.Information = NewDataFormat->FormatSize;
584
585#if 0
586 PC_ASSERT(NewDataFormat->FormatSize == sizeof(KSDATAFORMAT_WAVEFORMATEX));
590
591 DPRINT("NewDataFormat: Channels %u Bits %u Samples %u\n", ((PKSDATAFORMAT_WAVEFORMATEX)NewDataFormat)->WaveFormatEx.nChannels,
592 ((PKSDATAFORMAT_WAVEFORMATEX)NewDataFormat)->WaveFormatEx.wBitsPerSample,
593 ((PKSDATAFORMAT_WAVEFORMATEX)NewDataFormat)->WaveFormatEx.nSamplesPerSec);
594#endif
595
596 }
597 else
598 {
599 // failed to set format
600 FreeItem(NewDataFormat, TAG_PORTCLASS);
601 }
602
603 // done
604 return Status;
605 }
606 else if (Request->Flags & KSPROPERTY_TYPE_GET)
607 {
608 // get current data format
609 PC_ASSERT(Pin->m_Format);
610
611 if (Pin->m_Format->FormatSize > IoStack->Parameters.DeviceIoControl.OutputBufferLength)
612 {
613 // buffer too small
614 Irp->IoStatus.Information = Pin->m_Format->FormatSize;
615 return STATUS_MORE_ENTRIES;
616 }
617 // copy data format
618 RtlMoveMemory(Data, Pin->m_Format, Pin->m_Format->FormatSize);
619 // store result size
620 Irp->IoStatus.Information = Pin->m_Format->FormatSize;
621
622 // done
623 return STATUS_SUCCESS;
624 }
625
626 // unsupported request
628}
static PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(PIRP Irp)
KSDATAFORMAT * PKSDATAFORMAT
#define KSPROPERTY_TYPE_SET
Definition: dmksctrl.h:43
#define PASSIVE_LEVEL
Definition: env_spec_w32.h:693
#define RtlCompareMemory(s1, s2, l)
Definition: env_spec_w32.h:465
#define KeGetCurrentIrql()
Definition: env_spec_w32.h:706
@ KSSTATE_RUN
Definition: ks.h:1218
PVOID AllocateItem(IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes)
Definition: misc.c:29
#define KSDATAFORMAT_SUBTYPE_PCM
Definition: ksmedia.h:1021
#define KSDATAFORMAT_TYPE_AUDIO
Definition: ksmedia.h:983
#define KSDATAFORMAT_SPECIFIER_WAVEFORMATEX
Definition: ksmedia.h:1031
#define min(a, b)
Definition: monoChain.cc:55
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260
union _IO_STACK_LOCATION::@1573 Parameters
struct _IO_STACK_LOCATION::@1573::@1574 DeviceIoControl
uint32_t ULONG
Definition: typedefs.h:59
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
#define STATUS_MORE_ENTRIES
Definition: udferr_usr.h:124
_Must_inspect_result_ _In_ WDFDEVICE _In_ PWDF_DEVICE_PROPERTY_DATA _In_ DEVPROPTYPE _In_ ULONG Size
Definition: wdfdevice.h:4533
#define IsEqualGUIDAligned(guid1, guid2)
Definition: wdm.template.h:235

◆ PinWaveCyclicDRMHandler()

NTSTATUS NTAPI PinWaveCyclicDRMHandler ( IN PIRP  Irp,
IN PKSIDENTIFIER  Request,
IN OUT PVOID  Data 
)

Definition at line 221 of file pin_wavecyclic.cpp.

225{
226 DPRINT1("PinWaveCyclicDRMHandler\n");
227 ASSERT(0);
229}
#define ASSERT(a)
Definition: mode.c:44
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135

◆ PinWaveCyclicState()

NTSTATUS NTAPI PinWaveCyclicState ( IN PIRP  Irp,
IN PKSIDENTIFIER  Request,
IN OUT PVOID  Data 
)

Definition at line 446 of file pin_wavecyclic.cpp.

450{
455
456 // get sub device descriptor
457 Descriptor = (PSUBDEVICE_DESCRIPTOR)KSPROPERTY_ITEM_IRP_STORAGE(Irp);
458
459 // sanity check
461 PC_ASSERT(Descriptor->PortPin);
463
464 // cast to pin impl
465 Pin = (CPortPinWaveCyclic*)Descriptor->PortPin;
466
467 //sanity check
468 PC_ASSERT(Pin->m_Stream);
469
470 if (Request->Flags & KSPROPERTY_TYPE_SET)
471 {
472 // try set stream
473 Status = Pin->m_Stream->SetState(*State);
474
475 DPRINT("Setting state %u %x\n", *State, Status);
476 if (NT_SUCCESS(Status))
477 {
478 // store new state
479 Pin->m_State = *State;
480
481 if (Pin->m_ConnectDetails->Interface.Id == KSINTERFACE_STANDARD_LOOPED_STREAMING && Pin->m_State == KSSTATE_STOP)
482 {
483 // FIXME
484 // complete with successful state
485 Pin->m_Stream->Silence(Pin->m_CommonBuffer, Pin->m_CommonBufferSize);
486 Pin->m_IrpQueue->CancelBuffers();
487 Pin->m_Position.PlayOffset = 0;
488 Pin->m_Position.WriteOffset = 0;
489 }
490 else if (Pin->m_State == KSSTATE_STOP)
491 {
492 Pin->m_Stream->Silence(Pin->m_CommonBuffer, Pin->m_CommonBufferSize);
493 Pin->m_IrpQueue->CancelBuffers();
494 Pin->m_Position.PlayOffset = 0;
495 Pin->m_Position.WriteOffset = 0;
496 }
497 // store result
498 Irp->IoStatus.Information = sizeof(KSSTATE);
499 }
500 return Status;
501 }
502 else if (Request->Flags & KSPROPERTY_TYPE_GET)
503 {
504 // get current stream state
505 *State = Pin->m_State;
506 // store result
507 Irp->IoStatus.Information = sizeof(KSSTATE);
508
509 return STATUS_SUCCESS;
510 }
511
512 // unsupported request
514}
enum KSSTATE * PKSSTATE

Variable Documentation

◆ PinWaveCyclicConnectionEventSet

KSEVENT_ITEM PinWaveCyclicConnectionEventSet
Initial value:
=
{
sizeof(KSEVENTDATA),
0,
0
}
@ KSEVENT_CONNECTION_ENDOFSTREAM
Definition: ks.h:433
NTSTATUS NTAPI PinWaveCyclicAddEndOfStreamEvent(IN PIRP Irp, IN PKSEVENTDATA EventData, IN PKSEVENT_ENTRY EventEntry)

Definition at line 132 of file pin_wavecyclic.cpp.

◆ PinWaveCyclicEventSet

KSEVENT_SET PinWaveCyclicEventSet[]
Initial value:
=
{
{
sizeof(PinWaveCyclicStreamingEventSet) / sizeof(KSEVENT_ITEM),
(const KSEVENT_ITEM*)&PinWaveCyclicStreamingEventSet
},
{
sizeof(PinWaveCyclicConnectionEventSet) / sizeof(KSEVENT_ITEM),
(const KSEVENT_ITEM*)&PinWaveCyclicConnectionEventSet
}
}
#define KSEVENTSETID_Connection
Definition: ksmedia.h:1136
#define KSEVENTSETID_LoopedStreaming
Definition: ksmedia.h:1127
KSEVENT_ITEM PinWaveCyclicStreamingEventSet
KSEVENT_ITEM PinWaveCyclicConnectionEventSet

Definition at line 177 of file pin_wavecyclic.cpp.

◆ PinWaveCyclicPropertySet

KSPROPERTY_SET PinWaveCyclicPropertySet[]
Initial value:
=
{
{
sizeof(PinWaveCyclicConnectionSet) / sizeof(KSPROPERTY_ITEM),
(const KSPROPERTY_ITEM*)&PinWaveCyclicConnectionSet,
0,
},
{
sizeof(PinWaveCyclicAudioSet) / sizeof(KSPROPERTY_ITEM),
(const KSPROPERTY_ITEM*)&PinWaveCyclicAudioSet,
0,
},
{
sizeof(PinWaveCyclicDRMSet) / sizeof(KSPROPERTY_ITEM),
(const KSPROPERTY_ITEM*)&PinWaveCyclicDRMSet,
0,
}
}
#define KSPROPSETID_Connection
Definition: ks.h:346
#define KSPROPSETID_DrmAudioStream
Definition: ksmedia.h:1151
#define KSPROPSETID_Audio
Definition: ksmedia.h:1051

Definition at line 152 of file pin_wavecyclic.cpp.

◆ PinWaveCyclicStreamingEventSet

KSEVENT_ITEM PinWaveCyclicStreamingEventSet
Initial value:
=
{
0,
0
}
@ KSEVENT_LOOPEDSTREAMING_POSITION
Definition: ksmedia.h:1130
NTSTATUS NTAPI PinWaveCyclicAddLoopedStreamEvent(IN PIRP Irp, IN PKSEVENTDATA EventData, IN PKSEVENT_ENTRY EventEntry)

Definition at line 142 of file pin_wavecyclic.cpp.