Annotation of /trunk/libsndfile/patches/libsndfile-1.0.17-flac-1.1.3.patch
Parent Directory | Revision Log
Revision 487 -
(hide 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 | niro | 487 | 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 | } ; |