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); }