// Copyright 2021 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chromecast/shared/platform_info_serializer.h"
#include <string_view>
#include "base/check.h"
#include "base/functional/callback.h"
#include "base/logging.h"
#include "chromecast/bindings/shared/proto_serializer.h"
namespace chromecast {
namespace {
bool IsOutOfRange(int value, int min, int max) {
return min > value || max < value;
}
} // namespace
PlatformInfoSerializer::PlatformInfoSerializer() = default;
PlatformInfoSerializer::PlatformInfoSerializer(PlatformInfoSerializer&& other) =
default;
PlatformInfoSerializer::~PlatformInfoSerializer() = default;
PlatformInfoSerializer& PlatformInfoSerializer::operator=(
PlatformInfoSerializer&& other) = default;
// static
std::optional<PlatformInfoSerializer> PlatformInfoSerializer::Deserialize(
std::string_view base64) {
std::optional<cast::bindings::MediaCapabilitiesMessage> proto =
chromecast::bindings::ProtoSerializer<
cast::bindings::MediaCapabilitiesMessage>::Deserialize(base64);
if (!proto) {
return std::nullopt;
}
PlatformInfoSerializer parser;
parser.platform_info_ = std::move(*proto);
return parser;
}
std::string PlatformInfoSerializer::Serialize() const {
return chromecast::bindings::ProtoSerializer<
cast::bindings::MediaCapabilitiesMessage>::Serialize(platform_info_);
}
void PlatformInfoSerializer::SetMaxWidth(int max_width) {
platform_info_.set_max_width(max_width);
}
void PlatformInfoSerializer::SetMaxHeight(int max_height) {
platform_info_.set_max_height(max_height);
}
void PlatformInfoSerializer::SetMaxFrameRate(int max_frame_rate) {
platform_info_.set_max_frame_rate(max_frame_rate);
}
void PlatformInfoSerializer::SetSupportedCryptoBlockFormat(
const std::string& format) {
platform_info_.set_supported_cryptoblock_format(format);
}
void PlatformInfoSerializer::SetMaxChannels(int max_channels) {
platform_info_.set_max_channels(max_channels);
}
void PlatformInfoSerializer::SetPcmSurroundSoundSupported(bool is_supported) {
platform_info_.set_is_pcm_surround_sound_supported(is_supported);
}
void PlatformInfoSerializer::SetPlatformDolbyVisionEnabled(bool is_enabled) {
platform_info_.set_is_platform_dolby_vision_enabled(is_enabled);
}
void PlatformInfoSerializer::SetDolbyVisionSupported(bool is_supported) {
platform_info_.set_is_dolby_vision_supported(is_supported);
}
void PlatformInfoSerializer::SetDolbyVision4kP60Supported(bool is_supported) {
platform_info_.set_is_dolby_vision4k_p60_supported(is_supported);
}
void PlatformInfoSerializer::SetDolbyVisionSupportedByCurrentHdmiMode(
bool is_supported) {
platform_info_.set_is_dolby_vision_supported_by_current_hdmi_mode(
is_supported);
}
void PlatformInfoSerializer::SetHdmiVideoModeSwitchEnabled(bool is_enabled) {
platform_info_.set_is_hdmi_video_mode_switch_enabled(is_enabled);
}
void PlatformInfoSerializer::SetPlatformHevcEnabled(bool is_enabled) {
platform_info_.set_is_platform_hevc_enabled(is_enabled);
}
void PlatformInfoSerializer::SetHdmiModeHdrCheckEnforced(bool is_enforced) {
platform_info_.set_is_hdmi_mode_hdr_check_enforced(is_enforced);
}
void PlatformInfoSerializer::SetHdrSupportedByCurrentHdmiMode(
bool is_supported) {
platform_info_.set_is_hdr_supported_by_current_hdmi_mode(is_supported);
}
void PlatformInfoSerializer::SetSmpteSt2084Supported(bool is_supported) {
platform_info_.set_is_smpte_st2084_supported(is_supported);
}
void PlatformInfoSerializer::SetHlgSupported(bool is_supported) {
platform_info_.set_is_hlg_supported(is_supported);
}
void PlatformInfoSerializer::SetHdrFeatureEnabled(bool is_enabled) {
platform_info_.set_is_hdr_feature_enabled(is_enabled);
}
void PlatformInfoSerializer::SetSupportedLegacyVp9Levels(
std::vector<int> levels) {
platform_info_.clear_supported_legacy_vp9_levels();
for (int level : levels) {
platform_info_.add_supported_legacy_vp9_levels(level);
}
}
void PlatformInfoSerializer::SetHdcpVersion(int hdcp_version) {
platform_info_.set_hdcp_version(hdcp_version);
}
void PlatformInfoSerializer::SetSpatialRenderingSupportMask(int mask) {
platform_info_.set_spatial_rendering_support_mask(mask);
}
void PlatformInfoSerializer::SetMaxFillRate(int max_fill_rate) {
platform_info_.set_max_fill_rate(max_fill_rate);
}
void PlatformInfoSerializer::SetSupportedAudioCodecs(
std::vector<AudioCodecInfo> codec_infos) {
platform_info_.clear_supported_audio_codecs();
for (const auto& element : codec_infos) {
cast::bindings::AudioCodecInfo info;
DCHECK(cast::bindings::AudioCodecInfo::AudioCodec_IsValid(element.codec));
DCHECK(cast::bindings::AudioCodecInfo::SampleFormat_IsValid(
element.sample_format));
info.set_codec(
cast::bindings::AudioCodecInfo::AudioCodec_IsValid(element.codec)
? static_cast<cast::bindings::AudioCodecInfo::AudioCodec>(
element.codec)
: cast::bindings::AudioCodecInfo::AUDIO_CODEC_UNKNOWN);
info.set_sample_format(
cast::bindings::AudioCodecInfo::SampleFormat_IsValid(
element.sample_format)
? static_cast<cast::bindings::AudioCodecInfo::SampleFormat>(
element.sample_format)
: cast::bindings::AudioCodecInfo::SAMPLE_FORMAT_UNKNOWN);
info.set_max_samples_per_second(element.max_samples_per_second);
info.set_max_audio_channels(element.max_audio_channels);
*platform_info_.add_supported_audio_codecs() = std::move(info);
}
}
void PlatformInfoSerializer::SetSupportedVideoCodecs(
std::vector<VideoCodecInfo> codec_infos) {
for (auto& element : codec_infos) {
cast::bindings::VideoCodecInfo info;
DCHECK(cast::bindings::VideoCodecInfo::VideoCodec_IsValid(element.codec));
DCHECK(
cast::bindings::VideoCodecInfo::VideoProfile_IsValid(element.profile));
info.set_codec(
cast::bindings::VideoCodecInfo::VideoCodec_IsValid(element.codec)
? static_cast<cast::bindings::VideoCodecInfo::VideoCodec>(
element.codec)
: cast::bindings::VideoCodecInfo::VIDEO_CODEC_UNKNOWN);
info.set_profile(
cast::bindings::VideoCodecInfo::VideoProfile_IsValid(element.profile)
? static_cast<cast::bindings::VideoCodecInfo::VideoProfile>(
element.profile)
: cast::bindings::VideoCodecInfo::VIDEO_PROFILE_UNKNOWN);
*platform_info_.add_supported_video_codecs() = std::move(info);
}
}
std::optional<int> PlatformInfoSerializer::MaxWidth() const {
return platform_info_.max_width();
}
std::optional<int> PlatformInfoSerializer::MaxHeight() const {
return platform_info_.max_height();
}
std::optional<int> PlatformInfoSerializer::MaxFrameRate() const {
return platform_info_.max_frame_rate();
}
std::optional<std::string> PlatformInfoSerializer::SupportedCryptoBlockFormat()
const {
return platform_info_.supported_cryptoblock_format();
}
std::optional<int> PlatformInfoSerializer::MaxChannels() const {
return platform_info_.max_channels();
}
std::optional<bool> PlatformInfoSerializer::PcmSurroundSoundSupported() const {
return platform_info_.is_pcm_surround_sound_supported();
}
std::optional<bool> PlatformInfoSerializer::IsPlatformDolbyVisionEnabled()
const {
return platform_info_.is_platform_dolby_vision_enabled();
}
std::optional<bool> PlatformInfoSerializer::IsDolbyVisionSupported() const {
return platform_info_.is_dolby_vision_supported();
}
std::optional<bool> PlatformInfoSerializer::IsDolbyVision4kP60Supported()
const {
return platform_info_.is_dolby_vision4k_p60_supported();
}
std::optional<bool>
PlatformInfoSerializer::IsDolbyVisionSupportedByCurrentHdmiMode() const {
return platform_info_.is_dolby_vision_supported_by_current_hdmi_mode();
}
std::optional<bool> PlatformInfoSerializer::IsHdmiVideoModeSwitchEnabled()
const {
return platform_info_.is_hdmi_video_mode_switch_enabled();
}
std::optional<bool> PlatformInfoSerializer::IsPlatformHevcEnabled() const {
return platform_info_.is_platform_hevc_enabled();
}
std::optional<bool> PlatformInfoSerializer::IsHdmiModeHdrCheckEnforced() const {
return platform_info_.is_hdmi_mode_hdr_check_enforced();
}
std::optional<bool> PlatformInfoSerializer::IsHdrSupportedByCurrentHdmiMode()
const {
return platform_info_.is_hdr_supported_by_current_hdmi_mode();
}
std::optional<bool> PlatformInfoSerializer::IsSmpteSt2084Supported() const {
return platform_info_.is_smpte_st2084_supported();
}
std::optional<bool> PlatformInfoSerializer::IsHlgSupported() const {
return platform_info_.is_hlg_supported();
}
std::optional<bool> PlatformInfoSerializer::IsHdrFeatureEnabled() const {
return platform_info_.is_hdr_feature_enabled();
}
std::optional<std::vector<int>>
PlatformInfoSerializer::SupportedLegacyVp9Levels() const {
std::vector<int> levels;
levels.reserve(platform_info_.supported_legacy_vp9_levels_size());
for (const auto& level : platform_info_.supported_legacy_vp9_levels()) {
levels.push_back(level);
}
return levels;
}
std::optional<int> PlatformInfoSerializer::HdcpVersion() const {
return platform_info_.hdcp_version();
}
std::optional<int> PlatformInfoSerializer::SpatialRenderingSupportMask() const {
return platform_info_.spatial_rendering_support_mask();
}
std::optional<int> PlatformInfoSerializer::MaxFillRate() const {
return platform_info_.max_fill_rate();
}
std::optional<std::vector<PlatformInfoSerializer::AudioCodecInfo>>
PlatformInfoSerializer::SupportedAudioCodecs() const {
std::vector<AudioCodecInfo> infos;
infos.reserve(platform_info_.supported_audio_codecs_size());
for (const auto& info : platform_info_.supported_audio_codecs()) {
if (IsOutOfRange(info.codec(), media::AudioCodec::kAudioCodecMin,
media::AudioCodec::kAudioCodecMax)) {
LOG(WARNING) << "Unrecognized AudioCodec: " << info.codec();
continue;
}
if (IsOutOfRange(info.sample_format(),
media::SampleFormat::kSampleFormatMin,
media::SampleFormat::kSampleFormatMax)) {
LOG(WARNING) << "Unrecognized SampleFormat: " << info.sample_format();
continue;
}
AudioCodecInfo parsed;
parsed.codec = static_cast<media::AudioCodec>(info.codec());
parsed.sample_format =
static_cast<media::SampleFormat>(info.sample_format());
parsed.max_samples_per_second = info.max_samples_per_second();
parsed.max_audio_channels = info.max_audio_channels();
infos.push_back(std::move(parsed));
}
return infos.empty()
? std::nullopt
: std::make_optional<
std::vector<PlatformInfoSerializer::AudioCodecInfo>>(infos);
}
std::optional<std::vector<PlatformInfoSerializer::VideoCodecInfo>>
PlatformInfoSerializer::SupportedVideoCodecs() const {
std::vector<VideoCodecInfo> infos;
infos.reserve(platform_info_.supported_video_codecs_size());
for (const auto& info : platform_info_.supported_video_codecs()) {
if (IsOutOfRange(info.codec(), media::VideoCodec::kVideoCodecMin,
media::VideoCodec::kVideoCodecMax)) {
LOG(WARNING) << "Unrecognized VideoCodec: " << info.codec();
continue;
}
if (IsOutOfRange(info.profile(), media::VideoProfile::kVideoProfileMin,
media::VideoProfile::kVideoProfileMax)) {
LOG(WARNING) << "Unrecognized VideoProfile: " << info.profile();
continue;
}
VideoCodecInfo parsed;
parsed.codec = static_cast<media::VideoCodec>(info.codec());
parsed.profile = static_cast<media::VideoProfile>(info.profile());
infos.push_back(std::move(parsed));
}
return infos.empty()
? std::nullopt
: std::make_optional<
std::vector<PlatformInfoSerializer::VideoCodecInfo>>(infos);
}
bool operator==(const PlatformInfoSerializer::AudioCodecInfo& first,
const PlatformInfoSerializer::AudioCodecInfo& second) {
return first.codec == second.codec &&
first.sample_format == second.sample_format &&
first.max_samples_per_second == second.max_samples_per_second &&
first.max_audio_channels == second.max_audio_channels;
}
bool operator==(const PlatformInfoSerializer::VideoCodecInfo& first,
const PlatformInfoSerializer::VideoCodecInfo& second) {
return first.codec == second.codec && first.profile == second.profile;
}
} // namespace chromecast
Codebase Browser
chromium