1 /*
2 * Copyright (C) 2024 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 //#define LOG_NDEBUG 0
18 #define LOG_TAG "CodecCapabilitiesTest"
19
20 #include <utils/Log.h>
21
22 #include <memory>
23
24 #include <gtest/gtest.h>
25
26 #include <binder/Parcel.h>
27
28 #include <media/CodecCapabilities.h>
29 #include <media/CodecCapabilitiesUtils.h>
30 #include <media/MediaCodecInfo.h>
31
32 #include <media/stagefright/MediaCodecConstants.h>
33 #include <media/stagefright/MediaCodecList.h>
34 #include <media/stagefright/foundation/ABuffer.h>
35 #include <media/stagefright/foundation/AString.h>
36
37 using namespace android;
38
39 class AudioCapsAacTest : public testing::Test {
40 protected:
AudioCapsAacTest()41 AudioCapsAacTest() {
42 std::string mediaType = MIMETYPE_AUDIO_AAC;
43
44 sp<AMessage> details = new AMessage;
45 details->setString("bitrate-range", "8000-960000");
46 details->setString("max-channel-count", "8");
47 details->setString("sample-rate-ranges",
48 "7350,8000,11025,12000,16000,22050,24000,32000,44100,48000");
49
50 std::vector<ProfileLevel> profileLevel{
51 ProfileLevel(2, 0),
52 ProfileLevel(5, 0),
53 ProfileLevel(29, 0),
54 ProfileLevel(23, 0),
55 ProfileLevel(39, 0),
56 ProfileLevel(20, 0),
57 ProfileLevel(42, 0),
58 };
59
60 audioCaps = AudioCapabilities::Create(mediaType, profileLevel, details);
61 }
62
63 std::shared_ptr<AudioCapabilities> audioCaps;
64 };
65
TEST_F(AudioCapsAacTest,AudioCaps_Aac_Bitrate)66 TEST_F(AudioCapsAacTest, AudioCaps_Aac_Bitrate) {
67 const Range<int32_t>& bitrateRange = audioCaps->getBitrateRange();
68 EXPECT_EQ(bitrateRange.lower(), 8000) << "bitrate range1 does not match. lower: "
69 << bitrateRange.lower();
70 EXPECT_EQ(bitrateRange.upper(), 510000) << "bitrate range1 does not match. upper: "
71 << bitrateRange.upper();
72 }
73
TEST_F(AudioCapsAacTest,AudioCaps_Aac_InputChannelCount)74 TEST_F(AudioCapsAacTest, AudioCaps_Aac_InputChannelCount) {
75 int32_t maxInputChannelCount = audioCaps->getMaxInputChannelCount();
76 EXPECT_EQ(maxInputChannelCount, 8);
77 int32_t minInputChannelCount = audioCaps->getMinInputChannelCount();
78 EXPECT_EQ(minInputChannelCount, 1);
79 }
80
TEST_F(AudioCapsAacTest,AudioCaps_Aac_SupportedSampleRates)81 TEST_F(AudioCapsAacTest, AudioCaps_Aac_SupportedSampleRates) {
82 const std::vector<int32_t>& sampleRates = audioCaps->getSupportedSampleRates();
83 EXPECT_EQ(sampleRates, std::vector<int32_t>({7350, 8000, 11025, 12000, 16000, 22050,
84 24000, 32000, 44100, 48000}));
85
86 EXPECT_FALSE(audioCaps->isSampleRateSupported(6000))
87 << "isSampleRateSupported returned true for unsupported sample rate";
88 EXPECT_TRUE(audioCaps->isSampleRateSupported(8000))
89 << "isSampleRateSupported returned false for supported sample rate";
90 EXPECT_TRUE(audioCaps->isSampleRateSupported(12000))
91 << "isSampleRateSupported returned false for supported sample rate";
92 EXPECT_FALSE(audioCaps->isSampleRateSupported(44000))
93 << "isSampleRateSupported returned true for unsupported sample rate";
94 EXPECT_TRUE(audioCaps->isSampleRateSupported(48000))
95 << "isSampleRateSupported returned true for unsupported sample rate";
96 }
97
98 class AudioCapsRawTest : public testing::Test {
99 protected:
AudioCapsRawTest()100 AudioCapsRawTest() {
101 std::string mediaType = MIMETYPE_AUDIO_RAW;
102
103 sp<AMessage> details = new AMessage;
104 details->setString("bitrate-range", "1-10000000");
105 details->setString("channel-ranges", "1,2,3,4,5,6,7,8,9,10,11,12");
106 details->setString("sample-rate-ranges", "8000-192000");
107
108 std::vector<ProfileLevel> profileLevel;
109
110 audioCaps = AudioCapabilities::Create(mediaType, profileLevel, details);
111 }
112
113 std::shared_ptr<AudioCapabilities> audioCaps;
114 };
115
TEST_F(AudioCapsRawTest,AudioCaps_Raw_Bitrate)116 TEST_F(AudioCapsRawTest, AudioCaps_Raw_Bitrate) {
117 const Range<int32_t>& bitrateRange = audioCaps->getBitrateRange();
118 EXPECT_EQ(bitrateRange.lower(), 1);
119 EXPECT_EQ(bitrateRange.upper(), 10000000);
120 }
121
TEST_F(AudioCapsRawTest,AudioCaps_Raw_InputChannelCount)122 TEST_F(AudioCapsRawTest, AudioCaps_Raw_InputChannelCount) {
123 int32_t maxInputChannelCount = audioCaps->getMaxInputChannelCount();
124 EXPECT_EQ(maxInputChannelCount, 12);
125 int32_t minInputChannelCount = audioCaps->getMinInputChannelCount();
126 EXPECT_EQ(minInputChannelCount, 1);
127 }
128
TEST_F(AudioCapsRawTest,AudioCaps_Raw_InputChannelCountRanges)129 TEST_F(AudioCapsRawTest, AudioCaps_Raw_InputChannelCountRanges) {
130 const std::vector<Range<int32_t>>& inputChannelCountRanges
131 = audioCaps->getInputChannelCountRanges();
132 std::vector<Range<int32_t>> expectedOutput({{1,1}, {2,2}, {3,3}, {4,4}, {5,5},
133 {6,6}, {7,7}, {8,8}, {9,9}, {10,10}, {11,11}, {12,12}});
134 ASSERT_EQ(inputChannelCountRanges.size(), expectedOutput.size());
135 for (int i = 0; i < inputChannelCountRanges.size(); i++) {
136 EXPECT_EQ(inputChannelCountRanges.at(i).lower(), expectedOutput.at(i).lower());
137 EXPECT_EQ(inputChannelCountRanges.at(i).upper(), expectedOutput.at(i).upper());
138 }
139 }
140
TEST_F(AudioCapsRawTest,AudioCaps_Raw_SupportedSampleRates)141 TEST_F(AudioCapsRawTest, AudioCaps_Raw_SupportedSampleRates) {
142 const std::vector<Range<int32_t>>& sampleRateRanges = audioCaps->getSupportedSampleRateRanges();
143 EXPECT_EQ(sampleRateRanges.size(), 1);
144 EXPECT_EQ(sampleRateRanges.at(0).lower(), 8000);
145 EXPECT_EQ(sampleRateRanges.at(0).upper(), 192000);
146
147 EXPECT_EQ(audioCaps->isSampleRateSupported(7000), false);
148 EXPECT_EQ(audioCaps->isSampleRateSupported(10000), true);
149 EXPECT_EQ(audioCaps->isSampleRateSupported(193000), false);
150 }
151
152 class VideoCapsHevcTest : public testing::Test {
153 protected:
VideoCapsHevcTest()154 VideoCapsHevcTest() {
155 std::string mediaType = MIMETYPE_VIDEO_HEVC;
156
157 sp<AMessage> details = new AMessage;
158 details->setString("alignment", "2x2");
159 details->setString("bitrate-range", "1-120000000");
160 details->setString("block-count-range", "1-32640");
161 details->setString("block-size", "16x16");
162 details->setString("blocks-per-second-range", "1-3916800");
163 details->setInt32("feature-adaptive-playback", 0);
164 details->setInt32("feature-can-swap-width-height", 1);
165 details->setString("max-concurrent-instances", "16");
166 details->setString("measured-frame-rate-1280x720-range", "547-553");
167 details->setString("measured-frame-rate-1920x1080-range", "569-572");
168 details->setString("measured-frame-rate-352x288-range", "1150-1250");
169 details->setString("measured-frame-rate-3840x2160-range", "159-159");
170 details->setString("measured-frame-rate-640x360-range", "528-529");
171 details->setString("measured-frame-rate-720x480-range", "546-548");
172 details->setString("performance-point-1280x720-range", "240");
173 details->setString("performance-point-3840x2160-range", "120");
174 details->setString("size-range", "64x64-3840x2176");
175
176 std::vector<ProfileLevel> profileLevel{
177 ProfileLevel(1, 8388608),
178 ProfileLevel(2, 8388608),
179 ProfileLevel(4096, 8388608),
180 ProfileLevel(8192, 8388608),
181 };
182
183 videoCaps = VideoCapabilities::Create(mediaType, profileLevel, details);
184 }
185
186 std::shared_ptr<VideoCapabilities> videoCaps;
187 };
188
TEST_F(VideoCapsHevcTest,VideoCaps_HEVC_Alignment)189 TEST_F(VideoCapsHevcTest, VideoCaps_HEVC_Alignment) {
190 int32_t widthAlignment = videoCaps->getWidthAlignment();
191 EXPECT_EQ(widthAlignment, 2);
192 int32_t heightAlignment = videoCaps->getHeightAlignment();
193 EXPECT_EQ(heightAlignment, 2);
194 }
195
TEST_F(VideoCapsHevcTest,VideoCaps_HEVC_BitrateRange)196 TEST_F(VideoCapsHevcTest, VideoCaps_HEVC_BitrateRange) {
197 const Range<int32_t>& bitrateRange = videoCaps->getBitrateRange();
198 EXPECT_EQ(bitrateRange.lower(), 1);
199 EXPECT_EQ(bitrateRange.upper(), 120000000);
200 }
201
TEST_F(VideoCapsHevcTest,VideoCaps_HEVC_SupportedWidthsAndHeights)202 TEST_F(VideoCapsHevcTest, VideoCaps_HEVC_SupportedWidthsAndHeights) {
203 const Range<int32_t>& supportedWidths = videoCaps->getSupportedWidths();
204 EXPECT_EQ(supportedWidths.upper(), 3840);
205 const Range<int32_t>& supportedHeights = videoCaps->getSupportedHeights();
206 EXPECT_EQ(supportedHeights.upper(), 3840);
207 }
208
TEST_F(VideoCapsHevcTest,VideoCaps_HEVC_SupportedFrameRates)209 TEST_F(VideoCapsHevcTest, VideoCaps_HEVC_SupportedFrameRates) {
210 const Range<int32_t>& supportedFrameRates = videoCaps->getSupportedFrameRates();
211 EXPECT_EQ(supportedFrameRates.lower(), 0);
212 EXPECT_EQ(supportedFrameRates.upper(), 960);
213
214 std::optional<Range<double>> supportedFR720p = videoCaps->getSupportedFrameRatesFor(1280, 720);
215 EXPECT_EQ(supportedFR720p.value().upper(), 960.0);
216 std::optional<Range<double>> supportedFR1080p
217 = videoCaps->getSupportedFrameRatesFor(1920, 1080);
218 EXPECT_EQ(supportedFR1080p.value().upper(), 480.0);
219 std::optional<Range<double>> supportedFR4k = videoCaps->getSupportedFrameRatesFor(3840, 2160);
220 EXPECT_EQ(std::round(supportedFR4k.value().upper()), 121);
221 }
222
TEST_F(VideoCapsHevcTest,VideoCaps_HEVC_AchievableFrameRates)223 TEST_F(VideoCapsHevcTest, VideoCaps_HEVC_AchievableFrameRates) {
224 std::optional<Range<double>> achievableFR1080p
225 = videoCaps->getAchievableFrameRatesFor(1920, 1080);
226 ASSERT_NE(achievableFR1080p, std::nullopt) << "resolution not supported";
227 EXPECT_EQ(achievableFR1080p.value().lower(), 569);
228 EXPECT_EQ(achievableFR1080p.value().upper(), 572);
229 }
230
231 class EncoderCapsAacTest : public testing::Test {
232 protected:
EncoderCapsAacTest()233 EncoderCapsAacTest() {
234 std::string mediaType = MIMETYPE_AUDIO_AAC;
235
236 sp<AMessage> details = new AMessage;
237 details->setString("bitrate-range", "8000-960000");
238 details->setString("max-channel-count", "6");
239 details->setString("sample-rate-ranges",
240 "8000,11025,12000,16000,22050,24000,32000,44100,48000");
241
242 std::vector<ProfileLevel> profileLevel{
243 ProfileLevel(2, 0),
244 ProfileLevel(5, 0),
245 ProfileLevel(29, 0),
246 ProfileLevel(23, 0),
247 ProfileLevel(39, 0),
248 };
249
250 encoderCaps = EncoderCapabilities::Create(mediaType, profileLevel, details);
251 }
252
253 std::shared_ptr<EncoderCapabilities> encoderCaps;
254 };
255
256
TEST_F(EncoderCapsAacTest,EncoderCaps_AAC_ComplexityRange)257 TEST_F(EncoderCapsAacTest, EncoderCaps_AAC_ComplexityRange) {
258 const Range<int>& complexityRange = encoderCaps->getComplexityRange();
259 EXPECT_EQ(complexityRange.lower(), 0);
260 EXPECT_EQ(complexityRange.upper(), 0);
261 }
262
TEST_F(EncoderCapsAacTest,EncoderCaps_AAC_QualityRange)263 TEST_F(EncoderCapsAacTest, EncoderCaps_AAC_QualityRange) {
264 const Range<int>& qualityRange = encoderCaps->getQualityRange();
265 EXPECT_EQ(qualityRange.lower(), 0);
266 EXPECT_EQ(qualityRange.upper(), 0);
267 }
268
TEST_F(EncoderCapsAacTest,EncoderCaps_AAC_SupportedBitrateMode)269 TEST_F(EncoderCapsAacTest, EncoderCaps_AAC_SupportedBitrateMode) {
270 EXPECT_FALSE(encoderCaps->isBitrateModeSupported(BITRATE_MODE_CBR));
271 EXPECT_TRUE(encoderCaps->isBitrateModeSupported(BITRATE_MODE_VBR));
272 EXPECT_FALSE(encoderCaps->isBitrateModeSupported(BITRATE_MODE_CQ));
273 EXPECT_FALSE(encoderCaps->isBitrateModeSupported(BITRATE_MODE_CBR_FD));
274 }
275
276 class EncoderCapsFlacTest : public testing::Test {
277 protected:
EncoderCapsFlacTest()278 EncoderCapsFlacTest() {
279 std::string mediaType = MIMETYPE_AUDIO_FLAC;
280
281 sp<AMessage> details = new AMessage;
282 details->setString("bitrate-range", "1-21000000");
283 details->setString("complexity-default", "5");
284 details->setString("complexity-range", "0-8");
285 details->setString("feature-bitrate-modes", "CQ");
286 details->setString("max-channel-count", "2");
287 details->setString("sample-rate-ranges", "1-655350");
288
289 std::vector<ProfileLevel> profileLevel;
290
291 encoderCaps = EncoderCapabilities::Create(mediaType, profileLevel, details);
292 }
293
294 std::shared_ptr<EncoderCapabilities> encoderCaps;
295 };
296
TEST_F(EncoderCapsFlacTest,EncoderCaps_FLAC_ComplexityRange)297 TEST_F(EncoderCapsFlacTest, EncoderCaps_FLAC_ComplexityRange) {
298 const Range<int>& complexityRange = encoderCaps->getComplexityRange();
299 EXPECT_EQ(complexityRange.lower(), 0);
300 EXPECT_EQ(complexityRange.upper(), 8);
301 }
302
TEST_F(EncoderCapsFlacTest,EncoderCaps_FLAC_QualityRange)303 TEST_F(EncoderCapsFlacTest, EncoderCaps_FLAC_QualityRange) {
304 const Range<int>& qualityRange = encoderCaps->getQualityRange();
305 EXPECT_EQ(qualityRange.lower(), 0);
306 EXPECT_EQ(qualityRange.upper(), 0);
307 }
308
TEST_F(EncoderCapsFlacTest,EncoderCaps_FLAC_SupportedBitrateMode)309 TEST_F(EncoderCapsFlacTest, EncoderCaps_FLAC_SupportedBitrateMode) {
310 EXPECT_FALSE(encoderCaps->isBitrateModeSupported(BITRATE_MODE_CBR));
311 EXPECT_FALSE(encoderCaps->isBitrateModeSupported(BITRATE_MODE_VBR));
312 EXPECT_TRUE(encoderCaps->isBitrateModeSupported(BITRATE_MODE_CQ));
313 EXPECT_FALSE(encoderCaps->isBitrateModeSupported(BITRATE_MODE_CBR_FD));
314 }
315
316 class EncoderCapsHevcTest : public testing::Test {
317 protected:
EncoderCapsHevcTest()318 EncoderCapsHevcTest() {
319 std::string mediaType = MIMETYPE_VIDEO_HEVC;
320
321 sp<AMessage> details = new AMessage;
322 details->setString("alignment", "2x2");
323 details->setString("bitrate-range", "1-120000000");
324 details->setString("block-count-range", "1-8160");
325 details->setString("block-size", "32x32");
326 details->setString("blocks-per-second-range", "1-979200");
327 details->setString("feature-bitrate-modes", "VBR,CBR,CQ,CBR-FD");
328 details->setInt32("feature-can-swap-width-height", 1);
329 details->setInt32("feature-qp-bounds", 0);
330 details->setInt32("feature-vq-minimum-quality", 0);
331 details->setString("max-concurrent-instances", "16");
332 details->setString("measured-frame-rate-1280x720-range", "154-198");
333 details->setString("measured-frame-rate-1920x1080-range", "46-97");
334 details->setString("measured-frame-rate-320x240-range", "371-553");
335 details->setString("measured-frame-rate-720x480-range", "214-305");
336 details->setString("performance-point-1280x720-range", "240");
337 details->setString("performance-point-3840x2160-range", "120");
338 details->setString("quality-default", "57");
339 details->setString("quality-range", "0-100");
340 details->setString("quality-scale", "linear");
341 details->setString("size-range", "64x64-3840x2176");
342
343 std::vector<ProfileLevel> profileLevel{
344 ProfileLevel(1, 2097152),
345 ProfileLevel(2, 2097152),
346 ProfileLevel(4096, 2097152),
347 ProfileLevel(8192, 2097152),
348 };
349
350 encoderCaps = EncoderCapabilities::Create(mediaType, profileLevel, details);
351 }
352
353 std::shared_ptr<EncoderCapabilities> encoderCaps;
354 };
355
TEST_F(EncoderCapsHevcTest,EncoderCaps_HEVC_ComplexityRange)356 TEST_F(EncoderCapsHevcTest, EncoderCaps_HEVC_ComplexityRange) {
357 const Range<int>& complexityRange = encoderCaps->getComplexityRange();
358 EXPECT_EQ(complexityRange.lower(), 0);
359 EXPECT_EQ(complexityRange.upper(), 0);
360 }
361
TEST_F(EncoderCapsHevcTest,EncoderCaps_HEVC_QualityRange)362 TEST_F(EncoderCapsHevcTest, EncoderCaps_HEVC_QualityRange) {
363 const Range<int>& qualityRange = encoderCaps->getQualityRange();
364 EXPECT_EQ(qualityRange.lower(), 0);
365 EXPECT_EQ(qualityRange.upper(), 100);
366 }
367
TEST_F(EncoderCapsHevcTest,EncoderCaps_HEVC_SupportedBitrateMode)368 TEST_F(EncoderCapsHevcTest, EncoderCaps_HEVC_SupportedBitrateMode) {
369 EXPECT_TRUE(encoderCaps->isBitrateModeSupported(BITRATE_MODE_CBR));
370 EXPECT_TRUE(encoderCaps->isBitrateModeSupported(BITRATE_MODE_VBR));
371 EXPECT_TRUE(encoderCaps->isBitrateModeSupported(BITRATE_MODE_CQ));
372 EXPECT_TRUE(encoderCaps->isBitrateModeSupported(BITRATE_MODE_CBR_FD));
373 }
374