Merge "drm_hwcomposer: Use mode vrefresh if provided" into mnc-dr-dev
diff --git a/drmcompositorworker.h b/drmcompositorworker.h
index 9f74fb6..00e14ee 100644
--- a/drmcompositorworker.h
+++ b/drmcompositorworker.h
@@ -26,12 +26,12 @@
class DrmCompositorWorker : public Worker {
public:
DrmCompositorWorker(DrmDisplayCompositor *compositor);
- ~DrmCompositorWorker();
+ ~DrmCompositorWorker() override;
int Init();
protected:
- virtual void Routine();
+ void Routine() override;
DrmDisplayCompositor *compositor_;
};
diff --git a/drmdisplaycompositor.cpp b/drmdisplaycompositor.cpp
index c3042f5..3f41fca 100644
--- a/drmdisplaycompositor.cpp
+++ b/drmdisplaycompositor.cpp
@@ -35,7 +35,7 @@
#include <sync/sync.h>
#include <utils/Trace.h>
-#define DRM_DISPLAY_COMPOSITOR_MAX_QUEUE_DEPTH 3
+#define DRM_DISPLAY_COMPOSITOR_MAX_QUEUE_DEPTH 2
namespace android {
@@ -174,10 +174,68 @@
});
}
+DrmDisplayCompositor::FrameWorker::FrameWorker(DrmDisplayCompositor *compositor)
+ : Worker("frame-worker", HAL_PRIORITY_URGENT_DISPLAY),
+ compositor_(compositor) {
+}
+
+DrmDisplayCompositor::FrameWorker::~FrameWorker() {
+}
+
+int DrmDisplayCompositor::FrameWorker::Init() {
+ return InitWorker();
+}
+
+void DrmDisplayCompositor::FrameWorker::QueueFrame(
+ std::unique_ptr<DrmDisplayComposition> composition, int status) {
+ Lock();
+ FrameState frame;
+ frame.composition = std::move(composition);
+ frame.status = status;
+ frame_queue_.push(std::move(frame));
+ SignalLocked();
+ Unlock();
+}
+
+void DrmDisplayCompositor::FrameWorker::Routine() {
+ int ret = Lock();
+ if (ret) {
+ ALOGE("Failed to lock worker, %d", ret);
+ return;
+ }
+
+ int wait_ret = 0;
+ if (frame_queue_.empty()) {
+ wait_ret = WaitForSignalOrExitLocked();
+ }
+
+ FrameState frame;
+ if (!frame_queue_.empty()) {
+ frame = std::move(frame_queue_.front());
+ frame_queue_.pop();
+ }
+
+ ret = Unlock();
+ if (ret) {
+ ALOGE("Failed to unlock worker, %d", ret);
+ return;
+ }
+
+ if (wait_ret == -EINTR) {
+ return;
+ } else if (wait_ret) {
+ ALOGE("Failed to wait for signal, %d", wait_ret);
+ return;
+ }
+
+ compositor_->ApplyFrame(std::move(frame.composition), frame.status);
+}
+
DrmDisplayCompositor::DrmDisplayCompositor()
: drm_(NULL),
display_(-1),
worker_(this),
+ frame_worker_(this),
initialized_(false),
active_(false),
needs_modeset_(false),
@@ -196,6 +254,7 @@
return;
worker_.Exit();
+ frame_worker_.Exit();
int ret = pthread_mutex_lock(&lock_);
if (ret)
@@ -229,6 +288,12 @@
ALOGE("Failed to initialize compositor worker %d\n", ret);
return ret;
}
+ ret = frame_worker_.Init();
+ if (ret) {
+ pthread_mutex_destroy(&lock_);
+ ALOGE("Failed to initialize frame worker %d\n", ret);
+ return ret;
+ }
initialized_ = true;
return 0;
@@ -438,7 +503,7 @@
return 0;
}
-int DrmDisplayCompositor::ApplyFrame(DrmDisplayComposition *display_comp) {
+int DrmDisplayCompositor::PrepareFrame(DrmDisplayComposition *display_comp) {
int ret = 0;
std::vector<DrmHwcLayer> &layers = display_comp->layers();
@@ -497,6 +562,39 @@
framebuffer_index_ = (framebuffer_index_ + 1) % DRM_DISPLAY_BUFFERS;
}
+ for (DrmCompositionPlane &comp_plane : comp_planes) {
+ switch (comp_plane.source_layer) {
+ case DrmCompositionPlane::kSourceSquash:
+ comp_plane.source_layer = squash_layer_index;
+ break;
+ case DrmCompositionPlane::kSourcePreComp:
+ if (!do_pre_comp) {
+ ALOGE(
+ "Can not use pre composite framebuffer with no pre composite "
+ "regions");
+ return -EINVAL;
+ }
+ comp_plane.source_layer = pre_comp_layer_index;
+ break;
+ default:
+ break;
+ }
+ }
+
+ return ret;
+}
+
+int DrmDisplayCompositor::CommitFrame(DrmDisplayComposition *display_comp) {
+ int ret = 0;
+
+ std::vector<DrmHwcLayer> &layers = display_comp->layers();
+ std::vector<DrmCompositionPlane> &comp_planes =
+ display_comp->composition_planes();
+ std::vector<DrmCompositionRegion> &pre_comp_regions =
+ display_comp->pre_comp_regions();
+
+ DrmFramebuffer *pre_comp_fb;
+
DrmConnector *connector = drm_->GetConnectorForDisplay(display_);
if (!connector) {
ALOGE("Could not locate connector for display %d", display_);
@@ -568,27 +666,12 @@
switch (comp_plane.source_layer) {
case DrmCompositionPlane::kSourceNone:
break;
- case DrmCompositionPlane::kSourceSquash: {
- DrmHwcLayer &layer = layers[squash_layer_index];
- fb_id = layer.buffer->fb_id;
- display_frame = layer.display_frame;
- source_crop = layer.source_crop;
+ case DrmCompositionPlane::kSourceSquash:
+ ALOGE("Actual source layer index expected for squash layer");
break;
- }
- case DrmCompositionPlane::kSourcePreComp: {
- if (!do_pre_comp) {
- ALOGE(
- "Can not use pre composite framebuffer with no pre composite "
- "regions");
- ret = -EINVAL;
- goto out;
- }
- DrmHwcLayer &layer = layers[pre_comp_layer_index];
- fb_id = layer.buffer->fb_id;
- display_frame = layer.display_frame;
- source_crop = layer.source_crop;
+ case DrmCompositionPlane::kSourcePreComp:
+ ALOGE("Actual source layer index expected for pre-comp layer");
break;
- }
default: {
if (comp_plane.source_layer >= layers.size()) {
ALOGE("Source layer index %zu out of bounds %zu",
@@ -776,6 +859,38 @@
return 0;
}
+void DrmDisplayCompositor::ApplyFrame(
+ std::unique_ptr<DrmDisplayComposition> composition, int status) {
+ int ret = status;
+
+ if (!ret)
+ ret = CommitFrame(composition.get());
+
+ if (ret) {
+ ALOGE("Composite failed for display %d", display_);
+
+ // Disable the hw used by the last active composition. This allows us to
+ // signal the release fences from that composition to avoid hanging.
+ if (DisablePlanes(active_composition_.get()))
+ return;
+ }
+ ++dump_frames_composited_;
+
+ if (active_composition_)
+ active_composition_->SignalCompositionDone();
+
+ ret = pthread_mutex_lock(&lock_);
+ if (ret)
+ ALOGE("Failed to acquire lock for active_composition swap");
+
+ active_composition_.swap(composition);
+
+ if (!ret)
+ ret = pthread_mutex_unlock(&lock_);
+ if (ret)
+ ALOGE("Failed to release lock for active_composition swap");
+}
+
int DrmDisplayCompositor::Composite() {
ATRACE_CALL();
@@ -813,16 +928,8 @@
switch (composition->type()) {
case DRM_COMPOSITION_TYPE_FRAME:
- ret = ApplyFrame(composition.get());
- if (ret) {
- ALOGE("Composite failed for display %d", display_);
-
- // Disable the hw used by the last active composition. This allows us to
- // signal the release fences from that composition to avoid hanging.
- if (DisablePlanes(active_composition_.get()))
- return ret;
- }
- ++dump_frames_composited_;
+ ret = PrepareFrame(composition.get());
+ frame_worker_.QueueFrame(std::move(composition), ret);
break;
case DRM_COMPOSITION_TYPE_DPMS:
ret = ApplyDpms(composition.get());
@@ -838,20 +945,6 @@
return -EINVAL;
}
- if (active_composition_)
- active_composition_->SignalCompositionDone();
-
- ret = pthread_mutex_lock(&lock_);
- if (ret)
- ALOGE("Failed to acquire lock for active_composition swap");
-
- active_composition_.swap(composition);
-
- if (!ret)
- ret = pthread_mutex_unlock(&lock_);
- if (ret)
- ALOGE("Failed to release lock for active_composition swap");
-
return ret;
}
diff --git a/drmdisplaycompositor.h b/drmdisplaycompositor.h
index e9b529b..e756fde 100644
--- a/drmdisplaycompositor.h
+++ b/drmdisplaycompositor.h
@@ -40,7 +40,7 @@
class SquashState {
public:
- static const unsigned kHistoryLength = 6; // TODO: make this number not magic
+ static const unsigned kHistoryLength = 6; // TODO: make this number not magic
static const unsigned kMaxLayers = 64;
struct Region {
@@ -100,6 +100,28 @@
}
private:
+ struct FrameState {
+ std::unique_ptr<DrmDisplayComposition> composition;
+ int status = 0;
+ };
+
+ class FrameWorker : public Worker {
+ public:
+ FrameWorker(DrmDisplayCompositor *compositor);
+ ~FrameWorker() override;
+
+ int Init();
+ void QueueFrame(std::unique_ptr<DrmDisplayComposition> composition,
+ int status);
+
+ protected:
+ void Routine() override;
+
+ private:
+ DrmDisplayCompositor *compositor_;
+ std::queue<FrameState> frame_queue_;
+ };
+
DrmDisplayCompositor(const DrmDisplayCompositor &) = delete;
// We'll wait for acquire fences to fire for kAcquireWaitTimeoutMs,
@@ -111,14 +133,19 @@
DrmDisplayComposition *display_comp);
int ApplySquash(DrmDisplayComposition *display_comp);
int ApplyPreComposite(DrmDisplayComposition *display_comp);
- int ApplyFrame(DrmDisplayComposition *display_comp);
+ int PrepareFrame(DrmDisplayComposition *display_comp);
+ int CommitFrame(DrmDisplayComposition *display_comp);
int ApplyDpms(DrmDisplayComposition *display_comp);
int DisablePlanes(DrmDisplayComposition *display_comp);
+ void ApplyFrame(std::unique_ptr<DrmDisplayComposition> composition,
+ int status);
+
DrmResources *drm_;
int display_;
DrmCompositorWorker worker_;
+ FrameWorker frame_worker_;
std::queue<std::unique_ptr<DrmDisplayComposition>> composite_queue_;
std::unique_ptr<DrmDisplayComposition> active_composition_;
diff --git a/drmgenericimporter.h b/drmgenericimporter.h
index d509ed8..c362c17 100644
--- a/drmgenericimporter.h
+++ b/drmgenericimporter.h
@@ -27,12 +27,12 @@
class DrmGenericImporter : public Importer {
public:
DrmGenericImporter(DrmResources *drm);
- virtual ~DrmGenericImporter();
+ ~DrmGenericImporter() override;
int Init();
- virtual int ImportBuffer(buffer_handle_t handle, hwc_drm_bo_t *bo);
- virtual int ReleaseBuffer(hwc_drm_bo_t *bo);
+ int ImportBuffer(buffer_handle_t handle, hwc_drm_bo_t *bo) override;
+ int ReleaseBuffer(hwc_drm_bo_t *bo) override;
private:
uint32_t ConvertHalFormatToDrm(uint32_t hal_format);
diff --git a/drmhwcgralloc.h b/drmhwcgralloc.h
index 880c8a4..765c897 100644
--- a/drmhwcgralloc.h
+++ b/drmhwcgralloc.h
@@ -64,4 +64,4 @@
void *priv;
} hwc_drm_bo_t;
-#endif // ANDROID_DRMHWCGRALLOC_H_
+#endif // ANDROID_DRMHWCGRALLOC_H_
diff --git a/nvimporter.cpp b/nvimporter.cpp
index 71b3b7f..d5c3abc 100644
--- a/nvimporter.cpp
+++ b/nvimporter.cpp
@@ -161,8 +161,8 @@
ALOGE("Failed to close gem handle %d %d", i, ret);
} else {
/* Clear any duplicate gem handle as well but don't close again */
- for(int j = i + 1; j < num_gem_handles; j++)
- if(bo->gem_handles[j] == bo->gem_handles[i])
+ for (int j = i + 1; j < num_gem_handles; j++)
+ if (bo->gem_handles[j] == bo->gem_handles[i])
bo->gem_handles[j] = 0;
bo->gem_handles[i] = 0;
}
diff --git a/nvimporter.h b/nvimporter.h
index a07f577..d6033db 100644
--- a/nvimporter.h
+++ b/nvimporter.h
@@ -29,12 +29,12 @@
class NvImporter : public Importer {
public:
NvImporter(DrmResources *drm);
- virtual ~NvImporter();
+ ~NvImporter() override;
int Init();
- virtual int ImportBuffer(buffer_handle_t handle, hwc_drm_bo_t *bo);
- virtual int ReleaseBuffer(hwc_drm_bo_t *bo);
+ int ImportBuffer(buffer_handle_t handle, hwc_drm_bo_t *bo) override;
+ int ReleaseBuffer(hwc_drm_bo_t *bo) override;
private:
typedef struct NvBuffer {
diff --git a/virtualcompositorworker.cpp b/virtualcompositorworker.cpp
index e7acef0..ea46461 100644
--- a/virtualcompositorworker.cpp
+++ b/virtualcompositorworker.cpp
@@ -35,10 +35,10 @@
static const int kAcquireWaitTimeoutMs = 50;
VirtualCompositorWorker::VirtualCompositorWorker()
- : Worker("virtual-compositor", HAL_PRIORITY_URGENT_DISPLAY)
- , timeline_fd_(-1)
- , timeline_(0)
- , timeline_current_(0) {
+ : Worker("virtual-compositor", HAL_PRIORITY_URGENT_DISPLAY),
+ timeline_fd_(-1),
+ timeline_(0),
+ timeline_current_(0) {
}
VirtualCompositorWorker::~VirtualCompositorWorker() {
diff --git a/virtualcompositorworker.h b/virtualcompositorworker.h
index 4a15f0c..3066547 100644
--- a/virtualcompositorworker.h
+++ b/virtualcompositorworker.h
@@ -27,13 +27,13 @@
class VirtualCompositorWorker : public Worker {
public:
VirtualCompositorWorker();
- ~VirtualCompositorWorker();
+ ~VirtualCompositorWorker() override;
int Init();
void QueueComposite(hwc_display_contents_1_t *dc);
protected:
- virtual void Routine();
+ void Routine() override;
private:
struct VirtualComposition {
diff --git a/vsyncworker.h b/vsyncworker.h
index ce7b94a..98ac546 100644
--- a/vsyncworker.h
+++ b/vsyncworker.h
@@ -31,7 +31,7 @@
class VSyncWorker : public Worker {
public:
VSyncWorker();
- ~VSyncWorker();
+ ~VSyncWorker() override;
int Init(DrmResources *drm, int display);
int SetProcs(hwc_procs_t const *procs);
@@ -39,7 +39,7 @@
int VSyncControl(bool enabled);
protected:
- virtual void Routine();
+ void Routine() override;
private:
int64_t GetPhasedVSync(int64_t frame_ns, int64_t current);