bool DisplayDevice::prepare(hwc_display_contents_1_t *display)
{
log.v("DisplayDevice::prepare");
if (!initCheck())
return false;
Mutex::Autolock _l(mLock);
if (mConnection != DEVICE_CONNECTED)
return true;
if (!display)
return true;
// check if geometry is changed
if (display->flags & HWC_GEOMETRY_CHANGED)
onGeometryChanged(display);
if (!mLayerList) {
log.e("prepare: null HWC layer list");
return false;
}
// update list with new list
return mLayerList->update(display);
}
bool DisplayDevice::isConnected() const
{
if (!initCheck())
return false;
return (mConnection == DEVICE_CONNECTED) ? true : false;
}
bool DisplayDevice::vsyncControl(int enabled)
{
struct drm_psb_vsync_set_arg arg;
Drm& drm(Drm::getInstance());
bool ret;
log.v("vsyncControl");
if (!initCheck())
return false;
//Mutex::Autolock _l(mLock);
if (mConnection != DEVICE_CONNECTED)
return false;
memset(&arg, 0, sizeof(struct drm_psb_vsync_set_arg));
arg.vsync.pipe = mType;
if (enabled)
arg.vsync_operation_mask = VSYNC_ENABLE;
else
arg.vsync_operation_mask = VSYNC_DISABLE;
log.v("DisplayDevice::vsyncControl: disp %d, enabled %d", mType, enabled);
ret = drm.writeReadIoctl(DRM_PSB_VSYNC_SET, &arg, sizeof(arg));
if (ret == false) {
log.e("DisplayDevice::vsyncControl: failed set vsync");
return false;
}
mVsyncObserver->control(enabled);
return true;
}
void DisplayDevice::prePrepare(hwc_display_contents_1_t *display)
{
log.v("DisplayDevice::prepare");
if (!initCheck())
return;
Mutex::Autolock _l(mLock);
if (mConnection != DEVICE_CONNECTED)
return;
// for a null list, delete hwc list
if (!display) {
delete mLayerList;
mLayerList = 0;
return;
}
// check if geometry is changed, if changed delete list
if ((display->flags & HWC_GEOMETRY_CHANGED) && mLayerList) {
delete mLayerList;
mLayerList = 0;
}
}
bool Hwcomposer::compositionComplete(int disp)
{
log.v("compositionComplete");
if (!initCheck())
return false;
// complete fb device first
if (mFBDev) {
mFBDev->base.compositionComplete(&mFBDev->base);
}
if (disp < 0 || disp >= IDisplayDevice::DEVICE_COUNT) {
log.e("compositionComplete: invalid disp %d", disp);
return false;
}
IDisplayDevice *device = mDisplayDevices.itemAt(disp);
if (!device) {
log.e("compositionComplete: no device found");
return false;
}
return device->compositionComplete();
}
status_t AMRWBEncoder::start(MetaData *params) {
if (mStarted) {
LOGW("Call start() when encoder already started");
return OK;
}
/*m@nufront start*/
//mBufferGroup = new MediaBufferGroup;
// The largest buffer size is header + 477 bits
//mBufferGroup->add_buffer(new MediaBuffer(1024));
/*m@nufront end*/
CHECK_EQ(OK, initCheck());
mNumFramesOutput = 0;
status_t err = mSource->start(params);
if (err != OK) {
LOGE("AudioSource is not available");
return err;
}
mStarted = true;
return OK;
}
bool Hwcomposer::prepare(size_t numDisplays,
hwc_display_contents_1_t** displays)
{
bool ret = true;
//Mutex::Autolock _l(mLock);
log.v("prepare display count %d\n", numDisplays);
if (!initCheck())
return false;
if (!numDisplays || !displays) {
log.e("prepare: invalid parameters");
return false;
}
// disable reclaimed planes
if (mPlaneManager)
mPlaneManager->disableReclaimedPlanes();
// reclaim all allocated planes if possible
for (size_t i = 0; i < numDisplays; i++) {
IDisplayDevice *device = mDisplayDevices.itemAt(i);
if (!device) {
log.v("prepare: device %d doesn't exist", i);
continue;
}
if (!device->isConnected()) {
log.v("prepare: device %d is disconnected", i);
continue;
}
device->prePrepare(displays[i]);
}
for (size_t i = 0; i < numDisplays; i++) {
IDisplayDevice *device = mDisplayDevices.itemAt(i);
if (!device) {
log.v("prepare: device %d doesn't exist", i);
continue;
}
if (!device->isConnected()) {
log.v("prepare: device %d is disconnected", i);
continue;
}
ret = device->prepare(displays[i]);
if (ret == false) {
log.e("prepare: failed to do prepare for device %d", i);
continue;
}
}
return ret;
}
bool Hwcomposer::release()
{
log.d("release");
if (!initCheck())
return false;
return true;
}
bool IntelHWComposerLayerList::isProtectedLayer(int index) const
{
if (!initCheck() || index < 0 || index >= mNumLayers) {
LOGE("%s: Invalid parameters\n", __func__);
return false;
}
return mLayerList[index].mIsProtected;
}
int IntelHWComposerLayerList::getYUVLayerCount() const
{
if (!initCheck()) {
LOGE("%s: Invalid parameters\n", __func__);
return 0;
}
return mNumYUVLayers;
}
int IntelHWComposerLayerList::getLayerFormat(int index) const
{
if (!initCheck() || index < 0 || index >= mNumLayers) {
LOGE("%s: Invalid parameters\n", __func__);
return 0;
}
return mLayerList[index].mFormat;
}
int IntelHWComposerLayerList::getLayerType(int index) const
{
if (!initCheck() || index < 0 || index >= mNumLayers) {
LOGE("%s: Invalid parameters\n", __func__);
return IntelHWComposerLayer::LAYER_TYPE_INVALID;
}
return mLayerList[index].mLayerType;
}
std::string
ModuleInfoSingleton::getInstance()
{
initCheck();
char tmp[32];
sprintf(tmp, "%d", modInstance_);
std::string ret(tmp);
return ret;
}
void IntelHWComposerLayerList::setFlags(int index, int flags)
{
if (index < 0 || index >= mNumLayers) {
LOGE("%s: Invalid parameters\n", __func__);
return;
}
if (initCheck())
mLayerList[index].mFlags = flags;
}
void IntelHWComposerLayerList::setNeedClearup(int index, bool needClearup)
{
if (index < 0 || index >= mNumLayers) {
LOGE("%s: Invalid parameters\n", __func__);
return;
}
if (initCheck())
mLayerList[index].mNeedClearup = needClearup;
}
void IntelHWComposerLayerList::setForceOverlay(int index, bool isForceOverlay)
{
if (index < 0 || index >= mNumLayers) {
LOGE("%s: Invalid parameters\n", __func__);
return;
}
if (initCheck())
mLayerList[index].mForceOverlay = isForceOverlay;
}
bool IntelSpritePlane::setDataBuffer(IntelDisplayBuffer& buffer)
{
if (initCheck()) {
IntelDisplayBuffer *bufferPtr = &buffer;
IntelDisplayDataBuffer *spriteDataBuffer =
reinterpret_cast<IntelDisplayDataBuffer*>(bufferPtr);
IntelSpriteContext *spriteContext =
reinterpret_cast<IntelSpriteContext*>(mContext);
intel_sprite_context_t *context = spriteContext->getContext();
uint32_t format = spriteDataBuffer->getFormat();
uint32_t spriteFormat;
int bpp;
switch (format) {
case HAL_PIXEL_FORMAT_RGBA_8888:
spriteFormat = INTEL_SPRITE_PIXEL_FORMAT_RGBA8888;
bpp = 4;
break;
case HAL_PIXEL_FORMAT_RGBX_8888:
spriteFormat = INTEL_SPRITE_PIXEL_FORMAT_RGBX8888;
bpp = 4;
break;
case HAL_PIXEL_FORMAT_BGRA_8888:
spriteFormat = INTEL_SPRITE_PIXEL_FORMAT_BGRA8888;
bpp = 4;
break;
default:
ALOGE("%s: unsupported format 0x%x\n", __func__, format);
return false;
}
// set offset;
int srcX = spriteDataBuffer->getSrcX();
int srcY = spriteDataBuffer->getSrcY();
int srcWidth = spriteDataBuffer->getSrcWidth();
int srcHeight = spriteDataBuffer->getSrcHeight();
uint32_t stride = align_to(bpp * srcWidth, 64);
uint32_t linoff = srcY * stride + srcX * bpp;
// gtt
uint32_t gttOffsetInPage = spriteDataBuffer->getGttOffsetInPage();
// update context
context->cntr = spriteFormat | 0x80000000;
context->linoff = linoff;
context->stride = stride;
context->surf = gttOffsetInPage << 12;
context->update_mask = SPRITE_UPDATE_ALL;
return true;
}
ALOGE("%s: sprite plane was not initialized\n", __func__);
return false;
}
bool IntelHWComposerLayerList::getForceOverlay(int index)
{
if (index < 0 || index >= mNumLayers) {
LOGE("%s: Invalid parameters\n", __func__);
return false;
}
if (initCheck())
return mLayerList[index].mForceOverlay;
return false;
}
int IntelHWComposerLayerList::getFlags(int index)
{
if (index < 0 || index >= mNumLayers) {
LOGE("%s: Invalid parameters\n", __func__);
return 0;
}
if (initCheck())
return mLayerList[index].mFlags;
return 0;
}
bool IntelHWComposerLayerList::getNeedClearup(int index)
{
if (index < 0 || index >= mNumLayers) {
LOGE("%s: Invalid parameters\n", __func__);
return false;
}
if (initCheck())
return mLayerList[index].mNeedClearup;
return false;
}
IntelDisplayPlane* IntelHWComposerLayerList::getPlane(int index)
{
if (index < 0 || index >= mNumLayers) {
LOGE("%s: Invalid parameters\n", __func__);
return 0;
}
if (initCheck())
return mLayerList[index].mPlane;
return 0;
}
bool IntelSpritePlane::invalidateDataBuffer()
{
ALOGD_IF(ALLOW_SPRITE_PRINT, "%s\n", __func__);
if (initCheck()) {
mBufferManager->unmap(mDataBuffer);
delete mDataBuffer;
mDataBuffer = new IntelDisplayDataBuffer(0, 0, 0);
return true;
}
return false;
}
void Hwcomposer::vsync(int disp, int64_t timestamp)
{
//Mutex::Autolock _l(mLock);
if (!initCheck())
return;
if (mProcs && mProcs->vsync) {
log.v("report vsync disp %d timestamp %llu", disp, timestamp);
mProcs->vsync(const_cast<hwc_procs_t*>(mProcs), disp, timestamp);
}
}
void Hwcomposer::hotplug(int disp, int connected)
{
//Mutex::Autolock _l(mLock);
if (!initCheck())
return;
if (mProcs && mProcs->hotplug) {
log.v("report hotplug disp %d connected %d", disp, connected);
mProcs->hotplug(const_cast<hwc_procs_t*>(mProcs), disp, connected);
}
}
bool Hwcomposer::commit(size_t numDisplays,
hwc_display_contents_1_t **displays)
{
bool ret = true;
log.v("commit display count %d\n", numDisplays);
//Mutex::Autolock _l(mLock);
if (!initCheck())
return false;
if (!numDisplays || !displays) {
log.e("commit: invalid parameters");
return false;
}
void *hwContexts = getContexts();
int count = 0;
if (!hwContexts) {
log.e("Hwcomposer::commit: invalid hwContexts");
return false;
}
for (size_t i = 0; i < numDisplays; i++) {
IDisplayDevice *device = mDisplayDevices.itemAt(i);
if (!device) {
log.v("commit: device %d doesn't exist", i);
continue;
}
if (!device->isConnected()) {
log.v("commit: device %d is disconnected", i);
continue;
}
ret = device->commit(displays[i], hwContexts, count);
if (ret == false) {
log.e("commit: failed to do commit for device %d", i);
continue;
}
}
// commit hwContexts to hardware
ret = commitContexts(hwContexts, count);
if (ret == false) {
log.e("Hwcomposer::commit: failed to commit hwContexts");
return false;
}
return ret;
}
bool DisplayDevice::getDisplayAttributes(uint32_t configs,
const uint32_t *attributes,
int32_t *values)
{
log.v("getDisplayAttributes");
if (!initCheck())
return false;
//Mutex::Autolock _l(mLock);
if (mConnection != DEVICE_CONNECTED)
return false;
if (!attributes || !values) {
log.e("getDisplayAttributes: invalid parameters");
return false;
}
DisplayConfig *config = mDisplayConfigs.itemAt(mActiveDisplayConfig);
if (!config) {
log.e("getDisplayAttributes: failed to get display config");
return false;
}
int i = 0;
while (attributes[i] != HWC_DISPLAY_NO_ATTRIBUTE) {
switch (attributes[i]) {
case HWC_DISPLAY_VSYNC_PERIOD:
values[i] = 1e9 / config->getRefreshRate();
break;
case HWC_DISPLAY_WIDTH:
values[i] = config->getWidth();
break;
case HWC_DISPLAY_HEIGHT:
values[i] = config->getHeight();
break;
case HWC_DISPLAY_DPI_X:
values[i] = config->getDpiX();
break;
case HWC_DISPLAY_DPI_Y:
values[i] = config->getDpiY();
break;
default:
log.e("getDisplayAttributes: unknown attribute %d", attributes[i]);
break;
}
i++;
}
return true;
}
bool DisplayDevice::blank(int blank)
{
log.v("blank");
if (!initCheck())
return false;
//Mutex::Autolock _l(mLock);
if (mConnection != DEVICE_CONNECTED)
return false;
return true;
}
bool DisplayDevice::compositionComplete()
{
log.v("compositionComplete");
if (!initCheck())
return false;
//Mutex::Autolock _l(mLock);
if (mConnection != DEVICE_CONNECTED)
return true;
return true;
}
IntelHWComposerLayerList::~IntelHWComposerLayerList()
{
if (!initCheck())
return;
// delete list
mPlaneManager = 0;
delete[] mLayerList;
mNumLayers = 0;
mNumRGBLayers = 0;
mNumYUVLayers= 0;
mAttachedSpritePlanes = 0;
mAttachedOverlayPlanes = 0;
mInitialized = false;
}
void DisplayDevice::onVsync(int64_t timestamp)
{
log.v("DisplayDevice::timestamp");
if (!initCheck())
return;
//Mutex::Autolock _l(mLock);
if (mConnection != DEVICE_CONNECTED)
return;
// notify hwc
mHwc.vsync(mType, timestamp);
}
