blob: ed05240b6eddceba1683e61eb6a199ab753d8fbf [file] [log] [blame]
// Copyright 2018 The Cobalt Authors. All Rights Reserved.
//
// 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.
#include <cmath>
#include <random>
#include <vector>
#include "starboard/media.h"
#include "starboard/memory.h"
#include "starboard/nplb/performance_helpers.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace starboard {
namespace nplb {
namespace {
constexpr int kVideoResolutions[][2] = {
{kSbMediaVideoResolutionDimensionInvalid,
kSbMediaVideoResolutionDimensionInvalid},
{640, 480},
{1280, 720},
{1920, 1080},
{2560, 1440},
{3840, 2160},
};
constexpr int kBitsPerPixelValues[] = {
kSbMediaBitsPerPixelInvalid, 8, 10, 12,
};
constexpr SbMediaVideoCodec kVideoCodecs[] = {
kSbMediaVideoCodecNone,
kSbMediaVideoCodecH264, kSbMediaVideoCodecH265, kSbMediaVideoCodecMpeg2,
kSbMediaVideoCodecTheora, kSbMediaVideoCodecVc1, kSbMediaVideoCodecAv1,
kSbMediaVideoCodecVp8, kSbMediaVideoCodecVp9,
};
constexpr SbMediaType kMediaTypes[] = {
kSbMediaTypeAudio, kSbMediaTypeVideo,
};
// Minimum audio and video budgets required by the 2020 Youtube Software
// Requirements.
constexpr int kMinAudioBudget = 5 * 1024 * 1024;
constexpr int kMinVideoBudget = 30 * 1024 * 1024;
std::vector<void*> TryToAllocateMemory(int size,
int allocation_unit,
int alignment) {
int total_allocated = 0;
std::vector<void*> allocated_ptrs;
if (allocation_unit != 0) {
allocated_ptrs.reserve(std::ceil(size / allocation_unit));
}
while (total_allocated < size) {
// When |allocation_unit| == 0, randomly allocate a size between 100k -
// 500k.
int allocation_increment = allocation_unit != 0
? allocation_unit
: (std::rand() % 500 + 100) * 1024;
void* allocated_memory =
SbMemoryAllocateAligned(alignment, allocation_increment);
EXPECT_NE(allocated_memory, nullptr);
if (!allocated_memory) {
return allocated_ptrs;
}
allocated_ptrs.push_back(allocated_memory);
total_allocated += allocation_increment;
}
return allocated_ptrs;
}
} // namespace
TEST(SbMediaBufferTest, VideoCodecs) {
// Perform a check to determine if new codecs have been added to the
// enum, but not the array. If the compiler warns about a missing case here,
// the value must be added to the array and the switch case.
SbMediaVideoCodec codec = kVideoCodecs[0];
switch (codec) {
case kVideoCodecs[0]:
case kVideoCodecs[1]:
case kVideoCodecs[2]:
case kVideoCodecs[3]:
case kVideoCodecs[4]:
case kVideoCodecs[5]:
case kVideoCodecs[6]:
case kVideoCodecs[7]:
case kVideoCodecs[8]:
break;
}
}
TEST(SbMediaBufferTest, MediaTypes) {
// Perform a check to determine if new types have been added to the
// enum, but not the array. If the compiler warns about a missing case here,
// the value must be added to the array and the switch case.
SbMediaType type = kMediaTypes[0];
switch (type) {
case kMediaTypes[0]:
case kMediaTypes[1]:
break;
}
}
TEST(SbMediaBufferTest, Alignment) {
for (auto type : kMediaTypes) {
#if SB_API_VERSION >= 14
// The test will be run more than once, it's redundant but allows us to keep
// the test logic in one place.
int alignment = SbMediaGetBufferAlignment();
#else // SB_API_VERSION >= 14
int alignment = SbMediaGetBufferAlignment(type);
#endif // SB_API_VERSION >= 14
EXPECT_GE(alignment, 1);
EXPECT_EQ(alignment & (alignment - 1), 0)
<< "Alignment must always be a power of 2";
}
}
TEST(SbMediaBufferTest, AllocationUnit) {
EXPECT_GE(SbMediaGetBufferAllocationUnit(), 0);
if (SbMediaGetBufferAllocationUnit() != 0) {
EXPECT_GE(SbMediaGetBufferAllocationUnit(), 64 * 1024);
}
int allocation_unit = SbMediaGetBufferAllocationUnit();
std::vector<void*> allocated_ptrs;
int initial_buffer_capacity = SbMediaGetInitialBufferCapacity();
if (initial_buffer_capacity > 0) {
allocated_ptrs =
TryToAllocateMemory(initial_buffer_capacity, allocation_unit, 1);
}
if (!HasNonfatalFailure()) {
for (SbMediaType type : kMediaTypes) {
#if SB_API_VERSION >= 14
// The test will be run more than once, it's redundant but allows us to
// keep the test logic in one place.
int alignment = SbMediaGetBufferAlignment();
#else // SB_API_VERSION >= 14
int alignment = SbMediaGetBufferAlignment(type);
#endif // SB_API_VERSION >= 14
EXPECT_EQ(alignment & (alignment - 1), 0)
<< "Alignment must always be a power of 2";
if (HasNonfatalFailure()) {
break;
}
int media_budget = type == SbMediaType::kSbMediaTypeAudio
? kMinAudioBudget
: kMinVideoBudget;
std::vector<void*> media_buffer_allocated_memory =
TryToAllocateMemory(media_budget, allocation_unit, alignment);
allocated_ptrs.insert(allocated_ptrs.end(),
media_buffer_allocated_memory.begin(),
media_buffer_allocated_memory.end());
if (HasNonfatalFailure()) {
break;
}
}
}
for (void* ptr : allocated_ptrs) {
SbMemoryDeallocateAligned(ptr);
}
}
TEST(SbMediaBufferTest, AudioBudget) {
EXPECT_GE(SbMediaGetAudioBufferBudget(), kMinAudioBudget);
}
TEST(SbMediaBufferTest, GarbageCollectionDurationThreshold) {
int kMinGarbageCollectionDurationThreshold = 30 * kSbTimeSecond;
int kMaxGarbageCollectionDurationThreshold = 240 * kSbTimeSecond;
int threshold = SbMediaGetBufferGarbageCollectionDurationThreshold();
EXPECT_GE(threshold, kMinGarbageCollectionDurationThreshold);
EXPECT_LE(threshold, kMaxGarbageCollectionDurationThreshold);
}
TEST(SbMediaBufferTest, InitialCapacity) {
EXPECT_GE(SbMediaGetInitialBufferCapacity(), 0);
}
TEST(SbMediaBufferTest, MaxCapacity) {
// TODO: Limit EXPECT statements to only codecs and resolutions that are
// supported by the platform. If unsupported, still call
// SbMediaGetMaxBufferCapacity() to ensure there isn't a crash.
for (auto resolution : kVideoResolutions) {
for (auto bits_per_pixel : kBitsPerPixelValues) {
for (auto codec : kVideoCodecs) {
EXPECT_GT(SbMediaGetMaxBufferCapacity(codec, resolution[0],
resolution[1], bits_per_pixel),
0);
EXPECT_GE(SbMediaGetMaxBufferCapacity(codec, resolution[0],
resolution[1], bits_per_pixel),
SbMediaGetInitialBufferCapacity());
}
}
}
}
TEST(SbMediaBufferTest, Padding) {
#if SB_API_VERSION >= 14
EXPECT_GE(SbMediaGetBufferPadding(), 0);
#else // SB_API_VERSION >= 14
for (auto type : kMediaTypes) {
EXPECT_GE(SbMediaGetBufferPadding(type), 0);
}
#endif // SB_API_VERSION >= 14
}
TEST(SbMediaBufferTest, PoolAllocateOnDemand) {
// Just don't crash.
SbMediaIsBufferPoolAllocateOnDemand();
}
TEST(SbMediaBufferTest, ProgressiveBudget) {
const int kMinProgressiveBudget = 8 * 1024 * 1024;
int audio_budget = SbMediaGetAudioBufferBudget();
for (auto video_codec : kVideoCodecs) {
for (auto bits_per_pixel : kBitsPerPixelValues) {
int video_budget_1080p =
SbMediaGetVideoBufferBudget(video_codec, 1920, 1080, bits_per_pixel);
for (auto resolution : kVideoResolutions) {
int progressive_budget = SbMediaGetProgressiveBufferBudget(
video_codec, resolution[0], resolution[1], bits_per_pixel);
EXPECT_LT(progressive_budget, video_budget_1080p + audio_budget)
<< "Progressive budget must be less than sum of 1080p video "
"budget and audio budget";
EXPECT_GE(progressive_budget, kMinProgressiveBudget);
}
}
}
}
TEST(SbMediaBufferTest, StorageType) {
// Just don't crash.
SbMediaBufferStorageType type = SbMediaGetBufferStorageType();
switch (type) {
case kSbMediaBufferStorageTypeMemory:
case kSbMediaBufferStorageTypeFile:
return;
}
SB_NOTREACHED();
}
TEST(SbMediaBufferTest, UsingMemoryPool) {
// Just don't crash.
SbMediaIsBufferUsingMemoryPool();
}
TEST(SbMediaBufferTest, VideoBudget) {
for (auto codec : kVideoCodecs) {
for (auto resolution : kVideoResolutions) {
for (auto bits_per_pixel : kBitsPerPixelValues) {
EXPECT_GE(SbMediaGetVideoBufferBudget(codec, resolution[0],
resolution[1], bits_per_pixel),
kMinVideoBudget);
}
}
}
}
TEST(SbMediaBufferTest, ValidatePerformance) {
TEST_PERF_FUNCNOARGS_DEFAULT(SbMediaGetBufferAllocationUnit);
TEST_PERF_FUNCNOARGS_DEFAULT(SbMediaGetAudioBufferBudget);
TEST_PERF_FUNCNOARGS_DEFAULT(
SbMediaGetBufferGarbageCollectionDurationThreshold);
TEST_PERF_FUNCNOARGS_DEFAULT(SbMediaGetInitialBufferCapacity);
TEST_PERF_FUNCNOARGS_DEFAULT(SbMediaIsBufferPoolAllocateOnDemand);
TEST_PERF_FUNCNOARGS_DEFAULT(SbMediaGetBufferStorageType);
TEST_PERF_FUNCNOARGS_DEFAULT(SbMediaIsBufferUsingMemoryPool);
#if SB_API_VERSION >= 14
for (auto type : kMediaTypes) {
TEST_PERF_FUNCNOARGS_DEFAULT(SbMediaGetBufferAlignment);
TEST_PERF_FUNCNOARGS_DEFAULT(SbMediaGetBufferPadding);
}
#else // SB_API_VERSION >= 14
for (auto type : kMediaTypes) {
TEST_PERF_FUNCWITHARGS_DEFAULT(SbMediaGetBufferAlignment, type);
TEST_PERF_FUNCWITHARGS_DEFAULT(SbMediaGetBufferPadding, type);
}
#endif // SB_API_VERSION >= 14
for (auto resolution : kVideoResolutions) {
for (auto bits_per_pixel : kBitsPerPixelValues) {
for (auto codec : kVideoCodecs) {
TEST_PERF_FUNCWITHARGS_DEFAULT(SbMediaGetMaxBufferCapacity, codec,
resolution[0], resolution[1],
bits_per_pixel);
TEST_PERF_FUNCWITHARGS_DEFAULT(SbMediaGetProgressiveBufferBudget, codec,
resolution[0], resolution[1],
bits_per_pixel);
TEST_PERF_FUNCWITHARGS_DEFAULT(SbMediaGetVideoBufferBudget, codec,
resolution[0], resolution[1],
bits_per_pixel);
}
}
}
}
} // namespace nplb
} // namespace starboard