← Back to branch summary

~ubuntu-branches/ubuntu/trusty/flac/trusty-updates

« back to all changes in this revision

Viewing changes to src/libFLAC++/stream_decoder.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Marc 'HE' Brockschmidt
  • Date: 2008-03-16 18:02:56 UTC
  • mfrom: (1.1.5 upstream) (8.1.2 gutsy)
  • Revision ID: james.westby@ubuntu.com-20080316180256-qhf3wk704rp165pm
Tags: 1.2.1-1.2
http://bugs.debian.org/455304
* Non-maintainer upload.
* Fix gcc-4.3 FTBFS, patch by KiBi (Closes: #455304)

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/libFLAC++/stream_decoder.cpp
1
1
/* libFLAC++ - Free Lossless Audio Codec library
2
 
 * Copyright (C) 2002,2003,2004,2005  Josh Coalson
 
2
 * Copyright (C) 2002,2003,2004,2005,2006,2007  Josh Coalson
3
3
 *
4
4
 * Redistribution and use in source and binary forms, with or without
5
5
 * modification, are permitted provided that the following conditions
40
40
namespace FLAC {
41
41
        namespace Decoder {
42
42
 
 
43
                // ------------------------------------------------------------
 
44
                //
 
45
                // Stream
 
46
                //
 
47
                // ------------------------------------------------------------
 
48
 
43
49
                Stream::Stream():
44
50
                decoder_(::FLAC__stream_decoder_new())
45
51
                { }
47
53
                Stream::~Stream()
48
54
                {
49
55
                        if(0 != decoder_) {
50
 
                                ::FLAC__stream_decoder_finish(decoder_);
 
56
                                (void)::FLAC__stream_decoder_finish(decoder_);
51
57
                                ::FLAC__stream_decoder_delete(decoder_);
52
58
                        }
53
59
                }
57
63
                        return 0 != decoder_;
58
64
                }
59
65
 
 
66
                bool Stream::set_ogg_serial_number(long value)
 
67
                {
 
68
                        FLAC__ASSERT(is_valid());
 
69
                        return (bool)::FLAC__stream_decoder_set_ogg_serial_number(decoder_, value);
 
70
                }
 
71
 
 
72
                bool Stream::set_md5_checking(bool value)
 
73
                {
 
74
                        FLAC__ASSERT(is_valid());
 
75
                        return (bool)::FLAC__stream_decoder_set_md5_checking(decoder_, value);
 
76
                }
 
77
 
60
78
                bool Stream::set_metadata_respond(::FLAC__MetadataType type)
61
79
                {
62
80
                        FLAC__ASSERT(is_valid());
99
117
                        return State(::FLAC__stream_decoder_get_state(decoder_));
100
118
                }
101
119
 
 
120
                bool Stream::get_md5_checking() const
 
121
                {
 
122
                        FLAC__ASSERT(is_valid());
 
123
                        return (bool)::FLAC__stream_decoder_get_md5_checking(decoder_);
 
124
                }
 
125
 
 
126
                FLAC__uint64 Stream::get_total_samples() const
 
127
                {
 
128
                        FLAC__ASSERT(is_valid());
 
129
                        return ::FLAC__stream_decoder_get_total_samples(decoder_);
 
130
                }
 
131
 
102
132
                unsigned Stream::get_channels() const
103
133
                {
104
134
                        FLAC__ASSERT(is_valid());
129
159
                        return ::FLAC__stream_decoder_get_blocksize(decoder_);
130
160
                }
131
161
 
132
 
                Stream::State Stream::init()
133
 
                {
134
 
                        FLAC__ASSERT(is_valid());
135
 
                        ::FLAC__stream_decoder_set_read_callback(decoder_, read_callback_);
136
 
                        ::FLAC__stream_decoder_set_write_callback(decoder_, write_callback_);
137
 
                        ::FLAC__stream_decoder_set_metadata_callback(decoder_, metadata_callback_);
138
 
                        ::FLAC__stream_decoder_set_error_callback(decoder_, error_callback_);
139
 
                        ::FLAC__stream_decoder_set_client_data(decoder_, (void*)this);
140
 
                        return State(::FLAC__stream_decoder_init(decoder_));
141
 
                }
142
 
 
143
 
                void Stream::finish()
144
 
                {
145
 
                        FLAC__ASSERT(is_valid());
146
 
                        ::FLAC__stream_decoder_finish(decoder_);
 
162
                bool Stream::get_decode_position(FLAC__uint64 *position) const
 
163
                {
 
164
                        FLAC__ASSERT(is_valid());
 
165
                        return ::FLAC__stream_decoder_get_decode_position(decoder_, position);
 
166
                }
 
167
 
 
168
                ::FLAC__StreamDecoderInitStatus Stream::init()
 
169
                {
 
170
                        FLAC__ASSERT(is_valid());
 
171
                        return ::FLAC__stream_decoder_init_stream(decoder_, read_callback_, seek_callback_, tell_callback_, length_callback_, eof_callback_, write_callback_, metadata_callback_, error_callback_, /*client_data=*/(void*)this);
 
172
                }
 
173
 
 
174
                ::FLAC__StreamDecoderInitStatus Stream::init_ogg()
 
175
                {
 
176
                        FLAC__ASSERT(is_valid());
 
177
                        return ::FLAC__stream_decoder_init_ogg_stream(decoder_, read_callback_, seek_callback_, tell_callback_, length_callback_, eof_callback_, write_callback_, metadata_callback_, error_callback_, /*client_data=*/(void*)this);
 
178
                }
 
179
 
 
180
                bool Stream::finish()
 
181
                {
 
182
                        FLAC__ASSERT(is_valid());
 
183
                        return (bool)::FLAC__stream_decoder_finish(decoder_);
147
184
                }
148
185
 
149
186
                bool Stream::flush()
182
219
                        return (bool)::FLAC__stream_decoder_skip_single_frame(decoder_);
183
220
                }
184
221
 
185
 
                ::FLAC__StreamDecoderReadStatus Stream::read_callback_(const ::FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data)
 
222
                bool Stream::seek_absolute(FLAC__uint64 sample)
 
223
                {
 
224
                        FLAC__ASSERT(is_valid());
 
225
                        return (bool)::FLAC__stream_decoder_seek_absolute(decoder_, sample);
 
226
                }
 
227
 
 
228
                ::FLAC__StreamDecoderSeekStatus Stream::seek_callback(FLAC__uint64 absolute_byte_offset)
 
229
                {
 
230
                        (void)absolute_byte_offset;
 
231
                        return ::FLAC__STREAM_DECODER_SEEK_STATUS_UNSUPPORTED;
 
232
                }
 
233
 
 
234
                ::FLAC__StreamDecoderTellStatus Stream::tell_callback(FLAC__uint64 *absolute_byte_offset)
 
235
                {
 
236
                        (void)absolute_byte_offset;
 
237
                        return ::FLAC__STREAM_DECODER_TELL_STATUS_UNSUPPORTED;
 
238
                }
 
239
 
 
240
                ::FLAC__StreamDecoderLengthStatus Stream::length_callback(FLAC__uint64 *stream_length)
 
241
                {
 
242
                        (void)stream_length;
 
243
                        return ::FLAC__STREAM_DECODER_LENGTH_STATUS_UNSUPPORTED;
 
244
                }
 
245
 
 
246
                bool Stream::eof_callback()
 
247
                {
 
248
                        return false;
 
249
                }
 
250
 
 
251
                void Stream::metadata_callback(const ::FLAC__StreamMetadata *metadata)
 
252
                {
 
253
                        (void)metadata;
 
254
                }
 
255
 
 
256
                ::FLAC__StreamDecoderReadStatus Stream::read_callback_(const ::FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
186
257
                {
187
258
                        (void)decoder;
188
259
                        FLAC__ASSERT(0 != client_data);
191
262
                        return instance->read_callback(buffer, bytes);
192
263
                }
193
264
 
 
265
                ::FLAC__StreamDecoderSeekStatus Stream::seek_callback_(const ::FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data)
 
266
                {
 
267
                        (void) decoder;
 
268
                        FLAC__ASSERT(0 != client_data);
 
269
                        Stream *instance = reinterpret_cast<Stream *>(client_data);
 
270
                        FLAC__ASSERT(0 != instance);
 
271
                        return instance->seek_callback(absolute_byte_offset);
 
272
                }
 
273
 
 
274
                ::FLAC__StreamDecoderTellStatus Stream::tell_callback_(const ::FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
 
275
                {
 
276
                        (void) decoder;
 
277
                        FLAC__ASSERT(0 != client_data);
 
278
                        Stream *instance = reinterpret_cast<Stream *>(client_data);
 
279
                        FLAC__ASSERT(0 != instance);
 
280
                        return instance->tell_callback(absolute_byte_offset);
 
281
                }
 
282
 
 
283
                ::FLAC__StreamDecoderLengthStatus Stream::length_callback_(const ::FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data)
 
284
                {
 
285
                        (void) decoder;
 
286
                        FLAC__ASSERT(0 != client_data);
 
287
                        Stream *instance = reinterpret_cast<Stream *>(client_data);
 
288
                        FLAC__ASSERT(0 != instance);
 
289
                        return instance->length_callback(stream_length);
 
290
                }
 
291
 
 
292
                FLAC__bool Stream::eof_callback_(const ::FLAC__StreamDecoder *decoder, void *client_data)
 
293
                {
 
294
                        (void) decoder;
 
295
                        FLAC__ASSERT(0 != client_data);
 
296
                        Stream *instance = reinterpret_cast<Stream *>(client_data);
 
297
                        FLAC__ASSERT(0 != instance);
 
298
                        return instance->eof_callback();
 
299
                }
 
300
 
194
301
                ::FLAC__StreamDecoderWriteStatus Stream::write_callback_(const ::FLAC__StreamDecoder *decoder, const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
195
302
                {
196
303
                        (void)decoder;
218
325
                        instance->error_callback(status);
219
326
                }
220
327
 
 
328
                // ------------------------------------------------------------
 
329
                //
 
330
                // File
 
331
                //
 
332
                // ------------------------------------------------------------
 
333
 
 
334
                File::File():
 
335
                        Stream()
 
336
                { }
 
337
 
 
338
                File::~File()
 
339
                {
 
340
                }
 
341
 
 
342
                ::FLAC__StreamDecoderInitStatus File::init(FILE *file)
 
343
                {
 
344
                        FLAC__ASSERT(0 != decoder_);
 
345
                        return ::FLAC__stream_decoder_init_FILE(decoder_, file, write_callback_, metadata_callback_, error_callback_, /*client_data=*/(void*)this);
 
346
                }
 
347
 
 
348
                ::FLAC__StreamDecoderInitStatus File::init(const char *filename)
 
349
                {
 
350
                        FLAC__ASSERT(0 != decoder_);
 
351
                        return ::FLAC__stream_decoder_init_file(decoder_, filename, write_callback_, metadata_callback_, error_callback_, /*client_data=*/(void*)this);
 
352
                }
 
353
 
 
354
                ::FLAC__StreamDecoderInitStatus File::init(const std::string &filename)
 
355
                {
 
356
                        return init(filename.c_str());
 
357
                }
 
358
 
 
359
                ::FLAC__StreamDecoderInitStatus File::init_ogg(FILE *file)
 
360
                {
 
361
                        FLAC__ASSERT(0 != decoder_);
 
362
                        return ::FLAC__stream_decoder_init_ogg_FILE(decoder_, file, write_callback_, metadata_callback_, error_callback_, /*client_data=*/(void*)this);
 
363
                }
 
364
 
 
365
                ::FLAC__StreamDecoderInitStatus File::init_ogg(const char *filename)
 
366
                {
 
367
                        FLAC__ASSERT(0 != decoder_);
 
368
                        return ::FLAC__stream_decoder_init_ogg_file(decoder_, filename, write_callback_, metadata_callback_, error_callback_, /*client_data=*/(void*)this);
 
369
                }
 
370
 
 
371
                ::FLAC__StreamDecoderInitStatus File::init_ogg(const std::string &filename)
 
372
                {
 
373
                        return init_ogg(filename.c_str());
 
374
                }
 
375
 
 
376
                // This is a dummy to satisfy the pure virtual from Stream; the
 
377
                // read callback will never be called since we are initializing
 
378
                // with FLAC__stream_decoder_init_FILE() or
 
379
                // FLAC__stream_decoder_init_file() and those supply the read
 
380
                // callback internally.
 
381
                ::FLAC__StreamDecoderReadStatus File::read_callback(FLAC__byte buffer[], size_t *bytes)
 
382
                {
 
383
                        (void)buffer, (void)bytes;
 
384
                        FLAC__ASSERT(false);
 
385
                        return ::FLAC__STREAM_DECODER_READ_STATUS_ABORT; // double protection
 
386
                }
 
387
 
221
388
        }
222
389
}