src.com.android.server.usb.descriptors.UsbACInterface Maven / Gradle / Ivy
/*
* Copyright (C) 2017 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.server.usb.descriptors;
import android.util.Log;
import com.android.server.usb.descriptors.report.ReportCanvas;
import com.android.server.usb.descriptors.report.UsbStrings;
/**
* @hide
* An audio class-specific Interface.
* see audio10.pdf section 4.3.2
*/
public abstract class UsbACInterface extends UsbDescriptor {
private static final String TAG = "UsbACInterface";
// Audio Control Subtypes
public static final byte ACI_UNDEFINED = 0;
public static final byte ACI_HEADER = 1;
public static final byte ACI_INPUT_TERMINAL = 2;
public static final byte ACI_OUTPUT_TERMINAL = 3;
public static final byte ACI_MIXER_UNIT = 4;
public static final byte ACI_SELECTOR_UNIT = 5;
public static final byte ACI_FEATURE_UNIT = 6;
public static final byte ACI_PROCESSING_UNIT = 7;
public static final byte ACI_EXTENSION_UNIT = 8;
// Not handled yet
public static final byte ACI_CLOCK_SOURCE = 0x0A;
public static final byte ACI_CLOCK_SELECTOR = 0x0B;
public static final byte ACI_CLOCK_MULTIPLIER = 0x0C;
public static final byte ACI_SAMPLE_RATE_CONVERTER = 0x0D;
// Audio Streaming Subtypes
public static final byte ASI_UNDEFINED = 0;
public static final byte ASI_GENERAL = 1;
public static final byte ASI_FORMAT_TYPE = 2;
public static final byte ASI_FORMAT_SPECIFIC = 3;
// MIDI Streaming Subtypes
public static final byte MSI_UNDEFINED = 0;
public static final byte MSI_HEADER = 1;
public static final byte MSI_IN_JACK = 2;
public static final byte MSI_OUT_JACK = 3;
public static final byte MSI_ELEMENT = 4;
// Sample format IDs (encodings)
// FORMAT_I
public static final int FORMAT_I_UNDEFINED = 0x0000;
public static final int FORMAT_I_PCM = 0x0001;
public static final int FORMAT_I_PCM8 = 0x0002;
public static final int FORMAT_I_IEEE_FLOAT = 0x0003;
public static final int FORMAT_I_ALAW = 0x0004;
public static final int FORMAT_I_MULAW = 0x0005;
// FORMAT_II
public static final int FORMAT_II_UNDEFINED = 0x1000;
public static final int FORMAT_II_MPEG = 0x1001;
public static final int FORMAT_II_AC3 = 0x1002;
// FORMAT_III
public static final int FORMAT_III_UNDEFINED = 0x2000;
public static final int FORMAT_III_IEC1937AC3 = 0x2001;
public static final int FORMAT_III_IEC1937_MPEG1_Layer1 = 0x2002;
public static final int FORMAT_III_IEC1937_MPEG1_Layer2 = 0x2003;
public static final int FORMAT_III_IEC1937_MPEG2_EXT = 0x2004;
public static final int FORMAT_III_IEC1937_MPEG2_Layer1LS = 0x2005;
protected final byte mSubtype; // 2:1 HEADER descriptor subtype
protected final int mSubclass; // from the mSubclass member of the
// "enclosing" Interface Descriptor
public UsbACInterface(int length, byte type, byte subtype, int subclass) {
super(length, type);
mSubtype = subtype;
mSubclass = subclass;
}
public byte getSubtype() {
return mSubtype;
}
public int getSubclass() {
return mSubclass;
}
private static UsbDescriptor allocAudioControlDescriptor(UsbDescriptorParser parser,
ByteStream stream, int length, byte type, byte subtype, int subClass) {
switch (subtype) {
case ACI_HEADER:
{
if (UsbDescriptorParser.DEBUG) {
Log.d(TAG, " ---> ACI_HEADER");
}
int acInterfaceSpec = stream.unpackUsbShort();
parser.setACInterfaceSpec(acInterfaceSpec);
if (UsbDescriptorParser.DEBUG) {
Log.d(TAG, " acInterfaceSpec:0x" + Integer.toHexString(acInterfaceSpec));
}
if (acInterfaceSpec == UsbDeviceDescriptor.USBSPEC_2_0) {
return new Usb20ACHeader(length, type, subtype, subClass, acInterfaceSpec);
} else {
return new Usb10ACHeader(length, type, subtype, subClass, acInterfaceSpec);
}
}
case ACI_INPUT_TERMINAL:
{
if (UsbDescriptorParser.DEBUG) {
Log.d(TAG, " ---> ACI_INPUT_TERMINAL");
}
int acInterfaceSpec = parser.getACInterfaceSpec();
if (UsbDescriptorParser.DEBUG) {
Log.d(TAG, " acInterfaceSpec:0x" + Integer.toHexString(acInterfaceSpec));
}
if (acInterfaceSpec == UsbDeviceDescriptor.USBSPEC_2_0) {
return new Usb20ACInputTerminal(length, type, subtype, subClass);
} else {
return new Usb10ACInputTerminal(length, type, subtype, subClass);
}
}
case ACI_OUTPUT_TERMINAL:
{
if (UsbDescriptorParser.DEBUG) {
Log.d(TAG, " ---> ACI_OUTPUT_TERMINAL");
}
int acInterfaceSpec = parser.getACInterfaceSpec();
if (UsbDescriptorParser.DEBUG) {
Log.d(TAG, " acInterfaceSpec:0x" + Integer.toHexString(acInterfaceSpec));
}
if (acInterfaceSpec == UsbDeviceDescriptor.USBSPEC_2_0) {
return new Usb20ACOutputTerminal(length, type, subtype, subClass);
} else {
return new Usb10ACOutputTerminal(length, type, subtype, subClass);
}
}
case ACI_SELECTOR_UNIT:
if (UsbDescriptorParser.DEBUG) {
Log.d(TAG, " ---> ACI_SELECTOR_UNIT");
}
return new UsbACSelectorUnit(length, type, subtype, subClass);
case ACI_FEATURE_UNIT:
if (UsbDescriptorParser.DEBUG) {
Log.d(TAG, " ---> ACI_FEATURE_UNIT");
}
return new UsbACFeatureUnit(length, type, subtype, subClass);
case ACI_MIXER_UNIT:
{
if (UsbDescriptorParser.DEBUG) {
Log.d(TAG, " ---> ACI_MIXER_UNIT");
}
int acInterfaceSpec = parser.getACInterfaceSpec();
if (UsbDescriptorParser.DEBUG) {
Log.d(TAG, " acInterfaceSpec:0x" + Integer.toHexString(acInterfaceSpec));
}
if (acInterfaceSpec == UsbDeviceDescriptor.USBSPEC_2_0) {
return new Usb20ACMixerUnit(length, type, subtype, subClass);
} else {
return new Usb10ACMixerUnit(length, type, subtype, subClass);
}
}
case ACI_PROCESSING_UNIT:
case ACI_EXTENSION_UNIT:
case ACI_UNDEFINED:
// break; Fall through until we implement this descriptor
default:
Log.w(TAG, "Unknown Audio Class Interface subtype:0x"
+ Integer.toHexString(subtype));
return new UsbACInterfaceUnparsed(length, type, subtype, subClass);
}
}
private static UsbDescriptor allocAudioStreamingDescriptor(UsbDescriptorParser parser,
ByteStream stream, int length, byte type, byte subtype, int subClass) {
//int spec = parser.getUsbSpec();
int acInterfaceSpec = parser.getACInterfaceSpec();
switch (subtype) {
case ASI_GENERAL:
if (acInterfaceSpec == UsbDeviceDescriptor.USBSPEC_2_0) {
return new Usb20ASGeneral(length, type, subtype, subClass);
} else {
return new Usb10ASGeneral(length, type, subtype, subClass);
}
case ASI_FORMAT_TYPE:
return UsbASFormat.allocDescriptor(parser, stream, length, type, subtype, subClass);
case ASI_FORMAT_SPECIFIC:
case ASI_UNDEFINED:
// break; Fall through until we implement this descriptor
default:
Log.w(TAG, "Unknown Audio Streaming Interface subtype:0x"
+ Integer.toHexString(subtype));
return null;
}
}
private static UsbDescriptor allocMidiStreamingDescriptor(int length, byte type,
byte subtype, int subClass) {
switch (subtype) {
case MSI_HEADER:
return new UsbMSMidiHeader(length, type, subtype, subClass);
case MSI_IN_JACK:
return new UsbMSMidiInputJack(length, type, subtype, subClass);
case MSI_OUT_JACK:
return new UsbMSMidiOutputJack(length, type, subtype, subClass);
case MSI_ELEMENT:
// break;
// Fall through until we implement that descriptor
case MSI_UNDEFINED:
default:
Log.w(TAG, "Unknown MIDI Streaming Interface subtype:0x"
+ Integer.toHexString(subtype));
return null;
}
}
/**
* Allocates an audio class interface subtype based on subtype and subclass.
*/
public static UsbDescriptor allocDescriptor(UsbDescriptorParser parser, ByteStream stream,
int length, byte type) {
byte subtype = stream.getByte();
UsbInterfaceDescriptor interfaceDesc = parser.getCurInterface();
int subClass = interfaceDesc.getUsbSubclass();
switch (subClass) {
case AUDIO_AUDIOCONTROL:
if (UsbDescriptorParser.DEBUG) {
Log.d(TAG, " AUDIO_AUDIOCONTROL");
}
return allocAudioControlDescriptor(
parser, stream, length, type, subtype, subClass);
case AUDIO_AUDIOSTREAMING:
if (UsbDescriptorParser.DEBUG) {
Log.d(TAG, " AUDIO_AUDIOSTREAMING");
}
return allocAudioStreamingDescriptor(
parser, stream, length, type, subtype, subClass);
case AUDIO_MIDISTREAMING:
if (UsbDescriptorParser.DEBUG) {
Log.d(TAG, " AUDIO_MIDISTREAMING");
}
return allocMidiStreamingDescriptor(length, type, subtype, subClass);
default:
Log.w(TAG, "Unknown Audio Class Interface Subclass: 0x"
+ Integer.toHexString(subClass));
return null;
}
}
@Override
public void report(ReportCanvas canvas) {
super.report(canvas);
int subClass = getSubclass();
String subClassName = UsbStrings.getACInterfaceSubclassName(subClass);
byte subtype = getSubtype();
String subTypeName = UsbStrings.getACControlInterfaceName(subtype);
canvas.openList();
canvas.writeListItem("Subclass: " + ReportCanvas.getHexString(subClass)
+ " " + subClassName);
canvas.writeListItem("Subtype: " + ReportCanvas.getHexString(subtype) + " " + subTypeName);
canvas.closeList();
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy