[BDASUP]
[reactos.git] / reactos / drivers / multimedia / bdasup / bdasup.c
1
2 #include "precomp.h"
3
4 const GUID KSPROPSETID_BdaPinControl = {0xded49d5, 0xa8b7, 0x4d5d, {0x97, 0xa1, 0x12, 0xb0, 0xc1, 0x95, 0x87, 0x4d}};
5 const GUID KSMETHODSETID_BdaDeviceConfiguration = {0x71985f45, 0x1ca1, 0x11d3, {0x9c, 0xc8, 0x0, 0xc0, 0x4f, 0x79, 0x71, 0xe0}};
6 const GUID KSPROPSETID_BdaTopology = {0xa14ee835, 0x0a23, 0x11d3, {0x9c, 0xc7, 0x0, 0xc0, 0x4f, 0x79, 0x71, 0xe0}};
7
8 BDA_GLOBAL g_Settings =
9 {
10 0,
11 0,
12 {NULL, NULL}
13 };
14
15 KSPROPERTY_ITEM FilterPropertyItem[] =
16 {
17 DEFINE_KSPROPERTY_ITEM_BDA_NODE_TYPES(BdaPropertyNodeTypes, NULL),
18 DEFINE_KSPROPERTY_ITEM_BDA_PIN_TYPES( BdaPropertyPinTypes, NULL),
19 DEFINE_KSPROPERTY_ITEM_BDA_TEMPLATE_CONNECTIONS(BdaPropertyTemplateConnections, NULL),
20 DEFINE_KSPROPERTY_ITEM_BDA_NODE_METHODS(BdaPropertyNodeMethods, NULL),
21 DEFINE_KSPROPERTY_ITEM_BDA_NODE_PROPERTIES(BdaPropertyNodeProperties, NULL),
22 DEFINE_KSPROPERTY_ITEM_BDA_NODE_EVENTS(BdaPropertyNodeEvents, NULL),
23 DEFINE_KSPROPERTY_ITEM_BDA_CONTROLLING_PIN_ID(BdaPropertyGetControllingPinId, NULL),
24 DEFINE_KSPROPERTY_ITEM_BDA_NODE_DESCRIPTORS(BdaPropertyNodeDescriptors, NULL)
25 };
26
27
28 KSPROPERTY_SET FilterPropertySet =
29 {
30 &KSPROPSETID_BdaTopology,
31 8,
32 FilterPropertyItem,
33 0,
34 NULL
35 };
36
37 KSMETHOD_ITEM FilterMethodItem[] =
38 {
39 //DEFINE_KSMETHOD_ITEM_BDA_CREATE_PIN_FACTORY(BdaMethodCreatePin, NULL),
40 DEFINE_KSMETHOD_ITEM_BDA_CREATE_TOPOLOGY(BdaMethodCreateTopology, NULL)
41 };
42
43 KSMETHOD_SET FilterMethodSet =
44 {
45 &KSMETHODSETID_BdaDeviceConfiguration,
46 2,
47 FilterMethodItem,
48 0,
49 NULL
50 };
51
52 KSAUTOMATION_TABLE FilterAutomationTable =
53 {
54 1,
55 sizeof(KSPROPERTY_ITEM),
56 &FilterPropertySet,
57 1,
58 sizeof(KSMETHOD_ITEM),
59 &FilterMethodSet,
60 0,
61 sizeof(KSEVENT_ITEM),
62 NULL
63 };
64
65 KSPROPERTY_ITEM PinPropertyItem[] =
66 {
67 DEFINE_KSPROPERTY_ITEM_BDA_PIN_ID(BdaPropertyGetPinControl, NULL),
68 DEFINE_KSPROPERTY_ITEM_BDA_PIN_TYPE(BdaPropertyGetPinControl, NULL)
69 };
70
71 KSPROPERTY_SET PinPropertySet =
72 {
73 &KSPROPSETID_BdaPinControl,
74 2,
75 PinPropertyItem,
76 0,
77 NULL
78 };
79
80 KSAUTOMATION_TABLE PinAutomationTable =
81 {
82 1,
83 sizeof(KSPROPERTY_ITEM),
84 &PinPropertySet,
85 0,
86 sizeof(KSMETHOD_ITEM),
87 NULL,
88 0,
89 sizeof(KSEVENT_ITEM),
90 NULL
91 };
92
93
94 PVOID
95 AllocateItem(
96 IN POOL_TYPE PoolType,
97 IN SIZE_T NumberOfBytes)
98 {
99 PVOID Item = ExAllocatePool(PoolType, NumberOfBytes);
100 if (!Item)
101 return Item;
102
103 RtlZeroMemory(Item, NumberOfBytes);
104 return Item;
105 }
106
107 VOID
108 FreeItem(
109 IN PVOID Item)
110 {
111 ExFreePool(Item);
112 }
113
114
115 PBDA_FILTER_INSTANCE_ENTRY
116 GetFilterInstanceEntry(
117 IN PKSFILTERFACTORY FilterFactory)
118 {
119 PBDA_FILTER_INSTANCE_ENTRY InstanceEntry = NULL;
120 PLIST_ENTRY Entry;
121 KIRQL OldLevel;
122
123 /* acquire list lock */
124 KeAcquireSpinLock(&g_Settings.FilterFactoryInstanceListLock, &OldLevel);
125
126 /* point to first entry */
127 Entry = g_Settings.FilterFactoryInstanceList.Flink;
128
129 while(Entry != &g_Settings.FilterFactoryInstanceList)
130 {
131 /* get instance entry from list entry offset */
132 InstanceEntry = (PBDA_FILTER_INSTANCE_ENTRY)CONTAINING_RECORD(Entry, BDA_FILTER_INSTANCE_ENTRY, Entry);
133
134 /* is the instance entry the requested one */
135 if (InstanceEntry->FilterFactoryInstance == FilterFactory)
136 break;
137
138 /* move to next entry */
139 Entry = Entry->Flink;
140 /* set to null as it has not been found */
141 InstanceEntry = NULL;
142 }
143
144
145 /* release spin lock */
146 KeReleaseSpinLock(&g_Settings.FilterFactoryInstanceListLock, OldLevel);
147
148 /* return result */
149 return InstanceEntry;
150 }
151
152 /*
153 @implemented
154 */
155 NTSTATUS
156 NTAPI
157 DllInitialize(
158 PUNICODE_STRING RegistryPath)
159 {
160 DPRINT("BDASUP::DllInitialize\n");
161
162 KeInitializeSpinLock(&g_Settings.FilterFactoryInstanceListLock);
163 InitializeListHead(&g_Settings.FilterFactoryInstanceList);
164 g_Settings.Initialized = TRUE;
165
166 return STATUS_SUCCESS;
167 }
168
169 /*
170 @implemented
171 */
172 NTSTATUS
173 NTAPI
174 BdaCheckChanges(IN PIRP Irp)
175 {
176 DPRINT("BdaCheckChanges\n");
177
178 if (!Irp)
179 return STATUS_INVALID_PARAMETER;
180
181 return STATUS_SUCCESS;
182 }
183
184 /*
185 @implemented
186 */
187 NTSTATUS
188 NTAPI
189 BdaCommitChanges(IN PIRP Irp)
190 {
191 DPRINT("BdaCommitChanges\n");
192
193 if (!Irp)
194 return STATUS_INVALID_PARAMETER;
195
196 return STATUS_SUCCESS;
197 }
198
199 /*
200 @implemented
201 */
202 NTSTATUS
203 NTAPI
204 BdaCreateFilterFactory(
205 IN PKSDEVICE pKSDevice,
206 IN const KSFILTER_DESCRIPTOR *pFilterDescriptor,
207 IN const BDA_FILTER_TEMPLATE *pBdaFilterTemplate)
208 {
209 return BdaCreateFilterFactoryEx(pKSDevice, pFilterDescriptor, pBdaFilterTemplate, NULL);
210 }
211
212 VOID
213 NTAPI
214 FreeFilterInstance(
215 IN PVOID Context)
216 {
217 PBDA_FILTER_INSTANCE_ENTRY InstanceEntry = NULL;
218 PLIST_ENTRY Entry;
219 KIRQL OldLevel;
220
221 /* acquire list lock */
222 KeAcquireSpinLock(&g_Settings.FilterFactoryInstanceListLock, &OldLevel);
223
224 /* point to first entry */
225 Entry = g_Settings.FilterFactoryInstanceList.Flink;
226
227 while(Entry != &g_Settings.FilterFactoryInstanceList)
228 {
229 /* get instance entry from list entry offset */
230 InstanceEntry = (PBDA_FILTER_INSTANCE_ENTRY)CONTAINING_RECORD(Entry, BDA_FILTER_INSTANCE_ENTRY, Entry);
231
232 /* is the instance entry the requested one */
233 if (InstanceEntry == (PBDA_FILTER_INSTANCE_ENTRY)Context)
234 {
235 RemoveEntryList(&InstanceEntry->Entry);
236 FreeItem(InstanceEntry);
237 break;
238 }
239
240 /* move to next entry */
241 Entry = Entry->Flink;
242 }
243
244 /* release spin lock */
245 KeReleaseSpinLock(&g_Settings.FilterFactoryInstanceListLock, OldLevel);
246 }
247
248
249 /*
250 @implemented
251 */
252 NTSTATUS
253 NTAPI
254 BdaCreateFilterFactoryEx(
255 IN PKSDEVICE pKSDevice,
256 IN const KSFILTER_DESCRIPTOR *pFilterDescriptor,
257 IN const BDA_FILTER_TEMPLATE *BdaFilterTemplate,
258 OUT PKSFILTERFACTORY *ppKSFilterFactory)
259 {
260 PKSFILTERFACTORY FilterFactory;
261 PBDA_FILTER_INSTANCE_ENTRY FilterInstance;
262 KIRQL OldLevel;
263 NTSTATUS Status;
264 PKSFILTER_DESCRIPTOR FilterDescriptor;
265
266 DPRINT("BdaCreateFilterFactoryEx\n");
267
268 FilterDescriptor = AllocateItem(NonPagedPool, sizeof(KSFILTER_DESCRIPTOR));
269 if (!FilterDescriptor)
270 {
271 /* no memory */
272 return STATUS_INSUFFICIENT_RESOURCES;
273 }
274
275 /* copy filter descriptor template */
276 RtlMoveMemory(FilterDescriptor, pFilterDescriptor, sizeof(KSFILTER_DESCRIPTOR));
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);
285 FreeItem(FilterDescriptor);
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 */
294 FreeItem(FilterDescriptor);
295 return STATUS_INSUFFICIENT_RESOURCES;
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
305 /* add the item to filter object bag */
306 Status = KsAddItemToObjectBag(FilterFactory->Bag, FilterInstance, FreeFilterInstance);
307 if (!NT_SUCCESS(Status))
308 {
309 /* destroy filter instance */
310 DPRINT1("KsAddItemToObjectBag failed with %lx\n", Status);
311 FreeItem(FilterDescriptor);
312 FreeItem(FilterInstance);
313 KsDeleteFilterFactory(FilterFactory);
314 return Status;
315 }
316
317 /* initialize filter instance entry */
318 FilterInstance->FilterFactoryInstance = FilterFactory;
319 FilterInstance->FilterTemplate = (BDA_FILTER_TEMPLATE *)BdaFilterTemplate;
320
321 /* acquire list lock */
322 KeAcquireSpinLock(&g_Settings.FilterFactoryInstanceListLock, &OldLevel);
323
324 /* insert factory at the end */
325 InsertTailList(&g_Settings.FilterFactoryInstanceList, &FilterInstance->Entry);
326
327 /* release spin lock */
328 KeReleaseSpinLock(&g_Settings.FilterFactoryInstanceListLock, OldLevel);
329
330
331 if (ppKSFilterFactory)
332 {
333 /* store result */
334 *ppKSFilterFactory = FilterFactory;
335 }
336 }
337 else
338 {
339 /* failed to create filter factory */
340 FreeItem(FilterInstance);
341 DPRINT1("KsCreateFilterFactory failed with %lx\n", Status);
342 }
343
344 /* done */
345 DPRINT("BdaCreateFilterFactoryEx Status %x\n", Status);
346 return Status;
347 }
348
349 /*
350 @implemented
351 */
352 NTSTATUS
353 NTAPI
354 BdaCreatePin(
355 IN PKSFILTER pKSFilter,
356 IN ULONG ulPinType,
357 OUT ULONG *pulPinId)
358 {
359 PKSPIN_DESCRIPTOR_EX PinDescriptor;
360 PKSFILTERFACTORY FilterFactory;
361 PBDA_FILTER_INSTANCE_ENTRY InstanceEntry;
362 NTSTATUS Status;
363 ULONG PinId;
364 PKSPIN_DESCRIPTOR_EX NewPinDescriptor;
365
366 DPRINT("BdaCreatePin\n");
367
368 if (!pulPinId || !pKSFilter)
369 return STATUS_INVALID_PARAMETER;
370
371 /* get parent filter factory */
372 FilterFactory = KsFilterGetParentFilterFactory(pKSFilter);
373
374 /* sanity check */
375 ASSERT(FilterFactory);
376
377 /* find instance entry */
378 InstanceEntry = GetFilterInstanceEntry(FilterFactory);
379
380 if (!InstanceEntry)
381 {
382 /* the filter was not initialized with BDA */
383 return STATUS_NOT_FOUND;
384 }
385
386 /* sanity checks */
387 ASSERT(InstanceEntry->FilterTemplate);
388 ASSERT(InstanceEntry->FilterTemplate->pFilterDescriptor);
389
390 /* does the filter support any pins */
391 if (!InstanceEntry->FilterTemplate->pFilterDescriptor->PinDescriptorsCount)
392 {
393 /* no pins supported */
394 DPRINT("BdaCreatePin NoPins supported\n");
395 return STATUS_UNSUCCESSFUL;
396 }
397
398 /* is pin factory still existing */
399 if (InstanceEntry->FilterTemplate->pFilterDescriptor->PinDescriptorsCount <= ulPinType)
400 {
401 /* pin request is out of bounds */
402 DPRINT("BdaCreatePin ulPinType %lu >= PinDescriptorCount %lu\n", ulPinType, InstanceEntry->FilterTemplate->pFilterDescriptor->PinDescriptorsCount);
403 return STATUS_INVALID_PARAMETER;
404 }
405
406 /* FIXME custom pin descriptors */
407 ASSERT(InstanceEntry->FilterTemplate->pFilterDescriptor->PinDescriptorSize == sizeof(KSPIN_DESCRIPTOR_EX));
408
409 /* get pin descriptor */
410 PinDescriptor = (PKSPIN_DESCRIPTOR_EX)&InstanceEntry->FilterTemplate->pFilterDescriptor->PinDescriptors[ulPinType];
411
412 /* allocate pin descriptor */
413 NewPinDescriptor = AllocateItem(NonPagedPool, sizeof(KSPIN_DESCRIPTOR_EX));
414 if (!NewPinDescriptor)
415 {
416 /* no memory */
417 DPRINT("BdaCreatePin OutOfMemory\n");
418 return STATUS_INSUFFICIENT_RESOURCES;
419 }
420
421 /* make a copy of the pin descriptor */
422 RtlMoveMemory(NewPinDescriptor, PinDescriptor, sizeof(KSPIN_DESCRIPTOR_EX));
423
424 /* merge the automation tables */
425 Status = KsMergeAutomationTables((PKSAUTOMATION_TABLE*)&NewPinDescriptor->AutomationTable, (PKSAUTOMATION_TABLE)PinDescriptor->AutomationTable, &PinAutomationTable, pKSFilter->Bag);
426
427 /* check for success */
428 if (NT_SUCCESS(Status))
429 {
430 /* create the pin factory */
431 Status = KsFilterCreatePinFactory(pKSFilter, NewPinDescriptor, &PinId);
432
433 /* check for success */
434 if (NT_SUCCESS(Status))
435 {
436 /* store result */
437 *pulPinId = PinId;
438 }
439 }
440
441
442 DPRINT("BdaCreatePin Result %x PinId %u\n", Status, PinId);
443 return Status;
444 }
445
446 /*
447 @implemented
448 */
449 NTSTATUS
450 NTAPI
451 BdaMethodCreatePin(
452 IN PIRP Irp,
453 IN KSMETHOD *pKSMethod,
454 OUT ULONG *pulPinFactoryID)
455 {
456 PKSM_PIN Pin;
457 PKSFILTER Filter;
458
459 DPRINT("BdaMethodCreatePin\n");
460
461 if (!Irp)
462 {
463 /* invalid parameter */
464 return STATUS_INVALID_PARAMETER;
465 }
466
467 /* get filter from irp */
468 Filter = KsGetFilterFromIrp(Irp);
469
470 /* sanity check */
471 ASSERT(Filter);
472 ASSERT(pKSMethod);
473
474 /* get method request */
475 Pin = (PKSM_PIN)pKSMethod;
476
477 /* create the pin */
478 return BdaCreatePin(Filter, Pin->PinId, pulPinFactoryID);
479 }
480
481 /*
482 @implemented
483 */
484 NTSTATUS
485 NTAPI
486 BdaInitFilter(
487 IN PKSFILTER pKSFilter,
488 IN const BDA_FILTER_TEMPLATE *pBdaFilterTemplate)
489 {
490 PBDA_FILTER_INSTANCE_ENTRY InstanceEntry;
491 PKSFILTERFACTORY FilterFactory;
492 ULONG Index, PinId;
493 NTSTATUS Status = STATUS_SUCCESS;
494
495 DPRINT("BdaInitFilter %p\n", pBdaFilterTemplate);
496
497 /* check input parameters */
498 if (!pKSFilter)
499 return STATUS_INVALID_PARAMETER;
500
501 /* get parent filter factory */
502 FilterFactory = KsFilterGetParentFilterFactory(pKSFilter);
503
504 /* sanity check */
505 ASSERT(FilterFactory);
506
507 /* find instance entry */
508 InstanceEntry = GetFilterInstanceEntry(FilterFactory);
509
510 /* sanity check */
511 ASSERT(InstanceEntry);
512
513 if (!pBdaFilterTemplate)
514 {
515 /* use template from BdaCreateFilterFactoryEx */
516 pBdaFilterTemplate = InstanceEntry->FilterTemplate;
517 }
518
519 /* now create the pins */
520 for(Index = 0; Index < pBdaFilterTemplate->pFilterDescriptor->PinDescriptorsCount; Index++)
521 {
522 /* create the pin */
523 Status = BdaCreatePin(pKSFilter, Index, &PinId);
524
525 /* check for success */
526 if (!NT_SUCCESS(Status))
527 break;
528 }
529
530 /* done */
531 return Status;
532 }
533
534
535
536 /*
537 @implemented
538 */
539 NTSTATUS
540 NTAPI
541 BdaCreateTopology(
542 IN PKSFILTER pKSFilter,
543 IN ULONG InputPinId,
544 IN ULONG OutputPinId)
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)
554 return STATUS_INVALID_PARAMETER;
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 */
575 return STATUS_INVALID_PARAMETER;
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 }
587
588 /*
589 @unimplemented
590 */
591 NTSTATUS
592 NTAPI
593 BdaDeletePin(
594 IN PKSFILTER pKSFilter,
595 IN ULONG *pulPinId)
596 {
597 UNIMPLEMENTED
598 DPRINT("BdaDeletePin\n");
599 return STATUS_NOT_IMPLEMENTED;
600 }
601
602 /*
603 @implemented
604 */
605 NTSTATUS
606 NTAPI
607 BdaFilterFactoryUpdateCacheData(
608 IN PKSFILTERFACTORY FilterFactory,
609 IN const KSFILTER_DESCRIPTOR *FilterDescriptor OPTIONAL)
610 {
611 DPRINT("BdaFilterFactoryUpdateCacheData\n");
612 return KsFilterFactoryUpdateCacheData(FilterFactory, FilterDescriptor);
613 }
614
615 /*
616 @implemented
617 */
618 NTSTATUS
619 NTAPI
620 BdaGetChangeState(
621 IN PIRP Irp,
622 OUT BDA_CHANGE_STATE *ChangeState)
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 */
633 return STATUS_INVALID_PARAMETER;
634
635 }
636
637 /*
638 @implemented
639 */
640 NTSTATUS
641 NTAPI
642 BdaMethodCreateTopology(
643 IN PIRP Irp,
644 IN KSMETHOD *pKSMethod,
645 OPTIONAL PVOID pvIgnored)
646 {
647 PKSFILTER Filter;
648 PKSP_BDA_NODE_PIN Node;
649
650 DPRINT("BdaMethodCreateTopology\n");
651
652 /* check input parameters */
653 if (!Irp || !pKSMethod)
654 return STATUS_INVALID_PARAMETER;
655
656 /* get filter */
657 Filter = KsGetFilterFromIrp(Irp);
658
659 /* sanity check */
660 ASSERT(Filter);
661
662 /* get method request */
663 Node = (PKSP_BDA_NODE_PIN)pKSMethod;
664
665 /* create the topology */
666 return BdaCreateTopology(Filter, Node->ulInputPinId, Node->ulOutputPinId);
667 }
668
669 /*
670 @implemented
671 */
672 NTSTATUS
673 NTAPI
674 BdaMethodDeletePin(
675 IN PIRP Irp,
676 IN KSMETHOD *pKSMethod,
677 OPTIONAL PVOID pvIgnored)
678 {
679 DPRINT("BdaMethodDeletePin\n");
680
681 if (!Irp)
682 return STATUS_INVALID_PARAMETER;
683
684 return STATUS_SUCCESS;
685 }
686
687 /*
688 @unimplemented
689 */
690 NTSTATUS
691 NTAPI
692 BdaPropertyGetControllingPinId(
693 IN PIRP Irp,
694 IN KSP_BDA_NODE_PIN *pProperty,
695 OUT ULONG *pulControllingPinId)
696 {
697 UNIMPLEMENTED
698 DPRINT("BdaPropertyGetControllingPinId\n");
699 return STATUS_NOT_IMPLEMENTED;
700 }
701
702 /*
703 @implemented
704 */
705 NTSTATUS
706 NTAPI
707 BdaPropertyGetPinControl(
708 IN PIRP Irp,
709 IN KSPROPERTY *pKSProperty,
710 OUT ULONG *pulProperty)
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 */
720 Pin = KsGetPinFromIrp(Irp);
721 ASSERT(Pin);
722
723 /* now get the parent filter */
724 Filter = KsPinGetParentFilter(Pin);
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++;
737 ASSERT(pKSProperty->Id == KSPROPERTY_BDA_PIN_TYPE);
738
739 /* store pin id */
740 *pulProperty = Pin->Id;
741
742 return STATUS_SUCCESS;
743 }
744
745 /*
746 @unimplemented
747 */
748 NTSTATUS
749 NTAPI
750 BdaPropertyNodeDescriptors(
751 IN PIRP Irp,
752 IN KSPROPERTY *pKSProperty,
753 OUT BDANODE_DESCRIPTOR *pNodeDescriptorProperty)
754 {
755 UNIMPLEMENTED
756 DPRINT("BdaPropertyNodeDescriptors\n");
757 return STATUS_NOT_IMPLEMENTED;
758 }
759
760 /*
761 @unimplemented
762 */
763 NTSTATUS
764 NTAPI
765 BdaPropertyNodeEvents(
766 IN PIRP Irp,
767 IN KSP_NODE *pKSProperty,
768 OUT GUID *pguidProperty)
769 {
770 UNIMPLEMENTED
771 DPRINT("BdaPropertyNodeEvents\n");
772 return STATUS_NOT_IMPLEMENTED;
773 }
774
775 /*
776 @unimplemented
777 */
778 NTSTATUS
779 NTAPI
780 BdaPropertyNodeMethods(
781 IN PIRP Irp,
782 IN KSP_NODE *pKSProperty,
783 OUT GUID *pguidProperty)
784 {
785 UNIMPLEMENTED
786 DPRINT("BdaPropertyNodeMethods\n");
787 return STATUS_NOT_IMPLEMENTED;
788 }
789
790 /*
791 @unimplemented
792 */
793 NTSTATUS
794 NTAPI
795 BdaPropertyNodeProperties(
796 IN PIRP Irp,
797 IN KSP_NODE *pKSProperty,
798 OUT GUID *pguidProperty)
799 {
800 UNIMPLEMENTED
801 DPRINT("BdaPropertyNodeProperties\n");
802 return STATUS_NOT_IMPLEMENTED;
803 }
804
805 /*
806 @implemented
807 */
808 NTSTATUS
809 NTAPI
810 BdaPropertyNodeTypes(
811 IN PIRP Irp,
812 IN KSPROPERTY *pKSProperty,
813 OUT ULONG *pulProperty)
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)
825 return STATUS_INVALID_PARAMETER;
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 */
844 IoStack = IoGetCurrentIrpStackLocation(Irp);
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;
860 return 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 */
867 pulProperty[Index] = Index;
868 }
869
870 return STATUS_SUCCESS;
871 }
872
873 /*
874 @implemented
875 */
876 NTSTATUS
877 NTAPI
878 BdaPropertyPinTypes(
879 IN PIRP Irp,
880 IN KSPROPERTY *pKSProperty,
881 OUT ULONG *pulProperty)
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)
893 return STATUS_INVALID_PARAMETER;
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 */
912 IoStack = IoGetCurrentIrpStackLocation(Irp);
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;
928 return 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 */
935 pulProperty[Index] = Index;
936 }
937
938 return STATUS_SUCCESS;
939 }
940
941 /*
942 @implemented
943 */
944 NTSTATUS
945 NTAPI
946 BdaPropertyTemplateConnections(
947 IN PIRP Irp,
948 IN KSPROPERTY *pKSProperty,
949 OUT KSTOPOLOGY_CONNECTION *pConnectionProperty)
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)
960 return STATUS_INVALID_PARAMETER;
961
962 /* first get the filter */
963 Filter = KsGetFilterFromIrp(Irp);
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)
972 return STATUS_INVALID_PARAMETER;
973
974 /* get current irp stack */
975 IoStack = IoGetCurrentIrpStackLocation(Irp);
976
977 if (!pConnectionProperty)
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;
982 return 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 */
994 RtlMoveMemory(pConnectionProperty, &FilterInstance->FilterTemplate->pFilterDescriptor->Connections[Index], sizeof(KSTOPOLOGY_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 }
1005
1006 /*
1007 @implemented
1008 */
1009 NTSTATUS
1010 NTAPI
1011 BdaStartChanges(IN PIRP Irp)
1012 {
1013 DPRINT("BdaStartChanges\n");
1014
1015 if (Irp)
1016 return STATUS_SUCCESS;
1017 else
1018 return STATUS_INVALID_PARAMETER;
1019
1020 }
1021
1022 /*
1023 @implemented
1024 */
1025 NTSTATUS
1026 NTAPI
1027 BdaUninitFilter(IN PKSFILTER pKSFilter)
1028 {
1029 DPRINT("BdaUninitFilter\n");
1030 return STATUS_SUCCESS;
1031 }
1032
1033 /*
1034 @implemented
1035 */
1036 NTSTATUS
1037 NTAPI
1038 BdaValidateNodeProperty(
1039 IN PIRP Irp,
1040 IN KSPROPERTY *KSProperty)
1041 {
1042 DPRINT("BdaValidateNodeProperty\n");
1043
1044 /* check for valid parameter */
1045 if (Irp && KSProperty)
1046 return STATUS_SUCCESS;
1047
1048 return STATUS_INVALID_PARAMETER;
1049 }