Add parser for Short Audio Descriptor xml config (6bcc5963) · Commits · e / os / android_frameworks_base

services/core/java/com/android/server/hdmi/HdmiUtils.java

+203 −2

Original line number	Diff line number	Diff line
		@@ -16,23 +16,35 @@

		package com.android.server.hdmi;

		import android.annotation.Nullable;
		import android.hardware.hdmi.HdmiDeviceInfo;
		import android.util.Slog;
		import android.util.SparseArray;
		import android.util.Xml;

		import com.android.internal.util.HexDump;
		import com.android.internal.util.IndentingPrintWriter;
		import com.android.server.hdmi.Constants.AudioCodec;

		import org.xmlpull.v1.XmlPullParser;
		import org.xmlpull.v1.XmlPullParserException;

		import java.io.IOException;
		import java.io.InputStream;
		import java.util.ArrayList;
		import java.util.Arrays;
		import java.util.Collections;
		import java.util.List;
		import java.util.Map;

		import java.util.Objects;

		/**
		* Various utilities to handle HDMI CEC messages.
		*/
		final class HdmiUtils {

		private static final String TAG = "HdmiUtils";

		private static final int[] ADDRESS_TO_TYPE = {
		HdmiDeviceInfo.DEVICE_TV, // ADDR_TV
		HdmiDeviceInfo.DEVICE_RECORDER, // ADDR_RECORDER_1
		@@ -445,6 +457,156 @@ final class HdmiUtils {
		return port;
		}

		public static class ShortAudioDescriptorXmlParser {
		// We don't use namespaces
		private static final String NS = null;

		// return a list of devices config
		public static List<DeviceConfig> parse(InputStream in)
		throws XmlPullParserException, IOException {
		XmlPullParser parser = Xml.newPullParser();
		parser.setFeature(XmlPullParser.FEATURE_PROCESS_NAMESPACES, false);
		parser.setInput(in, null);
		parser.nextTag();
		return readDevices(parser);
		}

		private static void skip(XmlPullParser parser) throws XmlPullParserException, IOException {
		if (parser.getEventType() != XmlPullParser.START_TAG) {
		throw new IllegalStateException();
		}
		int depth = 1;
		while (depth != 0) {
		switch (parser.next()) {
		case XmlPullParser.END_TAG:
		depth--;
		break;
		case XmlPullParser.START_TAG:
		depth++;
		break;
		}
		}
		}

		private static List<DeviceConfig> readDevices(XmlPullParser parser)
		throws XmlPullParserException, IOException {
		List<DeviceConfig> devices = new ArrayList<>();

		parser.require(XmlPullParser.START_TAG, NS, "config");
		while (parser.next() != XmlPullParser.END_TAG) {
		if (parser.getEventType() != XmlPullParser.START_TAG) {
		continue;
		}
		String name = parser.getName();
		// Starts by looking for the device tag
		if (name.equals("device")) {
		String deviceType = parser.getAttributeValue(null, "type");
		DeviceConfig config = null;
		if (deviceType != null) {
		config = readDeviceConfig(parser, deviceType);
		}
		if (config != null) {
		devices.add(config);
		}
		} else {
		skip(parser);
		}
		}
		return devices;
		}

		// Processes device tags in the config.
		@Nullable
		private static DeviceConfig readDeviceConfig(XmlPullParser parser, String deviceType)
		throws XmlPullParserException, IOException {
		List<CodecSad> codecSads = new ArrayList<>();
		int format;
		byte[] descriptor;

		parser.require(XmlPullParser.START_TAG, NS, "device");
		while (parser.next() != XmlPullParser.END_TAG) {
		if (parser.getEventType() != XmlPullParser.START_TAG) {
		continue;
		}
		String tagName = parser.getName();

		// Starts by looking for the supportedFormat tag
		if (tagName.equals("supportedFormat")) {
		String codecAttriValue = parser.getAttributeValue(null, "format");
		String sadAttriValue = parser.getAttributeValue(null, "descriptor");
		format = (codecAttriValue) == null
		? Constants.AUDIO_CODEC_NONE : formatNameToNum(codecAttriValue);
		descriptor = readSad(sadAttriValue);
		if (format != Constants.AUDIO_CODEC_NONE && descriptor != null) {
		codecSads.add(new CodecSad(format, descriptor));
		}
		parser.nextTag();
		parser.require(XmlPullParser.END_TAG, NS, "supportedFormat");
		} else {
		skip(parser);
		}
		}
		if (codecSads.size() == 0) {
		return null;
		}
		return new DeviceConfig(deviceType, codecSads);
		}

		// Processes sad attribute in the supportedFormat.
		@Nullable
		private static byte[] readSad(String sad) {
		if (sad == null \|\| sad.length() == 0) {
		return null;
		}
		byte[] sadBytes = HexDump.hexStringToByteArray(sad);
		if (sadBytes.length != 3) {
		Slog.w(TAG, "SAD byte array length is not 3. Length = " + sadBytes.length);
		return null;
		}
		return sadBytes;
		}

		@AudioCodec
		private static int formatNameToNum(String codecAttriValue) {
		switch (codecAttriValue) {
		case "AUDIO_FORMAT_NONE":
		return Constants.AUDIO_CODEC_NONE;
		case "AUDIO_FORMAT_LPCM":
		return Constants.AUDIO_CODEC_LPCM;
		case "AUDIO_FORMAT_DD":
		return Constants.AUDIO_CODEC_DD;
		case "AUDIO_FORMAT_MPEG1":
		return Constants.AUDIO_CODEC_MPEG1;
		case "AUDIO_FORMAT_MP3":
		return Constants.AUDIO_CODEC_MP3;
		case "AUDIO_FORMAT_MPEG2":
		return Constants.AUDIO_CODEC_MPEG2;
		case "AUDIO_FORMAT_AAC":
		return Constants.AUDIO_CODEC_AAC;
		case "AUDIO_FORMAT_DTS":
		return Constants.AUDIO_CODEC_DTS;
		case "AUDIO_FORMAT_ATRAC":
		return Constants.AUDIO_CODEC_ATRAC;
		case "AUDIO_FORMAT_ONEBITAUDIO":
		return Constants.AUDIO_CODEC_ONEBITAUDIO;
		case "AUDIO_FORMAT_DDP":
		return Constants.AUDIO_CODEC_DDP;
		case "AUDIO_FORMAT_DTSHD":
		return Constants.AUDIO_CODEC_DTSHD;
		case "AUDIO_FORMAT_TRUEHD":
		return Constants.AUDIO_CODEC_TRUEHD;
		case "AUDIO_FORMAT_DST":
		return Constants.AUDIO_CODEC_DST;
		case "AUDIO_FORMAT_WMAPRO":
		return Constants.AUDIO_CODEC_WMAPRO;
		case "AUDIO_FORMAT_MAX":
		return Constants.AUDIO_CODEC_MAX;
		default:
		return Constants.AUDIO_CODEC_NONE;
		}
		}
		}

		// Device configuration of its supported Codecs and their Short Audio Descriptors.
		public static class DeviceConfig {
		/ Name of the device. Should be {@link Constants.AudioDevice}. /
		@@ -452,10 +614,27 @@ final class HdmiUtils {
		/ List of a {@link CodecSad}. /
		public final List<CodecSad> supportedCodecs;

		private DeviceConfig(String name, List<CodecSad> supportedCodecs) {
		public DeviceConfig(String name, List<CodecSad> supportedCodecs) {
		this.name = name;
		this.supportedCodecs = supportedCodecs;
		}

		@Override
		public boolean equals(Object obj) {
		if (obj instanceof DeviceConfig) {
		DeviceConfig that = (DeviceConfig) obj;
		return that.name.equals(this.name)
		&& that.supportedCodecs.equals(this.supportedCodecs);
		}
		return false;
		}

		@Override
		public int hashCode() {
		return Objects.hash(
		name,
		supportedCodecs.hashCode());
		}
		}

		// Short Audio Descriptor of a specific Codec
		@@ -472,5 +651,27 @@ final class HdmiUtils {
		this.audioCodec = audioCodec;
		this.sad = sad;
		}

		public CodecSad(int audioCodec, String sad) {
		this.audioCodec = audioCodec;
		this.sad = HexDump.hexStringToByteArray(sad);
		}

		@Override
		public boolean equals(Object obj) {
		if (obj instanceof CodecSad) {
		CodecSad that = (CodecSad) obj;
		return that.audioCodec == this.audioCodec
		&& Arrays.equals(that.sad, this.sad);
		}
		return false;
		}

		@Override
		public int hashCode() {
		return Objects.hash(
		audioCodec,
		Arrays.hashCode(sad));
		}
		}
		}

services/tests/servicestests/src/com/android/server/hdmi/HdmiUtilsTest.java

+64 −0

Original line number	Diff line number	Diff line
		@@ -17,17 +17,44 @@ package com.android.server.hdmi;

		import static com.google.common.truth.Truth.assertThat;

		import android.util.Slog;

		import androidx.test.filters.SmallTest;

		import com.android.server.hdmi.HdmiUtils.CodecSad;
		import com.android.server.hdmi.HdmiUtils.DeviceConfig;

		import org.junit.Test;
		import org.junit.runner.RunWith;
		import org.junit.runners.JUnit4;
		import org.xmlpull.v1.XmlPullParserException;

		import java.io.ByteArrayInputStream;
		import java.io.IOException;
		import java.nio.charset.StandardCharsets;
		import java.util.ArrayList;
		import java.util.List;

		@SmallTest
		@RunWith(JUnit4.class)
		/** Tests for {@link HdmiUtils} class. */
		public class HdmiUtilsTest {

		private static final String TAG = "HdmiUtilsTest";

		private final String mExampleXML =
		"<!-- A sample Short Audio Descriptor configuration xml -->"
		+ "<config version=\"1.0\" xmlns:xi=\"http://www.w3.org/2001/XInclude\">"
		+ "<device type=\"VX_AUDIO_DEVICE_IN_HDMI_ARC\">"
		+ "<supportedFormat format=\"AUDIO_FORMAT_LPCM\" descriptor=\"011a03\"/>"
		+ "<supportedFormat format=\"AUDIO_FORMAT_DD\" descriptor=\"0d0506\"/>"
		+ "</device>"
		+ "<device type=\"AUDIO_DEVICE_IN_SPDIF\">"
		+ "<supportedFormat format=\"AUDIO_FORMAT_LPCM\" descriptor=\"010203\"/>"
		+ "<supportedFormat format=\"AUDIO_FORMAT_DD\" descriptor=\"040506\"/>"
		+ "</device>"
		+ "</config>";

		@Test
		public void pathToPort_isMe() {
		int targetPhysicalAddress = 0x1000;
		@@ -79,4 +106,41 @@ public class HdmiUtilsTest {
		targetPhysicalAddress, myPhysicalAddress)).isEqualTo(
		HdmiUtils.TARGET_NOT_UNDER_LOCAL_DEVICE);
		}

		@Test
		public void parseSampleXML() {
		List<DeviceConfig> config = new ArrayList<>();
		try {
		config = HdmiUtils.ShortAudioDescriptorXmlParser.parse(
		new ByteArrayInputStream(mExampleXML.getBytes(StandardCharsets.UTF_8)));
		} catch (IOException e) {
		Slog.e(TAG, e.getMessage(), e);
		} catch (XmlPullParserException e) {
		Slog.e(TAG, e.getMessage(), e);
		}

		CodecSad expectedCodec1 = new CodecSad(Constants.AUDIO_CODEC_LPCM, "011a03");
		CodecSad expectedCodec2 = new CodecSad(Constants.AUDIO_CODEC_DD, "0d0506");
		CodecSad expectedCodec3 = new CodecSad(Constants.AUDIO_CODEC_LPCM, "010203");
		CodecSad expectedCodec4 = new CodecSad(Constants.AUDIO_CODEC_DD, "040506");

		List<CodecSad> expectedList1 = new ArrayList<>();
		expectedList1.add(expectedCodec1);
		expectedList1.add(expectedCodec2);

		List<CodecSad> expectedList2 = new ArrayList<>();
		expectedList2.add(expectedCodec3);
		expectedList2.add(expectedCodec4);

		DeviceConfig expectedDevice1 = new DeviceConfig(
		"VX_AUDIO_DEVICE_IN_HDMI_ARC", expectedList1);
		DeviceConfig expectedDevice2 = new DeviceConfig(
		"AUDIO_DEVICE_IN_SPDIF", expectedList2);

		List<DeviceConfig> expectedConfig = new ArrayList<>();
		expectedConfig.add(expectedDevice1);
		expectedConfig.add(expectedDevice2);

		assertThat(config).isEqualTo(expectedConfig);
		}
		}