← Back to branch summary

~njh-aelius/maxosx/musicbrainz-tags

« back to all changes in this revision

Viewing changes to Frameworks/taglib/taglib/taglib/mpeg/id3v2/frames/relativevolumeframe.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/id3v2/frames/relativevolumeframe.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 <tmap.h>
 
28
 
 
29
#include "relativevolumeframe.h"
 
30
 
 
31
using namespace TagLib;
 
32
using namespace ID3v2;
 
33
 
 
34
static inline int bitsToBytes(int i)
 
35
{
 
36
  return i % 8 == 0 ? i / 8 : (i - i % 8) / 8 + 1;
 
37
}
 
38
 
 
39
struct ChannelData
 
40
{
 
41
  ChannelData() : channelType(RelativeVolumeFrame::Other), volumeAdjustment(0) {}
 
42
 
 
43
  RelativeVolumeFrame::ChannelType channelType;
 
44
  short volumeAdjustment;
 
45
  RelativeVolumeFrame::PeakVolume peakVolume;
 
46
};
 
47
 
 
48
class RelativeVolumeFrame::RelativeVolumeFramePrivate
 
49
{
 
50
public:
 
51
  String identification;
 
52
  Map<ChannelType, ChannelData> channels;
 
53
};
 
54
 
 
55
////////////////////////////////////////////////////////////////////////////////
 
56
// public members
 
57
////////////////////////////////////////////////////////////////////////////////
 
58
 
 
59
RelativeVolumeFrame::RelativeVolumeFrame() : Frame("RVA2")
 
60
{
 
61
  d = new RelativeVolumeFramePrivate;
 
62
}
 
63
 
 
64
RelativeVolumeFrame::RelativeVolumeFrame(const ByteVector &data) : Frame(data)
 
65
{
 
66
  d = new RelativeVolumeFramePrivate;
 
67
  setData(data);
 
68
}
 
69
 
 
70
RelativeVolumeFrame::~RelativeVolumeFrame()
 
71
{
 
72
  delete d;
 
73
}
 
74
 
 
75
String RelativeVolumeFrame::toString() const
 
76
{
 
77
  return d->identification;
 
78
}
 
79
 
 
80
List<RelativeVolumeFrame::ChannelType> RelativeVolumeFrame::channels() const
 
81
{
 
82
  List<ChannelType> l;
 
83
 
 
84
  Map<ChannelType, ChannelData>::ConstIterator it = d->channels.begin();
 
85
  for(; it != d->channels.end(); ++it)
 
86
    l.append((*it).first);
 
87
 
 
88
  return l;
 
89
}
 
90
 
 
91
// deprecated
 
92
 
 
93
RelativeVolumeFrame::ChannelType RelativeVolumeFrame::channelType() const
 
94
{
 
95
  return MasterVolume;
 
96
}
 
97
 
 
98
// deprecated
 
99
 
 
100
void RelativeVolumeFrame::setChannelType(ChannelType)
 
101
{
 
102
 
 
103
}
 
104
 
 
105
short RelativeVolumeFrame::volumeAdjustmentIndex(ChannelType type) const
 
106
{
 
107
  return d->channels.contains(type) ? d->channels[type].volumeAdjustment : 0;
 
108
}
 
109
 
 
110
short RelativeVolumeFrame::volumeAdjustmentIndex() const
 
111
{
 
112
  return volumeAdjustmentIndex(MasterVolume);
 
113
}
 
114
 
 
115
void RelativeVolumeFrame::setVolumeAdjustmentIndex(short index, ChannelType type)
 
116
{
 
117
  d->channels[type].volumeAdjustment = index;
 
118
}
 
119
 
 
120
void RelativeVolumeFrame::setVolumeAdjustmentIndex(short index)
 
121
{
 
122
  setVolumeAdjustmentIndex(index, MasterVolume);
 
123
}
 
124
 
 
125
float RelativeVolumeFrame::volumeAdjustment(ChannelType type) const
 
126
{
 
127
  return d->channels.contains(type) ? float(d->channels[type].volumeAdjustment) / float(512) : 0;
 
128
}
 
129
 
 
130
float RelativeVolumeFrame::volumeAdjustment() const
 
131
{
 
132
  return volumeAdjustment(MasterVolume);
 
133
}
 
134
 
 
135
void RelativeVolumeFrame::setVolumeAdjustment(float adjustment, ChannelType type)
 
136
{
 
137
  d->channels[type].volumeAdjustment = short(adjustment * float(512));
 
138
}
 
139
 
 
140
void RelativeVolumeFrame::setVolumeAdjustment(float adjustment)
 
141
{
 
142
  setVolumeAdjustment(adjustment, MasterVolume);
 
143
}
 
144
 
 
145
RelativeVolumeFrame::PeakVolume RelativeVolumeFrame::peakVolume(ChannelType type) const
 
146
{
 
147
  return d->channels.contains(type) ? d->channels[type].peakVolume : PeakVolume();
 
148
}
 
149
 
 
150
RelativeVolumeFrame::PeakVolume RelativeVolumeFrame::peakVolume() const
 
151
{
 
152
  return peakVolume(MasterVolume);
 
153
}
 
154
 
 
155
void RelativeVolumeFrame::setPeakVolume(const PeakVolume &peak, ChannelType type)
 
156
{
 
157
  d->channels[type].peakVolume = peak;
 
158
}
 
159
 
 
160
void RelativeVolumeFrame::setPeakVolume(const PeakVolume &peak)
 
161
{
 
162
  setPeakVolume(peak, MasterVolume);
 
163
}
 
164
 
 
165
String RelativeVolumeFrame::identification() const
 
166
{
 
167
  return d->identification;
 
168
}
 
169
 
 
170
void RelativeVolumeFrame::setIdentification(const String &s)
 
171
{
 
172
  d->identification = s;
 
173
}
 
174
 
 
175
////////////////////////////////////////////////////////////////////////////////
 
176
// protected members
 
177
////////////////////////////////////////////////////////////////////////////////
 
178
 
 
179
void RelativeVolumeFrame::parseFields(const ByteVector &data)
 
180
{
 
181
  int pos = 0;
 
182
  d->identification = readStringField(data, String::Latin1, &pos);
 
183
 
 
184
  // Each channel is at least 4 bytes.
 
185
 
 
186
  while(pos <= (int)data.size() - 4) {
 
187
 
 
188
 
 
189
    ChannelType type = ChannelType(data[pos]);
 
190
    pos += 1;
 
191
 
 
192
    ChannelData &channel = d->channels[type];
 
193
 
 
194
    channel.volumeAdjustment = data.mid(pos, 2).toShort();
 
195
    pos += 2;
 
196
 
 
197
    channel.peakVolume.bitsRepresentingPeak = data[pos];
 
198
    pos += 1;
 
199
 
 
200
    int bytes = bitsToBytes(channel.peakVolume.bitsRepresentingPeak);
 
201
    channel.peakVolume.peakVolume = data.mid(pos, bytes);
 
202
    pos += bytes;
 
203
  }
 
204
}
 
205
 
 
206
ByteVector RelativeVolumeFrame::renderFields() const
 
207
{
 
208
  ByteVector data;
 
209
 
 
210
  data.append(d->identification.data(String::Latin1));
 
211
  data.append(textDelimiter(String::Latin1));
 
212
 
 
213
  Map<ChannelType, ChannelData>::ConstIterator it = d->channels.begin();
 
214
 
 
215
  for(; it != d->channels.end(); ++it) {
 
216
    ChannelType type = (*it).first;
 
217
    const ChannelData &channel = (*it).second;
 
218
 
 
219
    data.append(char(type));
 
220
    data.append(ByteVector::fromShort(channel.volumeAdjustment));
 
221
    data.append(char(channel.peakVolume.bitsRepresentingPeak));
 
222
    data.append(channel.peakVolume.peakVolume);
 
223
  }
 
224
 
 
225
  return data;
 
226
}
 
227
 
 
228
////////////////////////////////////////////////////////////////////////////////
 
229
// private members
 
230
////////////////////////////////////////////////////////////////////////////////
 
231
 
 
232
RelativeVolumeFrame::RelativeVolumeFrame(const ByteVector &data, Header *h) : Frame(h)
 
233
{
 
234
  d = new RelativeVolumeFramePrivate;
 
235
  parseFields(fieldData(data));
 
236
}