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 "overlayUtils.h" 21 #include "overlayRotator.h" 22 23 #define DEBUG_MDSS_ROT 0 24 25 #ifdef VENUS_COLOR_FORMAT 26 #include <media/msm_media_info.h> 27 #else 28 #define VENUS_BUFFER_SIZE(args...) 0 29 #endif 30 31 #ifndef MDSS_MDP_ROT_ONLY 32 #define MDSS_MDP_ROT_ONLY 0x80 33 #endif 34 35 #define MDSS_ROT_MASK (MDP_ROT_90 | MDP_FLIP_UD | MDP_FLIP_LR) 36 37 namespace ovutils = overlay::utils; 38 39 namespace overlay { 40 MdssRot::MdssRot() { 41 reset(); 42 init(); 43 } 44 45 MdssRot::~MdssRot() { close(); } 46 47 bool MdssRot::enabled() const { return mEnabled; } 48 49 void MdssRot::setRotations(uint32_t flags) { mRotInfo.flags |= flags; } 50 51 int MdssRot::getDstMemId() const { 52 return mRotData.dst_data.memory_id; 53 } 54 55 uint32_t MdssRot::getDstOffset() const { 56 return mRotData.dst_data.offset; 57 } 58 59 uint32_t MdssRot::getDstFormat() const { 60 //For mdss src and dst formats are same 61 return mRotInfo.src.format; 62 } 63 64 uint32_t MdssRot::getSessId() const { return mRotInfo.id; } 65 66 bool MdssRot::init() { 67 if(!utils::openDev(mFd, 0, Res::fbPath, O_RDWR)) { 68 ALOGE("MdssRot failed to init fb0"); 69 return false; 70 } 71 return true; 72 } 73 74 void MdssRot::setSource(const overlay::utils::Whf& awhf) { 75 utils::Whf whf(awhf); 76 77 mRotInfo.src.format = whf.format; 78 mRotInfo.src.width = whf.w; 79 mRotInfo.src.height = whf.h; 80 } 81 82 void MdssRot::setCrop(const utils::Dim& crop) { 83 84 mRotInfo.src_rect.x = crop.x; 85 mRotInfo.src_rect.y = crop.y; 86 mRotInfo.src_rect.w = crop.w; 87 mRotInfo.src_rect.h = crop.h; 88 89 mRotInfo.dst_rect.x = 0; 90 mRotInfo.dst_rect.y = 0; 91 mRotInfo.dst_rect.w = crop.w; 92 mRotInfo.dst_rect.h = crop.h; 93 } 94 95 void MdssRot::setDownscale(int /*ds*/) { 96 } 97 98 void MdssRot::setFlags(const utils::eMdpFlags& flags) { 99 mRotInfo.flags = flags; 100 } 101 102 void MdssRot::setTransform(const utils::eTransform& rot) 103 { 104 // reset rotation flags to avoid stale orientation values 105 mRotInfo.flags &= ~MDSS_ROT_MASK; 106 int flags = utils::getMdpOrient(rot); 107 if (flags != -1) 108 setRotations(flags); 109 mOrientation = static_cast<utils::eTransform>(flags); 110 ALOGE_IF(DEBUG_OVERLAY, "%s: rot=%d", __FUNCTION__, flags); 111 } 112 113 void MdssRot::doTransform() { 114 mRotInfo.flags |= mOrientation; 115 if(mOrientation & utils::OVERLAY_TRANSFORM_ROT_90) 116 utils::swap(mRotInfo.dst_rect.w, mRotInfo.dst_rect.h); 117 } 118 119 bool MdssRot::commit() { 120 doTransform(); 121 mRotInfo.flags |= MDSS_MDP_ROT_ONLY; 122 mEnabled = true; 123 if(!overlay::mdp_wrapper::setOverlay(mFd.getFD(), mRotInfo)) { 124 ALOGE("MdssRot commit failed!"); 125 dump(); 126 return (mEnabled = false); 127 } 128 mRotData.id = mRotInfo.id; 129 return true; 130 } 131 132 bool MdssRot::queueBuffer(int fd, uint32_t offset) { 133 if(enabled()) { 134 mRotData.data.memory_id = fd; 135 mRotData.data.offset = offset; 136 137 if(false == remap(RotMem::ROT_NUM_BUFS)) { 138 ALOGE("%s Remap failed, not queuing", __FUNCTION__); 139 return false; 140 } 141 142 mRotData.dst_data.offset = 143 mMem.mRotOffset[mMem.mCurrIndex]; 144 mMem.mCurrIndex = 145 (mMem.mCurrIndex + 1) % mMem.mem.numBufs(); 146 147 if(!overlay::mdp_wrapper::play(mFd.getFD(), mRotData)) { 148 ALOGE("MdssRot play failed!"); 149 dump(); 150 return false; 151 } 152 } 153 return true; 154 } 155 156 bool MdssRot::open_i(uint32_t numbufs, uint32_t bufsz) 157 { 158 OvMem mem; 159 OVASSERT(MAP_FAILED == mem.addr(), "MAP failed in open_i"); 160 bool isSecure = mRotInfo.flags & utils::OV_MDP_SECURE_OVERLAY_SESSION; 161 162 if(!mem.open(numbufs, bufsz, isSecure)){ 163 ALOGE("%s: Failed to open", __func__); 164 mem.close(); 165 return false; 166 } 167 168 OVASSERT(MAP_FAILED != mem.addr(), "MAP failed"); 169 OVASSERT(mem.getFD() != -1, "getFd is -1"); 170 171 mRotData.dst_data.memory_id = mem.getFD(); 172 mRotData.dst_data.offset = 0; 173 mMem.mem = mem; 174 return true; 175 } 176 177 bool MdssRot::remap(uint32_t numbufs) { 178 // Calculate the size based on rotator's dst format, w and h. 179 uint32_t opBufSize = calcOutputBufSize(); 180 // If current size changed, remap 181 if(opBufSize == mMem.size()) { 182 ALOGE_IF(DEBUG_OVERLAY, "%s: same size %d", __FUNCTION__, opBufSize); 183 return true; 184 } 185 186 ALOGE_IF(DEBUG_OVERLAY, "%s: size changed - remapping", __FUNCTION__); 187 188 if(!mMem.close()) { 189 ALOGE("%s error in closing prev rot mem", __FUNCTION__); 190 return false; 191 } 192 193 if(!open_i(numbufs, opBufSize)) { 194 ALOGE("%s Error could not open", __FUNCTION__); 195 return false; 196 } 197 198 for (uint32_t i = 0; i < numbufs; ++i) { 199 mMem.mRotOffset[i] = i * opBufSize; 200 } 201 202 return true; 203 } 204 205 bool MdssRot::close() { 206 bool success = true; 207 if(mFd.valid() && (getSessId() != (uint32_t) MSMFB_NEW_REQUEST)) { 208 if(!mdp_wrapper::unsetOverlay(mFd.getFD(), getSessId())) { 209 ALOGE("MdssRot::close unsetOverlay failed, fd=%d sessId=%d", 210 mFd.getFD(), getSessId()); 211 success = false; 212 } 213 } 214 215 if (!mFd.close()) { 216 ALOGE("Mdss Rot error closing fd"); 217 success = false; 218 } 219 if (!mMem.close()) { 220 ALOGE("Mdss Rot error closing mem"); 221 success = false; 222 } 223 reset(); 224 return success; 225 } 226 227 void MdssRot::reset() { 228 ovutils::memset0(mRotInfo); 229 ovutils::memset0(mRotData); 230 mRotData.data.memory_id = -1; 231 mRotInfo.id = MSMFB_NEW_REQUEST; 232 ovutils::memset0(mMem.mRotOffset); 233 mMem.mCurrIndex = 0; 234 mOrientation = utils::OVERLAY_TRANSFORM_0; 235 } 236 237 void MdssRot::dump() const { 238 ALOGE("== Dump MdssRot start =="); 239 mFd.dump(); 240 mMem.mem.dump(); 241 mdp_wrapper::dump("mRotInfo", mRotInfo); 242 mdp_wrapper::dump("mRotData", mRotData); 243 ALOGE("== Dump MdssRot end =="); 244 } 245 246 uint32_t MdssRot::calcOutputBufSize() { 247 uint32_t opBufSize = 0; 248 ovutils::Whf destWhf(mRotInfo.dst_rect.w, mRotInfo.dst_rect.h, 249 mRotInfo.src.format); //mdss src and dst formats are same. 250 251 if (mRotInfo.flags & ovutils::OV_MDSS_MDP_BWC_EN) { 252 opBufSize = calcCompressedBufSize(destWhf); 253 } else { 254 opBufSize = Rotator::calcOutputBufSize(destWhf); 255 } 256 257 return opBufSize; 258 } 259 260 void MdssRot::getDump(char *buf, size_t len) const { 261 ovutils::getDump(buf, len, "MdssRotCtrl", mRotInfo); 262 ovutils::getDump(buf, len, "MdssRotData", mRotData); 263 } 264 265 // Calculate the compressed o/p buffer size for BWC 266 uint32_t MdssRot::calcCompressedBufSize(const ovutils::Whf& destWhf) { 267 uint32_t bufSize = 0; 268 int aWidth = ovutils::align(destWhf.w, 64); 269 int aHeight = ovutils::align(destWhf.h, 4); 270 int rau_cnt = aWidth/64; 271 int stride0 = (64 * 4 * rau_cnt) + rau_cnt/8; 272 int stride1 = ((64 * 2 * rau_cnt) + rau_cnt/8) * 2; 273 int stride0_off = (aHeight/4); 274 int stride1_off = (aHeight/2); 275 276 //New o/p size for BWC 277 bufSize = (stride0 * stride0_off + stride1 * stride1_off) + 278 (rau_cnt * 2 * (stride0_off + stride1_off)); 279 ALOGD_IF(DEBUG_MDSS_ROT, "%s: width = %d, height = %d raucount = %d" 280 "opBufSize = %d ", __FUNCTION__, aWidth, aHeight, rau_cnt, bufSize); 281 return bufSize; 282 } 283 284 } // namespace overlay 285
