void QSGWindowsRenderLoop::exposureChanged(QQuickWindow *window)
{
if (windowData(window) == 0)
return;
if (window->isExposed() && window->isVisible()) {
// Stop non-visual animation timer as we now have a window rendering
if (m_animationTimer && anyoneShowing()) {
RLDEBUG(" - stopping non-visual animation timer");
killTimer(m_animationTimer);
m_animationTimer = 0;
}
RLDEBUG("exposureChanged - exposed");
WindowData *wd = windowData(window);
wd->pendingUpdate = true;
// If we have a pending timer and we get an expose, we need to stop it.
// Otherwise we get two frames and two animation ticks in the same time-interval.
if (m_updateTimer) {
RLDEBUG(" - killing pending update timer");
killTimer(m_updateTimer);
m_updateTimer = 0;
}
render();
} else {
handleObscurity();
}
}
void QSGWindowsRenderLoop::show(QQuickWindow *window)
{
RLDEBUG("show");
if (windowData(window) != 0)
return;
// This happens before the platform window is shown, but after
// it is created. Creating the GL context takes a lot of time
// (hundreds of milliseconds) and will prevent us from rendering
// the first frame in time for the initial show on screen.
// By preparing the GL context here, it is feasible (if the app
// is quick enough) to have a perfect first frame.
if (!m_gl) {
QSG_RENDER_TIMING_SAMPLE(time_start);
RLDEBUG(" - creating GL context");
m_gl = new QOpenGLContext();
m_gl->setFormat(window->requestedFormat());
if (QSGContext::sharedOpenGLContext())
m_gl->setShareContext(QSGContext::sharedOpenGLContext());
bool created = m_gl->create();
if (!created) {
qWarning("QtQuick: failed to create OpenGL context");
delete m_gl;
m_gl = 0;
return;
}
QSG_RENDER_TIMING_SAMPLE(time_created);
RLDEBUG(" - making current");
bool current = m_gl->makeCurrent(window);
RLDEBUG(" - initializing SG");
QSG_RENDER_TIMING_SAMPLE(time_current);
if (current)
m_rc->initialize(m_gl);
#ifndef QSG_NO_RENDER_TIMING
if (qsg_render_timing) {
qDebug("WindowsRenderLoop: GL=%d ms, makeCurrent=%d ms, SG=%d ms",
int((time_created - time_start)/1000000),
int((time_current - time_created)/1000000),
int((qsg_render_timer.nsecsElapsed() - time_current)/1000000));
}
if (QQmlProfilerService::enabled) {
QQmlProfilerService::sceneGraphFrame(
QQmlProfilerService::SceneGraphWindowsRenderShow,
time_created - time_start,
time_current - time_created,
qsg_render_timer.nsecsElapsed() - time_current);
}
#endif
}
WindowData data;
data.window = window;
data.pendingUpdate = false;
m_windows << data;
RLDEBUG(" - done with show");
}
bool FastFourierTransform::computeFFT(double *data){
if( !initialized || data == NULL ){
return false;
}
//Window the input data
if( !windowData(data) ){
return false;
}
//Perform the FFT
realFFT(data, fftReal, fftImag);
averagePower = 0;
for(unsigned int i = 0; i<windowSize/2; i++){
if( computeMagnitude ){
power[i] = fftReal[i]*fftReal[i] + fftImag[i]*fftImag[i];
averagePower += power[i];
magnitude[i] = 2.0*sqrt( power[i] );
}
if( computePhase ){
phase[i] = atan2(fftImag[i],fftReal[i]);
}
}
//Compute the average power
averagePower = averagePower / (double)(windowSize/2);
return true;
}
void PICadillo35t::flushCacheBlock() {
if (_cacheState != cacheDirty) {
return;
}
openWindow(_cacheX, _cacheY, 1 << cacheDimension, 1 << cacheDimension);
windowData(_cacheData, ((1 << cacheDimension) * (1 << cacheDimension)));
closeWindow();
_cacheState = cacheClean;
}
void QSGWindowsRenderLoop::maybeUpdate(QQuickWindow *window)
{
RLDEBUG("maybeUpdate");
WindowData *wd = windowData(window);
if (!wd || !anyoneShowing())
return;
wd->pendingUpdate = true;
maybePostUpdateTimer();
}
void QSGWindowsRenderLoop::show(QQuickWindow *window)
{
RLDEBUG("show");
if (windowData(window) != 0)
return;
// This happens before the platform window is shown, but after
// it is created. Creating the GL context takes a lot of time
// (hundreds of milliseconds) and will prevent us from rendering
// the first frame in time for the initial show on screen.
// By preparing the GL context here, it is feasible (if the app
// is quick enough) to have a perfect first frame.
if (!m_gl) {
RLDEBUG(" - creating GL context");
m_gl = new QOpenGLContext();
m_gl->setFormat(window->requestedFormat());
m_gl->setScreen(window->screen());
if (qt_gl_global_share_context())
m_gl->setShareContext(qt_gl_global_share_context());
bool created = m_gl->create();
if (!created) {
const bool isEs = m_gl->isOpenGLES();
delete m_gl;
m_gl = 0;
handleContextCreationFailure(window, isEs);
return;
}
QQuickWindowPrivate::get(window)->fireOpenGLContextCreated(m_gl);
RLDEBUG(" - making current");
bool current = m_gl->makeCurrent(window);
RLDEBUG(" - initializing SG");
if (current)
m_rc->initialize(m_gl);
}
WindowData data;
data.window = window;
data.pendingUpdate = false;
m_windows << data;
RLDEBUG(" - done with show");
}
/*
* Render the contents of this window. First polish, then sync, render
* then finally swap.
*
* Note: This render function does not implement aborting
* the render call when sync step results in no scene graph changes,
* like the threaded renderer does.
*/
void QSGWindowsRenderLoop::renderWindow(QQuickWindow *window)
{
RLDEBUG("renderWindow");
QQuickWindowPrivate *d = QQuickWindowPrivate::get(window);
if (!d->isRenderable())
return;
if (!m_gl->makeCurrent(window)) {
// Check for context loss.
if (!m_gl->isValid()) {
d->cleanupNodesOnShutdown();
m_rc->invalidate();
if (m_gl->create() && m_gl->makeCurrent(window))
m_rc->initialize(m_gl);
else
return;
}
}
d->flushDelayedTouchEvent();
// Event delivery or processing has caused the window to stop rendering.
if (!windowData(window))
return;
QSG_LOG_TIME_SAMPLE(time_start);
Q_QUICK_SG_PROFILE_START(QQuickProfiler::SceneGraphPolishFrame);
RLDEBUG(" - polishing");
d->polishItems();
QSG_LOG_TIME_SAMPLE(time_polished);
Q_QUICK_SG_PROFILE_SWITCH(QQuickProfiler::SceneGraphPolishFrame,
QQuickProfiler::SceneGraphRenderLoopFrame);
emit window->afterAnimating();
RLDEBUG(" - syncing");
d->syncSceneGraph();
QSG_RENDER_TIMING_SAMPLE(QQuickProfiler::SceneGraphRenderLoopFrame, time_synced);
RLDEBUG(" - rendering");
d->renderSceneGraph(window->size());
QSG_RENDER_TIMING_SAMPLE(QQuickProfiler::SceneGraphRenderLoopFrame, time_rendered);
RLDEBUG(" - swapping");
if (!d->customRenderStage || !d->customRenderStage->swap())
m_gl->swapBuffers(window);
QSG_RENDER_TIMING_SAMPLE(QQuickProfiler::SceneGraphRenderLoopFrame, time_swapped);
RLDEBUG(" - frameDone");
d->fireFrameSwapped();
qCDebug(QSG_LOG_TIME_RENDERLOOP()).nospace()
<< "Frame rendered with 'windows' renderloop in: " << (time_swapped - time_start) / 1000000 << "ms"
<< ", polish=" << (time_polished - time_start) / 1000000
<< ", sync=" << (time_synced - time_polished) / 1000000
<< ", render=" << (time_rendered - time_synced) / 1000000
<< ", swap=" << (time_swapped - time_rendered) / 1000000
<< " - " << window;
Q_QUICK_SG_PROFILE_REPORT(QQuickProfiler::SceneGraphRenderLoopFrame);
}