#include "linetestpane.h"
#ifdef LINETEST
#include "xsheetdragtool.h"
#include "toutputproperties.h"
#include "tapp.h"
#include "toutputproperties.h"
#include "toonz/tcolumnhandle.h"
#include "toonz/txshlevelhandle.h"
#include "toonz/toonzscene.h"
#include "toonz/sceneproperties.h"
#include <QThread>
#include <QStackedWidget>
using namespace DVGui;
//=============================================================================
// MixAudioThread
//-----------------------------------------------------------------------------
MixAudioThread::MixAudioThread(QObject *parent)
: QThread(parent), m_abort(false), m_restart(false) {}
//-----------------------------------------------------------------------------
MixAudioThread::~MixAudioThread() {
m_mutex.lock();
m_abort = true;
m_condition.wakeOne();
m_mutex.unlock();
wait();
}
//-----------------------------------------------------------------------------
void MixAudioThread::run() {
forever {
m_mutex.lock();
int from = this->m_from;
int to = this->m_to;
m_mutex.unlock();
if (m_abort) return;
TXsheet::SoundProperties *prop = new TXsheet::SoundProperties();
prop->m_fromFrame = from;
prop->m_toFrame = to;
m_computedBuffer =
TApp::instance()->getCurrentXsheet()->getXsheet()->makeSound(prop);
m_buffer = TSoundTrackP();
if (m_computedBuffer) m_buffer = m_computedBuffer->clone();
if (!m_restart && m_buffer) emit computedBuffer();
m_mutex.lock();
if (!m_restart) m_condition.wait(&m_mutex);
m_restart = false;
m_mutex.unlock();
}
}
//-----------------------------------------------------------------------------
void MixAudioThread::computeBuffer(int fromFrame, int toFrame) {
QMutexLocker locker(&m_mutex);
this->m_from = fromFrame;
this->m_to = toFrame;
if (!isRunning()) {
start(QThread::NormalPriority);
} else {
m_restart = true;
m_condition.wakeOne();
}
}
//=============================================================================
// LineTestPane
//-----------------------------------------------------------------------------
LineTestPane::LineTestPane(QWidget *parent, Qt::WFlags flags)
: TPanel(parent)
, m_flipConsole(0)
, m_keyFrameButton(0)
, m_mainTrack(0)
, m_startTrack(0)
, m_player(0)
, m_trackStartFrame(0)
, m_startPlayRange(-1)
, m_endPlayRange(0)
, m_bufferSize(0)
, m_nextBufferSize(0) {
bool ret = true;
QFrame *hbox = new QFrame(this);
hbox->setFrameStyle(QFrame::StyledPanel);
hbox->setObjectName("OnePixelMarginFrame");
QVBoxLayout *mainLayout = new QVBoxLayout(hbox);
mainLayout->setMargin(0);
mainLayout->setSpacing(0);
// Viewer
m_stackedWidget = new QStackedWidget(this);
m_sceneViewer = new SceneViewer(this);
m_stackedWidget->addWidget(m_sceneViewer);
m_lineTestViewer = new LineTestViewer(this);
m_stackedWidget->addWidget(m_lineTestViewer);
mainLayout->addWidget(m_stackedWidget, Qt::AlignCenter);
TApp *app = TApp::instance();
m_keyFrameButton = new ViewerKeyframeNavigator(0, app->getCurrentFrame());
m_keyFrameButton->setObjectHandle(app->getCurrentObject());
m_keyFrameButton->setXsheetHandle(app->getCurrentXsheet());
int buttons = FlipConsole::cFullConsole;
buttons &= (~FlipConsole::eSound);
buttons &= (~FlipConsole::eCheckBg);
buttons &= (~FlipConsole::eWhiteBg);
buttons &= (~FlipConsole::eBlackBg);
buttons &= (~FlipConsole::eSave);
buttons &= (~FlipConsole::eCompare);
buttons &= (~FlipConsole::eSaveImg);
buttons &= (~FlipConsole::eHisto);
buttons &= (~FlipConsole::eCustomize);
buttons &= (~FlipConsole::eMatte);
buttons &= (~FlipConsole::eGRed);
buttons &= (~FlipConsole::eGGreen);
buttons &= (~FlipConsole::eGBlue);
buttons &= (~FlipConsole::eRed);
buttons &= (~FlipConsole::eGreen);
buttons &= (~FlipConsole::eBlue);
buttons &= (~FlipConsole::eDefineSubCamera);
buttons &= (~FlipConsole::eDefineLoadBox);
buttons &= (~FlipConsole::eUseLoadBox);
m_flipConsole = new FlipConsole(mainLayout, buttons, false, m_keyFrameButton,
"SceneViewerConsole");
ret = ret && connect(m_sceneViewer, SIGNAL(onZoomChanged()),
SLOT(changeWindowTitle()));
ret = ret && connect(m_lineTestViewer, SIGNAL(onZoomChanged()),
SLOT(changeWindowTitle()));
ret = connect(m_flipConsole,
SIGNAL(drawFrame(int, const ImagePainter::VisualSettings &)),
this,
SLOT(onDrawFrame(int, const ImagePainter::VisualSettings &)));
ret = ret && connect(m_flipConsole, SIGNAL(playStateChanged(bool)), this,
SLOT(onPlayStateChanged(bool)));
ret = ret &&
connect(m_flipConsole, SIGNAL(buttonPressed(FlipConsole::EGadget)),
m_lineTestViewer, SLOT(onButtonPressed(FlipConsole::EGadget)));
ret = ret &&
connect(m_flipConsole, SIGNAL(buttonPressed(FlipConsole::EGadget)),
m_sceneViewer, SLOT(onButtonPressed(FlipConsole::EGadget)));
ret = ret && connect(m_flipConsole, SIGNAL(sliderReleased()), this,
SLOT(onFlipSliderReleased()));
m_flipConsole->setFrameRate(app->getCurrentScene()
->getScene()
->getProperties()
->getOutputProperties()
->getFrameRate());
hbox->setLayout(mainLayout);
setWidget(hbox);
initializeTitleBar(getTitleBar());
ret = ret && connect(&m_mixAudioThread, SIGNAL(computedBuffer()), this,
SLOT(onComputedBuffer()), Qt::DirectConnection);
ret = ret && connect(app->getCurrentScene(), SIGNAL(sceneSwitched()), this,
SLOT(onSceneSwitched()));
assert(ret);
setCurrentViewType(0);
}
//-----------------------------------------------------------------------------
LineTestPane::~LineTestPane() {}
//-----------------------------------------------------------------------------
void LineTestPane::showEvent(QShowEvent *) {
TApp *app = TApp::instance();
TFrameHandle *frameHandle = app->getCurrentFrame();
TSceneHandle *sceneHandle = app->getCurrentScene();
TXshLevelHandle *levelHandle = app->getCurrentLevel();
TObjectHandle *objectHandle = app->getCurrentObject();
TXsheetHandle *xshHandle = app->getCurrentXsheet();
updateFrameRange();
bool ret = true;
ret = ret && connect(xshHandle, SIGNAL(xsheetChanged()), this,
SLOT(onSceneChanged()));
ret = ret && connect(sceneHandle, SIGNAL(sceneChanged()), this,
SLOT(onSceneChanged()));
ret = ret && connect(sceneHandle, SIGNAL(nameSceneChanged()), this,
SLOT(changeWindowTitle()));
ret = ret && connect(levelHandle, SIGNAL(xshLevelSwitched(TXshLevel *)), this,
SLOT(onXshLevelSwitched(TXshLevel *)));
ret = ret && connect(levelHandle, SIGNAL(xshLevelChanged()), this,
SLOT(changeWindowTitle()));
ret = ret && connect(levelHandle, SIGNAL(xshLevelTitleChanged()), this,
SLOT(changeWindowTitle()));
ret = ret && connect(levelHandle, SIGNAL(xshLevelChanged()), this,
SLOT(updateFrameRange()));
ret = ret && connect(frameHandle, SIGNAL(frameSwitched()), this,
SLOT(changeWindowTitle()));
ret = ret && connect(frameHandle, SIGNAL(frameSwitched()), this,
SLOT(onFrameSwitched()));
ret = ret && connect(frameHandle, SIGNAL(frameTypeChanged()), this,
SLOT(onFrameTypeChanged()));
assert(ret);
// Aggiorno FPS al valore definito nel viewer corrente.
m_flipConsole->setActive(true);
}
//-----------------------------------------------------------------------------
void LineTestPane::hideEvent(QHideEvent *) {
TApp *app = TApp::instance();
TFrameHandle *frameHandle = app->getCurrentFrame();
TSceneHandle *sceneHandle = app->getCurrentScene();
TXshLevelHandle *levelHandle = app->getCurrentLevel();
TObjectHandle *objectHandle = app->getCurrentObject();
TXsheetHandle *xshHandle = app->getCurrentXsheet();
disconnect(xshHandle, SIGNAL(xsheetChanged()), this, SLOT(onSceneChanged()));
disconnect(sceneHandle, SIGNAL(sceneChanged()), this, SLOT(onSceneChanged()));
disconnect(sceneHandle, SIGNAL(nameSceneChanged()), this,
SLOT(changeWindowTitle()));
disconnect(levelHandle, SIGNAL(xshLevelSwitched(TXshLevel *)), this,
SLOT(onXshLevelSwitched(TXshLevel *)));
disconnect(levelHandle, SIGNAL(xshLevelChanged()), this,
SLOT(changeWindowTitle()));
disconnect(levelHandle, SIGNAL(xshLevelTitleChanged()), this,
SLOT(changeWindowTitle()));
disconnect(levelHandle, SIGNAL(xshLevelChanged()), this,
SLOT(updateFrameRange()));
disconnect(frameHandle, SIGNAL(frameSwitched()), this,
SLOT(changeWindowTitle()));
disconnect(frameHandle, SIGNAL(frameSwitched()), this,
SLOT(onFrameSwitched()));
disconnect(frameHandle, SIGNAL(frameTypeChanged()), this,
SLOT(onFrameTypeChanged()));
m_flipConsole->setActive(false);
}
//-----------------------------------------------------------------------------
int LineTestPane::computeBufferSize(int frame) {
int bufferSize = 0;
double time = 2.0;
ToonzScene *scene = TApp::instance()->getCurrentScene()->getScene();
TOutputProperties *outputSettings =
scene->getProperties()->getOutputProperties();
int frameRate = outputSettings->getFrameRate();
if (m_endPlayRange > m_startPlayRange) {
int range = m_endPlayRange - m_startPlayRange;
time = double(range) / double(frameRate);
int minuts = tround(time / 60.0);
if (minuts == 0) minuts = 1;
while (time > 2.0 * minuts) time = time * 0.5;
}
bufferSize = tfloor(frameRate * time) + 1;
// qDebug("BUFFER SIZE: %d", bufferSize);
if (frame + bufferSize > m_endPlayRange) {
bufferSize = m_endPlayRange - frame + 1;
// qDebug("\n BUFFER SIZE: %d \n", bufferSize);
}
return bufferSize;
}
//-----------------------------------------------------------------------------
void LineTestPane::computeBuffer(int frame) {
int startFrame = m_trackStartFrame + m_bufferSize;
if (startFrame >= m_endPlayRange) {
// qDebug("\n OPS \n");
return;
}
// qDebug("COMPUTE BUFFER SIZE AT FRAME: %d", startFrame);
m_nextBufferSize = computeBufferSize(startFrame);
// qDebug("start frame: %d, start next buffer size: %d", startFrame,
// m_nextBufferSize);
m_mixAudioThread.computeBuffer(startFrame, startFrame + m_nextBufferSize);
}
//-----------------------------------------------------------------------------
void LineTestPane::initSound() {
m_mainTrack = 0;
m_startTrack = 0;
TXsheet *xsh = TApp::instance()->getCurrentXsheet()->getXsheet();
TFrameHandle *frameHandle = TApp::instance()->getCurrentFrame();
m_trackStartFrame = frameHandle->getFrame();
m_startPlayRange = 0;
m_endPlayRange = frameHandle->getMaxFrameIndex();
int fromMarker, toMarker, step;
if (XsheetGUI::getPlayRange(fromMarker, toMarker, step)) {
m_startPlayRange = fromMarker;
m_endPlayRange = toMarker;
}
m_bufferSize = computeBufferSize(m_trackStartFrame);
// qDebug("initSound()");
// qDebug("m_startPlayRange: %d", m_startPlayRange);
// qDebug("m_endPlayRange: %d", m_endPlayRange);
// qDebug("start frame: %d, start bufferSize: %d", m_trackStartFrame,
// m_bufferSize);
if (xsh) {
if (!m_player) m_player = new TSoundOutputDevice();
// Compute the first seconds and then launch the thread to compute the next
// buffer
TXsheet::SoundProperties *prop = new TXsheet::SoundProperties();
prop->m_fromFrame = m_trackStartFrame;
prop->m_toFrame = m_trackStartFrame + m_bufferSize;
m_mainTrack = xsh->makeSound(prop);
if (m_trackStartFrame == m_startPlayRange) {
// qDebug("set start track");
m_startTrack = m_mainTrack;
m_startBufferSize = m_bufferSize;
} else // compute start track (it's necessary to avoid async in loop)
{
m_startBufferSize = computeBufferSize(m_startPlayRange);
TXsheet::SoundProperties *prop = new TXsheet::SoundProperties();
prop->m_fromFrame = m_startPlayRange;
prop->m_toFrame = m_startPlayRange + m_startBufferSize;
m_startTrack = xsh->makeSound(prop);
}
computeBuffer(m_trackStartFrame);
} else {
m_mainTrack = 0;
m_startTrack = 0;
}
}
//-----------------------------------------------------------------------------
void LineTestPane::playSound() {
if (m_player && m_mainTrack) {
try {
int currentFrame = TApp::instance()->getCurrentFrame()->getFrame();
double t0 = (double)(currentFrame - m_trackStartFrame) /
(double)(m_mainTrack->getSampleRate());
// Pay attention at don't call play everytime (there is a big leak
// otherwise !)
double trackDuration = m_mainTrack->getDuration();
// qDebug("trackDuration: %f", trackDuration);
if (m_mainTrack && trackDuration != 0)
if (trackDuration > t0) m_player->play(m_mainTrack, t0, trackDuration);
} catch (TSoundDeviceException &e) {
}
}
}
//-----------------------------------------------------------------------------
void LineTestPane::initializeTitleBar(TPanelTitleBar *titleBar) {
bool ret = true;
TPanelTitleBarButtonSet *viewModeButtonSet;
viewModeButtonSet = new TPanelTitleBarButtonSet();
int x = -100;
int iconWidth = 17;
TPanelTitleBarButton *button;
m_cameraStandButton = new TPanelTitleBarButton(
titleBar, ":Resources/standard.png", ":Resources/standard_over.png",
":Resources/standard_on.png");
m_cameraStandButton->setToolTip("Camera Stand View");
x += 18 + iconWidth;
titleBar->add(QPoint(x, 2), m_cameraStandButton);
m_cameraStandButton->setButtonSet(viewModeButtonSet, 0);
m_cameraStandButton->setPressed(true);
m_previewButton = new TPanelTitleBarButton(
titleBar, ":Resources/viewpreview.png", ":Resources/viewpreview_over.png",
":Resources/viewpreview_on.png");
m_previewButton->setToolTip(tr("Preview"));
x += 5 + iconWidth;
titleBar->add(QPoint(x, 2), m_previewButton);
m_previewButton->setButtonSet(viewModeButtonSet, 1);
ret = ret && connect(viewModeButtonSet, SIGNAL(selected(int)), this,
SLOT(setCurrentViewType(int)));
assert(ret);
}
//-----------------------------------------------------------------------------
void LineTestPane::onXshLevelSwitched(TXshLevel *) { changeWindowTitle(); }
//-----------------------------------------------------------------------------
void LineTestPane::changeWindowTitle() {
TApp *app = TApp::instance();
ToonzScene *scene = app->getCurrentScene()->getScene();
if (!scene) return;
int frame = app->getCurrentFrame()->getFrame();
QString name;
if (app->getCurrentFrame()->isEditingScene()) {
QString sceneName = QString::fromStdWString(scene->getSceneName());
if (sceneName.isEmpty()) sceneName = tr("Untitled");
if (app->getCurrentScene()->getDirtyFlag()) sceneName += QString("*");
name = tr("Scene: ") + sceneName;
if (frame >= 0)
name = name + tr(" :: Frame: ") + tr(toString(frame + 1).c_str());
int col = app->getCurrentColumn()->getColumnIndex();
if (col < 0) {
setWindowTitle(name);
return;
}
TXsheet *xsh = app->getCurrentXsheet()->getXsheet();
TXshCell cell = xsh->getCell(frame, col);
if (cell.isEmpty()) {
setWindowTitle(name);
return;
}
assert(cell.m_level.getPointer());
TFilePath fp(cell.m_level->getName());
QString imageName =
QString::fromStdWString(fp.withFrame(cell.m_frameId).getWideString());
name = name + tr(" :: Level: ") + imageName;
} else {
TXshLevel *level = app->getCurrentLevel()->getLevel();
if (level) {
TFilePath fp(level->getName());
QString imageName = QString::fromStdWString(
fp.withFrame(app->getCurrentFrame()->getFid()).getWideString());
name = name + tr("Level: ") + imageName;
}
}
if (m_stackedWidget->currentIndex() == 0) {
TAffine aff = m_sceneViewer->getViewMatrix() *
m_sceneViewer->getNormalZoomScale().inv();
name = name + " :: Zoom : " +
QString::number(tround(100.0 * sqrt(aff.det()))) + "%";
} else {
TAffine aff = m_lineTestViewer->getViewMatrix() *
m_lineTestViewer->getNormalZoomScale().inv();
name = name + " :: Zoom : " +
QString::number(tround(100.0 * sqrt(aff.det()))) + "%";
}
setWindowTitle(name);
}
//-----------------------------------------------------------------------------
void LineTestPane::updateFrameRange() {
TApp *app = TApp::instance();
TFrameHandle *fh = app->getCurrentFrame();
int frameIndex = fh->getFrameIndex();
int maxFrameIndex = fh->getMaxFrameIndex();
m_flipConsole->setFrameRange(1, maxFrameIndex + 1, 1, frameIndex + 1);
}
//-----------------------------------------------------------------------------
void LineTestPane::updateFrameMarkers() {
int fromIndex, toIndex, dummy;
XsheetGUI::getPlayRange(fromIndex, toIndex, dummy);
TFrameHandle *fh = TApp::instance()->getCurrentFrame();
if (fh->isEditingLevel()) {
fromIndex = 0;
toIndex = -1;
}
m_flipConsole->setMarkers(fromIndex, toIndex);
}
//-----------------------------------------------------------------------------
void LineTestPane::setCurrentViewType(int index) {
TFrameHandle *frameHandle = TApp::instance()->getCurrentFrame();
if (index == 1 && frameHandle->getFrameType() == TFrameHandle::LevelFrame)
frameHandle->setFrame(frameHandle->getFrameIndex());
m_stackedWidget->setCurrentIndex(index);
if (index == 0) {
CommandManager::instance()->enable("MI_ViewTable", true);
CommandManager::instance()->enable("MI_FieldGuide", true);
CommandManager::instance()->enable("MI_SafeArea", true);
CommandManager::instance()->enable("MI_RasterizePli", true);
CommandManager::instance()->enable("MI_ViewColorcard", true);
CommandManager::instance()->enable("MI_ViewCamera", true);
m_flipConsole->enableButton(FlipConsole::eFilledRaster, false, false);
} else {
CommandManager::instance()->enable("MI_ViewTable", false);
CommandManager::instance()->enable("MI_FieldGuide", false);
CommandManager::instance()->enable("MI_SafeArea", false);
CommandManager::instance()->enable("MI_RasterizePli", false);
CommandManager::instance()->enable("MI_ViewColorcard", false);
CommandManager::instance()->enable("MI_ViewCamera", false);
if (m_flipConsole)
m_flipConsole->enableButton(FlipConsole::eFilledRaster, true, false);
}
changeWindowTitle();
}
//-----------------------------------------------------------------------------
void LineTestPane::onDrawFrame(int frame,
const ImagePainter::VisualSettings &settings) {
TApp *app = TApp::instance();
TFrameHandle *frameHandle = app->getCurrentFrame();
assert(frame >= 0);
if (frame != frameHandle->getFrameIndex() + 1) {
int oldFrame = frameHandle->getFrame();
frameHandle->setCurrentFrame(frame);
if (!m_mainTrack && !frameHandle->isPlaying() &&
!frameHandle->isEditingLevel() && oldFrame != frameHandle->getFrame())
frameHandle->scrubXsheet(
frame - 1, frame - 1,
TApp::instance()->getCurrentXsheet()->getXsheet());
// qDebug("frame: %d",frame);
if (m_mainTrack && frameHandle->isPlaying() &&
!frameHandle->isEditingLevel()) {
if (frame == m_startPlayRange + 1) {
if (m_startTrack) {
m_mainTrack = m_startTrack;
m_trackStartFrame = frame;
// qDebug("1. play at m_trackStartFrame: %d", m_trackStartFrame);
playSound();
m_bufferSize = m_startBufferSize;
computeBuffer(frame);
} else {
// qDebug("2. play at m_trackStartFrame: %d", m_trackStartFrame);
assert(0);
initSound();
}
}
int frameElapsed = frame - m_trackStartFrame - 1;
if (frameElapsed >= (m_bufferSize)) {
if (m_buffer) m_mainTrack = m_buffer->clone();
m_trackStartFrame = frame;
// qDebug("PLAY SOUND AT FRAME: %d", frame);
playSound();
// qDebug("3. play at m_trackStartFrame: %d", m_trackStartFrame);
m_bufferSize = m_nextBufferSize;
computeBuffer(frame);
}
}
}
}
//-----------------------------------------------------------------------------
void LineTestPane::onComputedBuffer() {
m_buffer = TSoundTrackP();
m_buffer = m_mixAudioThread.getBuffer();
}
//-----------------------------------------------------------------------------
void LineTestPane::onPlayStateChanged(bool value) {
TFrameHandle *frameHandle = TApp::instance()->getCurrentFrame();
bool wasPlaying = frameHandle->isPlaying();
frameHandle->setPlaying(value);
if (value && !frameHandle->isEditingLevel()) {
if (m_player && wasPlaying) {
m_player->close();
if (m_mainTrack) m_mainTrack = TSoundTrackP();
if (m_startTrack) m_startTrack = TSoundTrackP();
if (m_buffer) m_buffer = TSoundTrackP();
}
initSound();
playSound();
} else if (m_player) {
m_player->close();
if (m_mainTrack) m_mainTrack = TSoundTrackP();
if (m_startTrack) m_startTrack = TSoundTrackP();
if (m_buffer) m_buffer = TSoundTrackP();
}
}
//-----------------------------------------------------------------------------
void LineTestPane::onSceneChanged() {
TApp *app = TApp::instance();
ToonzScene *scene = app->getCurrentScene()->getScene();
assert(scene);
m_flipConsole->updateCurrentFPS(
scene->getProperties()->getOutputProperties()->getFrameRate());
updateFrameRange();
updateFrameMarkers();
changeWindowTitle();
int frameIndex = app->getCurrentFrame()->getFrameIndex();
if (m_keyFrameButton->getCurrentFrame() != frameIndex)
m_keyFrameButton->setCurrentFrame(frameIndex);
}
//-----------------------------------------------------------------------------
void LineTestPane::onSceneSwitched() {
if (!isHidden()) onSceneChanged();
m_flipConsole->setFrameRate(TApp::instance()
->getCurrentScene()
->getScene()
->getProperties()
->getOutputProperties()
->getFrameRate());
}
//-----------------------------------------------------------------------------
void LineTestPane::onFrameSwitched() {
int frameIndex = TApp::instance()->getCurrentFrame()->getFrameIndex();
m_flipConsole->setCurrentFrame(frameIndex + 1);
if (m_keyFrameButton->getCurrentFrame() != frameIndex)
m_keyFrameButton->setCurrentFrame(frameIndex);
}
//-----------------------------------------------------------------------------
void LineTestPane::onFrameTypeChanged() {
if (TApp::instance()->getCurrentFrame()->getFrameType() ==
TFrameHandle::LevelFrame) {
if (m_stackedWidget->currentIndex() != 0) {
m_cameraStandButton->setPressed(true);
m_previewButton->setPressed(false);
setCurrentViewType(0);
}
}
updateFrameRange();
updateFrameMarkers();
}
//-----------------------------------------------------------------------------
void LineTestPane::onFlipSliderReleased() {
TApp::instance()->getCurrentXsheet()->getXsheet()->stopScrub();
}
#endif