1 /* 2 * Copyright (C) 2008 The Android Open Source Project 3 * Copyright (c) 2010-2014, The Linux Foundation. All rights reserved. 4 * Not a Contribution, Apache license notifications and license are retained 5 * for attribution purposes only. 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 */ 19 20 #include <math.h> 21 #include "overlayUtils.h" 22 #include "overlayRotator.h" 23 24 #define DEBUG_MDSS_ROT 0 25 26 #ifdef VENUS_COLOR_FORMAT 27 #include <media/msm_media_info.h> 28 #else 29 #define VENUS_BUFFER_SIZE(args...) 0 30 #endif 31 32 #ifndef MDSS_MDP_ROT_ONLY 33 #define MDSS_MDP_ROT_ONLY 0x80 34 #endif 35 36 #define MDSS_ROT_MASK (MDP_ROT_90 | MDP_FLIP_UD | MDP_FLIP_LR) 37 38 namespace ovutils = overlay::utils; 39 40 namespace overlay { 41 using namespace utils; 42 43 MdssRot::MdssRot() { 44 reset(); 45 init(); 46 } 47 48 MdssRot::~MdssRot() { close(); } 49 50 bool MdssRot::enabled() const { return mEnabled; } 51 52 void MdssRot::setRotations(uint32_t flags) { mRotInfo.flags |= flags; } 53 54 int MdssRot::getSrcMemId() const { 55 return mRotData.data.memory_id; 56 } 57 58 int MdssRot::getDstMemId() const { 59 return mRotData.dst_data.memory_id; 60 } 61 62 uint32_t MdssRot::getSrcOffset() const { 63 return mRotData.data.offset; 64 } 65 66 uint32_t MdssRot::getDstOffset() const { 67 return mRotData.dst_data.offset; 68 } 69 70 uint32_t MdssRot::getDstFormat() const { 71 //For mdss src and dst formats are same 72 return mRotInfo.src.format; 73 } 74 75 utils::Whf MdssRot::getDstWhf() const { 76 //For Mdss dst_rect itself represents buffer dimensions. We ignore actual 77 //aligned values during buffer allocation. Also the driver overwrites the 78 //src.format field if destination format is different. 79 //This implementation detail makes it possible to retrieve w,h even before 80 //buffer allocation, which happens in queueBuffer. 81 return utils::Whf(mRotInfo.dst_rect.w, mRotInfo.dst_rect.h, 82 mRotInfo.src.format); 83 } 84 85 utils::Dim MdssRot::getDstDimensions() const { 86 return utils::Dim(mRotInfo.dst_rect.x, mRotInfo.dst_rect.y, 87 mRotInfo.dst_rect.w, mRotInfo.dst_rect.h); 88 } 89 90 uint32_t MdssRot::getSessId() const { return mRotInfo.id; } 91 92 void MdssRot::save() { 93 mLSRotInfo = mRotInfo; 94 } 95 96 bool MdssRot::rotConfChanged() const { 97 // 0 means same 98 if(0 == ::memcmp(&mRotInfo, &mLSRotInfo, 99 sizeof (mdp_overlay))) { 100 return false; 101 } 102 return true; 103 } 104 105 bool MdssRot::init() { 106 if(!utils::openDev(mFd, 0, Res::fbPath, O_RDWR)) { 107 ALOGE("MdssRot failed to init fb0"); 108 return false; 109 } 110 return true; 111 } 112 113 void MdssRot::setSource(const overlay::utils::Whf& awhf) { 114 utils::Whf whf(awhf); 115 116 mRotInfo.src.format = whf.format; 117 mRotInfo.src.width = whf.w; 118 mRotInfo.src.height = whf.h; 119 } 120 121 void MdssRot::setCrop(const utils::Dim& crop) { 122 mRotInfo.src_rect.x = crop.x; 123 mRotInfo.src_rect.y = crop.y; 124 mRotInfo.src_rect.w = crop.w; 125 mRotInfo.src_rect.h = crop.h; 126 } 127 128 void MdssRot::setDownscale(int downscale) { 129 mDownscale = downscale; 130 } 131 132 void MdssRot::setFlags(const utils::eMdpFlags& flags) { 133 mRotInfo.flags = flags; 134 } 135 136 void MdssRot::setTransform(const utils::eTransform& rot) 137 { 138 // reset rotation flags to avoid stale orientation values 139 mRotInfo.flags &= ~MDSS_ROT_MASK; 140 int flags = utils::getMdpOrient(rot); 141 if (flags != -1) 142 setRotations(flags); 143 mOrientation = static_cast<utils::eTransform>(flags); 144 ALOGE_IF(DEBUG_OVERLAY, "%s: rot=%d", __FUNCTION__, flags); 145 } 146 147 void MdssRot::doTransform() { 148 mRotInfo.flags |= mOrientation; 149 if(mOrientation & utils::OVERLAY_TRANSFORM_ROT_90) 150 utils::swap(mRotInfo.dst_rect.w, mRotInfo.dst_rect.h); 151 } 152 153 bool MdssRot::commit() { 154 Dim adjCrop(mRotInfo.src_rect.x,mRotInfo.src_rect.y, 155 mRotInfo.src_rect.w,mRotInfo.src_rect.h); 156 adjCrop = getFormatAdjustedCrop(adjCrop, mRotInfo.src.format, 157 mRotInfo.flags & utils::OV_MDP_DEINTERLACE); 158 adjCrop = getDownscaleAdjustedCrop(adjCrop, mDownscale); 159 160 mRotInfo.src_rect.x = adjCrop.x; 161 mRotInfo.src_rect.y = adjCrop.y; 162 mRotInfo.src_rect.w = adjCrop.w; 163 mRotInfo.src_rect.h = adjCrop.h; 164 165 mRotInfo.dst_rect.x = 0; 166 mRotInfo.dst_rect.y = 0; 167 mRotInfo.dst_rect.w = mDownscale ? 168 mRotInfo.src_rect.w / mDownscale : mRotInfo.src_rect.w; 169 mRotInfo.dst_rect.h = mDownscale ? 170 mRotInfo.src_rect.h / mDownscale : mRotInfo.src_rect.h; 171 //Clear for next round 172 mDownscale = 0; 173 174 doTransform(); 175 176 mRotInfo.flags |= MDSS_MDP_ROT_ONLY; 177 mEnabled = true; 178 if(!overlay::mdp_wrapper::setOverlay(mFd.getFD(), mRotInfo)) { 179 ALOGE("MdssRot commit failed!"); 180 dump(); 181 return (mEnabled = false); 182 } 183 mRotData.id = mRotInfo.id; 184 return true; 185 } 186 187 bool MdssRot::queueBuffer(int fd, uint32_t offset) { 188 if(enabled() and (not isRotCached(fd,offset))) { 189 int prev_fd = getSrcMemId(); 190 uint32_t prev_offset = getSrcOffset(); 191 192 mRotData.data.memory_id = fd; 193 mRotData.data.offset = offset; 194 195 if(false == remap(RotMem::ROT_NUM_BUFS)) { 196 ALOGE("%s Remap failed, not queuing", __FUNCTION__); 197 return false; 198 } 199 200 mRotData.dst_data.offset = 201 mMem.mRotOffset[mMem.mCurrIndex]; 202 203 if(!overlay::mdp_wrapper::play(mFd.getFD(), mRotData)) { 204 ALOGE("MdssRot play failed!"); 205 dump(); 206 mRotData.data.memory_id = prev_fd; 207 mRotData.data.offset = prev_offset; 208 return false; 209 } 210 save(); 211 mMem.mCurrIndex = 212 (mMem.mCurrIndex + 1) % mMem.mem.numBufs(); 213 } 214 return true; 215 } 216 217 bool MdssRot::open_i(uint32_t numbufs, uint32_t bufsz) 218 { 219 OvMem mem; 220 OVASSERT(MAP_FAILED == mem.addr(), "MAP failed in open_i"); 221 bool isSecure = mRotInfo.flags & utils::OV_MDP_SECURE_OVERLAY_SESSION; 222 223 if(!mem.open(numbufs, bufsz, isSecure)){ 224 ALOGE("%s: Failed to open", __func__); 225 mem.close(); 226 return false; 227 } 228 229 OVASSERT(MAP_FAILED != mem.addr(), "MAP failed"); 230 OVASSERT(mem.getFD() != -1, "getFd is -1"); 231 232 mRotData.dst_data.memory_id = mem.getFD(); 233 mRotData.dst_data.offset = 0; 234 mMem.mem = mem; 235 return true; 236 } 237 238 bool MdssRot::remap(uint32_t numbufs) { 239 // Calculate the size based on rotator's dst format, w and h. 240 uint32_t opBufSize = calcOutputBufSize(); 241 // If current size changed, remap 242 if(opBufSize == mMem.size()) { 243 ALOGE_IF(DEBUG_OVERLAY, "%s: same size %d", __FUNCTION__, opBufSize); 244 return true; 245 } 246 247 ALOGE_IF(DEBUG_OVERLAY, "%s: size changed - remapping", __FUNCTION__); 248 249 if(!mMem.close()) { 250 ALOGE("%s error in closing prev rot mem", __FUNCTION__); 251 return false; 252 } 253 254 if(!open_i(numbufs, opBufSize)) { 255 ALOGE("%s Error could not open", __FUNCTION__); 256 return false; 257 } 258 259 for (uint32_t i = 0; i < numbufs; ++i) { 260 mMem.mRotOffset[i] = i * opBufSize; 261 } 262 263 return true; 264 } 265 266 bool MdssRot::close() { 267 bool success = true; 268 if(mFd.valid() && (getSessId() != (uint32_t) MSMFB_NEW_REQUEST)) { 269 if(!mdp_wrapper::unsetOverlay(mFd.getFD(), getSessId())) { 270 ALOGE("MdssRot::close unsetOverlay failed, fd=%d sessId=%d", 271 mFd.getFD(), getSessId()); 272 success = false; 273 } 274 } 275 276 if (!mFd.close()) { 277 ALOGE("Mdss Rot error closing fd"); 278 success = false; 279 } 280 if (!mMem.close()) { 281 ALOGE("Mdss Rot error closing mem"); 282 success = false; 283 } 284 reset(); 285 return success; 286 } 287 288 void MdssRot::reset() { 289 ovutils::memset0(mRotInfo); 290 ovutils::memset0(mLSRotInfo); 291 ovutils::memset0(mRotData); 292 mRotData.data.memory_id = -1; 293 mRotInfo.id = MSMFB_NEW_REQUEST; 294 ovutils::memset0(mMem.mRotOffset); 295 mMem.mCurrIndex = 0; 296 mOrientation = utils::OVERLAY_TRANSFORM_0; 297 mDownscale = 0; 298 } 299 300 void MdssRot::dump() const { 301 ALOGE("== Dump MdssRot start =="); 302 mFd.dump(); 303 mMem.mem.dump(); 304 mdp_wrapper::dump("mRotInfo", mRotInfo); 305 mdp_wrapper::dump("mRotData", mRotData); 306 ALOGE("== Dump MdssRot end =="); 307 } 308 309 uint32_t MdssRot::calcOutputBufSize() { 310 uint32_t opBufSize = 0; 311 ovutils::Whf destWhf(mRotInfo.dst_rect.w, mRotInfo.dst_rect.h, 312 mRotInfo.src.format); //mdss src and dst formats are same. 313 314 if (mRotInfo.flags & ovutils::OV_MDSS_MDP_BWC_EN) { 315 opBufSize = calcCompressedBufSize(destWhf); 316 } else { 317 opBufSize = Rotator::calcOutputBufSize(destWhf); 318 } 319 320 return opBufSize; 321 } 322 323 void MdssRot::getDump(char *buf, size_t len) const { 324 ovutils::getDump(buf, len, "MdssRotCtrl", mRotInfo); 325 ovutils::getDump(buf, len, "MdssRotData", mRotData); 326 } 327 328 // Calculate the compressed o/p buffer size for BWC 329 uint32_t MdssRot::calcCompressedBufSize(const ovutils::Whf& destWhf) { 330 uint32_t bufSize = 0; 331 //Worst case alignments 332 int aWidth = ovutils::align(destWhf.w, 64); 333 int aHeight = ovutils::align(destWhf.h, 4); 334 /* 335 Format | RAU size (width x height) 336 ---------------------------------------------- 337 ARGB | 32 pixel x 4 line 338 RGB888 | 32 pixel x 4 line 339 Y (Luma) | 64 pixel x 4 line 340 CRCB 420 | 32 pixel x 2 line 341 CRCB 422 H2V1 | 32 pixel x 4 line 342 CRCB 422 H1V2 | 64 pixel x 2 line 343 344 Metadata requirements:- 345 1 byte meta data for every 8 RAUs 346 2 byte meta data per RAU 347 */ 348 349 //These blocks attempt to allocate for the worst case in each of the 350 //respective format classes, yuv/rgb. The table above is for reference 351 if(utils::isYuv(destWhf.format)) { 352 int yRauCount = aWidth / 64; //Y 353 int cRauCount = aWidth / 32; //C 354 int yStride = (64 * 4 * yRauCount) + alignup(yRauCount, 8) / 8; 355 int cStride = ((32 * 2 * cRauCount) + alignup(cRauCount, 8) / 8) * 2; 356 int yStrideOffset = (aHeight / 4); 357 int cStrideOffset = (aHeight / 2); 358 bufSize = (yStride * yStrideOffset + cStride * cStrideOffset) + 359 (yRauCount * yStrideOffset * 2) + 360 (cRauCount * cStrideOffset * 2) * 2; 361 ALOGD_IF(DEBUG_MDSS_ROT, "%s:YUV Y RAU Count = %d C RAU Count = %d", 362 __FUNCTION__, yRauCount, cRauCount); 363 } else { 364 int rauCount = aWidth / 32; 365 //Single plane 366 int stride = (32 * 4 * rauCount) + alignup(rauCount, 8) / 8; 367 int strideOffset = (aHeight / 4); 368 bufSize = (stride * strideOffset * 4 /*bpp*/) + 369 (rauCount * strideOffset * 2); 370 ALOGD_IF(DEBUG_MDSS_ROT, "%s:RGB RAU count = %d", __FUNCTION__, 371 rauCount); 372 } 373 374 ALOGD_IF(DEBUG_MDSS_ROT, "%s: aligned width = %d, aligned height = %d " 375 "Buf Size = %d", __FUNCTION__, aWidth, aHeight, bufSize); 376 377 return bufSize; 378 } 379 380 int MdssRot::getDownscaleFactor(const int& srcW, const int& srcH, 381 const int& dstW, const int& dstH, const uint32_t& mdpFormat, 382 const bool& isInterlaced) { 383 if(not srcW or not srcH or not dstW or not dstH or isInterlaced) return 0; 384 385 Dim crop(0, 0, srcW, srcH); 386 Dim adjCrop = getFormatAdjustedCrop(crop, mdpFormat, 387 false /*isInterlaced */); 388 389 uint32_t downscale = min((adjCrop.w / dstW), (adjCrop.h / dstH)); 390 //Reduced to a power of 2 391 downscale = (uint32_t) powf(2.0f, floorf(log2f((float)downscale))); 392 393 if(downscale < 2 or downscale > 32) return 0; 394 395 //Allow only 1 line or pixel to be chopped off since the source needs to 396 //be aligned to downscale. Progressively try with smaller downscale to see 397 //if we can satisfy the threshold 398 //For YUV the loop shouldnt be needed, unless in exceptional cases 399 Dim dsAdjCrop = getDownscaleAdjustedCrop(adjCrop, downscale); 400 while(downscale > 2 and (adjCrop.w > dsAdjCrop.w or 401 adjCrop.h > dsAdjCrop.h)) { 402 downscale /= 2; 403 dsAdjCrop = getDownscaleAdjustedCrop(adjCrop, downscale); 404 } 405 406 if(not dsAdjCrop.w or not dsAdjCrop.h) return 0; 407 return downscale; 408 } 409 410 Dim MdssRot::getFormatAdjustedCrop(const Dim& crop, 411 const uint32_t& mdpFormat, const bool& isInterlaced) { 412 Dim adjCrop = crop; 413 if (isYuv(mdpFormat)) { 414 normalizeCrop(adjCrop.x, adjCrop.w); 415 normalizeCrop(adjCrop.y, adjCrop.h); 416 // For interlaced, crop.h should be 4-aligned 417 if (isInterlaced and (adjCrop.h % 4)) 418 adjCrop.h = aligndown(adjCrop.h, 4); 419 } 420 return adjCrop; 421 } 422 423 Dim MdssRot::getDownscaleAdjustedCrop(const Dim& crop, 424 const uint32_t& downscale) { 425 uint32_t alignedSrcW = aligndown(crop.w, downscale * 2); 426 uint32_t alignedSrcH = aligndown(crop.h, downscale * 2); 427 return Dim(crop.x, crop.y, alignedSrcW, alignedSrcH); 428 } 429 430 } // namespace overlay 431