1/*
2 *	Driver for USB Audio Device Class devices.
3 *	Copyright (c) 2009-13 S.Zharski <imker@gmx.li>
4 *	Distributed under the tems of the MIT license.
5 *
6 */
7
8
9#include "AudioStreamingInterface.h"
10
11#include <usb/USB_audio.h>
12
13#include "Driver.h"
14#include "Settings.h"
15
16
17static struct RatePair {
18	uint32 rate;
19	uint32 rateId;
20} ratesMap[] = {
21	{ 8000, B_SR_8000 },
22	{ 11025, B_SR_11025 },
23	{ 12000, B_SR_12000 },
24	{ 16000, B_SR_16000 },
25	{ 22050, B_SR_22050 },
26	{ 24000, B_SR_24000 },
27	{ 32000, B_SR_32000 },
28	{ 44100, B_SR_44100 },
29	{ 48000, B_SR_48000 },
30	{ 64000, B_SR_64000 },
31	{ 88200, B_SR_88200 },
32	{ 96000, B_SR_96000 },
33	{ 176400, B_SR_176400 },
34	{ 192000, B_SR_192000 },
35	{ 384000, B_SR_384000 },
36	{ 1536000, B_SR_1536000 }
37};
38
39
40//
41//	Audio Stream information entities
42//
43//
44ASInterfaceDescriptor::ASInterfaceDescriptor(
45		usb_audio_streaming_interface_descriptor* Descriptor)
46	:
47	fTerminalLink(0),
48	fDelay(0),
49	fFormatTag(0)
50{
51// TODO: what aboput rev 2???????
52	fTerminalLink = Descriptor->terminal_link;
53	fDelay = Descriptor->r1.delay;
54	fFormatTag = Descriptor->r1.format_tag;
55
56	TRACE(UAC, "fTerminalLink:%d\n", fTerminalLink);
57	TRACE(UAC, "fDelay:%d\n", fDelay);
58	TRACE(UAC, "fFormatTag:%#06x\n", fFormatTag);
59
60	// fStatus = B_OK;
61}
62
63
64ASInterfaceDescriptor::~ASInterfaceDescriptor()
65{
66}
67
68
69ASEndpointDescriptor::ASEndpointDescriptor(usb_endpoint_descriptor* Endpoint,
70		usb_audio_streaming_endpoint_descriptor* Descriptor)
71	:
72	fCSAttributes(0),
73	fLockDelayUnits(0),
74	fLockDelay(0),
75	fMaxPacketSize(0),
76	fEndpointAddress(0),
77	fEndpointAttributes(0)
78{
79	fCSAttributes = Descriptor->attributes;
80	fLockDelayUnits = Descriptor->lock_delay_units;
81	fLockDelay = Descriptor->lock_delay;
82
83//	usb_endpoint_descriptor* endpoint = Interface->endpoint[0]->descr;
84	fEndpointAttributes = Endpoint->attributes;
85	fEndpointAddress = Endpoint->endpoint_address;
86	fMaxPacketSize = Endpoint->max_packet_size;
87
88	TRACE(UAC, "fCSAttributes:%d\n", fCSAttributes);
89	TRACE(UAC, "fLockDelayUnits:%d\n", fLockDelayUnits);
90	TRACE(UAC, "fLockDelay:%d\n", fLockDelay);
91	TRACE(UAC, "fMaxPacketSize:%d\n", fMaxPacketSize);
92	TRACE(UAC, "fEndpointAddress:%#02x\n", fEndpointAddress);
93	TRACE(UAC, "fEndpointAttributes:%d\n", fEndpointAttributes);
94}
95
96
97ASEndpointDescriptor::~ASEndpointDescriptor()
98{
99}
100
101
102_ASFormatDescriptor::_ASFormatDescriptor(
103		usb_audio_format_descriptor* Descriptor)
104	:
105	fFormatType(USB_AUDIO_FORMAT_TYPE_UNDEFINED)
106{
107	fFormatType = Descriptor->format_type;
108}
109
110
111_ASFormatDescriptor::~_ASFormatDescriptor()
112{
113}
114
115
116uint32
117_ASFormatDescriptor::GetSamFreq(const usb_audio_sampling_freq& freq)
118{
119	return freq.bytes[0] | freq.bytes[1] << 8 | freq.bytes[2] << 16;
120}
121
122
123usb_audio_sampling_freq
124_ASFormatDescriptor::GetSamFreq(uint32 samplingRate)
125{
126	usb_audio_sampling_freq freq;
127	for (size_t i = 0; i < 3; i++)
128		freq.bytes[i] = 0xFF & samplingRate >> 8 * i;
129	return freq;
130}
131
132
133TypeIFormatDescriptor::TypeIFormatDescriptor(
134		usb_audio_format_descriptor* Descriptor)
135	:
136	_ASFormatDescriptor(Descriptor),
137	fNumChannels(0),
138	fSubframeSize(0),
139	fBitResolution(0),
140	fSampleFrequencyType(0)
141{
142	/*fStatus =*/ Init(Descriptor);
143}
144
145
146TypeIFormatDescriptor::~TypeIFormatDescriptor()
147{
148}
149
150
151status_t
152TypeIFormatDescriptor::Init(usb_audio_format_descriptor* Descriptor)
153{
154	fNumChannels = Descriptor->typeI.nr_channels;
155	fSubframeSize = Descriptor->typeI.subframe_size;
156	fBitResolution = Descriptor->typeI.bit_resolution;
157	fSampleFrequencyType = Descriptor->typeI.sam_freq_type;
158
159	if (fSampleFrequencyType == 0) {
160		fSampleFrequencies.PushBack(
161			GetSamFreq(Descriptor->typeI.sam_freqs[0]));
162		fSampleFrequencies.PushBack(
163			GetSamFreq(Descriptor->typeI.sam_freqs[1]));
164	} else
165		for (size_t i = 0; i < fSampleFrequencyType; i++)
166			fSampleFrequencies.PushBack(
167				GetSamFreq(Descriptor->typeI.sam_freqs[i]));
168
169	TRACE(UAC, "fNumChannels:%d\n", fNumChannels);
170	TRACE(UAC, "fSubframeSize:%d\n", fSubframeSize);
171	TRACE(UAC, "fBitResolution:%d\n", fBitResolution);
172	TRACE(UAC, "fSampleFrequencyType:%d\n", fSampleFrequencyType);
173
174	for (int32 i = 0; i < fSampleFrequencies.Count(); i++)
175		TRACE(UAC, "Frequency #%d: %d\n", i, fSampleFrequencies[i]);
176
177	return B_OK;
178}
179
180
181TypeIIFormatDescriptor::TypeIIFormatDescriptor(
182		usb_audio_format_descriptor* Descriptor)
183	:
184	_ASFormatDescriptor(Descriptor),
185	fMaxBitRate(0),
186	fSamplesPerFrame(0),
187	fSampleFrequencyType(0),
188	fSampleFrequencies(0)
189{
190}
191
192
193TypeIIFormatDescriptor::~TypeIIFormatDescriptor()
194{
195}
196
197
198TypeIIIFormatDescriptor::TypeIIIFormatDescriptor(
199		usb_audio_format_descriptor* Descriptor)
200	:
201	TypeIFormatDescriptor(Descriptor)
202{
203}
204
205
206TypeIIIFormatDescriptor::~TypeIIIFormatDescriptor()
207{
208}
209
210
211AudioStreamAlternate::AudioStreamAlternate(size_t alternate,
212		ASInterfaceDescriptor* interface, ASEndpointDescriptor* endpoint,
213		_ASFormatDescriptor* format)
214	:
215	fAlternate(alternate),
216	fInterface(interface),
217	fEndpoint(endpoint),
218	fFormat(format),
219	fSamplingRate(0)
220{
221}
222
223
224AudioStreamAlternate::~AudioStreamAlternate()
225{
226	delete fInterface;
227	delete fEndpoint;
228	delete fFormat;
229}
230
231
232status_t
233AudioStreamAlternate::SetSamplingRate(uint32 newRate)
234{
235	TypeIFormatDescriptor* format
236		= static_cast<TypeIFormatDescriptor*>(Format());
237
238	if (format == NULL) {
239		TRACE(ERR, "Format not set for active alternate\n");
240		return B_NO_INIT;
241	}
242
243	Vector<uint32>& frequencies = format->fSampleFrequencies;
244	bool continuous = format->fSampleFrequencyType == 0;
245
246	if (newRate == 0) { // by default select max available
247		fSamplingRate = 0;
248		if (continuous)
249			fSamplingRate = max_c(frequencies[0], frequencies[1]);
250		else
251			for (int i = 0; i < frequencies.Count(); i++)
252				fSamplingRate = max_c(fSamplingRate, frequencies[i]);
253	} else {
254		if (continuous) {
255			uint32 min = min_c(frequencies[0], frequencies[1]);
256			uint32 max = max_c(frequencies[0], frequencies[1]);
257			if (newRate < min || newRate > max) {
258				TRACE(ERR, "Rate %d outside of %d - %d ignored.\n",
259					newRate, min, max);
260				return B_BAD_INDEX;
261			}
262			fSamplingRate = newRate;
263		} else {
264			for (int i = 0; i < frequencies.Count(); i++) {
265				if (newRate == frequencies[i]) {
266					fSamplingRate = newRate;
267					return B_OK;
268				}
269			}
270			TRACE(ERR, "Rate %d not found - ignore it.\n", newRate);
271			return B_BAD_INDEX;
272		}
273	}
274
275	return B_OK;
276}
277
278
279uint32
280AudioStreamAlternate::GetSamplingRateId(uint32 rate)
281{
282	if (rate == 0)
283		rate = fSamplingRate;
284
285	for (size_t i = 0; i < B_COUNT_OF(ratesMap); i++)
286		if (ratesMap[i].rate == rate)
287			return ratesMap[i].rateId;
288
289	TRACE(ERR, "Ignore unsupported sample rate %d.\n", rate);
290	return 0;
291}
292
293
294uint32
295AudioStreamAlternate::GetSamplingRateIds()
296{
297	TypeIFormatDescriptor* format
298		= static_cast<TypeIFormatDescriptor*>(Format());
299
300	if (format == NULL) {
301		TRACE(ERR, "Format not set for active alternate\n");
302		return 0;
303	}
304
305	uint32 rates = 0;
306	Vector<uint32>& frequencies = format->fSampleFrequencies;
307	if (format->fSampleFrequencyType == 0) { // continuous frequencies
308		uint32 min = min_c(frequencies[0], frequencies[1]);
309		uint32 max = max_c(frequencies[0], frequencies[1]);
310
311		for (int i = 0; i < frequencies.Count(); i++) {
312			if (frequencies[i] < min || frequencies[i] > max)
313				continue;
314			rates |= GetSamplingRateId(frequencies[i]);
315		}
316	} else
317		for (int i = 0; i < frequencies.Count(); i++)
318			rates |= GetSamplingRateId(frequencies[i]);
319
320	return rates;
321}
322
323
324uint32
325AudioStreamAlternate::GetFormatId()
326{
327	TypeIFormatDescriptor* format
328		= static_cast<TypeIFormatDescriptor*>(Format());
329
330	if (format == NULL || Interface() == NULL) {
331		TRACE(ERR, "Ignore alternate due format "
332			"%#08x or interface %#08x null.\n", format, Interface());
333		return 0;
334	}
335
336	uint32 formats = 0;
337	switch (Interface()->fFormatTag) {
338		case USB_AUDIO_FORMAT_PCM8:
339			formats = B_FMT_8BIT_U;
340			break;
341		case USB_AUDIO_FORMAT_IEEE_FLOAT:
342			formats = B_FMT_FLOAT;
343			break;
344		case USB_AUDIO_FORMAT_PCM:
345			switch(format->fBitResolution) {
346				case 8: formats = B_FMT_8BIT_S; break;
347				case 16: formats = B_FMT_16BIT; break;
348				case 18: formats = B_FMT_18BIT; break;
349				case 20: formats = B_FMT_20BIT; break;
350				case 24: formats = B_FMT_24BIT; break;
351				case 32: formats = B_FMT_32BIT; break;
352				default:
353					TRACE(ERR, "Ignore unsupported "
354						"bit resolution %d for alternate.\n",
355						format->fBitResolution);
356					break;
357			}
358			break;
359		default:
360			TRACE(ERR, "Ignore unsupported "
361				"format bit resolution %d for alternate.\n",
362				Interface()->fFormatTag);
363			break;
364	}
365
366	return formats;
367}
368
369
370uint32
371AudioStreamAlternate::SamplingRateFromId(uint32 id)
372{
373	for (size_t i = 0; i < B_COUNT_OF(ratesMap); i++)
374		if (ratesMap[i].rateId == id)
375			return ratesMap[i].rate;
376
377	TRACE(ERR, "Unknown sample rate id: %d.\n", id);
378	return 0;
379}
380
381
382status_t
383AudioStreamAlternate::SetSamplingRateById(uint32 newId)
384{
385	return SetSamplingRate(SamplingRateFromId(newId));
386}
387
388
389status_t
390AudioStreamAlternate::SetFormatId(uint32 /*newFormatId*/)
391{
392	return B_OK; // TODO
393}
394
395
396AudioStreamingInterface::AudioStreamingInterface(
397		AudioControlInterface*	controlInterface,
398		size_t interface, usb_interface_list* List)
399	:
400	fInterface(interface),
401	fControlInterface(controlInterface),
402	fIsInput(false),
403	fActiveAlternate(0)
404{
405	TRACE(ERR, "if[%d]:alt_count:%d\n", interface, List->alt_count);
406
407	for (size_t alt = 0; alt < List->alt_count; alt++) {
408		ASInterfaceDescriptor*	ASInterface	= NULL;
409		ASEndpointDescriptor*	ASEndpoint	= NULL;
410		_ASFormatDescriptor*	ASFormat	= NULL;
411
412		usb_interface_info* Interface = &List->alt[alt];
413
414		TRACE(ERR, "if[%d]:alt[%d]:descrs_count:%d\n",
415			interface, alt, Interface->generic_count);
416		for (size_t i = 0; i < Interface->generic_count; i++) {
417			usb_audiocontrol_header_descriptor* Header
418				= (usb_audiocontrol_header_descriptor*)Interface->generic[i];
419
420			if (Header->descriptor_type == USB_AUDIO_CS_INTERFACE) {
421				switch(Header->descriptor_subtype) {
422					case USB_AUDIO_AS_GENERAL:
423						if (ASInterface == 0)
424							ASInterface = new(std::nothrow)
425								ASInterfaceDescriptor(
426								(usb_audio_streaming_interface_descriptor*)Header);
427						else
428							TRACE(ERR, "Duplicate AStream interface ignored.\n");
429						break;
430					case USB_AUDIO_AS_FORMAT_TYPE:
431						if (ASFormat == 0)
432							ASFormat = new(std::nothrow) TypeIFormatDescriptor(
433								(usb_audio_format_descriptor*) Header);
434						else
435							TRACE(ERR, "Duplicate AStream format ignored.\n");
436						break;
437					default:
438						TRACE(ERR, "Ignore AStream descr subtype %#04x\n",
439							Header->descriptor_subtype);
440						break;
441				}
442				continue;
443			}
444
445			if (Header->descriptor_type == USB_AUDIO_CS_ENDPOINT) {
446				if (ASEndpoint == 0) {
447					usb_endpoint_descriptor* Endpoint
448						= Interface->endpoint[0].descr;
449					ASEndpoint = new(std::nothrow) ASEndpointDescriptor(Endpoint,
450						(usb_audio_streaming_endpoint_descriptor*)Header);
451				} else
452					TRACE(ERR, "Duplicate AStream endpoint ignored.\n");
453				continue;
454			}
455
456			TRACE(ERR, "Ignore Audio Stream of "
457				"unknown descriptor type %#04x.\n",	Header->descriptor_type);
458		}
459
460		fAlternates.Add(new(std::nothrow) AudioStreamAlternate(alt, ASInterface,
461			ASEndpoint, ASFormat));
462	}
463}
464
465
466AudioStreamingInterface::~AudioStreamingInterface()
467{
468	// we own stream header objects too, so free them
469	for (Vector<AudioStreamAlternate*>::Iterator I = fAlternates.Begin();
470			I != fAlternates.End(); I++)
471		delete *I;
472
473	fAlternates.MakeEmpty();
474}
475
476
477uint8
478AudioStreamingInterface::TerminalLink()
479{
480	if (fAlternates[fActiveAlternate]->Interface() != NULL)
481		return fAlternates[fActiveAlternate]->Interface()->fTerminalLink;
482	return 0;
483}
484
485
486AudioChannelCluster*
487AudioStreamingInterface::ChannelCluster()
488{
489	_AudioControl* control = fControlInterface->Find(TerminalLink());
490	if (control == 0) {
491		TRACE(ERR, "Control was not found for terminal id:%d.\n",
492			TerminalLink());
493		return NULL;
494	}
495
496	return control->OutCluster();
497}
498
499
500void
501AudioStreamingInterface::GetFormatsAndRates(multi_description* Description)
502{
503	Description->interface_flags
504		|= fIsInput ? B_MULTI_INTERFACE_RECORD : B_MULTI_INTERFACE_PLAYBACK;
505
506	uint32 rates = fAlternates[fActiveAlternate]->GetSamplingRateIds();
507	uint32 formats = fAlternates[fActiveAlternate]->GetFormatId();
508
509	if (fIsInput) {
510		Description->input_rates = rates;
511		Description->input_formats = formats;
512	} else {
513		Description->output_rates = rates;
514		Description->output_formats = formats;
515	}
516}
517
518