1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
/* -*- c-basic-offset: 4 indent-tabs-mode: nil -*- vi:set ts=8 sts=4 sw=4: */
/*
Sonic Visualiser
An audio file viewer and annotation editor.
Centre for Digital Music, Queen Mary, University of London.
This file copyright 2006 Chris Cannam.
This program 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 2 of the
License, or (at your option) any later version. See the file
COPYING included with this distribution for more information.
*/
#ifndef SV_AUDIO_FILE_READER_H
#define SV_AUDIO_FILE_READER_H
#include <QString>
#include "base/BaseTypes.h"
#include "FileSource.h"
#include <vector>
#include <map>
namespace sv {
class AudioFileReader : public QObject
{
Q_OBJECT
public:
virtual ~AudioFileReader() { }
/**
* Return true if the file was opened successfully and no error
* has subsequently occurred.
*/
bool isOK() const { return (m_channelCount > 0); }
/**
* If isOK() is false, return an error string.
*/
virtual QString getError() const { return ""; }
/**
* Return the number of audio sample frames (i.e. samples per
* channel) in the file.
*/
sv_frame_t getFrameCount() const { return m_frameCount; }
/**
* Return the number of channels in the file.
*/
int getChannelCount() const { return m_channelCount; }
/**
* Return the samplerate at which the file is being read. This is
* the rate requested when the file was opened, which may differ
* from the native rate of the file (in which case the file will
* be resampled as it is read).
*/
sv_samplerate_t getSampleRate() const { return m_sampleRate; }
/**
* Return the native samplerate of the file. This will differ from
* getSampleRate() if the file is being resampled because it was
* requested to open at a different rate from native.
*/
virtual sv_samplerate_t getNativeRate() const { return m_sampleRate; }
/**
* Return the location of the audio data in the reader (as passed
* in to the FileSource constructor, for example). This might be a
* remote URL.
*
* See also getLocalFilename().
*/
virtual QString getLocation() const = 0;
/**
* Return the local file path of the audio data. This is the
* filesystem location most likely to contain readable audio data,
* but it may be in a different place or format from the
* originally specified location - for example, if the file has
* been retrieved and decoded, then it will be the (possibly
* temporary) decode target file.
*
* This returns a non-empty value only if there is some local
* filename that contains exactly the audio data being provided by
* this reader. In some cases this may not exist, for example when
* a file has been resampled or normalised directly into a memory
* buffer. In this case, return an empty string.
*
* See also getLocation().
*/
virtual QString getLocalFilename() const = 0;
/**
* Return the title of the work in the audio file, if known. This
* may be implemented by subclasses that support file tagging.
* This is not the same thing as the file name.
*/
virtual QString getTitle() const = 0;
/**
* Return the "maker" of the work in the audio file, if known.
* This could represent almost anything (band, composer,
* conductor, artist etc).
*/
virtual QString getMaker() const = 0;
/**
* Return any tag pairs picked up from the audio file. See also
* getTitle and getMaker, and note that a reader which does not
* implement getTags may still return values from those.
*/
typedef std::map<QString, QString> TagMap;
virtual TagMap getTags() const { return TagMap(); }
/**
* Return true if this file supports fast seek and random
* access. Typically this will be true for uncompressed formats
* and false for compressed ones.
*/
virtual bool isQuicklySeekable() const = 0;
/**
* Return a percentage value indicating how far through decoding
* the audio file we are. This should be implemented by subclasses
* that will not know exactly how long the audio file is (in
* sample frames) until it has been completely decoded. A reader
* that initialises the frame count directly within its
* constructor should always return 100 from this.
*/
virtual int getDecodeCompletion() const { return 100; }
/**
* Return true if decoding is still in progress and the frame
* count may change.
*/
virtual bool isUpdating() const { return false; }
/**
* Return interleaved samples for count frames from index start.
* The resulting vector will contain count * getChannelCount()
* samples (or fewer if end of file is reached).
*
* The subclass implementations of this function must be
* thread-safe -- that is, safe to call from multiple threads with
* different arguments on the same object at the same time.
*/
virtual floatvec_t getInterleavedFrames(sv_frame_t start,
sv_frame_t count) const = 0;
/**
* Return de-interleaved samples for count frames from index
* start. Implemented in this class (it calls
* getInterleavedFrames and de-interleaves). The resulting vector
* will contain getChannelCount() sample blocks of count samples
* each (or fewer if end of file is reached).
*/
virtual std::vector<floatvec_t> getDeInterleavedFrames(sv_frame_t start,
sv_frame_t count) const;
/**
* Notify the reader that the frame count may have changed
* (i.e. something has been appended to the file). If isUpdating
* returns true, the reader is aware that this may happen and will
* handle it, perhaps by re-opening the file. If isUpdating
* returns false, then this will do nothing.
*
* The default implementation of isUpdating in this class always
* returns false, so the default implementation of
* updateFrameCount also does nothing.
*/
virtual void updateFrameCount() { }
/**
* Notify the reader that the frame count has stopped changing
* (i.e. nothing further has been appended to the file and
* updateFrameCount will not be called again).
*/
virtual void updateDone() { }
signals:
void frameCountChanged();
protected:
sv_frame_t m_frameCount;
int m_channelCount;
sv_samplerate_t m_sampleRate;
};
} // end namespace sv
#endif
|
