Jira: None.
Test: Build passes on Android.
Signed-off-by: Kalyan Kondapally <kalyan.kondapally@intel.com>
compositor/va/varenderer.cpp \
core/gpudevice.cpp \
core/hwclayer.cpp \
- core/hwclayerbuffermanager.cpp \
+ core/resourcemanager.cpp \
core/logicaldisplay.cpp \
core/logicaldisplaymanager.cpp \
core/mosaicdisplay.cpp \
compositor/nativesurface.cpp \
compositor/renderstate.cpp \
core/hwclayer.cpp \
- core/hwclayerbuffermanager.cpp \
+ core/resourcemanager.cpp \
core/overlaylayer.cpp \
core/gpudevice.cpp \
core/logicaldisplay.cpp \
Compositor::~Compositor() {
}
-void Compositor::Init(HwcLayerBufferManager *buffer_manager, uint32_t gpu_fd) {
+void Compositor::Init(ResourceManager *resource_manager, uint32_t gpu_fd) {
if (!thread_)
thread_.reset(new CompositorThread());
- thread_->Initialize(buffer_manager, gpu_fd);
+ thread_->Initialize(resource_manager, gpu_fd);
}
bool Compositor::BeginFrame(bool disable_explicit_sync) {
bool Compositor::DrawOffscreen(std::vector<OverlayLayer> &layers,
const std::vector<HwcRect<int>> &display_frame,
const std::vector<size_t> &source_layers,
- HwcLayerBufferManager *resource_manager,
+ ResourceManager *resource_manager,
uint32_t width, uint32_t height,
HWCNativeHandle output_handle,
int32_t acquire_fence, int32_t *retire_fence) {
namespace hwcomposer {
class DisplayPlaneManager;
-class HwcLayerBufferManager;
+class ResourceManager;
struct OverlayLayer;
class Compositor {
Compositor();
~Compositor();
- void Init(HwcLayerBufferManager *buffer_manager, uint32_t gpu_fd);
+ void Init(ResourceManager *buffer_manager, uint32_t gpu_fd);
void Reset();
Compositor(const Compositor &) = delete;
bool DrawOffscreen(std::vector<OverlayLayer> &layers,
const std::vector<HwcRect<int>> &display_frame,
const std::vector<size_t> &source_layers,
- HwcLayerBufferManager *resource_manager, uint32_t width,
+ ResourceManager *resource_manager, uint32_t width,
uint32_t height, HWCNativeHandle output_handle,
int32_t acquire_fence, int32_t *retire_fence);
void FreeResources();
#include "hwcutils.h"
#include "hwctrace.h"
-#include "hwclayerbuffermanager.h"
#include "nativegpuresource.h"
#include "overlaylayer.h"
#include "renderer.h"
+#include "resourcemanager.h"
#include "displayplanemanager.h"
#include "nativesurface.h"
CompositorThread::~CompositorThread() {
}
-void CompositorThread::Initialize(HwcLayerBufferManager *resource_manager,
+void CompositorThread::Initialize(ResourceManager *resource_manager,
uint32_t gpu_fd) {
tasks_lock_.lock();
if (!gpu_resource_handler_)
}
void CompositorThread::FreeResources() {
- tasks_lock_.lock();
- const std::vector<ResourceHandle> &purged_resources =
- resource_manager_->GetPurgedResources();
- size_t purged_size = purged_resources.size();
// Let's not post a task if it's not needed.
- if (purged_size == 0) {
- tasks_lock_.unlock();
+ if (!resource_manager_->HasPurgedResources()) {
return;
}
+ tasks_lock_.lock();
tasks_ |= kReleaseResources;
tasks_lock_.unlock();
Resume();
ScopedSpinLock lock(tasks_lock_);
tasks_ &= ~kReleaseResources;
- const std::vector<ResourceHandle> &purged_resources =
- resource_manager_->GetPurgedResources();
+ std::vector<ResourceHandle> purged_resources;
+ resource_manager_->GetPurgedResources(purged_resources);
size_t purged_size = purged_resources.size();
if (purged_size != 0) {
handler->ReleaseBuffer(handle.handle_);
handler->DestroyHandle(handle.handle_);
}
-
- resource_manager_->ResetPurgedResources();
}
}
class OverlayBuffer;
class DisplayPlaneManager;
-class HwcLayerBufferManager;
+class ResourceManager;
class NativeBufferHandler;
class CompositorThread : public HWCThread {
CompositorThread();
~CompositorThread() override;
- void Initialize(HwcLayerBufferManager* buffer_manager, uint32_t gpu_fd);
+ void Initialize(ResourceManager* resource_manager, uint32_t gpu_fd);
void Draw(std::vector<DrawState>& states,
std::vector<DrawState>& media_states,
std::vector<DrawState> media_states_;
std::vector<ResourceHandle> purged_resources_;
bool disable_explicit_sync_;
- HwcLayerBufferManager* resource_manager_ = NULL;
+ ResourceManager* resource_manager_ = NULL;
uint32_t tasks_ = kNone;
uint32_t gpu_fd_ = 0;
FDHandler fd_chandler_;
#include "glsurface.h"
#include "hwctrace.h"
-#include "hwclayerbuffermanager.h"
#include "overlaybuffer.h"
+#include "resourcemanager.h"
#include "shim.h"
namespace hwcomposer {
#include "displayplanestate.h"
#include "hwctrace.h"
#include "nativebufferhandler.h"
-#include "hwclayerbuffermanager.h"
+#include "resourcemanager.h"
namespace hwcomposer {
}
}
-bool NativeSurface::Init(HwcLayerBufferManager *resource_manager,
- uint32_t format, bool cursor_layer) {
+bool NativeSurface::Init(ResourceManager *resource_manager, uint32_t format,
+ bool cursor_layer) {
uint32_t usage = hwcomposer::kLayerNormal;
if (cursor_layer) {
usage = hwcomposer::kLayerCursor;
}
bool NativeSurface::InitializeForOffScreenRendering(
- HWCNativeHandle native_handle, HwcLayerBufferManager *resource_manager) {
+ HWCNativeHandle native_handle, ResourceManager *resource_manager) {
resource_manager_ = resource_manager;
InitializeLayer(native_handle);
layer_.SetSourceCrop(HwcRect<float>(0, 0, width_, height_));
namespace hwcomposer {
-class HwcLayerBufferManager;
+class ResourceManager;
class DisplayPlaneState;
class NativeSurface {
virtual ~NativeSurface();
- bool Init(HwcLayerBufferManager* resource_manager, uint32_t format,
+ bool Init(ResourceManager* resource_manager, uint32_t format,
bool cursor_layer = false);
bool InitializeForOffScreenRendering(HWCNativeHandle native_handle,
- HwcLayerBufferManager* resource_manager);
+ ResourceManager* resource_manager);
virtual bool MakeCurrent() = 0;
protected:
OverlayLayer layer_;
- HwcLayerBufferManager* resource_manager_;
+ ResourceManager* resource_manager_;
private:
void InitializeLayer(HWCNativeHandle native_handle);
+++ /dev/null
-/*
-// Copyright (c) 2016 Intel Corporation
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-*/
-
-#include "hwclayerbuffermanager.h"
-
-namespace hwcomposer {
-
-HwcLayerBufferManager::HwcLayerBufferManager(
- NativeBufferHandler* buffer_handler)
- : buffer_handler_(buffer_handler) {
- for (size_t i = 0; i < BUFFER_CACHE_LENGTH; i++)
- cached_buffers_.emplace_back();
-}
-
-HwcLayerBufferManager::~HwcLayerBufferManager() {
- PurgeBuffer();
-}
-
-void HwcLayerBufferManager::PurgeBuffer() {
- for(auto &map : cached_buffers_) {
- map.clear();
- }
-}
-
-void HwcLayerBufferManager::Dump() {
-}
-
-std::shared_ptr<OverlayBuffer>& HwcLayerBufferManager::FindCachedBuffer(const HWCNativeBuffer& native_buffer) {
-
- BUFFER_MAP& first_map = cached_buffers_[0];
- static std::shared_ptr<OverlayBuffer> pBufNull = nullptr;
- for (auto& map : cached_buffers_) {
- if (map.count(native_buffer)) {
- std::shared_ptr<OverlayBuffer>& pBuf = map[native_buffer];
- if (&map != &first_map) {
- first_map.emplace(std::make_pair(native_buffer, pBuf));
- map.erase(native_buffer);
- }
-#ifdef CACHE_TRACING
- hit_count_++;
-#endif
- return pBuf;
- }
- }
-
-#ifdef CACHE_TRACING
- miss_count_++;
- if (miss_count_ % 100 == 0)
- ICACHETRACE("cache miss count is %llu, while hit count is %llu",
- miss_count_, hit_count_);
-#endif
-
- return pBufNull;
-}
-
-void HwcLayerBufferManager::RegisterBuffer(const HWCNativeBuffer& native_buffer, std::shared_ptr<OverlayBuffer>& pBuffer) {
-
- BUFFER_MAP& first_map = cached_buffers_[0];
- first_map.emplace(std::make_pair(native_buffer, pBuffer));
-}
-
-void HwcLayerBufferManager::MarkResourceForDeletion(
- const ResourceHandle& handle) {
- purged_resources_.emplace_back();
- ResourceHandle& temp = purged_resources_.back();
- temp.handle_ = handle.handle_;
- temp.image_ = handle.image_;
- temp.texture_ = handle.texture_;
- temp.fb_ = handle.fb_;
-}
-
-void HwcLayerBufferManager::RefreshBufferCache() {
- auto begin = cached_buffers_.begin();
- cached_buffers_.emplace(begin);
- cached_buffers_.pop_back();
-}
-
-void HwcLayerBufferManager::ResetPurgedResources() {
- std::vector<ResourceHandle>().swap(purged_resources_);
-}
-
-} // namespace hwcomposer
#include "hwcutils.h"
-#include "hwclayerbuffermanager.h"
+#include "resourcemanager.h"
namespace hwcomposer {
}
void OverlayLayer::SetBuffer(HWCNativeHandle handle, int32_t acquire_fence,
- HwcLayerBufferManager* resource_manager,
+ ResourceManager* resource_manager,
bool register_buffer) {
std::shared_ptr<OverlayBuffer> buffer(NULL);
}
void OverlayLayer::InitializeState(HwcLayer* layer,
- HwcLayerBufferManager* resource_manager,
+ ResourceManager* resource_manager,
OverlayLayer* previous_layer,
uint32_t z_order, uint32_t layer_index,
uint32_t max_height, HWCRotation rotation,
}
void OverlayLayer::InitializeFromHwcLayer(
- HwcLayer* layer, HwcLayerBufferManager* resource_manager,
+ HwcLayer* layer, ResourceManager* resource_manager,
OverlayLayer* previous_layer, uint32_t z_order, uint32_t layer_index,
uint32_t max_height, HWCRotation rotation, bool handle_constraints) {
display_frame_width_ = layer->GetDisplayFrameWidth();
}
void OverlayLayer::InitializeFromScaledHwcLayer(
- HwcLayer* layer, HwcLayerBufferManager* resource_manager,
+ HwcLayer* layer, ResourceManager* resource_manager,
OverlayLayer* previous_layer, uint32_t z_order, uint32_t layer_index,
const HwcRect<int>& display_frame, uint32_t max_height,
HWCRotation rotation, bool handle_constraints) {
struct HwcLayer;
class OverlayBuffer;
-class HwcLayerBufferManager;
+class ResourceManager;
struct OverlayLayer {
OverlayLayer() = default;
int32_t ReleaseAcquireFence() const;
// Initialize OverlayLayer from layer.
- void InitializeFromHwcLayer(HwcLayer* layer,
- HwcLayerBufferManager* buffer_manager,
+ void InitializeFromHwcLayer(HwcLayer* layer, ResourceManager* buffer_manager,
OverlayLayer* previous_layer, uint32_t z_order,
uint32_t layer_index, uint32_t max_height,
HWCRotation rotation, bool handle_constraints);
void InitializeFromScaledHwcLayer(HwcLayer* layer,
- HwcLayerBufferManager* buffer_manager,
+ ResourceManager* buffer_manager,
OverlayLayer* previous_layer,
uint32_t z_order, uint32_t layer_index,
const HwcRect<int>& display_frame,
OverlayBuffer* GetBuffer() const;
void SetBuffer(HWCNativeHandle handle, int32_t acquire_fence,
- HwcLayerBufferManager* buffer_manager, bool register_buffer);
+ ResourceManager* buffer_manager, bool register_buffer);
void ResetBuffer();
void SetSourceCrop(const HwcRect<float>& source_crop);
void UpdateSurfaceDamage(HwcLayer* layer);
- void InitializeState(HwcLayer* layer, HwcLayerBufferManager* buffer_manager,
+ void InitializeState(HwcLayer* layer, ResourceManager* buffer_manager,
OverlayLayer* previous_layer, uint32_t z_order,
uint32_t layer_index, uint32_t max_height,
HWCRotation rotation, bool handle_constraints);
--- /dev/null
+/*
+// Copyright (c) 2017 Intel Corporation
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+*/
+
+#include "resourcemanager.h"
+
+namespace hwcomposer {
+
+ResourceManager::ResourceManager(NativeBufferHandler* buffer_handler)
+ : buffer_handler_(buffer_handler) {
+ for (size_t i = 0; i < BUFFER_CACHE_LENGTH; i++)
+ cached_buffers_.emplace_back();
+}
+
+ResourceManager::~ResourceManager() {
+ if (cached_buffers_.size() > 0) {
+ ETRACE("ResourceManager destroyed with valid native resources \n");
+ }
+
+ if (purged_resources_.size() > 0) {
+ ETRACE("ResourceManager destroyed with valid GPU resources \n");
+ }
+}
+
+void ResourceManager::PurgeBuffer() {
+ for (auto& map : cached_buffers_) {
+ map.clear();
+ }
+}
+
+void ResourceManager::Dump() {
+}
+
+std::shared_ptr<OverlayBuffer>& ResourceManager::FindCachedBuffer(
+ const HWCNativeBuffer& native_buffer) {
+ BUFFER_MAP& first_map = cached_buffers_[0];
+ static std::shared_ptr<OverlayBuffer> pBufNull = nullptr;
+ for (auto& map : cached_buffers_) {
+ if (map.count(native_buffer)) {
+ std::shared_ptr<OverlayBuffer>& pBuf = map[native_buffer];
+ if (&map != &first_map) {
+ first_map.emplace(std::make_pair(native_buffer, pBuf));
+ map.erase(native_buffer);
+ }
+#ifdef CACHE_TRACING
+ hit_count_++;
+#endif
+ return pBuf;
+ }
+ }
+
+#ifdef CACHE_TRACING
+ miss_count_++;
+ if (miss_count_ % 100 == 0)
+ ICACHETRACE("cache miss count is %llu, while hit count is %llu",
+ miss_count_, hit_count_);
+#endif
+
+ return pBufNull;
+}
+
+void ResourceManager::RegisterBuffer(const HWCNativeBuffer& native_buffer,
+ std::shared_ptr<OverlayBuffer>& pBuffer) {
+ BUFFER_MAP& first_map = cached_buffers_[0];
+ first_map.emplace(std::make_pair(native_buffer, pBuffer));
+}
+
+void ResourceManager::MarkResourceForDeletion(const ResourceHandle& handle) {
+ lock_.lock();
+ purged_resources_.emplace_back();
+ ResourceHandle& temp = purged_resources_.back();
+ std::memcpy(&temp, &handle, sizeof temp);
+ lock_.unlock();
+}
+
+void ResourceManager::GetPurgedResources(
+ std::vector<ResourceHandle>& resources) {
+ lock_.lock();
+ size_t purged_size = purged_resources_.size();
+
+ if (purged_size != 0) {
+ for (size_t i = 0; i < purged_size; i++) {
+ const ResourceHandle& handle = purged_resources_.at(i);
+ resources.emplace_back();
+ ResourceHandle& temp = resources.back();
+ std::memcpy(&temp, &handle, sizeof temp);
+ }
+
+ std::vector<ResourceHandle>().swap(purged_resources_);
+ }
+
+ lock_.unlock();
+}
+
+bool ResourceManager::HasPurgedResources() {
+ lock_.lock();
+ bool status = purged_resources_.empty();
+ lock_.unlock();
+
+ return !status;
+}
+
+void ResourceManager::RefreshBufferCache() {
+ auto begin = cached_buffers_.begin();
+ cached_buffers_.emplace(begin);
+ cached_buffers_.pop_back();
+}
+
+} // namespace hwcomposer
*/
/*
-Design of hwclayerbuffermanager:
+Design of ResourceManager:
The purpose is to add cache magagement to external buffer owned by hwcLayer
to avoid import buffer and glimage/texture generation overhead
-1: the hwclayerbuffermanager is owned per display, as each display has a
+1: the ResourceManager is owned per display, as each display has a
separate
GL context
-2: hwclayerbuffermanager stores a refernce of external buffers in a vector
+2: ResourceManager stores a refernce of external buffers in a vector
cached_buffers, each vector member is hash map.
The vector stores history buffer in this way, vector[0] is for the current
frame buffers, vector[1] is for last frame (-1) buffers, vector[2] is -2
can be resued.
*/
-#ifndef COMMON_CORE_HWCLAYERBUFFER_MANAGER_H_
-#define COMMON_CORE_HWCLAYERBUFFER_MANAGER_H_
+#ifndef COMMON_CORE_RESOURCE_MANAGER_H_
+#define COMMON_CORE_RESOURCE_MANAGER_H_
#include <hwcdefs.h>
#include <platformdefines.h>
#include <memory>
#include <unordered_map>
+#include <spinlock.h>
+
#include "overlaybuffer.h"
namespace hwcomposer {
class OverlayBuffer;
class NativeBufferHandler;
-class HwcLayerBufferManager {
+class ResourceManager {
public:
- HwcLayerBufferManager(NativeBufferHandler* buffer_handler);
- ~HwcLayerBufferManager();
+ ResourceManager(NativeBufferHandler* buffer_handler);
+ ~ResourceManager();
void Dump();
std::shared_ptr<OverlayBuffer>& FindCachedBuffer(
const HWCNativeBuffer& native_buffer);
std::shared_ptr<OverlayBuffer>& pBuffer);
void MarkResourceForDeletion(const ResourceHandle& handle);
void RefreshBufferCache();
- const std::vector<ResourceHandle>& GetPurgedResources() const {
- return purged_resources_;
- }
- void ResetPurgedResources();
+ void GetPurgedResources(std::vector<ResourceHandle>& resources);
+ bool HasPurgedResources();
void PurgeBuffer();
const NativeBufferHandler* GetNativeBufferHandler() const {
std::vector<BUFFER_MAP> cached_buffers_;
std::vector<ResourceHandle> purged_resources_;
NativeBufferHandler* buffer_handler_;
+ SpinLock lock_;
};
} // namespace hwcomposer
-#endif // COMMON_CORE_OVERLAYLAYER_H_
+#endif // COMMON_CORE_RESOURCE_MANAGER_H_
namespace hwcomposer {
-DisplayPlaneManager::DisplayPlaneManager(
- int gpu_fd, DisplayPlaneHandler *plane_handler,
- HwcLayerBufferManager *resource_manager)
+DisplayPlaneManager::DisplayPlaneManager(int gpu_fd,
+ DisplayPlaneHandler *plane_handler,
+ ResourceManager *resource_manager)
: plane_handler_(plane_handler),
resource_manager_(resource_manager),
width_(0),
class DisplayPlane;
class DisplayPlaneState;
class GpuDevice;
-class HwcLayerBufferManager;
+class ResourceManager;
struct OverlayLayer;
class DisplayPlaneManager {
public:
DisplayPlaneManager(int gpu_fd, DisplayPlaneHandler *plane_handler,
- HwcLayerBufferManager *resource_manager);
+ ResourceManager *resource_manager);
virtual ~DisplayPlaneManager();
void PreparePlaneForCursor(DisplayPlaneState *plane);
DisplayPlaneHandler *plane_handler_;
- HwcLayerBufferManager *resource_manager_;
+ ResourceManager *resource_manager_;
DisplayPlane *cursor_plane_;
DisplayPlane *primary_plane_;
std::vector<std::unique_ptr<NativeSurface>> surfaces_;
}
vblank_handler_.reset(new VblankEventHandler(this));
- buffer_manager_.reset(new HwcLayerBufferManager(buffer_handler));
+ resource_manager_.reset(new ResourceManager(buffer_handler));
/* use 0x80 as default brightness for all colors */
brightness_ = 0x808080;
compositor_.Reset();
- if (!buffer_manager_) {
+ if (!resource_manager_) {
ETRACE("Failed to construct hwc layer buffer manager");
return false;
}
display_plane_manager_.reset(
- new DisplayPlaneManager(gpu_fd_, plane_handler, buffer_manager_.get()));
+ new DisplayPlaneManager(gpu_fd_, plane_handler, resource_manager_.get()));
if (!display_plane_manager_->Initialize(width, height)) {
ETRACE("Failed to initialize DisplayPlane Manager.");
return false;
vblank_handler_->SetPowerMode(kOn);
power_mode_lock_.lock();
state_ &= ~kIgnoreIdleRefresh;
- compositor_.Init(buffer_manager_.get(),
+ compositor_.Init(resource_manager_.get(),
display_plane_manager_->GetGpuFd());
power_mode_lock_.unlock();
break;
cursor_state_changed = true;
}
- buffer_manager_->RefreshBufferCache();
+ resource_manager_->RefreshBufferCache();
for (size_t layer_index = 0; layer_index < size; layer_index++) {
HwcLayer* layer = source_layers.at(layer_index);
(display_frame.bottom * scaling_tracker_.scaling_height);
overlay_layer->InitializeFromScaledHwcLayer(
- layer, buffer_manager_.get(), previous_layer, z_order, layer_index,
+ layer, resource_manager_.get(), previous_layer, z_order, layer_index,
display_frame, display_plane_manager_->GetHeight(), rotation_,
handle_constraints);
} else {
overlay_layer->InitializeFromHwcLayer(
- layer, buffer_manager_.get(), previous_layer, z_order, layer_index,
+ layer, resource_manager_.get(), previous_layer, z_order, layer_index,
display_plane_manager_->GetHeight(), rotation_, handle_constraints);
}
state_ |= kClonedMode;
}
- buffer_manager_->PurgeBuffer();
+ resource_manager_->PurgeBuffer();
compositor_.Reset();
cursor_state_ = kNoCursorState;
}
#include "compositor.h"
#include "displayplanemanager.h"
#include "hwcthread.h"
-#include "vblankeventhandler.h"
#include "platformdefines.h"
-#include "hwclayerbuffermanager.h"
+#include "resourcemanager.h"
+#include "vblankeventhandler.h"
namespace hwcomposer {
struct gamma_colors {
struct gamma_colors gamma_;
std::unique_ptr<VblankEventHandler> vblank_handler_;
std::unique_ptr<DisplayPlaneManager> display_plane_manager_;
- std::unique_ptr<HwcLayerBufferManager> buffer_manager_;
+ std::unique_ptr<ResourceManager> resource_manager_;
std::vector<OverlayLayer> in_flight_layers_;
DisplayPlaneStateList previous_plane_state_;
FrameStateTracker idle_tracker_;
NativeBufferHandler *buffer_handler,
uint32_t /*pipe_id*/, uint32_t /*crtc_id*/)
: output_handle_(0), acquire_fence_(-1), width_(0), height_(0) {
- buffer_manager_.reset(new HwcLayerBufferManager(buffer_handler));
- if (!buffer_manager_) {
+ resource_manager_.reset(new ResourceManager(buffer_handler));
+ if (!resource_manager_) {
ETRACE("Failed to construct hwc layer buffer manager");
}
- compositor_.Init(buffer_manager_.get(), gpu_fd);
+ compositor_.Init(resource_manager_.get(), gpu_fd);
}
VirtualDisplay::~VirtualDisplay() {
}
if (handle_) {
- buffer_manager_->GetNativeBufferHandler()->DestroyHandle(handle_);
+ resource_manager_->GetNativeBufferHandler()->DestroyHandle(handle_);
}
delete output_handle_;
*retire_fence = -1;
uint32_t z_order = 0;
- buffer_manager_->RefreshBufferCache();
+ resource_manager_->RefreshBufferCache();
for (size_t layer_index = 0; layer_index < size; layer_index++) {
HwcLayer *layer = source_layers.at(layer_index);
layer->SetReleaseFence(-1);
}
overlay_layer.InitializeFromHwcLayer(
- layer, buffer_manager_.get(), previous_layer, z_order, layer_index,
+ layer, resource_manager_.get(), previous_layer, z_order, layer_index,
width_, kRotateNone, handle_constraints);
index.emplace_back(z_order);
layers_rects.emplace_back(layer->GetDisplayFrame());
// Prepare for final composition.
if (!compositor_.DrawOffscreen(
- layers, layers_rects, index, buffer_manager_.get(), width_, height_,
- output_handle_, acquire_fence_, retire_fence)) {
+ layers, layers_rects, index, resource_manager_.get(), width_,
+ height_, output_handle_, acquire_fence_, retire_fence)) {
ETRACE("Failed to prepare for the frame composition ret=%d", ret);
return false;
}
int32_t acquire_fence) {
if (!output_handle_ || output_handle_ != buffer) {
const NativeBufferHandler *handler =
- buffer_manager_->GetNativeBufferHandler();
+ resource_manager_->GetNativeBufferHandler();
if (handle_) {
handler->DestroyHandle(handle_);
}
#include <vector>
#include "compositor.h"
-#include "hwclayerbuffermanager.h"
+#include "resourcemanager.h"
namespace hwcomposer {
struct HwcLayer;
uint32_t height_ = 1;
std::vector<OverlayLayer> in_flight_layers_;
HWCNativeHandle handle_ = 0;
- std::unique_ptr<HwcLayerBufferManager> buffer_manager_;
+ std::unique_ptr<ResourceManager> resource_manager_;
};
} // namespace hwcomposer
#include <nativebufferhandler.h>
#include "hwctrace.h"
-#include "hwclayerbuffermanager.h"
+#include "resourcemanager.h"
namespace hwcomposer {
}
}
-void DrmBuffer::InitializeFromNativeHandle(
- HWCNativeHandle handle, HwcLayerBufferManager* resource_manager) {
+void DrmBuffer::InitializeFromNativeHandle(HWCNativeHandle handle,
+ ResourceManager* resource_manager) {
const NativeBufferHandler* handler =
resource_manager->GetNativeBufferHandler();
handler->CopyHandle(handle, &image_.handle_);
image_.texture_ = texture;
}
#elif USE_VK
+ ETRACE("Missing implementation for Vulkan. \n");
#endif
return image_;
void Initialize(const HwcBuffer& bo);
- void InitializeFromNativeHandle(
- HWCNativeHandle handle, HwcLayerBufferManager* buffer_manager) override;
+ void InitializeFromNativeHandle(HWCNativeHandle handle,
+ ResourceManager* buffer_manager) override;
uint32_t GetWidth() const override {
return width_;
uint32_t gpu_fd_ = 0;
uint32_t total_planes_ = 0;
bool is_yuv_ = false;
- HwcLayerBufferManager* resource_manager_ = 0;
+ ResourceManager* resource_manager_ = 0;
ResourceHandle image_;
};
namespace hwcomposer {
class NativeBufferHandler;
-class HwcLayerBufferManager;
+class ResourceManager;
class OverlayBuffer {
public:
virtual ~OverlayBuffer() {
}
- virtual void InitializeFromNativeHandle(
- HWCNativeHandle handle, HwcLayerBufferManager* buffer_manager) = 0;
+ virtual void InitializeFromNativeHandle(HWCNativeHandle handle,
+ ResourceManager* buffer_manager) = 0;
virtual uint32_t GetWidth() const = 0;
OSDN Git Service
