144 lines
5.5 KiB
C++
144 lines
5.5 KiB
C++
// Copyright 2020 The Chromium Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#include "cast/streaming/capture_recommendations.h"
|
|
|
|
#include <algorithm>
|
|
#include <utility>
|
|
|
|
#include "cast/streaming/answer_messages.h"
|
|
#include "util/osp_logging.h"
|
|
|
|
namespace openscreen {
|
|
namespace cast {
|
|
namespace capture_recommendations {
|
|
namespace {
|
|
|
|
void ApplyDisplay(const DisplayDescription& description,
|
|
Recommendations* recommendations) {
|
|
recommendations->video.supports_scaling =
|
|
(description.aspect_ratio_constraint &&
|
|
(description.aspect_ratio_constraint.value() ==
|
|
AspectRatioConstraint::kVariable));
|
|
|
|
// We should never exceed the display's resolution, since it will always
|
|
// force scaling.
|
|
if (description.dimensions) {
|
|
recommendations->video.maximum = description.dimensions.value();
|
|
recommendations->video.bit_rate_limits.maximum =
|
|
recommendations->video.maximum.effective_bit_rate();
|
|
|
|
if (recommendations->video.maximum.width <
|
|
recommendations->video.minimum.width) {
|
|
recommendations->video.minimum =
|
|
recommendations->video.maximum.ToResolution();
|
|
}
|
|
}
|
|
|
|
// If the receiver gives us an aspect ratio that doesn't match the display
|
|
// resolution they give us, the behavior is undefined from the spec.
|
|
// Here we prioritize the aspect ratio, and the receiver can scale the frame
|
|
// as they wish.
|
|
double aspect_ratio = 0.0;
|
|
if (description.aspect_ratio) {
|
|
aspect_ratio = static_cast<double>(description.aspect_ratio->width) /
|
|
description.aspect_ratio->height;
|
|
recommendations->video.maximum.width =
|
|
recommendations->video.maximum.height * aspect_ratio;
|
|
} else if (description.dimensions) {
|
|
aspect_ratio = static_cast<double>(description.dimensions->width) /
|
|
description.dimensions->height;
|
|
} else {
|
|
return;
|
|
}
|
|
recommendations->video.minimum.width =
|
|
recommendations->video.minimum.height * aspect_ratio;
|
|
}
|
|
|
|
void ApplyConstraints(const Constraints& constraints,
|
|
Recommendations* recommendations) {
|
|
// Audio has no fields in the display description, so we can safely
|
|
// ignore the current recommendations when setting values here.
|
|
if (constraints.audio.max_delay.has_value()) {
|
|
recommendations->audio.max_delay = constraints.audio.max_delay.value();
|
|
}
|
|
recommendations->audio.max_channels = constraints.audio.max_channels;
|
|
recommendations->audio.max_sample_rate = constraints.audio.max_sample_rate;
|
|
|
|
recommendations->audio.bit_rate_limits = BitRateLimits{
|
|
std::max(constraints.audio.min_bit_rate, kDefaultAudioMinBitRate),
|
|
std::max(constraints.audio.max_bit_rate, kDefaultAudioMinBitRate)};
|
|
|
|
// With video, we take the intersection of values of the constraints and
|
|
// the display description.
|
|
if (constraints.video.max_delay.has_value()) {
|
|
recommendations->video.max_delay = constraints.video.max_delay.value();
|
|
}
|
|
|
|
if (constraints.video.max_pixels_per_second.has_value()) {
|
|
recommendations->video.max_pixels_per_second =
|
|
constraints.video.max_pixels_per_second.value();
|
|
}
|
|
|
|
recommendations->video.bit_rate_limits =
|
|
BitRateLimits{std::max(constraints.video.min_bit_rate,
|
|
recommendations->video.bit_rate_limits.minimum),
|
|
std::min(constraints.video.max_bit_rate,
|
|
recommendations->video.bit_rate_limits.maximum)};
|
|
Dimensions dimensions = constraints.video.max_dimensions;
|
|
if (dimensions.width <= kDefaultMinResolution.width) {
|
|
recommendations->video.maximum = {kDefaultMinResolution.width,
|
|
kDefaultMinResolution.height,
|
|
kDefaultFrameRate};
|
|
} else if (dimensions.width < recommendations->video.maximum.width) {
|
|
recommendations->video.maximum = std::move(dimensions);
|
|
}
|
|
|
|
if (constraints.video.min_resolution) {
|
|
const Resolution& min = constraints.video.min_resolution->ToResolution();
|
|
if (kDefaultMinResolution.width < min.width) {
|
|
recommendations->video.minimum = std::move(min);
|
|
}
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
bool BitRateLimits::operator==(const BitRateLimits& other) const {
|
|
return std::tie(minimum, maximum) == std::tie(other.minimum, other.maximum);
|
|
}
|
|
|
|
bool Audio::operator==(const Audio& other) const {
|
|
return std::tie(bit_rate_limits, max_delay, max_channels, max_sample_rate) ==
|
|
std::tie(other.bit_rate_limits, other.max_delay, other.max_channels,
|
|
other.max_sample_rate);
|
|
}
|
|
|
|
bool Video::operator==(const Video& other) const {
|
|
return std::tie(bit_rate_limits, minimum, maximum, supports_scaling,
|
|
max_delay, max_pixels_per_second) ==
|
|
std::tie(other.bit_rate_limits, other.minimum, other.maximum,
|
|
other.supports_scaling, other.max_delay,
|
|
other.max_pixels_per_second);
|
|
}
|
|
|
|
bool Recommendations::operator==(const Recommendations& other) const {
|
|
return std::tie(audio, video) == std::tie(other.audio, other.video);
|
|
}
|
|
|
|
Recommendations GetRecommendations(const Answer& answer) {
|
|
Recommendations recommendations;
|
|
if (answer.display.has_value() && answer.display->IsValid()) {
|
|
ApplyDisplay(answer.display.value(), &recommendations);
|
|
}
|
|
if (answer.constraints.has_value() && answer.constraints->IsValid()) {
|
|
ApplyConstraints(answer.constraints.value(), &recommendations);
|
|
}
|
|
return recommendations;
|
|
}
|
|
|
|
} // namespace capture_recommendations
|
|
} // namespace cast
|
|
} // namespace openscreen
|