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