← Back to branch summary

~ubuntu-branches/ubuntu/saucy/flac/saucy

« back to all changes in this revision

Viewing changes to .pc/0002-Add-missing-config.h-includes.patch/src/libFLAC++/stream_decoder.cpp

  • Committer: Package Import Robot
  • Author(s): Fabian Greffrath
  • Date: 2013-06-07 10:24:30 UTC
  • mfrom: (8.1.7 sid)
  • Revision ID: package-import@ubuntu.com-20130607102430-8xn8qdlir5gmdo4m
Tags: 1.3.0-1
http://bugs.debian.org/527542
http://bugs.debian.org/705601
http://bugs.debian.org/710062
* Imported Upstream version 1.3.0 (Closes: #527542, #705601).
* Update debian/watch file, thanks Ulrich Klauer (Closes: #710062).
* Revert "Remove manpages from master branch."
* Imported Upstream version 1.3.0
* Convert package to "3.0 (quilt)" source format.
* Remove all patches, they have either been merged upstream or do not
  apply anymore (tested).
* Explicitly enable static libraries.
* Simplify debian/libflac-doc.install.
* Bump shlibs for added symbols.
* Remove needless Build-Depends: libid3-3.8.3-dev.
* Update Homepage field.
* Repair upstream manpage regeneration rule.
* Bump Build-Depends: debhelper (>= 9).
* Fix vcs-field-not-canonical.
* Import two patches from upstream GIT:
  + Add missing config.h includes.
  + Fix local_strcat() to terminate string correctly.
* Disable 3DNow! optimizations, enable SSE only on amd64, enable Altivec
  only on ppc64, disable ASM optimizations elsewhere.

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/0002-Add-missing-config.h-includes.patch/src/libFLAC++/stream_decoder.cpp
 
1
/* libFLAC++ - Free Lossless Audio Codec library
 
2
 * Copyright (C) 2002-2009  Josh Coalson
 
3
 * Copyright (C) 2011-2013  Xiph.Org Foundation
 
4
 *
 
5
 * Redistribution and use in source and binary forms, with or without
 
6
 * modification, are permitted provided that the following conditions
 
7
 * are met:
 
8
 *
 
9
 * - Redistributions of source code must retain the above copyright
 
10
 * notice, this list of conditions and the following disclaimer.
 
11
 *
 
12
 * - Redistributions in binary form must reproduce the above copyright
 
13
 * notice, this list of conditions and the following disclaimer in the
 
14
 * documentation and/or other materials provided with the distribution.
 
15
 *
 
16
 * - Neither the name of the Xiph.org Foundation nor the names of its
 
17
 * contributors may be used to endorse or promote products derived from
 
18
 * this software without specific prior written permission.
 
19
 *
 
20
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
21
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 
22
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 
23
 * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
 
24
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 
25
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 
26
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 
27
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 
28
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 
29
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 
30
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
31
 */
 
32
 
 
33
#include "FLAC++/decoder.h"
 
34
#include "FLAC/assert.h"
 
35
 
 
36
#ifdef _MSC_VER
 
37
// warning C4800: 'int' : forcing to bool 'true' or 'false' (performance warning)
 
38
#pragma warning ( disable : 4800 )
 
39
#endif
 
40
 
 
41
namespace FLAC {
 
42
        namespace Decoder {
 
43
 
 
44
                // ------------------------------------------------------------
 
45
                //
 
46
                // Stream
 
47
                //
 
48
                // ------------------------------------------------------------
 
49
 
 
50
                Stream::Stream():
 
51
                decoder_(::FLAC__stream_decoder_new())
 
52
                { }
 
53
 
 
54
                Stream::~Stream()
 
55
                {
 
56
                        if(0 != decoder_) {
 
57
                                (void)::FLAC__stream_decoder_finish(decoder_);
 
58
                                ::FLAC__stream_decoder_delete(decoder_);
 
59
                        }
 
60
                }
 
61
 
 
62
                bool Stream::is_valid() const
 
63
                {
 
64
                        return 0 != decoder_;
 
65
                }
 
66
 
 
67
                bool Stream::set_ogg_serial_number(long value)
 
68
                {
 
69
                        FLAC__ASSERT(is_valid());
 
70
                        return (bool)::FLAC__stream_decoder_set_ogg_serial_number(decoder_, value);
 
71
                }
 
72
 
 
73
                bool Stream::set_md5_checking(bool value)
 
74
                {
 
75
                        FLAC__ASSERT(is_valid());
 
76
                        return (bool)::FLAC__stream_decoder_set_md5_checking(decoder_, value);
 
77
                }
 
78
 
 
79
                bool Stream::set_metadata_respond(::FLAC__MetadataType type)
 
80
                {
 
81
                        FLAC__ASSERT(is_valid());
 
82
                        return (bool)::FLAC__stream_decoder_set_metadata_respond(decoder_, type);
 
83
                }
 
84
 
 
85
                bool Stream::set_metadata_respond_application(const FLAC__byte id[4])
 
86
                {
 
87
                        FLAC__ASSERT(is_valid());
 
88
                        return (bool)::FLAC__stream_decoder_set_metadata_respond_application(decoder_, id);
 
89
                }
 
90
 
 
91
                bool Stream::set_metadata_respond_all()
 
92
                {
 
93
                        FLAC__ASSERT(is_valid());
 
94
                        return (bool)::FLAC__stream_decoder_set_metadata_respond_all(decoder_);
 
95
                }
 
96
 
 
97
                bool Stream::set_metadata_ignore(::FLAC__MetadataType type)
 
98
                {
 
99
                        FLAC__ASSERT(is_valid());
 
100
                        return (bool)::FLAC__stream_decoder_set_metadata_ignore(decoder_, type);
 
101
                }
 
102
 
 
103
                bool Stream::set_metadata_ignore_application(const FLAC__byte id[4])
 
104
                {
 
105
                        FLAC__ASSERT(is_valid());
 
106
                        return (bool)::FLAC__stream_decoder_set_metadata_ignore_application(decoder_, id);
 
107
                }
 
108
 
 
109
                bool Stream::set_metadata_ignore_all()
 
110
                {
 
111
                        FLAC__ASSERT(is_valid());
 
112
                        return (bool)::FLAC__stream_decoder_set_metadata_ignore_all(decoder_);
 
113
                }
 
114
 
 
115
                Stream::State Stream::get_state() const
 
116
                {
 
117
                        FLAC__ASSERT(is_valid());
 
118
                        return State(::FLAC__stream_decoder_get_state(decoder_));
 
119
                }
 
120
 
 
121
                bool Stream::get_md5_checking() const
 
122
                {
 
123
                        FLAC__ASSERT(is_valid());
 
124
                        return (bool)::FLAC__stream_decoder_get_md5_checking(decoder_);
 
125
                }
 
126
 
 
127
                FLAC__uint64 Stream::get_total_samples() const
 
128
                {
 
129
                        FLAC__ASSERT(is_valid());
 
130
                        return ::FLAC__stream_decoder_get_total_samples(decoder_);
 
131
                }
 
132
 
 
133
                unsigned Stream::get_channels() const
 
134
                {
 
135
                        FLAC__ASSERT(is_valid());
 
136
                        return ::FLAC__stream_decoder_get_channels(decoder_);
 
137
                }
 
138
 
 
139
                ::FLAC__ChannelAssignment Stream::get_channel_assignment() const
 
140
                {
 
141
                        FLAC__ASSERT(is_valid());
 
142
                        return ::FLAC__stream_decoder_get_channel_assignment(decoder_);
 
143
                }
 
144
 
 
145
                unsigned Stream::get_bits_per_sample() const
 
146
                {
 
147
                        FLAC__ASSERT(is_valid());
 
148
                        return ::FLAC__stream_decoder_get_bits_per_sample(decoder_);
 
149
                }
 
150
 
 
151
                unsigned Stream::get_sample_rate() const
 
152
                {
 
153
                        FLAC__ASSERT(is_valid());
 
154
                        return ::FLAC__stream_decoder_get_sample_rate(decoder_);
 
155
                }
 
156
 
 
157
                unsigned Stream::get_blocksize() const
 
158
                {
 
159
                        FLAC__ASSERT(is_valid());
 
160
                        return ::FLAC__stream_decoder_get_blocksize(decoder_);
 
161
                }
 
162
 
 
163
                bool Stream::get_decode_position(FLAC__uint64 *position) const
 
164
                {
 
165
                        FLAC__ASSERT(is_valid());
 
166
                        return ::FLAC__stream_decoder_get_decode_position(decoder_, position);
 
167
                }
 
168
 
 
169
                ::FLAC__StreamDecoderInitStatus Stream::init()
 
170
                {
 
171
                        FLAC__ASSERT(is_valid());
 
172
                        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);
 
173
                }
 
174
 
 
175
                ::FLAC__StreamDecoderInitStatus Stream::init_ogg()
 
176
                {
 
177
                        FLAC__ASSERT(is_valid());
 
178
                        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);
 
179
                }
 
180
 
 
181
                bool Stream::finish()
 
182
                {
 
183
                        FLAC__ASSERT(is_valid());
 
184
                        return (bool)::FLAC__stream_decoder_finish(decoder_);
 
185
                }
 
186
 
 
187
                bool Stream::flush()
 
188
                {
 
189
                        FLAC__ASSERT(is_valid());
 
190
                        return (bool)::FLAC__stream_decoder_flush(decoder_);
 
191
                }
 
192
 
 
193
                bool Stream::reset()
 
194
                {
 
195
                        FLAC__ASSERT(is_valid());
 
196
                        return (bool)::FLAC__stream_decoder_reset(decoder_);
 
197
                }
 
198
 
 
199
                bool Stream::process_single()
 
200
                {
 
201
                        FLAC__ASSERT(is_valid());
 
202
                        return (bool)::FLAC__stream_decoder_process_single(decoder_);
 
203
                }
 
204
 
 
205
                bool Stream::process_until_end_of_metadata()
 
206
                {
 
207
                        FLAC__ASSERT(is_valid());
 
208
                        return (bool)::FLAC__stream_decoder_process_until_end_of_metadata(decoder_);
 
209
                }
 
210
 
 
211
                bool Stream::process_until_end_of_stream()
 
212
                {
 
213
                        FLAC__ASSERT(is_valid());
 
214
                        return (bool)::FLAC__stream_decoder_process_until_end_of_stream(decoder_);
 
215
                }
 
216
 
 
217
                bool Stream::skip_single_frame()
 
218
                {
 
219
                        FLAC__ASSERT(is_valid());
 
220
                        return (bool)::FLAC__stream_decoder_skip_single_frame(decoder_);
 
221
                }
 
222
 
 
223
                bool Stream::seek_absolute(FLAC__uint64 sample)
 
224
                {
 
225
                        FLAC__ASSERT(is_valid());
 
226
                        return (bool)::FLAC__stream_decoder_seek_absolute(decoder_, sample);
 
227
                }
 
228
 
 
229
                ::FLAC__StreamDecoderSeekStatus Stream::seek_callback(FLAC__uint64 absolute_byte_offset)
 
230
                {
 
231
                        (void)absolute_byte_offset;
 
232
                        return ::FLAC__STREAM_DECODER_SEEK_STATUS_UNSUPPORTED;
 
233
                }
 
234
 
 
235
                ::FLAC__StreamDecoderTellStatus Stream::tell_callback(FLAC__uint64 *absolute_byte_offset)
 
236
                {
 
237
                        (void)absolute_byte_offset;
 
238
                        return ::FLAC__STREAM_DECODER_TELL_STATUS_UNSUPPORTED;
 
239
                }
 
240
 
 
241
                ::FLAC__StreamDecoderLengthStatus Stream::length_callback(FLAC__uint64 *stream_length)
 
242
                {
 
243
                        (void)stream_length;
 
244
                        return ::FLAC__STREAM_DECODER_LENGTH_STATUS_UNSUPPORTED;
 
245
                }
 
246
 
 
247
                bool Stream::eof_callback()
 
248
                {
 
249
                        return false;
 
250
                }
 
251
 
 
252
                void Stream::metadata_callback(const ::FLAC__StreamMetadata *metadata)
 
253
                {
 
254
                        (void)metadata;
 
255
                }
 
256
 
 
257
                ::FLAC__StreamDecoderReadStatus Stream::read_callback_(const ::FLAC__StreamDecoder *decoder, FLAC__byte buffer[], size_t *bytes, void *client_data)
 
258
                {
 
259
                        (void)decoder;
 
260
                        FLAC__ASSERT(0 != client_data);
 
261
                        Stream *instance = reinterpret_cast<Stream *>(client_data);
 
262
                        FLAC__ASSERT(0 != instance);
 
263
                        return instance->read_callback(buffer, bytes);
 
264
                }
 
265
 
 
266
                ::FLAC__StreamDecoderSeekStatus Stream::seek_callback_(const ::FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data)
 
267
                {
 
268
                        (void) decoder;
 
269
                        FLAC__ASSERT(0 != client_data);
 
270
                        Stream *instance = reinterpret_cast<Stream *>(client_data);
 
271
                        FLAC__ASSERT(0 != instance);
 
272
                        return instance->seek_callback(absolute_byte_offset);
 
273
                }
 
274
 
 
275
                ::FLAC__StreamDecoderTellStatus Stream::tell_callback_(const ::FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data)
 
276
                {
 
277
                        (void) decoder;
 
278
                        FLAC__ASSERT(0 != client_data);
 
279
                        Stream *instance = reinterpret_cast<Stream *>(client_data);
 
280
                        FLAC__ASSERT(0 != instance);
 
281
                        return instance->tell_callback(absolute_byte_offset);
 
282
                }
 
283
 
 
284
                ::FLAC__StreamDecoderLengthStatus Stream::length_callback_(const ::FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data)
 
285
                {
 
286
                        (void) decoder;
 
287
                        FLAC__ASSERT(0 != client_data);
 
288
                        Stream *instance = reinterpret_cast<Stream *>(client_data);
 
289
                        FLAC__ASSERT(0 != instance);
 
290
                        return instance->length_callback(stream_length);
 
291
                }
 
292
 
 
293
                FLAC__bool Stream::eof_callback_(const ::FLAC__StreamDecoder *decoder, void *client_data)
 
294
                {
 
295
                        (void) decoder;
 
296
                        FLAC__ASSERT(0 != client_data);
 
297
                        Stream *instance = reinterpret_cast<Stream *>(client_data);
 
298
                        FLAC__ASSERT(0 != instance);
 
299
                        return instance->eof_callback();
 
300
                }
 
301
 
 
302
                ::FLAC__StreamDecoderWriteStatus Stream::write_callback_(const ::FLAC__StreamDecoder *decoder, const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
 
303
                {
 
304
                        (void)decoder;
 
305
                        FLAC__ASSERT(0 != client_data);
 
306
                        Stream *instance = reinterpret_cast<Stream *>(client_data);
 
307
                        FLAC__ASSERT(0 != instance);
 
308
                        return instance->write_callback(frame, buffer);
 
309
                }
 
310
 
 
311
                void Stream::metadata_callback_(const ::FLAC__StreamDecoder *decoder, const ::FLAC__StreamMetadata *metadata, void *client_data)
 
312
                {
 
313
                        (void)decoder;
 
314
                        FLAC__ASSERT(0 != client_data);
 
315
                        Stream *instance = reinterpret_cast<Stream *>(client_data);
 
316
                        FLAC__ASSERT(0 != instance);
 
317
                        instance->metadata_callback(metadata);
 
318
                }
 
319
 
 
320
                void Stream::error_callback_(const ::FLAC__StreamDecoder *decoder, ::FLAC__StreamDecoderErrorStatus status, void *client_data)
 
321
                {
 
322
                        (void)decoder;
 
323
                        FLAC__ASSERT(0 != client_data);
 
324
                        Stream *instance = reinterpret_cast<Stream *>(client_data);
 
325
                        FLAC__ASSERT(0 != instance);
 
326
                        instance->error_callback(status);
 
327
                }
 
328
 
 
329
                // ------------------------------------------------------------
 
330
                //
 
331
                // File
 
332
                //
 
333
                // ------------------------------------------------------------
 
334
 
 
335
                File::File():
 
336
                        Stream()
 
337
                { }
 
338
 
 
339
                File::~File()
 
340
                {
 
341
                }
 
342
 
 
343
                ::FLAC__StreamDecoderInitStatus File::init(FILE *file)
 
344
                {
 
345
                        FLAC__ASSERT(0 != decoder_);
 
346
                        return ::FLAC__stream_decoder_init_FILE(decoder_, file, write_callback_, metadata_callback_, error_callback_, /*client_data=*/(void*)this);
 
347
                }
 
348
 
 
349
                ::FLAC__StreamDecoderInitStatus File::init(const char *filename)
 
350
                {
 
351
                        FLAC__ASSERT(0 != decoder_);
 
352
                        return ::FLAC__stream_decoder_init_file(decoder_, filename, write_callback_, metadata_callback_, error_callback_, /*client_data=*/(void*)this);
 
353
                }
 
354
 
 
355
                ::FLAC__StreamDecoderInitStatus File::init(const std::string &filename)
 
356
                {
 
357
                        return init(filename.c_str());
 
358
                }
 
359
 
 
360
                ::FLAC__StreamDecoderInitStatus File::init_ogg(FILE *file)
 
361
                {
 
362
                        FLAC__ASSERT(0 != decoder_);
 
363
                        return ::FLAC__stream_decoder_init_ogg_FILE(decoder_, file, write_callback_, metadata_callback_, error_callback_, /*client_data=*/(void*)this);
 
364
                }
 
365
 
 
366
                ::FLAC__StreamDecoderInitStatus File::init_ogg(const char *filename)
 
367
                {
 
368
                        FLAC__ASSERT(0 != decoder_);
 
369
                        return ::FLAC__stream_decoder_init_ogg_file(decoder_, filename, write_callback_, metadata_callback_, error_callback_, /*client_data=*/(void*)this);
 
370
                }
 
371
 
 
372
                ::FLAC__StreamDecoderInitStatus File::init_ogg(const std::string &filename)
 
373
                {
 
374
                        return init_ogg(filename.c_str());
 
375
                }
 
376
 
 
377
                // This is a dummy to satisfy the pure virtual from Stream; the
 
378
                // read callback will never be called since we are initializing
 
379
                // with FLAC__stream_decoder_init_FILE() or
 
380
                // FLAC__stream_decoder_init_file() and those supply the read
 
381
                // callback internally.
 
382
                ::FLAC__StreamDecoderReadStatus File::read_callback(FLAC__byte buffer[], size_t *bytes)
 
383
                {
 
384
                        (void)buffer, (void)bytes;
 
385
                        FLAC__ASSERT(false);
 
386
                        return ::FLAC__STREAM_DECODER_READ_STATUS_ABORT; // double protection
 
387
                }
 
388
 
 
389
        }
 
390
}