drivers/usb/usbaudio/filter.c

   1 /*
   2 * PROJECT:     ReactOS Universal Audio Class Driver
   3 * LICENSE:     GPL - See COPYING in the top level directory
   4 * FILE:        drivers/usb/usbaudio/filter.c
   5 * PURPOSE:     USB Audio device driver.
   6 * PROGRAMMERS:
   7 *              Johannes Anderwald (johannes.anderwald@reactos.org)
   8 */
   9
  10 #include "usbaudio.h"
  11
  12 GUID NodeTypeMicrophone = { STATIC_KSNODETYPE_MICROPHONE };
  13 GUID NodeTypeDesktopMicrophone = { STATIC_KSNODETYPE_DESKTOP_MICROPHONE };
  14 GUID NodeTypePersonalMicrophone = { STATIC_KSNODETYPE_PERSONAL_MICROPHONE };
  15 GUID NodeTypeOmmniMicrophone = { STATIC_KSNODETYPE_OMNI_DIRECTIONAL_MICROPHONE };
  16 GUID NodeTypeArrayMicrophone = { STATIC_KSNODETYPE_MICROPHONE_ARRAY };
  17 GUID NodeTypeProcessingArrayMicrophone = { STATIC_KSNODETYPE_PROCESSING_MICROPHONE_ARRAY };
  18 GUID NodeTypeSpeaker = { STATIC_KSNODETYPE_SPEAKER };
  19 GUID NodeTypeHeadphonesSpeaker = { STATIC_KSNODETYPE_HEADPHONES };
  20 GUID NodeTypeHMDA = { STATIC_KSNODETYPE_HEAD_MOUNTED_DISPLAY_AUDIO };
  21 GUID NodeTypeDesktopSpeaker = { STATIC_KSNODETYPE_DESKTOP_SPEAKER };
  22 GUID NodeTypeRoomSpeaker = { STATIC_KSNODETYPE_ROOM_SPEAKER };
  23 GUID NodeTypeCommunicationSpeaker = { STATIC_KSNODETYPE_COMMUNICATION_SPEAKER };
  24 GUID NodeTypeSubwoofer = { STATIC_KSNODETYPE_LOW_FREQUENCY_EFFECTS_SPEAKER };
  25 GUID NodeTypeCapture = { STATIC_PINNAME_CAPTURE };
  26 GUID NodeTypePlayback = { STATIC_KSCATEGORY_AUDIO };
  27 GUID GUID_KSCATEGORY_AUDIO = { STATIC_KSCATEGORY_AUDIO };
  28
  29 KSPIN_INTERFACE StandardPinInterface =
  30 {
  31      {STATIC_KSINTERFACESETID_Standard},
  32      KSINTERFACE_STANDARD_STREAMING,
  33      0
  34 };
  35
  36 KSPIN_MEDIUM StandardPinMedium =
  37 {
  38      {STATIC_KSMEDIUMSETID_Standard},
  39      KSMEDIUM_TYPE_ANYINSTANCE,
  40      0
  41 };
  42
  43 KSDATARANGE BridgePinAudioFormat[] =
  44 {
  45     {
  46         {
  47             sizeof(KSDATAFORMAT),
  48             0,
  49             0,
  50             0,
  51             {STATIC_KSDATAFORMAT_TYPE_AUDIO},
  52             {STATIC_KSDATAFORMAT_SUBTYPE_ANALOG},
  53             {STATIC_KSDATAFORMAT_SPECIFIER_NONE}
  54         }
  55     }
  56 };
  57
  58 static PKSDATARANGE BridgePinAudioFormats[] =
  59 {
  60     &BridgePinAudioFormat[0]
  61 };
  62
  63 static LPWSTR ReferenceString = L"global";
  64
  65 NTSTATUS
  66 NTAPI
  67 USBAudioFilterCreate(
  68     PKSFILTER Filter,
  69     PIRP Irp);
  70
  71 static KSFILTER_DISPATCH USBAudioFilterDispatch =
  72 {
  73     USBAudioFilterCreate,
  74     NULL,
  75     NULL,
  76     NULL
  77 };
  78
  79 static KSPIN_DISPATCH UsbAudioPinDispatch =
  80 {
  81     USBAudioPinCreate,
  82     USBAudioPinClose,
  83     USBAudioPinProcess,
  84     USBAudioPinReset,
  85     USBAudioPinSetDataFormat,
  86     USBAudioPinSetDeviceState,
  87     NULL,
  88     NULL,
  89     NULL,
  90     NULL
  91 };
  92
  93 NTSTATUS NTAPI FilterAudioVolumeHandler(IN PIRP Irp, IN PKSIDENTIFIER  Request, IN OUT PVOID  Data);
  94 NTSTATUS NTAPI FilterAudioMuteHandler(IN PIRP Irp, IN PKSIDENTIFIER  Request, IN OUT PVOID  Data);
  95
  96 DEFINE_KSPROPERTY_TABLE_AUDIO_VOLUME(FilterAudioVolumePropertySet, FilterAudioVolumeHandler);
  97 DEFINE_KSPROPERTY_TABLE_AUDIO_MUTE(FilterAudioMutePropertySet, FilterAudioMuteHandler);
  98
  99
 100 static KSPROPERTY_SET FilterAudioVolumePropertySetArray[] =
 101 {
 102     {
 103         &KSPROPSETID_Audio,
 104         sizeof(FilterAudioVolumePropertySet) / sizeof(KSPROPERTY_ITEM),
 105         (const KSPROPERTY_ITEM*)&FilterAudioVolumePropertySet,
 106         0,
 107         NULL
 108     }
 109 };
 110
 111 static KSPROPERTY_SET FilterAudioMutePropertySetArray[] =
 112 {
 113     {
 114         &KSPROPSETID_Audio,
 115         sizeof(FilterAudioMutePropertySet) / sizeof(KSPROPERTY_ITEM),
 116         (const KSPROPERTY_ITEM*)&FilterAudioMutePropertySet,
 117         0,
 118         NULL
 119     }
 120 };
 121
 122 NTSTATUS
 123 UsbAudioGetSetProperty(
 124     IN PDEVICE_OBJECT DeviceObject,
 125     IN UCHAR Request,
 126     IN USHORT Value,
 127     IN USHORT Index,
 128     IN PVOID TransferBuffer,
 129     IN ULONG TransferBufferLength,
 130     IN ULONG TransferFlags)
 131 {
 132     PURB Urb;
 133     NTSTATUS Status;
 134
 135     /* allocate urb */
 136     Urb = AllocFunction(sizeof(struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST));
 137     if (!Urb)
 138     {
 139         /* no memory */
 140         return STATUS_INSUFFICIENT_RESOURCES;
 141     }
 142
 143     /* format urb */
 144     UsbBuildVendorRequest(Urb,
 145         URB_FUNCTION_CLASS_INTERFACE,
 146         sizeof(struct _URB_CONTROL_VENDOR_OR_CLASS_REQUEST),
 147         TransferFlags,
 148         0,
 149         Request,
 150         Value,
 151         Index,
 152         TransferBuffer,
 153         NULL,
 154         TransferBufferLength,
 155         NULL);
 156
 157     /* submit urb */
 158     Status = SubmitUrbSync(DeviceObject, Urb);
 159
 160     FreeFunction(Urb);
 161     return Status;
 162 }
 163
 164 PNODE_CONTEXT
 165 FindNodeContextWithNode(
 166     IN PNODE_CONTEXT NodeContext,
 167     IN ULONG NodeContextCount,
 168     IN ULONG NodeId)
 169 {
 170     ULONG Index, NodeIndex;
 171     for (Index = 0; Index < NodeContextCount; Index++)
 172     {
 173         for (NodeIndex = 0; NodeIndex < NodeContext[Index].NodeCount; NodeIndex++)
 174         {
 175             if (NodeContext[Index].Nodes[NodeIndex] == NodeId)
 176             {
 177                 return &NodeContext[Index];
 178             }
 179         }
 180     }
 181     return NULL;
 182 }
 183
 184
 185 NTSTATUS
 186 NTAPI
 187 FilterAudioMuteHandler(
 188     IN PIRP Irp,
 189     IN PKSIDENTIFIER  Request,
 190     IN OUT PVOID  Data)
 191 {
 192     PKSNODEPROPERTY_AUDIO_CHANNEL Property;
 193     PKSFILTER Filter;
 194     PFILTER_CONTEXT FilterContext;
 195     PNODE_CONTEXT NodeContext;
 196     PUSB_AUDIO_CONTROL_FEATURE_UNIT_DESCRIPTOR FeatureUnitDescriptor;
 197     NTSTATUS Status = STATUS_INVALID_PARAMETER;
 198
 199     /* get filter from irp */
 200     Filter = KsGetFilterFromIrp(Irp);
 201
 202     if (Filter)
 203     {
 204         /* get property */
 205         Property = (PKSNODEPROPERTY_AUDIO_CHANNEL)Request;
 206
 207         /* get filter context */
 208         FilterContext = (PFILTER_CONTEXT)Filter->Context;
 209
 210         /* search for node context */
 211         NodeContext = FindNodeContextWithNode(FilterContext->DeviceExtension->NodeContext, FilterContext->DeviceExtension->NodeContextCount, Property->NodeProperty.NodeId);
 212         if (NodeContext)
 213         {
 214             FeatureUnitDescriptor = (PUSB_AUDIO_CONTROL_FEATURE_UNIT_DESCRIPTOR)NodeContext->Descriptor;
 215             if (Property->NodeProperty.Property.Flags & KSPROPERTY_TYPE_GET)
 216             {
 217                 Status = UsbAudioGetSetProperty(FilterContext->DeviceExtension->LowerDevice, 0x81, 0x1 << 8, FeatureUnitDescriptor->bUnitID << 8, Data, 1, USBD_TRANSFER_DIRECTION_IN);
 218                 Irp->IoStatus.Information = sizeof(BOOL);
 219             }
 220             else
 221             {
 222                 Status = UsbAudioGetSetProperty(FilterContext->DeviceExtension->LowerDevice, 0x01, 0x1 << 8, FeatureUnitDescriptor->bUnitID << 8, Data, 1, USBD_TRANSFER_DIRECTION_OUT);
 223             }
 224         }
 225     }
 226     return Status;
 227 }
 228
 229 NTSTATUS
 230 NTAPI
 231 FilterAudioVolumeHandler(
 232     IN PIRP Irp,
 233     IN PKSIDENTIFIER  Request,
 234     IN OUT PVOID  Data)
 235 {
 236     PKSNODEPROPERTY_AUDIO_CHANNEL Property;
 237     PKSFILTER Filter;
 238     PFILTER_CONTEXT FilterContext;
 239     PNODE_CONTEXT NodeContext;
 240     PUSB_AUDIO_CONTROL_FEATURE_UNIT_DESCRIPTOR FeatureUnitDescriptor;
 241     PSHORT TransferBuffer;
 242     LONG Value;
 243     NTSTATUS Status = STATUS_INVALID_PARAMETER;
 244
 245
 246     /* get filter from irp */
 247     Filter = KsGetFilterFromIrp(Irp);
 248
 249     if (Filter)
 250     {
 251         /* get property */
 252         Property = (PKSNODEPROPERTY_AUDIO_CHANNEL)Request;
 253
 254         /* get filter context */
 255         FilterContext = (PFILTER_CONTEXT)Filter->Context;
 256
 257         TransferBuffer = AllocFunction(sizeof(USHORT) * 3);
 258         ASSERT(TransferBuffer);
 259
 260         Value = *(PLONG)Data;
 261
 262         /* search for node context */
 263         NodeContext = FindNodeContextWithNode(FilterContext->DeviceExtension->NodeContext, FilterContext->DeviceExtension->NodeContextCount, Property->NodeProperty.NodeId);
 264         if (NodeContext)
 265         {
 266             FeatureUnitDescriptor = (PUSB_AUDIO_CONTROL_FEATURE_UNIT_DESCRIPTOR)NodeContext->Descriptor;
 267             if (Property->NodeProperty.Property.Flags & KSPROPERTY_TYPE_GET)
 268             {
 269                 Status = UsbAudioGetSetProperty(FilterContext->DeviceExtension->LowerDevice, 0x81, 0x2 << 8, FeatureUnitDescriptor->bUnitID << 8, &TransferBuffer[0], sizeof(USHORT), USBD_TRANSFER_DIRECTION_IN);
 270                 Value = (LONG)TransferBuffer[0] * 256;
 271
 272                 *(PLONG)Data = Value;
 273                 Irp->IoStatus.Information = sizeof(BOOL);
 274             }
 275             else
 276             {
 277                 /* downscale value */
 278                 Value /= 256;
 279
 280                 /* get minimum value */
 281                 UsbAudioGetSetProperty(FilterContext->DeviceExtension->LowerDevice, 0x82, 0x2 << 8, FeatureUnitDescriptor->bUnitID << 8, &TransferBuffer[0], sizeof(USHORT), USBD_TRANSFER_DIRECTION_IN);
 282
 283                 /* get maximum value */
 284                 UsbAudioGetSetProperty(FilterContext->DeviceExtension->LowerDevice, 0x83, 0x2 << 8, FeatureUnitDescriptor->bUnitID << 8, &TransferBuffer[1], sizeof(USHORT), USBD_TRANSFER_DIRECTION_IN);
 285
 286                 if (TransferBuffer[0] > Value)
 287                 {
 288                     /* use minimum value */
 289                     Value = TransferBuffer[0];
 290                 }
 291
 292                 if (TransferBuffer[1] < Value)
 293                 {
 294                     /* use maximum value */
 295                     Value = TransferBuffer[1];
 296                 }
 297
 298                 /* store value */
 299                 TransferBuffer[2] = Value;
 300
 301                 /* set volume request */
 302                 Status = UsbAudioGetSetProperty(FilterContext->DeviceExtension->LowerDevice, 0x01, 0x2 << 8, FeatureUnitDescriptor->bUnitID << 8, &TransferBuffer[2], sizeof(USHORT), USBD_TRANSFER_DIRECTION_OUT);
 303                 if (NT_SUCCESS(Status))
 304                 {
 305                     /* store number of bytes transferred*/
 306                     Irp->IoStatus.Information = sizeof(LONG);
 307                 }
 308             }
 309         }
 310
 311         /* free transfer buffer */
 312         FreeFunction(TransferBuffer);
 313     }
 314     return Status;
 315 }
 316
 317
 318 ULONG
 319 CountTopologyComponents(
 320     IN PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor,
 321     OUT PULONG OutDescriptorCount)
 322 {
 323     PUSB_INTERFACE_DESCRIPTOR Descriptor;
 324     PUSB_AUDIO_CONTROL_INTERFACE_HEADER_DESCRIPTOR InterfaceHeaderDescriptor;
 325     PUSB_COMMON_DESCRIPTOR CommonDescriptor;
 326     PUSB_AUDIO_CONTROL_INPUT_TERMINAL_DESCRIPTOR InputTerminalDescriptor;
 327     PUSB_AUDIO_CONTROL_FEATURE_UNIT_DESCRIPTOR FeatureUnitDescriptor;
 328     PUSB_AUDIO_CONTROL_MIXER_UNIT_DESCRIPTOR MixerUnitDescriptor;
 329     PUSB_AUDIO_CONTROL_SELECTOR_UNIT_DESCRIPTOR SelectorUnitDescriptor;
 330     ULONG NodeCount = 0, Length, Index;
 331     ULONG DescriptorCount = 0;
 332     UCHAR Value;
 333
 334     for (Descriptor = USBD_ParseConfigurationDescriptorEx(ConfigurationDescriptor, ConfigurationDescriptor, -1, -1, USB_DEVICE_CLASS_AUDIO, -1, -1);
 335     Descriptor != NULL;
 336         Descriptor = USBD_ParseConfigurationDescriptorEx(ConfigurationDescriptor, (PVOID)((ULONG_PTR)Descriptor + Descriptor->bLength), -1, -1, USB_DEVICE_CLASS_AUDIO, -1, -1))
 337     {
 338         if (Descriptor->bInterfaceSubClass == 0x01) /* AUDIO_CONTROL */
 339         {
 340             InterfaceHeaderDescriptor = (PUSB_AUDIO_CONTROL_INTERFACE_HEADER_DESCRIPTOR)USBD_ParseDescriptors(ConfigurationDescriptor, ConfigurationDescriptor->wTotalLength, Descriptor, USB_AUDIO_CONTROL_TERMINAL_DESCRIPTOR_TYPE);
 341             if (InterfaceHeaderDescriptor != NULL)
 342             {
 343                 CommonDescriptor = USBD_ParseDescriptors(InterfaceHeaderDescriptor, InterfaceHeaderDescriptor->wTotalLength, (PVOID)((ULONG_PTR)InterfaceHeaderDescriptor + InterfaceHeaderDescriptor->bLength), USB_AUDIO_CONTROL_TERMINAL_DESCRIPTOR_TYPE);
 344                 while (CommonDescriptor)
 345                 {
 346                     InputTerminalDescriptor = (PUSB_AUDIO_CONTROL_INPUT_TERMINAL_DESCRIPTOR)CommonDescriptor;
 347                     if (InputTerminalDescriptor->bDescriptorSubtype == 0x02 /* INPUT TERMINAL*/ || InputTerminalDescriptor->bDescriptorSubtype == 0x03 /* OUTPUT_TERMINAL*/)
 348                     {
 349                         NodeCount++;
 350                         DescriptorCount++;
 351                     }
 352                     else if (InputTerminalDescriptor->bDescriptorSubtype == 0x06 /* FEATURE_UNIT*/)
 353                     {
 354                         FeatureUnitDescriptor = (PUSB_AUDIO_CONTROL_FEATURE_UNIT_DESCRIPTOR)InputTerminalDescriptor;
 355                         DescriptorCount++;
 356
 357                         /* get controls from all channels*/
 358                         Value = 0;
 359                         Length = FeatureUnitDescriptor->bLength - 7;
 360                         for (Index = 0; Index < Length; Index++)
 361                         {
 362                             Value |= FeatureUnitDescriptor->bmaControls[Index];
 363                         }
 364
 365                         if (Value & 0x01) /* MUTE*/
 366                             NodeCount++;
 367                         if (Value & 0x02) /* VOLUME */
 368                             NodeCount++;
 369                         if (Value & 0x04) /* BASS */
 370                             NodeCount++;
 371                         if (Value & 0x08) /* MID */
 372                             NodeCount++;
 373                         if (Value & 0x10) /* TREBLE */
 374                             NodeCount++;
 375                         if (Value & 0x20) /* GRAPHIC EQUALIZER */
 376                             NodeCount++;
 377                         if (Value & 0x40) /* AUTOMATIC GAIN */
 378                             NodeCount++;
 379                         if (Value & 0x80) /* DELAY */
 380                             NodeCount++;
 381                     }
 382                     else if (InputTerminalDescriptor->bDescriptorSubtype == 0x04 /* MIXER_UNIT */)
 383                     {
 384                         MixerUnitDescriptor = (PUSB_AUDIO_CONTROL_MIXER_UNIT_DESCRIPTOR)InputTerminalDescriptor;
 385                         DescriptorCount++;
 386                         NodeCount += MixerUnitDescriptor->bNrInPins + 1; /* KSNODETYPE_SUPERMIX for each source pin and KSNODETYPE_SUM for target */
 387                     }
 388                     else if (InputTerminalDescriptor->bDescriptorSubtype == 0x05 /* SELECTOR_UNIT */)
 389                     {
 390                         SelectorUnitDescriptor = (PUSB_AUDIO_CONTROL_SELECTOR_UNIT_DESCRIPTOR)InputTerminalDescriptor;
 391                         DescriptorCount++;
 392                         NodeCount++;
 393                     }
 394                     else
 395                     {
 396                         UNIMPLEMENTED;
 397                     }
 398                     CommonDescriptor = (PUSB_COMMON_DESCRIPTOR)((ULONG_PTR)CommonDescriptor + CommonDescriptor->bLength);
 399                     if ((ULONG_PTR)CommonDescriptor >= ((ULONG_PTR)InterfaceHeaderDescriptor + InterfaceHeaderDescriptor->wTotalLength))
 400                         break;
 401                 }
 402             }
 403         }
 404     }
 405     *OutDescriptorCount = DescriptorCount;
 406     return NodeCount;
 407 }
 408
 409 PNODE_CONTEXT
 410 FindNodeContextWithId(
 411     IN PNODE_CONTEXT NodeContext,
 412     IN ULONG NodeContextCount,
 413     IN UCHAR TerminalId)
 414 {
 415     ULONG Index;
 416     PUSB_AUDIO_CONTROL_INPUT_TERMINAL_DESCRIPTOR TerminalDescriptor;
 417
 418     for (Index = 0; Index < NodeContextCount; Index++)
 419     {
 420         TerminalDescriptor = (PUSB_AUDIO_CONTROL_INPUT_TERMINAL_DESCRIPTOR)NodeContext[Index].Descriptor;
 421         if (TerminalDescriptor->bTerminalID == TerminalId)
 422             return &NodeContext[Index];
 423     }
 424     return NULL;
 425 }
 426
 427 NTSTATUS
 428 BuildUSBAudioFilterTopology(
 429     PKSDEVICE Device,
 430     PKSFILTER_DESCRIPTOR FilterDescriptor)
 431 {
 432     PDEVICE_EXTENSION DeviceExtension;
 433     ULONG NodeCount, Index, DescriptorCount, StreamingTerminalIndex, NonStreamingTerminalDescriptorCount, TotalTerminalDescriptorCount, StreamingTerminalPinOffset, ControlDescriptorCount, Length;
 434     UCHAR Value;
 435     PUSB_INTERFACE_DESCRIPTOR Descriptor;
 436     PUSB_AUDIO_CONTROL_INTERFACE_HEADER_DESCRIPTOR InterfaceHeaderDescriptor;
 437     PUSB_COMMON_DESCRIPTOR CommonDescriptor;
 438     PUSB_AUDIO_CONTROL_INPUT_TERMINAL_DESCRIPTOR InputTerminalDescriptor;
 439     PUSB_AUDIO_CONTROL_FEATURE_UNIT_DESCRIPTOR FeatureUnitDescriptor;
 440     PUSB_AUDIO_CONTROL_MIXER_UNIT_DESCRIPTOR MixerUnitDescriptor;
 441     PUSB_AUDIO_CONTROL_OUTPUT_TERMINAL_DESCRIPTOR OutputTerminalDescriptor;
 442     PUSB_AUDIO_CONTROL_SELECTOR_UNIT_DESCRIPTOR SelectorUnitDescriptor;
 443     PKSNODE_DESCRIPTOR NodeDescriptors;
 444     PNODE_CONTEXT NodeContext, PreviousNodeContext;
 445     PKSTOPOLOGY_CONNECTION Connections;
 446     PKSAUTOMATION_TABLE AutomationTable;
 447
 448     /* get device extension */
 449     DeviceExtension = Device->Context;
 450
 451     /* count topology nodes */
 452     NodeCount = CountTopologyComponents(DeviceExtension->ConfigurationDescriptor, &ControlDescriptorCount);
 453
 454     /* init node descriptors*/
 455     FilterDescriptor->NodeDescriptors = NodeDescriptors = AllocFunction(NodeCount * sizeof(KSNODE_DESCRIPTOR));
 456     if (FilterDescriptor->NodeDescriptors == NULL)
 457     {
 458         /* no memory */
 459         return STATUS_INSUFFICIENT_RESOURCES;
 460     }
 461     FilterDescriptor->NodeDescriptorSize = sizeof(KSNODE_DESCRIPTOR);
 462
 463     DeviceExtension->NodeContext = NodeContext = AllocFunction(sizeof(NODE_CONTEXT) * ControlDescriptorCount);
 464     if (!NodeContext)
 465     {
 466         /* no memory */
 467         return STATUS_INSUFFICIENT_RESOURCES;
 468     }
 469     DeviceExtension->NodeContextCount = ControlDescriptorCount;
 470     DescriptorCount = 0;
 471
 472     /* first enumerate all topology nodes */
 473     for (Descriptor = USBD_ParseConfigurationDescriptorEx(DeviceExtension->ConfigurationDescriptor, DeviceExtension->ConfigurationDescriptor, -1, -1, USB_DEVICE_CLASS_AUDIO, -1, -1);
 474     Descriptor != NULL;
 475         Descriptor = USBD_ParseConfigurationDescriptorEx(DeviceExtension->ConfigurationDescriptor, (PVOID)((ULONG_PTR)Descriptor + Descriptor->bLength), -1, -1, USB_DEVICE_CLASS_AUDIO, -1, -1))
 476     {
 477         if (Descriptor->bInterfaceSubClass == 0x01) /* AUDIO_CONTROL */
 478         {
 479             InterfaceHeaderDescriptor = (PUSB_AUDIO_CONTROL_INTERFACE_HEADER_DESCRIPTOR)USBD_ParseDescriptors(DeviceExtension->ConfigurationDescriptor, DeviceExtension->ConfigurationDescriptor->wTotalLength, Descriptor, USB_AUDIO_CONTROL_TERMINAL_DESCRIPTOR_TYPE);
 480             if (InterfaceHeaderDescriptor != NULL)
 481             {
 482                 CommonDescriptor = USBD_ParseDescriptors(InterfaceHeaderDescriptor, InterfaceHeaderDescriptor->wTotalLength, (PVOID)((ULONG_PTR)InterfaceHeaderDescriptor + InterfaceHeaderDescriptor->bLength), USB_AUDIO_CONTROL_TERMINAL_DESCRIPTOR_TYPE);
 483                 while (CommonDescriptor)
 484                 {
 485                     InputTerminalDescriptor = (PUSB_AUDIO_CONTROL_INPUT_TERMINAL_DESCRIPTOR)CommonDescriptor;
 486                     if (InputTerminalDescriptor->bDescriptorSubtype == 0x02 /* INPUT TERMINAL*/)
 487                     {
 488                         if (InputTerminalDescriptor->wTerminalType == USB_AUDIO_STREAMING_TERMINAL_TYPE)
 489                         {
 490                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Type = &KSNODETYPE_SRC;
 491                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Name = &KSNODETYPE_SRC;
 492                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].AutomationTable = AllocFunction(sizeof(KSAUTOMATION_TABLE));
 493
 494                             /* insert into node context*/
 495                             NodeContext[DescriptorCount].Descriptor = CommonDescriptor;
 496                             NodeContext[DescriptorCount].NodeCount = 1;
 497                             NodeContext[DescriptorCount].Nodes[0] = FilterDescriptor->NodeDescriptorsCount;
 498                             DescriptorCount++;
 499
 500                             FilterDescriptor->NodeDescriptorsCount++;
 501                         }
 502                         else if ((InputTerminalDescriptor->wTerminalType & 0xFF00) == 0x200)
 503                         {
 504                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Type = &KSNODETYPE_ADC;
 505                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Name = &KSNODETYPE_ADC;
 506                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].AutomationTable = AllocFunction(sizeof(KSAUTOMATION_TABLE));
 507
 508                             /* insert into node context*/
 509                             NodeContext[DescriptorCount].Descriptor = CommonDescriptor;
 510                             NodeContext[DescriptorCount].NodeCount = 1;
 511                             NodeContext[DescriptorCount].Nodes[0] = FilterDescriptor->NodeDescriptorsCount;
 512                             DescriptorCount++;
 513
 514
 515                             FilterDescriptor->NodeDescriptorsCount++;
 516                         }
 517                         else if ((InputTerminalDescriptor->wTerminalType & 0xFF00) == 0x300)
 518                         {
 519                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Type = &KSNODETYPE_DAC;
 520                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Name = &KSNODETYPE_DAC;
 521                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].AutomationTable = AllocFunction(sizeof(KSAUTOMATION_TABLE));
 522
 523                             /* insert into node context*/
 524                             NodeContext[DescriptorCount].Descriptor = CommonDescriptor;
 525                             NodeContext[DescriptorCount].NodeCount = 1;
 526                             NodeContext[DescriptorCount].Nodes[0] = FilterDescriptor->NodeDescriptorsCount;
 527                             DescriptorCount++;
 528
 529                             FilterDescriptor->NodeDescriptorsCount++;
 530                         }
 531                         else
 532                         {
 533                             DPRINT1("Unexpected input terminal type %x\n", InputTerminalDescriptor->wTerminalType);
 534                         }
 535                     }
 536                     else if (InputTerminalDescriptor->bDescriptorSubtype == 0x03 /* OUTPUT_TERMINAL*/)
 537                     {
 538                         if (InputTerminalDescriptor->wTerminalType == USB_AUDIO_STREAMING_TERMINAL_TYPE)
 539                         {
 540                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Type = &KSNODETYPE_SRC;
 541                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Name = &KSNODETYPE_SRC;
 542                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].AutomationTable = AllocFunction(sizeof(KSAUTOMATION_TABLE));
 543
 544                             /* insert into node context*/
 545                             NodeContext[DescriptorCount].Descriptor = CommonDescriptor;
 546                             NodeContext[DescriptorCount].NodeCount = 1;
 547                             NodeContext[DescriptorCount].Nodes[0] = FilterDescriptor->NodeDescriptorsCount;
 548                             DescriptorCount++;
 549
 550                             FilterDescriptor->NodeDescriptorsCount++;
 551                         }
 552                         else if ((InputTerminalDescriptor->wTerminalType & 0xFF00) == 0x300)
 553                         {
 554                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Type = &KSNODETYPE_DAC;
 555                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Name = &KSNODETYPE_DAC;
 556                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].AutomationTable = AllocFunction(sizeof(KSAUTOMATION_TABLE));
 557
 558                             /* insert into node context*/
 559                             NodeContext[DescriptorCount].Descriptor = CommonDescriptor;
 560                             NodeContext[DescriptorCount].NodeCount = 1;
 561                             NodeContext[DescriptorCount].Nodes[0] = FilterDescriptor->NodeDescriptorsCount;
 562                             DescriptorCount++;
 563
 564                             FilterDescriptor->NodeDescriptorsCount++;
 565                         }
 566                         else
 567                         {
 568                             DPRINT1("Unexpected output terminal type %x\n", InputTerminalDescriptor->wTerminalType);
 569                         }
 570                     }
 571
 572                     else if (InputTerminalDescriptor->bDescriptorSubtype == 0x06 /* FEATURE_UNIT*/)
 573                     {
 574                         FeatureUnitDescriptor = (PUSB_AUDIO_CONTROL_FEATURE_UNIT_DESCRIPTOR)CommonDescriptor;
 575
 576                         /* get controls from all channels*/
 577                         Value = 0;
 578                         Length = FeatureUnitDescriptor->bLength - 7;
 579                         for (Index = 0; Index < Length; Index++)
 580                         {
 581                             Value |= FeatureUnitDescriptor->bmaControls[Index];
 582                         }
 583
 584
 585                         if (Value & 0x01) /* MUTE*/
 586                         {
 587                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Type = &KSNODETYPE_MUTE;
 588                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Name = &KSNODETYPE_MUTE;
 589                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].AutomationTable = AutomationTable = AllocFunction(sizeof(KSAUTOMATION_TABLE));
 590                             if (AutomationTable)
 591                             {
 592                                 AutomationTable->PropertySets = FilterAudioMutePropertySetArray;
 593                                 AutomationTable->PropertySetsCount = 1;
 594                                 AutomationTable->PropertyItemSize = sizeof(KSPROPERTY_ITEM);
 595                             }
 596
 597                             /* insert into node context*/
 598                             NodeContext[DescriptorCount].Nodes[NodeContext[DescriptorCount].NodeCount] = FilterDescriptor->NodeDescriptorsCount;
 599                             NodeContext[DescriptorCount].NodeCount++;
 600
 601                             FilterDescriptor->NodeDescriptorsCount++;
 602                         }
 603                         if (Value & 0x02) /* VOLUME */
 604                         {
 605                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Type = &KSNODETYPE_VOLUME;
 606                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Name = &KSNODETYPE_VOLUME;
 607                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].AutomationTable = AutomationTable = AllocFunction(sizeof(KSAUTOMATION_TABLE));
 608                             if (AutomationTable)
 609                             {
 610                                 AutomationTable->PropertySets = FilterAudioVolumePropertySetArray;
 611                                 AutomationTable->PropertySetsCount = 1;
 612                                 AutomationTable->PropertyItemSize = sizeof(KSPROPERTY_ITEM);
 613                             }
 614
 615                             /* insert into node context*/
 616                             NodeContext[DescriptorCount].Nodes[NodeContext[DescriptorCount].NodeCount] = FilterDescriptor->NodeDescriptorsCount;
 617                             NodeContext[DescriptorCount].NodeCount++;
 618
 619                             FilterDescriptor->NodeDescriptorsCount++;
 620                         }
 621
 622                         if (Value & 0x04) /* BASS */
 623                         {
 624                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Type = &KSNODETYPE_TONE;
 625                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Name = &KSNODETYPE_TONE;
 626                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].AutomationTable = AllocFunction(sizeof(KSAUTOMATION_TABLE));
 627
 628                             /* insert into node context*/
 629                             NodeContext[DescriptorCount].Nodes[NodeContext[DescriptorCount].NodeCount] = FilterDescriptor->NodeDescriptorsCount;
 630                             NodeContext[DescriptorCount].NodeCount++;
 631
 632                             FilterDescriptor->NodeDescriptorsCount++;
 633                         }
 634
 635                         if (Value & 0x08) /* MID */
 636                         {
 637                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Type = &KSNODETYPE_TONE;
 638                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Name = &KSNODETYPE_TONE;
 639                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].AutomationTable = AllocFunction(sizeof(KSAUTOMATION_TABLE));
 640
 641                             /* insert into node context*/
 642                             NodeContext[DescriptorCount].Nodes[NodeContext[DescriptorCount].NodeCount] = FilterDescriptor->NodeDescriptorsCount;
 643                             NodeContext[DescriptorCount].NodeCount++;
 644
 645                             FilterDescriptor->NodeDescriptorsCount++;
 646                         }
 647
 648                         if (Value & 0x10) /* TREBLE */
 649                         {
 650                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Type = &KSNODETYPE_TONE;
 651                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Name = &KSNODETYPE_TONE;
 652                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].AutomationTable = AllocFunction(sizeof(KSAUTOMATION_TABLE));
 653
 654                             /* insert into node context*/
 655                             NodeContext[DescriptorCount].Nodes[NodeContext[DescriptorCount].NodeCount] = FilterDescriptor->NodeDescriptorsCount;
 656                             NodeContext[DescriptorCount].NodeCount++;
 657
 658
 659                             FilterDescriptor->NodeDescriptorsCount++;
 660                         }
 661
 662                         if (Value & 0x20) /* GRAPHIC EQUALIZER */
 663                         {
 664                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Type = &KSNODETYPE_TONE;
 665                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Name = &KSNODETYPE_TONE;
 666                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].AutomationTable = AllocFunction(sizeof(KSAUTOMATION_TABLE));
 667
 668                             /* insert into node context*/
 669                             NodeContext[DescriptorCount].Nodes[NodeContext[DescriptorCount].NodeCount] = FilterDescriptor->NodeDescriptorsCount;
 670                             NodeContext[DescriptorCount].NodeCount++;
 671
 672                             FilterDescriptor->NodeDescriptorsCount++;
 673                         }
 674
 675                         if (Value & 0x40) /* AUTOMATIC GAIN */
 676                         {
 677                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Type = &KSNODETYPE_AGC;
 678                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Name = &KSNODETYPE_AGC;
 679                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].AutomationTable = AllocFunction(sizeof(KSAUTOMATION_TABLE));
 680
 681                             /* insert into node context*/
 682                             NodeContext[DescriptorCount].Nodes[NodeContext[DescriptorCount].NodeCount] = FilterDescriptor->NodeDescriptorsCount;
 683                             NodeContext[DescriptorCount].NodeCount++;
 684
 685
 686                             FilterDescriptor->NodeDescriptorsCount++;
 687                         }
 688
 689                         if (Value & 0x80) /* DELAY */
 690                         {
 691                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Type = &KSNODETYPE_TONE;
 692                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Name = &KSNODETYPE_TONE;
 693                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].AutomationTable = AllocFunction(sizeof(KSAUTOMATION_TABLE));
 694
 695                             /* insert into node context*/
 696                             NodeContext[DescriptorCount].Nodes[NodeContext[DescriptorCount].NodeCount] = FilterDescriptor->NodeDescriptorsCount;
 697                             NodeContext[DescriptorCount].NodeCount++;
 698
 699                             FilterDescriptor->NodeDescriptorsCount++;
 700                         }
 701                         NodeContext[DescriptorCount].Descriptor = CommonDescriptor;
 702                         DescriptorCount++;
 703
 704                     }
 705                     else if (InputTerminalDescriptor->bDescriptorSubtype == 0x04 /* MIXER_UNIT */)
 706                     {
 707                         MixerUnitDescriptor = (PUSB_AUDIO_CONTROL_MIXER_UNIT_DESCRIPTOR)CommonDescriptor;
 708                         for (Index = 0; Index < MixerUnitDescriptor->bNrInPins; Index++)
 709                         {
 710                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Type = &KSNODETYPE_SUPERMIX;
 711                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Name = &KSNODETYPE_SUPERMIX;
 712                             NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].AutomationTable = AllocFunction(sizeof(KSAUTOMATION_TABLE));
 713
 714                             /* insert into node context*/
 715                             NodeContext[DescriptorCount].Nodes[NodeContext[DescriptorCount].NodeCount] = FilterDescriptor->NodeDescriptorsCount;
 716                             NodeContext[DescriptorCount].NodeCount++;
 717
 718                             FilterDescriptor->NodeDescriptorsCount++;
 719                         }
 720
 721                         NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Type = &KSNODETYPE_SUM;
 722                         NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Name = &KSNODETYPE_SUM;
 723                         NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].AutomationTable = AllocFunction(sizeof(KSAUTOMATION_TABLE));
 724
 725                         /* insert into node context*/
 726                         NodeContext[DescriptorCount].Nodes[NodeContext[DescriptorCount].NodeCount] = FilterDescriptor->NodeDescriptorsCount;
 727                         NodeContext[DescriptorCount].NodeCount++;
 728                         NodeContext[DescriptorCount].Descriptor = CommonDescriptor;
 729                         DescriptorCount++;
 730
 731                         FilterDescriptor->NodeDescriptorsCount++;
 732                     }
 733                     else if (InputTerminalDescriptor->bDescriptorSubtype == 0x05 /* SELECTOR UNIT */)
 734                     {
 735                         NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Type = &KSNODETYPE_MUX;
 736                         NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].Name = &KSNODETYPE_MUX;
 737                         NodeDescriptors[FilterDescriptor->NodeDescriptorsCount].AutomationTable = AllocFunction(sizeof(KSAUTOMATION_TABLE));
 738
 739                         /* insert into node context*/
 740                         NodeContext[DescriptorCount].Descriptor = CommonDescriptor;
 741                         NodeContext[DescriptorCount].NodeCount = 1;
 742                         NodeContext[DescriptorCount].Nodes[0] = FilterDescriptor->NodeDescriptorsCount;
 743                         DescriptorCount++;
 744                         FilterDescriptor->NodeDescriptorsCount++;
 745                     }
 746                     else
 747                     {
 748                         UNIMPLEMENTED;
 749                     }
 750                     CommonDescriptor = (PUSB_COMMON_DESCRIPTOR)((ULONG_PTR)CommonDescriptor + CommonDescriptor->bLength);
 751                     if ((ULONG_PTR)CommonDescriptor >= ((ULONG_PTR)InterfaceHeaderDescriptor + InterfaceHeaderDescriptor->wTotalLength))
 752                         break;
 753                 }
 754             }
 755         }
 756     }
 757
 758     /* FIXME determine connections count*/
 759     FilterDescriptor->Connections = Connections = AllocFunction(sizeof(KSTOPOLOGY_CONNECTION) * FilterDescriptor->NodeDescriptorsCount * 2);
 760     if (!FilterDescriptor->Connections)
 761     {
 762         /* no memory */
 763         return STATUS_INSUFFICIENT_RESOURCES;
 764     }
 765     FilterDescriptor->ConnectionsCount = 0;
 766
 767     /* now build connections array */
 768     DescriptorCount = 0;
 769     StreamingTerminalIndex = 0;
 770     NodeCount = 0;
 771
 772     CountTerminalUnits(DeviceExtension->ConfigurationDescriptor, &NonStreamingTerminalDescriptorCount, &TotalTerminalDescriptorCount);
 773     StreamingTerminalPinOffset = TotalTerminalDescriptorCount - NonStreamingTerminalDescriptorCount;
 774
 775     for (Descriptor = USBD_ParseConfigurationDescriptorEx(DeviceExtension->ConfigurationDescriptor, DeviceExtension->ConfigurationDescriptor, -1, -1, USB_DEVICE_CLASS_AUDIO, -1, -1);
 776     Descriptor != NULL;
 777         Descriptor = USBD_ParseConfigurationDescriptorEx(DeviceExtension->ConfigurationDescriptor, (PVOID)((ULONG_PTR)Descriptor + Descriptor->bLength), -1, -1, USB_DEVICE_CLASS_AUDIO, -1, -1))
 778     {
 779         if (Descriptor->bInterfaceSubClass == 0x01) /* AUDIO_CONTROL */
 780         {
 781             InterfaceHeaderDescriptor = (PUSB_AUDIO_CONTROL_INTERFACE_HEADER_DESCRIPTOR)USBD_ParseDescriptors(DeviceExtension->ConfigurationDescriptor, DeviceExtension->ConfigurationDescriptor->wTotalLength, Descriptor, USB_AUDIO_CONTROL_TERMINAL_DESCRIPTOR_TYPE);
 782             if (InterfaceHeaderDescriptor != NULL)
 783             {
 784                 CommonDescriptor = USBD_ParseDescriptors(InterfaceHeaderDescriptor, InterfaceHeaderDescriptor->wTotalLength, (PVOID)((ULONG_PTR)InterfaceHeaderDescriptor + InterfaceHeaderDescriptor->bLength), USB_AUDIO_CONTROL_TERMINAL_DESCRIPTOR_TYPE);
 785                 while (CommonDescriptor)
 786                 {
 787                     InputTerminalDescriptor = (PUSB_AUDIO_CONTROL_INPUT_TERMINAL_DESCRIPTOR)CommonDescriptor;
 788                     if (InputTerminalDescriptor->bDescriptorSubtype == 0x02 /* INPUT TERMINAL*/)
 789                     {
 790                         if (InputTerminalDescriptor->wTerminalType == USB_AUDIO_STREAMING_TERMINAL_TYPE)
 791                         {
 792                              Connections[FilterDescriptor->ConnectionsCount].FromNode = KSFILTER_NODE;
 793                              Connections[FilterDescriptor->ConnectionsCount].FromNodePin = StreamingTerminalIndex;
 794                              Connections[FilterDescriptor->ConnectionsCount].ToNodePin = 1;
 795                              Connections[FilterDescriptor->ConnectionsCount].ToNode = NodeContext[DescriptorCount].Nodes[0];
 796                              FilterDescriptor->ConnectionsCount++;
 797                              StreamingTerminalIndex++;
 798
 799                         }
 800                         else
 801                         {
 802                             Connections[FilterDescriptor->ConnectionsCount].FromNode = KSFILTER_NODE;
 803                             Connections[FilterDescriptor->ConnectionsCount].FromNodePin = StreamingTerminalPinOffset;
 804                             Connections[FilterDescriptor->ConnectionsCount].ToNodePin = 1;
 805                             Connections[FilterDescriptor->ConnectionsCount].ToNode = NodeContext[DescriptorCount].Nodes[0];
 806                             FilterDescriptor->ConnectionsCount++;
 807                             StreamingTerminalPinOffset++;
 808                         }
 809                         DescriptorCount++;
 810                     }
 811                     else if (InputTerminalDescriptor->bDescriptorSubtype == 0x03 /* OUTPUT_TERMINAL*/)
 812                     {
 813                         OutputTerminalDescriptor = (PUSB_AUDIO_CONTROL_OUTPUT_TERMINAL_DESCRIPTOR)CommonDescriptor;
 814                         PreviousNodeContext = FindNodeContextWithId(NodeContext, ControlDescriptorCount, OutputTerminalDescriptor->bSourceID);
 815                         if (PreviousNodeContext)
 816                         {
 817                             Connections[FilterDescriptor->ConnectionsCount].FromNode = PreviousNodeContext->Nodes[PreviousNodeContext->NodeCount - 1];
 818                             Connections[FilterDescriptor->ConnectionsCount].FromNodePin = 0;
 819                             Connections[FilterDescriptor->ConnectionsCount].ToNodePin = 1;
 820                             Connections[FilterDescriptor->ConnectionsCount].ToNode = NodeContext[DescriptorCount].Nodes[0];
 821                             FilterDescriptor->ConnectionsCount++;
 822                         }
 823
 824                         if (InputTerminalDescriptor->wTerminalType == USB_AUDIO_STREAMING_TERMINAL_TYPE)
 825                         {
 826                             Connections[FilterDescriptor->ConnectionsCount].FromNode = NodeContext[DescriptorCount].Nodes[0];
 827                             Connections[FilterDescriptor->ConnectionsCount].FromNodePin = 0;
 828                             Connections[FilterDescriptor->ConnectionsCount].ToNodePin = StreamingTerminalIndex;
 829                             Connections[FilterDescriptor->ConnectionsCount].ToNode = KSFILTER_NODE;
 830                             FilterDescriptor->ConnectionsCount++;
 831                             StreamingTerminalIndex++;
 832                         }
 833                         else
 834                         {
 835                             Connections[FilterDescriptor->ConnectionsCount].FromNode = NodeContext[DescriptorCount].Nodes[0];
 836                             Connections[FilterDescriptor->ConnectionsCount].FromNodePin = 0;
 837                             Connections[FilterDescriptor->ConnectionsCount].ToNodePin = StreamingTerminalPinOffset;
 838                             Connections[FilterDescriptor->ConnectionsCount].ToNode = KSFILTER_NODE;
 839                             FilterDescriptor->ConnectionsCount++;
 840
 841                             StreamingTerminalPinOffset++;
 842                         }
 843                         DescriptorCount++;
 844                     }
 845                     else if (InputTerminalDescriptor->bDescriptorSubtype == 0x06 /* FEATURE_UNIT*/)
 846                     {
 847                         FeatureUnitDescriptor = (PUSB_AUDIO_CONTROL_FEATURE_UNIT_DESCRIPTOR)InputTerminalDescriptor;
 848                         PreviousNodeContext = FindNodeContextWithId(NodeContext, ControlDescriptorCount, FeatureUnitDescriptor->bSourceID);
 849                         if (PreviousNodeContext)
 850                         {
 851                             Connections[FilterDescriptor->ConnectionsCount].FromNode = PreviousNodeContext->Nodes[PreviousNodeContext->NodeCount-1];
 852                             Connections[FilterDescriptor->ConnectionsCount].FromNodePin = 0;
 853                             Connections[FilterDescriptor->ConnectionsCount].ToNodePin = 1;
 854                             Connections[FilterDescriptor->ConnectionsCount].ToNode = NodeContext[DescriptorCount].Nodes[0];
 855                             FilterDescriptor->ConnectionsCount++;
 856                         }
 857                         for (Index = 1; Index < NodeContext[DescriptorCount].NodeCount; Index++)
 858                         {
 859                             Connections[FilterDescriptor->ConnectionsCount].FromNode = NodeContext[DescriptorCount].Nodes[Index - 1];
 860                             Connections[FilterDescriptor->ConnectionsCount].FromNodePin = 0;
 861                             Connections[FilterDescriptor->ConnectionsCount].ToNodePin = 1;
 862                             Connections[FilterDescriptor->ConnectionsCount].ToNode = NodeContext[DescriptorCount].Nodes[Index];
 863                             FilterDescriptor->ConnectionsCount++;
 864                         }
 865
 866                         DescriptorCount++;
 867                     }
 868                     else if (InputTerminalDescriptor->bDescriptorSubtype == 0x04 /* MIXER_UNIT */)
 869                     {
 870                         MixerUnitDescriptor = (PUSB_AUDIO_CONTROL_MIXER_UNIT_DESCRIPTOR)InputTerminalDescriptor;
 871                         for (Index = 0; Index < MixerUnitDescriptor->bNrInPins; Index++)
 872                         {
 873                             Value = MixerUnitDescriptor->baSourceID[Index];
 874                             PreviousNodeContext = FindNodeContextWithId(NodeContext, ControlDescriptorCount, Value);
 875                             if (PreviousNodeContext)
 876                             {
 877                                 Connections[FilterDescriptor->ConnectionsCount].FromNode = PreviousNodeContext->Nodes[PreviousNodeContext->NodeCount - 1];
 878                                 Connections[FilterDescriptor->ConnectionsCount].FromNodePin = 0;
 879                                 Connections[FilterDescriptor->ConnectionsCount].ToNodePin = 1;
 880                                 Connections[FilterDescriptor->ConnectionsCount].ToNode = NodeContext[DescriptorCount].Nodes[Index];
 881                                 FilterDescriptor->ConnectionsCount++;
 882                             }
 883
 884                             Connections[FilterDescriptor->ConnectionsCount].FromNode = NodeContext[DescriptorCount].Nodes[Index];
 885                             Connections[FilterDescriptor->ConnectionsCount].FromNodePin = 0;
 886                             Connections[FilterDescriptor->ConnectionsCount].ToNodePin = 1 + Index;
 887                             Connections[FilterDescriptor->ConnectionsCount].ToNode = NodeContext[DescriptorCount].Nodes[NodeContext[DescriptorCount].NodeCount-1];
 888                             FilterDescriptor->ConnectionsCount++;
 889                         }
 890                         DescriptorCount++;
 891                     }
 892                     else if (InputTerminalDescriptor->bDescriptorSubtype == 0x05 /* SELECTOR_UNIT */)
 893                     {
 894                         SelectorUnitDescriptor = (PUSB_AUDIO_CONTROL_SELECTOR_UNIT_DESCRIPTOR)InputTerminalDescriptor;
 895                         for (Index = 0; Index < SelectorUnitDescriptor->bNrInPins; Index++)
 896                         {
 897                             Value = SelectorUnitDescriptor->baSourceID[Index];
 898                             PreviousNodeContext = FindNodeContextWithId(NodeContext, ControlDescriptorCount, Value);
 899                             if (PreviousNodeContext)
 900                             {
 901                                 Connections[FilterDescriptor->ConnectionsCount].FromNode = PreviousNodeContext->Nodes[PreviousNodeContext->NodeCount - 1];
 902                                 Connections[FilterDescriptor->ConnectionsCount].FromNodePin = 0;
 903                                 Connections[FilterDescriptor->ConnectionsCount].ToNodePin = 1;
 904                                 Connections[FilterDescriptor->ConnectionsCount].ToNode = NodeContext[DescriptorCount].Nodes[0];
 905                                 FilterDescriptor->ConnectionsCount++;
 906                             }
 907                         }
 908                         DescriptorCount++;
 909                     }
 910                     else
 911                     {
 912                         UNIMPLEMENTED;
 913                     }
 914                     CommonDescriptor = (PUSB_COMMON_DESCRIPTOR)((ULONG_PTR)CommonDescriptor + CommonDescriptor->bLength);
 915                     if ((ULONG_PTR)CommonDescriptor >= ((ULONG_PTR)InterfaceHeaderDescriptor + InterfaceHeaderDescriptor->wTotalLength))
 916                         break;
 917                 }
 918             }
 919         }
 920     }
 921
 922
 923
 924     return STATUS_SUCCESS;
 925 }
 926
 927 NTSTATUS
 928 NTAPI
 929 USBAudioFilterCreate(
 930     PKSFILTER Filter,
 931     PIRP Irp)
 932 {
 933     PKSFILTERFACTORY FilterFactory;
 934     PKSDEVICE Device;
 935     PFILTER_CONTEXT FilterContext;
 936
 937     FilterFactory = KsGetParent(Filter);
 938     if (FilterFactory == NULL)
 939     {
 940         /* invalid parameter */
 941         return STATUS_INVALID_PARAMETER;
 942     }
 943
 944     Device = KsGetParent(FilterFactory);
 945     if (Device == NULL)
 946     {
 947         /* invalid parameter */
 948         return STATUS_INVALID_PARAMETER;
 949     }
 950
 951     /* alloc filter context */
 952     FilterContext = AllocFunction(sizeof(FILTER_CONTEXT));
 953     if (FilterContext == NULL)
 954     {
 955         /* no memory */
 956         return STATUS_INSUFFICIENT_RESOURCES;
 957     }
 958
 959     /* init context */
 960     FilterContext->DeviceExtension = Device->Context;
 961     FilterContext->LowerDevice = Device->NextDeviceObject;
 962     Filter->Context = FilterContext;
 963
 964     DPRINT("USBAudioFilterCreate FilterContext %p LowerDevice %p DeviceExtension %p\n", FilterContext, FilterContext->LowerDevice, FilterContext->DeviceExtension);
 965     KsAddItemToObjectBag(Filter->Bag, FilterContext, ExFreePool);
 966     return STATUS_SUCCESS;
 967 }
 968
 969
 970 VOID
 971 NTAPI
 972 CountTerminalUnits(
 973     IN PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor,
 974     OUT PULONG NonStreamingTerminalDescriptorCount,
 975     OUT PULONG TotalTerminalDescriptorCount)
 976 {
 977     PUSB_INTERFACE_DESCRIPTOR Descriptor;
 978     PUSB_AUDIO_CONTROL_INTERFACE_HEADER_DESCRIPTOR InterfaceHeaderDescriptor;
 979     PUSB_COMMON_DESCRIPTOR CommonDescriptor;
 980     PUSB_AUDIO_CONTROL_INPUT_TERMINAL_DESCRIPTOR InputTerminalDescriptor;
 981     ULONG NonStreamingTerminalCount = 0;
 982     ULONG TotalTerminalCount = 0;
 983
 984     for(Descriptor = USBD_ParseConfigurationDescriptorEx(ConfigurationDescriptor, ConfigurationDescriptor, -1, -1, USB_DEVICE_CLASS_AUDIO, -1, -1);
 985         Descriptor != NULL;
 986         Descriptor = USBD_ParseConfigurationDescriptorEx(ConfigurationDescriptor, (PVOID)((ULONG_PTR)Descriptor + Descriptor->bLength), -1, -1, USB_DEVICE_CLASS_AUDIO, -1, -1))
 987     {
 988         if (Descriptor->bInterfaceSubClass == 0x01) /* AUDIO_CONTROL */
 989         {
 990             InterfaceHeaderDescriptor = (PUSB_AUDIO_CONTROL_INTERFACE_HEADER_DESCRIPTOR)USBD_ParseDescriptors(ConfigurationDescriptor, ConfigurationDescriptor->wTotalLength, Descriptor, USB_AUDIO_CONTROL_TERMINAL_DESCRIPTOR_TYPE);
 991             if (InterfaceHeaderDescriptor != NULL)
 992             {
 993                 CommonDescriptor = USBD_ParseDescriptors(InterfaceHeaderDescriptor, InterfaceHeaderDescriptor->wTotalLength, (PVOID)((ULONG_PTR)InterfaceHeaderDescriptor + InterfaceHeaderDescriptor->bLength), USB_AUDIO_CONTROL_TERMINAL_DESCRIPTOR_TYPE);
 994                 while (CommonDescriptor)
 995                 {
 996                     InputTerminalDescriptor = (PUSB_AUDIO_CONTROL_INPUT_TERMINAL_DESCRIPTOR)CommonDescriptor;
 997                     if (InputTerminalDescriptor->bDescriptorSubtype == 0x02 /* INPUT TERMINAL*/ || InputTerminalDescriptor->bDescriptorSubtype == 0x03 /* OUTPUT_TERMINAL*/)
 998                     {
 999                         if (InputTerminalDescriptor->wTerminalType != USB_AUDIO_STREAMING_TERMINAL_TYPE)
1000                         {
1001                             NonStreamingTerminalCount++;
1002                         }
1003                         TotalTerminalCount++;
1004                     }
1005                     CommonDescriptor = (PUSB_COMMON_DESCRIPTOR)((ULONG_PTR)CommonDescriptor + CommonDescriptor->bLength);
1006                     if ((ULONG_PTR)CommonDescriptor >= ((ULONG_PTR)InterfaceHeaderDescriptor + InterfaceHeaderDescriptor->wTotalLength))
1007                         break;
1008                 }
1009             }
1010         }
1011         else if (Descriptor->bInterfaceSubClass == 0x03) /* MIDI_STREAMING */
1012         {
1013             UNIMPLEMENTED;
1014         }
1015     }
1016     *NonStreamingTerminalDescriptorCount = NonStreamingTerminalCount;
1017     *TotalTerminalDescriptorCount = TotalTerminalCount;
1018 }
1019
1020 LPGUID
1021 UsbAudioGetPinCategoryFromTerminalDescriptor(
1022     IN PUSB_AUDIO_CONTROL_INPUT_TERMINAL_DESCRIPTOR TerminalDescriptor)
1023 {
1024     if (TerminalDescriptor->wTerminalType == USB_AUDIO_MICROPHONE_TERMINAL_TYPE)
1025         return &NodeTypeMicrophone;
1026     else if (TerminalDescriptor->wTerminalType == USB_AUDIO_DESKTOP_MICROPHONE_TERMINAL_TYPE)
1027         return &NodeTypeDesktopMicrophone;
1028     else if (TerminalDescriptor->wTerminalType == USB_AUDIO_PERSONAL_MICROPHONE_TERMINAL_TYPE)
1029         return &NodeTypePersonalMicrophone;
1030     else if (TerminalDescriptor->wTerminalType == USB_AUDIO_OMMNI_MICROPHONE_TERMINAL_TYPE)
1031         return &NodeTypeOmmniMicrophone;
1032     else if (TerminalDescriptor->wTerminalType == USB_AUDIO_ARRAY_MICROPHONE_TERMINAL_TYPE)
1033         return &NodeTypeArrayMicrophone;
1034     else if (TerminalDescriptor->wTerminalType == USB_AUDIO_ARRAY_PROCESSING_MICROPHONE_TERMINAL_TYPE)
1035         return &NodeTypeProcessingArrayMicrophone;
1036
1037     /* playback types */
1038     if (TerminalDescriptor->wTerminalType == USB_AUDIO_SPEAKER_TERMINAL_TYPE)
1039         return &NodeTypeSpeaker;
1040     else if (TerminalDescriptor->wTerminalType == USB_HEADPHONES_SPEAKER_TERMINAL_TYPE)
1041         return &NodeTypeHeadphonesSpeaker;
1042     else if (TerminalDescriptor->wTerminalType == USB_AUDIO_HMDA_TERMINAL_TYPE)
1043         return &NodeTypeHMDA;
1044     else if (TerminalDescriptor->wTerminalType == USB_AUDIO_DESKTOP_SPEAKER_TERMINAL_TYPE)
1045         return &NodeTypeDesktopSpeaker;
1046     else if (TerminalDescriptor->wTerminalType == USB_AUDIO_ROOM_SPEAKER_TERMINAL_TYPE)
1047         return &NodeTypeRoomSpeaker;
1048     else if (TerminalDescriptor->wTerminalType == USB_AUDIO_COMMUNICATION_SPEAKER_TERMINAL_TYPE)
1049         return &NodeTypeCommunicationSpeaker;
1050     else if (TerminalDescriptor->wTerminalType == USB_AUDIO_SUBWOOFER_TERMINAL_TYPE)
1051         return &NodeTypeSubwoofer;
1052
1053     if (TerminalDescriptor->wTerminalType == USB_AUDIO_STREAMING_TERMINAL_TYPE)
1054     {
1055         if (TerminalDescriptor->bDescriptorSubtype == USB_AUDIO_OUTPUT_TERMINAL)
1056             return &NodeTypeCapture;
1057         else if (TerminalDescriptor->bDescriptorSubtype == USB_AUDIO_INPUT_TERMINAL)
1058             return &NodeTypePlayback;
1059
1060     }
1061     return NULL;
1062 }
1063
1064 PUSB_AUDIO_CONTROL_INPUT_TERMINAL_DESCRIPTOR
1065 UsbAudioGetStreamingTerminalDescriptorByIndex(
1066     IN PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor,
1067     IN ULONG Index)
1068 {
1069     PUSB_INTERFACE_DESCRIPTOR Descriptor;
1070     PUSB_AUDIO_CONTROL_INTERFACE_HEADER_DESCRIPTOR InterfaceHeaderDescriptor;
1071     PUSB_COMMON_DESCRIPTOR CommonDescriptor;
1072     PUSB_AUDIO_CONTROL_INPUT_TERMINAL_DESCRIPTOR InputTerminalDescriptor;
1073     ULONG TerminalCount = 0;
1074
1075     for (Descriptor = USBD_ParseConfigurationDescriptorEx(ConfigurationDescriptor, ConfigurationDescriptor, -1, -1, USB_DEVICE_CLASS_AUDIO, -1, -1);
1076     Descriptor != NULL;
1077         Descriptor = USBD_ParseConfigurationDescriptorEx(ConfigurationDescriptor, (PVOID)((ULONG_PTR)Descriptor + Descriptor->bLength), -1, -1, USB_DEVICE_CLASS_AUDIO, -1, -1))
1078     {
1079         if (Descriptor->bInterfaceSubClass == 0x01) /* AUDIO_CONTROL */
1080         {
1081             InterfaceHeaderDescriptor = (PUSB_AUDIO_CONTROL_INTERFACE_HEADER_DESCRIPTOR)USBD_ParseDescriptors(ConfigurationDescriptor, ConfigurationDescriptor->wTotalLength, Descriptor, USB_AUDIO_CONTROL_TERMINAL_DESCRIPTOR_TYPE);
1082             if (InterfaceHeaderDescriptor != NULL)
1083             {
1084                 CommonDescriptor = USBD_ParseDescriptors(InterfaceHeaderDescriptor, InterfaceHeaderDescriptor->wTotalLength, (PVOID)((ULONG_PTR)InterfaceHeaderDescriptor + InterfaceHeaderDescriptor->bLength), USB_AUDIO_CONTROL_TERMINAL_DESCRIPTOR_TYPE);
1085                 while (CommonDescriptor)
1086                 {
1087                     InputTerminalDescriptor = (PUSB_AUDIO_CONTROL_INPUT_TERMINAL_DESCRIPTOR)CommonDescriptor;
1088                     if (InputTerminalDescriptor->bDescriptorSubtype == 0x02 /* INPUT TERMINAL*/ || InputTerminalDescriptor->bDescriptorSubtype == 0x03 /* OUTPUT_TERMINAL*/)
1089                     {
1090                         if (InputTerminalDescriptor->wTerminalType == USB_AUDIO_STREAMING_TERMINAL_TYPE)
1091                         {
1092                             if (TerminalCount == Index)
1093                             {
1094                                 return InputTerminalDescriptor;
1095                             }
1096                             TerminalCount++;
1097                         }
1098                     }
1099                     CommonDescriptor = (PUSB_COMMON_DESCRIPTOR)((ULONG_PTR)CommonDescriptor + CommonDescriptor->bLength);
1100                     if ((ULONG_PTR)CommonDescriptor >= ((ULONG_PTR)InterfaceHeaderDescriptor + InterfaceHeaderDescriptor->wTotalLength))
1101                         break;
1102                 }
1103             }
1104         }
1105     }
1106     return NULL;
1107 }
1108
1109 PUSB_AUDIO_CONTROL_INPUT_TERMINAL_DESCRIPTOR
1110 UsbAudioGetNonStreamingTerminalDescriptorByIndex(
1111     IN PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor,
1112     IN ULONG Index)
1113 {
1114
1115     PUSB_INTERFACE_DESCRIPTOR Descriptor;
1116     PUSB_AUDIO_CONTROL_INTERFACE_HEADER_DESCRIPTOR InterfaceHeaderDescriptor;
1117     PUSB_COMMON_DESCRIPTOR CommonDescriptor;
1118     PUSB_AUDIO_CONTROL_INPUT_TERMINAL_DESCRIPTOR InputTerminalDescriptor;
1119     ULONG TerminalCount = 0;
1120
1121     for (Descriptor = USBD_ParseConfigurationDescriptorEx(ConfigurationDescriptor, ConfigurationDescriptor, -1, -1, USB_DEVICE_CLASS_AUDIO, -1, -1);
1122     Descriptor != NULL;
1123         Descriptor = USBD_ParseConfigurationDescriptorEx(ConfigurationDescriptor, (PVOID)((ULONG_PTR)Descriptor + Descriptor->bLength), -1, -1, USB_DEVICE_CLASS_AUDIO, -1, -1))
1124     {
1125         if (Descriptor->bInterfaceSubClass == 0x01) /* AUDIO_CONTROL */
1126         {
1127             InterfaceHeaderDescriptor = (PUSB_AUDIO_CONTROL_INTERFACE_HEADER_DESCRIPTOR)USBD_ParseDescriptors(ConfigurationDescriptor, ConfigurationDescriptor->wTotalLength, Descriptor, USB_AUDIO_CONTROL_TERMINAL_DESCRIPTOR_TYPE);
1128             if (InterfaceHeaderDescriptor != NULL)
1129             {
1130                 CommonDescriptor = USBD_ParseDescriptors(InterfaceHeaderDescriptor, InterfaceHeaderDescriptor->wTotalLength, (PVOID)((ULONG_PTR)InterfaceHeaderDescriptor + InterfaceHeaderDescriptor->bLength), USB_AUDIO_CONTROL_TERMINAL_DESCRIPTOR_TYPE);
1131                 while (CommonDescriptor)
1132                 {
1133                     InputTerminalDescriptor = (PUSB_AUDIO_CONTROL_INPUT_TERMINAL_DESCRIPTOR)CommonDescriptor;
1134                     if (InputTerminalDescriptor->bDescriptorSubtype == 0x02 /* INPUT TERMINAL*/ || InputTerminalDescriptor->bDescriptorSubtype == 0x03 /* OUTPUT_TERMINAL*/)
1135                     {
1136                         if (InputTerminalDescriptor->wTerminalType != USB_AUDIO_STREAMING_TERMINAL_TYPE)
1137                         {
1138                             if (TerminalCount == Index)
1139                             {
1140                                 return InputTerminalDescriptor;
1141                             }
1142                             TerminalCount++;
1143                         }
1144                     }
1145                     CommonDescriptor = (PUSB_COMMON_DESCRIPTOR)((ULONG_PTR)CommonDescriptor + CommonDescriptor->bLength);
1146                     if ((ULONG_PTR)CommonDescriptor >= ((ULONG_PTR)InterfaceHeaderDescriptor + InterfaceHeaderDescriptor->wTotalLength))
1147                         break;
1148                 }
1149             }
1150         }
1151     }
1152     return NULL;
1153 }
1154
1155 VOID
1156 UsbAudioGetDataRanges(
1157     IN PUSB_CONFIGURATION_DESCRIPTOR ConfigurationDescriptor,
1158     IN UCHAR bTerminalID,
1159     OUT PKSDATARANGE** OutDataRanges,
1160     OUT PULONG OutDataRangesCount)
1161 {
1162     PUSB_AUDIO_STREAMING_INTERFACE_DESCRIPTOR StreamingInterfaceDescriptor;
1163     PUSB_AUDIO_STREAMING_FORMAT_TYPE_DESCRIPTOR StreamingFormatDescriptor;
1164     PUSB_INTERFACE_DESCRIPTOR Descriptor;
1165     PKSDATARANGE_AUDIO DataRangeAudio;
1166     PKSDATARANGE *DataRangeAudioArray;
1167     ULONG NumFrequency, DataRangeCount, DataRangeIndex, Index;
1168
1169     /* count all data ranges */
1170     DataRangeCount = 0;
1171     for (Descriptor = USBD_ParseConfigurationDescriptorEx(ConfigurationDescriptor, ConfigurationDescriptor, -1, -1, USB_DEVICE_CLASS_AUDIO, -1, -1);
1172     Descriptor != NULL;
1173         Descriptor = USBD_ParseConfigurationDescriptorEx(ConfigurationDescriptor, (PVOID)((ULONG_PTR)Descriptor + Descriptor->bLength), -1, -1, USB_DEVICE_CLASS_AUDIO, -1, -1))
1174     {
1175         if (Descriptor->bInterfaceSubClass == 0x02) /* AUDIO_STREAMING */
1176         {
1177             StreamingInterfaceDescriptor = (PUSB_AUDIO_STREAMING_INTERFACE_DESCRIPTOR)USBD_ParseDescriptors(ConfigurationDescriptor, ConfigurationDescriptor->wTotalLength, Descriptor, USB_AUDIO_CONTROL_TERMINAL_DESCRIPTOR_TYPE);
1178             if (StreamingInterfaceDescriptor != NULL)
1179             {
1180                 ASSERT(StreamingInterfaceDescriptor->bDescriptorSubtype == 0x01);
1181                 ASSERT(StreamingInterfaceDescriptor->wFormatTag == WAVE_FORMAT_PCM);
1182                 if (StreamingInterfaceDescriptor->bTerminalLink == bTerminalID)
1183                 {
1184                     DataRangeCount++;
1185                     DPRINT1("StreamingInterfaceDescriptor %p TerminalID %x\n", StreamingInterfaceDescriptor, bTerminalID);
1186                 }
1187             }
1188             Descriptor = (PUSB_INTERFACE_DESCRIPTOR)StreamingInterfaceDescriptor;
1189         }
1190     }
1191
1192     DataRangeAudioArray = AllocFunction(sizeof(PVOID) * DataRangeCount);
1193     if (DataRangeAudioArray == NULL)
1194     {
1195         /* no memory */
1196         return;
1197     }
1198
1199     DataRangeIndex = 0;
1200     for (Descriptor = USBD_ParseConfigurationDescriptorEx(ConfigurationDescriptor, ConfigurationDescriptor, -1, -1, USB_DEVICE_CLASS_AUDIO, -1, -1);
1201     Descriptor != NULL;
1202         Descriptor = USBD_ParseConfigurationDescriptorEx(ConfigurationDescriptor, (PVOID)((ULONG_PTR)Descriptor + Descriptor->bLength), -1, -1, USB_DEVICE_CLASS_AUDIO, -1, -1))
1203     {
1204         if (Descriptor->bInterfaceSubClass == 0x02) /* AUDIO_STREAMING */
1205         {
1206             StreamingInterfaceDescriptor = (PUSB_AUDIO_STREAMING_INTERFACE_DESCRIPTOR)USBD_ParseDescriptors(ConfigurationDescriptor, ConfigurationDescriptor->wTotalLength, Descriptor, USB_AUDIO_CONTROL_TERMINAL_DESCRIPTOR_TYPE);
1207             if (StreamingInterfaceDescriptor != NULL)
1208             {
1209                 ASSERT(StreamingInterfaceDescriptor->bDescriptorSubtype == 0x01);
1210                 ASSERT(StreamingInterfaceDescriptor->wFormatTag == WAVE_FORMAT_PCM);
1211                 if (StreamingInterfaceDescriptor->bTerminalLink == bTerminalID)
1212                 {
1213                     StreamingFormatDescriptor = (PUSB_AUDIO_STREAMING_FORMAT_TYPE_DESCRIPTOR)((ULONG_PTR)StreamingInterfaceDescriptor + StreamingInterfaceDescriptor->bLength);
1214                     ASSERT(StreamingFormatDescriptor->bDescriptorType == 0x24);
1215                     ASSERT(StreamingFormatDescriptor->bDescriptorSubtype == 0x02);
1216                     ASSERT(StreamingFormatDescriptor->bFormatType == 0x01);
1217
1218                     DataRangeAudio = AllocFunction(sizeof(KSDATARANGE_AUDIO));
1219                     if (DataRangeAudio == NULL)
1220                     {
1221                         /* no memory*/
1222                         return;
1223                     }
1224
1225                     DataRangeAudio->DataRange.FormatSize = sizeof(KSDATARANGE_AUDIO);
1226                     DataRangeAudio->DataRange.MajorFormat = KSDATAFORMAT_TYPE_AUDIO;
1227                     DataRangeAudio->DataRange.SubFormat = KSDATAFORMAT_SUBTYPE_PCM;
1228                     DataRangeAudio->DataRange.Specifier = KSDATAFORMAT_SPECIFIER_WAVEFORMATEX;
1229                     DataRangeAudio->MaximumChannels = StreamingFormatDescriptor->bNrChannels;
1230                     DataRangeAudio->MinimumBitsPerSample = StreamingFormatDescriptor->bBitResolution;
1231                     DataRangeAudio->MaximumBitsPerSample = StreamingFormatDescriptor->bBitResolution;
1232                     NumFrequency = StreamingFormatDescriptor->bSamFreqType;
1233                     DataRangeAudio->MinimumSampleFrequency = MAXULONG;
1234                     DataRangeAudio->MaximumSampleFrequency = 0;
1235                     for (Index = 0; Index < NumFrequency; Index++)
1236                     {
1237                         DataRangeAudio->MinimumSampleFrequency = min(StreamingFormatDescriptor->tSamFreq[Index * 3] | StreamingFormatDescriptor->tSamFreq[(Index * 3) + 1] << 8 | StreamingFormatDescriptor->tSamFreq[(Index * 3) + 2] << 16, DataRangeAudio->MinimumSampleFrequency);
1238                         DataRangeAudio->MaximumSampleFrequency = max(StreamingFormatDescriptor->tSamFreq[Index * 3] | StreamingFormatDescriptor->tSamFreq[(Index * 3) + 1] << 8 | StreamingFormatDescriptor->tSamFreq[(Index * 3) + 2] << 16, DataRangeAudio->MaximumSampleFrequency);
1239                     }
1240                     DataRangeAudioArray[DataRangeIndex] = (PKSDATARANGE)DataRangeAudio;
1241                     DataRangeIndex++;
1242                 }
1243             }
1244             Descriptor = (PUSB_INTERFACE_DESCRIPTOR)StreamingInterfaceDescriptor;
1245         }
1246     }
1247
1248     *OutDataRanges = DataRangeAudioArray;
1249     *OutDataRangesCount = DataRangeCount;
1250 }
1251
1252
1253 NTSTATUS
1254 USBAudioPinBuildDescriptors(
1255     PKSDEVICE Device,
1256     PKSPIN_DESCRIPTOR_EX *PinDescriptors,
1257     PULONG PinDescriptorsCount,
1258     PULONG PinDescriptorSize)
1259 {
1260     PDEVICE_EXTENSION DeviceExtension;
1261     PKSPIN_DESCRIPTOR_EX Pins;
1262     ULONG TotalTerminalDescriptorCount = 0;
1263     ULONG NonStreamingTerminalDescriptorCount = 0;
1264     ULONG Index = 0;
1265     PUSB_AUDIO_CONTROL_INPUT_TERMINAL_DESCRIPTOR TerminalDescriptor = NULL;
1266
1267     /* get device extension */
1268     DeviceExtension = Device->Context;
1269
1270     CountTerminalUnits(DeviceExtension->ConfigurationDescriptor, &NonStreamingTerminalDescriptorCount, &TotalTerminalDescriptorCount);
1271     DPRINT("TotalTerminalDescriptorCount %lu NonStreamingTerminalDescriptorCount %lu\n", TotalTerminalDescriptorCount, NonStreamingTerminalDescriptorCount);
1272
1273     /* allocate pins */
1274     Pins = AllocFunction(sizeof(KSPIN_DESCRIPTOR_EX) * TotalTerminalDescriptorCount);
1275     if (!Pins)
1276     {
1277         /* no memory*/
1278         return STATUS_INSUFFICIENT_RESOURCES;
1279     }
1280
1281     for (Index = 0; Index < TotalTerminalDescriptorCount; Index++)
1282     {
1283         if (Index < (TotalTerminalDescriptorCount - NonStreamingTerminalDescriptorCount))
1284         {
1285             /* irp sink pins*/
1286             TerminalDescriptor = UsbAudioGetStreamingTerminalDescriptorByIndex(DeviceExtension->ConfigurationDescriptor, Index);
1287             ASSERT(TerminalDescriptor != NULL);
1288
1289             Pins[Index].Dispatch = &UsbAudioPinDispatch;
1290             Pins[Index].PinDescriptor.InterfacesCount = 1;
1291             Pins[Index].PinDescriptor.Interfaces = &StandardPinInterface;
1292             Pins[Index].PinDescriptor.MediumsCount = 1;
1293             Pins[Index].PinDescriptor.Mediums = &StandardPinMedium;
1294             Pins[Index].PinDescriptor.Category = UsbAudioGetPinCategoryFromTerminalDescriptor(TerminalDescriptor);
1295             UsbAudioGetDataRanges(DeviceExtension->ConfigurationDescriptor, TerminalDescriptor->bTerminalID, (PKSDATARANGE**)&Pins[Index].PinDescriptor.DataRanges, &Pins[Index].PinDescriptor.DataRangesCount);
1296
1297             if (TerminalDescriptor->bDescriptorSubtype == USB_AUDIO_OUTPUT_TERMINAL)
1298             {
1299                 Pins[Index].PinDescriptor.Communication = KSPIN_COMMUNICATION_BOTH;
1300                 Pins[Index].PinDescriptor.DataFlow = KSPIN_DATAFLOW_OUT;
1301
1302                 /* pin flags */
1303                 Pins[Index].Flags = KSPIN_FLAG_PROCESS_IN_RUN_STATE_ONLY | KSFILTER_FLAG_CRITICAL_PROCESSING;
1304             }
1305             else if (TerminalDescriptor->bDescriptorSubtype == USB_AUDIO_INPUT_TERMINAL)
1306             {
1307                 Pins[Index].PinDescriptor.Communication = KSPIN_COMMUNICATION_SINK;
1308                 Pins[Index].PinDescriptor.DataFlow = KSPIN_DATAFLOW_IN;
1309
1310                 /* pin flags */
1311                 Pins[Index].Flags = KSPIN_FLAG_PROCESS_IN_RUN_STATE_ONLY | KSPIN_FLAG_GENERATE_EOS_EVENTS;
1312             }
1313
1314             /* data intersect handler */
1315             Pins[Index].IntersectHandler = UsbAudioPinDataIntersect;
1316
1317             /* irp sinks / sources can be instantiated */
1318             Pins[Index].InstancesPossible = 1;
1319         }
1320         else
1321         {
1322             /* bridge pins */
1323             TerminalDescriptor = UsbAudioGetNonStreamingTerminalDescriptorByIndex(DeviceExtension->ConfigurationDescriptor, Index - (TotalTerminalDescriptorCount - NonStreamingTerminalDescriptorCount));
1324             Pins[Index].PinDescriptor.InterfacesCount = 1;
1325             Pins[Index].PinDescriptor.Interfaces = &StandardPinInterface;
1326             Pins[Index].PinDescriptor.MediumsCount = 1;
1327             Pins[Index].PinDescriptor.Mediums = &StandardPinMedium;
1328             Pins[Index].PinDescriptor.DataRanges = BridgePinAudioFormats;
1329             Pins[Index].PinDescriptor.DataRangesCount = 1;
1330             Pins[Index].PinDescriptor.Communication = KSPIN_COMMUNICATION_BRIDGE;
1331             Pins[Index].PinDescriptor.Category = UsbAudioGetPinCategoryFromTerminalDescriptor(TerminalDescriptor);
1332
1333             if (TerminalDescriptor->bDescriptorSubtype == USB_AUDIO_INPUT_TERMINAL)
1334             {
1335                 Pins[Index].PinDescriptor.DataFlow = KSPIN_DATAFLOW_IN;
1336             }
1337             else if (TerminalDescriptor->bDescriptorSubtype == USB_AUDIO_OUTPUT_TERMINAL)
1338             {
1339                 Pins[Index].PinDescriptor.DataFlow = KSPIN_DATAFLOW_OUT;
1340             }
1341         }
1342
1343     }
1344
1345     *PinDescriptors = Pins;
1346     *PinDescriptorSize = sizeof(KSPIN_DESCRIPTOR_EX);
1347     *PinDescriptorsCount = TotalTerminalDescriptorCount;
1348
1349     return STATUS_SUCCESS;
1350 }
1351
1352 NTSTATUS
1353 NTAPI
1354 USBAudioGetDescriptor(
1355     IN PDEVICE_OBJECT DeviceObject,
1356     IN UCHAR DescriptorType,
1357     IN ULONG DescriptorLength,
1358     IN UCHAR DescriptorIndex,
1359     IN LANGID LanguageId,
1360     OUT PVOID *OutDescriptor)
1361 {
1362     PURB Urb;
1363     NTSTATUS Status;
1364     PVOID Descriptor;
1365
1366     /* sanity checks */
1367     ASSERT(DeviceObject);
1368     ASSERT(OutDescriptor);
1369     ASSERT(DescriptorLength);
1370
1371     //
1372     // first allocate descriptor buffer
1373     //
1374     Descriptor = AllocFunction(DescriptorLength);
1375     if (!Descriptor)
1376     {
1377         /* no memory */
1378         return STATUS_INSUFFICIENT_RESOURCES;
1379     }
1380
1381     /* allocate urb */
1382     Urb = (PURB)AllocFunction(sizeof(URB));
1383     if (!Urb)
1384     {
1385         /* no memory */
1386         FreeFunction(Descriptor);
1387         return STATUS_INSUFFICIENT_RESOURCES;
1388     }
1389
1390     /* initialize urb */
1391     UsbBuildGetDescriptorRequest(Urb,
1392         sizeof(Urb->UrbControlDescriptorRequest),
1393         DescriptorType,
1394         DescriptorIndex,
1395         LanguageId,
1396         Descriptor,
1397         NULL,
1398         DescriptorLength,
1399         NULL);
1400
1401     /* submit urb */
1402     Status = SubmitUrbSync(DeviceObject, Urb);
1403
1404     /* free urb */
1405     FreeFunction(Urb);
1406
1407     if (NT_SUCCESS(Status))
1408     {
1409         /* store result */
1410         *OutDescriptor = Descriptor;
1411     }
1412     else
1413     {
1414         /* failed */
1415         FreeFunction(Descriptor);
1416     }
1417
1418     /* done */
1419     return Status;
1420 }
1421
1422 NTSTATUS
1423 NTAPI
1424 USBAudioGetStringDescriptor(
1425     IN PDEVICE_OBJECT DeviceObject,
1426     IN ULONG DescriptorLength,
1427     IN UCHAR DescriptorIndex,
1428     IN LANGID LanguageId,
1429     OUT PVOID *OutDescriptor)
1430 {
1431     NTSTATUS Status;
1432
1433     /* retrieve descriptor */
1434     Status = USBAudioGetDescriptor(DeviceObject, USB_STRING_DESCRIPTOR_TYPE, DescriptorLength, DescriptorIndex, LanguageId, OutDescriptor);
1435     if (!NT_SUCCESS(Status))
1436     {
1437         // failed
1438         return Status;
1439     }
1440     return STATUS_SUCCESS;
1441 }
1442
1443 NTSTATUS
1444 USBAudioRegCreateMediaCategoriesKey(
1445     IN PUNICODE_STRING Name,
1446     OUT PHANDLE OutHandle)
1447 {
1448     NTSTATUS Status;
1449     OBJECT_ATTRIBUTES ObjectAttributes;
1450     UNICODE_STRING DestinationString;
1451     HANDLE Handle;
1452
1453     /* initialize root name*/
1454     RtlInitUnicodeString(&DestinationString, L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control\\MediaCategories\\");
1455
1456     /* initialize object attributes */
1457     InitializeObjectAttributes(&ObjectAttributes, &DestinationString, OBJ_CASE_INSENSITIVE | OBJ_OPENIF | OBJ_KERNEL_HANDLE, NULL, NULL);
1458
1459     /* create the key */
1460     Status = ZwOpenKey(&Handle, KEY_ALL_ACCESS, &ObjectAttributes);
1461     if (NT_SUCCESS(Status))
1462     {
1463         /* initialize object attributes */
1464         InitializeObjectAttributes(&ObjectAttributes, Name, OBJ_CASE_INSENSITIVE | OBJ_KERNEL_HANDLE, Handle, NULL);
1465
1466         Status = ZwCreateKey(OutHandle, KEY_ALL_ACCESS, &ObjectAttributes, 0, NULL, 0, NULL);
1467         ZwClose(Handle);
1468
1469     }
1470     return Status;
1471 }
1472
1473
1474 NTSTATUS
1475 USBAudioInitComponentId(
1476     PKSDEVICE Device,
1477     IN PKSCOMPONENTID ComponentId)
1478 {
1479     PDEVICE_EXTENSION DeviceExtension;
1480     NTSTATUS Status;
1481     LPWSTR DescriptionBuffer;
1482     UNICODE_STRING GuidString;
1483     UNICODE_STRING Name;
1484     HANDLE hKey;
1485     GUID TempGuid;
1486
1487     /* get device extension */
1488     DeviceExtension = Device->Context;
1489
1490     /* init component id */
1491     ComponentId->Component = KSCOMPONENTID_USBAUDIO;
1492     ComponentId->Version = HIBYTE(DeviceExtension->DeviceDescriptor->bcdDevice);
1493     ComponentId->Revision = LOBYTE(DeviceExtension->DeviceDescriptor->bcdDevice);
1494
1495     INIT_USBAUDIO_MID(&ComponentId->Manufacturer, DeviceExtension->DeviceDescriptor->idVendor);
1496     INIT_USBAUDIO_PID(&ComponentId->Product, DeviceExtension->DeviceDescriptor->idProduct);
1497     INIT_USBAUDIO_PRODUCT_NAME(&TempGuid, DeviceExtension->DeviceDescriptor->idVendor, DeviceExtension->DeviceDescriptor->idProduct, 0);
1498
1499     if (DeviceExtension->DeviceDescriptor->iProduct)
1500     {
1501         Status = USBAudioGetStringDescriptor(DeviceExtension->LowerDevice, 100 * sizeof(WCHAR), DeviceExtension->DeviceDescriptor->iProduct, 0x0409 /* FIXME */, (PVOID*)&DescriptionBuffer);
1502         if (NT_SUCCESS(Status))
1503         {
1504             Status = RtlStringFromGUID(&TempGuid, &GuidString);
1505             if (NT_SUCCESS(Status))
1506             {
1507                 Status = USBAudioRegCreateMediaCategoriesKey(&GuidString, &hKey);
1508                 if (NT_SUCCESS(Status))
1509                 {
1510                     RtlInitUnicodeString(&Name, L"Name");
1511                     ZwSetValueKey(hKey, &Name, 0, REG_SZ, DescriptionBuffer, (wcslen(DescriptionBuffer) + 1) * sizeof(WCHAR));
1512                     ZwClose(hKey);
1513
1514                     INIT_USBAUDIO_PRODUCT_NAME(&ComponentId->Name, DeviceExtension->DeviceDescriptor->idVendor, DeviceExtension->DeviceDescriptor->idProduct, 0);
1515                 }
1516                 RtlFreeUnicodeString(&GuidString);
1517             }
1518             FreeFunction(DescriptionBuffer);
1519         }
1520     }
1521     return STATUS_SUCCESS;
1522 }
1523
1524
1525 NTSTATUS
1526 NTAPI
1527 USBAudioCreateFilterContext(
1528     PKSDEVICE Device)
1529 {
1530     PKSFILTER_DESCRIPTOR FilterDescriptor;
1531     PKSCOMPONENTID ComponentId;
1532     NTSTATUS Status;
1533
1534     /* allocate descriptor */
1535     FilterDescriptor = AllocFunction(sizeof(KSFILTER_DESCRIPTOR));
1536     if (!FilterDescriptor)
1537     {
1538         /* no memory */
1539         return USBD_STATUS_INSUFFICIENT_RESOURCES;
1540     }
1541
1542     /* init filter descriptor*/
1543     FilterDescriptor->Version = KSFILTER_DESCRIPTOR_VERSION;
1544     FilterDescriptor->Flags = 0;
1545     FilterDescriptor->ReferenceGuid = &KSNAME_Filter;
1546     FilterDescriptor->Dispatch = &USBAudioFilterDispatch;
1547     FilterDescriptor->CategoriesCount = 1;
1548     FilterDescriptor->Categories = &GUID_KSCATEGORY_AUDIO;
1549
1550     /* init component id*/
1551     ComponentId = AllocFunction(sizeof(KSCOMPONENTID));
1552     if (!ComponentId)
1553     {
1554         /* no memory */
1555         return STATUS_INSUFFICIENT_RESOURCES;
1556     }
1557     Status = USBAudioInitComponentId(Device, ComponentId);
1558     if (!NT_SUCCESS(Status))
1559     {
1560         /* failed*/
1561         FreeFunction(ComponentId);
1562         return Status;
1563     }
1564     FilterDescriptor->ComponentId = ComponentId;
1565
1566     /* build pin descriptors */
1567     Status = USBAudioPinBuildDescriptors(Device, (PKSPIN_DESCRIPTOR_EX *)&FilterDescriptor->PinDescriptors, &FilterDescriptor->PinDescriptorsCount, &FilterDescriptor->PinDescriptorSize);
1568     if (!NT_SUCCESS(Status))
1569     {
1570         /* failed*/
1571         FreeFunction(ComponentId);
1572         return Status;
1573     }
1574
1575     /* build topology */
1576     Status = BuildUSBAudioFilterTopology(Device, FilterDescriptor);
1577     if (!NT_SUCCESS(Status))
1578     {
1579         /* failed*/
1580         FreeFunction(ComponentId);
1581         return Status;
1582     }
1583
1584     /* lets create the filter */
1585     Status = KsCreateFilterFactory(Device->FunctionalDeviceObject, FilterDescriptor, ReferenceString, NULL, KSCREATE_ITEM_FREEONSTOP, NULL, NULL, NULL);
1586     DPRINT("KsCreateFilterFactory: %x\n", Status);
1587
1588     return Status;
1589 }
1590
1591