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
37namespace ovutils = overlay::utils;
38
39namespace overlay {
40using namespace utils;
41
42MdssRot::MdssRot() {
43    reset();
44    init();
45}
46
47MdssRot::~MdssRot() { close(); }
48
49bool MdssRot::enabled() const { return mEnabled; }
50
51void MdssRot::setRotations(uint32_t flags) { mRotInfo.flags |= flags; }
52
53int MdssRot::getDstMemId() const {
54    return mRotData.dst_data.memory_id;
55}
56
57uint32_t MdssRot::getDstOffset() const {
58    return mRotData.dst_data.offset;
59}
60
61uint32_t MdssRot::getDstFormat() const {
62    //For mdss src and dst formats are same
63    return mRotInfo.src.format;
64}
65
66uint32_t MdssRot::getSessId() const { return mRotInfo.id; }
67
68bool MdssRot::init() {
69    if(!utils::openDev(mFd, 0, Res::fbPath, O_RDWR)) {
70        ALOGE("MdssRot failed to init fb0");
71        return false;
72    }
73    return true;
74}
75
76void MdssRot::setSource(const overlay::utils::Whf& awhf) {
77    utils::Whf whf(awhf);
78
79    mRotInfo.src.format = whf.format;
80    mRotInfo.src.width = whf.w;
81    mRotInfo.src.height = whf.h;
82}
83
84void MdssRot::setCrop(const utils::Dim& crop) {
85
86    mRotInfo.src_rect.x = crop.x;
87    mRotInfo.src_rect.y = crop.y;
88    mRotInfo.src_rect.w = crop.w;
89    mRotInfo.src_rect.h = crop.h;
90
91    mRotInfo.dst_rect.x = 0;
92    mRotInfo.dst_rect.y = 0;
93    mRotInfo.dst_rect.w = crop.w;
94    mRotInfo.dst_rect.h = crop.h;
95}
96
97void MdssRot::setDownscale(int /*ds*/) {
98}
99
100void MdssRot::setFlags(const utils::eMdpFlags& flags) {
101    mRotInfo.flags = flags;
102}
103
104void MdssRot::setTransform(const utils::eTransform& rot)
105{
106    // reset rotation flags to avoid stale orientation values
107    mRotInfo.flags &= ~MDSS_ROT_MASK;
108    int flags = utils::getMdpOrient(rot);
109    if (flags != -1)
110        setRotations(flags);
111    mOrientation = static_cast<utils::eTransform>(flags);
112    ALOGE_IF(DEBUG_OVERLAY, "%s: rot=%d", __FUNCTION__, flags);
113}
114
115void MdssRot::doTransform() {
116    mRotInfo.flags |= mOrientation;
117    if(mOrientation & utils::OVERLAY_TRANSFORM_ROT_90)
118        utils::swap(mRotInfo.dst_rect.w, mRotInfo.dst_rect.h);
119}
120
121bool MdssRot::commit() {
122    doTransform();
123    mRotInfo.flags |= MDSS_MDP_ROT_ONLY;
124    mEnabled = true;
125    if(!overlay::mdp_wrapper::setOverlay(mFd.getFD(), mRotInfo)) {
126        ALOGE("MdssRot commit failed!");
127        dump();
128        return (mEnabled = false);
129    }
130    mRotData.id = mRotInfo.id;
131    return true;
132}
133
134bool MdssRot::queueBuffer(int fd, uint32_t offset) {
135    if(enabled()) {
136        mRotData.data.memory_id = fd;
137        mRotData.data.offset = offset;
138
139        if(false == remap(RotMem::ROT_NUM_BUFS)) {
140            ALOGE("%s Remap failed, not queuing", __FUNCTION__);
141            return false;
142        }
143
144        mRotData.dst_data.offset =
145                mMem.mRotOffset[mMem.mCurrIndex];
146        mMem.mCurrIndex =
147                (mMem.mCurrIndex + 1) % mMem.mem.numBufs();
148
149        if(!overlay::mdp_wrapper::play(mFd.getFD(), mRotData)) {
150            ALOGE("MdssRot play failed!");
151            dump();
152            return false;
153        }
154    }
155    return true;
156}
157
158bool MdssRot::open_i(uint32_t numbufs, uint32_t bufsz)
159{
160    OvMem mem;
161    OVASSERT(MAP_FAILED == mem.addr(), "MAP failed in open_i");
162    bool isSecure = mRotInfo.flags & utils::OV_MDP_SECURE_OVERLAY_SESSION;
163
164    if(!mem.open(numbufs, bufsz, isSecure)){
165        ALOGE("%s: Failed to open", __func__);
166        mem.close();
167        return false;
168    }
169
170    OVASSERT(MAP_FAILED != mem.addr(), "MAP failed");
171    OVASSERT(mem.getFD() != -1, "getFd is -1");
172
173    mRotData.dst_data.memory_id = mem.getFD();
174    mRotData.dst_data.offset = 0;
175    mMem.mem = mem;
176    return true;
177}
178
179bool MdssRot::remap(uint32_t numbufs) {
180    // Calculate the size based on rotator's dst format, w and h.
181    uint32_t opBufSize = calcOutputBufSize();
182    // If current size changed, remap
183    if(opBufSize == mMem.size()) {
184        ALOGE_IF(DEBUG_OVERLAY, "%s: same size %d", __FUNCTION__, opBufSize);
185        return true;
186    }
187
188    ALOGE_IF(DEBUG_OVERLAY, "%s: size changed - remapping", __FUNCTION__);
189
190    if(!mMem.close()) {
191        ALOGE("%s error in closing prev rot mem", __FUNCTION__);
192        return false;
193    }
194
195    if(!open_i(numbufs, opBufSize)) {
196        ALOGE("%s Error could not open", __FUNCTION__);
197        return false;
198    }
199
200    for (uint32_t i = 0; i < numbufs; ++i) {
201        mMem.mRotOffset[i] = i * opBufSize;
202    }
203
204    return true;
205}
206
207bool MdssRot::close() {
208    bool success = true;
209    if(mFd.valid() && (getSessId() != (uint32_t) MSMFB_NEW_REQUEST)) {
210        if(!mdp_wrapper::unsetOverlay(mFd.getFD(), getSessId())) {
211            ALOGE("MdssRot::close unsetOverlay failed, fd=%d sessId=%d",
212                  mFd.getFD(), getSessId());
213            success = false;
214        }
215    }
216
217    if (!mFd.close()) {
218        ALOGE("Mdss Rot error closing fd");
219        success = false;
220    }
221    if (!mMem.close()) {
222        ALOGE("Mdss Rot error closing mem");
223        success = false;
224    }
225    reset();
226    return success;
227}
228
229void MdssRot::reset() {
230    ovutils::memset0(mRotInfo);
231    ovutils::memset0(mRotData);
232    mRotData.data.memory_id = -1;
233    mRotInfo.id = MSMFB_NEW_REQUEST;
234    ovutils::memset0(mMem.mRotOffset);
235    mMem.mCurrIndex = 0;
236    mOrientation = utils::OVERLAY_TRANSFORM_0;
237}
238
239void MdssRot::dump() const {
240    ALOGE("== Dump MdssRot start ==");
241    mFd.dump();
242    mMem.mem.dump();
243    mdp_wrapper::dump("mRotInfo", mRotInfo);
244    mdp_wrapper::dump("mRotData", mRotData);
245    ALOGE("== Dump MdssRot end ==");
246}
247
248uint32_t MdssRot::calcOutputBufSize() {
249    uint32_t opBufSize = 0;
250    ovutils::Whf destWhf(mRotInfo.dst_rect.w, mRotInfo.dst_rect.h,
251            mRotInfo.src.format); //mdss src and dst formats are same.
252
253    if (mRotInfo.flags & ovutils::OV_MDSS_MDP_BWC_EN) {
254        opBufSize = calcCompressedBufSize(destWhf);
255    } else {
256        opBufSize = Rotator::calcOutputBufSize(destWhf);
257    }
258
259    return opBufSize;
260}
261
262void MdssRot::getDump(char *buf, size_t len) const {
263    ovutils::getDump(buf, len, "MdssRotCtrl", mRotInfo);
264    ovutils::getDump(buf, len, "MdssRotData", mRotData);
265}
266
267// Calculate the compressed o/p buffer size for BWC
268uint32_t MdssRot::calcCompressedBufSize(const ovutils::Whf& destWhf) {
269    uint32_t bufSize = 0;
270    //Worst case alignments
271    int aWidth = ovutils::align(destWhf.w, 64);
272    int aHeight = ovutils::align(destWhf.h, 4);
273    /*
274       Format           |   RAU size (width x height)
275       ----------------------------------------------
276       ARGB             |       32 pixel x 4 line
277       RGB888           |       32 pixel x 4 line
278       Y (Luma)         |       64 pixel x 4 line
279       CRCB 420         |       32 pixel x 2 line
280       CRCB 422 H2V1    |       32 pixel x 4 line
281       CRCB 422 H1V2    |       64 pixel x 2 line
282
283       Metadata requirements:-
284       1 byte meta data for every 8 RAUs
285       2 byte meta data per RAU
286     */
287
288    //These blocks attempt to allocate for the worst case in each of the
289    //respective format classes, yuv/rgb. The table above is for reference
290    if(utils::isYuv(destWhf.format)) {
291        int yRauCount = aWidth / 64; //Y
292        int cRauCount = aWidth / 32; //C
293        int yStride = (64 * 4 * yRauCount) + alignup(yRauCount, 8) / 8;
294        int cStride = ((32 * 2 * cRauCount) + alignup(cRauCount, 8) / 8) * 2;
295        int yStrideOffset = (aHeight / 4);
296        int cStrideOffset = (aHeight / 2);
297        bufSize = (yStride * yStrideOffset + cStride * cStrideOffset) +
298                (yRauCount * yStrideOffset * 2) +
299                (cRauCount * cStrideOffset * 2) * 2;
300        ALOGD_IF(DEBUG_MDSS_ROT, "%s:YUV Y RAU Count = %d C RAU Count = %d",
301                __FUNCTION__, yRauCount, cRauCount);
302    } else {
303        int rauCount = aWidth / 32;
304        //Single plane
305        int stride = (32 * 4 * rauCount) + alignup(rauCount, 8) / 8;
306        int strideOffset = (aHeight / 4);
307        bufSize = (stride * strideOffset * 4 /*bpp*/) +
308            (rauCount * strideOffset * 2);
309        ALOGD_IF(DEBUG_MDSS_ROT, "%s:RGB RAU count = %d", __FUNCTION__,
310                rauCount);
311    }
312
313    ALOGD_IF(DEBUG_MDSS_ROT, "%s: aligned width = %d, aligned height = %d "
314            "Buf Size = %d", __FUNCTION__, aWidth, aHeight, bufSize);
315
316    return bufSize;
317}
318
319} // namespace overlay
320