bool AnalyserGain::loadStored(TrackPointer tio) const {
bool bAnalyserEnabled = (bool)m_pConfigReplayGain->getValueString(ConfigKey("[ReplayGain]","ReplayGainAnalyserEnabled")).toInt();
float fReplayGain = tio->getReplayGain();
if (fReplayGain != 0 || !bAnalyserEnabled) {
return true;
}
return false;
}
bool AnalyzerGain::loadStored(TrackPointer tio) const {
// WARNING: Do not fix the "analyser" spelling here since user config files
// contain these strings.
bool bAnalyzerEnabled = (bool)m_pConfigReplayGain->getValueString(
ConfigKey("[ReplayGain]","ReplayGainAnalyserEnabled")).toInt();
if (tio->getReplayGain().hasRatio() || !bAnalyzerEnabled) {
return true;
}
return false;
}
bool ReplayGainSettings::isAnalyzerDisabled(int version, TrackPointer tio) const {
if (isAnalyzerEnabled(version)) {
if (getReplayGainReanalyze()) {
// ignore stored replay gain
return false;
}
return tio->getReplayGain().hasRatio();
}
// not enabled, pretend we have already a stored value.
return true;
}
bool ReplayGainSettings::isAnalyzerDisabled(int version, TrackPointer tio) const {
int prefversion = getReplayGainAnalyzerVersion();
bool analyzerEnabled = getReplayGainAnalyzerEnabled() && (version == prefversion);
bool reanalyze = getReplayGainReanalyze();
if (analyzerEnabled) {
if (reanalyze) {
// ignore stored replay gain
return false;
}
return tio->getReplayGain().hasRatio();
}
// not enabled, pretend we have already a stored value.
return true;
}
void AnalyzerGain::finalize(TrackPointer tio) {
//TODO: We are going to store values as relative peaks so that "0" means that no replaygain has been evaluated.
// This means that we are going to transform from dB to peaks and viceversa.
// One may think to digg into replay_gain code and modify it so that
// it directly sends results as relative peaks.
// In that way there is no need to spend resources in calculating log10 or pow.
if(!m_initalized)
return;
float fReplayGainOutput = m_pReplayGain->end();
if (fReplayGainOutput == GAIN_NOT_ENOUGH_SAMPLES) {
qDebug() << "ReplayGain 1.0 analysis failed";
m_initalized = false;
return;
}
Mixxx::ReplayGain replayGain(tio->getReplayGain());
replayGain.setRatio(db2ratio(fReplayGainOutput));
tio->setReplayGain(replayGain);
qDebug() << "ReplayGain 1.0 result is" << fReplayGainOutput << "dB for" << tio->getLocation();
m_initalized = false;
}
void BrowseThread::populateModel() {
m_path_mutex.lock();
MDir thisPath = m_path;
BrowseTableModel* thisModelObserver = m_model_observer;
m_path_mutex.unlock();
// Refresh the name filters in case we loaded new SoundSource plugins.
QStringList nameFilters(SoundSourceProxy::getSupportedFileNamePatterns());
QDirIterator fileIt(thisPath.dir().absolutePath(), nameFilters,
QDir::Files | QDir::NoDotAndDotDot);
// remove all rows
// This is a blocking operation
// see signal/slot connection in BrowseTableModel
emit(clearModel(thisModelObserver));
QList< QList<QStandardItem*> > rows;
int row = 0;
// Iterate over the files
while (fileIt.hasNext()) {
// If a user quickly jumps through the folders
// the current task becomes "dirty"
m_path_mutex.lock();
MDir newPath = m_path;
m_path_mutex.unlock();
if (thisPath.dir() != newPath.dir()) {
qDebug() << "Abort populateModel()";
return populateModel();
}
QList<QStandardItem*> row_data;
QStandardItem* item = new QStandardItem("0");
item->setData("0", Qt::UserRole);
row_data.insert(COLUMN_PREVIEW, item);
const QString filepath = fileIt.next();
{
const TrackPointer pTrack =
SoundSourceProxy::importTemporaryTrack(
filepath,
thisPath.token());
item = new QStandardItem(pTrack->getFileName());
item->setToolTip(item->text());
item->setData(item->text(), Qt::UserRole);
row_data.insert(COLUMN_FILENAME, item);
item = new QStandardItem(pTrack->getArtist());
item->setToolTip(item->text());
item->setData(item->text(), Qt::UserRole);
row_data.insert(COLUMN_ARTIST, item);
item = new QStandardItem(pTrack->getTitle());
item->setToolTip(item->text());
item->setData(item->text(), Qt::UserRole);
row_data.insert(COLUMN_TITLE, item);
item = new QStandardItem(pTrack->getAlbum());
item->setToolTip(item->text());
item->setData(item->text(), Qt::UserRole);
row_data.insert(COLUMN_ALBUM, item);
item = new QStandardItem(pTrack->getAlbumArtist());
item->setToolTip(item->text());
item->setData(item->text(), Qt::UserRole);
row_data.insert(COLUMN_ALBUMARTIST, item);
item = new QStandardItem(pTrack->getTrackNumber());
item->setToolTip(item->text());
item->setData(item->text().toInt(), Qt::UserRole);
row_data.insert(COLUMN_TRACK_NUMBER, item);
const QString year(pTrack->getYear());
item = new YearItem(year);
item->setToolTip(year);
// The year column is sorted according to the numeric calendar year
item->setData(mixxx::TrackMetadata::parseCalendarYear(year), Qt::UserRole);
row_data.insert(COLUMN_YEAR, item);
item = new QStandardItem(pTrack->getGenre());
item->setToolTip(item->text());
item->setData(item->text(), Qt::UserRole);
row_data.insert(COLUMN_GENRE, item);
item = new QStandardItem(pTrack->getComposer());
item->setToolTip(item->text());
item->setData(item->text(), Qt::UserRole);
row_data.insert(COLUMN_COMPOSER, item);
item = new QStandardItem(pTrack->getGrouping());
item->setToolTip(item->text());
item->setData(item->text(), Qt::UserRole);
row_data.insert(COLUMN_GROUPING, item);
item = new QStandardItem(pTrack->getComment());
item->setToolTip(item->text());
item->setData(item->text(), Qt::UserRole);
row_data.insert(COLUMN_COMMENT, item);
QString duration = pTrack->getDurationText(mixxx::Duration::Precision::SECONDS);
item = new QStandardItem(duration);
item->setToolTip(item->text());
item->setData(item->text(), Qt::UserRole);
row_data.insert(COLUMN_DURATION, item);
item = new QStandardItem(pTrack->getBpmText());
item->setToolTip(item->text());
item->setData(pTrack->getBpm(), Qt::UserRole);
row_data.insert(COLUMN_BPM, item);
item = new QStandardItem(pTrack->getKeyText());
item->setToolTip(item->text());
item->setData(item->text(), Qt::UserRole);
row_data.insert(COLUMN_KEY, item);
item = new QStandardItem(pTrack->getType());
item->setToolTip(item->text());
item->setData(item->text(), Qt::UserRole);
row_data.insert(COLUMN_TYPE, item);
item = new QStandardItem(pTrack->getBitrateText());
item->setToolTip(item->text());
item->setData(pTrack->getBitrate(), Qt::UserRole);
row_data.insert(COLUMN_BITRATE, item);
QString location = pTrack->getLocation();
QString nativeLocation = QDir::toNativeSeparators(location);
item = new QStandardItem(nativeLocation);
item->setToolTip(nativeLocation);
item->setData(location, Qt::UserRole);
row_data.insert(COLUMN_NATIVELOCATION, item);
QDateTime modifiedTime = pTrack->getFileModifiedTime().toLocalTime();
item = new QStandardItem(modifiedTime.toString(Qt::DefaultLocaleShortDate));
item->setToolTip(item->text());
item->setData(modifiedTime, Qt::UserRole);
row_data.insert(COLUMN_FILE_MODIFIED_TIME, item);
QDateTime creationTime = pTrack->getFileCreationTime().toLocalTime();
item = new QStandardItem(creationTime.toString(Qt::DefaultLocaleShortDate));
item->setToolTip(item->text());
item->setData(creationTime, Qt::UserRole);
row_data.insert(COLUMN_FILE_CREATION_TIME, item);
const mixxx::ReplayGain replayGain(pTrack->getReplayGain());
item = new QStandardItem(
mixxx::ReplayGain::ratioToString(replayGain.getRatio()));
item->setToolTip(item->text());
item->setData(item->text(), Qt::UserRole);
row_data.insert(COLUMN_REPLAYGAIN, item);
} // implicitly release track pointer and unlock cache
rows.append(row_data);
++row;
// If 10 tracks have been analyzed, send it to GUI
// Will limit GUI freezing
if (row % 10 == 0) {
// this is a blocking operation
emit(rowsAppended(rows, thisModelObserver));
qDebug() << "Append " << rows.count() << " from " << filepath;
rows.clear();
}
// Sleep additionally for 10ms which prevents us from GUI freezes
msleep(20);
}
emit(rowsAppended(rows, thisModelObserver));
qDebug() << "Append last " << rows.count();
}
void BaseTrackCache::getTrackValueForColumn(TrackPointer pTrack,
int column,
QVariant& trackValue) const {
if (!pTrack || column < 0) {
return;
}
// TODO(XXX) Qt properties could really help here.
// TODO(rryan) this is all TrackDAO specific. What about iTunes/RB/etc.?
if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_ARTIST) == column) {
trackValue.setValue(pTrack->getArtist());
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_TITLE) == column) {
trackValue.setValue(pTrack->getTitle());
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_ALBUM) == column) {
trackValue.setValue(pTrack->getAlbum());
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_ALBUMARTIST) == column) {
trackValue.setValue(pTrack->getAlbumArtist());
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_YEAR) == column) {
trackValue.setValue(pTrack->getYear());
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_DATETIMEADDED) == column) {
trackValue.setValue(pTrack->getDateAdded());
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_GENRE) == column) {
trackValue.setValue(pTrack->getGenre());
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_COMPOSER) == column) {
trackValue.setValue(pTrack->getComposer());
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_GROUPING) == column) {
trackValue.setValue(pTrack->getGrouping());
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_FILETYPE) == column) {
trackValue.setValue(pTrack->getType());
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_TRACKNUMBER) == column) {
trackValue.setValue(pTrack->getTrackNumber());
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_LOCATION) == column) {
trackValue.setValue(QDir::toNativeSeparators(pTrack->getLocation()));
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_COMMENT) == column) {
trackValue.setValue(pTrack->getComment());
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_DURATION) == column) {
trackValue.setValue(pTrack->getDuration());
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_BITRATE) == column) {
trackValue.setValue(pTrack->getBitrate());
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_BPM) == column) {
trackValue.setValue(pTrack->getBpm());
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_REPLAYGAIN) == column) {
trackValue.setValue(pTrack->getReplayGain().getRatio());
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_PLAYED) == column) {
trackValue.setValue(pTrack->getPlayCounter().isPlayed());
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_TIMESPLAYED) == column) {
trackValue.setValue(pTrack->getPlayCounter().getTimesPlayed());
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_RATING) == column) {
trackValue.setValue(pTrack->getRating());
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_KEY) == column) {
trackValue.setValue(pTrack->getKeyText());
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_KEY_ID) == column) {
trackValue.setValue(static_cast<int>(pTrack->getKey()));
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_BPM_LOCK) == column) {
trackValue.setValue(pTrack->isBpmLocked());
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_COVERART_LOCATION) == column) {
trackValue.setValue(pTrack->getCoverInfo().coverLocation);
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_COVERART_HASH) == column ||
fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_COVERART) == column) {
// For sorting, we give COLUMN_LIBRARYTABLE_COVERART the same value as
// the cover hash.
trackValue.setValue(pTrack->getCoverHash());
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_COVERART_SOURCE) == column) {
trackValue.setValue(static_cast<int>(pTrack->getCoverInfo().source));
} else if (fieldIndex(ColumnCache::COLUMN_LIBRARYTABLE_COVERART_TYPE) == column) {
trackValue.setValue(static_cast<int>(pTrack->getCoverInfo().type));
}
}