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