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
38namespace ovutils = overlay::utils;
39
40namespace overlay {
41using namespace utils;
42
43MdssRot::MdssRot() {
44    reset();
45    init();
46}
47
48MdssRot::~MdssRot() { close(); }
49
50bool MdssRot::enabled() const { return mEnabled; }
51
52void MdssRot::setRotations(uint32_t flags) { mRotInfo.flags |= flags; }
53
54int MdssRot::getSrcMemId() const {
55    return mRotData.data.memory_id;
56}
57
58int MdssRot::getDstMemId() const {
59    return mRotData.dst_data.memory_id;
60}
61
62uint32_t MdssRot::getSrcOffset() const {
63    return mRotData.data.offset;
64}
65
66uint32_t MdssRot::getDstOffset() const {
67    return mRotData.dst_data.offset;
68}
69
70uint32_t MdssRot::getDstFormat() const {
71    //For mdss src and dst formats are same
72    return mRotInfo.src.format;
73}
74
75utils::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
85utils::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
90uint32_t MdssRot::getSessId() const { return mRotInfo.id; }
91
92void MdssRot::save() {
93    mLSRotInfo = mRotInfo;
94}
95
96bool 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
105bool 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
113void 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
121void 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
128void MdssRot::setDownscale(int downscale) {
129    mDownscale = downscale;
130}
131
132void MdssRot::setFlags(const utils::eMdpFlags& flags) {
133    mRotInfo.flags = flags;
134}
135
136void 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
147void 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
153bool 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
187bool 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
217bool 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
238bool 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
266bool 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
288void 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
300void 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
309uint32_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
323void 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
329uint32_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
380int 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
410Dim 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
423Dim 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