Commit 07ebb049 authored by Stan Seibert's avatar Stan Seibert
Browse files

FLAC read support for oggenc. Comments from the FLAC are preserved by

default.

Special thanks to OldMan, adiabatic, and smack from #vorbis for sponsoring
this feature.

svn path=/trunk/vorbis-tools/; revision=5246
parent bbd4fe52
......@@ -133,9 +133,9 @@ AC_CHECK_LIB(FLAC, [FLAC__stream_decoder_process_single],
have_libFLAC=no, [$FLAC_LIBS]
)
AC_CHECK_LIB(OggFLAC, [OggFLAC__stream_decoder_new],
[FLAC_LIBS="-lOggFLAC $FLAC_LIBS"],
[FLAC_LIBS="-lOggFLAC $FLAC_LIBS $OGG_LIBS"],
AC_MSG_WARN([libOggFLAC missing])
have_libFLAC=no, [$FLAC_LIBS]
have_libFLAC=no, [$FLAC_LIBS $OGG_LIBS]
)
AC_CHECK_HEADER(FLAC/stream_decoder.h,,
AC_MSG_WARN(libFLAC headers missing)
......@@ -209,10 +209,13 @@ if test "x$build_ogg123" = xyes; then
OPT_SUBDIRS="$OPT_SUBDIRS ogg123"
if test "x$have_libFLAC" = xyes; then
OGG123_FLAC_OBJS='flac_format.$(OBJEXT) easyflac.$(OBJEXT)'
OGGENC_FLAC_OBJS='flac.$(OBJEXT) easyflac.$(OBJEXT)'
else
OGG123_FLAC_OBJS=''
OGGENC_FLAC_OBJS=''
fi
AC_SUBST(OGG123_FLAC_OBJS)
AC_SUBST(OGGENC_FLAC_OBJS)
if test "x$have_libspeex" = xyes; then
OGG123_SPEEX_OBJS='speex_format.$(OBJEXT)'
else
......@@ -249,8 +252,22 @@ AC_SUBST(I18N_LIBS)
AC_OUTPUT(Makefile intl/Makefile po/Makefile.in include/Makefile share/Makefile win32/Makefile oggdec/Makefile oggenc/Makefile oggenc/man/Makefile ogg123/Makefile vorbiscomment/Makefile vcut/Makefile ogginfo/Makefile debian/Makefile)
if test "x$build_oggenc" = xyes -a "x$have_libFLAC" != xyes; then
AC_MSG_WARN([FLAC and OggFLAC libraries or headers missing, oggenc
will NOT be built with FLAC read support.])
fi
if test "x$build_ogg123" != xyes; then
AC_MSG_WARN([Prerequisites for ogg123 not met, ogg123 will be skipped.
Please ensure that you have POSIX threads, libcurl and libao libraries and
headers present if you would like to build ogg123.])
Please ensure that you have POSIX threads, libcurl and libao libraries and
headers present if you would like to build ogg123.])
else
if test "x$have_libFLAC" != xyes; then
AC_MSG_WARN([FLAC and OggFLAC libraries or headers missing, ogg123
will NOT be built with FLAC read support.])
fi
if test "x$have_libspeex" != xyes; then
AC_MSG_WARN([Speex libraries or headers missing, ogg123 will NOT be
built with FLAC read support.])
fi
fi
......@@ -4,9 +4,6 @@ AUTOMAKE_OPTIONS = foreign
SUBDIRS = man
oggencsources = oggenc.c audio.c encode.c platform.c \
audio.h encode.h platform.h resample.c resample.h
datadir = @datadir@
localedir = $(datadir)/locale
DEFS = -DLOCALEDIR=\"$(localedir)\" @DEFS@
......@@ -15,13 +12,16 @@ bin_PROGRAMS = oggenc
INCLUDES = @SHARE_CFLAGS@ @OGG_CFLAGS@ @VORBIS_CFLAGS@ @I18N_CFLAGS@
oggenc_LDADD = @SHARE_LIBS@ \
oggenc_LDADD = @OGGENC_FLAC_OBJS@ @SHARE_LIBS@ \
@VORBISENC_LIBS@ @VORBIS_LIBS@ @OGG_LIBS@ \
@LIBICONV@ @I18N_LIBS@
oggenc_DEPENDENCIES = @SHARE_LIBS@
@LIBICONV@ @I18N_LIBS@ @FLAC_LIBS@
oggenc_SOURCES = $(oggencsources)
oggenc_DEPENDENCIES = @OGGENC_FLAC_OBJS@ @SHARE_LIBS@
oggenc_SOURCES = oggenc.c audio.c encode.c platform.c \
audio.h encode.h platform.h resample.c resample.h
EXTRA_oggenc_SOURCES = flac.c flac.h easyflac.c easyflac.h
debug:
$(MAKE) all CFLAGS="@DEBUG@"
......
......@@ -19,6 +19,10 @@
#include "i18n.h"
#include "resample.h"
#ifdef HAVE_LIBFLAC
#include "flac.h"
#endif
#define WAV_HEADER_SIZE 44
/* Macros to read header data */
......@@ -38,6 +42,10 @@
input_format formats[] = {
{wav_id, 12, wav_open, wav_close, "wav", N_("WAV file reader")},
{aiff_id, 12, aiff_open, wav_close, "aiff", N_("AIFF/AIFC file reader")},
#ifdef HAVE_LIBFLAC
{flac_id, 4, flac_open, flac_close, "flac", N_("FLAC file reader")},
{oggflac_id, 32, flac_open, flac_close, "ogg", N_("Ogg FLAC file reader")},
#endif
{NULL, 0, NULL, NULL, NULL, NULL}
};
......
/* EasyFLAC - A thin decoding wrapper around libFLAC and libOggFLAC to
* make your code less ugly. See easyflac.h for explanation.
*
* Copyright 2003 - Stan Seibert <volsung@xiph.org>
* This code is licensed under a BSD style license:
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* - Neither the name of the Xiph.org Foundation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
#include <stdlib.h>
#include "easyflac.h"
FLAC__bool EasyFLAC__is_oggflac(EasyFLAC__StreamDecoder *decoder)
{
return decoder->is_oggflac;
}
EasyFLAC__StreamDecoder *EasyFLAC__stream_decoder_new(FLAC__bool is_oggflac)
{
EasyFLAC__StreamDecoder *decoder = malloc(sizeof(EasyFLAC__StreamDecoder));
if (decoder != NULL)
{
decoder->is_oggflac = is_oggflac;
if (decoder->is_oggflac)
decoder->oggflac = OggFLAC__stream_decoder_new();
else
decoder->flac = FLAC__stream_decoder_new();
if ( (decoder->is_oggflac && decoder->oggflac == NULL)
||(!decoder->is_oggflac && decoder->flac == NULL) )
{
free(decoder);
decoder = NULL;
}
}
return decoder;
}
void EasyFLAC__stream_decoder_delete(EasyFLAC__StreamDecoder *decoder)
{
if (decoder->is_oggflac)
OggFLAC__stream_decoder_delete(decoder->oggflac);
else
FLAC__stream_decoder_delete(decoder->flac);
free(decoder);
}
/* Wrappers around the callbacks for OggFLAC */
FLAC__StreamDecoderReadStatus oggflac_read_callback(const OggFLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data)
{
EasyFLAC__StreamDecoder *e_decoder = (EasyFLAC__StreamDecoder *) client_data;
return (*e_decoder->callbacks.read)(e_decoder, buffer, bytes, e_decoder->callbacks.client_data);
}
FLAC__StreamDecoderWriteStatus oggflac_write_callback(const OggFLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
{
EasyFLAC__StreamDecoder *e_decoder = (EasyFLAC__StreamDecoder *) client_data;
return (*(e_decoder->callbacks.write))(e_decoder, frame, buffer, e_decoder->callbacks.client_data);
}
void oggflac_metadata_callback(const OggFLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
{
EasyFLAC__StreamDecoder *e_decoder = (EasyFLAC__StreamDecoder *) client_data;
(*e_decoder->callbacks.metadata)(e_decoder, metadata, e_decoder->callbacks.client_data);
}
void oggflac_error_callback(const OggFLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
{
EasyFLAC__StreamDecoder *e_decoder = (EasyFLAC__StreamDecoder *) client_data;
(*e_decoder->callbacks.error)(e_decoder, status, e_decoder->callbacks.client_data);
}
/* Wrappers around the callbacks for FLAC */
FLAC__StreamDecoderReadStatus flac_read_callback(const FLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data)
{
EasyFLAC__StreamDecoder *e_decoder = (EasyFLAC__StreamDecoder *) client_data;
return (*e_decoder->callbacks.read)(e_decoder, buffer, bytes, e_decoder->callbacks.client_data);
}
FLAC__StreamDecoderWriteStatus flac_write_callback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data)
{
EasyFLAC__StreamDecoder *e_decoder = (EasyFLAC__StreamDecoder *) client_data;
return (*e_decoder->callbacks.write)(e_decoder, frame, buffer, e_decoder->callbacks.client_data);
}
void flac_metadata_callback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data)
{
EasyFLAC__StreamDecoder *e_decoder = (EasyFLAC__StreamDecoder *) client_data;
(*e_decoder->callbacks.metadata)(e_decoder, metadata, e_decoder->callbacks.client_data);
}
void flac_error_callback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data)
{
EasyFLAC__StreamDecoder *e_decoder = (EasyFLAC__StreamDecoder *) client_data;
(*e_decoder->callbacks.error)(e_decoder, status, e_decoder->callbacks.client_data);
}
FLAC__bool EasyFLAC__set_read_callback(EasyFLAC__StreamDecoder *decoder, EasyFLAC__StreamDecoderReadCallback value)
{
decoder->callbacks.read = value;
if (decoder->is_oggflac)
return OggFLAC__stream_decoder_set_read_callback(decoder->oggflac, &oggflac_read_callback);
else
return FLAC__stream_decoder_set_read_callback(decoder->flac, &flac_read_callback);
}
FLAC__bool EasyFLAC__set_write_callback(EasyFLAC__StreamDecoder *decoder, EasyFLAC__StreamDecoderWriteCallback value)
{
decoder->callbacks.write = value;
if (decoder->is_oggflac)
return OggFLAC__stream_decoder_set_write_callback(decoder->oggflac, &oggflac_write_callback);
else
return FLAC__stream_decoder_set_write_callback(decoder->flac, &flac_write_callback);
}
FLAC__bool EasyFLAC__set_metadata_callback(EasyFLAC__StreamDecoder *decoder, EasyFLAC__StreamDecoderMetadataCallback value)
{
decoder->callbacks.metadata = value;
if (decoder->is_oggflac)
return OggFLAC__stream_decoder_set_metadata_callback(decoder->oggflac, &oggflac_metadata_callback);
else
return FLAC__stream_decoder_set_metadata_callback(decoder->flac, &flac_metadata_callback);
}
FLAC__bool EasyFLAC__set_error_callback(EasyFLAC__StreamDecoder *decoder, EasyFLAC__StreamDecoderErrorCallback value)
{
decoder->callbacks.error = value;
if (decoder->is_oggflac)
return OggFLAC__stream_decoder_set_error_callback(decoder->oggflac, &oggflac_error_callback);
else
return FLAC__stream_decoder_set_error_callback(decoder->flac, &flac_error_callback);
}
FLAC__bool EasyFLAC__set_client_data(EasyFLAC__StreamDecoder *decoder, void *value)
{
decoder->callbacks.client_data = value;
if (decoder->is_oggflac)
return OggFLAC__stream_decoder_set_client_data(decoder->oggflac, decoder);
else
return FLAC__stream_decoder_set_client_data(decoder->flac, decoder);
}
FLAC__bool EasyFLAC__set_metadata_respond(EasyFLAC__StreamDecoder *decoder, FLAC__MetadataType type)
{
if (decoder->is_oggflac)
return OggFLAC__stream_decoder_set_metadata_respond(decoder->oggflac, type);
else
return FLAC__stream_decoder_set_metadata_respond(decoder->flac, type);
}
FLAC__bool EasyFLAC__set_metadata_respond_application(EasyFLAC__StreamDecoder *decoder, const FLAC__byte id[4])
{
if (decoder->is_oggflac)
return OggFLAC__stream_decoder_set_metadata_respond_application(decoder->oggflac, id);
else
return FLAC__stream_decoder_set_metadata_respond_application(decoder->flac, id);
}
FLAC__bool EasyFLAC__set_metadata_respond_all(EasyFLAC__StreamDecoder *decoder)
{
if (decoder->is_oggflac)
return OggFLAC__stream_decoder_set_metadata_respond_all(decoder->oggflac);
else
return FLAC__stream_decoder_set_metadata_respond_all(decoder->flac);
}
FLAC__bool EasyFLAC__set_metadata_ignore(EasyFLAC__StreamDecoder *decoder, FLAC__MetadataType type)
{
if (decoder->is_oggflac)
return OggFLAC__stream_decoder_set_metadata_ignore(decoder->oggflac, type);
else
return FLAC__stream_decoder_set_metadata_ignore(decoder->flac, type);
}
FLAC__bool EasyFLAC__set_metadata_ignore_application(EasyFLAC__StreamDecoder *decoder, const FLAC__byte id[4])
{
if (decoder->is_oggflac)
return OggFLAC__stream_decoder_set_metadata_ignore_application(decoder->oggflac, id);
else
return FLAC__stream_decoder_set_metadata_ignore_application(decoder->flac, id);
}
FLAC__bool EasyFLAC__set_metadata_ignore_all(EasyFLAC__StreamDecoder *decoder)
{
if (decoder->is_oggflac)
return OggFLAC__stream_decoder_set_metadata_ignore_all(decoder->oggflac);
else
return FLAC__stream_decoder_set_metadata_ignore_all(decoder->flac);
}
FLAC__StreamDecoderState EasyFLAC__get_state(const EasyFLAC__StreamDecoder *decoder)
{
if (decoder->is_oggflac)
return OggFLAC__stream_decoder_get_FLAC_stream_decoder_state(decoder->oggflac);
else
return FLAC__stream_decoder_get_state(decoder->flac);
}
unsigned EasyFLAC__get_channels(const EasyFLAC__StreamDecoder *decoder)
{
if (decoder->is_oggflac)
return OggFLAC__stream_decoder_get_channels(decoder->oggflac);
else
return FLAC__stream_decoder_get_channels(decoder->flac);
}
FLAC__ChannelAssignment EasyFLAC__get_channel_assignment(const EasyFLAC__StreamDecoder *decoder)
{
if (decoder->is_oggflac)
return OggFLAC__stream_decoder_get_channel_assignment(decoder->oggflac);
else
return FLAC__stream_decoder_get_channel_assignment(decoder->flac);
}
unsigned EasyFLAC__get_bits_per_sample(const EasyFLAC__StreamDecoder *decoder)
{
if (decoder->is_oggflac)
return OggFLAC__stream_decoder_get_bits_per_sample(decoder->oggflac);
else
return FLAC__stream_decoder_get_bits_per_sample(decoder->flac);
}
unsigned EasyFLAC__get_sample_rate(const EasyFLAC__StreamDecoder *decoder)
{
if (decoder->is_oggflac)
return OggFLAC__stream_decoder_get_sample_rate(decoder->oggflac);
else
return FLAC__stream_decoder_get_sample_rate(decoder->flac);
}
unsigned EasyFLAC__get_blocksize(const EasyFLAC__StreamDecoder *decoder)
{
if (decoder->is_oggflac)
return OggFLAC__stream_decoder_get_blocksize(decoder->oggflac);
else
return FLAC__stream_decoder_get_blocksize(decoder->flac);
}
FLAC__StreamDecoderState EasyFLAC__init(EasyFLAC__StreamDecoder *decoder)
{
if (decoder->is_oggflac)
{
OggFLAC__stream_decoder_init(decoder->oggflac);
return OggFLAC__stream_decoder_get_FLAC_stream_decoder_state(decoder->oggflac);
}
else
return FLAC__stream_decoder_init(decoder->flac);
}
void EasyFLAC__finish(EasyFLAC__StreamDecoder *decoder)
{
if (decoder->is_oggflac)
OggFLAC__stream_decoder_finish(decoder->oggflac);
else
FLAC__stream_decoder_finish(decoder->flac);
}
FLAC__bool EasyFLAC__flush(EasyFLAC__StreamDecoder *decoder)
{
if (decoder->is_oggflac)
return OggFLAC__stream_decoder_flush(decoder->oggflac);
else
return FLAC__stream_decoder_flush(decoder->flac);
}
FLAC__bool EasyFLAC__reset(EasyFLAC__StreamDecoder *decoder)
{
if (decoder->is_oggflac)
return OggFLAC__stream_decoder_reset(decoder->oggflac);
else
return FLAC__stream_decoder_reset(decoder->flac);
}
FLAC__bool EasyFLAC__process_single(EasyFLAC__StreamDecoder *decoder)
{
if (decoder->is_oggflac)
return OggFLAC__stream_decoder_process_single(decoder->oggflac);
else
return FLAC__stream_decoder_process_single(decoder->flac);
}
FLAC__bool EasyFLAC__process_until_end_of_metadata(EasyFLAC__StreamDecoder *decoder)
{
if (decoder->is_oggflac)
return OggFLAC__stream_decoder_process_until_end_of_metadata(decoder->oggflac);
else
return FLAC__stream_decoder_process_until_end_of_metadata(decoder->flac);
}
FLAC__bool EasyFLAC__process_until_end_of_stream(EasyFLAC__StreamDecoder *decoder)
{
if (decoder->is_oggflac)
return OggFLAC__stream_decoder_process_until_end_of_stream(decoder->oggflac);
else
return FLAC__stream_decoder_process_until_end_of_stream(decoder->flac);
}
/* EasyFLAC - A thin decoding wrapper around libFLAC and libOggFLAC to
* make your code less ugly.
*
* Copyright 2003 - Stan Seibert <volsung@xiph.org>
* This code is licensed under a BSD style license:
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* - Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* - Neither the name of the Xiph.org Foundation nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION
* OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
************************************************************************
*
* The motivation for this wrapper is to avoid issues where you need to
* decode both FLAC and Ogg FLAC but don't want to enclose all of your code
* in enormous if blocks where the body of the two branches is essentially
* the same. For example, you don't want to do something like this:
*
* if (is_ogg_flac)
* {
* OggFLAC__blah_blah();
* OggFLAC__more_stuff();
* }
* else
* {
* FLAC__blah_blah();
* FLAC__more_stuff();
* }
*
* when you really just want this:
*
* EasyFLAC__blah_blah();
* EasyFLAC__more_stuff();
*
* This is even more cumbersome when you have to deal with constants.
*
* EasyFLAC uses essentially the same API as
* FLAC__stream_decoder with two additions:
*
* - EasyFLAC__is_oggflac() for those rare occassions when you might
* need to distiguish the difference cases.
*
* - EasyFLAC__stream_decoder_new() takes a parameter to select when
* you are reading FLAC or Ogg FLAC.
*
* The constants are all FLAC__stream_decoder_*.
*
* WARNING: Always call EasyFLAC__set_client_data() even if all you
* want to do is set the client data to NULL.
*/
#ifndef __EASYFLAC_H
#define __EASYFLAC_H
#include <FLAC/stream_decoder.h>
#include <OggFLAC/stream_decoder.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef struct EasyFLAC__StreamDecoder EasyFLAC__StreamDecoder;
typedef FLAC__StreamDecoderReadStatus (*EasyFLAC__StreamDecoderReadCallback)(const EasyFLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data);
typedef FLAC__StreamDecoderWriteStatus (*EasyFLAC__StreamDecoderWriteCallback)(const EasyFLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data);
typedef void (*EasyFLAC__StreamDecoderMetadataCallback)(const EasyFLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data);
typedef void (*EasyFLAC__StreamDecoderErrorCallback)(const EasyFLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data);
struct EasyFLAC__StreamDecoder {
FLAC__bool is_oggflac;
FLAC__StreamDecoder *flac;
OggFLAC__StreamDecoder *oggflac;
struct {
EasyFLAC__StreamDecoderReadCallback read;
EasyFLAC__StreamDecoderWriteCallback write;
EasyFLAC__StreamDecoderMetadataCallback metadata;
EasyFLAC__StreamDecoderErrorCallback error;
void *client_data;
} callbacks;
};
FLAC__bool EasyFLAC__is_oggflac(EasyFLAC__StreamDecoder *decoder);
EasyFLAC__StreamDecoder *EasyFLAC__stream_decoder_new(FLAC__bool is_oggflac);
void EasyFLAC__stream_decoder_delete(EasyFLAC__StreamDecoder *decoder);
FLAC__bool EasyFLAC__set_read_callback(EasyFLAC__StreamDecoder *decoder, EasyFLAC__StreamDecoderReadCallback value);
FLAC__bool EasyFLAC__set_write_callback(EasyFLAC__StreamDecoder *decoder, EasyFLAC__StreamDecoderWriteCallback value);
FLAC__bool EasyFLAC__set_metadata_callback(EasyFLAC__StreamDecoder *decoder, EasyFLAC__StreamDecoderMetadataCallback value);
FLAC__bool EasyFLAC__set_error_callback(EasyFLAC__StreamDecoder *decoder, EasyFLAC__StreamDecoderErrorCallback value);
FLAC__bool EasyFLAC__set_client_data(EasyFLAC__StreamDecoder *decoder, void *value);
FLAC__bool EasyFLAC__set_metadata_respond(EasyFLAC__StreamDecoder *decoder, FLAC__MetadataType type);
FLAC__bool EasyFLAC__set_metadata_respond_application(EasyFLAC__StreamDecoder *decoder, const FLAC__byte id[4]);
FLAC__bool EasyFLAC__set_metadata_respond_all(EasyFLAC__StreamDecoder *decoder);
FLAC__bool EasyFLAC__set_metadata_ignore(EasyFLAC__StreamDecoder *decoder, FLAC__MetadataType type);
FLAC__bool EasyFLAC__set_metadata_ignore_application(EasyFLAC__StreamDecoder *decoder, const FLAC__byte id[4]);
FLAC__bool EasyFLAC__set_metadata_ignore_all(EasyFLAC__StreamDecoder *decoder);
FLAC__StreamDecoderState EasyFLAC__get_state(const EasyFLAC__StreamDecoder *decoder);
unsigned EasyFLAC__get_channels(const EasyFLAC__StreamDecoder *decoder);
FLAC__ChannelAssignment EasyFLAC__get_channel_assignment(const EasyFLAC__StreamDecoder *decoder);
unsigned EasyFLAC__get_bits_per_sample(const EasyFLAC__StreamDecoder *decoder);
unsigned EasyFLAC__get_sample_rate(const EasyFLAC__StreamDecoder *decoder);
unsigned EasyFLAC__get_blocksize(const EasyFLAC__StreamDecoder *decoder);
FLAC__StreamDecoderState EasyFLAC__init(EasyFLAC__StreamDecoder *decoder);
void EasyFLAC__finish(EasyFLAC__StreamDecoder *decoder);
FLAC__bool EasyFLAC__flush(EasyFLAC__StreamDecoder *decoder);
FLAC__bool EasyFLAC__reset(EasyFLAC__StreamDecoder *decoder);
FLAC__bool EasyFLAC__process_single(EasyFLAC__StreamDecoder *decoder);
FLAC__bool EasyFLAC__process_until_end_of_metadata(EasyFLAC__StreamDecoder *decoder);
FLAC__bool EasyFLAC__process_until_end_of_stream(EasyFLAC__StreamDecoder *decoder);
#ifdef __cplusplus
}
#endif
#endif
......@@ -56,6 +56,7 @@ typedef struct
int genre_count;
adv_opt *advopt;
int advopt_count;
int copy_comments;
int quiet;