Ticket #11424: patch-flac

File patch-flac, 23.7 KB (added by ehainry@…, 14 years ago)

patch for _flac_common.h and flac_plugin.c (both remove the dependency on seekable_stream)

Line 
1--- src/inputPlugins/_flac_common.h.orig        2007-04-02 11:51:57.000000000 +0200
2+++ src/inputPlugins/_flac_common.h     2007-04-02 11:52:10.000000000 +0200
3@@ -30,7 +30,116 @@
4 #include "../inputStream.h"
5 #include "../outputBuffer.h"
6 #include "../decode.h"
7-#include <FLAC/seekable_stream_decoder.h>
8+#include <FLAC/export.h>
9+#if !defined(FLAC_API_VERSION_CURRENT) || FLAC_API_VERSION_CURRENT <= 7
10+#  include <FLAC/seekable_stream_decoder.h>
11+#  define flac_decoder           FLAC__SeekableStreamDecoder
12+#  define flac_new()             FLAC__seekable_stream_decoder_new()
13+
14+#  define flac_ogg_init(a,b,c,d,e,f,g,h,i,j) (0)
15+
16+#  define flac_get_decode_position(x,y) \
17+                 FLAC__seekable_stream_decoder_get_decode_position(x,y)
18+#  define flac_get_state(x)      FLAC__seekable_stream_decoder_get_state(x)
19+#  define flac_process_single(x) FLAC__seekable_stream_decoder_process_single(x)
20+#  define flac_process_metadata(x) \
21+                 FLAC__seekable_stream_decoder_process_until_end_of_metadata(x)
22+#  define flac_seek_absolute(x,y) \
23+                 FLAC__seekable_stream_decoder_seek_absolute(x,y)
24+#  define flac_finish(x)         FLAC__seekable_stream_decoder_finish(x)
25+#  define flac_delete(x)         FLAC__seekable_stream_decoder_delete(x)
26+
27+#  define flac_decoder_eof       FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM
28+
29+typedef unsigned flac_read_status_size_t;
30+#  define flac_read_status       FLAC__SeekableStreamDecoderReadStatus
31+#  define flac_read_status_continue \
32+                                 FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_OK
33+#  define flac_read_status_eof   FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_OK
34+#  define flac_read_status_abort \
35+                               FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_ERROR
36+
37+#  define flac_seek_status       FLAC__SeekableStreamDecoderSeekStatus
38+#  define flac_seek_status_ok    FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_OK
39+#  define flac_seek_status_error FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_ERROR
40+
41+#  define flac_tell_status         FLAC__SeekableStreamDecoderTellStatus
42+#  define flac_tell_status_ok      FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_OK
43+#  define flac_tell_status_error \
44+                                FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_ERROR
45+#  define flac_tell_status_unsupported \
46+                                FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_ERROR
47+
48+#  define flac_length_status       FLAC__SeekableStreamDecoderLengthStatus
49+#  define flac_length_status_ok  FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_OK
50+#  define flac_length_status_error \
51+                              FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_ERROR
52+#  define flac_length_status_unsupported \
53+                              FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_ERROR
54+
55+#  ifdef HAVE_OGGFLAC
56+#    include <OggFLAC/seekable_stream_decoder.h>
57+#  endif
58+#else /* FLAC_API_VERSION_CURRENT >= 7 */
59+
60+   /* OggFLAC support is handled by our flac_plugin already, and
61+    * thus we *can* always have it if libFLAC was compiled with it */
62+#  ifndef HAVE_OGGFLAC
63+#    define HAVE_OGGFLAC 1
64+#  endif
65+#  include "_ogg_common.h"
66+#  undef HAVE_OGGFLAC /* we don't need this defined anymore */
67+
68+#  include <FLAC/stream_decoder.h>
69+#  define flac_decoder           FLAC__StreamDecoder
70+#  define flac_new()             FLAC__stream_decoder_new()
71+
72+#  define flac_init(a,b,c,d,e,f,g,h,i,j) \
73+        (FLAC__stream_decoder_init_stream(a,b,c,d,e,f,g,h,i,j) \
74+         == FLAC__STREAM_DECODER_INIT_STATUS_OK)
75+#  define flac_ogg_init(a,b,c,d,e,f,g,h,i,j) \
76+        (FLAC__stream_decoder_init_ogg_stream(a,b,c,d,e,f,g,h,i,j) \
77+         == FLAC__STREAM_DECODER_INIT_STATUS_OK)
78+
79+#  define flac_get_decode_position(x,y) \
80+                 FLAC__stream_decoder_get_decode_position(x,y)
81+#  define flac_get_state(x)      FLAC__stream_decoder_get_state(x)
82+#  define flac_process_single(x) FLAC__stream_decoder_process_single(x)
83+#  define flac_process_metadata(x) \
84+                          FLAC__stream_decoder_process_until_end_of_metadata(x)
85+#  define flac_seek_absolute(x,y)  FLAC__stream_decoder_seek_absolute(x,y)
86+#  define flac_finish(x)         FLAC__stream_decoder_finish(x)
87+#  define flac_delete(x)         FLAC__stream_decoder_delete(x)
88+
89+#  define flac_decoder_eof       FLAC__STREAM_DECODER_END_OF_STREAM
90+
91+typedef size_t flac_read_status_size_t;
92+#  define flac_read_status       FLAC__StreamDecoderReadStatus
93+#  define flac_read_status_continue \
94+                                 FLAC__STREAM_DECODER_READ_STATUS_CONTINUE
95+#  define flac_read_status_eof   FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM
96+#  define flac_read_status_abort FLAC__STREAM_DECODER_READ_STATUS_ABORT
97+
98+#  define flac_seek_status       FLAC__StreamDecoderSeekStatus
99+#  define flac_seek_status_ok    FLAC__STREAM_DECODER_SEEK_STATUS_OK
100+#  define flac_seek_status_error FLAC__STREAM_DECODER_SEEK_STATUS_ERROR
101+#  define flac_seek_status_unsupported \
102+                                 FLAC__STREAM_DECODER_SEEK_STATUS_UNSUPPORTED
103+
104+#  define flac_tell_status         FLAC__StreamDecoderTellStatus
105+#  define flac_tell_status_ok      FLAC__STREAM_DECODER_TELL_STATUS_OK
106+#  define flac_tell_status_error   FLAC__STREAM_DECODER_TELL_STATUS_ERROR
107+#  define flac_tell_status_unsupported \
108+                                   FLAC__STREAM_DECODER_TELL_STATUS_UNSUPPORTED
109+
110+#  define flac_length_status       FLAC__StreamDecoderLengthStatus
111+#  define flac_length_status_ok    FLAC__STREAM_DECODER_LENGTH_STATUS_OK
112+#  define flac_length_status_error FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR
113+#  define flac_length_status_unsupported \
114+                                 FLAC__STREAM_DECODER_LENGTH_STATUS_UNSUPPORTED
115+
116+#endif /* FLAC_API_VERSION_CURRENT >= 7 */
117+
118 #include <FLAC/metadata.h>
119 
120 #define FLAC_CHUNK_SIZE 4080
121
122--- src/inputPlugins/flac_plugin.c.orig 2007-04-02 11:54:26.000000000 +0200
123+++ src/inputPlugins/flac_plugin.c      2007-04-02 11:54:42.000000000 +0200
124@@ -16,12 +16,10 @@
125  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
126  */
127 
128-#include "../inputPlugin.h"
129+#include "_flac_common.h"
130 
131 #ifdef HAVE_FLAC
132 
133-#include "_flac_common.h"
134-
135 #include "../utils.h"
136 #include "../log.h"
137 #include "../pcm_utils.h"
138@@ -33,166 +31,14 @@
139 #include <stdio.h>
140 #include <string.h>
141 #include <unistd.h>
142-#include <FLAC/seekable_stream_decoder.h>
143-#include <FLAC/metadata.h>
144-
145-/* this code is based on flac123, from flac-tools */
146-
147-static void flacError(const FLAC__SeekableStreamDecoder *,
148-                     FLAC__StreamDecoderErrorStatus, void *);
149-static void flacPrintErroredState(FLAC__SeekableStreamDecoderState state);
150-static void flacMetadata(const FLAC__SeekableStreamDecoder *,
151-                        const FLAC__StreamMetadata *, void *);
152-static FLAC__StreamDecoderWriteStatus flacWrite(const
153-                                               FLAC__SeekableStreamDecoder *,
154-                                               const FLAC__Frame *,
155-                                               const FLAC__int32 * const buf[],
156-                                               void *);
157-static FLAC__SeekableStreamDecoderReadStatus flacRead(const
158-                                                     FLAC__SeekableStreamDecoder
159-                                                     *, FLAC__byte buf[],
160-                                                     unsigned *, void *);
161-static FLAC__SeekableStreamDecoderSeekStatus flacSeek(const
162-                                                     FLAC__SeekableStreamDecoder
163-                                                     *, FLAC__uint64, void *);
164-static FLAC__SeekableStreamDecoderTellStatus flacTell(const
165-                                                     FLAC__SeekableStreamDecoder
166-                                                     *, FLAC__uint64 *,
167-                                                     void *);
168-static FLAC__SeekableStreamDecoderLengthStatus flacLength(const
169-                                                         FLAC__SeekableStreamDecoder
170-                                                         *, FLAC__uint64 *,
171-                                                         void *);
172-static FLAC__bool flacEOF(const FLAC__SeekableStreamDecoder *, void *);
173-
174-static int flac_decode(OutputBuffer * cb, DecoderControl * dc,
175-                      InputStream * inStream)
176-{
177-       FLAC__SeekableStreamDecoder *flacDec = NULL;
178-       FlacData data;
179-       int status = 1;
180-       int ret = 0;
181-
182-       init_FlacData(&data, cb, dc, inStream);
183-
184-       if (!(flacDec = FLAC__seekable_stream_decoder_new())) {
185-               ret = -1;
186-               goto fail;
187-       }
188-       /*status&=FLAC__file_decoder_set_md5_checking(flacDec,1); */
189-       status &= FLAC__seekable_stream_decoder_set_read_callback(flacDec,
190-                                                                 flacRead);
191-       status &= FLAC__seekable_stream_decoder_set_seek_callback(flacDec,
192-                                                                 flacSeek);
193-       status &= FLAC__seekable_stream_decoder_set_tell_callback(flacDec,
194-                                                                 flacTell);
195-       status &= FLAC__seekable_stream_decoder_set_length_callback(flacDec,
196-                                                                   flacLength);
197-       status &=
198-           FLAC__seekable_stream_decoder_set_eof_callback(flacDec, flacEOF);
199-       status &=
200-           FLAC__seekable_stream_decoder_set_write_callback(flacDec,
201-                                                            flacWrite);
202-       status &=
203-           FLAC__seekable_stream_decoder_set_metadata_callback(flacDec,
204-                                                               flacMetadata);
205-       status &=
206-           FLAC__seekable_stream_decoder_set_metadata_respond(flacDec,
207-                                                              FLAC__METADATA_TYPE_VORBIS_COMMENT);
208-       status &=
209-           FLAC__seekable_stream_decoder_set_error_callback(flacDec,
210-                                                            flacError);
211-       status &=
212-           FLAC__seekable_stream_decoder_set_client_data(flacDec,
213-                                                         (void *)&data);
214-       if (!status) {
215-               ERROR("flac problem before init()\n");
216-               flacPrintErroredState(FLAC__seekable_stream_decoder_get_state
217-                                     (flacDec));
218-               ret = -1;
219-               goto fail;
220-       }
221-
222-       if (FLAC__seekable_stream_decoder_init(flacDec) !=
223-           FLAC__SEEKABLE_STREAM_DECODER_OK) {
224-               ERROR("flac problem doing init()\n");
225-               flacPrintErroredState(FLAC__seekable_stream_decoder_get_state
226-                                     (flacDec));
227-               ret = -1;
228-               goto fail;
229-       }
230-
231-       if (!FLAC__seekable_stream_decoder_process_until_end_of_metadata
232-           (flacDec)) {
233-               ERROR("flac problem reading metadata\n");
234-               flacPrintErroredState(FLAC__seekable_stream_decoder_get_state
235-                                     (flacDec));
236-               ret = -1;
237-               goto fail;
238-       }
239-
240-       dc->state = DECODE_STATE_DECODE;
241-
242-       while (1) {
243-               FLAC__seekable_stream_decoder_process_single(flacDec);
244-               if (FLAC__seekable_stream_decoder_get_state(flacDec) !=
245-                   FLAC__SEEKABLE_STREAM_DECODER_OK) {
246-                       break;
247-               }
248-               if (dc->seek) {
249-                       FLAC__uint64 sampleToSeek = dc->seekWhere *
250-                           dc->audioFormat.sampleRate + 0.5;
251-                       if (FLAC__seekable_stream_decoder_seek_absolute(flacDec,
252-                                                                       sampleToSeek))
253-                       {
254-                               clearOutputBuffer(cb);
255-                               data.time = ((float)sampleToSeek) /
256-                                   dc->audioFormat.sampleRate;
257-                               data.position = 0;
258-                       } else
259-                               dc->seekError = 1;
260-                       dc->seek = 0;
261-               }
262-       }
263-       /* I don't think we need this bit here! -shank */
264-       /*FLAC__file_decoder_process_until_end_of_file(flacDec); */
265-       if (!dc->stop) {
266-               flacPrintErroredState(FLAC__seekable_stream_decoder_get_state
267-                                     (flacDec));
268-               FLAC__seekable_stream_decoder_finish(flacDec);
269-       }
270-       /* send last little bit */
271-       if (data.chunk_length > 0 && !dc->stop) {
272-               flacSendChunk(&data);
273-               flushOutputBuffer(data.cb);
274-       }
275-
276-       /*if(dc->seek) {
277-          dc->seekError = 1;
278-          dc->seek = 0;
279-          } */
280-
281-       dc->state = DECODE_STATE_STOP;
282-       dc->stop = 0;
283-
284-fail:
285-       if (data.replayGainInfo)
286-               freeReplayGainInfo(data.replayGainInfo);
287-
288-       if (flacDec)
289-               FLAC__seekable_stream_decoder_delete(flacDec);
290-
291-       closeInputStream(inStream);
292+#include <assert.h>
293 
294-       return ret;
295-}
296+/* this code was based on flac123, from flac-tools */
297 
298-static FLAC__SeekableStreamDecoderReadStatus flacRead(const
299-                                                     FLAC__SeekableStreamDecoder
300-                                                     * flacDec,
301-                                                     FLAC__byte buf[],
302-                                                     unsigned *bytes,
303-                                                     void *fdata)
304+static flac_read_status flacRead(const flac_decoder * flacDec,
305+                                  FLAC__byte buf[],
306+                                 flac_read_status_size_t *bytes,
307+                                 void *fdata)
308 {
309        FlacData *data = (FlacData *) fdata;
310        size_t r;
311@@ -207,55 +53,51 @@
312        }
313        *bytes = r;
314 
315-       if (*bytes == 0 && !inputStreamAtEOF(data->inStream) && !data->dc->stop)
316-               return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_ERROR;
317-
318-       return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_OK;
319+       if (r == 0 && !data->dc->stop) {
320+               if (inputStreamAtEOF(data->inStream))
321+                       return flac_read_status_eof;
322+               else
323+                       return flac_read_status_abort;
324+       }
325+       return flac_read_status_continue;
326 }
327 
328-static FLAC__SeekableStreamDecoderSeekStatus flacSeek(const
329-                                                     FLAC__SeekableStreamDecoder
330-                                                     * flacDec,
331-                                                     FLAC__uint64 offset,
332-                                                     void *fdata)
333+static flac_seek_status flacSeek(const flac_decoder * flacDec,
334+                                FLAC__uint64 offset,
335+                                void *fdata)
336 {
337        FlacData *data = (FlacData *) fdata;
338 
339        if (seekInputStream(data->inStream, offset, SEEK_SET) < 0) {
340-               return FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_ERROR;
341+               return flac_seek_status_error;
342        }
343 
344-       return FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_OK;
345+       return flac_seek_status_ok;
346 }
347 
348-static FLAC__SeekableStreamDecoderTellStatus flacTell(const
349-                                                     FLAC__SeekableStreamDecoder
350-                                                     * flacDec,
351-                                                     FLAC__uint64 * offset,
352-                                                     void *fdata)
353+static flac_tell_status flacTell(const flac_decoder * flacDec,
354+                                FLAC__uint64 * offset,
355+                                void *fdata)
356 {
357        FlacData *data = (FlacData *) fdata;
358 
359        *offset = (long)(data->inStream->offset);
360 
361-       return FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_OK;
362+       return flac_tell_status_ok;
363 }
364 
365-static FLAC__SeekableStreamDecoderLengthStatus flacLength(const
366-                                                         FLAC__SeekableStreamDecoder
367-                                                         * flacDec,
368-                                                         FLAC__uint64 * length,
369-                                                         void *fdata)
370+static flac_length_status flacLength(const flac_decoder * flacDec,
371+                                    FLAC__uint64 * length,
372+                                    void *fdata)
373 {
374        FlacData *data = (FlacData *) fdata;
375 
376        *length = (size_t) (data->inStream->size);
377 
378-       return FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_OK;
379+       return flac_length_status_ok;
380 }
381 
382-static FLAC__bool flacEOF(const FLAC__SeekableStreamDecoder * flacDec,
383-                         void *fdata)
384+static FLAC__bool flacEOF(const flac_decoder * flacDec, void *fdata)
385 {
386        FlacData *data = (FlacData *) fdata;
387 
388@@ -264,52 +106,112 @@
389        return false;
390 }
391 
392-static void flacError(const FLAC__SeekableStreamDecoder * dec,
393+static void flacError(const flac_decoder *dec,
394                      FLAC__StreamDecoderErrorStatus status, void *fdata)
395 {
396        flac_error_common_cb("flac", status, (FlacData *) fdata);
397 }
398 
399+#if !defined(FLAC_API_VERSION_CURRENT) || FLAC_API_VERSION_CURRENT <= 7
400 static void flacPrintErroredState(FLAC__SeekableStreamDecoderState state)
401 {
402+       const char *str = ""; /* "" to silence compiler warning */
403        switch (state) {
404+       case FLAC__SEEKABLE_STREAM_DECODER_OK:
405+       case FLAC__SEEKABLE_STREAM_DECODER_SEEKING:
406+       case FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM:
407+               return;
408        case FLAC__SEEKABLE_STREAM_DECODER_MEMORY_ALLOCATION_ERROR:
409-               ERROR("flac allocation error\n");
410+               str = "allocation error";
411                break;
412        case FLAC__SEEKABLE_STREAM_DECODER_READ_ERROR:
413-               ERROR("flac read error\n");
414+               str = "read error";
415                break;
416        case FLAC__SEEKABLE_STREAM_DECODER_SEEK_ERROR:
417-               ERROR("flac seek error\n");
418+               str = "seek error";
419                break;
420        case FLAC__SEEKABLE_STREAM_DECODER_STREAM_DECODER_ERROR:
421-               ERROR("flac seekable stream error\n");
422+               str = "seekable stream error";
423                break;
424        case FLAC__SEEKABLE_STREAM_DECODER_ALREADY_INITIALIZED:
425-               ERROR("flac decoder already initialized\n");
426+               str = "decoder already initialized";
427                break;
428        case FLAC__SEEKABLE_STREAM_DECODER_INVALID_CALLBACK:
429-               ERROR("invalid flac callback\n");
430+               str = "invalid callback";
431                break;
432        case FLAC__SEEKABLE_STREAM_DECODER_UNINITIALIZED:
433-               ERROR("flac decoder uninitialized\n");
434+               str = "decoder uninitialized";
435+       }
436+       ERROR("flac %s\n", str);
437+}
438+
439+static int flac_init(FLAC__SeekableStreamDecoder *dec,
440+                     FLAC__SeekableStreamDecoderReadCallback read_cb,
441+                     FLAC__SeekableStreamDecoderSeekCallback seek_cb,
442+                     FLAC__SeekableStreamDecoderTellCallback tell_cb,
443+                     FLAC__SeekableStreamDecoderLengthCallback length_cb,
444+                     FLAC__SeekableStreamDecoderEofCallback eof_cb,
445+                     FLAC__SeekableStreamDecoderWriteCallback write_cb,
446+                     FLAC__SeekableStreamDecoderMetadataCallback metadata_cb,
447+                     FLAC__SeekableStreamDecoderErrorCallback error_cb,
448+                     void *data)
449+{
450+       int s = 1;
451+       s &= FLAC__seekable_stream_decoder_set_read_callback(dec, read_cb);
452+       s &= FLAC__seekable_stream_decoder_set_seek_callback(dec, seek_cb);
453+       s &= FLAC__seekable_stream_decoder_set_tell_callback(dec, tell_cb);
454+       s &= FLAC__seekable_stream_decoder_set_length_callback(dec, length_cb);
455+       s &= FLAC__seekable_stream_decoder_set_eof_callback(dec, eof_cb);
456+       s &= FLAC__seekable_stream_decoder_set_write_callback(dec, write_cb);
457+       s &= FLAC__seekable_stream_decoder_set_metadata_callback(dec,
458+                                                                metadata_cb);
459+       s &= FLAC__seekable_stream_decoder_set_metadata_respond(dec,
460+                                         FLAC__METADATA_TYPE_VORBIS_COMMENT);
461+       s &= FLAC__seekable_stream_decoder_set_error_callback(dec, error_cb);
462+       s &= FLAC__seekable_stream_decoder_set_client_data(dec, data);
463+       if (!s || (FLAC__seekable_stream_decoder_init(dec) !=
464+                  FLAC__SEEKABLE_STREAM_DECODER_OK))
465+               return 0;
466+       return 1;
467+}
468+#else /* FLAC_API_VERSION_CURRENT >= 7 */
469+static void flacPrintErroredState(FLAC__StreamDecoderState state)
470+{
471+       const char *str = ""; /* "" to silence compiler warning */
472+       switch (state) {
473+       case FLAC__STREAM_DECODER_SEARCH_FOR_METADATA:
474+       case FLAC__STREAM_DECODER_READ_METADATA:
475+       case FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC:
476+       case FLAC__STREAM_DECODER_READ_FRAME:
477+       case FLAC__STREAM_DECODER_END_OF_STREAM:
478+               return;
479+       case FLAC__STREAM_DECODER_OGG_ERROR:
480+               str = "error in the Ogg layer";
481                break;
482-       case FLAC__SEEKABLE_STREAM_DECODER_OK:
483-       case FLAC__SEEKABLE_STREAM_DECODER_SEEKING:
484-       case FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM:
485+       case FLAC__STREAM_DECODER_SEEK_ERROR:
486+               str = "seek error";
487+               break;
488+       case FLAC__STREAM_DECODER_ABORTED:
489+               str = "decoder aborted by read";
490+               break;
491+       case FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR:
492+               str = "allocation error";
493                break;
494+       case FLAC__STREAM_DECODER_UNINITIALIZED:
495+               str = "decoder uninitialized";
496        }
497+       ERROR("flac %s\n", str);
498 }
499+#endif /* FLAC_API_VERSION_CURRENT >= 7 */
500 
501-static void flacMetadata(const FLAC__SeekableStreamDecoder * dec,
502+static void flacMetadata(const flac_decoder * dec,
503                         const FLAC__StreamMetadata * block, void *vdata)
504 {
505        flac_metadata_common_cb(block, (FlacData *) vdata);
506 }
507 
508-static FLAC__StreamDecoderWriteStatus flacWrite(const
509-                                               FLAC__SeekableStreamDecoder *
510-                                               dec, const FLAC__Frame * frame,
511+static FLAC__StreamDecoderWriteStatus flacWrite(const flac_decoder *dec,
512+                                                const FLAC__Frame * frame,
513                                                const FLAC__int32 * const buf[],
514                                                void *vdata)
515 {
516@@ -325,7 +227,7 @@
517        timeChange = ((float)samples) / frame->header.sample_rate;
518        data->time += timeChange;
519 
520-       FLAC__seekable_stream_decoder_get_decode_position(dec, &newPosition);
521+       flac_get_decode_position(dec, &newPosition);
522        if (data->position) {
523                data->bitRate =
524                    ((newPosition - data->position) * 8.0 / timeChange)
525@@ -438,12 +340,179 @@
526        return ret;
527 }
528 
529+static int flac_decode_internal(OutputBuffer * cb, DecoderControl * dc,
530+                               InputStream * inStream, int is_ogg)
531+{
532+       flac_decoder *flacDec;
533+       FlacData data;
534+       const char *err = NULL;
535+
536+       if (!(flacDec = flac_new()))
537+               return -1;
538+       init_FlacData(&data, cb, dc, inStream);
539+       if (is_ogg) {
540+               if (!flac_ogg_init(flacDec, flacRead, flacSeek, flacTell,
541+                                  flacLength, flacEOF, flacWrite, flacMetadata,
542+                                  flacError, (void *)&data)) {
543+                       err = "doing Ogg init()";
544+                       goto fail;
545+               }
546+       } else {
547+               if (!flac_init(flacDec, flacRead, flacSeek, flacTell,
548+                              flacLength, flacEOF, flacWrite, flacMetadata,
549+                              flacError, (void *)&data)) {
550+                       err = "doing init()";
551+                       goto fail;
552+               }
553+               if (!flac_process_metadata(flacDec)) {
554+                       err = "problem reading metadata";
555+                       goto fail;
556+               }
557+       }
558+
559+       dc->state = DECODE_STATE_DECODE;
560+
561+       while (1) {
562+               if (!flac_process_single(flacDec))
563+                       break;
564+               if (flac_get_state(flacDec) == flac_decoder_eof)
565+                       break;
566+               if (dc->seek) {
567+                       FLAC__uint64 sampleToSeek = dc->seekWhere *
568+                           dc->audioFormat.sampleRate + 0.5;
569+                       if (flac_seek_absolute(flacDec, sampleToSeek)) {
570+                               clearOutputBuffer(cb);
571+                               data.time = ((float)sampleToSeek) /
572+                                   dc->audioFormat.sampleRate;
573+                               data.position = 0;
574+                       } else
575+                               dc->seekError = 1;
576+                       dc->seek = 0;
577+               }
578+       }
579+       if (!dc->stop) {
580+               flacPrintErroredState(flac_get_state(flacDec));
581+               flac_finish(flacDec);
582+       }
583+       /* send last little bit */
584+       if (data.chunk_length > 0 && !dc->stop) {
585+               flacSendChunk(&data);
586+               flushOutputBuffer(data.cb);
587+       }
588+
589+       /*if(dc->seek) {
590+          dc->seekError = 1;
591+          dc->seek = 0;
592+          } */
593+
594+       dc->state = DECODE_STATE_STOP;
595+       dc->stop = 0;
596+
597+fail:
598+       if (data.replayGainInfo)
599+               freeReplayGainInfo(data.replayGainInfo);
600+
601+       if (flacDec)
602+               flac_delete(flacDec);
603+
604+       closeInputStream(inStream);
605+
606+       if (err) {
607+               ERROR("flac %s\n", err);
608+               return -1;
609+       }
610+       return 0;
611+}
612+
613+static int flac_decode(OutputBuffer * cb, DecoderControl * dc,
614+                       InputStream * inStream)
615+{
616+       return flac_decode_internal(cb, dc, inStream, 0);
617+}
618+
619+#if !defined(FLAC_API_VERSION_CURRENT) || FLAC_API_VERSION_CURRENT <= 7
620+#  define flac_plugin_init NULL
621+#else /* FLAC_API_VERSION_CURRENT >= 7 */
622+/* some of this stuff is duplicated from oggflac_plugin.c */
623+extern InputPlugin oggflacPlugin;
624+
625+static MpdTag *oggflac_tag_dup(char *file)
626+{
627+       MpdTag *ret = NULL;
628+       FLAC__Metadata_Iterator *it;
629+       FLAC__StreamMetadata *block;
630+       FLAC__Metadata_Chain *chain = FLAC__metadata_chain_new();
631+
632+       if (!(FLAC__metadata_chain_read_ogg(chain, file)))
633+               goto out;
634+       it = FLAC__metadata_iterator_new();
635+       FLAC__metadata_iterator_init(it, chain);
636+       do {
637+               if (!(block = FLAC__metadata_iterator_get_block(it)))
638+                       break;
639+               if (block->type == FLAC__METADATA_TYPE_VORBIS_COMMENT) {
640+                       ret = copyVorbisCommentBlockToMpdTag(block, ret);
641+               } else if (block->type == FLAC__METADATA_TYPE_STREAMINFO) {
642+                       if (!ret)
643+                               ret = newMpdTag();
644+                       ret->time = ((float)block->data.stream_info.
645+                                    total_samples) /
646+                           block->data.stream_info.sample_rate + 0.5;
647+               }
648+       } while (FLAC__metadata_iterator_next(it));
649+       FLAC__metadata_iterator_delete(it);
650+out:
651+       FLAC__metadata_chain_delete(chain);
652+       return ret;
653+}
654+
655+static int oggflac_decode(OutputBuffer * cb, DecoderControl * dc,
656+                         InputStream * inStream)
657+{
658+       return flac_decode_internal(cb, dc, inStream, 1);
659+}
660+
661+static unsigned int oggflac_try_decode(InputStream * inStream)
662+{
663+       return (ogg_stream_type_detect(inStream) == FLAC) ? 1 : 0;
664+}
665+
666+static char *oggflac_suffixes[] = { "ogg", NULL };
667+static char *oggflac_mime_types[] = { "audio/x-flac+ogg",
668+                                      "application/ogg",
669+                                      "application/x-ogg",
670+                                      NULL };
671+
672+static int flac_plugin_init(void)
673+{
674+       if (!FLAC_API_SUPPORTS_OGG_FLAC) {
675+               DEBUG("libFLAC does not support OggFLAC\n");
676+               return 1;
677+       }
678+       DEBUG("libFLAC supports OggFLAC, initializing OggFLAC support\n");
679+       assert(oggflacPlugin.name == NULL);
680+       oggflacPlugin.name = "oggflac";
681+       oggflacPlugin.tryDecodeFunc = oggflac_try_decode;
682+       oggflacPlugin.streamDecodeFunc = oggflac_decode;
683+       oggflacPlugin.tagDupFunc = oggflac_tag_dup;
684+       oggflacPlugin.streamTypes = INPUT_PLUGIN_STREAM_URL |
685+                                   INPUT_PLUGIN_STREAM_FILE;
686+       oggflacPlugin.suffixes = oggflac_suffixes;
687+       oggflacPlugin.mimeTypes = oggflac_mime_types;
688+       loadInputPlugin(&oggflacPlugin);
689+       return 1;
690+}
691+
692+#endif /* FLAC_API_VERSION_CURRENT >= 7 */
693+
694 static char *flacSuffixes[] = { "flac", NULL };
695-static char *flac_mime_types[] = { "application/x-flac", NULL };
696+static char *flac_mime_types[] = { "audio/x-flac",
697+                                   "application/x-flac",
698+                                   NULL };
699 
700 InputPlugin flacPlugin = {
701        "flac",
702-       NULL,
703+       flac_plugin_init,
704        NULL,
705        NULL,
706        flac_decode,
707@@ -456,17 +525,6 @@
708 
709 #else /* !HAVE_FLAC */
710 
711-InputPlugin flacPlugin = {
712-       NULL,
713-       NULL,
714-       NULL,
715-       NULL,
716-       NULL,
717-       NULL,
718-       NULL,
719-       0,
720-       NULL,
721-       NULL,
722-};
723+InputPlugin flacPlugin;
724 
725 #endif /* HAVE_FLAC */