common/core/hwclayer.cpp \
common/core/gpudevice.cpp \
common/core/overlaybuffer.cpp \
- common/core/overlaybuffermanager.cpp \
common/core/overlaylayer.cpp \
common/display/display.cpp \
common/display/displayplane.cpp \
common/core/gpudevice.cpp \
common/core/hwclayer.cpp \
common/core/overlaybuffer.cpp \
- common/core/overlaybuffermanager.cpp \
common/core/overlaylayer.cpp \
common/display/display.cpp \
common/display/displayqueue.cpp \
bool Compositor::DrawOffscreen(std::vector<OverlayLayer> &layers,
const std::vector<HwcRect<int>> &display_frame,
const std::vector<size_t> &source_layers,
- OverlayBufferManager *buffer_manager,
+ NativeBufferHandler *buffer_handler,
uint32_t width, uint32_t height,
HWCNativeHandle output_handle,
int32_t *retire_fence) {
}
std::unique_ptr<NativeSurface> surface(CreateBackBuffer(width, height));
- surface->InitializeForOffScreenRendering(buffer_manager, output_handle);
+ surface->InitializeForOffScreenRendering(buffer_handler, output_handle);
if (!Render(layers, surface.get(), comp_regions))
return false;
namespace hwcomposer {
-class OverlayBufferManager;
+class NativeBufferHandler;
struct OverlayLayer;
class Compositor {
bool DrawOffscreen(std::vector<OverlayLayer> &layers,
const std::vector<HwcRect<int>> &display_frame,
const std::vector<size_t> &source_layers,
- OverlayBufferManager *buffer_manager, uint32_t width,
+ NativeBufferHandler *buffer_handler, uint32_t width,
uint32_t height, HWCNativeHandle output_handle,
int32_t *retire_fence);
void InsertFence(uint64_t fence);
#include "displayplane.h"
#include "hwctrace.h"
#include "nativebufferhandler.h"
-#include "overlaybuffermanager.h"
namespace hwcomposer {
NativeSurface::~NativeSurface() {
// Ensure we close any framebuffers before
// releasing buffer.
- buffer_.reset(nullptr);
+ layer_.ResetBuffer();
if (native_handle_) {
buffer_handler_->DestroyHandle(native_handle_);
}
}
-bool NativeSurface::Init(OverlayBufferManager *buffer_manager) {
- buffer_handler_ = buffer_manager->GetNativeBufferHandler();
+bool NativeSurface::Init(NativeBufferHandler *buffer_handler) {
+ buffer_handler_ = buffer_handler;
buffer_handler_->CreateBuffer(width_, height_, 0, &native_handle_);
if (!native_handle_) {
ETRACE("NativeSurface: Failed to create buffer.");
return false;
}
- InitializeLayer(buffer_manager, native_handle_);
+ InitializeLayer(buffer_handler, native_handle_);
return true;
}
bool NativeSurface::InitializeForOffScreenRendering(
- OverlayBufferManager *buffer_manager, HWCNativeHandle native_handle) {
- InitializeLayer(buffer_manager, native_handle);
+ NativeBufferHandler *buffer_handler, HWCNativeHandle native_handle) {
+ InitializeLayer(buffer_handler, native_handle);
layer_.SetSourceCrop(HwcRect<float>(0, 0, width_, height_));
layer_.SetDisplayFrame(HwcRect<int>(0, 0, width_, height_));
layer_.GetBuffer()->CreateFrameBuffer(gpu_fd);
}
-void NativeSurface::InitializeLayer(OverlayBufferManager *buffer_manager,
+void NativeSurface::InitializeLayer(NativeBufferHandler *buffer_handler,
HWCNativeHandle native_handle) {
- buffer_.reset(new OverlayBuffer());
- buffer_->InitializeFromNativeHandle(native_handle,
- buffer_manager->GetNativeBufferHandler());
- ImportedBuffer *imported_buffer_ =
- new ImportedBuffer(buffer_.get(), buffer_manager);
- imported_buffer_->owned_buffer_ = false;
- width_ = buffer_->GetWidth();
- height_ = buffer_->GetHeight();
layer_.SetBlending(HWCBlending::kBlendingPremult);
layer_.SetTransform(0);
- layer_.SetBuffer(imported_buffer_, -1);
+ layer_.SetBuffer(buffer_handler, native_handle, -1);
}
} // namespace hwcomposer
namespace hwcomposer {
class NativeBufferHandler;
-class OverlayBufferManager;
class NativeSurface {
public:
virtual ~NativeSurface();
- bool Init(OverlayBufferManager* buffer_manager);
+ bool Init(NativeBufferHandler* buffer_handler);
- bool InitializeForOffScreenRendering(OverlayBufferManager* buffer_manager,
+ bool InitializeForOffScreenRendering(NativeBufferHandler* buffer_handler,
HWCNativeHandle native_handle);
virtual bool MakeCurrent() = 0;
OverlayLayer layer_;
private:
- void InitializeLayer(OverlayBufferManager* buffer_manager,
+ void InitializeLayer(NativeBufferHandler* buffer_handler,
HWCNativeHandle native_handle);
HWCNativeHandle native_handle_;
NativeBufferHandler* buffer_handler_;
uint32_t height_;
bool in_use_;
uint32_t framebuffer_format_;
- std::unique_ptr<OverlayBuffer> buffer_;
};
} // namespace hwcomposer
#include "compositionregion.h"
#include "nativegpuresource.h"
+#include "overlaybuffer.h"
#include "overlaylayer.h"
namespace hwcomposer {
#include <utility>
#include <vector>
+#include <nativebufferhandler.h>
+
#include "display.h"
#include "displayplanemanager.h"
#include "drmscopedtypes.h"
#include "headless.h"
#include "hwcthread.h"
-#include "overlaybuffermanager.h"
#include "spinlock.h"
#include "vblankeventhandler.h"
#include "virtualdisplay.h"
std::vector<std::unique_ptr<NativeDisplay>> displays_;
std::vector<NativeDisplay *> connected_displays_;
std::shared_ptr<DisplayHotPlugEventCallback> callback_ = NULL;
- std::unique_ptr<OverlayBufferManager> buffer_manager_;
+ std::unique_ptr<NativeBufferHandler> buffer_handler_;
int fd_ = -1;
int hotplug_fd_;
SpinLock spin_lock_;
return false;
}
- buffer_manager_.reset(new OverlayBufferManager());
- if (!buffer_manager_->Initialize(fd_)) {
- ETRACE("Failed to Initialize Buffer Manager.");
+ buffer_handler_.reset(NativeBufferHandler::CreateInstance(fd_));
+ if (!buffer_handler_) {
+ ETRACE("Failed to create native buffer handler instance");
return false;
}
}
std::unique_ptr<NativeDisplay> display(new Display(fd_, i, c->crtc_id));
- if (!display->Initialize(buffer_manager_.get())) {
+ if (!display->Initialize(buffer_handler_.get())) {
ETRACE("Failed to Initialize Display %d", c->crtc_id);
return false;
}
displays_.emplace_back(std::move(display));
}
- virtual_display_.reset(new VirtualDisplay(fd_, buffer_manager_.get(), 0, 0));
+ virtual_display_.reset(new VirtualDisplay(fd_, buffer_handler_.get(), 0, 0));
if (!UpdateDisplayState()) {
ETRACE("Failed to connect display.");
protected:
OverlayBuffer() = default;
- friend class OverlayBufferManager;
- friend class NativeSurface;
+ friend struct OverlayLayer;
private:
uint32_t width_ = 0;
+++ /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 "overlaybuffermanager.h"
-
-#include "hwctrace.h"
-#include "overlaylayer.h"
-
-namespace hwcomposer {
-
-ImportedBuffer::~ImportedBuffer() {
- if (owned_buffer_)
- buffer_manager_->UnRegisterBuffer(buffer_);
-
- if (acquire_fence_ > 0) {
- close(acquire_fence_);
- }
-}
-
-OverlayBufferManager::~OverlayBufferManager() {
-}
-
-bool OverlayBufferManager::Initialize(uint32_t gpu_fd) {
- buffer_handler_.reset(NativeBufferHandler::CreateInstance(gpu_fd));
- if (!buffer_handler_) {
- ETRACE("Failed to create native buffer handler instance");
- return false;
- }
-
- return true;
-}
-
-ImportedBuffer* OverlayBufferManager::CreateBuffer(const HwcBuffer& bo) {
- buffers_.emplace_back();
- Buffer& buffer = buffers_.back();
- buffer.buffer_.reset(new OverlayBuffer());
- buffer.buffer_->Initialize(bo);
- buffer.ref_count_ = 1;
-
- return new ImportedBuffer(buffer.buffer_.get(), this);
-}
-
-ImportedBuffer* OverlayBufferManager::CreateBufferFromNativeHandle(
- HWCNativeHandle handle) {
- buffers_.emplace_back();
- Buffer& buffer = buffers_.back();
- buffer.buffer_.reset(new OverlayBuffer());
- buffer.buffer_->InitializeFromNativeHandle(handle, buffer_handler_.get());
- buffer.ref_count_ = 1;
-
- return new ImportedBuffer(buffer.buffer_.get(), this);
-}
-
-void OverlayBufferManager::RegisterBuffer(const OverlayBuffer* const buffer) {
- for (Buffer& overlay_buffer : buffers_) {
- if (overlay_buffer.buffer_.get() != buffer)
- continue;
-
- overlay_buffer.ref_count_++;
- break;
- }
-}
-
-void OverlayBufferManager::RegisterBuffers(
- const std::vector<const OverlayBuffer*>& buffers) {
- for (const OverlayBuffer* const buffer : buffers) {
- for (Buffer& overlay_buffer : buffers_) {
- if (overlay_buffer.buffer_.get() != buffer)
- continue;
-
- overlay_buffer.ref_count_++;
- break;
- }
- }
-}
-
-void OverlayBufferManager::UnRegisterBuffer(const OverlayBuffer* const buffer) {
- int32_t index = -1;
- for (Buffer& overlay_buffer : buffers_) {
- index++;
- if (overlay_buffer.buffer_.get() != buffer)
- continue;
-
- overlay_buffer.ref_count_--;
- if (overlay_buffer.ref_count_ > 0) {
- index = -1;
- }
-
- break;
- }
-
- if (index >= 0 && index < buffers_.size()) {
- buffers_.erase(buffers_.begin() + index);
- }
-}
-
-void OverlayBufferManager::UnRegisterLayerBuffers(
- std::vector<OverlayLayer>& layers) {
- CTRACE();
- for (OverlayLayer& layer : layers) {
- const OverlayBuffer* const buffer = layer.GetBuffer();
- if (!buffer)
- continue;
- int32_t index = -1;
- for (Buffer& overlay_buffer : buffers_) {
- index++;
- if (overlay_buffer.buffer_.get() != buffer)
- continue;
-
- overlay_buffer.ref_count_--;
- layer.ReleaseBuffer();
- if (overlay_buffer.ref_count_ > 0) {
- index = -1;
- }
-
- break;
- }
-
- if (index >= 0 && index < buffers_.size()) {
- buffers_.erase(buffers_.begin() + index);
- }
- }
-}
-
-} // namespace hwcomposer
+++ /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.
-*/
-#ifndef COMMON_CORE_OVERLAYBUFFERMANAGER_H_
-#define COMMON_CORE_OVERLAYBUFFERMANAGER_H_
-
-#include <platformdefines.h>
-
-#include <nativebufferhandler.h>
-
-#include <memory>
-#include <vector>
-
-#include "overlaybuffer.h"
-
-namespace hwcomposer {
-
-class NativeBufferHandler;
-class OverlayBufferManager;
-struct OverlayLayer;
-
-struct ImportedBuffer {
- public:
- ImportedBuffer(OverlayBuffer* const buffer,
- OverlayBufferManager* buffer_manager)
- : buffer_(buffer), buffer_manager_(buffer_manager) {
- }
-
- ~ImportedBuffer();
-
- OverlayBuffer* const buffer_;
- bool owned_buffer_ = true;
- int32_t acquire_fence_ = -1;
-
- private:
- OverlayBufferManager* buffer_manager_;
-};
-
-class OverlayBufferManager {
- public:
- OverlayBufferManager() = default;
- OverlayBufferManager(OverlayBufferManager&& rhs) = default;
- OverlayBufferManager& operator=(OverlayBufferManager&& other) = default;
-
- ~OverlayBufferManager();
-
- bool Initialize(uint32_t gpu_fd);
-
- // Creates new ImportedBuffer for bo. Also, creates
- // a sync fence object associated for this buffer.
- // Sync fence is automatically signalled when buffer
- // is destroyed. RefCount of buffer is initialized to
- // 1.
- ImportedBuffer* CreateBuffer(const HwcBuffer& bo);
-
- // Creates new ImportedBuffer for handle. Also, creates
- // a sync fence object associated for this buffer.
- // Sync fence is automatically signalled when buffer
- // is destroyed. RefCount of buffer is initialized to
- // 1.
- ImportedBuffer* CreateBufferFromNativeHandle(HWCNativeHandle handle);
-
- // Increments RefCount of buffer by 1. Buffer will not be released
- // or associated fence object signalled until UnRegisterBuffer
- // is called and RefCount decreases to zero.
- void RegisterBuffer(const OverlayBuffer* const buffer);
-
- // Decreases RefCount of buffer by 1. Buffer will be released
- // and associated fence object will be signalled if RefCount
- // is equal to zero.
- void UnRegisterBuffer(const OverlayBuffer* const buffer);
-
- // Convenient function to call together RegisterBuffer for
- // OverlayBuffers.
- void RegisterBuffers(const std::vector<const OverlayBuffer*>& buffers);
-
- // Convenient function to call together UnRegisterBuffers for
- // layers.
- void UnRegisterLayerBuffers(std::vector<OverlayLayer>& layers);
-
- NativeBufferHandler* GetNativeBufferHandler() const {
- return buffer_handler_.get();
- }
-
- private:
- struct Buffer {
- std::unique_ptr<OverlayBuffer> buffer_;
- uint32_t ref_count_ = 0;
- };
-
- std::vector<Buffer> buffers_;
- std::unique_ptr<NativeBufferHandler> buffer_handler_;
-};
-
-} // namespace hwcomposer
-#endif // COMMON_CORE_OVERLAYBUFFERMANAGER_H_
#include "hwcutils.h"
#include <hwclayer.h>
+#include <nativebufferhandler.h>
namespace hwcomposer {
+OverlayLayer::ImportedBuffer::~ImportedBuffer() {
+ if (acquire_fence_ > 0) {
+ close(acquire_fence_);
+ }
+}
+
+OverlayLayer::ImportedBuffer::ImportedBuffer(OverlayBuffer* buffer,
+ int32_t acquire_fence)
+ : acquire_fence_(acquire_fence) {
+ buffer_.reset(buffer);
+}
+
void OverlayLayer::SetAcquireFence(int32_t acquire_fence) {
// Release any existing fence.
if (imported_buffer_->acquire_fence_ > 0) {
}
OverlayBuffer* OverlayLayer::GetBuffer() const {
- return imported_buffer_->buffer_;
+ return imported_buffer_->buffer_.get();
}
-void OverlayLayer::SetBuffer(ImportedBuffer* buffer, int32_t acquire_fence) {
- imported_buffer_.reset(buffer);
- imported_buffer_->acquire_fence_ = acquire_fence;
+void OverlayLayer::SetBuffer(NativeBufferHandler* buffer_handler,
+ HWCNativeHandle handle, int32_t acquire_fence) {
+ OverlayBuffer* buffer = new OverlayBuffer();
+ buffer->InitializeFromNativeHandle(handle, buffer_handler);
+ imported_buffer_.reset(new ImportedBuffer(buffer, acquire_fence));
}
-void OverlayLayer::ReleaseBuffer() {
- imported_buffer_->owned_buffer_ = false;
+void OverlayLayer::ResetBuffer() {
+ imported_buffer_.reset(nullptr);
}
void OverlayLayer::SetIndex(uint32_t index) {
void OverlayLayer::ValidatePreviousFrameState(const OverlayLayer& rhs,
HwcLayer* layer) {
- OverlayBuffer* buffer = imported_buffer_->buffer_;
+ OverlayBuffer* buffer = imported_buffer_->buffer_.get();
if (!prefer_separate_plane_)
prefer_separate_plane_ = rhs.prefer_separate_plane_;
#include <memory>
-#include "overlaybuffermanager.h"
+#include "overlaybuffer.h"
namespace hwcomposer {
struct HwcLayer;
+class OverlayBuffer;
+class NativeBufferHandler;
struct OverlayLayer {
void SetAcquireFence(int32_t acquire_fence);
OverlayBuffer* GetBuffer() const;
- void SetBuffer(ImportedBuffer* buffer, int32_t acquire_fence);
-
- // Only KMSFenceEventHandler should use this.
- // KMSFenceEventHandler will call this API when
- // the buffer associated with this layer is no
- // longer owned by this layer.
- void ReleaseBuffer();
+ void SetBuffer(NativeBufferHandler* buffer_handler, HWCNativeHandle handle,
+ int32_t acquire_fence);
+ void ResetBuffer();
void SetSourceCrop(const HwcRect<float>& source_crop);
const HwcRect<float>& GetSourceCrop() const {
kLayerAcquireFenceSignalled = 1 << 3
};
+ struct ImportedBuffer {
+ public:
+ ImportedBuffer(OverlayBuffer* buffer, int32_t acquire_fence);
+ ~ImportedBuffer();
+
+ std::unique_ptr<OverlayBuffer> buffer_;
+ int32_t acquire_fence_ = -1;
+ };
+
uint32_t transform_;
uint32_t rotation_;
uint32_t index_;
display_queue_->SetPowerMode(kOff);
}
-bool Display::Initialize(OverlayBufferManager *buffer_manager) {
- display_queue_.reset(new DisplayQueue(gpu_fd_, crtc_id_, buffer_manager));
+bool Display::Initialize(NativeBufferHandler *buffer_handler) {
+ display_queue_.reset(new DisplayQueue(gpu_fd_, crtc_id_, buffer_handler));
return true;
}
class DisplayPlaneState;
class DisplayPlaneManager;
class DisplayQueue;
-class OverlayBufferManager;
+class NativeBufferHandler;
class GpuDevice;
struct HwcLayer;
Display(uint32_t gpu_fd, uint32_t pipe_id, uint32_t crtc_id);
~Display() override;
- bool Initialize(OverlayBufferManager *buffer_manager) override;
+ bool Initialize(NativeBufferHandler *buffer_handler) override;
DisplayType Type() const override {
return DisplayType::kInternal;
namespace hwcomposer {
DisplayPlaneManager::DisplayPlaneManager(int gpu_fd, uint32_t crtc_id,
- OverlayBufferManager *buffer_manager)
- : buffer_manager_(buffer_manager),
+ NativeBufferHandler *buffer_handler)
+ : buffer_handler_(buffer_handler),
width_(0),
height_(0),
crtc_id_(crtc_id),
if (!surface) {
NativeSurface *new_surface = CreateBackBuffer(width_, height_);
- new_surface->Init(buffer_manager_);
+ new_surface->Init(buffer_handler_);
surfaces_.emplace_back(std::move(new_surface));
surface = surfaces_.back().get();
}
class DisplayPlane;
class DisplayPlaneState;
class GpuDevice;
-class OverlayBufferManager;
+class NativeBufferHandler;
struct OverlayLayer;
class DisplayPlaneManager {
public:
DisplayPlaneManager(int gpu_fd, uint32_t crtc_id,
- OverlayBufferManager *buffer_manager);
+ NativeBufferHandler *buffer_handler);
virtual ~DisplayPlaneManager();
const std::vector<OverlayPlane> &commit_planes) const;
void ValidateFinalLayers(DisplayPlaneStateList &list,
- std::vector<OverlayLayer> &layers);
+ std::vector<OverlayLayer> &layers);
- OverlayBufferManager *buffer_manager_;
+ NativeBufferHandler *buffer_handler_;
std::vector<std::unique_ptr<NativeSurface>> surfaces_;
std::unique_ptr<DisplayPlane> primary_plane_;
std::unique_ptr<DisplayPlane> cursor_plane_;
namespace hwcomposer {
DisplayQueue::DisplayQueue(uint32_t gpu_fd, uint32_t crtc_id,
- OverlayBufferManager* buffer_manager)
+ NativeBufferHandler* buffer_handler)
: frame_(0),
dpms_prop_(0),
out_fence_ptr_prop_(0),
broadcastrgb_id_(0),
broadcastrgb_full_(-1),
broadcastrgb_automatic_(-1),
- buffer_manager_(buffer_manager) {
+ buffer_handler_(buffer_handler) {
compositor_.Init();
ScopedDrmObjectPropertyPtr crtc_props(
drmModeObjectGetProperties(gpu_fd_, crtc_id_, DRM_MODE_OBJECT_CRTC));
memset(&mode_, 0, sizeof(mode_));
display_plane_manager_.reset(
- new DisplayPlaneManager(gpu_fd_, crtc_id_, buffer_manager_));
+ new DisplayPlaneManager(gpu_fd_, crtc_id_, buffer_handler_));
vblank_handler_.reset(new VblankEventHandler(this));
overlay_layer.SetDisplayFrame(layer->GetDisplayFrame());
overlay_layer.SetIndex(layer_index);
layers_rects.emplace_back(layer->GetDisplayFrame());
- ImportedBuffer* buffer =
- buffer_manager_->CreateBufferFromNativeHandle(layer->GetNativeHandle());
- overlay_layer.SetBuffer(buffer, layer->GetAcquireFence());
-
+ overlay_layer.SetBuffer(buffer_handler_, layer->GetNativeHandle(),
+ layer->GetAcquireFence());
overlay_layer.ValidateForOverlayUsage();
if (frame_changed) {
surface->SetInUse(false);
}
- buffer_manager_->UnRegisterLayerBuffers(previous_layers_);
previous_layers_.swap(in_flight_layers_);
in_flight_layers_.swap(layers);
previous_plane_state_.swap(current_composition_planes);
DRM_MODE_DPMS_OFF);
compositor_.Reset();
vblank_handler_->SetPowerMode(kOff);
- if (previous_layers_.size())
- buffer_manager_->UnRegisterLayerBuffers(previous_layers_);
-
- if (in_flight_layers_.size())
- buffer_manager_->UnRegisterLayerBuffers(in_flight_layers_);
-
std::vector<OverlayLayer>().swap(previous_layers_);
std::vector<OverlayLayer>().swap(in_flight_layers_);
previous_plane_state_.clear();
class DisplayPlaneManager;
struct HwcLayer;
-class OverlayBufferManager;
+class NativeBufferHandler;
class DisplayQueue {
public:
DisplayQueue(uint32_t gpu_fd, uint32_t crtc_id,
- OverlayBufferManager* buffer_manager);
+ NativeBufferHandler* buffer_handler);
~DisplayQueue();
bool Initialize(float refresh, uint32_t width, uint32_t height, uint32_t pipe,
std::vector<OverlayLayer> in_flight_layers_;
std::vector<OverlayLayer> previous_layers_;
DisplayPlaneStateList previous_plane_state_;
- OverlayBufferManager* buffer_manager_;
+ NativeBufferHandler* buffer_handler_;
std::vector<NativeSurface*> in_flight_surfaces_;
std::vector<NativeSurface*> previous_surfaces_;
FrameStateTracker idle_tracker_;
Headless::~Headless() {
}
-bool Headless::Initialize(OverlayBufferManager * /*buffer_manager*/) {
+bool Headless::Initialize(NativeBufferHandler * /*buffer_manager*/) {
return true;
}
Headless(uint32_t gpu_fd, uint32_t pipe_id, uint32_t crtc_id);
~Headless() override;
- bool Initialize(OverlayBufferManager *buffer_manager) override;
+ bool Initialize(NativeBufferHandler *buffer_handler) override;
DisplayType Type() const override {
return DisplayType::kHeadless;
#include <drm_fourcc.h>
#include <hwclayer.h>
+#include <nativebufferhandler.h>
#include <vector>
#include "hwctrace.h"
-#include "overlaybuffermanager.h"
#include "overlaylayer.h"
#include "hwcutils.h"
namespace hwcomposer {
VirtualDisplay::VirtualDisplay(uint32_t gpu_fd,
- OverlayBufferManager *buffer_manager,
+ NativeBufferHandler *buffer_handler,
uint32_t pipe_id, uint32_t crtc_id)
: Headless(gpu_fd, pipe_id, crtc_id),
output_handle_(0),
acquire_fence_(-1),
- buffer_manager_(buffer_manager),
+ buffer_handler_(buffer_handler),
width_(0),
height_(0) {
}
overlay_layer.SetIndex(layer_index);
layers_rects.emplace_back(layer->GetDisplayFrame());
index.emplace_back(layer_index);
- ImportedBuffer *buffer =
- buffer_manager_->CreateBufferFromNativeHandle(layer->GetNativeHandle());
-
- overlay_layer.SetBuffer(buffer, layer->GetAcquireFence());
+ overlay_layer.SetBuffer(buffer_handler_, layer->GetNativeHandle(),
+ layer->GetAcquireFence());
}
if (acquire_fence_ > 0) {
}
// Prepare for final composition.
- if (!compositor_.DrawOffscreen(layers, layers_rects, index, buffer_manager_,
+ if (!compositor_.DrawOffscreen(layers, layers_rects, index, buffer_handler_,
width_, height_, output_handle_,
retire_fence)) {
ETRACE("Failed to prepare for the frame composition ret=%d", ret);
namespace hwcomposer {
struct HwcLayer;
-class OverlayBufferManager;
+class NativeBufferHandler;
class VirtualDisplay : public Headless {
public:
- VirtualDisplay(uint32_t gpu_fd, OverlayBufferManager *buffer_manager,
+ VirtualDisplay(uint32_t gpu_fd, NativeBufferHandler *buffer_handler,
uint32_t pipe_id, uint32_t crtc_id);
~VirtualDisplay() override;
private:
HWCNativeHandle output_handle_;
int32_t acquire_fence_ = -1;
- OverlayBufferManager *buffer_manager_;
+ NativeBufferHandler *buffer_handler_;
Compositor compositor_;
uint32_t width_;
uint32_t height_;
namespace hwcomposer {
struct HwcLayer;
class GpuDevice;
-class OverlayBufferManager;
+class NativeBufferHandler;
class VsyncCallback {
public:
virtual ~NativeDisplay() {
}
- virtual bool Initialize(OverlayBufferManager *buffer_manager) = 0;
+ virtual bool Initialize(NativeBufferHandler *buffer_handler) = 0;
virtual DisplayType Type() const = 0;
OSDN Git Service
