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