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