← 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 01:48:01 UTC
  • Revision ID: svn-v4:6b6cea13-1402-0410-9567-a7afb52bf336:trunk:1371
Fixing the taglib source tree

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
 
}