1/* 2 * Driver for USB Audio Device Class devices. 3 * Copyright (c) 2009,10,12 S.Zharski <imker@gmx.li> 4 * Distributed under the tems of the MIT license. 5 * 6 */ 7 8#include "AudioFunction.h" 9#include "Settings.h" 10#include "Device.h" 11#include "audio.h" 12 13 14enum TerminalTypes { 15 // USB Terminal Types 16 UndefinedUSB_IO = 0x100, 17 StreamingUSB_IO = 0x101, 18 VendorUSB_IO = 0x1ff, 19 // Input Terminal Types 20 Undefined_In = 0x200, 21 Microphone_In = 0x201, 22 DesktopMic_In = 0x202, 23 PersonalMic_In = 0x203, 24 OmniMic_In = 0x204, 25 MicsArray_In = 0x205, 26 ProcMicsArray_In = 0x206, 27 // Output Terminal Types 28 Undefined_Out = 0x300, 29 Speaker_Out = 0x301, 30 HeadPhones_Out = 0x302, 31 HMDAudio_Out = 0x303, 32 DesktopSpeaker = 0x304, 33 RoomSpeaker = 0x305, 34 CommSpeaker = 0x306, 35 LFESpeaker = 0x307, 36 // Bi-directional Terminal Types 37 Undefined_IO = 0x400, 38 Handset_IO = 0x401, 39 Headset_IO = 0x402, 40 SpeakerPhone_IO = 0x403, 41 SpeakerPhoneES_IO = 0x404, 42 SpeakerPhoneEC_IO = 0x405, 43 // Telephony Terminal Types 44 UndefTelephony_IO = 0x500, 45 PhoneLine_IO = 0x501, 46 Telephone_IO = 0x502, 47 DownLinePhone_IO = 0x503, 48 // External Terminal Types 49 UndefinedExt_IO = 0x600, 50 AnalogConnector_IO = 0x601, 51 DAInterface_IO = 0x602, 52 LineConnector_IO = 0x603, 53 LegacyConnector_IO = 0x604, 54 SPDIFInterface_IO = 0x605, 55 DA1394Stream_IO = 0x606, 56 DV1394StreamSound_IO= 0x607, 57 ADATLightpipe_IO = 0x608, 58 TDIF_IO = 0x609, 59 MADI_IO = 0x60a, 60 // Embedded Terminal Types 61 UndefEmbedded_IO = 0x700, 62 LCNoiseSource_Out = 0x701, 63 EqualizationNoise_Out = 0x702, 64 CDPlayer_In = 0x703, 65 DAT_IO = 0x704, 66 DCC_IO = 0x705, 67 MiniDisk_IO = 0x706, 68 AnalogTape_IO = 0x707, 69 Phonograph_In = 0x708, 70 VCRAudio_In = 0x709, 71 VideoDiscAudio_In = 0x70a, 72 DVDAudio_In = 0x70b, 73 TVTunerAudio_In = 0x70c, 74 SatReceiverAudio_In = 0x70d, 75 CableTunerAudio_In = 0x70e, 76 DSSAudio_In = 0x70f, 77 Radio_Receiver_In = 0x710, 78 RadioTransmitter_In = 0x711, 79 MultiTrackRecorder_IO = 0x712, 80 Synthesizer_IO = 0x713, 81 Piano_IO = 0x714, 82 Guitar_IO = 0x715, 83 Drums_IO = 0x716, 84 Instrument_IO = 0x717 85}; 86 87 88const char* 89GetTerminalDescription(uint16 TerminalType) 90{ 91 switch(TerminalType) { 92 // USB Terminal Types 93 case UndefinedUSB_IO: return "USB I/O"; 94 case StreamingUSB_IO: return "USB Streaming I/O"; 95 case VendorUSB_IO: return "Vendor USB I/O"; 96 // Input Terminal Types 97 case Undefined_In: return "Undefined Input"; 98 case Microphone_In: return "Microphone"; 99 case DesktopMic_In: return "Desktop Microphone"; 100 case PersonalMic_In: return "Personal Microphone"; 101 case OmniMic_In: return "Omni-directional Mic"; 102 case MicsArray_In: return "Microphone Array"; 103 case ProcMicsArray_In: return "Processing Mic Array"; 104 // Output Terminal Types 105 case Undefined_Out: return "Undefined Output"; 106 case Speaker_Out: return "Speaker"; 107 case HeadPhones_Out: return "Headphones"; 108 case HMDAudio_Out: return "Head Mounted Disp.Audio"; 109 case DesktopSpeaker: return "Desktop Speaker"; 110 case RoomSpeaker: return "Room Speaker"; 111 case CommSpeaker: return "Communication Speaker"; 112 case LFESpeaker: return "LFE Speaker"; 113 // Bi-directional Terminal Types 114 case Undefined_IO: return "Undefined I/O"; 115 case Handset_IO: return "Handset"; 116 case Headset_IO: return "Headset"; 117 case SpeakerPhone_IO: return "Speakerphone"; 118 case SpeakerPhoneES_IO: return "Echo-supp Speakerphone"; 119 case SpeakerPhoneEC_IO: return "Echo-cancel Speakerphone"; 120 // Telephony Terminal Types 121 case UndefTelephony_IO: return "Undefined Telephony"; 122 case PhoneLine_IO: return "Phone Line"; 123 case Telephone_IO: return "Telephone"; 124 case DownLinePhone_IO: return "Down Line Phone"; 125 // External Terminal Types 126 case UndefinedExt_IO: return "Undefined External I/O"; 127 case AnalogConnector_IO: return "Analog Connector"; 128 case DAInterface_IO: return "Digital Audio Interface"; 129 case LineConnector_IO: return "Line Connector"; 130 case LegacyConnector_IO: return "LegacyAudioConnector"; 131 case SPDIFInterface_IO: return "S/PDIF Interface"; 132 case DA1394Stream_IO: return "1394 DA Stream"; 133 case DV1394StreamSound_IO: return "1394 DV Stream Soundtrack"; 134 case ADATLightpipe_IO: return "Alesis DAT Stream"; 135 case TDIF_IO: return "Tascam Digital Interface"; 136 case MADI_IO: return "AES Multi-channel interface"; 137 // Embedded Terminal Types 138 case UndefEmbedded_IO: return "Undefined Embedded I/O"; 139 case LCNoiseSource_Out: return "Level Calibration Noise Source"; 140 case EqualizationNoise_Out: return "Equalization Noise"; 141 case CDPlayer_In: return "CD Player"; 142 case DAT_IO: return "DAT"; 143 case DCC_IO: return "DCC"; 144 case MiniDisk_IO: return "Mini Disk"; 145 case AnalogTape_IO: return "Analog Tape"; 146 case Phonograph_In: return "Phonograph"; 147 case VCRAudio_In: return "VCR Audio"; 148 case VideoDiscAudio_In: return "Video Disc Audio"; 149 case DVDAudio_In: return "DVD Audio"; 150 case TVTunerAudio_In: return "TV Tuner Audio"; 151 case SatReceiverAudio_In: return "Satellite Receiver Audio"; 152 case CableTunerAudio_In: return "Cable Tuner Audio"; 153 case DSSAudio_In: return "DSS Audio"; 154 case Radio_Receiver_In: return "Radio Receiver"; 155 case RadioTransmitter_In: return "Radio Transmitter"; 156 case MultiTrackRecorder_IO: return "Multi-track Recorder"; 157 case Synthesizer_IO: return "Synthesizer"; 158 case Piano_IO: return "Piano"; 159 case Guitar_IO: return "Guitar"; 160 case Drums_IO: return "Percussion Instrument"; 161 case Instrument_IO: return "Musical Instrument"; 162 } 163 164 TRACE_ALWAYS("Unknown Terminal Type: %#06x", TerminalType); 165 return "Unknown"; 166} 167 168 169_AudioFunctionEntity::_AudioFunctionEntity(Device* device, size_t interface) 170 : 171 fStatus(B_NO_INIT), 172 fDevice(device), 173 fInterface(interface) 174{ 175} 176 177 178_AudioFunctionEntity::~_AudioFunctionEntity() 179{ 180 181} 182 183 184_AudioControl::_AudioControl(Device* device, size_t interface, 185 usb_audiocontrol_header_descriptor* Header) 186 : 187 _AudioFunctionEntity(device, interface), 188 fSubType(Header->descriptor_subtype), 189 fID(0), 190 fSourceID(0), 191 fStringIndex(0) 192{ 193} 194 195 196_AudioControl::~_AudioControl() 197{ 198} 199 200 201_AudioChannelsCluster* 202_AudioControl::OutputCluster() 203{ 204 if (SourceID() == 0 || fDevice == 0) { 205 return NULL; 206 } 207 208 _AudioControl* control = fDevice->FindAudioControl(SourceID()); 209 if (control == 0) { 210 return NULL; 211 } 212 213 return control->OutputCluster(); 214} 215 216 217AudioControlHeader::AudioControlHeader(Device* device, size_t interface, 218 usb_audiocontrol_header_descriptor* Header) 219 : 220 _AudioControl(device, interface, Header), 221 fADCSpecification(0), 222 fFunctionCategory(0), 223 fControlsBitmap(0) 224{ 225 if (Header == NULL) { 226 return; 227 } 228 229 fADCSpecification = Header->bcd_release_no; 230 TRACE("ADCSpecification:%#06x\n", fADCSpecification); 231 232 if (fADCSpecification < 0x200) { 233 usb_audiocontrol_header_descriptor_r1* Header1 234 = (usb_audiocontrol_header_descriptor_r1*) Header; 235 236 TRACE("InterfacesCount:%d\n", Header1->in_collection); 237 for (size_t i = 0; i < Header1->in_collection; i++) { 238 fStreams.PushBack(Header1->interface_numbers[i]); 239 TRACE("Interface[%d] number is %d\n", i, fStreams[i]); 240 } 241 } else { 242 fFunctionCategory = Header->function_category; 243 fControlsBitmap = Header->bm_controls; 244 TRACE("Function Category:%#04x\n", fFunctionCategory); 245 TRACE("Controls Bitmap:%#04x\n", fControlsBitmap); 246 } 247 248 fStatus = B_OK; 249} 250 251 252AudioControlHeader::~AudioControlHeader() 253{ 254 255} 256 257 258_AudioChannelsCluster::_AudioChannelsCluster() 259 : 260 fOutChannelsNumber(0), 261 fChannelsConfig(0), 262 fChannelNames(0) 263{ 264 265} 266 267 268_AudioChannelsCluster::~_AudioChannelsCluster() 269{ 270 271} 272 273 274_AudioChannelsCluster* 275_AudioChannelsCluster::OutputCluster() 276{ 277 return this; 278} 279 280 281_Terminal::_Terminal(Device* device, size_t interface, 282 usb_audiocontrol_header_descriptor* Header) 283 : 284 _AudioControl(device, interface, Header), 285 fTerminalType(0), 286 fAssociatedTerminal(0), 287 fClockSourceId(0), 288 fControlsBitmap(0) 289{ 290 291} 292 293 294_Terminal::~_Terminal() 295{ 296 297} 298 299 300const char* 301_Terminal::Name() 302{ 303 return GetTerminalDescription(fTerminalType); 304} 305 306 307bool 308_Terminal::IsUSBIO() 309{ 310 return (fTerminalType && 0xff00) == UndefinedUSB_IO; 311} 312 313 314InputTerminal::InputTerminal(Device* device, size_t interface, 315 usb_audiocontrol_header_descriptor* Header) 316 : 317 _Terminal(device, interface, Header) 318{ 319 usb_input_terminal_descriptor_r1* Terminal 320 = (usb_input_terminal_descriptor_r1*) Header; 321 fID = Terminal->terminal_id; 322 fTerminalType = Terminal->terminal_type; 323 fAssociatedTerminal = Terminal->assoc_terminal; 324 325 TRACE("Input Terminal ID:%d\n", fID); 326 TRACE("Terminal type:%s (%#06x)\n", 327 GetTerminalDescription(fTerminalType), fTerminalType); 328 TRACE("Assoc.terminal:%d\n", fAssociatedTerminal); 329 330 if (device->SpecReleaseNumber() < 0x200) { 331 fOutChannelsNumber = Terminal->num_channels; 332 fChannelsConfig = Terminal->channel_config; 333 fChannelNames = Terminal->channel_names; 334 fStringIndex = Terminal->terminal; 335 } else { 336 usb_input_terminal_descriptor* Terminal 337 = (usb_input_terminal_descriptor*) Header; 338 fClockSourceId = Terminal->clock_source_id; 339 fOutChannelsNumber = Terminal->num_channels; 340 fChannelsConfig = Terminal->channel_config; 341 fChannelNames = Terminal->channel_names; 342 fControlsBitmap = Terminal->bm_controls; 343 fStringIndex = Terminal->terminal; 344 345 TRACE("Clock Source ID:%d\n", fClockSourceId); 346 TRACE("Controls Bitmap:%#04x\n", fControlsBitmap); 347 } 348 349 TRACE("Out.channels num:%d\n", fOutChannelsNumber); 350 TRACE("Channels config:%#06x\n", fChannelsConfig); 351 TRACE("Channels names:%d\n", fChannelNames); 352 TRACE("StringIndex:%d\n", fStringIndex); 353 354 fStatus = B_OK; 355} 356 357 358InputTerminal::~InputTerminal() 359{ 360} 361 362 363OutputTerminal::OutputTerminal(Device* device, size_t interface, 364 usb_audiocontrol_header_descriptor* Header) 365 : 366 _Terminal(device, interface, Header) 367{ 368 usb_output_terminal_descriptor_r1* Terminal 369 = (usb_output_terminal_descriptor_r1*) Header; 370 371 fID = Terminal->terminal_id; 372 fTerminalType = Terminal->terminal_type; 373 fAssociatedTerminal = Terminal->assoc_terminal; 374 fSourceID = Terminal->source_id; 375 376 TRACE("Output Terminal ID:%d\n", fID); 377 TRACE("Terminal type:%s (%#06x)\n", 378 GetTerminalDescription(fTerminalType), fTerminalType); 379 TRACE("Assoc.terminal:%d\n", fAssociatedTerminal); 380 TRACE("Source ID:%d\n", fSourceID); 381 382 if (device->SpecReleaseNumber() < 0x200) { 383 fStringIndex = Terminal->terminal; 384 } else { 385 usb_output_terminal_descriptor* Terminal 386 = (usb_output_terminal_descriptor*) Header; 387 388 fClockSourceId = Terminal->clock_source_id; 389 fControlsBitmap = Terminal->bm_controls; 390 fStringIndex = Terminal->terminal; 391 392 TRACE("Clock Source ID:%d\n", fClockSourceId); 393 TRACE("Controls Bitmap:%#04x\n", fControlsBitmap); 394 } 395 396 TRACE("StringIndex:%d\n", fStringIndex); 397 398 fStatus = B_OK; 399} 400 401 402OutputTerminal::~OutputTerminal() 403{ 404} 405 406 407MixerUnit::MixerUnit(Device* device, size_t interface, 408 usb_audiocontrol_header_descriptor* Header) 409 : 410 _AudioControl(device, interface, Header), 411 fControlsBitmap(0) 412{ 413 usb_mixer_unit_descriptor* Mixer 414 = (usb_mixer_unit_descriptor*) Header; 415 416 fID = Mixer->unit_id; 417 TRACE("Mixer ID:%d\n", fID); 418 419 TRACE("Number of input pins:%d\n", Mixer->num_input_pins); 420 for (size_t i = 0; i < Mixer->num_input_pins; i++) { 421 fInputPins.PushBack(Mixer->input_pins[i]); 422 TRACE("Input pin #%d:%d\n", i, fInputPins[i]); 423 } 424 425 uint8* mixerControlsData = NULL; 426 uint8 mixerControlsSize = 0; 427 428 if (device->SpecReleaseNumber() < 0x200) { 429 usb_output_channels_descriptor_r1* OutChannels 430 = (usb_output_channels_descriptor_r1*) 431 &Mixer->input_pins[Mixer->num_input_pins]; 432 433 fOutChannelsNumber = OutChannels->num_output_pins; 434 fChannelsConfig = OutChannels->channel_config; 435 fChannelNames = OutChannels->channel_names; 436 437 mixerControlsData = (uint8*) ++OutChannels; 438 mixerControlsSize = Mixer->length - 10 - Mixer->num_input_pins; 439 fStringIndex = *(mixerControlsData + mixerControlsSize); 440 } else { 441 usb_output_channels_descriptor* OutChannels 442 = (usb_output_channels_descriptor*) 443 &Mixer->input_pins[Mixer->num_input_pins]; 444 445 fOutChannelsNumber = OutChannels->num_output_pins; 446 fChannelsConfig = OutChannels->channel_config; 447 fChannelNames = OutChannels->channel_names; 448 449 mixerControlsData = (uint8*) ++OutChannels; 450 mixerControlsSize = Mixer->length - 13 - Mixer->num_input_pins; 451 fControlsBitmap = *(mixerControlsData + mixerControlsSize); 452 fStringIndex = *(mixerControlsData + mixerControlsSize + 1); 453 454 TRACE("Control Bitmap:%#04x\n", fControlsBitmap); 455 } 456 457 TRACE("Out channels number:%d\n", fOutChannelsNumber); 458 TRACE("Out channels config:%#06x\n", fChannelsConfig); 459 TRACE("Out channels names:%d\n", fChannelNames); 460 TRACE("Controls Size:%d\n", mixerControlsSize); 461 462 for (size_t i = 0; i < mixerControlsSize; i++) { 463 fProgrammableControls.PushBack(mixerControlsData[i]); 464 TRACE("Controls Data[%d]:%#x\n", i, fProgrammableControls[i]); 465 } 466 467 TRACE("StringIndex:%d\n", fStringIndex); 468 469 fStatus = B_OK; 470} 471 472 473MixerUnit::~MixerUnit() 474{ 475} 476 477 478SelectorUnit::SelectorUnit(Device* device, size_t interface, 479 usb_audiocontrol_header_descriptor* Header) 480 : 481 _AudioControl(device, interface, Header), 482 fControlsBitmap(0) 483{ 484 usb_selector_unit_descriptor* Selector 485 = (usb_selector_unit_descriptor*) Header; 486 487 fID = Selector->unit_id; 488 TRACE("Selector ID:%d\n", fID); 489 490 TRACE("Number of input pins:%d\n", Selector->num_input_pins); 491 for (size_t i = 0; i < Selector->num_input_pins; i++) { 492 fInputPins.PushBack(Selector->input_pins[i]); 493 TRACE("Input pin #%d:%d\n", i, fInputPins[i]); 494 } 495 496 if (device->SpecReleaseNumber() < 0x200) { 497 498 fStringIndex = Selector->input_pins[Selector->num_input_pins]; 499 } else { 500 501 fControlsBitmap = Selector->input_pins[Selector->num_input_pins]; 502 fStringIndex = Selector->input_pins[Selector->num_input_pins + 1]; 503 504 TRACE("Controls Bitmap:%d\n", fControlsBitmap); 505 } 506 507 TRACE("StringIndex:%d\n", fStringIndex); 508 509 fStatus = B_OK; 510} 511 512 513SelectorUnit::~SelectorUnit() 514{ 515} 516 517 518FeatureUnit::FeatureUnit(Device* device, size_t interface, 519 usb_audiocontrol_header_descriptor* Header) 520 : 521 _AudioControl(device, interface, Header) 522{ 523 usb_feature_unit_descriptor* Feature 524 = (usb_feature_unit_descriptor*) Header; 525 526 fID = Feature->unit_id; 527 TRACE("Feature ID:%d\n", fID); 528 529 fSourceID = Feature->source_id; 530 TRACE("Source ID:%d\n", fSourceID); 531 532 uint8 controlSize = 4; 533 uint8 channelsCount = (Feature->length - 6) / controlSize; 534 uint8 *ControlsBitmapPointer = (uint8*)&Feature->bma_controls[0]; 535 536 if (device->SpecReleaseNumber() < 0x200) { 537 usb_feature_unit_descriptor_r1* Feature 538 = (usb_feature_unit_descriptor_r1*) Header; 539 controlSize = Feature->control_size; 540 channelsCount = (Feature->length - 7) / Feature->control_size; 541 ControlsBitmapPointer = &Feature->bma_controls[0]; 542 } 543 544 TRACE("Channel bitmap size:%d\n", controlSize); 545 TRACE("Channels number:%d\n", channelsCount - 1); // not add master! 546 547 for (size_t i = 0; i < channelsCount; i++) { 548 uint8 *controlPointer = &ControlsBitmapPointer[i * controlSize]; 549 switch(controlSize) { 550 case 1: fControlBitmaps.PushBack(*controlPointer); break; 551 case 2: fControlBitmaps.PushBack(*(uint16*)controlPointer); break; 552 case 4: fControlBitmaps.PushBack(*(uint32*)controlPointer); break; 553 default: 554 TRACE_ALWAYS("Feature control of unsupported size %d ignored\n", 555 controlSize); 556 continue; 557 } 558 559 TraceChannel(device, i); 560 } 561 562 fStringIndex = ControlsBitmapPointer[channelsCount * controlSize]; 563 TRACE("StringIndex:%d\n", fStringIndex); 564 565 fStatus = B_OK; 566} 567 568 569FeatureUnit::~FeatureUnit() 570{ 571} 572 573 574const char* 575FeatureUnit::Name() 576{ 577 // first check if source of this FU is an input terminal 578 AudioControlsIterator it = fDevice->fAudioControls.Find(fSourceID); 579 while (it != fDevice->fAudioControls.End()) { 580 _AudioControl *control = it->Value(); 581 if (control != 0) 582 break; 583 584 if (control->SubType() != IDSInputTerminal) 585 break; 586 587 // USB I/O terminal is a not good candidate to use it's name 588 if (static_cast<_Terminal*>(control)->IsUSBIO()) 589 break; 590 591 // use the name of source input terminal as name of this FU 592 return control->Name(); 593 } 594 595 // check if output of this FU is connected to output terminal 596 it = fDevice->fOutputTerminals.Find(fID); 597 while (it != fDevice->fOutputTerminals.End()) { 598 _AudioControl *control = it->Value(); 599 if (control != 0) 600 break; 601 602 if (control->SubType() != IDSOutputTerminal) 603 break; 604 605 // USB I/O terminal is a not good candidate to use it's name 606 uint16 Type = static_cast<OutputTerminal*>(control)->TerminalType(); 607 if ((Type && 0xff00) == UndefinedUSB_IO) 608 break; 609 610 // use the name of this output terminal as name of this FU 611 return control->Name(); 612 } 613 614 return "Unknown"; 615} 616 617 618bool 619FeatureUnit::HasControl(int32 Channel, uint32 Control) 620{ 621 if (Channel >= fControlBitmaps.Count()) { 622 TRACE_ALWAYS("Out of limits error of retrieving control %#010x " 623 "for channel %d\n", Control, Channel); 624 return false; 625 } 626 627 return (Control & fControlBitmaps[Channel]) != 0; 628} 629 630 631void 632FeatureUnit::TraceChannel(Device* device, int32 Channel) 633{ 634 if (Channel >= fControlBitmaps.Count()) { 635 TRACE_ALWAYS("Out of limits error of tracing channel %d\n", Channel); 636 return; 637 } 638 639 if (Channel == 0) 640 TRACE("Master channel bitmap:%#x\n", fControlBitmaps[Channel]); 641 else 642 TRACE("Channel %d bitmap:%#x\n", Channel, fControlBitmaps[Channel]); 643 644 if (device->SpecReleaseNumber() < 0x200) { 645 if (HasControl(Channel, MuteControl1)) 646 TRACE("\tMute\n"); 647 if (HasControl(Channel, VolumeControl1)) 648 TRACE("\tVolume\n"); 649 if (HasControl(Channel, BassControl1)) 650 TRACE("\tBass\n"); 651 if (HasControl(Channel, MidControl1)) 652 TRACE("\tMid\n"); 653 if (HasControl(Channel, TrebleControl1)) 654 TRACE("\tTreble\n"); 655 if (HasControl(Channel, GraphEqControl1)) 656 TRACE("\tGraphic Equalizer\n"); 657 if (HasControl(Channel, AutoGainControl1)) 658 TRACE("\tAutomatic Gain\n"); 659 if (HasControl(Channel, DelayControl1)) 660 TRACE("\tDelay\n"); 661 if (HasControl(Channel, BassBoostControl1)) 662 TRACE("\tBass Boost\n"); 663 if (HasControl(Channel, LoudnessControl1)) 664 TRACE("\tLoudness\n"); 665 } else { 666 if (HasControl(Channel, MuteControl)) 667 TRACE("\tMute\n"); 668 if (HasControl(Channel, VolumeControl)) 669 TRACE("\tVolume\n"); 670 if (HasControl(Channel, BassControl)) 671 TRACE("\tBass\n"); 672 if (HasControl(Channel, MidControl)) 673 TRACE("\tMid\n"); 674 if (HasControl(Channel, TrebleControl)) 675 TRACE("\tTreble\n"); 676 if (HasControl(Channel, GraphEqControl)) 677 TRACE("\tGraphic Equalizer\n"); 678 if (HasControl(Channel, AutoGainControl)) 679 TRACE("\tAutomatic Gain\n"); 680 if (HasControl(Channel, DelayControl)) 681 TRACE("\tDelay\n"); 682 if (HasControl(Channel, BassBoostControl)) 683 TRACE("\tBass Boost\n"); 684 if (HasControl(Channel, LoudnessControl)) 685 TRACE("\tLoudness\n"); 686 if (HasControl(Channel, InputGainControl)) 687 TRACE("\tInputGain\n"); 688 if (HasControl(Channel, InputGainPadControl)) 689 TRACE("\tInputGainPad\n"); 690 if (HasControl(Channel, PhaseInverterControl)) 691 TRACE("\tPhaseInverter\n"); 692 if (HasControl(Channel, UnderflowControl)) 693 TRACE("\tUnderflow\n"); 694 if (HasControl(Channel, OverflowControl)) 695 TRACE("\tOverflow\n"); 696 } 697} 698 699 700EffectUnit::EffectUnit(Device* device, size_t interface, 701 usb_audiocontrol_header_descriptor* Header) 702 : 703 _AudioControl(device, interface, Header) 704{ 705 usb_input_terminal_descriptor* D 706 = (usb_input_terminal_descriptor*) Header; 707 TRACE("Effect Unit:%d\n", D->terminal_id); 708} 709 710 711EffectUnit::~EffectUnit() 712{ 713} 714 715 716ProcessingUnit::ProcessingUnit(Device* device, size_t interface, 717 usb_audiocontrol_header_descriptor* Header) 718 : 719 _AudioControl(device, interface, Header), 720 fProcessType(0), 721 fControlsBitmap(0) 722{ 723 usb_processing_unit_descriptor* Processing 724 = (usb_processing_unit_descriptor*) Header; 725 726 fID = Processing->unit_id; 727 TRACE("Processing ID:%d\n", fID); 728 729 fProcessType = Processing->process_type; 730 TRACE("Processing Type:%d\n", fProcessType); 731 732 TRACE("Number of input pins:%d\n", Processing->num_input_pins); 733 for (size_t i = 0; i < Processing->num_input_pins; i++) { 734 fInputPins.PushBack(Processing->input_pins[i]); 735 TRACE("Input pin #%d:%d\n", i, fInputPins[i]); 736 } 737 738 if (device->SpecReleaseNumber() < 0x200) { 739 usb_output_channels_descriptor_r1* OutChannels 740 = (usb_output_channels_descriptor_r1*) 741 &Processing->input_pins[Processing->num_input_pins]; 742 743 fOutChannelsNumber = OutChannels->num_output_pins; 744 fChannelsConfig = OutChannels->channel_config; 745 fChannelNames = OutChannels->channel_names; 746 } else { 747 usb_output_channels_descriptor* OutChannels 748 = (usb_output_channels_descriptor*) 749 &Processing->input_pins[Processing->num_input_pins]; 750 751 fOutChannelsNumber = OutChannels->num_output_pins; 752 fChannelsConfig = OutChannels->channel_config; 753 fChannelNames = OutChannels->channel_names; 754 } 755 756 TRACE("Out channels number:%d\n", fOutChannelsNumber); 757 TRACE("Out channels config:%#06x\n", fChannelsConfig); 758 TRACE("Out channels names:%d\n", fChannelNames); 759 /* 760 uint8 controlsSize = Processing->length - 10 - Processing->num_input_pins; 761 TRACE("Controls Size:%d\n", controlsSize); 762 763 uint8* controlsData = (uint8*) ++OutChannels; 764 765 for (size_t i = 0; i < controlsSize; i++) { 766 fProgrammableControls.PushBack(controlsData[i]); 767 TRACE("Controls Data[%d]:%#x\n", i, controlsData[i]); 768 } 769 770 fStringIndex = *(controlsData + controlsSize); 771 772 TRACE("StringIndex:%d\n", fStringIndex); 773*/ 774 fStatus = B_OK; 775} 776 777 778ProcessingUnit::~ProcessingUnit() 779{ 780} 781 782 783ExtensionUnit::ExtensionUnit(Device* device, size_t interface, 784 usb_audiocontrol_header_descriptor* Header) 785 : 786 _AudioControl(device, interface, Header), 787 fExtensionCode(0), 788 fControlsBitmap(0) 789{ 790 usb_extension_unit_descriptor* Extension 791 = (usb_extension_unit_descriptor*) Header; 792 793 fID = Extension->unit_id; 794 TRACE("Extension ID:%d\n", fID); 795 796 fExtensionCode = Extension->extension_code; 797 TRACE("Extension Type:%d\n", fExtensionCode); 798 799 TRACE("Number of input pins:%d\n", Extension->num_input_pins); 800 for (size_t i = 0; i < Extension->num_input_pins; i++) { 801 fInputPins.PushBack(Extension->input_pins[i]); 802 TRACE("Input pin #%d:%d\n", i, fInputPins[i]); 803 } 804 805 806 if (device->SpecReleaseNumber() < 0x200) { 807 usb_output_channels_descriptor_r1* OutChannels 808 = (usb_output_channels_descriptor_r1*) 809 &Extension->input_pins[Extension->num_input_pins]; 810 811 fOutChannelsNumber = OutChannels->num_output_pins; 812 fChannelsConfig = OutChannels->channel_config; 813 fChannelNames = OutChannels->channel_names; 814 } else { 815 usb_output_channels_descriptor* OutChannels 816 = (usb_output_channels_descriptor*) 817 &Extension->input_pins[Extension->num_input_pins]; 818 819 fOutChannelsNumber = OutChannels->num_output_pins; 820 fChannelsConfig = OutChannels->channel_config; 821 fChannelNames = OutChannels->channel_names; 822 } 823 824 TRACE("Out channels number:%d\n", fOutChannelsNumber); 825 TRACE("Out channels config:%#06x\n", fChannelsConfig); 826 TRACE("Out channels names:%d\n", fChannelNames); 827 /* 828 uint8 controlsSize = Processing->length - 10 - Processing->num_input_pins; 829 TRACE("Controls Size:%d\n", controlsSize); 830 831 uint8* controlsData = (uint8*) ++OutChannels; 832 833 for (size_t i = 0; i < controlsSize; i++) { 834 fProgrammableControls.PushBack(controlsData[i]); 835 TRACE("Controls Data[%d]:%#x\n", i, controlsData[i]); 836 } 837 838 fStringIndex = *(controlsData + controlsSize); 839 840 TRACE("StringIndex:%d\n", fStringIndex); 841*/ 842 fStatus = B_OK; 843} 844 845 846ExtensionUnit::~ExtensionUnit() 847{ 848} 849 850 851ClockSource::ClockSource(Device* device, size_t interface, 852 usb_audiocontrol_header_descriptor* Header) 853 : 854 _AudioControl(device, interface, Header) 855{ 856 usb_input_terminal_descriptor* D 857 = (usb_input_terminal_descriptor*) Header; 858 TRACE("Clock Source:%d\n", D->terminal_id); 859} 860 861 862ClockSource::~ClockSource() 863{ 864} 865 866 867ClockSelector::ClockSelector(Device* device, size_t interface, 868 usb_audiocontrol_header_descriptor* Header) 869 : 870 _AudioControl(device, interface, Header) 871{ 872 usb_input_terminal_descriptor* D 873 = (usb_input_terminal_descriptor*) Header; 874 TRACE("Clock Selector:%d\n", D->terminal_id); 875} 876 877 878ClockSelector::~ClockSelector() 879{ 880} 881 882 883ClockMultiplier::ClockMultiplier(Device* device, size_t interface, 884 usb_audiocontrol_header_descriptor* Header) 885 : 886 _AudioControl(device, interface, Header) 887{ 888 usb_input_terminal_descriptor* D 889 = (usb_input_terminal_descriptor*) Header; 890 TRACE("Clock Multiplier:%d\n", D->terminal_id); 891} 892 893 894ClockMultiplier::~ClockMultiplier() 895{ 896} 897 898 899SampleRateConverter::SampleRateConverter(Device* device, size_t interface, 900 usb_audiocontrol_header_descriptor* Header) 901 : 902 _AudioControl(device, interface, Header) 903{ 904 usb_input_terminal_descriptor* D 905 = (usb_input_terminal_descriptor*) Header; 906 TRACE("Sample Rate Converter:%d\n", D->terminal_id); 907} 908 909 910SampleRateConverter::~SampleRateConverter() 911{ 912} 913 914 915// 916// Audio Stream information entities 917// 918// 919ASInterfaceDescriptor::ASInterfaceDescriptor(Device* device, size_t interface, 920 usb_as_interface_descriptor_r1* Descriptor) 921 : 922 _AudioFunctionEntity(device, interface), 923 fTerminalLink(0), 924 fDelay(0), 925 fFormatTag(0) 926{ 927 fTerminalLink = Descriptor->terminal_link; 928 fDelay = Descriptor->delay; 929 fFormatTag = Descriptor->format_tag; 930 931 TRACE("fTerminalLink:%d\n", fTerminalLink); 932 TRACE("fDelay:%d\n", fDelay); 933 TRACE("fFormatTag:%#06x\n", fFormatTag); 934 935 fStatus = B_OK; 936} 937 938 939ASInterfaceDescriptor::~ASInterfaceDescriptor() 940{ 941 942} 943 944 945ASEndpointDescriptor::ASEndpointDescriptor(Device* device, size_t interface, 946 usb_as_cs_endpoint_descriptor* Descriptor) 947 : 948 _AudioFunctionEntity(device, interface), 949 fAttributes(0), 950 fLockDelayUnits(0), 951 fLockDelay(0) 952{ 953 954 fAttributes = Descriptor->attributes; 955 fLockDelayUnits = Descriptor->lock_delay_units; 956 fLockDelay = Descriptor->lock_delay; 957 958 TRACE("fAttributes:%d\n", fAttributes); 959 TRACE("fLockDelayUnits:%d\n", fLockDelayUnits); 960 TRACE("fLockDelay:%d\n", fLockDelay); 961 962 fStatus = B_OK; 963} 964 965 966ASEndpointDescriptor::~ASEndpointDescriptor() 967{ 968} 969 970 971_ASFormatDescriptor::_ASFormatDescriptor(Device* device, size_t interface) 972 : 973 _AudioFunctionEntity(device, interface) 974{ 975} 976 977 978_ASFormatDescriptor::~_ASFormatDescriptor() 979{ 980} 981 982 983uint32 984_ASFormatDescriptor::GetSamFreq(uint8* freq) 985{ 986 return freq[0] | freq[1] << 8 | freq[2] << 16; 987} 988 989 990TypeIFormatDescriptor::TypeIFormatDescriptor(Device* device, size_t interface, 991 usb_type_I_format_descriptor* Descriptor) 992 : 993 _ASFormatDescriptor(device, interface), 994 fNumChannels(0), 995 fSubframeSize(0), 996 fBitResolution(0), 997 fSampleFrequencyType(0) 998{ 999 fStatus = Init(Descriptor); 1000} 1001 1002 1003TypeIFormatDescriptor::~TypeIFormatDescriptor() 1004{ 1005} 1006 1007 1008status_t 1009TypeIFormatDescriptor::Init(usb_type_I_format_descriptor* Descriptor) 1010{ 1011 fNumChannels = Descriptor->nr_channels; 1012 fSubframeSize = Descriptor->subframe_size; 1013 fBitResolution = Descriptor->bit_resolution; 1014 fSampleFrequencyType = Descriptor->sam_freq_type; 1015 1016 if (fSampleFrequencyType == 0) { 1017 fSampleFrequencies.PushBack( 1018 GetSamFreq(Descriptor->sf.cont.lower_sam_freq)); 1019 fSampleFrequencies.PushBack( 1020 GetSamFreq(Descriptor->sf.cont.upper_sam_freq)); 1021 } else { 1022 for (size_t i = 0; i < fSampleFrequencyType; i++) { 1023 fSampleFrequencies.PushBack( 1024 GetSamFreq(Descriptor->sf.discr.sam_freq[i])); 1025 } 1026 } 1027 1028 TRACE("fNumChannels:%d\n", fNumChannels); 1029 TRACE("fSubframeSize:%d\n", fSubframeSize); 1030 TRACE("fBitResolution:%d\n", fBitResolution); 1031 TRACE("fSampleFrequencyType:%d\n", fSampleFrequencyType); 1032 1033 for (int32 i = 0; i < fSampleFrequencies.Count(); i++) { 1034 TRACE("Frequency #%d: %d\n", i, fSampleFrequencies[i]); 1035 } 1036 1037 return B_OK; 1038} 1039 1040 1041TypeIIFormatDescriptor::TypeIIFormatDescriptor(Device* device, size_t interface, 1042 usb_type_II_format_descriptor* Descriptor) 1043 : 1044 _ASFormatDescriptor(device, interface), 1045 fMaxBitRate(0), 1046 fSamplesPerFrame(0), 1047 fSampleFrequencyType(0), 1048 fSampleFrequencies(0) 1049{ 1050} 1051 1052 1053TypeIIFormatDescriptor::~TypeIIFormatDescriptor() 1054{ 1055} 1056 1057 1058TypeIIIFormatDescriptor::TypeIIIFormatDescriptor(Device* device, size_t interface, 1059 usb_type_III_format_descriptor* Descriptor) 1060 : 1061 TypeIFormatDescriptor(device, interface, 1062 (usb_type_I_format_descriptor*) Descriptor) 1063{ 1064 1065} 1066 1067 1068TypeIIIFormatDescriptor::~TypeIIIFormatDescriptor() 1069{ 1070} 1071 1072 1073AudioStreamAlternate::AudioStreamAlternate(size_t alternate, 1074 ASInterfaceDescriptor* interface, 1075 ASEndpointDescriptor* endpoint, 1076 _ASFormatDescriptor* format) 1077 : 1078 fAlternate(alternate), 1079 fInterface(interface), 1080 fEndpoint(endpoint), 1081 fFormat(format) 1082{ 1083} 1084 1085 1086AudioStreamAlternate::~AudioStreamAlternate() 1087{ 1088 delete fInterface; 1089 delete fEndpoint; 1090 delete fFormat; 1091} 1092 1093