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

#include "AudioControlInterface.h"

#include <usb/USB_audio.h>

#include "Device.h"
#include "Driver.h"
#include "Settings.h"


// control id is encoded in following way
//      CS      CN      ID      IF where:
//      CS                              - control selector
//              CN                      - channel
//                      ID              - id of this feature unit
//                              IF      - interface

#define CTL_ID(_CS, _CN, _ID, _IF) \
        (((_CS) << 24) | ((_CN) << 16) | ((_ID) << 8) | (_IF))

#define CS_FROM_CTLID(_ID) (0xff & ((_ID) >> 24))
#define CN_FROM_CTLID(_ID) (0xff & ((_ID) >> 16))
#define ID_FROM_CTLID(_ID) (0xff & ((_ID) >> 8))

#define REQ_VALUE(_ID) (0xffff & ((_ID) >> 16))
#define REQ_INDEX(_ID) (0xffff & (_ID))


struct _Designation {
        uint32 ch;
        uint32 bus;
} gDesignations[AudioControlInterface::kChannels] = {
        { B_CHANNEL_LEFT,                               B_CHANNEL_STEREO_BUS    },
        { B_CHANNEL_RIGHT,                              B_CHANNEL_STEREO_BUS    },
        { B_CHANNEL_CENTER,                             B_CHANNEL_SURROUND_BUS  },
        { B_CHANNEL_SUB,                                B_CHANNEL_SURROUND_BUS  },
        { B_CHANNEL_REARLEFT,                   B_CHANNEL_STEREO_BUS    },
        { B_CHANNEL_REARRIGHT,                  B_CHANNEL_STEREO_BUS    },
        { B_CHANNEL_FRONT_LEFT_CENTER,  B_CHANNEL_STEREO_BUS    },
        { B_CHANNEL_FRONT_RIGHT_CENTER, B_CHANNEL_STEREO_BUS    },
        { B_CHANNEL_BACK_CENTER,                B_CHANNEL_SURROUND_BUS  },
        { B_CHANNEL_SIDE_LEFT,                  B_CHANNEL_STEREO_BUS    },
        { B_CHANNEL_SIDE_RIGHT,                 B_CHANNEL_STEREO_BUS    },
        { B_CHANNEL_TOP_CENTER,                 B_CHANNEL_SURROUND_BUS  },
        { B_CHANNEL_TOP_FRONT_LEFT,             B_CHANNEL_STEREO_BUS    },
        { B_CHANNEL_TOP_FRONT_CENTER,   B_CHANNEL_SURROUND_BUS  },
        { B_CHANNEL_TOP_FRONT_RIGHT,    B_CHANNEL_STEREO_BUS    },
        { B_CHANNEL_TOP_BACK_LEFT,              B_CHANNEL_STEREO_BUS    },
        { B_CHANNEL_TOP_BACK_CENTER,    B_CHANNEL_SURROUND_BUS  },
        { B_CHANNEL_TOP_BACK_RIGHT,             B_CHANNEL_STEREO_BUS    }
};


struct _MixPageCollector : public Vector<multi_mix_control> {
        _MixPageCollector(const char* pageName) {
                multi_mix_control page;
                memset(&page, 0, sizeof(multi_mix_control));
                page.flags = B_MULTI_MIX_GROUP;
                strlcpy(page.name, pageName, sizeof(page.name));
                PushBack(page);
        }
};


_AudioControl::_AudioControl(AudioControlInterface*     interface,
                usb_audiocontrol_header_descriptor* Header)
        :
        fStatus(B_NO_INIT),
        fInterface(interface),
        fSubType(Header->descriptor_subtype),
        fID(0),
        fSourceID(0),
        fStringIndex(0)
{
}


_AudioControl::~_AudioControl()
{
}


AudioChannelCluster*
_AudioControl::OutCluster()
{
        if (SourceID() == 0 || fInterface == NULL)
                return NULL;

        _AudioControl* control = fInterface->Find(SourceID());
        if (control == NULL)
                return NULL;

        return control->OutCluster();
}


AudioChannelCluster::AudioChannelCluster()
        :
        fOutChannelsNumber(0),
        fChannelsConfig(0),
        fChannelNames(0)
{
}


AudioChannelCluster::~AudioChannelCluster()
{
}


bool
AudioChannelCluster::HasChannel(uint32 location)
{
        return (fChannelsConfig & location) == location;
}


_Terminal::_Terminal(AudioControlInterface*     interface,
        usb_audiocontrol_header_descriptor* Header)
        :
        _AudioControl(interface, Header),
        fTerminalType(0),
        fAssociatedTerminal(0),
        fClockSourceId(0),
        fControlsBitmap(0)
{
}


_Terminal::~_Terminal()
{
}


const char*
_Terminal::Name()
{
        return _GetTerminalDescription(fTerminalType);
}


bool
_Terminal::IsUSBIO()
{
        return (fTerminalType & 0xff00) == USB_AUDIO_UNDEFINED_USB_IO;
}


const char*
_Terminal::_GetTerminalDescription(uint16 TerminalType)
{
        static struct _pair {
                uint16 type;
                const char* description;
        } termInfoPairs[] = {
                // USB Terminal Types
                { USB_AUDIO_UNDEFINED_USB_IO,           "USB I/O" },
                { USB_AUDIO_STREAMING_USB_IO,           "USB I/O" },
                { USB_AUDIO_VENDOR_USB_IO,                      "Vendor USB I/O" },
                // Input Terminal Types
                { USB_AUDIO_UNDEFINED_IN,                       "Undefined Input" },
                { USB_AUDIO_MICROPHONE_IN,                      "Microphone" },
                { USB_AUDIO_DESKTOPMIC_IN,                      "Desktop Microphone" },
                { USB_AUDIO_PERSONALMIC_IN,                     "Personal Microphone" },
                { USB_AUDIO_OMNI_MIC_IN,                        "Omni-directional Mic" },
                { USB_AUDIO_MICS_ARRAY_IN,                      "Microphone Array" },
                { USB_AUDIO_PROC_MICS_ARRAY_IN,         "Processing Mic Array" },
                // Output Terminal Types
                { USB_AUDIO_UNDEFINED_OUT,                      "Undefined Output" },
                { USB_AUDIO_SPEAKER_OUT,                        "Speaker" },
                { USB_AUDIO_HEAD_PHONES_OUT,            "Headphones" },
                { USB_AUDIO_HMD_AUDIO_OUT,                      "Head Mounted Disp.Audio" },
                { USB_AUDIO_DESKTOP_SPEAKER,            "Desktop Speaker" },
                { USB_AUDIO_ROOM_SPEAKER,                       "Room Speaker" },
                { USB_AUDIO_COMM_SPEAKER,                       "Communication Speaker" },
                { USB_AUDIO_LFE_SPEAKER,                        "LFE Speaker" },
                // Bi-directional Terminal Types
                { USB_AUDIO_UNDEFINED_IO,                       "Undefined I/O" },
                { USB_AUDIO_HANDSET_IO,                         "Handset" },
                { USB_AUDIO_HEADSET_IO,                         "Headset" },
                { USB_AUDIO_SPEAKER_PHONE_IO,           "Speakerphone" },
                { USB_AUDIO_SPEAKER_PHONEES_IO,         "Echo-supp Speakerphone" },
                { USB_AUDIO_SPEAKER_PHONEEC_IO,         "Echo-cancel Speakerphone" },
                // Telephony Terminal Types
                { USB_AUDIO_UNDEF_TELEPHONY_IO,         "Undefined Telephony" },
                { USB_AUDIO_PHONE_LINE_IO,                      "Phone Line" },
                { USB_AUDIO_TELEPHONE_IO,                       "Telephone" },
                { USB_AUDIO_DOWNLINE_PHONE_IO,          "Down Line Phone" },
                // External Terminal Types
                { USB_AUDIO_UNDEFINEDEXT_IO,            "Undefined External I/O" },
                { USB_AUDIO_ANALOG_CONNECTOR_IO,        "Analog Connector" },
                { USB_AUDIO_DAINTERFACE_IO,                     "Digital Audio Interface" },
                { USB_AUDIO_LINE_CONNECTOR_IO,          "Line Connector" },
                { USB_AUDIO_LEGACY_CONNECTOR_IO,        "LegacyAudioConnector" },
                { USB_AUDIO_SPDIF_INTERFACE_IO,         "S/PDIF Interface" },
                { USB_AUDIO_DA1394_STREAM_IO,           "1394 DA Stream" },
                { USB_AUDIO_DV1394_STREAMSOUND_IO,      "1394 DV Stream Soundtrack" },
                { USB_AUDIO_ADAT_LIGHTPIPE_IO,          "Alesis DAT Stream" },
                { USB_AUDIO_TDIF_IO,                            "Tascam Digital Interface" },
                { USB_AUDIO_MADI_IO,                            "AES Multi-channel interface" },
                // Embedded Terminal Types
                { USB_AUDIO_UNDEF_EMBEDDED_IO,          "Undefined Embedded I/O" },
                { USB_AUDIO_LC_NOISE_SOURCE_OUT,        "Level Calibration Noise Source" },
                { USB_AUDIO_EQUALIZATION_NOISE_OUT,     "Equalization Noise" },
                { USB_AUDIO_CDPLAYER_IN,                        "CD Player" },
                { USB_AUDIO_DAT_IO,                                     "DAT" },
                { USB_AUDIO_DCC_IO,                                     "DCC" },
                { USB_AUDIO_MINI_DISK_IO,                       "Mini Disk" },
                { USB_AUDIO_ANALOG_TAPE_IO,                     "Analog Tape" },
                { USB_AUDIO_PHONOGRAPH_IN,                      "Phonograph" },
                { USB_AUDIO_VCR_AUDIO_IN,                       "VCR Audio" },
                { USB_AUDIO_VIDEO_DISC_AUDIO_IN,        "Video Disc Audio" },
                { USB_AUDIO_DVD_AUDIO_IN,                       "DVD Audio" },
                { USB_AUDIO_TV_TUNER_AUDIO_IN,          "TV Tuner Audio" },
                { USB_AUDIO_SAT_RECEIVER_AUDIO_IN,      "Satellite Receiver Audio" },
                { USB_AUDIO_CABLE_TUNER_AUDIO_IN,       "Cable Tuner Audio" },
                { USB_AUDIO_DSS_AUDIO_IN,                       "DSS Audio" },
                { USB_AUDIO_RADIO_RECEIVER_IN,          "Radio Receiver" },
                { USB_AUDIO_RADIO_TRANSMITTER_IN,       "Radio Transmitter" },
                { USB_AUDIO_MULTI_TRACK_RECORDER_IO,"Multi-track Recorder" },
                { USB_AUDIO_SYNTHESIZER_IO,                     "Synthesizer" },
                { USB_AUDIO_PIANO_IO,                           "Piano" },
                { USB_AUDIO_GUITAR_IO,                          "Guitar" },
                { USB_AUDIO_DRUMS_IO,                           "Percussion Instrument" },
                { USB_AUDIO_INSTRUMENT_IO,                      "Musical Instrument" }
        };

        for (size_t i = 0; i < B_COUNT_OF(termInfoPairs); i++)
                if (termInfoPairs[i].type == TerminalType)
                        return termInfoPairs[i].description;

        TRACE(ERR, "Unknown Terminal Type: %#06x", TerminalType);
        return "Unknown";
}


InputTerminal::InputTerminal(AudioControlInterface*     interface,
                usb_audiocontrol_header_descriptor* Header)
        :
        _AudioChannelCluster<_Terminal>(interface, Header)
{
        usb_audio_input_terminal_descriptor* Terminal
                = (usb_audio_input_terminal_descriptor*) Header;
        fID                                     = Terminal->terminal_id;
        fTerminalType           = Terminal->terminal_type;
        fAssociatedTerminal = Terminal->assoc_terminal;

        TRACE(UAC, "Input Terminal ID:%d >>>\n", fID);
        TRACE(UAC, "Terminal type:%s (%#06x)\n",
                _GetTerminalDescription(fTerminalType), fTerminalType);
        TRACE(UAC, "Assoc.terminal:%d\n",       fAssociatedTerminal);

        if (fInterface->SpecReleaseNumber() < 0x200) {
                fOutChannelsNumber      = Terminal->r1.num_channels;
                fChannelsConfig         = Terminal->r1.channel_config;
                fChannelNames           = Terminal->r1.channel_names;
                fStringIndex            = Terminal->r1.terminal;
        } else {
                fClockSourceId          = Terminal->r2.clock_source_id;
                fOutChannelsNumber      = Terminal->r2.num_channels;
                fChannelsConfig         = Terminal->r2.channel_config;
                fChannelNames           = Terminal->r2.channel_names;
                fControlsBitmap         = Terminal->r2.bm_controls;
                fStringIndex            = Terminal->r2.terminal;

                TRACE(UAC, "Clock Source ID:%d\n", fClockSourceId);
                TRACE(UAC, "Controls Bitmap:%#04x\n", fControlsBitmap);
        }

        TRACE(UAC, "Out.channels num:%d\n",      fOutChannelsNumber);
        TRACE(UAC, "Channels config:%#06x\n", fChannelsConfig);
        TRACE(UAC, "Channels names:%d\n",        fChannelNames);
        TRACE(UAC, "StringIndex:%d\n",           fStringIndex);

        fStatus = B_OK;
}


InputTerminal::~InputTerminal()
{
}


const char*
InputTerminal::Name()
{
        if (fTerminalType == USB_AUDIO_STREAMING_USB_IO)
                return "USB Input";
        return _Terminal::Name();
}


OutputTerminal::OutputTerminal(AudioControlInterface*   interface,
                usb_audiocontrol_header_descriptor* Header)
        :
        _Terminal(interface, Header)
{
        usb_audio_output_terminal_descriptor* Terminal
                = (usb_audio_output_terminal_descriptor*) Header;

        fID                                     = Terminal->terminal_id;
        fTerminalType           = Terminal->terminal_type;
        fAssociatedTerminal     = Terminal->assoc_terminal;
        fSourceID                       = Terminal->source_id;

        TRACE(UAC, "Output Terminal ID:%d >>>\n",       fID);
        TRACE(UAC, "Terminal type:%s (%#06x)\n",
                _GetTerminalDescription(fTerminalType), fTerminalType);
        TRACE(UAC, "Assoc.terminal:%d\n",               fAssociatedTerminal);
        TRACE(UAC, "Source ID:%d\n",                            fSourceID);

        if (fInterface->SpecReleaseNumber() < 0x200) {
                fStringIndex = Terminal->r1.terminal;
        } else {
                fClockSourceId  = Terminal->r2.clock_source_id;
                fControlsBitmap = Terminal->r2.bm_controls;
                fStringIndex    = Terminal->r2.terminal;

                TRACE(UAC, "Clock Source ID:%d\n", fClockSourceId);
                TRACE(UAC, "Controls Bitmap:%#04x\n", fControlsBitmap);
        }

        TRACE(UAC, "StringIndex:%d\n", fStringIndex);

        fStatus = B_OK;
}


OutputTerminal::~OutputTerminal()
{
}


const char*
OutputTerminal::Name()
{
        if (fTerminalType == USB_AUDIO_STREAMING_USB_IO)
                return "USB Output";
        return _Terminal::Name();
}


MixerUnit::MixerUnit(AudioControlInterface*     interface,
                usb_audiocontrol_header_descriptor* Header)
        :
        _AudioChannelCluster<_AudioControl>(interface, Header),
        fBmControlsR2(0)
{
        usb_audio_mixer_unit_descriptor* Mixer
                = (usb_audio_mixer_unit_descriptor*) Header;

        fID = Mixer->unit_id;
        TRACE(UAC, "Mixer ID:%d >>>\n", fID);

        TRACE(UAC, "Number of input pins:%d\n", Mixer->num_input_pins);
        for (size_t i = 0; i < Mixer->num_input_pins; i++) {
                fInputPins.PushBack(Mixer->input_pins[i]);
                TRACE(UAC, "Input pin #%d:%d\n", i, fInputPins[i]);
        }

        uint8* mixerControlsData = NULL;
        uint8 mixerControlsSize = 0;

        if (fInterface->SpecReleaseNumber() < 0x200) {
                usb_audio_output_channels_descriptor_r1* OutChannels
                        = (usb_audio_output_channels_descriptor_r1*)
                        &Mixer->input_pins[Mixer->num_input_pins];

                fOutChannelsNumber      = OutChannels->num_output_pins;
                fChannelsConfig         = OutChannels->channel_config;
                fChannelNames           = OutChannels->channel_names;

                mixerControlsData = (uint8*) ++OutChannels;
                mixerControlsSize = Mixer->length - 10 - Mixer->num_input_pins;
                fStringIndex = *(mixerControlsData + mixerControlsSize);

#if 0 // TEST
                if (fOutChannelsNumber > 2) {
                //      fOutChannelsNumber = 2;
                //      fChannelsConfig = 0x03;
                        mixerControlsData[0] = 0x80;
                        mixerControlsData[1] = 0x40;
                        mixerControlsData[2] = 0x20;
                        mixerControlsData[3] = 0x10;
                        mixerControlsData[4] = 0x08;
                        mixerControlsData[5] = 0x04;
                        mixerControlsData[6] = 0x02;
                        mixerControlsData[7] = 0x01;
                        mixerControlsData[8] = 0x80;
                        mixerControlsData[9] = 0x40;
                        mixerControlsData[10] = 0x02;
                        mixerControlsData[11] = 0x01;
                }
#endif

        } else {
                usb_audio_output_channels_descriptor* OutChannels
                        = (usb_audio_output_channels_descriptor*)
                        &Mixer->input_pins[Mixer->num_input_pins];

                fOutChannelsNumber      = OutChannels->num_output_pins;
                fChannelsConfig         = OutChannels->channel_config;
                fChannelNames           = OutChannels->channel_names;

                mixerControlsData = (uint8*) ++OutChannels;
                mixerControlsSize = Mixer->length - 13 - Mixer->num_input_pins;
                fBmControlsR2 = *(mixerControlsData + mixerControlsSize);
                fStringIndex = *(mixerControlsData + mixerControlsSize + 1);

                TRACE(UAC, "Control Bitmap:%#04x\n", fBmControlsR2);
        }

        TRACE(UAC, "Out channels number:%d\n",          fOutChannelsNumber);
        TRACE(UAC, "Out channels config:%#06x\n",       fChannelsConfig);
        TRACE(UAC, "Out channels names:%d\n",           fChannelNames);
        TRACE(UAC, "Controls Size:%d\n", mixerControlsSize);

        for (size_t i = 0; i < mixerControlsSize; i++) {
                fControlsBitmap.PushBack(mixerControlsData[i]);
                TRACE(UAC, "Controls Data[%d]:%#x\n", i, fControlsBitmap[i]);
        }

        TRACE(UAC, "StringIndex:%d\n", fStringIndex);

        fStatus = B_OK;
}


MixerUnit::~MixerUnit()
{
}


bool
MixerUnit::HasProgrammableControls()
{
        for (int i = 0; i < fControlsBitmap.Count(); i++)
                if (fControlsBitmap[i] != 0)
                        return true;
        return false;
}


bool
MixerUnit::IsControlProgrammable(int inChannel, int outChannel)
{
        AudioChannelCluster* outCluster = OutCluster();
        if (outCluster == NULL) {
                TRACE(ERR, "Output cluster is not valid.\n");
                return false;
        }

        bool result = false;
        if (outChannel < outCluster->ChannelsCount()) {
                int index = inChannel * outCluster->ChannelsCount()+ outChannel;
                result = (fControlsBitmap[index >> 3] & (0x80 >> (index & 7))) != 0;
        }

//      TRACE(UAC, "in:%d out:%d is %s\n",
//              inChannel, outChannel, result ? "on" : "off");
        return result;
}


SelectorUnit::SelectorUnit(AudioControlInterface*       interface,
                usb_audiocontrol_header_descriptor* Header)
        :
        _AudioControl(interface, Header),
        fControlsBitmap(0)
{
        usb_audio_selector_unit_descriptor* Selector
                = (usb_audio_selector_unit_descriptor*) Header;

        fID = Selector->unit_id;
        TRACE(UAC, "Selector ID:%d >>>\n", fID);

        TRACE(UAC, "Number of input pins:%d\n", Selector->num_input_pins);
        for (size_t i = 0; i < Selector->num_input_pins; i++) {
                fInputPins.PushBack(Selector->input_pins[i]);
                TRACE(UAC, "Input pin #%d:%d\n", i, fInputPins[i]);
        }

        if (fInterface->SpecReleaseNumber() < 0x200) {
                fStringIndex = Selector->input_pins[Selector->num_input_pins];
        } else {
                fControlsBitmap = Selector->input_pins[Selector->num_input_pins];
                fStringIndex = Selector->input_pins[Selector->num_input_pins + 1];

                TRACE(UAC, "Controls Bitmap:%d\n", fControlsBitmap);
        }

        TRACE(UAC, "StringIndex:%d\n", fStringIndex);

        fStatus = B_OK;
}


SelectorUnit::~SelectorUnit()
{
}


AudioChannelCluster*
SelectorUnit::OutCluster()
{
        if (fInterface == NULL)
                return NULL;

        for (int i = 0; i < fInputPins.Count(); i++) {
                _AudioControl* control = fInterface->Find(fInputPins[i]);
                if (control == NULL)
                        continue;
                // selector has the same channels number in the
                // out cluster as anyone of his inputs
                if (control->OutCluster() != NULL)
                        return control->OutCluster();
        }

        return NULL;
}


FeatureUnit::FeatureUnit(AudioControlInterface* interface,
                usb_audiocontrol_header_descriptor* Header)
        :
        _AudioControl(interface, Header)
{
        usb_audio_feature_unit_descriptor* Feature
                = (usb_audio_feature_unit_descriptor*) Header;

        fID = Feature->unit_id;
        TRACE(UAC, "Feature ID:%d >>>\n", fID);

        fSourceID = Feature->source_id;
        TRACE(UAC, "Source ID:%d\n", fSourceID);

        uint8 controlSize = 4;
        uint8 channelsCount = (Feature->length - 6) / controlSize;
        uint8* ControlsBitmapPointer = (uint8*)&Feature->r2.bma_controls[0];

        if (fInterface->SpecReleaseNumber() < 0x200) {
                controlSize = Feature->r1.control_size;
                channelsCount = (Feature->length - 7) / Feature->r1.control_size;
                ControlsBitmapPointer = &Feature->r1.bma_controls[0];
        }

        TRACE(UAC, "Channel bitmap size:%d\n", controlSize);
        TRACE(UAC, "Channels number:%d\n", channelsCount - 1); // not add master!

        for (size_t i = 0; i < channelsCount; i++) {
                uint8* controlPointer = &ControlsBitmapPointer[i* controlSize];
                switch(controlSize) {
                        case 1: fControlBitmaps.PushBack(*controlPointer); break;
                        case 2: fControlBitmaps.PushBack(*(uint16*)controlPointer); break;
                        case 4: fControlBitmaps.PushBack(*(uint32*)controlPointer); break;
                        default:
                                TRACE(ERR, "Feature control of unsupported size %d ignored\n",
                                                                                                                controlSize);
                                continue;
                }

                NormalizeAndTraceChannel(i);
        }

        fStringIndex = ControlsBitmapPointer[channelsCount* controlSize];
        TRACE(UAC, "StringIndex:%d\n", fStringIndex);

        fStatus = B_OK;
}


FeatureUnit::~FeatureUnit()
{
}


const char*
FeatureUnit::Name()
{
        // first check if source of this FU is an input terminal
        _AudioControl* control = fInterface->Find(fSourceID);
        while (control != NULL) {
                if (control->SubType() != USB_AUDIO_AC_INPUT_TERMINAL)
                        break;

                // USB I/O terminal is a not good candidate to use it's name
                if (static_cast<_Terminal*>(control)->IsUSBIO())
                        break;

                // use the name of source input terminal as name of this FU
                return control->Name();
        }

        // check if output of this FU is connected to output terminal
        control = fInterface->FindOutputTerminal(fID);
        while (control != NULL) {
                if (control->SubType() != USB_AUDIO_AC_OUTPUT_TERMINAL)
                        break;

                // USB I/O terminal is a not good candidate to use it's name
                if (static_cast<_Terminal*>(control)->IsUSBIO())
                        break;

                // use the name of this output terminal as name of this FU
                return control->Name();
        }

        // otherwise get the generic name of this FU's source
        control = fInterface->Find(fSourceID);
        if (control != NULL && control->Name() != NULL
                        && strlen(control->Name()) > 0)
                return control->Name();

        // I have no more ideas, have you one?
        return "Unknown";
}


bool
FeatureUnit::HasControl(int32 Channel, uint32 Control)
{
        if (Channel >= fControlBitmaps.Count()) {
                TRACE(ERR, "Out of limits error of retrieving control %#010x "
                        "for channel %d\n", Control, Channel);
                return false;
        }

        return (Control & fControlBitmaps[Channel]) != 0;
}


void
FeatureUnit::NormalizeAndTraceChannel(int32 Channel)
{
        if (Channel >= fControlBitmaps.Count()) {
                TRACE(ERR, "Out of limits error of tracing channel %d\n", Channel);
                return;
        }

        struct _RemapInfo {
                uint32  rev1Bits;
                uint32  rev2Bits;
                const char* name;
        } remapInfos[] = {
                { BMA_CTL_MUTE_R1,              BMA_CTL_MUTE,                   "Mute"          },
                { BMA_CTL_VOLUME_R1,    BMA_CTL_VOLUME,                 "Volume"        },
                { BMA_CTL_BASS_R1,              BMA_CTL_BASS,                   "Bass"          },
                { BMA_CTL_MID_R1,               BMA_CTL_MID,                    "Mid"           },
                { BMA_CTL_TREBLE_R1,    BMA_CTL_TREBLE,                 "Treble"        },
                { BMA_CTL_GRAPHEQ_R1,   BMA_CTL_GRAPHEQ,                "Graphic Equalizer"     },
                { BMA_CTL_AUTOGAIN_R1,  BMA_CTL_AUTOGAIN,               "Automatic Gain"},
                { BMA_CTL_DELAY_R1,             BMA_CTL_DELAY,                  "Delay"                 },
                { BMA_CTL_BASSBOOST_R1, BMA_CTL_BASSBOOST,              "Bass Boost"    },
                { BMA_CTL_LOUDNESS_R1,  BMA_CTL_LOUDNESS,               "Loudness"              },
                { 0,                                    BMA_CTL_INPUTGAIN,              "InputGain"             },
                { 0,                                    BMA_CTL_INPUTGAINPAD,   "InputGainPad"  },
                { 0,                                    BMA_CTL_PHASEINVERTER,  "PhaseInverter" },
                { 0,                                    BMA_CTL_UNDERFLOW,              "Underflow"             },
                { 0,                                    BMA_CTL_OVERFLOW,               "Overflow"              }
        };

        if (Channel == 0)
                TRACE(UAC, "Master channel bitmap:%#x\n", fControlBitmaps[Channel]);
        else
                TRACE(UAC, "Channel %d bitmap:%#x\n", Channel, fControlBitmaps[Channel]);

        bool isRev1 = (fInterface->SpecReleaseNumber() < 0x200);

        uint32 remappedBitmap = 0;
        for (size_t i = 0; i < B_COUNT_OF(remapInfos); i++) {
                uint32 bits = isRev1 ? remapInfos[i].rev1Bits : remapInfos[i].rev2Bits;
                if ((fControlBitmaps[Channel] & bits) > 0) {
                        if (isRev1)
                                remappedBitmap |= remapInfos[i].rev2Bits;
                        TRACE(UAC, "\t%s\n", remapInfos[i].name);
                }
        }

        if (isRev1) {
                TRACE(UAC, "\t%#08x -> %#08x.\n",
                        fControlBitmaps[Channel], remappedBitmap);
                fControlBitmaps[Channel] = remappedBitmap;
        }
}


EffectUnit::EffectUnit(AudioControlInterface*   interface,
                usb_audiocontrol_header_descriptor* Header)
        :
        _AudioControl(interface, Header)
{
        usb_audio_input_terminal_descriptor* descriptor
                = (usb_audio_input_terminal_descriptor*) Header;
        TRACE(UAC, "Effect Unit:%d >>>\n", descriptor->terminal_id);
}


EffectUnit::~EffectUnit()
{
}


ProcessingUnit::ProcessingUnit(AudioControlInterface*   interface,
                usb_audiocontrol_header_descriptor* Header)
        :
        _AudioChannelCluster<_AudioControl>(interface, Header),
        fProcessType(0),
        fControlsBitmap(0)
{
        usb_audio_processing_unit_descriptor* Processing
                = (usb_audio_processing_unit_descriptor*) Header;

        fID = Processing->unit_id;
        TRACE(UAC, "Processing ID:%d >>>\n", fID);

        fProcessType = Processing->process_type;
        TRACE(UAC, "Processing Type:%d\n", fProcessType);

        TRACE(UAC, "Number of input pins:%d\n", Processing->num_input_pins);
        for (size_t i = 0; i < Processing->num_input_pins; i++) {
                fInputPins.PushBack(Processing->input_pins[i]);
                TRACE(UAC, "Input pin #%d:%d\n", i, fInputPins[i]);
        }

        if (fInterface->SpecReleaseNumber() < 0x200) {
                usb_audio_output_channels_descriptor_r1* OutChannels
                        = (usb_audio_output_channels_descriptor_r1*)
                        &Processing->input_pins[Processing->num_input_pins];

                fOutChannelsNumber      = OutChannels->num_output_pins;
                fChannelsConfig         = OutChannels->channel_config;
                fChannelNames           = OutChannels->channel_names;
        } else {
                usb_audio_output_channels_descriptor* OutChannels
                        = (usb_audio_output_channels_descriptor*)
                        &Processing->input_pins[Processing->num_input_pins];

                fOutChannelsNumber      = OutChannels->num_output_pins;
                fChannelsConfig         = OutChannels->channel_config;
                fChannelNames           = OutChannels->channel_names;
        }

        TRACE(UAC, "Out channels number:%d\n",          fOutChannelsNumber);
        TRACE(UAC, "Out channels config:%#06x\n",       fChannelsConfig);
        TRACE(UAC, "Out channels names:%d\n",           fChannelNames);
        /*
        uint8 controlsSize = Processing->length - 10 - Processing->num_input_pins;
        TRACE(UAC, "Controls Size:%d\n", controlsSize);

        uint8* controlsData = (uint8*) ++OutChannels;

        for (size_t i = 0; i < controlsSize; i++) {
                fProgrammableControls.PushBack(controlsData[i]);
                TRACE(UAC, "Controls Data[%d]:%#x\n", i, controlsData[i]);
        }

        fStringIndex = *(controlsData + controlsSize);

        TRACE(UAC, "StringIndex:%d\n", fStringIndex);
*/
        fStatus = B_OK;
}


ProcessingUnit::~ProcessingUnit()
{
}


ExtensionUnit::ExtensionUnit(AudioControlInterface*     interface,
                usb_audiocontrol_header_descriptor* Header)
        :
        _AudioChannelCluster<_AudioControl>(interface, Header),
        fExtensionCode(0),
        fControlsBitmap(0)
{
        usb_audio_extension_unit_descriptor* Extension
                = (usb_audio_extension_unit_descriptor*) Header;

        fID = Extension->unit_id;
        TRACE(UAC, "Extension ID:%d >>>\n", fID);

        fExtensionCode = Extension->extension_code;
        TRACE(UAC, "Extension Type:%d\n", fExtensionCode);

        TRACE(UAC, "Number of input pins:%d\n", Extension->num_input_pins);
        for (size_t i = 0; i < Extension->num_input_pins; i++) {
                fInputPins.PushBack(Extension->input_pins[i]);
                TRACE(UAC, "Input pin #%d:%d\n", i, fInputPins[i]);
        }

        if (fInterface->SpecReleaseNumber() < 0x200) {
                usb_audio_output_channels_descriptor_r1* OutChannels
                        = (usb_audio_output_channels_descriptor_r1*)
                        &Extension->input_pins[Extension->num_input_pins];

                fOutChannelsNumber      = OutChannels->num_output_pins;
                fChannelsConfig         = OutChannels->channel_config;
                fChannelNames           = OutChannels->channel_names;
        } else {
                usb_audio_output_channels_descriptor* OutChannels
                        = (usb_audio_output_channels_descriptor*)
                        &Extension->input_pins[Extension->num_input_pins];

                fOutChannelsNumber      = OutChannels->num_output_pins;
                fChannelsConfig         = OutChannels->channel_config;
                fChannelNames           = OutChannels->channel_names;
        }

        TRACE(UAC, "Out channels number:%d\n",          fOutChannelsNumber);
        TRACE(UAC, "Out channels config:%#06x\n",       fChannelsConfig);
        TRACE(UAC, "Out channels names:%d\n",           fChannelNames);
        /*
        uint8 controlsSize = Processing->length - 10 - Processing->num_input_pins;
        TRACE(UAC, "Controls Size:%d\n", controlsSize);

        uint8* controlsData = (uint8*) ++OutChannels;

        for (size_t i = 0; i < controlsSize; i++) {
                fProgrammableControls.PushBack(controlsData[i]);
                TRACE(UAC, "Controls Data[%d]:%#x\n", i, controlsData[i]);
        }

        fStringIndex = *(controlsData + controlsSize);

        TRACE(UAC, "StringIndex:%d\n", fStringIndex);
*/
        fStatus = B_OK;
}


ExtensionUnit::~ExtensionUnit()
{
}


ClockSource::ClockSource(AudioControlInterface* interface,
                usb_audiocontrol_header_descriptor* Header)
        :
        _AudioControl(interface, Header)
{
        usb_audio_input_terminal_descriptor* descriptor
                = (usb_audio_input_terminal_descriptor*) Header;
        TRACE(UAC, "Clock Source:%d >>>\n",     descriptor->terminal_id);
}


ClockSource::~ClockSource()
{
}


ClockSelector::ClockSelector(AudioControlInterface*     interface,
                usb_audiocontrol_header_descriptor* Header)
        :
        _AudioControl(interface, Header)
{
        usb_audio_input_terminal_descriptor* descriptor
                = (usb_audio_input_terminal_descriptor*) Header;
        TRACE(UAC, "Clock Selector:%d >>>\n", descriptor->terminal_id);
}


ClockSelector::~ClockSelector()
{
}


ClockMultiplier::ClockMultiplier(AudioControlInterface* interface,
                usb_audiocontrol_header_descriptor* Header)
        :
        _AudioControl(interface, Header)
{
        usb_audio_input_terminal_descriptor* descriptor
                = (usb_audio_input_terminal_descriptor*) Header;
        TRACE(UAC, "Clock Multiplier:%d >>>\n", descriptor->terminal_id);
}


ClockMultiplier::~ClockMultiplier()
{
}


SampleRateConverter::SampleRateConverter(AudioControlInterface* interface,
                usb_audiocontrol_header_descriptor* Header)
        :
        _AudioControl(interface, Header)
{
        usb_audio_input_terminal_descriptor* descriptor
                = (usb_audio_input_terminal_descriptor*) Header;
        TRACE(UAC, "Sample Rate Converter:%d >>>\n", descriptor->terminal_id);
}


SampleRateConverter::~SampleRateConverter()
{
}


AudioControlInterface::AudioControlInterface(Device* device)
        :
        fInterface(0),
        fStatus(B_NO_INIT),
        fADCSpecification(0),
        fFunctionCategory(0),
        fControlsBitmap(0),
        fDevice(device)
{
}


AudioControlInterface::~AudioControlInterface()
{
        for (AudioControlsIterator I = fAudioControls.Begin();
                        I != fAudioControls.End(); I++)
                delete I->Value();

        fAudioControls.MakeEmpty();

        // object already freed. just purge the map
        fOutputTerminals.MakeEmpty();

        // object already freed. just purge the map
        fInputTerminals.MakeEmpty();
}


status_t
AudioControlInterface::Init(size_t interface, usb_interface_info* Interface)
{
        for (size_t i = 0; i < Interface->generic_count; i++) {
                usb_audiocontrol_header_descriptor* Header
                        = (usb_audiocontrol_header_descriptor* )Interface->generic[i];

                if (Header->descriptor_type != USB_AUDIO_CS_INTERFACE) {
                        TRACE(ERR, "Ignore Audio Control of "
                                "unknown descriptor type %#04x.\n",     Header->descriptor_type);
                        continue;
                }

                _AudioControl* control = NULL;

                switch(Header->descriptor_subtype) {
                        default:
                                TRACE(ERR, "Ignore Audio Control of unknown "
                                        "descriptor sub-type %#04x\n", Header->descriptor_subtype);
                                break;
                        case USB_AUDIO_AC_DESCRIPTOR_UNDEFINED:
                                TRACE(ERR, "Ignore Audio Control of undefined sub-type\n");
                                break;
                        case USB_AUDIO_AC_HEADER:
                                InitACHeader(interface, Header);
                                break;
                        case USB_AUDIO_AC_INPUT_TERMINAL:
                                control = new(std::nothrow) InputTerminal(this, Header);
                                break;
                        case USB_AUDIO_AC_OUTPUT_TERMINAL:
                                control = new(std::nothrow) OutputTerminal(this, Header);
                                break;
                        case USB_AUDIO_AC_MIXER_UNIT:
                                control = new(std::nothrow) MixerUnit(this, Header);
                                break;
                        case USB_AUDIO_AC_SELECTOR_UNIT:
                                control = new(std::nothrow) SelectorUnit(this, Header);
                                break;
                        case USB_AUDIO_AC_FEATURE_UNIT:
                                control = new(std::nothrow) FeatureUnit(this, Header);
                                break;
                        case USB_AUDIO_AC_PROCESSING_UNIT:
                                if (SpecReleaseNumber() < 200)
                                        control = new(std::nothrow) ProcessingUnit(this, Header);
                                else
                                        control = new(std::nothrow) EffectUnit(this, Header);
                                break;
                        case USB_AUDIO_AC_EXTENSION_UNIT:
                                if (SpecReleaseNumber() < 200)
                                        control = new(std::nothrow) ExtensionUnit(this, Header);
                                else
                                        control = new(std::nothrow) ProcessingUnit(this, Header);
                                break;
                        case USB_AUDIO_AC_EXTENSION_UNIT_R2:
                                control = new(std::nothrow) ExtensionUnit(this, Header);
                                break;
                        case USB_AUDIO_AC_CLOCK_SOURCE_R2:
                                control = new(std::nothrow) ClockSource(this, Header);
                                break;
                        case USB_AUDIO_AC_CLOCK_SELECTOR_R2:
                                control = new(std::nothrow) ClockSelector(this, Header);
                                break;
                        case USB_AUDIO_AC_CLOCK_MULTIPLIER_R2:
                                control = new(std::nothrow) ClockMultiplier(this, Header);
                                break;
                        case USB_AUDIO_AC_SAMPLE_RATE_CONVERTER_R2:
                                control = new(std::nothrow) SampleRateConverter(this, Header);
                                break;
                }

                if (control != 0 && control->InitCheck() == B_OK) {
                        switch(control->SubType()) {
                                case USB_AUDIO_AC_OUTPUT_TERMINAL:
                                        fOutputTerminals.Put(control->SourceID(), control);
                                        break;
                                case USB_AUDIO_AC_INPUT_TERMINAL:
                                        fInputTerminals.Put(control->ID(), control);
                                        break;
                        }
                        fAudioControls.Put(control->ID(), control);

                } else
                        delete control;
        }

        return fStatus = B_OK;
}


_AudioControl*
AudioControlInterface::Find(uint8 id)
{
        return fAudioControls.Get(id);
}


_AudioControl*
AudioControlInterface::FindOutputTerminal(uint8 id)
{
        return fOutputTerminals.Get(id);
}


status_t
AudioControlInterface::InitACHeader(size_t interface,
                usb_audiocontrol_header_descriptor* Header)
{
        if (Header == NULL)
                return fStatus = B_NO_INIT;

        fInterface = interface;

        fADCSpecification = Header->bcd_release_no;
        TRACE(UAC, "ADCSpecification:%#06x\n", fADCSpecification);

        if (fADCSpecification < 0x200) {
                TRACE(UAC, "InterfacesCount:%d\n",      Header->r1.in_collection);
                for (size_t i = 0; i < Header->r1.in_collection; i++) {
                        fStreams.PushBack(Header->r1.interface_numbers[i]);
                        TRACE(UAC, "Interface[%d] number is %d\n", i, fStreams[i]);
                }
        } else {
                fFunctionCategory = Header->r2.function_category;
                fControlsBitmap = Header->r2.bm_controls;
                TRACE(UAC, "Function Category:%#04x\n", fFunctionCategory);
                TRACE(UAC, "Controls Bitmap:%#04x\n", fControlsBitmap);
        }

        return B_OK;
}


uint32
AudioControlInterface::GetChannelsDescription(
        Vector<multi_channel_info>& Channels, multi_description* Description,
        Vector<_AudioControl*>& Terminals, bool isForInput)
{
        uint32 addedChannels = 0;

        for (int32 i = 0; i < Terminals.Count(); i++) {
                AudioChannelCluster* cluster = Terminals[i]->OutCluster();
                if (cluster == NULL || cluster->ChannelsCount() <= 0) {
                        TRACE(ERR, "Terminal #%d ignored due null "
                                "channels cluster (%08x)\n", Terminals[i]->ID(), cluster);
                        continue;
                }

                uint32 channels = GetTerminalChannels(Channels, cluster,
                        isForInput ? B_MULTI_INPUT_CHANNEL : B_MULTI_OUTPUT_CHANNEL);

                if (isForInput)
                        Description->input_channel_count += channels;
                else
                        Description->output_channel_count += channels;

                addedChannels += channels;
        }

        return addedChannels;
}


uint32
AudioControlInterface::GetTerminalChannels(Vector<multi_channel_info>& Channels,
                AudioChannelCluster* cluster, channel_kind kind, uint32 connectors)
{
        if (cluster->ChannelsCount() < 2) { // mono channel
                multi_channel_info info;
                info.channel_id = Channels.Count();
                info.kind               = kind;
                info.designations= B_CHANNEL_MONO_BUS;
                info.connectors = connectors;
                Channels.PushBack(info);

                return 1;
        }

        uint32 startCount = Channels.Count();

        // Haiku multi-aduio designations have the same bits
        // as USB Audio 2.0 cluster spatial locations :-)
        for (size_t i = 0; i < kChannels; i++) {
                uint32 designation = 1 << i;
                if ((cluster->ChannelsConfig() & designation) == designation) {
                        multi_channel_info info;
                        info.channel_id = Channels.Count();
                        info.kind               = kind;
                        info.designations= gDesignations[i].ch | gDesignations[i].bus;
                        info.connectors = connectors;
                        Channels.PushBack(info);
                }
        }

        return Channels.Count() - startCount;
}


uint32
AudioControlInterface::GetBusChannelsDescription(
        Vector<multi_channel_info>& Channels, multi_description* Description)
{
        uint32 addedChannels = 0;

        // first iterate output channels
        for (AudioControlsIterator I = fOutputTerminals.Begin();
                        I != fOutputTerminals.End(); I++) {
                _AudioControl* control = I->Value();
                if (static_cast<_Terminal*>(control)->IsUSBIO())
                        continue;

                AudioChannelCluster* cluster = control->OutCluster();
                if (cluster == 0 || cluster->ChannelsCount() <= 0) {
                        TRACE(ERR, "Terminal #%d ignored due null "
                                "channels cluster (%08x)\n", control->ID(), cluster);
                        continue;
                }

                uint32 channels = GetTerminalChannels(Channels,
                        cluster, B_MULTI_OUTPUT_BUS);

                Description->output_bus_channel_count += channels;
                addedChannels += channels;
        }

        // input channels should follow too
        for (AudioControlsIterator I = fInputTerminals.Begin();
                        I != fInputTerminals.End(); I++) {
                _AudioControl* control = I->Value();
                if (static_cast<_Terminal*>(control)->IsUSBIO())
                        continue;

                AudioChannelCluster* cluster = control->OutCluster();
                if (cluster == NULL || cluster->ChannelsCount() <= 0) {
                        TRACE(ERR, "Terminal #%d ignored due null "
                                "channels cluster (%08x)\n", control->ID(), cluster);
                        continue;
                }

                uint32 channels = GetTerminalChannels(Channels,
                        cluster, B_MULTI_INPUT_BUS);

                Description->input_bus_channel_count += channels;
                addedChannels += channels;
        }

        return addedChannels;
}


void
AudioControlInterface::_HarvestRecordFeatureUnits(_AudioControl* rootControl,
                AudioControlsMap& Map)
{
        if (rootControl == 0) {
                TRACE(ERR, "Not processing due NULL root control.\n");
                return;
        }

        switch(rootControl->SubType()) {
                case USB_AUDIO_AC_SELECTOR_UNIT:
                        {
                                SelectorUnit* unit = static_cast<SelectorUnit*>(rootControl);
                                for (int i = 0; i < unit->fInputPins.Count(); i++)
                                        _HarvestRecordFeatureUnits(Find(unit->fInputPins[i]), Map);
                                Map.Put(rootControl->ID(), rootControl);
                        }
                        break;

                case USB_AUDIO_AC_FEATURE_UNIT:
                        Map.Put(rootControl->ID(), rootControl);
                        break;
        }
}


void
AudioControlInterface::_HarvestOutputFeatureUnits(_AudioControl* rootControl,
                AudioControlsMap& Map)
{
        if (rootControl == 0) {
                TRACE(ERR, "Not processing due NULL root control.\n");
                return;
        }

        switch(rootControl->SubType()) {
                case USB_AUDIO_AC_MIXER_UNIT:
                        {
                                MixerUnit* unit = static_cast<MixerUnit*>(rootControl);
                                for (int i = 0; i < unit->fInputPins.Count(); i++)
                                        _HarvestOutputFeatureUnits(Find(unit->fInputPins[i]), Map);
                                Map.Put(rootControl->ID(), rootControl);
                        }
                        break;

                case USB_AUDIO_AC_FEATURE_UNIT:
                        Map.Put(rootControl->ID(), rootControl);
                        break;
        }
}


bool
AudioControlInterface::_InitGainLimits(multi_mix_control& Control)
{
        bool canControl = false;
        float current = 0.;
        struct _GainInfo {
                uint8   request;
                int16   data;
                float&  value;
        } gainInfos[] = {
                { USB_AUDIO_GET_CUR, 0, current },
                { USB_AUDIO_GET_MIN, 0, Control.gain.min_gain },
                { USB_AUDIO_GET_MAX, 0, Control.gain.max_gain },
                { USB_AUDIO_GET_RES, 0, Control.gain.granularity }
        };

        Control.gain.min_gain = 0.;
        Control.gain.max_gain = 100.;
        Control.gain.granularity = 1.;

        size_t actualLength = 0;
        for (size_t i = 0; i < B_COUNT_OF(gainInfos); i++) {
                status_t status = gUSBModule->send_request(fDevice->USBDevice(),
                        USB_REQTYPE_INTERFACE_IN | USB_REQTYPE_CLASS,
                        gainInfos[i].request, REQ_VALUE(Control.id),
                        REQ_INDEX(Control.id), sizeof(gainInfos[i].data),
                        &gainInfos[i].data, &actualLength);

                if (status != B_OK || actualLength != sizeof(gainInfos[i].data)) {
                        TRACE(ERR, "Request %d (%04x:%04x) fail:%#08x; received %d of %d\n",
                                i, REQ_VALUE(Control.id), REQ_INDEX(Control.id), status,
                                actualLength, sizeof(gainInfos[i].data));
                        continue;
                }

                if (i == 0)
                        canControl = true;

                gainInfos[i].value = static_cast<float>(gainInfos[i].data) / 256.;
        }

        TRACE(ERR, "Control %s: %f dB, from %f to %f dB, step %f dB.\n",
                Control.name, current, Control.gain.min_gain, Control.gain.max_gain,
                Control.gain.granularity);
        return canControl;
}


uint32
AudioControlInterface::_ListFeatureUnitOption(uint32 controlType,
                int32& index, int32 parentIndex, multi_mix_control_info* Info,
                FeatureUnit* unit, uint32 channel, uint32 channels)
{
        int32 startIndex = index;
        uint32 id = 0;
        uint32 flags = 0;
        strind_id string = S_null;
        const char* name = NULL;
        bool initGainLimits = false;

        switch(controlType) {
                case BMA_CTL_MUTE:
                        id = USB_AUDIO_MUTE_CONTROL;
                        flags = B_MULTI_MIX_ENABLE;
                        string = S_MUTE;
                        break;
                case BMA_CTL_VOLUME:
                        id = USB_AUDIO_VOLUME_CONTROL;
                        flags = B_MULTI_MIX_GAIN;
                        string = S_GAIN;
                        initGainLimits = true;
                        break;
                case BMA_CTL_AUTOGAIN:
                        id = USB_AUDIO_AUTOMATIC_GAIN_CONTROL;
                        flags = B_MULTI_MIX_ENABLE;
                        name = "Auto Gain";
                        break;
                default:
                        TRACE(ERR, "Unsupported type %#08x ignored.\n", controlType);
                        return 0;
        }

        multi_mix_control* Controls = Info->controls;

        if (unit->HasControl(channel, controlType)) {
                uint32 masterIndex = CTL_ID(id, channel, unit->ID(), fInterface);
                Controls[index].id  = masterIndex;
                Controls[index].flags = flags;
                Controls[index].parent = parentIndex;
                Controls[index].string = string;
                if (name != NULL)
                        strlcpy(Controls[index].name, name, sizeof(Controls[index].name));
                if (initGainLimits)
                        _InitGainLimits(Controls[index]);

                index++;

                if (channels == 2) {
                        Controls[index].id = CTL_ID(id, channel + 1, unit->ID(), fInterface);
                        Controls[index].flags = flags;
                        Controls[index].parent = parentIndex;
                        Controls[index].master = masterIndex;
                        Controls[index].string = string;
                        if (name != NULL)
                                strlcpy(Controls[index].name, name, sizeof(Controls[index].name));
                        if (initGainLimits)
                                _InitGainLimits(Controls[index]);
                        index++;
                }
        }

        return index - startIndex;
}


int32
AudioControlInterface::_ListFeatureUnitControl(int32& index, int32 parentIndex,
                multi_mix_control_info* Info, _AudioControl* control)
{
        FeatureUnit* unit = static_cast<FeatureUnit*>(control);
        if (unit == 0) {
                TRACE(ERR, "Feature Unit for null control ignored.\n");
                return 0;
        }

        if (index + 4 > Info->control_count) {
                TRACE(ERR, "Could not list feature control group."
                        " Limit %d of %d has been reached.\n",
                        index, Info->control_count);
                return 0;
        }

        AudioChannelCluster* cluster = unit->OutCluster();
        if (cluster == 0) {
                TRACE(ERR, "Control %s with null cluster ignored.\n", unit->Name());
                return 0;
        }

        struct _ChannelInfo {
                const char*     Name;
                uint8           channels;
                uint32          Mask;
        } channelInfos[] = {
                { "",                   1, 0 }, // Master channel entry - no bitmask
                { "",                   2, B_CHANNEL_LEFT | B_CHANNEL_RIGHT },
                { "Left",               1, B_CHANNEL_LEFT       },
                { "Right",              1, B_CHANNEL_RIGHT      },
                { "Center",             1, B_CHANNEL_CENTER },
                { "L.F.E.",             1, B_CHANNEL_SUB        },
                { "Back",               2, B_CHANNEL_REARLEFT | B_CHANNEL_REARRIGHT },
                { "Back Left",  1, B_CHANNEL_REARLEFT   },
                { "Back Right", 1, B_CHANNEL_REARRIGHT  },
                { "Front of Center",            2, B_CHANNEL_FRONT_LEFT_CENTER
                                                                                | B_CHANNEL_FRONT_RIGHT_CENTER },
                { "Front Left of Center",       1, B_CHANNEL_FRONT_LEFT_CENTER  },
                { "Front Right of Center",      1, B_CHANNEL_FRONT_RIGHT_CENTER },
                { "Back Center",                1, B_CHANNEL_BACK_CENTER },
                { "Side",                               2, B_CHANNEL_SIDE_LEFT | B_CHANNEL_SIDE_RIGHT },
                { "Side Left",                  1, B_CHANNEL_SIDE_LEFT },
                { "Side Right",                 1, B_CHANNEL_SIDE_RIGHT },
                { "Top Center",                 1, B_CHANNEL_TOP_CENTER },
                { "Top Front Left",             1, B_CHANNEL_TOP_FRONT_LEFT },
                { "Top Front Center",   1, B_CHANNEL_TOP_FRONT_CENTER },
                { "Top Front Right",    1, B_CHANNEL_TOP_FRONT_RIGHT },
                { "Top Back Left",              1, B_CHANNEL_TOP_BACK_LEFT },
                { "Top Back Center",    1, B_CHANNEL_TOP_BACK_CENTER },
                { "Top Back Right",             1, B_CHANNEL_TOP_BACK_RIGHT }
        };

        multi_mix_control* Controls = Info->controls;

        uint32 channelsConfig = cluster->ChannelsConfig();
        int32 groupIndex = 0;
        int32 channel = 0;
        int32 masterIndex = 0;  // in case master channel has no volume
                                                        // control - add following "L+R" channels into it

        for (size_t i = 0; i < B_COUNT_OF(channelInfos); i++) {
                if ((channelsConfig & channelInfos[i].Mask) != channelInfos[i].Mask) {
                        // ignore non-listed and possibly non-paired stereo channels.
                        //      note that master channel with zero mask pass this check! ;-)
                        continue;
                }

                if (masterIndex == 0) {
                        groupIndex = index;
                        Controls[index].id = groupIndex;
                        Controls[index].flags = B_MULTI_MIX_GROUP;
                        Controls[index].parent = parentIndex;
                        snprintf(Controls[index].name, sizeof(Controls[index].name),
                                "%s %s", unit->Name(), channelInfos[i].Name);
                        index++;
                } else {
                        groupIndex = masterIndex;
                        masterIndex = 0;
                }

                // First list possible Mute controls
                _ListFeatureUnitOption(BMA_CTL_MUTE, index, groupIndex, Info,
                                unit, channel, channelInfos[i].channels);

                // Gain controls may be usefull too
                if (_ListFeatureUnitOption(BMA_CTL_VOLUME, index, groupIndex, Info,
                                unit, channel, channelInfos[i].channels) == 0) {
                        masterIndex = (i == 0) ? groupIndex : 0 ;
                        TRACE(UAC, "channel:%d set master index to %d\n",
                                channel, masterIndex);
                }

                // Auto Gain checkbox will be listed too
                _ListFeatureUnitOption(BMA_CTL_AUTOGAIN, index, groupIndex, Info,
                        unit, channel, channelInfos[i].channels);

                // Now check if the group filled with something usefull.
                // In case no controls were added into it - "remove" it
                if (Controls[index - 1].flags == B_MULTI_MIX_GROUP) {
                        Controls[index - 1].id = 0;
                        index--;

                        masterIndex = 0;
                }

                channel += channelInfos[i].channels;

                // remove bits for already processed channels - this prevent from
                // duplication of the stereo channels as "orphaned" ones and optimize
                // exit from this iterations after all channels are processed.
                channelsConfig &= ~channelInfos[i].Mask;

                if (0 == channelsConfig)
                        break;
        }

        if (channelsConfig > 0)
                TRACE(ERR, "Following channels were not processed: %#08x.\n",
                        channelsConfig);

        // return last group index to stick possible selector unit to it. ;-)
        return groupIndex;
}


void
AudioControlInterface::_ListSelectorUnitControl(int32& index, int32 parentGroup,
                multi_mix_control_info* Info, _AudioControl* control)
{
        SelectorUnit* selector = static_cast<SelectorUnit*>(control);
        if (selector == 0 || selector->SubType() != USB_AUDIO_AC_SELECTOR_UNIT)
                return;

        if ((index + 1 + selector->fInputPins.Count()) > Info->control_count) {
                TRACE(ERR, "Could not list selector control."
                        " Limit %d of %d has been reached.\n",
                        index, Info->control_count);
                return;
        }

        multi_mix_control* Controls = Info->controls;

        int32 recordMUX = CTL_ID(0, 0, selector->ID(), fInterface);
        Controls[index].id      = recordMUX;
        Controls[index].flags = B_MULTI_MIX_MUX;
        Controls[index].parent = parentGroup;
        Controls[index].string = S_null;
        strlcpy(Controls[index].name, "Source", sizeof(Controls[index].name));
        index++;

        for (int i = 0; i < selector->fInputPins.Count(); i++) {
                Controls[index].id = CTL_ID(0, 1, selector->ID(), fInterface);
                Controls[index].flags = B_MULTI_MIX_MUX_VALUE;
                Controls[index].master = 0;
                Controls[index].string = S_null;
                Controls[index].parent = recordMUX;
                _AudioControl* control = Find(selector->fInputPins[i]);
                if (control != NULL)
                        strlcpy(Controls[index].name,
                                control->Name(), sizeof(Controls[index].name));
                else
                        snprintf(Controls[index].name,
                                sizeof(Controls[index].name), "Input #%d", i + 1);
                index++;
        }
}


size_t
AudioControlInterface::_CollectMixerUnitControls(
                const uint32 controlIds[kChannels][kChannels],
                size_t inLeft, size_t outLeft, size_t inRight, size_t outRight,
                const char* inputName, const char* name,
                Vector<multi_mix_control>& Controls)
{
        size_t count = 0;
        uint32 leftId = controlIds[inLeft][outLeft];
        uint32 rightId = controlIds[inRight][outRight];

//      TRACE(UAC, "left:%d %d: %08x; right:%d %d: %08x\n",
//                      inLeft, outLeft, leftId, inRight, outRight, rightId);

        multi_mix_control control;
        memset(&control, 0, sizeof(multi_mix_control));
        snprintf(control.name, sizeof(control.name), "%s %s", inputName, name);

        for (size_t i = 0; i < 2; i++) {
                if (leftId != 0 || rightId != 0) {
                        control.flags = B_MULTI_MIX_GROUP;
                        control.string = S_null;
                        Controls.PushBack(control);

                        int gainControls = 0;
                        if (leftId != 0) {
                                control.id = leftId;
                                control.flags = B_MULTI_MIX_GAIN;
                                control.string = S_GAIN;
                                if (_InitGainLimits(control)) {
                                        gainControls++;
                                        Controls.PushBack(control);
                                }
                        }

                        if (rightId != 0) {
                                control.id = rightId;
                                control.flags = B_MULTI_MIX_GAIN;
                                control.string = S_GAIN;
                                control.master = leftId;
                                if (_InitGainLimits(control)) {
                                        gainControls++;
                                        Controls.PushBack(control);
                                }
                        }

                        // remove empty mix group
                        if (gainControls == 0)
                                Controls.PopBack();
                        else
                                count++;
                }

                // take care about surround bus
                if (inLeft == inRight)
                        break;
                // handle possible reverse controls
                leftId = controlIds[inLeft][outRight];
                rightId = controlIds[inRight][outLeft];
                snprintf(control.name, sizeof(control.name),
                        "%s %s (Reverse)", inputName, name);
        }

        return count;
}


void
AudioControlInterface::_ListMixerUnitControls(int32& index,
                multi_mix_control_info* Info, Vector<multi_mix_control>& controls)
{
        multi_mix_control* Controls = Info->controls;
        uint32 groupParent = 0;
        uint32 gainParent = 0;
        for (Vector<multi_mix_control>::Iterator I = controls.Begin();
                        I != controls.End() && index < Info->control_count; I++) {
                memcpy(Controls + index, &*I, sizeof(multi_mix_control));
                switch (I->flags) {
                        case B_MULTI_MIX_GROUP:
                                Controls[index].id = index;
                                Controls[index].parent = groupParent;
                                if (groupParent == 0) {
                                        Controls[index].id |= 0x10000;
                                        groupParent = Controls[index].id;
                                }
                                gainParent = Controls[index].id;
                                break;
                        case B_MULTI_MIX_GAIN:
                                Controls[index].parent = gainParent;
                                break;
                        default:
                                TRACE(ERR, "Control type %d ignored\n", I->flags);
                                continue;
                }

                index++;
        }

        if (index == Info->control_count)
                TRACE(ERR, "Control count limit %d has been reached.\n", index);
}


void
AudioControlInterface::_ListMixControlsForMixerUnit(int32& index,
                multi_mix_control_info* Info, _AudioControl* control)
{
        MixerUnit* mixer = static_cast<MixerUnit*>(control);
        if (mixer == 0 || mixer->SubType() != USB_AUDIO_AC_MIXER_UNIT)
                return;

        struct _ChannelPair {
                size_t inLeft;
                size_t inRight;
                const char* name;
        } channelPairs[] = {
                { 0, 1, "" },
                { 2, 2, "Center" },
                { 3, 3, "L.F.E" },
                { 4, 5, "Back" },
                { 6, 7, "Front of Center" },
                { 8, 8, "Back Center" },
                { 9, 10, "Side" },
                { 11, 11, "Top Center" },
                { 12, 14, "Top Front" },
                { 13, 13, "Top Front Center" },
                { 15, 17, "Top Back" },
                { 16, 16, "Top Back Center" }
        };

        Vector<_MixPageCollector*> mixControls;

        _MixPageCollector* genericPage = new(std::nothrow) _MixPageCollector("Mixer");
        mixControls.PushBack(genericPage);

        // page for extended in (>2) and out (>2) mixer controls
        size_t controlsOnExMixerPage = 0;
        _MixPageCollector* exMixerPage = new(std::nothrow) _MixPageCollector("Mixer");

        AudioChannelCluster* outCluster = mixer->OutCluster();

        int inOffset = 0;
        for (int iPin = 0; iPin < mixer->fInputPins.Count(); iPin++) {
                _AudioControl* control = Find(mixer->fInputPins[iPin]);
                AudioChannelCluster* inCluster = NULL;
                if (control != NULL)
                        inCluster = control->OutCluster();
                if (inCluster == NULL) {
                        TRACE(ERR, "control %p cluster %p failed!\n", control, inCluster);
                        break;
                }

                // at first - collect programmable control ids
                uint32 controlIds[kChannels][kChannels] = { { 0 } };

                int inChannel = 0;
                for (size_t in = 0; in < kChannels
                                && inChannel < inCluster->ChannelsCount(); in++) {
                        if ((inCluster->ChannelsConfig() & (1 << in)) == 0)
                                continue;

                        for (size_t out = 0, outChannel = 0; out < kChannels
                                        && outChannel < outCluster->ChannelsCount(); out++) {
                                if ((outCluster->ChannelsConfig() & (1 << out)) == 0)
                                        continue;

                                if (mixer->IsControlProgrammable(
                                                inOffset + inChannel, outChannel)) {
                                        if (SpecReleaseNumber() < 0x200)
                                                // USB Audio 1.0 uses ICN/OCN for request
                                                controlIds[in][out] = CTL_ID(inOffset + inChannel + 1,
                                                        outChannel + 1, mixer->ID(), fInterface);
                                        else
                                                // USB Audio 2.0 uses CS/MCN for request
                                                controlIds[in][out] = CTL_ID(USB_AUDIO_MIXER_CONTROL,
                                                        (inOffset + inChannel) * outCluster->ChannelsCount()
                                                        + outChannel, mixer->ID(), fInterface);
                                }

                                outChannel++;
                        }

                        inChannel++;
                }

                inOffset += inChannel;

                for (size_t in = 0; in < kChannels; in++)
                        for (size_t out = 0; out < kChannels; out++)
                                if (controlIds[in][out] != 0)
                                        TRACE(UAC, "ctrl:%08x for in %d; out %d;\n",
                                                controlIds[in][out], in, out);

                // second step - distribute controls on
                // mixer pages in logical groups
                uint32 exChannelsMask = ~(B_CHANNEL_LEFT | B_CHANNEL_RIGHT);
                bool inIsEx = (inCluster->ChannelsConfig() & exChannelsMask) != 0;
                bool outIsEx = (outCluster->ChannelsConfig() & exChannelsMask) != 0;

                if (!inIsEx && !outIsEx) {
                        // heap up all mono and stereo controls into single "Mixer" page
                        for (size_t i = 0; i < 2; i++)
                                _CollectMixerUnitControls(controlIds,
                                        kLeftChannel, channelPairs[i].inLeft,
                                        kRightChannel, channelPairs[i].inRight,
                                        control->Name(), channelPairs[i].name,
                                        *mixControls[0]);
                        continue; // go next input cluster
                }

                if (!outIsEx) {
                        // special case - extended (>2 channels) input cluster
                        // connected to 2-channels output - add into generic "Mixer" page
                        for (size_t i = 0; i < B_COUNT_OF(channelPairs); i++)
                                _CollectMixerUnitControls(controlIds,
                                        channelPairs[i].inLeft, kLeftChannel,
                                        channelPairs[i].inRight, kRightChannel,
                                        control->Name(), channelPairs[i].name,
                                        *mixControls[0]);
                        continue; // go next input cluster
                }

                // make separate mixer pages for set of extended (>2) input
                // channels connected to extended (>2 channels) output
                for (size_t in = 0; in < B_COUNT_OF(channelPairs); in++) {
                        for (size_t out = 0; out < B_COUNT_OF(channelPairs); out++) {
                                char outName[sizeof(Info->controls->name)] = { 0 };
                                if (in == out)
                                        strlcpy(outName, channelPairs[out].name, sizeof(outName));
                                else
                                        snprintf(outName, sizeof(outName), "%s to %s",
                                                channelPairs[in].name, channelPairs[out].name);

                                controlsOnExMixerPage += _CollectMixerUnitControls(controlIds,
                                        channelPairs[in].inLeft, channelPairs[out].inLeft,
                                        channelPairs[in].inRight, channelPairs[out].inRight,
                                        control->Name(), outName, *exMixerPage);
                        }

                        if (controlsOnExMixerPage >= 6) {
                                mixControls.PushBack(exMixerPage);
                                exMixerPage = new(std::nothrow) _MixPageCollector("Mixer");
                                controlsOnExMixerPage = 0;
                        }
                }
        }

        if (exMixerPage->Count() > 1)
                mixControls.PushBack(exMixerPage);
        else
                delete exMixerPage;

        // final step - fill multiaudio controls info with
        // already structured pages/controls info arrays
        for (Vector<_MixPageCollector*>::Iterator I = mixControls.Begin();
                        I != mixControls.End(); I++) {
                Vector<multi_mix_control>* controls = *I;
                        TRACE(UAC, "controls count: %d\n", controls->Count());
                if (controls->Count() > 1)
                        _ListMixerUnitControls(index, Info, *controls);
                delete controls;
        }
}


void
AudioControlInterface::_ListMixControlsPage(int32& index,
                multi_mix_control_info* Info, AudioControlsMap& Map, const char* Name)
{
        multi_mix_control* Controls = Info->controls;
        int32 groupIndex = index | 0x10000;
        Controls[index].id      = groupIndex;
        Controls[index].flags = B_MULTI_MIX_GROUP;
        Controls[index].parent = 0;
        strlcpy(Controls[index].name, Name, sizeof(Controls[index].name));
        index++;

        int32 group = groupIndex;
        for (AudioControlsIterator I = Map.Begin(); I != Map.End(); I++) {
                TRACE(UAC, "%s control %d listed.\n", Name, I->Value()->ID());
                switch(I->Value()->SubType()) {
                        case USB_AUDIO_AC_FEATURE_UNIT:
                                group = _ListFeatureUnitControl(index, groupIndex,
                                        Info, I->Value());
                                break;
                        case USB_AUDIO_AC_SELECTOR_UNIT:
                                _ListSelectorUnitControl(index, group, Info, I->Value());
                                break;
                        default:
                                break;
                }
        }
}


status_t
AudioControlInterface::ListMixControls(multi_mix_control_info* Info)
{
        // first harvest feature units that assigned to output terminal(s)
        AudioControlsMap RecordControlsMap;
        AudioControlsMap OutputControlsMap;

        for (AudioControlsIterator I = fOutputTerminals.Begin();
                        I != fOutputTerminals.End(); I++) {
                _Terminal* terminal = static_cast<_Terminal*>(I->Value());
                if (terminal->IsUSBIO())
                        _HarvestRecordFeatureUnits(terminal, RecordControlsMap);
                else
                        _HarvestOutputFeatureUnits(terminal, OutputControlsMap);
        }

        // separate input and output Feature units
        // and collect mixer units that can be controlled
        AudioControlsMap InputControlsMap;
        AudioControlsMap MixerControlsMap;

        for (AudioControlsIterator I = fAudioControls.Begin();
                        I != fAudioControls.End(); I++) {
                _AudioControl* control = I->Value();

                if (control->SubType() == USB_AUDIO_AC_MIXER_UNIT) {
                        MixerUnit* mixerControl = static_cast<MixerUnit*>(control);
                        if (mixerControl->HasProgrammableControls())
                                MixerControlsMap.Put(control->ID(), control);
                        continue;
                }

                // filter out feature units
                if (control->SubType() != USB_AUDIO_AC_FEATURE_UNIT)
                        continue;

                // ignore controls that are already in the output controls maps
                if (RecordControlsMap.Find(control->ID()) != RecordControlsMap.End()
                        || OutputControlsMap.Find(control->ID()) != OutputControlsMap.End())
                        continue;

                _AudioControl* sourceControl = Find(control->SourceID());
                if (sourceControl != 0
                                && sourceControl->SubType() == USB_AUDIO_AC_INPUT_TERMINAL)
                        InputControlsMap.Put(control->ID(), control);
                else
                        OutputControlsMap.Put(control->ID(), control);
        }

        int32 index = 0;
        if (InputControlsMap.Count() > 0)
                _ListMixControlsPage(index, Info, InputControlsMap, "Input");

        if (OutputControlsMap.Count() > 0)
                _ListMixControlsPage(index, Info, OutputControlsMap, "Output");

        if (RecordControlsMap.Count() > 0)
                _ListMixControlsPage(index, Info, RecordControlsMap, "Record");


        for (AudioControlsIterator I = MixerControlsMap.Begin();
                        I != MixerControlsMap.End(); I++)
                _ListMixControlsForMixerUnit(index, Info, I->Value());

        Info->control_count = index;

        return B_OK;
}


status_t
AudioControlInterface::GetMix(multi_mix_value_info* Info)
{
        for (int32 i = 0; i < Info->item_count; i++) {
                uint16 length = 0;
                int16 data = 0;

                _AudioControl* control = Find(ID_FROM_CTLID(Info->values[i].id));
                if (control == NULL) {
                        TRACE(ERR, "No control found for unit id %#02x. Ignore it.\n",
                                ID_FROM_CTLID(Info->values[i].id));
                        continue;
                }

                switch (control->SubType()) {
                        case USB_AUDIO_AC_FEATURE_UNIT:
                                switch(CS_FROM_CTLID(Info->values[i].id)) {
                                        case USB_AUDIO_VOLUME_CONTROL:
                                                length = 2;
                                                break;
                                        case USB_AUDIO_MUTE_CONTROL:
                                        case USB_AUDIO_AUTOMATIC_GAIN_CONTROL:
                                                length = 1;
                                                break;
                                        default:
                                                TRACE(ERR, "Unsupported control id:%08x of type %#02x "
                                                        "ignored.\n", ID_FROM_CTLID(Info->values[i].id),
                                                        CS_FROM_CTLID(Info->values[i].id));
                                                continue;
                                }
                                break;
                        case USB_AUDIO_AC_SELECTOR_UNIT:
                                length = 1;
                                break;
                        case USB_AUDIO_AC_MIXER_UNIT:
                                length = 2;
                                break;
                        default:
                                TRACE(ERR, "Control id:%08x of type %d is not supported\n",
                                        ID_FROM_CTLID(Info->values[i].id), control->SubType());
                                continue;
                }

                size_t actualLength = 0;
                status_t status = gUSBModule->send_request(fDevice->USBDevice(),
                        USB_REQTYPE_INTERFACE_IN | USB_REQTYPE_CLASS, USB_AUDIO_GET_CUR,
                        REQ_VALUE(Info->values[i].id), REQ_INDEX(Info->values[i].id),
                        length, &data, &actualLength);

                if (status != B_OK || actualLength != length) {
                        TRACE(ERR, "Request (%04x:%04x) failed:%#08x; received %d of %d\n",
                                REQ_VALUE(Info->values[i].id), REQ_INDEX(Info->values[i].id),
                                status, actualLength, length);
                        continue;
                }

                switch (control->SubType()) {
                        case USB_AUDIO_AC_FEATURE_UNIT:
                                switch(CS_FROM_CTLID(Info->values[i].id)) {
                                        case USB_AUDIO_VOLUME_CONTROL:
                                                Info->values[i].gain = static_cast<float>(data) / 256.;
                                                TRACE(MIX, "Gain control %d; channel: %d; is %f dB.\n",
                                                        ID_FROM_CTLID(Info->values[i].id),
                                                        CN_FROM_CTLID(Info->values[i].id),
                                                        Info->values[i].gain);
                                                break;
                                        case USB_AUDIO_MUTE_CONTROL:
                                                Info->values[i].enable = data > 0;
                                                TRACE(MIX, "Mute control %d; channel: %d; is %d.\n",
                                                        ID_FROM_CTLID(Info->values[i].id),
                                                        CN_FROM_CTLID(Info->values[i].id),
                                                        Info->values[i].enable);
                                                break;
                                        case USB_AUDIO_AUTOMATIC_GAIN_CONTROL:
                                                Info->values[i].enable = data > 0;
                                                TRACE(MIX, "AGain control %d; channel: %d; is %d.\n",
                                                        ID_FROM_CTLID(Info->values[i].id),
                                                        CN_FROM_CTLID(Info->values[i].id),
                                                        Info->values[i].enable);
                                                break;
                                        default:
                                                break;
                                }
                                break;
                        case USB_AUDIO_AC_SELECTOR_UNIT:
                                Info->values[i].mux = data - 1;
                                TRACE(MIX, "Selector control %d; is %d.\n",
                                        ID_FROM_CTLID(Info->values[i].id),
                                        Info->values[i].mux);
                                break;
                        case USB_AUDIO_AC_MIXER_UNIT:
                                Info->values[i].gain = static_cast<float>(data) / 256.;
                                TRACE(MIX, "Mixer #%d channels in: %d; out: %d; is %f dB.\n",
                                        ID_FROM_CTLID(Info->values[i].id),
                                        CS_FROM_CTLID(Info->values[i].id),
                                        CN_FROM_CTLID(Info->values[i].id),
                                        Info->values[i].gain);
                                break;
                }
        }

        return B_OK;
}


status_t
AudioControlInterface::SetMix(multi_mix_value_info* Info)
{
        for (int32 i = 0; i < Info->item_count; i++) {
                uint16 length = 0;
                int16 data = 0;

                _AudioControl* control = Find(ID_FROM_CTLID(Info->values[i].id));
                if (control == NULL) {
                        TRACE(ERR, "No control found for unit id %#02x. Ignore it.\n",
                                ID_FROM_CTLID(Info->values[i].id));
                        continue;
                }

                switch (control->SubType()) {
                        case USB_AUDIO_AC_FEATURE_UNIT:
                                switch(CS_FROM_CTLID(Info->values[i].id)) {
                                        case USB_AUDIO_VOLUME_CONTROL:
                                                data = static_cast<int16>(Info->values[i].gain * 256.);
                                                length = 2;
                                                TRACE(MIX, "Gain control %d; channel: %d; "
                                                        "about to set to %f dB.\n",
                                                        ID_FROM_CTLID(Info->values[i].id),
                                                        CN_FROM_CTLID(Info->values[i].id),
                                                        Info->values[i].gain);
                                                break;
                                        case USB_AUDIO_MUTE_CONTROL:
                                                data = (Info->values[i].enable ? 1 : 0);
                                                length = 1;
                                                TRACE(MIX, "Mute control %d; channel: %d; "
                                                        "about to set to %d.\n",
                                                        ID_FROM_CTLID(Info->values[i].id),
                                                        CN_FROM_CTLID(Info->values[i].id),
                                                        Info->values[i].enable);
                                                break;
                                        case USB_AUDIO_AUTOMATIC_GAIN_CONTROL:
                                                data = (Info->values[i].enable ? 1 : 0);
                                                length = 1;
                                                TRACE(MIX, "AGain control %d; channel: %d; "
                                                        "about to set to %d.\n",
                                                        ID_FROM_CTLID(Info->values[i].id),
                                                        CN_FROM_CTLID(Info->values[i].id),
                                                        Info->values[i].enable);
                                                break;
                                        default:
                                                TRACE(ERR, "Unsupported control id:%08x of type %#02x "
                                                        "ignored.\n", ID_FROM_CTLID(Info->values[i].id),
                                                        CS_FROM_CTLID(Info->values[i].id));
                                                continue;
                                }
                                break;
                        case USB_AUDIO_AC_SELECTOR_UNIT:
                                data = Info->values[i].mux + 1;
                                length = 1;
                                TRACE(MIX, "Selector Control %d about to set to %d.\n",
                                        ID_FROM_CTLID(Info->values[i].id),
                                        Info->values[i].mux);
                                break;
                        case USB_AUDIO_AC_MIXER_UNIT:
                                data = static_cast<int16>(Info->values[i].gain * 256.);
                                length = 2;
                                TRACE(MIX, "Mixer %d channels in: %d; out: %d; "
                                        "about to set to %f dB.\n",
                                        ID_FROM_CTLID(Info->values[i].id),
                                        CS_FROM_CTLID(Info->values[i].id),
                                        CN_FROM_CTLID(Info->values[i].id),
                                        Info->values[i].gain);
                                break;
                        default:
                                TRACE(ERR, "Control id:%08x of type %d is not supported\n",
                                        Info->values[i].id, control->SubType());
                                continue;
                }

                size_t actualLength = 0;
                status_t status = gUSBModule->send_request(fDevice->USBDevice(),
                        USB_REQTYPE_INTERFACE_OUT | USB_REQTYPE_CLASS, USB_AUDIO_SET_CUR,
                        REQ_VALUE(Info->values[i].id), REQ_INDEX(Info->values[i].id),
                        length, &data, &actualLength);

                if (status != B_OK || actualLength != length) {
                        TRACE(ERR, "Request (%04x:%04x) failed:%#08x; send %d of %d\n",
                                REQ_VALUE(Info->values[i].id), REQ_INDEX(Info->values[i].id),
                                status, actualLength, length);
                        continue;
                }

                TRACE(MIX, "Value set OK\n");
        }

        return B_OK;
}