You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
172 lines
7.1 KiB
172 lines
7.1 KiB
/*
|
|
* 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>
|
|
|
|
// =============================================================================
|
|
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;
|
|
}
|
|
// =============================================================================
|
|
#include "bt_types.h"
|
|
#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_
|