1 /****************************************************************************** 2 * 3 * Copyright 2016 The Android Open Source Project 4 * 5 * Licensed under the Apache License, Version 2.0 (the "License"); 6 * you may not use this file except in compliance with the License. 7 * You may obtain a copy of the License at: 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 * 17 ******************************************************************************/ 18 19 #include <dlfcn.h> 20 21 #include <set> 22 #include <vector> 23 24 #include <gtest/gtest.h> 25 26 #include "stack/include/a2dp_aac.h" 27 #include "stack/include/a2dp_api.h" 28 #include "stack/include/a2dp_codec_api.h" 29 #include "stack/include/a2dp_sbc.h" 30 #include "stack/include/a2dp_vendor.h" 31 32 namespace { 33 const uint8_t codec_info_sbc[AVDT_CODEC_SIZE] = { 34 6, // Length (A2DP_SBC_INFO_LEN) 35 0, // Media Type: AVDT_MEDIA_TYPE_AUDIO 36 0, // Media Codec Type: A2DP_MEDIA_CT_SBC 37 0x20 | 0x01, // Sample Frequency: A2DP_SBC_IE_SAMP_FREQ_44 | 38 // Channel Mode: A2DP_SBC_IE_CH_MD_JOINT 39 0x10 | 0x04 | 0x01, // Block Length: A2DP_SBC_IE_BLOCKS_16 | 40 // Subbands: A2DP_SBC_IE_SUBBAND_8 | 41 // Allocation Method: A2DP_SBC_IE_ALLOC_MD_L 42 2, // MinimumBitpool Value: A2DP_SBC_IE_MIN_BITPOOL 43 53, // Maximum Bitpool Value: A2DP_SBC_MAX_BITPOOL 44 7, // Dummy 45 8, // Dummy 46 9 // Dummy 47 }; 48 49 const uint8_t codec_info_sbc_capability[AVDT_CODEC_SIZE] = { 50 6, // Length (A2DP_SBC_INFO_LEN) 51 0, // Media Type: AVDT_MEDIA_TYPE_AUDIO 52 0, // Media Codec Type: A2DP_MEDIA_CT_SBC 53 0x20 | // Sample Frequency: A2DP_SBC_IE_SAMP_FREQ_44 | 54 0x08 | 0x01, // Channel Mode: A2DP_SBC_IE_CH_MD_MONO | 55 // A2DP_SBC_IE_CH_MD_JOINT 56 0x80 | 0x40 | 0x20 | 0x10 | // Block Length: A2DP_SBC_IE_BLOCKS_4 | 57 // A2DP_SBC_IE_BLOCKS_8 | 58 // A2DP_SBC_IE_BLOCKS_12 | 59 // A2DP_SBC_IE_BLOCKS_16 | 60 0x04 | // Subbands: A2DP_SBC_IE_SUBBAND_8 | 61 0x01, // Allocation Method: A2DP_SBC_IE_ALLOC_MD_L 62 2, // MinimumBitpool Value: A2DP_SBC_IE_MIN_BITPOOL 63 53, // Maximum Bitpool Value: A2DP_SBC_MAX_BITPOOL 64 7, // Dummy 65 8, // Dummy 66 9 // Dummy 67 }; 68 69 const uint8_t codec_info_sbc_sink_capability[AVDT_CODEC_SIZE] = { 70 6, // Length (A2DP_SBC_INFO_LEN) 71 0, // Media Type: AVDT_MEDIA_TYPE_AUDIO 72 0, // Media Codec Type: A2DP_MEDIA_CT_SBC 73 0x20 | 0x10 | // Sample Frequency: A2DP_SBC_IE_SAMP_FREQ_44 | 74 // A2DP_SBC_IE_SAMP_FREQ_48 | 75 0x08 | 0x04 | 0x02 | 0x01, // Channel Mode: A2DP_SBC_IE_CH_MD_MONO | 76 // A2DP_SBC_IE_CH_MD_DUAL | 77 // A2DP_SBC_IE_CH_MD_STEREO | 78 // A2DP_SBC_IE_CH_MD_JOINT 79 0x80 | 0x40 | 0x20 | 0x10 | // Block Length: A2DP_SBC_IE_BLOCKS_4 | 80 // A2DP_SBC_IE_BLOCKS_8 | 81 // A2DP_SBC_IE_BLOCKS_12 | 82 // A2DP_SBC_IE_BLOCKS_16 | 83 0x08 | 0x04 | // Subbands: A2DP_SBC_IE_SUBBAND_4 | 84 // A2DP_SBC_IE_SUBBAND_8 | 85 0x02 | 0x01, // Allocation Method: A2DP_SBC_IE_ALLOC_MD_S | 86 // A2DP_SBC_IE_ALLOC_MD_L 87 2, // MinimumBitpool Value: A2DP_SBC_IE_MIN_BITPOOL 88 53, // Maximum Bitpool Value: A2DP_SBC_MAX_BITPOOL 89 7, // Dummy 90 8, // Dummy 91 9 // Dummy 92 }; 93 94 const uint8_t codec_info_aac[AVDT_CODEC_SIZE] = { 95 8, // Length (A2DP_AAC_INFO_LEN) 96 0, // Media Type: AVDT_MEDIA_TYPE_AUDIO 97 2, // Media Codec Type: A2DP_MEDIA_CT_AAC 98 0x80, // Object Type: A2DP_AAC_OBJECT_TYPE_MPEG2_LC 99 0x01, // Sampling Frequency: A2DP_AAC_SAMPLING_FREQ_44100 100 0x04, // Channels: A2DP_AAC_CHANNEL_MODE_STEREO 101 0x00 | 0x4, // Variable Bit Rate: 102 // A2DP_AAC_VARIABLE_BIT_RATE_DISABLED 103 // Bit Rate: 320000 = 0x4e200 104 0xe2, // Bit Rate: 320000 = 0x4e200 105 0x00, // Bit Rate: 320000 = 0x4e200 106 7, // Dummy 107 8, // Dummy 108 9 // Dummy 109 }; 110 111 const uint8_t codec_info_aac_capability[AVDT_CODEC_SIZE] = { 112 8, // Length (A2DP_AAC_INFO_LEN) 113 0, // Media Type: AVDT_MEDIA_TYPE_AUDIO 114 2, // Media Codec Type: A2DP_MEDIA_CT_AAC 115 0x80, // Object Type: A2DP_AAC_OBJECT_TYPE_MPEG2_LC 116 0x01, // Sampling Frequency: A2DP_AAC_SAMPLING_FREQ_44100 117 // TODO: AAC 48.0kHz sampling rate should be added back - see b/62301376 118 0x04, // Channels: A2DP_AAC_CHANNEL_MODE_STEREO 119 0x00 | 0x4, // Variable Bit Rate: 120 // A2DP_AAC_VARIABLE_BIT_RATE_DISABLED 121 // Bit Rate: 320000 = 0x4e200 122 0xe2, // Bit Rate: 320000 = 0x4e200 123 0x00, // Bit Rate: 320000 = 0x4e200 124 7, // Dummy 125 8, // Dummy 126 9 // Dummy 127 }; 128 129 const uint8_t codec_info_aac_sink_capability[AVDT_CODEC_SIZE] = { 130 8, // Length (A2DP_AAC_INFO_LEN) 131 0, // Media Type: AVDT_MEDIA_TYPE_AUDIO 132 2, // Media Codec Type: A2DP_MEDIA_CT_AAC 133 0x80 | 0x40 | 0x20 | 0x10, // Object Type: A2DP_AAC_OBJECT_TYPE_MPEG2_LC | 134 // A2DP_AAC_OBJECT_TYPE_MPEG4_LC 135 // A2DP_AAC_OBJECT_TYPE_MPEG4_LTP 136 // A2DP_AAC_OBJECT_TYPE_MPEG4_SCALABLE 137 0x01, // Sampling Frequency: A2DP_AAC_SAMPLING_FREQ_44100 138 0x80 | 0x20 | 0x10 | 0x08 | 0x04, // Sampling Frequency: 139 // A2DP_AAC_SAMPLING_FREQ_48000 | 140 // A2DP_AAC_SAMPLING_FREQ_88200 | 141 // A2DP_AAC_SAMPLING_FREQ_96000 | 142 // Channels: 143 // A2DP_AAC_CHANNEL_MODE_MONO | 144 // A2DP_AAC_CHANNEL_MODE_STEREO 145 0x80 | 0x4, // Variable Bit Rate: 146 // A2DP_AAC_VARIABLE_BIT_RATE_ENABLED 147 // Bit Rate: 320000 = 0x4e200 148 0xe2, // Bit Rate: 320000 = 0x4e200 149 0x00, // Bit Rate: 320000 = 0x4e200 150 7, // Dummy 151 8, // Dummy 152 9 // Dummy 153 }; 154 155 const uint8_t codec_info_non_a2dp[AVDT_CODEC_SIZE] = { 156 8, // Length 157 0, // Media Type: AVDT_MEDIA_TYPE_AUDIO 158 0xFF, // Media Codec Type: A2DP_MEDIA_CT_NON_A2DP 159 3, 4, 0, 0, // Vendor ID: LSB first, upper two octets should be 0 160 7, 8, // Codec ID: LSB first 161 9 // Dummy 162 }; 163 164 const uint8_t codec_info_non_a2dp_dummy[AVDT_CODEC_SIZE] = { 165 8, // Length 166 0, // Media Type: AVDT_MEDIA_TYPE_AUDIO 167 0xFF, // Media Codec Type: A2DP_MEDIA_CT_NON_A2DP 168 3, 4, 0, 0, // Vendor ID: LSB first, upper two octets should be 0 169 7, 8, // Codec ID: LSB first 170 10 // Dummy 171 }; 172 173 static const char* APTX_ENCODER_LIB_NAME = "libaptX_encoder.so"; 174 static const char* APTX_HD_ENCODER_LIB_NAME = "libaptXHD_encoder.so"; 175 static const char* LDAC_ENCODER_LIB_NAME = "libldacBT_enc.so"; 176 has_shared_library(const char * name)177 static bool has_shared_library(const char* name) { 178 void* lib_handle = dlopen(name, RTLD_NOW); 179 if (lib_handle != nullptr) { 180 dlclose(lib_handle); 181 return true; 182 } 183 return false; 184 } 185 186 } // namespace 187 188 class StackA2dpTest : public ::testing::Test { 189 protected: StackA2dpTest()190 StackA2dpTest() { 191 // Create the set with all supported codecs 192 for (int i = BTAV_A2DP_CODEC_INDEX_MIN; i < BTAV_A2DP_CODEC_INDEX_MAX; 193 i++) { 194 btav_a2dp_codec_index_t codec_index = 195 static_cast<btav_a2dp_codec_index_t>(i); 196 197 bool supported = false; 198 switch (codec_index) { 199 case BTAV_A2DP_CODEC_INDEX_SOURCE_SBC: 200 supported = true; 201 break; 202 case BTAV_A2DP_CODEC_INDEX_SOURCE_AAC: 203 supported = true; 204 break; 205 case BTAV_A2DP_CODEC_INDEX_SOURCE_APTX: 206 // Codec aptX is supported only if the device has the corresponding 207 // shared library installed. 208 supported = has_shared_library(APTX_ENCODER_LIB_NAME); 209 break; 210 case BTAV_A2DP_CODEC_INDEX_SOURCE_APTX_HD: 211 // Codec aptX-HD is supported only if the device has the corresponding 212 // shared library installed. 213 supported = has_shared_library(APTX_HD_ENCODER_LIB_NAME); 214 break; 215 case BTAV_A2DP_CODEC_INDEX_SOURCE_LDAC: 216 // Codec LDAC is supported only if the device has the corresponding 217 // shared library installed. 218 supported = has_shared_library(LDAC_ENCODER_LIB_NAME); 219 break; 220 case BTAV_A2DP_CODEC_INDEX_SINK_SBC: 221 supported = true; 222 break; 223 case BTAV_A2DP_CODEC_INDEX_SINK_AAC: 224 supported = true; 225 break; 226 case BTAV_A2DP_CODEC_INDEX_MAX: 227 // Needed to avoid using "default:" case so we can capture when 228 // a new codec is added, and it can be included here. 229 break; 230 } 231 232 if (supported) { 233 supported_codecs_.insert(codec_index); 234 } 235 } 236 } 237 has_codec_support(btav_a2dp_codec_index_t codec_index)238 bool has_codec_support(btav_a2dp_codec_index_t codec_index) { 239 return supported_codecs_.find(codec_index) != supported_codecs_.end(); 240 } 241 242 private: 243 std::set<btav_a2dp_codec_index_t> supported_codecs_; 244 }; 245 246 class A2dpCodecConfigTest : public StackA2dpTest {}; 247 TEST_F(StackA2dpTest,test_a2dp_bits_set)248 TEST_F(StackA2dpTest, test_a2dp_bits_set) { 249 EXPECT_TRUE(A2DP_BitsSet(0x0) == A2DP_SET_ZERO_BIT); 250 EXPECT_TRUE(A2DP_BitsSet(0x1) == A2DP_SET_ONE_BIT); 251 EXPECT_TRUE(A2DP_BitsSet(0x2) == A2DP_SET_ONE_BIT); 252 EXPECT_TRUE(A2DP_BitsSet(0x3) == A2DP_SET_MULTL_BIT); 253 EXPECT_TRUE(A2DP_BitsSet(0x7f) == A2DP_SET_MULTL_BIT); 254 EXPECT_TRUE(A2DP_BitsSet(0x80) == A2DP_SET_ONE_BIT); 255 EXPECT_TRUE(A2DP_BitsSet(0x81) == A2DP_SET_MULTL_BIT); 256 EXPECT_TRUE(A2DP_BitsSet(0xc0) == A2DP_SET_MULTL_BIT); 257 EXPECT_TRUE(A2DP_BitsSet(0xff) == A2DP_SET_MULTL_BIT); 258 EXPECT_TRUE(A2DP_BitsSet(0x8000) == A2DP_SET_ONE_BIT); 259 EXPECT_TRUE(A2DP_BitsSet(0x8001) == A2DP_SET_MULTL_BIT); 260 EXPECT_TRUE(A2DP_BitsSet(0xc000) == A2DP_SET_MULTL_BIT); 261 EXPECT_TRUE(A2DP_BitsSet(0xffff) == A2DP_SET_MULTL_BIT); 262 EXPECT_TRUE(A2DP_BitsSet(0x80000) == A2DP_SET_ONE_BIT); 263 EXPECT_TRUE(A2DP_BitsSet(0x80001) == A2DP_SET_MULTL_BIT); 264 EXPECT_TRUE(A2DP_BitsSet(0xc0000) == A2DP_SET_MULTL_BIT); 265 EXPECT_TRUE(A2DP_BitsSet(0xfffff) == A2DP_SET_MULTL_BIT); 266 EXPECT_TRUE(A2DP_BitsSet(0x80000000) == A2DP_SET_ONE_BIT); 267 EXPECT_TRUE(A2DP_BitsSet(0x80000001) == A2DP_SET_MULTL_BIT); 268 EXPECT_TRUE(A2DP_BitsSet(0xc0000000) == A2DP_SET_MULTL_BIT); 269 EXPECT_TRUE(A2DP_BitsSet(0xffffffff) == A2DP_SET_MULTL_BIT); 270 EXPECT_TRUE(A2DP_BitsSet(0x8000000000000000) == A2DP_SET_ONE_BIT); 271 EXPECT_TRUE(A2DP_BitsSet(0x8000000000000001) == A2DP_SET_MULTL_BIT); 272 EXPECT_TRUE(A2DP_BitsSet(0xc000000000000000) == A2DP_SET_MULTL_BIT); 273 EXPECT_TRUE(A2DP_BitsSet(0xffffffffffffffff) == A2DP_SET_MULTL_BIT); 274 } 275 TEST_F(StackA2dpTest,test_a2dp_is_codec_valid_sbc)276 TEST_F(StackA2dpTest, test_a2dp_is_codec_valid_sbc) { 277 EXPECT_TRUE(A2DP_IsSourceCodecValid(codec_info_sbc)); 278 EXPECT_TRUE(A2DP_IsSourceCodecValid(codec_info_sbc_capability)); 279 EXPECT_TRUE(A2DP_IsPeerSourceCodecValid(codec_info_sbc)); 280 EXPECT_TRUE(A2DP_IsPeerSourceCodecValid(codec_info_sbc_capability)); 281 282 EXPECT_TRUE(A2DP_IsSinkCodecValid(codec_info_sbc_sink_capability)); 283 EXPECT_TRUE(A2DP_IsPeerSinkCodecValid(codec_info_sbc_sink_capability)); 284 285 EXPECT_FALSE(A2DP_IsSourceCodecValid(codec_info_non_a2dp)); 286 EXPECT_FALSE(A2DP_IsSinkCodecValid(codec_info_non_a2dp)); 287 EXPECT_FALSE(A2DP_IsPeerSourceCodecValid(codec_info_non_a2dp)); 288 EXPECT_FALSE(A2DP_IsPeerSinkCodecValid(codec_info_non_a2dp)); 289 290 // Test with invalid SBC codecs 291 uint8_t codec_info_sbc_invalid[AVDT_CODEC_SIZE]; 292 memset(codec_info_sbc_invalid, 0, sizeof(codec_info_sbc_invalid)); 293 EXPECT_FALSE(A2DP_IsSourceCodecValid(codec_info_sbc_invalid)); 294 EXPECT_FALSE(A2DP_IsSinkCodecValid(codec_info_sbc_invalid)); 295 EXPECT_FALSE(A2DP_IsPeerSourceCodecValid(codec_info_sbc_invalid)); 296 EXPECT_FALSE(A2DP_IsPeerSinkCodecValid(codec_info_sbc_invalid)); 297 298 memcpy(codec_info_sbc_invalid, codec_info_sbc, sizeof(codec_info_sbc)); 299 codec_info_sbc_invalid[0] = 0; // Corrupt the Length field 300 EXPECT_FALSE(A2DP_IsSourceCodecValid(codec_info_sbc_invalid)); 301 EXPECT_FALSE(A2DP_IsSinkCodecValid(codec_info_sbc_invalid)); 302 EXPECT_FALSE(A2DP_IsPeerSourceCodecValid(codec_info_sbc_invalid)); 303 EXPECT_FALSE(A2DP_IsPeerSinkCodecValid(codec_info_sbc_invalid)); 304 305 memcpy(codec_info_sbc_invalid, codec_info_sbc, sizeof(codec_info_sbc)); 306 codec_info_sbc_invalid[1] = 0xff; // Corrupt the Media Type field 307 EXPECT_FALSE(A2DP_IsSourceCodecValid(codec_info_sbc_invalid)); 308 EXPECT_FALSE(A2DP_IsSinkCodecValid(codec_info_sbc_invalid)); 309 EXPECT_FALSE(A2DP_IsPeerSourceCodecValid(codec_info_sbc_invalid)); 310 EXPECT_FALSE(A2DP_IsPeerSinkCodecValid(codec_info_sbc_invalid)); 311 } 312 TEST_F(StackA2dpTest,test_a2dp_is_codec_valid_aac)313 TEST_F(StackA2dpTest, test_a2dp_is_codec_valid_aac) { 314 EXPECT_TRUE(A2DP_IsSourceCodecValid(codec_info_aac)); 315 EXPECT_TRUE(A2DP_IsSourceCodecValid(codec_info_aac_capability)); 316 EXPECT_TRUE(A2DP_IsPeerSourceCodecValid(codec_info_aac)); 317 EXPECT_TRUE(A2DP_IsPeerSourceCodecValid(codec_info_aac_capability)); 318 319 EXPECT_TRUE(A2DP_IsSinkCodecValid(codec_info_aac_sink_capability)); 320 EXPECT_TRUE(A2DP_IsPeerSinkCodecValid(codec_info_aac_sink_capability)); 321 322 // Test with invalid AAC codecs 323 uint8_t codec_info_aac_invalid[AVDT_CODEC_SIZE]; 324 memcpy(codec_info_aac_invalid, codec_info_aac, sizeof(codec_info_aac)); 325 codec_info_aac_invalid[0] = 0; // Corrupt the Length field 326 EXPECT_FALSE(A2DP_IsSourceCodecValid(codec_info_aac_invalid)); 327 EXPECT_FALSE(A2DP_IsSinkCodecValid(codec_info_aac_invalid)); 328 EXPECT_FALSE(A2DP_IsPeerSourceCodecValid(codec_info_aac_invalid)); 329 EXPECT_FALSE(A2DP_IsPeerSinkCodecValid(codec_info_aac_invalid)); 330 331 memcpy(codec_info_aac_invalid, codec_info_aac, sizeof(codec_info_aac)); 332 codec_info_aac_invalid[1] = 0xff; // Corrupt the Media Type field 333 EXPECT_FALSE(A2DP_IsSourceCodecValid(codec_info_aac_invalid)); 334 EXPECT_FALSE(A2DP_IsSinkCodecValid(codec_info_aac_invalid)); 335 EXPECT_FALSE(A2DP_IsPeerSourceCodecValid(codec_info_aac_invalid)); 336 EXPECT_FALSE(A2DP_IsPeerSinkCodecValid(codec_info_aac_invalid)); 337 } 338 TEST_F(StackA2dpTest,test_a2dp_get_codec_type)339 TEST_F(StackA2dpTest, test_a2dp_get_codec_type) { 340 tA2DP_CODEC_TYPE codec_type = A2DP_GetCodecType(codec_info_sbc); 341 EXPECT_EQ(codec_type, A2DP_MEDIA_CT_SBC); 342 343 codec_type = A2DP_GetCodecType(codec_info_aac); 344 EXPECT_EQ(codec_type, A2DP_MEDIA_CT_AAC); 345 346 codec_type = A2DP_GetCodecType(codec_info_non_a2dp); 347 EXPECT_EQ(codec_type, A2DP_MEDIA_CT_NON_A2DP); 348 } 349 TEST_F(StackA2dpTest,test_a2dp_is_sink_codec_supported)350 TEST_F(StackA2dpTest, test_a2dp_is_sink_codec_supported) { 351 EXPECT_TRUE(A2DP_IsSinkCodecSupported(codec_info_sbc)); 352 EXPECT_FALSE(A2DP_IsSinkCodecSupported(codec_info_sbc_capability)); 353 EXPECT_FALSE(A2DP_IsSinkCodecSupported(codec_info_sbc_sink_capability)); 354 355 EXPECT_TRUE(A2DP_IsSinkCodecSupported(codec_info_aac)); 356 // NOTE: The test below should be EXPECT_FALSE. 357 // However, codec_info_aac_capability is practically same as codec_info_aac, 358 // therefore we cannot differentiate it as a capability. 359 EXPECT_TRUE(A2DP_IsSinkCodecSupported(codec_info_aac_capability)); 360 EXPECT_FALSE(A2DP_IsSinkCodecSupported(codec_info_aac_sink_capability)); 361 362 EXPECT_FALSE(A2DP_IsSinkCodecSupported(codec_info_non_a2dp)); 363 } 364 TEST_F(StackA2dpTest,test_a2dp_is_peer_source_codec_supported)365 TEST_F(StackA2dpTest, test_a2dp_is_peer_source_codec_supported) { 366 EXPECT_TRUE(A2DP_IsPeerSourceCodecSupported(codec_info_sbc)); 367 EXPECT_TRUE(A2DP_IsPeerSourceCodecSupported(codec_info_sbc_capability)); 368 EXPECT_TRUE(A2DP_IsPeerSourceCodecSupported(codec_info_sbc_sink_capability)); 369 370 EXPECT_TRUE(A2DP_IsPeerSourceCodecSupported(codec_info_aac)); 371 EXPECT_TRUE(A2DP_IsPeerSourceCodecSupported(codec_info_aac_capability)); 372 EXPECT_TRUE(A2DP_IsPeerSourceCodecSupported(codec_info_aac_sink_capability)); 373 374 EXPECT_FALSE(A2DP_IsPeerSourceCodecSupported(codec_info_non_a2dp)); 375 } 376 TEST_F(StackA2dpTest,test_init_default_codec)377 TEST_F(StackA2dpTest, test_init_default_codec) { 378 uint8_t codec_info_result[AVDT_CODEC_SIZE]; 379 380 memset(codec_info_result, 0, sizeof(codec_info_result)); 381 A2DP_InitDefaultCodec(codec_info_result); 382 383 // Compare the result codec with the local test codec info 384 for (size_t i = 0; i < codec_info_sbc[0] + 1; i++) { 385 EXPECT_EQ(codec_info_result[i], codec_info_sbc[i]); 386 } 387 } 388 TEST_F(StackA2dpTest,test_a2dp_uses_rtp_header)389 TEST_F(StackA2dpTest, test_a2dp_uses_rtp_header) { 390 EXPECT_TRUE(A2DP_UsesRtpHeader(true, codec_info_sbc)); 391 EXPECT_TRUE(A2DP_UsesRtpHeader(false, codec_info_sbc)); 392 393 EXPECT_TRUE(A2DP_UsesRtpHeader(true, codec_info_aac)); 394 EXPECT_TRUE(A2DP_UsesRtpHeader(false, codec_info_aac)); 395 396 EXPECT_TRUE(A2DP_UsesRtpHeader(true, codec_info_non_a2dp)); 397 EXPECT_TRUE(A2DP_UsesRtpHeader(false, codec_info_non_a2dp)); 398 } 399 TEST_F(StackA2dpTest,test_a2dp_get_media_type)400 TEST_F(StackA2dpTest, test_a2dp_get_media_type) { 401 uint8_t codec_info_test[AVDT_CODEC_SIZE]; 402 403 EXPECT_EQ(A2DP_GetMediaType(codec_info_sbc), AVDT_MEDIA_TYPE_AUDIO); 404 EXPECT_EQ(A2DP_GetMediaType(codec_info_aac), AVDT_MEDIA_TYPE_AUDIO); 405 EXPECT_EQ(A2DP_GetMediaType(codec_info_non_a2dp), AVDT_MEDIA_TYPE_AUDIO); 406 407 // Prepare dummy codec info for video and for multimedia 408 memset(codec_info_test, 0, sizeof(codec_info_test)); 409 codec_info_test[0] = sizeof(codec_info_test); 410 codec_info_test[1] = 0x01 << 4; 411 EXPECT_EQ(A2DP_GetMediaType(codec_info_test), AVDT_MEDIA_TYPE_VIDEO); 412 codec_info_test[1] = 0x02 << 4; 413 EXPECT_EQ(A2DP_GetMediaType(codec_info_test), AVDT_MEDIA_TYPE_MULTI); 414 } 415 TEST_F(StackA2dpTest,test_a2dp_codec_name)416 TEST_F(StackA2dpTest, test_a2dp_codec_name) { 417 uint8_t codec_info_test[AVDT_CODEC_SIZE]; 418 419 // Explicit tests for known codecs 420 EXPECT_STREQ(A2DP_CodecName(codec_info_sbc), "SBC"); 421 EXPECT_STREQ(A2DP_CodecName(codec_info_sbc_capability), "SBC"); 422 EXPECT_STREQ(A2DP_CodecName(codec_info_sbc_sink_capability), "SBC"); 423 EXPECT_STREQ(A2DP_CodecName(codec_info_aac), "AAC"); 424 EXPECT_STREQ(A2DP_CodecName(codec_info_aac_capability), "AAC"); 425 EXPECT_STREQ(A2DP_CodecName(codec_info_aac_sink_capability), "AAC"); 426 EXPECT_STREQ(A2DP_CodecName(codec_info_non_a2dp), "UNKNOWN VENDOR CODEC"); 427 428 // Test all unknown codecs 429 memcpy(codec_info_test, codec_info_sbc, sizeof(codec_info_sbc)); 430 for (uint8_t codec_type = A2DP_MEDIA_CT_AAC + 1; 431 codec_type < A2DP_MEDIA_CT_NON_A2DP; codec_type++) { 432 codec_info_test[2] = codec_type; // Unknown codec type 433 EXPECT_STREQ(A2DP_CodecName(codec_info_test), "UNKNOWN CODEC"); 434 } 435 } 436 TEST_F(StackA2dpTest,test_a2dp_vendor)437 TEST_F(StackA2dpTest, test_a2dp_vendor) { 438 EXPECT_EQ(A2DP_VendorCodecGetVendorId(codec_info_non_a2dp), 439 (uint32_t)0x00000403); 440 EXPECT_EQ(A2DP_VendorCodecGetCodecId(codec_info_non_a2dp), (uint16_t)0x0807); 441 EXPECT_TRUE(A2DP_VendorUsesRtpHeader(true, codec_info_non_a2dp)); 442 EXPECT_TRUE(A2DP_VendorUsesRtpHeader(false, codec_info_non_a2dp)); 443 } 444 TEST_F(StackA2dpTest,test_a2dp_codec_type_equals)445 TEST_F(StackA2dpTest, test_a2dp_codec_type_equals) { 446 EXPECT_TRUE(A2DP_CodecTypeEquals(codec_info_sbc, codec_info_sbc_capability)); 447 EXPECT_TRUE( 448 A2DP_CodecTypeEquals(codec_info_sbc, codec_info_sbc_sink_capability)); 449 EXPECT_TRUE(A2DP_CodecTypeEquals(codec_info_aac, codec_info_aac_capability)); 450 EXPECT_TRUE( 451 A2DP_CodecTypeEquals(codec_info_aac, codec_info_aac_sink_capability)); 452 EXPECT_TRUE( 453 A2DP_CodecTypeEquals(codec_info_non_a2dp, codec_info_non_a2dp_dummy)); 454 EXPECT_FALSE(A2DP_CodecTypeEquals(codec_info_sbc, codec_info_non_a2dp)); 455 EXPECT_FALSE(A2DP_CodecTypeEquals(codec_info_aac, codec_info_non_a2dp)); 456 EXPECT_FALSE(A2DP_CodecTypeEquals(codec_info_sbc, codec_info_aac)); 457 } 458 TEST_F(StackA2dpTest,test_a2dp_codec_equals)459 TEST_F(StackA2dpTest, test_a2dp_codec_equals) { 460 uint8_t codec_info_sbc_test[AVDT_CODEC_SIZE]; 461 uint8_t codec_info_aac_test[AVDT_CODEC_SIZE]; 462 uint8_t codec_info_non_a2dp_test[AVDT_CODEC_SIZE]; 463 464 // Test two identical SBC codecs 465 memset(codec_info_sbc_test, 0xAB, sizeof(codec_info_sbc_test)); 466 memcpy(codec_info_sbc_test, codec_info_sbc, sizeof(codec_info_sbc)); 467 EXPECT_TRUE(A2DP_CodecEquals(codec_info_sbc, codec_info_sbc_test)); 468 469 // Test two identical AAC codecs 470 memset(codec_info_aac_test, 0xAB, sizeof(codec_info_aac_test)); 471 memcpy(codec_info_aac_test, codec_info_aac, sizeof(codec_info_aac)); 472 EXPECT_TRUE(A2DP_CodecEquals(codec_info_aac, codec_info_aac_test)); 473 474 // Test two identical non-A2DP codecs that are not recognized 475 memset(codec_info_non_a2dp_test, 0xAB, sizeof(codec_info_non_a2dp_test)); 476 memcpy(codec_info_non_a2dp_test, codec_info_non_a2dp, 477 sizeof(codec_info_non_a2dp)); 478 EXPECT_FALSE(A2DP_CodecEquals(codec_info_non_a2dp, codec_info_non_a2dp_test)); 479 480 // Test two codecs that have different types 481 EXPECT_FALSE(A2DP_CodecEquals(codec_info_sbc, codec_info_non_a2dp)); 482 EXPECT_FALSE(A2DP_CodecEquals(codec_info_sbc, codec_info_aac)); 483 484 // Test two SBC codecs that are slightly different 485 memset(codec_info_sbc_test, 0xAB, sizeof(codec_info_sbc_test)); 486 memcpy(codec_info_sbc_test, codec_info_sbc, sizeof(codec_info_sbc)); 487 codec_info_sbc_test[5] = codec_info_sbc[5] + 1; 488 EXPECT_FALSE(A2DP_CodecEquals(codec_info_sbc, codec_info_sbc_test)); 489 codec_info_sbc_test[5] = codec_info_sbc[5]; 490 codec_info_sbc_test[6] = codec_info_sbc[6] + 1; 491 EXPECT_FALSE(A2DP_CodecEquals(codec_info_sbc, codec_info_sbc_test)); 492 493 // Test two AAC codecs that are slightly different 494 memset(codec_info_aac_test, 0xAB, sizeof(codec_info_aac_test)); 495 memcpy(codec_info_aac_test, codec_info_aac, sizeof(codec_info_aac)); 496 codec_info_aac_test[7] = codec_info_aac[7] + 1; 497 EXPECT_FALSE(A2DP_CodecEquals(codec_info_aac, codec_info_aac_test)); 498 codec_info_aac_test[7] = codec_info_aac[7]; 499 codec_info_aac_test[8] = codec_info_aac[8] + 1; 500 EXPECT_FALSE(A2DP_CodecEquals(codec_info_aac, codec_info_aac_test)); 501 502 // Test two SBC codecs that are identical, but with different dummy 503 // trailer data. 504 memset(codec_info_sbc_test, 0xAB, sizeof(codec_info_sbc_test)); 505 memcpy(codec_info_sbc_test, codec_info_sbc, sizeof(codec_info_sbc)); 506 codec_info_sbc_test[7] = codec_info_sbc[7] + 1; 507 EXPECT_TRUE(A2DP_CodecEquals(codec_info_sbc, codec_info_sbc_test)); 508 509 // Test two AAC codecs that are identical, but with different dummy 510 // trailer data. 511 memset(codec_info_aac_test, 0xAB, sizeof(codec_info_aac_test)); 512 memcpy(codec_info_aac_test, codec_info_aac, sizeof(codec_info_aac)); 513 codec_info_aac_test[9] = codec_info_aac[9] + 1; 514 EXPECT_TRUE(A2DP_CodecEquals(codec_info_aac, codec_info_aac_test)); 515 } 516 TEST_F(StackA2dpTest,test_a2dp_get_track_sample_rate)517 TEST_F(StackA2dpTest, test_a2dp_get_track_sample_rate) { 518 EXPECT_EQ(A2DP_GetTrackSampleRate(codec_info_sbc), 44100); 519 EXPECT_EQ(A2DP_GetTrackSampleRate(codec_info_aac), 44100); 520 EXPECT_EQ(A2DP_GetTrackSampleRate(codec_info_non_a2dp), -1); 521 } 522 TEST_F(StackA2dpTest,test_a2dp_get_track_channel_count)523 TEST_F(StackA2dpTest, test_a2dp_get_track_channel_count) { 524 EXPECT_EQ(A2DP_GetTrackChannelCount(codec_info_sbc), 2); 525 EXPECT_EQ(A2DP_GetTrackChannelCount(codec_info_aac), 2); 526 EXPECT_EQ(A2DP_GetTrackChannelCount(codec_info_non_a2dp), -1); 527 } 528 TEST_F(StackA2dpTest,test_a2dp_get_number_of_subbands_sbc)529 TEST_F(StackA2dpTest, test_a2dp_get_number_of_subbands_sbc) { 530 EXPECT_EQ(A2DP_GetNumberOfSubbandsSbc(codec_info_sbc), 8); 531 EXPECT_EQ(A2DP_GetNumberOfSubbandsSbc(codec_info_aac), -1); 532 EXPECT_EQ(A2DP_GetNumberOfSubbandsSbc(codec_info_non_a2dp), -1); 533 } 534 TEST_F(StackA2dpTest,test_a2dp_get_number_of_blocks_sbc)535 TEST_F(StackA2dpTest, test_a2dp_get_number_of_blocks_sbc) { 536 EXPECT_EQ(A2DP_GetNumberOfBlocksSbc(codec_info_sbc), 16); 537 EXPECT_EQ(A2DP_GetNumberOfBlocksSbc(codec_info_aac), -1); 538 EXPECT_EQ(A2DP_GetNumberOfBlocksSbc(codec_info_non_a2dp), -1); 539 } 540 TEST_F(StackA2dpTest,test_a2dp_get_allocation_method_code_sbc)541 TEST_F(StackA2dpTest, test_a2dp_get_allocation_method_code_sbc) { 542 EXPECT_EQ(A2DP_GetAllocationMethodCodeSbc(codec_info_sbc), 0); 543 EXPECT_EQ(A2DP_GetAllocationMethodCodeSbc(codec_info_aac), -1); 544 EXPECT_EQ(A2DP_GetAllocationMethodCodeSbc(codec_info_non_a2dp), -1); 545 } 546 TEST_F(StackA2dpTest,test_a2dp_get_channel_mode_code_sbc)547 TEST_F(StackA2dpTest, test_a2dp_get_channel_mode_code_sbc) { 548 EXPECT_EQ(A2DP_GetChannelModeCodeSbc(codec_info_sbc), 3); 549 EXPECT_EQ(A2DP_GetChannelModeCodeSbc(codec_info_aac), -1); 550 EXPECT_EQ(A2DP_GetChannelModeCodeSbc(codec_info_non_a2dp), -1); 551 } 552 TEST_F(StackA2dpTest,test_a2dp_get_sampling_frequency_code_sbc)553 TEST_F(StackA2dpTest, test_a2dp_get_sampling_frequency_code_sbc) { 554 EXPECT_EQ(A2DP_GetSamplingFrequencyCodeSbc(codec_info_sbc), 2); 555 EXPECT_EQ(A2DP_GetSamplingFrequencyCodeSbc(codec_info_aac), -1); 556 EXPECT_EQ(A2DP_GetSamplingFrequencyCodeSbc(codec_info_non_a2dp), -1); 557 } 558 TEST_F(StackA2dpTest,test_a2dp_get_min_bitpool_sbc)559 TEST_F(StackA2dpTest, test_a2dp_get_min_bitpool_sbc) { 560 EXPECT_EQ(A2DP_GetMinBitpoolSbc(codec_info_sbc), 2); 561 EXPECT_EQ(A2DP_GetMinBitpoolSbc(codec_info_sbc_capability), 2); 562 EXPECT_EQ(A2DP_GetMinBitpoolSbc(codec_info_sbc_sink_capability), 2); 563 EXPECT_EQ(A2DP_GetMinBitpoolSbc(codec_info_aac), -1); 564 EXPECT_EQ(A2DP_GetMinBitpoolSbc(codec_info_non_a2dp), -1); 565 } 566 TEST_F(StackA2dpTest,test_a2dp_get_max_bitpool_sbc)567 TEST_F(StackA2dpTest, test_a2dp_get_max_bitpool_sbc) { 568 EXPECT_EQ(A2DP_GetMaxBitpoolSbc(codec_info_sbc), 53); 569 EXPECT_EQ(A2DP_GetMaxBitpoolSbc(codec_info_sbc_capability), 53); 570 EXPECT_EQ(A2DP_GetMaxBitpoolSbc(codec_info_sbc_sink_capability), 53); 571 EXPECT_EQ(A2DP_GetMaxBitpoolSbc(codec_info_aac), -1); 572 EXPECT_EQ(A2DP_GetMaxBitpoolSbc(codec_info_non_a2dp), -1); 573 } 574 TEST_F(StackA2dpTest,test_a2dp_get_sink_track_channel_type)575 TEST_F(StackA2dpTest, test_a2dp_get_sink_track_channel_type) { 576 EXPECT_EQ(A2DP_GetSinkTrackChannelType(codec_info_sbc), 3); 577 EXPECT_EQ(A2DP_GetSinkTrackChannelType(codec_info_aac), 3); 578 EXPECT_EQ(A2DP_GetSinkTrackChannelType(codec_info_non_a2dp), -1); 579 } 580 TEST_F(StackA2dpTest,test_a2dp_get_object_type_code_aac)581 TEST_F(StackA2dpTest, test_a2dp_get_object_type_code_aac) { 582 EXPECT_EQ(A2DP_GetObjectTypeCodeAac(codec_info_sbc), -1); 583 EXPECT_EQ(A2DP_GetObjectTypeCodeAac(codec_info_aac), 0x80); 584 EXPECT_EQ(A2DP_GetObjectTypeCodeAac(codec_info_non_a2dp), -1); 585 } 586 TEST_F(StackA2dpTest,test_a2dp_get_channel_mode_code_aac)587 TEST_F(StackA2dpTest, test_a2dp_get_channel_mode_code_aac) { 588 EXPECT_EQ(A2DP_GetChannelModeCodeAac(codec_info_sbc), -1); 589 EXPECT_EQ(A2DP_GetChannelModeCodeAac(codec_info_aac), 0x04); 590 EXPECT_EQ(A2DP_GetChannelModeCodeAac(codec_info_non_a2dp), -1); 591 } 592 TEST_F(StackA2dpTest,test_a2dp_get_variable_bit_rate_support_aac)593 TEST_F(StackA2dpTest, test_a2dp_get_variable_bit_rate_support_aac) { 594 EXPECT_EQ(A2DP_GetVariableBitRateSupportAac(codec_info_sbc), -1); 595 EXPECT_EQ(A2DP_GetVariableBitRateSupportAac(codec_info_aac), 0); 596 EXPECT_EQ(A2DP_GetVariableBitRateSupportAac(codec_info_non_a2dp), -1); 597 } 598 TEST_F(StackA2dpTest,test_a2dp_get_bit_rate_aac)599 TEST_F(StackA2dpTest, test_a2dp_get_bit_rate_aac) { 600 EXPECT_EQ(A2DP_GetBitRateAac(codec_info_sbc), -1); 601 EXPECT_EQ(A2DP_GetBitRateAac(codec_info_aac), 320000); 602 EXPECT_EQ(A2DP_GetBitRateAac(codec_info_non_a2dp), -1); 603 } 604 TEST_F(StackA2dpTest,test_a2dp_get_packet_timestamp)605 TEST_F(StackA2dpTest, test_a2dp_get_packet_timestamp) { 606 uint8_t a2dp_data[1000]; 607 uint32_t timestamp; 608 uint32_t* p_ts = reinterpret_cast<uint32_t*>(a2dp_data); 609 610 memset(a2dp_data, 0xAB, sizeof(a2dp_data)); 611 *p_ts = 0x12345678; 612 timestamp = 0xFFFFFFFF; 613 EXPECT_TRUE(A2DP_GetPacketTimestamp(codec_info_sbc, a2dp_data, ×tamp)); 614 EXPECT_EQ(timestamp, static_cast<uint32_t>(0x12345678)); 615 616 memset(a2dp_data, 0xAB, sizeof(a2dp_data)); 617 *p_ts = 0x12345678; 618 timestamp = 0xFFFFFFFF; 619 EXPECT_TRUE(A2DP_GetPacketTimestamp(codec_info_aac, a2dp_data, ×tamp)); 620 EXPECT_EQ(timestamp, static_cast<uint32_t>(0x12345678)); 621 622 memset(a2dp_data, 0xAB, sizeof(a2dp_data)); 623 *p_ts = 0x12345678; 624 timestamp = 0xFFFFFFFF; 625 EXPECT_FALSE( 626 A2DP_GetPacketTimestamp(codec_info_non_a2dp, a2dp_data, ×tamp)); 627 } 628 TEST_F(StackA2dpTest,test_a2dp_build_codec_header)629 TEST_F(StackA2dpTest, test_a2dp_build_codec_header) { 630 uint8_t a2dp_data[1000]; 631 BT_HDR* p_buf = reinterpret_cast<BT_HDR*>(a2dp_data); 632 const uint16_t BT_HDR_LEN = 500; 633 const uint16_t BT_HDR_OFFSET = 50; 634 const uint8_t FRAMES_PER_PACKET = 0xCD; 635 636 memset(a2dp_data, 0xAB, sizeof(a2dp_data)); 637 p_buf->len = BT_HDR_LEN; 638 p_buf->offset = BT_HDR_OFFSET; 639 EXPECT_TRUE(A2DP_BuildCodecHeader(codec_info_sbc, p_buf, FRAMES_PER_PACKET)); 640 EXPECT_EQ(p_buf->offset + 1, 641 BT_HDR_OFFSET); // Modified by A2DP_SBC_MPL_HDR_LEN 642 EXPECT_EQ(p_buf->len - 1, BT_HDR_LEN); // Modified by A2DP_SBC_MPL_HDR_LEN 643 const uint8_t* p = 644 reinterpret_cast<const uint8_t*>(p_buf + 1) + p_buf->offset; 645 EXPECT_EQ( 646 *p, static_cast<uint8_t>(0x0D)); // 0xCD masked with A2DP_SBC_HDR_NUM_MSK 647 648 memset(a2dp_data, 0xAB, sizeof(a2dp_data)); 649 p_buf->len = BT_HDR_LEN; 650 p_buf->offset = BT_HDR_OFFSET; 651 EXPECT_TRUE(A2DP_BuildCodecHeader(codec_info_aac, p_buf, FRAMES_PER_PACKET)); 652 653 memset(a2dp_data, 0xAB, sizeof(a2dp_data)); 654 p_buf->len = BT_HDR_LEN; 655 p_buf->offset = BT_HDR_OFFSET; 656 EXPECT_FALSE( 657 A2DP_BuildCodecHeader(codec_info_non_a2dp, p_buf, FRAMES_PER_PACKET)); 658 } 659 TEST_F(StackA2dpTest,test_a2dp_adjust_codec)660 TEST_F(StackA2dpTest, test_a2dp_adjust_codec) { 661 uint8_t codec_info_sbc_test[AVDT_CODEC_SIZE]; 662 uint8_t codec_info_aac_test[AVDT_CODEC_SIZE]; 663 uint8_t codec_info_non_a2dp_test[AVDT_CODEC_SIZE]; 664 665 // Test updating a valid SBC codec that doesn't need adjustment 666 memset(codec_info_sbc_test, 0xAB, sizeof(codec_info_sbc_test)); 667 memcpy(codec_info_sbc_test, codec_info_sbc, sizeof(codec_info_sbc)); 668 EXPECT_TRUE(A2DP_AdjustCodec(codec_info_sbc_test)); 669 EXPECT_TRUE( 670 memcmp(codec_info_sbc_test, codec_info_sbc, sizeof(codec_info_sbc)) == 0); 671 672 // Test updating a valid SBC codec that needs adjustment 673 memset(codec_info_sbc_test, 0xAB, sizeof(codec_info_sbc_test)); 674 memcpy(codec_info_sbc_test, codec_info_sbc, sizeof(codec_info_sbc)); 675 codec_info_sbc_test[6] = 54; // A2DP_SBC_MAX_BITPOOL + 1 676 EXPECT_TRUE(A2DP_AdjustCodec(codec_info_sbc_test)); 677 EXPECT_TRUE( 678 memcmp(codec_info_sbc_test, codec_info_sbc, sizeof(codec_info_sbc)) == 0); 679 680 // Test updating an invalid SBC codec 681 memset(codec_info_sbc_test, 0xAB, sizeof(codec_info_sbc_test)); 682 memcpy(codec_info_sbc_test, codec_info_sbc, sizeof(codec_info_sbc)); 683 codec_info_sbc_test[6] = 255; // Invalid MAX_BITPOOL 684 EXPECT_FALSE(A2DP_AdjustCodec(codec_info_sbc_test)); 685 686 // Test updating a valid AAC codec that doesn't need adjustment 687 memset(codec_info_aac_test, 0xAB, sizeof(codec_info_aac_test)); 688 memcpy(codec_info_aac_test, codec_info_aac, sizeof(codec_info_aac)); 689 EXPECT_TRUE(A2DP_AdjustCodec(codec_info_aac_test)); 690 EXPECT_TRUE( 691 memcmp(codec_info_aac_test, codec_info_aac, sizeof(codec_info_aac)) == 0); 692 693 // Test updating a non-A2DP codec that is not recognized 694 memset(codec_info_non_a2dp_test, 0xAB, sizeof(codec_info_non_a2dp_test)); 695 memcpy(codec_info_non_a2dp_test, codec_info_non_a2dp, 696 sizeof(codec_info_non_a2dp)); 697 EXPECT_FALSE(A2DP_AdjustCodec(codec_info_non_a2dp_test)); 698 } 699 TEST_F(StackA2dpTest,test_a2dp_source_codec_index)700 TEST_F(StackA2dpTest, test_a2dp_source_codec_index) { 701 // Explicit tests for known Source codecs 702 EXPECT_EQ(A2DP_SourceCodecIndex(codec_info_sbc), 703 BTAV_A2DP_CODEC_INDEX_SOURCE_SBC); 704 EXPECT_EQ(A2DP_SourceCodecIndex(codec_info_sbc_capability), 705 BTAV_A2DP_CODEC_INDEX_SOURCE_SBC); 706 EXPECT_EQ(A2DP_SourceCodecIndex(codec_info_sbc_sink_capability), 707 BTAV_A2DP_CODEC_INDEX_SOURCE_SBC); 708 EXPECT_EQ(A2DP_SourceCodecIndex(codec_info_aac), 709 BTAV_A2DP_CODEC_INDEX_SOURCE_AAC); 710 EXPECT_EQ(A2DP_SourceCodecIndex(codec_info_aac_capability), 711 BTAV_A2DP_CODEC_INDEX_SOURCE_AAC); 712 EXPECT_EQ(A2DP_SourceCodecIndex(codec_info_aac_sink_capability), 713 BTAV_A2DP_CODEC_INDEX_SOURCE_AAC); 714 EXPECT_EQ(A2DP_SourceCodecIndex(codec_info_non_a2dp), 715 BTAV_A2DP_CODEC_INDEX_MAX); 716 } 717 TEST_F(StackA2dpTest,test_a2dp_sink_codec_index)718 TEST_F(StackA2dpTest, test_a2dp_sink_codec_index) { 719 // Explicit tests for known Sink codecs 720 EXPECT_EQ(A2DP_SinkCodecIndex(codec_info_sbc), 721 BTAV_A2DP_CODEC_INDEX_SINK_SBC); 722 EXPECT_EQ(A2DP_SinkCodecIndex(codec_info_sbc_capability), 723 BTAV_A2DP_CODEC_INDEX_SINK_SBC); 724 EXPECT_EQ(A2DP_SinkCodecIndex(codec_info_sbc_sink_capability), 725 BTAV_A2DP_CODEC_INDEX_SINK_SBC); 726 EXPECT_EQ(A2DP_SinkCodecIndex(codec_info_aac), 727 BTAV_A2DP_CODEC_INDEX_SINK_AAC); 728 EXPECT_EQ(A2DP_SinkCodecIndex(codec_info_aac_capability), 729 BTAV_A2DP_CODEC_INDEX_SINK_AAC); 730 EXPECT_EQ(A2DP_SinkCodecIndex(codec_info_aac_sink_capability), 731 BTAV_A2DP_CODEC_INDEX_SINK_AAC); 732 EXPECT_EQ(A2DP_SinkCodecIndex(codec_info_non_a2dp), 733 BTAV_A2DP_CODEC_INDEX_MAX); 734 } 735 TEST_F(StackA2dpTest,test_a2dp_codec_index_str)736 TEST_F(StackA2dpTest, test_a2dp_codec_index_str) { 737 // Explicit tests for known codecs 738 EXPECT_STREQ(A2DP_CodecIndexStr(BTAV_A2DP_CODEC_INDEX_SOURCE_SBC), "SBC"); 739 EXPECT_STREQ(A2DP_CodecIndexStr(BTAV_A2DP_CODEC_INDEX_SINK_SBC), "SBC SINK"); 740 EXPECT_STREQ(A2DP_CodecIndexStr(BTAV_A2DP_CODEC_INDEX_SOURCE_AAC), "AAC"); 741 742 // Test that the unknown codec string has not changed 743 EXPECT_STREQ(A2DP_CodecIndexStr(BTAV_A2DP_CODEC_INDEX_MAX), 744 "UNKNOWN CODEC INDEX"); 745 746 // Test that each codec has a known string 747 for (int i = BTAV_A2DP_CODEC_INDEX_MIN; i < BTAV_A2DP_CODEC_INDEX_MAX; i++) { 748 btav_a2dp_codec_index_t codec_index = 749 static_cast<btav_a2dp_codec_index_t>(i); 750 EXPECT_STRNE(A2DP_CodecIndexStr(codec_index), "UNKNOWN CODEC INDEX"); 751 } 752 } 753 TEST_F(StackA2dpTest,test_a2dp_init_codec_config)754 TEST_F(StackA2dpTest, test_a2dp_init_codec_config) { 755 AvdtpSepConfig avdt_cfg; 756 757 // 758 // Test for SBC Source 759 // 760 memset(&avdt_cfg, 0, sizeof(avdt_cfg)); 761 EXPECT_TRUE( 762 A2DP_InitCodecConfig(BTAV_A2DP_CODEC_INDEX_SOURCE_SBC, &avdt_cfg)); 763 // Compare the result codec with the local test codec info 764 for (size_t i = 0; i < codec_info_sbc_capability[0] + 1; i++) { 765 EXPECT_EQ(avdt_cfg.codec_info[i], codec_info_sbc_capability[i]); 766 } 767 // Test for content protection 768 #if (BTA_AV_CO_CP_SCMS_T == TRUE) 769 EXPECT_EQ(avdt_cfg.protect_info[0], AVDT_CP_LOSC); 770 EXPECT_EQ(avdt_cfg.protect_info[1], (AVDT_CP_SCMS_T_ID & 0xFF)); 771 EXPECT_EQ(avdt_cfg.protect_info[2], ((AVDT_CP_SCMS_T_ID >> 8) & 0xFF)); 772 EXPECT_EQ(avdt_cfg.num_protect, 1); 773 #endif 774 775 // 776 // Test for SBC Sink 777 // 778 memset(&avdt_cfg, 0, sizeof(avdt_cfg)); 779 EXPECT_TRUE(A2DP_InitCodecConfig(BTAV_A2DP_CODEC_INDEX_SINK_SBC, &avdt_cfg)); 780 // Compare the result codec with the local test codec info 781 for (size_t i = 0; i < codec_info_sbc_sink_capability[0] + 1; i++) { 782 EXPECT_EQ(avdt_cfg.codec_info[i], codec_info_sbc_sink_capability[i]); 783 } 784 785 // 786 // Test for AAC Source 787 // 788 memset(&avdt_cfg, 0, sizeof(avdt_cfg)); 789 EXPECT_TRUE( 790 A2DP_InitCodecConfig(BTAV_A2DP_CODEC_INDEX_SOURCE_AAC, &avdt_cfg)); 791 // Compare the result codec with the local test codec info 792 for (size_t i = 0; i < codec_info_aac_capability[0] + 1; i++) { 793 EXPECT_EQ(avdt_cfg.codec_info[i], codec_info_aac_capability[i]); 794 } 795 // Test for content protection 796 #if (BTA_AV_CO_CP_SCMS_T == TRUE) 797 EXPECT_EQ(avdt_cfg.protect_info[0], AVDT_CP_LOSC); 798 EXPECT_EQ(avdt_cfg.protect_info[1], (AVDT_CP_SCMS_T_ID & 0xFF)); 799 EXPECT_EQ(avdt_cfg.protect_info[2], ((AVDT_CP_SCMS_T_ID >> 8) & 0xFF)); 800 EXPECT_EQ(avdt_cfg.num_protect, 1); 801 #endif 802 } 803 TEST_F(A2dpCodecConfigTest,createCodec)804 TEST_F(A2dpCodecConfigTest, createCodec) { 805 for (int i = BTAV_A2DP_CODEC_INDEX_MIN; i < BTAV_A2DP_CODEC_INDEX_MAX; i++) { 806 btav_a2dp_codec_index_t codec_index = 807 static_cast<btav_a2dp_codec_index_t>(i); 808 809 // Ignore codecs that are not supported on the device 810 if (!has_codec_support(codec_index)) { 811 continue; 812 } 813 814 A2dpCodecConfig* codec_config = A2dpCodecConfig::createCodec(codec_index); 815 EXPECT_NE(codec_config, nullptr); 816 EXPECT_EQ(codec_config->codecIndex(), codec_index); 817 EXPECT_FALSE(codec_config->name().empty()); 818 EXPECT_NE(codec_config->codecPriority(), BTAV_A2DP_CODEC_PRIORITY_DISABLED); 819 EXPECT_NE(codec_config->codecPriority(), BTAV_A2DP_CODEC_PRIORITY_DEFAULT); 820 delete codec_config; 821 } 822 } 823 TEST_F(A2dpCodecConfigTest,setCodecConfig)824 TEST_F(A2dpCodecConfigTest, setCodecConfig) { 825 uint8_t codec_info_result[AVDT_CODEC_SIZE]; 826 btav_a2dp_codec_index_t peer_codec_index; 827 A2dpCodecs* a2dp_codecs = 828 new A2dpCodecs(std::vector<btav_a2dp_codec_config_t>()); 829 A2dpCodecConfig* codec_config; 830 831 EXPECT_TRUE(a2dp_codecs->init()); 832 833 // Create the codec capability - SBC 834 memset(codec_info_result, 0, sizeof(codec_info_result)); 835 peer_codec_index = A2DP_SourceCodecIndex(codec_info_sbc_sink_capability); 836 EXPECT_NE(peer_codec_index, BTAV_A2DP_CODEC_INDEX_MAX); 837 codec_config = 838 a2dp_codecs->findSourceCodecConfig(codec_info_sbc_sink_capability); 839 EXPECT_NE(codec_config, nullptr); 840 EXPECT_TRUE(a2dp_codecs->setCodecConfig( 841 codec_info_sbc_sink_capability, true /* is_capability */, 842 codec_info_result, true /* select_current_codec */)); 843 EXPECT_EQ(a2dp_codecs->getCurrentCodecConfig(), codec_config); 844 // Compare the result codec with the local test codec info 845 for (size_t i = 0; i < codec_info_sbc[0] + 1; i++) { 846 EXPECT_EQ(codec_info_result[i], codec_info_sbc[i]); 847 } 848 EXPECT_EQ(codec_config->getAudioBitsPerSample(), 16); 849 850 // Create the codec capability - AAC 851 memset(codec_info_result, 0, sizeof(codec_info_result)); 852 peer_codec_index = A2DP_SourceCodecIndex(codec_info_aac_sink_capability); 853 EXPECT_NE(peer_codec_index, BTAV_A2DP_CODEC_INDEX_MAX); 854 codec_config = 855 a2dp_codecs->findSourceCodecConfig(codec_info_aac_sink_capability); 856 EXPECT_NE(codec_config, nullptr); 857 EXPECT_TRUE(a2dp_codecs->setCodecConfig( 858 codec_info_aac_sink_capability, true /* is_capability */, 859 codec_info_result, true /* select_current_codec */)); 860 EXPECT_EQ(a2dp_codecs->getCurrentCodecConfig(), codec_config); 861 // Compare the result codec with the local test codec info 862 for (size_t i = 0; i < codec_info_aac[0] + 1; i++) { 863 EXPECT_EQ(codec_info_result[i], codec_info_aac[i]); 864 } 865 EXPECT_EQ(codec_config->getAudioBitsPerSample(), 16); 866 867 // Create the codec config - SBC 868 memset(codec_info_result, 0, sizeof(codec_info_result)); 869 peer_codec_index = A2DP_SourceCodecIndex(codec_info_sbc); 870 EXPECT_NE(peer_codec_index, BTAV_A2DP_CODEC_INDEX_MAX); 871 codec_config = a2dp_codecs->findSourceCodecConfig(codec_info_sbc); 872 EXPECT_NE(codec_config, nullptr); 873 EXPECT_TRUE(a2dp_codecs->setCodecConfig( 874 codec_info_sbc, false /* is_capability */, codec_info_result, 875 true /* select_current_codec */)); 876 EXPECT_EQ(a2dp_codecs->getCurrentCodecConfig(), codec_config); 877 // Compare the result codec with the local test codec info 878 for (size_t i = 0; i < codec_info_sbc[0] + 1; i++) { 879 EXPECT_EQ(codec_info_result[i], codec_info_sbc[i]); 880 } 881 EXPECT_FALSE(codec_config->useRtpHeaderMarkerBit()); 882 883 // Create the codec config - AAC 884 memset(codec_info_result, 0, sizeof(codec_info_result)); 885 peer_codec_index = A2DP_SourceCodecIndex(codec_info_aac); 886 EXPECT_NE(peer_codec_index, BTAV_A2DP_CODEC_INDEX_MAX); 887 codec_config = a2dp_codecs->findSourceCodecConfig(codec_info_aac); 888 EXPECT_NE(codec_config, nullptr); 889 EXPECT_TRUE(a2dp_codecs->setCodecConfig( 890 codec_info_aac, false /* is_capability */, codec_info_result, 891 true /* select_current_codec */)); 892 EXPECT_EQ(a2dp_codecs->getCurrentCodecConfig(), codec_config); 893 // Compare the result codec with the local test codec info 894 for (size_t i = 0; i < codec_info_aac[0] + 1; i++) { 895 EXPECT_EQ(codec_info_result[i], codec_info_aac[i]); 896 } 897 EXPECT_TRUE(codec_config->useRtpHeaderMarkerBit()); 898 899 // Create the codec capability - SBC Sink 900 memset(codec_info_result, 0, sizeof(codec_info_result)); 901 peer_codec_index = A2DP_SinkCodecIndex(codec_info_sbc_capability); 902 EXPECT_NE(peer_codec_index, BTAV_A2DP_CODEC_INDEX_MAX); 903 codec_config = a2dp_codecs->findSinkCodecConfig(codec_info_sbc_capability); 904 EXPECT_NE(codec_config, nullptr); 905 EXPECT_TRUE(a2dp_codecs->setSinkCodecConfig( 906 codec_info_sbc_capability, true /* is_capability */, codec_info_result, 907 true /* select_current_codec */)); 908 EXPECT_EQ(a2dp_codecs->getCurrentCodecConfig(), codec_config); 909 // Compare the result codec with the local test codec info 910 for (size_t i = 0; i < codec_info_sbc[0] + 1; i++) { 911 EXPECT_EQ(codec_info_result[i], codec_info_sbc[i]); 912 } 913 EXPECT_EQ(codec_config->getAudioBitsPerSample(), 16); 914 915 // Create the codec capability - AAC Sink 916 memset(codec_info_result, 0, sizeof(codec_info_result)); 917 peer_codec_index = A2DP_SinkCodecIndex(codec_info_aac_capability); 918 EXPECT_NE(peer_codec_index, BTAV_A2DP_CODEC_INDEX_MAX); 919 codec_config = a2dp_codecs->findSinkCodecConfig(codec_info_aac_capability); 920 EXPECT_NE(codec_config, nullptr); 921 EXPECT_TRUE(a2dp_codecs->setSinkCodecConfig( 922 codec_info_aac_capability, true /* is_capability */, codec_info_result, 923 true /* select_current_codec */)); 924 EXPECT_EQ(a2dp_codecs->getCurrentCodecConfig(), codec_config); 925 // Compare the result codec with the local test codec info 926 for (size_t i = 0; i < codec_info_aac[0] + 1; i++) { 927 EXPECT_EQ(codec_info_result[i], codec_info_aac[i]); 928 } 929 EXPECT_EQ(codec_config->getAudioBitsPerSample(), 16); 930 931 // Create the codec config - SBC Sink 932 memset(codec_info_result, 0, sizeof(codec_info_result)); 933 peer_codec_index = A2DP_SinkCodecIndex(codec_info_sbc); 934 EXPECT_NE(peer_codec_index, BTAV_A2DP_CODEC_INDEX_MAX); 935 codec_config = a2dp_codecs->findSinkCodecConfig(codec_info_sbc); 936 EXPECT_NE(codec_config, nullptr); 937 EXPECT_TRUE(a2dp_codecs->setSinkCodecConfig( 938 codec_info_sbc, false /* is_capability */, codec_info_result, 939 true /* select_current_codec */)); 940 EXPECT_EQ(a2dp_codecs->getCurrentCodecConfig(), codec_config); 941 // Compare the result codec with the local test codec info 942 for (size_t i = 0; i < codec_info_sbc[0] + 1; i++) { 943 EXPECT_EQ(codec_info_result[i], codec_info_sbc[i]); 944 } 945 EXPECT_EQ(codec_config->getAudioBitsPerSample(), 16); 946 947 // Create the codec config - AAC Sink 948 memset(codec_info_result, 0, sizeof(codec_info_result)); 949 peer_codec_index = A2DP_SinkCodecIndex(codec_info_aac); 950 EXPECT_NE(peer_codec_index, BTAV_A2DP_CODEC_INDEX_MAX); 951 codec_config = a2dp_codecs->findSinkCodecConfig(codec_info_aac); 952 EXPECT_NE(codec_config, nullptr); 953 EXPECT_TRUE(a2dp_codecs->setSinkCodecConfig( 954 codec_info_aac, false /* is_capability */, codec_info_result, 955 true /* select_current_codec */)); 956 EXPECT_EQ(a2dp_codecs->getCurrentCodecConfig(), codec_config); 957 // Compare the result codec with the local test codec info 958 for (size_t i = 0; i < codec_info_aac[0] + 1; i++) { 959 EXPECT_EQ(codec_info_result[i], codec_info_aac[i]); 960 } 961 EXPECT_EQ(codec_config->getAudioBitsPerSample(), 16); 962 963 // Test invalid codec info 964 uint8_t codec_info_sbc_test1[AVDT_CODEC_SIZE]; 965 memset(codec_info_result, 0, sizeof(codec_info_result)); 966 memset(codec_info_sbc_test1, 0, sizeof(codec_info_sbc_test1)); 967 EXPECT_FALSE(a2dp_codecs->setCodecConfig( 968 codec_info_sbc_test1, true /* is_capability */, codec_info_result, 969 true /* select_current_codec */)); 970 delete a2dp_codecs; 971 } 972 TEST_F(A2dpCodecConfigTest,init)973 TEST_F(A2dpCodecConfigTest, init) { 974 std::vector<btav_a2dp_codec_config_t> default_priorities; 975 A2dpCodecs codecs(default_priorities); 976 977 EXPECT_TRUE(codecs.init()); 978 979 const std::list<A2dpCodecConfig*> orderedSourceCodecs = 980 codecs.orderedSourceCodecs(); 981 EXPECT_FALSE(orderedSourceCodecs.empty()); 982 983 const std::list<A2dpCodecConfig*> orderedSinkCodecs = 984 codecs.orderedSinkCodecs(); 985 EXPECT_FALSE(orderedSinkCodecs.empty()); 986 } 987