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 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 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 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 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 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 100 void MdpCtrl::setCrop(const utils::Dim& d) { 101 setSrcRectDim(d); 102 } 103 104 void MdpCtrl::setPosition(const overlay::utils::Dim& d) { 105 setDstRectDim(d); 106 } 107 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 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 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 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 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. 217 void MdpCtrl::updateSrcFormat(const uint32_t& rotDestFmt) { 218 utils::Whf whf = getSrcWhf(); 219 whf.format = rotDestFmt; 220 setSrcWhf(whf); 221 } 222 223 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 230 void MdpCtrl::getDump(char *buf, size_t len) { 231 ovutils::getDump(buf, len, "Ctrl", mOVInfo); 232 } 233 234 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 241 void MdpData::getDump(char *buf, size_t len) { 242 ovutils::getDump(buf, len, "Data", mOvData); 243 } 244 245 void MdpCtrl3D::dump() const { 246 ALOGE("== Dump MdpCtrl start =="); 247 mFd.dump(); 248 ALOGE("== Dump MdpCtrl end =="); 249 } 250 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
