2 * Copyright (C) 2015 The Android Open Source Project
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 #define LOG_TAG "hwc-drm-compositor"
19 #include "drmcompositor.h"
22 #include "drmresources.h"
29 #include <cutils/log.h>
30 #include <sync/sync.h>
34 DrmCompositor::DrmCompositor(DrmResources *drm)
37 active_composition_(NULL),
40 dump_frames_composited_(0),
41 dump_last_timestamp_ns_(0) {
43 if (clock_gettime(CLOCK_MONOTONIC, &ts))
45 dump_last_timestamp_ns_ = ts.tv_sec * 1000 * 1000 * 1000 + ts.tv_nsec;
48 DrmCompositor::~DrmCompositor() {
50 pthread_mutex_destroy(&lock_);
53 int DrmCompositor::Init() {
54 int ret = pthread_mutex_init(&lock_, NULL);
56 ALOGE("Failed to initialize drm compositor lock %d\n", ret);
61 pthread_mutex_destroy(&lock_);
62 ALOGE("Failed to initialize compositor worker %d\n", ret);
70 Composition *DrmCompositor::CreateComposition(Importer *importer) {
71 DrmComposition *composition = new DrmComposition(drm_, importer, frame_no_++);
73 ALOGE("Failed to allocate drm composition");
76 int ret = composition->Init();
78 ALOGE("Failed to initialize drm composition %d", ret);
85 int DrmCompositor::QueueComposition(Composition *composition) {
86 int ret = pthread_mutex_lock(&lock_);
88 ALOGE("Failed to acquire compositor lock %d", ret);
92 composite_queue_.push((DrmComposition *)composition);
94 ret = pthread_mutex_unlock(&lock_);
96 ALOGE("Failed to release compositor lock %d", ret);
104 int DrmCompositor::PerformModeset(DrmCompositionLayerMap_t::iterator begin,
105 DrmCompositionLayerMap_t::iterator end) {
106 DrmCompositionLayer *layer = NULL;
107 for (DrmCompositionLayerMap_t::iterator iter = begin; iter != end; ++iter) {
108 if (iter->second.layer.compositionType == HWC_FRAMEBUFFER_TARGET) {
109 layer = &iter->second;
113 int display = begin->first;
115 ALOGE("Could not find target framebuffer for display %d", display);
120 DrmConnector *connector = drm_->GetConnectorForDisplay(display);
121 connector->active_mode().ToModeModeInfo(&m);
123 uint32_t connectors = connector->id();
124 int ret = drmModeSetCrtc(drm_->fd(), layer->crtc->id(), layer->bo.fb_id, 0, 0,
127 ALOGE("Failed set crtc for disp %d/%d", display, ret);
129 layer->crtc->set_requires_modeset(false);
134 int DrmCompositor::CompositeDisplay(DrmCompositionLayerMap_t::iterator begin,
135 DrmCompositionLayerMap_t::iterator end) {
137 // Wait for all acquire fences to signal
138 for (DrmCompositionLayerMap_t::iterator iter = begin; iter != end; ++iter) {
139 hwc_layer_1_t *layer = &iter->second.layer;
141 if (layer->acquireFenceFd < 0)
144 ret = sync_wait(layer->acquireFenceFd, -1);
146 ALOGE("Failed to wait for acquire %d/%d", layer->acquireFenceFd, ret);
149 close(layer->acquireFenceFd);
150 layer->acquireFenceFd = -1;
153 DrmCrtc *crtc = begin->second.crtc;
154 if (crtc->requires_modeset()) {
155 ret = PerformModeset(begin, end);
157 ALOGE("Failed modeset on display %d", begin->first);
161 drmModePropertySetPtr pset = drmModePropertySetAlloc();
163 ALOGE("Failed to allocate property set");
167 for (DrmCompositionLayerMap_t::iterator iter = begin; iter != end; ++iter) {
168 DrmCompositionLayer_t *comp = &iter->second;
169 hwc_layer_1_t *layer = &comp->layer;
170 DrmPlane *plane = comp->plane;
173 drmModePropertySetAdd(pset, plane->id(), plane->crtc_property().id(),
175 drmModePropertySetAdd(pset, plane->id(), plane->fb_property().id(),
177 drmModePropertySetAdd(pset, plane->id(), plane->crtc_x_property().id(),
178 layer->displayFrame.left) ||
179 drmModePropertySetAdd(pset, plane->id(), plane->crtc_y_property().id(),
180 layer->displayFrame.top) ||
181 drmModePropertySetAdd(
182 pset, plane->id(), plane->crtc_w_property().id(),
183 layer->displayFrame.right - layer->displayFrame.left) ||
184 drmModePropertySetAdd(
185 pset, plane->id(), plane->crtc_h_property().id(),
186 layer->displayFrame.bottom - layer->displayFrame.top) ||
187 drmModePropertySetAdd(pset, plane->id(), plane->src_x_property().id(),
188 layer->sourceCropf.left) ||
189 drmModePropertySetAdd(pset, plane->id(), plane->src_y_property().id(),
190 layer->sourceCropf.top) ||
191 drmModePropertySetAdd(
192 pset, plane->id(), plane->src_w_property().id(),
193 (int)(layer->sourceCropf.right - layer->sourceCropf.left) << 16) ||
194 drmModePropertySetAdd(
195 pset, plane->id(), plane->src_h_property().id(),
196 (int)(layer->sourceCropf.bottom - layer->sourceCropf.top) << 16);
198 ALOGE("Failed to add plane %d to set", plane->id());
204 ret = drmModePropertySetCommit(drm_->fd(), 0, drm_, pset);
206 ALOGE("Failed to commit pset ret=%d\n", ret);
209 drmModePropertySetFree(pset);
214 int DrmCompositor::Composite() {
215 int ret = pthread_mutex_lock(&lock_);
217 ALOGE("Failed to acquire compositor lock %d", ret);
220 if (composite_queue_.empty()) {
221 ret = pthread_mutex_unlock(&lock_);
223 ALOGE("Failed to release compositor lock %d", ret);
227 DrmComposition *composition = composite_queue_.front();
228 composite_queue_.pop();
229 ++dump_frames_composited_;
231 ret = pthread_mutex_unlock(&lock_);
233 ALOGE("Failed to release compositor lock %d", ret);
237 DrmCompositionLayerMap_t *map = composition->GetCompositionMap();
238 for (DrmResources::ConnectorIter iter = drm_->begin_connectors();
239 iter != drm_->end_connectors(); ++iter) {
240 int display = (*iter)->display();
241 std::pair<DrmCompositionLayerMap_t::iterator,
242 DrmCompositionLayerMap_t::iterator> layer_iters =
243 map->equal_range(display);
245 if (layer_iters.first != layer_iters.second) {
246 ret = CompositeDisplay(layer_iters.first, layer_iters.second);
248 ALOGE("Composite failed for display %d:", display);
254 if (active_composition_) {
255 active_composition_->FinishComposition();
256 delete active_composition_;
258 active_composition_ = composition;
262 bool DrmCompositor::HaveQueuedComposites() const {
263 int ret = pthread_mutex_lock(&lock_);
265 ALOGE("Failed to acquire compositor lock %d", ret);
269 bool empty_ret = !composite_queue_.empty();
271 ret = pthread_mutex_unlock(&lock_);
273 ALOGE("Failed to release compositor lock %d", ret);
280 void DrmCompositor::Dump(std::ostringstream *out) const {
283 int ret = pthread_mutex_lock(&lock_);
287 uint64_t num_frames = dump_frames_composited_;
288 dump_frames_composited_ = 0;
291 ret = clock_gettime(CLOCK_MONOTONIC, &ts);
293 ret |= pthread_mutex_unlock(&lock_);
297 cur_ts = ts.tv_sec * 1000 * 1000 * 1000 + ts.tv_nsec;
298 uint64_t num_ms = (cur_ts - dump_last_timestamp_ns_) / (1000 * 1000);
299 unsigned fps = num_ms ? (num_frames * 1000) / (num_ms) : 0;
301 *out << "DrmCompositor: num_frames=" << num_frames << " num_ms=" << num_ms <<
302 " fps=" << fps << "\n";
304 dump_last_timestamp_ns_ = cur_ts;