#include "toonz/txshsoundcolumn.h"
#include "toonz/levelset.h"
#include "toonz/txsheet.h"
#include "toonz/toonzscene.h"
#include "toonz/tproject.h"
#include "toonz/sceneproperties.h"
#include "toonz/txshsoundlevel.h"
#include "tstream.h"
#include "toutputproperties.h"
#include "tsop.h"
#include "tconvert.h"
//=============================================================================
// ColumnLevel
//=============================================================================
class ColumnLevel
{
TXshSoundLevelP m_soundLevel;
/*!Offsets: in frames. Start offset is a positive number.*/
int m_startOffset;
/*!Offsets: in frames. End offset is a positive number(to subtract to..).*/
int m_endOffset;
//! Starting frame in the timeline
int m_startFrame;
//! frameRate
double m_fps;
public:
ColumnLevel(TXshSoundLevel *soundLevel = 0, int startFrame = -1, int startOffset = -1, int endOffset = -1, double fps = -1);
~ColumnLevel();
ColumnLevel *clone() const;
//! Overridden from TXshLevel
TXshSoundLevel *getSoundLevel() const { return m_soundLevel.getPointer(); }
void setSoundLevel(TXshSoundLevelP level) { m_soundLevel = level; }
void loadData(TIStream &is);
void saveData(TOStream &os);
void setStartOffset(int value);
int getStartOffset() const { return m_startOffset; }
void setEndOffset(int value);
int getEndOffset() const { return m_endOffset; }
void setOffsets(int startOffset, int endOffset);
//! Return the starting frame without offsets.
void setStartFrame(int frame) { m_startFrame = frame; }
int getStartFrame() const { return m_startFrame; }
//! Return the ending frame without offsets.
int getEndFrame() const;
//! Return frame count without offset.
int getFrameCount() const;
//! Return frame count with offset.
int getVisibleFrameCount() const;
//! Return start frame with offset.
int getVisibleStartFrame() const;
//! Return last frame with offset.
int getVisibleEndFrame() const;
//! Updates m_startOfset and m_endOffset.
void updateFrameRate(double newFrameRate);
void setFrameRate(double fps) { m_fps = fps; }
};
//=============================================================================
ColumnLevel::ColumnLevel(TXshSoundLevel *soundLevel, int startFrame, int startOffset, int endOffset, double fps)
: m_soundLevel(soundLevel), m_startOffset(startOffset), m_endOffset(endOffset), m_startFrame(startFrame), m_fps(fps)
{
}
//-----------------------------------------------------------------------------
ColumnLevel::~ColumnLevel()
{
}
//-----------------------------------------------------------------------------
ColumnLevel *ColumnLevel::clone() const
{
ColumnLevel *soundColumnLevel = new ColumnLevel();
soundColumnLevel->setSoundLevel(getSoundLevel());
soundColumnLevel->setStartFrame(m_startFrame);
soundColumnLevel->setStartOffset(m_startOffset);
soundColumnLevel->setEndOffset(m_endOffset);
soundColumnLevel->setFrameRate(m_fps);
return soundColumnLevel;
}
//-----------------------------------------------------------------------------
void ColumnLevel::loadData(TIStream &is)
{
string tagName;
is.openChild(tagName);
if (tagName == "SoundCells") {
TPersist *p = 0;
is >> m_startOffset >> m_endOffset >> m_startFrame >> p;
TXshSoundLevel *xshLevel = dynamic_cast<TXshSoundLevel *>(p);
if (xshLevel)
m_soundLevel = xshLevel;
}
is.closeChild();
}
//-----------------------------------------------------------------------------
void ColumnLevel::saveData(TOStream &os)
{
os.child("SoundCells") << getStartOffset() << getEndOffset() << getStartFrame() << m_soundLevel.getPointer();
}
//-----------------------------------------------------------------------------
void ColumnLevel::setStartOffset(int value)
{
if (!m_soundLevel)
return;
if (value < 0 || value > getFrameCount() - getEndOffset() - 1)
return;
m_startOffset = value;
}
//-----------------------------------------------------------------------------
void ColumnLevel::setEndOffset(int value)
{
if (!m_soundLevel)
return;
if (value < 0 || getStartFrame() + getFrameCount() - value < getStartFrame() + getStartOffset() + 1)
return;
m_endOffset = value;
}
//-----------------------------------------------------------------------------
void ColumnLevel::setOffsets(int startOffset, int endOffset)
{
assert(startOffset > 0 && endOffset > 0);
if (startOffset < 0 || startOffset > getFrameCount() - endOffset - 1)
return;
m_startOffset = startOffset;
if (endOffset < 0 || getStartFrame() + getFrameCount() - endOffset < getStartFrame() + getStartOffset() + 1)
return;
m_endOffset = endOffset;
}
//-----------------------------------------------------------------------------
int ColumnLevel::getEndFrame() const
{
if (!m_soundLevel)
return -1;
return getStartFrame() + getFrameCount() - 1;
}
//-----------------------------------------------------------------------------
int ColumnLevel::getFrameCount() const
{
if (!m_soundLevel)
return -1;
return m_soundLevel->getFrameCount();
}
//-----------------------------------------------------------------------------
int ColumnLevel::getVisibleFrameCount() const
{
if (!m_soundLevel)
return -1;
return getFrameCount() - getStartOffset() - getEndOffset();
}
//-----------------------------------------------------------------------------
int ColumnLevel::getVisibleStartFrame() const
{
if (!m_soundLevel)
return -1;
return getStartFrame() + getStartOffset();
}
//-----------------------------------------------------------------------------
int ColumnLevel::getVisibleEndFrame() const
{
if (!m_soundLevel)
return -1;
return getVisibleStartFrame() + getVisibleFrameCount() - 1;
}
//-----------------------------------------------------------------------------
void ColumnLevel::updateFrameRate(double newFrameRate)
{
if (m_fps == newFrameRate)
return;
double fact = (double)newFrameRate / m_fps;
m_startFrame = tround(m_startFrame * fact);
m_startOffset = tround(m_startOffset * fact);
m_endOffset = tround(m_endOffset * fact);
m_fps = newFrameRate;
}
//=============================================================================
namespace
{
//-----------------------------------------------------------------------------
bool lessThan(const ColumnLevel *s1, const ColumnLevel *s2)
{
return s1->getVisibleStartFrame() < s2->getVisibleStartFrame();
}
//-----------------------------------------------------------------------------
}
//=============================================================================
TXshSoundColumn::TXshSoundColumn()
: m_player(0), m_volume(0.4), m_currentPlaySoundTrack(0), m_isOldVersion(false)
{
m_timer.setInterval(500);
m_timer.setSingleShot(true);
m_timer.stop();
connect(&m_timer, SIGNAL(timeout()), this, SLOT(onTimerOut()));
}
//-----------------------------------------------------------------------------
TXshSoundColumn::~TXshSoundColumn()
{
clear();
if (m_timer.isActive()) {
m_timer.stop();
stop();
}
}
//-----------------------------------------------------------------------------
TXshColumn::ColumnType TXshSoundColumn::getColumnType() const
{
return eSoundType;
}
//-----------------------------------------------------------------------------
bool TXshSoundColumn::canSetCell(const TXshCell &cell) const
{
return cell.isEmpty() || cell.m_level->getSoundLevel() != 0;
}
//-----------------------------------------------------------------------------
TXshColumn *TXshSoundColumn::clone() const
{
TXshSoundColumn *column = new TXshSoundColumn();
column->setVolume(m_volume);
column->setXsheet(getXsheet());
int i;
for (i = 0; i < m_levels.size(); i++)
column->insertColumnLevel(m_levels.at(i)->clone(), i);
return column;
}
//-----------------------------------------------------------------------------
void TXshSoundColumn::assignLevels(const TXshSoundColumn *src)
{
//Svuoto la lista dei livelli
clear();
int r;
for (r = src->getFirstRow(); r <= src->getMaxFrame(); r++) {
int r0, r1;
if (!src->getLevelRange(r, r0, r1))
continue;
TXshCell cell = src->getCell(r);
if (cell.isEmpty())
continue;
TXshSoundLevel *soundLevel = cell.m_level->getSoundLevel();
assert(!!soundLevel);
int startOffset = cell.getFrameId().getNumber();
int startFrame = r - startOffset;
int endOffset = startFrame + soundLevel->getFrameCount() - r1 - 1;
ColumnLevel *l = new ColumnLevel(soundLevel, startFrame, startOffset, endOffset);
insertColumnLevel(l);
r = r1;
}
}
//-----------------------------------------------------------------------------
void TXshSoundColumn::loadData(TIStream &is)
{
VersionNumber tnzVersion = is.getVersion();
if (tnzVersion < VersionNumber(1, 17)) {
TFilePath path;
is >> path;
m_isOldVersion = true;
int offset = 0;
is >> offset;
is >> m_volume;
if (!is.eos()) {
int status;
is >> status;
setStatusWord(status);
}
TXshSoundLevelP level = new TXshSoundLevel(path.getWideName());
level->setPath(path);
ColumnLevel *l = new ColumnLevel(level.getPointer(), offset, 0, 0);
insertColumnLevel(l);
return;
}
is >> m_volume;
int levelCount = 0;
is >> levelCount;
int i;
for (i = 0; i < levelCount; i++) {
ColumnLevel *sl = new ColumnLevel();
sl->loadData(is);
insertColumnLevel(sl, i);
}
if (!is.eos()) {
int status;
is >> status;
setStatusWord(status);
}
}
//-----------------------------------------------------------------------------
void TXshSoundColumn::saveData(TOStream &os)
{
os << m_volume;
int levelsCount = m_levels.size();
os << levelsCount;
if (levelsCount == 0)
return;
int i;
for (i = 0; i < levelsCount; i++)
m_levels.at(i)->saveData(os);
os << getStatusWord();
}
//-----------------------------------------------------------------------------
int TXshSoundColumn::getRange(int &r0, int &r1) const
{
r0 = getFirstRow();
r1 = getMaxFrame();
return r1 - r0 + 1;
}
//-----------------------------------------------------------------------------
int TXshSoundColumn::getRowCount() const
{
return getMaxFrame() - getFirstRow();
}
//-----------------------------------------------------------------------------
int TXshSoundColumn::getMaxFrame() const
{
int levelsCount = m_levels.size();
if (levelsCount == 0)
return -1;
return m_levels.at(levelsCount - 1)->getVisibleEndFrame();
}
//-----------------------------------------------------------------------------
int TXshSoundColumn::getFirstRow() const
{
if (m_levels.size() == 0)
return -1;
return m_levels.at(0)->getVisibleStartFrame();
}
//-----------------------------------------------------------------------------
const TXshCell &TXshSoundColumn::getCell(int row) const
{
static TXshCell emptyCell;
ColumnLevel *l = getColumnLevelByFrame(row);
if (row < 0 || row < getFirstRow() || row > getMaxFrame()) {
if (l)
emptyCell.m_level = l->getSoundLevel();
return emptyCell;
}
if (!l)
return emptyCell;
TXshSoundLevel *soundLevel = l->getSoundLevel();
TXshCell *cell = new TXshCell(soundLevel, TFrameId(row - l->getStartFrame()));
// La nuova cella aggiunge un reference al TXshSoundLevel; poiche' le celle delle
// TXshSoundColumn non sono strutture persistenti ma sono strutture dinamiche
// (vengono ricreate ogni volta) devo occuparmi di fare il release altrimenti il
// TXshSoundLevel non viene mai buttato.
soundLevel->release();
return *cell;
}
//-----------------------------------------------------------------------------
bool TXshSoundColumn::isCellEmpty(int row) const
{
if (m_levels.empty())
return true;
ColumnLevel *l = getColumnLevelByFrame(row);
if (!l || !l->getSoundLevel())
return true;
return false;
}
//-----------------------------------------------------------------------------
//--- debug only
void TXshSoundColumn::checkColumn() const
{
#ifndef NDEBUG
int size = m_levels.size();
int i;
for (i = 0; i < size; i++) {
ColumnLevel *level = m_levels.at(i);
assert(level);
assert(level->getSoundLevel());
int start1 = level->getVisibleStartFrame();
int end1 = level->getVisibleEndFrame();
assert(start1 <= end1);
if (i < size - 1) {
ColumnLevel *nextLevel = m_levels.at(i + 1);
assert(nextLevel);
assert(nextLevel->getSoundLevel());
int start2 = nextLevel->getVisibleStartFrame();
int end2 = nextLevel->getVisibleEndFrame();
assert(start2 <= end2);
assert(end1 < start2);
}
}
#endif
}
//-----------------------------------------------------------------------------
void TXshSoundColumn::getCells(int row, int rowCount, TXshCell cells[])
{
// le celle da settare sono [ra, rb]
int ra = row;
int rb = row + rowCount - 1;
assert(ra <= rb);
TXshCell *dstCell = cells;
int r;
for (r = ra; r <= rb; r++)
*cells++ = getCell(r);
checkColumn();
}
//-----------------------------------------------------------------------------
void TXshSoundColumn::setCellInEmptyFrame(int row, const TXshCell &cell)
{
if (cell.isEmpty())
return;
TXshSoundLevel *soundLevel = cell.getSoundLevel();
if (!soundLevel)
return;
int startOffset = cell.getFrameId().getNumber();
int startFrame = row - startOffset;
int endOffset = startFrame + soundLevel->getFrameCount() - 1 - row;
insertColumnLevel(new ColumnLevel(soundLevel, startFrame, startOffset, endOffset));
}
//-----------------------------------------------------------------------------
bool TXshSoundColumn::setCell(int row, const TXshCell &cell)
{
return setCell(row, cell, false);
}
//-----------------------------------------------------------------------------
bool TXshSoundColumn::setCell(int row, const TXshCell &cell, bool updateSequence)
{
if (!canSetCell(cell))
return false;
assert(row >= 0);
ColumnLevel *lBefore = getColumnLevelByFrame(row - 1);
ColumnLevel *l = getColumnLevelByFrame(row);
ColumnLevel *lNext = getColumnLevelByFrame(row + 1);
//Se non devo fare un update della sequenzialita' e la cella e' uguale a quella gia' esistente ritorno.
if (!updateSequence &&
l && l->getSoundLevel() == cell.getSoundLevel() &&
row - l->getStartFrame() == cell.getFrameId().getNumber())
return false;
bool isBeforeLevelInSequence = (lBefore &&
lBefore->getSoundLevel() == cell.getSoundLevel() &&
row - lBefore->getStartFrame() == cell.getFrameId().getNumber());
bool isNextLevelInSequence = (lNext &&
lNext->getSoundLevel() == cell.getSoundLevel() &&
row - lNext->getStartFrame() == cell.getFrameId().getNumber());
//Modifico solo l'endOffset del BeforeLevel
if (isBeforeLevelInSequence) {
int oldEndOffset = lBefore->getEndOffset();
int endOffset = (lBefore->getVisibleEndFrame() != row) ? oldEndOffset - 1 : oldEndOffset;
if (isNextLevelInSequence) {
endOffset = lNext->getEndOffset();
//Se precedente e successivo sono diversi elimino il successivo (caso in cui inserisci un frame in successione su una cella vuota)
if (lNext != lBefore)
removeColumnLevel(lNext);
}
if (l && l != lBefore) {
if (l->getVisibleFrameCount() == 1)
removeColumnLevel(l);
else
l->setStartOffset(l->getStartOffset() + 1);
}
lBefore->setEndOffset(endOffset);
checkColumn();
return true;
}
//Modifico solo lo startOffset del NextLevel
if (isNextLevelInSequence) {
int oldStartOffset = lNext->getStartOffset();
int startOffset = (lNext->getVisibleStartFrame() != row) ? oldStartOffset - 1 : oldStartOffset;
if (l && l != lNext) {
if (l->getVisibleFrameCount() == 1)
removeColumnLevel(l);
else
l->setEndOffset(l->getEndOffset() + 1);
}
lNext->setStartOffset(startOffset);
checkColumn();
return true;
}
//I Frame non sono in successione quindi devo inserire la cella in frame un vuoto:
clearCells(row, 1);
setCellInEmptyFrame(row, cell);
checkColumn();
return true;
}
//-----------------------------------------------------------------------------
bool TXshSoundColumn::setCells(int row, int rowCount, const TXshCell cells[])
{
assert(row >= 0);
// le celle da settare sono [ra, rb]
int ra = row;
int rb = row + rowCount - 1;
assert(ra <= rb);
bool ret = false;
int r;
for (r = ra; r <= rb; r++) {
bool isOneCellSet = setCell(r, cells[r - ra]);
if (isOneCellSet)
ret = isOneCellSet;
}
return ret;
}
//-----------------------------------------------------------------------------
void TXshSoundColumn::insertEmptyCells(int row, int rowCount)
{
if (m_levels.isEmpty())
return; //se la colonna e' vuota non devo inserire celle
int ra = row;
int rb = row + rowCount - 1;
assert(ra <= rb);
//Se il livello nella riga ra inizia prima devo "spezzarlo"
ColumnLevel *l = getColumnLevelByFrame(ra);
if (l && l->getVisibleStartFrame() < ra) {
int oldOffset = l->getEndOffset();
l->setEndOffset(oldOffset + l->getVisibleEndFrame() - ra + 1);
insertColumnLevel(new ColumnLevel(l->getSoundLevel(), l->getStartFrame(), row - l->getStartFrame(), oldOffset));
}
//Sposto il first frame di tutti i livelli successivi ad ra.
int i;
for (i = m_levels.count() - 1; i >= 0; i--) {
ColumnLevel *cl = m_levels.at(i);
if (cl->getVisibleStartFrame() < ra)
continue;
cl->setStartFrame(cl->getStartFrame() + rowCount);
}
checkColumn();
}
//-----------------------------------------------------------------------------
void TXshSoundColumn::removeCells(int row, int rowCount, bool shift)
{
// le celle da cancellare sono [ra, rb]
int ra = row;
int rb = row + rowCount - 1;
assert(ra <= rb);
int i;
for (i = m_levels.size() - 1; i >= 0; i--) {
ColumnLevel *l = m_levels.at(i);
if (!l)
continue; // Non dovrebbe accadere!
int visibleStartFrame = l->getVisibleStartFrame();
int visibleEndFrame = l->getVisibleEndFrame();
// Fuori dal range da tagliare.
if (visibleStartFrame > rb || visibleEndFrame < ra)
continue;
int newEndOffset = l->getEndFrame() - ra + 1;
int newStartOffset = rb - l->getStartFrame() + 1;
// Il livello contiene il range da cancellare: devo "spezzare" il livello in due.
if (visibleStartFrame < ra && visibleEndFrame > rb) {
int oldEndOffset = l->getEndOffset();
l->setEndOffset(newEndOffset);
insertColumnLevel(new ColumnLevel(l->getSoundLevel(), l->getStartFrame(), newStartOffset, oldEndOffset));
continue;
}
if (visibleStartFrame < ra)
l->setEndOffset(newEndOffset);
if (visibleEndFrame > rb)
l->setStartOffset(newStartOffset);
//Il livello e' contenuto nel range da cancellare: lo rimuovo.
if (visibleStartFrame >= ra && visibleEndFrame <= rb)
removeColumnLevel(l);
}
if (shift) {
for (i = m_levels.size() - 1; i >= 0; i--) {
ColumnLevel *l = m_levels.at(i);
if (!l)
continue; // Non dovrebbe accadere!
int visibleStartFrame = l->getVisibleStartFrame();
int visibleEndFrame = l->getVisibleEndFrame();
if (visibleStartFrame > ra)
l->setStartFrame(l->getStartFrame() - rowCount);
}
//Devo controllare se il livello precedente il taglio e quello successivo sono in sequenza
ColumnLevel *beforeL = getColumnLevelByFrame(ra - 1);
ColumnLevel *nextL = getColumnLevelByFrame(ra);
if (beforeL && nextL &&
beforeL->getSoundLevel() == nextL->getSoundLevel() &&
beforeL->getStartFrame() == nextL->getStartFrame()) {
beforeL->setEndOffset(nextL->getEndOffset());
removeColumnLevel(nextL);
}
}
checkColumn();
}
//-----------------------------------------------------------------------------
void TXshSoundColumn::clearCells(int row, int rowCount)
{
if (rowCount <= 0)
return;
if (m_levels.isEmpty())
return; //se la colonna e' vuota non devo "sbiancare" celle
removeCells(row, rowCount, false);
}
//-----------------------------------------------------------------------------
void TXshSoundColumn::removeCells(int row, int rowCount)
{
removeCells(row, rowCount, true);
}
//-----------------------------------------------------------------------------
void TXshSoundColumn::updateCells(int row, int rowCount)
{
int r;
for (r = row; r < row + rowCount; r++) {
TXshCell cell = getCell(r);
setCell(row, cell, true);
}
}
//-----------------------------------------------------------------------------
int TXshSoundColumn::modifyCellRange(int row, int delta, bool modifyStartValue)
{
ColumnLevel *l = getColumnLevelByFrame(row);
if (!l)
return -1;
int startVisibleFrame = l->getVisibleStartFrame();
int endVisibleFrame = l->getVisibleEndFrame();
//Non dovrebbe mai accadere, metto un controllo di sicurezza.
if (startVisibleFrame != row && endVisibleFrame != row)
return -1;
int r0 = delta > 0 ? row : row + delta;
int r1 = delta > 0 ? row + delta : row;
int r;
for (r = r0; r <= r1; r++) {
ColumnLevel *oldL = getColumnLevelByFrame(r);
if (!oldL || oldL == l)
continue;
int visibleStartFrame = oldL->getVisibleStartFrame();
int visibleEndFrame = oldL->getVisibleEndFrame();
if (visibleStartFrame >= r0 && visibleEndFrame <= r1)
removeColumnLevel(oldL);
if (visibleStartFrame <= r0)
oldL->setEndOffset(oldL->getEndOffset() + visibleEndFrame - r0 + 1);
if (visibleEndFrame >= r1)
oldL->setStartOffset(oldL->getStartOffset() + r1 - visibleStartFrame + 1);
r = visibleEndFrame;
}
if (modifyStartValue) {
//Evito che vada oltre il limite infieriore
if (endVisibleFrame < startVisibleFrame + delta)
delta = endVisibleFrame - startVisibleFrame;
int newStartOffset = l->getStartOffset() + delta;
//Evito che vada oltre il limite superiore
if (newStartOffset < 0)
newStartOffset = 0;
l->setStartOffset(newStartOffset);
checkColumn();
getXsheet()->updateFrameCount();
return l->getVisibleStartFrame();
}
//Evito che vada oltre il limite superiore
if (startVisibleFrame > endVisibleFrame + delta)
delta = startVisibleFrame - endVisibleFrame;
//Evito che vada oltre il limite inferiore
int newEndOffset = l->getEndOffset() - delta;
if (newEndOffset < 0)
newEndOffset = 0;
l->setEndOffset(newEndOffset);
checkColumn();
getXsheet()->updateFrameCount();
return l->getVisibleEndFrame();
}
//-----------------------------------------------------------------------------
bool TXshSoundColumn::getLevelRange(int row, int &r0, int &r1) const
{
ColumnLevel *l = getColumnLevelByFrame(row);
if (!l) {
r0 = r1 = row;
return false;
}
r0 = l->getVisibleStartFrame();
r1 = l->getVisibleEndFrame();
return true;
}
//-----------------------------------------------------------------------------
bool TXshSoundColumn::getLevelRangeWithoutOffset(int row, int &r0, int &r1) const
{
ColumnLevel *l = getColumnLevelByFrame(row);
if (!l) {
r0 = r1 = row;
return false;
}
r0 = l->getStartFrame();
r1 = l->getEndFrame();
return true;
}
//-----------------------------------------------------------------------------
void TXshSoundColumn::setXsheet(TXsheet *xsheet)
{
TXshColumn::setXsheet(xsheet);
ToonzScene *scene = xsheet->getScene();
if (!scene || m_levels.empty())
return;
if (m_isOldVersion) {
assert(m_levels.size() == 1);
scene->getLevelSet()->insertLevel(m_levels.at(0)->getSoundLevel());
m_isOldVersion = false;
}
TOutputProperties *properties = scene->getProperties()->getOutputProperties();
setFrameRate(properties->getFrameRate());
}
//-----------------------------------------------------------------------------
void TXshSoundColumn::setFrameRate(double fps)
{
if (m_levels.empty())
return;
int i;
for (i = 0; i < m_levels.size(); i++) {
ColumnLevel *column = m_levels.at(i);
TXshSoundLevel *soundLevel = column->getSoundLevel();
if (soundLevel->getFrameRate() != fps)
soundLevel->setFrameRate(fps);
column->setFrameRate(fps);
}
}
//-----------------------------------------------------------------------------
void TXshSoundColumn::updateFrameRate(double fps)
{
if (m_levels.empty())
return;
int i;
for (i = 0; i < m_levels.size(); i++) {
ColumnLevel *column = m_levels.at(i);
TXshSoundLevel *soundLevel = column->getSoundLevel();
double oldFps = soundLevel->getFrameRate();
if (oldFps != fps)
soundLevel->setFrameRate(fps);
column->updateFrameRate(fps);
}
}
//-----------------------------------------------------------------------------
void TXshSoundColumn::setVolume(double value)
{
m_volume = tcrop<double>(value, 0.0, 1.0);
if (m_player && m_player->isPlaying())
#ifdef MACOSX
m_player->setVolume(m_volume);
#else
stop();
#endif
}
//-----------------------------------------------------------------------------
double TXshSoundColumn::getVolume() const
{
return m_volume;
}
//-----------------------------------------------------------------------------
void TXshSoundColumn::play(TSoundTrackP soundtrack, int s0, int s1, bool loop)
{
if (!TSoundOutputDevice::installed())
return;
if (!m_player)
m_player = new TSoundOutputDevice();
if (m_player) {
try {
#ifdef MACOSX
m_player->setVolume(m_volume);
TSoundTrackP mixedTrack = soundtrack;
#else
TSoundTrackP mixedTrack = TSoundTrack::create(soundtrack->getFormat(), soundtrack->getSampleCount());
mixedTrack = TSop::mix(mixedTrack, soundtrack, 1.0, m_volume);
#endif
m_player->play(mixedTrack, s0, s1, loop);
m_currentPlaySoundTrack = mixedTrack;
#ifndef MACOSX
m_timer.start();
#endif
} catch (TSoundDeviceException &) {
}
}
}
//-----------------------------------------------------------------------------
void TXshSoundColumn::play(ColumnLevel *columnLevel, int currentFrame)
{
assert(columnLevel);
TXshSoundLevel *soundLevel = columnLevel->getSoundLevel();
int offset = 0;
int startFrame = currentFrame - columnLevel->getStartFrame();
int endFrame = soundLevel->getFrameCount() - columnLevel->getEndOffset();
int spf = soundLevel->getSamplePerFrame();
int s0 = startFrame * spf;
int s1 = endFrame * spf;
if (!soundLevel->getSoundTrack())
return;
play(soundLevel->getSoundTrack(), s0, s1, false);
}
//-----------------------------------------------------------------------------
void TXshSoundColumn::play(int currentFrame)
{
TSoundTrackP soundTrack = getOverallSoundTrack(currentFrame);
if (!soundTrack)
return;
int spf = m_levels.at(0)->getSoundLevel()->getSamplePerFrame();
int startFrame = (currentFrame - getFirstRow());
int s0 = startFrame * spf;
int s1 = getMaxFrame() * spf;
play(soundTrack, s0, s1, false);
}
//-----------------------------------------------------------------------------
void TXshSoundColumn::stop()
{
if (m_player) {
m_player->stop();
m_player->close();
m_player = 0;
m_currentPlaySoundTrack = TSoundTrackP();
}
}
//-----------------------------------------------------------------------------
bool TXshSoundColumn::isPlaying() const
{
return m_player && m_player->isPlaying();
}
//-----------------------------------------------------------------------------
void TXshSoundColumn::insertColumnLevel(ColumnLevel *columnLevel, int index)
{
if (index == -1)
index = m_levels.size();
m_levels.insert(index, columnLevel);
qSort(m_levels.begin(), m_levels.end(), lessThan);
}
//-----------------------------------------------------------------------------
void TXshSoundColumn::removeColumnLevel(ColumnLevel *columnLevel)
{
if (!columnLevel)
return;
int index = m_levels.indexOf(columnLevel);
if (index == -1)
return;
m_levels.removeAt(index);
delete columnLevel;
}
//-----------------------------------------------------------------------------
ColumnLevel *TXshSoundColumn::getColumnLevelByFrame(int frame) const
{
int levelCount = m_levels.size();
for (int i = 0; i < levelCount; i++) {
ColumnLevel *l = m_levels.at(i);
TXshSoundLevel *soundLevel = l->getSoundLevel();
int startFrame = l->getStartFrame() + l->getStartOffset();
int frameCount = soundLevel->getFrameCount() - l->getStartOffset() - l->getEndOffset();
if (startFrame <= frame && startFrame + frameCount > frame)
return l;
}
return 0;
}
//-----------------------------------------------------------------------------
ColumnLevel *TXshSoundColumn::getColumnLevel(int index)
{
if (index < 0 || index >= m_levels.count())
return 0;
return m_levels.at(index);
}
//-----------------------------------------------------------------------------
int TXshSoundColumn::getColumnLevelIndex(ColumnLevel *columnLevel) const
{
return m_levels.indexOf(columnLevel);
}
//-----------------------------------------------------------------------------
void TXshSoundColumn::clear()
{
int sequenceCount = m_levels.size();
for (int i = 0; i < sequenceCount; i++) {
ColumnLevel *s = m_levels[i];
delete s;
}
m_levels.clear();
}
//-----------------------------------------------------------------------------
void TXshSoundColumn::onTimerOut()
{
#ifndef MACOSX
if (m_player && m_player->isAllQueuedItemsPlayed())
stop();
#endif
}
//-----------------------------------------------------------------------------
void TXshSoundColumn::scrub(int fromFrame, int toFrame)
{
if (!isCamstandVisible())
return;
TSoundTrackP soundTrack = getOverallSoundTrack(fromFrame, toFrame + 1);
if (!soundTrack)
return;
play(soundTrack, 0, soundTrack->getSampleCount(), false);
}
//-----------------------------------------------------------------------------
TSoundTrackP TXshSoundColumn::getOverallSoundTrack(int fromFrame, int toFrame, double fps, TSoundTrackFormat format)
{
int levelsCount = m_levels.size();
if (levelsCount == 0)
return 0;
if (fps == -1)
fps = m_levels[0]->getSoundLevel()->getFrameRate();
if (fromFrame == -1)
fromFrame = getFirstRow();
if (toFrame == -1)
toFrame = getMaxFrame();
if (format.m_sampleRate == 0) {
// Found the best format inside the soundsequences
int sampleRate = 0;
int bitsPerSample = 8;
int channels = 1;
for (int i = 0; i < levelsCount; i++) {
TXshSoundLevel *soundLevel = m_levels.at(i)->getSoundLevel();
TSoundTrackP soundTrack = soundLevel->getSoundTrack();
if (soundTrack.getPointer() == 0)
continue;
TSoundTrackFormat f = soundTrack->getFormat();
if ((int)f.m_sampleRate > sampleRate) {
format.m_sampleRate = f.m_sampleRate;
sampleRate = f.m_sampleRate;
format.m_channelCount = f.m_channelCount;
channels = f.m_channelCount;
format.m_signedSample = f.m_signedSample;
format.m_bitPerSample = f.m_bitPerSample;
bitsPerSample = f.m_bitPerSample;
}
if (f.m_channelCount > channels) {
format.m_channelCount = f.m_channelCount;
channels = f.m_channelCount;
}
if (f.m_bitPerSample > bitsPerSample) {
format.m_bitPerSample = f.m_bitPerSample;
bitsPerSample = f.m_bitPerSample;
}
}
}
// If there is no soundSequence I use a default format
if (levelsCount == 0 || format.m_sampleRate == 0) {
format.m_sampleRate = 44100;
format.m_bitPerSample = 16;
format.m_channelCount = 1;
format.m_signedSample = true;
}
// We prefer to have 22050 as a maximum sampleRate (to avoid crashes or another issues)
if (format.m_sampleRate >= 44100)
format.m_sampleRate = 22050;
// Create the soundTrack
double samplePerFrame = format.m_sampleRate / fps;
// In seconds
double duration = double(toFrame - fromFrame) / fps;
// Seconds to Sample (it is more accurate than using sampleCount
double dsamp = duration * format.m_sampleRate;
TINT32 lsamp = (TINT32)dsamp;
if ((double)lsamp < dsamp - TConsts::epsilon)
lsamp++;
TSoundTrackP overallSoundTrack;
try {
overallSoundTrack = TSoundTrack::create(format, lsamp);
} catch (TSoundDeviceException &) {
}
// Blank the whole track
overallSoundTrack->blank(0, lsamp);
if (levelsCount == 0)
return overallSoundTrack;
for (int i = 0; i < levelsCount; i++) {
ColumnLevel *l = m_levels.at(i);
TXshSoundLevel *soundLevel = l->getSoundLevel();
// Check if the soundtrack is inside the frame Range.
int levelStartFrame = l->getStartFrame() + l->getStartOffset();
int levelEndFrame = levelStartFrame + soundLevel->getFrameCount() - l->getStartOffset() - l->getEndOffset();
// If the soundSequence is completely before fromFrame I will skip it
if ((levelStartFrame < fromFrame && levelEndFrame < fromFrame))
continue;
// If the soundSequence is after toFrame I don't check the others (that comes later..)
if ((levelStartFrame > toFrame && levelEndFrame > toFrame))
break;
// Extract the right soundTrack (using the offsets)
// (pay attention to convert it before)
TSoundTrackP s = soundLevel->getSoundTrack();
if (!s)
continue;
TSoundTrackP soundTrack = TSop::convert(s, format);
int s0delta = 0;
if (fromFrame > levelStartFrame)
s0delta = fromFrame - levelStartFrame;
int s0 = (l->getStartOffset() + s0delta) * samplePerFrame;
int s1delta = 0;
if (toFrame < levelEndFrame)
s1delta = levelEndFrame - toFrame;
int s1 = (soundLevel->getFrameCount() - l->getEndOffset() - s1delta) * samplePerFrame;
if (s1 > 0 && s1 >= s0) {
soundTrack = soundTrack->extract(s0, s1);
// Copy the sound track
overallSoundTrack->copy(soundTrack,
int((levelStartFrame - fromFrame) * samplePerFrame)); // The int cast is IMPORTANT, since
} // there are 2 overloads (int & double)
} // with DIFFERENT SCALES. We mean the
// SAMPLES-BASED one.
return overallSoundTrack;
}
//-----------------------------------------------------------------------------
TSoundTrackP TXshSoundColumn::mixingTogether(const std::vector<TXshSoundColumn *> &vect, int fromFrame, int toFrame, double fps)
{
int offset = 0xffff;
long sampleCount = 0;
std::vector<TSoundTrackP> tracks;
TSoundTrackP mix;
int size = vect.size(), i = 0;
ColumnLevel *l = vect[0]->getColumnLevel(0);
if (!l) // May happen if the sound level is not
return mix; // correctly loaded from disk
TXshSoundLevel *soundLevel = l->getSoundLevel();
assert(soundLevel);
if (fps == -1)
fps = soundLevel->getFrameRate();
if (fromFrame == -1)
fromFrame = 0;
if (toFrame == -1)
toFrame = getXsheet()->getFrameCount();
if (!soundLevel->getSoundTrack())
return mix;
TSoundTrackFormat format = soundLevel->getSoundTrack()->getFormat();
TXshSoundColumn *c = 0;
int j;
for (j = 0; j < size; ++j) {
TXshSoundColumn *oldC = c;
c = vect[j];
if (j == 0) {
mix = c->getOverallSoundTrack(fromFrame, toFrame, fps, format);
TSoundTrackP mixedTrack = TSoundTrack::create(mix->getFormat(), mix->getSampleCount());
mix = TSop::mix(mixedTrack, mix, 1.0, c->getVolume());
continue;
}
assert(oldC);
if (c->getVolume() == 0 || c->isEmpty()) {
c = oldC;
continue;
}
mix = TSop::mix(mix, c->getOverallSoundTrack(fromFrame, toFrame, fps, format), 1.0, c->getVolume());
}
//Per ora perche mov vuole solo 16 bit
TSoundTrackFormat fmt = mix->getFormat();
if (fmt.m_bitPerSample != 16)
fmt.m_bitPerSample = 16;
mix = TSop::convert(mix, fmt);
return mix;
}
PERSIST_IDENTIFIER(TXshSoundColumn, "soundColumn")