1 /*
2 * Copyright (C) 2008 The Android Open Source Project
3 * Copyright (c) 2010-2013, The Linux Foundation. All rights reserved.
4 *
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
8 *
9 * http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18 #include <math.h>
19 #include <mdp_version.h>
20 #include "overlayUtils.h"
21 #include "overlayMdp.h"
22 #include "mdp_version.h"
23
24 #define HSIC_SETTINGS_DEBUG 0
25
26 using namespace qdutils;
27
isEqual(float f1,float f2)28 static inline bool isEqual(float f1, float f2) {
29 return ((int)(f1*100) == (int)(f2*100)) ? true : false;
30 }
31
32 namespace ovutils = overlay::utils;
33 namespace overlay {
34
init(uint32_t fbnum)35 bool MdpCtrl::init(uint32_t fbnum) {
36 // FD init
37 if(!utils::openDev(mFd, fbnum,
38 Res::fbPath, O_RDWR)){
39 ALOGE("Ctrl failed to init fbnum=%d", fbnum);
40 return false;
41 }
42 return true;
43 }
44
reset()45 void MdpCtrl::reset() {
46 utils::memset0(mOVInfo);
47 utils::memset0(mLkgo);
48 mOVInfo.id = MSMFB_NEW_REQUEST;
49 mLkgo.id = MSMFB_NEW_REQUEST;
50 mOrientation = utils::OVERLAY_TRANSFORM_0;
51 mDownscale = 0;
52 mForceSet = false;
53 #ifdef USES_POST_PROCESSING
54 mPPChanged = false;
55 memset(&mParams, 0, sizeof(struct compute_params));
56 mParams.params.conv_params.order = hsic_order_hsc_i;
57 mParams.params.conv_params.interface = interface_rec601;
58 mParams.params.conv_params.cc_matrix[0][0] = 1;
59 mParams.params.conv_params.cc_matrix[1][1] = 1;
60 mParams.params.conv_params.cc_matrix[2][2] = 1;
61 #endif
62 }
63
close()64 bool MdpCtrl::close() {
65 bool result = true;
66 if(MSMFB_NEW_REQUEST != static_cast<int>(mOVInfo.id)) {
67 if(!mdp_wrapper::unsetOverlay(mFd.getFD(), mOVInfo.id)) {
68 ALOGE("MdpCtrl close error in unset");
69 result = false;
70 }
71 }
72 #ifdef USES_POST_PROCESSING
73 /* free allocated memory in PP */
74 if (mOVInfo.overlay_pp_cfg.igc_cfg.c0_c1_data)
75 free(mOVInfo.overlay_pp_cfg.igc_cfg.c0_c1_data);
76 #endif
77 reset();
78
79 if(!mFd.close()) {
80 result = false;
81 }
82
83 return result;
84 }
85
setSource(const utils::PipeArgs & args)86 void MdpCtrl::setSource(const utils::PipeArgs& args) {
87 setSrcWhf(args.whf);
88
89 //TODO These are hardcoded. Can be moved out of setSource.
90 mOVInfo.transp_mask = 0xffffffff;
91
92 //TODO These calls should ideally be a part of setPipeParams API
93 setFlags(args.mdpFlags);
94 setZ(args.zorder);
95 setIsFg(args.isFg);
96 setPlaneAlpha(args.planeAlpha);
97 setBlending(args.blending);
98 }
99
setCrop(const utils::Dim & d)100 void MdpCtrl::setCrop(const utils::Dim& d) {
101 setSrcRectDim(d);
102 }
103
setPosition(const overlay::utils::Dim & d)104 void MdpCtrl::setPosition(const overlay::utils::Dim& d) {
105 setDstRectDim(d);
106 }
107
setTransform(const utils::eTransform & orient)108 void MdpCtrl::setTransform(const utils::eTransform& orient) {
109 int rot = utils::getMdpOrient(orient);
110 setUserData(rot);
111 mOrientation = static_cast<utils::eTransform>(rot);
112 }
113
doTransform()114 void MdpCtrl::doTransform() {
115 setRotationFlags();
116 utils::Whf whf = getSrcWhf();
117 utils::Dim dim = getSrcRectDim();
118 utils::preRotateSource(mOrientation, whf, dim);
119 setSrcWhf(whf);
120 setSrcRectDim(dim);
121 }
122
doDownscale()123 void MdpCtrl::doDownscale() {
124 int mdpVersion = MDPVersion::getInstance().getMDPVersion();
125 if(mdpVersion < MDSS_V5) {
126 mOVInfo.src_rect.x >>= mDownscale;
127 mOVInfo.src_rect.y >>= mDownscale;
128 mOVInfo.src_rect.w >>= mDownscale;
129 mOVInfo.src_rect.h >>= mDownscale;
130 } else if(MDPVersion::getInstance().supportsDecimation()) {
131 //Decimation + MDP Downscale
132 mOVInfo.horz_deci = 0;
133 mOVInfo.vert_deci = 0;
134 int minHorDeci = 0;
135 if(mOVInfo.src_rect.w > 2048) {
136 //If the client sends us something > what a layer mixer supports
137 //then it means it doesn't want to use split-pipe but wants us to
138 //decimate. A minimum decimation of 2 will ensure that the width is
139 //always within layer mixer limits.
140 minHorDeci = 2;
141 }
142
143 float horDscale = 0.0f;
144 float verDscale = 0.0f;
145
146 utils::getDecimationFactor(mOVInfo.src_rect.w, mOVInfo.src_rect.h,
147 mOVInfo.dst_rect.w, mOVInfo.dst_rect.h, horDscale, verDscale);
148
149 if(horDscale < minHorDeci)
150 horDscale = minHorDeci;
151
152 if((int)horDscale)
153 mOVInfo.horz_deci = (int)log2f(horDscale);
154
155 if((int)verDscale)
156 mOVInfo.vert_deci = (int)log2f(verDscale);
157 }
158 }
159
set()160 bool MdpCtrl::set() {
161 int mdpVersion = MDPVersion::getInstance().getMDPVersion();
162 //deferred calcs, so APIs could be called in any order.
163 doTransform();
164 utils::Whf whf = getSrcWhf();
165 if(utils::isYuv(whf.format)) {
166 utils::normalizeCrop(mOVInfo.src_rect.x, mOVInfo.src_rect.w);
167 utils::normalizeCrop(mOVInfo.src_rect.y, mOVInfo.src_rect.h);
168 if(mdpVersion < MDSS_V5) {
169 utils::even_floor(mOVInfo.dst_rect.w);
170 utils::even_floor(mOVInfo.dst_rect.h);
171 } else if (mOVInfo.flags & MDP_DEINTERLACE) {
172 // For interlaced, crop.h should be 4-aligned
173 if (!(mOVInfo.flags & MDP_SOURCE_ROTATED_90) &&
174 (mOVInfo.src_rect.h % 4))
175 mOVInfo.src_rect.h = utils::aligndown(mOVInfo.src_rect.h, 4);
176 }
177 } else {
178 if (mdpVersion >= MDSS_V5) {
179 // Check for 1-pixel down-scaling
180 if (mOVInfo.src_rect.w - mOVInfo.dst_rect.w == 1)
181 mOVInfo.src_rect.w -= 1;
182 if (mOVInfo.src_rect.h - mOVInfo.dst_rect.h == 1)
183 mOVInfo.src_rect.h -= 1;
184 }
185 }
186
187 doDownscale();
188
189 if(this->ovChanged() || mForceSet) {
190 mForceSet = false;
191 if(!mdp_wrapper::setOverlay(mFd.getFD(), mOVInfo)) {
192 ALOGE("MdpCtrl failed to setOverlay, restoring last known "
193 "good ov info");
194 mdp_wrapper::dump("== Bad OVInfo is: ", mOVInfo);
195 mdp_wrapper::dump("== Last good known OVInfo is: ", mLkgo);
196 this->restore();
197 return false;
198 }
199 this->save();
200 }
201
202 return true;
203 }
204
get()205 bool MdpCtrl::get() {
206 mdp_overlay ov;
207 ov.id = mOVInfo.id;
208 if (!mdp_wrapper::getOverlay(mFd.getFD(), ov)) {
209 ALOGE("MdpCtrl get failed");
210 return false;
211 }
212 mOVInfo = ov;
213 return true;
214 }
215
216 //Update src format based on rotator's destination format.
updateSrcFormat(const uint32_t & rotDestFmt)217 void MdpCtrl::updateSrcFormat(const uint32_t& rotDestFmt) {
218 utils::Whf whf = getSrcWhf();
219 whf.format = rotDestFmt;
220 setSrcWhf(whf);
221 }
222
dump() const223 void MdpCtrl::dump() const {
224 ALOGE("== Dump MdpCtrl start ==");
225 mFd.dump();
226 mdp_wrapper::dump("mOVInfo", mOVInfo);
227 ALOGE("== Dump MdpCtrl end ==");
228 }
229
getDump(char * buf,size_t len)230 void MdpCtrl::getDump(char *buf, size_t len) {
231 ovutils::getDump(buf, len, "Ctrl", mOVInfo);
232 }
233
dump() const234 void MdpData::dump() const {
235 ALOGE("== Dump MdpData start ==");
236 mFd.dump();
237 mdp_wrapper::dump("mOvData", mOvData);
238 ALOGE("== Dump MdpData end ==");
239 }
240
getDump(char * buf,size_t len)241 void MdpData::getDump(char *buf, size_t len) {
242 ovutils::getDump(buf, len, "Data", mOvData);
243 }
244
dump() const245 void MdpCtrl3D::dump() const {
246 ALOGE("== Dump MdpCtrl start ==");
247 mFd.dump();
248 ALOGE("== Dump MdpCtrl end ==");
249 }
250
setVisualParams(const MetaData_t & data)251 bool MdpCtrl::setVisualParams(const MetaData_t& data) {
252 bool needUpdate = false;
253 #ifdef USES_POST_PROCESSING
254 /* calculate the data */
255 if (data.operation & PP_PARAM_HSIC) {
256 if (mParams.params.pa_params.hue != data.hsicData.hue) {
257 ALOGD_IF(HSIC_SETTINGS_DEBUG,
258 "Hue has changed from %d to %d",
259 mParams.params.pa_params.hue,data.hsicData.hue);
260 needUpdate = true;
261 }
262
263 if (!isEqual(mParams.params.pa_params.sat,
264 data.hsicData.saturation)) {
265 ALOGD_IF(HSIC_SETTINGS_DEBUG,
266 "Saturation has changed from %f to %f",
267 mParams.params.pa_params.sat,
268 data.hsicData.saturation);
269 needUpdate = true;
270 }
271
272 if (mParams.params.pa_params.intensity != data.hsicData.intensity) {
273 ALOGD_IF(HSIC_SETTINGS_DEBUG,
274 "Intensity has changed from %d to %d",
275 mParams.params.pa_params.intensity,
276 data.hsicData.intensity);
277 needUpdate = true;
278 }
279
280 if (!isEqual(mParams.params.pa_params.contrast,
281 data.hsicData.contrast)) {
282 ALOGD_IF(HSIC_SETTINGS_DEBUG,
283 "Contrast has changed from %f to %f",
284 mParams.params.pa_params.contrast,
285 data.hsicData.contrast);
286 needUpdate = true;
287 }
288
289 if (needUpdate) {
290 mParams.params.pa_params.hue = data.hsicData.hue;
291 mParams.params.pa_params.sat = data.hsicData.saturation;
292 mParams.params.pa_params.intensity = data.hsicData.intensity;
293 mParams.params.pa_params.contrast = data.hsicData.contrast;
294 mParams.params.pa_params.ops = MDP_PP_OPS_WRITE | MDP_PP_OPS_ENABLE;
295 mParams.operation |= PP_OP_PA;
296 }
297 }
298
299 if (data.operation & PP_PARAM_SHARP2) {
300 if (mParams.params.sharp_params.strength != data.Sharp2Data.strength) {
301 needUpdate = true;
302 }
303 if (mParams.params.sharp_params.edge_thr != data.Sharp2Data.edge_thr) {
304 needUpdate = true;
305 }
306 if (mParams.params.sharp_params.smooth_thr !=
307 data.Sharp2Data.smooth_thr) {
308 needUpdate = true;
309 }
310 if (mParams.params.sharp_params.noise_thr !=
311 data.Sharp2Data.noise_thr) {
312 needUpdate = true;
313 }
314
315 if (needUpdate) {
316 mParams.params.sharp_params.strength = data.Sharp2Data.strength;
317 mParams.params.sharp_params.edge_thr = data.Sharp2Data.edge_thr;
318 mParams.params.sharp_params.smooth_thr =
319 data.Sharp2Data.smooth_thr;
320 mParams.params.sharp_params.noise_thr = data.Sharp2Data.noise_thr;
321 mParams.params.sharp_params.ops =
322 MDP_PP_OPS_WRITE | MDP_PP_OPS_ENABLE;
323 mParams.operation |= PP_OP_SHARP;
324 }
325 }
326
327 if (data.operation & PP_PARAM_IGC) {
328 if (mOVInfo.overlay_pp_cfg.igc_cfg.c0_c1_data == NULL){
329 uint32_t *igcData
330 = (uint32_t *)malloc(2 * MAX_IGC_LUT_ENTRIES * sizeof(uint32_t));
331 if (!igcData) {
332 ALOGE("IGC storage allocated failed");
333 return false;
334 }
335 mOVInfo.overlay_pp_cfg.igc_cfg.c0_c1_data = igcData;
336 mOVInfo.overlay_pp_cfg.igc_cfg.c2_data
337 = igcData + MAX_IGC_LUT_ENTRIES;
338 }
339
340 memcpy(mParams.params.igc_lut_params.c0,
341 data.igcData.c0, sizeof(uint16_t) * MAX_IGC_LUT_ENTRIES);
342 memcpy(mParams.params.igc_lut_params.c1,
343 data.igcData.c1, sizeof(uint16_t) * MAX_IGC_LUT_ENTRIES);
344 memcpy(mParams.params.igc_lut_params.c2,
345 data.igcData.c2, sizeof(uint16_t) * MAX_IGC_LUT_ENTRIES);
346
347 mParams.params.igc_lut_params.ops
348 = MDP_PP_OPS_WRITE | MDP_PP_OPS_ENABLE;
349 mParams.operation |= PP_OP_IGC;
350 needUpdate = true;
351 }
352
353 if (data.operation & PP_PARAM_VID_INTFC) {
354 mParams.params.conv_params.interface =
355 (interface_type) data.video_interface;
356 needUpdate = true;
357 }
358
359 if (needUpdate) {
360 display_pp_compute_params(&mParams, &mOVInfo.overlay_pp_cfg);
361 mPPChanged = true;
362 }
363 #endif
364 return true;
365 }
366
367 } // overlay
368