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