blob: b0843a7e616a13a677bc05f1ed1ed02e22b5db29 [file] [log] [blame]
// Copyright 2017 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 "media/gpu/android/android_video_surface_chooser_impl.h"
#include <memory>
#include "base/time/default_tick_clock.h"
namespace media {
// Minimum time that we require after a failed overlay attempt before we'll try
// again for an overlay.
constexpr base::TimeDelta MinimumDelayAfterFailedOverlay =
bool allow_dynamic,
const base::TickClock* tick_clock)
: allow_dynamic_(allow_dynamic),
weak_factory_(this) {
// Use a DefaultTickClock if one wasn't provided.
if (!tick_clock_)
tick_clock_ = base::DefaultTickClock::GetInstance();
AndroidVideoSurfaceChooserImpl::~AndroidVideoSurfaceChooserImpl() {}
void AndroidVideoSurfaceChooserImpl::SetClientCallbacks(
UseOverlayCB use_overlay_cb,
UseTextureOwnerCB use_texture_owner_cb) {
DCHECK(use_overlay_cb && use_texture_owner_cb);
use_overlay_cb_ = std::move(use_overlay_cb);
use_texture_owner_cb_ = std::move(use_texture_owner_cb);
void AndroidVideoSurfaceChooserImpl::UpdateState(
base::Optional<AndroidOverlayFactoryCB> new_factory,
const State& new_state) {
bool entered_fullscreen =
!current_state_.is_fullscreen && new_state.is_fullscreen;
current_state_ = new_state;
bool factory_changed = new_factory.has_value();
if (factory_changed)
overlay_factory_ = std::move(*new_factory);
if (!allow_dynamic_) {
if (!initial_state_received_) {
initial_state_received_ = true;
// Choose here so that Choose() doesn't have to handle non-dynamic.
// Note that we ignore |is_expecting_relayout| here, since it's transient.
// We don't want to pick TextureOwner permanently for that.
if (overlay_factory_ &&
(current_state_.is_fullscreen || current_state_.is_secure ||
current_state_.is_required) &&
current_state_.video_rotation == VIDEO_ROTATION_0) {
} else {
// If we're entering fullscreen, clear any previous failure attempt. It's
// likely that any previous failure was due to a lack of power efficiency,
// but entering fs likely changes that anyway.
if (entered_fullscreen)
most_recent_overlay_failure_ = base::TimeTicks();
// If the factory changed, we should cancel pending overlay requests and
// set the client state back to Unknown if they're using an old overlay.
if (factory_changed) {
overlay_ = nullptr;
if (client_overlay_state_ == kUsingOverlay)
client_overlay_state_ = kUnknown;
void AndroidVideoSurfaceChooserImpl::Choose() {
// Pre-M we shouldn't be called.
// TODO(liberato): should this depend on resolution?
OverlayState new_overlay_state =
current_state_.promote_aggressively ? kUsingOverlay : kUsingTextureOwner;
// Do we require a power-efficient overlay?
bool needs_power_efficient = current_state_.promote_aggressively;
// In player element fullscreen, we want to use overlays if we can. Note that
// this does nothing if |promote_aggressively|, which is fine since switching
// from "want power efficient" from "don't care" is problematic.
if (current_state_.is_fullscreen)
new_overlay_state = kUsingOverlay;
// Try to use an overlay if possible for protected content. If the compositor
// won't promote, though, it's okay if we switch out. Set |is_required| in
// addition, if you don't want this behavior.
if (current_state_.is_secure) {
new_overlay_state = kUsingOverlay;
// Don't un-promote if not power efficient. If we did, then inline playback
// would likely not promote.
needs_power_efficient = false;
// If the compositor won't promote, then don't.
if (!current_state_.is_compositor_promotable)
new_overlay_state = kUsingTextureOwner;
// If we're expecting a relayout, then don't transition to overlay if we're
// not already in one. We don't want to transition out, though. This lets us
// delay entering on a fullscreen transition until blink relayout is complete.
// TODO(liberato): Detect this more directly.
if (current_state_.is_expecting_relayout &&
client_overlay_state_ != kUsingOverlay)
new_overlay_state = kUsingTextureOwner;
// If we're requesting an overlay, check that we haven't asked too recently
// since the last failure. This includes L1. We don't bother to check for
// our current state, since using an overlay would imply that our most recent
// failure was long ago enough to pass this check earlier.
if (new_overlay_state == kUsingOverlay) {
base::TimeDelta time_since_last_failure =
tick_clock_->NowTicks() - most_recent_overlay_failure_;
if (time_since_last_failure < MinimumDelayAfterFailedOverlay)
new_overlay_state = kUsingTextureOwner;
// If an overlay is required, then choose one. The only way we won't is if we
// don't have a factory or our request fails, or if it's rotated.
if (current_state_.is_required) {
new_overlay_state = kUsingOverlay;
// Required overlays don't need to be power efficient.
needs_power_efficient = false;
// Specifying a rotated overlay can NOTREACHED() in the compositor, so it's
// better to fail.
if (current_state_.video_rotation != VIDEO_ROTATION_0)
new_overlay_state = kUsingTextureOwner;
// If we have no factory, then we definitely don't want to use overlays.
if (!overlay_factory_)
new_overlay_state = kUsingTextureOwner;
if (current_state_.always_use_texture_owner)
new_overlay_state = kUsingTextureOwner;
// Make sure that we're in |new_overlay_state_|.
if (new_overlay_state == kUsingTextureOwner)
void AndroidVideoSurfaceChooserImpl::SwitchToTextureOwner() {
// Invalidate any outstanding deletion callbacks for any overlays that we've
// provided to the client already. We assume that it will eventually drop
// them in response to the callback. Ready / failed callbacks aren't affected
// by this, since we own the overlay until those occur. We're about to
// drop |overlay_|, if we have one, which cancels them.
// Cancel any outstanding overlay request, in case we're switching to overlay.
if (overlay_)
overlay_ = nullptr;
// Notify the client to switch if it's in the wrong state.
if (client_overlay_state_ != kUsingTextureOwner) {
client_overlay_state_ = kUsingTextureOwner;
void AndroidVideoSurfaceChooserImpl::SwitchToOverlay(
bool needs_power_efficient) {
// If there's already an overlay request outstanding, then do nothing. We'll
// finish switching when it completes.
// TODO(liberato): If the power efficient flag for |overlay_| doesn't match
// |needs_power_efficient|, then we should cancel it anyway. In practice,
// this doesn't happen, so we ignore it.
if (overlay_)
// Do nothing if the client is already using an overlay. Note that if one
// changes overlay factories, then this might not be true; an overlay from the
// old factory is not the same as an overlay from the new factory. However,
// we assume that ReplaceOverlayFactory handles that.
if (client_overlay_state_ == kUsingOverlay)
// We don't modify |client_overlay_state_| yet, since we don't call the client
// back yet.
// Invalidate any outstanding callbacks. This is needed for the deletion
// callback, since for ready/failed callbacks, we still have ownership of the
// object. If we delete the object, then callbacks are cancelled anyway.
// We also don't want to receive the power efficient callback.
AndroidOverlayConfig config;
// We bind all of our callbacks with weak ptrs, since we don't know how long
// the client will hold on to overlays. They could, in principle, show up
// long after the client is destroyed too, if codec destruction hangs.
config.ready_cb = base::Bind(&AndroidVideoSurfaceChooserImpl::OnOverlayReady,
config.failed_cb =
config.rect = current_state_.initial_position; = current_state_.is_secure;
// Request power efficient overlays and callbacks if we're supposed to.
config.power_efficient = needs_power_efficient;
config.power_cb =
overlay_ = overlay_factory_.Run(std::move(config));
if (!overlay_)
void AndroidVideoSurfaceChooserImpl::OnOverlayReady(AndroidOverlay* overlay) {
// |overlay_| is the only overlay for which we haven't gotten a ready callback
// back yet.
DCHECK_EQ(overlay, overlay_.get());
// Notify the overlay that we'd like to know if it's destroyed, so that we can
// update our internal state if the client drops it without being told.
client_overlay_state_ = kUsingOverlay;
void AndroidVideoSurfaceChooserImpl::OnOverlayFailed(AndroidOverlay* overlay) {
// We shouldn't get a failure for any overlay except the incoming one.
DCHECK_EQ(overlay, overlay_.get());
overlay_ = nullptr;
most_recent_overlay_failure_ = tick_clock_->NowTicks();
// If the client isn't already using a TextureOwner, then switch to it.
// Note that this covers the case of kUnknown, when we might not have told the
// client anything yet. That's important for Initialize, so that a failed
// overlay request still results in some callback to the client to know what
// surface to start with.
void AndroidVideoSurfaceChooserImpl::OnOverlayDeleted(AndroidOverlay* overlay) {
client_overlay_state_ = kUsingTextureOwner;
// We don't call SwitchToTextureOwner since the client dropped the overlay.
// It's already using TextureOwner.
void AndroidVideoSurfaceChooserImpl::OnPowerEfficientState(
AndroidOverlay* overlay,
bool is_power_efficient) {
// We cannot receive this before OnSurfaceReady, since that is the first
// callback if it arrives. Getting a new overlay clears any previous cbs.
// We cannot receive it after switching to TextureOwner, since that also
// clears all callbacks.
DCHECK(client_overlay_state_ == kUsingOverlay);
// If the overlay has become power efficient, then take no action.
if (is_power_efficient)
// If the overlay is now required, then keep it. It might have become
// required since we requested it.
if (current_state_.is_required)
// If we're not able to switch dynamically, then keep the overlay.
if (!allow_dynamic_)
// We could set the failure timer here, but we don't mostly for fullscreen.
// We don't want to delay transitioning to an overlay if the user re-enters
// fullscreen. TODO(liberato): Perhaps we should just clear the failure timer
// if we detect a transition into fs when we get new state from the client.
} // namespace media