ReactOS 0.4.15-dev-8348-gc1b9bb5
bdasup.c File Reference
#include "precomp.h"
Include dependency graph for bdasup.c:

Go to the source code of this file.

Macros

#define TAG_BDASUP   'SadB'
 

Functions

PVOID AllocateItem (IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes)
 
VOID FreeItem (IN PVOID Item)
 
PBDA_FILTER_INSTANCE_ENTRY GetFilterInstanceEntry (IN PKSFILTERFACTORY FilterFactory)
 
NTSTATUS NTAPI DllInitialize (PUNICODE_STRING RegistryPath)
 
NTSTATUS NTAPI BdaCheckChanges (IN PIRP Irp)
 
NTSTATUS NTAPI BdaCommitChanges (IN PIRP Irp)
 
NTSTATUS NTAPI BdaCreateFilterFactory (IN PKSDEVICE pKSDevice, IN const KSFILTER_DESCRIPTOR *pFilterDescriptor, IN const BDA_FILTER_TEMPLATE *pBdaFilterTemplate)
 
VOID NTAPI FreeFilterInstance (IN PVOID Context)
 
NTSTATUS NTAPI BdaCreateFilterFactoryEx (IN PKSDEVICE pKSDevice, IN const KSFILTER_DESCRIPTOR *pFilterDescriptor, IN const BDA_FILTER_TEMPLATE *BdaFilterTemplate, OUT PKSFILTERFACTORY *ppKSFilterFactory)
 
NTSTATUS NTAPI BdaCreatePin (IN PKSFILTER pKSFilter, IN ULONG ulPinType, OUT ULONG *pulPinId)
 
NTSTATUS NTAPI BdaMethodCreatePin (IN PIRP Irp, IN KSMETHOD *pKSMethod, OUT ULONG *pulPinFactoryID)
 
NTSTATUS NTAPI BdaInitFilter (IN PKSFILTER pKSFilter, IN const BDA_FILTER_TEMPLATE *pBdaFilterTemplate)
 
NTSTATUS NTAPI BdaCreateTopology (IN PKSFILTER pKSFilter, IN ULONG InputPinId, IN ULONG OutputPinId)
 
NTSTATUS NTAPI BdaDeletePin (IN PKSFILTER pKSFilter, IN ULONG *pulPinId)
 
NTSTATUS NTAPI BdaFilterFactoryUpdateCacheData (IN PKSFILTERFACTORY FilterFactory, IN const KSFILTER_DESCRIPTOR *FilterDescriptor OPTIONAL)
 
NTSTATUS NTAPI BdaGetChangeState (IN PIRP Irp, OUT BDA_CHANGE_STATE *ChangeState)
 
NTSTATUS NTAPI BdaMethodCreateTopology (IN PIRP Irp, IN KSMETHOD *pKSMethod, OPTIONAL PVOID pvIgnored)
 
NTSTATUS NTAPI BdaMethodDeletePin (IN PIRP Irp, IN KSMETHOD *pKSMethod, OPTIONAL PVOID pvIgnored)
 
NTSTATUS NTAPI BdaPropertyGetControllingPinId (IN PIRP Irp, IN KSP_BDA_NODE_PIN *pProperty, OUT ULONG *pulControllingPinId)
 
NTSTATUS NTAPI BdaPropertyGetPinControl (IN PIRP Irp, IN KSPROPERTY *pKSProperty, OUT ULONG *pulProperty)
 
NTSTATUS NTAPI BdaPropertyNodeDescriptors (IN PIRP Irp, IN KSPROPERTY *pKSProperty, OUT BDANODE_DESCRIPTOR *pNodeDescriptorProperty)
 
NTSTATUS NTAPI BdaPropertyNodeEvents (IN PIRP Irp, IN KSP_NODE *pKSProperty, OUT GUID *pguidProperty)
 
NTSTATUS NTAPI BdaPropertyNodeMethods (IN PIRP Irp, IN KSP_NODE *pKSProperty, OUT GUID *pguidProperty)
 
NTSTATUS NTAPI BdaPropertyNodeProperties (IN PIRP Irp, IN KSP_NODE *pKSProperty, OUT GUID *pguidProperty)
 
NTSTATUS NTAPI BdaPropertyNodeTypes (IN PIRP Irp, IN KSPROPERTY *pKSProperty, OUT ULONG *pulProperty)
 
NTSTATUS NTAPI BdaPropertyPinTypes (IN PIRP Irp, IN KSPROPERTY *pKSProperty, OUT ULONG *pulProperty)
 
NTSTATUS NTAPI BdaPropertyTemplateConnections (IN PIRP Irp, IN KSPROPERTY *pKSProperty, OUT KSTOPOLOGY_CONNECTION *pConnectionProperty)
 
NTSTATUS NTAPI BdaStartChanges (IN PIRP Irp)
 
NTSTATUS NTAPI BdaUninitFilter (IN PKSFILTER pKSFilter)
 
NTSTATUS NTAPI BdaValidateNodeProperty (IN PIRP Irp, IN KSPROPERTY *KSProperty)
 

Variables

const GUID KSPROPSETID_BdaPinControl = {0xded49d5, 0xa8b7, 0x4d5d, {0x97, 0xa1, 0x12, 0xb0, 0xc1, 0x95, 0x87, 0x4d}}
 
const GUID KSMETHODSETID_BdaDeviceConfiguration = {0x71985f45, 0x1ca1, 0x11d3, {0x9c, 0xc8, 0x0, 0xc0, 0x4f, 0x79, 0x71, 0xe0}}
 
const GUID KSPROPSETID_BdaTopology = {0xa14ee835, 0x0a23, 0x11d3, {0x9c, 0xc7, 0x0, 0xc0, 0x4f, 0x79, 0x71, 0xe0}}
 
BDA_GLOBAL g_Settings
 
KSPROPERTY_ITEM FilterPropertyItem []
 
KSPROPERTY_SET FilterPropertySet
 
KSMETHOD_ITEM FilterMethodItem []
 
KSMETHOD_SET FilterMethodSet
 
KSAUTOMATION_TABLE FilterAutomationTable
 
KSPROPERTY_ITEM PinPropertyItem []
 
KSPROPERTY_SET PinPropertySet
 
KSAUTOMATION_TABLE PinAutomationTable
 

Macro Definition Documentation

◆ TAG_BDASUP

#define TAG_BDASUP   'SadB'

Definition at line 4 of file bdasup.c.

Function Documentation

◆ AllocateItem()

PVOID AllocateItem ( IN POOL_TYPE  PoolType,
IN SIZE_T  NumberOfBytes 
)

Definition at line 95 of file bdasup.c.

98{
99 return ExAllocatePoolZero(PoolType, NumberOfBytes, TAG_BDASUP);
100}
#define TAG_BDASUP
Definition: bdasup.c:4
_Must_inspect_result_ _In_ WDFDEVICE _In_ DEVICE_REGISTRY_PROPERTY _In_ _Strict_type_match_ POOL_TYPE PoolType
Definition: wdfdevice.h:3815
_Must_inspect_result_ typedef _In_ PHYSICAL_ADDRESS _Inout_ PLARGE_INTEGER NumberOfBytes
Definition: iotypes.h:1036

Referenced by BdaCreateFilterFactoryEx(), and BdaCreatePin().

◆ BdaCheckChanges()

NTSTATUS NTAPI BdaCheckChanges ( IN PIRP  Irp)

Definition at line 167 of file bdasup.c.

168{
169 DPRINT("BdaCheckChanges\n");
170
171 if (!Irp)
173
174 return STATUS_SUCCESS;
175}
_In_ PIRP Irp
Definition: csq.h:116
#define STATUS_SUCCESS
Definition: shellext.h:65
#define DPRINT
Definition: sndvol32.h:73
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135

◆ BdaCommitChanges()

NTSTATUS NTAPI BdaCommitChanges ( IN PIRP  Irp)

Definition at line 182 of file bdasup.c.

183{
184 DPRINT("BdaCommitChanges\n");
185
186 if (!Irp)
188
189 return STATUS_SUCCESS;
190}

◆ BdaCreateFilterFactory()

NTSTATUS NTAPI BdaCreateFilterFactory ( IN PKSDEVICE  pKSDevice,
IN const KSFILTER_DESCRIPTOR *  pFilterDescriptor,
IN const BDA_FILTER_TEMPLATE pBdaFilterTemplate 
)

Definition at line 197 of file bdasup.c.

201{
203}
NTSTATUS NTAPI BdaCreateFilterFactoryEx(IN PKSDEVICE pKSDevice, IN const KSFILTER_DESCRIPTOR *pFilterDescriptor, IN const BDA_FILTER_TEMPLATE *BdaFilterTemplate, OUT PKSFILTERFACTORY *ppKSFilterFactory)
Definition: bdasup.c:246
_Must_inspect_result_ _In_ const KSFILTER_DESCRIPTOR * pFilterDescriptor
Definition: bdasup.h:71
_Must_inspect_result_ _In_ const KSFILTER_DESCRIPTOR _In_ const BDA_FILTER_TEMPLATE * pBdaFilterTemplate
Definition: bdasup.h:72
#define NULL
Definition: types.h:112

◆ BdaCreateFilterFactoryEx()

NTSTATUS NTAPI BdaCreateFilterFactoryEx ( IN PKSDEVICE  pKSDevice,
IN const KSFILTER_DESCRIPTOR *  pFilterDescriptor,
IN const BDA_FILTER_TEMPLATE BdaFilterTemplate,
OUT PKSFILTERFACTORY *  ppKSFilterFactory 
)

Definition at line 246 of file bdasup.c.

251{
252 PKSFILTERFACTORY FilterFactory;
253 PBDA_FILTER_INSTANCE_ENTRY FilterInstance;
254 KIRQL OldLevel;
256 PKSFILTER_DESCRIPTOR FilterDescriptor;
257
258 DPRINT("BdaCreateFilterFactoryEx\n");
259
260 FilterDescriptor = AllocateItem(NonPagedPool, sizeof(KSFILTER_DESCRIPTOR));
261 if (!FilterDescriptor)
262 {
263 /* no memory */
265 }
266
267 /* copy filter descriptor template */
268 RtlMoveMemory(FilterDescriptor, pFilterDescriptor, sizeof(KSFILTER_DESCRIPTOR));
269
270 /* erase pin / nodes / connections from filter descriptor */
271 FilterDescriptor->PinDescriptorsCount = 0;
272 FilterDescriptor->PinDescriptors = NULL;
273 FilterDescriptor->NodeDescriptorsCount = 0;
274 FilterDescriptor->NodeDescriptors = NULL;
275 FilterDescriptor->ConnectionsCount = 0;
276 FilterDescriptor->Connections = NULL;
277
278 /* merge the automation tables */
279 Status = KsMergeAutomationTables((PKSAUTOMATION_TABLE*)&FilterDescriptor->AutomationTable, (PKSAUTOMATION_TABLE)pFilterDescriptor->AutomationTable, &FilterAutomationTable, NULL);
280
281 /* check for success */
282 if (!NT_SUCCESS(Status))
283 {
284 DPRINT1("KsMergeAutomationTables failed with %lx\n", Status);
286 return Status;
287 }
288
289 /* allocate filter instance */
290 FilterInstance = AllocateItem(NonPagedPool, sizeof(BDA_FILTER_INSTANCE_ENTRY));
291 if (!FilterInstance)
292 {
293 /* not enough memory */
296 }
297
298 /* create the filter factory */
299 Status = KsCreateFilterFactory(pKSDevice->FunctionalDeviceObject, FilterDescriptor, NULL, NULL, 0, NULL, NULL, &FilterFactory);
300
301 /* check for success */
302 if (NT_SUCCESS(Status))
303 {
304 if (FilterDescriptor->AutomationTable != &FilterAutomationTable)
305 {
306 /* add the item to filter object bag */
307 KsAddItemToObjectBag(FilterFactory->Bag, (PVOID)FilterDescriptor->AutomationTable, FreeFilterInstance);
308 }
309 else
310 {
311 /* make sure the automation table is not-read only */
312 Status = _KsEdit(FilterFactory->Bag, (PVOID*)&FilterDescriptor->AutomationTable, sizeof(KSAUTOMATION_TABLE), sizeof(KSAUTOMATION_TABLE), 0);
313
314 /* sanity check */
316
317 /* add to object bag */
318 KsAddItemToObjectBag(FilterFactory->Bag, (PVOID)FilterDescriptor->AutomationTable, FreeFilterInstance);
319 }
320
321 /* initialize filter instance entry */
322 FilterInstance->FilterFactoryInstance = FilterFactory;
323 FilterInstance->FilterTemplate = (BDA_FILTER_TEMPLATE *)BdaFilterTemplate;
324
325 /* acquire list lock */
327
328 /* insert factory at the end */
330
331 /* release spin lock */
333
335 {
336 /* store result */
337 *ppKSFilterFactory = FilterFactory;
338 }
339 }
340 else
341 {
342 /* failed to create filter factory */
343 FreeItem(FilterInstance);
345 }
346
347 /* done */
348 DPRINT("BdaCreateFilterFactoryEx Status %x\n", Status);
349 return Status;
350}
NTSTATUS NTAPI KsAddItemToObjectBag(IN KSOBJECT_BAG ObjectBag, IN PVOID Item, IN PFNKSFREE Free OPTIONAL)
Definition: bag.c:86
KSDDKAPI NTSTATUS NTAPI _KsEdit(IN KSOBJECT_BAG ObjectBag, IN OUT PVOID *PointerToPointerToItem, IN ULONG NewSize, IN ULONG OldSize, IN ULONG Tag)
Definition: bag.c:358
LONG NTSTATUS
Definition: precomp.h:26
#define DPRINT1
Definition: precomp.h:8
PVOID AllocateItem(IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes)
Definition: bdasup.c:95
VOID NTAPI FreeFilterInstance(IN PVOID Context)
Definition: bdasup.c:207
KSAUTOMATION_TABLE FilterAutomationTable
Definition: bdasup.c:53
VOID FreeItem(IN PVOID Item)
Definition: bdasup.c:103
BDA_GLOBAL g_Settings
Definition: bdasup.c:10
_Must_inspect_result_ _In_ const KSFILTER_DESCRIPTOR _In_ const BDA_FILTER_TEMPLATE _Out_opt_ PKSFILTERFACTORY * ppKSFilterFactory
Definition: bdasup.h:81
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:33
NTSTATUS NTAPI KsMergeAutomationTables(OUT PKSAUTOMATION_TABLE *AutomationTableAB, IN PKSAUTOMATION_TABLE AutomationTableA OPTIONAL, IN PKSAUTOMATION_TABLE AutomationTableB OPTIONAL, IN KSOBJECT_BAG Bag OPTIONAL)
Definition: api.c:2303
#define InsertTailList(ListHead, Entry)
UCHAR KIRQL
Definition: env_spec_w32.h:591
#define KeReleaseSpinLock(sl, irql)
Definition: env_spec_w32.h:627
#define KeAcquireSpinLock(sl, irql)
Definition: env_spec_w32.h:609
#define NonPagedPool
Definition: env_spec_w32.h:307
KSDDKAPI NTSTATUS NTAPI KsCreateFilterFactory(IN PDEVICE_OBJECT DeviceObject, IN const KSFILTER_DESCRIPTOR *Descriptor, IN PWSTR RefString OPTIONAL, IN PSECURITY_DESCRIPTOR SecurityDescriptor OPTIONAL, IN ULONG CreateItemFlags, IN PFNKSFILTERFACTORYPOWER SleepCallback OPTIONAL, IN PFNKSFILTERFACTORYPOWER WakeCallback OPTIONAL, OUT PKSFILTERFACTORY *FilterFactory OPTIONAL)
Status
Definition: gdiplustypes.h:25
#define ASSERT(a)
Definition: mode.c:44
const KSFILTER_DESCRIPTOR FilterDescriptor
Definition: splitter.c:229
Definition: precomp.h:18
PKSFILTERFACTORY FilterFactoryInstance
Definition: precomp.h:20
LIST_ENTRY Entry
Definition: precomp.h:19
PBDA_FILTER_TEMPLATE FilterTemplate
Definition: precomp.h:21
LIST_ENTRY FilterFactoryInstanceList
Definition: precomp.h:28
KSPIN_LOCK FilterFactoryInstanceListLock
Definition: precomp.h:27
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:264
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158

Referenced by BdaCreateFilterFactory().

◆ BdaCreatePin()

NTSTATUS NTAPI BdaCreatePin ( IN PKSFILTER  pKSFilter,
IN ULONG  ulPinType,
OUT ULONG pulPinId 
)

Definition at line 357 of file bdasup.c.

361{
362 PKSPIN_DESCRIPTOR_EX PinDescriptor;
363 PKSFILTERFACTORY FilterFactory;
364 PBDA_FILTER_INSTANCE_ENTRY InstanceEntry;
366 ULONG PinId;
367 PKSPIN_DESCRIPTOR_EX NewPinDescriptor;
368
369 DPRINT("BdaCreatePin\n");
370
371 if (!pulPinId || !pKSFilter)
373
374 /* get parent filter factory */
375 FilterFactory = KsFilterGetParentFilterFactory(pKSFilter);
376
377 /* sanity check */
378 ASSERT(FilterFactory);
379
380 /* find instance entry */
381 InstanceEntry = GetFilterInstanceEntry(FilterFactory);
382
383 if (!InstanceEntry)
384 {
385 /* the filter was not initialized with BDA */
386 return STATUS_NOT_FOUND;
387 }
388
389 /* sanity checks */
390 ASSERT(InstanceEntry->FilterTemplate);
391 ASSERT(InstanceEntry->FilterTemplate->pFilterDescriptor);
392
393 /* does the filter support any pins */
394 if (!InstanceEntry->FilterTemplate->pFilterDescriptor->PinDescriptorsCount)
395 {
396 /* no pins supported */
397 DPRINT("BdaCreatePin NoPins supported\n");
398 return STATUS_UNSUCCESSFUL;
399 }
400
401 /* is pin factory still existing */
402 if (InstanceEntry->FilterTemplate->pFilterDescriptor->PinDescriptorsCount <= ulPinType)
403 {
404 /* pin request is out of bounds */
405 DPRINT("BdaCreatePin ulPinType %lu >= PinDescriptorCount %lu\n", ulPinType, InstanceEntry->FilterTemplate->pFilterDescriptor->PinDescriptorsCount);
407 }
408
409 /* FIXME custom pin descriptors */
410 ASSERT(InstanceEntry->FilterTemplate->pFilterDescriptor->PinDescriptorSize == sizeof(KSPIN_DESCRIPTOR_EX));
411
412 /* get pin descriptor */
413 PinDescriptor = (PKSPIN_DESCRIPTOR_EX)&InstanceEntry->FilterTemplate->pFilterDescriptor->PinDescriptors[ulPinType];
414
415 /* allocate pin descriptor */
416 NewPinDescriptor = AllocateItem(NonPagedPool, sizeof(KSPIN_DESCRIPTOR_EX));
417 if (!NewPinDescriptor)
418 {
419 /* no memory */
420 DPRINT("BdaCreatePin OutOfMemory\n");
422 }
423
424 /* make a copy of the pin descriptor */
425 RtlMoveMemory(NewPinDescriptor, PinDescriptor, sizeof(KSPIN_DESCRIPTOR_EX));
426
427 /* merge the automation tables */
428 Status = KsMergeAutomationTables((PKSAUTOMATION_TABLE*)&NewPinDescriptor->AutomationTable, (PKSAUTOMATION_TABLE)PinDescriptor->AutomationTable, &PinAutomationTable, pKSFilter->Bag);
429
430 /* check for success */
431 if (NT_SUCCESS(Status))
432 {
433 /* create the pin factory */
434 Status = KsFilterCreatePinFactory(pKSFilter, NewPinDescriptor, &PinId);
435
436 /* check for success */
437 if (NT_SUCCESS(Status))
438 {
439 /* store result */
440 *pulPinId = PinId;
441 }
442 }
443
444 DPRINT("BdaCreatePin Result %x PinId %u\n", Status, PinId);
445 return Status;
446}
KSAUTOMATION_TABLE PinAutomationTable
Definition: bdasup.c:81
PBDA_FILTER_INSTANCE_ENTRY GetFilterInstanceEntry(IN PKSFILTERFACTORY FilterFactory)
Definition: bdasup.c:110
_Must_inspect_result_ _In_ ULONG ulPinType
Definition: bdasup.h:88
_Must_inspect_result_ _In_ ULONG _Out_opt_ ULONG * pulPinId
Definition: bdasup.h:89
KSDDKAPI NTSTATUS NTAPI KsFilterCreatePinFactory(IN PKSFILTER Filter, IN const KSPIN_DESCRIPTOR_EX *const InPinDescriptor, OUT PULONG PinID)
Definition: filter.c:1956
#define STATUS_NOT_FOUND
Definition: shellext.h:72
const KSFILTER_DESCRIPTOR * pFilterDescriptor
Definition: bdasup.h:31
uint32_t ULONG
Definition: typedefs.h:59
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132

Referenced by BdaInitFilter(), and BdaMethodCreatePin().

◆ BdaCreateTopology()

NTSTATUS NTAPI BdaCreateTopology ( IN PKSFILTER  pKSFilter,
IN ULONG  InputPinId,
IN ULONG  OutputPinId 
)

Definition at line 541 of file bdasup.c.

545{
546 PBDA_FILTER_INSTANCE_ENTRY InstanceEntry;
547 PKSFILTERFACTORY FilterFactory;
548 KSTOPOLOGY_CONNECTION Connection;
549
550 DPRINT("BdaCreateTopology\n");
551
552 /* check input parameters */
553 if (!pKSFilter)
555
556 /* get parent filter factory */
557 FilterFactory = KsFilterGetParentFilterFactory(pKSFilter);
558
559 /* sanity check */
560 ASSERT(FilterFactory);
561
562 /* find instance entry */
563 InstanceEntry = GetFilterInstanceEntry(FilterFactory);
564
565 if (!InstanceEntry)
566 {
567 /* the filter was not initialized with BDA */
568 return STATUS_NOT_FOUND;
569 }
570
571 if (InputPinId >= InstanceEntry->FilterTemplate->pFilterDescriptor->PinDescriptorsCount ||
572 OutputPinId >= InstanceEntry->FilterTemplate->pFilterDescriptor->PinDescriptorsCount)
573 {
574 /* invalid pin id */
576 }
577
578 /* initialize topology connection */
579 Connection.FromNode = KSFILTER_NODE;
580 Connection.ToNode = KSFILTER_NODE;
581 Connection.FromNodePin = InputPinId;
582 Connection.ToNodePin = OutputPinId;
583
584 /* add the connection */
585 return KsFilterAddTopologyConnections(pKSFilter, 1, &Connection);
586}
_Must_inspect_result_ _In_ ULONG InputPinId
Definition: bdasup.h:96
_Must_inspect_result_ _In_ ULONG _In_ ULONG OutputPinId
Definition: bdasup.h:97
KSDDKAPI NTSTATUS NTAPI KsFilterAddTopologyConnections(IN PKSFILTER Filter, IN ULONG NewConnectionsCount, IN const KSTOPOLOGY_CONNECTION *const NewTopologyConnections)
Definition: filter.c:1865
#define KSFILTER_NODE
Definition: ks.h:44

Referenced by BdaMethodCreateTopology().

◆ BdaDeletePin()

NTSTATUS NTAPI BdaDeletePin ( IN PKSFILTER  pKSFilter,
IN ULONG pulPinId 
)

Definition at line 593 of file bdasup.c.

596{
598 DPRINT("BdaDeletePin\n");
600}
#define UNIMPLEMENTED
Definition: debug.h:118
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:239

◆ BdaFilterFactoryUpdateCacheData()

NTSTATUS NTAPI BdaFilterFactoryUpdateCacheData ( IN PKSFILTERFACTORY  FilterFactory,
IN const KSFILTER_DESCRIPTOR *FilterDescriptor  OPTIONAL 
)

Definition at line 607 of file bdasup.c.

610{
611 DPRINT("BdaFilterFactoryUpdateCacheData\n");
613}
KSDDKAPI NTSTATUS NTAPI KsFilterFactoryUpdateCacheData(IN PKSFILTERFACTORY FilterFactory, IN const KSFILTER_DESCRIPTOR *FilterDescriptor OPTIONAL)

◆ BdaGetChangeState()

NTSTATUS NTAPI BdaGetChangeState ( IN PIRP  Irp,
OUT BDA_CHANGE_STATE ChangeState 
)

Definition at line 620 of file bdasup.c.

623{
624 DPRINT("BdaGetChangeState\n");
625
626 if (Irp && ChangeState)
627 {
628 *ChangeState = BDA_CHANGES_COMPLETE;
629 return STATUS_SUCCESS;
630 }
631
632 /* invalid parameters supplied */
634
635}
@ BDA_CHANGES_COMPLETE
Definition: bdatypes.h:116

◆ BdaInitFilter()

NTSTATUS NTAPI BdaInitFilter ( IN PKSFILTER  pKSFilter,
IN const BDA_FILTER_TEMPLATE pBdaFilterTemplate 
)

Definition at line 488 of file bdasup.c.

491{
492 PBDA_FILTER_INSTANCE_ENTRY InstanceEntry;
493 PKSFILTERFACTORY FilterFactory;
494 ULONG Index, PinId;
496
497 DPRINT("BdaInitFilter %p\n", pBdaFilterTemplate);
498
499 /* check input parameters */
500 if (!pKSFilter)
502
503 /* get parent filter factory */
504 FilterFactory = KsFilterGetParentFilterFactory(pKSFilter);
505
506 /* sanity check */
507 ASSERT(FilterFactory);
508
509 /* find instance entry */
510 InstanceEntry = GetFilterInstanceEntry(FilterFactory);
511
512 /* sanity check */
513 ASSERT(InstanceEntry);
514
516 {
517 /* use template from BdaCreateFilterFactoryEx */
518 pBdaFilterTemplate = InstanceEntry->FilterTemplate;
519 }
520
521 /* now create the pins */
522 for(Index = 0; Index < pBdaFilterTemplate->pFilterDescriptor->PinDescriptorsCount; Index++)
523 {
524 /* create the pin */
525 Status = BdaCreatePin(pKSFilter, Index, &PinId);
526
527 /* check for success */
528 if (!NT_SUCCESS(Status))
529 break;
530 }
531
532 /* done */
533 return Status;
534}
NTSTATUS NTAPI BdaCreatePin(IN PKSFILTER pKSFilter, IN ULONG ulPinType, OUT ULONG *pulPinId)
Definition: bdasup.c:357
_In_ WDFCOLLECTION _In_ ULONG Index

◆ BdaMethodCreatePin()

NTSTATUS NTAPI BdaMethodCreatePin ( IN PIRP  Irp,
IN KSMETHOD pKSMethod,
OUT ULONG pulPinFactoryID 
)

Definition at line 453 of file bdasup.c.

457{
459 PKSFILTER Filter;
460
461 DPRINT("BdaMethodCreatePin\n");
462
463 if (!Irp)
464 {
465 /* invalid parameter */
467 }
468
469 /* get filter from irp */
471
472 /* sanity check */
473 ASSERT(Filter);
475
476 /* get method request */
478
479 /* create the pin */
480 return BdaCreatePin(Filter, Pin->PinId, pulPinFactoryID);
481}
struct _KSM_PIN * PKSM_PIN
_Must_inspect_result_ _In_ KSMETHOD _Out_opt_ ULONG * pulPinFactoryID
Definition: bdasup.h:133
_Must_inspect_result_ _In_ KSMETHOD * pKSMethod
Definition: bdasup.h:132
KSDDKAPI PKSFILTER NTAPI KsGetFilterFromIrp(IN PIRP Irp)
Definition: filter.c:2106
IN PDCB IN VBO IN ULONG IN BOOLEAN Pin
Definition: fatprocs.h:427
_Must_inspect_result_ _In_opt_ PFLT_FILTER Filter
Definition: fltkernel.h:1801

◆ BdaMethodCreateTopology()

NTSTATUS NTAPI BdaMethodCreateTopology ( IN PIRP  Irp,
IN KSMETHOD pKSMethod,
OPTIONAL PVOID  pvIgnored 
)

Definition at line 642 of file bdasup.c.

646{
647 PKSFILTER Filter;
649
650 DPRINT("BdaMethodCreateTopology\n");
651
652 /* check input parameters */
653 if (!Irp || !pKSMethod)
655
656 /* get filter */
658
659 /* sanity check */
660 ASSERT(Filter);
661
662 /* get method request */
664
665 /* create the topology */
666 return BdaCreateTopology(Filter, Node->ulInputPinId, Node->ulOutputPinId);
667}
struct _KSP_BDA_NODE_PIN * PKSP_BDA_NODE_PIN
NTSTATUS NTAPI BdaCreateTopology(IN PKSFILTER pKSFilter, IN ULONG InputPinId, IN ULONG OutputPinId)
Definition: bdasup.c:541
union node Node
Definition: types.h:1255
Definition: dlist.c:348

◆ BdaMethodDeletePin()

NTSTATUS NTAPI BdaMethodDeletePin ( IN PIRP  Irp,
IN KSMETHOD pKSMethod,
OPTIONAL PVOID  pvIgnored 
)

Definition at line 674 of file bdasup.c.

678{
679 DPRINT("BdaMethodDeletePin\n");
680
681 if (!Irp)
683
684 return STATUS_SUCCESS;
685}

◆ BdaPropertyGetControllingPinId()

NTSTATUS NTAPI BdaPropertyGetControllingPinId ( IN PIRP  Irp,
IN KSP_BDA_NODE_PIN pProperty,
OUT ULONG pulControllingPinId 
)

Definition at line 692 of file bdasup.c.

696{
698 DPRINT("BdaPropertyGetControllingPinId\n");
700}

◆ BdaPropertyGetPinControl()

NTSTATUS NTAPI BdaPropertyGetPinControl ( IN PIRP  Irp,
IN KSPROPERTY pKSProperty,
OUT ULONG pulProperty 
)

Definition at line 707 of file bdasup.c.

711{
712 PKSPIN Pin;
713 PKSFILTER Filter;
714 PKSFILTERFACTORY FilterFactory;
715 PBDA_FILTER_INSTANCE_ENTRY InstanceEntry;
716
717 DPRINT("BdaPropertyGetPinControl\n");
718
719 /* first get the pin */
721 ASSERT(Pin);
722
723 /* now get the parent filter */
725 ASSERT(Filter);
726
727 /* get parent filter factory */
728 FilterFactory = KsFilterGetParentFilterFactory(Filter);
729 ASSERT(FilterFactory);
730
731 /* find instance entry */
732 InstanceEntry = GetFilterInstanceEntry(FilterFactory);
733 ASSERT(InstanceEntry);
734
735 /* sanity check */
736 pKSProperty++;
738
739 /* store pin id */
740 *pulProperty = Pin->Id;
741
742 return STATUS_SUCCESS;
743}
@ KSPROPERTY_BDA_PIN_TYPE
Definition: bdamedia.h:195
_Must_inspect_result_ _In_ KSPROPERTY _Out_opt_ ULONG * pulProperty
Definition: bdasup.h:165
_Must_inspect_result_ _In_ KSPROPERTY * pKSProperty
Definition: bdasup.h:164
PKSFILTER NTAPI KsPinGetParentFilter(IN PKSPIN Pin)
Definition: pin.c:1097
KSDDKAPI PKSPIN NTAPI KsGetPinFromIrp(IN PIRP Irp)
Definition: pin.c:1211
ULONG Id
Definition: dmksctrl.h:77

◆ BdaPropertyNodeDescriptors()

NTSTATUS NTAPI BdaPropertyNodeDescriptors ( IN PIRP  Irp,
IN KSPROPERTY pKSProperty,
OUT BDANODE_DESCRIPTOR pNodeDescriptorProperty 
)

Definition at line 750 of file bdasup.c.

754{
756 DPRINT("BdaPropertyNodeDescriptors\n");
758}

◆ BdaPropertyNodeEvents()

NTSTATUS NTAPI BdaPropertyNodeEvents ( IN PIRP  Irp,
IN KSP_NODE pKSProperty,
OUT GUID pguidProperty 
)

Definition at line 765 of file bdasup.c.

769{
771 DPRINT("BdaPropertyNodeEvents\n");
773}

◆ BdaPropertyNodeMethods()

NTSTATUS NTAPI BdaPropertyNodeMethods ( IN PIRP  Irp,
IN KSP_NODE pKSProperty,
OUT GUID pguidProperty 
)

Definition at line 780 of file bdasup.c.

784{
786 DPRINT("BdaPropertyNodeMethods\n");
788}

◆ BdaPropertyNodeProperties()

NTSTATUS NTAPI BdaPropertyNodeProperties ( IN PIRP  Irp,
IN KSP_NODE pKSProperty,
OUT GUID pguidProperty 
)

Definition at line 795 of file bdasup.c.

799{
801 DPRINT("BdaPropertyNodeProperties\n");
803}

◆ BdaPropertyNodeTypes()

NTSTATUS NTAPI BdaPropertyNodeTypes ( IN PIRP  Irp,
IN KSPROPERTY pKSProperty,
OUT ULONG pulProperty 
)

Definition at line 810 of file bdasup.c.

814{
815 PBDA_FILTER_INSTANCE_ENTRY InstanceEntry;
816 PKSFILTERFACTORY FilterFactory;
817 PKSFILTER pKSFilter;
818 PIO_STACK_LOCATION IoStack;
819 ULONG Index;
820
821 DPRINT("BdaPropertyNodeTypes\n");
822
823 /* check input parameter */
824 if (!Irp || !pKSProperty)
826
827 /* first get the filter */
828 pKSFilter = KsGetFilterFromIrp(Irp);
829
830 /* sanity check */
831 ASSERT(pKSFilter);
832
833 /* get parent filter factory */
834 FilterFactory = KsFilterGetParentFilterFactory(pKSFilter);
835
836 /* sanity check */
837 ASSERT(FilterFactory);
838
839 /* find instance entry */
840 InstanceEntry = GetFilterInstanceEntry(FilterFactory);
841 ASSERT(InstanceEntry);
842
843 /* get current irp stack */
845
846 /* are there node types provided */
847 if (!pulProperty)
848 {
849 /* no node entry array provided */
850 Irp->IoStatus.Information = InstanceEntry->FilterTemplate->pFilterDescriptor->NodeDescriptorsCount * sizeof(ULONG);
851 Irp->IoStatus.Status = STATUS_MORE_ENTRIES;
852 return STATUS_MORE_ENTRIES;
853 }
854
855 if (InstanceEntry->FilterTemplate->pFilterDescriptor->NodeDescriptorsCount * sizeof(ULONG) > IoStack->Parameters.DeviceIoControl.OutputBufferLength)
856 {
857 /* buffer too small */
858 Irp->IoStatus.Information = InstanceEntry->FilterTemplate->pFilterDescriptor->NodeDescriptorsCount * sizeof(ULONG);
859 Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
861 }
862
863 /* now copy all descriptors */
864 for(Index = 0; Index < InstanceEntry->FilterTemplate->pFilterDescriptor->NodeDescriptorsCount; Index++)
865 {
866 /* use the index as the type */
868 }
869
870 return STATUS_SUCCESS;
871}
static PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(PIRP Irp)
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
union _IO_STACK_LOCATION::@1565 Parameters
struct _IO_STACK_LOCATION::@1565::@1566 DeviceIoControl
#define STATUS_MORE_ENTRIES
Definition: udferr_usr.h:124

◆ BdaPropertyPinTypes()

NTSTATUS NTAPI BdaPropertyPinTypes ( IN PIRP  Irp,
IN KSPROPERTY pKSProperty,
OUT ULONG pulProperty 
)

Definition at line 878 of file bdasup.c.

882{
883 PBDA_FILTER_INSTANCE_ENTRY InstanceEntry;
884 PKSFILTERFACTORY FilterFactory;
885 PKSFILTER pKSFilter;
886 PIO_STACK_LOCATION IoStack;
887 ULONG Index;
888
889 DPRINT("BdaPropertyPinTypes\n");
890
891 /* check input parameter */
892 if (!Irp || !pKSProperty)
894
895 /* first get the filter */
896 pKSFilter = KsGetFilterFromIrp(Irp);
897
898 /* sanity check */
899 ASSERT(pKSFilter);
900
901 /* get parent filter factory */
902 FilterFactory = KsFilterGetParentFilterFactory(pKSFilter);
903
904 /* sanity check */
905 ASSERT(FilterFactory);
906
907 /* find instance entry */
908 InstanceEntry = GetFilterInstanceEntry(FilterFactory);
909 ASSERT(InstanceEntry);
910
911 /* get current irp stack */
913
914 /* are there node types provided */
915 if (!pKSProperty)
916 {
917 /* no node entry array provided */
918 Irp->IoStatus.Information = InstanceEntry->FilterTemplate->pFilterDescriptor->PinDescriptorsCount * sizeof(ULONG);
919 Irp->IoStatus.Status = STATUS_MORE_ENTRIES;
920 return STATUS_MORE_ENTRIES;
921 }
922
923 if (InstanceEntry->FilterTemplate->pFilterDescriptor->PinDescriptorsCount * sizeof(ULONG) > IoStack->Parameters.DeviceIoControl.OutputBufferLength)
924 {
925 /* buffer too small */
926 Irp->IoStatus.Information = InstanceEntry->FilterTemplate->pFilterDescriptor->PinDescriptorsCount * sizeof(ULONG);
927 Irp->IoStatus.Status = STATUS_BUFFER_TOO_SMALL;
929 }
930
931 /* now copy all descriptors */
932 for(Index = 0; Index < InstanceEntry->FilterTemplate->pFilterDescriptor->PinDescriptorsCount; Index++)
933 {
934 /* use the index as the type */
936 }
937
938 return STATUS_SUCCESS;
939}

◆ BdaPropertyTemplateConnections()

NTSTATUS NTAPI BdaPropertyTemplateConnections ( IN PIRP  Irp,
IN KSPROPERTY pKSProperty,
OUT KSTOPOLOGY_CONNECTION pConnectionProperty 
)

Definition at line 946 of file bdasup.c.

950{
951 PBDA_FILTER_INSTANCE_ENTRY FilterInstance;
952 PKSFILTER Filter;
953 PIO_STACK_LOCATION IoStack;
954 ULONG Index;
955
956 DPRINT("BdaPropertyTemplateConnections\n");
957
958 /* validate parameters */
959 if (!Irp || !pKSProperty)
961
962 /* first get the filter */
964
965 /* sanity check */
966 ASSERT(Filter);
967
968 /* verify filter has been registered with BDA */
969 FilterInstance = GetFilterInstanceEntry(KsFilterGetParentFilterFactory(Filter));
970
971 if (!FilterInstance)
973
974 /* get current irp stack */
976
978 {
979 /* caller needs the size first */
980 Irp->IoStatus.Information = FilterInstance->FilterTemplate->pFilterDescriptor->ConnectionsCount * sizeof(KSTOPOLOGY_CONNECTION);
981 Irp->IoStatus.Status = STATUS_BUFFER_OVERFLOW;
983 }
984
985 /* sanity check */
986 ASSERT(FilterInstance->FilterTemplate->pFilterDescriptor->ConnectionsCount * sizeof(KSTOPOLOGY_CONNECTION) <= IoStack->Parameters.DeviceIoControl.OutputBufferLength);
987
988 for(Index = 0; Index < FilterInstance->FilterTemplate->pFilterDescriptor->ConnectionsCount; Index++)
989 {
990 /* sanity check */
991 ASSERT(FilterInstance->FilterTemplate->pFilterDescriptor->Connections);
992
993 /* copy connection */
995 }
996
997 /* store result */
998 Irp->IoStatus.Information = FilterInstance->FilterTemplate->pFilterDescriptor->ConnectionsCount * sizeof(KSTOPOLOGY_CONNECTION);
999 Irp->IoStatus.Status = STATUS_SUCCESS;
1000
1001 /* done */
1002 return STATUS_SUCCESS;
1003
1004}
_Must_inspect_result_ _In_ KSPROPERTY _Out_opt_ KSTOPOLOGY_CONNECTION * pConnectionProperty
Definition: bdasup.h:221
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:66

◆ BdaStartChanges()

NTSTATUS NTAPI BdaStartChanges ( IN PIRP  Irp)

Definition at line 1011 of file bdasup.c.

1012{
1013 DPRINT("BdaStartChanges\n");
1014
1015 if (Irp)
1016 return STATUS_SUCCESS;
1017 else
1019
1020}

◆ BdaUninitFilter()

NTSTATUS NTAPI BdaUninitFilter ( IN PKSFILTER  pKSFilter)

Definition at line 1027 of file bdasup.c.

1028{
1029 DPRINT("BdaUninitFilter\n");
1030 return STATUS_SUCCESS;
1031}

◆ BdaValidateNodeProperty()

NTSTATUS NTAPI BdaValidateNodeProperty ( IN PIRP  Irp,
IN KSPROPERTY KSProperty 
)

Definition at line 1038 of file bdasup.c.

1041{
1042 DPRINT("BdaValidateNodeProperty\n");
1043
1044 /* check for valid parameter */
1045 if (Irp && KSProperty)
1046 return STATUS_SUCCESS;
1047
1049}

◆ DllInitialize()

NTSTATUS NTAPI DllInitialize ( PUNICODE_STRING  RegistryPath)

Definition at line 150 of file bdasup.c.

152{
153 DPRINT("BDASUP::DllInitialize\n");
154
158
159 return STATUS_SUCCESS;
160}
#define TRUE
Definition: types.h:120
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
#define KeInitializeSpinLock(sl)
Definition: env_spec_w32.h:604
BOOLEAN Initialized
Definition: precomp.h:26

◆ FreeFilterInstance()

VOID NTAPI FreeFilterInstance ( IN PVOID  Context)

Definition at line 207 of file bdasup.c.

209{
210 PBDA_FILTER_INSTANCE_ENTRY InstanceEntry = NULL;
212 KIRQL OldLevel;
213
214 /* acquire list lock */
216
217 /* point to first entry */
219
221 {
222 /* get instance entry from list entry offset */
224
225 /* is the instance entry the requested one */
226 if (InstanceEntry == (PBDA_FILTER_INSTANCE_ENTRY)Context)
227 {
228 RemoveEntryList(&InstanceEntry->Entry);
229 FreeItem(InstanceEntry);
230 break;
231 }
232
233 /* move to next entry */
234 Entry = Entry->Flink;
235 }
236
237 /* release spin lock */
239}
struct BDA_FILTER_INSTANCE_ENTRY * PBDA_FILTER_INSTANCE_ENTRY
#define RemoveEntryList(Entry)
Definition: env_spec_w32.h:986
base of all file and directory entries
Definition: entries.h:83
Definition: typedefs.h:120
struct _LIST_ENTRY * Flink
Definition: typedefs.h:121
#define CONTAINING_RECORD(address, type, field)
Definition: typedefs.h:260

Referenced by BdaCreateFilterFactoryEx().

◆ FreeItem()

VOID FreeItem ( IN PVOID  Item)

Definition at line 103 of file bdasup.c.

105{
107}
#define ExFreePoolWithTag(_P, _T)
Definition: module.h:1109
_In_ WDFCOLLECTION _In_ WDFOBJECT Item

Referenced by BdaCreateFilterFactoryEx(), and FreeFilterInstance().

◆ GetFilterInstanceEntry()

PBDA_FILTER_INSTANCE_ENTRY GetFilterInstanceEntry ( IN PKSFILTERFACTORY  FilterFactory)

Definition at line 110 of file bdasup.c.

112{
113 PBDA_FILTER_INSTANCE_ENTRY InstanceEntry = NULL;
115 KIRQL OldLevel;
116
117 /* acquire list lock */
119
120 /* point to first entry */
122
124 {
125 /* get instance entry from list entry offset */
127
128 /* is the instance entry the requested one */
129 if (InstanceEntry->FilterFactoryInstance == FilterFactory)
130 break;
131
132 /* move to next entry */
133 Entry = Entry->Flink;
134 /* set to null as it has not been found */
135 InstanceEntry = NULL;
136 }
137
138 /* release spin lock */
140
141 /* return result */
142 return InstanceEntry;
143}

Referenced by BdaCreatePin(), BdaCreateTopology(), BdaInitFilter(), BdaPropertyGetPinControl(), BdaPropertyNodeTypes(), BdaPropertyPinTypes(), and BdaPropertyTemplateConnections().

Variable Documentation

◆ FilterAutomationTable

KSAUTOMATION_TABLE FilterAutomationTable
Initial value:
=
{
1,
sizeof(KSPROPERTY_ITEM),
1,
sizeof(KSMETHOD_ITEM),
0,
sizeof(KSEVENT_ITEM),
}
KSMETHOD_SET FilterMethodSet
Definition: bdasup.c:44
KSPROPERTY_SET FilterPropertySet
Definition: bdasup.c:29

Definition at line 53 of file bdasup.c.

Referenced by BdaCreateFilterFactoryEx().

◆ FilterMethodItem

KSMETHOD_ITEM FilterMethodItem[]
Initial value:
=
{
}

Definition at line 38 of file bdasup.c.

◆ FilterMethodSet

KSMETHOD_SET FilterMethodSet
Initial value:
=
{
2,
0,
}
const GUID KSMETHODSETID_BdaDeviceConfiguration
Definition: bdasup.c:7
KSMETHOD_ITEM FilterMethodItem[]
Definition: bdasup.c:38

Definition at line 44 of file bdasup.c.

◆ FilterPropertyItem

KSPROPERTY_ITEM FilterPropertyItem[]
Initial value:
=
{
}
#define DEFINE_KSPROPERTY_ITEM_BDA_NODE_EVENTS(GetHandler, SetHandler)
Definition: bdamedia.h:115
#define DEFINE_KSPROPERTY_ITEM_BDA_TEMPLATE_CONNECTIONS(GetHandler, SetHandler)
Definition: bdamedia.h:91
#define DEFINE_KSPROPERTY_ITEM_BDA_NODE_TYPES(GetHandler, SetHandler)
Definition: bdamedia.h:75
#define DEFINE_KSPROPERTY_ITEM_BDA_PIN_TYPES(GetHandler, SetHandler)
Definition: bdamedia.h:83
#define DEFINE_KSPROPERTY_ITEM_BDA_NODE_PROPERTIES(GetHandler, SetHandler)
Definition: bdamedia.h:107
#define DEFINE_KSPROPERTY_ITEM_BDA_NODE_METHODS(GetHandler, SetHandler)
Definition: bdamedia.h:99
#define DEFINE_KSPROPERTY_ITEM_BDA_CONTROLLING_PIN_ID(GetHandler, SetHandler)
Definition: bdamedia.h:123
NTSTATUS NTAPI BdaPropertyNodeMethods(IN PIRP Irp, IN KSP_NODE *pKSProperty, OUT GUID *pguidProperty)
Definition: bdasup.c:780
NTSTATUS NTAPI BdaPropertyNodeTypes(IN PIRP Irp, IN KSPROPERTY *pKSProperty, OUT ULONG *pulProperty)
Definition: bdasup.c:810
NTSTATUS NTAPI BdaPropertyNodeEvents(IN PIRP Irp, IN KSP_NODE *pKSProperty, OUT GUID *pguidProperty)
Definition: bdasup.c:765
NTSTATUS NTAPI BdaPropertyPinTypes(IN PIRP Irp, IN KSPROPERTY *pKSProperty, OUT ULONG *pulProperty)
Definition: bdasup.c:878
NTSTATUS NTAPI BdaPropertyGetControllingPinId(IN PIRP Irp, IN KSP_BDA_NODE_PIN *pProperty, OUT ULONG *pulControllingPinId)
Definition: bdasup.c:692
NTSTATUS NTAPI BdaPropertyNodeProperties(IN PIRP Irp, IN KSP_NODE *pKSProperty, OUT GUID *pguidProperty)
Definition: bdasup.c:795
NTSTATUS NTAPI BdaPropertyTemplateConnections(IN PIRP Irp, IN KSPROPERTY *pKSProperty, OUT KSTOPOLOGY_CONNECTION *pConnectionProperty)
Definition: bdasup.c:946

Definition at line 17 of file bdasup.c.

Referenced by PcAddToPropertyTable().

◆ FilterPropertySet

KSPROPERTY_SET FilterPropertySet
Initial value:
=
{
8,
0,
}
KSPROPERTY_ITEM FilterPropertyItem[]
Definition: bdasup.c:17
const GUID KSPROPSETID_BdaTopology
Definition: bdasup.c:8

Definition at line 29 of file bdasup.c.

◆ g_Settings

BDA_GLOBAL g_Settings
Initial value:
=
{
0,
0,
}

Definition at line 10 of file bdasup.c.

Referenced by BdaCreateFilterFactoryEx(), DllInitialize(), FreeFilterInstance(), and GetFilterInstanceEntry().

◆ KSMETHODSETID_BdaDeviceConfiguration

const GUID KSMETHODSETID_BdaDeviceConfiguration = {0x71985f45, 0x1ca1, 0x11d3, {0x9c, 0xc8, 0x0, 0xc0, 0x4f, 0x79, 0x71, 0xe0}}

Definition at line 7 of file bdasup.c.

◆ KSPROPSETID_BdaPinControl

const GUID KSPROPSETID_BdaPinControl = {0xded49d5, 0xa8b7, 0x4d5d, {0x97, 0xa1, 0x12, 0xb0, 0xc1, 0x95, 0x87, 0x4d}}

Definition at line 6 of file bdasup.c.

◆ KSPROPSETID_BdaTopology

const GUID KSPROPSETID_BdaTopology = {0xa14ee835, 0x0a23, 0x11d3, {0x9c, 0xc7, 0x0, 0xc0, 0x4f, 0x79, 0x71, 0xe0}}

Definition at line 8 of file bdasup.c.

◆ PinAutomationTable

KSAUTOMATION_TABLE PinAutomationTable
Initial value:
=
{
1,
sizeof(KSPROPERTY_ITEM),
0,
sizeof(KSMETHOD_ITEM),
0,
sizeof(KSEVENT_ITEM),
}
KSPROPERTY_SET PinPropertySet
Definition: bdasup.c:72

Definition at line 81 of file bdasup.c.

Referenced by BdaCreatePin().

◆ PinPropertyItem

KSPROPERTY_ITEM PinPropertyItem[]
Initial value:
=
{
}
#define DEFINE_KSPROPERTY_ITEM_BDA_PIN_ID(GetHandler, SetHandler)
Definition: bdamedia.h:198
NTSTATUS NTAPI BdaPropertyGetPinControl(IN PIRP Irp, IN KSPROPERTY *pKSProperty, OUT ULONG *pulProperty)
Definition: bdasup.c:707

Definition at line 66 of file bdasup.c.

◆ PinPropertySet

KSPROPERTY_SET PinPropertySet
Initial value:
=
{
2,
0,
}
const GUID KSPROPSETID_BdaPinControl
Definition: bdasup.c:6
KSPROPERTY_ITEM PinPropertyItem[]
Definition: bdasup.c:66

Definition at line 72 of file bdasup.c.