1 /*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
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
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
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.
15 */
16
17 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
18 #define LOG_TAG "hwc-drm-display-compositor"
19
20 #include "drmdisplaycompositor.h"
21 #include "drmcrtc.h"
22 #include "drmplane.h"
23 #include "drmresources.h"
24
25 #include <pthread.h>
26 #include <sstream>
27 #include <stdlib.h>
28 #include <time.h>
29 #include <vector>
30
31 #include <cutils/log.h>
32 #include <sync/sync.h>
33 #include <utils/Trace.h>
34
35 namespace android {
36
DrmDisplayCompositor()37 DrmDisplayCompositor::DrmDisplayCompositor()
38 : drm_(NULL),
39 display_(-1),
40 worker_(this),
41 frame_no_(0),
42 initialized_(false),
43 active_(false),
44 dump_frames_composited_(0),
45 dump_last_timestamp_ns_(0) {
46 struct timespec ts;
47 if (clock_gettime(CLOCK_MONOTONIC, &ts))
48 return;
49 dump_last_timestamp_ns_ = ts.tv_sec * 1000 * 1000 * 1000 + ts.tv_nsec;
50 }
51
~DrmDisplayCompositor()52 DrmDisplayCompositor::~DrmDisplayCompositor() {
53 if (!initialized_)
54 return;
55
56 worker_.Exit();
57
58 int ret = pthread_mutex_lock(&lock_);
59 if (ret)
60 ALOGE("Failed to acquire compositor lock %d", ret);
61
62 while (!composite_queue_.empty()) {
63 composite_queue_.front().reset();
64 composite_queue_.pop();
65 }
66 active_composition_.reset();
67
68 ret = pthread_mutex_unlock(&lock_);
69 if (ret)
70 ALOGE("Failed to acquire compositor lock %d", ret);
71
72 pthread_mutex_destroy(&lock_);
73 }
74
Init(DrmResources * drm,int display)75 int DrmDisplayCompositor::Init(DrmResources *drm, int display) {
76 drm_ = drm;
77 display_ = display;
78
79 int ret = pthread_mutex_init(&lock_, NULL);
80 if (ret) {
81 ALOGE("Failed to initialize drm compositor lock %d\n", ret);
82 return ret;
83 }
84 ret = worker_.Init();
85 if (ret) {
86 pthread_mutex_destroy(&lock_);
87 ALOGE("Failed to initialize compositor worker %d\n", ret);
88 return ret;
89 }
90
91 initialized_ = true;
92 return 0;
93 }
94
QueueComposition(std::unique_ptr<DrmDisplayComposition> composition)95 int DrmDisplayCompositor::QueueComposition(
96 std::unique_ptr<DrmDisplayComposition> composition) {
97 switch (composition->type()) {
98 case DRM_COMPOSITION_TYPE_FRAME:
99 if (!active_)
100 return -ENODEV;
101 break;
102 case DRM_COMPOSITION_TYPE_DPMS:
103 /*
104 * Update the state as soon as we get it so we can start/stop queuing
105 * frames asap.
106 */
107 active_ = (composition->dpms_mode() == DRM_MODE_DPMS_ON);
108 break;
109 case DRM_COMPOSITION_TYPE_EMPTY:
110 return 0;
111 default:
112 ALOGE("Unknown composition type %d/%d", composition->type(), display_);
113 return -ENOENT;
114 }
115
116 int ret = pthread_mutex_lock(&lock_);
117 if (ret) {
118 ALOGE("Failed to acquire compositor lock %d", ret);
119 return ret;
120 }
121
122 composite_queue_.push(std::move(composition));
123
124 ret = pthread_mutex_unlock(&lock_);
125 if (ret) {
126 ALOGE("Failed to release compositor lock %d", ret);
127 return ret;
128 }
129
130 worker_.Signal();
131 return 0;
132 }
133
ApplyFrame(DrmDisplayComposition * display_comp)134 int DrmDisplayCompositor::ApplyFrame(DrmDisplayComposition *display_comp) {
135 int ret = 0;
136
137 drmModePropertySetPtr pset = drmModePropertySetAlloc();
138 if (!pset) {
139 ALOGE("Failed to allocate property set");
140 return -ENOMEM;
141 }
142
143 DrmCompositionLayerVector_t *layers = display_comp->GetCompositionLayers();
144 for (DrmCompositionLayerVector_t::iterator iter = layers->begin();
145 iter != layers->end(); ++iter) {
146 hwc_layer_1_t *layer = &iter->layer;
147
148 if (layer->acquireFenceFd >= 0) {
149 ret = sync_wait(layer->acquireFenceFd, -1);
150 if (ret) {
151 ALOGE("Failed to wait for acquire %d/%d", layer->acquireFenceFd, ret);
152 drmModePropertySetFree(pset);
153 return ret;
154 }
155 close(layer->acquireFenceFd);
156 layer->acquireFenceFd = -1;
157 }
158
159 DrmPlane *plane = iter->plane;
160 ret =
161 drmModePropertySetAdd(pset, plane->id(), plane->crtc_property().id(),
162 iter->crtc->id()) ||
163 drmModePropertySetAdd(pset, plane->id(), plane->fb_property().id(),
164 iter->bo.fb_id) ||
165 drmModePropertySetAdd(pset, plane->id(), plane->crtc_x_property().id(),
166 layer->displayFrame.left) ||
167 drmModePropertySetAdd(pset, plane->id(), plane->crtc_y_property().id(),
168 layer->displayFrame.top) ||
169 drmModePropertySetAdd(
170 pset, plane->id(), plane->crtc_w_property().id(),
171 layer->displayFrame.right - layer->displayFrame.left) ||
172 drmModePropertySetAdd(
173 pset, plane->id(), plane->crtc_h_property().id(),
174 layer->displayFrame.bottom - layer->displayFrame.top) ||
175 drmModePropertySetAdd(pset, plane->id(), plane->src_x_property().id(),
176 layer->sourceCropf.left) ||
177 drmModePropertySetAdd(pset, plane->id(), plane->src_y_property().id(),
178 layer->sourceCropf.top) ||
179 drmModePropertySetAdd(
180 pset, plane->id(), plane->src_w_property().id(),
181 (int)(layer->sourceCropf.right - layer->sourceCropf.left) << 16) ||
182 drmModePropertySetAdd(
183 pset, plane->id(), plane->src_h_property().id(),
184 (int)(layer->sourceCropf.bottom - layer->sourceCropf.top) << 16);
185 if (ret) {
186 ALOGE("Failed to add plane %d to set", plane->id());
187 break;
188 }
189 }
190
191 if (!ret) {
192 ret = drmModePropertySetCommit(drm_->fd(), 0, drm_, pset);
193 if (ret)
194 ALOGE("Failed to commit pset ret=%d\n", ret);
195 }
196 if (pset)
197 drmModePropertySetFree(pset);
198
199 return ret;
200 }
201
ApplyDpms(DrmDisplayComposition * display_comp)202 int DrmDisplayCompositor::ApplyDpms(DrmDisplayComposition *display_comp) {
203 DrmConnector *conn = drm_->GetConnectorForDisplay(display_);
204 if (!conn) {
205 ALOGE("Failed to get DrmConnector for display %d", display_);
206 return -ENODEV;
207 }
208
209 const DrmProperty &prop = conn->dpms_property();
210 int ret = drmModeConnectorSetProperty(drm_->fd(), conn->id(), prop.id(),
211 display_comp->dpms_mode());
212 if (ret) {
213 ALOGE("Failed to set DPMS property for connector %d", conn->id());
214 return ret;
215 }
216 return 0;
217 }
218
Composite()219 int DrmDisplayCompositor::Composite() {
220 ATRACE_CALL();
221 int ret = pthread_mutex_lock(&lock_);
222 if (ret) {
223 ALOGE("Failed to acquire compositor lock %d", ret);
224 return ret;
225 }
226 if (composite_queue_.empty()) {
227 ret = pthread_mutex_unlock(&lock_);
228 if (ret)
229 ALOGE("Failed to release compositor lock %d", ret);
230 return ret;
231 }
232
233 std::unique_ptr<DrmDisplayComposition> composition(
234 std::move(composite_queue_.front()));
235 composite_queue_.pop();
236
237 ret = pthread_mutex_unlock(&lock_);
238 if (ret) {
239 ALOGE("Failed to release compositor lock %d", ret);
240 return ret;
241 }
242
243 switch (composition->type()) {
244 case DRM_COMPOSITION_TYPE_FRAME:
245 ret = ApplyFrame(composition.get());
246 if (ret) {
247 ALOGE("Composite failed for display %d", display_);
248 return ret;
249 }
250 ++dump_frames_composited_;
251 break;
252 case DRM_COMPOSITION_TYPE_DPMS:
253 ret = ApplyDpms(composition.get());
254 if (ret)
255 ALOGE("Failed to apply dpms for display %d", display_);
256 return ret;
257 default:
258 ALOGE("Unknown composition type %d", composition->type());
259 return -EINVAL;
260 }
261
262 if (active_composition_)
263 active_composition_->FinishComposition();
264
265 active_composition_.swap(composition);
266 return ret;
267 }
268
HaveQueuedComposites() const269 bool DrmDisplayCompositor::HaveQueuedComposites() const {
270 int ret = pthread_mutex_lock(&lock_);
271 if (ret) {
272 ALOGE("Failed to acquire compositor lock %d", ret);
273 return false;
274 }
275
276 bool empty_ret = !composite_queue_.empty();
277
278 ret = pthread_mutex_unlock(&lock_);
279 if (ret) {
280 ALOGE("Failed to release compositor lock %d", ret);
281 return false;
282 }
283
284 return empty_ret;
285 }
286
Dump(std::ostringstream * out) const287 void DrmDisplayCompositor::Dump(std::ostringstream *out) const {
288 uint64_t cur_ts;
289
290 int ret = pthread_mutex_lock(&lock_);
291 if (ret)
292 return;
293
294 uint64_t num_frames = dump_frames_composited_;
295 dump_frames_composited_ = 0;
296
297 struct timespec ts;
298 ret = clock_gettime(CLOCK_MONOTONIC, &ts);
299
300 ret |= pthread_mutex_unlock(&lock_);
301 if (ret)
302 return;
303
304 cur_ts = ts.tv_sec * 1000 * 1000 * 1000 + ts.tv_nsec;
305 uint64_t num_ms = (cur_ts - dump_last_timestamp_ns_) / (1000 * 1000);
306 unsigned fps = num_ms ? (num_frames * 1000) / (num_ms) : 0;
307
308 *out << "--DrmDisplayCompositor[" << display_
309 << "]: num_frames=" << num_frames << " num_ms=" << num_ms
310 << " fps=" << fps << "\n";
311
312 dump_last_timestamp_ns_ = cur_ts;
313 }
314 }
315