1 /*
2 * Copyright (C) 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 #include <media/AudioValidator.h>
18 #include <cmath>
19
20 namespace android {
21
22 /** returns true if string is overflow */
23 template <size_t size>
checkStringOverflow(const char (& s)[size])24 bool checkStringOverflow(const char (&s)[size]) {
25 return strnlen(s, size) >= size;
26 }
27
safetyNetLog(status_t status,std::string_view bugNumber)28 status_t safetyNetLog(status_t status, std::string_view bugNumber) {
29 if (status != NO_ERROR && !bugNumber.empty()) {
30 android_errorWriteLog(0x534e4554, bugNumber.data()); // SafetyNet logging
31 }
32 return status;
33 }
34
validateAudioAttributes(const audio_attributes_t & attr,std::string_view bugNumber)35 status_t AudioValidator::validateAudioAttributes(
36 const audio_attributes_t& attr, std::string_view bugNumber)
37 {
38 status_t status = NO_ERROR;
39 const size_t tagsMaxSize = AUDIO_ATTRIBUTES_TAGS_MAX_SIZE;
40 if (strnlen(attr.tags, tagsMaxSize) >= tagsMaxSize) {
41 status = BAD_VALUE;
42 }
43 return safetyNetLog(status, bugNumber);
44 }
45
validateEffectDescriptor(const effect_descriptor_t & desc,std::string_view bugNumber)46 status_t AudioValidator::validateEffectDescriptor(
47 const effect_descriptor_t& desc, std::string_view bugNumber)
48 {
49 status_t status = NO_ERROR;
50 if (checkStringOverflow(desc.name)
51 | /* always */ checkStringOverflow(desc.implementor)) {
52 status = BAD_VALUE;
53 }
54 return safetyNetLog(status, bugNumber);
55 }
56
validateAudioPortConfig(const struct audio_port_config & config,std::string_view bugNumber)57 status_t AudioValidator::validateAudioPortConfig(
58 const struct audio_port_config& config, std::string_view bugNumber)
59 {
60 status_t status = NO_ERROR;
61 if (config.type == AUDIO_PORT_TYPE_DEVICE &&
62 checkStringOverflow(config.ext.device.address)) {
63 status = BAD_VALUE;
64 }
65 return safetyNetLog(status, bugNumber);
66 }
67
68 namespace {
69
70 template <typename T, std::enable_if_t<std::is_same<T, struct audio_port>::value
71 || std::is_same<T, struct audio_port_v7>::value, int> = 0>
validateAudioPortInternal(const T & port,std::string_view bugNumber={})72 static status_t validateAudioPortInternal(const T& port, std::string_view bugNumber = {}) {
73 status_t status = NO_ERROR;
74 if (checkStringOverflow(port.name)) {
75 status = BAD_VALUE;
76 }
77 if (AudioValidator::validateAudioPortConfig(port.active_config) != NO_ERROR) {
78 status = BAD_VALUE;
79 }
80 if (port.type == AUDIO_PORT_TYPE_DEVICE &&
81 checkStringOverflow(port.ext.device.address)) {
82 status = BAD_VALUE;
83 }
84 return safetyNetLog(status, bugNumber);
85 }
86
87 } // namespace
88
validateAudioPort(const struct audio_port & port,std::string_view bugNumber)89 status_t AudioValidator::validateAudioPort(
90 const struct audio_port& port, std::string_view bugNumber)
91 {
92 return validateAudioPortInternal(port, bugNumber);
93 }
94
validateAudioPort(const struct audio_port_v7 & port,std::string_view bugNumber)95 status_t AudioValidator::validateAudioPort(
96 const struct audio_port_v7& port, std::string_view bugNumber)
97 {
98 return validateAudioPortInternal(port, bugNumber);
99 }
100
101 /** returns BAD_VALUE if sanitization was required. */
validateAudioPatch(const struct audio_patch & patch,std::string_view bugNumber)102 status_t AudioValidator::validateAudioPatch(
103 const struct audio_patch& patch, std::string_view bugNumber)
104 {
105 status_t status = NO_ERROR;
106 if (patch.num_sources > AUDIO_PATCH_PORTS_MAX) {
107 status = BAD_VALUE;
108 }
109 if (patch.num_sinks > AUDIO_PATCH_PORTS_MAX) {
110 status = BAD_VALUE;
111 }
112 for (size_t i = 0; i < patch.num_sources; i++) {
113 if (validateAudioPortConfig(patch.sources[i]) != NO_ERROR) {
114 status = BAD_VALUE;
115 }
116 }
117 for (size_t i = 0; i < patch.num_sinks; i++) {
118 if (validateAudioPortConfig(patch.sinks[i]) != NO_ERROR) {
119 status = BAD_VALUE;
120 }
121 }
122 return safetyNetLog(status, bugNumber);
123 }
124
125 /* static */
validateAudioDescriptionMixLevel(float leveldB)126 status_t AudioValidator::validateAudioDescriptionMixLevel(float leveldB)
127 {
128 constexpr float MAX_AUDIO_DESCRIPTION_MIX_LEVEL = 48.f;
129 return std::isnan(leveldB) || leveldB > MAX_AUDIO_DESCRIPTION_MIX_LEVEL ? BAD_VALUE : OK;
130 }
131
132 /* static */
validateDualMonoMode(audio_dual_mono_mode_t dualMonoMode)133 status_t AudioValidator::validateDualMonoMode(audio_dual_mono_mode_t dualMonoMode)
134 {
135 switch (dualMonoMode) {
136 case AUDIO_DUAL_MONO_MODE_OFF:
137 case AUDIO_DUAL_MONO_MODE_LR:
138 case AUDIO_DUAL_MONO_MODE_LL:
139 case AUDIO_DUAL_MONO_MODE_RR:
140 return OK;
141 }
142 return BAD_VALUE;
143 }
144
145 /* static */
validatePlaybackRateFallbackMode(audio_timestretch_fallback_mode_t fallbackMode)146 status_t AudioValidator::validatePlaybackRateFallbackMode(
147 audio_timestretch_fallback_mode_t fallbackMode)
148 {
149 switch (fallbackMode) {
150 case AUDIO_TIMESTRETCH_FALLBACK_CUT_REPEAT:
151 // This is coarse sounding timestretching used for internal debugging,
152 // not intended for general use.
153 break; // warning if not listed.
154 case AUDIO_TIMESTRETCH_FALLBACK_DEFAULT:
155 case AUDIO_TIMESTRETCH_FALLBACK_MUTE:
156 case AUDIO_TIMESTRETCH_FALLBACK_FAIL:
157 return OK;
158 }
159 return BAD_VALUE;
160 }
161
162 /* static */
validatePlaybackRateStretchMode(audio_timestretch_stretch_mode_t stretchMode)163 status_t AudioValidator::validatePlaybackRateStretchMode(
164 audio_timestretch_stretch_mode_t stretchMode)
165 {
166 switch (stretchMode) {
167 case AUDIO_TIMESTRETCH_STRETCH_DEFAULT:
168 case AUDIO_TIMESTRETCH_STRETCH_VOICE:
169 return OK;
170 }
171 return BAD_VALUE;
172 }
173
174 /* static */
validatePlaybackRate(const audio_playback_rate_t & playbackRate)175 status_t AudioValidator::validatePlaybackRate(
176 const audio_playback_rate_t& playbackRate)
177 {
178 if (playbackRate.mSpeed < 0.f || playbackRate.mPitch < 0.f) return BAD_VALUE;
179 return validatePlaybackRateFallbackMode(playbackRate.mFallbackMode) ?:
180 validatePlaybackRateStretchMode(playbackRate.mStretchMode);
181 }
182
183 }; // namespace android
184