/*
// Copyright (c) 2014 Intel Corporation
//
// 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 <HwcTrace.h>
#include <Drm.h>
#include <Hwcomposer.h>
#include <PhysicalDevice.h>
#include <common/OverlayPlaneBase.h>
#include <common/TTMBufferMapper.h>
#include <common/GrallocSubBuffer.h>
#include <DisplayQuery.h>
// FIXME: remove it
#include <OMX_IVCommon.h>
#include <OMX_IntelVideoExt.h>
namespace android {
namespace intel {
OverlayPlaneBase::OverlayPlaneBase(int index, int disp)
: DisplayPlane(index, PLANE_OVERLAY, disp),
mTTMBuffers(),
mActiveTTMBuffers(),
mCurrent(0),
mWsbm(0),
mPipeConfig(0),
mBobDeinterlace(0),
mUseScaledBuffer(0)
{
CTRACE();
for (int i = 0; i < OVERLAY_BACK_BUFFER_COUNT; i++) {
mBackBuffer[i] = 0;
}
}
OverlayPlaneBase::~OverlayPlaneBase()
{
CTRACE();
}
bool OverlayPlaneBase::initialize(uint32_t bufferCount)
{
Drm *drm = Hwcomposer::getInstance().getDrm();
CTRACE();
// NOTE: use overlay's data buffer count for the overlay plane
if (bufferCount < OVERLAY_DATA_BUFFER_COUNT) {
ITRACE("override overlay buffer count from %d to %d",
bufferCount, OVERLAY_DATA_BUFFER_COUNT);
bufferCount = OVERLAY_DATA_BUFFER_COUNT;
}
if (!DisplayPlane::initialize(bufferCount)) {
DEINIT_AND_RETURN_FALSE("failed to initialize display plane");
}
mTTMBuffers.setCapacity(bufferCount);
mActiveTTMBuffers.setCapacity(MIN_DATA_BUFFER_COUNT);
// init wsbm
mWsbm = new Wsbm(drm->getDrmFd());
if (!mWsbm || !mWsbm->initialize()) {
DEINIT_AND_RETURN_FALSE("failed to create wsbm");
}
// create overlay back buffer
for (int i = 0; i < OVERLAY_BACK_BUFFER_COUNT; i++) {
mBackBuffer[i] = createBackBuffer();
if (!mBackBuffer[i]) {
DEINIT_AND_RETURN_FALSE("failed to create overlay back buffer");
}
// reset back buffer
resetBackBuffer(i);
}
// disable overlay when created
flush(PLANE_DISABLE);
return true;
}
bool OverlayPlaneBase::isDisabled()
{
RETURN_FALSE_IF_NOT_INIT();
struct drm_psb_register_rw_arg arg;
memset(&arg, 0, sizeof(struct drm_psb_register_rw_arg));
arg.get_plane_state_mask = 1;
arg.plane.type = DC_OVERLAY_PLANE;
arg.plane.index = mIndex;
// pass the pipe index to check its enabled status
// now we can pass the device id directly since
// their values are just equal
arg.plane.ctx = mDevice; // not used in kernel
Drm *drm = Hwcomposer::getInstance().getDrm();
bool ret = drm->writeReadIoctl(DRM_PSB_REGISTER_RW, &arg, sizeof(arg));
if (ret == false) {
WTRACE("overlay plane query failed with error code %d", ret);
return false;
}
DTRACE("overlay %d status %s on device %d, current device %d",
mIndex, arg.plane.ctx ? "DISABLED" : "ENABLED", mDevice, mDevice);
return arg.plane.ctx == PSB_DC_PLANE_DISABLED;
}
void OverlayPlaneBase::deinitialize()
{
if (mTTMBuffers.size()) {
invalidateBufferCache();
}
if (mActiveTTMBuffers.size() > 0) {
invalidateActiveTTMBuffers();
}
// delete back buffer
for (int i = 0; i < OVERLAY_BACK_BUFFER_COUNT; i++) {
if (mBackBuffer[i]) {
deleteBackBuffer(i);
mBackBuffer[i] = NULL;
}
}
DEINIT_AND_DELETE_OBJ(mWsbm);
DisplayPlane::deinitialize();
}
void OverlayPlaneBase::invalidateBufferCache()
{
// clear plane buffer cache
DisplayPlane::invalidateBufferCache();
invalidateTTMBuffers();
}
bool OverlayPlaneBase::assignToDevice(int disp)
{
uint32_t pipeConfig = 0;
RETURN_FALSE_IF_NOT_INIT();
VTRACE("overlay %d assigned to disp %d", mIndex, disp);
switch (disp) {
case IDisplayDevice::DEVICE_EXTERNAL:
pipeConfig = (0x2 << 6);
break;
case IDisplayDevice::DEVICE_PRIMARY:
default:
pipeConfig = 0;
break;
}
// if pipe switching happened, then disable overlay first
if (mPipeConfig != pipeConfig) {
DTRACE("overlay %d switched from %d to %d", mIndex, mDevice, disp);
disable();
}
mPipeConfig = pipeConfig;
DisplayPlane::assignToDevice(disp);
enable();
return true;
}
void OverlayPlaneBase::setZOrderConfig(ZOrderConfig& zorderConfig,
void *nativeConfig)
{
CTRACE();
// setup overlay z order
int ovaZOrder = -1;
int ovcZOrder = -1;
for (size_t i = 0; i < zorderConfig.size(); i++) {
DisplayPlane *plane = zorderConfig[i]->plane;
if (plane->getType() == DisplayPlane::PLANE_OVERLAY) {
if (plane->getIndex() == 0) {
ovaZOrder = i;
} else if (plane->getIndex() == 1) {
ovcZOrder = i;
}
}
}
for (int i = 0; i < OVERLAY_BACK_BUFFER_COUNT; i++) {
OverlayBackBufferBlk *backBuffer = mBackBuffer[i]->buf;
if (!backBuffer)
return;
// force overlay c above overlay a
if ((ovaZOrder >= 0) && (ovaZOrder < ovcZOrder)) {
backBuffer->OCONFIG |= (1 << 15);
} else {
backBuffer->OCONFIG &= ~(1 << 15);
}
}
}
bool OverlayPlaneBase::reset()
{
RETURN_FALSE_IF_NOT_INIT();
DisplayPlane::reset();
// invalidate active TTM buffers
if (mActiveTTMBuffers.size() > 0) {
invalidateActiveTTMBuffers();
}
// reset back buffers
for (int i = 0; i < OVERLAY_BACK_BUFFER_COUNT; i++) {
resetBackBuffer(i);
}
return true;
}
bool OverlayPlaneBase::enable()
{
RETURN_FALSE_IF_NOT_INIT();
for (int i = 0; i < OVERLAY_BACK_BUFFER_COUNT; i++) {
OverlayBackBufferBlk *backBuffer = mBackBuffer[i]->buf;
if (!backBuffer)
return false;
if (backBuffer->OCMD & 0x1)
return true;
backBuffer->OCMD |= 0x1;
}
// flush
flush(PLANE_ENABLE);
return true;
}
bool OverlayPlaneBase::disable()
{
RETURN_FALSE_IF_NOT_INIT();
for (int i = 0; i < OVERLAY_BACK_BUFFER_COUNT; i++) {
OverlayBackBufferBlk *backBuffer = mBackBuffer[i]->buf;
if (!backBuffer)
return false;
if (!(backBuffer->OCMD & 0x1))
return true;
backBuffer->OCMD &= ~0x1;
}
// flush
flush(PLANE_DISABLE);
return true;
}
OverlayBackBuffer* OverlayPlaneBase::createBackBuffer()
{
CTRACE();
// create back buffer
OverlayBackBuffer *backBuffer = (OverlayBackBuffer *)malloc(sizeof(OverlayBackBuffer));
if (!backBuffer) {
ETRACE("failed to allocate back buffer");
return 0;
}
int size = sizeof(OverlayBackBufferBlk);
int alignment = 64 * 1024;
void *wsbmBufferObject = 0;
bool ret = mWsbm->allocateTTMBuffer(size, alignment, &wsbmBufferObject);
if (ret == false) {
ETRACE("failed to allocate TTM buffer");
return 0;
}
void *virtAddr = mWsbm->getCPUAddress(wsbmBufferObject);
uint32_t gttOffsetInPage = mWsbm->getGttOffset(wsbmBufferObject);
backBuffer->buf = (OverlayBackBufferBlk *)virtAddr;
backBuffer->gttOffsetInPage = gttOffsetInPage;
backBuffer->bufObject = wsbmBufferObject;
VTRACE("cpu %p, gtt %d", virtAddr, gttOffsetInPage);
return backBuffer;
}
void OverlayPlaneBase::deleteBackBuffer(int buf)
{
if (!mBackBuffer[buf])
return;
void *wsbmBufferObject = mBackBuffer[buf]->bufObject;
bool ret = mWsbm->destroyTTMBuffer(wsbmBufferObject);
if (ret == false) {
WTRACE("failed to destroy TTM buffer");
}
// free back buffer
free(mBackBuffer[buf]);
mBackBuffer[buf] = 0;
}
void OverlayPlaneBase::resetBackBuffer(int buf)
{
CTRACE();
if (!mBackBuffer[buf] || !mBackBuffer[buf]->buf)
return;
OverlayBackBufferBlk *backBuffer = mBackBuffer[buf]->buf;
memset(backBuffer, 0, sizeof(OverlayBackBufferBlk));
// reset overlay
backBuffer->OCLRC0 = (OVERLAY_INIT_CONTRAST << 18) |
(OVERLAY_INIT_BRIGHTNESS & 0xff);
backBuffer->OCLRC1 = OVERLAY_INIT_SATURATION;
backBuffer->DCLRKV = OVERLAY_INIT_COLORKEY;
backBuffer->DCLRKM = OVERLAY_INIT_COLORKEYMASK;
backBuffer->OCONFIG = 0;
backBuffer->OCONFIG |= (0x1 << 3);
backBuffer->OCONFIG |= (0x1 << 27);
backBuffer->SCHRKEN &= ~(0x7 << 24);
backBuffer->SCHRKEN |= 0xff;
}
BufferMapper* OverlayPlaneBase::getTTMMapper(BufferMapper& grallocMapper, struct VideoPayloadBuffer *payload)
{
buffer_handle_t khandle;
uint32_t w, h;
uint32_t yStride, uvStride;
stride_t stride;
int srcX, srcY, srcW, srcH;
int tmp;
DataBuffer *buf;
ssize_t index;
TTMBufferMapper *mapper;
bool ret;
if (!payload) {
ETRACE("invalid payload buffer");
return 0;
}
srcX = grallocMapper.getCrop().x;
srcY = grallocMapper.getCrop().y;
srcW = grallocMapper.getCrop().w;
srcH = grallocMapper.getCrop().h;
// init ttm buffer
if (mUseScaledBuffer) {
khandle = payload->scaling_khandle;
} else {
khandle = payload->rotated_buffer_handle;
}
index = mTTMBuffers.indexOfKey(khandle);
if (index < 0) {
VTRACE("unmapped TTM buffer, will map it");
if (mUseScaledBuffer) {
w = payload->scaling_width;
h = payload->scaling_height;
} else {
w = payload->rotated_width;
h = payload->rotated_height;
checkCrop(srcX, srcY, srcW, srcH, payload->coded_width, payload->coded_height);
}
uint32_t format = grallocMapper.getFormat();
// this is for sw decode with tiled buffer in landscape mode
if (payload->tiling)
format = OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar_Tiled;
// calculate stride
switch (format) {
case HAL_PIXEL_FORMAT_YV12:
case HAL_PIXEL_FORMAT_I420:
uint32_t yStride_align;
yStride_align = DisplayQuery::getOverlayLumaStrideAlignment(grallocMapper.getFormat());
if (yStride_align > 0)
{
yStride = align_to(align_to(w, 32), yStride_align);
}
else
{
yStride = align_to(align_to(w, 32), 64);
}
uvStride = align_to(yStride >> 1, 64);
stride.yuv.yStride = yStride;
stride.yuv.uvStride = uvStride;
break;
case HAL_PIXEL_FORMAT_NV12:
yStride = align_to(align_to(w, 32), 64);
uvStride = yStride;
stride.yuv.yStride = yStride;
stride.yuv.uvStride = uvStride;
break;
case OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar:
case OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar_Tiled:
if (mUseScaledBuffer) {
stride.yuv.yStride = payload->scaling_luma_stride;
stride.yuv.uvStride = payload->scaling_chroma_u_stride;
} else {
yStride = align_to(align_to(w, 32), 64);
uvStride = yStride;
stride.yuv.yStride = yStride;
stride.yuv.uvStride = uvStride;
}
break;
case HAL_PIXEL_FORMAT_YUY2:
case HAL_PIXEL_FORMAT_UYVY:
yStride = align_to((align_to(w, 32) << 1), 64);
uvStride = 0;
stride.yuv.yStride = yStride;
stride.yuv.uvStride = uvStride;
break;
}
DataBuffer buf(khandle);
// update buffer
buf.setStride(stride);
buf.setWidth(w);
buf.setHeight(h);
buf.setCrop(srcX, srcY, srcW, srcH);
buf.setFormat(format);
// create buffer mapper
bool res = false;
do {
mapper = new TTMBufferMapper(*mWsbm, buf);
if (!mapper) {
ETRACE("failed to allocate mapper");
break;
}
// map ttm buffer
ret = mapper->map();
if (!ret) {
ETRACE("failed to map");
invalidateTTMBuffers();
ret = mapper->map();
if (!ret) {
ETRACE("failed to remap");
break;
}
}
if (mTTMBuffers.size() >= OVERLAY_DATA_BUFFER_COUNT) {
invalidateTTMBuffers();
}
// add mapper
index = mTTMBuffers.add(khandle, mapper);
if (index < 0) {
ETRACE("failed to add TTMMapper");
break;
}
// increase mapper refCount since it is added to mTTMBuffers
mapper->incRef();
res = true;
} while (0);
if (!res) {
// error handling
if (mapper) {
mapper->unmap();
delete mapper;
mapper = NULL;
}
return 0;
}
} else {
VTRACE("got mapper in saved ttm buffers");
mapper = reinterpret_cast<TTMBufferMapper *>(mTTMBuffers.valueAt(index));
if (mapper->getCrop().x != srcX || mapper->getCrop().y != srcY ||
mapper->getCrop().w != srcW || mapper->getCrop().h != srcH) {
if(!mUseScaledBuffer)
checkCrop(srcX, srcY, srcW, srcH, payload->coded_width, payload->coded_height);
mapper->setCrop(srcX, srcY, srcW, srcH);
}
}
XTRACE();
return mapper;
}
void OverlayPlaneBase::putTTMMapper(BufferMapper* mapper)
{
if (!mapper)
return;
if (!mapper->decRef()) {
// unmap it
mapper->unmap();
// destroy this mapper
delete mapper;
}
}
bool OverlayPlaneBase::isActiveTTMBuffer(BufferMapper *mapper)
{
for (size_t i = 0; i < mActiveTTMBuffers.size(); i++) {
BufferMapper *activeMapper = mActiveTTMBuffers.itemAt(i);
if (!activeMapper)
continue;
if (activeMapper->getKey() == mapper->getKey())
return true;
}
return false;
}
void OverlayPlaneBase::updateActiveTTMBuffers(BufferMapper *mapper)
{
// unmap the first entry (oldest buffer)
if (mActiveTTMBuffers.size() >= MAX_ACTIVE_TTM_BUFFERS) {
BufferMapper *oldest = mActiveTTMBuffers.itemAt(0);
putTTMMapper(oldest);
mActiveTTMBuffers.removeAt(0);
}
// queue it to cached buffers
if (!isActiveTTMBuffer(mapper)) {
mapper->incRef();
mActiveTTMBuffers.push_back(mapper);
}
}
void OverlayPlaneBase::invalidateActiveTTMBuffers()
{
BufferMapper* mapper;
RETURN_VOID_IF_NOT_INIT();
for (size_t i = 0; i < mActiveTTMBuffers.size(); i++) {
mapper = mActiveTTMBuffers.itemAt(i);
// unmap it
putTTMMapper(mapper);
}
// clear recorded data buffers
mActiveTTMBuffers.clear();
}
void OverlayPlaneBase::invalidateTTMBuffers()
{
BufferMapper* mapper;
for (size_t i = 0; i < mTTMBuffers.size(); i++) {
mapper = mTTMBuffers.valueAt(i);
// putTTMMapper removes mapper from cache
putTTMMapper(mapper);
}
mTTMBuffers.clear();
}
bool OverlayPlaneBase::rotatedBufferReady(BufferMapper& mapper, BufferMapper* &rotatedMapper)
{
struct VideoPayloadBuffer *payload;
uint32_t format;
// only NV12_VED has rotated buffer
format = mapper.getFormat();
if (format != OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar &&
format != OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar_Tiled)
return false;
payload = (struct VideoPayloadBuffer *)mapper.getCpuAddress(SUB_BUFFER1);
// check payload
if (!payload) {
ETRACE("no payload found");
return false;
}
if (payload->force_output_method == FORCE_OUTPUT_GPU)
return false;
if (payload->client_transform != mTransform) {
if (payload->surface_protected) {
payload->hwc_timestamp = systemTime();
payload->layer_transform = mTransform;
}
WTRACE("client is not ready");
return false;
}
rotatedMapper = getTTMMapper(mapper, payload);
return true;
}
bool OverlayPlaneBase::useOverlayRotation(BufferMapper& mapper)
{
// by default overlay plane does not support rotation.
return false;
}
bool OverlayPlaneBase::scaledBufferReady(BufferMapper& mapper, BufferMapper* &scaledMapper, VideoPayloadBuffer *payload)
{
return false;
}
void OverlayPlaneBase::checkPosition(int& x, int& y, int& w, int& h)
{
drmModeModeInfoPtr mode = &mModeInfo;
if (mode->hdisplay == 0 || mode->vdisplay == 0)
return;
if (x < 0)
x = 0;
if (y < 0)
y = 0;
if ((x + w) > mode->hdisplay)
w = mode->hdisplay - x;
if ((y + h) > mode->vdisplay)
h = mode->vdisplay - y;
}
void OverlayPlaneBase::checkCrop(int& srcX, int& srcY, int& srcW, int& srcH,
int coded_width, int coded_height)
{
int tmp;
if (mTransform)
srcH >>= mBobDeinterlace;
if (mTransform == HWC_TRANSFORM_ROT_90 || mTransform == HWC_TRANSFORM_ROT_270) {
tmp = srcH;
srcH = srcW;
srcW = tmp;
tmp = srcX;
srcX = srcY;
srcY = tmp;
tmp = coded_width;
coded_width = coded_height;
coded_height = tmp;
}
// skip pading bytes in rotate buffer
switch(mTransform) {
case HWC_TRANSFORM_ROT_90:
srcX = (coded_width >> mBobDeinterlace) - srcW - srcX;
break;
case HWC_TRANSFORM_ROT_180:
srcX = coded_width - srcW - srcX;
srcY = (coded_height >> mBobDeinterlace) - srcH - srcY;
break;
case HWC_TRANSFORM_ROT_270:
srcY = coded_height - srcH - srcY;
break;
default:
break;
}
}
bool OverlayPlaneBase::bufferOffsetSetup(BufferMapper& mapper)
{
CTRACE();
OverlayBackBufferBlk *backBuffer = mBackBuffer[mCurrent]->buf;
if (!backBuffer) {
ETRACE("invalid back buffer");
return false;
}
uint32_t format = mapper.getFormat();
uint32_t gttOffsetInBytes = (mapper.getGttOffsetInPage(0) << 12);
uint32_t yStride = mapper.getStride().yuv.yStride;
uint32_t uvStride = mapper.getStride().yuv.uvStride;
uint32_t w = mapper.getWidth();
uint32_t h = mapper.getHeight();
uint32_t srcX= mapper.getCrop().x;
uint32_t srcY= mapper.getCrop().y;
// clear original format setting
backBuffer->OCMD &= ~(0xf << 10);
backBuffer->OCMD &= ~OVERLAY_MEMORY_LAYOUT_TILED;
// Y/U/V plane must be 4k bytes aligned.
backBuffer->OSTART_0Y = gttOffsetInBytes;
if (mIsProtectedBuffer) {
// temporary workaround until vsync event logic is corrected.
// it seems that overlay buffer update and renderring can be overlapped,
// as such encryption bit may be cleared during HW rendering
backBuffer->OSTART_0Y |= 0x01;
}
backBuffer->OSTART_0U = gttOffsetInBytes;
backBuffer->OSTART_0V = gttOffsetInBytes;
backBuffer->OSTART_1Y = backBuffer->OSTART_0Y;
backBuffer->OSTART_1U = backBuffer->OSTART_0U;
backBuffer->OSTART_1V = backBuffer->OSTART_0V;
switch(format) {
case HAL_PIXEL_FORMAT_YV12: // YV12
backBuffer->OBUF_0Y = 0;
backBuffer->OBUF_0V = yStride * h;
backBuffer->OBUF_0U = backBuffer->OBUF_0V + (uvStride * (h / 2));
backBuffer->OCMD |= OVERLAY_FORMAT_PLANAR_YUV420;
break;
case HAL_PIXEL_FORMAT_I420: // I420
backBuffer->OBUF_0Y = 0;
backBuffer->OBUF_0U = yStride * h;
backBuffer->OBUF_0V = backBuffer->OBUF_0U + (uvStride * (h / 2));
backBuffer->OCMD |= OVERLAY_FORMAT_PLANAR_YUV420;
break;
case HAL_PIXEL_FORMAT_NV12: // NV12
backBuffer->OBUF_0Y = 0;
backBuffer->OBUF_0U = yStride * h;
backBuffer->OBUF_0V = 0;
backBuffer->OCMD |= OVERLAY_FORMAT_PLANAR_NV12_2;
break;
// NOTE: this is the decoded video format, align the height to 32B
//as it's defined by video driver
case OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar: // Intel codec NV12
backBuffer->OBUF_0Y = 0;
backBuffer->OBUF_0U = yStride * align_to(h, 32);
backBuffer->OBUF_0V = 0;
backBuffer->OCMD |= OVERLAY_FORMAT_PLANAR_NV12_2;
break;
case OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar_Tiled: //NV12_tiled
backBuffer->OBUF_0Y = 0;
backBuffer->OBUF_0U = yStride * align_to(h, 32);
backBuffer->OBUF_0V = 0;
backBuffer->OSTART_0U += yStride * align_to(h, 32);
backBuffer->OSTART_0V += yStride * align_to(h, 32);
backBuffer->OSTART_1U = backBuffer->OSTART_0U;
backBuffer->OSTART_1V = backBuffer->OSTART_0V;
backBuffer->OTILEOFF_0Y = srcX + (srcY << 16);
backBuffer->OTILEOFF_1Y = backBuffer->OTILEOFF_0Y;
backBuffer->OTILEOFF_0U = srcX + ((srcY / 2) << 16);
backBuffer->OTILEOFF_1U = backBuffer->OTILEOFF_0U;
backBuffer->OTILEOFF_0V = backBuffer->OTILEOFF_0U;
backBuffer->OTILEOFF_1V = backBuffer->OTILEOFF_0U;
backBuffer->OCMD |= OVERLAY_FORMAT_PLANAR_NV12_2;
backBuffer->OCMD |= OVERLAY_MEMORY_LAYOUT_TILED;
break;
case HAL_PIXEL_FORMAT_YUY2: // YUY2
backBuffer->OBUF_0Y = 0;
backBuffer->OBUF_0U = 0;
backBuffer->OBUF_0V = 0;
backBuffer->OCMD |= OVERLAY_FORMAT_PACKED_YUV422;
backBuffer->OCMD |= OVERLAY_PACKED_ORDER_YUY2;
break;
case HAL_PIXEL_FORMAT_UYVY: // UYVY
backBuffer->OBUF_0Y = 0;
backBuffer->OBUF_0U = 0;
backBuffer->OBUF_0V = 0;
backBuffer->OCMD |= OVERLAY_FORMAT_PACKED_YUV422;
backBuffer->OCMD |= OVERLAY_PACKED_ORDER_UYVY;
break;
default:
ETRACE("unsupported format %d", format);
return false;
}
backBuffer->OBUF_0Y += srcY * yStride + srcX;
backBuffer->OBUF_0V += (srcY / 2) * uvStride + srcX;
backBuffer->OBUF_0U += (srcY / 2) * uvStride + srcX;
backBuffer->OBUF_1Y = backBuffer->OBUF_0Y;
backBuffer->OBUF_1U = backBuffer->OBUF_0U;
backBuffer->OBUF_1V = backBuffer->OBUF_0V;
VTRACE("done. offset (%d, %d, %d)",
backBuffer->OBUF_0Y,
backBuffer->OBUF_0U,
backBuffer->OBUF_0V);
return true;
}
uint32_t OverlayPlaneBase::calculateSWidthSW(uint32_t offset, uint32_t width)
{
ATRACE("offset = %d, width = %d", offset, width);
uint32_t swidth = ((offset + width + 0x3F) >> 6) - (offset >> 6);
swidth <<= 1;
swidth -= 1;
return swidth;
}
bool OverlayPlaneBase::coordinateSetup(BufferMapper& mapper)
{
CTRACE();
OverlayBackBufferBlk *backBuffer = mBackBuffer[mCurrent]->buf;
if (!backBuffer) {
ETRACE("invalid back buffer");
return false;
}
uint32_t swidthy = 0;
uint32_t swidthuv = 0;
uint32_t format = mapper.getFormat();
uint32_t width = mapper.getCrop().w;
uint32_t height = mapper.getCrop().h;
uint32_t yStride = mapper.getStride().yuv.yStride;
uint32_t uvStride = mapper.getStride().yuv.uvStride;
uint32_t offsety = backBuffer->OBUF_0Y;
uint32_t offsetu = backBuffer->OBUF_0U;
switch (format) {
case HAL_PIXEL_FORMAT_YV12: // YV12
case HAL_PIXEL_FORMAT_I420: // I420
case HAL_PIXEL_FORMAT_NV12: // NV12
case OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar: // NV12
case OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar_Tiled: // NV12_tiled
break;
case HAL_PIXEL_FORMAT_YUY2: // YUY2
case HAL_PIXEL_FORMAT_UYVY: // UYVY
width <<= 1;
break;
default:
ETRACE("unsupported format %d", format);
return false;
}
if (width <= 0 || height <= 0) {
ETRACE("invalid src dim");
return false;
}
if (yStride <=0 && uvStride <= 0) {
ETRACE("invalid source stride");
return false;
}
backBuffer->SWIDTH = width | ((width / 2) << 16);
swidthy = calculateSWidthSW(offsety, width);
swidthuv = calculateSWidthSW(offsetu, width / 2);
backBuffer->SWIDTHSW = (swidthy << 2) | (swidthuv << 18);
backBuffer->SHEIGHT = height | ((height / 2) << 16);
backBuffer->OSTRIDE = (yStride & (~0x3f)) | ((uvStride & (~0x3f)) << 16);
XTRACE();
return true;
}
bool OverlayPlaneBase::setCoeffRegs(double *coeff, int mantSize,
coeffPtr pCoeff, int pos)
{
int maxVal, icoeff, res;
int sign;
double c;
sign = 0;
maxVal = 1 << mantSize;
c = *coeff;
if (c < 0.0) {
sign = 1;
c = -c;
}
res = 12 - mantSize;
if ((icoeff = (int)(c * 4 * maxVal + 0.5)) < maxVal) {
pCoeff[pos].exponent = 3;
pCoeff[pos].mantissa = icoeff << res;
*coeff = (double)icoeff / (double)(4 * maxVal);
} else if ((icoeff = (int)(c * 2 * maxVal + 0.5)) < maxVal) {
pCoeff[pos].exponent = 2;
pCoeff[pos].mantissa = icoeff << res;
*coeff = (double)icoeff / (double)(2 * maxVal);
} else if ((icoeff = (int)(c * maxVal + 0.5)) < maxVal) {
pCoeff[pos].exponent = 1;
pCoeff[pos].mantissa = icoeff << res;
*coeff = (double)icoeff / (double)(maxVal);
} else if ((icoeff = (int)(c * maxVal * 0.5 + 0.5)) < maxVal) {
pCoeff[pos].exponent = 0;
pCoeff[pos].mantissa = icoeff << res;
*coeff = (double)icoeff / (double)(maxVal / 2);
} else {
// Coeff out of range
return false;
}
pCoeff[pos].sign = sign;
if (sign)
*coeff = -(*coeff);
return true;
}
void OverlayPlaneBase::updateCoeff(int taps, double fCutoff,
bool isHoriz, bool isY,
coeffPtr pCoeff)
{
int i, j, j1, num, pos, mantSize;
double pi = 3.1415926535, val, sinc, window, sum;
double rawCoeff[MAX_TAPS * 32], coeffs[N_PHASES][MAX_TAPS];
double diff;
int tapAdjust[MAX_TAPS], tap2Fix;
bool isVertAndUV;
if (isHoriz)
mantSize = 7;
else
mantSize = 6;
isVertAndUV = !isHoriz && !isY;
num = taps * 16;
for (i = 0; i < num * 2; i++) {
val = (1.0 / fCutoff) * taps * pi * (i - num) / (2 * num);
if (val == 0.0)
sinc = 1.0;
else
sinc = sin(val) / val;
// Hamming window
window = (0.54 - 0.46 * cos(2 * i * pi / (2 * num - 1)));
rawCoeff[i] = sinc * window;
}
for (i = 0; i < N_PHASES; i++) {
// Normalise the coefficients
sum = 0.0;
for (j = 0; j < taps; j++) {
pos = i + j * 32;
sum += rawCoeff[pos];
}
for (j = 0; j < taps; j++) {
pos = i + j * 32;
coeffs[i][j] = rawCoeff[pos] / sum;
}
// Set the register values
for (j = 0; j < taps; j++) {
pos = j + i * taps;
if ((j == (taps - 1) / 2) && !isVertAndUV)
setCoeffRegs(&coeffs[i][j], mantSize + 2, pCoeff, pos);
else
setCoeffRegs(&coeffs[i][j], mantSize, pCoeff, pos);
}
tapAdjust[0] = (taps - 1) / 2;
for (j = 1, j1 = 1; j <= tapAdjust[0]; j++, j1++) {
tapAdjust[j1] = tapAdjust[0] - j;
tapAdjust[++j1] = tapAdjust[0] + j;
}
// Adjust the coefficients
sum = 0.0;
for (j = 0; j < taps; j++)
sum += coeffs[i][j];
if (sum != 1.0) {
for (j1 = 0; j1 < taps; j1++) {
tap2Fix = tapAdjust[j1];
diff = 1.0 - sum;
coeffs[i][tap2Fix] += diff;
pos = tap2Fix + i * taps;
if ((tap2Fix == (taps - 1) / 2) && !isVertAndUV)
setCoeffRegs(&coeffs[i][tap2Fix], mantSize + 2, pCoeff, pos);
else
setCoeffRegs(&coeffs[i][tap2Fix], mantSize, pCoeff, pos);
sum = 0.0;
for (j = 0; j < taps; j++)
sum += coeffs[i][j];
if (sum == 1.0)
break;
}
}
}
}
bool OverlayPlaneBase::scalingSetup(BufferMapper& mapper)
{
int xscaleInt, xscaleFract, yscaleInt, yscaleFract;
int xscaleIntUV, xscaleFractUV;
int yscaleIntUV, yscaleFractUV;
int deinterlace_factor = 1;
// UV is half the size of Y -- YUV420
int uvratio = 2;
uint32_t newval;
coeffRec xcoeffY[N_HORIZ_Y_TAPS * N_PHASES];
coeffRec xcoeffUV[N_HORIZ_UV_TAPS * N_PHASES];
int i, j, pos;
bool scaleChanged = false;
int x, y, w, h;
OverlayBackBufferBlk *backBuffer = mBackBuffer[mCurrent]->buf;
if (!backBuffer) {
ETRACE("invalid back buffer");
return false;
}
x = mPosition.x;
y = mPosition.y;
w = mPosition.w;
h = mPosition.h;
// check position
checkPosition(x, y, w, h);
VTRACE("final position (%d, %d, %d, %d)", x, y, w, h);
if ((w <= 0) || (h <= 0)) {
ETRACE("invalid dst width/height");
return false;
}
// setup dst position
backBuffer->DWINPOS = (y << 16) | x;
backBuffer->DWINSZ = (h << 16) | w;
uint32_t srcWidth = mapper.getCrop().w;
uint32_t srcHeight = mapper.getCrop().h;
uint32_t dstWidth = w;
uint32_t dstHeight = h;
if (mBobDeinterlace && !mTransform)
deinterlace_factor = 2;
VTRACE("src (%dx%d), dst (%dx%d)",
srcWidth, srcHeight,
dstWidth, dstHeight);
// Y down-scale factor as a multiple of 4096
if (srcWidth == dstWidth && srcHeight == dstHeight) {
xscaleFract = (1 << 12);
yscaleFract = (1 << 12)/deinterlace_factor;
} else {
xscaleFract = ((srcWidth - 1) << 12) / dstWidth;
yscaleFract = ((srcHeight - 1) << 12) / (dstHeight * deinterlace_factor);
}
// Calculate the UV scaling factor
xscaleFractUV = xscaleFract / uvratio;
yscaleFractUV = yscaleFract / uvratio;
// To keep the relative Y and UV ratios exact, round the Y scales
// to a multiple of the Y/UV ratio.
xscaleFract = xscaleFractUV * uvratio;
yscaleFract = yscaleFractUV * uvratio;
// Integer (un-multiplied) values
xscaleInt = xscaleFract >> 12;
yscaleInt = yscaleFract >> 12;
xscaleIntUV = xscaleFractUV >> 12;
yscaleIntUV = yscaleFractUV >> 12;
// Check scaling ratio
if (xscaleInt > INTEL_OVERLAY_MAX_SCALING_RATIO) {
ETRACE("xscaleInt > %d", INTEL_OVERLAY_MAX_SCALING_RATIO);
return false;
}
// shouldn't get here
if (xscaleIntUV > INTEL_OVERLAY_MAX_SCALING_RATIO) {
ETRACE("xscaleIntUV > %d", INTEL_OVERLAY_MAX_SCALING_RATIO);
return false;
}
newval = (xscaleInt << 15) |
((xscaleFract & 0xFFF) << 3) | ((yscaleFract & 0xFFF) << 20);
if (newval != backBuffer->YRGBSCALE) {
scaleChanged = true;
backBuffer->YRGBSCALE = newval;
}
newval = (xscaleIntUV << 15) | ((xscaleFractUV & 0xFFF) << 3) |
((yscaleFractUV & 0xFFF) << 20);
if (newval != backBuffer->UVSCALE) {
scaleChanged = true;
backBuffer->UVSCALE = newval;
}
newval = yscaleInt << 16 | yscaleIntUV;
if (newval != backBuffer->UVSCALEV) {
scaleChanged = true;
backBuffer->UVSCALEV = newval;
}
// Recalculate coefficients if the scaling changed
// Only Horizontal coefficients so far.
if (scaleChanged) {
double fCutoffY;
double fCutoffUV;
fCutoffY = xscaleFract / 4096.0;
fCutoffUV = xscaleFractUV / 4096.0;
// Limit to between 1.0 and 3.0
if (fCutoffY < MIN_CUTOFF_FREQ)
fCutoffY = MIN_CUTOFF_FREQ;
if (fCutoffY > MAX_CUTOFF_FREQ)
fCutoffY = MAX_CUTOFF_FREQ;
if (fCutoffUV < MIN_CUTOFF_FREQ)
fCutoffUV = MIN_CUTOFF_FREQ;
if (fCutoffUV > MAX_CUTOFF_FREQ)
fCutoffUV = MAX_CUTOFF_FREQ;
updateCoeff(N_HORIZ_Y_TAPS, fCutoffY, true, true, xcoeffY);
updateCoeff(N_HORIZ_UV_TAPS, fCutoffUV, true, false, xcoeffUV);
for (i = 0; i < N_PHASES; i++) {
for (j = 0; j < N_HORIZ_Y_TAPS; j++) {
pos = i * N_HORIZ_Y_TAPS + j;
backBuffer->Y_HCOEFS[pos] =
(xcoeffY[pos].sign << 15 |
xcoeffY[pos].exponent << 12 |
xcoeffY[pos].mantissa);
}
}
for (i = 0; i < N_PHASES; i++) {
for (j = 0; j < N_HORIZ_UV_TAPS; j++) {
pos = i * N_HORIZ_UV_TAPS + j;
backBuffer->UV_HCOEFS[pos] =
(xcoeffUV[pos].sign << 15 |
xcoeffUV[pos].exponent << 12 |
xcoeffUV[pos].mantissa);
}
}
}
XTRACE();
return true;
}
bool OverlayPlaneBase::colorSetup(BufferMapper& mapper)
{
CTRACE();
OverlayBackBufferBlk *backBuffer = mBackBuffer[mCurrent]->buf;
if (!backBuffer) {
ETRACE("invalid back buffer");
return false;
}
uint32_t format = mapper.getFormat();
if (format != OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar &&
format != OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar_Tiled) {
VTRACE("Not video layer, use default color setting");
backBuffer->OCLRC0 = (OVERLAY_INIT_CONTRAST << 18) |
(OVERLAY_INIT_BRIGHTNESS & 0xff);
backBuffer->OCLRC1 = OVERLAY_INIT_SATURATION;
backBuffer->OCONFIG &= ~(1 << 5);
return true;
}
struct VideoPayloadBuffer *payload;
payload = (struct VideoPayloadBuffer *)mapper.getCpuAddress(SUB_BUFFER1);
// check payload
if (!payload) {
ETRACE("no payload found");
return false;
}
// BT.601 or BT.709
backBuffer->OCONFIG &= ~(1 << 5);
backBuffer->OCONFIG |= ((payload->csc_mode & 1) << 5);
// no level expansion for video on HDMI
if (payload->video_range || mPipeConfig == (0x2 << 6)) {
// full range, no need to do level expansion
backBuffer->OCLRC0 = 0x1000000;
backBuffer->OCLRC1 = 0x80;
} else {
// level expansion for limited range
backBuffer->OCLRC0 = (OVERLAY_INIT_CONTRAST << 18) |
(OVERLAY_INIT_BRIGHTNESS & 0xff);
backBuffer->OCLRC1 = OVERLAY_INIT_SATURATION;
}
return true;
}
bool OverlayPlaneBase::setDataBuffer(BufferMapper& grallocMapper)
{
BufferMapper *mapper;
BufferMapper *videoBufferMapper = 0;
bool ret;
uint32_t format;
RETURN_FALSE_IF_NOT_INIT();
// get gralloc mapper
mapper = &grallocMapper;
format = grallocMapper.getFormat();
if (format == OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar ||
format == OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar_Tiled) {
struct VideoPayloadBuffer *payload;
payload = (struct VideoPayloadBuffer *)grallocMapper.getCpuAddress(SUB_BUFFER1);
if (!payload) {
ETRACE("invalid payload buffer");
return 0;
}
mBobDeinterlace = payload->bob_deinterlace;
int srcW, srcH;
srcW = grallocMapper.getCrop().w - grallocMapper.getCrop().x;
srcH = grallocMapper.getCrop().h - grallocMapper.getCrop().y;
if ((srcW > INTEL_OVERLAY_MAX_WIDTH - 1) || (srcH > INTEL_OVERLAY_MAX_HEIGHT - 1)) {
if (mTransform) {
int x, y, w, h;
x = mSrcCrop.x;
y = mSrcCrop.y;
w = mSrcCrop.w;
h = mSrcCrop.h;
setSourceCrop(0, 0, payload->scaling_width, payload->scaling_height);
if (!useOverlayRotation(grallocMapper)) {
DTRACE("The scaled buffer will hit overlay rotation limitation, fall back to GLES");
setSourceCrop(x, y, w, h);
return false;
}
}
if (!scaledBufferReady(grallocMapper, videoBufferMapper, payload)) {
DTRACE("scaled buffer is not ready, fall back to GLES");
return false;
} else {
videoBufferMapper->setFormat(OMX_INTEL_COLOR_FormatYUV420PackedSemiPlanar);
mapper = videoBufferMapper;
}
}
}
if (!mUseScaledBuffer && mTransform && !useOverlayRotation(grallocMapper)) {
if (!rotatedBufferReady(grallocMapper, videoBufferMapper)) {
DTRACE("rotated buffer is not ready");
return false;
}
if (!videoBufferMapper) {
ETRACE("failed to get rotated buffer");
return false;
}
mapper = videoBufferMapper;
}
OverlayBackBufferBlk *backBuffer = mBackBuffer[mCurrent]->buf;
if (!backBuffer) {
ETRACE("invalid back buffer");
return false;
}
ret = bufferOffsetSetup(*mapper);
if (ret == false) {
ETRACE("failed to set up buffer offsets");
return false;
}
ret = coordinateSetup(*mapper);
if (ret == false) {
ETRACE("failed to set up overlay coordinates");
return false;
}
ret = scalingSetup(*mapper);
if (ret == false) {
ETRACE("failed to set up scaling parameters");
return false;
}
backBuffer->OCMD |= 0x1;
ret = colorSetup(grallocMapper);
if (ret == false) {
ETRACE("failed to set up color parameters");
return false;
}
if (mBobDeinterlace && !mTransform) {
backBuffer->OCMD |= BUF_TYPE_FIELD;
backBuffer->OCMD &= ~FIELD_SELECT;
backBuffer->OCMD |= FIELD0;
backBuffer->OCMD &= ~(BUFFER_SELECT);
backBuffer->OCMD |= BUFFER0;
}
// add to active ttm buffers if it's a rotated buffer
if (videoBufferMapper) {
updateActiveTTMBuffers(mapper);
}
mUseScaledBuffer = 0;
return true;
}
} // namespace intel
} // namespace android