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