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