1 /*
2 * Copyright 2020 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #ifndef A2DP_CODEC_HELPERFUNCTIONS_H_
18 #define A2DP_CODEC_HELPERFUNCTIONS_H_
19
20 #include <fuzzer/FuzzedDataProvider.h>
21
22 #include <vector>
23
24 #include "stack/include/bt_hdr.h"
25
26 static const std::vector<btav_a2dp_codec_index_t> CODEC_INDEX_ENUM_VALS = {
27 BTAV_A2DP_CODEC_INDEX_SOURCE_MIN,
28 BTAV_A2DP_CODEC_INDEX_SOURCE_SBC,
29 BTAV_A2DP_CODEC_INDEX_SOURCE_AAC,
30 BTAV_A2DP_CODEC_INDEX_SOURCE_APTX,
31 BTAV_A2DP_CODEC_INDEX_SOURCE_APTX_HD,
32 BTAV_A2DP_CODEC_INDEX_SOURCE_LDAC,
33 BTAV_A2DP_CODEC_INDEX_SOURCE_MAX,
34 BTAV_A2DP_CODEC_INDEX_SINK_MIN,
35 BTAV_A2DP_CODEC_INDEX_SINK_SBC,
36 BTAV_A2DP_CODEC_INDEX_SINK_AAC,
37 BTAV_A2DP_CODEC_INDEX_SINK_LDAC,
38 BTAV_A2DP_CODEC_INDEX_SINK_MAX,
39 BTAV_A2DP_CODEC_INDEX_MIN,
40 BTAV_A2DP_CODEC_INDEX_MAX};
41
42 static const std::vector<btav_a2dp_codec_priority_t> CODEC_PRIORITY_ENUM_VALS = {
43 BTAV_A2DP_CODEC_PRIORITY_DISABLED, BTAV_A2DP_CODEC_PRIORITY_DEFAULT,
44 BTAV_A2DP_CODEC_PRIORITY_HIGHEST};
45
46 static const std::vector<btav_a2dp_codec_sample_rate_t> CODEC_SAMPLERATE_ENUM_VALS = {
47 BTAV_A2DP_CODEC_SAMPLE_RATE_NONE, BTAV_A2DP_CODEC_SAMPLE_RATE_44100,
48 BTAV_A2DP_CODEC_SAMPLE_RATE_48000, BTAV_A2DP_CODEC_SAMPLE_RATE_88200,
49 BTAV_A2DP_CODEC_SAMPLE_RATE_96000, BTAV_A2DP_CODEC_SAMPLE_RATE_176400,
50 BTAV_A2DP_CODEC_SAMPLE_RATE_192000, BTAV_A2DP_CODEC_SAMPLE_RATE_16000,
51 BTAV_A2DP_CODEC_SAMPLE_RATE_24000};
52
53 static const std::vector<btav_a2dp_codec_bits_per_sample_t> CODEC_BPS_ENUM_VALS = {
54 BTAV_A2DP_CODEC_BITS_PER_SAMPLE_NONE, BTAV_A2DP_CODEC_BITS_PER_SAMPLE_16,
55 BTAV_A2DP_CODEC_BITS_PER_SAMPLE_24, BTAV_A2DP_CODEC_BITS_PER_SAMPLE_32};
56
57 static const std::vector<btav_a2dp_codec_channel_mode_t> CODEC_CHANNELMODE_ENUM_VALS = {
58 BTAV_A2DP_CODEC_CHANNEL_MODE_NONE, BTAV_A2DP_CODEC_CHANNEL_MODE_MONO,
59 BTAV_A2DP_CODEC_CHANNEL_MODE_STEREO};
60
61 // Construct a btav_a2dp_codec_index_t object
getArbitraryBtavCodecIndex(FuzzedDataProvider * fdp)62 btav_a2dp_codec_index_t getArbitraryBtavCodecIndex(FuzzedDataProvider* fdp) {
63 return CODEC_INDEX_ENUM_VALS.at(
64 fdp->ConsumeIntegralInRange<size_t>(0, CODEC_INDEX_ENUM_VALS.size() - 1));
65 }
66
67 // Construct a btav_a2dp_codec_priority_t object
getArbitraryBtavCodecPriority(FuzzedDataProvider * fdp)68 btav_a2dp_codec_priority_t getArbitraryBtavCodecPriority(FuzzedDataProvider* fdp) {
69 return CODEC_PRIORITY_ENUM_VALS.at(
70 fdp->ConsumeIntegralInRange<size_t>(0, CODEC_PRIORITY_ENUM_VALS.size() - 1));
71 }
72 // Construct a btav_a2dp_codec_sample_rate_t object
getArbitraryBtavCodecSampleRate(FuzzedDataProvider * fdp)73 btav_a2dp_codec_sample_rate_t getArbitraryBtavCodecSampleRate(FuzzedDataProvider* fdp) {
74 return CODEC_SAMPLERATE_ENUM_VALS.at(
75 fdp->ConsumeIntegralInRange<size_t>(0, CODEC_SAMPLERATE_ENUM_VALS.size() - 1));
76 }
77 // Construct a btav_a2dp_codec_bits_per_sample_t object
getArbitraryBtavCodecBitsPerSample(FuzzedDataProvider * fdp)78 btav_a2dp_codec_bits_per_sample_t getArbitraryBtavCodecBitsPerSample(FuzzedDataProvider* fdp) {
79 return CODEC_BPS_ENUM_VALS.at(
80 fdp->ConsumeIntegralInRange<size_t>(0, CODEC_BPS_ENUM_VALS.size() - 1));
81 }
82 // Construct a btav_a2dp_codec_channel_mode_t object
getArbitraryBtavCodecChannelMode(FuzzedDataProvider * fdp)83 btav_a2dp_codec_channel_mode_t getArbitraryBtavCodecChannelMode(FuzzedDataProvider* fdp) {
84 return CODEC_CHANNELMODE_ENUM_VALS.at(
85 fdp->ConsumeIntegralInRange<size_t>(0, CODEC_CHANNELMODE_ENUM_VALS.size() - 1));
86 }
87 // Construct a btav_a2dp_codec_config_t object
getArbitraryBtavCodecConfig(FuzzedDataProvider * fdp)88 btav_a2dp_codec_config_t getArbitraryBtavCodecConfig(FuzzedDataProvider* fdp) {
89 btav_a2dp_codec_config_t config;
90
91 config.codec_type = getArbitraryBtavCodecIndex(fdp);
92 config.codec_priority = getArbitraryBtavCodecPriority(fdp);
93 config.sample_rate = getArbitraryBtavCodecSampleRate(fdp);
94 config.bits_per_sample = getArbitraryBtavCodecBitsPerSample(fdp);
95 config.channel_mode = getArbitraryBtavCodecChannelMode(fdp);
96 config.codec_specific_1 = fdp->ConsumeIntegral<int64_t>();
97 config.codec_specific_2 = fdp->ConsumeIntegral<int64_t>();
98 config.codec_specific_3 = fdp->ConsumeIntegral<int64_t>();
99 config.codec_specific_4 = fdp->ConsumeIntegral<int64_t>();
100
101 return config;
102 }
103
getArbitraryA2dpEncoderInitPeerParams(FuzzedDataProvider * fdp)104 tA2DP_ENCODER_INIT_PEER_PARAMS getArbitraryA2dpEncoderInitPeerParams(FuzzedDataProvider* fdp) {
105 tA2DP_ENCODER_INIT_PEER_PARAMS params;
106
107 params.is_peer_edr = fdp->ConsumeBool();
108 params.peer_supports_3mbps = fdp->ConsumeBool();
109 params.peer_mtu = fdp->ConsumeIntegral<uint16_t>();
110
111 return params;
112 }
113
114 #define MAX_BTHDR_SIZE 1024
getArbitraryBtHdr(FuzzedDataProvider * fdp)115 std::shared_ptr<BT_HDR> getArbitraryBtHdr(FuzzedDataProvider* fdp) {
116 // Build a data buffer
117 size_t buf_size = fdp->ConsumeIntegralInRange<size_t>(0, MAX_BTHDR_SIZE);
118 std::vector<uint8_t> bytes = fdp->ConsumeBytes<uint8_t>(buf_size);
119
120 if (bytes.empty()) {
121 return nullptr;
122 }
123
124 uint16_t hdr_size = bytes.size() + sizeof(BT_HDR);
125 std::shared_ptr<BT_HDR> bt_hdr(reinterpret_cast<BT_HDR*>(calloc(1, hdr_size)), free);
126
127 bt_hdr->event = fdp->ConsumeIntegral<uint16_t>();
128 bt_hdr->len = bytes.size();
129 bt_hdr->offset = fdp->ConsumeIntegralInRange<uint16_t>(0, hdr_size - sizeof(BT_HDR));
130 bt_hdr->layer_specific = fdp->ConsumeIntegral<uint16_t>();
131 std::copy(bytes.begin(), bytes.end(), bt_hdr->data);
132
133 return bt_hdr;
134 }
135
136 #include "bta/av/bta_av_int.h"
generateArbitrarytA2dpOffload(FuzzedDataProvider * fdp)137 tBT_A2DP_OFFLOAD generateArbitrarytA2dpOffload(FuzzedDataProvider* fdp) {
138 tBT_A2DP_OFFLOAD retval;
139
140 retval.codec_type = fdp->ConsumeIntegral<uint32_t>();
141 retval.max_latency = fdp->ConsumeIntegral<uint16_t>();
142 std::vector<uint8_t> scms_t_enable = fdp->ConsumeBytes<uint8_t>(2);
143 memcpy(&retval.scms_t_enable[0], scms_t_enable.data(), scms_t_enable.size());
144 retval.sample_rate = fdp->ConsumeIntegral<uint32_t>();
145 retval.bits_per_sample = fdp->ConsumeIntegral<uint8_t>();
146 retval.ch_mode = fdp->ConsumeIntegral<uint8_t>();
147 retval.encoded_audio_bitrate = fdp->ConsumeIntegral<uint32_t>();
148 retval.acl_hdl = fdp->ConsumeIntegral<uint16_t>();
149 retval.l2c_rcid = fdp->ConsumeIntegral<uint16_t>();
150 retval.mtu = fdp->ConsumeIntegral<uint16_t>();
151
152 std::vector<uint8_t> codec_info_bytes = fdp->ConsumeBytes<uint8_t>(32);
153 memcpy(&retval.codec_info[0], codec_info_bytes.data(), codec_info_bytes.size());
154
155 return retval;
156 }
157
158 #endif // A2DP_CODEC_HELPERFUNCTIONS_H_
159