Contents of /trunk/libsndfile/patches/libsndfile-1.0.17-flac-1.1.3.patch
Parent Directory | Revision Log
Revision 487 -
(show annotations)
(download)
Wed Feb 13 20:35:23 2008 UTC (16 years, 7 months ago) by niro
File size: 19742 byte(s)
Wed Feb 13 20:35:23 2008 UTC (16 years, 7 months ago) by niro
File size: 19742 byte(s)
-fix builds against newer flac versions
1 | diff -ru libsndfile-1.0.17/configure.ac libsndfile-1.0.17-b2/configure.ac |
2 | --- libsndfile-1.0.17/configure.ac 2006-08-31 02:39:37.000000000 -0700 |
3 | +++ libsndfile-1.0.17-b2/configure.ac 2006-10-27 08:54:45.000000000 -0700 |
4 | @@ -339,7 +339,8 @@ |
5 | if test "x$HAVE_FLAC_1_1_1" = xyes ; then |
6 | AC_DEFINE(HAVE_FLAC_1_1_1, [1], [Define to 1 if you have libflac 1.1.1]) |
7 | fi |
8 | - FLAC_LIBS="-lFLAC" |
9 | + # in FLAC 1.1.3 libOggFLAC was merged into libFLAC, hence we need -logg |
10 | + FLAC_LIBS="-lFLAC -logg" |
11 | fi |
12 | fi |
13 | |
14 | diff -ru libsndfile-1.0.17/src/flac.c libsndfile-1.0.17-b2/src/flac.c |
15 | --- libsndfile-1.0.17/src/flac.c 2006-08-31 02:22:19.000000000 -0700 |
16 | +++ libsndfile-1.0.17-b2/src/flac.c 2006-10-27 08:47:36.000000000 -0700 |
17 | @@ -46,6 +46,13 @@ |
18 | #include "sfendian.h" |
19 | #include "float_cast.h" |
20 | |
21 | +/* FLAC 1.1.3 has FLAC_API_VERSION_CURRENT == 8 */ |
22 | +#if !defined(FLAC_API_VERSION_CURRENT) || FLAC_API_VERSION_CURRENT < 8 |
23 | +#define LEGACY_FLAC |
24 | +#else |
25 | +#undef LEGACY_FLAC |
26 | +#endif |
27 | + |
28 | /*------------------------------------------------------------------------------ |
29 | ** Private static functions. |
30 | */ |
31 | @@ -60,8 +67,14 @@ |
32 | } PFLAC_PCM ; |
33 | |
34 | typedef struct |
35 | -{ FLAC__SeekableStreamDecoder *fsd ; |
36 | +{ |
37 | +#ifdef LEGACY_FLAC |
38 | + FLAC__SeekableStreamDecoder *fsd ; |
39 | FLAC__SeekableStreamEncoder *fse ; |
40 | +#else |
41 | + FLAC__StreamDecoder *fsd ; |
42 | + FLAC__StreamEncoder *fse ; |
43 | +#endif |
44 | PFLAC_PCM pcmtype ; |
45 | void* ptr ; |
46 | unsigned pos, len, remain ; |
47 | @@ -108,6 +121,7 @@ |
48 | static int flac_command (SF_PRIVATE *psf, int command, void *data, int datasize) ; |
49 | |
50 | /* Decoder Callbacks */ |
51 | +#ifdef LEGACY_FLAC |
52 | static FLAC__SeekableStreamDecoderReadStatus sf_flac_read_callback (const FLAC__SeekableStreamDecoder *decoder, FLAC__byte buffer [], unsigned *bytes, void *client_data) ; |
53 | static FLAC__SeekableStreamDecoderSeekStatus sf_flac_seek_callback (const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data) ; |
54 | static FLAC__SeekableStreamDecoderTellStatus sf_flac_tell_callback (const FLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data) ; |
55 | @@ -116,13 +130,29 @@ |
56 | static FLAC__StreamDecoderWriteStatus sf_flac_write_callback (const FLAC__SeekableStreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer [], void *client_data) ; |
57 | static void sf_flac_meta_callback (const FLAC__SeekableStreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data) ; |
58 | static void sf_flac_error_callback (const FLAC__SeekableStreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data) ; |
59 | +#else |
60 | +static FLAC__StreamDecoderReadStatus sf_flac_read_callback (const FLAC__StreamDecoder *decoder, FLAC__byte buffer [], size_t *bytes, void *client_data) ; |
61 | +static FLAC__StreamDecoderSeekStatus sf_flac_seek_callback (const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data) ; |
62 | +static FLAC__StreamDecoderTellStatus sf_flac_tell_callback (const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data) ; |
63 | +static FLAC__StreamDecoderLengthStatus sf_flac_length_callback (const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data) ; |
64 | +static FLAC__bool sf_flac_eof_callback (const FLAC__StreamDecoder *decoder, void *client_data) ; |
65 | +static FLAC__StreamDecoderWriteStatus sf_flac_write_callback (const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer [], void *client_data) ; |
66 | +static void sf_flac_meta_callback (const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data) ; |
67 | +static void sf_flac_error_callback (const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data) ; |
68 | +#endif |
69 | |
70 | /* Encoder Callbacks */ |
71 | +#ifdef LEGACY_FLAC |
72 | static FLAC__SeekableStreamEncoderSeekStatus sf_flac_enc_seek_callback (const FLAC__SeekableStreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data) ; |
73 | #ifdef HAVE_FLAC_1_1_1 |
74 | static FLAC__SeekableStreamEncoderTellStatus sf_flac_enc_tell_callback (const FLAC__SeekableStreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data) ; |
75 | #endif |
76 | static FLAC__StreamEncoderWriteStatus sf_flac_enc_write_callback (const FLAC__SeekableStreamEncoder *encoder, const FLAC__byte buffer [], unsigned bytes, unsigned samples, unsigned current_frame, void *client_data) ; |
77 | +#else |
78 | +static FLAC__StreamEncoderSeekStatus sf_flac_enc_seek_callback (const FLAC__StreamEncoder *encoder, FLAC__uint64 absolute_byte_offset, void *client_data) ; |
79 | +static FLAC__StreamEncoderTellStatus sf_flac_enc_tell_callback (const FLAC__StreamEncoder *encoder, FLAC__uint64 *absolute_byte_offset, void *client_data) ; |
80 | +static FLAC__StreamEncoderWriteStatus sf_flac_enc_write_callback (const FLAC__StreamEncoder *encoder, const FLAC__byte buffer [], size_t bytes, unsigned samples, unsigned current_frame, void *client_data) ; |
81 | +#endif |
82 | |
83 | static const int legal_sample_rates [] = |
84 | { 8000, 16000, 22050, 24000, 32000, 44100, 48000, 96000 |
85 | @@ -283,51 +313,99 @@ |
86 | } /* flac_buffer_copy */ |
87 | |
88 | |
89 | +#ifdef LEGACY_FLAC |
90 | static FLAC__SeekableStreamDecoderReadStatus |
91 | sf_flac_read_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), FLAC__byte buffer [], unsigned *bytes, void *client_data) |
92 | +#else |
93 | +static FLAC__StreamDecoderReadStatus |
94 | +sf_flac_read_callback (const FLAC__StreamDecoder * UNUSED (decoder), FLAC__byte buffer [], size_t *bytes, void *client_data) |
95 | +#endif |
96 | { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ; |
97 | |
98 | *bytes = psf_fread (buffer, 1, *bytes, psf) ; |
99 | if (*bytes > 0 && psf->error == 0) |
100 | +#ifdef LEGACY_FLAC |
101 | return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_OK ; |
102 | |
103 | return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_ERROR ; |
104 | +#else |
105 | + return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE ; |
106 | + |
107 | + return FLAC__STREAM_DECODER_READ_STATUS_ABORT ; |
108 | +#endif |
109 | } /* sf_flac_read_callback */ |
110 | |
111 | +#ifdef LEGACY_FLAC |
112 | static FLAC__SeekableStreamDecoderSeekStatus |
113 | sf_flac_seek_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), FLAC__uint64 absolute_byte_offset, void *client_data) |
114 | +#else |
115 | +static FLAC__StreamDecoderSeekStatus |
116 | +sf_flac_seek_callback (const FLAC__StreamDecoder * UNUSED (decoder), FLAC__uint64 absolute_byte_offset, void *client_data) |
117 | +#endif |
118 | { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ; |
119 | |
120 | psf_fseek (psf, absolute_byte_offset, SEEK_SET) ; |
121 | if (psf->error) |
122 | +#ifdef LEGACY_FLAC |
123 | return FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_ERROR ; |
124 | |
125 | return FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_OK ; |
126 | +#else |
127 | + return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR ; |
128 | + |
129 | + return FLAC__STREAM_DECODER_SEEK_STATUS_OK ; |
130 | +#endif |
131 | } /* sf_flac_seek_callback */ |
132 | |
133 | +#ifdef LEGACY_FLAC |
134 | static FLAC__SeekableStreamDecoderTellStatus |
135 | sf_flac_tell_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), FLAC__uint64 *absolute_byte_offset, void *client_data) |
136 | +#else |
137 | +static FLAC__StreamDecoderTellStatus |
138 | +sf_flac_tell_callback (const FLAC__StreamDecoder * UNUSED (decoder), FLAC__uint64 *absolute_byte_offset, void *client_data) |
139 | +#endif |
140 | { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ; |
141 | |
142 | *absolute_byte_offset = psf_ftell (psf) ; |
143 | if (psf->error) |
144 | +#ifdef LEGACY_FLAC |
145 | return FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_ERROR ; |
146 | |
147 | return FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_OK ; |
148 | +#else |
149 | + return FLAC__STREAM_DECODER_TELL_STATUS_ERROR ; |
150 | + |
151 | + return FLAC__STREAM_DECODER_TELL_STATUS_OK ; |
152 | +#endif |
153 | } /* sf_flac_tell_callback */ |
154 | |
155 | +#ifdef LEGACY_FLAC |
156 | static FLAC__SeekableStreamDecoderLengthStatus |
157 | sf_flac_length_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), FLAC__uint64 *stream_length, void *client_data) |
158 | +#else |
159 | +static FLAC__StreamDecoderLengthStatus |
160 | +sf_flac_length_callback (const FLAC__StreamDecoder * UNUSED (decoder), FLAC__uint64 *stream_length, void *client_data) |
161 | +#endif |
162 | { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ; |
163 | |
164 | if ((*stream_length = psf->filelength) == 0) |
165 | +#ifdef LEGACY_FLAC |
166 | return FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_ERROR ; |
167 | |
168 | return FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_OK ; |
169 | +#else |
170 | + return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR ; |
171 | + |
172 | + return FLAC__STREAM_DECODER_LENGTH_STATUS_OK ; |
173 | +#endif |
174 | } /* sf_flac_length_callback */ |
175 | |
176 | static FLAC__bool |
177 | +#ifdef LEGACY_FLAC |
178 | sf_flac_eof_callback (const FLAC__SeekableStreamDecoder *UNUSED (decoder), void *client_data) |
179 | +#else |
180 | +sf_flac_eof_callback (const FLAC__StreamDecoder *UNUSED (decoder), void *client_data) |
181 | +#endif |
182 | { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ; |
183 | |
184 | if (psf_ftell (psf) == psf->filelength) |
185 | @@ -337,7 +415,11 @@ |
186 | } /* sf_flac_eof_callback */ |
187 | |
188 | static FLAC__StreamDecoderWriteStatus |
189 | +#ifdef LEGACY_FLAC |
190 | sf_flac_write_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), const FLAC__Frame *frame, const FLAC__int32 * const buffer [], void *client_data) |
191 | +#else |
192 | +sf_flac_write_callback (const FLAC__StreamDecoder * UNUSED (decoder), const FLAC__Frame *frame, const FLAC__int32 * const buffer [], void *client_data) |
193 | +#endif |
194 | { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ; |
195 | FLAC_PRIVATE* pflac = (FLAC_PRIVATE*) psf->codec_data ; |
196 | |
197 | @@ -353,7 +435,11 @@ |
198 | } /* sf_flac_write_callback */ |
199 | |
200 | static void |
201 | +#ifdef LEGACY_FLAC |
202 | sf_flac_meta_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), const FLAC__StreamMetadata *metadata, void *client_data) |
203 | +#else |
204 | +sf_flac_meta_callback (const FLAC__StreamDecoder * UNUSED (decoder), const FLAC__StreamMetadata *metadata, void *client_data) |
205 | +#endif |
206 | { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ; |
207 | |
208 | switch (metadata->type) |
209 | @@ -387,7 +473,11 @@ |
210 | } /* sf_flac_meta_callback */ |
211 | |
212 | static void |
213 | +#ifdef LEGACY_FLAC |
214 | sf_flac_error_callback (const FLAC__SeekableStreamDecoder * UNUSED (decoder), FLAC__StreamDecoderErrorStatus status, void *client_data) |
215 | +#else |
216 | +sf_flac_error_callback (const FLAC__StreamDecoder * UNUSED (decoder), FLAC__StreamDecoderErrorStatus status, void *client_data) |
217 | +#endif |
218 | { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ; |
219 | |
220 | psf_log_printf (psf, "ERROR : %s\n", FLAC__StreamDecoderErrorStatusString [status]) ; |
221 | @@ -407,17 +497,29 @@ |
222 | return ; |
223 | } /* sf_flac_error_callback */ |
224 | |
225 | +#ifdef LEGACY_FLAC |
226 | static FLAC__SeekableStreamEncoderSeekStatus |
227 | sf_flac_enc_seek_callback (const FLAC__SeekableStreamEncoder * UNUSED (encoder), FLAC__uint64 absolute_byte_offset, void *client_data) |
228 | +#else |
229 | +static FLAC__StreamEncoderSeekStatus |
230 | +sf_flac_enc_seek_callback (const FLAC__StreamEncoder * UNUSED (encoder), FLAC__uint64 absolute_byte_offset, void *client_data) |
231 | +#endif |
232 | { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ; |
233 | |
234 | psf_fseek (psf, absolute_byte_offset, SEEK_SET) ; |
235 | if (psf->error) |
236 | +#ifdef LEGACY_FLAC |
237 | return FLAC__SEEKABLE_STREAM_ENCODER_SEEK_STATUS_ERROR ; |
238 | |
239 | return FLAC__SEEKABLE_STREAM_ENCODER_SEEK_STATUS_OK ; |
240 | +#else |
241 | + return FLAC__STREAM_ENCODER_SEEK_STATUS_ERROR ; |
242 | + |
243 | + return FLAC__STREAM_ENCODER_SEEK_STATUS_OK ; |
244 | +#endif |
245 | } /* sf_flac_enc_seek_callback */ |
246 | |
247 | +#ifdef LEGACY_FLAC |
248 | #ifdef HAVE_FLAC_1_1_1 |
249 | static FLAC__SeekableStreamEncoderTellStatus |
250 | sf_flac_enc_tell_callback (const FLAC__SeekableStreamEncoder *UNUSED (encoder), FLAC__uint64 *absolute_byte_offset, void *client_data) |
251 | @@ -430,9 +532,25 @@ |
252 | return FLAC__SEEKABLE_STREAM_ENCODER_TELL_STATUS_OK ; |
253 | } /* sf_flac_enc_tell_callback */ |
254 | #endif |
255 | +#else |
256 | +static FLAC__StreamEncoderTellStatus |
257 | +sf_flac_enc_tell_callback (const FLAC__StreamEncoder *UNUSED (encoder), FLAC__uint64 *absolute_byte_offset, void *client_data) |
258 | +{ SF_PRIVATE *psf = (SF_PRIVATE*) client_data ; |
259 | + |
260 | + *absolute_byte_offset = psf_ftell (psf) ; |
261 | + if (psf->error) |
262 | + return FLAC__STREAM_ENCODER_TELL_STATUS_ERROR ; |
263 | + |
264 | + return FLAC__STREAM_ENCODER_TELL_STATUS_OK ; |
265 | +} /* sf_flac_enc_tell_callback */ |
266 | +#endif |
267 | |
268 | static FLAC__StreamEncoderWriteStatus |
269 | +#ifdef LEGACY_FLAC |
270 | sf_flac_enc_write_callback (const FLAC__SeekableStreamEncoder * UNUSED (encoder), const FLAC__byte buffer [], unsigned bytes, unsigned UNUSED (samples), unsigned UNUSED (current_frame), void *client_data) |
271 | +#else |
272 | +sf_flac_enc_write_callback (const FLAC__StreamEncoder * UNUSED (encoder), const FLAC__byte buffer [], size_t bytes, unsigned UNUSED (samples), unsigned UNUSED (current_frame), void *client_data) |
273 | +#endif |
274 | { SF_PRIVATE *psf = (SF_PRIVATE*) client_data ; |
275 | |
276 | if (psf_fwrite (buffer, 1, bytes, psf) == bytes && psf->error == 0) |
277 | @@ -509,15 +627,27 @@ |
278 | return 0 ; |
279 | |
280 | if (psf->mode == SFM_WRITE) |
281 | - { FLAC__seekable_stream_encoder_finish (pflac->fse) ; |
282 | + { |
283 | +#ifdef LEGACY_FLAC |
284 | + FLAC__seekable_stream_encoder_finish (pflac->fse) ; |
285 | FLAC__seekable_stream_encoder_delete (pflac->fse) ; |
286 | +#else |
287 | + FLAC__stream_encoder_finish (pflac->fse) ; |
288 | + FLAC__stream_encoder_delete (pflac->fse) ; |
289 | +#endif |
290 | if (pflac->encbuffer) |
291 | free (pflac->encbuffer) ; |
292 | } ; |
293 | |
294 | if (psf->mode == SFM_READ) |
295 | - { FLAC__seekable_stream_decoder_finish (pflac->fsd) ; |
296 | + { |
297 | +#ifdef LEGACY_FLAC |
298 | + FLAC__seekable_stream_decoder_finish (pflac->fsd) ; |
299 | FLAC__seekable_stream_decoder_delete (pflac->fsd) ; |
300 | +#else |
301 | + FLAC__stream_decoder_finish (pflac->fsd) ; |
302 | + FLAC__stream_decoder_delete (pflac->fsd) ; |
303 | +#endif |
304 | } ; |
305 | |
306 | for (k = 0 ; k < ARRAY_LEN (pflac->rbuffer) ; k++) |
307 | @@ -546,17 +676,6 @@ |
308 | return SFE_FLAC_BAD_SAMPLE_RATE ; |
309 | |
310 | psf_fseek (psf, 0, SEEK_SET) ; |
311 | - if ((pflac->fse = FLAC__seekable_stream_encoder_new ()) == NULL) |
312 | - return SFE_FLAC_NEW_DECODER ; |
313 | - FLAC__seekable_stream_encoder_set_write_callback (pflac->fse, sf_flac_enc_write_callback) ; |
314 | - FLAC__seekable_stream_encoder_set_seek_callback (pflac->fse, sf_flac_enc_seek_callback) ; |
315 | - |
316 | -#ifdef HAVE_FLAC_1_1_1 |
317 | - FLAC__seekable_stream_encoder_set_tell_callback (pflac->fse, sf_flac_enc_tell_callback) ; |
318 | -#endif |
319 | - FLAC__seekable_stream_encoder_set_client_data (pflac->fse, psf) ; |
320 | - FLAC__seekable_stream_encoder_set_channels (pflac->fse, psf->sf.channels) ; |
321 | - FLAC__seekable_stream_encoder_set_sample_rate (pflac->fse, psf->sf.samplerate) ; |
322 | |
323 | switch (psf->sf.format & SF_FORMAT_SUBMASK) |
324 | { case SF_FORMAT_PCM_S8 : |
325 | @@ -574,12 +693,36 @@ |
326 | break ; |
327 | } ; |
328 | |
329 | +#ifdef LEGACY_FLAC |
330 | + if ((pflac->fse = FLAC__seekable_stream_encoder_new ()) == NULL) |
331 | + return SFE_FLAC_NEW_DECODER ; |
332 | + FLAC__seekable_stream_encoder_set_write_callback (pflac->fse, sf_flac_enc_write_callback) ; |
333 | + FLAC__seekable_stream_encoder_set_seek_callback (pflac->fse, sf_flac_enc_seek_callback) ; |
334 | + |
335 | +#ifdef HAVE_FLAC_1_1_1 |
336 | + FLAC__seekable_stream_encoder_set_tell_callback (pflac->fse, sf_flac_enc_tell_callback) ; |
337 | +#endif |
338 | + FLAC__seekable_stream_encoder_set_client_data (pflac->fse, psf) ; |
339 | + FLAC__seekable_stream_encoder_set_channels (pflac->fse, psf->sf.channels) ; |
340 | + FLAC__seekable_stream_encoder_set_sample_rate (pflac->fse, psf->sf.samplerate) ; |
341 | FLAC__seekable_stream_encoder_set_bits_per_sample (pflac->fse, bps) ; |
342 | |
343 | if ((bps = FLAC__seekable_stream_encoder_init (pflac->fse)) != FLAC__SEEKABLE_STREAM_DECODER_OK) |
344 | { psf_log_printf (psf, "Error : FLAC encoder init returned error : %s\n", FLAC__seekable_stream_encoder_get_resolved_state_string (pflac->fse)) ; |
345 | return SFE_FLAC_INIT_DECODER ; |
346 | } ; |
347 | +#else |
348 | + if ((pflac->fse = FLAC__stream_encoder_new ()) == NULL) |
349 | + return SFE_FLAC_NEW_DECODER ; |
350 | + FLAC__stream_encoder_set_channels (pflac->fse, psf->sf.channels) ; |
351 | + FLAC__stream_encoder_set_sample_rate (pflac->fse, psf->sf.samplerate) ; |
352 | + FLAC__stream_encoder_set_bits_per_sample (pflac->fse, bps) ; |
353 | + |
354 | + if ((bps = FLAC__stream_encoder_init_stream (pflac->fse, sf_flac_enc_write_callback, sf_flac_enc_seek_callback, sf_flac_enc_tell_callback, NULL, psf)) != FLAC__STREAM_DECODER_INIT_STATUS_OK) |
355 | + { psf_log_printf (psf, "Error : FLAC encoder init returned error : %s\n", FLAC__StreamEncoderInitStatusString[bps]) ; |
356 | + return SFE_FLAC_INIT_DECODER ; |
357 | + } ; |
358 | +#endif |
359 | |
360 | if (psf->error == 0) |
361 | psf->dataoffset = psf_ftell (psf) ; |
362 | @@ -593,6 +736,7 @@ |
363 | { FLAC_PRIVATE* pflac = (FLAC_PRIVATE*) psf->codec_data ; |
364 | |
365 | psf_fseek (psf, 0, SEEK_SET) ; |
366 | +#ifdef LEGACY_FLAC |
367 | if ((pflac->fsd = FLAC__seekable_stream_decoder_new ()) == NULL) |
368 | return SFE_FLAC_NEW_DECODER ; |
369 | |
370 | @@ -610,9 +754,22 @@ |
371 | return SFE_FLAC_INIT_DECODER ; |
372 | |
373 | FLAC__seekable_stream_decoder_process_until_end_of_metadata (pflac->fsd) ; |
374 | +#else |
375 | + if ((pflac->fsd = FLAC__stream_decoder_new ()) == NULL) |
376 | + return SFE_FLAC_NEW_DECODER ; |
377 | + |
378 | + if (FLAC__stream_decoder_init_stream (pflac->fsd, sf_flac_read_callback, sf_flac_seek_callback, sf_flac_tell_callback, sf_flac_length_callback, sf_flac_eof_callback, sf_flac_write_callback, sf_flac_meta_callback, sf_flac_error_callback, psf) != FLAC__STREAM_DECODER_INIT_STATUS_OK) |
379 | + return SFE_FLAC_INIT_DECODER ; |
380 | + |
381 | + FLAC__stream_decoder_process_until_end_of_metadata (pflac->fsd) ; |
382 | +#endif |
383 | if (psf->error == 0) |
384 | { FLAC__uint64 position ; |
385 | +#ifdef LEGACY_FLAC |
386 | FLAC__seekable_stream_decoder_get_decode_position (pflac->fsd, &position) ; |
387 | +#else |
388 | + FLAC__stream_decoder_get_decode_position (pflac->fsd, &position) ; |
389 | +#endif |
390 | psf->dataoffset = position ; |
391 | } ; |
392 | |
393 | @@ -676,10 +833,18 @@ |
394 | flac_buffer_copy (psf) ; |
395 | |
396 | while (pflac->pos < pflac->len) |
397 | - { if (FLAC__seekable_stream_decoder_process_single (pflac->fsd) == 0) |
398 | + { |
399 | +#ifdef LEGACY_FLAC |
400 | + if (FLAC__seekable_stream_decoder_process_single (pflac->fsd) == 0) |
401 | break ; |
402 | if (FLAC__seekable_stream_decoder_get_state (pflac->fsd) != FLAC__SEEKABLE_STREAM_DECODER_OK) |
403 | break ; |
404 | +#else |
405 | + if (FLAC__stream_decoder_process_single (pflac->fsd) == 0) |
406 | + break ; |
407 | + if (FLAC__stream_decoder_get_state (pflac->fsd) >= FLAC__STREAM_DECODER_END_OF_STREAM) |
408 | + break ; |
409 | +#endif |
410 | } ; |
411 | |
412 | pflac->ptr = NULL ; |
413 | @@ -795,7 +960,11 @@ |
414 | while (len > 0) |
415 | { writecount = (len >= bufferlen) ? bufferlen : (int) len ; |
416 | convert (ptr + total, buffer, writecount) ; |
417 | +#ifdef LEGACY_FLAC |
418 | if (FLAC__seekable_stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels)) |
419 | +#else |
420 | + if (FLAC__stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels)) |
421 | +#endif |
422 | thiswrite = writecount ; |
423 | else |
424 | break ; |
425 | @@ -837,7 +1006,11 @@ |
426 | while (len > 0) |
427 | { writecount = (len >= bufferlen) ? bufferlen : (int) len ; |
428 | convert (ptr + total, buffer, writecount) ; |
429 | +#ifdef LEGACY_FLAC |
430 | if (FLAC__seekable_stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels)) |
431 | +#else |
432 | + if (FLAC__stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels)) |
433 | +#endif |
434 | thiswrite = writecount ; |
435 | else |
436 | break ; |
437 | @@ -879,7 +1052,11 @@ |
438 | while (len > 0) |
439 | { writecount = (len >= bufferlen) ? bufferlen : (int) len ; |
440 | convert (ptr + total, buffer, writecount, psf->norm_float) ; |
441 | +#ifdef LEGACY_FLAC |
442 | if (FLAC__seekable_stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels)) |
443 | +#else |
444 | + if (FLAC__stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels)) |
445 | +#endif |
446 | thiswrite = writecount ; |
447 | else |
448 | break ; |
449 | @@ -1011,7 +1188,11 @@ |
450 | while (len > 0) |
451 | { writecount = (len >= bufferlen) ? bufferlen : (int) len ; |
452 | convert (ptr + total, buffer, writecount, psf->norm_double) ; |
453 | +#ifdef LEGACY_FLAC |
454 | if (FLAC__seekable_stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels)) |
455 | +#else |
456 | + if (FLAC__stream_encoder_process_interleaved (pflac->fse, buffer, writecount/psf->sf.channels)) |
457 | +#endif |
458 | thiswrite = writecount ; |
459 | else |
460 | break ; |
461 | @@ -1131,10 +1312,17 @@ |
462 | |
463 | if (psf->mode == SFM_READ) |
464 | { FLAC__uint64 position ; |
465 | +#ifdef LEGACY_FLAC |
466 | if (FLAC__seekable_stream_decoder_seek_absolute (pflac->fsd, offset)) |
467 | { FLAC__seekable_stream_decoder_get_decode_position (pflac->fsd, &position) ; |
468 | return offset ; |
469 | } ; |
470 | +#else |
471 | + if (FLAC__stream_decoder_seek_absolute (pflac->fsd, offset)) |
472 | + { FLAC__stream_decoder_get_decode_position (pflac->fsd, &position) ; |
473 | + return offset ; |
474 | + } ; |
475 | +#endif |
476 | |
477 | return ((sf_count_t) -1) ; |
478 | } ; |