status_t CameraService::Client::startPreviewMode() { LOG1("startPreviewMode"); status_t result = NO_ERROR; // if preview has been enabled, nothing needs to be done if (mHardware->previewEnabled()) { return NO_ERROR; } if (mUseOverlay) { // If preview display has been set, set overlay now. if (mSurface != 0) { result = setOverlay(); } #ifdef USE_OVERLAY_FORMAT_YCbCr_420_SP result = mHardware->startPreview(); #endif if (result != NO_ERROR) return result; #ifndef USE_OVERLAY_FORMAT_YCbCr_420_SP result = mHardware->startPreview(); #endif } else { enableMsgType(CAMERA_MSG_PREVIEW_FRAME); result = mHardware->startPreview(); if (result != NO_ERROR) return result; // If preview display has been set, register preview buffers now. if (mSurface != 0) { // Unregister here because the surface may be previously registered // with the raw (snapshot) heap. mSurface->unregisterBuffers(); result = registerPreviewBuffers(); } } return result; }
//--------------------------------------------------------------------- //! @brief Set how the Image is being displayed. This is //! usually determined by the model's Validity. //! @param[in] _visibility How the Image should be //! displayed. //--------------------------------------------------------------------- void Image::setVisibility( Visibility const& _visibility ) { visibility__ = _visibility; switch( visibility__ ) { case Visibility::INVISIBLE: evas_object_hide( image__ ); break; case Visibility::VISIBLE: evas_object_show( image__ ); break; case Visibility::SHADED: evas_object_show( image__ ); setOverlay( SHADED_GREY , SHADED_GREY , SHADED_GREY , 128 ); break; default: ASSERT( false , "Wrong value passed to setVisibility => use the Visibility enum." ); break; } evas_object_hide( image_pressed__ ); }
bool QGstreamerVideoWidgetControl::eventFilter(QObject *object, QEvent *e) { if (m_widget && object == m_widget) { if (e->type() == QEvent::ParentChange || e->type() == QEvent::Show) { WId newWId = m_widget->winId(); if (newWId != m_windowId) { m_windowId = newWId; // Even if we have created a winId at this point, other X applications // need to be aware of it. QApplication::syncX(); setOverlay(); } } if (e->type() == QEvent::Show) { // Setting these values ensures smooth resizing since it // will prevent the system from clearing the background m_widget->setAttribute(Qt::WA_NoSystemBackground, true); m_widget->setAttribute(Qt::WA_PaintOnScreen, true); } else if (e->type() == QEvent::Resize) { // This is a workaround for missing background repaints // when reducing window size windowExposed(); } } return false; }
void Hud::init(Tunnel* tunnel, Player* player) { link(tunnel, player); setOverlay(); if (tunnel->getMode() == GAME_TIMED) { healthArea->hide(); barHP->hide(); indicator->hide(); } else if (tunnel->getMode() == GAME_PROFICIENCY) { healthArea->show(); barHP->show(); indicator->show(); } else //if (tunnel->getMode() == GAME_NAVIGATION) { healthArea->hide(); barHP->hide(); indicator->hide(); } for(int i = 0; i < overlays.size(); ++i) overlays[i]->show(); }
BufferViewOverlayFilter::BufferViewOverlayFilter(QAbstractItemModel *model, BufferViewOverlay *overlay) : QSortFilterProxyModel(model), _overlay(0) { setOverlay(overlay); setSourceModel(model); setDynamicSortFilter(true); }
void X11Renderer::handleMediaNodeEvent(const MediaNodeEvent *event) { switch (event->type()) { case MediaNodeEvent::SourceChanged: setOverlay(); // We need to do this whenever the pipeline is reset break; // otherwise the videosink will open in its own window default: break; } }
bool QGstreamerVideoWidgetControl::processSyncMessage(const QGstreamerMessage &message) { GstMessage* gm = message.rawMessage(); if (gm && (GST_MESSAGE_TYPE(gm) == GST_MESSAGE_ELEMENT) && gst_structure_has_name(gm->structure, "prepare-xwindow-id")) { setOverlay(); QMetaObject::invokeMethod(this, "updateNativeVideoSize", Qt::QueuedConnection); return true; } return false; }
X11Renderer::X11Renderer(VideoWidget *videoWidget) : AbstractRenderer(videoWidget) { m_renderWidget = new OverlayWidget(videoWidget, this); videoWidget->backend()->logMessage("Creating X11 overlay renderer"); QPalette palette; palette.setColor(QPalette::Background, Qt::black); m_videoWidget->setPalette(palette); m_videoWidget->setAutoFillBackground(true); m_renderWidget->setMouseTracking(true); m_videoSink = createVideoSink(); aspectRatioChanged(videoWidget->aspectRatio()); setOverlay(); }
bool X11Renderer::eventFilter(QEvent *e) { if (e->type() == QEvent::Show) { // Setting these values ensures smooth resizing since it // will prevent the system from clearing the background m_renderWidget->setAttribute(Qt::WA_NoSystemBackground, true); m_renderWidget->setAttribute(Qt::WA_PaintOnScreen, true); setOverlay(); } else if (e->type() == QEvent::Resize) { // This is a workaround for missing background repaints // when reducing window size m_renderWidget->setGeometry(m_videoWidget->calculateDrawFrameRect()); windowExposed(); } return false; }
bool QGstreamerVideoWidgetControl::eventFilter(QObject *object, QEvent *e) { if (m_widget && object == m_widget) { if (e->type() == QEvent::ParentChange || e->type() == QEvent::Show) { WId newWId = m_widget->winId(); if (newWId != m_windowId) { m_windowId = newWId; setOverlay(); } } if (e->type() == QEvent::Show) { // Setting these values ensures smooth resizing since it // will prevent the system from clearing the background m_widget->setAttribute(Qt::WA_NoSystemBackground, true); } else if (e->type() == QEvent::Resize) { // This is a workaround for missing background repaints // when reducing window size windowExposed(); } } return false; }
void HudStage::update(float elapsed) { std::string GUIToggleNumber = "General/GUIToggleTextNumber"; toggle1TextArt->setMaterialName(GUIToggleNumber + Util::toStringInt(tunnel->getNBack() % 10)); toggle2TextArt->setMaterialName(GUIToggleNumber + Util::toStringInt(Util::clamp((tunnel->getNBack() - 1) % 10, 0, tunnel->getNBack()))); toggle3TextArt->setMaterialName(GUIToggleNumber + Util::toStringInt(Util::clamp((tunnel->getNBack() - 2) % 10, 0, tunnel->getNBack()))); // toggle4 is always n-back 0 if (!tunnel->needsCleaning()) resumeButtonBackground->setMaterialName("General/ResumeButtonRound"); else resumeButtonBackground->setMaterialName("General/ResumeButtonRoundGRAY"); LevelSet* levels = player->getLevels(); int levelRow = player->getLevelRequestRow(); int levelCol = player->getLevelRequestCol(); int level = levels->getLevelNo(levelRow, levelCol); if (player->isLevelAvailable(level + 1)) nextButtonBackground->setMaterialName("General/NextButtonRound"); else nextButtonBackground->setMaterialName("General/NextButtonRoundGRAY"); if( player->winFlag ) { setOverlay(3, true); tunnel->addToTimePenalty(2.0f); float timeLeft = tunnel->getStageTime() - tunnel->getTotalElapsed() - tunnel->getTimePenalty(); if( timeLeft < 0.0f && timeLeft > -1.0f) player->setScore(player->getScore()+100.0f); else if( timeLeft > 0.0f ) player->setScore(player->getScore()+200.0f); label2->setColour(ColourValue(1.0,1.0,0.0)); label5->setColour(ColourValue(1.0,1.0,0.0)); label2->setCaption(Util::toStringInt(timeLeft)); endTallyTimeLabel->setCaption("Time " + Util::toStringInt(timeLeft)); label5->setCaption(Util::toStringInt(player->getScore())); endTallyScoreLabel->setCaption(Util::toStringInt(player->getScore()) + " Score"); if( timeLeft <= 0.0f ) { label2->setCaption("0"); endTallyTimeLabel->setCaption("Time 0"); tunnel->setCleaning(true); player->winFlag = false; } return; } if( tunnel->isDone() ) return; float timeLeft = fmax(tunnel->getStageTime() - tunnel->getTotalElapsed() - tunnel->getTimePenalty(), 0.0f); label1->setCaption(globals.messageBig); Ogre::ColourValue fontColor = timeLeft <= 0.0 ? ColourValue(1.0, 0.0, 0.0) : ColourValue(1.0, 1.0, 1.0); label2->setColour(fontColor); label2->setCaption(Util::toStringInt(timeLeft)); if (tunnel->getMode() == STAGE_MODE_RECESS) label3->setCaption(Util::toStringInt(tunnel->getPercentComplete() * 100) + "%"); else label3->setCaption(""); label4->setCaption(Util::toStringInt(player->getBaseSpeed())); if (player->hasTriggeredStartup()) { speedSlider->setBallDestination(player->getBaseSpeed()); speedSlider->update(elapsed); } speedSlider->adjust(); label5->setCaption(Util::toStringInt(player->getScore())); label6->setCaption(globals.message); label7->setCaption(""); if( player->isPowerUpActive("TimeWarp") ) { TimeWarp* t = (TimeWarp*)player->getPowerUpPtr("TimeWarp"); if( t->zoomIn == 0 ) { setOverlay(2, false); timeWarpLabel->setCharHeight(0.05 * FONT_SZ_MULT); timeWarpContainer->setPosition(0.50, 0.15); } else if( t->zoomIn == 1 ) { setOverlay(2, true); timeWarpLabel->setCharHeight(timeWarpLabel->getCharHeight()-0.0005 * FONT_SZ_MULT); //timeWarpContainer->setPosition(timeWarpContainer->getLeft()+0.001 * FONT_SZ_MULT, timeWarpContainer->getTop()+0.0005 * FONT_SZ_MULT); } else { setOverlay(2, true); label2->setColour(ColourValue(1.0,1.0,0.0)); label2->setCharHeight(0.030 * FONT_SZ_MULT); } std::string val; if( t->currentTimeVal < 10 ) val = " "+Util::toStringInt(t->currentTimeVal); else val = Util::toStringInt(t->currentTimeVal); timeWarpLabel->setCaption("+" + val + " Seconds"); } else { setOverlay(2, false); label2->setColour(ColourValue(1.0,1.0,1.0)); label2->setCharHeight(0.025 * FONT_SZ_MULT); } // Set Progress Bar indicator position for the appropriate mode float barWidth = barHP->getWidth(); if (tunnel->getMode() == STAGE_MODE_PROFICIENCY) { float HPRange = globals.HPPositiveLimit - globals.HPNegativeLimit + 1; //indicator->setPosition(barHP->getLeft() + barWidth * player->getProgress(), indicator->getTop()); indicator->setPosition(barHP->getLeft() + barWidth * (player->getHP() - globals.HPNegativeLimit) / HPRange, indicator->getTop()); } switch (player->getToggleBack()) { case 0: toggleIndicator->setPosition(0.897, 0.31); break; case 1: toggleIndicator->setPosition(0.897, 0.43); break; case 2: toggleIndicator->setPosition(0.897, 0.55); break; case 3: toggleIndicator->setPosition(0.897, 0.67); break; } if (player->isPowerUpAvailable("TractorBeam")) buttons[BUTTON_POWERUP1].backgroundRef->setMaterialName("General/GUIPowerupButton2"); else buttons[BUTTON_POWERUP1].backgroundRef->setMaterialName("General/GUIPowerupButtonBlank"); if (player->isPowerUpAvailable("Shields")) buttons[BUTTON_POWERUP2].backgroundRef->setMaterialName("General/GUIPowerupButton0"); else buttons[BUTTON_POWERUP2].backgroundRef->setMaterialName("General/GUIPowerupButtonBlank"); if (player->isPowerUpAvailable("TimeWarp")) buttons[BUTTON_POWERUP3].backgroundRef->setMaterialName("General/GUIPowerupButton1"); else buttons[BUTTON_POWERUP3].backgroundRef->setMaterialName("General/GUIPowerupButtonBlank"); std::vector<CollectionCriteria> criterias = tunnel->getCollectionCriteria(); for (int i = 0; i < collectionBar.size(); ++i) { if (i < criterias.size()) { std::string scoreName = "General/GUICollection"; // For togglebacks //if (criterias[i].nback <= 0) // scoreName += Util::toStringInt(0); //else // scoreName += Util::toStringInt(Util::clamp(3 - (tunnel->getNBack() - criterias[i].nback), 0, 3)); // For just a single n-back and task switch (tunnel->getPhase()) { case 'A': scoreName += "0"; break; case 'B': scoreName += "1"; break; case 'C': scoreName += "2"; break; case 'D': scoreName += "3"; break; default: scoreName += "0"; break; } if (criterias[i].collected) scoreName += "Filled"; else scoreName += "Blank"; collectionBar[i]->setMaterialName(scoreName); } else { collectionBar[i]->setMaterialName("General/GUICollectionGreyed"); } } }
void BufferViewOverlayFilter::overlayDestroyed() { setOverlay(0); }
// set the ISurface that the preview will use status_t CameraService::Client::setPreviewDisplay(const sp<ISurface>& surface) { LOG1("setPreviewDisplay(%p) (pid %d)", surface.get(), getCallingPid()); Mutex::Autolock lock(mLock); status_t result = checkPidAndHardware(); if (result != NO_ERROR) return result; result = NO_ERROR; // return if no change in surface. // asBinder() is safe on NULL (returns NULL) if (surface->asBinder() == mSurface->asBinder()) { return result; } if (mSurface != 0) { LOG1("clearing old preview surface %p", mSurface.get()); if (mUseOverlay) { // Force the destruction of any previous overlay sp<Overlay> dummy; mHardware->setOverlay(dummy); mOverlayRef = 0; } else { mSurface->unregisterBuffers(); } } mSurface = surface; mOverlayRef = 0; // If preview has been already started, set overlay or register preview // buffers now. #ifdef USE_OVERLAY_FORMAT_YCbCr_420_SP if (mHardware->previewEnabled() || mUseOverlay) { #else if (mHardware->previewEnabled()) { #endif if (mUseOverlay) { #ifdef USE_OVERLAY_FORMAT_YCbCr_420_SP if (mSurface != NULL) { #endif result = setOverlay(); #ifdef USE_OVERLAY_FORMAT_YCbCr_420_SP } #endif } else if (mSurface != 0) { result = registerPreviewBuffers(); } } return result; } status_t CameraService::Client::registerPreviewBuffers() { int w, h; CameraParameters params(mHardware->getParameters()); params.getPreviewSize(&w, &h); //for 720p recording , preview can be 800X448 if(w == preview_sizes[0].width && h== preview_sizes[0].height){ LOGD("registerpreviewbufs :changing dimensions to 768X432 for 720p recording."); w = preview_sizes[1].width; h = preview_sizes[1].height; } // FIXME: don't use a hardcoded format here. ISurface::BufferHeap buffers(w, h, w, h, HAL_PIXEL_FORMAT_YCrCb_420_SP, mOrientation, 0, mHardware->getPreviewHeap()); status_t result = mSurface->registerBuffers(buffers); if (result != NO_ERROR) { LOGE("registerBuffers failed with status %d", result); } return result; } status_t CameraService::Client::setOverlay() { int w, h; CameraParameters params(mHardware->getParameters()); params.getPreviewSize(&w, &h); //for 720p recording , preview can be 800X448 if(w == preview_sizes[0].width && h==preview_sizes[0].height){ LOGD("Changing overlay dimensions to 768X432 for 720p recording."); w = preview_sizes[1].width; h = preview_sizes[1].height; } if (w != mOverlayW || h != mOverlayH || mOrientationChanged) { // Force the destruction of any previous overlay sp<Overlay> dummy; mHardware->setOverlay(dummy); mOverlayRef = 0; #ifdef USE_OVERLAY_FORMAT_YCbCr_420_SP if (mOverlay != NULL) { mOverlay->destroy(); } #endif mOrientationChanged = false; } status_t result = NO_ERROR; if (mSurface == 0) { result = mHardware->setOverlay(NULL); } else { if (mOverlayRef == 0) { // FIXME: // Surfaceflinger may hold onto the previous overlay reference for some // time after we try to destroy it. retry a few times. In the future, we // should make the destroy call block, or possibly specify that we can // wait in the createOverlay call if the previous overlay is in the // process of being destroyed. for (int retry = 0; retry < 50; ++retry) { mOverlayRef = mSurface->createOverlay(w, h, #ifdef USE_OVERLAY_FORMAT_YCbCr_420_SP HAL_PIXEL_FORMAT_YCbCr_420_SP, #else OVERLAY_FORMAT_DEFAULT, #endif mOrientation); if (mOverlayRef != 0) break; LOGW("Overlay create failed - retrying"); usleep(20000); } if (mOverlayRef == 0) { LOGE("Overlay Creation Failed!"); return -EINVAL; } #ifdef USE_OVERLAY_FORMAT_YCbCr_420_SP mOverlay = new Overlay(mOverlayRef); result = mHardware->setOverlay(mOverlay); #else result = mHardware->setOverlay(new Overlay(mOverlayRef)); #endif } } if (result != NO_ERROR) { LOGE("mHardware->setOverlay() failed with status %d\n", result); return result; } mOverlayW = w; mOverlayH = h; return result; } // set the preview callback flag to affect how the received frames from // preview are handled. void CameraService::Client::setPreviewCallbackFlag(int callback_flag) { LOG1("setPreviewCallbackFlag(%d) (pid %d)", callback_flag, getCallingPid()); Mutex::Autolock lock(mLock); if (checkPidAndHardware() != NO_ERROR) return; mPreviewCallbackFlag = callback_flag; // If we don't use overlay, we always need the preview frame for display. // If we do use overlay, we only need the preview frame if the user // wants the data. if (mUseOverlay) { if(mPreviewCallbackFlag & FRAME_CALLBACK_FLAG_ENABLE_MASK) { enableMsgType(CAMERA_MSG_PREVIEW_FRAME); } else { disableMsgType(CAMERA_MSG_PREVIEW_FRAME); } } }
void QGstreamerVideoWidgetControl::precessNewStream() { setOverlay(); QMetaObject::invokeMethod(this, "updateNativeVideoSize", Qt::QueuedConnection); }