haiku.git

/*
 *	Driver for USB Audio Device Class devices.
 *	Copyright (c) 2009-13 S.Zharski <imker@gmx.li>
 *	Distributed under the terms of the MIT license.
 *
 */
#ifndef _AUDIO_STREAMING_INTERFACE_H_
#define _AUDIO_STREAMING_INTERFACE_H_


#include <USB3.h>
#include <util/VectorMap.h>

#include "AudioControlInterface.h"


class ASInterfaceDescriptor {
public:
							ASInterfaceDescriptor(
								usb_audio_streaming_interface_descriptor*
								Descriptor);
							~ASInterfaceDescriptor();

// protected:
			uint8			fTerminalLink;
			uint8			fDelay;
			uint16			fFormatTag;
};


class ASEndpointDescriptor {
public:
							ASEndpointDescriptor(
								usb_endpoint_descriptor* Endpoint,
								usb_audio_streaming_endpoint_descriptor*
								Descriptor);
							~ASEndpointDescriptor();

// protected:
			uint8			fCSAttributes;
			uint8			fLockDelayUnits;
			uint16			fLockDelay;
			uint16			fMaxPacketSize;
			uint8			fEndpointAddress;
			uint8			fEndpointAttributes;
};


class _ASFormatDescriptor {
public:
							_ASFormatDescriptor(
								usb_audio_format_descriptor* Descriptor);
	virtual					~_ASFormatDescriptor();

// protected:
			uint8			fFormatType;
	static	uint32			GetSamFreq(const usb_audio_sampling_freq& freq);
	static	usb_audio_sampling_freq	GetSamFreq(uint32 rate);
};


class TypeIFormatDescriptor : public _ASFormatDescriptor {
public:
							TypeIFormatDescriptor(
								usb_audio_format_descriptor* Descriptor);
	virtual					~TypeIFormatDescriptor();

			status_t		Init(usb_audio_format_descriptor* Descriptor);

// protected:
			uint8			fNumChannels;
			uint8			fSubframeSize;
			uint8			fBitResolution;
			uint8			fSampleFrequencyType;
			Vector<uint32>	fSampleFrequencies;
};


class TypeIIFormatDescriptor : public _ASFormatDescriptor {
public:
							TypeIIFormatDescriptor(
								usb_audio_format_descriptor* Descriptor);
	virtual					~TypeIIFormatDescriptor();

// protected:
			uint16			fMaxBitRate;
			uint16			fSamplesPerFrame;
			uint8			fSampleFrequencyType;
			Vector<uint32>	fSampleFrequencies;
};


class TypeIIIFormatDescriptor : public TypeIFormatDescriptor {
public:
							TypeIIIFormatDescriptor(
								usb_audio_format_descriptor* Descriptor);
	virtual					~TypeIIIFormatDescriptor();

// protected:
};


class AudioStreamAlternate {
public:
									AudioStreamAlternate(size_t alternate,
										ASInterfaceDescriptor* interface,
										ASEndpointDescriptor* endpoint,
										_ASFormatDescriptor* format);
									~AudioStreamAlternate();

			ASInterfaceDescriptor*	Interface()	{ return fInterface; }
			ASEndpointDescriptor*	Endpoint()	{ return fEndpoint;	 }
			_ASFormatDescriptor*	Format()	{ return fFormat;	 }

			status_t				SetSamplingRate(uint32 newRate);
			status_t				SetSamplingRateById(uint32 newId);
			uint32					GetSamplingRate() { return fSamplingRate; }
			uint32					GetSamplingRateId(uint32 rate);
			uint32					GetSamplingRateIds();
			uint32					GetFormatId();
			status_t				SetFormatId(uint32 newFormatId);
			uint32					SamplingRateFromId(uint32 id);

protected:

			size_t					fAlternate;
			ASInterfaceDescriptor*	fInterface;
			ASEndpointDescriptor*	fEndpoint;
			_ASFormatDescriptor*	fFormat;
			uint32					fSamplingRate;
};


class AudioStreamingInterface {
public:
								AudioStreamingInterface(
									AudioControlInterface*	controlInterface,
									size_t interface, usb_interface_list* List);
								~AudioStreamingInterface();

	//		status_t			InitCheck() { return fStatus; }
			uint8				TerminalLink();
			bool				IsInput() { return fIsInput; }

			AudioChannelCluster* ChannelCluster();

			void				GetFormatsAndRates(
									multi_description* Description);
protected:
			size_t				fInterface;
			AudioControlInterface*	fControlInterface;

	//		status_t			fStatus;
			bool				fIsInput;
		// alternates of the streams
			Vector<AudioStreamAlternate*>	fAlternates;
			size_t				fActiveAlternate;
};


#endif // _AUDIO_STREAMING_INTERFACE_H_