blob: db0f6d51d07cb0f95f8482ee8f832f6b7b265f67 [file] [log] [blame]
// Copyright 2018 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 "gpu/command_buffer/service/shared_image/shared_image_backing.h"
#include "base/notreached.h"
#include "build/build_config.h"
#include "components/viz/common/resources/resource_format_utils.h"
#include "gpu/command_buffer/service/memory_tracking.h"
#include "gpu/command_buffer/service/shared_context_state.h"
#include "gpu/command_buffer/service/shared_image/shared_image_factory.h"
#include "gpu/command_buffer/service/shared_image/shared_image_representation.h"
#include "third_party/skia/include/core/SkColorSpace.h"
namespace gpu {
namespace {
const char* BackingTypeToString(SharedImageBackingType type) {
switch (type) {
case SharedImageBackingType::kTest:
return "TestImageBacking";
case SharedImageBackingType::kExternalVkImage:
return "ExternalVkImageBacking";
case SharedImageBackingType::kD3D:
return "D3DImageBacking";
case SharedImageBackingType::kEGLImage:
return "EGLImageBacking";
case SharedImageBackingType::kAHardwareBuffer:
return "AHardwareBufferImageBacking";
case SharedImageBackingType::kAngleVulkan:
return "AngleVulkanImageBacking";
case SharedImageBackingType::kGLImage:
return "GLImageBacking";
case SharedImageBackingType::kGLTexture:
return "GLTextureImageBacking";
case SharedImageBackingType::kOzone:
return "OzoneImageBacking";
case SharedImageBackingType::kRawDraw:
return "RawDrawImageBacking";
case SharedImageBackingType::kSharedMemory:
return "SharedMemoryImageBacking";
case SharedImageBackingType::kVideo:
return "SharedImageVideo";
case SharedImageBackingType::kWrappedSkImage:
return "WrappedSkImage";
case SharedImageBackingType::kCompound:
return "CompoundImageBacking";
}
NOTREACHED();
};
} // namespace
SharedImageBacking::SharedImageBacking(const Mailbox& mailbox,
viz::ResourceFormat format,
const gfx::Size& size,
const gfx::ColorSpace& color_space,
GrSurfaceOrigin surface_origin,
SkAlphaType alpha_type,
uint32_t usage,
size_t estimated_size,
bool is_thread_safe)
: mailbox_(mailbox),
format_(format),
size_(size),
color_space_(color_space),
surface_origin_(surface_origin),
alpha_type_(alpha_type),
usage_(usage),
estimated_size_(estimated_size) {
DCHECK_CALLED_ON_VALID_THREAD(factory_thread_checker_);
if (is_thread_safe)
lock_.emplace();
}
SharedImageBacking::~SharedImageBacking() = default;
void SharedImageBacking::OnContextLost() {
AutoLock auto_lock(this);
have_context_ = false;
}
SkImageInfo SharedImageBacking::AsSkImageInfo() const {
return SkImageInfo::Make(size_.width(), size_.height(),
viz::ResourceFormatToClosestSkColorType(
/*gpu_compositing=*/true, format_),
alpha_type_, color_space_.ToSkColorSpace());
}
bool SharedImageBacking::CopyToGpuMemoryBuffer() {
return false;
}
bool SharedImageBacking::UploadFromMemory(const SkPixmap& pixmap) {
NOTREACHED();
return false;
}
bool SharedImageBacking::PresentSwapChain() {
return false;
}
void SharedImageBacking::OnMemoryDump(
const std::string& dump_name,
base::trace_event::MemoryAllocatorDump* dump,
base::trace_event::ProcessMemoryDump* pmd,
uint64_t client_tracing_id) {
NOTIMPLEMENTED();
}
std::unique_ptr<GLTextureImageRepresentation>
SharedImageBacking::ProduceGLTexture(SharedImageManager* manager,
MemoryTypeTracker* tracker) {
return nullptr;
}
std::unique_ptr<GLTextureImageRepresentation>
SharedImageBacking::ProduceRGBEmulationGLTexture(SharedImageManager* manager,
MemoryTypeTracker* tracker) {
return nullptr;
}
std::unique_ptr<GLTexturePassthroughImageRepresentation>
SharedImageBacking::ProduceGLTexturePassthrough(SharedImageManager* manager,
MemoryTypeTracker* tracker) {
return nullptr;
}
std::unique_ptr<SkiaImageRepresentation> SharedImageBacking::ProduceSkia(
SharedImageManager* manager,
MemoryTypeTracker* tracker,
scoped_refptr<SharedContextState> context_state) {
return nullptr;
}
std::unique_ptr<DawnImageRepresentation> SharedImageBacking::ProduceDawn(
SharedImageManager* manager,
MemoryTypeTracker* tracker,
WGPUDevice device,
WGPUBackendType backend_type) {
return nullptr;
}
std::unique_ptr<OverlayImageRepresentation> SharedImageBacking::ProduceOverlay(
SharedImageManager* manager,
MemoryTypeTracker* tracker) {
return nullptr;
}
std::unique_ptr<VaapiImageRepresentation> SharedImageBacking::ProduceVASurface(
SharedImageManager* manager,
MemoryTypeTracker* tracker,
VaapiDependenciesFactory* dep_factory) {
return nullptr;
}
std::unique_ptr<MemoryImageRepresentation> SharedImageBacking::ProduceMemory(
SharedImageManager* manager,
MemoryTypeTracker* tracker) {
return nullptr;
}
std::unique_ptr<RasterImageRepresentation> SharedImageBacking::ProduceRaster(
SharedImageManager* manager,
MemoryTypeTracker* tracker) {
return nullptr;
}
#if BUILDFLAG(IS_ANDROID)
std::unique_ptr<LegacyOverlayImageRepresentation>
SharedImageBacking::ProduceLegacyOverlay(SharedImageManager* manager,
MemoryTypeTracker* tracker) {
return nullptr;
}
#endif
void SharedImageBacking::AddRef(SharedImageRepresentation* representation) {
AutoLock auto_lock(this);
bool first_ref = refs_.empty();
refs_.push_back(representation);
if (first_ref) {
refs_[0]->tracker()->TrackMemAlloc(estimated_size_);
}
}
void SharedImageBacking::ReleaseRef(SharedImageRepresentation* representation) {
AutoLock auto_lock(this);
auto found = std::find(refs_.begin(), refs_.end(), representation);
DCHECK(found != refs_.end());
// If the found representation is the first (owning) ref, free the attributed
// memory.
bool released_owning_ref = found == refs_.begin();
if (released_owning_ref)
(*found)->tracker()->TrackMemFree(estimated_size_);
refs_.erase(found);
if (!released_owning_ref)
return;
if (!refs_.empty()) {
refs_[0]->tracker()->TrackMemAlloc(estimated_size_);
return;
}
}
void SharedImageBacking::RegisterImageFactory(SharedImageFactory* factory) {
DCHECK_CALLED_ON_VALID_THREAD(factory_thread_checker_);
DCHECK(!factory_);
factory_ = factory;
}
void SharedImageBacking::UnregisterImageFactory() {
DCHECK_CALLED_ON_VALID_THREAD(factory_thread_checker_);
factory_ = nullptr;
}
const char* SharedImageBacking::GetName() const {
return BackingTypeToString(GetType());
}
bool SharedImageBacking::HasAnyRefs() const {
AutoLock auto_lock(this);
return !refs_.empty();
}
void SharedImageBacking::OnReadSucceeded() {
AutoLock auto_lock(this);
if (scoped_write_uma_) {
scoped_write_uma_->SetConsumed();
scoped_write_uma_.reset();
}
}
void SharedImageBacking::OnWriteSucceeded() {
AutoLock auto_lock(this);
scoped_write_uma_.emplace();
}
size_t SharedImageBacking::EstimatedSizeForMemTracking() const {
return estimated_size_;
}
bool SharedImageBacking::have_context() const {
return have_context_;
}
SharedImageBacking::AutoLock::AutoLock(
const SharedImageBacking* shared_image_backing)
: auto_lock_(InitializeLock(shared_image_backing)) {}
SharedImageBacking::AutoLock::~AutoLock() = default;
base::Lock* SharedImageBacking::AutoLock::InitializeLock(
const SharedImageBacking* shared_image_backing) {
if (!shared_image_backing->lock_)
return nullptr;
return &shared_image_backing->lock_.value();
}
ClearTrackingSharedImageBacking::ClearTrackingSharedImageBacking(
const Mailbox& mailbox,
viz::ResourceFormat format,
const gfx::Size& size,
const gfx::ColorSpace& color_space,
GrSurfaceOrigin surface_origin,
SkAlphaType alpha_type,
uint32_t usage,
size_t estimated_size,
bool is_thread_safe)
: SharedImageBacking(mailbox,
format,
size,
color_space,
surface_origin,
alpha_type,
usage,
estimated_size,
is_thread_safe) {}
gfx::Rect ClearTrackingSharedImageBacking::ClearedRect() const {
AutoLock auto_lock(this);
return ClearedRectInternal();
}
void ClearTrackingSharedImageBacking::SetClearedRect(
const gfx::Rect& cleared_rect) {
AutoLock auto_lock(this);
SetClearedRectInternal(cleared_rect);
}
gfx::Rect ClearTrackingSharedImageBacking::ClearedRectInternal() const {
return cleared_rect_;
}
void ClearTrackingSharedImageBacking::SetClearedRectInternal(
const gfx::Rect& cleared_rect) {
cleared_rect_ = cleared_rect;
}
scoped_refptr<gfx::NativePixmap> SharedImageBacking::GetNativePixmap() {
return nullptr;
}
} // namespace gpu