1 /* 2 * Copyright (C) 2008 The Android Open Source Project 3 * Copyright (c) 2010-2014, 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 #include <overlay.h> 24 25 #ifdef USES_QSEED_SCALAR 26 #include <scale/scale.h> 27 using namespace scale; 28 #endif 29 30 #define HSIC_SETTINGS_DEBUG 0 31 32 using namespace qdutils; 33 34 static inline bool isEqual(float f1, float f2) { 35 return ((int)(f1*100) == (int)(f2*100)) ? true : false; 36 } 37 38 namespace ovutils = overlay::utils; 39 namespace overlay { 40 41 bool MdpCtrl::init(const int& dpy) { 42 int fbnum = Overlay::getFbForDpy(dpy); 43 if( fbnum < 0 ) { 44 ALOGE("%s: Invalid FB for the display: %d",__FUNCTION__, dpy); 45 return false; 46 } 47 48 // FD init 49 if(!utils::openDev(mFd, fbnum, 50 Res::fbPath, O_RDWR)){ 51 ALOGE("Ctrl failed to init fbnum=%d", fbnum); 52 return false; 53 } 54 mDpy = dpy; 55 return true; 56 } 57 58 void MdpCtrl::reset() { 59 utils::memset0(mOVInfo); 60 mOVInfo.id = MSMFB_NEW_REQUEST; 61 mOrientation = utils::OVERLAY_TRANSFORM_0; 62 mDownscale = 0; 63 mDpy = 0; 64 #ifdef USES_POST_PROCESSING 65 memset(&mParams, 0, sizeof(struct compute_params)); 66 mParams.params.conv_params.order = hsic_order_hsc_i; 67 mParams.params.conv_params.interface = interface_rec601; 68 mParams.params.conv_params.cc_matrix[0][0] = 1; 69 mParams.params.conv_params.cc_matrix[1][1] = 1; 70 mParams.params.conv_params.cc_matrix[2][2] = 1; 71 #endif 72 } 73 74 bool MdpCtrl::close() { 75 bool result = true; 76 if(MSMFB_NEW_REQUEST != static_cast<int>(mOVInfo.id)) { 77 if(!mdp_wrapper::unsetOverlay(mFd.getFD(), mOVInfo.id)) { 78 ALOGE("MdpCtrl close error in unset"); 79 result = false; 80 } 81 } 82 #ifdef USES_POST_PROCESSING 83 /* free allocated memory in PP */ 84 if (mOVInfo.overlay_pp_cfg.igc_cfg.c0_c1_data) 85 free(mOVInfo.overlay_pp_cfg.igc_cfg.c0_c1_data); 86 #endif 87 reset(); 88 89 if(!mFd.close()) { 90 result = false; 91 } 92 93 return result; 94 } 95 96 void MdpCtrl::setSource(const utils::PipeArgs& args) { 97 setSrcWhf(args.whf); 98 99 //TODO These are hardcoded. Can be moved out of setSource. 100 mOVInfo.transp_mask = 0xffffffff; 101 102 //TODO These calls should ideally be a part of setPipeParams API 103 setFlags(args.mdpFlags); 104 setZ(args.zorder); 105 setIsFg(args.isFg); 106 setPlaneAlpha(args.planeAlpha); 107 setBlending(args.blending); 108 } 109 110 void MdpCtrl::setCrop(const utils::Dim& d) { 111 setSrcRectDim(d); 112 } 113 114 void MdpCtrl::setColor(const uint32_t color) { 115 mOVInfo.bg_color = color; 116 } 117 118 void MdpCtrl::setPosition(const overlay::utils::Dim& d) { 119 setDstRectDim(d); 120 } 121 122 void MdpCtrl::setTransform(const utils::eTransform& orient) { 123 int rot = utils::getMdpOrient(orient); 124 setUserData(rot); 125 mOrientation = static_cast<utils::eTransform>(rot); 126 } 127 128 void MdpCtrl::doTransform() { 129 setRotationFlags(); 130 utils::Whf whf = getSrcWhf(); 131 utils::Dim dim = getSrcRectDim(); 132 utils::preRotateSource(mOrientation, whf, dim); 133 setSrcWhf(whf); 134 setSrcRectDim(dim); 135 } 136 137 void MdpCtrl::doDownscale() { 138 int mdpVersion = MDPVersion::getInstance().getMDPVersion(); 139 if(mdpVersion < MDSS_V5) { 140 mOVInfo.src_rect.x >>= mDownscale; 141 mOVInfo.src_rect.y >>= mDownscale; 142 mOVInfo.src_rect.w >>= mDownscale; 143 mOVInfo.src_rect.h >>= mDownscale; 144 } else if(MDPVersion::getInstance().supportsDecimation()) { 145 //Decimation + MDP Downscale 146 mOVInfo.horz_deci = 0; 147 mOVInfo.vert_deci = 0; 148 int minHorDeci = 0; 149 if(mOVInfo.src_rect.w > 2048) { 150 //If the client sends us something > what a layer mixer supports 151 //then it means it doesn't want to use split-pipe but wants us to 152 //decimate. A minimum decimation of 2 will ensure that the width is 153 //always within layer mixer limits. 154 minHorDeci = 2; 155 } 156 157 float horDscale = 0.0f; 158 float verDscale = 0.0f; 159 160 utils::getDecimationFactor(mOVInfo.src_rect.w, mOVInfo.src_rect.h, 161 mOVInfo.dst_rect.w, mOVInfo.dst_rect.h, horDscale, verDscale); 162 163 if(horDscale < minHorDeci) 164 horDscale = minHorDeci; 165 166 if((int)horDscale) 167 mOVInfo.horz_deci = (int)log2f(horDscale); 168 169 if((int)verDscale) 170 mOVInfo.vert_deci = (int)log2f(verDscale); 171 } 172 } 173 174 bool MdpCtrl::set() { 175 int mdpVersion = MDPVersion::getInstance().getMDPVersion(); 176 //deferred calcs, so APIs could be called in any order. 177 doTransform(); 178 utils::Whf whf = getSrcWhf(); 179 if(utils::isYuv(whf.format)) { 180 utils::normalizeCrop(mOVInfo.src_rect.x, mOVInfo.src_rect.w); 181 utils::normalizeCrop(mOVInfo.src_rect.y, mOVInfo.src_rect.h); 182 if(mdpVersion < MDSS_V5) { 183 utils::even_floor(mOVInfo.dst_rect.w); 184 utils::even_floor(mOVInfo.dst_rect.h); 185 } else if (mOVInfo.flags & MDP_DEINTERLACE) { 186 // For interlaced, crop.h should be 4-aligned 187 if (!(mOVInfo.flags & MDP_SOURCE_ROTATED_90) && 188 (mOVInfo.src_rect.h % 4)) 189 mOVInfo.src_rect.h = utils::aligndown(mOVInfo.src_rect.h, 4); 190 } 191 } else { 192 if (mdpVersion >= MDSS_V5) { 193 // Check for 1-pixel down-scaling 194 if (mOVInfo.src_rect.w - mOVInfo.dst_rect.w == 1) 195 mOVInfo.src_rect.w -= 1; 196 if (mOVInfo.src_rect.h - mOVInfo.dst_rect.h == 1) 197 mOVInfo.src_rect.h -= 1; 198 } 199 } 200 201 doDownscale(); 202 return true; 203 } 204 205 //Update src format based on rotator's destination format. 206 void MdpCtrl::updateSrcFormat(const uint32_t& rotDestFmt) { 207 utils::Whf whf = getSrcWhf(); 208 whf.format = rotDestFmt; 209 setSrcWhf(whf); 210 } 211 212 void MdpCtrl::dump() const { 213 ALOGE("== Dump MdpCtrl start =="); 214 mFd.dump(); 215 mdp_wrapper::dump("mOVInfo", mOVInfo); 216 ALOGE("== Dump MdpCtrl end =="); 217 } 218 219 void MdpCtrl::getDump(char *buf, size_t len) { 220 ovutils::getDump(buf, len, "Ctrl", mOVInfo); 221 } 222 223 void MdpData::dump() const { 224 ALOGE("== Dump MdpData start =="); 225 mFd.dump(); 226 mdp_wrapper::dump("mOvData", mOvData); 227 ALOGE("== Dump MdpData end =="); 228 } 229 230 void MdpData::getDump(char *buf, size_t len) { 231 ovutils::getDump(buf, len, "Data", mOvData); 232 } 233 234 void MdpCtrl3D::dump() const { 235 ALOGE("== Dump MdpCtrl start =="); 236 mFd.dump(); 237 ALOGE("== Dump MdpCtrl end =="); 238 } 239 240 bool MdpCtrl::setVisualParams(const MetaData_t& data) { 241 ALOGD_IF(0, "In %s: data.operation = %d", __FUNCTION__, data.operation); 242 #ifdef USES_POST_PROCESSING 243 bool needUpdate = false; 244 /* calculate the data */ 245 if (data.operation & PP_PARAM_HSIC) { 246 if (mParams.params.pa_params.hue != data.hsicData.hue) { 247 ALOGD_IF(HSIC_SETTINGS_DEBUG, 248 "Hue has changed from %d to %d", 249 mParams.params.pa_params.hue,data.hsicData.hue); 250 needUpdate = true; 251 } 252 253 if (!isEqual(mParams.params.pa_params.sat, 254 data.hsicData.saturation)) { 255 ALOGD_IF(HSIC_SETTINGS_DEBUG, 256 "Saturation has changed from %f to %f", 257 mParams.params.pa_params.sat, 258 data.hsicData.saturation); 259 needUpdate = true; 260 } 261 262 if (mParams.params.pa_params.intensity != data.hsicData.intensity) { 263 ALOGD_IF(HSIC_SETTINGS_DEBUG, 264 "Intensity has changed from %d to %d", 265 mParams.params.pa_params.intensity, 266 data.hsicData.intensity); 267 needUpdate = true; 268 } 269 270 if (!isEqual(mParams.params.pa_params.contrast, 271 data.hsicData.contrast)) { 272 ALOGD_IF(HSIC_SETTINGS_DEBUG, 273 "Contrast has changed from %f to %f", 274 mParams.params.pa_params.contrast, 275 data.hsicData.contrast); 276 needUpdate = true; 277 } 278 279 if (needUpdate) { 280 mParams.params.pa_params.hue = data.hsicData.hue; 281 mParams.params.pa_params.sat = data.hsicData.saturation; 282 mParams.params.pa_params.intensity = data.hsicData.intensity; 283 mParams.params.pa_params.contrast = data.hsicData.contrast; 284 mParams.params.pa_params.ops = MDP_PP_OPS_WRITE | MDP_PP_OPS_ENABLE; 285 mParams.operation |= PP_OP_PA; 286 } 287 } 288 289 if (data.operation & PP_PARAM_SHARP2) { 290 if (mParams.params.sharp_params.strength != data.Sharp2Data.strength) { 291 needUpdate = true; 292 } 293 if (mParams.params.sharp_params.edge_thr != data.Sharp2Data.edge_thr) { 294 needUpdate = true; 295 } 296 if (mParams.params.sharp_params.smooth_thr != 297 data.Sharp2Data.smooth_thr) { 298 needUpdate = true; 299 } 300 if (mParams.params.sharp_params.noise_thr != 301 data.Sharp2Data.noise_thr) { 302 needUpdate = true; 303 } 304 305 if (needUpdate) { 306 mParams.params.sharp_params.strength = data.Sharp2Data.strength; 307 mParams.params.sharp_params.edge_thr = data.Sharp2Data.edge_thr; 308 mParams.params.sharp_params.smooth_thr = 309 data.Sharp2Data.smooth_thr; 310 mParams.params.sharp_params.noise_thr = data.Sharp2Data.noise_thr; 311 mParams.params.sharp_params.ops = 312 MDP_PP_OPS_WRITE | MDP_PP_OPS_ENABLE; 313 mParams.operation |= PP_OP_SHARP; 314 } 315 } 316 317 if (data.operation & PP_PARAM_IGC) { 318 if (mOVInfo.overlay_pp_cfg.igc_cfg.c0_c1_data == NULL){ 319 uint32_t *igcData 320 = (uint32_t *)malloc(2 * MAX_IGC_LUT_ENTRIES * sizeof(uint32_t)); 321 if (!igcData) { 322 ALOGE("IGC storage allocated failed"); 323 return false; 324 } 325 mOVInfo.overlay_pp_cfg.igc_cfg.c0_c1_data = igcData; 326 mOVInfo.overlay_pp_cfg.igc_cfg.c2_data 327 = igcData + MAX_IGC_LUT_ENTRIES; 328 } 329 330 memcpy(mParams.params.igc_lut_params.c0, 331 data.igcData.c0, sizeof(uint16_t) * MAX_IGC_LUT_ENTRIES); 332 memcpy(mParams.params.igc_lut_params.c1, 333 data.igcData.c1, sizeof(uint16_t) * MAX_IGC_LUT_ENTRIES); 334 memcpy(mParams.params.igc_lut_params.c2, 335 data.igcData.c2, sizeof(uint16_t) * MAX_IGC_LUT_ENTRIES); 336 337 mParams.params.igc_lut_params.ops 338 = MDP_PP_OPS_WRITE | MDP_PP_OPS_ENABLE; 339 mParams.operation |= PP_OP_IGC; 340 needUpdate = true; 341 } 342 343 if (data.operation & PP_PARAM_VID_INTFC) { 344 mParams.params.conv_params.interface = 345 (interface_type) data.video_interface; 346 needUpdate = true; 347 } 348 349 if (needUpdate) { 350 display_pp_compute_params(&mParams, &mOVInfo.overlay_pp_cfg); 351 } 352 #endif 353 return true; 354 } 355 356 bool MdpCtrl::validateAndSet(MdpCtrl* mdpCtrlArray[], const int& count, 357 const int& fbFd) { 358 mdp_overlay* ovArray[count]; 359 memset(&ovArray, 0, sizeof(ovArray)); 360 361 for(int i = 0; i < count; i++) { 362 ovArray[i] = &mdpCtrlArray[i]->mOVInfo; 363 } 364 365 struct mdp_overlay_list list; 366 memset(&list, 0, sizeof(struct mdp_overlay_list)); 367 list.num_overlays = count; 368 list.overlay_list = ovArray; 369 370 #ifdef USES_QSEED_SCALAR 371 Scale *scalar = Overlay::getScalar(); 372 if(scalar) { 373 scalar->applyScale(&list); 374 } 375 #endif 376 377 if(!mdp_wrapper::validateAndSet(fbFd, list)) { 378 if(list.processed_overlays < list.num_overlays) { 379 mdp_wrapper::dump("Bad ov dump: ", 380 *list.overlay_list[list.processed_overlays]); 381 } 382 return false; 383 } 384 385 return true; 386 } 387 388 389 //// MdpData //////////// 390 bool MdpData::init(const int& dpy) { 391 int fbnum = Overlay::getFbForDpy(dpy); 392 if( fbnum < 0 ) { 393 ALOGE("%s: Invalid FB for the display: %d",__FUNCTION__, dpy); 394 return false; 395 } 396 397 // FD init 398 if(!utils::openDev(mFd, fbnum, Res::fbPath, O_RDWR)){ 399 ALOGE("Ctrl failed to init fbnum=%d", fbnum); 400 return false; 401 } 402 return true; 403 } 404 405 } // overlay 406
