/* // 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 #include #include #include #include #include #include #include #include // FIXME: remove it #include #include 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(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