← Back to branch summary

~njh-aelius/maxosx/musicbrainz-tags

« back to all changes in this revision

Viewing changes to Frameworks/taglib/taglib/taglib/mpeg/id3v1/id3v1tag.cpp

  • Committer: stephen_booth
  • Date: 2008-04-30 02:09:12 UTC
  • Revision ID: svn-v4:6b6cea13-1402-0410-9567-a7afb52bf336:trunk:1372
Update to latest taglib SVN

Show diffs side-by-side

added added

removed removed

Lines of Context:
Frameworks/taglib/taglib/taglib/mpeg/id3v1/id3v1tag.cpp
 
1
/***************************************************************************
 
2
    copyright            : (C) 2002 - 2008 by Scott Wheeler
 
3
    email                : wheeler@kde.org
 
4
 ***************************************************************************/
 
5
 
 
6
/***************************************************************************
 
7
 *   This library is free software; you can redistribute it and/or modify  *
 
8
 *   it under the terms of the GNU Lesser General Public License version   *
 
9
 *   2.1 as published by the Free Software Foundation.                     *
 
10
 *                                                                         *
 
11
 *   This library is distributed in the hope that it will be useful, but   *
 
12
 *   WITHOUT ANY WARRANTY; without even the implied warranty of            *
 
13
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU     *
 
14
 *   Lesser General Public License for more details.                       *
 
15
 *                                                                         *
 
16
 *   You should have received a copy of the GNU Lesser General Public      *
 
17
 *   License along with this library; if not, write to the Free Software   *
 
18
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  *
 
19
 *   USA                                                                   *
 
20
 *                                                                         *
 
21
 *   Alternatively, this file is available under the Mozilla Public        *
 
22
 *   License Version 1.1.  You may obtain a copy of the License at         *
 
23
 *   http://www.mozilla.org/MPL/                                           *
 
24
 ***************************************************************************/
 
25
 
 
26
#include <tdebug.h>
 
27
#include <tfile.h>
 
28
 
 
29
#include "id3v1tag.h"
 
30
#include "id3v1genres.h"
 
31
 
 
32
using namespace TagLib;
 
33
using namespace ID3v1;
 
34
 
 
35
class ID3v1::Tag::TagPrivate
 
36
{
 
37
public:
 
38
  TagPrivate() : file(0), tagOffset(-1), track(0), genre(255) {}
 
39
 
 
40
  File *file;
 
41
  long tagOffset;
 
42
 
 
43
  String title;
 
44
  String artist;
 
45
  String album;
 
46
  String year;
 
47
  String comment;
 
48
  uchar track;
 
49
  uchar genre;
 
50
 
 
51
  static const StringHandler *stringHandler;
 
52
};
 
53
 
 
54
const ID3v1::StringHandler *ID3v1::Tag::TagPrivate::stringHandler = new StringHandler;
 
55
 
 
56
////////////////////////////////////////////////////////////////////////////////
 
57
// StringHandler implementation
 
58
////////////////////////////////////////////////////////////////////////////////
 
59
 
 
60
String ID3v1::StringHandler::parse(const ByteVector &data) const
 
61
{
 
62
  return String(data, String::Latin1).stripWhiteSpace();
 
63
}
 
64
 
 
65
ByteVector ID3v1::StringHandler::render(const String &s) const
 
66
{
 
67
  if(!s.isLatin1())
 
68
  {
 
69
    return ByteVector();
 
70
  }
 
71
 
 
72
  return s.data(String::Latin1);
 
73
}
 
74
 
 
75
////////////////////////////////////////////////////////////////////////////////
 
76
// public methods
 
77
////////////////////////////////////////////////////////////////////////////////
 
78
 
 
79
ID3v1::Tag::Tag() : TagLib::Tag()
 
80
{
 
81
  d = new TagPrivate;
 
82
}
 
83
 
 
84
ID3v1::Tag::Tag(File *file, long tagOffset) : TagLib::Tag()
 
85
{
 
86
  d = new TagPrivate;
 
87
  d->file = file;
 
88
  d->tagOffset = tagOffset;
 
89
 
 
90
  read();
 
91
}
 
92
 
 
93
ID3v1::Tag::~Tag()
 
94
{
 
95
  delete d;
 
96
}
 
97
 
 
98
ByteVector ID3v1::Tag::render() const
 
99
{
 
100
  ByteVector data;
 
101
 
 
102
  data.append(fileIdentifier());
 
103
  data.append(TagPrivate::stringHandler->render(d->title).resize(30));
 
104
  data.append(TagPrivate::stringHandler->render(d->artist).resize(30));
 
105
  data.append(TagPrivate::stringHandler->render(d->album).resize(30));
 
106
  data.append(TagPrivate::stringHandler->render(d->year).resize(4));
 
107
  data.append(TagPrivate::stringHandler->render(d->comment).resize(28));
 
108
  data.append(char(0));
 
109
  data.append(char(d->track));
 
110
  data.append(char(d->genre));
 
111
 
 
112
  return data;
 
113
}
 
114
 
 
115
ByteVector ID3v1::Tag::fileIdentifier()
 
116
{
 
117
  return ByteVector::fromCString("TAG");
 
118
}
 
119
 
 
120
String ID3v1::Tag::title() const
 
121
{
 
122
  return d->title;
 
123
}
 
124
 
 
125
String ID3v1::Tag::artist() const
 
126
{
 
127
  return d->artist;
 
128
}
 
129
 
 
130
String ID3v1::Tag::album() const
 
131
{
 
132
  return d->album;
 
133
}
 
134
 
 
135
String ID3v1::Tag::comment() const
 
136
{
 
137
  return d->comment;
 
138
}
 
139
 
 
140
String ID3v1::Tag::genre() const
 
141
{
 
142
  return ID3v1::genre(d->genre);
 
143
}
 
144
 
 
145
TagLib::uint ID3v1::Tag::year() const
 
146
{
 
147
  return d->year.toInt();
 
148
}
 
149
 
 
150
TagLib::uint ID3v1::Tag::track() const
 
151
{
 
152
  return d->track;
 
153
}
 
154
 
 
155
void ID3v1::Tag::setTitle(const String &s)
 
156
{
 
157
  d->title = s;
 
158
}
 
159
 
 
160
void ID3v1::Tag::setArtist(const String &s)
 
161
{
 
162
  d->artist = s;
 
163
}
 
164
 
 
165
void ID3v1::Tag::setAlbum(const String &s)
 
166
{
 
167
  d->album = s;
 
168
}
 
169
 
 
170
void ID3v1::Tag::setComment(const String &s)
 
171
{
 
172
  d->comment = s;
 
173
}
 
174
 
 
175
void ID3v1::Tag::setGenre(const String &s)
 
176
{
 
177
  d->genre = ID3v1::genreIndex(s);
 
178
}
 
179
 
 
180
void ID3v1::Tag::setYear(uint i)
 
181
{
 
182
  d->year = i > 0 ? String::number(i) : String::null;
 
183
}
 
184
 
 
185
void ID3v1::Tag::setTrack(uint i)
 
186
{
 
187
  d->track = i < 256 ? i : 0;
 
188
}
 
189
 
 
190
void ID3v1::Tag::setStringHandler(const StringHandler *handler)
 
191
{
 
192
  delete TagPrivate::stringHandler;
 
193
  TagPrivate::stringHandler = handler;
 
194
}
 
195
 
 
196
////////////////////////////////////////////////////////////////////////////////
 
197
// protected methods
 
198
////////////////////////////////////////////////////////////////////////////////
 
199
 
 
200
void ID3v1::Tag::read()
 
201
{
 
202
  if(d->file && d->file->isValid()) {
 
203
    d->file->seek(d->tagOffset);
 
204
    // read the tag -- always 128 bytes
 
205
    ByteVector data = d->file->readBlock(128);
 
206
 
 
207
    // some initial sanity checking
 
208
    if(data.size() == 128 && data.startsWith("TAG"))
 
209
      parse(data);
 
210
    else
 
211
      debug("ID3v1 tag is not valid or could not be read at the specified offset.");
 
212
  }
 
213
}
 
214
 
 
215
void ID3v1::Tag::parse(const ByteVector &data)
 
216
{
 
217
  int offset = 3;
 
218
 
 
219
  d->title = TagPrivate::stringHandler->parse(data.mid(offset, 30));
 
220
  offset += 30;
 
221
 
 
222
  d->artist = TagPrivate::stringHandler->parse(data.mid(offset, 30));
 
223
  offset += 30;
 
224
 
 
225
  d->album = TagPrivate::stringHandler->parse(data.mid(offset, 30));
 
226
  offset += 30;
 
227
 
 
228
  d->year = TagPrivate::stringHandler->parse(data.mid(offset, 4));
 
229
  offset += 4;
 
230
 
 
231
  // Check for ID3v1.1 -- Note that ID3v1 *does not* support "track zero" -- this
 
232
  // is not a bug in TagLib.  Since a zeroed byte is what we would expect to
 
233
  // indicate the end of a C-String, specifically the comment string, a value of
 
234
  // zero must be assumed to be just that.
 
235
 
 
236
  if(data[offset + 28] == 0 && data[offset + 29] != 0) {
 
237
    // ID3v1.1 detected
 
238
 
 
239
    d->comment = TagPrivate::stringHandler->parse(data.mid(offset, 28));
 
240
    d->track = uchar(data[offset + 29]);
 
241
  }
 
242
  else
 
243
    d->comment = data.mid(offset, 30);
 
244
 
 
245
  offset += 30;
 
246
 
 
247
  d->genre = uchar(data[offset]);
 
248
}