~ubuntu-branches/ubuntu/hoary/flac/hoary

<a class="qindex" href="index.html">Main Page</a>   <a class="qindex" href="modules.html">Modules</a>   <a class="qindex" href="hierarchy.html">Class Hierarchy</a>   <a class="qindex" href="classes.html">Alphabetical List</a>   <a class="qindex" href="annotated.html">Compound List</a>   <a class="qindex" href="files.html">File List</a>   <a class="qindex" href="functions.html">Compound Members</a>   <a class="qindex" href="globals.html">File Members</a>   </center>

<hr><h1>include/FLAC++/decoder.h</h1><a href="FLAC++_2decoder_8h.html">Go to the documentation of this file.</a><div class="fragment"><pre>00001 /* libFLAC++ - Free Lossless Audio Codec library

00003 *

00004 * This library is free software; you can redistribute it and/or

00005 * modify it under the terms of the GNU Library General Public

00006 * License as published by the Free Software Foundation; either

00007 * version 2 of the License, or (at your option) any later version.

00008 *

00009 * This library is distributed in the hope that it will be useful,

00010 * but WITHOUT ANY WARRANTY; without even the implied warranty of

00011 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

00012 * Library General Public License for more details.

00013 *

00014 * You should have received a copy of the GNU Library General Public

00015 * License along with this library; if not, write to the

00016 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

00017 * Boston, MA 02111-1307, USA.

00018 */

00019

00020 #ifndef FLACPP__DECODER_H

00021 #define FLACPP__DECODER_H

00022

00023 #include "export.h"

00024

00025 #include "<a class="code" href="file__decoder_8h.html">FLAC/file_decoder.h</a>"

00026 #include "<a class="code" href="seekable__stream__decoder_8h.html">FLAC/seekable_stream_decoder.h</a>"

00027 #include "<a class="code" href="OggFLAC_2stream__decoder_8h.html">FLAC/stream_decoder.h</a>"

00028

00029

00057 namespace FLAC {

00058 namespace Decoder {

00059

00060 // ============================================================

00061 //

00062 // Equivalent: FLAC__StreamDecoder

00063 //

00064 // ============================================================

00065

<a name="l00079"></a><a class="code" href="classFLAC_1_1Decoder_1_1Stream.html">00079</a> class FLACPP_API Stream {

00080 public:

00081 class FLACPP_API State {

00082 public:

00083 inline State(::<a class="code" href="FLAC_2stream__decoder_8h.html#a34">FLAC__StreamDecoderState</a> state): state_(state) { }

00084 inline <a class="code" href="FLAC_2stream__decoder_8h.html#a34">operator ::FLAC__StreamDecoderState</a>() const { return state_; }

00085 inline const char *as_cstring() const { return ::FLAC__StreamDecoderStateString[state_]; }

00086 const char *resolved_as_cstring(const Stream &) const;

00087 protected:

00088 ::FLAC__StreamDecoderState state_;

00089 };

00090

00091 Stream();

00092 virtual ~Stream();

00093

00094 bool is_valid() const;

00095 inline operator bool() const { return is_valid(); }

00096

00097 bool set_metadata_respond(::<a class="code" href="format_8h.html#a93">FLAC__MetadataType</a> type);

00098 bool set_metadata_respond_application(const FLAC__byte id[4]);

00099 bool set_metadata_respond_all();

00100 bool set_metadata_ignore(::<a class="code" href="format_8h.html#a93">FLAC__MetadataType</a> type);

00101 bool set_metadata_ignore_application(const FLAC__byte id[4]);

00102 bool set_metadata_ignore_all();

00103

00104 State get_state() const;

00105 unsigned get_channels() const;

00106 ::FLAC__ChannelAssignment get_channel_assignment() const;

00107 unsigned get_bits_per_sample() const;

00108 unsigned get_sample_rate() const;

00109 unsigned get_blocksize() const;

00110

00115 State init();

00116

00117 void finish();

00118

00119 bool flush();

00120 bool reset();

00121

00122 bool process_single();

00123 bool process_until_end_of_metadata();

00124 bool process_until_end_of_stream();

00125 protected:

00126 virtual ::FLAC__StreamDecoderReadStatus read_callback(FLAC__byte buffer[], unsigned *bytes) = 0;

00127 virtual ::FLAC__StreamDecoderWriteStatus write_callback(const ::<a class="code" href="structFLAC____Frame.html">FLAC__Frame</a> *frame, const FLAC__int32 * const buffer[]) = 0;

00128 virtual void metadata_callback(const ::<a class="code" href="structFLAC____StreamMetadata.html">FLAC__StreamMetadata</a> *metadata) = 0;

00129 virtual void error_callback(::<a class="code" href="FLAC_2stream__decoder_8h.html#a37">FLAC__StreamDecoderErrorStatus</a> status) = 0;

00130

00131 ::FLAC__StreamDecoder *decoder_;

00132 private:

00133 static ::FLAC__StreamDecoderReadStatus read_callback_(const ::<a class="code" href="structFLAC____StreamDecoder.html">FLAC__StreamDecoder</a> *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data);

00134 static ::FLAC__StreamDecoderWriteStatus write_callback_(const ::<a class="code" href="structFLAC____StreamDecoder.html">FLAC__StreamDecoder</a> *decoder, const ::<a class="code" href="structFLAC____Frame.html">FLAC__Frame</a> *frame, const FLAC__int32 * const buffer[], void *client_data);

00135 static void metadata_callback_(const ::<a class="code" href="structFLAC____StreamDecoder.html">FLAC__StreamDecoder</a> *decoder, const ::<a class="code" href="structFLAC____StreamMetadata.html">FLAC__StreamMetadata</a> *metadata, void *client_data);

100

00136 static void error_callback_(const ::<a class="code" href="structFLAC____StreamDecoder.html">FLAC__StreamDecoder</a> *decoder, ::<a class="code" href="FLAC_2stream__decoder_8h.html#a37">FLAC__StreamDecoderErrorStatus</a> status, void *client_data);

101

00137

102

00138 // Private and undefined so you can't use them:

103

00139 Stream(const Stream &);

104

00140 void operator=(const Stream &);

105

00141 };

106

00142

107

00143 /* \} */

108

00144

109

00145

110

00146 // ============================================================

111

00147 //

112

00148 // Equivalent: FLAC__SeekableStreamDecoder

113

00149 //

114

00150 // ============================================================

115

00151

116

<a name="l00165"></a><a class="code" href="classFLAC_1_1Decoder_1_1SeekableStream.html">00165</a> class FLACPP_API SeekableStream {

117

00166 public:

118

00167 class FLACPP_API State {

119

00168 public:

120

00169 inline State(::<a class="code" href="seekable__stream__decoder_8h.html#a49">FLAC__SeekableStreamDecoderState</a> state): state_(state) { }

121

00170 inline <a class="code" href="seekable__stream__decoder_8h.html#a49">operator ::FLAC__SeekableStreamDecoderState</a>() const { return state_; }

122

00171 inline const char *as_cstring() const { return ::FLAC__SeekableStreamDecoderStateString[state_]; }

123

00172 const char *resolved_as_cstring(const SeekableStream &) const;

124

00173 protected:

125

00174 ::FLAC__SeekableStreamDecoderState state_;

126

00175 };

127

00176

128

00177 SeekableStream();

129

00178 virtual ~SeekableStream();

130

00179

131

00180 bool is_valid() const;

132

00181 inline operator bool() const { return is_valid(); }

133

00182

134

00183 bool set_md5_checking(bool value);

135

00184 bool set_metadata_respond(::<a class="code" href="format_8h.html#a93">FLAC__MetadataType</a> type);

136

00185 bool set_metadata_respond_application(const FLAC__byte id[4]);

137

00186 bool set_metadata_respond_all();

138

00187 bool set_metadata_ignore(::<a class="code" href="format_8h.html#a93">FLAC__MetadataType</a> type);

139

00188 bool set_metadata_ignore_application(const FLAC__byte id[4]);

140

00189 bool set_metadata_ignore_all();

141

00190

142

00191 State get_state() const;

143

00192 Stream::State get_stream_decoder_state() const;

144

00193 bool get_md5_checking() const;

145

00194 unsigned get_channels() const;

146

00195 ::FLAC__ChannelAssignment get_channel_assignment() const;

147

00196 unsigned get_bits_per_sample() const;

148

00197 unsigned get_sample_rate() const;

149

00198 unsigned get_blocksize() const;

150

00199

151

00200 State init();

152

00201

153

00202 bool finish();

154

00203

155

00204 bool flush();

156

00205 bool reset();

157

00206

158

00207 bool process_single();

159

00208 bool process_until_end_of_metadata();

160

00209 bool process_until_end_of_stream();

161

00210

162

00211 bool seek_absolute(FLAC__uint64 sample);

163

00212 protected:

164

00213 virtual ::FLAC__SeekableStreamDecoderReadStatus read_callback(FLAC__byte buffer[], unsigned *bytes) = 0;

165

00214 virtual ::FLAC__SeekableStreamDecoderSeekStatus seek_callback(FLAC__uint64 absolute_byte_offset) = 0;

166

00215 virtual ::FLAC__SeekableStreamDecoderTellStatus tell_callback(FLAC__uint64 *absolute_byte_offset) = 0;

167

00216 virtual ::FLAC__SeekableStreamDecoderLengthStatus length_callback(FLAC__uint64 *stream_length) = 0;

168

00217 virtual bool eof_callback() = 0;

169

00218 virtual ::FLAC__StreamDecoderWriteStatus write_callback(const ::<a class="code" href="structFLAC____Frame.html">FLAC__Frame</a> *frame, const FLAC__int32 * const buffer[]) = 0;

170

00219 virtual void metadata_callback(const ::<a class="code" href="structFLAC____StreamMetadata.html">FLAC__StreamMetadata</a> *metadata) = 0;

171

00220 virtual void error_callback(::<a class="code" href="FLAC_2stream__decoder_8h.html#a37">FLAC__StreamDecoderErrorStatus</a> status) = 0;

172

00221

173

00222 ::FLAC__SeekableStreamDecoder *decoder_;

174

00223 private:

175

00224 static ::FLAC__SeekableStreamDecoderReadStatus read_callback_(const ::<a class="code" href="structFLAC____SeekableStreamDecoder.html">FLAC__SeekableStreamDecoder</a> *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data);

176

00225 static ::FLAC__SeekableStreamDecoderSeekStatus seek_callback_(const ::<a class="code" href="structFLAC____SeekableStreamDecoder.html">FLAC__SeekableStreamDecoder</a> *decoder, FLAC__uint64 absolute_byte_offset, void *client_data);

177

00226 static ::FLAC__SeekableStreamDecoderTellStatus tell_callback_(const ::<a class="code" href="structFLAC____SeekableStreamDecoder.html">FLAC__SeekableStreamDecoder</a> *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data);

178

00227 static ::FLAC__SeekableStreamDecoderLengthStatus length_callback_(const ::<a class="code" href="structFLAC____SeekableStreamDecoder.html">FLAC__SeekableStreamDecoder</a> *decoder, FLAC__uint64 *stream_length, void *client_data);

179

00228 static FLAC__bool eof_callback_(const ::<a class="code" href="structFLAC____SeekableStreamDecoder.html">FLAC__SeekableStreamDecoder</a> *decoder, void *client_data);

180

00229 static ::FLAC__StreamDecoderWriteStatus write_callback_(const ::<a class="code" href="structFLAC____SeekableStreamDecoder.html">FLAC__SeekableStreamDecoder</a> *decoder, const ::<a class="code" href="structFLAC____Frame.html">FLAC__Frame</a> *frame, const FLAC__int32 * const buffer[], void *client_data);

181

00230 static void metadata_callback_(const ::<a class="code" href="structFLAC____SeekableStreamDecoder.html">FLAC__SeekableStreamDecoder</a> *decoder, const ::<a class="code" href="structFLAC____StreamMetadata.html">FLAC__StreamMetadata</a> *metadata, void *client_data);

182

00231 static void error_callback_(const ::<a class="code" href="structFLAC____SeekableStreamDecoder.html">FLAC__SeekableStreamDecoder</a> *decoder, ::<a class="code" href="FLAC_2stream__decoder_8h.html#a37">FLAC__StreamDecoderErrorStatus</a> status, void *client_data);

183

00232

184

00233 // Private and undefined so you can't use them:

185

00234 SeekableStream(const SeekableStream &);

186

00235 void operator=(const SeekableStream &);

187

00236 };

188

00237

189

00238 /* \} */

190

00239

191

00240

192

00241 // ============================================================

193

00242 //

194

00243 // Equivalent: FLAC__FileDecoder

195

00244 //

196

00245 // ============================================================

197

00246

198

<a name="l00260"></a><a class="code" href="classFLAC_1_1Decoder_1_1File.html">00260</a> class FLACPP_API File {

199

00261 public:

200

00262 class FLACPP_API State {

201

00263 public:

202

00264 inline State(::<a class="code" href="file__decoder_8h.html#a36">FLAC__FileDecoderState</a> state): state_(state) { }

203

00265 inline <a class="code" href="file__decoder_8h.html#a36">operator ::FLAC__FileDecoderState</a>() const { return state_; }

204

00266 inline const char *as_cstring() const { return ::FLAC__FileDecoderStateString[state_]; }

205

00267 const char *resolved_as_cstring(const File &) const;

206

00268 protected:

207

00269 ::FLAC__FileDecoderState state_;

208

00270 };

209

00271

210

00272 File();

211

00273 virtual ~File();

212

00274

213

00275 bool is_valid() const;

214

00276 inline operator bool() const { return is_valid(); }

215

00277

216

00278 bool set_md5_checking(bool value);

217

00279 bool set_filename(const char *value);

218

00280 bool set_metadata_respond(::<a class="code" href="format_8h.html#a93">FLAC__MetadataType</a> type);

219

00281 bool set_metadata_respond_application(const FLAC__byte id[4]);

220

00282 bool set_metadata_respond_all();

221

00283 bool set_metadata_ignore(::<a class="code" href="format_8h.html#a93">FLAC__MetadataType</a> type);

222

00284 bool set_metadata_ignore_application(const FLAC__byte id[4]);

223

00285 bool set_metadata_ignore_all();

224

00286

225

00287 State get_state() const;

226

00288 SeekableStream::State get_seekable_stream_decoder_state() const;

227

00289 Stream::State get_stream_decoder_state() const;

228

00290 bool get_md5_checking() const;

229

00291 unsigned get_channels() const;

230

00292 ::FLAC__ChannelAssignment get_channel_assignment() const;

231

00293 unsigned get_bits_per_sample() const;

232

00294 unsigned get_sample_rate() const;

233

00295 unsigned get_blocksize() const;

234

00296

235

00297 State init();

236

00298

237

00299 bool finish();

238

00300

239

00301 bool process_single();

240

00302 bool process_until_end_of_metadata();

241

00303 bool process_until_end_of_file();

242

00304

243

00305 bool seek_absolute(FLAC__uint64 sample);

244

00306 protected:

245

00307 virtual ::FLAC__StreamDecoderWriteStatus write_callback(const ::<a class="code" href="structFLAC____Frame.html">FLAC__Frame</a> *frame, const FLAC__int32 * const buffer[]) = 0;

246

00308 virtual void metadata_callback(const ::<a class="code" href="structFLAC____StreamMetadata.html">FLAC__StreamMetadata</a> *metadata) = 0;

247

00309 virtual void error_callback(::<a class="code" href="FLAC_2stream__decoder_8h.html#a37">FLAC__StreamDecoderErrorStatus</a> status) = 0;

248

00310

249

00311 ::FLAC__FileDecoder *decoder_;

250

00312 private:

251

00313 static ::FLAC__StreamDecoderWriteStatus write_callback_(const ::<a class="code" href="structFLAC____FileDecoder.html">FLAC__FileDecoder</a> *decoder, const ::<a class="code" href="structFLAC____Frame.html">FLAC__Frame</a> *frame, const FLAC__int32 * const buffer[], void *client_data);

252

00314 static void metadata_callback_(const ::<a class="code" href="structFLAC____FileDecoder.html">FLAC__FileDecoder</a> *decoder, const ::<a class="code" href="structFLAC____StreamMetadata.html">FLAC__StreamMetadata</a> *metadata, void *client_data);

253

00315 static void error_callback_(const ::<a class="code" href="structFLAC____FileDecoder.html">FLAC__FileDecoder</a> *decoder, ::<a class="code" href="FLAC_2stream__decoder_8h.html#a37">FLAC__StreamDecoderErrorStatus</a> status, void *client_data);

254

00316

255

00317 // Private and undefined so you can't use them:

256

00318 File(const File &);

257

00319 void operator=(const File &);

258

00320 };

259

00321

260

00322 /* \} */

261

00323

262

00324 };

263

00325 };

264

00326

265

00327 #endif

266

</pre></div><hr><address>Generated on Sat Jan 25 10:44:46 2003 for FLAC by

267

268

<img src="doxygen.gif" alt="doxygen" align="middle" border=0

269

width=110 height=53></a>1.2.14 written by <a href="mailto:dimitri@stack.nl">Dimitri van Heesch</a>,

270

271

</body>

272

</html>

Older »