blob: 013833fc7727ac7e998a0cb8aef07de29071deab [file] [log] [blame]
Naseer Ahmed29a26812012-06-14 00:56:20 -07001/*
2 * Copyright (C) 2010 The Android Open Source Project
Arun Kumar K.R361da4f2012-11-28 10:42:59 -08003 * Copyright (C) 2012-2013, The Linux Foundation All rights reserved.
4 *
5 * Not a Contribution, Apache license notifications and license are retained
6 * for attribution purposes only.
Naseer Ahmed29a26812012-06-14 00:56:20 -07007 *
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 */
Arun Kumar K.R361da4f2012-11-28 10:42:59 -080020#define HWC_UTILS_DEBUG 0
Naseer Ahmed758bfc52012-11-28 17:02:08 -050021#include <sys/ioctl.h>
Naseer Ahmed66e97882013-03-19 20:42:11 -040022#include <linux/fb.h>
Saurabh Shah86c17292013-02-08 15:24:13 -080023#include <binder/IServiceManager.h>
Naseer Ahmed5b6708a2012-08-02 13:46:08 -070024#include <EGL/egl.h>
Saurabh Shahfc2acbe2012-08-17 19:47:52 -070025#include <cutils/properties.h>
26#include <gralloc_priv.h>
Naseer Ahmed758bfc52012-11-28 17:02:08 -050027#include <overlay.h>
Saurabh Shahacf10202013-02-26 10:15:15 -080028#include <overlayRotator.h>
Naseer Ahmed29a26812012-06-14 00:56:20 -070029#include "hwc_utils.h"
Naseer Ahmed54821fe2012-11-28 18:44:38 -050030#include "hwc_mdpcomp.h"
Saurabh Shahcf053c62012-12-13 12:32:55 -080031#include "hwc_fbupdate.h"
Saurabh Shahacf10202013-02-26 10:15:15 -080032#include "hwc_video.h"
Naseer Ahmeda87da602012-07-01 23:54:19 -070033#include "mdp_version.h"
Arun Kumar K.R361da4f2012-11-28 10:42:59 -080034#include "hwc_copybit.h"
Saurabh Shah56f610d2012-08-07 15:27:06 -070035#include "external.h"
Saurabh Shah86c17292013-02-08 15:24:13 -080036#include "hwc_qclient.h"
Saurabh Shah56f610d2012-08-07 15:27:06 -070037#include "QService.h"
Arun Kumar K.R361da4f2012-11-28 10:42:59 -080038#include "comptype.h"
Saurabh Shah86c17292013-02-08 15:24:13 -080039
40using namespace qClient;
41using namespace qService;
42using namespace android;
Saurabh Shahacf10202013-02-26 10:15:15 -080043using namespace overlay;
44using namespace overlay::utils;
45namespace ovutils = overlay::utils;
Saurabh Shah86c17292013-02-08 15:24:13 -080046
Naseer Ahmed29a26812012-06-14 00:56:20 -070047namespace qhwc {
Naseer Ahmed72cf9762012-07-21 12:17:13 -070048
Jeykumar Sankaranc1f86822013-02-20 18:32:01 -080049static int openFramebufferDevice(hwc_context_t *ctx)
Naseer Ahmed72cf9762012-07-21 12:17:13 -070050{
Jeykumar Sankaranc1f86822013-02-20 18:32:01 -080051 struct fb_fix_screeninfo finfo;
52 struct fb_var_screeninfo info;
53
54 int fb_fd = openFb(HWC_DISPLAY_PRIMARY);
55
56 if (ioctl(fb_fd, FBIOGET_VSCREENINFO, &info) == -1)
57 return -errno;
58
59 if (int(info.width) <= 0 || int(info.height) <= 0) {
60 // the driver doesn't return that information
61 // default to 160 dpi
62 info.width = ((info.xres * 25.4f)/160.0f + 0.5f);
63 info.height = ((info.yres * 25.4f)/160.0f + 0.5f);
Naseer Ahmed72cf9762012-07-21 12:17:13 -070064 }
Jeykumar Sankaranc1f86822013-02-20 18:32:01 -080065
66 float xdpi = (info.xres * 25.4f) / info.width;
67 float ydpi = (info.yres * 25.4f) / info.height;
68
69#ifdef MSMFB_METADATA_GET
70 struct msmfb_metadata metadata;
71 memset(&metadata, 0 , sizeof(metadata));
72 metadata.op = metadata_op_frame_rate;
73
74 if (ioctl(fb_fd, MSMFB_METADATA_GET, &metadata) == -1) {
75 ALOGE("Error retrieving panel frame rate");
76 return -errno;
77 }
78
79 float fps = metadata.data.panel_frame_rate;
80#else
81 //XXX: Remove reserved field usage on all baselines
82 //The reserved[3] field is used to store FPS by the driver.
83 float fps = info.reserved[3] & 0xFF;
84#endif
85
86 if (ioctl(fb_fd, FBIOGET_FSCREENINFO, &finfo) == -1)
87 return -errno;
88
89 if (finfo.smem_len <= 0)
90 return -errno;
91
92 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].fd = fb_fd;
93 //xres, yres may not be 32 aligned
94 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].stride = finfo.line_length /(info.xres/8);
95 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].xres = info.xres;
96 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].yres = info.yres;
97 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].xdpi = xdpi;
98 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].ydpi = ydpi;
99 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].vsync_period = 1000000000l / fps;
100
101 return 0;
Naseer Ahmed72cf9762012-07-21 12:17:13 -0700102}
103
Naseer Ahmed29a26812012-06-14 00:56:20 -0700104void initContext(hwc_context_t *ctx)
105{
Naseer Ahmed72cf9762012-07-21 12:17:13 -0700106 openFramebufferDevice(ctx);
Naseer Ahmed96c4c952012-07-25 18:27:14 -0700107 ctx->mMDP.version = qdutils::MDPVersion::getInstance().getMDPVersion();
108 ctx->mMDP.hasOverlay = qdutils::MDPVersion::getInstance().hasOverlay();
109 ctx->mMDP.panel = qdutils::MDPVersion::getInstance().getPanelType();
Sushil Chauhan07a2c762013-03-06 15:36:49 -0800110 overlay::Overlay::initOverlay();
111 ctx->mOverlay = overlay::Overlay::getInstance();
112 ctx->mRotMgr = new RotMgr();
113
Saurabh Shahcf053c62012-12-13 12:32:55 -0800114 //Is created and destroyed only once for primary
115 //For external it could get created and destroyed multiple times depending
116 //on what external we connect to.
117 ctx->mFBUpdate[HWC_DISPLAY_PRIMARY] =
118 IFBUpdate::getObject(ctx->dpyAttr[HWC_DISPLAY_PRIMARY].xres,
119 HWC_DISPLAY_PRIMARY);
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800120
Saurabh Shahacf10202013-02-26 10:15:15 -0800121 ctx->mVidOv[HWC_DISPLAY_PRIMARY] =
122 IVideoOverlay::getObject(ctx->dpyAttr[HWC_DISPLAY_PRIMARY].xres,
123 HWC_DISPLAY_PRIMARY);
124
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800125 char value[PROPERTY_VALUE_MAX];
126 // Check if the target supports copybit compostion (dyn/mdp/c2d) to
127 // decide if we need to open the copybit module.
128 int compositionType =
129 qdutils::QCCompositionType::getInstance().getCompositionType();
130
131 if (compositionType & (qdutils::COMPOSITION_TYPE_DYN |
132 qdutils::COMPOSITION_TYPE_MDP |
133 qdutils::COMPOSITION_TYPE_C2D)) {
134 ctx->mCopyBit[HWC_DISPLAY_PRIMARY] = new CopyBit();
135 }
136
Naseer Ahmed72cf9762012-07-21 12:17:13 -0700137 ctx->mExtDisplay = new ExternalDisplay(ctx);
Amara Venkata Mastan Manoj Kumar11a380d2013-01-17 09:30:56 -0800138 for (uint32_t i = 0; i < MAX_DISPLAYS; i++)
Naseer Ahmede78f0522012-12-07 18:24:28 -0500139 ctx->mLayerCache[i] = new LayerCache();
Saurabh Shahcbf7ccc2012-12-19 16:45:51 -0800140 ctx->mMDPComp = MDPComp::getObject(ctx->dpyAttr[HWC_DISPLAY_PRIMARY].xres);
Naseer Ahmed54821fe2012-11-28 18:44:38 -0500141 MDPComp::init(ctx);
Naseer Ahmed72cf9762012-07-21 12:17:13 -0700142
Naseer Ahmedff4f0252012-10-01 13:03:01 -0400143 pthread_mutex_init(&(ctx->vstate.lock), NULL);
144 pthread_cond_init(&(ctx->vstate.cond), NULL);
145 ctx->vstate.enable = false;
Naseer Ahmed56601cd2013-03-05 11:34:14 -0500146 ctx->vstate.fakevsync = false;
Amara Venkata Mastan Manoj Kumar75526f52012-12-27 18:27:01 -0800147 ctx->mExtDispConfiguring = false;
Saurabh Shah86c17292013-02-08 15:24:13 -0800148
149 //Right now hwc starts the service but anybody could do it, or it could be
150 //independent process as well.
151 QService::init();
152 sp<IQClient> client = new QClient(ctx);
153 interface_cast<IQService>(
154 defaultServiceManager()->getService(
155 String16("display.qservice")))->connect(client);
156
Naseer Ahmed72cf9762012-07-21 12:17:13 -0700157 ALOGI("Initializing Qualcomm Hardware Composer");
Naseer Ahmed96c4c952012-07-25 18:27:14 -0700158 ALOGI("MDP version: %d", ctx->mMDP.version);
Naseer Ahmed29a26812012-06-14 00:56:20 -0700159}
160
161void closeContext(hwc_context_t *ctx)
162{
Naseer Ahmed758bfc52012-11-28 17:02:08 -0500163 if(ctx->mOverlay) {
164 delete ctx->mOverlay;
165 ctx->mOverlay = NULL;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700166 }
Naseer Ahmedf48aef62012-07-20 09:05:53 -0700167
Saurabh Shahacf10202013-02-26 10:15:15 -0800168 if(ctx->mRotMgr) {
169 delete ctx->mRotMgr;
170 ctx->mRotMgr = NULL;
171 }
172
Amara Venkata Mastan Manoj Kumar11a380d2013-01-17 09:30:56 -0800173 for(int i = 0; i < MAX_DISPLAYS; i++) {
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800174 if(ctx->mCopyBit[i]) {
175 delete ctx->mCopyBit[i];
176 ctx->mCopyBit[i] = NULL;
177 }
178 }
179
Jeykumar Sankaranc1f86822013-02-20 18:32:01 -0800180 if(ctx->dpyAttr[HWC_DISPLAY_PRIMARY].fd) {
Saurabh Shah3e858eb2012-09-17 16:53:21 -0700181 close(ctx->dpyAttr[HWC_DISPLAY_PRIMARY].fd);
182 ctx->dpyAttr[HWC_DISPLAY_PRIMARY].fd = -1;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700183 }
Naseer Ahmed72cf9762012-07-21 12:17:13 -0700184
185 if(ctx->mExtDisplay) {
186 delete ctx->mExtDisplay;
187 ctx->mExtDisplay = NULL;
188 }
Naseer Ahmedff4f0252012-10-01 13:03:01 -0400189
Amara Venkata Mastan Manoj Kumar11a380d2013-01-17 09:30:56 -0800190 for(int i = 0; i < MAX_DISPLAYS; i++) {
Saurabh Shahcf053c62012-12-13 12:32:55 -0800191 if(ctx->mFBUpdate[i]) {
192 delete ctx->mFBUpdate[i];
193 ctx->mFBUpdate[i] = NULL;
194 }
Saurabh Shahacf10202013-02-26 10:15:15 -0800195 if(ctx->mVidOv[i]) {
196 delete ctx->mVidOv[i];
197 ctx->mVidOv[i] = NULL;
198 }
Saurabh Shahcf053c62012-12-13 12:32:55 -0800199 }
200
Saurabh Shahcbf7ccc2012-12-19 16:45:51 -0800201 if(ctx->mMDPComp) {
202 delete ctx->mMDPComp;
203 ctx->mMDPComp = NULL;
204 }
205
Naseer Ahmedff4f0252012-10-01 13:03:01 -0400206 pthread_mutex_destroy(&(ctx->vstate.lock));
207 pthread_cond_destroy(&(ctx->vstate.cond));
Naseer Ahmed29a26812012-06-14 00:56:20 -0700208}
209
Naseer Ahmed1d183f52012-11-26 12:35:16 -0500210
211void dumpsys_log(android::String8& buf, const char* fmt, ...)
Naseer Ahmed29a26812012-06-14 00:56:20 -0700212{
Naseer Ahmed1d183f52012-11-26 12:35:16 -0500213 va_list varargs;
214 va_start(varargs, fmt);
215 buf.appendFormatV(fmt, varargs);
216 va_end(varargs);
Naseer Ahmed29a26812012-06-14 00:56:20 -0700217}
218
Arun Kumar K.Rfeb2d8a2013-02-01 02:53:13 -0800219/* Calculates the destination position based on the action safe rectangle */
220void getActionSafePosition(hwc_context_t *ctx, int dpy, uint32_t& x,
221 uint32_t& y, uint32_t& w, uint32_t& h) {
222
223 // if external supports underscan, do nothing
224 // it will be taken care in the driver
225 if(ctx->mExtDisplay->isCEUnderscanSupported())
226 return;
227
228 float wRatio = 1.0;
229 float hRatio = 1.0;
230 float xRatio = 1.0;
231 float yRatio = 1.0;
232
233 float fbWidth = ctx->dpyAttr[dpy].xres;
234 float fbHeight = ctx->dpyAttr[dpy].yres;
235
236 float asX = 0;
237 float asY = 0;
238 float asW = fbWidth;
239 float asH= fbHeight;
240 char value[PROPERTY_VALUE_MAX];
241
242 // Apply action safe parameters
243 property_get("hw.actionsafe.width", value, "0");
244 int asWidthRatio = atoi(value);
245 property_get("hw.actionsafe.height", value, "0");
246 int asHeightRatio = atoi(value);
247 // based on the action safe ratio, get the Action safe rectangle
248 asW = fbWidth * (1.0f - asWidthRatio / 100.0f);
249 asH = fbHeight * (1.0f - asHeightRatio / 100.0f);
250 asX = (fbWidth - asW) / 2;
251 asY = (fbHeight - asH) / 2;
252
253 // calculate the position ratio
254 xRatio = (float)x/fbWidth;
255 yRatio = (float)y/fbHeight;
256 wRatio = (float)w/fbWidth;
257 hRatio = (float)h/fbHeight;
258
259 //Calculate the position...
260 x = (xRatio * asW) + asX;
261 y = (yRatio * asH) + asY;
262 w = (wRatio * asW);
263 h = (hRatio * asH);
264
265 return;
266}
267
Jeykumar Sankaranb551ce42013-01-10 16:26:48 -0800268bool needsScaling(hwc_layer_1_t const* layer) {
Naseer Ahmed018e5452012-12-03 14:46:15 -0500269 int dst_w, dst_h, src_w, src_h;
270
271 hwc_rect_t displayFrame = layer->displayFrame;
272 hwc_rect_t sourceCrop = layer->sourceCrop;
273
274 dst_w = displayFrame.right - displayFrame.left;
275 dst_h = displayFrame.bottom - displayFrame.top;
276
277 src_w = sourceCrop.right - sourceCrop.left;
278 src_h = sourceCrop.bottom - sourceCrop.top;
279
Jeykumar Sankaranb551ce42013-01-10 16:26:48 -0800280 if(((src_w != dst_w) || (src_h != dst_h)))
281 return true;
282
283 return false;
284}
285
286bool isAlphaScaled(hwc_layer_1_t const* layer) {
287 if(needsScaling(layer)) {
Naseer Ahmed018e5452012-12-03 14:46:15 -0500288 if(layer->blending != HWC_BLENDING_NONE)
289 return true;
290 }
291 return false;
292}
293
Saurabh Shah3e858eb2012-09-17 16:53:21 -0700294void setListStats(hwc_context_t *ctx,
295 const hwc_display_contents_1_t *list, int dpy) {
296
297 ctx->listStats[dpy].numAppLayers = list->numHwLayers - 1;
298 ctx->listStats[dpy].fbLayerIndex = list->numHwLayers - 1;
Saurabh Shahc4d034f2012-09-27 15:55:15 -0700299 ctx->listStats[dpy].skipCount = 0;
Naseer Ahmed018e5452012-12-03 14:46:15 -0500300 ctx->listStats[dpy].needsAlphaScale = false;
Jeykumar Sankarancf537002013-01-21 21:19:15 -0800301 ctx->listStats[dpy].yuvCount = 0;
Jeykumar Sankaranb551ce42013-01-10 16:26:48 -0800302 ctx->mDMAInUse = false;
Naseer Ahmedf48aef62012-07-20 09:05:53 -0700303
304 for (size_t i = 0; i < list->numHwLayers; i++) {
Naseer Ahmed018e5452012-12-03 14:46:15 -0500305 hwc_layer_1_t const* layer = &list->hwLayers[i];
306 private_handle_t *hnd = (private_handle_t *)layer->handle;
Naseer Ahmedf48aef62012-07-20 09:05:53 -0700307
Jeykumar Sankarancf537002013-01-21 21:19:15 -0800308 //reset stored yuv index
309 ctx->listStats[dpy].yuvIndices[i] = -1;
310
Saurabh Shah3e858eb2012-09-17 16:53:21 -0700311 if(list->hwLayers[i].compositionType == HWC_FRAMEBUFFER_TARGET) {
312 continue;
313 //We disregard FB being skip for now! so the else if
Saurabh Shah35712cb2012-09-14 10:28:18 -0700314 } else if (isSkipLayer(&list->hwLayers[i])) {
Saurabh Shah3e858eb2012-09-17 16:53:21 -0700315 ctx->listStats[dpy].skipCount++;
Jeykumar Sankaran7535aba2013-02-04 11:03:09 -0800316 } else if (UNLIKELY(isYuvBuffer(hnd))) {
Jeykumar Sankarancf537002013-01-21 21:19:15 -0800317 int& yuvCount = ctx->listStats[dpy].yuvCount;
318 ctx->listStats[dpy].yuvIndices[yuvCount] = i;
319 yuvCount++;
Jeykumar Sankaranb551ce42013-01-10 16:26:48 -0800320
321 if((layer->transform & HWC_TRANSFORM_ROT_90) && !ctx->mDMAInUse)
322 ctx->mDMAInUse = true;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700323 }
Jeykumar Sankaran7535aba2013-02-04 11:03:09 -0800324
325 if(!ctx->listStats[dpy].needsAlphaScale)
326 ctx->listStats[dpy].needsAlphaScale = isAlphaScaled(layer);
Naseer Ahmed29a26812012-06-14 00:56:20 -0700327 }
Naseer Ahmed29a26812012-06-14 00:56:20 -0700328}
329
Naseer Ahmed018e5452012-12-03 14:46:15 -0500330
Saurabh Shah541b59d2012-10-11 11:08:12 -0700331static inline void calc_cut(float& leftCutRatio, float& topCutRatio,
332 float& rightCutRatio, float& bottomCutRatio, int orient) {
Saurabh Shah27c1d652012-08-14 19:30:28 -0700333 if(orient & HAL_TRANSFORM_FLIP_H) {
Saurabh Shah541b59d2012-10-11 11:08:12 -0700334 swap(leftCutRatio, rightCutRatio);
Saurabh Shah27c1d652012-08-14 19:30:28 -0700335 }
336 if(orient & HAL_TRANSFORM_FLIP_V) {
Saurabh Shah541b59d2012-10-11 11:08:12 -0700337 swap(topCutRatio, bottomCutRatio);
Saurabh Shah27c1d652012-08-14 19:30:28 -0700338 }
339 if(orient & HAL_TRANSFORM_ROT_90) {
340 //Anti clock swapping
Saurabh Shah541b59d2012-10-11 11:08:12 -0700341 float tmpCutRatio = leftCutRatio;
342 leftCutRatio = topCutRatio;
343 topCutRatio = rightCutRatio;
344 rightCutRatio = bottomCutRatio;
345 bottomCutRatio = tmpCutRatio;
Saurabh Shah27c1d652012-08-14 19:30:28 -0700346 }
347}
348
Naseer Ahmed54821fe2012-11-28 18:44:38 -0500349bool isSecuring(hwc_context_t* ctx) {
350 if((ctx->mMDP.version < qdutils::MDSS_V5) &&
351 (ctx->mMDP.version > qdutils::MDP_V3_0) &&
352 ctx->mSecuring) {
353 return true;
354 }
355 return false;
356}
357
Sushil Chauhan2515abf2013-01-08 16:40:05 -0800358bool isSecureModePolicy(int mdpVersion) {
359 if (mdpVersion < qdutils::MDSS_V5)
360 return true;
361 else
362 return false;
363}
Naseer Ahmed54821fe2012-11-28 18:44:38 -0500364
Naseer Ahmedf48aef62012-07-20 09:05:53 -0700365//Crops source buffer against destination and FB boundaries
366void calculate_crop_rects(hwc_rect_t& crop, hwc_rect_t& dst,
Jeykumar Sankaranb551ce42013-01-10 16:26:48 -0800367 const hwc_rect_t& scissor, int orient) {
368
Saurabh Shah27c1d652012-08-14 19:30:28 -0700369 int& crop_l = crop.left;
370 int& crop_t = crop.top;
Naseer Ahmedf48aef62012-07-20 09:05:53 -0700371 int& crop_r = crop.right;
372 int& crop_b = crop.bottom;
373 int crop_w = crop.right - crop.left;
374 int crop_h = crop.bottom - crop.top;
375
Saurabh Shah27c1d652012-08-14 19:30:28 -0700376 int& dst_l = dst.left;
377 int& dst_t = dst.top;
Naseer Ahmedf48aef62012-07-20 09:05:53 -0700378 int& dst_r = dst.right;
379 int& dst_b = dst.bottom;
Saurabh Shah27c1d652012-08-14 19:30:28 -0700380 int dst_w = abs(dst.right - dst.left);
381 int dst_h = abs(dst.bottom - dst.top);
Naseer Ahmedf48aef62012-07-20 09:05:53 -0700382
Jeykumar Sankaranb551ce42013-01-10 16:26:48 -0800383 const int& sci_l = scissor.left;
384 const int& sci_t = scissor.top;
385 const int& sci_r = scissor.right;
386 const int& sci_b = scissor.bottom;
387 int sci_w = abs(sci_r - sci_l);
388 int sci_h = abs(sci_b - sci_t);
389
Saurabh Shah541b59d2012-10-11 11:08:12 -0700390 float leftCutRatio = 0.0f, rightCutRatio = 0.0f, topCutRatio = 0.0f,
391 bottomCutRatio = 0.0f;
Naseer Ahmedf48aef62012-07-20 09:05:53 -0700392
Jeykumar Sankaranb551ce42013-01-10 16:26:48 -0800393 if(dst_l < sci_l) {
394 leftCutRatio = (float)(sci_l - dst_l) / (float)dst_w;
395 dst_l = sci_l;
Naseer Ahmedf48aef62012-07-20 09:05:53 -0700396 }
Jeykumar Sankaranb551ce42013-01-10 16:26:48 -0800397
398 if(dst_r > sci_r) {
399 rightCutRatio = (float)(dst_r - sci_r) / (float)dst_w;
400 dst_r = sci_r;
Naseer Ahmedf48aef62012-07-20 09:05:53 -0700401 }
Jeykumar Sankaranb551ce42013-01-10 16:26:48 -0800402
403 if(dst_t < sci_t) {
404 topCutRatio = (float)(sci_t - dst_t) / (float)dst_h;
405 dst_t = sci_t;
Naseer Ahmedf48aef62012-07-20 09:05:53 -0700406 }
Jeykumar Sankaranb551ce42013-01-10 16:26:48 -0800407
408 if(dst_b > sci_b) {
409 bottomCutRatio = (float)(dst_b - sci_b) / (float)dst_h;
410 dst_b = sci_b;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700411 }
Saurabh Shah27c1d652012-08-14 19:30:28 -0700412
Saurabh Shah541b59d2012-10-11 11:08:12 -0700413 calc_cut(leftCutRatio, topCutRatio, rightCutRatio, bottomCutRatio, orient);
414 crop_l += crop_w * leftCutRatio;
415 crop_t += crop_h * topCutRatio;
416 crop_r -= crop_w * rightCutRatio;
417 crop_b -= crop_h * bottomCutRatio;
Naseer Ahmed29a26812012-06-14 00:56:20 -0700418}
Naseer Ahmedf48aef62012-07-20 09:05:53 -0700419
Naseer Ahmed64b81212013-02-14 10:29:47 -0500420void getNonWormholeRegion(hwc_display_contents_1_t* list,
421 hwc_rect_t& nwr)
422{
423 uint32_t last = list->numHwLayers - 1;
424 hwc_rect_t fbDisplayFrame = list->hwLayers[last].displayFrame;
425 //Initiliaze nwr to first frame
426 nwr.left = list->hwLayers[0].displayFrame.left;
427 nwr.top = list->hwLayers[0].displayFrame.top;
428 nwr.right = list->hwLayers[0].displayFrame.right;
429 nwr.bottom = list->hwLayers[0].displayFrame.bottom;
430
431 for (uint32_t i = 1; i < last; i++) {
432 hwc_rect_t displayFrame = list->hwLayers[i].displayFrame;
433 nwr.left = min(nwr.left, displayFrame.left);
434 nwr.top = min(nwr.top, displayFrame.top);
435 nwr.right = max(nwr.right, displayFrame.right);
436 nwr.bottom = max(nwr.bottom, displayFrame.bottom);
437 }
438
439 //Intersect with the framebuffer
440 nwr.left = max(nwr.left, fbDisplayFrame.left);
441 nwr.top = max(nwr.top, fbDisplayFrame.top);
442 nwr.right = min(nwr.right, fbDisplayFrame.right);
443 nwr.bottom = min(nwr.bottom, fbDisplayFrame.bottom);
444
445}
446
Saurabh Shah3e858eb2012-09-17 16:53:21 -0700447bool isExternalActive(hwc_context_t* ctx) {
448 return ctx->dpyAttr[HWC_DISPLAY_EXTERNAL].isActive;
Saurabh Shahfc2acbe2012-08-17 19:47:52 -0700449}
450
Saurabh Shah747af1e2013-02-26 10:25:12 -0800451void closeAcquireFds(hwc_display_contents_1_t* list) {
452 for(uint32_t i = 0; list && i < list->numHwLayers; i++) {
453 //Close the acquireFenceFds
454 //HWC_FRAMEBUFFER are -1 already by SF, rest we close.
455 if(list->hwLayers[i].acquireFenceFd >= 0) {
456 close(list->hwLayers[i].acquireFenceFd);
457 list->hwLayers[i].acquireFenceFd = -1;
458 }
459 }
460}
461
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800462int hwc_sync(hwc_context_t *ctx, hwc_display_contents_1_t* list, int dpy,
463 int fd) {
Kinjal Bhavsar2dd04a82012-09-18 18:27:59 -0700464 int ret = 0;
Kinjal Bhavsar2dd04a82012-09-18 18:27:59 -0700465 struct mdp_buf_sync data;
Naseer Ahmedb1c76322012-10-17 00:32:50 -0400466 int acquireFd[MAX_NUM_LAYERS];
Kinjal Bhavsar2dd04a82012-09-18 18:27:59 -0700467 int count = 0;
468 int releaseFd = -1;
469 int fbFd = -1;
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800470 memset(&data, 0, sizeof(data));
Naseer Ahmed94baddc2012-12-17 18:51:01 -0500471 bool swapzero = false;
Saurabh Shahc4d034f2012-09-27 15:55:15 -0700472 data.flags = MDP_BUF_SYNC_FLAG_WAIT;
Kinjal Bhavsar2dd04a82012-09-18 18:27:59 -0700473 data.acq_fen_fd = acquireFd;
474 data.rel_fen_fd = &releaseFd;
Naseer Ahmed94baddc2012-12-17 18:51:01 -0500475 char property[PROPERTY_VALUE_MAX];
476 if(property_get("debug.egl.swapinterval", property, "1") > 0) {
477 if(atoi(property) == 0)
478 swapzero = true;
479 }
480
Kinjal Bhavsar2dd04a82012-09-18 18:27:59 -0700481 //Accumulate acquireFenceFds
482 for(uint32_t i = 0; i < list->numHwLayers; i++) {
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800483 if(list->hwLayers[i].compositionType == HWC_OVERLAY &&
484 list->hwLayers[i].acquireFenceFd != -1) {
Naseer Ahmed94baddc2012-12-17 18:51:01 -0500485 if(UNLIKELY(swapzero))
486 acquireFd[count++] = -1;
487 else
488 acquireFd[count++] = list->hwLayers[i].acquireFenceFd;
Kinjal Bhavsar2dd04a82012-09-18 18:27:59 -0700489 }
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800490 if(list->hwLayers[i].compositionType == HWC_FRAMEBUFFER_TARGET) {
491 if(UNLIKELY(swapzero))
492 acquireFd[count++] = -1;
493 else if(fd != -1) {
494 //set the acquireFD from fd - which is coming from c2d
495 acquireFd[count++] = fd;
496 // Buffer sync IOCTL should be async when using c2d fence is
497 // used
498 data.flags &= ~MDP_BUF_SYNC_FLAG_WAIT;
499 } else if(list->hwLayers[i].acquireFenceFd != -1)
500 acquireFd[count++] = list->hwLayers[i].acquireFenceFd;
501 }
Kinjal Bhavsar2dd04a82012-09-18 18:27:59 -0700502 }
503
Kinjal Bhavsar40a1cc52012-10-10 15:52:03 -0700504 data.acq_fen_fd_cnt = count;
505 fbFd = ctx->dpyAttr[dpy].fd;
Kinjal Bhavsar40a1cc52012-10-10 15:52:03 -0700506 //Waits for acquire fences, returns a release fence
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800507 if(LIKELY(!swapzero)) {
508 uint64_t start = systemTime();
Naseer Ahmed94baddc2012-12-17 18:51:01 -0500509 ret = ioctl(fbFd, MSMFB_BUFFER_SYNC, &data);
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800510 ALOGD_IF(HWC_UTILS_DEBUG, "%s: time taken for MSMFB_BUFFER_SYNC IOCTL = %d",
511 __FUNCTION__, (size_t) ns2ms(systemTime() - start));
512 }
Saurabh Shah747af1e2013-02-26 10:25:12 -0800513
Kinjal Bhavsar40a1cc52012-10-10 15:52:03 -0700514 if(ret < 0) {
515 ALOGE("ioctl MSMFB_BUFFER_SYNC failed, err=%s",
516 strerror(errno));
Kinjal Bhavsar2dd04a82012-09-18 18:27:59 -0700517 }
Saurabh Shah747af1e2013-02-26 10:25:12 -0800518
Kinjal Bhavsar40a1cc52012-10-10 15:52:03 -0700519 for(uint32_t i = 0; i < list->numHwLayers; i++) {
Arun Kumar K.R361da4f2012-11-28 10:42:59 -0800520 if(list->hwLayers[i].compositionType == HWC_OVERLAY ||
521 list->hwLayers[i].compositionType == HWC_FRAMEBUFFER_TARGET) {
Kinjal Bhavsar40a1cc52012-10-10 15:52:03 -0700522 //Populate releaseFenceFds.
Naseer Ahmed94baddc2012-12-17 18:51:01 -0500523 if(UNLIKELY(swapzero))
524 list->hwLayers[i].releaseFenceFd = -1;
525 else
526 list->hwLayers[i].releaseFenceFd = dup(releaseFd);
Kinjal Bhavsar40a1cc52012-10-10 15:52:03 -0700527 }
528 }
Saurabh Shah747af1e2013-02-26 10:25:12 -0800529
530 if(fd >= 0) {
531 close(fd);
532 fd = -1;
533 }
534
Naseer Ahmed64b81212013-02-14 10:29:47 -0500535 if (ctx->mCopyBit[dpy])
536 ctx->mCopyBit[dpy]->setReleaseFd(releaseFd);
Naseer Ahmed94baddc2012-12-17 18:51:01 -0500537 if(UNLIKELY(swapzero)){
538 list->retireFenceFd = -1;
539 close(releaseFd);
540 } else {
541 list->retireFenceFd = releaseFd;
542 }
Saurabh Shah747af1e2013-02-26 10:25:12 -0800543
Kinjal Bhavsar2dd04a82012-09-18 18:27:59 -0700544 return ret;
545}
546
Saurabh Shahacf10202013-02-26 10:15:15 -0800547void trimLayer(hwc_context_t *ctx, const int& dpy, const int& transform,
548 hwc_rect_t& crop, hwc_rect_t& dst) {
549 int hw_w = ctx->dpyAttr[dpy].xres;
550 int hw_h = ctx->dpyAttr[dpy].yres;
551 if(dst.left < 0 || dst.top < 0 ||
552 dst.right > hw_w || dst.bottom > hw_h) {
553 hwc_rect_t scissor = {0, 0, hw_w, hw_h };
554 qhwc::calculate_crop_rects(crop, dst, scissor, transform);
555 }
556}
557
558void setMdpFlags(hwc_layer_1_t *layer,
559 ovutils::eMdpFlags &mdpFlags,
560 int rotDownscale) {
561 private_handle_t *hnd = (private_handle_t *)layer->handle;
562 MetaData_t *metadata = (MetaData_t *)hnd->base_metadata;
563 const int& transform = layer->transform;
564
565 if(layer->blending == HWC_BLENDING_PREMULT) {
566 ovutils::setMdpFlags(mdpFlags,
567 ovutils::OV_MDP_BLEND_FG_PREMULT);
568 }
569
570 if(isYuvBuffer(hnd)) {
571 if(isSecureBuffer(hnd)) {
572 ovutils::setMdpFlags(mdpFlags,
573 ovutils::OV_MDP_SECURE_OVERLAY_SESSION);
574 }
575 if(metadata && (metadata->operation & PP_PARAM_INTERLACED) &&
576 metadata->interlaced) {
577 ovutils::setMdpFlags(mdpFlags,
578 ovutils::OV_MDP_DEINTERLACE);
579 }
580 //Pre-rotation will be used using rotator.
581 if(transform & HWC_TRANSFORM_ROT_90) {
582 ovutils::setMdpFlags(mdpFlags,
583 ovutils::OV_MDP_SOURCE_ROTATED_90);
584 }
585 }
586
587 //No 90 component and no rot-downscale then flips done by MDP
588 //If we use rot then it might as well do flips
589 if(!(layer->transform & HWC_TRANSFORM_ROT_90) && !rotDownscale) {
590 if(layer->transform & HWC_TRANSFORM_FLIP_H) {
591 ovutils::setMdpFlags(mdpFlags, ovutils::OV_MDP_FLIP_H);
592 }
593
594 if(layer->transform & HWC_TRANSFORM_FLIP_V) {
595 ovutils::setMdpFlags(mdpFlags, ovutils::OV_MDP_FLIP_V);
596 }
597 }
598}
599
600static inline int configRotator(Rotator *rot, const Whf& whf,
601 const eMdpFlags& mdpFlags, const eTransform& orient,
602 const int& downscale) {
603 rot->setSource(whf);
604 rot->setFlags(mdpFlags);
605 rot->setTransform(orient);
606 rot->setDownscale(downscale);
607 if(!rot->commit()) return -1;
608 return 0;
609}
610
611static inline int configMdp(Overlay *ov, const PipeArgs& parg,
612 const eTransform& orient, const hwc_rect_t& crop,
613 const hwc_rect_t& pos, const eDest& dest) {
614 ov->setSource(parg, dest);
615 ov->setTransform(orient, dest);
616
617 int crop_w = crop.right - crop.left;
618 int crop_h = crop.bottom - crop.top;
619 Dim dcrop(crop.left, crop.top, crop_w, crop_h);
620 ov->setCrop(dcrop, dest);
621
622 int posW = pos.right - pos.left;
623 int posH = pos.bottom - pos.top;
624 Dim position(pos.left, pos.top, posW, posH);
625 ov->setPosition(position, dest);
626
627 if (!ov->commit(dest)) {
628 return -1;
629 }
630 return 0;
631}
632
633static inline void updateSource(eTransform& orient, Whf& whf,
634 hwc_rect_t& crop) {
635 Dim srcCrop(crop.left, crop.top,
636 crop.right - crop.left,
637 crop.bottom - crop.top);
Saurabh Shah76fd6552013-03-14 14:45:38 -0700638 //getMdpOrient will switch the flips if the source is 90 rotated.
639 //Clients in Android dont factor in 90 rotation while deciding the flip.
640 orient = static_cast<eTransform>(ovutils::getMdpOrient(orient));
Saurabh Shahacf10202013-02-26 10:15:15 -0800641 preRotateSource(orient, whf, srcCrop);
642 crop.left = srcCrop.x;
643 crop.top = srcCrop.y;
644 crop.right = srcCrop.x + srcCrop.w;
645 crop.bottom = srcCrop.y + srcCrop.h;
646}
647
648int configureLowRes(hwc_context_t *ctx, hwc_layer_1_t *layer,
649 const int& dpy, eMdpFlags& mdpFlags, const eZorder& z,
650 const eIsFg& isFg, const eDest& dest, Rotator **rot) {
651
652 private_handle_t *hnd = (private_handle_t *)layer->handle;
653 if(!hnd) {
654 ALOGE("%s: layer handle is NULL", __FUNCTION__);
655 return -1;
656 }
657
658 hwc_rect_t crop = layer->sourceCrop;
659 hwc_rect_t dst = layer->displayFrame;
660 int transform = layer->transform;
661 eTransform orient = static_cast<eTransform>(transform);
662 int downscale = 0;
663 int rotFlags = ovutils::ROT_FLAGS_NONE;
664 Whf whf(hnd->width, hnd->height,
665 getMdpFormat(hnd->format), hnd->size);
666
667 if(isYuvBuffer(hnd) && ctx->mMDP.version >= qdutils::MDP_V4_2 &&
668 ctx->mMDP.version < qdutils::MDSS_V5) {
669 downscale = getDownscaleFactor(
670 crop.right - crop.left,
671 crop.bottom - crop.top,
672 dst.right - dst.left,
673 dst.bottom - dst.top);
674 if(downscale) {
675 rotFlags = ROT_DOWNSCALE_ENABLED;
676 }
677 }
678
679 setMdpFlags(layer, mdpFlags, downscale);
680 trimLayer(ctx, dpy, transform, crop, dst);
681
682 if(isYuvBuffer(hnd) && //if 90 component or downscale, use rot
683 ((transform & HWC_TRANSFORM_ROT_90) || downscale)) {
684 *rot = ctx->mRotMgr->getNext();
685 if(*rot == NULL) return -1;
686 //Configure rotator for pre-rotation
687 if(configRotator(*rot, whf, mdpFlags, orient, downscale) < 0)
688 return -1;
689 whf.format = (*rot)->getDstFormat();
690 updateSource(orient, whf, crop);
Saurabh Shahacf10202013-02-26 10:15:15 -0800691 rotFlags |= ovutils::ROT_PREROTATED;
692 }
693
Saurabh Shah76fd6552013-03-14 14:45:38 -0700694 //For the mdp, since either we are pre-rotating or MDP does flips
695 orient = OVERLAY_TRANSFORM_0;
696 transform = 0;
697
Saurabh Shahacf10202013-02-26 10:15:15 -0800698 PipeArgs parg(mdpFlags, whf, z, isFg, static_cast<eRotFlags>(rotFlags));
699 if(configMdp(ctx->mOverlay, parg, orient, crop, dst, dest) < 0) {
700 ALOGE("%s: commit failed for low res panel", __FUNCTION__);
701 return -1;
702 }
703 return 0;
704}
705
706int configureHighRes(hwc_context_t *ctx, hwc_layer_1_t *layer,
707 const int& dpy, eMdpFlags& mdpFlagsL, const eZorder& z,
708 const eIsFg& isFg, const eDest& lDest, const eDest& rDest,
709 Rotator **rot) {
710 private_handle_t *hnd = (private_handle_t *)layer->handle;
711 if(!hnd) {
712 ALOGE("%s: layer handle is NULL", __FUNCTION__);
713 return -1;
714 }
715
716 int hw_w = ctx->dpyAttr[dpy].xres;
717 int hw_h = ctx->dpyAttr[dpy].yres;
718 hwc_rect_t crop = layer->sourceCrop;
719 hwc_rect_t dst = layer->displayFrame;
720 int transform = layer->transform;
721 eTransform orient = static_cast<eTransform>(transform);
722 const int downscale = 0;
723 int rotFlags = ROT_FLAGS_NONE;
724
725 Whf whf(hnd->width, hnd->height,
726 getMdpFormat(hnd->format), hnd->size);
727
728 setMdpFlags(layer, mdpFlagsL);
729 trimLayer(ctx, dpy, transform, crop, dst);
730
731 if(isYuvBuffer(hnd) && (transform & HWC_TRANSFORM_ROT_90)) {
732 (*rot) = ctx->mRotMgr->getNext();
733 if((*rot) == NULL) return -1;
734 //Configure rotator for pre-rotation
735 if(configRotator(*rot, whf, mdpFlagsL, orient, downscale) < 0)
736 return -1;
737 whf.format = (*rot)->getDstFormat();
738 updateSource(orient, whf, crop);
Saurabh Shahacf10202013-02-26 10:15:15 -0800739 rotFlags |= ROT_PREROTATED;
740 }
741
742 eMdpFlags mdpFlagsR = mdpFlagsL;
743 setMdpFlags(mdpFlagsR, OV_MDSS_MDP_RIGHT_MIXER);
744
745 hwc_rect_t tmp_cropL, tmp_dstL;
746 hwc_rect_t tmp_cropR, tmp_dstR;
747
748 if(lDest != OV_INVALID) {
749 tmp_cropL = crop;
750 tmp_dstL = dst;
751 hwc_rect_t scissor = {0, 0, hw_w/2, hw_h };
752 qhwc::calculate_crop_rects(tmp_cropL, tmp_dstL, scissor, 0);
753 }
754 if(rDest != OV_INVALID) {
755 tmp_cropR = crop;
756 tmp_dstR = dst;
757 hwc_rect_t scissor = {hw_w/2, 0, hw_w, hw_h };
758 qhwc::calculate_crop_rects(tmp_cropR, tmp_dstR, scissor, 0);
759 }
760
761 //When buffer is flipped, contents of mixer config also needs to swapped.
762 //Not needed if the layer is confined to one half of the screen.
763 //If rotator has been used then it has also done the flips, so ignore them.
Saurabh Shah76fd6552013-03-14 14:45:38 -0700764 if((orient & OVERLAY_TRANSFORM_FLIP_V) && lDest != OV_INVALID
Saurabh Shahacf10202013-02-26 10:15:15 -0800765 && rDest != OV_INVALID && rot == NULL) {
766 hwc_rect_t new_cropR;
767 new_cropR.left = tmp_cropL.left;
768 new_cropR.right = new_cropR.left + (tmp_cropR.right - tmp_cropR.left);
769
770 hwc_rect_t new_cropL;
771 new_cropL.left = new_cropR.right;
772 new_cropL.right = tmp_cropR.right;
773
774 tmp_cropL.left = new_cropL.left;
775 tmp_cropL.right = new_cropL.right;
776
777 tmp_cropR.left = new_cropR.left;
778 tmp_cropR.right = new_cropR.right;
779
780 }
781
Saurabh Shah76fd6552013-03-14 14:45:38 -0700782 //For the mdp, since either we are pre-rotating or MDP does flips
783 orient = OVERLAY_TRANSFORM_0;
784 transform = 0;
785
Saurabh Shahacf10202013-02-26 10:15:15 -0800786 //configure left mixer
787 if(lDest != OV_INVALID) {
788 PipeArgs pargL(mdpFlagsL, whf, z, isFg,
789 static_cast<eRotFlags>(rotFlags));
790 if(configMdp(ctx->mOverlay, pargL, orient,
791 tmp_cropL, tmp_dstL, lDest) < 0) {
792 ALOGE("%s: commit failed for left mixer config", __FUNCTION__);
793 return -1;
794 }
795 }
796
797 //configure right mixer
798 if(rDest != OV_INVALID) {
799 PipeArgs pargR(mdpFlagsR, whf, z, isFg,
800 static_cast<eRotFlags>(rotFlags));
801 if(configMdp(ctx->mOverlay, pargR, orient,
802 tmp_cropR, tmp_dstR, rDest) < 0) {
803 ALOGE("%s: commit failed for right mixer config", __FUNCTION__);
804 return -1;
805 }
806 }
807
808 return 0;
809}
810
Naseer Ahmedb1c76322012-10-17 00:32:50 -0400811void LayerCache::resetLayerCache(int num) {
812 for(uint32_t i = 0; i < MAX_NUM_LAYERS; i++) {
813 hnd[i] = NULL;
814 }
815 numHwLayers = num;
816}
817
818void LayerCache::updateLayerCache(hwc_display_contents_1_t* list) {
819
820 int numFbLayers = 0;
821 int numCacheableLayers = 0;
822
823 canUseLayerCache = false;
824 //Bail if geometry changed or num of layers changed
825 if(list->flags & HWC_GEOMETRY_CHANGED ||
826 list->numHwLayers != numHwLayers ) {
827 resetLayerCache(list->numHwLayers);
828 return;
829 }
830
831 for(uint32_t i = 0; i < list->numHwLayers; i++) {
832 //Bail on skip layers
833 if(list->hwLayers[i].flags & HWC_SKIP_LAYER) {
834 resetLayerCache(list->numHwLayers);
835 return;
836 }
837
838 if(list->hwLayers[i].compositionType == HWC_FRAMEBUFFER) {
839 numFbLayers++;
840 if(hnd[i] == NULL) {
841 hnd[i] = list->hwLayers[i].handle;
842 } else if (hnd[i] ==
843 list->hwLayers[i].handle) {
844 numCacheableLayers++;
845 } else {
846 hnd[i] = NULL;
847 return;
848 }
849 } else {
850 hnd[i] = NULL;
851 }
852 }
853 if(numFbLayers == numCacheableLayers)
854 canUseLayerCache = true;
855
856 //XXX: The marking part is separate, if MDP comp wants
857 // to use it in the future. Right now getting MDP comp
858 // to use this is more trouble than it is worth.
859 markCachedLayersAsOverlay(list);
860}
861
862void LayerCache::markCachedLayersAsOverlay(hwc_display_contents_1_t* list) {
863 //This optimization only works if ALL the layer handles
864 //that were on the framebuffer didn't change.
865 if(canUseLayerCache){
866 for(uint32_t i = 0; i < list->numHwLayers; i++) {
867 if (list->hwLayers[i].handle &&
868 list->hwLayers[i].handle == hnd[i] &&
869 list->hwLayers[i].compositionType != HWC_FRAMEBUFFER_TARGET)
870 {
871 list->hwLayers[i].compositionType = HWC_OVERLAY;
872 }
873 }
874 }
Naseer Ahmedb1c76322012-10-17 00:32:50 -0400875}
876
Saurabh Shahacf10202013-02-26 10:15:15 -0800877};//namespace qhwc