File: graphite_image_provider.cc

package info (click to toggle)
chromium 139.0.7258.127-1
  • links: PTS, VCS
  • area: main
  • in suites:
  • size: 6,122,068 kB
  • sloc: cpp: 35,100,771; ansic: 7,163,530; javascript: 4,103,002; python: 1,436,920; asm: 946,517; xml: 746,709; pascal: 187,653; perl: 88,691; sh: 88,436; objc: 79,953; sql: 51,488; cs: 44,583; fortran: 24,137; makefile: 22,147; tcl: 15,277; php: 13,980; yacc: 8,984; ruby: 7,485; awk: 3,720; lisp: 3,096; lex: 1,327; ada: 727; jsp: 228; sed: 36
file content (113 lines) | stat: -rw-r--r-- 4,085 bytes parent folder | download | duplicates (9)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
// Copyright 2023 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "gpu/command_buffer/service/graphite_image_provider.h"
#include "base/metrics/histogram_macros.h"
#include "third_party/skia/include/gpu/graphite/Image.h"

namespace gpu {

GraphiteImageProvider::ImageHolder::ImageHolder(sk_sp<SkImage> image)
    : image(std::move(image)), last_use_time(base::TimeTicks::Now()) {}
GraphiteImageProvider::ImageHolder::ImageHolder(ImageHolder&&) = default;
GraphiteImageProvider::ImageHolder&
GraphiteImageProvider::ImageHolder::operator=(ImageHolder&&) = default;
GraphiteImageProvider::ImageHolder::~ImageHolder() = default;

GraphiteImageProvider::GraphiteImageProvider(size_t max_cache_bytes)
    : preferred_max_cache_bytes_(max_cache_bytes) {
  CHECK(preferred_max_cache_bytes_);
}

GraphiteImageProvider::~GraphiteImageProvider() = default;

sk_sp<SkImage> GraphiteImageProvider::findOrCreate(
    skgpu::graphite::Recorder* recorder,
    const SkImage* image,
    SkImage::RequiredProperties required_props) {
  // If no mipmaps are required, check to see if we have a mipmapped version
  // anyway - since it can be used in that case.
  // TODO: we could get fancy and, if ever a mipmapped key eclipsed a
  // non-mipmapped key, we could remove the hidden non-mipmapped key/image
  // from the cache.
  if (!required_props.fMipmapped) {
    auto mipmapped_props = required_props;
    mipmapped_props.fMipmapped = true;
    ImageKey mipmapped_key(image, mipmapped_props);
    auto result = cache_.Get(mipmapped_key);
    if (result != cache_.end()) {
      result->second.last_use_time = base::TimeTicks::Now();
      return result->second.image;
    }
  }

  ImageKey key(image, required_props);

  // Check whether this image has an entry in the cache and return it if so.
  auto it = cache_.Get(key);
  bool hit_in_cache = it != cache_.end();
  UMA_HISTOGRAM_BOOLEAN("Gpu.Graphite.GraphiteImageProviderAccessHitInCache",
                        hit_in_cache);

  if (hit_in_cache) {
    it->second.last_use_time = base::TimeTicks::Now();
    return it->second.image;
  }

  // Create a Graphite-backed image for `image`.
  sk_sp<SkImage> new_image =
      SkImages::TextureFromImage(recorder, image, required_props);
  if (!new_image) {
    return nullptr;
  }

  // Add the just-created Graphite-backed image to the cache.
  size_t new_image_bytes = new_image->textureSize();
  PurgeCacheIfNecessaryToAllowForNewImage(new_image_bytes);
  cache_.Put(key, ImageHolder(new_image));

  // Update the current size of the cache, which should not have overflowed its
  // max size unless the new image is itself larger than the maximum allowed
  // size.
  current_cache_bytes_ += new_image_bytes;
  CHECK(current_cache_bytes_ <= preferred_max_cache_bytes_ ||
        current_cache_bytes_ == new_image_bytes);

  return new_image;
}

void GraphiteImageProvider::PurgeCacheIfNecessaryToAllowForNewImage(
    size_t new_bytes) {
  // Check for the corner case of the new image being larger than the maximum
  // allowed size, in which case we just empty the cache.
  if (new_bytes > preferred_max_cache_bytes_) {
    ClearImageCache();
    return;
  }

  // Remove entries from the cache in LRU order until it is small enough to
  // admit `new_bytes` while remaining at or below the maximum allowed size.
  while (current_cache_bytes_ + new_bytes > preferred_max_cache_bytes_) {
    CHECK(!cache_.empty());
    current_cache_bytes_ -= cache_.rbegin()->second.image->textureSize();
    cache_.Erase(cache_.rbegin());
  }
}

void GraphiteImageProvider::PurgeImagesNotUsedSince(
    base::TimeDelta last_use_delta) {
  base::TimeTicks now = base::TimeTicks::Now();
  while (!cache_.empty() &&
         cache_.rbegin()->second.last_use_time + last_use_delta < now) {
    current_cache_bytes_ -= cache_.rbegin()->second.image->textureSize();
    cache_.Erase(cache_.rbegin());
  }
}

void GraphiteImageProvider::ClearImageCache() {
  cache_.Clear();
  current_cache_bytes_ = 0;
}

}  // namespace gpu