You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
431 lines
13 KiB
431 lines
13 KiB
/*
|
|
* Copyright (C) 2008 The Android Open Source Project
|
|
* Copyright (c) 2010-2014, The Linux Foundation. All rights reserved.
|
|
* Not a Contribution, Apache license notifications and license are retained
|
|
* for attribution purposes only.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <math.h>
|
|
#include "overlayUtils.h"
|
|
#include "overlayRotator.h"
|
|
|
|
#define DEBUG_MDSS_ROT 0
|
|
|
|
#ifdef VENUS_COLOR_FORMAT
|
|
#include <media/msm_media_info.h>
|
|
#else
|
|
#define VENUS_BUFFER_SIZE(args...) 0
|
|
#endif
|
|
|
|
#ifndef MDSS_MDP_ROT_ONLY
|
|
#define MDSS_MDP_ROT_ONLY 0x80
|
|
#endif
|
|
|
|
#define MDSS_ROT_MASK (MDP_ROT_90 | MDP_FLIP_UD | MDP_FLIP_LR)
|
|
|
|
namespace ovutils = overlay::utils;
|
|
|
|
namespace overlay {
|
|
using namespace utils;
|
|
|
|
MdssRot::MdssRot() {
|
|
reset();
|
|
init();
|
|
}
|
|
|
|
MdssRot::~MdssRot() { close(); }
|
|
|
|
bool MdssRot::enabled() const { return mEnabled; }
|
|
|
|
void MdssRot::setRotations(uint32_t flags) { mRotInfo.flags |= flags; }
|
|
|
|
int MdssRot::getSrcMemId() const {
|
|
return mRotData.data.memory_id;
|
|
}
|
|
|
|
int MdssRot::getDstMemId() const {
|
|
return mRotData.dst_data.memory_id;
|
|
}
|
|
|
|
uint32_t MdssRot::getSrcOffset() const {
|
|
return mRotData.data.offset;
|
|
}
|
|
|
|
uint32_t MdssRot::getDstOffset() const {
|
|
return mRotData.dst_data.offset;
|
|
}
|
|
|
|
uint32_t MdssRot::getDstFormat() const {
|
|
//For mdss src and dst formats are same
|
|
return mRotInfo.src.format;
|
|
}
|
|
|
|
utils::Whf MdssRot::getDstWhf() const {
|
|
//For Mdss dst_rect itself represents buffer dimensions. We ignore actual
|
|
//aligned values during buffer allocation. Also the driver overwrites the
|
|
//src.format field if destination format is different.
|
|
//This implementation detail makes it possible to retrieve w,h even before
|
|
//buffer allocation, which happens in queueBuffer.
|
|
return utils::Whf(mRotInfo.dst_rect.w, mRotInfo.dst_rect.h,
|
|
mRotInfo.src.format);
|
|
}
|
|
|
|
utils::Dim MdssRot::getDstDimensions() const {
|
|
return utils::Dim(mRotInfo.dst_rect.x, mRotInfo.dst_rect.y,
|
|
mRotInfo.dst_rect.w, mRotInfo.dst_rect.h);
|
|
}
|
|
|
|
uint32_t MdssRot::getSessId() const { return mRotInfo.id; }
|
|
|
|
void MdssRot::save() {
|
|
mLSRotInfo = mRotInfo;
|
|
}
|
|
|
|
bool MdssRot::rotConfChanged() const {
|
|
// 0 means same
|
|
if(0 == ::memcmp(&mRotInfo, &mLSRotInfo,
|
|
sizeof (mdp_overlay))) {
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool MdssRot::init() {
|
|
if(!utils::openDev(mFd, 0, Res::fbPath, O_RDWR)) {
|
|
ALOGE("MdssRot failed to init fb0");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void MdssRot::setSource(const overlay::utils::Whf& awhf) {
|
|
utils::Whf whf(awhf);
|
|
|
|
mRotInfo.src.format = whf.format;
|
|
mRotInfo.src.width = whf.w;
|
|
mRotInfo.src.height = whf.h;
|
|
}
|
|
|
|
void MdssRot::setCrop(const utils::Dim& crop) {
|
|
mRotInfo.src_rect.x = crop.x;
|
|
mRotInfo.src_rect.y = crop.y;
|
|
mRotInfo.src_rect.w = crop.w;
|
|
mRotInfo.src_rect.h = crop.h;
|
|
}
|
|
|
|
void MdssRot::setDownscale(int downscale) {
|
|
mDownscale = downscale;
|
|
}
|
|
|
|
void MdssRot::setFlags(const utils::eMdpFlags& flags) {
|
|
mRotInfo.flags = flags;
|
|
}
|
|
|
|
void MdssRot::setTransform(const utils::eTransform& rot)
|
|
{
|
|
// reset rotation flags to avoid stale orientation values
|
|
mRotInfo.flags &= ~MDSS_ROT_MASK;
|
|
int flags = utils::getMdpOrient(rot);
|
|
if (flags != -1)
|
|
setRotations(flags);
|
|
mOrientation = static_cast<utils::eTransform>(flags);
|
|
ALOGE_IF(DEBUG_OVERLAY, "%s: rot=%d", __FUNCTION__, flags);
|
|
}
|
|
|
|
void MdssRot::doTransform() {
|
|
mRotInfo.flags |= mOrientation;
|
|
if(mOrientation & utils::OVERLAY_TRANSFORM_ROT_90)
|
|
utils::swap(mRotInfo.dst_rect.w, mRotInfo.dst_rect.h);
|
|
}
|
|
|
|
bool MdssRot::commit() {
|
|
Dim adjCrop(mRotInfo.src_rect.x,mRotInfo.src_rect.y,
|
|
mRotInfo.src_rect.w,mRotInfo.src_rect.h);
|
|
adjCrop = getFormatAdjustedCrop(adjCrop, mRotInfo.src.format,
|
|
mRotInfo.flags & utils::OV_MDP_DEINTERLACE);
|
|
adjCrop = getDownscaleAdjustedCrop(adjCrop, mDownscale);
|
|
|
|
mRotInfo.src_rect.x = adjCrop.x;
|
|
mRotInfo.src_rect.y = adjCrop.y;
|
|
mRotInfo.src_rect.w = adjCrop.w;
|
|
mRotInfo.src_rect.h = adjCrop.h;
|
|
|
|
mRotInfo.dst_rect.x = 0;
|
|
mRotInfo.dst_rect.y = 0;
|
|
mRotInfo.dst_rect.w = mDownscale ?
|
|
mRotInfo.src_rect.w / mDownscale : mRotInfo.src_rect.w;
|
|
mRotInfo.dst_rect.h = mDownscale ?
|
|
mRotInfo.src_rect.h / mDownscale : mRotInfo.src_rect.h;
|
|
//Clear for next round
|
|
mDownscale = 0;
|
|
|
|
doTransform();
|
|
|
|
mRotInfo.flags |= MDSS_MDP_ROT_ONLY;
|
|
mEnabled = true;
|
|
if(!overlay::mdp_wrapper::setOverlay(mFd.getFD(), mRotInfo)) {
|
|
ALOGE("MdssRot commit failed!");
|
|
dump();
|
|
return (mEnabled = false);
|
|
}
|
|
mRotData.id = mRotInfo.id;
|
|
return true;
|
|
}
|
|
|
|
bool MdssRot::queueBuffer(int fd, uint32_t offset) {
|
|
if(enabled() and (not isRotCached(fd,offset))) {
|
|
int prev_fd = getSrcMemId();
|
|
uint32_t prev_offset = getSrcOffset();
|
|
|
|
mRotData.data.memory_id = fd;
|
|
mRotData.data.offset = offset;
|
|
|
|
if(false == remap(RotMem::ROT_NUM_BUFS)) {
|
|
ALOGE("%s Remap failed, not queuing", __FUNCTION__);
|
|
return false;
|
|
}
|
|
|
|
mRotData.dst_data.offset =
|
|
mMem.mRotOffset[mMem.mCurrIndex];
|
|
|
|
if(!overlay::mdp_wrapper::play(mFd.getFD(), mRotData)) {
|
|
ALOGE("MdssRot play failed!");
|
|
dump();
|
|
mRotData.data.memory_id = prev_fd;
|
|
mRotData.data.offset = prev_offset;
|
|
return false;
|
|
}
|
|
save();
|
|
mMem.mCurrIndex =
|
|
(mMem.mCurrIndex + 1) % mMem.mem.numBufs();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool MdssRot::open_i(uint32_t numbufs, uint32_t bufsz)
|
|
{
|
|
OvMem mem;
|
|
OVASSERT(MAP_FAILED == mem.addr(), "MAP failed in open_i");
|
|
bool isSecure = mRotInfo.flags & utils::OV_MDP_SECURE_OVERLAY_SESSION;
|
|
|
|
if(!mem.open(numbufs, bufsz, isSecure)){
|
|
ALOGE("%s: Failed to open", __func__);
|
|
mem.close();
|
|
return false;
|
|
}
|
|
|
|
OVASSERT(MAP_FAILED != mem.addr(), "MAP failed");
|
|
OVASSERT(mem.getFD() != -1, "getFd is -1");
|
|
|
|
mRotData.dst_data.memory_id = mem.getFD();
|
|
mRotData.dst_data.offset = 0;
|
|
mMem.mem = mem;
|
|
return true;
|
|
}
|
|
|
|
bool MdssRot::remap(uint32_t numbufs) {
|
|
// Calculate the size based on rotator's dst format, w and h.
|
|
uint32_t opBufSize = calcOutputBufSize();
|
|
// If current size changed, remap
|
|
if(opBufSize == mMem.size()) {
|
|
ALOGE_IF(DEBUG_OVERLAY, "%s: same size %d", __FUNCTION__, opBufSize);
|
|
return true;
|
|
}
|
|
|
|
ALOGE_IF(DEBUG_OVERLAY, "%s: size changed - remapping", __FUNCTION__);
|
|
|
|
if(!mMem.close()) {
|
|
ALOGE("%s error in closing prev rot mem", __FUNCTION__);
|
|
return false;
|
|
}
|
|
|
|
if(!open_i(numbufs, opBufSize)) {
|
|
ALOGE("%s Error could not open", __FUNCTION__);
|
|
return false;
|
|
}
|
|
|
|
for (uint32_t i = 0; i < numbufs; ++i) {
|
|
mMem.mRotOffset[i] = i * opBufSize;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool MdssRot::close() {
|
|
bool success = true;
|
|
if(mFd.valid() && (getSessId() != (uint32_t) MSMFB_NEW_REQUEST)) {
|
|
if(!mdp_wrapper::unsetOverlay(mFd.getFD(), getSessId())) {
|
|
ALOGE("MdssRot::close unsetOverlay failed, fd=%d sessId=%d",
|
|
mFd.getFD(), getSessId());
|
|
success = false;
|
|
}
|
|
}
|
|
|
|
if (!mFd.close()) {
|
|
ALOGE("Mdss Rot error closing fd");
|
|
success = false;
|
|
}
|
|
if (!mMem.close()) {
|
|
ALOGE("Mdss Rot error closing mem");
|
|
success = false;
|
|
}
|
|
reset();
|
|
return success;
|
|
}
|
|
|
|
void MdssRot::reset() {
|
|
ovutils::memset0(mRotInfo);
|
|
ovutils::memset0(mLSRotInfo);
|
|
ovutils::memset0(mRotData);
|
|
mRotData.data.memory_id = -1;
|
|
mRotInfo.id = MSMFB_NEW_REQUEST;
|
|
ovutils::memset0(mMem.mRotOffset);
|
|
mMem.mCurrIndex = 0;
|
|
mOrientation = utils::OVERLAY_TRANSFORM_0;
|
|
mDownscale = 0;
|
|
}
|
|
|
|
void MdssRot::dump() const {
|
|
ALOGE("== Dump MdssRot start ==");
|
|
mFd.dump();
|
|
mMem.mem.dump();
|
|
mdp_wrapper::dump("mRotInfo", mRotInfo);
|
|
mdp_wrapper::dump("mRotData", mRotData);
|
|
ALOGE("== Dump MdssRot end ==");
|
|
}
|
|
|
|
uint32_t MdssRot::calcOutputBufSize() {
|
|
uint32_t opBufSize = 0;
|
|
ovutils::Whf destWhf(mRotInfo.dst_rect.w, mRotInfo.dst_rect.h,
|
|
mRotInfo.src.format); //mdss src and dst formats are same.
|
|
|
|
if (mRotInfo.flags & ovutils::OV_MDSS_MDP_BWC_EN) {
|
|
opBufSize = calcCompressedBufSize(destWhf);
|
|
} else {
|
|
opBufSize = Rotator::calcOutputBufSize(destWhf);
|
|
}
|
|
|
|
return opBufSize;
|
|
}
|
|
|
|
void MdssRot::getDump(char *buf, size_t len) const {
|
|
ovutils::getDump(buf, len, "MdssRotCtrl", mRotInfo);
|
|
ovutils::getDump(buf, len, "MdssRotData", mRotData);
|
|
}
|
|
|
|
// Calculate the compressed o/p buffer size for BWC
|
|
uint32_t MdssRot::calcCompressedBufSize(const ovutils::Whf& destWhf) {
|
|
uint32_t bufSize = 0;
|
|
//Worst case alignments
|
|
int aWidth = ovutils::align(destWhf.w, 64);
|
|
int aHeight = ovutils::align(destWhf.h, 4);
|
|
/*
|
|
Format | RAU size (width x height)
|
|
----------------------------------------------
|
|
ARGB | 32 pixel x 4 line
|
|
RGB888 | 32 pixel x 4 line
|
|
Y (Luma) | 64 pixel x 4 line
|
|
CRCB 420 | 32 pixel x 2 line
|
|
CRCB 422 H2V1 | 32 pixel x 4 line
|
|
CRCB 422 H1V2 | 64 pixel x 2 line
|
|
|
|
Metadata requirements:-
|
|
1 byte meta data for every 8 RAUs
|
|
2 byte meta data per RAU
|
|
*/
|
|
|
|
//These blocks attempt to allocate for the worst case in each of the
|
|
//respective format classes, yuv/rgb. The table above is for reference
|
|
if(utils::isYuv(destWhf.format)) {
|
|
int yRauCount = aWidth / 64; //Y
|
|
int cRauCount = aWidth / 32; //C
|
|
int yStride = (64 * 4 * yRauCount) + alignup(yRauCount, 8) / 8;
|
|
int cStride = ((32 * 2 * cRauCount) + alignup(cRauCount, 8) / 8) * 2;
|
|
int yStrideOffset = (aHeight / 4);
|
|
int cStrideOffset = (aHeight / 2);
|
|
bufSize = (yStride * yStrideOffset + cStride * cStrideOffset) +
|
|
(yRauCount * yStrideOffset * 2) +
|
|
(cRauCount * cStrideOffset * 2) * 2;
|
|
ALOGD_IF(DEBUG_MDSS_ROT, "%s:YUV Y RAU Count = %d C RAU Count = %d",
|
|
__FUNCTION__, yRauCount, cRauCount);
|
|
} else {
|
|
int rauCount = aWidth / 32;
|
|
//Single plane
|
|
int stride = (32 * 4 * rauCount) + alignup(rauCount, 8) / 8;
|
|
int strideOffset = (aHeight / 4);
|
|
bufSize = (stride * strideOffset * 4 /*bpp*/) +
|
|
(rauCount * strideOffset * 2);
|
|
ALOGD_IF(DEBUG_MDSS_ROT, "%s:RGB RAU count = %d", __FUNCTION__,
|
|
rauCount);
|
|
}
|
|
|
|
ALOGD_IF(DEBUG_MDSS_ROT, "%s: aligned width = %d, aligned height = %d "
|
|
"Buf Size = %d", __FUNCTION__, aWidth, aHeight, bufSize);
|
|
|
|
return bufSize;
|
|
}
|
|
|
|
int MdssRot::getDownscaleFactor(const int& srcW, const int& srcH,
|
|
const int& dstW, const int& dstH, const uint32_t& mdpFormat,
|
|
const bool& isInterlaced) {
|
|
if(not srcW or not srcH or not dstW or not dstH or isInterlaced) return 0;
|
|
|
|
Dim crop(0, 0, srcW, srcH);
|
|
Dim adjCrop = getFormatAdjustedCrop(crop, mdpFormat,
|
|
false /*isInterlaced */);
|
|
|
|
uint32_t downscale = min((adjCrop.w / dstW), (adjCrop.h / dstH));
|
|
//Reduced to a power of 2
|
|
downscale = (uint32_t) powf(2.0f, floorf(log2f((float)downscale)));
|
|
|
|
if(downscale < 2 or downscale > 32) return 0;
|
|
|
|
//Allow only 1 line or pixel to be chopped off since the source needs to
|
|
//be aligned to downscale. Progressively try with smaller downscale to see
|
|
//if we can satisfy the threshold
|
|
//For YUV the loop shouldnt be needed, unless in exceptional cases
|
|
Dim dsAdjCrop = getDownscaleAdjustedCrop(adjCrop, downscale);
|
|
while(downscale > 2 and (adjCrop.w > dsAdjCrop.w or
|
|
adjCrop.h > dsAdjCrop.h)) {
|
|
downscale /= 2;
|
|
dsAdjCrop = getDownscaleAdjustedCrop(adjCrop, downscale);
|
|
}
|
|
|
|
if(not dsAdjCrop.w or not dsAdjCrop.h) return 0;
|
|
return downscale;
|
|
}
|
|
|
|
Dim MdssRot::getFormatAdjustedCrop(const Dim& crop,
|
|
const uint32_t& mdpFormat, const bool& isInterlaced) {
|
|
Dim adjCrop = crop;
|
|
if (isYuv(mdpFormat)) {
|
|
normalizeCrop(adjCrop.x, adjCrop.w);
|
|
normalizeCrop(adjCrop.y, adjCrop.h);
|
|
// For interlaced, crop.h should be 4-aligned
|
|
if (isInterlaced and (adjCrop.h % 4))
|
|
adjCrop.h = aligndown(adjCrop.h, 4);
|
|
}
|
|
return adjCrop;
|
|
}
|
|
|
|
Dim MdssRot::getDownscaleAdjustedCrop(const Dim& crop,
|
|
const uint32_t& downscale) {
|
|
uint32_t alignedSrcW = aligndown(crop.w, downscale * 2);
|
|
uint32_t alignedSrcH = aligndown(crop.h, downscale * 2);
|
|
return Dim(crop.x, crop.y, alignedSrcW, alignedSrcH);
|
|
}
|
|
|
|
} // namespace overlay
|