|
|
/* |
|
|
// 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 |
|
|
|
|
|
|
