ash / ambient / model / ambient_topic_queue_animation_delegate.cc [blame]

// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ash/ambient/model/ambient_topic_queue_animation_delegate.h"

#include <algorithm>

#include "ash/ambient/util/ambient_util.h"
#include "base/logging.h"
#include "base/numerics/safe_conversions.h"
#include "cc/paint/skottie_resource_metadata.h"
#include "ui/gfx/geometry/size_f.h"

namespace ash {
namespace {

bool IsPortrait(const gfx::Size& size) {
  DCHECK(!size.IsEmpty());
  return size.height() > size.width();
}

bool IsSquare(const gfx::Size& size) {
  DCHECK(!size.IsEmpty());
  // This is arbitrary. Just a rough estimate that a "square" picture has an
  // aspect ratio in the range [1 - kAspectRatioDelta, 1 + kAspectRatioDelta].
  static constexpr float kAspectRatioDelta = 0.05f;
  static constexpr float kAspectRatioLowerBound = 1.f - kAspectRatioDelta;
  static constexpr float kAspectRatioUpperBound = 1.f + kAspectRatioDelta;
  float aspect_ratio = gfx::SizeF(size).AspectRatio();
  return aspect_ratio > kAspectRatioLowerBound &&
         aspect_ratio < kAspectRatioUpperBound;
}

// Determines one size that best represents the group of image assets in the
// |resource_metadata| whose orientation matches |is_portrait|. The logic is
// currently as follows:
// * Compute the average aspect ratio of all assets with matching orientation.
// * Calculate the smallest size whose a) aspect ratio matches the average
//   computed above and b) dimensions exceed those of all assets with matching
//   orientation. This ensures that we ultimately download the largest
//   possible resolution of photos from IMAX and any resizing that happens
//   "shrinks" the photo to fit in the animation, which generally has better
//   quality that "growing" a photo.
// * Discard any "square" orientations from the aspect ratio calculation. These
//   are outliers that aren't quite portrait or landscape and bias the average
//   aspect ratio. Since they are "square", it is a good enough compromise to
//   use either a portrait or landscape photo and center-crop it to a square
//   orientation before rendering. If this is not good enough in the future, we
//   can return a third size in |GetTopicSizes()|, but it is currently not worth
//   it.
//
// Returns an empty gfx::Size instance if there are no assets that match the
// |is_portrait| orientation.
gfx::Size SummarizeImageAssetSizes(
    const cc::SkottieResourceMetadataMap& resource_metadata,
    bool is_portrait) {
  constexpr int kDimensionInvalid = -1;
  int largest_width_observed = kDimensionInvalid;
  int largest_height_observed = kDimensionInvalid;
  float aspect_ratio_sum = 0.f;
  int num_assets_found = 0;
  for (const auto& [asset_id, asset_metadata] :
       resource_metadata.asset_storage()) {
    // IMAX photos are only assigned to dynamic image assets in the animation,
    // so static image assets should be ignored when calculating.
    ambient::util::ParsedDynamicAssetId parsed_dynamic_asset_id;
    bool is_dynamic_image_asset = ambient::util::ParseDynamicLottieAssetId(
        asset_id, parsed_dynamic_asset_id);
    if (!is_dynamic_image_asset || !asset_metadata.size.has_value() ||
        IsPortrait(*asset_metadata.size) != is_portrait) {
      continue;
    }

    largest_width_observed =
        std::max(asset_metadata.size->width(), largest_width_observed);
    largest_height_observed =
        std::max(asset_metadata.size->height(), largest_height_observed);
    if (!IsSquare(*asset_metadata.size)) {
      ++num_assets_found;
      aspect_ratio_sum += gfx::SizeF(*asset_metadata.size).AspectRatio();
    }
  }

  if (num_assets_found == 0) {
    if (largest_width_observed == kDimensionInvalid) {
      // There were no assets matching the desired orientation.
      return gfx::Size();
    } else {
      // There were assets matching the desired orientation, but all of them
      // were closer to being "square".
      int square_length =
          std::max(largest_width_observed, largest_height_observed);
      return gfx::Size(square_length, square_length);
    }
  }

  float average_aspect_ratio = aspect_ratio_sum / num_assets_found;
  // There are corner cases here where an asset found above may ultimately have
  // a dimension larger than the computed size, but it's not worth accounting
  // for.
  gfx::Size candidate_a = gfx::Size(
      largest_width_observed,
      base::ClampRound<int>(largest_width_observed / average_aspect_ratio));
  gfx::Size candidate_b = gfx::Size(
      base::ClampRound<int>(largest_height_observed * average_aspect_ratio),
      largest_height_observed);
  // Both candidates should have the same aspect ratio, so comparing one of the
  // dimensions (width in this case) is sufficient.
  return candidate_a.width() > candidate_b.width() ? candidate_a : candidate_b;
}

// The output will always have 1 size for landscape assets and 1 size for
// portrait assets (or 0 if there are no assets of a particular orientation).
std::vector<gfx::Size> ComputeTopicSizes(
    const cc::SkottieResourceMetadataMap& resource_metadata) {
  static constexpr gfx::Size kDefaultTopicSize = gfx::Size(500, 500);

  gfx::Size landscape_size =
      SummarizeImageAssetSizes(resource_metadata, /*is_portrait=*/false);
  gfx::Size portrait_size =
      SummarizeImageAssetSizes(resource_metadata, /*is_portrait=*/true);
  std::vector<gfx::Size> output;
  if (!landscape_size.IsEmpty())
    output.push_back(std::move(landscape_size));
  if (!portrait_size.IsEmpty())
    output.push_back(std::move(portrait_size));

  if (output.empty()) {
    LOG(DFATAL) << "Failed to compute topic sizes for animation. Animation "
                   "file is likely invalid.";
    return {kDefaultTopicSize};
  }
  return output;
}

}  // namespace

AmbientTopicQueueAnimationDelegate::AmbientTopicQueueAnimationDelegate(
    const cc::SkottieResourceMetadataMap& resource_metadata)
    : topic_sizes_(ComputeTopicSizes(resource_metadata)) {}

AmbientTopicQueueAnimationDelegate::~AmbientTopicQueueAnimationDelegate() =
    default;

std::vector<gfx::Size> AmbientTopicQueueAnimationDelegate::GetTopicSizes() {
  // At the time this was written, UX has agreed that the landscape and portrait
  // versions of a given animation theme will have the same image asset sizes
  // (only the animation's layout will be different). Thus, it is sufficient
  // and simplest to just compute the desired topic sizes once with whichever
  // version of the animation is loaded initially (either topic or landscape).
  //
  // If this changes in the future, this will need to recompute topic sizes with
  // the new animation orientation.
  return topic_sizes_;
}

}  // namespace ash