blob: 84a94767823c011cd403293e2c33aa411427b24d [file] [log] [blame]
// Copyright 2018 The Fuchsia 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 "garnet/bin/mediaplayer/test/mediaplayer_test_util_view.h"
#include <fcntl.h>
#include <hid/usages.h>
#include <zx/eventpair.h>
#include "garnet/bin/mediaplayer/graph/formatting.h"
#include "garnet/bin/mediaplayer/test/mediaplayer_test_util_params.h"
#include "lib/fidl/cpp/clone.h"
#include "lib/fidl/cpp/optional.h"
#include "lib/fsl/io/fd.h"
#include "lib/fxl/logging.h"
#include "lib/media/timeline/timeline.h"
#include "lib/media/timeline/type_converters.h"
#include "lib/url/gurl.h"
namespace media_player {
namespace test {
namespace {
constexpr uint32_t kVideoChildKey = 0u;
constexpr int32_t kDefaultWidth = 640;
constexpr int32_t kDefaultHeight = 100;
constexpr float kBackgroundElevation = 0.f;
constexpr float kVideoElevation = 1.0f;
constexpr float kProgressBarElevation = 1.0f;
constexpr float kProgressBarSliderElevation = 2.0f;
constexpr float kControlsGap = 12.0f;
constexpr float kControlsHeight = 36.0f;
// Determines whether the rectangle contains the point x,y.
bool Contains(const fuchsia::math::RectF& rect, float x, float y) {
return rect.x <= x && rect.y <= y && rect.x + rect.width >= x &&
rect.y + rect.height >= y;
}
int64_t rand_less_than(int64_t limit) {
return (static_cast<int64_t>(std::rand()) * RAND_MAX + std::rand()) % limit;
}
} // namespace
MediaPlayerTestUtilView::MediaPlayerTestUtilView(
scenic::ViewContext view_context, fit::function<void(int)> quit_callback,
const MediaPlayerTestUtilParams& params)
: scenic::V1BaseView(std::move(view_context), "Media Player"),
quit_callback_(std::move(quit_callback)),
params_(params),
background_node_(session()),
progress_bar_node_(session()),
progress_bar_slider_node_(session()) {
FXL_DCHECK(quit_callback_);
FXL_DCHECK(params_.is_valid());
FXL_DCHECK(!params_.urls().empty());
scenic::Material background_material(session());
background_material.SetColor(0x00, 0x00, 0x00, 0xff);
background_node_.SetMaterial(background_material);
parent_node().AddChild(background_node_);
scenic::Material progress_bar_material(session());
progress_bar_material.SetColor(0x23, 0x23, 0x23, 0xff);
progress_bar_node_.SetMaterial(progress_bar_material);
parent_node().AddChild(progress_bar_node_);
scenic::Material progress_bar_slider_material(session());
progress_bar_slider_material.SetColor(0x00, 0x00, 0xff, 0xff);
progress_bar_slider_node_.SetMaterial(progress_bar_slider_material);
parent_node().AddChild(progress_bar_slider_node_);
// We start with a non-zero size so we get a progress bar regardless of
// whether we get video.
video_size_.width = 0;
video_size_.height = 0;
pixel_aspect_ratio_.width = 1;
pixel_aspect_ratio_.height = 1;
// Create a player from all that stuff.
player_ = startup_context()
->ConnectToEnvironmentService<fuchsia::mediaplayer::Player>();
// Create the video view.
zx::eventpair view_owner_token, view_token;
if (zx::eventpair::create(0u, &view_owner_token, &view_token) != ZX_OK)
FXL_NOTREACHED() << "failed to create tokens.";
player_->CreateView2(std::move(view_token));
zx::eventpair video_host_import_token;
video_host_node_.reset(new scenic::EntityNode(session()));
video_host_node_->ExportAsRequest(&video_host_import_token);
parent_node().AddChild(*video_host_node_);
GetViewContainer()->AddChild2(kVideoChildKey, std::move(view_owner_token),
std::move(video_host_import_token));
commands_.Init(player_.get());
player_.events().OnStatusChanged =
[this](fuchsia::mediaplayer::PlayerStatus status) {
HandleStatusChanged(status);
};
// Seed the random number generator.
std::srand(std::time(nullptr));
if (params_.experiment()) {
RunExperiment();
} else if (params_.test_seek()) {
TestSeek();
} else {
// Get the player primed now.
commands_.SetUrl(params_.urls().front());
commands_.Pause();
commands_.WaitForViewReady();
if (params_.auto_play()) {
commands_.Play();
}
ScheduleNextUrl();
}
commands_.Execute();
}
void MediaPlayerTestUtilView::RunExperiment() {
// Add experimental code here.
// In general, no implementation for this method should be submitted.
}
void MediaPlayerTestUtilView::TestSeek() {
commands_.SetUrl(params_.urls().front());
commands_.WaitForViewReady();
// Need to load content before deciding where to seek.
commands_.WaitForContentLoaded();
commands_.Invoke([this]() { ContinueTestSeek(); });
}
void MediaPlayerTestUtilView::ContinueTestSeek() {
if (duration_ns_ == 0) {
// We have no duration yet. Just start over at zero.
commands_.Seek(0);
commands_.Play();
commands_.WaitForEndOfStream();
commands_.Invoke([this]() { ContinueTestSeek(); });
FXL_LOG(INFO) << "Seek interval: beginning to end";
return;
}
// For the start position, generate a number in the range [0..duration_ns_]
// with a 10% chance of being zero.
int64_t seek_interval_start =
rand_less_than(duration_ns_ + duration_ns_ / 10);
if (seek_interval_start >= duration_ns_) {
seek_interval_start = 0;
}
// For the end position, choose a position between start and 10% past the
// duration. If this value is greater than the duration, the interval
// effectively ends at the end of the file.
int64_t seek_interval_end =
seek_interval_start +
rand_less_than((duration_ns_ + duration_ns_ / 10) - seek_interval_start);
commands_.Seek(seek_interval_start);
commands_.Play();
if (seek_interval_end >= duration_ns_) {
FXL_LOG(INFO) << "Seek interval: " << AsNs(seek_interval_start)
<< " to end";
commands_.WaitForEndOfStream();
} else {
FXL_LOG(INFO) << "Seek interval: " << AsNs(seek_interval_start) << " to "
<< AsNs(seek_interval_end);
commands_.WaitForSeekCompletion();
commands_.WaitForPosition(seek_interval_end);
}
commands_.Invoke([this]() { ContinueTestSeek(); });
}
void MediaPlayerTestUtilView::ScheduleNextUrl() {
if (++next_url_index_ == params_.urls().size()) {
if (!params_.loop()) {
// No more files, not looping.
return;
}
next_url_index_ = 0;
}
commands_.WaitForEndOfStream();
if (params_.urls().size() > 1) {
commands_.SetUrl(params_.urls()[next_url_index_]);
} else {
// Just one file...seek to the beginning.
commands_.Seek(0);
}
commands_.Play();
commands_.Invoke([this]() { ScheduleNextUrl(); });
}
MediaPlayerTestUtilView::~MediaPlayerTestUtilView() {}
bool MediaPlayerTestUtilView::OnInputEvent(
fuchsia::ui::input::InputEvent event) {
bool handled = false;
if (event.is_pointer()) {
const auto& pointer = event.pointer();
if (pointer.phase == fuchsia::ui::input::PointerEventPhase::DOWN) {
if (duration_ns_ != 0 && Contains(controls_rect_, pointer.x, pointer.y)) {
// User poked the progress bar...seek.
player_->Seek((pointer.x - controls_rect_.x) * duration_ns_ /
controls_rect_.width);
if (state_ != State::kPlaying) {
player_->Play();
}
} else {
// User poked elsewhere.
TogglePlayPause();
}
handled = true;
}
} else if (event.is_keyboard()) {
auto& keyboard = event.keyboard();
if (keyboard.phase == fuchsia::ui::input::KeyboardEventPhase::PRESSED) {
switch (keyboard.hid_usage) {
case HID_USAGE_KEY_SPACE:
TogglePlayPause();
handled = true;
break;
case HID_USAGE_KEY_Q:
quit_callback_(0);
handled = true;
break;
default:
break;
}
}
}
return handled;
}
void MediaPlayerTestUtilView::OnPropertiesChanged(
::fuchsia::ui::viewsv1::ViewProperties old_properties) {
Layout();
}
void MediaPlayerTestUtilView::Layout() {
if (!has_logical_size())
return;
if (!scenic_ready_) {
scenic_ready_ = true;
commands_.NotifyViewReady();
}
// Make the background fill the space.
scenic::Rectangle background_shape(session(), logical_size().width,
logical_size().height);
background_node_.SetShape(background_shape);
background_node_.SetTranslation(logical_size().width * .5f,
logical_size().height * .5f,
kBackgroundElevation);
// Compute maximum size of video content after reserving space
// for decorations.
fuchsia::math::SizeF max_content_size;
max_content_size.width = logical_size().width;
max_content_size.height =
logical_size().height - kControlsHeight - kControlsGap;
// Shrink video to fit if needed.
uint32_t video_width =
(video_size_.width == 0 ? kDefaultWidth : video_size_.width) *
pixel_aspect_ratio_.width;
uint32_t video_height =
(video_size_.height == 0 ? kDefaultHeight : video_size_.height) *
pixel_aspect_ratio_.height;
if (max_content_size.width * video_height <
max_content_size.height * video_width) {
content_rect_.width = max_content_size.width;
content_rect_.height = video_height * max_content_size.width / video_width;
} else {
content_rect_.width = video_width * max_content_size.height / video_height;
content_rect_.height = max_content_size.height;
}
// Position the video.
content_rect_.x = (logical_size().width - content_rect_.width) / 2.0f;
content_rect_.y = (logical_size().height - content_rect_.height -
kControlsHeight - kControlsGap) /
2.0f;
// Position the controls.
controls_rect_.x = content_rect_.x;
controls_rect_.y = content_rect_.y + content_rect_.height + kControlsGap;
controls_rect_.width = content_rect_.width;
controls_rect_.height = kControlsHeight;
// Put the progress bar under the content.
scenic::Rectangle progress_bar_shape(session(), controls_rect_.width,
controls_rect_.height);
progress_bar_node_.SetShape(progress_bar_shape);
progress_bar_node_.SetTranslation(
controls_rect_.x + controls_rect_.width * 0.5f,
controls_rect_.y + controls_rect_.height * 0.5f, kProgressBarElevation);
// Put the progress bar slider on top of the progress bar.
scenic::Rectangle progress_bar_slider_shape(session(), controls_rect_.width,
controls_rect_.height);
progress_bar_slider_node_.SetShape(progress_bar_slider_shape);
progress_bar_slider_node_.SetTranslation(
controls_rect_.x + controls_rect_.width * 0.5f,
controls_rect_.y + controls_rect_.height * 0.5f,
kProgressBarSliderElevation);
// Ask the view to fill the space.
::fuchsia::ui::viewsv1::ViewProperties view_properties;
view_properties.view_layout = ::fuchsia::ui::viewsv1::ViewLayout::New();
view_properties.view_layout->size.width = content_rect_.width;
view_properties.view_layout->size.height = content_rect_.height;
GetViewContainer()->SetChildProperties(
kVideoChildKey, fidl::MakeOptional(std::move(view_properties)));
InvalidateScene();
}
void MediaPlayerTestUtilView::OnSceneInvalidated(
fuchsia::images::PresentationInfo presentation_info) {
if (!has_physical_size())
return;
// Position the video.
if (video_host_node_) {
// TODO(dalesat): Fix this when SCN-1041 is fixed. Should be:
// video_host_node_->SetTranslation(
// content_rect_.x + content_rect_.width * 0.5f,
// content_rect_.y + content_rect_.height * 0.5f, kVideoElevation);
video_host_node_->SetTranslation(content_rect_.x, content_rect_.y,
kVideoElevation);
}
float progress_bar_slider_width =
controls_rect_.width * normalized_progress();
scenic::Rectangle progress_bar_slider_shape(
session(), progress_bar_slider_width, controls_rect_.height);
progress_bar_slider_node_.SetShape(progress_bar_slider_shape);
progress_bar_slider_node_.SetTranslation(
controls_rect_.x + progress_bar_slider_width * 0.5f,
controls_rect_.y + controls_rect_.height * 0.5f,
kProgressBarSliderElevation);
if (state_ == State::kPlaying) {
InvalidateScene();
}
}
void MediaPlayerTestUtilView::OnChildAttached(
uint32_t child_key, ::fuchsia::ui::viewsv1::ViewInfo child_view_info) {
FXL_DCHECK(child_key == kVideoChildKey);
parent_node().AddChild(*video_host_node_);
Layout();
}
void MediaPlayerTestUtilView::OnChildUnavailable(uint32_t child_key) {
FXL_DCHECK(child_key == kVideoChildKey);
FXL_LOG(ERROR) << "Video view died unexpectedly";
video_host_node_->Detach();
video_host_node_.reset();
GetViewContainer()->RemoveChild2(child_key, zx::eventpair());
Layout();
}
void MediaPlayerTestUtilView::HandleStatusChanged(
const fuchsia::mediaplayer::PlayerStatus& status) {
// Process status received from the player.
if (status.timeline_function) {
timeline_function_ =
fxl::To<media::TimelineFunction>(*status.timeline_function);
state_ = status.end_of_stream
? State::kEnded
: (timeline_function_.subject_delta() == 0) ? State::kPaused
: State::kPlaying;
} else {
state_ = State::kPaused;
}
commands_.NotifyStatusChanged(status);
if (status.problem) {
if (!problem_shown_) {
FXL_LOG(ERROR) << "PROBLEM: " << status.problem->type << ", "
<< status.problem->details;
problem_shown_ = true;
}
} else {
problem_shown_ = false;
}
if (status.video_size && status.pixel_aspect_ratio &&
(video_size_ != *status.video_size ||
pixel_aspect_ratio_ != *status.pixel_aspect_ratio)) {
video_size_ = *status.video_size;
pixel_aspect_ratio_ = *status.pixel_aspect_ratio;
Layout();
}
duration_ns_ = status.duration_ns;
metadata_ = fidl::Clone(status.metadata);
InvalidateScene();
}
void MediaPlayerTestUtilView::TogglePlayPause() {
switch (state_) {
case State::kPaused:
player_->Play();
break;
case State::kPlaying:
player_->Pause();
break;
case State::kEnded:
player_->Seek(0);
player_->Play();
break;
default:
break;
}
}
int64_t MediaPlayerTestUtilView::progress_ns() const {
if (duration_ns_ == 0) {
return 0;
}
// Apply the timeline function to the current time.
int64_t position = timeline_function_(media::Timeline::local_now());
if (position < 0) {
position = 0;
}
if (position > duration_ns_) {
position = duration_ns_;
}
return position;
}
float MediaPlayerTestUtilView::normalized_progress() const {
if (duration_ns_ == 0) {
return 0.0f;
}
return progress_ns() / static_cast<float>(duration_ns_);
}
} // namespace test
} // namespace media_player