2010-03-24 00:11:46 +01:00
|
|
|
/* This file is part of Clementine.
|
2010-11-20 14:27:10 +01:00
|
|
|
Copyright 2010, David Sansome <me@davidsansome.com>
|
2010-03-24 00:11:46 +01:00
|
|
|
|
|
|
|
Clementine is free software: you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
Clementine is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with Clementine. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
|
2010-10-17 18:03:49 +02:00
|
|
|
#include "fmpsparser.h"
|
2009-12-24 20:16:07 +01:00
|
|
|
#include "song.h"
|
2010-08-03 21:29:49 +02:00
|
|
|
|
|
|
|
#include <algorithm>
|
2009-12-24 20:16:07 +01:00
|
|
|
|
2010-01-16 18:17:00 +01:00
|
|
|
#include <sys/stat.h>
|
|
|
|
|
2010-08-03 21:29:49 +02:00
|
|
|
#include <taglib/aifffile.h>
|
|
|
|
#include <taglib/asffile.h>
|
2011-01-24 21:06:59 +01:00
|
|
|
#include <taglib/attachedpictureframe.h>
|
2010-09-15 21:24:31 +02:00
|
|
|
#include <taglib/commentsframe.h>
|
2009-12-24 20:16:07 +01:00
|
|
|
#include <taglib/fileref.h>
|
|
|
|
#include <taglib/flacfile.h>
|
2010-11-23 18:38:39 +01:00
|
|
|
#include <taglib/id3v1genres.h>
|
2010-08-03 21:29:49 +02:00
|
|
|
#include <taglib/id3v2tag.h>
|
2010-03-07 23:46:41 +01:00
|
|
|
#include <taglib/mp4file.h>
|
|
|
|
#include <taglib/mpcfile.h>
|
2010-08-03 21:29:49 +02:00
|
|
|
#include <taglib/mpegfile.h>
|
|
|
|
#include <taglib/oggfile.h>
|
|
|
|
#include <taglib/oggflacfile.h>
|
2010-03-07 23:46:41 +01:00
|
|
|
#include <taglib/speexfile.h>
|
2010-08-03 21:29:49 +02:00
|
|
|
#include <taglib/tag.h>
|
2010-03-29 15:15:47 +02:00
|
|
|
#include <taglib/textidentificationframe.h>
|
2010-08-03 21:29:49 +02:00
|
|
|
#include <taglib/trueaudiofile.h>
|
|
|
|
#include <taglib/tstring.h>
|
|
|
|
#include <taglib/vorbisfile.h>
|
|
|
|
#include <taglib/wavfile.h>
|
2009-12-24 20:16:07 +01:00
|
|
|
|
2010-12-18 18:28:02 +01:00
|
|
|
#ifdef HAVE_LIBLASTFM
|
|
|
|
#include "radio/fixlastfm.h"
|
|
|
|
#include <lastfm/Track>
|
|
|
|
#endif
|
2009-12-26 23:15:57 +01:00
|
|
|
|
2009-12-24 20:16:07 +01:00
|
|
|
#include <QFile>
|
|
|
|
#include <QFileInfo>
|
|
|
|
#include <QSqlQuery>
|
2010-08-03 21:29:49 +02:00
|
|
|
#include <QtConcurrentRun>
|
2010-05-10 15:46:06 +02:00
|
|
|
#include <QTextCodec>
|
2010-08-03 21:29:49 +02:00
|
|
|
#include <QTime>
|
2009-12-24 20:16:07 +01:00
|
|
|
#include <QVariant>
|
|
|
|
|
2010-08-23 21:13:27 +02:00
|
|
|
#ifdef Q_OS_WIN32
|
|
|
|
# include <mswmdm.h>
|
|
|
|
# include <QUuid>
|
|
|
|
#endif // Q_OS_WIN32
|
|
|
|
|
|
|
|
#include <boost/scoped_array.hpp>
|
2010-03-06 21:08:01 +01:00
|
|
|
#include <boost/scoped_ptr.hpp>
|
|
|
|
using boost::scoped_ptr;
|
|
|
|
|
2010-03-03 15:29:53 +01:00
|
|
|
#include "albumcoverloader.h"
|
2010-08-03 21:29:49 +02:00
|
|
|
#include "encoding.h"
|
|
|
|
#include "utilities.h"
|
|
|
|
|
2010-05-10 23:50:31 +02:00
|
|
|
#include "engines/enginebase.h"
|
2010-08-03 20:57:17 +02:00
|
|
|
#include "library/sqlrow.h"
|
2010-05-10 23:50:31 +02:00
|
|
|
#include "widgets/trackslider.h"
|
2010-01-15 22:57:22 +01:00
|
|
|
|
2010-04-14 23:03:00 +02:00
|
|
|
static QStringList Prepend(const QString& text, const QStringList& list) {
|
|
|
|
QStringList ret(list);
|
|
|
|
for (int i=0 ; i<ret.count() ; ++i)
|
|
|
|
ret[i].prepend(text);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static QStringList Updateify(const QStringList& list) {
|
|
|
|
QStringList ret(list);
|
|
|
|
for (int i=0 ; i<ret.count() ; ++i)
|
|
|
|
ret[i].prepend(ret[i] + " = :");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
const QStringList Song::kColumns = QStringList()
|
|
|
|
<< "title" << "album" << "artist" << "albumartist" << "composer" << "track"
|
|
|
|
<< "disc" << "bpm" << "year" << "genre" << "comment" << "compilation"
|
2011-01-04 18:12:29 +01:00
|
|
|
<< "bitrate" << "samplerate" << "directory" << "filename"
|
2010-04-14 23:03:00 +02:00
|
|
|
<< "mtime" << "ctime" << "filesize" << "sampler" << "art_automatic"
|
|
|
|
<< "art_manual" << "filetype" << "playcount" << "lastplayed" << "rating"
|
|
|
|
<< "forced_compilation_on" << "forced_compilation_off"
|
2011-01-15 19:46:23 +01:00
|
|
|
<< "effective_compilation" << "skipcount" << "score" << "beginning" << "length"
|
|
|
|
<< "cue_path";
|
2010-04-14 23:03:00 +02:00
|
|
|
|
|
|
|
const QString Song::kColumnSpec = Song::kColumns.join(", ");
|
|
|
|
const QString Song::kBindSpec = Prepend(":", Song::kColumns).join(", ");
|
|
|
|
const QString Song::kUpdateSpec = Updateify(Song::kColumns).join(", ");
|
|
|
|
|
2010-06-20 18:30:10 +02:00
|
|
|
|
|
|
|
const QStringList Song::kFtsColumns = QStringList()
|
|
|
|
<< "ftstitle" << "ftsalbum" << "ftsartist" << "ftsalbumartist"
|
|
|
|
<< "ftscomposer" << "ftsgenre" << "ftscomment";
|
|
|
|
|
|
|
|
const QString Song::kFtsColumnSpec = Song::kFtsColumns.join(", ");
|
|
|
|
const QString Song::kFtsBindSpec = Prepend(":", Song::kFtsColumns).join(", ");
|
|
|
|
const QString Song::kFtsUpdateSpec = Updateify(Song::kFtsColumns).join(", ");
|
|
|
|
|
2011-02-02 22:01:08 +01:00
|
|
|
const QString Song::kManuallyUnsetCover = "(unset)";
|
|
|
|
const QString Song::kEmbeddedCover = "(embedded)";
|
|
|
|
|
2010-05-10 16:19:43 +02:00
|
|
|
QString Song::JoinSpec(const QString& table) {
|
|
|
|
return Prepend(table + ".", kColumns).join(", ");
|
|
|
|
}
|
2010-04-14 23:03:00 +02:00
|
|
|
|
2010-07-31 16:14:03 +02:00
|
|
|
QString Song::TextForFiletype(FileType type) {
|
|
|
|
switch (type) {
|
2010-08-29 18:12:55 +02:00
|
|
|
case Song::Type_Asf: return QObject::tr("Windows Media audio");
|
|
|
|
case Song::Type_Flac: return QObject::tr("Flac");
|
|
|
|
case Song::Type_Mp4: return QObject::tr("MP4 AAC");
|
2010-07-31 16:14:03 +02:00
|
|
|
case Song::Type_Mpc: return QObject::tr("MPC");
|
|
|
|
case Song::Type_Mpeg: return QObject::tr("MP3"); // Not technically correct
|
2010-08-29 18:12:55 +02:00
|
|
|
case Song::Type_OggFlac: return QObject::tr("Ogg Flac");
|
2010-07-31 16:14:03 +02:00
|
|
|
case Song::Type_OggSpeex: return QObject::tr("Ogg Speex");
|
|
|
|
case Song::Type_OggVorbis: return QObject::tr("Ogg Vorbis");
|
|
|
|
case Song::Type_Aiff: return QObject::tr("AIFF");
|
2010-08-29 18:12:55 +02:00
|
|
|
case Song::Type_Wav: return QObject::tr("Wav");
|
2010-07-31 16:14:03 +02:00
|
|
|
case Song::Type_TrueAudio: return QObject::tr("TrueAudio");
|
|
|
|
|
|
|
|
case Song::Type_Stream: return QObject::tr("Stream");
|
|
|
|
|
|
|
|
case Song::Type_Unknown:
|
|
|
|
default:
|
|
|
|
return QObject::tr("Unknown");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-12-24 20:16:07 +01:00
|
|
|
|
2010-03-29 15:15:47 +02:00
|
|
|
static TagLib::String QStringToTaglibString(const QString& s);
|
|
|
|
|
2010-03-06 21:08:01 +01:00
|
|
|
TagLibFileRefFactory Song::kDefaultFactory;
|
|
|
|
|
2010-08-08 14:35:23 +02:00
|
|
|
QMutex Song::taglib_mutex_;
|
|
|
|
|
2010-06-02 14:31:40 +02:00
|
|
|
|
2010-03-07 23:46:41 +01:00
|
|
|
Song::Private::Private()
|
2009-12-24 20:16:07 +01:00
|
|
|
: valid_(false),
|
|
|
|
id_(-1),
|
|
|
|
track_(-1),
|
|
|
|
disc_(-1),
|
|
|
|
bpm_(-1),
|
|
|
|
year_(-1),
|
|
|
|
compilation_(false),
|
2010-02-27 21:12:22 +01:00
|
|
|
sampler_(false),
|
2010-03-21 00:59:39 +01:00
|
|
|
forced_compilation_on_(false),
|
|
|
|
forced_compilation_off_(false),
|
2010-10-17 18:03:49 +02:00
|
|
|
rating_(-1.0),
|
|
|
|
playcount_(0),
|
2010-10-17 19:50:20 +02:00
|
|
|
skipcount_(0),
|
|
|
|
lastplayed_(-1),
|
2010-11-01 22:15:52 +01:00
|
|
|
score_(0),
|
2010-12-23 22:13:43 +01:00
|
|
|
beginning_(0),
|
|
|
|
end_(-1),
|
2009-12-24 20:16:07 +01:00
|
|
|
bitrate_(-1),
|
|
|
|
samplerate_(-1),
|
|
|
|
directory_id_(-1),
|
|
|
|
mtime_(-1),
|
|
|
|
ctime_(-1),
|
2010-03-07 23:46:41 +01:00
|
|
|
filesize_(-1),
|
2010-10-12 13:55:45 +02:00
|
|
|
filetype_(Type_Unknown),
|
|
|
|
init_from_file_(false)
|
2009-12-24 20:16:07 +01:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2010-03-06 21:08:01 +01:00
|
|
|
TagLib::FileRef* TagLibFileRefFactory::GetFileRef(const QString& filename) {
|
2010-12-30 18:13:11 +01:00
|
|
|
#ifdef Q_OS_WIN32
|
|
|
|
return new TagLib::FileRef(filename.toStdWString().c_str());
|
|
|
|
#else
|
2010-03-06 21:08:01 +01:00
|
|
|
return new TagLib::FileRef(QFile::encodeName(filename).constData());
|
2010-12-30 18:13:11 +01:00
|
|
|
#endif
|
2010-03-06 21:08:01 +01:00
|
|
|
}
|
|
|
|
|
2010-01-15 22:57:22 +01:00
|
|
|
Song::Song()
|
2010-03-07 23:46:41 +01:00
|
|
|
: d(new Private),
|
2010-03-06 21:08:01 +01:00
|
|
|
factory_(&kDefaultFactory)
|
2010-01-15 22:57:22 +01:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
Song::Song(const Song &other)
|
2010-03-06 21:08:01 +01:00
|
|
|
: d(other.d),
|
|
|
|
factory_(&kDefaultFactory)
|
2010-01-15 22:57:22 +01:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2010-03-06 21:08:01 +01:00
|
|
|
Song::Song(FileRefFactory* factory)
|
2010-03-07 23:46:41 +01:00
|
|
|
: d(new Private),
|
2010-03-06 21:08:01 +01:00
|
|
|
factory_(factory) {
|
|
|
|
}
|
|
|
|
|
2010-03-09 18:17:32 +01:00
|
|
|
void Song::Init(const QString& title, const QString& artist, const QString& album, int length) {
|
2010-03-07 16:26:54 +01:00
|
|
|
d->valid_ = true;
|
2010-12-23 22:13:43 +01:00
|
|
|
|
2010-03-07 16:26:54 +01:00
|
|
|
d->title_ = title;
|
|
|
|
d->artist_ = artist;
|
2010-03-09 18:17:32 +01:00
|
|
|
d->album_ = album;
|
2010-12-23 22:13:43 +01:00
|
|
|
|
|
|
|
set_length(length);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Song::Init(const QString& title, const QString& artist, const QString& album, int beginning, int end) {
|
|
|
|
d->valid_ = true;
|
|
|
|
|
|
|
|
d->title_ = title;
|
|
|
|
d->artist_ = artist;
|
|
|
|
d->album_ = album;
|
|
|
|
|
|
|
|
d->beginning_ = beginning;
|
|
|
|
d->end_ = end;
|
2010-03-07 16:26:54 +01:00
|
|
|
}
|
|
|
|
|
2010-11-23 18:38:39 +01:00
|
|
|
void Song::set_genre(int id) {
|
|
|
|
set_genre(TStringToQString(TagLib::ID3v1::genre(id)));
|
|
|
|
}
|
|
|
|
|
2010-06-03 17:16:15 +02:00
|
|
|
QString Song::Decode(const TagLib::String& tag, const QTextCodec* codec) {
|
2010-06-03 17:22:30 +02:00
|
|
|
if (codec && tag.isLatin1()) { // Never override UTF-8.
|
2010-06-03 14:36:43 +02:00
|
|
|
const std::string fixed = QString::fromUtf8(tag.toCString(true)).toStdString();
|
|
|
|
return codec->toUnicode(fixed.c_str()).trimmed();
|
|
|
|
} else {
|
|
|
|
return TStringToQString(tag).trimmed();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-08-09 15:12:54 +02:00
|
|
|
QString Song::Decode(const QString& tag, const QTextCodec* codec) {
|
|
|
|
if (!codec) {
|
|
|
|
return tag;
|
|
|
|
}
|
|
|
|
|
|
|
|
return codec->toUnicode(tag.toUtf8());
|
|
|
|
}
|
|
|
|
|
2009-12-24 20:16:07 +01:00
|
|
|
void Song::InitFromFile(const QString& filename, int directory_id) {
|
2010-08-03 15:37:47 +02:00
|
|
|
#ifndef QT_NO_DEBUG_OUTPUT
|
|
|
|
if (qApp->thread() == QThread::currentThread())
|
|
|
|
qWarning() << Q_FUNC_INFO << "on GUI thread!";
|
|
|
|
#endif
|
2010-01-15 22:57:22 +01:00
|
|
|
d->filename_ = filename;
|
|
|
|
d->directory_id_ = directory_id;
|
2009-12-24 20:16:07 +01:00
|
|
|
|
2010-08-08 14:35:23 +02:00
|
|
|
QMutexLocker l(&taglib_mutex_);
|
2010-03-06 21:08:01 +01:00
|
|
|
scoped_ptr<TagLib::FileRef> fileref(factory_->GetFileRef(filename));
|
2009-12-24 20:16:07 +01:00
|
|
|
|
2010-03-06 21:08:01 +01:00
|
|
|
if(fileref->isNull())
|
2009-12-24 20:16:07 +01:00
|
|
|
return;
|
|
|
|
|
2010-10-12 13:55:45 +02:00
|
|
|
d->init_from_file_ = true;
|
|
|
|
|
2009-12-24 20:16:07 +01:00
|
|
|
QFileInfo info(filename);
|
2010-03-19 11:39:22 +01:00
|
|
|
d->basefilename_ = info.fileName();
|
2010-01-15 22:57:22 +01:00
|
|
|
d->filesize_ = info.size();
|
|
|
|
d->mtime_ = info.lastModified().toTime_t();
|
|
|
|
d->ctime_ = info.created().toTime_t();
|
2009-12-24 20:16:07 +01:00
|
|
|
|
2010-06-03 14:36:43 +02:00
|
|
|
// This is single byte encoding, therefore can't be CJK.
|
|
|
|
UniversalEncodingHandler detector(NS_FILTER_NON_CJK);
|
|
|
|
|
2010-03-06 21:08:01 +01:00
|
|
|
TagLib::Tag* tag = fileref->tag();
|
2010-06-03 14:36:43 +02:00
|
|
|
QTextCodec* codec = NULL;
|
2009-12-24 20:16:07 +01:00
|
|
|
if (tag) {
|
2011-01-12 19:46:23 +01:00
|
|
|
TagLib::MPEG::File* file = dynamic_cast<TagLib::MPEG::File*>(fileref->file());
|
|
|
|
if (file && (file->ID3v2Tag() || file->ID3v1Tag())) {
|
|
|
|
codec = detector.Guess(*fileref);
|
|
|
|
}
|
2010-06-03 14:36:43 +02:00
|
|
|
d->title_ = Decode(tag->title(), codec);
|
|
|
|
d->artist_ = Decode(tag->artist(), codec);
|
|
|
|
d->album_ = Decode(tag->album(), codec);
|
|
|
|
d->genre_ = Decode(tag->genre(), codec);
|
2010-01-15 22:57:22 +01:00
|
|
|
d->year_ = tag->year();
|
|
|
|
d->track_ = tag->track();
|
2009-12-24 20:16:07 +01:00
|
|
|
|
2010-01-15 22:57:22 +01:00
|
|
|
d->valid_ = true;
|
2009-12-24 20:16:07 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
QString disc;
|
|
|
|
QString compilation;
|
2010-03-06 21:08:01 +01:00
|
|
|
if (TagLib::MPEG::File* file = dynamic_cast<TagLib::MPEG::File*>(fileref->file())) {
|
2009-12-24 20:16:07 +01:00
|
|
|
if (file->ID3v2Tag()) {
|
2010-09-15 21:24:31 +02:00
|
|
|
const TagLib::ID3v2::FrameListMap& map = file->ID3v2Tag()->frameListMap();
|
2009-12-24 20:16:07 +01:00
|
|
|
|
2010-09-15 21:24:31 +02:00
|
|
|
if (!map["TPOS"].isEmpty())
|
|
|
|
disc = TStringToQString(map["TPOS"].front()->toString()).trimmed();
|
2009-12-24 20:16:07 +01:00
|
|
|
|
2010-09-15 21:24:31 +02:00
|
|
|
if (!map["TBPM"].isEmpty())
|
|
|
|
d->bpm_ = TStringToQString(map["TBPM"].front()->toString()).trimmed().toFloat();
|
2009-12-24 20:16:07 +01:00
|
|
|
|
2010-09-15 21:24:31 +02:00
|
|
|
if (!map["TCOM"].isEmpty())
|
|
|
|
d->composer_ = Decode(map["TCOM"].front()->toString(), codec);
|
2010-07-19 13:40:30 +02:00
|
|
|
|
2010-09-15 21:24:31 +02:00
|
|
|
if (!map["TPE2"].isEmpty()) // non-standard: Apple, Microsoft
|
|
|
|
d->albumartist_ = Decode(map["TPE2"].front()->toString(), codec);
|
2009-12-24 20:16:07 +01:00
|
|
|
|
2010-09-15 21:24:31 +02:00
|
|
|
if (!map["TCMP"].isEmpty())
|
|
|
|
compilation = TStringToQString(map["TCMP"].front()->toString()).trimmed();
|
2010-07-24 16:49:49 +02:00
|
|
|
|
2010-09-15 21:24:31 +02:00
|
|
|
if (!map["APIC"].isEmpty())
|
2011-02-02 22:01:08 +01:00
|
|
|
set_embedded_cover();
|
2009-12-24 20:16:07 +01:00
|
|
|
|
2010-09-15 21:24:31 +02:00
|
|
|
// Find a suitable comment tag. For now we ignore iTunNORM comments.
|
|
|
|
for (int i=0 ; i<map["COMM"].size() ; ++i) {
|
|
|
|
const TagLib::ID3v2::CommentsFrame* frame =
|
|
|
|
dynamic_cast<const TagLib::ID3v2::CommentsFrame*>(map["COMM"][i]);
|
2009-12-24 20:16:07 +01:00
|
|
|
|
2010-12-18 18:01:25 +01:00
|
|
|
if (frame && TStringToQString(frame->description()) != "iTunNORM") {
|
2010-09-15 21:24:31 +02:00
|
|
|
d->comment_ = Decode(frame->text(), codec);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2010-10-17 18:03:49 +02:00
|
|
|
|
|
|
|
// Parse FMPS frames
|
|
|
|
for (int i=0 ; i<map["TXXX"].size() ; ++i) {
|
|
|
|
const TagLib::ID3v2::UserTextIdentificationFrame* frame =
|
|
|
|
dynamic_cast<const TagLib::ID3v2::UserTextIdentificationFrame*>(map["TXXX"][i]);
|
|
|
|
|
2010-12-18 18:01:25 +01:00
|
|
|
if (frame && frame->description().startsWith("FMPS_")) {
|
2010-10-17 18:03:49 +02:00
|
|
|
ParseFMPSFrame(TStringToQString(frame->description()),
|
|
|
|
TStringToQString(frame->fieldList()[1]));
|
|
|
|
}
|
|
|
|
}
|
2009-12-24 20:16:07 +01:00
|
|
|
}
|
2010-09-15 21:24:31 +02:00
|
|
|
} else if (TagLib::Ogg::Vorbis::File* file = dynamic_cast<TagLib::Ogg::Vorbis::File*>(fileref->file())) {
|
|
|
|
if (file->tag()) {
|
|
|
|
ParseOggTag(file->tag()->fieldListMap(), codec, &disc, &compilation);
|
|
|
|
}
|
|
|
|
d->comment_ = Decode(tag->comment(), codec);
|
|
|
|
} else if (TagLib::FLAC::File* file = dynamic_cast<TagLib::FLAC::File*>(fileref->file())) {
|
2009-12-24 20:16:07 +01:00
|
|
|
if ( file->xiphComment() ) {
|
2010-09-15 21:24:31 +02:00
|
|
|
ParseOggTag(file->xiphComment()->fieldListMap(), codec, &disc, &compilation);
|
2009-12-24 20:16:07 +01:00
|
|
|
}
|
2010-09-15 21:24:31 +02:00
|
|
|
d->comment_ = Decode(tag->comment(), codec);
|
2010-09-25 17:46:35 +02:00
|
|
|
} else if (tag) {
|
2010-09-15 21:24:31 +02:00
|
|
|
d->comment_ = Decode(tag->comment(), codec);
|
2009-12-24 20:16:07 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if ( !disc.isEmpty() ) {
|
|
|
|
int i = disc.indexOf('/');
|
|
|
|
if ( i != -1 )
|
|
|
|
// disc.right( i ).toInt() is total number of discs, we don't use this at the moment
|
2010-01-15 22:57:22 +01:00
|
|
|
d->disc_ = disc.left( i ).toInt();
|
2009-12-24 20:16:07 +01:00
|
|
|
else
|
2010-01-15 22:57:22 +01:00
|
|
|
d->disc_ = disc.toInt();
|
2009-12-24 20:16:07 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if ( compilation.isEmpty() ) {
|
|
|
|
// well, it wasn't set, but if the artist is VA assume it's a compilation
|
2010-01-15 22:57:22 +01:00
|
|
|
if ( d->artist_.toLower() == "various artists" )
|
|
|
|
d->compilation_ = true;
|
2009-12-24 20:16:07 +01:00
|
|
|
} else {
|
|
|
|
int i = compilation.toInt();
|
2010-01-15 22:57:22 +01:00
|
|
|
d->compilation_ = (i == 1);
|
2009-12-24 20:16:07 +01:00
|
|
|
}
|
|
|
|
|
2010-03-06 21:08:01 +01:00
|
|
|
if (fileref->audioProperties()) {
|
|
|
|
d->bitrate_ = fileref->audioProperties()->bitrate();
|
|
|
|
d->samplerate_ = fileref->audioProperties()->sampleRate();
|
2010-12-23 22:13:43 +01:00
|
|
|
set_length(fileref->audioProperties()->length());
|
2010-01-17 20:03:54 +01:00
|
|
|
}
|
2010-03-07 23:46:41 +01:00
|
|
|
|
|
|
|
// Get the filetype if we can
|
|
|
|
GuessFileType(fileref.get());
|
|
|
|
}
|
|
|
|
|
2010-10-17 18:03:49 +02:00
|
|
|
void Song::ParseFMPSFrame(const QString& name, const QString& value) {
|
|
|
|
FMPSParser parser;
|
|
|
|
if (!parser.Parse(value) || parser.is_empty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
QVariant var;
|
|
|
|
if (name == "FMPS_Rating") {
|
|
|
|
var = parser.result()[0][0];
|
|
|
|
if (var.type() == QVariant::Double) {
|
|
|
|
d->rating_ = var.toDouble();
|
|
|
|
}
|
|
|
|
} else if (name == "FMPS_Rating_User") {
|
|
|
|
// Take a user rating only if there's no rating already set
|
|
|
|
if (d->rating_ == -1 && parser.result()[0].count() >= 2) {
|
|
|
|
var = parser.result()[0][1];
|
|
|
|
if (var.type() == QVariant::Double) {
|
|
|
|
d->rating_ = var.toDouble();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
} else if (name == "FMPS_PlayCount") {
|
|
|
|
var = parser.result()[0][0];
|
|
|
|
if (var.type() == QVariant::Double) {
|
|
|
|
d->playcount_ = var.toDouble();
|
|
|
|
}
|
|
|
|
} else if (name == "FMPS_PlayCount_User") {
|
|
|
|
// Take a user rating only if there's no playcount already set
|
|
|
|
if (d->rating_ == -1 && parser.result()[0].count() >= 2) {
|
|
|
|
var = parser.result()[0][1];
|
|
|
|
if (var.type() == QVariant::Double) {
|
|
|
|
d->playcount_ = var.toDouble();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-09-15 21:24:31 +02:00
|
|
|
void Song::ParseOggTag(const TagLib::Ogg::FieldListMap& map, const QTextCodec* codec,
|
|
|
|
QString* disc, QString* compilation) {
|
|
|
|
if (!map["COMPOSER"].isEmpty())
|
|
|
|
d->composer_ = Decode(map["COMPOSER"].front(), codec);
|
|
|
|
|
|
|
|
if (!map["ALBUMARTIST"].isEmpty())
|
|
|
|
d->albumartist_ = Decode(map["ALBUMARTIST"].front(), codec);
|
|
|
|
|
|
|
|
if (!map["BPM"].isEmpty() )
|
|
|
|
d->bpm_ = TStringToQString( map["BPM"].front() ).trimmed().toFloat();
|
|
|
|
|
|
|
|
if (!map["DISCNUMBER"].isEmpty() )
|
|
|
|
*disc = TStringToQString( map["DISCNUMBER"].front() ).trimmed();
|
|
|
|
|
|
|
|
if (!map["COMPILATION"].isEmpty() )
|
|
|
|
*compilation = TStringToQString( map["COMPILATION"].front() ).trimmed();
|
2011-01-23 16:50:59 +01:00
|
|
|
|
|
|
|
if (!map["COVERART"].isEmpty())
|
2011-02-02 22:01:08 +01:00
|
|
|
set_embedded_cover();
|
2010-09-15 21:24:31 +02:00
|
|
|
}
|
|
|
|
|
2010-03-07 23:46:41 +01:00
|
|
|
void Song::GuessFileType(TagLib::FileRef* fileref) {
|
2010-03-16 16:09:08 +01:00
|
|
|
#ifdef TAGLIB_WITH_ASF
|
2010-03-07 23:46:41 +01:00
|
|
|
if (dynamic_cast<TagLib::ASF::File*>(fileref->file()))
|
|
|
|
d->filetype_ = Type_Asf;
|
2010-03-16 16:09:08 +01:00
|
|
|
#endif
|
2010-03-07 23:46:41 +01:00
|
|
|
if (dynamic_cast<TagLib::FLAC::File*>(fileref->file()))
|
|
|
|
d->filetype_ = Type_Flac;
|
2010-03-16 16:09:08 +01:00
|
|
|
#ifdef TAGLIB_WITH_MP4
|
2010-03-07 23:46:41 +01:00
|
|
|
if (dynamic_cast<TagLib::MP4::File*>(fileref->file()))
|
|
|
|
d->filetype_ = Type_Mp4;
|
2010-03-16 16:09:08 +01:00
|
|
|
#endif
|
2010-03-07 23:46:41 +01:00
|
|
|
if (dynamic_cast<TagLib::MPC::File*>(fileref->file()))
|
|
|
|
d->filetype_ = Type_Mpc;
|
|
|
|
if (dynamic_cast<TagLib::MPEG::File*>(fileref->file()))
|
|
|
|
d->filetype_ = Type_Mpeg;
|
|
|
|
if (dynamic_cast<TagLib::Ogg::FLAC::File*>(fileref->file()))
|
|
|
|
d->filetype_ = Type_OggFlac;
|
|
|
|
if (dynamic_cast<TagLib::Ogg::Speex::File*>(fileref->file()))
|
|
|
|
d->filetype_ = Type_OggSpeex;
|
|
|
|
if (dynamic_cast<TagLib::Ogg::Vorbis::File*>(fileref->file()))
|
|
|
|
d->filetype_ = Type_OggVorbis;
|
|
|
|
if (dynamic_cast<TagLib::RIFF::AIFF::File*>(fileref->file()))
|
|
|
|
d->filetype_ = Type_Aiff;
|
|
|
|
if (dynamic_cast<TagLib::RIFF::WAV::File*>(fileref->file()))
|
|
|
|
d->filetype_ = Type_Wav;
|
|
|
|
if (dynamic_cast<TagLib::TrueAudio::File*>(fileref->file()))
|
|
|
|
d->filetype_ = Type_TrueAudio;
|
2009-12-24 20:16:07 +01:00
|
|
|
}
|
|
|
|
|
2010-08-03 20:57:17 +02:00
|
|
|
void Song::InitFromQuery(const SqlRow& q, int col) {
|
2010-01-15 22:57:22 +01:00
|
|
|
d->valid_ = true;
|
2009-12-24 20:16:07 +01:00
|
|
|
|
2010-10-12 13:55:45 +02:00
|
|
|
d->init_from_file_ = true;
|
|
|
|
|
2009-12-24 20:16:07 +01:00
|
|
|
#define tostr(n) (q.value(n).isNull() ? QString::null : q.value(n).toString())
|
|
|
|
#define toint(n) (q.value(n).isNull() ? -1 : q.value(n).toInt())
|
|
|
|
#define tofloat(n) (q.value(n).isNull() ? -1 : q.value(n).toDouble())
|
|
|
|
|
2010-05-10 16:19:43 +02:00
|
|
|
d->id_ = toint(col + 0);
|
|
|
|
d->title_ = tostr(col + 1);
|
|
|
|
d->album_ = tostr(col + 2);
|
|
|
|
d->artist_ = tostr(col + 3);
|
|
|
|
d->albumartist_ = tostr(col + 4);
|
|
|
|
d->composer_ = tostr(col + 5);
|
|
|
|
d->track_ = toint(col + 6);
|
|
|
|
d->disc_ = toint(col + 7);
|
|
|
|
d->bpm_ = tofloat(col + 8);
|
|
|
|
d->year_ = toint(col + 9);
|
|
|
|
d->genre_ = tostr(col + 10);
|
|
|
|
d->comment_ = tostr(col + 11);
|
|
|
|
d->compilation_ = q.value(col + 12).toBool();
|
|
|
|
|
2011-01-04 18:12:29 +01:00
|
|
|
d->bitrate_ = toint(col + 13);
|
|
|
|
d->samplerate_ = toint(col + 14);
|
2010-05-10 16:19:43 +02:00
|
|
|
|
2011-01-04 18:12:29 +01:00
|
|
|
d->directory_id_ = toint(col + 15);
|
|
|
|
d->filename_ = tostr(col + 16);
|
2010-03-19 11:39:22 +01:00
|
|
|
d->basefilename_ = QFileInfo(d->filename_).fileName();
|
2011-01-04 18:12:29 +01:00
|
|
|
d->mtime_ = toint(col + 17);
|
|
|
|
d->ctime_ = toint(col + 18);
|
|
|
|
d->filesize_ = toint(col + 19);
|
2009-12-24 20:16:07 +01:00
|
|
|
|
2011-01-04 18:12:29 +01:00
|
|
|
d->sampler_ = q.value(col + 20).toBool();
|
2010-02-27 21:12:22 +01:00
|
|
|
|
2011-01-04 18:12:29 +01:00
|
|
|
d->art_automatic_ = q.value(col + 21).toString();
|
|
|
|
d->art_manual_ = q.value(col + 22).toString();
|
2010-02-28 01:35:20 +01:00
|
|
|
|
2011-01-04 18:12:29 +01:00
|
|
|
d->filetype_ = FileType(q.value(col + 23).toInt());
|
|
|
|
d->playcount_ = q.value(col + 24).isNull() ? 0 : q.value(col + 24).toInt();
|
|
|
|
d->lastplayed_ = toint(col + 25);
|
|
|
|
d->rating_ = tofloat(col + 26);
|
2010-03-07 23:46:41 +01:00
|
|
|
|
2011-01-04 18:12:29 +01:00
|
|
|
d->forced_compilation_on_ = q.value(col + 27).toBool();
|
|
|
|
d->forced_compilation_off_ = q.value(col + 28).toBool();
|
2010-03-21 00:59:39 +01:00
|
|
|
|
2011-01-04 18:12:29 +01:00
|
|
|
// effective_compilation = 29
|
2010-03-21 22:17:01 +01:00
|
|
|
|
2011-01-04 18:12:29 +01:00
|
|
|
d->skipcount_ = q.value(col + 30).isNull() ? 0 : q.value(col + 30).toInt();
|
|
|
|
d->score_ = q.value(col + 31).isNull() ? 0 : q.value(col + 31).toInt();
|
2010-11-01 22:15:52 +01:00
|
|
|
|
2011-01-04 18:12:29 +01:00
|
|
|
// do not move those statements - beginning must be initialized before
|
|
|
|
// length is!
|
|
|
|
d->beginning_ = q.value(col + 32).isNull() ? 0 : q.value(col + 32).toInt();
|
|
|
|
set_length(toint(col + 33));
|
2010-12-28 16:36:01 +01:00
|
|
|
|
2011-01-15 19:46:23 +01:00
|
|
|
d->cue_path_ = tostr(col + 34);
|
|
|
|
|
2009-12-24 20:16:07 +01:00
|
|
|
#undef tostr
|
|
|
|
#undef toint
|
|
|
|
#undef tofloat
|
|
|
|
}
|
|
|
|
|
2010-12-18 18:28:02 +01:00
|
|
|
#ifdef HAVE_LIBLASTFM
|
2009-12-26 23:15:57 +01:00
|
|
|
void Song::InitFromLastFM(const lastfm::Track& track) {
|
2010-01-15 22:57:22 +01:00
|
|
|
d->valid_ = true;
|
2010-03-07 23:46:41 +01:00
|
|
|
d->filetype_ = Type_Stream;
|
2009-12-26 23:15:57 +01:00
|
|
|
|
2010-01-15 22:57:22 +01:00
|
|
|
d->title_ = track.title();
|
|
|
|
d->album_ = track.album();
|
|
|
|
d->artist_ = track.artist();
|
|
|
|
d->track_ = track.trackNumber();
|
2010-12-23 22:13:43 +01:00
|
|
|
|
|
|
|
set_length(track.duration());
|
2009-12-26 23:15:57 +01:00
|
|
|
}
|
2010-12-18 18:28:02 +01:00
|
|
|
#endif // HAVE_LIBLASTFM
|
2009-12-26 23:15:57 +01:00
|
|
|
|
2010-07-04 22:52:45 +02:00
|
|
|
#ifdef HAVE_LIBGPOD
|
2010-08-08 19:41:06 +02:00
|
|
|
void Song::InitFromItdb(const Itdb_Track* track) {
|
2010-07-04 22:52:45 +02:00
|
|
|
d->valid_ = true;
|
|
|
|
|
|
|
|
d->title_ = QString::fromUtf8(track->title);
|
|
|
|
d->album_ = QString::fromUtf8(track->album);
|
|
|
|
d->artist_ = QString::fromUtf8(track->artist);
|
|
|
|
d->albumartist_ = QString::fromUtf8(track->albumartist);
|
|
|
|
d->composer_ = QString::fromUtf8(track->composer);
|
|
|
|
d->track_ = track->track_nr;
|
|
|
|
d->disc_ = track->cd_nr;
|
|
|
|
d->bpm_ = track->BPM;
|
|
|
|
d->year_ = track->year;
|
|
|
|
d->genre_ = QString::fromUtf8(track->genre);
|
|
|
|
d->comment_ = QString::fromUtf8(track->comment);
|
|
|
|
d->compilation_ = track->compilation;
|
2010-12-23 22:13:43 +01:00
|
|
|
set_length(track->tracklen / 1000);
|
2010-07-04 22:52:45 +02:00
|
|
|
d->bitrate_ = track->bitrate;
|
|
|
|
d->samplerate_ = track->samplerate;
|
|
|
|
d->mtime_ = track->time_modified;
|
|
|
|
d->ctime_ = track->time_added;
|
|
|
|
d->filesize_ = track->size;
|
|
|
|
d->filetype_ = track->type2 ? Type_Mpeg : Type_Mp4;
|
2010-10-17 18:03:49 +02:00
|
|
|
d->rating_ = float(track->rating) / 100; // 100 = 20 * 5 stars
|
|
|
|
d->playcount_ = track->playcount;
|
2010-10-17 19:50:20 +02:00
|
|
|
d->skipcount_ = track->skipcount;
|
|
|
|
d->lastplayed_ = track->time_played;
|
2010-07-04 22:52:45 +02:00
|
|
|
|
|
|
|
d->filename_ = QString::fromLocal8Bit(track->ipod_path);
|
2010-08-08 19:41:06 +02:00
|
|
|
d->filename_.replace(':', '/');
|
2010-07-04 22:52:45 +02:00
|
|
|
d->basefilename_ = QFileInfo(d->filename_).fileName();
|
|
|
|
}
|
2010-07-24 18:58:14 +02:00
|
|
|
|
|
|
|
void Song::ToItdb(Itdb_Track *track) const {
|
2010-08-08 19:45:57 +02:00
|
|
|
track->title = strdup(d->title_.toUtf8().constData());
|
|
|
|
track->album = strdup(d->album_.toUtf8().constData());
|
|
|
|
track->artist = strdup(d->artist_.toUtf8().constData());
|
|
|
|
track->albumartist = strdup(d->albumartist_.toUtf8().constData());
|
|
|
|
track->composer = strdup(d->composer_.toUtf8().constData());
|
2010-07-24 18:58:14 +02:00
|
|
|
track->track_nr = d->track_;
|
|
|
|
track->cd_nr = d->disc_;
|
|
|
|
track->BPM = d->bpm_;
|
|
|
|
track->year = d->year_;
|
2010-08-08 19:45:57 +02:00
|
|
|
track->genre = strdup(d->genre_.toUtf8().constData());
|
|
|
|
track->comment = strdup(d->comment_.toUtf8().constData());
|
2010-07-24 18:58:14 +02:00
|
|
|
track->compilation = d->compilation_;
|
2010-12-23 22:13:43 +01:00
|
|
|
track->tracklen = length() * 1000;
|
2010-07-24 18:58:14 +02:00
|
|
|
track->bitrate = d->bitrate_;
|
|
|
|
track->samplerate = d->samplerate_;
|
|
|
|
track->time_modified = d->mtime_;
|
|
|
|
track->time_added = d->ctime_;
|
|
|
|
track->size = d->filesize_;
|
2010-08-08 19:41:06 +02:00
|
|
|
track->type1 = 0;
|
2010-07-24 18:58:14 +02:00
|
|
|
track->type2 = d->filetype_ == Type_Mp4 ? 0 : 1;
|
2010-08-08 19:41:06 +02:00
|
|
|
track->mediatype = 1; // Audio
|
2010-10-17 18:03:49 +02:00
|
|
|
track->rating = d->rating_ * 100; // 100 = 20 * 5 stars
|
|
|
|
track->playcount = d->playcount_;
|
2010-10-17 19:50:20 +02:00
|
|
|
track->skipcount = d->skipcount_;
|
|
|
|
track->time_played = d->lastplayed_;
|
2010-07-24 18:58:14 +02:00
|
|
|
}
|
2010-07-04 22:52:45 +02:00
|
|
|
#endif
|
|
|
|
|
2010-08-14 17:57:05 +02:00
|
|
|
#ifdef HAVE_LIBMTP
|
|
|
|
void Song::InitFromMTP(const LIBMTP_track_t* track) {
|
|
|
|
d->valid_ = true;
|
|
|
|
|
|
|
|
d->title_ = QString::fromUtf8(track->title);
|
|
|
|
d->artist_ = QString::fromUtf8(track->artist);
|
|
|
|
d->album_ = QString::fromUtf8(track->album);
|
|
|
|
d->composer_ = QString::fromUtf8(track->composer);
|
|
|
|
d->genre_ = QString::fromUtf8(track->genre);
|
2010-08-14 19:06:38 +02:00
|
|
|
d->filename_ = QString::number(track->item_id);
|
2010-08-22 19:54:49 +02:00
|
|
|
d->basefilename_ = d->filename_;
|
2010-08-14 17:57:05 +02:00
|
|
|
|
|
|
|
d->track_ = track->tracknumber;
|
2010-12-23 22:13:43 +01:00
|
|
|
set_length(track->duration / 1000);
|
2010-08-14 17:57:05 +02:00
|
|
|
d->samplerate_ = track->samplerate;
|
|
|
|
d->bitrate_ = track->bitrate;
|
|
|
|
d->filesize_ = track->filesize;
|
|
|
|
d->mtime_ = track->modificationdate;
|
|
|
|
d->ctime_ = track->modificationdate;
|
|
|
|
|
2010-10-17 18:03:49 +02:00
|
|
|
d->rating_ = float(track->rating) / 100;
|
|
|
|
d->playcount_ = track->usecount;
|
|
|
|
|
2010-08-14 17:57:05 +02:00
|
|
|
switch (track->filetype) {
|
|
|
|
case LIBMTP_FILETYPE_WAV: d->filetype_ = Type_Wav; break;
|
|
|
|
case LIBMTP_FILETYPE_MP3: d->filetype_ = Type_Mpeg; break;
|
|
|
|
case LIBMTP_FILETYPE_WMA: d->filetype_ = Type_Asf; break;
|
|
|
|
case LIBMTP_FILETYPE_OGG: d->filetype_ = Type_OggVorbis; break;
|
|
|
|
case LIBMTP_FILETYPE_MP4: d->filetype_ = Type_Mp4; break;
|
|
|
|
case LIBMTP_FILETYPE_AAC: d->filetype_ = Type_Mp4; break;
|
|
|
|
case LIBMTP_FILETYPE_FLAC: d->filetype_ = Type_OggFlac; break;
|
|
|
|
case LIBMTP_FILETYPE_MP2: d->filetype_ = Type_Mpeg; break;
|
|
|
|
case LIBMTP_FILETYPE_M4A: d->filetype_ = Type_Mp4; break;
|
|
|
|
default: d->filetype_ = Type_Unknown; break;
|
|
|
|
}
|
|
|
|
}
|
2010-08-14 18:39:45 +02:00
|
|
|
|
|
|
|
void Song::ToMTP(LIBMTP_track_t* track) const {
|
|
|
|
track->item_id = 0;
|
|
|
|
track->parent_id = 0;
|
|
|
|
track->storage_id = 0;
|
|
|
|
|
|
|
|
track->title = strdup(d->title_.toUtf8().constData());
|
|
|
|
track->artist = strdup(d->artist_.toUtf8().constData());
|
|
|
|
track->album = strdup(d->album_.toUtf8().constData());
|
|
|
|
track->composer = strdup(d->composer_.toUtf8().constData());
|
|
|
|
track->genre = strdup(d->genre_.toUtf8().constData());
|
|
|
|
track->title = strdup(d->title_.toUtf8().constData());
|
|
|
|
track->date = NULL;
|
|
|
|
|
2010-08-22 19:54:49 +02:00
|
|
|
track->filename = strdup(d->basefilename_.toUtf8().constData());
|
|
|
|
|
2010-08-14 18:39:45 +02:00
|
|
|
track->tracknumber = d->track_;
|
2010-12-23 22:13:43 +01:00
|
|
|
track->duration = length() * 1000;
|
2010-08-14 18:39:45 +02:00
|
|
|
track->samplerate = d->samplerate_;
|
|
|
|
track->nochannels = 0;
|
|
|
|
track->wavecodec = 0;
|
|
|
|
track->bitrate = d->bitrate_;
|
|
|
|
track->bitratetype = 0;
|
2010-10-17 18:03:49 +02:00
|
|
|
track->rating = d->rating_ * 100;
|
|
|
|
track->usecount = d->playcount_;
|
2010-08-14 18:39:45 +02:00
|
|
|
track->filesize = d->filesize_;
|
|
|
|
track->modificationdate = d->mtime_;
|
|
|
|
|
|
|
|
switch (d->filetype_) {
|
|
|
|
case Type_Asf: track->filetype = LIBMTP_FILETYPE_ASF; break;
|
|
|
|
case Type_Mp4: track->filetype = LIBMTP_FILETYPE_MP4; break;
|
|
|
|
case Type_Mpeg: track->filetype = LIBMTP_FILETYPE_MP3; break;
|
|
|
|
case Type_Flac:
|
|
|
|
case Type_OggFlac: track->filetype = LIBMTP_FILETYPE_FLAC; break;
|
|
|
|
case Type_OggSpeex:
|
|
|
|
case Type_OggVorbis: track->filetype = LIBMTP_FILETYPE_OGG; break;
|
|
|
|
case Type_Wav: track->filetype = LIBMTP_FILETYPE_WAV; break;
|
|
|
|
default: track->filetype = LIBMTP_FILETYPE_UNDEF_AUDIO; break;
|
|
|
|
}
|
|
|
|
}
|
2010-08-14 17:57:05 +02:00
|
|
|
#endif
|
|
|
|
|
2010-08-23 21:13:27 +02:00
|
|
|
#ifdef Q_OS_WIN32
|
|
|
|
static void AddWmdmItem(IWMDMMetaData* metadata, const wchar_t* name,
|
|
|
|
const QVariant& value) {
|
|
|
|
switch (value.type()) {
|
|
|
|
case QVariant::Int:
|
|
|
|
case QVariant::UInt: {
|
|
|
|
DWORD data = value.toUInt();
|
|
|
|
metadata->AddItem(WMDM_TYPE_DWORD, name, (BYTE*)&data, sizeof(data));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case QVariant::String: {
|
|
|
|
ScopedWCharArray data(value.toString());
|
|
|
|
metadata->AddItem(WMDM_TYPE_STRING, name, (BYTE*)data.get(), data.bytes());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case QVariant::ByteArray: {
|
|
|
|
QByteArray data = value.toByteArray();
|
|
|
|
metadata->AddItem(WMDM_TYPE_BINARY, name, (BYTE*)data.constData(), data.size());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case QVariant::Bool: {
|
|
|
|
int data = value.toBool();
|
|
|
|
metadata->AddItem(WMDM_TYPE_BOOL, name, (BYTE*)&data, sizeof(data));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case QVariant::LongLong:
|
|
|
|
case QVariant::ULongLong: {
|
|
|
|
quint64 data = value.toULongLong();
|
|
|
|
metadata->AddItem(WMDM_TYPE_QWORD, name, (BYTE*)&data, sizeof(data));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
default:
|
2010-08-26 00:13:58 +02:00
|
|
|
qWarning() << "Type" << value.type() << "not handled";
|
2010-08-23 21:13:27 +02:00
|
|
|
Q_ASSERT(0);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static QVariant ReadWmdmValue(int type, uchar* data, uint length) {
|
|
|
|
switch (type) {
|
|
|
|
case WMDM_TYPE_DWORD:
|
|
|
|
return QVariant::fromValue(uint(*reinterpret_cast<DWORD*>(data)));
|
|
|
|
case WMDM_TYPE_WORD:
|
|
|
|
return QVariant::fromValue(uint(*reinterpret_cast<WORD*>(data)));
|
|
|
|
case WMDM_TYPE_QWORD:
|
|
|
|
return QVariant::fromValue(qulonglong(*reinterpret_cast<quint64*>(data)));
|
|
|
|
case WMDM_TYPE_STRING:
|
2010-08-28 15:23:33 +02:00
|
|
|
return QString::fromWCharArray(reinterpret_cast<wchar_t*>(data), length/2);
|
2010-08-23 21:13:27 +02:00
|
|
|
case WMDM_TYPE_BINARY:
|
|
|
|
return QByteArray(reinterpret_cast<char*>(data), length);
|
|
|
|
case WMDM_TYPE_BOOL:
|
|
|
|
return bool(*reinterpret_cast<int*>(data));
|
|
|
|
case WMDM_TYPE_GUID:
|
|
|
|
return QUuid(*reinterpret_cast<GUID*>(data)).toString();
|
|
|
|
}
|
|
|
|
return QVariant();
|
|
|
|
}
|
|
|
|
|
|
|
|
void Song::InitFromWmdm(IWMDMMetaData* metadata) {
|
|
|
|
bool non_consumable = false;
|
|
|
|
int format = 0;
|
|
|
|
|
|
|
|
// How much metadata is there?
|
|
|
|
uint count = 0;
|
|
|
|
metadata->GetItemCount(&count);
|
|
|
|
|
|
|
|
for (int i=0 ; i<count ; ++i) {
|
|
|
|
// Get this metadata item
|
|
|
|
wchar_t* name = NULL;
|
|
|
|
WMDM_TAG_DATATYPE type;
|
|
|
|
BYTE* value = NULL;
|
|
|
|
uint length = 0;
|
|
|
|
|
|
|
|
metadata->QueryByIndex(i, &name, &type, &value, &length);
|
|
|
|
|
|
|
|
QVariant item_value = ReadWmdmValue(type, value, length);
|
|
|
|
|
|
|
|
// Store it in the song if it's something we recognise
|
|
|
|
if (wcscmp(name, g_wszWMDMTitle) == 0)
|
|
|
|
d->title_ = item_value.toString();
|
|
|
|
|
|
|
|
else if (wcscmp(name, g_wszWMDMAuthor) == 0)
|
|
|
|
d->artist_ = item_value.toString();
|
|
|
|
|
|
|
|
else if (wcscmp(name, g_wszWMDMDescription) == 0)
|
|
|
|
d->comment_ = item_value.toString();
|
|
|
|
|
|
|
|
else if (wcscmp(name, g_wszWMDMAlbumTitle) == 0)
|
|
|
|
d->album_ = item_value.toString();
|
|
|
|
|
|
|
|
else if (wcscmp(name, g_wszWMDMTrack) == 0)
|
|
|
|
d->track_ = item_value.toInt();
|
|
|
|
|
|
|
|
else if (wcscmp(name, g_wszWMDMGenre) == 0)
|
|
|
|
d->genre_ = item_value.toString();
|
|
|
|
|
|
|
|
else if (wcscmp(name, g_wszWMDMYear) == 0)
|
|
|
|
d->year_ = item_value.toInt();
|
|
|
|
|
|
|
|
else if (wcscmp(name, g_wszWMDMComposer) == 0)
|
|
|
|
d->composer_ = item_value.toString();
|
|
|
|
|
|
|
|
else if (wcscmp(name, g_wszWMDMBitrate) == 0)
|
|
|
|
d->bitrate_ = item_value.toInt();
|
|
|
|
|
|
|
|
else if (wcscmp(name, g_wszWMDMFileName) == 0)
|
|
|
|
d->filename_ = item_value.toString();
|
|
|
|
|
|
|
|
else if (wcscmp(name, g_wszWMDMDuration) == 0)
|
2010-12-23 22:13:43 +01:00
|
|
|
set_length(item_value.toULongLong() / 10000000ll);
|
2010-08-23 21:13:27 +02:00
|
|
|
|
|
|
|
else if (wcscmp(name, L"WMDM/FileSize") == 0)
|
|
|
|
d->filesize_ = item_value.toULongLong();
|
|
|
|
|
|
|
|
else if (wcscmp(name, L"WMDM/NonConsumable") == 0)
|
|
|
|
non_consumable = item_value.toBool();
|
|
|
|
|
|
|
|
else if (wcscmp(name, L"WMDM/FormatCode") == 0)
|
|
|
|
format = item_value.toInt();
|
|
|
|
|
|
|
|
CoTaskMemFree(name);
|
|
|
|
CoTaskMemFree(value);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Decide if this is music or not
|
|
|
|
if (count == 0 || non_consumable)
|
|
|
|
return;
|
|
|
|
|
|
|
|
switch (format) {
|
|
|
|
case WMDM_FORMATCODE_AIFF:
|
|
|
|
d->filetype_ = Song::Type_Aiff;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WMDM_FORMATCODE_WAVE:
|
|
|
|
d->filetype_ = Song::Type_Wav;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WMDM_FORMATCODE_MP2:
|
|
|
|
case WMDM_FORMATCODE_MP3:
|
|
|
|
case WMDM_FORMATCODE_MPEG:
|
|
|
|
d->filetype_ = Song::Type_Mpeg;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WMDM_FORMATCODE_WMA:
|
|
|
|
case WMDM_FORMATCODE_ASF:
|
|
|
|
d->filetype_ = Song::Type_Asf;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WMDM_FORMATCODE_OGG:
|
|
|
|
d->filetype_ = Song::Type_OggVorbis;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WMDM_FORMATCODE_AAC:
|
|
|
|
case WMDM_FORMATCODE_MP4:
|
|
|
|
d->filetype_ = Song::Type_Mp4;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WMDM_FORMATCODE_FLAC:
|
|
|
|
d->filetype_ = Song::Type_Flac;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WMDM_FORMATCODE_AUDIBLE:
|
|
|
|
case WMDM_FORMATCODE_UNDEFINEDAUDIO:
|
|
|
|
d->filetype_ = Song::Type_Unknown;
|
|
|
|
break;
|
|
|
|
|
2010-08-28 15:23:33 +02:00
|
|
|
case WMDM_FORMATCODE_UNDEFINED:
|
|
|
|
// WMDM doesn't know what type of file it is, so we start guessing - first
|
|
|
|
// check if any of the music metadata fields were defined. If they were,
|
|
|
|
// there's a fairly good chance the file was music.
|
|
|
|
if (!d->title_.isEmpty() || !d->artist_.isEmpty() ||
|
|
|
|
!d->album_.isEmpty() || !d->comment_.isEmpty() ||
|
|
|
|
!d->genre_.isEmpty() || d->track_ != -1 || d->year_ != -1 ||
|
2010-12-23 22:13:43 +01:00
|
|
|
length() != -1) {
|
2010-08-28 15:23:33 +02:00
|
|
|
d->filetype_ = Song::Type_Unknown;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Make a final guess based on the file extension
|
|
|
|
{
|
|
|
|
QString ext = d->filename_.section('.', -1, -1).toLower();
|
|
|
|
if (ext == "mp3" || ext == "wma" || ext == "flac" || ext == "ogg" ||
|
|
|
|
ext == "spx" || ext == "mp4" || ext == "aac" || ext == "m4a")
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return;
|
|
|
|
|
2010-08-23 21:13:27 +02:00
|
|
|
default:
|
|
|
|
return; // It's not music
|
|
|
|
}
|
|
|
|
|
|
|
|
d->valid_ = true;
|
|
|
|
d->mtime_ = 0;
|
|
|
|
d->ctime_ = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Song::ToWmdm(IWMDMMetaData* metadata) const {
|
|
|
|
AddWmdmItem(metadata, g_wszWMDMTitle, d->title_);
|
|
|
|
AddWmdmItem(metadata, g_wszWMDMAuthor, d->artist_);
|
|
|
|
AddWmdmItem(metadata, g_wszWMDMDescription, d->comment_);
|
|
|
|
AddWmdmItem(metadata, g_wszWMDMAlbumTitle, d->album_);
|
|
|
|
AddWmdmItem(metadata, g_wszWMDMTrack, d->track_);
|
|
|
|
AddWmdmItem(metadata, g_wszWMDMGenre, d->genre_);
|
|
|
|
AddWmdmItem(metadata, g_wszWMDMYear, QString::number(d->year_));
|
|
|
|
AddWmdmItem(metadata, g_wszWMDMComposer, d->composer_);
|
|
|
|
AddWmdmItem(metadata, g_wszWMDMBitrate, d->bitrate_);
|
|
|
|
AddWmdmItem(metadata, g_wszWMDMFileName, d->basefilename_);
|
2010-12-23 22:13:43 +01:00
|
|
|
AddWmdmItem(metadata, g_wszWMDMDuration, qint64(length()) * 10000000ll);
|
2010-08-23 21:13:27 +02:00
|
|
|
AddWmdmItem(metadata, L"WMDM/FileSize", d->filesize_);
|
|
|
|
|
|
|
|
WMDM_FORMATCODE format;
|
|
|
|
switch (d->filetype_) {
|
|
|
|
case Type_Aiff: format = WMDM_FORMATCODE_AIFF; break;
|
|
|
|
case Type_Wav: format = WMDM_FORMATCODE_WAVE; break;
|
|
|
|
case Type_Mpeg: format = WMDM_FORMATCODE_MP3; break;
|
|
|
|
case Type_Asf: format = WMDM_FORMATCODE_ASF; break;
|
|
|
|
case Type_OggFlac:
|
|
|
|
case Type_OggSpeex:
|
|
|
|
case Type_OggVorbis: format = WMDM_FORMATCODE_OGG; break;
|
|
|
|
case Type_Mp4: format = WMDM_FORMATCODE_MP4; break;
|
|
|
|
case Type_Flac: format = WMDM_FORMATCODE_FLAC; break;
|
|
|
|
default: format = WMDM_FORMATCODE_UNDEFINEDAUDIO; break;
|
|
|
|
}
|
|
|
|
AddWmdmItem(metadata, L"WMDM/FormatCode", format);
|
|
|
|
}
|
|
|
|
#endif // Q_OS_WIN32
|
|
|
|
|
2010-04-21 16:04:40 +02:00
|
|
|
void Song::MergeFromSimpleMetaBundle(const Engine::SimpleMetaBundle &bundle) {
|
2010-02-03 23:20:31 +01:00
|
|
|
d->valid_ = true;
|
|
|
|
|
2010-10-12 13:55:45 +02:00
|
|
|
if (d->init_from_file_) {
|
|
|
|
// This Song was already loaded using taglib. Our tags are probably better than the engine's.
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2010-08-09 15:12:54 +02:00
|
|
|
UniversalEncodingHandler detector(NS_FILTER_NON_CJK);
|
|
|
|
QTextCodec* codec = detector.Guess(bundle);
|
|
|
|
|
|
|
|
if (!bundle.title.isEmpty()) d->title_ = Decode(bundle.title, codec);
|
|
|
|
if (!bundle.artist.isEmpty()) d->artist_ = Decode(bundle.artist, codec);
|
|
|
|
if (!bundle.album.isEmpty()) d->album_ = Decode(bundle.album, codec);
|
|
|
|
if (!bundle.comment.isEmpty()) d->comment_ = Decode(bundle.comment, codec);
|
|
|
|
if (!bundle.genre.isEmpty()) d->genre_ = Decode(bundle.genre, codec);
|
2010-04-21 16:04:40 +02:00
|
|
|
if (!bundle.bitrate.isEmpty()) d->bitrate_ = bundle.bitrate.toInt();
|
|
|
|
if (!bundle.samplerate.isEmpty()) d->samplerate_ = bundle.samplerate.toInt();
|
2010-12-23 22:13:43 +01:00
|
|
|
if (!bundle.length.isEmpty()) set_length(bundle.length.toInt());
|
2010-04-21 16:04:40 +02:00
|
|
|
if (!bundle.year.isEmpty()) d->year_ = bundle.year.toInt();
|
|
|
|
if (!bundle.tracknr.isEmpty()) d->track_ = bundle.tracknr.toInt();
|
2010-02-03 23:20:31 +01:00
|
|
|
}
|
|
|
|
|
2009-12-24 20:16:07 +01:00
|
|
|
void Song::BindToQuery(QSqlQuery *query) const {
|
2010-07-24 17:13:09 +02:00
|
|
|
#define strval(x) (x.isNull() ? "" : x)
|
|
|
|
#define intval(x) (x <= 0 ? -1 : x)
|
2010-06-18 02:11:15 +02:00
|
|
|
#define notnullintval(x) (x == -1 ? QVariant() : x)
|
2009-12-24 20:16:07 +01:00
|
|
|
|
2010-02-28 01:35:20 +01:00
|
|
|
// Remember to bind these in the same order as kBindSpec
|
|
|
|
|
2010-07-24 17:13:09 +02:00
|
|
|
query->bindValue(":title", strval(d->title_));
|
|
|
|
query->bindValue(":album", strval(d->album_));
|
|
|
|
query->bindValue(":artist", strval(d->artist_));
|
|
|
|
query->bindValue(":albumartist", strval(d->albumartist_));
|
|
|
|
query->bindValue(":composer", strval(d->composer_));
|
2010-01-15 22:57:22 +01:00
|
|
|
query->bindValue(":track", intval(d->track_));
|
|
|
|
query->bindValue(":disc", intval(d->disc_));
|
|
|
|
query->bindValue(":bpm", intval(d->bpm_));
|
|
|
|
query->bindValue(":year", intval(d->year_));
|
2010-07-24 17:13:09 +02:00
|
|
|
query->bindValue(":genre", strval(d->genre_));
|
|
|
|
query->bindValue(":comment", strval(d->comment_));
|
2010-01-15 22:57:22 +01:00
|
|
|
query->bindValue(":compilation", d->compilation_ ? 1 : 0);
|
|
|
|
|
|
|
|
query->bindValue(":bitrate", intval(d->bitrate_));
|
|
|
|
query->bindValue(":samplerate", intval(d->samplerate_));
|
|
|
|
|
2010-11-23 18:38:39 +01:00
|
|
|
query->bindValue(":directory", notnullintval(d->directory_id_));
|
2010-01-15 22:57:22 +01:00
|
|
|
query->bindValue(":filename", d->filename_);
|
2010-06-18 02:11:15 +02:00
|
|
|
query->bindValue(":mtime", notnullintval(d->mtime_));
|
|
|
|
query->bindValue(":ctime", notnullintval(d->ctime_));
|
|
|
|
query->bindValue(":filesize", notnullintval(d->filesize_));
|
2009-12-24 20:16:07 +01:00
|
|
|
|
2010-02-27 21:12:22 +01:00
|
|
|
query->bindValue(":sampler", d->sampler_ ? 1 : 0);
|
2010-02-28 01:35:20 +01:00
|
|
|
query->bindValue(":art_automatic", d->art_automatic_);
|
|
|
|
query->bindValue(":art_manual", d->art_manual_);
|
2010-02-27 21:12:22 +01:00
|
|
|
|
2010-03-07 23:46:41 +01:00
|
|
|
query->bindValue(":filetype", d->filetype_);
|
2010-10-17 18:03:49 +02:00
|
|
|
query->bindValue(":playcount", d->playcount_);
|
2010-10-17 19:50:20 +02:00
|
|
|
query->bindValue(":lastplayed", intval(d->lastplayed_));
|
2010-10-17 18:03:49 +02:00
|
|
|
query->bindValue(":rating", intval(d->rating_));
|
2010-03-07 23:46:41 +01:00
|
|
|
|
2010-03-21 14:50:00 +01:00
|
|
|
query->bindValue(":forced_compilation_on", d->forced_compilation_on_ ? 1 : 0);
|
|
|
|
query->bindValue(":forced_compilation_off", d->forced_compilation_off_ ? 1 : 0);
|
2010-03-21 00:59:39 +01:00
|
|
|
|
2010-03-21 22:17:01 +01:00
|
|
|
query->bindValue(":effective_compilation", is_compilation() ? 1 : 0);
|
|
|
|
|
2010-10-17 19:50:20 +02:00
|
|
|
query->bindValue(":skipcount", d->skipcount_);
|
2010-11-01 22:15:52 +01:00
|
|
|
query->bindValue(":score", d->score_);
|
|
|
|
|
2010-12-28 16:36:01 +01:00
|
|
|
query->bindValue(":beginning", d->beginning_);
|
2011-01-04 18:12:29 +01:00
|
|
|
query->bindValue(":length", intval(length()));
|
2010-12-28 16:36:01 +01:00
|
|
|
|
2011-01-15 19:46:23 +01:00
|
|
|
query->bindValue(":cue_path", d->cue_path_);
|
|
|
|
|
2009-12-24 20:16:07 +01:00
|
|
|
#undef intval
|
2010-06-18 02:11:15 +02:00
|
|
|
#undef notnullintval
|
2009-12-24 20:16:07 +01:00
|
|
|
}
|
|
|
|
|
2010-06-20 18:30:10 +02:00
|
|
|
void Song::BindToFtsQuery(QSqlQuery *query) const {
|
|
|
|
query->bindValue(":ftstitle", d->title_);
|
|
|
|
query->bindValue(":ftsalbum", d->album_);
|
|
|
|
query->bindValue(":ftsartist", d->artist_);
|
|
|
|
query->bindValue(":ftsalbumartist", d->albumartist_);
|
|
|
|
query->bindValue(":ftscomposer", d->composer_);
|
|
|
|
query->bindValue(":ftsgenre", d->genre_);
|
|
|
|
query->bindValue(":ftscomment", d->comment_);
|
|
|
|
}
|
|
|
|
|
2010-12-18 18:28:02 +01:00
|
|
|
#ifdef HAVE_LIBLASTFM
|
2009-12-29 20:22:02 +01:00
|
|
|
void Song::ToLastFM(lastfm::Track* track) const {
|
|
|
|
lastfm::MutableTrack mtrack(*track);
|
|
|
|
|
2010-01-15 22:57:22 +01:00
|
|
|
mtrack.setArtist(d->artist_);
|
|
|
|
mtrack.setAlbum(d->album_);
|
|
|
|
mtrack.setTitle(d->title_);
|
2010-12-23 22:13:43 +01:00
|
|
|
mtrack.setDuration(length());
|
2010-01-15 22:57:22 +01:00
|
|
|
mtrack.setTrackNumber(d->track_);
|
2010-02-22 22:26:49 +01:00
|
|
|
mtrack.setSource(lastfm::Track::Player);
|
2009-12-29 20:22:02 +01:00
|
|
|
}
|
2010-12-18 18:28:02 +01:00
|
|
|
#endif // HAVE_LIBLASTFM
|
2009-12-29 20:22:02 +01:00
|
|
|
|
2010-11-21 22:36:27 +01:00
|
|
|
QString Song::PrettyTitle() const {
|
2010-01-15 22:57:22 +01:00
|
|
|
QString title(d->title_);
|
2009-12-24 20:16:07 +01:00
|
|
|
|
|
|
|
if (title.isEmpty())
|
2010-12-18 21:40:35 +01:00
|
|
|
title = d->basefilename_;
|
2009-12-24 20:16:07 +01:00
|
|
|
|
|
|
|
return title;
|
|
|
|
}
|
|
|
|
|
2010-11-21 22:36:27 +01:00
|
|
|
QString Song::PrettyTitleWithArtist() const {
|
2010-01-15 22:57:22 +01:00
|
|
|
QString title(d->title_);
|
2009-12-24 20:16:07 +01:00
|
|
|
|
|
|
|
if (title.isEmpty())
|
2010-12-18 21:40:35 +01:00
|
|
|
title = d->basefilename_;
|
2009-12-24 20:16:07 +01:00
|
|
|
|
2010-11-21 22:36:27 +01:00
|
|
|
if (!d->artist_.isEmpty())
|
|
|
|
title = d->artist_ + " - " + title;
|
|
|
|
|
2009-12-24 20:16:07 +01:00
|
|
|
return title;
|
|
|
|
}
|
|
|
|
|
|
|
|
QString Song::PrettyLength() const {
|
2010-12-23 22:13:43 +01:00
|
|
|
if (length() == -1)
|
2009-12-24 20:16:07 +01:00
|
|
|
return QString::null;
|
|
|
|
|
2010-12-23 22:13:43 +01:00
|
|
|
return Utilities::PrettyTime(length());
|
2009-12-24 20:16:07 +01:00
|
|
|
}
|
|
|
|
|
2010-12-06 00:41:41 +01:00
|
|
|
QString Song::PrettyYear() const {
|
|
|
|
if (d->year_ == -1)
|
|
|
|
return QString::null;
|
|
|
|
|
|
|
|
return QString::number(d->year_);
|
|
|
|
}
|
|
|
|
|
2010-11-21 22:36:27 +01:00
|
|
|
QString Song::TitleWithCompilationArtist() const {
|
|
|
|
QString title(d->title_);
|
|
|
|
|
|
|
|
if (title.isEmpty())
|
2010-12-18 21:40:35 +01:00
|
|
|
title = d->basefilename_;
|
2010-11-21 22:36:27 +01:00
|
|
|
|
|
|
|
if (is_compilation() && !d->artist_.isEmpty() && !d->artist_.toLower().contains("various"))
|
|
|
|
title = d->artist_ + " - " + title;
|
|
|
|
|
|
|
|
return title;
|
|
|
|
}
|
|
|
|
|
2009-12-24 20:16:07 +01:00
|
|
|
bool Song::IsMetadataEqual(const Song& other) const {
|
2010-01-15 22:57:22 +01:00
|
|
|
return d->title_ == other.d->title_ &&
|
|
|
|
d->album_ == other.d->album_ &&
|
|
|
|
d->artist_ == other.d->artist_ &&
|
|
|
|
d->albumartist_ == other.d->albumartist_ &&
|
|
|
|
d->composer_ == other.d->composer_ &&
|
|
|
|
d->track_ == other.d->track_ &&
|
|
|
|
d->disc_ == other.d->disc_ &&
|
|
|
|
qFuzzyCompare(d->bpm_, other.d->bpm_) &&
|
|
|
|
d->year_ == other.d->year_ &&
|
|
|
|
d->genre_ == other.d->genre_ &&
|
|
|
|
d->comment_ == other.d->comment_ &&
|
|
|
|
d->compilation_ == other.d->compilation_ &&
|
2010-12-28 16:36:01 +01:00
|
|
|
d->beginning_ == other.d->beginning_ &&
|
2010-12-23 22:13:43 +01:00
|
|
|
length() == other.length() &&
|
2010-01-15 22:57:22 +01:00
|
|
|
d->bitrate_ == other.d->bitrate_ &&
|
2010-02-28 01:35:20 +01:00
|
|
|
d->samplerate_ == other.d->samplerate_ &&
|
|
|
|
d->sampler_ == other.d->sampler_ &&
|
|
|
|
d->art_automatic_ == other.d->art_automatic_ &&
|
2011-01-15 19:46:23 +01:00
|
|
|
d->art_manual_ == other.d->art_manual_ &&
|
|
|
|
d->cue_path_ == other.d->cue_path_;
|
2009-12-24 20:16:07 +01:00
|
|
|
}
|
2010-01-16 17:12:47 +01:00
|
|
|
|
2010-03-29 15:28:29 +02:00
|
|
|
void Song::SetTextFrame(const QString& id, const QString& value,
|
|
|
|
TagLib::ID3v2::Tag* tag) {
|
2010-03-29 15:15:47 +02:00
|
|
|
TagLib::ByteVector id_vector = id.toUtf8().constData();
|
|
|
|
|
|
|
|
// Remove the frame if it already exists
|
|
|
|
while (tag->frameListMap().contains(id_vector) &&
|
|
|
|
tag->frameListMap()[id_vector].size() != 0) {
|
|
|
|
tag->removeFrame(tag->frameListMap()[id_vector].front());
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create and add a new frame
|
|
|
|
TagLib::ID3v2::TextIdentificationFrame* frame =
|
|
|
|
new TagLib::ID3v2::TextIdentificationFrame(id.toUtf8().constData(),
|
|
|
|
TagLib::String::UTF8);
|
|
|
|
frame->setText(QStringToTaglibString(value));
|
|
|
|
tag->addFrame(frame);
|
|
|
|
}
|
|
|
|
|
|
|
|
TagLib::String QStringToTaglibString(const QString& s) {
|
|
|
|
return TagLib::String(s.toUtf8().constData(), TagLib::String::UTF8);
|
|
|
|
}
|
|
|
|
|
2010-06-25 01:36:39 +02:00
|
|
|
bool Song::IsEditable() const {
|
|
|
|
return d->valid_ && !d->filename_.isNull() &&
|
|
|
|
d->filetype_ != Type_Stream && d->filetype_ != Type_Unknown;
|
|
|
|
}
|
|
|
|
|
2010-01-16 17:12:47 +01:00
|
|
|
bool Song::Save() const {
|
|
|
|
if (d->filename_.isNull())
|
|
|
|
return false;
|
|
|
|
|
2010-08-08 14:35:23 +02:00
|
|
|
QMutexLocker l(&taglib_mutex_);
|
2010-03-29 15:15:47 +02:00
|
|
|
scoped_ptr<TagLib::FileRef> fileref(factory_->GetFileRef(d->filename_));
|
2010-02-23 15:52:22 +01:00
|
|
|
|
2010-04-27 19:37:26 +02:00
|
|
|
if (!fileref || fileref->isNull()) // The file probably doesn't exist
|
|
|
|
return false;
|
|
|
|
|
2010-03-29 15:15:47 +02:00
|
|
|
fileref->tag()->setTitle(QStringToTaglibString(d->title_));
|
|
|
|
fileref->tag()->setArtist(QStringToTaglibString(d->artist_));
|
|
|
|
fileref->tag()->setAlbum(QStringToTaglibString(d->album_));
|
|
|
|
fileref->tag()->setGenre(QStringToTaglibString(d->genre_));
|
|
|
|
fileref->tag()->setComment(QStringToTaglibString(d->comment_));
|
|
|
|
fileref->tag()->setYear(d->year_);
|
|
|
|
fileref->tag()->setTrack(d->track_);
|
2010-01-16 17:12:47 +01:00
|
|
|
|
2010-03-29 15:15:47 +02:00
|
|
|
if (TagLib::MPEG::File* file = dynamic_cast<TagLib::MPEG::File*>(fileref->file())) {
|
|
|
|
TagLib::ID3v2::Tag* tag = file->ID3v2Tag(true);
|
2010-03-29 15:28:29 +02:00
|
|
|
SetTextFrame("TPOS", d->disc_ <= 0 -1 ? QString() : QString::number(d->disc_), tag);
|
|
|
|
SetTextFrame("TBPM", d->bpm_ <= 0 -1 ? QString() : QString::number(d->bpm_), tag);
|
|
|
|
SetTextFrame("TCOM", d->composer_, tag);
|
|
|
|
SetTextFrame("TPE2", d->albumartist_, tag);
|
|
|
|
SetTextFrame("TCMP", d->compilation_ ? "1" : "0", tag);
|
2010-03-29 15:15:47 +02:00
|
|
|
}
|
|
|
|
else if (TagLib::Ogg::Vorbis::File* file = dynamic_cast<TagLib::Ogg::Vorbis::File*>(fileref->file())) {
|
|
|
|
TagLib::Ogg::XiphComment* tag = file->tag();
|
|
|
|
tag->addField("COMPOSER", QStringToTaglibString(d->composer_), true);
|
|
|
|
tag->addField("BPM", QStringToTaglibString(d->bpm_ <= 0 -1 ? QString() : QString::number(d->bpm_)), true);
|
|
|
|
tag->addField("DISCNUMBER", QStringToTaglibString(d->disc_ <= 0 -1 ? QString() : QString::number(d->disc_)), true);
|
|
|
|
tag->addField("COMPILATION", QStringToTaglibString(d->compilation_ ? "1" : "0"), true);
|
|
|
|
}
|
|
|
|
else if (TagLib::FLAC::File* file = dynamic_cast<TagLib::FLAC::File*>(fileref->file())) {
|
|
|
|
TagLib::Ogg::XiphComment* tag = file->xiphComment();
|
|
|
|
tag->addField("COMPOSER", QStringToTaglibString(d->composer_), true);
|
|
|
|
tag->addField("BPM", QStringToTaglibString(d->bpm_ <= 0 -1 ? QString() : QString::number(d->bpm_)), true);
|
|
|
|
tag->addField("DISCNUMBER", QStringToTaglibString(d->disc_ <= 0 -1 ? QString() : QString::number(d->disc_)), true);
|
|
|
|
tag->addField("COMPILATION", QStringToTaglibString(d->compilation_ ? "1" : "0"), true);
|
|
|
|
}
|
2010-02-23 15:52:22 +01:00
|
|
|
|
2010-03-29 15:15:47 +02:00
|
|
|
bool ret = fileref->save();
|
2010-02-10 14:15:18 +01:00
|
|
|
#ifdef Q_OS_LINUX
|
2010-01-16 18:17:00 +01:00
|
|
|
if (ret) {
|
|
|
|
// Linux: inotify doesn't seem to notice the change to the file unless we
|
|
|
|
// change the timestamps as well. (this is what touch does)
|
|
|
|
utimensat(0, QFile::encodeName(d->filename_).constData(), NULL, 0);
|
|
|
|
}
|
2010-02-10 14:15:18 +01:00
|
|
|
#endif // Q_OS_LINUX
|
2010-01-16 18:17:00 +01:00
|
|
|
|
|
|
|
return ret;
|
2010-01-16 17:12:47 +01:00
|
|
|
}
|
2010-08-02 16:00:43 +02:00
|
|
|
|
|
|
|
bool Song::Save(const Song& song) {
|
|
|
|
return song.Save();
|
|
|
|
}
|
|
|
|
|
|
|
|
QFuture<bool> Song::BackgroundSave() const {
|
|
|
|
QFuture<bool> future = QtConcurrent::run(&Song::Save, Song(*this));
|
|
|
|
return future;
|
|
|
|
}
|
2011-01-17 00:46:58 +01:00
|
|
|
|
|
|
|
bool Song::operator==(const Song& other) const {
|
|
|
|
// TODO: this isn't working for radios
|
|
|
|
return filename() == other.filename() &&
|
|
|
|
beginning() == other.beginning();
|
|
|
|
}
|
2011-01-24 21:06:59 +01:00
|
|
|
|
|
|
|
QImage Song::LoadEmbeddedArt(const QString& filename) {
|
|
|
|
QImage ret;
|
|
|
|
if (filename.isEmpty())
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
QMutexLocker l(&taglib_mutex_);
|
|
|
|
|
|
|
|
#ifdef Q_OS_WIN32
|
|
|
|
TagLib::FileRef ref(filename.toStdWString().c_str());
|
|
|
|
#else
|
|
|
|
TagLib::FileRef ref(QFile::encodeName(filename).constData());
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if (ref.isNull() || !ref.file())
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
// MP3
|
|
|
|
TagLib::MPEG::File* file = dynamic_cast<TagLib::MPEG::File*>(ref.file());
|
|
|
|
if (file && file->ID3v2Tag()) {
|
|
|
|
TagLib::ID3v2::FrameList apic_frames = file->ID3v2Tag()->frameListMap()["APIC"];
|
|
|
|
if (apic_frames.isEmpty())
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
TagLib::ID3v2::AttachedPictureFrame* pic =
|
|
|
|
static_cast<TagLib::ID3v2::AttachedPictureFrame*>(apic_frames.front());
|
|
|
|
|
|
|
|
ret.loadFromData((const uchar*) pic->picture().data(), pic->picture().size());
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Ogg vorbis/flac/speex
|
|
|
|
TagLib::Ogg::XiphComment* xiph_comment =
|
|
|
|
dynamic_cast<TagLib::Ogg::XiphComment*>(ref.file()->tag());
|
|
|
|
|
|
|
|
if (xiph_comment) {
|
|
|
|
TagLib::Ogg::FieldListMap map = xiph_comment->fieldListMap();
|
|
|
|
|
|
|
|
// Ogg lacks a definitive standard for embedding cover art, but it seems
|
|
|
|
// b64 encoding a field called COVERART is the general convention
|
|
|
|
if (!map.contains("COVERART"))
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
QByteArray image_data_b64(map["COVERART"].toString().toCString());
|
|
|
|
QByteArray image_data = QByteArray::fromBase64(image_data_b64);
|
|
|
|
|
|
|
|
if (!ret.loadFromData(image_data))
|
|
|
|
ret.loadFromData(image_data_b64); //maybe it's not b64 after all
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|