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