← Back to branch summary

~ubuntu-branches/ubuntu/karmic/flac/karmic

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Joshua Kwan
  • Date: 2007-05-29 22:56:36 UTC
  • mfrom: (1.1.4 upstream)
  • Revision ID: james.westby@ubuntu.com-20070529225636-ljeff8xxip09qaap
Tags: 1.1.4-1
http://bugs.debian.org/405167
http://bugs.debian.org/411311
* New upstream release. closes: #405167, #411311
  - libOggFLAC and libOggFLAC++ have been merged into libFLAC, so
    remove their corresponding packages.
  - Because of the API changes required to effect the above, there has
    been yet another soname bump. libflac7 -> libflac8 and
    libflac++5 -> libflac++6. Emails have been dispatched to the
    maintainers of dependent packages.
* Some notes on patches that were removed:
  - 02_stdin_stdout, 06_manpage_mention_utf8_convert: merged upstream
  - 08_manpage_warnings: Upstream has changed the manpage so it defintely
    can't fit in in 80 cols, so just forget about it. We'll live.
  - 05_eof_warnings_are_errors: Upstream decided to add a -w option to
    flac to treat all warnings as errors. I am going to defer to that
    for now, but if people think it's stupid let me know and I'll port
    the patch forward.
  - 04_stack_smasher: was a backport from 1.1.3, so it's obsolete.

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
                ::FLAC__StreamDecoderInitStatus Stream::init()
 
163
                {
 
164
                        FLAC__ASSERT(is_valid());
 
165
                        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);
 
166
                }
 
167
 
 
168
                ::FLAC__StreamDecoderInitStatus Stream::init_ogg()
 
169
                {
 
170
                        FLAC__ASSERT(is_valid());
 
171
                        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);
 
172
                }
 
173
 
 
174
                bool Stream::finish()
 
175
                {
 
176
                        FLAC__ASSERT(is_valid());
 
177
                        return (bool)::FLAC__stream_decoder_finish(decoder_);
147
178
                }
148
179
 
149
180
                bool Stream::flush()
182
213
                        return (bool)::FLAC__stream_decoder_skip_single_frame(decoder_);
183
214
                }
184
215
 
185
 
                ::FLAC__StreamDecoderReadStatus Stream::read_callback_(const ::FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data)
 
216
                bool Stream::seek_absolute(FLAC__uint64 sample)
 
217
                {
 
218
                        FLAC__ASSERT(is_valid());
 
219
                        return (bool)::FLAC__stream_decoder_seek_absolute(decoder_, sample);
 
220
                }
 
221
 
 
222
                ::FLAC__StreamDecoderSeekStatus Stream::seek_callback(FLAC__uint64 absolute_byte_offset)
 
223
                {
 
224
                        (void)absolute_byte_offset;
 
225
                        return ::FLAC__STREAM_DECODER_SEEK_STATUS_UNSUPPORTED;
 
226
                }
 
227
 
 
228
                ::FLAC__StreamDecoderTellStatus Stream::tell_callback(FLAC__uint64 *absolute_byte_offset)
 
229
                {
 
230
                        (void)absolute_byte_offset;
 
231
                        return ::FLAC__STREAM_DECODER_TELL_STATUS_UNSUPPORTED;
 
232
                }
 
233
 
 
234
                ::FLAC__StreamDecoderLengthStatus Stream::length_callback(FLAC__uint64 *stream_length)
 
235
                {
 
236
                        (void)stream_length;
 
237
                        return ::FLAC__STREAM_DECODER_LENGTH_STATUS_UNSUPPORTED;
 
238
                }
 
239
 
 
240
                bool Stream::eof_callback()
 
241
                {
 
242
                        return false;
 
243
                }
 
244
 
 
245
                void Stream::metadata_callback(const ::FLAC__StreamMetadata *metadata)
 
246
                {
 
247
                        (void)metadata;
 
248
                }
 
249
 
 
250
                ::FLAC__StreamDecoderReadStatus Stream::read_callback_(const ::FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
186
251
                {
187
252
                        (void)decoder;
188
253
                        FLAC__ASSERT(0 != client_data);
191
256
                        return instance->read_callback(buffer, bytes);
192
257
                }
193
258
 
 
259
                ::FLAC__StreamDecoderSeekStatus Stream::seek_callback_(const ::FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data)
 
260
                {
 
261
                        (void) decoder;
 
262
                        FLAC__ASSERT(0 != client_data);
 
263
                        Stream *instance = reinterpret_cast<Stream *>(client_data);
 
264
                        FLAC__ASSERT(0 != instance);
 
265
                        return instance->seek_callback(absolute_byte_offset);
 
266
                }
 
267
 
 
268
                ::FLAC__StreamDecoderTellStatus Stream::tell_callback_(const ::FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
 
269
                {
 
270
                        (void) decoder;
 
271
                        FLAC__ASSERT(0 != client_data);
 
272
                        Stream *instance = reinterpret_cast<Stream *>(client_data);
 
273
                        FLAC__ASSERT(0 != instance);
 
274
                        return instance->tell_callback(absolute_byte_offset);
 
275
                }
 
276
 
 
277
                ::FLAC__StreamDecoderLengthStatus Stream::length_callback_(const ::FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data)
 
278
                {
 
279
                        (void) decoder;
 
280
                        FLAC__ASSERT(0 != client_data);
 
281
                        Stream *instance = reinterpret_cast<Stream *>(client_data);
 
282
                        FLAC__ASSERT(0 != instance);
 
283
                        return instance->length_callback(stream_length);
 
284
                }
 
285
 
 
286
                FLAC__bool Stream::eof_callback_(const ::FLAC__StreamDecoder *decoder, void *client_data)
 
287
                {
 
288
                        (void) decoder;
 
289
                        FLAC__ASSERT(0 != client_data);
 
290
                        Stream *instance = reinterpret_cast<Stream *>(client_data);
 
291
                        FLAC__ASSERT(0 != instance);
 
292
                        return instance->eof_callback();
 
293
                }
 
294
 
194
295
                ::FLAC__StreamDecoderWriteStatus Stream::write_callback_(const ::FLAC__StreamDecoder *decoder, const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
195
296
                {
196
297
                        (void)decoder;
218
319
                        instance->error_callback(status);
219
320
                }
220
321
 
 
322
                // ------------------------------------------------------------
 
323
                //
 
324
                // File
 
325
                //
 
326
                // ------------------------------------------------------------
 
327
 
 
328
                File::File():
 
329
                        Stream()
 
330
                { }
 
331
 
 
332
                File::~File()
 
333
                {
 
334
                }
 
335
 
 
336
                ::FLAC__StreamDecoderInitStatus File::init(FILE *file)
 
337
                {
 
338
                        FLAC__ASSERT(0 != decoder_);
 
339
                        return ::FLAC__stream_decoder_init_FILE(decoder_, file, write_callback_, metadata_callback_, error_callback_, /*client_data=*/(void*)this);
 
340
                }
 
341
 
 
342
                ::FLAC__StreamDecoderInitStatus File::init(const char *filename)
 
343
                {
 
344
                        FLAC__ASSERT(0 != decoder_);
 
345
                        return ::FLAC__stream_decoder_init_file(decoder_, filename, write_callback_, metadata_callback_, error_callback_, /*client_data=*/(void*)this);
 
346
                }
 
347
 
 
348
                ::FLAC__StreamDecoderInitStatus File::init(const std::string &filename)
 
349
                {
 
350
                        return init(filename.c_str());
 
351
                }
 
352
 
 
353
                ::FLAC__StreamDecoderInitStatus File::init_ogg(FILE *file)
 
354
                {
 
355
                        FLAC__ASSERT(0 != decoder_);
 
356
                        return ::FLAC__stream_decoder_init_ogg_FILE(decoder_, file, write_callback_, metadata_callback_, error_callback_, /*client_data=*/(void*)this);
 
357
                }
 
358
 
 
359
                ::FLAC__StreamDecoderInitStatus File::init_ogg(const char *filename)
 
360
                {
 
361
                        FLAC__ASSERT(0 != decoder_);
 
362
                        return ::FLAC__stream_decoder_init_ogg_file(decoder_, filename, write_callback_, metadata_callback_, error_callback_, /*client_data=*/(void*)this);
 
363
                }
 
364
 
 
365
                ::FLAC__StreamDecoderInitStatus File::init_ogg(const std::string &filename)
 
366
                {
 
367
                        return init_ogg(filename.c_str());
 
368
                }
 
369
 
 
370
                // This is a dummy to satisfy the pure virtual from Stream; the
 
371
                // read callback will never be called since we are initializing
 
372
                // with FLAC__stream_decoder_init_FILE() or
 
373
                // FLAC__stream_decoder_init_file() and those supply the read
 
374
                // callback internally.
 
375
                ::FLAC__StreamDecoderReadStatus File::read_callback(FLAC__byte buffer[], size_t *bytes)
 
376
                {
 
377
                        (void)buffer, (void)bytes;
 
378
                        FLAC__ASSERT(false);
 
379
                        return ::FLAC__STREAM_DECODER_READ_STATUS_ABORT; // double protection
 
380
                }
 
381
 
221
382
        }
222
383
}