Attachment #1815 for bug #10871

View | Details | Raw Unified | Return to bug 10871
Collapse All | Expand All




  have_libFLAC=no
  KDE_CHECK_HEADER(FLAC/metadata.h,
  [
     KDE_CHECK_LIB(FLAC,FLAC__stream_decoder_process_single,
	          have_libFLAC=yes)

    ])
  if test "x$have_libFLAC" = "xyes"; then
      LIBFLAC="-lFLAC -logg"
      AC_DEFINE(HAVE_LIBFLAC, 1,
        [Define if you have libFLAC (required for loading FLAC files)])
  fi

  have_libOggFLAC=no
  KDE_CHECK_HEADER(OggFLAC/seekable_stream_decoder.h,
  [
     KDE_CHECK_LIB(OggFLAC,OggFLAC__stream_decoder_process_single,
	          have_libOggFLAC=yes,,[-lm -lOggFLAC -lFLAC])

    ])




#include <string.h>
#include <iostream>

#include <FLAC/format.h>
#include <FLAC/seekable_stream_decoder.h>

#ifdef HAVE_LIBOGGFLAC
 #include <OggFLAC/seekable_stream_decoder.h>
#endif

#include "audioframe.h"
#include "decoder.h"
#include "file.h"
#include "flac_decoder.h"

#include <FLAC/format.h>
#ifdef LEGACY_FLAC
 #include <FLAC/seekable_stream_decoder.h>

 #ifdef HAVE_LIBOGGFLAC
  #include <OggFLAC/seekable_stream_decoder.h>
 #endif
#else
 #include <FLAC/stream_decoder.h>
#endif


namespace aKode {



extern "C" { FLACDecoderPlugin flac_decoder; }

// Starting with FLAC 1.1.3 libFLAC supports Ogg FLAC and there is no more libOggFLAC. 
#if defined(HAVE_LIBOGGFLAC) || !defined(LEGACY_FLAC)
bool OggFLACDecoderPlugin::canDecode(File* src) {
    char header[34];
    bool res = false;

struct FLACDecoder::private_data {
    private_data() : decoder(0), valid(false), out(0), source(0), eof(false), error(false) {};

#ifdef LEGACY_FLAC
    FLAC__SeekableStreamDecoder *decoder;
#else
    FLAC__StreamDecoder *decoder;
#endif
    const FLAC__StreamMetadata_StreamInfo* si;
    const FLAC__StreamMetadata_VorbisComment* vc;


    bool eof, error;
};

#if defined(HAVE_LIBOGGFLAC) || !defined(LEGACY_FLAC)
struct OggFLACDecoder::private_data {
    private_data() : decoder(0), valid(false), out(0), source(0), eof(false), error(false) {};

#ifdef LEGACY_FLAC
    OggFLAC__SeekableStreamDecoder *decoder;
#else
    FLAC__StreamDecoder *decoder;
#endif
    const FLAC__StreamMetadata_StreamInfo* si;
    const FLAC__StreamMetadata_VorbisComment* vc;


};
#endif

#ifdef LEGACY_FLAC
static FLAC__SeekableStreamDecoderReadStatus flac_read_callback(
        const FLAC__SeekableStreamDecoder *,
        FLAC__byte buffer[],
        unsigned *bytes,
        void *client_data)
#else
static FLAC__StreamDecoderReadStatus flac_read_callback(
        const FLAC__StreamDecoder *,
        FLAC__byte buffer[],
        size_t *bytes,
        void *client_data)
#endif
{
    FLACDecoder::private_data *data = (FLACDecoder::private_data*)client_data;

    long res = data->source->read((char*)buffer, *bytes);
    if (res<=0) {
        if (data->source->eof()) data->eof = true;
#ifdef LEGACY_FLAC
        return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_ERROR;
#else
        return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
#endif
    }
    else {
        *bytes = res;
#ifdef LEGACY_FLAC
        return FLAC__SEEKABLE_STREAM_DECODER_READ_STATUS_OK;
#else
        return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
#endif
    }
}

// we only need Ogg flavors of the callbacks for before FLAC 1.1.3
#if defined(HAVE_LIBOGGFLAC) && defined(LEGACY_FLAC)
// God, I hate people doing OO in C!
static OggFLAC__SeekableStreamDecoderReadStatus oggflac_read_callback(
        const OggFLAC__SeekableStreamDecoder *,

}
#endif

#ifdef LEGACY_FLAC
static FLAC__SeekableStreamDecoderSeekStatus flac_seek_callback(
        const FLAC__SeekableStreamDecoder *,
        FLAC__uint64 absolute_byte_offset,
        void *client_data)
#else
static FLAC__StreamDecoderSeekStatus flac_seek_callback(
        const FLAC__StreamDecoder *,
        FLAC__uint64 absolute_byte_offset,
        void *client_data)
#endif
{
    FLACDecoder::private_data *data = (FLACDecoder::private_data*)client_data;

    if(data->source->seek(absolute_byte_offset))
#ifdef LEGACY_FLAC
        return FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_OK;
#else
        return FLAC__STREAM_DECODER_SEEK_STATUS_OK;
#endif
    else
#ifdef LEGACY_FLAC
        return FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_ERROR;
#else
        return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
#endif
}

#if defined(HAVE_LIBOGGFLAC) && defined(LEGACY_FLAC)
static OggFLAC__SeekableStreamDecoderSeekStatus oggflac_seek_callback(
        const OggFLAC__SeekableStreamDecoder *,
        FLAC__uint64 absolute_byte_offset,

}
#endif

#ifdef LEGACY_FLAC
static FLAC__SeekableStreamDecoderTellStatus flac_tell_callback(
        const FLAC__SeekableStreamDecoder *,
        FLAC__uint64 *absolute_byte_offset,
        void *client_data)
#else
static FLAC__StreamDecoderTellStatus flac_tell_callback(
        const FLAC__StreamDecoder *,
        FLAC__uint64 *absolute_byte_offset,
        void *client_data)
#endif
{
    FLACDecoder::private_data *data = (FLACDecoder::private_data*)client_data;

    long res = data->source->position();
    if (res<0)
#ifdef LEGACY_FLAC
        return FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_ERROR;
#else
        return FLAC__STREAM_DECODER_TELL_STATUS_ERROR;
#endif
    else {
        *absolute_byte_offset = res;
#ifdef LEGACY_FLAC
        return FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_OK;
#else
        return FLAC__STREAM_DECODER_TELL_STATUS_OK;
#endif
    }
}

#if defined(HAVE_LIBOGGFLAC) && defined(LEGACY_FLAC)
static OggFLAC__SeekableStreamDecoderTellStatus oggflac_tell_callback(
        const OggFLAC__SeekableStreamDecoder *,
        FLAC__uint64 *absolute_byte_offset,

}
#endif

#ifdef LEGACY_FLAC
static FLAC__SeekableStreamDecoderLengthStatus flac_length_callback(
        const FLAC__SeekableStreamDecoder *,
        FLAC__uint64 *stream_length,
        void *client_data)
#else
static FLAC__StreamDecoderLengthStatus flac_length_callback(
        const FLAC__StreamDecoder *,
        FLAC__uint64 *stream_length,
        void *client_data)
#endif
{
    FLACDecoder::private_data *data = (FLACDecoder::private_data*)client_data;

    long res = data->source->length();
    if (res<0)
#ifdef LEGACY_FLAC
        return FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_ERROR;
#else
        return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR;
#endif
    else {
        *stream_length = res;
#ifdef LEGACY_FLAC
        return FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_OK;
#else
        return FLAC__STREAM_DECODER_LENGTH_STATUS_OK;
#endif
    }
}

#if defined(HAVE_LIBOGGFLAC) && defined(LEGACY_FLAC)
static OggFLAC__SeekableStreamDecoderLengthStatus oggflac_length_callback(
        const OggFLAC__SeekableStreamDecoder *,
        FLAC__uint64 *stream_length,

            break;
        case FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH:
            break;
#ifndef LEGACY_FLAC
        case FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM:
            break;
#endif
    }
    //data->valid = false;
}

    return &m_data->config;
}

#if defined(HAVE_LIBOGGFLAC) || !defined(LEGACY_FLAC)
const AudioConfiguration* OggFLACDecoder::audioConfiguration() {
    return &m_data->config;
}

FLACDecoder::FLACDecoder(File* src) {
    m_data = new private_data;
    m_data->out = 0;
    m_data->decoder = FLAC__seekable_stream_decoder_new();
    m_data->source = src;
    m_data->source->openRO();
    m_data->source->fadvise();
#ifdef LEGACY_FLAC
    m_data->decoder = FLAC__seekable_stream_decoder_new();
    FLAC__seekable_stream_decoder_set_client_data(m_data->decoder, m_data);
    FLAC__seekable_stream_decoder_set_read_callback    (m_data->decoder, flac_read_callback);
    FLAC__seekable_stream_decoder_set_seek_callback    (m_data->decoder, flac_seek_callback);

            metadata_callback<FLAC__SeekableStreamDecoder, private_data>);
    FLAC__seekable_stream_decoder_set_metadata_respond (m_data->decoder, FLAC__METADATA_TYPE_VORBIS_COMMENT);

    FLAC__seekable_stream_decoder_init(m_data->decoder); // really should check the return value here
    FLAC__seekable_stream_decoder_process_until_end_of_metadata(m_data->decoder);
#else
    m_data->decoder = FLAC__stream_decoder_new();
    FLAC__stream_decoder_set_metadata_respond (m_data->decoder, FLAC__METADATA_TYPE_VORBIS_COMMENT);

    // really should check the return value here
    FLAC__stream_decoder_init_stream(
        m_data->decoder,
        flac_read_callback,
        flac_seek_callback,
        flac_tell_callback,
        flac_length_callback,
        eof_callback<FLAC__StreamDecoder, private_data>,
        write_callback<FLAC__StreamDecoder, private_data>,
        metadata_callback<FLAC__StreamDecoder, private_data>,
        error_callback<FLAC__StreamDecoder, private_data>,
        m_data
    );
    FLAC__stream_decoder_process_until_end_of_metadata(m_data->decoder);
#endif
}

FLACDecoder::~FLACDecoder() {
#ifdef LEGACY_FLAC
    FLAC__seekable_stream_decoder_finish(m_data->decoder);
    FLAC__seekable_stream_decoder_delete(m_data->decoder);
#else
    FLAC__stream_decoder_finish(m_data->decoder);
    FLAC__stream_decoder_delete(m_data->decoder);
#endif
    m_data->source->close();
    delete m_data;
}

#if defined(HAVE_LIBOGGFLAC) || !defined(LEGACY_FLAC)
OggFLACDecoder::OggFLACDecoder(File* src) {
    m_data = new private_data;
    m_data->out = 0;
    m_data->decoder = OggFLAC__seekable_stream_decoder_new();
    m_data->source = src;
    m_data->source->openRO();
    m_data->source->fadvise();
#ifdef LEGACY_FLAC
    m_data->decoder = OggFLAC__seekable_stream_decoder_new();
    OggFLAC__seekable_stream_decoder_set_client_data(m_data->decoder, m_data);
    OggFLAC__seekable_stream_decoder_set_read_callback    (m_data->decoder, oggflac_read_callback);
    OggFLAC__seekable_stream_decoder_set_seek_callback    (m_data->decoder, oggflac_seek_callback);


    OggFLAC__seekable_stream_decoder_init(m_data->decoder);
    OggFLAC__seekable_stream_decoder_process_until_end_of_metadata(m_data->decoder);
#else
    m_data->decoder = FLAC__stream_decoder_new();
    FLAC__stream_decoder_set_metadata_respond (m_data->decoder, FLAC__METADATA_TYPE_VORBIS_COMMENT);

    // really should check the return value here
    FLAC__stream_decoder_init_ogg_stream(
        m_data->decoder,
        flac_read_callback,
        flac_seek_callback,
        flac_tell_callback,
        flac_length_callback,
        eof_callback<FLAC__StreamDecoder, private_data>,
        write_callback<FLAC__StreamDecoder, private_data>,
        metadata_callback<FLAC__StreamDecoder, private_data>,
        error_callback<FLAC__StreamDecoder, private_data>,
        m_data
    );
    FLAC__stream_decoder_process_until_end_of_metadata(m_data->decoder);
#endif
}

OggFLACDecoder::~OggFLACDecoder() {
#ifdef LEGACY_FLAC
    OggFLAC__seekable_stream_decoder_finish(m_data->decoder);
    OggFLAC__seekable_stream_decoder_delete(m_data->decoder);
#else
    FLAC__stream_decoder_finish(m_data->decoder);
    FLAC__stream_decoder_delete(m_data->decoder);
#endif
    m_data->source->close();
    delete m_data;
}

    }
    m_data->valid = false;
    m_data->out = frame;
#ifdef LEGACY_FLAC
    bool ret = FLAC__seekable_stream_decoder_process_single(m_data->decoder);
#else
    bool ret = FLAC__stream_decoder_process_single(m_data->decoder);
#endif
    m_data->out = 0;
    if (ret && m_data->valid) {
        frame->pos = position();
        return true;
    } else {
#ifdef LEGACY_FLAC
        FLAC__SeekableStreamDecoderState state = FLAC__seekable_stream_decoder_get_state(m_data->decoder);
        switch (state) {
            case FLAC__SEEKABLE_STREAM_DECODER_OK:

                m_data->error = true;
                break;
        }
#else
        FLAC__StreamDecoderState state = FLAC__stream_decoder_get_state(m_data->decoder);
        if (state == FLAC__STREAM_DECODER_END_OF_STREAM)
            m_data->eof = true;
        else if (state > FLAC__STREAM_DECODER_END_OF_STREAM)
	    m_data->error = true;
#endif
        return false;
    }
}

#if defined(HAVE_LIBOGGFLAC) || !defined(LEGACY_FLAC)
bool OggFLACDecoder::readFrame(AudioFrame* frame) {
    if (m_data->error || m_data->eof) return false;


    }
    m_data->valid = false;
    m_data->out = frame;
#ifdef LEGACY_FLAC
    bool ret = OggFLAC__seekable_stream_decoder_process_single(m_data->decoder);
#else
    bool ret = FLAC__stream_decoder_process_single(m_data->decoder);
#endif
    m_data->out = 0;
    if (ret && m_data->valid) {
        frame->pos = position();
        return true;
    } else {
#ifdef LEGACY_FLAC
        OggFLAC__SeekableStreamDecoderState state = OggFLAC__seekable_stream_decoder_get_state(m_data->decoder);
        switch (state) {
            case OggFLAC__SEEKABLE_STREAM_DECODER_OK:

                m_data->error = true;
                break;
        }
#else
        FLAC__StreamDecoderState state = FLAC__stream_decoder_get_state(m_data->decoder);
        if (state == FLAC__STREAM_DECODER_END_OF_STREAM)
            m_data->eof = true;
        else if (state > FLAC__STREAM_DECODER_END_OF_STREAM)
	    m_data->error = true;
#endif
        return false;
    }
}

    if (m_data->error) return false;
    float samplePos = (float)pos * (float)m_data->config.sample_rate / 1000.0;
    m_data->position = (uint64_t)samplePos;
#ifdef LEGACY_FLAC
    return FLAC__seekable_stream_decoder_seek_absolute(m_data->decoder, m_data->position);
#else
    return FLAC__stream_decoder_seek_absolute(m_data->decoder, m_data->position);
#endif
}

#if defined(HAVE_LIBOGGFLAC) || !defined(LEGACY_FLAC)
long OggFLACDecoder::length() {
    float pos = ((float)m_data->length)/m_data->config.sample_rate;
    return (long)(pos*1000.0);

    if (m_data->error) return false;
    float samplePos = (float)pos * (float)m_data->config.sample_rate / 1000.0;
    m_data->position = (uint64_t)samplePos;
#ifdef LEGACY_FLAC
    return OggFLAC__seekable_stream_decoder_seek_absolute(m_data->decoder, m_data->position);
#else
    return FLAC__stream_decoder_seek_absolute(m_data->decoder, m_data->position);
#endif
}
#endif


Lines 26-31 Link Here

(-)akode-2.0.1/akode/plugins/xiph_decoder/flac_decoder.h (-2 / +11 lines)
26		26
27	#include "decoder.h"	27	#include "decoder.h"
28		28
		29	// FLAC 1.1.3 has FLAC_API_VERSION_CURRENT == 8
		30	#include <FLAC/export.h>
		31	#if !defined(FLAC_API_VERSION_CURRENT) \|\| FLAC_API_VERSION_CURRENT < 8
		32	#define LEGACY_FLAC
		33	#else
		34	#undef LEGACY_FLAC
		35	#endif
		36
29	namespace aKode {	37	namespace aKode {
30		38
31	class File;	39	class File;
Lines 50-56 Link Here
50	private_data *m_data;	58	private_data *m_data;
51	};	59	};
52		60
53	#ifdef HAVE_LIBOGGFLAC	61	// Starting with FLAC 1.1.3 libFLAC supports Ogg FLAC and there is no more libOggFLAC.
		62	#if defined(HAVE_LIBOGGFLAC) \|\| !defined(LEGACY_FLAC)
54	class OggFLACDecoder : public Decoder {	63	class OggFLACDecoder : public Decoder {
55	public:	64	public:
56	OggFLACDecoder(File* src);	65	OggFLACDecoder(File* src);
Lines 81-87 Link Here
81		90
82	extern "C" FLACDecoderPlugin flac_decoder;	91	extern "C" FLACDecoderPlugin flac_decoder;
83		92
84	#ifdef HAVE_LIBOGGFLAC	93	#if defined(HAVE_LIBOGGFLAC) \|\| !defined(LEGACY_FLAC)
85	class OggFLACDecoderPlugin : public DecoderPlugin {	94	class OggFLACDecoderPlugin : public DecoderPlugin {
86	public:	95	public:
87	virtual bool canDecode(File*);	96	virtual bool canDecode(File*);




  have_libFLAC=no
  KDE_CHECK_HEADER(FLAC/metadata.h,
  [
     KDE_CHECK_LIB(FLAC,FLAC__stream_decoder_process_single,
	          have_libFLAC=yes)

    ])
  if test "x$have_libFLAC" = "xyes"; then
      LIBFLAC="-lFLAC -logg"
      AC_DEFINE(HAVE_LIBFLAC, 1,
        [Define if you have libFLAC (required for loading FLAC files)])
  fi

  have_libOggFLAC=no
  KDE_CHECK_HEADER(OggFLAC/seekable_stream_decoder.h,
  [
     KDE_CHECK_LIB(OggFLAC,OggFLAC__stream_decoder_process_single,
	          have_libOggFLAC=yes,,[-lm -lOggFLAC -lFLAC])

    ])

Return to bug 10871

Lines 115-126 Link Here

(-)akode-2.0.1/configure.in (-3 / +3 lines)
115	have_libFLAC=no	115	have_libFLAC=no
116	KDE_CHECK_HEADER(FLAC/metadata.h,	116	KDE_CHECK_HEADER(FLAC/metadata.h,
117	[	117	[
118	KDE_CHECK_LIB(FLAC,FLAC__seekable_stream_decoder_process_single,	118	KDE_CHECK_LIB(FLAC,FLAC__stream_decoder_process_single,
119	have_libFLAC=yes)	119	have_libFLAC=yes)
120		120
121	])	121	])
122	if test "x$have_libFLAC" = "xyes"; then	122	if test "x$have_libFLAC" = "xyes"; then
123	LIBFLAC="-lFLAC"	123	LIBFLAC="-lFLAC -logg"
124	AC_DEFINE(HAVE_LIBFLAC, 1,	124	AC_DEFINE(HAVE_LIBFLAC, 1,
125	[Define if you have libFLAC (required for loading FLAC files)])	125	[Define if you have libFLAC (required for loading FLAC files)])
126	fi	126	fi
Lines 135-141 Link Here
135	have_libOggFLAC=no	135	have_libOggFLAC=no
136	KDE_CHECK_HEADER(OggFLAC/seekable_stream_decoder.h,	136	KDE_CHECK_HEADER(OggFLAC/seekable_stream_decoder.h,
137	[	137	[
138	KDE_CHECK_LIB(OggFLAC,OggFLAC__seekable_stream_decoder_process_single,	138	KDE_CHECK_LIB(OggFLAC,OggFLAC__stream_decoder_process_single,
139	have_libOggFLAC=yes,,[-lm -lOggFLAC -lFLAC])	139	have_libOggFLAC=yes,,[-lm -lOggFLAC -lFLAC])
140		140
141	])	141	])

Lines 10-21 Link Here

(-)akode-2.0.1/akode/configure.in.in (-3 / +3 lines)
10	have_libFLAC=no	10	have_libFLAC=no
11	KDE_CHECK_HEADER(FLAC/metadata.h,	11	KDE_CHECK_HEADER(FLAC/metadata.h,
12	[	12	[
13	KDE_CHECK_LIB(FLAC,FLAC__seekable_stream_decoder_process_single,	13	KDE_CHECK_LIB(FLAC,FLAC__stream_decoder_process_single,
14	have_libFLAC=yes)	14	have_libFLAC=yes)
15		15
16	])	16	])
17	if test "x$have_libFLAC" = "xyes"; then	17	if test "x$have_libFLAC" = "xyes"; then
18	LIBFLAC="-lFLAC"	18	LIBFLAC="-lFLAC -logg"
19	AC_DEFINE(HAVE_LIBFLAC, 1,	19	AC_DEFINE(HAVE_LIBFLAC, 1,
20	[Define if you have libFLAC (required for loading FLAC files)])	20	[Define if you have libFLAC (required for loading FLAC files)])
21	fi	21	fi
Lines 30-36 Link Here
30	have_libOggFLAC=no	30	have_libOggFLAC=no
31	KDE_CHECK_HEADER(OggFLAC/seekable_stream_decoder.h,	31	KDE_CHECK_HEADER(OggFLAC/seekable_stream_decoder.h,
32	[	32	[
33	KDE_CHECK_LIB(OggFLAC,OggFLAC__seekable_stream_decoder_process_single,	33	KDE_CHECK_LIB(OggFLAC,OggFLAC__stream_decoder_process_single,
34	have_libOggFLAC=yes,,[-lm -lOggFLAC -lFLAC])	34	have_libOggFLAC=yes,,[-lm -lOggFLAC -lFLAC])
35		35
36	])	36	])