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