reactos/drivers/wdm/audio/legacy/wdmaud/control.c

   1 /*
   2  * COPYRIGHT:       See COPYING in the top level directory
   3  * PROJECT:         ReactOS Kernel Streaming
   4  * FILE:            drivers/wdm/audio/legacy/wdmaud/deviface.c
   5  * PURPOSE:         System Audio graph builder
   6  * PROGRAMMER:      Andrew Greenwood
   7  *                  Johannes Anderwald
   8  */
   9 #include "wdmaud.h"
  10
  11 const GUID KSPROPSETID_Pin                     = {0x8C134960L, 0x51AD, 0x11CF, {0x87, 0x8A, 0x94, 0xF8, 0x01, 0xC1, 0x00, 0x00}};
  12 const GUID KSPROPSETID_Connection               = {0x1D58C920L, 0xAC9B, 0x11CF, {0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00}};
  13 const GUID KSPROPSETID_Sysaudio                 = {0xCBE3FAA0L, 0xCC75, 0x11D0, {0xB4, 0x65, 0x00, 0x00, 0x1A, 0x18, 0x18, 0xE6}};
  14 const GUID KSPROPSETID_General                  = {0x1464EDA5L, 0x6A8F, 0x11D1, {0x9A, 0xA7, 0x00, 0xA0, 0xC9, 0x22, 0x31, 0x96}};
  15 const GUID KSINTERFACESETID_Standard            = {0x1A8766A0L, 0x62CE, 0x11CF, {0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00}};
  16 const GUID KSMEDIUMSETID_Standard               = {0x4747B320L, 0x62CE, 0x11CF, {0xA5, 0xD6, 0x28, 0xDB, 0x04, 0xC1, 0x00, 0x00}};
  17 const GUID KSDATAFORMAT_TYPE_AUDIO              = {0x73647561L, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}};
  18 const GUID KSDATAFORMAT_SUBTYPE_PCM             = {0x00000001L, 0x0000, 0x0010, {0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71}};
  19 const GUID KSDATAFORMAT_SPECIFIER_WAVEFORMATEX  = {0x05589f81L, 0xc356, 0x11ce, {0xbf, 0x01, 0x00, 0xaa, 0x00, 0x55, 0x59, 0x5a}};
  20
  21 NTSTATUS
  22 SetIrpIoStatus(
  23     IN PIRP Irp,
  24     IN NTSTATUS Status,
  25     IN ULONG Length)
  26 {
  27     Irp->IoStatus.Information = Length;
  28     Irp->IoStatus.Status = Status;
  29     IoCompleteRequest(Irp, IO_NO_INCREMENT);
  30     return Status;
  31
  32 }
  33
  34 NTSTATUS
  35 GetFilterIdAndPinId(
  36     IN  PDEVICE_OBJECT DeviceObject,
  37     IN  PWDMAUD_DEVICE_INFO DeviceInfo,
  38     IN  PWDMAUD_CLIENT ClientInfo,
  39     IN PULONG FilterId,
  40     IN PULONG PinId)
  41 {
  42     KSP_PIN Pin;
  43     ULONG Count, BytesReturned, Index, SubIndex, Result, NumPins;
  44     NTSTATUS Status;
  45     KSPIN_COMMUNICATION Communication;
  46     KSPIN_DATAFLOW DataFlow;
  47
  48     if (DeviceInfo->DeviceType != WAVE_OUT_DEVICE_TYPE && DeviceInfo->DeviceType != WAVE_IN_DEVICE_TYPE)
  49     {
  50         DPRINT1("FIXME: Unsupported device type %x\n", DeviceInfo->DeviceType);
  51         return STATUS_UNSUCCESSFUL;
  52     }
  53
  54     Pin.Property.Set = KSPROPSETID_Sysaudio;
  55     Pin.Property.Id = KSPROPERTY_SYSAUDIO_DEVICE_COUNT;
  56     Pin.Property.Flags = KSPROPERTY_TYPE_GET;
  57
  58     Status = KsSynchronousIoControlDevice(ClientInfo->FileObject, KernelMode, IOCTL_KS_PROPERTY, (PVOID)&Pin, sizeof(KSPROPERTY), (PVOID)&Count, sizeof(ULONG), &BytesReturned);
  59     if (!NT_SUCCESS(Status))
  60         return STATUS_UNSUCCESSFUL;
  61
  62     Result = 0;
  63     for(Index = 0; Index < Count; Index++)
  64     {
  65         /* query number of pins */
  66         Pin.Reserved = Index; // see sysaudio
  67         Pin.Property.Flags = KSPROPERTY_TYPE_GET;
  68         Pin.Property.Set = KSPROPSETID_Pin;
  69         Pin.Property.Id = KSPROPERTY_PIN_CTYPES;
  70         Pin.PinId = 0;
  71
  72         Status = KsSynchronousIoControlDevice(ClientInfo->FileObject, KernelMode, IOCTL_KS_PROPERTY, (PVOID)&Pin, sizeof(KSP_PIN), (PVOID)&NumPins, sizeof(ULONG), &BytesReturned);
  73         if (NT_SUCCESS(Status))
  74         {
  75             /* enumerate now all pins */
  76             for(SubIndex = 0; SubIndex < NumPins; SubIndex++)
  77             {
  78                 Pin.PinId = SubIndex;
  79                 Pin.Property.Id = KSPROPERTY_PIN_COMMUNICATION;
  80                 Communication = KSPIN_COMMUNICATION_NONE;
  81
  82                 /* get pin communication type */
  83                 KsSynchronousIoControlDevice(ClientInfo->FileObject, KernelMode, IOCTL_KS_PROPERTY, (PVOID)&Pin, sizeof(KSP_PIN), (PVOID)&Communication, sizeof(KSPIN_COMMUNICATION), &BytesReturned);
  84
  85                 Pin.Property.Id = KSPROPERTY_PIN_DATAFLOW;
  86                 DataFlow = 0;
  87
  88                 /* get pin dataflow type */
  89                 KsSynchronousIoControlDevice(ClientInfo->FileObject, KernelMode, IOCTL_KS_PROPERTY, (PVOID)&Pin, sizeof(KSP_PIN), (PVOID)&DataFlow, sizeof(KSPIN_DATAFLOW), &BytesReturned);
  90
  91                 if (DeviceInfo->DeviceType == WAVE_OUT_DEVICE_TYPE)
  92                 {
  93                     if (Communication == KSPIN_COMMUNICATION_SINK && DataFlow == KSPIN_DATAFLOW_IN)
  94                     {
  95                         if(DeviceInfo->DeviceIndex == Result)
  96                         {
  97                             /* found the index */
  98                             *FilterId = Index;
  99                             *PinId = SubIndex;
 100                             return STATUS_SUCCESS;
 101                         }
 102
 103                         Result++;
 104                     }
 105                 }
 106                 else if (DeviceInfo->DeviceType == WAVE_IN_DEVICE_TYPE)
 107                 {
 108                     if (Communication == KSPIN_COMMUNICATION_SINK && DataFlow == KSPIN_DATAFLOW_OUT)
 109                     {
 110                         if(DeviceInfo->DeviceIndex == Result)
 111                         {
 112                             /* found the index */
 113                             *FilterId = Index;
 114                             *PinId = SubIndex;
 115                             return STATUS_SUCCESS;
 116                         }
 117                         Result++;
 118                     }
 119                 }
 120             }
 121         }
 122     }
 123
 124     return STATUS_UNSUCCESSFUL;
 125 }
 126
 127 NTSTATUS
 128 WdmAudControlOpen(
 129     IN  PDEVICE_OBJECT DeviceObject,
 130     IN  PIRP Irp,
 131     IN  PWDMAUD_DEVICE_INFO DeviceInfo,
 132     IN  PWDMAUD_CLIENT ClientInfo)
 133 {
 134     PSYSAUDIO_INSTANCE_INFO InstanceInfo;
 135     ULONG BytesReturned;
 136     NTSTATUS Status;
 137     ACCESS_MASK DesiredAccess = 0;
 138     HANDLE PinHandle;
 139     KSPIN_CONNECT * PinConnect;
 140     ULONG Length, Index;
 141     KSDATAFORMAT_WAVEFORMATEX * DataFormat;
 142     ULONG FilterId;
 143     ULONG PinId;
 144
 145     if (DeviceInfo->DeviceType != WAVE_OUT_DEVICE_TYPE && DeviceInfo->DeviceType != WAVE_IN_DEVICE_TYPE)
 146     {
 147         DPRINT1("FIXME: only waveout / wavein devices are supported\n");
 148         return SetIrpIoStatus(Irp, STATUS_UNSUCCESSFUL, 0);
 149     }
 150
 151     Status = GetFilterIdAndPinId(DeviceObject, DeviceInfo, ClientInfo, &FilterId, &PinId);
 152     if (!NT_SUCCESS(Status))
 153     {
 154         DPRINT1("Invalid device index %u\n", DeviceInfo->DeviceIndex);
 155         return SetIrpIoStatus(Irp, STATUS_UNSUCCESSFUL, 0);
 156     }
 157
 158     Length = sizeof(KSDATAFORMAT_WAVEFORMATEX) + sizeof(KSPIN_CONNECT) + sizeof(SYSAUDIO_INSTANCE_INFO);
 159     InstanceInfo = ExAllocatePool(NonPagedPool, Length);
 160     if (!InstanceInfo)
 161     {
 162         /* no memory */
 163         return SetIrpIoStatus(Irp, STATUS_NO_MEMORY, 0);
 164     }
 165
 166     InstanceInfo->Property.Set = KSPROPSETID_Sysaudio;
 167     InstanceInfo->Property.Id = KSPROPERTY_SYSAUDIO_INSTANCE_INFO;
 168     InstanceInfo->Property.Flags = KSPROPERTY_TYPE_SET;
 169     InstanceInfo->Flags = 0;
 170     InstanceInfo->DeviceNumber = FilterId;
 171
 172     Status = KsSynchronousIoControlDevice(ClientInfo->FileObject, KernelMode, IOCTL_KS_PROPERTY, (PVOID)InstanceInfo, sizeof(SYSAUDIO_INSTANCE_INFO), NULL, 0, &BytesReturned);
 173
 174     if (!NT_SUCCESS(Status))
 175     {
 176         /* failed to acquire audio device */
 177         DPRINT1("KsSynchronousIoControlDevice failed with %x\n", Status);
 178         ExFreePool(InstanceInfo);
 179         return SetIrpIoStatus(Irp, Status, 0);
 180     }
 181
 182     if (DeviceInfo->DeviceType == WAVE_IN_DEVICE_TYPE ||
 183         DeviceInfo->DeviceType == MIDI_IN_DEVICE_TYPE ||
 184         DeviceInfo->DeviceType == MIXER_DEVICE_TYPE)
 185     {
 186         DesiredAccess |= GENERIC_READ;
 187     }
 188
 189     if (DeviceInfo->DeviceType == WAVE_OUT_DEVICE_TYPE ||
 190         DeviceInfo->DeviceType == MIDI_OUT_DEVICE_TYPE ||
 191         DeviceInfo->DeviceType == AUX_DEVICE_TYPE ||
 192         DeviceInfo->DeviceType == MIXER_DEVICE_TYPE)
 193     {
 194         DesiredAccess |= GENERIC_WRITE;
 195     }
 196
 197     PinConnect = (KSPIN_CONNECT*)(InstanceInfo + 1);
 198
 199
 200     PinConnect->Interface.Set = KSINTERFACESETID_Standard;
 201     PinConnect->Interface.Id = KSINTERFACE_STANDARD_STREAMING;
 202     PinConnect->Interface.Flags = 0;
 203     PinConnect->Medium.Set = KSMEDIUMSETID_Standard;
 204     PinConnect->Medium.Id = KSMEDIUM_TYPE_ANYINSTANCE;
 205     PinConnect->Medium.Flags = 0;
 206     PinConnect->PinId = PinId;
 207     PinConnect->PinToHandle = ClientInfo->hSysAudio;
 208     PinConnect->Priority.PriorityClass = KSPRIORITY_NORMAL;
 209     PinConnect->Priority.PrioritySubClass = 1;
 210
 211
 212     DataFormat = (KSDATAFORMAT_WAVEFORMATEX*) (PinConnect + 1);
 213     DataFormat->WaveFormatEx.wFormatTag = DeviceInfo->u.WaveFormatEx.wFormatTag;
 214     DataFormat->WaveFormatEx.nChannels = DeviceInfo->u.WaveFormatEx.nChannels;
 215     DataFormat->WaveFormatEx.nSamplesPerSec = DeviceInfo->u.WaveFormatEx.nSamplesPerSec;
 216     DataFormat->WaveFormatEx.nBlockAlign = DeviceInfo->u.WaveFormatEx.nBlockAlign;
 217     DataFormat->WaveFormatEx.nAvgBytesPerSec = DeviceInfo->u.WaveFormatEx.nAvgBytesPerSec;
 218     DataFormat->WaveFormatEx.wBitsPerSample = DeviceInfo->u.WaveFormatEx.wBitsPerSample;
 219     DataFormat->WaveFormatEx.cbSize = 0;
 220     DataFormat->DataFormat.FormatSize = sizeof(KSDATAFORMAT) + sizeof(WAVEFORMATEX);
 221     DataFormat->DataFormat.Flags = 0;
 222     DataFormat->DataFormat.Reserved = 0;
 223     DataFormat->DataFormat.MajorFormat = KSDATAFORMAT_TYPE_AUDIO;
 224
 225     if (DeviceInfo->u.WaveFormatEx.wFormatTag != WAVE_FORMAT_PCM)
 226         DPRINT1("FIXME\n");
 227
 228     DataFormat->DataFormat.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
 229     DataFormat->DataFormat.Specifier = KSDATAFORMAT_SPECIFIER_WAVEFORMATEX;
 230     DataFormat->DataFormat.SampleSize = 4;
 231
 232     /* ros specific pin creation request */
 233     InstanceInfo->Property.Id = (ULONG)-1;
 234     Status = KsSynchronousIoControlDevice(ClientInfo->FileObject, KernelMode, IOCTL_KS_PROPERTY, (PVOID)InstanceInfo, Length, &PinHandle, sizeof(HANDLE), &BytesReturned);
 235     if (NT_SUCCESS(Status))
 236     {
 237         PHANDLE Handels;
 238
 239         for(Index = 0; Index < ClientInfo->NumPins; Index++)
 240         {
 241             if (ClientInfo->hPins[Index] == PinHandle)
 242             {
 243                 /* the pin handle has been re-used */
 244                 DeviceInfo->hDevice = PinHandle;
 245                 return SetIrpIoStatus(Irp, Status, sizeof(WDMAUD_DEVICE_INFO));
 246             }
 247
 248         }
 249
 250         Handels = ExAllocatePool(NonPagedPool, sizeof(HANDLE) * (ClientInfo->NumPins+1));
 251
 252         if (Handels)
 253         {
 254             if (ClientInfo->NumPins)
 255             {
 256                 RtlMoveMemory(Handels, ClientInfo->hPins, sizeof(HANDLE) * ClientInfo->NumPins);
 257                 ExFreePool(ClientInfo->hPins);
 258             }
 259
 260             ClientInfo->hPins = Handels;
 261             ClientInfo->hPins[ClientInfo->NumPins] = PinHandle;
 262             ClientInfo->NumPins++;
 263         }
 264         DeviceInfo->hDevice = PinHandle;
 265     }
 266     else
 267     {
 268         DeviceInfo->hDevice = NULL;
 269     }
 270
 271     return SetIrpIoStatus(Irp, Status, sizeof(WDMAUD_DEVICE_INFO));
 272 }
 273
 274 NTSTATUS
 275 WdmAudControlDeviceType(
 276     IN  PDEVICE_OBJECT DeviceObject,
 277     IN  PIRP Irp,
 278     IN  PWDMAUD_DEVICE_INFO DeviceInfo,
 279     IN  PWDMAUD_CLIENT ClientInfo)
 280 {
 281     KSP_PIN Pin;
 282     ULONG Count, BytesReturned, Index, SubIndex, Result, NumPins;
 283     NTSTATUS Status;
 284     KSPIN_COMMUNICATION Communication;
 285     KSPIN_DATAFLOW DataFlow;
 286
 287     if (DeviceInfo->DeviceType != WAVE_OUT_DEVICE_TYPE && DeviceInfo->DeviceType != WAVE_IN_DEVICE_TYPE)
 288     {
 289         DPRINT1("FIXME: Unsupported device type %x\n", DeviceInfo->DeviceType);
 290         return SetIrpIoStatus(Irp, STATUS_UNSUCCESSFUL, 0);
 291     }
 292
 293     Pin.Property.Set = KSPROPSETID_Sysaudio;
 294     Pin.Property.Id = KSPROPERTY_SYSAUDIO_DEVICE_COUNT;
 295     Pin.Property.Flags = KSPROPERTY_TYPE_GET;
 296
 297     Status = KsSynchronousIoControlDevice(ClientInfo->FileObject, KernelMode, IOCTL_KS_PROPERTY, (PVOID)&Pin, sizeof(KSPROPERTY), (PVOID)&Count, sizeof(ULONG), &BytesReturned);
 298     if (!NT_SUCCESS(Status))
 299     {
 300         DPRINT1("KSPROPERTY_SYSAUDIO_DEVICE_COUNT failed with %x\n", Status);
 301         return SetIrpIoStatus(Irp, Status, sizeof(WDMAUD_DEVICE_INFO));
 302     }
 303     Result = 0;
 304     /* now enumerate all available filters */
 305     for(Index = 0; Index < Count; Index++)
 306     {
 307         /* query number of pins */
 308         Pin.Reserved = Index; // see sysaudio
 309         Pin.Property.Flags = KSPROPERTY_TYPE_GET;
 310         Pin.Property.Set = KSPROPSETID_Pin;
 311         Pin.Property.Id = KSPROPERTY_PIN_CTYPES;
 312         Pin.PinId = 0;
 313
 314         Status = KsSynchronousIoControlDevice(ClientInfo->FileObject, KernelMode, IOCTL_KS_PROPERTY, (PVOID)&Pin, sizeof(KSP_PIN), (PVOID)&NumPins, sizeof(ULONG), &BytesReturned);
 315         if (NT_SUCCESS(Status))
 316         {
 317             /* enumerate now all pins */
 318             for(SubIndex = 0; SubIndex < NumPins; SubIndex++)
 319             {
 320                 Pin.PinId = SubIndex;
 321                 Pin.Property.Id = KSPROPERTY_PIN_COMMUNICATION;
 322                 Communication = KSPIN_COMMUNICATION_NONE;
 323
 324                 /* get pin communication type */
 325                 KsSynchronousIoControlDevice(ClientInfo->FileObject, KernelMode, IOCTL_KS_PROPERTY, (PVOID)&Pin, sizeof(KSP_PIN), (PVOID)&Communication, sizeof(KSPIN_COMMUNICATION), &BytesReturned);
 326
 327                 Pin.Property.Id = KSPROPERTY_PIN_DATAFLOW;
 328                 DataFlow = 0;
 329
 330                 /* get pin dataflow type */
 331                 KsSynchronousIoControlDevice(ClientInfo->FileObject, KernelMode, IOCTL_KS_PROPERTY, (PVOID)&Pin, sizeof(KSP_PIN), (PVOID)&DataFlow, sizeof(KSPIN_DATAFLOW), &BytesReturned);
 332
 333                 if (DeviceInfo->DeviceType == WAVE_OUT_DEVICE_TYPE)
 334                 {
 335                     if (Communication == KSPIN_COMMUNICATION_SINK && DataFlow == KSPIN_DATAFLOW_IN)
 336                         Result++;
 337                 }
 338                 else if (DeviceInfo->DeviceType == WAVE_IN_DEVICE_TYPE)
 339                 {
 340                     if (Communication == KSPIN_COMMUNICATION_SINK && DataFlow == KSPIN_DATAFLOW_OUT)
 341                         Result++;
 342                 }
 343             }
 344         }
 345     }
 346
 347
 348     if (NT_SUCCESS(Status))
 349         DeviceInfo->DeviceCount = Result;
 350     else
 351         DeviceInfo->DeviceCount = 0;
 352
 353     DPRINT1("WdmAudControlDeviceType Status %x Devices %u\n", Status, DeviceInfo->DeviceCount);
 354     return SetIrpIoStatus(Irp, Status, sizeof(WDMAUD_DEVICE_INFO));
 355 }
 356
 357 NTSTATUS
 358 WdmAudControlDeviceState(
 359     IN  PDEVICE_OBJECT DeviceObject,
 360     IN  PIRP Irp,
 361     IN  PWDMAUD_DEVICE_INFO DeviceInfo,
 362     IN  PWDMAUD_CLIENT ClientInfo)
 363 {
 364     KSPROPERTY Property;
 365     KSSTATE State;
 366     NTSTATUS Status;
 367     ULONG BytesReturned;
 368     PFILE_OBJECT FileObject;
 369
 370     //DPRINT1("WdmAudControlDeviceState\n");
 371
 372     Status = ObReferenceObjectByHandle(DeviceInfo->hDevice, GENERIC_READ | GENERIC_WRITE, IoFileObjectType, KernelMode, (PVOID*)&FileObject, NULL);
 373     if (!NT_SUCCESS(Status))
 374     {
 375         DPRINT1("Error: invalid device handle provided %p\n", DeviceInfo->hDevice);
 376         return SetIrpIoStatus(Irp, STATUS_UNSUCCESSFUL, 0);
 377     }
 378
 379     Property.Set = KSPROPSETID_Connection;
 380     Property.Id = KSPROPERTY_CONNECTION_STATE;
 381     Property.Flags = KSPROPERTY_TYPE_SET;
 382
 383     State = DeviceInfo->State;
 384
 385     Status = KsSynchronousIoControlDevice(FileObject, KernelMode, IOCTL_KS_PROPERTY, (PVOID)&Property, sizeof(KSPROPERTY), (PVOID)&State, sizeof(KSSTATE), &BytesReturned);
 386
 387     ObDereferenceObject(FileObject);
 388
 389     //DPRINT1("WdmAudControlDeviceState Status %x\n", Status);
 390     return SetIrpIoStatus(Irp, Status, sizeof(WDMAUD_DEVICE_INFO));
 391 }
 392
 393 ULONG
 394 CheckFormatSupport(
 395     IN PKSDATARANGE_AUDIO DataRangeAudio,
 396     ULONG SampleFrequency,
 397     ULONG Mono8Bit,
 398     ULONG Stereo8Bit,
 399     ULONG Mono16Bit,
 400     ULONG Stereo16Bit)
 401 {
 402     ULONG Result = 0;
 403
 404     if (DataRangeAudio->MinimumSampleFrequency <= SampleFrequency && DataRangeAudio->MaximumSampleFrequency >= SampleFrequency)
 405     {
 406         if (DataRangeAudio->MinimumBitsPerSample <= 8 && DataRangeAudio->MaximumBitsPerSample >= 8)
 407         {
 408             Result |= Mono8Bit;
 409             if (DataRangeAudio->MaximumChannels >= 2)
 410             {
 411                 Result |= Stereo8Bit;
 412             }
 413         }
 414
 415         if (DataRangeAudio->MinimumBitsPerSample <= 16 && DataRangeAudio->MaximumBitsPerSample >= 16)
 416         {
 417             Result |= Mono16Bit;
 418             if (DataRangeAudio->MaximumChannels >= 2)
 419             {
 420                 Result |= Stereo8Bit;
 421             }
 422         }
 423     }
 424     return Result;
 425
 426 }
 427
 428 NTSTATUS
 429 WdmAudCapabilities(
 430     IN  PDEVICE_OBJECT DeviceObject,
 431     IN  PIRP Irp,
 432     IN  PWDMAUD_DEVICE_INFO DeviceInfo,
 433     IN  PWDMAUD_CLIENT ClientInfo)
 434 {
 435     NTSTATUS Status = STATUS_UNSUCCESSFUL;
 436     KSP_PIN PinProperty;
 437     KSCOMPONENTID ComponentId;
 438     KSMULTIPLE_ITEM * MultipleItem;
 439     ULONG BytesReturned;
 440     PKSDATARANGE_AUDIO DataRangeAudio;
 441     PKSDATARANGE DataRange;
 442     ULONG Index;
 443     ULONG wChannels = 0;
 444     ULONG dwFormats = 0;
 445     ULONG dwSupport = 0;
 446     ULONG FilterId;
 447     ULONG PinId;
 448
 449     DPRINT("WdmAudCapabilities entered\n");
 450
 451     Status = GetFilterIdAndPinId(DeviceObject, DeviceInfo, ClientInfo, &FilterId, &PinId);
 452     if (!NT_SUCCESS(Status))
 453     {
 454         DPRINT1("Invalid device index provided %u\n", DeviceInfo->DeviceIndex);
 455         return SetIrpIoStatus(Irp, STATUS_INVALID_PARAMETER, 0);
 456     }
 457
 458     PinProperty.PinId = FilterId;
 459     PinProperty.Property.Set = KSPROPSETID_Sysaudio;
 460     PinProperty.Property.Id = KSPROPERTY_SYSAUDIO_COMPONENT_ID;
 461     PinProperty.Property.Flags = KSPROPERTY_TYPE_GET;
 462
 463     RtlZeroMemory(&ComponentId, sizeof(KSCOMPONENTID));
 464
 465     Status = KsSynchronousIoControlDevice(ClientInfo->FileObject, KernelMode, IOCTL_KS_PROPERTY, (PVOID)&PinProperty, sizeof(KSP_PIN), (PVOID)&ComponentId, sizeof(KSCOMPONENTID), &BytesReturned);
 466     if (NT_SUCCESS(Status))
 467     {
 468         DeviceInfo->u.WaveOutCaps.wMid = ComponentId.Manufacturer.Data1 - 0xd5a47fa7;
 469         DeviceInfo->u.WaveOutCaps.vDriverVersion = MAKELONG(ComponentId.Version, ComponentId.Revision);
 470     }
 471
 472     PinProperty.Reserved = DeviceInfo->DeviceIndex;
 473     PinProperty.PinId = PinId;
 474     PinProperty.Property.Set = KSPROPSETID_Pin;
 475     PinProperty.Property.Id = KSPROPERTY_PIN_DATARANGES;
 476     PinProperty.Property.Flags = KSPROPERTY_TYPE_GET;
 477
 478     BytesReturned = 0;
 479     Status = KsSynchronousIoControlDevice(ClientInfo->FileObject, KernelMode, IOCTL_KS_PROPERTY, (PVOID)&PinProperty, sizeof(KSP_PIN), (PVOID)NULL, 0, &BytesReturned);
 480     if (Status != STATUS_BUFFER_TOO_SMALL)
 481     {
 482         return SetIrpIoStatus(Irp, Status, 0);
 483     }
 484
 485     MultipleItem = ExAllocatePool(NonPagedPool, BytesReturned);
 486     if (!MultipleItem)
 487     {
 488         /* no memory */
 489         return SetIrpIoStatus(Irp, STATUS_NO_MEMORY, 0);
 490     }
 491
 492     Status = KsSynchronousIoControlDevice(ClientInfo->FileObject, KernelMode, IOCTL_KS_PROPERTY, (PVOID)&PinProperty, sizeof(KSP_PIN), (PVOID)MultipleItem, BytesReturned, &BytesReturned);
 493     if (!NT_SUCCESS(Status))
 494     {
 495         ExFreePool(MultipleItem);
 496         return SetIrpIoStatus(Irp, Status, 0);
 497     }
 498
 499     DataRange = (PKSDATARANGE) (MultipleItem + 1);
 500     for(Index = 0; Index < MultipleItem->Count; Index++)
 501     {
 502         if (DeviceInfo->DeviceType == WAVE_OUT_DEVICE_TYPE || DeviceInfo->DeviceType == WAVE_IN_DEVICE_TYPE)
 503         {
 504             if (DataRange->FormatSize == sizeof(KSDATARANGE_AUDIO))
 505             {
 506                 DataRangeAudio = (PKSDATARANGE_AUDIO)DataRange;
 507
 508                 if (IsEqualGUIDAligned(&DataRangeAudio->DataRange.MajorFormat, &KSDATAFORMAT_TYPE_AUDIO) &&
 509                     IsEqualGUIDAligned(&DataRangeAudio->DataRange.SubFormat, &KSDATAFORMAT_SUBTYPE_PCM) &&
 510                     IsEqualGUIDAligned(&DataRangeAudio->DataRange.Specifier, &KSDATAFORMAT_SPECIFIER_WAVEFORMATEX))
 511                 {
 512                     DPRINT("Min Sample %u Max Sample %u Min Bits %u Max Bits %u Max Channel %u\n", DataRangeAudio->MinimumSampleFrequency, DataRangeAudio->MaximumSampleFrequency,
 513                                                              DataRangeAudio->MinimumBitsPerSample, DataRangeAudio->MaximumBitsPerSample, DataRangeAudio->MaximumChannels);
 514
 515                     dwFormats |= CheckFormatSupport(DataRangeAudio, 11025, WAVE_FORMAT_1M08, WAVE_FORMAT_1S08, WAVE_FORMAT_1M16, WAVE_FORMAT_1S16);
 516                     dwFormats |= CheckFormatSupport(DataRangeAudio, 22050, WAVE_FORMAT_2M08, WAVE_FORMAT_2S08, WAVE_FORMAT_2M16, WAVE_FORMAT_2S16);
 517                     dwFormats |= CheckFormatSupport(DataRangeAudio, 44100, WAVE_FORMAT_4M08, WAVE_FORMAT_4S08, WAVE_FORMAT_4M16, WAVE_FORMAT_4S16);
 518                     dwFormats |= CheckFormatSupport(DataRangeAudio, 48000, WAVE_FORMAT_48M08, WAVE_FORMAT_48S08, WAVE_FORMAT_48M16, WAVE_FORMAT_48S16);
 519                     dwFormats |= CheckFormatSupport(DataRangeAudio, 96000, WAVE_FORMAT_96M08, WAVE_FORMAT_96S08, WAVE_FORMAT_96M16, WAVE_FORMAT_96S16);
 520
 521
 522                     wChannels = DataRangeAudio->MaximumChannels;
 523                     dwSupport = WAVECAPS_VOLUME; //FIXME get info from nodes
 524                 }
 525             }
 526         }
 527         DataRange = (PKSDATARANGE)((PUCHAR)DataRange + DataRange->FormatSize);
 528     }
 529
 530     DeviceInfo->u.WaveOutCaps.dwFormats = dwFormats;
 531     DeviceInfo->u.WaveOutCaps.dwSupport = dwSupport;
 532     DeviceInfo->u.WaveOutCaps.wChannels = wChannels;
 533     DeviceInfo->u.WaveOutCaps.szPname[0] = L'\0';
 534
 535
 536     ExFreePool(MultipleItem);
 537     return SetIrpIoStatus(Irp, Status, sizeof(WDMAUD_DEVICE_INFO));
 538 }
 539
 540 NTSTATUS
 541 NTAPI
 542 WdmAudIoctlClose(
 543     IN  PDEVICE_OBJECT DeviceObject,
 544     IN  PIRP Irp,
 545     IN  PWDMAUD_DEVICE_INFO DeviceInfo,
 546     IN  PWDMAUD_CLIENT ClientInfo)
 547 {
 548     ULONG Index;
 549
 550     for(Index = 0; Index < ClientInfo->NumPins; Index++)
 551     {
 552         if (ClientInfo->hPins[Index] == DeviceInfo->hDevice)
 553         {
 554             DPRINT1("Closing device %p\n", DeviceInfo->hDevice);
 555             ZwClose(DeviceInfo->hDevice);
 556             ClientInfo->hPins[Index] = NULL;
 557             SetIrpIoStatus(Irp, STATUS_SUCCESS, sizeof(WDMAUD_DEVICE_INFO));
 558             return STATUS_SUCCESS;
 559         }
 560     }
 561     SetIrpIoStatus(Irp, STATUS_INVALID_PARAMETER, sizeof(WDMAUD_DEVICE_INFO));
 562     return STATUS_INVALID_PARAMETER;
 563 }
 564
 565 NTSTATUS
 566 NTAPI
 567 WdmAudDeviceControl(
 568     IN  PDEVICE_OBJECT DeviceObject,
 569     IN  PIRP Irp)
 570 {
 571     PIO_STACK_LOCATION IoStack;
 572     PWDMAUD_DEVICE_INFO DeviceInfo;
 573     PWDMAUD_CLIENT ClientInfo;
 574
 575     IoStack = IoGetCurrentIrpStackLocation(Irp);
 576
 577     DPRINT("WdmAudDeviceControl entered\n");
 578
 579     if (IoStack->Parameters.DeviceIoControl.InputBufferLength < sizeof(WDMAUD_DEVICE_INFO))
 580     {
 581         /* invalid parameter */
 582         DPRINT1("Input buffer too small size %u expected %u\n", IoStack->Parameters.DeviceIoControl.InputBufferLength, sizeof(WDMAUD_DEVICE_INFO));
 583         return SetIrpIoStatus(Irp, STATUS_INVALID_PARAMETER, 0);
 584     }
 585
 586     DeviceInfo = (PWDMAUD_DEVICE_INFO)Irp->AssociatedIrp.SystemBuffer;
 587
 588     if (DeviceInfo->DeviceType < MIN_SOUND_DEVICE_TYPE || DeviceInfo->DeviceType > MAX_SOUND_DEVICE_TYPE)
 589     {
 590         /* invalid parameter */
 591         DPRINT1("Error: device type not set\n");
 592         return SetIrpIoStatus(Irp, STATUS_INVALID_PARAMETER, 0);
 593     }
 594
 595     if (!IoStack->FileObject)
 596     {
 597         /* file object parameter */
 598         DPRINT1("Error: file object is not attached\n");
 599         return SetIrpIoStatus(Irp, STATUS_UNSUCCESSFUL, 0);
 600     }
 601     ClientInfo = (PWDMAUD_CLIENT)IoStack->FileObject->FsContext;
 602
 603     DPRINT("WdmAudDeviceControl entered\n");
 604
 605     switch(IoStack->Parameters.DeviceIoControl.IoControlCode)
 606     {
 607         case IOCTL_OPEN_WDMAUD:
 608             return WdmAudControlOpen(DeviceObject, Irp, DeviceInfo, ClientInfo);
 609         case IOCTL_GETNUMDEVS_TYPE:
 610             return WdmAudControlDeviceType(DeviceObject, Irp, DeviceInfo, ClientInfo);
 611         case IOCTL_SETDEVICE_STATE:
 612             return WdmAudControlDeviceState(DeviceObject, Irp, DeviceInfo, ClientInfo);
 613         case IOCTL_GETCAPABILITIES:
 614             return WdmAudCapabilities(DeviceObject, Irp, DeviceInfo, ClientInfo);
 615         case IOCTL_CLOSE_WDMAUD:
 616             return WdmAudIoctlClose(DeviceObject, Irp, DeviceInfo, ClientInfo);
 617         case IOCTL_GETDEVID:
 618         case IOCTL_GETVOLUME:
 619         case IOCTL_SETVOLUME:
 620
 621            DPRINT1("Unhandeled %x\n", IoStack->Parameters.DeviceIoControl.IoControlCode);
 622            break;
 623     }
 624
 625     return SetIrpIoStatus(Irp, STATUS_NOT_IMPLEMENTED, 0);
 626 }
 627
 628 NTSTATUS
 629 NTAPI
 630 WdmAudWrite(
 631     IN  PDEVICE_OBJECT DeviceObject,
 632     IN  PIRP Irp)
 633 {
 634     PIO_STACK_LOCATION IoStack;
 635     PWDMAUD_DEVICE_INFO DeviceInfo;
 636     PWDMAUD_CLIENT ClientInfo;
 637     NTSTATUS Status = STATUS_SUCCESS;
 638     PUCHAR Buffer;
 639     PCONTEXT_WRITE Packet;
 640     PFILE_OBJECT FileObject;
 641     IO_STATUS_BLOCK IoStatusBlock;
 642
 643     IoStack = IoGetCurrentIrpStackLocation(Irp);
 644
 645     //DPRINT("WdmAudWrite entered\n");
 646
 647     if (IoStack->Parameters.Write.Length < sizeof(WDMAUD_DEVICE_INFO))
 648     {
 649         /* invalid parameter */
 650         DPRINT1("Input buffer too small size %u expected %u\n", IoStack->Parameters.Write.Length, sizeof(WDMAUD_DEVICE_INFO));
 651         return SetIrpIoStatus(Irp, STATUS_INVALID_PARAMETER, 0);
 652     }
 653
 654     DeviceInfo = (PWDMAUD_DEVICE_INFO)MmGetMdlVirtualAddress(Irp->MdlAddress);
 655
 656
 657     Status = ObReferenceObjectByHandle(DeviceInfo->hDevice, GENERIC_WRITE, IoFileObjectType, KernelMode, (PVOID*)&FileObject, NULL);
 658     if (!NT_SUCCESS(Status))
 659     {
 660         DPRINT1("Invalid buffer handle %x\n", DeviceInfo->hDevice);
 661         return SetIrpIoStatus(Irp, Status, 0);
 662     }
 663
 664
 665     //DPRINT("DeviceInfo %p %p %p\n", DeviceInfo, Irp->MdlAddress->StartVa, Irp->MdlAddress->MappedSystemVa);
 666     if (DeviceInfo->DeviceType < MIN_SOUND_DEVICE_TYPE || DeviceInfo->DeviceType > MAX_SOUND_DEVICE_TYPE)
 667     {
 668         /* invalid parameter */
 669         DPRINT1("Error: device type not set\n");
 670         ObDereferenceObject(FileObject);
 671         return SetIrpIoStatus(Irp, STATUS_INVALID_PARAMETER, 0);
 672     }
 673
 674     if (!IoStack->FileObject)
 675     {
 676         /* file object parameter */
 677         DPRINT1("Error: file object is not attached\n");
 678         ObDereferenceObject(FileObject);
 679         return SetIrpIoStatus(Irp, STATUS_UNSUCCESSFUL, 0);
 680     }
 681     ClientInfo = (PWDMAUD_CLIENT)IoStack->FileObject->FsContext;
 682
 683
 684     /* setup stream context */
 685     Packet = (PCONTEXT_WRITE)ExAllocatePool(NonPagedPool, sizeof(CONTEXT_WRITE));
 686     if (!Packet)
 687     {
 688         /* no memory */
 689         return SetIrpIoStatus(Irp, STATUS_NO_MEMORY, 0);
 690     }
 691
 692     Packet->Header.FrameExtent = DeviceInfo->BufferSize;
 693     Packet->Header.DataUsed = DeviceInfo->BufferSize;
 694     Packet->Header.Size = sizeof(KSSTREAM_HEADER);
 695     Packet->Header.PresentationTime.Numerator = 1;
 696     Packet->Header.PresentationTime.Denominator = 1;
 697     Packet->Irp = Irp;
 698
 699     Buffer = ExAllocatePool(NonPagedPool, DeviceInfo->BufferSize);
 700     if (!Buffer)
 701     {
 702         /* no memory */
 703         ExFreePool(Packet);
 704         ObDereferenceObject(FileObject);
 705         return SetIrpIoStatus(Irp, STATUS_NO_MEMORY, 0);
 706     }
 707     Packet->Header.Data = Buffer;
 708
 709     _SEH2_TRY
 710     {
 711         ProbeForRead(DeviceInfo->Buffer, DeviceInfo->BufferSize, TYPE_ALIGNMENT(char));
 712         RtlMoveMemory(Buffer, DeviceInfo->Buffer, DeviceInfo->BufferSize);
 713     }
 714     _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
 715     {
 716         /* Exception, get the error code */
 717         Status = _SEH2_GetExceptionCode();
 718     }
 719     _SEH2_END;
 720
 721     if (!NT_SUCCESS(Status))
 722     {
 723         DPRINT1("Invalid buffer supplied\n");
 724         ExFreePool(Buffer);
 725         ExFreePool(Packet);
 726         ObDereferenceObject(FileObject);
 727         return SetIrpIoStatus(Irp, Status, 0);
 728     }
 729
 730     KsStreamIo(FileObject, NULL, NULL, NULL, NULL, 0, &IoStatusBlock, Packet, sizeof(CONTEXT_WRITE), KSSTREAM_WRITE, KernelMode);
 731     ObDereferenceObject(FileObject);
 732     return IoStatusBlock.Status;
 733 }
 734