Merge changes from topic "am-f4304a1e0933443083cc3d854839c296" into tm-qpr-dev-plus-aosp (71d51f48) · Commits · e / os / android_packages_modules_Bluetooth

system/stack/Android.bp

+102 −0

Original line number	Diff line number	Diff line
		@@ -615,6 +615,108 @@ cc_test {
		},
		}

		cc_test {
		name: "net_test_stack_a2dp_codecs_native",
		defaults: [
		"fluoride_defaults",
		"mts_defaults",
		],
		test_suites: ["device-tests"],
		host_supported: true,
		test_options: {
		unit_test: true,
		},
		include_dirs: [
		"external/aac/libAACenc/include",
		"external/aac/libAACdec/include",
		"external/aac/libSYS/include",
		"external/libldac/inc",
		"external/libldac/abr/inc",
		"external/libopus/include",
		"packages/modules/Bluetooth/system",
		"packages/modules/Bluetooth/system/btif/include",
		"packages/modules/Bluetooth/system/embdrv/encoder_for_aptxhd/include",
		"packages/modules/Bluetooth/system/gd",
		"packages/modules/Bluetooth/system/stack/include",
		"packages/modules/Bluetooth/system/utils/include",
		],
		target: {
		host: {
		srcs: [
		":BluetoothHostTestingLogCapture",
		],
		},
		android: {
		srcs: [
		":BluetoothAndroidTestingLogCapture",
		],
		test_config: "test/a2dp/AndroidTest.xml",
		}
		},
		data: [
		"test/a2dp/raw_data/*",
		],
		srcs: [
		"a2dp/a2dp_aac.cc",
		"a2dp/a2dp_aac_decoder.cc",
		"a2dp/a2dp_aac_encoder.cc",
		"a2dp/a2dp_codec_config.cc",
		"a2dp/a2dp_sbc.cc",
		"a2dp/a2dp_sbc_decoder.cc",
		"a2dp/a2dp_sbc_encoder.cc",
		"a2dp/a2dp_sbc_up_sample.cc",
		"a2dp/a2dp_vendor.cc",
		"a2dp/a2dp_vendor_aptx.cc",
		"a2dp/a2dp_vendor_aptx_hd.cc",
		"a2dp/a2dp_vendor_aptx_encoder.cc",
		"a2dp/a2dp_vendor_aptx_hd_encoder.cc",
		"a2dp/a2dp_vendor_ldac.cc",
		"a2dp/a2dp_vendor_ldac_decoder.cc",
		"a2dp/a2dp_vendor_ldac_encoder.cc",
		"a2dp/a2dp_vendor_opus.cc",
		"a2dp/a2dp_vendor_opus_encoder.cc",
		"a2dp/a2dp_vendor_opus_decoder.cc",
		"test/a2dp/a2dp_aac_unittest.cc",
		"test/a2dp/a2dp_sbc_unittest.cc",
		"test/a2dp/a2dp_opus_unittest.cc",
		"test/a2dp/a2dp_vendor_ldac_unittest.cc",
		"test/a2dp/mock_bta_av_codec.cc",
		"test/a2dp/test_util.cc",
		"test/a2dp/wav_reader.cc",
		"test/a2dp/wav_reader_unittest.cc",
		":TestMockBta",
		":TestMockStackA2dpApi",
		],
		shared_libs: [
		"libcrypto",
		"libcutils",
		"libprotobuf-cpp-lite",
		],
		static_libs: [
		"libbt-common",
		"libbt-protos-lite",
		"libbt-sbc-decoder",
		"libbt-sbc-encoder",
		"libFraunhoferAAC",
		"libgmock",
		"liblog",
		"libopus",
		"libosi",
		"libosi-AllocationTestHarness",
		],
		whole_static_libs: [
		"libaptx_enc",
		"libaptxhd_enc",
		"libldacBT_abr",
		"libldacBT_enc",
		],
		sanitize: {
		address: true,
		cfi: true,
		misc_undefined: ["bounds"],
		},
		}

		cc_test {
		name: "net_test_stack_a2dp_native",
		defaults: [

system/stack/a2dp/a2dp_vendor_opus_decoder.cc

+5 −0

Original line number	Diff line number	Diff line
		@@ -100,6 +100,11 @@ bool a2dp_vendor_opus_decoder_decode_packet(BT_HDR* p_buf) {
		return false;
		}

		if (p_buf->len == 0) {
		LOG_ERROR("Empty packet");
		return false;
		}

		auto* pBuffer =
		reinterpret_cast<unsigned char*>(p_buf->data + p_buf->offset + 1);
		int32_t bufferSize = p_buf->len - 1;

system/stack/a2dp/a2dp_vendor_opus_encoder.cc

+2 −1

Original line number	Diff line number	Diff line
		@@ -231,7 +231,6 @@ static bool a2dp_vendor_opus_encoder_update(uint16_t peer_mtu,
		LOG_INFO("sample_rate=%u bits_per_sample=%u channel_count=%u",
		p_feeding_params->sample_rate, p_feeding_params->bits_per_sample,
		p_feeding_params->channel_count);
		a2dp_vendor_opus_feeding_reset();

		// The codec parameters
		p_encoder_params->sample_rate =
		@@ -241,6 +240,8 @@ static bool a2dp_vendor_opus_encoder_update(uint16_t peer_mtu,
		p_encoder_params->framesize = A2DP_VendorGetFrameSizeOpus(p_codec_info);
		p_encoder_params->bitrate = A2DP_VendorGetBitRateOpus(p_codec_info);

		a2dp_vendor_opus_feeding_reset();

		uint16_t mtu_size =
		BT_DEFAULT_BUFFER_SIZE - A2DP_OPUS_OFFSET - sizeof(BT_HDR);
		if (mtu_size < peer_mtu) {

system/stack/test/a2dp/AndroidTest.xml

0 → 100644

+39 −0

Original line number	Diff line number	Diff line
		<?xml version="1.0" encoding="utf-8"?>
		<!-- Copyright 2022 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.
		-->
		<configuration description="Runs net_test_stack_a2dp_codecs_native.">
		<target_preparer class="com.android.tradefed.targetprep.RootTargetPreparer" />
		<target_preparer class="com.android.compatibility.common.tradefed.targetprep.FilePusher">
		<option name="cleanup" value="true" />
		<option name="push" value="net_test_stack_a2dp_codecs_native->/data/local/tmp/net_test_stack_a2dp_codecs_native" />
		<option name="append-bitness" value="true" />
		</target_preparer>
		<target_preparer class="com.android.compatibility.common.tradefed.targetprep.FilePusher">
		<option name="cleanup" value="true" />
		<option name="push" value="pcm0844s.wav->/data/local/tmp/test/a2dp/raw_data/pcm0844s.wav" />
		<option name="push" value="pcm1644s.wav->/data/local/tmp/test/a2dp/raw_data/pcm1644s.wav" />
		</target_preparer>
		<test class="com.android.tradefed.testtype.GTest" >
		<option name="native-test-device-path" value="/data/local/tmp" />
		<option name="module-name" value="net_test_stack_a2dp_codecs_native" />
		<option name="run-test-as" value="0" />
		</test>

		<!-- Only run tests in MTS if the Bluetooth Mainline module is installed. -->
		<object type="module_controller"
		class="com.android.tradefed.testtype.suite.module.MainlineTestModuleController">
		<option name="mainline-module-package-name" value="com.google.android.bluetooth" />
		</object>
		</configuration>

system/stack/test/a2dp/a2dp_aac_unittest.cc

0 → 100644

+307 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright 2022 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.
		*/

		#include "stack/include/a2dp_aac.h"

		#include <base/logging.h>
		#include <gtest/gtest.h>
		#include <stdio.h>

		#include <cstdint>
		#include <fstream>
		#include <future>
		#include <iomanip>
		#include <map>
		#include <string>

		#include "common/init_flags.h"
		#include "common/testing/log_capture.h"
		#include "common/time_util.h"
		#include "os/log.h"
		#include "osi/include/allocator.h"
		#include "osi/test/AllocationTestHarness.h"
		#include "stack/include/bt_hdr.h"
		#include "stack/include/a2dp_aac_decoder.h"
		#include "stack/include/a2dp_aac_encoder.h"
		#include "stack/include/avdt_api.h"
		#include "test_util.h"
		#include "wav_reader.h"

		extern void allocation_tracker_uninit(void);
		namespace {
		constexpr uint32_t kAacReadSize = 1024 * 2 * 2;
		constexpr uint32_t kA2dpTickUs = 23 * 1000;
		constexpr char kDecodedDataCallbackIsInvoked[] =
		"A2DP decoded data callback is invoked.";
		constexpr char kEnqueueCallbackIsInvoked[] =
		"A2DP source enqueue callback is invoked.";
		constexpr uint16_t kPeerMtu = 1000;
		constexpr char kWavFile[] = "test/a2dp/raw_data/pcm1644s.wav";
		constexpr uint8_t kCodecInfoAacCapability[AVDT_CODEC_SIZE] = {
		8, // Length (A2DP_AAC_INFO_LEN)
		0, // Media Type: AVDT_MEDIA_TYPE_AUDIO
		2, // Media Codec Type: A2DP_MEDIA_CT_AAC
		0x80, // Object Type: A2DP_AAC_OBJECT_TYPE_MPEG2_LC
		0x01, // Sampling Frequency: A2DP_AAC_SAMPLING_FREQ_44100
		0x04, // Channels: A2DP_AAC_CHANNEL_MODE_STEREO
		0x00 \| 0x4, // Variable Bit Rate:
		// A2DP_AAC_VARIABLE_BIT_RATE_DISABLED
		// Bit Rate: 320000 = 0x4e200
		0xe2, // Bit Rate: 320000 = 0x4e200
		0x00, // Bit Rate: 320000 = 0x4e200
		7, // Unused
		8, // Unused
		9 // Unused
		};
		uint8_t* Data(BT_HDR* packet) { return packet->data + packet->offset; }
		} // namespace

		namespace bluetooth {
		namespace testing {

		static BT_HDR* packet = nullptr;
		static WavReader wav_reader = WavReader(GetWavFilePath(kWavFile).c_str());

		class A2dpAacTest : public AllocationTestHarness {
		protected:
		void SetUp() override {
		AllocationTestHarness::SetUp();
		common::InitFlags::SetAllForTesting();
		// Disable our allocation tracker to allow ASAN full range
		allocation_tracker_uninit();
		SetCodecConfig();
		encoder_iface_ = const_cast<tA2DP_ENCODER_INTERFACE*>(
		A2DP_GetEncoderInterfaceAac(kCodecInfoAacCapability));
		ASSERT_NE(encoder_iface_, nullptr);
		decoder_iface_ = const_cast<tA2DP_DECODER_INTERFACE*>(
		A2DP_GetDecoderInterfaceAac(kCodecInfoAacCapability));
		ASSERT_NE(decoder_iface_, nullptr);
		}

		void TearDown() override {
		if (a2dp_codecs_ != nullptr) {
		delete a2dp_codecs_;
		}
		if (encoder_iface_ != nullptr) {
		encoder_iface_->encoder_cleanup();
		}
		A2DP_UnloadEncoderAac();
		if (decoder_iface_ != nullptr) {
		decoder_iface_->decoder_cleanup();
		}
		A2DP_UnloadDecoderAac();
		AllocationTestHarness::TearDown();
		}

		void SetCodecConfig() {
		uint8_t codec_info_result[AVDT_CODEC_SIZE];
		btav_a2dp_codec_index_t peer_codec_index;
		a2dp_codecs_ = new A2dpCodecs(std::vector<btav_a2dp_codec_config_t>());

		ASSERT_TRUE(a2dp_codecs_->init());

		// Create the codec capability - AAC Sink
		memset(codec_info_result, 0, sizeof(codec_info_result));
		ASSERT_TRUE(A2DP_IsSinkCodecSupportedAac(kCodecInfoAacCapability));
		peer_codec_index = A2DP_SinkCodecIndex(kCodecInfoAacCapability);
		ASSERT_NE(peer_codec_index, BTAV_A2DP_CODEC_INDEX_MAX);
		sink_codec_config_ = a2dp_codecs_->findSinkCodecConfig(kCodecInfoAacCapability);
		ASSERT_NE(sink_codec_config_, nullptr);
		ASSERT_TRUE(a2dp_codecs_->setSinkCodecConfig(kCodecInfoAacCapability, true,
		codec_info_result, true));
		ASSERT_TRUE(a2dp_codecs_->setPeerSinkCodecCapabilities(kCodecInfoAacCapability));
		// Compare the result codec with the local test codec info
		for (size_t i = 0; i < kCodecInfoAacCapability[0] + 1; i++) {
		ASSERT_EQ(codec_info_result[i], kCodecInfoAacCapability[i]);
		}
		ASSERT_TRUE(a2dp_codecs_->setCodecConfig(kCodecInfoAacCapability, true, codec_info_result, true));
		source_codec_config_ = a2dp_codecs_->getCurrentCodecConfig();
		}

		void InitializeEncoder(bool peer_supports_3mbps, a2dp_source_read_callback_t read_cb,
		a2dp_source_enqueue_callback_t enqueue_cb) {
		tA2DP_ENCODER_INIT_PEER_PARAMS peer_params = {true, peer_supports_3mbps, kPeerMtu};
		encoder_iface_->encoder_init(&peer_params, sink_codec_config_, read_cb,
		enqueue_cb);
		}

		void InitializeDecoder(decoded_data_callback_t data_cb) {
		decoder_iface_->decoder_init(data_cb);
		}

		BT_HDR* AllocateL2capPacket(const std::vector<uint8_t> data) const {
		auto packet = AllocatePacket(data.size());
		std::copy(data.cbegin(), data.cend(), Data(packet));
		return packet;
		}

		BT_HDR* AllocatePacket(size_t packet_length) const {
		BT_HDR* packet =
		static_cast<BT_HDR*>(osi_calloc(sizeof(BT_HDR) + packet_length));
		packet->len = packet_length;
		return packet;
		}
		A2dpCodecConfig* sink_codec_config_;
		A2dpCodecConfig* source_codec_config_;
		A2dpCodecs* a2dp_codecs_;
		tA2DP_ENCODER_INTERFACE* encoder_iface_;
		tA2DP_DECODER_INTERFACE* decoder_iface_;
		std::unique_ptr<LogCapture> log_capture_;
		};

		TEST_F(A2dpAacTest, a2dp_source_read_underflow) {
		log_capture_ = std::make_unique<LogCapture>();
		auto read_cb = +[](uint8_t* p_buf, uint32_t len) -> uint32_t {
		// underflow
		return 0;
		};
		auto enqueue_cb = +[](BT_HDR* p_buf, size_t frames_n, uint32_t len) -> bool {
		return false;
		};
		InitializeEncoder(true, read_cb, enqueue_cb);
		uint64_t timestamp_us = bluetooth::common::time_gettimeofday_us();
		encoder_iface_->send_frames(timestamp_us);
		usleep(kA2dpTickUs);
		timestamp_us = bluetooth::common::time_gettimeofday_us();
		encoder_iface_->send_frames(timestamp_us);
		std::promise<void> promise;
		log_capture_->WaitUntilLogContains(&promise,
		"a2dp_aac_encode_frames: underflow");
		}

		TEST_F(A2dpAacTest, a2dp_enqueue_cb_is_invoked) {
		log_capture_ = std::make_unique<LogCapture>();
		auto read_cb = +[](uint8_t* p_buf, uint32_t len) -> uint32_t {
		ASSERT(kAacReadSize == len);
		return len;
		};
		auto enqueue_cb = +[](BT_HDR* p_buf, size_t frames_n, uint32_t len) -> bool {
		LOG_DEBUG("%s", kEnqueueCallbackIsInvoked);
		osi_free(p_buf);
		return false;
		};
		InitializeEncoder(true, read_cb, enqueue_cb);
		uint64_t timestamp_us = bluetooth::common::time_gettimeofday_us();
		encoder_iface_->send_frames(timestamp_us);
		usleep(kA2dpTickUs);
		timestamp_us = bluetooth::common::time_gettimeofday_us();
		encoder_iface_->send_frames(timestamp_us);
		std::promise<void> promise;
		log_capture_->WaitUntilLogContains(&promise, kEnqueueCallbackIsInvoked);
		}

		TEST_F(A2dpAacTest, decoded_data_cb_not_invoked_when_empty_packet) {
		auto data_cb = +[](uint8_t* p_buf, uint32_t len) { FAIL(); };
		InitializeDecoder(data_cb);
		std::vector<uint8_t> data;
		BT_HDR* packet = AllocateL2capPacket(data);
		decoder_iface_->decode_packet(packet);
		osi_free(packet);
		}

		TEST_F(A2dpAacTest, decoded_data_cb_invoked) {
		log_capture_ = std::make_unique<LogCapture>();
		auto data_cb = +[](uint8_t* p_buf, uint32_t len) {
		LOG_DEBUG("%s", kDecodedDataCallbackIsInvoked);
		};
		InitializeDecoder(data_cb);

		auto read_cb = +[](uint8_t* p_buf, uint32_t len) -> uint32_t {
		static uint32_t counter = 0;
		memcpy(p_buf, wav_reader.GetSamples() + counter, len);
		counter += len;
		return len;
		};
		auto enqueue_cb = +[](BT_HDR* p_buf, size_t frames_n, uint32_t len) -> bool {
		packet = p_buf;
		LOG_DEBUG("%s", kEnqueueCallbackIsInvoked);
		return false;
		};
		InitializeEncoder(true, read_cb, enqueue_cb);

		uint64_t timestamp_us = bluetooth::common::time_gettimeofday_us();
		encoder_iface_->send_frames(timestamp_us);
		usleep(kA2dpTickUs);
		timestamp_us = bluetooth::common::time_gettimeofday_us();
		encoder_iface_->send_frames(timestamp_us);

		std::promise<void> promise;
		log_capture_->WaitUntilLogContains(&promise, kEnqueueCallbackIsInvoked);
		decoder_iface_->decode_packet(packet);
		osi_free(packet);
		ASSERT_TRUE(log_capture_->Find(kDecodedDataCallbackIsInvoked));
		}

		TEST_F(A2dpAacTest, set_source_codec_config_works) {
		uint8_t codec_info_result[AVDT_CODEC_SIZE];
		ASSERT_TRUE(a2dp_codecs_->setCodecConfig(kCodecInfoAacCapability, true, codec_info_result, true));
		ASSERT_TRUE(A2DP_CodecTypeEqualsAac(codec_info_result, kCodecInfoAacCapability));
		ASSERT_TRUE(A2DP_CodecEqualsAac(codec_info_result, kCodecInfoAacCapability));
		auto* codec_config = a2dp_codecs_->findSourceCodecConfig(kCodecInfoAacCapability);
		ASSERT_EQ(codec_config->name(), source_codec_config_->name());
		ASSERT_EQ(codec_config->getAudioBitsPerSample(), source_codec_config_->getAudioBitsPerSample());
		}

		TEST_F(A2dpAacTest, sink_supports_aac) {
		ASSERT_TRUE(A2DP_IsSinkCodecSupportedAac(kCodecInfoAacCapability));
		}

		TEST_F(A2dpAacTest, effective_mtu_when_peer_supports_3mbps) {
		auto read_cb = +[](uint8_t* p_buf, uint32_t len) -> uint32_t {
		ASSERT(kAacReadSize == len);
		return len;
		};
		auto enqueue_cb = +[](BT_HDR* p_buf, size_t frames_n, uint32_t len) -> bool {
		osi_free(p_buf);
		return false;
		};
		InitializeEncoder(true, read_cb, enqueue_cb);
		ASSERT_EQ(a2dp_aac_get_effective_frame_size(), kPeerMtu);
		}

		TEST_F(A2dpAacTest, effective_mtu_when_peer_does_not_support_3mbps) {
		auto read_cb = +[](uint8_t* p_buf, uint32_t len) -> uint32_t {
		ASSERT(kAacReadSize == len);
		return len;
		};
		auto enqueue_cb = +[](BT_HDR* p_buf, size_t frames_n, uint32_t len) -> bool {
		osi_free(p_buf);
		return false;
		};
		InitializeEncoder(false, read_cb, enqueue_cb);
		ASSERT_EQ(a2dp_aac_get_effective_frame_size(), 663 /* MAX_2MBPS_AVDTP_MTU */);
		}

		TEST_F(A2dpAacTest, debug_codec_dump) {
		log_capture_ = std::make_unique<LogCapture>();
		a2dp_codecs_->debug_codec_dump(2);
		std::promise<void> promise;
		log_capture_->WaitUntilLogContains(&promise,
		"Current Codec: AAC");
		}

		TEST_F(A2dpAacTest, codec_info_string) {
		auto codec_info = A2DP_CodecInfoString(kCodecInfoAacCapability);
		ASSERT_NE(codec_info.find("samp_freq: 44100"), std::string::npos);
		ASSERT_NE(codec_info.find("ch_mode: Stereo"), std::string::npos);
		}

		TEST_F(A2dpAacTest, get_track_bits_per_sample) {
		ASSERT_EQ(A2DP_GetTrackBitsPerSampleAac(kCodecInfoAacCapability), 16);
		}

		} // namespace testing
		} // namespace bluetooth