ReactOS  0.4.14-dev-57-g333b8f1
pin.c
Go to the documentation of this file.
1 /*
2  * COPYRIGHT: See COPYING in the top level directory
3  * PROJECT: ReactOS Kernel Streaming
4  * FILE: drivers/ksfilter/ks/worker.c
5  * PURPOSE: KS pin functions
6  * PROGRAMMER: Johannes Anderwald
7  */
8 
9 #include "precomp.h"
10 
11 #include <bdamedia.h>
12 
13 #define NDEBUG
14 #include <debug.h>
15 
16 typedef struct _KSISTREAM_POINTER
17 {
18  PFNKSSTREAMPOINTER Callback;
23  PKSPIN Pin;
27  KSSTREAM_POINTER StreamPointer;
30 
31 typedef struct
32 {
34  KSPIN Pin;
36  KSPROCESSPIN ProcessPin;
38 
40 
41  IKsFilter * Filter;
44 
45  PKSGATE AttachedGate;
47 
50  volatile LONG IrpCount;
51 
55 
56  PFNKSPINPOWER Sleep;
57  PFNKSPINPOWER Wake;
58  PFNKSPINHANDSHAKE Handshake;
59  PFNKSPINFRAMERETURN FrameReturn;
60  PFNKSPINIRPCOMPLETION IrpCompletion;
61 
62  KSCLOCK_FUNCTIONTABLE ClockTable;
64  IKsReferenceClockVtbl * lpVtblReferenceClock;
66 
67  PKSWORKER PinWorker;
74 
75 }IKsPinImpl;
76 
83 
84 
85 
88 
89 //TODO
90 // KSPROPSETID_Connection
91 // KSPROPERTY_CONNECTION_ACQUIREORDERING
92 // KSPROPSETID_StreamInterface
93 // KSPROPERTY_STREAMINTERFACE_HEADERSIZE
94 
95 KSPROPERTY_SET PinPropertySet[] =
96 {
97  {
99  sizeof(PinConnectionSet) / sizeof(KSPROPERTY_ITEM),
100  (const KSPROPERTY_ITEM*)&PinConnectionSet,
101  0,
102  NULL
103  },
104  {
106  sizeof(PinStreamSet) / sizeof(KSPROPERTY_ITEM),
107  (const KSPROPERTY_ITEM*)&PinStreamSet,
108  0,
109  NULL
110  }
111 };
112 
113 const GUID KSPROPSETID_Connection = {0x1D58C920L, 0xAC9B, 0x11CF, {0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00}};
114 const GUID KSPROPSETID_Stream = {0x65aaba60L, 0x98ae, 0x11cf, {0xa1, 0x0d, 0x00, 0x20, 0xaf, 0xd1, 0x56, 0xe4}};
115 const GUID KSPROPSETID_Clock = {0xDF12A4C0L, 0xAC17, 0x11CF, {0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00}};
116 
117 NTSTATUS
118 NTAPI
120  IN PIRP Irp,
122  IN OUT PVOID Data)
123 {
125  return STATUS_NOT_IMPLEMENTED;
126 }
127 
128 NTSTATUS
129 NTAPI
131  IN PIRP Irp,
133  IN OUT PVOID Data)
134 {
135  PIO_STACK_LOCATION IoStack;
136  PKSIOBJECT_HEADER ObjectHeader;
137  IKsPinImpl * This;
139  PHANDLE Handle;
144 
145  /* get current irp stack */
147 
148  DPRINT("IKsPin_PinMasterClock\n");
149 
150  /* sanity check */
151  ASSERT(IoStack->FileObject);
152  ASSERT(IoStack->FileObject->FsContext2);
153 
154  /* get the object header */
155  ObjectHeader = (PKSIOBJECT_HEADER)IoStack->FileObject->FsContext2;
156 
157  /* sanity check */
158  ASSERT(ObjectHeader);
159 
160  /* locate ks pin implementation from KSPIN offset */
162 
163  /* sanity check */
164  ASSERT(This);
165 
166  Handle = (PHANDLE)Data;
167 
168  if (Request->Flags & KSPROPERTY_TYPE_GET)
169  {
170  if (This->Pin.Descriptor->PinDescriptor.Communication != KSPIN_COMMUNICATION_NONE &&
171  This->Pin.Descriptor->Dispatch &&
172  (This->Pin.Descriptor->Flags & KSPIN_FLAG_IMPLEMENT_CLOCK))
173  {
174  *Handle = NULL;
176  }
177  else
178  {
179  /* no clock available */
181  }
182  }
183  else if (Request->Flags & KSPROPERTY_TYPE_SET)
184  {
185  if (This->Pin.ClientState != KSSTATE_STOP)
186  {
187  /* can only set in stopped state */
189  }
190  else
191  {
192  if (*Handle)
193  {
195 
197 
198  DPRINT("IKsPin_PinMasterClock ObReferenceObjectByHandle %lx\n", Status);
199  if (NT_SUCCESS(Status))
200  {
202  Property.Id = KSPROPERTY_CLOCK_FUNCTIONTABLE;
204 
205  Status = KsSynchronousIoControlDevice(FileObject, KernelMode, IOCTL_KS_PROPERTY, &Property, sizeof(KSPROPERTY), &This->ClockTable, sizeof(KSCLOCK_FUNCTIONTABLE), &BytesReturned);
206 
207  DPRINT("IKsPin_PinMasterClock KSPROPERTY_CLOCK_FUNCTIONTABLE %lx\n", Status);
208 
209  if (NT_SUCCESS(Status))
210  {
211  This->ClockFileObject = FileObject;
212  }
213  else
214  {
216  }
217  }
218  }
219  else
220  {
221  /* zeroing clock handle */
222  RtlZeroMemory(&This->ClockTable, sizeof(KSCLOCK_FUNCTIONTABLE));
224  if (This->ClockFileObject)
225  {
226  FileObject = This->ClockFileObject;
227  This->ClockFileObject = NULL;
228 
229  ObDereferenceObject(This->ClockFileObject);
230  }
231  }
232  }
233  }
234 
235  DPRINT("IKsPin_PinMasterClock Status %lx\n", Status);
236  return Status;
237 }
238 
239 
240 
241 NTSTATUS
242 NTAPI
244  IN PIRP Irp,
246  IN OUT PVOID Data)
247 {
249  return STATUS_NOT_IMPLEMENTED;
250 }
251 
252 
253 NTSTATUS
254 NTAPI
256  IN PIRP Irp,
258  IN OUT PVOID Data)
259 {
260  PIO_STACK_LOCATION IoStack;
261  PKSIOBJECT_HEADER ObjectHeader;
262  IKsPinImpl * This;
264  KSSTATE OldState;
265  PKSSTATE NewState;
266 
267  /* get current irp stack */
269 
270  DPRINT("IKsPin_PinStatePropertyHandler\n");
271 
272  /* sanity check */
273  ASSERT(IoStack->FileObject);
274  ASSERT(IoStack->FileObject->FsContext2);
275 
276  /* get the object header */
277  ObjectHeader = (PKSIOBJECT_HEADER)IoStack->FileObject->FsContext2;
278 
279  /* locate ks pin implementation from KSPIN offset */
281 
282  /* acquire control mutex */
283  KeWaitForSingleObject(This->BasicHeader.ControlMutex, Executive, KernelMode, FALSE, NULL);
284 
285  /* grab state */
286  NewState = (PKSSTATE)Data;
287 
288  if (Request->Flags & KSPROPERTY_TYPE_GET)
289  {
290  *NewState = This->Pin.DeviceState;
291  Irp->IoStatus.Information = sizeof(KSSTATE);
292  }
293  else if (Request->Flags & KSPROPERTY_TYPE_SET)
294  {
295  if (This->Pin.Descriptor->Dispatch->SetDeviceState)
296  {
297  /* backup old state */
298  OldState = This->Pin.ClientState;
299 
300  /* set new state */
301  This->Pin.ClientState = *NewState;
302  This->Pin.DeviceState = KSSTATE_RUN;
303 
304  /* check if it supported */
305  Status = This->Pin.Descriptor->Dispatch->SetDeviceState(&This->Pin, *NewState, OldState);
306 
307  DPRINT("IKsPin_PinStatePropertyHandler NewState %lu Result %lx\n", *NewState, Status);
308 
309  if (!NT_SUCCESS(Status))
310  {
311  /* revert to old state */
312  This->Pin.ClientState = OldState;
313  This->Pin.DeviceState = OldState;
314  DPRINT("IKsPin_PinStatePropertyHandler failed to set state %lx Result %lx\n", *NewState, Status);
315  DbgBreakPoint();
316  }
317  else
318  {
319  /* update device state */
320  This->Pin.DeviceState = *NewState;
321  }
322  }
323  else
324  {
325  /* just set new state */
326  This->Pin.DeviceState = *NewState;
327  This->Pin.ClientState = *NewState;
328  }
329  }
330 
331  /* release processing mutex */
332  KeReleaseMutex(This->BasicHeader.ControlMutex, FALSE);
333 
334  DPRINT("IKsPin_PinStatePropertyHandler Status %lx\n", Status);
335  return Status;
336 }
337 
338 NTSTATUS
339 NTAPI
341  IN PIRP Irp,
343  IN OUT PVOID Data)
344 {
345  PIO_STACK_LOCATION IoStack;
346  PKSIOBJECT_HEADER ObjectHeader;
347  IKsPinImpl * This;
348  ULONG Size;
350 
351  /* get current irp stack */
353 
354  /* sanity check */
355  ASSERT(IoStack->FileObject);
356  ASSERT(IoStack->FileObject->FsContext2);
357 
358  /* get the object header */
359  ObjectHeader = (PKSIOBJECT_HEADER)IoStack->FileObject->FsContext2;
360 
361  /* locate ks pin implementation from KSPIN offset */
363 
364  /* setting allocator flags is not supported */
365  ASSERT(!(Request->Flags & KSPROPERTY_TYPE_SET));
366 
367  /* acquire control mutex */
368  KeWaitForSingleObject(This->BasicHeader.ControlMutex, Executive, KernelMode, FALSE, NULL);
369 
370  if (This->Pin.Descriptor->AllocatorFraming)
371  {
372  /* calculate size */
373  Size = FIELD_OFFSET(KSALLOCATOR_FRAMING_EX, FramingItem[0]) + This->Pin.Descriptor->AllocatorFraming->CountItems * sizeof(KS_FRAMING_ITEM);
374 
375  if (IoStack->Parameters.DeviceIoControl.OutputBufferLength == 0)
376  {
377  /* no buffer */
379  }
380  else if (Size > IoStack->Parameters.DeviceIoControl.OutputBufferLength)
381  {
382  /* buffer too small */
384  }
385  else
386  {
387  /* copy buffer */
388  RtlMoveMemory(Data, This->Pin.Descriptor->AllocatorFraming, Size);
389  }
390 
391  /* store size */
392  Irp->IoStatus.Information = Size;
393  }
394  else
395  {
396  /* no allocator framing details */
398  }
399 
400  /* release processing mutex */
401  KeReleaseMutex(This->BasicHeader.ControlMutex, FALSE);
402 
403  DPRINT("IKsPin_PinAllocatorFramingPropertyHandler Status %lx\n", Status);
404 
405  return Status;
406 }
407 
408 NTSTATUS
409 NTAPI
411  IN PIRP Irp,
413  IN OUT PVOID Data)
414 {
415  PIO_STACK_LOCATION IoStack;
416  PKSIOBJECT_HEADER ObjectHeader;
417  IKsPinImpl * This;
419 
420  /* get current irp stack */
422 
423  DPRINT("IKsPin_PinDataFormatPropertyHandler\n");
424 
425  /* sanity check */
426  ASSERT(IoStack->FileObject);
427  ASSERT(IoStack->FileObject->FsContext2);
428 
429  /* get the object header */
430  ObjectHeader = (PKSIOBJECT_HEADER)IoStack->FileObject->FsContext2;
431 
432  /* locate ks pin implementation from KSPIN offset */
434 
435  /* acquire control mutex */
436  KeWaitForSingleObject(This->BasicHeader.ControlMutex, Executive, KernelMode, FALSE, NULL);
437 
438  if (Request->Flags & KSPROPERTY_TYPE_GET)
439  {
440  if (IoStack->Parameters.DeviceIoControl.OutputBufferLength < This->Pin.ConnectionFormat->FormatSize)
441  {
442  /* buffer too small */
443  Irp->IoStatus.Information = This->Pin.ConnectionFormat->FormatSize;
445  }
446  else
447  {
448  /* copy format */
449  RtlMoveMemory(Data, This->Pin.ConnectionFormat, This->Pin.ConnectionFormat->FormatSize);
450  }
451  }
452  else if (Request->Flags & KSPROPERTY_TYPE_SET)
453  {
454  /* set format */
455  if (This->Pin.Descriptor->Flags & KSPIN_FLAG_FIXED_FORMAT)
456  {
457  /* format cannot be changed */
459  }
460  else
461  {
462  /* FIXME check if the format is supported */
463  Status = _KsEdit(This->Pin.Bag, (PVOID*)&This->Pin.ConnectionFormat, IoStack->Parameters.DeviceIoControl.OutputBufferLength, This->Pin.ConnectionFormat->FormatSize, 0);
464 
465  if (NT_SUCCESS(Status))
466  {
467  /* store new format */
468  RtlMoveMemory(This->Pin.ConnectionFormat, Data, IoStack->Parameters.DeviceIoControl.OutputBufferLength);
469  }
470  }
471  }
472 
473  /* release processing mutex */
474  KeReleaseMutex(This->BasicHeader.ControlMutex, FALSE);
475 
476  DPRINT("IKsPin_PinDataFormatPropertyHandler Status %lx\n", Status);
477 
478  return Status;
479 }
480 
481 NTSTATUS
482 NTAPI
484  IKsPin * iface,
485  IN REFIID refiid,
486  OUT PVOID* Output)
487 {
489  IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(iface, IKsPinImpl, BasicHeader.OuterUnknown);
490 
491  if (IsEqualGUIDAligned(refiid, &IID_IUnknown))
492  {
493  *Output = &This->BasicHeader.OuterUnknown;
495  return STATUS_SUCCESS;
496  }
497 
498 
499  if (This->BasicHeader.ClientAggregate)
500  {
501  /* using client aggregate */
502  Status = This->BasicHeader.ClientAggregate->lpVtbl->QueryInterface(This->BasicHeader.ClientAggregate, refiid, Output);
503 
504  if (NT_SUCCESS(Status))
505  {
506  /* client aggregate supports interface */
507  return Status;
508  }
509  }
510 
511  DPRINT("IKsPin_fnQueryInterface no interface\n");
512  return STATUS_NOT_SUPPORTED;
513 }
514 
515 ULONG
516 NTAPI
518  IKsPin * iface)
519 {
520  IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(iface, IKsPinImpl, BasicHeader.OuterUnknown);
521 
522  return InterlockedIncrement(&This->ref);
523 }
524 
525 ULONG
526 NTAPI
528  IKsPin * iface)
529 {
530  IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(iface, IKsPinImpl, BasicHeader.OuterUnknown);
531 
532  InterlockedDecrement(&This->ref);
533 
534  if (This->ref == 0)
535  {
536  FreeItem(This);
537  return 0;
538  }
539  /* Return new reference count */
540  return This->ref;
541 }
542 
543 NTSTATUS
544 NTAPI
546  IN IKsPin *iface,
547  IN PIRP Irp,
548  IN IKsTransport **OutTransport)
549 {
551  return STATUS_NOT_IMPLEMENTED;
552 }
553 
554 VOID
555 NTAPI
557  IN IKsPin *iface,
558  IN PIRP Irp,
559  IN IKsTransport * *OutTransport)
560 {
562 }
563 
564 
565 NTSTATUS
566 NTAPI
568  IN IKsPin *iface,
569  IN IKsTransport * TransportIn,
570  OUT IKsTransport ** OutTransportIn,
571  OUT IKsTransport * *OutTransportOut,
573 {
575  return STATUS_NOT_IMPLEMENTED;
576 }
577 
578 NTSTATUS
579 NTAPI
581  IN IKsPin *iface,
582  IN KSSTATE OldState,
583  IN KSSTATE NewState,
584  IN IKsTransport * *OutTransport)
585 {
587  return STATUS_NOT_IMPLEMENTED;
588 }
589 
590 VOID
591 NTAPI
593  IN IKsPin *iface,
595  OUT IKsTransport * * OutTransportOut)
596 {
598 }
599 
600 NTSTATUS
601 NTAPI
603  IN IKsPin *iface,
604  IN struct KSPTRANSPORTCONFIG * TransportConfig,
605  OUT IKsTransport ** OutTransportIn,
606  OUT IKsTransport ** OutTransportOut)
607 {
609  return STATUS_NOT_IMPLEMENTED;
610 }
611 
612 NTSTATUS
613 NTAPI
615  IN IKsPin *iface,
616  IN struct KSPTRANSPORTCONFIG const * TransportConfig,
617  OUT IKsTransport ** OutTransportIn,
618  OUT IKsTransport ** OutTransportOut)
619 {
621  return STATUS_NOT_IMPLEMENTED;
622 }
623 
624 NTSTATUS
625 NTAPI
627  IN IKsPin *iface,
628  OUT IKsTransport ** OutTransportIn,
629  OUT IKsTransport ** OutTransportOut)
630 {
632  return STATUS_NOT_IMPLEMENTED;
633 }
634 
635 PKSPIN
636 NTAPI
638  IN IKsPin *iface)
639 {
641  return NULL;
642 }
643 
644 PKSPROCESSPIN
645 NTAPI
647  IN IKsPin *iface)
648 {
650  return NULL;
651 }
652 
653 NTSTATUS
654 NTAPI
656  IN IKsPin *iface)
657 {
659  return STATUS_NOT_IMPLEMENTED;
660 }
661 
662 NTSTATUS
663 NTAPI
665  IN IKsPin *iface)
666 {
668  return STATUS_NOT_IMPLEMENTED;
669 }
670 
671 VOID
672 NTAPI
674  IN IKsPin *iface,
675  IN ULONG EventMask)
676 {
678 }
679 
680 NTSTATUS
681 NTAPI
683  IN IKsPin *iface,
684  IN KSSTATE StateIn,
685  IN KSSTATE StateOut)
686 {
688  return STATUS_NOT_IMPLEMENTED;
689 }
690 
691 static IKsPinVtbl vt_IKsPin =
692 {
710 };
711 
712 
713 //==============================================================
714 
715 NTSTATUS
716 NTAPI
718  IKsReferenceClock * iface,
719  IN REFIID refiid,
720  OUT PVOID* Output)
721 {
722  IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(iface, IKsPinImpl, lpVtblReferenceClock);
723 
724  return IKsPin_fnQueryInterface((IKsPin*)&This->BasicHeader.OuterUnknown, refiid, Output);
725 }
726 
727 ULONG
728 NTAPI
730  IKsReferenceClock * iface)
731 {
732  IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(iface, IKsPinImpl, lpVtblReferenceClock);
733 
734  return IKsPin_fnAddRef((IKsPin*)&This->BasicHeader.OuterUnknown);
735 }
736 
737 ULONG
738 NTAPI
740  IKsReferenceClock * iface)
741 {
742  IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(iface, IKsPinImpl, lpVtblReferenceClock);
743 
744  return IKsPin_fnRelease((IKsPin*)&This->BasicHeader.OuterUnknown);
745 }
746 
747 LONGLONG
748 NTAPI
750  IKsReferenceClock * iface)
751 {
753 
754  IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(iface, IKsPinImpl, lpVtblReferenceClock);
755 
756 
757  DPRINT1("IKsReferenceClock_fnGetTime\n");
758 
759  if (!This->ClockFileObject || !This->ClockTable.GetTime)
760  {
761  Result = 0;
762  }
763  else
764  {
765  Result = This->ClockTable.GetTime(This->ClockFileObject);
766  }
767 
768  return Result;
769 }
770 
771 LONGLONG
772 NTAPI
774  IKsReferenceClock * iface)
775 {
777 
778  IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(iface, IKsPinImpl, lpVtblReferenceClock);
779 
780  DPRINT1("IKsReferenceClock_fnGetPhysicalTime\n");
781 
782 
783  if (!This->ClockFileObject || !This->ClockTable.GetPhysicalTime)
784  {
785  Result = 0;
786  }
787  else
788  {
789  Result = This->ClockTable.GetPhysicalTime(This->ClockFileObject);
790  }
791 
792  return Result;
793 }
794 
795 
796 LONGLONG
797 NTAPI
799  IKsReferenceClock * iface,
800  OUT PLONGLONG SystemTime)
801 {
803 
804  IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(iface, IKsPinImpl, lpVtblReferenceClock);
805 
806  DPRINT1("IKsReferenceClock_fnGetCorrelatedTime\n");
807 
808  if (!This->ClockFileObject || !This->ClockTable.GetCorrelatedTime)
809  {
810  Result = 0;
811  }
812  else
813  {
814  Result = This->ClockTable.GetCorrelatedTime(This->ClockFileObject, SystemTime);
815  }
816 
817  return Result;
818 }
819 
820 
821 LONGLONG
822 NTAPI
824  IKsReferenceClock * iface,
825  OUT PLONGLONG SystemTime)
826 {
828 
829  IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(iface, IKsPinImpl, lpVtblReferenceClock);
830 
831  DPRINT1("IKsReferenceClock_fnGetCorrelatedPhysicalTime\n");
832 
833  if (!This->ClockFileObject || !This->ClockTable.GetCorrelatedPhysicalTime)
834  {
835  Result = 0;
836  }
837  else
838  {
839  Result = This->ClockTable.GetCorrelatedPhysicalTime(This->ClockFileObject, SystemTime);
840  }
841 
842  return Result;
843 }
844 
845 NTSTATUS
846 NTAPI
848  IKsReferenceClock * iface,
850 {
853 
854  IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(iface, IKsPinImpl, lpVtblReferenceClock);
855 
856  DPRINT1("IKsReferenceClock_fnGetResolution\n");
857 
858  if (!This->ClockFileObject)
859  {
860  Resolution->Error = 0;
861  Resolution->Granularity = 1;
862  DPRINT1("IKsReferenceClock_fnGetResolution Using HACK\n");
863  return STATUS_SUCCESS;
864  }
865 
866 
867  if (!This->ClockFileObject)
869 
870 
874 
876 
877 }
878 
879 NTSTATUS
880 NTAPI
882  IKsReferenceClock * iface,
884 {
887 
888  IKsPinImpl * This = (IKsPinImpl*)CONTAINING_RECORD(iface, IKsPinImpl, lpVtblReferenceClock);
889 
890  DPRINT1("IKsReferenceClock_fnGetState\n");
891 
892  if (!This->ClockFileObject)
893  {
894  *State = This->Pin.ClientState;
895  DPRINT1("IKsReferenceClock_fnGetState Using HACK\n");
896  return STATUS_SUCCESS;
897  }
898 
899 
900  if (!This->ClockFileObject)
902 
903 
907 
909 }
910 
911 static IKsReferenceClockVtbl vt_ReferenceClock =
912 {
922 };
923 
924 
925 //==============================================================
926 
927 
928 /*
929  @implemented
930 */
931 VOID
932 NTAPI
934  IN PKSPIN Pin)
935 {
937 
938  KeWaitForSingleObject(&This->ProcessingMutex, Executive, KernelMode, FALSE, NULL);
939 }
940 
941 /*
942  @implemented
943 */
944 VOID
945 NTAPI
947  IN PKSPIN Pin,
948  IN PKSGATE AndGate OPTIONAL)
949 {
951 
952  /* FIXME attach to filter's and gate (filter-centric processing) */
953 
954  This->AttachedGate = AndGate;
955  This->OrGate = FALSE;
956 }
957 
958 /*
959  @implemented
960 */
961 VOID
962 NTAPI
964  IN PKSPIN Pin,
965  IN PKSGATE OrGate OPTIONAL)
966 {
968 
969  /* FIXME attach to filter's and gate (filter-centric processing) */
970 
971  This->AttachedGate = OrGate;
972  This->OrGate = TRUE;
973 }
974 
975 /*
976  @implemented
977 */
978 PKSGATE
979 NTAPI
981  IN PKSPIN Pin)
982 {
984 
985  return This->AttachedGate;
986 }
987 
988 /*
989  @unimplemented
990 */
991 VOID
992 NTAPI
994  IN PKSPIN Pin,
996 {
997  DPRINT("KsPinAttemptProcessing\n");
998  DbgBreakPoint();
1000 }
1001 
1002 /*
1003  @unimplemented
1004 */
1005 NTSTATUS
1006 NTAPI
1008  IN PKSPIN Pin,
1009  OUT PLONG InputDataBytes OPTIONAL,
1010  OUT PLONG OutputBufferBytes OPTIONAL)
1011 {
1012  UNIMPLEMENTED;
1013  return STATUS_NOT_IMPLEMENTED;
1014 }
1015 
1016 /*
1017  @unimplemented
1018 */
1019 NTSTATUS
1020 NTAPI
1022  IN PKSPIN Pin,
1023  IN const GUID* InterfaceId,
1024  OUT PVOID* Interface)
1025 {
1026  UNIMPLEMENTED;
1027  return STATUS_NOT_IMPLEMENTED;
1028 }
1029 
1030 /*
1031  @unimplemented
1032 */
1034 NTAPI
1036  IN PKSPIN Pin)
1037 {
1038  UNIMPLEMENTED;
1039  return NULL;
1040 }
1041 
1042 /*
1043  @unimplemented
1044 */
1046 NTAPI
1048  IN PKSPIN Pin)
1049 {
1050  UNIMPLEMENTED;
1051  return NULL;
1052 }
1053 
1054 /*
1055  @unimplemented
1056 */
1057 NTSTATUS
1058 NTAPI
1060  IN PKSPIN Pin,
1061  IN const GUID* InterfaceId,
1062  OUT PVOID* Interface)
1063 {
1064  UNIMPLEMENTED;
1065  return STATUS_NOT_IMPLEMENTED;
1066 }
1067 
1068 /*
1069  @unimplemented
1070 */
1071 VOID
1072 NTAPI
1074  IN PKSPIN Pin,
1075  OUT PKSPIN* CopySource,
1076  OUT PKSPIN* DelegateBranch)
1077 {
1078  UNIMPLEMENTED;
1079 }
1080 
1081 /*
1082  @implemented
1083 */
1084 PKSPIN
1085 NTAPI
1087  IN PKSPIN Pin)
1088 {
1089  return KsGetNextSibling((PVOID)Pin);
1090 }
1091 
1092 /*
1093  @implemented
1094 */
1095 PKSFILTER
1096 NTAPI
1098  IN PKSPIN Pin)
1099 {
1101 
1102  /* return parent filter */
1103  return This->BasicHeader.Parent.KsFilter;
1104 }
1105 
1106 /*
1107  @implemented
1108 */
1109 NTSTATUS
1110 NTAPI
1112  IN PKSPIN Pin,
1113  OUT PIKSREFERENCECLOCK* Interface)
1114 {
1117 
1118  if (This->ClockFileObject)
1119  {
1120  /* clock is available */
1121  *Interface = (PIKSREFERENCECLOCK)&This->lpVtblReferenceClock;
1123  }
1124 
1125  DPRINT("KsPinGetReferenceClockInterface Pin %p Interface %p Status %x\n", Pin, Interface, Status);
1126  return Status;
1127 }
1128 
1129 /*
1130  @implemented
1131 */
1132 VOID
1133 NTAPI
1135  IN PKSPIN Pin,
1136  IN PFNKSPINFRAMERETURN FrameReturn)
1137 {
1139 
1140  /* register frame return callback */
1141  This->FrameReturn = FrameReturn;
1142 }
1143 
1144 /*
1145  @implemented
1146 */
1147 VOID
1148 NTAPI
1150  IN PKSPIN Pin,
1151  IN PFNKSPINHANDSHAKE Handshake)
1152 {
1154 
1155  /* register private protocol handshake callback */
1156  This->Handshake = Handshake;
1157 }
1158 
1159 /*
1160  @implemented
1161 */
1162 VOID
1163 NTAPI
1165  IN PKSPIN Pin,
1166  IN PFNKSPINIRPCOMPLETION IrpCompletion)
1167 {
1169 
1170  /* register irp completion callback */
1171  This->IrpCompletion = IrpCompletion;
1172 }
1173 
1174 /*
1175  @implemented
1176 */
1177 VOID
1178 NTAPI
1180  IN PKSPIN Pin,
1181  IN PFNKSPINPOWER Sleep OPTIONAL,
1182  IN PFNKSPINPOWER Wake OPTIONAL)
1183 {
1185 
1186  /* register power callbacks */
1187  This->Sleep = Sleep;
1188  This->Wake = Wake;
1189 }
1190 
1191 /*
1192  @implemented
1193 */
1194 VOID
1195 NTAPI
1197  IN PKSPIN Pin)
1198 {
1200 
1201  /* release processing mutex */
1202  KeReleaseMutex(&This->ProcessingMutex, FALSE);
1203 }
1204 
1205 /*
1206  @implemented
1207 */
1208 KSDDKAPI
1209 PKSPIN
1210 NTAPI
1212  IN PIRP Irp)
1213 {
1214  PKSIOBJECT_HEADER ObjectHeader;
1215  PKSPIN Pin;
1218 
1219  DPRINT("KsGetPinFromIrp\n");
1220 
1221  /* get object header */
1222  ObjectHeader = (PKSIOBJECT_HEADER)IoStack->FileObject->FsContext2;
1223 
1224  if (!ObjectHeader)
1225  return NULL;
1226 
1227  Pin = (PKSPIN)ObjectHeader->ObjectType;
1229 
1230  /* sanity check */
1231  ASSERT(Header->Type == KsObjectTypePin);
1232 
1233  /* return object type */
1234  return Pin;
1235 }
1236 
1237 
1238 
1239 /*
1240  @unimplemented
1241 */
1242 VOID
1243 NTAPI
1245  IN PKSPIN Pin,
1246  IN LONGLONG Time)
1247 {
1248  UNIMPLEMENTED;
1249 }
1250 
1251 /*
1252  @unimplemented
1253 */
1254 NTSTATUS
1255 NTAPI
1257  IN PKSPIN Pin,
1260  IN PKSSTREAM_HEADER StreamHeader OPTIONAL,
1262 {
1263  UNIMPLEMENTED;
1264  return STATUS_UNSUCCESSFUL;
1265 }
1266 
1267 /*
1268  @unimplemented
1269 */
1270 KSDDKAPI
1271 NTSTATUS
1272 NTAPI
1274  IN PKSPIN Pin,
1275  IN PMDL Mdl OPTIONAL,
1276  IN PKSSTREAM_HEADER StreamHeader OPTIONAL,
1278 {
1279  UNIMPLEMENTED;
1280  return STATUS_UNSUCCESSFUL;
1281 }
1282 
1283 /*
1284  @unimplemented
1285 */
1286 KSDDKAPI
1287 BOOLEAN
1288 NTAPI
1290  IN PKSPROCESSPIN ProcessPin)
1291 {
1292  UNIMPLEMENTED;
1293  return FALSE;
1294 }
1295 
1296 NTSTATUS
1298  IN IKsPinImpl * This,
1300 {
1302  ULONG Length;
1303 
1304  /* grab new irp */
1306  if (!StreamPointer->Irp)
1307  {
1308  /* run out of mappings */
1309  DPRINT("OutOfMappings\n");
1310  return STATUS_DEVICE_NOT_READY;
1311  }
1312 
1313  InterlockedDecrement(&This->IrpCount);
1314  KsDecrementCountedWorker(This->PinWorker);
1315 
1316  /* get stream header */
1317  if (StreamPointer->Irp->RequestorMode == UserMode)
1318  Header = (PKSSTREAM_HEADER)StreamPointer->Irp->AssociatedIrp.SystemBuffer;
1319  else
1320  Header = (PKSSTREAM_HEADER)StreamPointer->Irp->UserBuffer;
1321 
1322  /* initialize stream pointer */
1323  StreamPointer->Callback = NULL;
1324  StreamPointer->Length = max(Header->DataUsed, Header->FrameExtent);
1325  StreamPointer->Next = NULL;
1326  StreamPointer->Offset = 0;
1327  StreamPointer->Pin = &This->Pin;
1328  StreamPointer->Data = Header->Data;
1329 
1330  StreamPointer->StreamPointer.Context = NULL;
1331  StreamPointer->StreamPointer.Pin = &This->Pin;
1332  StreamPointer->StreamPointer.StreamHeader = Header;
1333 
1334  if (This->Pin.Descriptor->PinDescriptor.DataFlow == KSPIN_DATAFLOW_IN)
1335  StreamPointer->StreamPointer.Offset = &StreamPointer->StreamPointer.OffsetIn;
1336  else
1337  StreamPointer->StreamPointer.Offset = &StreamPointer->StreamPointer.OffsetOut;
1338 
1339 #ifndef _WIN64
1340  StreamPointer->StreamPointer.Offset->Alignment = 0;
1341 #endif
1342  StreamPointer->StreamPointer.Offset->Count = 0;
1343  StreamPointer->StreamPointer.Offset->Data = NULL;
1344  StreamPointer->StreamPointer.Offset->Remaining = 0;
1345 
1346  ASSERT(StreamPointer->StreamPointer.Offset->Remaining == 0);
1347 
1348  //StreamPointer->Offset += StreamPointer->StreamPointer.Offset->Count;
1349 
1350  ASSERT(StreamPointer->Length > StreamPointer->Offset);
1351  ASSERT(StreamPointer->StreamPointer.StreamHeader);
1352  ASSERT(This->FrameSize);
1353 
1354  /* calculate length */
1355  /* TODO split into frames */
1356  Length = StreamPointer->Length;
1357 
1358  /* FIXME */
1359  ASSERT(Length);
1360 
1361 #ifndef _WIN64
1362  StreamPointer->StreamPointer.Offset->Alignment = 0;
1363 #endif
1364  StreamPointer->StreamPointer.Context = NULL;
1365  StreamPointer->StreamPointer.Pin = &This->Pin;
1366  StreamPointer->StreamPointer.Offset->Count = Length;
1367  StreamPointer->StreamPointer.Offset->Remaining = Length;
1368  StreamPointer->StreamPointer.Offset->Data = (PVOID)((ULONG_PTR)StreamPointer->Data + StreamPointer->Offset);
1369  StreamPointer->StreamPointer.StreamHeader->FrameExtent = Length;
1370  if (StreamPointer->StreamPointer.StreamHeader->DataUsed)
1371  StreamPointer->StreamPointer.StreamHeader->DataUsed = Length;
1372 
1373  StreamPointer->StreamPointer.StreamHeader->Data = StreamPointer->StreamPointer.Offset->Data;
1374 
1375  return STATUS_SUCCESS;
1376 }
1377 
1378 
1379 /*
1380  @unimplemented
1381 */
1382 KSDDKAPI
1383 PKSSTREAM_POINTER
1384 NTAPI
1386  IN PKSPIN Pin,
1388 {
1389  IKsPinImpl * This;
1390  NTSTATUS Status;
1391 
1393 
1394  DPRINT("KsPinGetLeadingEdgeStreamPointer Pin %p State %x Count %lu Remaining %lu\n", Pin, State,
1395  This->LeadingEdgeStreamPointer.Length,
1396  This->LeadingEdgeStreamPointer.Offset);
1397 
1398  /* sanity check */
1400 
1402  {
1403  if (!This->LeadingEdgeStreamPointer.Irp || This->LeadingEdgeStreamPointer.StreamPointer.Offset->Remaining == 0)
1404  {
1405  Status = IKsPin_PrepareStreamHeader(This, &This->LeadingEdgeStreamPointer);
1406  if (!NT_SUCCESS(Status))
1407  return NULL;
1408  }
1409 
1410  DPRINT("KsPinGetLeadingEdgeStreamPointer NewOffset %lu TotalLength %lu\n", This->LeadingEdgeStreamPointer.Offset, This->LeadingEdgeStreamPointer.Length);
1411  }
1412 
1413  return &This->LeadingEdgeStreamPointer.StreamPointer;
1414 }
1415 
1416 /*
1417  @unimplemented
1418 */
1419 KSDDKAPI
1420 PKSSTREAM_POINTER
1421 NTAPI
1423  IN PKSPIN Pin,
1425 {
1426  UNIMPLEMENTED;
1427  return NULL;
1428 }
1429 
1430 /*
1431  @unimplemented
1432 */
1433 KSDDKAPI
1434 NTSTATUS
1435 NTAPI
1437  IN PKSSTREAM_POINTER StreamPointer,
1438  IN NTSTATUS Status)
1439 {
1440  UNIMPLEMENTED;
1441  return STATUS_UNSUCCESSFUL;
1442 }
1443 
1444 /*
1445  @unimplemented
1446 */
1447 KSDDKAPI
1448 NTSTATUS
1449 NTAPI
1451  IN PKSSTREAM_POINTER StreamPointer)
1452 {
1453  UNIMPLEMENTED;
1454  return STATUS_UNSUCCESSFUL;
1455 }
1456 
1457 /*
1458  @unimplemented
1459 */
1460 KSDDKAPI
1461 VOID
1462 NTAPI
1464  IN PKSSTREAM_POINTER StreamPointer,
1465  IN BOOLEAN Eject)
1466 {
1468 
1469  DPRINT1("KsStreamPointerUnlock StreamPointer %pEject %lu\n", StreamPointer, Eject);
1470 
1471  Pointer->Irp = NULL;
1472 }
1473 
1474 /*
1475  @unimplemented
1476 */
1477 KSDDKAPI
1478 VOID
1479 NTAPI
1481  IN PKSSTREAM_POINTER StreamPointer,
1482  IN ULONG InUsed,
1483  IN ULONG OutUsed,
1484  IN BOOLEAN Eject)
1485 {
1486  DPRINT1("KsStreamPointerAdvanceOffsets InUsed %lu OutUsed %lu Eject %lu\n", InUsed, OutUsed, Eject);
1487  DbgBreakPoint();
1488  UNIMPLEMENTED;
1489 }
1490 
1491 /*
1492  @implemented
1493 */
1494 KSDDKAPI
1495 VOID
1496 NTAPI
1498  IN PKSSTREAM_POINTER StreamPointer)
1499 {
1500  IKsPinImpl * This;
1501  PKSISTREAM_POINTER Cur, Last;
1503 
1504  DPRINT("KsStreamPointerDelete %p\n", Pointer);
1505 DbgBreakPoint();
1507 
1508  /* point to first stream pointer */
1509  Last = NULL;
1510  Cur = This->ClonedStreamPointer;
1511 
1512  while(Cur != Pointer && Cur)
1513  {
1514  Last = Cur;
1515  /* iterate to next cloned pointer */
1516  Cur = Cur->Next;
1517  }
1518 
1519  if (!Cur)
1520  {
1521  /* you naughty driver */
1522  return;
1523  }
1524 
1525  if (!Last)
1526  {
1527  /* remove first cloned pointer */
1528  This->ClonedStreamPointer = Pointer->Next;
1529  }
1530  else
1531  {
1532  Last->Next = Pointer->Next;
1533  }
1534 
1535  /* FIXME make sure no timeouts are pending */
1536  FreeItem(Pointer);
1537 }
1538 
1539 /*
1540  @implemented
1541 */
1542 KSDDKAPI
1543 NTSTATUS
1544 NTAPI
1546  IN PKSSTREAM_POINTER StreamPointer,
1547  IN PFNKSSTREAMPOINTER CancelCallback OPTIONAL,
1549  OUT PKSSTREAM_POINTER* CloneStreamPointer)
1550 {
1551  IKsPinImpl * This;
1552  PKSISTREAM_POINTER CurFrame;
1553  PKSISTREAM_POINTER NewFrame;
1554  ULONG_PTR RefCount;
1555  NTSTATUS Status;
1556  ULONG Size;
1557 
1558  DPRINT("KsStreamPointerClone StreamPointer %p CancelCallback %p ContextSize %p CloneStreamPointer %p\n", StreamPointer, CancelCallback, ContextSize, CloneStreamPointer);
1559 
1560  /* get stream pointer */
1562 
1563  /* calculate context size */
1564  Size = sizeof(KSISTREAM_POINTER) + ContextSize;
1565 
1566  /* allocate new stream pointer */
1568 
1569  if (!NewFrame)
1571 
1572  /* get current irp stack location */
1573  RefCount = (ULONG_PTR)CurFrame->Irp->Tail.Overlay.DriverContext[0];
1574 
1575  /* increment reference count */
1576  RefCount++;
1577  CurFrame->Irp->Tail.Overlay.DriverContext[0] = (PVOID)RefCount;
1578 
1579  /* copy stream pointer */
1580  RtlMoveMemory(NewFrame, CurFrame, sizeof(KSISTREAM_POINTER));
1581 
1582  /* locate pin */
1584 
1585  /* prepare stream header in case required */
1586  if (CurFrame->StreamPointer.Offset->Remaining == 0)
1587  {
1588  Status = IKsPin_PrepareStreamHeader(This, NewFrame);
1589  if (!NT_SUCCESS(Status))
1590  {
1591  FreeItem(NewFrame);
1592  return STATUS_DEVICE_NOT_READY;
1593  }
1594  }
1595 
1596  if (ContextSize)
1597  NewFrame->StreamPointer.Context = (NewFrame + 1);
1598 
1599 
1600  if (This->Pin.Descriptor->PinDescriptor.DataFlow == KSPIN_DATAFLOW_IN)
1601  NewFrame->StreamPointer.Offset = &NewFrame->StreamPointer.OffsetIn;
1602  else
1603  NewFrame->StreamPointer.Offset = &NewFrame->StreamPointer.OffsetOut;
1604 
1605 
1606 
1607  NewFrame->StreamPointer.Pin = &This->Pin;
1608 
1609  ASSERT(NewFrame->StreamPointer.Pin);
1610  ASSERT(NewFrame->StreamPointer.Context);
1611  ASSERT(NewFrame->StreamPointer.Offset);
1612  ASSERT(NewFrame->StreamPointer.StreamHeader);
1613 
1614  /* store result */
1615  *CloneStreamPointer = &NewFrame->StreamPointer;
1616 
1617  DPRINT("KsStreamPointerClone CloneStreamPointer %p\n", *CloneStreamPointer);
1618 
1619  return STATUS_SUCCESS;
1620 }
1621 
1622 /*
1623  @implemented
1624 */
1625 KSDDKAPI
1626 NTSTATUS
1627 NTAPI
1629  IN PKSSTREAM_POINTER StreamPointer,
1630  IN ULONG InUsed,
1631  IN ULONG OutUsed,
1632  IN BOOLEAN Eject)
1633 {
1634  PKSISTREAM_POINTER CurFrame;
1635  IKsPinImpl * This;
1636  NTSTATUS Status;
1637 
1638  DPRINT("KsStreamPointerAdvanceOffsets StreamPointer %p InUsed %lu OutUsed %lu Eject %lu\n", StreamPointer, InUsed, OutUsed, Eject);
1639 
1640  /* get stream pointer */
1642 
1643  /* locate pin */
1645 
1646  /* TODO */
1647  ASSERT(InUsed == 0);
1648  ASSERT(Eject == 0);
1649  ASSERT(OutUsed);
1650 
1651  DPRINT("KsStreamPointerAdvanceOffsets Offset %lu Length %lu NewOffset %lu Remaining %lu LeadingEdge %p DataUsed %lu\n", CurFrame->Offset, CurFrame->Length, CurFrame->Offset + OutUsed,
1652 CurFrame->StreamPointer.OffsetOut.Remaining, &This->LeadingEdgeStreamPointer.StreamPointer, CurFrame->StreamPointer.StreamHeader->DataUsed);
1653 DbgBreakPoint();
1654 
1655  if (This->Pin.Descriptor->PinDescriptor.DataFlow == KSPIN_DATAFLOW_IN)
1656  {
1657  ASSERT(CurFrame->StreamPointer.OffsetIn.Remaining >= InUsed);
1658  CurFrame->StreamPointer.OffsetIn.Remaining -= InUsed;
1659  CurFrame->StreamPointer.OffsetIn.Data = (PVOID)((ULONG_PTR)CurFrame->StreamPointer.OffsetIn.Data + InUsed);
1660  }
1661  else
1662  {
1663  if (!CurFrame->StreamPointer.OffsetOut.Remaining)
1664  {
1665  Status = IKsPin_PrepareStreamHeader(This, CurFrame);
1666  if (!NT_SUCCESS(Status))
1667  {
1668  return STATUS_DEVICE_NOT_READY;
1669  }
1670  }
1671  else
1672  {
1673  ASSERT(CurFrame->StreamPointer.OffsetOut.Remaining >= OutUsed);
1674  CurFrame->StreamPointer.OffsetOut.Remaining -= OutUsed;
1675  CurFrame->StreamPointer.OffsetOut.Data = (PVOID)((ULONG_PTR)CurFrame->StreamPointer.OffsetOut.Data + OutUsed);
1676  }
1677  }
1678 
1679  return STATUS_SUCCESS;
1680 }
1681 
1682 /*
1683  @unimplemented
1684 */
1685 KSDDKAPI
1686 NTSTATUS
1687 NTAPI
1689  IN PKSSTREAM_POINTER StreamPointer)
1690 {
1691  UNIMPLEMENTED;
1692  DbgBreakPoint();
1693  return STATUS_NOT_IMPLEMENTED;
1694 }
1695 
1696 /*
1697  @unimplemented
1698 */
1699 KSDDKAPI
1700 PMDL
1701 NTAPI
1703  IN PKSSTREAM_POINTER StreamPointer)
1704 {
1705  UNIMPLEMENTED;
1706  return NULL;
1707 }
1708 
1709 /*
1710  @unimplemented
1711 */
1712 KSDDKAPI
1713 PIRP
1714 NTAPI
1716  IN PKSSTREAM_POINTER StreamPointer,
1717  OUT PBOOLEAN FirstFrameInIrp OPTIONAL,
1718  OUT PBOOLEAN LastFrameInIrp OPTIONAL)
1719 {
1720  UNIMPLEMENTED;
1721  return NULL;
1722 }
1723 
1724 /*
1725  @implemented
1726 */
1727 KSDDKAPI
1728 VOID
1729 NTAPI
1731  IN PKSSTREAM_POINTER StreamPointer,
1732  IN PFNKSSTREAMPOINTER Callback,
1734 {
1736  PKSISTREAM_POINTER Pointer;
1737 
1738  /* get stream pointer */
1740 
1741  /* setup timer callback */
1742  Pointer->Callback = Callback;
1743 
1744  /* setup expiration */
1746 
1747  /* setup the timer */
1748  KeSetTimer(&Pointer->Timer, DueTime, &Pointer->TimerDpc);
1749 
1750 }
1751 
1752 /*
1753  @implemented
1754 */
1755 KSDDKAPI
1756 VOID
1757 NTAPI
1759  IN PKSSTREAM_POINTER StreamPointer)
1760 {
1761  PKSISTREAM_POINTER Pointer;
1762 
1763  /* get stream pointer */
1765 
1766  KeCancelTimer(&Pointer->Timer);
1767 
1768 }
1769 
1770 /*
1771  @implemented
1772 */
1773 KSDDKAPI
1774 PKSSTREAM_POINTER
1775 NTAPI
1777  IN PKSPIN Pin)
1778 {
1779  IKsPinImpl * This;
1780 
1781  DPRINT("KsPinGetFirstCloneStreamPointer %p\n", Pin);
1782 
1784 
1785  if (!This->ClonedStreamPointer)
1786  return NULL;
1787 
1788  /* return first cloned stream pointer */
1789  return &This->ClonedStreamPointer->StreamPointer;
1790 }
1791 
1792 /*
1793  @implemented
1794 */
1795 KSDDKAPI
1796 PKSSTREAM_POINTER
1797 NTAPI
1799  IN PKSSTREAM_POINTER StreamPointer)
1800 {
1801  PKSISTREAM_POINTER Pointer;
1802 
1803  DPRINT("KsStreamPointerGetNextClone\n");
1804 DbgBreakPoint();
1805  /* get stream pointer */
1807 
1808  /* is there a another cloned stream pointer */
1809  if (!Pointer->Next)
1810  return NULL;
1811 
1812  /* return next stream pointer */
1813  return &Pointer->Next->StreamPointer;
1814 }
1815 
1816 VOID
1817 NTAPI
1819  IN PVOID Parameter)
1820 {
1821  NTSTATUS Status;
1823 
1824  DPRINT("IKsPin_PinCentricWorker\n");
1825 
1826  /* sanity checks */
1827  ASSERT(This);
1828  ASSERT(This->Pin.Descriptor);
1829  ASSERT(This->Pin.Descriptor->Dispatch);
1830  ASSERT(This->Pin.Descriptor->Dispatch->Process);
1832  ASSERT(!(This->Pin.Descriptor->Flags & KSPIN_FLAG_DISPATCH_LEVEL_PROCESSING));
1833  ASSERT(!(This->Pin.Descriptor->Flags & KSPIN_FLAG_GENERATE_MAPPINGS));
1834 
1835  do
1836  {
1837  DPRINT("IKsPin_PinCentricWorker calling Pin Process Routine\n");
1838 
1839  Status = This->Pin.Descriptor->Dispatch->Process(&This->Pin);
1840  DPRINT("IKsPin_PinCentricWorker Status %lx, Offset %lu Length %lu\n", Status,
1841  This->LeadingEdgeStreamPointer.Offset,
1842  This->LeadingEdgeStreamPointer.Length);
1843  break;
1844 
1845  }while(This->IrpCount);
1846 }
1847 
1848 
1849 NTSTATUS
1850 NTAPI
1853  PIRP Irp,
1854  IKsPinImpl * This)
1855 {
1856  PKSPROCESSPIN_INDEXENTRY ProcessPinIndex;
1858  ULONG NumHeaders;
1859  PKSFILTER Filter;
1860  PIO_STACK_LOCATION IoStack;
1862 
1863  DPRINT("IKsPin_DispatchKsStream\n");
1864 
1865  /* FIXME handle reset states */
1866  ASSERT(This->Pin.ResetState == KSRESET_END);
1867 
1868  /* get current stack location */
1869  IoStack = IoGetCurrentIrpStackLocation(Irp);
1870 
1871  /* probe stream pointer */
1872  if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_WRITE_STREAM)
1873  Status = KsProbeStreamIrp(Irp, KSSTREAM_WRITE | KSPROBE_ALLOCATEMDL | KSPROBE_PROBEANDLOCK | KSPROBE_SYSTEMADDRESS, This->Pin.StreamHeaderSize);
1874  else
1875  Status = KsProbeStreamIrp(Irp, KSSTREAM_READ | KSPROBE_ALLOCATEMDL | KSPROBE_PROBEANDLOCK | KSPROBE_SYSTEMADDRESS, This->Pin.StreamHeaderSize);
1876 
1877  if (!NT_SUCCESS(Status))
1878  {
1879  DPRINT1("KsProbeStreamIrp failed with %x\n", Status);
1880 
1881  Irp->IoStatus.Status = Status;
1883  return Status;
1884  }
1885 
1886  if (Irp->RequestorMode == UserMode)
1887  Header = (PKSSTREAM_HEADER)Irp->AssociatedIrp.SystemBuffer;
1888  else
1889  Header = (PKSSTREAM_HEADER)Irp->UserBuffer;
1890 
1891  if (!Header)
1892  {
1893  DPRINT("NoHeader Canceling Irp %p\n", Irp);
1894  Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
1896  return Status;
1897  }
1898 
1899  /* calculate num headers */
1900  NumHeaders = IoStack->Parameters.DeviceIoControl.OutputBufferLength / Header->Size;
1901 
1902  /* assume headers of same length */
1903  ASSERT(IoStack->Parameters.DeviceIoControl.OutputBufferLength % Header->Size == 0);
1904 
1905  /* FIXME support multiple stream headers */
1906  ASSERT(NumHeaders == 1);
1907 
1908  if (Irp->RequestorMode == UserMode)
1909  {
1910  /* prepare header */
1911  ASSERT(Irp->MdlAddress);
1913 
1914  if (!Header->Data)
1915  {
1916  DPRINT("NoHeader->Data Canceling Irp %p\n", Irp);
1917  Irp->IoStatus.Status = STATUS_INSUFFICIENT_RESOURCES;
1919  return Status;
1920  }
1921 
1922  }
1923 
1924 
1925 
1926  if (This->Pin.Descriptor->Dispatch->Process)
1927  {
1928  /* it is a pin centric avstream */
1929 
1930  /* mark irp as pending */
1932 
1933  /* add irp to cancelable queue */
1934  KsAddIrpToCancelableQueue(&This->IrpList, &This->IrpListLock, Irp, KsListEntryTail, NULL /* FIXME */);
1935 
1936  /* sanity checks */
1937  ASSERT(!(This->Pin.Descriptor->Flags & KSPIN_FLAG_DISPATCH_LEVEL_PROCESSING));
1938  ASSERT(This->PinWorker);
1939 
1940  InterlockedIncrement(&This->IrpCount);
1941 
1942  DPRINT("IKsPin_DispatchKsStream IrpCount %lu\n", This->IrpCount);
1943 
1944  /* start the processing loop */
1945  KsIncrementCountedWorker(This->PinWorker);
1946 
1948  }
1949  else
1950  {
1951  /* filter-centric avstream */
1952  ASSERT(This->Filter);
1953 
1954  ProcessPinIndex = This->Filter->lpVtbl->GetProcessDispatch(This->Filter);
1955  Filter = This->Filter->lpVtbl->GetStruct(This->Filter);
1956 
1957  ASSERT(ProcessPinIndex);
1958  ASSERT(Filter);
1959  ASSERT(Filter->Descriptor);
1960  ASSERT(Filter->Descriptor->Dispatch);
1961 
1962  if (!Filter->Descriptor->Dispatch->Process)
1963  {
1964  /* invalid device request */
1965  DPRINT("Filter Centric Processing No Process Routine\n");
1966  Irp->IoStatus.Status = STATUS_UNSUCCESSFUL;
1968  return STATUS_UNSUCCESSFUL;
1969  }
1970 
1971  /* mark irp as pending */
1973 
1974  /* add irp to cancelable queue */
1975  KsAddIrpToCancelableQueue(&This->IrpList, &This->IrpListLock, Irp, KsListEntryTail, NULL /* FIXME */);
1976 
1977  Status = Filter->Descriptor->Dispatch->Process(Filter, ProcessPinIndex);
1978 
1979  DPRINT("IKsPin_DispatchKsStream FilterCentric: Status %lx \n", Status);
1980 
1981  }
1982 
1983  return Status;
1984 }
1985 
1986 NTSTATUS
1987 NTAPI
1990  IN PIRP Irp)
1991 {
1992  PIO_STACK_LOCATION IoStack;
1993  PKSIOBJECT_HEADER ObjectHeader;
1994  IKsPinImpl * This;
1995  NTSTATUS Status;
1998  ULONG SetCount = 0;
1999 
2000  /* get current irp stack */
2001  IoStack = IoGetCurrentIrpStackLocation(Irp);
2002 
2003  /* sanity check */
2004  ASSERT(IoStack->FileObject);
2005  ASSERT(IoStack->FileObject->FsContext2);
2006 
2007  /* get the object header */
2008  ObjectHeader = (PKSIOBJECT_HEADER)IoStack->FileObject->FsContext2;
2009 
2010  /* locate ks pin implementation from KSPIN offset */
2012 
2013  /* current irp stack */
2014  IoStack = IoGetCurrentIrpStackLocation(Irp);
2015 
2016  if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_READ_STREAM ||
2017  IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_WRITE_STREAM)
2018  {
2019  /* handle ks stream packets */
2021  }
2022 
2023  /* get property from input buffer */
2024  Property = (PKSPROPERTY)IoStack->Parameters.DeviceIoControl.Type3InputBuffer;
2025 
2026  /* sanity check */
2027  ASSERT(IoStack->Parameters.DeviceIoControl.InputBufferLength >= sizeof(KSIDENTIFIER));
2028  ASSERT(This->Pin.Descriptor->AutomationTable);
2029 
2031  DPRINT("IKsPin_DispatchDeviceIoControl property Set |%S| Id %u Flags %x\n", GuidString.Buffer, Property->Id, Property->Flags);
2033 
2034 
2035  if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_METHOD)
2036  {
2037  const KSMETHOD_SET *MethodSet = NULL;
2038  ULONG MethodItemSize = 0;
2039 
2040  /* check if the driver supports method sets */
2041  if (This->Pin.Descriptor->AutomationTable->MethodSetsCount)
2042  {
2043  SetCount = This->Pin.Descriptor->AutomationTable->MethodSetsCount;
2044  MethodSet = This->Pin.Descriptor->AutomationTable->MethodSets;
2045  MethodItemSize = This->Pin.Descriptor->AutomationTable->MethodItemSize;
2046  }
2047 
2048  /* call method set handler */
2049  Status = KspMethodHandlerWithAllocator(Irp, SetCount, MethodSet, NULL, MethodItemSize);
2050  }
2051  else if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_PROPERTY)
2052  {
2053  const KSPROPERTY_SET *PropertySet = NULL;
2054  ULONG PropertyItemSize = 0;
2055 
2056  /* check if the driver supports method sets */
2057  if (This->Pin.Descriptor->AutomationTable->PropertySetsCount)
2058  {
2059  SetCount = This->Pin.Descriptor->AutomationTable->PropertySetsCount;
2060  PropertySet = This->Pin.Descriptor->AutomationTable->PropertySets;
2061  PropertyItemSize = This->Pin.Descriptor->AutomationTable->PropertyItemSize;
2062  }
2063 
2064  /* needed for our property handlers */
2065  KSPROPERTY_ITEM_IRP_STORAGE(Irp) = (KSPROPERTY_ITEM*)This;
2066 
2067  /* call property handler */
2068  Status = KspPropertyHandler(Irp, SetCount, PropertySet, NULL, PropertyItemSize);
2069  }
2070  else
2071  {
2072  /* sanity check */
2073  ASSERT(IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_ENABLE_EVENT ||
2074  IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_DISABLE_EVENT);
2075 
2076  if (IoStack->Parameters.DeviceIoControl.IoControlCode == IOCTL_KS_ENABLE_EVENT)
2077  {
2078  /* call enable event handlers */
2080  This->Pin.Descriptor->AutomationTable->EventSetsCount,
2081  (PKSEVENT_SET)This->Pin.Descriptor->AutomationTable->EventSets,
2082  &This->BasicHeader.EventList,
2084  (PVOID)&This->BasicHeader.EventListLock,
2085  NULL,
2086  This->Pin.Descriptor->AutomationTable->EventItemSize);
2087  }
2088  else
2089  {
2090  /* disable event handler */
2091  Status = KsDisableEvent(Irp, &This->BasicHeader.EventList, KSEVENTS_SPINLOCK, &This->BasicHeader.EventListLock);
2092  }
2093  }
2094 
2096  DPRINT("IKsPin_DispatchDeviceIoControl property Set |%S| Id %u Flags %x Status %lx ResultLength %lu\n", GuidString.Buffer, Property->Id, Property->Flags, Status, Irp->IoStatus.Information);
2098 
2099  if (Status != STATUS_PENDING)
2100  {
2101  Irp->IoStatus.Status = Status;
2103  }
2104 
2105  /* done */
2106  return Status;
2107 }
2108 
2109 NTSTATUS
2110 NTAPI
2113  IN PIRP Irp)
2114 {
2115  PIO_STACK_LOCATION IoStack;
2116  PKSIOBJECT_HEADER ObjectHeader;
2117  IKsPinImpl * This;
2119 
2120  /* get current irp stack */
2121  IoStack = IoGetCurrentIrpStackLocation(Irp);
2122 
2123  /* sanity check */
2124  ASSERT(IoStack->FileObject);
2125  ASSERT(IoStack->FileObject->FsContext2);
2126 
2127  /* get the object header */
2128  ObjectHeader = (PKSIOBJECT_HEADER)IoStack->FileObject->FsContext2;
2129 
2130  /* locate ks pin implementation fro KSPIN offset */
2132 
2133  if (This->Pin.Descriptor->Dispatch->Close)
2134  {
2135  /* call pin close routine */
2136  Status = This->Pin.Descriptor->Dispatch->Close(&This->Pin, Irp);
2137 
2138  if (!NT_SUCCESS(Status))
2139  {
2140  /* abort closing */
2141  Irp->IoStatus.Status = Status;
2143  return Status;
2144  }
2145 
2146  /* remove pin from filter pin list and decrement reference count */
2147  IKsFilter_RemovePin(This->Filter->lpVtbl->GetStruct(This->Filter), &This->Pin);
2148 
2149  if (Status != STATUS_PENDING)
2150  {
2151  Irp->IoStatus.Status = Status;
2153  return Status;
2154  }
2155  }
2156 
2157  return Status;
2158 }
2159 
2160 NTSTATUS
2161 NTAPI
2164  IN PIRP Irp)
2165 {
2166  UNIMPLEMENTED;
2167 
2168  Irp->IoStatus.Status = STATUS_NOT_IMPLEMENTED;
2170  return STATUS_NOT_IMPLEMENTED;
2171 }
2172 
2173 NTSTATUS
2174 NTAPI
2177  IN PIRP Irp)
2178 {
2179  PKSPIN Pin;
2181  IKsPinImpl * This;
2183  PKSRESOLUTION pResolution = NULL;
2184  PKSOBJECT_CREATE_ITEM CreateItem;
2185 
2186  DPRINT("IKsPin_DispatchCreateClock\n");
2187 
2188  /* get the create item */
2189  CreateItem = KSCREATE_ITEM_IRP_STORAGE(Irp);
2190 
2191  /* sanity check */
2192  ASSERT(CreateItem);
2193 
2194  /* get the pin object */
2195  Pin = (PKSPIN)CreateItem->Context;
2196 
2197  /* sanity check */
2198  ASSERT(Pin);
2199 
2200  /* locate ks pin implementation fro KSPIN offset */
2202 
2203  /* sanity check */
2204  ASSERT(This->BasicHeader.Type == KsObjectTypePin);
2205  ASSERT(This->BasicHeader.ControlMutex);
2206 
2207  /* acquire control mutex */
2209 
2210  if ((This->Pin.Descriptor->PinDescriptor.Communication != KSPIN_COMMUNICATION_NONE &&
2211  This->Pin.Descriptor->Dispatch) ||
2212  (This->Pin.Descriptor->Flags & KSPIN_FLAG_IMPLEMENT_CLOCK))
2213  {
2214  if (!This->DefaultClock)
2215  {
2216  if (This->Pin.Descriptor->Dispatch && This->Pin.Descriptor->Dispatch->Clock)
2217  {
2218  if (This->Pin.Descriptor->Dispatch->Clock->Resolution)
2219  {
2220  This->Pin.Descriptor->Dispatch->Clock->Resolution(&This->Pin, &Resolution);
2221  pResolution = &Resolution;
2222  }
2223 
2224  Status = KsAllocateDefaultClockEx(&This->DefaultClock,
2225  (PVOID)&This->Pin,
2226  (PFNKSSETTIMER)This->Pin.Descriptor->Dispatch->Clock->SetTimer,
2227  (PFNKSCANCELTIMER)This->Pin.Descriptor->Dispatch->Clock->CancelTimer,
2228  (PFNKSCORRELATEDTIME)This->Pin.Descriptor->Dispatch->Clock->CorrelatedTime,
2229  pResolution,
2230  0);
2231  }
2232  else
2233  {
2234  Status = KsAllocateDefaultClockEx(&This->DefaultClock, (PVOID)&This->Pin, NULL, NULL, NULL, NULL, 0);
2235  }
2236  }
2237 
2238  if (NT_SUCCESS(Status))
2239  {
2240  Status = KsCreateDefaultClock(Irp, This->DefaultClock);
2241  }
2242  }
2243 
2244  DPRINT("IKsPin_DispatchCreateClock %lx\n", Status);
2245 
2246  /* release control mutex */
2248 
2249  /* done */
2250  Irp->IoStatus.Status = Status;
2252  return Status;
2253 }
2254 
2255 NTSTATUS
2256 NTAPI
2259  IN PIRP Irp)
2260 {
2261  UNIMPLEMENTED;
2262 
2263  Irp->IoStatus.Status = STATUS_NOT_IMPLEMENTED;
2265  return STATUS_NOT_IMPLEMENTED;
2266 }
2267 
2268 static KSDISPATCH_TABLE PinDispatchTable =
2269 {
2274  IKsPin_Close,
2280 };
2281 
2282 NTSTATUS
2285  IN PIRP Irp,
2286  IN PKSDEVICE KsDevice,
2287  IN IKsFilterFactory * FilterFactory,
2288  IN IKsFilter* Filter,
2290  IN KSPIN_DESCRIPTOR_EX* Descriptor)
2291 {
2292  IKsPinImpl * This;
2293  PIO_STACK_LOCATION IoStack;
2294  IKsDevice * Device;
2295  PDEVICE_EXTENSION DeviceExtension;
2296  PKSOBJECT_CREATE_ITEM CreateItem;
2297  NTSTATUS Status;
2299  PKSBASIC_HEADER BasicHeader;
2300  ULONG Index;
2301  ULONG FrameSize = 0;
2302  ULONG NumFrames = 0;
2303  KSAUTOMATION_TABLE AutomationTable;
2304 
2305  /* sanity checks */
2306  ASSERT(Descriptor->Dispatch);
2307 
2308  DPRINT("KspCreatePin PinId %lu Flags %x\n", Connect->PinId, Descriptor->Flags);
2309 
2310 //Output Pin: KSPIN_FLAG_PROCESS_IN_RUN_STATE_ONLY
2311 //Input Pin: KSPIN_FLAG_FIXED_FORMAT|KSPIN_FLAG_DO_NOT_USE_STANDARD_TRANSPORT|KSPIN_FLAG_FRAMES_NOT_REQUIRED_FOR_PROCESSING
2312 
2313  DPRINT("KspCreatePin Dataflow %lu\n", Descriptor->PinDescriptor.DataFlow);
2314  DPRINT("KspCreatePin Communication %lu\n", Descriptor->PinDescriptor.Communication);
2315  if (Descriptor->AllocatorFraming)
2316  {
2317  DPRINT("KspCreatePin CountItems %lu\n", Descriptor->AllocatorFraming->CountItems);
2318  DPRINT("KspCreatePin PinFlags %lx\n", Descriptor->AllocatorFraming->PinFlags);
2319  DPRINT("KspCreatePin OutputCompression RatioNumerator %lu RatioDenominator %lu RatioConstantMargin %lu\n", Descriptor->AllocatorFraming->OutputCompression.RatioNumerator,
2320  Descriptor->AllocatorFraming->OutputCompression.RatioDenominator, Descriptor->AllocatorFraming->OutputCompression.RatioConstantMargin);
2321  DPRINT("KspCreatePin PinWeight %lx\n", Descriptor->AllocatorFraming->PinWeight);
2322 
2323  for(Index = 0; Index < Descriptor->AllocatorFraming->CountItems; Index++)
2324  {
2325  DPRINT("KspCreatePin Index %lu MemoryFlags %lx\n", Index, Descriptor->AllocatorFraming->FramingItem[Index].MemoryFlags);
2326  DPRINT("KspCreatePin Index %lu BusFlags %lx\n", Index, Descriptor->AllocatorFraming->FramingItem[Index].BusFlags);
2327  DPRINT("KspCreatePin Index %lu Flags %lx\n", Index, Descriptor->AllocatorFraming->FramingItem[Index].Flags);
2328  DPRINT("KspCreatePin Index %lu Frames %lu\n", Index, Descriptor->AllocatorFraming->FramingItem[Index].Frames);
2329  DPRINT("KspCreatePin Index %lu FileAlignment %lx\n", Index, Descriptor->AllocatorFraming->FramingItem[Index].FileAlignment);
2330  DPRINT("KspCreatePin Index %lu MemoryTypeWeight %lx\n", Index, Descriptor->AllocatorFraming->FramingItem[Index].MemoryTypeWeight);
2331  DPRINT("KspCreatePin Index %lu PhysicalRange MinFrameSize %lu MaxFrameSize %lu Stepping %lu\n", Index, Descriptor->AllocatorFraming->FramingItem[Index].PhysicalRange.MinFrameSize,
2332  Descriptor->AllocatorFraming->FramingItem[Index].PhysicalRange.MaxFrameSize,
2333  Descriptor->AllocatorFraming->FramingItem[Index].PhysicalRange.Stepping);
2334 
2335  DPRINT("KspCreatePin Index %lu FramingRange MinFrameSize %lu MaxFrameSize %lu Stepping %lu InPlaceWeight %lu NotInPlaceWeight %lu\n",
2336  Index,
2337  Descriptor->AllocatorFraming->FramingItem[Index].FramingRange.Range.MinFrameSize,
2338  Descriptor->AllocatorFraming->FramingItem[Index].FramingRange.Range.MaxFrameSize,
2339  Descriptor->AllocatorFraming->FramingItem[Index].FramingRange.Range.Stepping,
2340  Descriptor->AllocatorFraming->FramingItem[Index].FramingRange.InPlaceWeight,
2341  Descriptor->AllocatorFraming->FramingItem[Index].FramingRange.NotInPlaceWeight);
2342 
2343  FrameSize = Descriptor->AllocatorFraming->FramingItem[Index].FramingRange.Range.MaxFrameSize;
2344  NumFrames = Descriptor->AllocatorFraming->FramingItem[Index].Frames;
2345  }
2346  }
2347 
2348  for (Index = 0; Index < Descriptor->PinDescriptor.DataRangesCount; Index++)
2349  {
2351  /* convert the guid to string */
2352  RtlStringFromGUID(&Descriptor->PinDescriptor.DataRanges[Index]->MajorFormat, &GuidString);
2353  DPRINT("Index %lu MajorFormat %S\n", Index, GuidString.Buffer);
2354  RtlStringFromGUID(&Descriptor->PinDescriptor.DataRanges[Index]->SubFormat, &GuidString);
2355  DPRINT("Index %lu SubFormat %S\n", Index, GuidString.Buffer);
2356  RtlStringFromGUID(&Descriptor->PinDescriptor.DataRanges[Index]->Specifier, &GuidString);
2357  DPRINT("Index %lu Specifier %S\n", Index, GuidString.Buffer);
2358  RtlStringFromGUID(&Descriptor->PinDescriptor.DataRanges[Index]->Specifier, &GuidString);
2359  DPRINT("Index %lu FormatSize %lu Flags %lu SampleSize %lu Reserved %lu KSDATAFORMAT %lu\n", Index,
2360  Descriptor->PinDescriptor.DataRanges[Index]->FormatSize, Descriptor->PinDescriptor.DataRanges[Index]->Flags, Descriptor->PinDescriptor.DataRanges[Index]->SampleSize, Descriptor->PinDescriptor.DataRanges[Index]->Reserved, sizeof(KSDATAFORMAT));
2361 
2362  if (IsEqualGUIDAligned(&Descriptor->PinDescriptor.DataRanges[Index]->SubFormat, &KSDATAFORMAT_SUBTYPE_BDA_MPEG2_TRANSPORT))
2363  {
2364 #if !defined(NDEBUG)
2365  PKS_DATARANGE_BDA_TRANSPORT Transport = (PKS_DATARANGE_BDA_TRANSPORT)&Descriptor->PinDescriptor.DataRanges[Index];
2366  DPRINT("KSDATAFORMAT_SUBTYPE_BDA_MPEG2_TRANSPORT AvgTimePerFrame %I64u ulcbPhyiscalFrame %lu ulcbPhyiscalFrameAlignment %lu ulcbPhyiscalPacket %lu\n", Transport->BdaTransportInfo.AvgTimePerFrame, Transport->BdaTransportInfo.ulcbPhyiscalFrame,
2368 #endif
2369  }
2370  }
2371  if (!FrameSize)
2372  {
2373  /* default to 50 * 188 (MPEG2 TS packet size) */
2374  FrameSize = 9400;
2375  }
2376 
2377  if (!NumFrames)
2378  {
2379  NumFrames = 8;
2380  }
2381 
2382  /* get current irp stack */
2383  IoStack = IoGetCurrentIrpStackLocation(Irp);
2384 
2385  /* get device extension */
2386  DeviceExtension = (PDEVICE_EXTENSION)DeviceObject->DeviceExtension;
2387 
2388  /* get ks device interface */
2389  Device = (IKsDevice*)&DeviceExtension->DeviceHeader->BasicHeader.OuterUnknown;
2390 
2391  /* first allocate pin ctx */
2393  if (!This)
2394  {
2395  /* not enough memory */
2397  }
2398 
2399  /* allocate create item */
2400  CreateItem = AllocateItem(NonPagedPool, sizeof(KSOBJECT_CREATE_ITEM) * 3);
2401  if (!CreateItem)
2402  {
2403  /* not enough memory */
2404  FreeItem(This);
2405  DPRINT("KspCreatePin OutOfMemory\n");
2407  }
2408 
2409  /* initialize basic header */
2410  This->BasicHeader.KsDevice = KsDevice;
2411  This->BasicHeader.Type = KsObjectTypePin;
2412  This->BasicHeader.Parent.KsFilter = Filter->lpVtbl->GetStruct(Filter);
2413  This->BasicHeader.OuterUnknown = (PUNKNOWN)&vt_IKsPin;
2414  InitializeListHead(&This->BasicHeader.EventList);
2415  KeInitializeSpinLock(&This->BasicHeader.EventListLock);
2416 
2417  ASSERT(This->BasicHeader.Parent.KsFilter);
2418 
2419  BasicHeader = (PKSBASIC_HEADER)((ULONG_PTR)This->BasicHeader.Parent.KsFilter - sizeof(KSBASIC_HEADER));
2420 
2421  This->BasicHeader.ControlMutex = BasicHeader->ControlMutex;
2422  ASSERT(This->BasicHeader.ControlMutex);
2423 
2424  InitializeListHead(&This->BasicHeader.EventList);
2425  KeInitializeSpinLock(&This->BasicHeader.EventListLock);
2426 
2427  /* initialize pin */
2428  This->FrameSize = FrameSize;
2429  This->NumFrames = NumFrames;
2430  This->lpVtblReferenceClock = &vt_ReferenceClock;
2431  This->ref = 1;
2432  This->FileObject = IoStack->FileObject;
2433  This->Filter = Filter;
2434  KeInitializeMutex(&This->ProcessingMutex, 0);
2435  InitializeListHead(&This->IrpList);
2436  KeInitializeSpinLock(&This->IrpListLock);
2437 
2438  /* allocate object bag */
2439  This->Pin.Bag = AllocateItem(NonPagedPool, sizeof(KSIOBJECT_BAG));
2440  if (!This->Pin.Bag)
2441  {
2442  /* not enough memory */
2443  FreeItem(This);
2444  FreeItem(CreateItem);
2446  }
2447 
2448  /* initialize object bag */
2449  Device->lpVtbl->InitializeObjectBag(Device, This->Pin.Bag, NULL);
2450 
2451  /* allocate pin descriptor */
2452  This->Pin.Descriptor = AllocateItem(NonPagedPool, sizeof(KSPIN_DESCRIPTOR_EX));
2453  if (!This->Pin.Descriptor)
2454  {
2455  /* not enough memory */
2456  KsFreeObjectBag(This->Pin.Bag);
2457  FreeItem(This);
2458  FreeItem(CreateItem);
2460  }
2461 
2462  /* copy pin descriptor */
2463  RtlMoveMemory((PVOID)This->Pin.Descriptor, Descriptor, sizeof(KSPIN_DESCRIPTOR_EX));
2464 
2465  /* initialize automation table */
2466  RtlZeroMemory(&AutomationTable, sizeof(KSAUTOMATION_TABLE));
2467 
2468  AutomationTable.PropertyItemSize = sizeof(KSPROPERTY_ITEM);
2469  AutomationTable.PropertySets = PinPropertySet;
2470  AutomationTable.PropertySetsCount = sizeof(PinPropertySet) / sizeof(KSPROPERTY_SET);
2471 
2472  /* merge in pin property sets */
2473  Status = KsMergeAutomationTables((PKSAUTOMATION_TABLE*)&This->Pin.Descriptor->AutomationTable, (PKSAUTOMATION_TABLE)Descriptor->AutomationTable, &AutomationTable, This->Pin.Bag);
2474 
2475  if (!NT_SUCCESS(Status))
2476  {
2477  /* not enough memory */
2478  KsFreeObjectBag(This->Pin.Bag);
2479  FreeItem(This);
2480  FreeItem(CreateItem);
2481  return Status;
2482  }
2483 
2484  /* get format */
2485  DataFormat = (PKSDATAFORMAT)(Connect + 1);
2486 
2487  /* initialize pin descriptor */
2488  This->Pin.Context = NULL;
2489  This->Pin.Id = Connect->PinId;
2490  This->Pin.Communication = Descriptor->PinDescriptor.Communication;
2491  This->Pin.ConnectionIsExternal = FALSE; //FIXME
2492  RtlMoveMemory(&This->Pin.ConnectionInterface, &Connect->Interface, sizeof(KSPIN_INTERFACE));
2493  RtlMoveMemory(&This->Pin.ConnectionMedium, &Connect->Medium, sizeof(KSPIN_MEDIUM));
2494  RtlMoveMemory(&This->Pin.ConnectionPriority, &Connect->Priority, sizeof(KSPRIORITY));
2495 
2496  /* allocate format */
2497  Status = _KsEdit(This->Pin.Bag, (PVOID*)&This->Pin.ConnectionFormat, DataFormat->FormatSize, DataFormat->FormatSize, 0);
2498  if (!NT_SUCCESS(Status))
2499  {
2500  /* failed to allocate format */
2501  KsFreeObjectBag((KSOBJECT_BAG)This->Pin.Bag);
2502  FreeItem(This);
2503  FreeItem(CreateItem);
2505  }
2506 
2507  /* copy format */
2508  RtlMoveMemory((PVOID)This->Pin.ConnectionFormat, DataFormat, DataFormat->FormatSize);
2509 
2510  This->Pin.AttributeList = NULL; //FIXME
2511  This->Pin.StreamHeaderSize = sizeof(KSSTREAM_HEADER);
2512  This->Pin.DataFlow = Descriptor->PinDescriptor.DataFlow;
2513  This->Pin.DeviceState = KSSTATE_STOP;
2514  This->Pin.ResetState = KSRESET_END;
2515  This->Pin.ClientState = KSSTATE_STOP;
2516 
2517  /* initialize allocator create item */
2518  CreateItem[0].Context = (PVOID)&This->Pin;
2519  CreateItem[0].Create = IKsPin_DispatchCreateAllocator;
2520  CreateItem[0].Flags = KSCREATE_ITEM_FREEONSTOP;
2521  RtlInitUnicodeString(&CreateItem[0].ObjectClass, KSSTRING_Allocator);
2522 
2523  /* initialize clock create item */
2524  CreateItem[1].Context = (PVOID)&This->Pin;
2525  CreateItem[1].Create = IKsPin_DispatchCreateClock;
2526  CreateItem[1].Flags = KSCREATE_ITEM_FREEONSTOP;
2527  RtlInitUnicodeString(&CreateItem[1].ObjectClass, KSSTRING_Clock);
2528 
2529  /* initialize topology node create item */
2530  CreateItem[2].Context = (PVOID)&This->Pin;
2531  CreateItem[2].Create = IKsPin_DispatchCreateNode;
2532  CreateItem[2].Flags = KSCREATE_ITEM_FREEONSTOP;
2533  RtlInitUnicodeString(&CreateItem[2].ObjectClass, KSSTRING_TopologyNode);
2534 
2535  /* now allocate object header */
2536  Status = KsAllocateObjectHeader((KSOBJECT_HEADER*)&This->ObjectHeader, 3, CreateItem, Irp, &PinDispatchTable);
2537  if (!NT_SUCCESS(Status))
2538  {
2539  /* failed to create object header */
2540  DPRINT("KspCreatePin KsAllocateObjectHeader failed %lx\n", Status);
2541  KsFreeObjectBag((KSOBJECT_BAG)This->Pin.Bag);
2542  FreeItem(This);
2543  FreeItem(CreateItem);
2544 
2545  /* return failure code */
2546  return Status;
2547  }
2548 
2549  /* add extra info to object header */
2550  This->ObjectHeader->Type = KsObjectTypePin;
2551  This->ObjectHeader->Unknown = (PUNKNOWN)&This->BasicHeader.OuterUnknown;
2552  This->ObjectHeader->ObjectType = (PVOID)&This->Pin;
2553 
2554  if (!Descriptor->Dispatch || !Descriptor->Dispatch->Process)
2555  {
2556  /* the pin is part of filter-centric processing filter
2557  * add process pin to filter
2558  */
2559  This->ProcessPin.BytesAvailable = 0;
2560  This->ProcessPin.BytesUsed = 0;
2561  This->ProcessPin.CopySource = NULL;
2562  This->ProcessPin.Data = NULL;
2563  This->ProcessPin.DelegateBranch = NULL;
2564  This->ProcessPin.Flags = 0;
2565  This->ProcessPin.InPlaceCounterpart = NULL;
2566  This->ProcessPin.Pin = &This->Pin;
2567  This->ProcessPin.StreamPointer = (PKSSTREAM_POINTER)&This->LeadingEdgeStreamPointer.StreamPointer;
2568  This->ProcessPin.Terminate = FALSE;
2569 
2570  Status = Filter->lpVtbl->AddProcessPin(Filter, &This->ProcessPin);
2571  DPRINT("KspCreatePin AddProcessPin %lx\n", Status);
2572 
2573  if (!NT_SUCCESS(Status))
2574  {
2575  /* failed to add process pin */
2576  KsFreeObjectBag((KSOBJECT_BAG)This->Pin.Bag);
2577  KsFreeObjectHeader(&This->ObjectHeader);
2578  FreeItem(This);
2579  FreeItem(CreateItem);
2580  /* return failure code */
2581  return Status;
2582  }
2583  }
2584  else if (Descriptor->Dispatch && Descriptor->Dispatch->Process)
2585  {
2586  /* pin centric processing filter */
2587 
2588  /* initialize work item */
2590 
2591  /* allocate counted work item */
2592  Status = KsRegisterCountedWorker(HyperCriticalWorkQueue, &This->PinWorkQueueItem, &This->PinWorker);
2593 
2594  if (!NT_SUCCESS(Status))
2595  {
2596  DPRINT("Failed to register Worker %lx\n", Status);
2597  KsFreeObjectBag((KSOBJECT_BAG)This->Pin.Bag);
2598  KsFreeObjectHeader(&This->ObjectHeader);
2599  FreeItem(This);
2600  FreeItem(CreateItem);
2601  return Status;
2602  }
2603 
2604  if (This->Pin.Descriptor->PinDescriptor.DataFlow == KSPIN_DATAFLOW_IN)
2605  This->LeadingEdgeStreamPointer.StreamPointer.Offset = &This->LeadingEdgeStreamPointer.StreamPointer.OffsetIn;
2606  else
2607  This->LeadingEdgeStreamPointer.StreamPointer.Offset = &This->LeadingEdgeStreamPointer.StreamPointer.OffsetOut;
2608 
2609 
2610  KeInitializeEvent(&This->FrameComplete, NotificationEvent, FALSE);
2611 
2612  }
2613 
2614  /* FIXME add pin instance to filter instance */
2615  IKsFilter_AddPin(Filter->lpVtbl->GetStruct(Filter), &This->Pin);
2616 
2617  if (Descriptor->Dispatch && Descriptor->Dispatch->SetDataFormat)
2618  {
2619  Status = Descriptor->Dispatch->SetDataFormat(&This->Pin, NULL, NULL, This->Pin.ConnectionFormat, NULL);
2620  DPRINT("KspCreatePin SetDataFormat %lx\n", Status);
2621  }
2622 
2623 
2624  /* does the driver have a pin dispatch */
2625  if (Descriptor->Dispatch && Descriptor->Dispatch->Create)
2626  {
2627  /* now inform the driver to create a new pin */
2628  Status = Descriptor->Dispatch->Create(&This->Pin, Irp);
2629  DPRINT("KspCreatePin DispatchCreate %lx\n", Status);
2630  }
2631 
2632 
2633  DPRINT("KspCreatePin Status %lx KsDevice %p\n", Status, KsDevice);
2634 
2635  if (!NT_SUCCESS(Status) && Status != STATUS_PENDING)
2636  {
2637  /* failed to create pin, release resources */
2638  IKsFilter_RemovePin(Filter->lpVtbl->GetStruct(Filter), &This->Pin);
2639  KsFreeObjectBag((KSOBJECT_BAG)This->Pin.Bag);
2640  KsFreeObjectHeader((KSOBJECT_HEADER)This->ObjectHeader);
2641  FreeItem(This);
2642 
2643  /* return failure code */
2644  return Status;
2645  }
2646 
2647  return Status;
2648 }
VOID NTAPI KsPinRegisterFrameReturnCallback(IN PKSPIN Pin, IN PFNKSPINFRAMERETURN FrameReturn)
Definition: pin.c:1134
KSDDKAPI VOID NTAPI KsStreamPointerDelete(IN PKSSTREAM_POINTER StreamPointer)
Definition: pin.c:1497
#define KeGetCurrentIrql()
Definition: env_spec_w32.h:706
PKSFILTER NTAPI KsPinGetParentFilter(IN PKSPIN Pin)
Definition: pin.c:1097
PFILE_OBJECT ClockFileObject
Definition: pin.c:63
VOID NTAPI KsPinRegisterIrpCompletionCallback(IN PKSPIN Pin, IN PFNKSPINIRPCOMPLETION IrpCompletion)
Definition: pin.c:1164
PKSDEFAULTCLOCK DefaultClock
Definition: pin.c:65
struct KSBASIC_HEADER * PKSBASIC_HEADER
static PWSTR GuidString
Definition: apphelp.c:91
#define IOCTL_KS_PROPERTY
Definition: ks.h:127
NTSTATUS NTAPI KsPinGetAvailableByteCount(IN PKSPIN Pin, OUT PLONG InputDataBytes OPTIONAL, OUT PLONG OutputBufferBytes OPTIONAL)
Definition: pin.c:1007
NTSTATUS NTAPI IKsPin_fnQueryInterface(IKsPin *iface, IN REFIID refiid, OUT PVOID *Output)
Definition: pin.c:483
#define IN
Definition: typedefs.h:38
VOID NTAPI KsPinAttachOrGate(IN PKSPIN Pin, IN PKSGATE OrGate OPTIONAL)
Definition: pin.c:963
VOID NTAPI KsPinAcquireProcessingMutex(IN PKSPIN Pin)
Definition: pin.c:933
#define max(a, b)
Definition: svc.c:63
PFNKSPINPOWER Sleep
Definition: pin.c:56
#define IOCTL_KS_WRITE_STREAM
Definition: ks.h:139
#define REFIID
Definition: guiddef.h:118
#define TRUE
Definition: types.h:120
NTSTATUS NTAPI IKsPin_Close(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: pin.c:2111
KSPIN_INTERFACE Interface
Definition: ks.h:2601
KSDDKAPI NTSTATUS NTAPI KsDispatchSetSecurity(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:67
NTSTATUS IKsPin_PrepareStreamHeader(IN IKsPinImpl *This, IN PKSISTREAM_POINTER StreamPointer)
Definition: pin.c:1297
VOID WINAPI DECLSPEC_HOTPATCH Sleep(IN DWORD dwMilliseconds)
Definition: synch.c:790
ULONG Length
Definition: pin.c:26
BOOLEAN NTAPI KeSetTimer(IN OUT PKTIMER Timer, IN LARGE_INTEGER DueTime, IN PKDPC Dpc OPTIONAL)
Definition: timerobj.c:281
KSDDKAPI NTSTATUS NTAPI KsAllocateDefaultClockEx(OUT PKSDEFAULTCLOCK *DefaultClock, IN PVOID Context OPTIONAL, IN PFNKSSETTIMER SetTimer OPTIONAL, IN PFNKSCANCELTIMER CancelTimer OPTIONAL, IN PFNKSCORRELATEDTIME CorrelatedTime OPTIONAL, IN const KSRESOLUTION *Resolution OPTIONAL, IN ULONG Flags)
Definition: clocks.c:446
#define KSSTRING_Allocator
Definition: ks.h:50
#define IOCTL_KS_DISABLE_EVENT
Definition: ks.h:133
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
NTSTATUS NTAPI IKsPin_PinDataFormatPropertyHandler(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data)
Definition: pin.c:410
KSPIN_MEDIUM Medium
Definition: ks.h:2602
NTSTATUS NTAPI IKsPin_PinPipeId(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data)
Definition: pin.c:243
NTSTATUS KspPropertyHandler(IN PIRP Irp, IN ULONG PropertySetsCount, IN const KSPROPERTY_SET *PropertySet, IN PFNKSALLOCATOR Allocator OPTIONAL, IN ULONG PropertyItemSize OPTIONAL)
Definition: property.c:138
_In_ PKSPIN_CONNECT Connect
Definition: ks.h:4536
NTSTATUS NTAPI IKsPin_DispatchCreateClock(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: pin.c:2175
_In_ PIRP _In_ PDEVICE_OBJECT Device
Definition: fatprocs.h:2020
KSDDKAPI NTSTATUS NTAPI KsDispatchQuerySecurity(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:22
VOID NTAPI KsPinAttemptProcessing(IN PKSPIN Pin, IN BOOLEAN Asynchronous)
Definition: pin.c:993
_In_ ULONG Mode
Definition: hubbusif.h:303
ULONG FrameSize
Definition: pin.c:70
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:225
ULONG NTAPI IKsPin_fnRelease(IKsPin *iface)
Definition: pin.c:527
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
NTSTATUS NTAPI IKsPin_fnAttemptUnbypass(IN IKsPin *iface)
Definition: pin.c:664
LONG ref
Definition: pin.c:39
KMUTEX ProcessingMutex
Definition: pin.c:42
KSDDKAPI NTSTATUS NTAPI KsStreamPointerClone(IN PKSSTREAM_POINTER StreamPointer, IN PFNKSSTREAMPOINTER CancelCallback OPTIONAL, IN ULONG ContextSize, OUT PKSSTREAM_POINTER *CloneStreamPointer)
Definition: pin.c:1545
_In_ PIRP Irp
Definition: csq.h:116
_In_ LARGE_INTEGER DueTime
Definition: kefuncs.h:524
IUnknown * PUNKNOWN
Definition: com_apitest.h:45
PKSGATE NTAPI KsPinGetAndGate(IN PKSPIN Pin)
Definition: pin.c:980
#define IOCTL_KS_READ_STREAM
Definition: ks.h:142
PKSISTREAM_POINTER ClonedStreamPointer
Definition: pin.c:52
struct KSIOBJECT_HEADER * PKSIOBJECT_HEADER
Definition: pin.c:31
KSPROPERTY_SET PinPropertySet[]
Definition: pin.c:95
REFERENCE_TIME AvgTimePerFrame
Definition: bdamedia.h:340
PVOID AllocateItem(IN POOL_TYPE PoolType, IN SIZE_T NumberOfBytes)
Definition: misc.c:30
KSDDKAPI NTSTATUS NTAPI KsProbeStreamIrp(IN PIRP Irp, IN ULONG ProbeFlags, IN ULONG HeaderSize)
Definition: irp.c:647
KSBASIC_HEADER BasicHeader
Definition: pin.c:33
LONG NTSTATUS
Definition: precomp.h:26
ULONG MapRegisters
Definition: pin.c:73
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
KSDDKAPI BOOLEAN NTAPI KsDispatchFastIoDeviceControlFailure(IN PFILE_OBJECT FileObject, IN BOOLEAN Wait, IN PVOID InputBuffer OPTIONAL, IN ULONG InputBufferLength, OUT PVOID OutputBuffer OPTIONAL, IN ULONG OutputBufferLength, IN ULONG IoControlCode, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
Definition: irp.c:1218
#define STATUS_INVALID_DEVICE_REQUEST
Definition: udferr_usr.h:138
KSDDKAPI NTSTATUS NTAPI KsStreamPointerAdvance(IN PKSSTREAM_POINTER StreamPointer)
Definition: pin.c:1688
KSDDKAPI VOID NTAPI KsAcquireControl(IN PVOID Object)
Definition: api.c:1587
KPROCESSOR_MODE NTAPI ExGetPreviousMode(VOID)
Definition: sysinfo.c:3066
PVOID Data
Definition: pin.c:24
PKSPIN NTAPI KsPinGetNextSiblingPin(IN PKSPIN Pin)
Definition: pin.c:1086
VOID NTAPI ObDereferenceObject(IN PVOID Object)
Definition: obref.c:375
_Must_inspect_result_ _In_ FLT_CONTEXT_TYPE _In_ SIZE_T ContextSize
Definition: fltkernel.h:1444
VOID NTAPI KsPinSetPinClockTime(IN PKSPIN Pin, IN LONGLONG Time)
Definition: pin.c:1244
_In_ PVOID Parameter
Definition: ldrtypes.h:241
PFNKSPINPOWER Wake
Definition: pin.c:57
const GUID KSPROPSETID_Stream
Definition: pin.c:114
BDA_TRANSPORT_INFO BdaTransportInfo
Definition: bdamedia.h:345
NTSTATUS NTAPI KspMethodHandlerWithAllocator(IN PIRP Irp, IN ULONG MethodSetsCount, IN const KSMETHOD_SET *MethodSet, IN PFNKSALLOCATOR Allocator OPTIONAL, IN ULONG MethodItemSize OPTIONAL)
Definition: methods.c:99
struct KSSTREAM_HEADER * PKSSTREAM_HEADER
#define MmGetSystemAddressForMdlSafe(_Mdl, _Priority)
LONG NTAPI KeReleaseMutex(IN PKMUTEX Mutex, IN BOOLEAN Wait)
Definition: mutex.c:189
void DbgBreakPoint()
Definition: mach.c:553
NTSTATUS NTAPI KsPinSubmitFrame(IN PKSPIN Pin, IN PVOID Data OPTIONAL, IN ULONG Size OPTIONAL, IN PKSSTREAM_HEADER StreamHeader OPTIONAL, IN PVOID Context OPTIONAL)
Definition: pin.c:1256
NTSTATUS KspEnableEvent(IN PIRP Irp, IN ULONG EventSetsCount, IN const KSEVENT_SET *EventSet, IN OUT PLIST_ENTRY EventsList OPTIONAL, IN KSEVENTS_LOCKTYPE EventsFlags OPTIONAL, IN PVOID EventsLock OPTIONAL, IN PFNKSALLOCATOR Allocator OPTIONAL, IN ULONG EventItemSize OPTIONAL)
Definition: event.c:87
NTSTATUS NTAPI KeWaitForSingleObject(IN PVOID Object, IN KWAIT_REASON WaitReason, IN KPROCESSOR_MODE WaitMode, IN BOOLEAN Alertable, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: wait.c:416
KSSTREAM_POINTER StreamPointer
Definition: pin.c:27
#define KSDDKAPI
Definition: ks.h:40
VOID NTAPI IKsPin_PinCentricWorker(IN PVOID Parameter)
Definition: pin.c:1818
#define KSPROPERTY_TYPE_GET
Definition: dmksctrl.h:42
VOID NTAPI KsReleaseControl(IN PVOID Object)
Definition: api.c:1604
KSDDKAPI NTSTATUS NTAPI KsDisableEvent(IN PIRP Irp, IN OUT PLIST_ENTRY EventsList, IN KSEVENTS_LOCKTYPE EventsFlags, IN PVOID EventsLock)
Definition: event.c:469
KSDDKAPI PIRP NTAPI KsStreamPointerGetIrp(IN PKSSTREAM_POINTER StreamPointer, OUT PBOOLEAN FirstFrameInIrp OPTIONAL, OUT PBOOLEAN LastFrameInIrp OPTIONAL)
Definition: pin.c:1715
KSDDKAPI VOID NTAPI KsFreeObjectHeader(IN PVOID Header)
Definition: api.c:720
#define KSSTRING_Clock
Definition: ks.h:49
#define RtlMoveMemory(Destination, Source, Length)
Definition: typedefs.h:263
static VOID Wake(USHORT Csn)
Definition: hardware.c:100
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:64
WORK_QUEUE_ITEM PinWorkQueueItem
Definition: pin.c:68
#define IsEqualGUIDAligned(guid1, guid2)
Definition: wdm.template.h:233
uint32_t ULONG_PTR
Definition: typedefs.h:63
#define STATUS_INVALID_DEVICE_STATE
Definition: udferr_usr.h:178
KSPROCESSPIN ProcessPin
Definition: pin.c:36
KSDDKAPI PIRP NTAPI KsRemoveIrpFromCancelableQueue(IN OUT PLIST_ENTRY QueueHead, IN PKSPIN_LOCK SpinLock, IN KSLIST_ENTRY_LOCATION ListLocation, IN KSIRP_REMOVAL_OPERATION RemovalOperation)
Definition: irp.c:1375
KSCLOCK_FUNCTIONTABLE ClockTable
Definition: pin.c:62
KSDDKAPI ULONG NTAPI KsIncrementCountedWorker(IN PKSWORKER Worker)
Definition: worker.c:222
_In_ NDIS_HANDLE _In_ PNDIS_REQUEST Request
Definition: ndis.h:5173
KSDDKAPI NTSTATUS NTAPI KsSynchronousIoControlDevice(IN PFILE_OBJECT FileObject, IN KPROCESSOR_MODE RequestorMode, IN ULONG IoControl, IN PVOID InBuffer, IN ULONG InSize, OUT PVOID OutBuffer, IN ULONG OutSize, OUT PULONG BytesReturned)
Definition: api.c:1099
NTSTATUS NTAPI IKsPin_fnResetTransportConfig(IN IKsPin *iface, OUT IKsTransport **OutTransportIn, OUT IKsTransport **OutTransportOut)
Definition: pin.c:626
__GNU_EXTENSION typedef __int64 * PLONGLONG
Definition: ntbasedef.h:389
VOID FreeItem(IN PVOID Item)
Definition: misc.c:43
NTSTATUS NTAPI ObReferenceObjectByHandle(IN HANDLE Handle, IN ACCESS_MASK DesiredAccess, IN POBJECT_TYPE ObjectType, IN KPROCESSOR_MODE AccessMode, OUT PVOID *Object, OUT POBJECT_HANDLE_INFORMATION HandleInformation OPTIONAL)
Definition: obref.c:496
KSDDKAPI PKSSTREAM_POINTER NTAPI KsPinGetTrailingEdgeStreamPointer(IN PKSPIN Pin, IN KSSTREAM_POINTER_STATE State)
Definition: pin.c:1422
long __cdecl _InterlockedIncrement(_Interlocked_operand_ long volatile *_Addend)
_In_ SYSTEM_POWER_STATE _In_ ULONG _In_ BOOLEAN Asynchronous
Definition: ntpoapi.h:303
ULONG PinId
Definition: ks.h:2603
static IKsPinVtbl vt_IKsPin
Definition: pin.c:691
NTSTATUS(* NTAPI)(IN PFILE_FULL_EA_INFORMATION EaBuffer, IN ULONG EaLength, OUT PULONG ErrorOffset)
Definition: IoEaTest.cpp:117
LIST_ENTRY Entry
Definition: pin.c:37
enum KSSTATE * PKSSTATE
KSPIN_LOCK Lock
Definition: pin.c:28
Definition: Header.h:8
unsigned int BOOL
Definition: ntddk_ex.h:94
long LONG
Definition: pedump.c:60
VOID NTAPI KsPinAttachAndGate(IN PKSPIN Pin, IN PKSGATE AndGate OPTIONAL)
Definition: pin.c:946
NTSTATUS NTAPI IKsPin_fnConnect(IN IKsPin *iface, IN IKsTransport *TransportIn, OUT IKsTransport **OutTransportIn, OUT IKsTransport **OutTransportOut, IN KSPIN_DATAFLOW DataFlow)
Definition: pin.c:567
_Must_inspect_result_ _In_opt_ PFLT_FILTER Filter
Definition: fltkernel.h:1802
VOID NTAPI KsPinGetCopyRelationships(IN PKSPIN Pin, OUT PKSPIN *CopySource, OUT PKSPIN *DelegateBranch)
Definition: pin.c:1073
NTSTATUS NTAPI IKsReferenceClock_fnGetResolution(IKsReferenceClock *iface, OUT PKSRESOLUTION Resolution)
Definition: pin.c:847
PRKMUTEX ControlMutex
Definition: kstypes.h:58
const GUID KSPROPSETID_Clock
Definition: pin.c:115
ULONG NTAPI IKsReferenceClock_fnAddRef(IKsReferenceClock *iface)
Definition: pin.c:729
FORCEINLINE VOID KeInitializeSpinLock(_Out_ PKSPIN_LOCK SpinLock)
Definition: kefuncs.h:251
PVOID DeviceExtension
Definition: env_spec_w32.h:418
unsigned char BOOLEAN
NTSTATUS NTAPI KsPinGetConnectedPinInterface(IN PKSPIN Pin, IN const GUID *InterfaceId, OUT PVOID *Interface)
Definition: pin.c:1059
smooth NULL
Definition: ftsmooth.c:416
const GUID KSPROPSETID_Connection
Definition: pin.c:113
_At_(*)(_In_ PWSK_CLIENT Client, _In_opt_ PUNICODE_STRING NodeName, _In_opt_ PUNICODE_STRING ServiceName, _In_opt_ ULONG NameSpace, _In_opt_ GUID *Provider, _In_opt_ PADDRINFOEXW Hints, _Outptr_ PADDRINFOEXW *Result, _In_opt_ PEPROCESS OwningProcess, _In_opt_ PETHREAD OwningThread, _Inout_ PIRP Irp Result)(Mem)) NTSTATUS(WSKAPI *PFN_WSK_GET_ADDRESS_INFO
Definition: wsk.h:426
void DPRINT(...)
Definition: polytest.cpp:61
ULONG NTAPI IKsReferenceClock_fnRelease(IKsReferenceClock *iface)
Definition: pin.c:739
KSDDKAPI NTSTATUS NTAPI KsPinSubmitFrameMdl(IN PKSPIN Pin, IN PMDL Mdl OPTIONAL, IN PKSSTREAM_HEADER StreamHeader OPTIONAL, IN PVOID Context OPTIONAL)
Definition: pin.c:1273
PKSWORKER PinWorker
Definition: pin.c:67
void * PVOID
Definition: retypes.h:9
ULONG Offset
Definition: pin.c:25
_Inout_ PFILE_OBJECT FileObject
Definition: cdprocs.h:593
NTSTATUS KspCreatePin(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp, IN PKSDEVICE KsDevice, IN IKsFilterFactory *FilterFactory, IN IKsFilter *Filter, IN PKSPIN_CONNECT Connect, IN KSPIN_DESCRIPTOR_EX *Descriptor)
Definition: pin.c:2283
KSDDKAPI NTSTATUS NTAPI KsCreateDefaultClock(IN PIRP Irp, IN PKSDEFAULTCLOCK DefaultClock)
Definition: clocks.c:383
#define IOCTL_KS_METHOD
Definition: ks.h:136
NTSTATUS NTAPI IKsPin_PinStatePropertyHandler(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data)
Definition: pin.c:255
KSPIN_DATAFLOW
Definition: ks.h:1248
PFLT_MESSAGE_WAITER_QUEUE CONTAINING_RECORD(Csq, DEVICE_EXTENSION, IrpQueue)) -> WaiterQ.mLock) _IRQL_raises_(DISPATCH_LEVEL) VOID NTAPI FltpAcquireMessageWaiterLock(_In_ PIO_CSQ Csq, _Out_ PKIRQL Irql)
Definition: Messaging.c:560
const GUID KSDATAFORMAT_SUBTYPE_BDA_MPEG2_TRANSPORT
Definition: connectivity.c:28
PVOID ObjectType
Definition: kstypes.h:30
DWORD Interval
Definition: netstat.c:33
int64_t LONGLONG
Definition: typedefs.h:66
NTSTATUS NTAPI IKsPin_DispatchKsStream(PDEVICE_OBJECT DeviceObject, PIRP Irp, IKsPinImpl *This)
Definition: pin.c:1851
_In_ HANDLE Handle
Definition: extypes.h:390
static KSDISPATCH_TABLE PinDispatchTable
Definition: pin.c:2268
IN PVOID IN PVOID IN USHORT IN USHORT IN PINTERFACE Interface
Definition: pci.h:359
#define STATUS_NOT_FOUND
Definition: shellext.h:67
KSDDKAPI PMDL NTAPI KsStreamPointerGetMdl(IN PKSSTREAM_POINTER StreamPointer)
Definition: pin.c:1702
BOOLEAN NTAPI KeCancelTimer(IN OUT PKTIMER Timer)
Definition: timerobj.c:206
KSDDKAPI ULONG NTAPI KsDecrementCountedWorker(IN PKSWORKER Worker)
Definition: worker.c:198
KSDDKAPI NTSTATUS NTAPI KsDispatchInvalidDeviceRequest(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: irp.c:1156
NTSTATUS NTAPI IKsPin_DispatchCreateAllocator(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: pin.c:2162
#define ExInitializeWorkItem(Item, Routine, Context)
Definition: exfuncs.h:265
ULONG NTAPI IKsPin_fnAddRef(IKsPin *iface)
Definition: pin.c:517
VOID IKsFilter_RemovePin(PKSFILTER Filter, PKSPIN Pin)
Definition: filter.c:1378
if(!(yy_init))
Definition: macro.lex.yy.c:714
IN PDCB IN VBO IN ULONG IN BOOLEAN Pin
Definition: fatprocs.h:415
KSDDKAPI BOOLEAN NTAPI KsProcessPinUpdate(IN PKSPROCESSPIN ProcessPin)
Definition: pin.c:1289
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
uint64_t ULONGLONG
Definition: typedefs.h:65
const GUID IID_IUnknown
KSSTREAM_POINTER_STATE
Definition: ks.h:3023
KSDDKAPI VOID NTAPI KsStreamPointerCancelTimeout(IN PKSSTREAM_POINTER StreamPointer)
Definition: pin.c:1758
static const UCHAR Index[8]
Definition: usbohci.c:18
NTSTATUS NTAPI IKsPin_fnSetTransportConfig(IN IKsPin *iface, IN struct KSPTRANSPORTCONFIG const *TransportConfig, OUT IKsTransport **OutTransportIn, OUT IKsTransport **OutTransportOut)
Definition: pin.c:614
NTSTATUS NTAPI IKsPin_DispatchDeviceIoControl(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: pin.c:1988
NTSYSAPI VOID NTAPI RtlFreeUnicodeString(PUNICODE_STRING UnicodeString)
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
CCHAR KPROCESSOR_MODE
Definition: ketypes.h:7
NTSTATUS NTAPI IKsPin_fnGetTransportConfig(IN IKsPin *iface, IN struct KSPTRANSPORTCONFIG *TransportConfig, OUT IKsTransport **OutTransportIn, OUT IKsTransport **OutTransportOut)
Definition: pin.c:602
* PFILE_OBJECT
Definition: iotypes.h:1955
NTSTATUS NTAPI CompleteRequest(IN PIRP Irp, IN NTSTATUS Status, IN ULONG_PTR Information)
Definition: dispatch.c:19
KTIMER Timer
Definition: pin.c:20
KSDDKAPI NTSTATUS NTAPI KsRegisterCountedWorker(IN WORK_QUEUE_TYPE WorkQueueType, IN PWORK_QUEUE_ITEM CountedWorkItem, OUT PKSWORKER *Worker)
Definition: worker.c:166
PFNKSPINHANDSHAKE Handshake
Definition: pin.c:58
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
KDPC TimerDpc
Definition: pin.c:21
KSDDKAPI VOID NTAPI KsStreamPointerScheduleTimeout(IN PKSSTREAM_POINTER StreamPointer, IN PFNKSSTREAMPOINTER Callback, IN ULONGLONG Interval)
Definition: pin.c:1730
NTSTATUS NTAPI IKsPin_fnClientSetDeviceState(IN IKsPin *iface, IN KSSTATE StateIn, IN KSSTATE StateOut)
Definition: pin.c:682
char * PBOOLEAN
Definition: retypes.h:11
VOID IKsFilter_AddPin(PKSFILTER Filter, PKSPIN Pin)
Definition: filter.c:1337
VOID NTAPI KeInitializeMutex(IN PKMUTEX Mutex, IN ULONG Level)
Definition: mutex.c:67
struct _KSISTREAM_POINTER * Next
Definition: pin.c:22
VOID NTAPI KsPinRegisterHandshakeCallback(IN PKSPIN Pin, IN PFNKSPINHANDSHAKE Handshake)
Definition: pin.c:1149
static const WCHAR L[]
Definition: oid.c:1250
ULONG NumFrames
Definition: pin.c:71
#define InterlockedDecrement
Definition: armddk.h:52
#define IOCTL_KS_ENABLE_EVENT
Definition: ks.h:130
Definition: ketypes.h:687
KSISTREAM_POINTER LeadingEdgeStreamPointer
Definition: pin.c:53
NTSTATUS NTAPI KsPinGetConnectedFilterInterface(IN PKSPIN Pin, IN const GUID *InterfaceId, OUT PVOID *Interface)
Definition: pin.c:1021
Definition: arc.h:85
PVOID *typedef PHANDLE
Definition: ntsecpkg.h:414
NTSTATUS NTAPI IKsPin_PinAllocatorFramingPropertyHandler(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data)
Definition: pin.c:340
VOID NTAPI IKsPin_fnGenerateConnectionEvents(IN IKsPin *iface, IN ULONG EventMask)
Definition: pin.c:673
PKSPROCESSPIN NTAPI IKsPin_fnGetProcessPin(IN IKsPin *iface)
Definition: pin.c:646
Definition: typedefs.h:117
NTSYSAPI NTSTATUS WINAPI RtlStringFromGUID(REFGUID, PUNICODE_STRING)
KSDDKAPI PKSSTREAM_POINTER NTAPI KsPinGetFirstCloneStreamPointer(IN PKSPIN Pin)
Definition: pin.c:1776
IN PVOID IN PVOID IN USHORT IN USHORT Size
Definition: pci.h:359
#define SYNCHRONIZE
Definition: nt_native.h:61
#define PASSIVE_LEVEL
Definition: env_spec_w32.h:693
POBJECT_TYPE IoFileObjectType
Definition: iomgr.c:36
static IKsReferenceClockVtbl vt_ReferenceClock
Definition: pin.c:911
PKSPIN Pin
Definition: pin.c:23
NTSTATUS NTAPI IKsPin_fnSetDeviceState(IN IKsPin *iface, IN KSSTATE OldState, IN KSSTATE NewState, IN IKsTransport **OutTransport)
Definition: pin.c:580
struct tagKS_DATARANGE_BDA_TRANSPORT * PKS_DATARANGE_BDA_TRANSPORT
Status
Definition: gdiplustypes.h:24
_In_ DWORD Property
Definition: setupapi.h:1545
IN PDEVICE_OBJECT DeviceObject
Definition: fatprocs.h:1560
__drv_aliasesMem FORCEINLINE PIO_STACK_LOCATION IoGetCurrentIrpStackLocation(_In_ PIRP Irp)
Definition: iofuncs.h:2745
IKsReferenceClockVtbl * lpVtblReferenceClock
Definition: pin.c:64
KSDDKAPI PKSSTREAM_POINTER NTAPI KsPinGetLeadingEdgeStreamPointer(IN PKSPIN Pin, IN KSSTREAM_POINTER_STATE State)
Definition: pin.c:1385
PFILE_OBJECT FileObject
Definition: iotypes.h:2813
KEVENT FrameComplete
Definition: pin.c:69
BOOL OrGate
Definition: pin.c:46
#define KeInitializeEvent(pEvt, foo, foo2)
Definition: env_spec_w32.h:477
#define InterlockedIncrement
Definition: armddk.h:53
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:61
VOID NTAPI KsPinReleaseProcessingMutex(IN PKSPIN Pin)
Definition: pin.c:1196
KSSTATE
Definition: ks.h:1214
KSDDKAPI PVOID NTAPI KsGetNextSibling(IN PVOID Object)
Definition: api.c:1882
LONGLONG NTAPI IKsReferenceClock_fnGetCorrelatedPhysicalTime(IKsReferenceClock *iface, OUT PLONGLONG SystemTime)
Definition: pin.c:823
PKSIOBJECT_HEADER ObjectHeader
Definition: pin.c:35
KSDDKAPI BOOLEAN NTAPI KsDispatchFastReadFailure(IN PFILE_OBJECT FileObject, IN PLARGE_INTEGER FileOffset, IN ULONG Length, IN BOOLEAN Wait, IN ULONG LockKey, OUT PVOID Buffer, OUT PIO_STATUS_BLOCK IoStatus, IN PDEVICE_OBJECT DeviceObject)
Definition: irp.c:1238
PKSPIN NTAPI IKsPin_fnGetStruct(IN IKsPin *iface)
Definition: pin.c:637
KSPIN Pin
Definition: pin.c:34
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
NTSTATUS NTAPI IKsReferenceClock_fnGetState(IKsReferenceClock *iface, OUT PKSSTATE State)
Definition: pin.c:881
ULONG KSPIN_LOCK
Definition: env_spec_w32.h:72
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:254
_In_ FILTER_INFORMATION_CLASS _In_ ULONG _Out_ PULONG BytesReturned
Definition: fltkernel.h:1716
KSDDKAPI VOID NTAPI KsStreamPointerUnlock(IN PKSSTREAM_POINTER StreamPointer, IN BOOLEAN Eject)
Definition: pin.c:1463
ULONG ulcbPhyiscalFrameAlignment
Definition: bdamedia.h:339
KSDDKAPI VOID NTAPI KsAddIrpToCancelableQueue(IN OUT PLIST_ENTRY QueueHead, IN PKSPIN_LOCK SpinLock, IN PIRP Irp, IN KSLIST_ENTRY_LOCATION ListLocation, IN PDRIVER_CANCEL DriverCancel OPTIONAL)
Definition: irp.c:1633
struct _KSPROCESSPIN_INDEXENTRY * PKSPROCESSPIN_INDEXENTRY
Definition: ks.h:3028
NTSTATUS NTAPI KsPinGetReferenceClockInterface(IN PKSPIN Pin, OUT PIKSREFERENCECLOCK *Interface)
Definition: pin.c:1111
NTSTATUS NTAPI IKsPin_fnTransferKsIrp(IN IKsPin *iface, IN PIRP Irp, IN IKsTransport **OutTransport)
Definition: pin.c:545
#define KSSTRING_TopologyNode
Definition: ks.h:52
VOID NTAPI IKsPin_fnSetResetState(IN IKsPin *iface, IN KSRESET ResetState, OUT IKsTransport **OutTransportOut)
Definition: pin.c:592
LIST_ENTRY IrpList
Definition: pin.c:48
#define DPRINT1
Definition: precomp.h:8
NTSTATUS NTAPI IKsReferenceClock_fnQueryInterface(IKsReferenceClock *iface, IN REFIID refiid, OUT PVOID *Output)
Definition: pin.c:717
KSDDKAPI NTSTATUS NTAPI KsStreamPointerAdvanceOffsets(IN PKSSTREAM_POINTER StreamPointer, IN ULONG InUsed, IN ULONG OutUsed, IN BOOLEAN Eject)
Definition: pin.c:1628
KSDDKAPI NTSTATUS NTAPI KsStreamPointerSetStatusCode(IN PKSSTREAM_POINTER StreamPointer, IN NTSTATUS Status)
Definition: pin.c:1436
KSISTREAM_POINTER TrailingStreamPointer
Definition: pin.c:54
NTSTATUS NTAPI IKsPin_DispatchCreateNode(IN PDEVICE_OBJECT DeviceObject, IN PIRP Irp)
Definition: pin.c:2257
PDEVICE_OBJECT NTAPI KsPinGetConnectedPinDeviceObject(IN PKSPIN Pin)
Definition: pin.c:1035
KSDDKAPI PKSPIN NTAPI KsGetPinFromIrp(IN PIRP Irp)
Definition: pin.c:1211
#define OUT
Definition: typedefs.h:39
static BYTE Resolution
Definition: mouse.c:35
VOID NTAPI IKsPin_fnDiscardKsIrp(IN IKsPin *iface, IN PIRP Irp, IN IKsTransport **OutTransport)
Definition: pin.c:556
struct _KSISTREAM_POINTER * PKSISTREAM_POINTER
DEFINE_KSPROPERTY_CONNECTIONSET(PinConnectionSet, IKsPin_PinStatePropertyHandler, IKsPin_PinDataFormatPropertyHandler, IKsPin_PinAllocatorFramingPropertyHandler)
KSDDKAPI NTSTATUS NTAPI KsAllocateObjectHeader(OUT KSOBJECT_HEADER *Header, IN ULONG ItemsCount, IN PKSOBJECT_CREATE_ITEM ItemsList OPTIONAL, IN PIRP Irp, IN KSDISPATCH_TABLE *Table)
Definition: api.c:610
KSDDKAPI PKSSTREAM_POINTER NTAPI KsStreamPointerGetNextClone(IN PKSSTREAM_POINTER StreamPointer)
Definition: pin.c:1798
PFILE_OBJECT NTAPI KsPinGetConnectedPinFileObject(IN PKSPIN Pin)
Definition: pin.c:1047
#define STATUS_NOT_SUPPORTED
Definition: ntstatus.h:409
unsigned int ULONG
Definition: retypes.h:1
#define IO_NO_INCREMENT
Definition: iotypes.h:566
struct _KSISTREAM_POINTER KSISTREAM_POINTER
KSDDKAPI VOID NTAPI KsStreamPointerAdvanceOffsetsAndUnlock(IN PKSSTREAM_POINTER StreamPointer, IN ULONG InUsed, IN ULONG OutUsed, IN BOOLEAN Eject)
Definition: pin.c:1480
#define DIRECTORY_QUERY
Definition: nt_native.h:1254
PKSGATE AttachedGate
Definition: pin.c:45
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define UNIMPLEMENTED
Definition: debug.h:114
#define RtlZeroMemory(Destination, Length)
Definition: typedefs.h:261
KSPRIORITY Priority
Definition: ks.h:2605
#define ULONG_PTR
Definition: config.h:101
NTSTATUS NTAPI IKsPin_fnAttemptBypass(IN IKsPin *iface)
Definition: pin.c:655
struct KSIDENTIFIER * PKSPROPERTY
KSDDKAPI NTSTATUS NTAPI KsStreamPointerLock(IN PKSSTREAM_POINTER StreamPointer)
Definition: pin.c:1450
VOID NTAPI KsPinRegisterPowerCallbacks(IN PKSPIN Pin, IN PFNKSPINPOWER Sleep OPTIONAL, IN PFNKSPINPOWER Wake OPTIONAL)
Definition: pin.c:1179
LONGLONG NTAPI IKsReferenceClock_fnGetPhysicalTime(IKsReferenceClock *iface)
Definition: pin.c:773
PFNKSPINFRAMERETURN FrameReturn
Definition: pin.c:59
DEFINE_KSPROPERTY_STREAMSET(PinStreamSet, IKsPin_PinStreamAllocator, IKsPin_PinMasterClock, IKsPin_PinPipeId)
struct _NAMED_PIPE_CREATE_PARAMETERS * Parameters
Definition: iotypes.h:2772
NTSTATUS NTAPI IKsPin_PinStreamAllocator(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data)
Definition: pin.c:119
return STATUS_SUCCESS
Definition: btrfs.c:2966
DataFlow
IoMarkIrpPending(Irp)
signed int * PLONG
Definition: retypes.h:5
#define KSPROPERTY_TYPE_SET
Definition: dmksctrl.h:43
LPFNPSPCALLBACK Callback
Definition: desk.c:111
struct _BEEP_DEVICE_EXTENSION * PDEVICE_EXTENSION
NTSTATUS NTAPI IKsPin_PinMasterClock(IN PIRP Irp, IN PKSIDENTIFIER Request, IN OUT PVOID Data)
Definition: pin.c:130
PFILE_OBJECT FileObject
Definition: pin.c:43
static PLARGE_INTEGER Time
Definition: time.c:105
volatile LONG IrpCount
Definition: pin.c:50
PFNKSSTREAMPOINTER Callback
Definition: pin.c:18
KSDDKAPI VOID NTAPI KsFreeObjectBag(IN KSOBJECT_BAG ObjectBag)
Definition: bag.c:308
LONGLONG NTAPI IKsReferenceClock_fnGetTime(IKsReferenceClock *iface)
Definition: pin.c:749
LONGLONG NTAPI IKsReferenceClock_fnGetCorrelatedTime(IKsReferenceClock *iface, OUT PLONGLONG SystemTime)
Definition: pin.c:798
LONGLONG QuadPart
Definition: typedefs.h:112
KSDATAFORMAT * PKSDATAFORMAT
KSRESET
Definition: ks.h:1226
#define STATUS_DEVICE_NOT_READY
Definition: shellext.h:65
IKsFilter * Filter
Definition: pin.c:41
PFNKSPINIRPCOMPLETION IrpCompletion
Definition: pin.c:60
PDMA_ADAPTER Dma
Definition: pin.c:72
_In_ PSTORAGE_PROPERTY_ID _Outptr_ PSTORAGE_DESCRIPTOR_HEADER * Descriptor
Definition: classpnp.h:966
PULONG MinorVersion OPTIONAL
Definition: CrossNt.h:68
KSPIN_LOCK IrpListLock
Definition: pin.c:49