Home | History | Annotate | Download | only in liboverlay 
      1 /*
      2  * Copyright (C) 2008 The Android Open Source Project
      3  * Copyright (c) 2010-2013, 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 namespace ovutils = overlay::utils;
     24 
     25 namespace overlay {
     26 
     27 MdpRot::MdpRot() {
     28     reset();
     29     init();
     30 }
     31 
     32 MdpRot::~MdpRot() { close(); }
     33 
     34 bool MdpRot::enabled() const { return mRotImgInfo.enable; }
     35 
     36 void MdpRot::setRotations(uint32_t r) { mRotImgInfo.rotations = r; }
     37 
     38 int MdpRot::getDstMemId() const {
     39     return mRotDataInfo.dst.memory_id;
     40 }
     41 
     42 uint32_t MdpRot::getDstOffset() const {
     43     return mRotDataInfo.dst.offset;
     44 }
     45 
     46 uint32_t MdpRot::getDstFormat() const {
     47     return mRotImgInfo.dst.format;
     48 }
     49 
     50 uint32_t MdpRot::getSessId() const { return mRotImgInfo.session_id; }
     51 
     52 void MdpRot::setDownscale(int ds) {
     53     if ((utils::ROT_DS_EIGHTH == ds) && (mRotImgInfo.src_rect.h & 0xF)) {
     54         // Ensure src_rect.h is a multiple of 16 for 1/8 downscaling.
     55         // This is an undocumented MDP Rotator constraint.
     56         mRotImgInfo.src_rect.h = utils::aligndown(mRotImgInfo.src_rect.h, 16);
     57     }
     58     mRotImgInfo.downscale_ratio = ds;
     59 }
     60 
     61 void MdpRot::save() {
     62     mLSRotImgInfo = mRotImgInfo;
     63 }
     64 
     65 bool MdpRot::rotConfChanged() const {
     66     // 0 means same
     67     if(0 == ::memcmp(&mRotImgInfo, &mLSRotImgInfo,
     68                 sizeof (msm_rotator_img_info))) {
     69         return false;
     70     }
     71     return true;
     72 }
     73 
     74 bool MdpRot::init()
     75 {
     76     if(!mFd.open(Res::rotPath, O_RDWR)){
     77         ALOGE("MdpRot failed to init %s", Res::rotPath);
     78         return false;
     79     }
     80     return true;
     81 }
     82 
     83 void MdpRot::setSource(const overlay::utils::Whf& awhf) {
     84     utils::Whf whf(awhf);
     85     mRotImgInfo.src.format = whf.format;
     86 
     87     mRotImgInfo.src.width = whf.w;
     88     mRotImgInfo.src.height = whf.h;
     89 
     90     mRotImgInfo.src_rect.w = whf.w;
     91     mRotImgInfo.src_rect.h = whf.h;
     92 
     93     mRotImgInfo.dst.width = whf.w;
     94     mRotImgInfo.dst.height = whf.h;
     95 }
     96 
     97 void MdpRot::setFlags(const utils::eMdpFlags& flags) {
     98     mRotImgInfo.secure = 0;
     99     if(flags & utils::OV_MDP_SECURE_OVERLAY_SESSION)
    100         mRotImgInfo.secure = 1;
    101 }
    102 
    103 void MdpRot::setTransform(const utils::eTransform& rot)
    104 {
    105     int r = utils::getMdpOrient(rot);
    106     setRotations(r);
    107     //getMdpOrient will switch the flips if the source is 90 rotated.
    108     //Clients in Android dont factor in 90 rotation while deciding the flip.
    109     mOrientation = static_cast<utils::eTransform>(r);
    110     ALOGE_IF(DEBUG_OVERLAY, "%s: r=%d", __FUNCTION__, r);
    111 }
    112 
    113 void MdpRot::doTransform() {
    114     if(mOrientation & utils::OVERLAY_TRANSFORM_ROT_90)
    115         utils::swap(mRotImgInfo.dst.width, mRotImgInfo.dst.height);
    116 }
    117 
    118 bool MdpRot::commit() {
    119     doTransform();
    120     if(rotConfChanged()) {
    121         mRotImgInfo.enable = 1;
    122         if(!overlay::mdp_wrapper::startRotator(mFd.getFD(), mRotImgInfo)) {
    123             ALOGE("MdpRot commit failed");
    124             dump();
    125             mRotImgInfo.enable = 0;
    126             return false;
    127         }
    128         save();
    129         mRotDataInfo.session_id = mRotImgInfo.session_id;
    130     }
    131     return true;
    132 }
    133 
    134 uint32_t MdpRot::calcOutputBufSize() {
    135     ovutils::Whf destWhf(mRotImgInfo.dst.width,
    136             mRotImgInfo.dst.height, mRotImgInfo.dst.format);
    137     return Rotator::calcOutputBufSize(destWhf);
    138 }
    139 
    140 bool MdpRot::open_i(uint32_t numbufs, uint32_t bufsz)
    141 {
    142     OvMem mem;
    143 
    144     OVASSERT(MAP_FAILED == mem.addr(), "MAP failed in open_i");
    145 
    146     if(!mem.open(numbufs, bufsz, mRotImgInfo.secure)){
    147         ALOGE("%s: Failed to open", __func__);
    148         mem.close();
    149         return false;
    150     }
    151 
    152     OVASSERT(MAP_FAILED != mem.addr(), "MAP failed");
    153     OVASSERT(mem.getFD() != -1, "getFd is -1");
    154 
    155     mRotDataInfo.dst.memory_id = mem.getFD();
    156     mRotDataInfo.dst.offset = 0;
    157     mMem.curr().m = mem;
    158     return true;
    159 }
    160 
    161 bool MdpRot::close() {
    162     bool success = true;
    163     if(mFd.valid() && (getSessId() != 0)) {
    164         if(!mdp_wrapper::endRotator(mFd.getFD(), getSessId())) {
    165             ALOGE("Mdp Rot error endRotator, fd=%d sessId=%u",
    166                     mFd.getFD(), getSessId());
    167             success = false;
    168         }
    169     }
    170     if (!mFd.close()) {
    171         ALOGE("Mdp Rot error closing fd");
    172         success = false;
    173     }
    174     if (!mMem.close()) {
    175         ALOGE("Mdp Rot error closing mem");
    176         success = false;
    177     }
    178     reset();
    179     return success;
    180 }
    181 
    182 bool MdpRot::remap(uint32_t numbufs) {
    183     // if current size changed, remap
    184     uint32_t opBufSize = calcOutputBufSize();
    185     if(opBufSize == mMem.curr().size()) {
    186         ALOGE_IF(DEBUG_OVERLAY, "%s: same size %d", __FUNCTION__, opBufSize);
    187         return true;
    188     }
    189 
    190     ALOGE_IF(DEBUG_OVERLAY, "%s: size changed - remapping", __FUNCTION__);
    191     OVASSERT(!mMem.prev().valid(), "Prev should not be valid");
    192 
    193     // ++mMem will make curr to be prev, and prev will be curr
    194     ++mMem;
    195     if(!open_i(numbufs, opBufSize)) {
    196         ALOGE("%s Error could not open", __FUNCTION__);
    197         return false;
    198     }
    199     for (uint32_t i = 0; i < numbufs; ++i) {
    200         mMem.curr().mRotOffset[i] = i * opBufSize;
    201     }
    202     return true;
    203 }
    204 
    205 void MdpRot::reset() {
    206     ovutils::memset0(mRotImgInfo);
    207     ovutils::memset0(mLSRotImgInfo);
    208     ovutils::memset0(mRotDataInfo);
    209     ovutils::memset0(mMem.curr().mRotOffset);
    210     ovutils::memset0(mMem.prev().mRotOffset);
    211     mMem.curr().mCurrOffset = 0;
    212     mMem.prev().mCurrOffset = 0;
    213     mOrientation = utils::OVERLAY_TRANSFORM_0;
    214 }
    215 
    216 bool MdpRot::queueBuffer(int fd, uint32_t offset) {
    217     if(enabled()) {
    218         mRotDataInfo.src.memory_id = fd;
    219         mRotDataInfo.src.offset = offset;
    220 
    221         remap(RotMem::Mem::ROT_NUM_BUFS);
    222         OVASSERT(mMem.curr().m.numBufs(),
    223                 "queueBuffer numbufs is 0");
    224         mRotDataInfo.dst.offset =
    225                 mMem.curr().mRotOffset[mMem.curr().mCurrOffset];
    226         mMem.curr().mCurrOffset =
    227                 (mMem.curr().mCurrOffset + 1) % mMem.curr().m.numBufs();
    228 
    229         if(!overlay::mdp_wrapper::rotate(mFd.getFD(), mRotDataInfo)) {
    230             ALOGE("MdpRot failed rotate");
    231             dump();
    232             return false;
    233         }
    234 
    235         // if the prev mem is valid, we need to close
    236         if(mMem.prev().valid()) {
    237             // FIXME if no wait for vsync the above
    238             // play will return immediatly and might cause
    239             // tearing when prev.close is called.
    240             if(!mMem.prev().close()) {
    241                 ALOGE("%s error in closing prev rot mem", __FUNCTION__);
    242                 return false;
    243             }
    244         }
    245     }
    246     return true;
    247 }
    248 
    249 void MdpRot::dump() const {
    250     ALOGE("== Dump MdpRot start ==");
    251     mFd.dump();
    252     mMem.curr().m.dump();
    253     mdp_wrapper::dump("mRotImgInfo", mRotImgInfo);
    254     mdp_wrapper::dump("mRotDataInfo", mRotDataInfo);
    255     ALOGE("== Dump MdpRot end ==");
    256 }
    257 
    258 void MdpRot::getDump(char *buf, size_t len) const {
    259     ovutils::getDump(buf, len, "MdpRotCtrl(msm_rotator_img_info)", mRotImgInfo);
    260     ovutils::getDump(buf, len, "MdpRotData(msm_rotator_data_info)", mRotDataInfo);
    261 }
    262 
    263 } // namespace overlay
    264