← Back to branch summary

~ubuntu-branches/debian/jessie/acoustid-fingerprinter/jessie

« back to all changes in this revision

Viewing changes to tagreader.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Clint Adams
  • Date: 2011-08-25 21:10:42 UTC
  • mto: This revision was merged to the branch mainline in revision 3.
  • Revision ID: james.westby@ubuntu.com-20110825211042-tfmm24qz1hu5malg
Tags: upstream-0.4
Import upstream version 0.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
tagreader.cpp
16
16
#endif
17
17
#include <mpegfile.h>
18
18
#include <id3v2tag.h>
 
19
#include <textidentificationframe.h>
19
20
#include <uniquefileidentifierframe.h>
20
21
#include "tagreader.h"
21
22
 
22
23
QMutex TagReader::m_mutex;
23
24
 
24
25
TagReader::TagReader(const QString &fileName)
25
 
    : m_fileName(fileName)
 
26
    : m_fileName(fileName), m_trackNo(0), m_discNo(0), m_year(0)
26
27
{
27
28
}
28
29
 
30
31
{
31
32
}
32
33
 
33
 
#define DISPATCH_TAGLIB_FILE(type, file) \
 
34
#define TAGLIB_STRING_TO_QSTRING(a) QString::fromStdWString((a).toWString())
 
35
 
 
36
#define DISPATCH_TAGLIB_FILE(tr, type, file) \
34
37
        { \
35
38
                type *tmp = dynamic_cast<type *>(file); \
36
39
                if (tmp) { \
37
 
                        return extractMBIDFromFile(tmp); \
 
40
                        extractMetaFromFile(tr, tmp); \
 
41
                        return; \
38
42
                } \
39
43
        }
40
44
 
41
 
QString extractMBIDFromXiphComment(TagLib::Ogg::XiphComment *tag)
 
45
void extractMetaFromXiphComment(TagReader *tr, TagLib::Ogg::XiphComment *tag)
42
46
{
43
47
        const char *key = "MUSICBRAINZ_TRACKID"; 
44
48
        if (tag->fieldListMap().contains(key)) {
45
 
                return QString::fromUtf8(tag->fieldListMap()[key].front().toCString(true));
46
 
        }
47
 
        return QString();
 
49
                tr->m_mbid = TAGLIB_STRING_TO_QSTRING(tag->fieldListMap()[key].front());
 
50
        }
 
51
        key = "ALBUMARTIST"; 
 
52
        if (tag->fieldListMap().contains(key)) {
 
53
                tr->m_albumArtist = TAGLIB_STRING_TO_QSTRING(tag->fieldListMap()[key].front());
 
54
        }
 
55
        key = "DISCNUMBER"; 
 
56
        if (tag->fieldListMap().contains(key)) {
 
57
                tr->m_discNo = tag->fieldListMap()[key].front().toInt();
 
58
        }
 
59
        key = "MUSICIP_PUID";
 
60
        if (tag->fieldListMap().contains(key)) {
 
61
                tr->m_puid = TAGLIB_STRING_TO_QSTRING(tag->fieldListMap()[key].front());
 
62
        }
48
63
}
49
64
 
50
 
QString extractMBIDFromAPETag(TagLib::APE::Tag *tag)
 
65
void extractMetaFromAPETag(TagReader *tr, TagLib::APE::Tag *tag)
51
66
{
52
67
        const char *key = "MUSICBRAINZ_TRACKID";
53
68
        if (tag->itemListMap().contains(key)) {
54
 
                return QString::fromUtf8(tag->itemListMap()[key].toString().toCString(true));
55
 
        }
56
 
        return QString();
57
 
}
58
 
 
59
 
QString extractMBIDFromFile(TagLib::Ogg::Vorbis::File *file)
60
 
{
61
 
        return extractMBIDFromXiphComment(file->tag());
62
 
}
63
 
 
64
 
QString extractMBIDFromFile(TagLib::Ogg::FLAC::File *file)
65
 
{
66
 
        return extractMBIDFromXiphComment(file->tag());
67
 
}
68
 
 
69
 
QString extractMBIDFromFile(TagLib::Ogg::Speex::File *file)
70
 
{
71
 
        return extractMBIDFromXiphComment(file->tag());
72
 
}
73
 
 
74
 
QString extractMBIDFromFile(TagLib::FLAC::File *file)
75
 
{
76
 
        return extractMBIDFromXiphComment(file->xiphComment());
77
 
}
78
 
 
79
 
QString extractMBIDFromFile(TagLib::MPC::File *file)
80
 
{
81
 
        return extractMBIDFromAPETag(file->APETag());
82
 
}
83
 
 
84
 
QString extractMBIDFromFile(TagLib::WavPack::File *file)
85
 
{
86
 
        return extractMBIDFromAPETag(file->APETag());
 
69
                tr->m_mbid = TAGLIB_STRING_TO_QSTRING(tag->itemListMap()[key].toString());
 
70
        }
 
71
        key = "ALBUM ARTIST"; // Foobar
 
72
        if (tag->itemListMap().contains(key)) {
 
73
                tr->m_albumArtist = TAGLIB_STRING_TO_QSTRING(tag->itemListMap()[key].toString());
 
74
        }
 
75
        key = "ALBUMARTIST"; // Picard
 
76
        if (tag->itemListMap().contains(key)) {
 
77
                tr->m_albumArtist = TAGLIB_STRING_TO_QSTRING(tag->itemListMap()[key].toString());
 
78
        }
 
79
        key = "DISC"; 
 
80
        if (tag->itemListMap().contains(key)) {
 
81
                tr->m_discNo = tag->itemListMap()[key].toString().toInt();
 
82
        }
 
83
        key = "MUSICIP_PUID";
 
84
        if (tag->itemListMap().contains(key)) {
 
85
                tr->m_puid = TAGLIB_STRING_TO_QSTRING(tag->itemListMap()[key].toString());
 
86
        }
 
87
}
 
88
 
 
89
void extractMetaFromFile(TagReader *tr, TagLib::Ogg::Vorbis::File *file)
 
90
{
 
91
        extractMetaFromXiphComment(tr, file->tag());
 
92
}
 
93
 
 
94
void extractMetaFromFile(TagReader *tr, TagLib::Ogg::FLAC::File *file)
 
95
{
 
96
        extractMetaFromXiphComment(tr, file->tag());
 
97
}
 
98
 
 
99
void extractMetaFromFile(TagReader *tr, TagLib::Ogg::Speex::File *file)
 
100
{
 
101
        extractMetaFromXiphComment(tr, file->tag());
 
102
}
 
103
 
 
104
void extractMetaFromFile(TagReader *tr, TagLib::FLAC::File *file)
 
105
{
 
106
        extractMetaFromXiphComment(tr, file->xiphComment());
 
107
}
 
108
 
 
109
void extractMetaFromFile(TagReader *tr, TagLib::MPC::File *file)
 
110
{
 
111
        extractMetaFromAPETag(tr, file->APETag());
 
112
}
 
113
 
 
114
void extractMetaFromFile(TagReader *tr, TagLib::WavPack::File *file)
 
115
{
 
116
        extractMetaFromAPETag(tr, file->APETag());
87
117
}
88
118
 
89
119
#ifdef TAGLIB_WITH_ASF
90
 
QString extractMBIDFromFile(TagLib::ASF::File *file)
 
120
void extractMetaFromFile(TagReader *tr, TagLib::ASF::File *file)
91
121
{
92
122
        const char *key = "MusicBrainz/Track Id";
93
123
        TagLib::ASF::Tag *tag = file->tag();
94
124
        if (tag->attributeListMap().contains(key)) {
95
 
                return QString::fromUtf8(tag->attributeListMap()[key].front().toString().toCString(true));
96
 
        }
97
 
        return QString();
 
125
                tr->m_mbid = TAGLIB_STRING_TO_QSTRING(tag->attributeListMap()[key].front().toString());
 
126
        }
 
127
        key = "WM/AlbumArtist";
 
128
        if (tag->attributeListMap().contains(key)) {
 
129
                tr->m_albumArtist = TAGLIB_STRING_TO_QSTRING(tag->attributeListMap()[key].front().toString());
 
130
        }
 
131
        key = "WM/PartOfSet";
 
132
        if (tag->attributeListMap().contains(key)) {
 
133
                tr->m_discNo = tag->attributeListMap()[key].front().toString().toInt();
 
134
        }
 
135
        key = "MusicIP/PUID";
 
136
        if (tag->attributeListMap().contains(key)) {
 
137
                tr->m_puid = TAGLIB_STRING_TO_QSTRING(tag->attributeListMap()[key].front().toString());
 
138
        }
98
139
}
99
140
#endif
100
141
 
101
142
#ifdef TAGLIB_WITH_MP4
102
 
QString extractMBIDFromFile(TagLib::MP4::File *file)
 
143
void extractMetaFromFile(TagReader *tr, TagLib::MP4::File *file)
103
144
{
104
145
        const char *key = "----:com.apple.iTunes:MusicBrainz Track Id";
105
146
        TagLib::MP4::Tag *tag = file->tag();
106
147
        if (tag->itemListMap().contains(key)) {
107
 
                return QString::fromUtf8(tag->itemListMap()[key].toStringList().toString().toCString(true));
108
 
        }
109
 
        return QString();
 
148
                tr->m_mbid = TAGLIB_STRING_TO_QSTRING(tag->itemListMap()[key].toStringList().toString());
 
149
        }
 
150
        key = "aART";
 
151
        if (tag->itemListMap().contains(key)) {
 
152
                tr->m_albumArtist = TAGLIB_STRING_TO_QSTRING(tag->itemListMap()[key].toStringList().toString());
 
153
        }
 
154
        key = "disk";
 
155
        if (tag->itemListMap().contains(key)) {
 
156
                tr->m_discNo = tag->itemListMap()[key].toIntPair().first;
 
157
        }
 
158
        key = "----:com.apple.iTunes:MusicIP PUID";
 
159
        if (tag->itemListMap().contains(key)) {
 
160
                tr->m_puid = TAGLIB_STRING_TO_QSTRING(tag->itemListMap()[key].toStringList().toString());
 
161
        }
110
162
}
111
163
#endif
112
164
 
113
 
QString extractMBIDFromFile(TagLib::MPEG::File *file)
 
165
void extractMetaFromFile(TagReader *tr, TagLib::MPEG::File *file)
114
166
{
115
167
        TagLib::ID3v2::Tag *tag = file->ID3v2Tag();
116
168
        TagLib::ID3v2::FrameList ufid = tag->frameListMap()["UFID"];
119
171
                        TagLib::ID3v2::UniqueFileIdentifierFrame *frame = dynamic_cast<TagLib::ID3v2::UniqueFileIdentifierFrame *>(*i);
120
172
                        if (frame && frame->owner() == "http://musicbrainz.org") {
121
173
                                TagLib::ByteVector id = frame->identifier();
122
 
                                return QString::fromAscii(id.data(), id.size());
 
174
                                tr->m_mbid = QString::fromAscii(id.data(), id.size());
123
175
                        }
124
176
                }
125
177
        }
126
 
        return QString();
 
178
        TagLib::ID3v2::FrameList tpe2 = tag->frameListMap()["TPE2"];
 
179
        if (!tpe2.isEmpty()) {
 
180
                tr->m_albumArtist = TAGLIB_STRING_TO_QSTRING(tpe2.front()->toString());
 
181
        }
 
182
        TagLib::ID3v2::FrameList tpos = tag->frameListMap()["TPOS"];
 
183
        if (!tpos.isEmpty()) {
 
184
                tr->m_discNo = tpos.front()->toString().toInt();
 
185
        }
 
186
        TagLib::ID3v2::UserTextIdentificationFrame *puidFrame = TagLib::ID3v2::UserTextIdentificationFrame::find(tag, "MusicIP PUID");
 
187
        if (puidFrame) {
 
188
                TagLib::StringList texts = puidFrame->fieldList();
 
189
                if (texts.size() > 1) {
 
190
                        tr->m_puid = TAGLIB_STRING_TO_QSTRING(texts[1]);
 
191
                }
 
192
        }
127
193
}
128
194
 
129
 
QString extractMusicBrainzTrackID(TagLib::File *file)
 
195
void extractMeta(TagReader *tr, TagLib::File *file)
130
196
{
131
 
        DISPATCH_TAGLIB_FILE(TagLib::FLAC::File, file);
132
 
        DISPATCH_TAGLIB_FILE(TagLib::Ogg::Vorbis::File, file);
133
 
        DISPATCH_TAGLIB_FILE(TagLib::Ogg::FLAC::File, file);
134
 
        DISPATCH_TAGLIB_FILE(TagLib::Ogg::Speex::File, file);
135
 
        DISPATCH_TAGLIB_FILE(TagLib::MPC::File, file);
136
 
        DISPATCH_TAGLIB_FILE(TagLib::WavPack::File, file);
 
197
        DISPATCH_TAGLIB_FILE(tr, TagLib::FLAC::File, file);
 
198
        DISPATCH_TAGLIB_FILE(tr, TagLib::Ogg::Vorbis::File, file);
 
199
        DISPATCH_TAGLIB_FILE(tr, TagLib::Ogg::FLAC::File, file);
 
200
        DISPATCH_TAGLIB_FILE(tr, TagLib::Ogg::Speex::File, file);
 
201
        DISPATCH_TAGLIB_FILE(tr, TagLib::MPC::File, file);
 
202
        DISPATCH_TAGLIB_FILE(tr, TagLib::WavPack::File, file);
137
203
#ifdef TAGLIB_WITH_ASF
138
 
        DISPATCH_TAGLIB_FILE(TagLib::ASF::File, file);
 
204
        DISPATCH_TAGLIB_FILE(tr, TagLib::ASF::File, file);
139
205
#endif
140
206
#ifdef TAGLIB_WITH_MP4
141
 
        DISPATCH_TAGLIB_FILE(TagLib::MP4::File, file);
 
207
        DISPATCH_TAGLIB_FILE(tr, TagLib::MP4::File, file);
142
208
#endif
143
 
        DISPATCH_TAGLIB_FILE(TagLib::MPEG::File, file);
144
 
        return QString();
 
209
        DISPATCH_TAGLIB_FILE(tr, TagLib::MPEG::File, file);
145
210
}
146
211
 
147
212
bool TagReader::read()
161
226
        return false;
162
227
    }
163
228
 
 
229
        m_artist = TAGLIB_STRING_TO_QSTRING(tags->artist());
 
230
        m_album = TAGLIB_STRING_TO_QSTRING(tags->album());
 
231
        m_track = TAGLIB_STRING_TO_QSTRING(tags->title());
 
232
        m_trackNo = tags->track();
 
233
        m_year = tags->year();
 
234
 
164
235
        m_length = props->length();
165
236
    m_bitrate = props->bitrate();
166
 
        m_mbid = extractMusicBrainzTrackID(file.file());
167
 
        if (!m_length || m_mbid.size() != 36) {
 
237
        extractMeta(this, file.file());
 
238
        if (!m_length) {
168
239
                return false;
169
240
    }
170
241