/*

* SDL_sound -- An abstract sound format decoding API.

* Copyright (C) 2001 Ryan C. Gordon.

*

* This library is free software; you can redistribute it and/or

* modify it under the terms of the GNU Lesser General Public

* License as published by the Free Software Foundation; either

* version 2.1 of the License, or (at your option) any later version.

*

* This library is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

* Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public

* License along with this library; if not, write to the Free Software

* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

*/

/*

* FLAC decoder for SDL_sound.

*

* This driver handles FLAC audio, that is to say the Free Lossless Audio

* Codec. It depends on libFLAC for decoding, which can be grabbed from:

* http://flac.sourceforge.net

*

*

* This file written by Torbjörn Andersson. (d91tan@Update.UU.SE)

*/

#if HAVE_CONFIG_H

# include <config.h>

#endif

#ifdef SOUND_SUPPORTS_FLAC

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "SDL_sound.h"

#define __SDL_SOUND_INTERNAL__

#include "SDL_sound_internal.h"

#define D_END_OF_STREAM FLAC__SEEKABLE_STREAM_DECODER_END_OF_STREAM

#define d_new() FLAC__seekable_stream_decoder_new()

#define d_init(x) FLAC__seekable_stream_decoder_init(x)

#define d_process_metadata(x) FLAC__seekable_stream_decoder_process_until_end_of_metadata(x)

#define d_process_one_frame(x) FLAC__seekable_stream_decoder_process_single(x)

#define d_get_state(x) FLAC__seekable_stream_decoder_get_state(x)

#define d_finish(x) FLAC__seekable_stream_decoder_finish(x)

#define d_delete(x) FLAC__seekable_stream_decoder_delete(x)

#define d_set_read_callback(x, y) FLAC__seekable_stream_decoder_set_read_callback(x, y)

#define d_set_write_callback(x, y) FLAC__seekable_stream_decoder_set_write_callback(x, y)

#define d_set_metadata_callback(x, y) FLAC__seekable_stream_decoder_set_metadata_callback(x, y)

#define d_set_error_callback(x, y) FLAC__seekable_stream_decoder_set_error_callback(x, y)

#define d_set_client_data(x, y) FLAC__seekable_stream_decoder_set_client_data(x, y)

typedef FLAC__SeekableStreamDecoder decoder_t;

typedef FLAC__SeekableStreamDecoderReadStatus d_read_status_t;

#define D_SEEK_STATUS_OK FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_OK

#define D_SEEK_STATUS_ERROR FLAC__SEEKABLE_STREAM_DECODER_SEEK_STATUS_ERROR

#define D_TELL_STATUS_OK FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_OK

#define D_TELL_STATUS_ERROR FLAC__SEEKABLE_STREAM_DECODER_TELL_STATUS_ERROR

#define D_LENGTH_STATUS_OK FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_OK

#define D_LENGTH_STATUS_ERROR FLAC__SEEKABLE_STREAM_DECODER_LENGTH_STATUS_ERROR

#define d_set_seek_callback(x, y) FLAC__seekable_stream_decoder_set_seek_callback(x, y)

#define d_set_tell_callback(x, y) FLAC__seekable_stream_decoder_set_tell_callback(x, y)

#define d_set_length_callback(x, y) FLAC__seekable_stream_decoder_set_length_callback(x, y)

#define d_set_eof_callback(x, y) FLAC__seekable_stream_decoder_set_eof_callback(x, y)

#define d_seek_absolute(x, y) FLAC__seekable_stream_decoder_seek_absolute(x, y)

typedef FLAC__SeekableStreamDecoderSeekStatus d_seek_status_t;

typedef FLAC__SeekableStreamDecoderTellStatus d_tell_status_t;

typedef FLAC__SeekableStreamDecoderLengthStatus d_length_status_t;

#define D_WRITE_CONTINUE FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE

#define D_READ_END_OF_STREAM FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM

#define D_READ_ABORT FLAC__STREAM_DECODER_READ_STATUS_ABORT

#define D_READ_CONTINUE FLAC__STREAM_DECODER_READ_STATUS_CONTINUE

#define d_error_status_string FLAC__StreamDecoderErrorStatusString

typedef FLAC__StreamDecoderErrorStatus d_error_status_t;

typedef FLAC__StreamMetadata d_metadata_t;

typedef FLAC__StreamDecoderWriteStatus d_write_status_t;

static int FLAC_init(void);

static void FLAC_quit(void);

static int FLAC_open(Sound_Sample *sample, const char *ext);

static void FLAC_close(Sound_Sample *sample);

static Uint32 FLAC_read(Sound_Sample *sample);

static const char *extensions_flac[] = { "FLAC", "FLA", NULL };

const Sound_DecoderFunctions __Sound_DecoderFunctions_FLAC =

{

{

extensions_flac,

"Free Lossless Audio Codec",

"Torbjörn Andersson <d91tan@Update.UU.SE>",

"http://flac.sourceforge.net/"

},

FLAC_init, /* init() method */

FLAC_quit, /* quit() method */

FLAC_open, /* open() method */

FLAC_close, /* close() method */

FLAC_read, /* read() method */

FLAC_rewind, /* rewind() method */

FLAC_seek /* seek() method */

};

/* This is what we store in our internal->decoder_private field. */

typedef struct

{

SDL_RWops *rw;

Sound_Sample *sample;

Uint32 frame_size;

} flac_t;

static void free_flac(flac_t *f)

{

d_finish(f->decoder);

d_delete(f->decoder);

free(f);

} /* free_flac */

static d_read_status_t read_callback(

const decoder_t *decoder, FLAC__byte buffer[],

unsigned int *bytes, void *client_data)

{

flac_t *f = (flac_t *) client_data;

Uint32 retval;

retval = SDL_RWread(f->rw, (Uint8 *) buffer, 1, *bytes);

if (retval == 0)

{

*bytes = 0;

f->sample->flags |= SOUND_SAMPLEFLAG_EOF;

} /* if */

if (retval == -1)

{

*bytes = 0;

f->sample->flags |= SOUND_SAMPLEFLAG_ERROR;

} /* if */

if (retval < *bytes)

{

*bytes = retval;

f->sample->flags |= SOUND_SAMPLEFLAG_EAGAIN;

} /* if */

return(D_READ_CONTINUE);

} /* read_callback */

static d_write_status_t write_callback(

const decoder_t *decoder, const FLAC__Frame *frame,

const FLAC__int32 * const buffer[],

void *client_data)

{

flac_t *f = (flac_t *) client_data;

Uint32 i, j;

Uint8 *dst;

f->frame_size = frame->header.channels * frame->header.blocksize

* frame->header.bits_per_sample / 8;

if (f->frame_size > f->sample->buffer_size)

Sound_SetBufferSize(f->sample, f->frame_size);

dst = f->sample->buffer;

/* If the sample is neither exactly 8-bit nor 16-bit, it will have to

* be converted. Unfortunately the buffer is read-only, so we either

* have to check for each sample, or make a copy of the buffer. I'm

* not sure which way is best, so I've arbitrarily picked the former.

*/

if (f->sample->actual.format == AUDIO_S8)

{

for (i = 0; i < frame->header.blocksize; i++)

for (j = 0; j < frame->header.channels; j++)

{

sample = buffer[j][i];

if (frame->header.bits_per_sample < 8)

sample <<= (8 - frame->header.bits_per_sample);

*dst++ = sample & 0x00ff;

} /* for */

} /* if */

else

{

for (i = 0; i < frame->header.blocksize; i++)

for (j = 0; j < frame->header.channels; j++)

{

sample = buffer[j][i];

if (frame->header.bits_per_sample < 16)

sample <<= (16 - frame->header.bits_per_sample);

else if (frame->header.bits_per_sample > 16)

sample >>= (frame->header.bits_per_sample - 16);

*dst++ = (sample & 0xff00) >> 8;

*dst++ = sample & 0x00ff;

} /* for */

} /* else */

return(D_WRITE_CONTINUE);

} /* write_callback */

static void metadata_callback(

const decoder_t *decoder,

const d_metadata_t *metadata,

void *client_data)

{

flac_t *f = (flac_t *) client_data;

Sound_Sample *sample = f->sample;

Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;

SNDDBG(("FLAC: Metadata callback.\n"));

/* There are several kinds of metadata, but STREAMINFO is the only

* one that always has to be there.

*/

if (metadata->type == FLAC__METADATA_TYPE_STREAMINFO)

{

SNDDBG(("FLAC: Metadata is streaminfo.\n"));

f->is_flac = 1;

sample->actual.channels = metadata->data.stream_info.channels;

sample->actual.rate = metadata->data.stream_info.sample_rate;

{

internal->total_time = -1;

} /* if */

else

{

internal->total_time = (metadata->data.stream_info.total_samples)

% metadata->data.stream_info.sample_rate) * 1000

/ metadata->data.stream_info.sample_rate;

static void error_callback(

const decoder_t *decoder,

d_error_status_t status,

void *client_data)

{

flac_t *f = (flac_t *) client_data;

} /* error_callback */

static d_seek_status_t seek_callback(

const decoder_t *decoder,

FLAC__uint64 absolute_byte_offset,

void *client_data)

{

flac_t *f = (flac_t *) client_data;

if (SDL_RWseek(f->rw, absolute_byte_offset, SEEK_SET) >= 0)

{

return(D_SEEK_STATUS_OK);

} /* if */

return(D_SEEK_STATUS_ERROR);

} /* seek_callback*/

static d_tell_status_t tell_callback(

const decoder_t *decoder,

FLAC__uint64 *absolute_byte_offset,

void *client_data)

{

flac_t *f = (flac_t *) client_data;

pos = SDL_RWtell(f->rw);

if (pos < 0)

{

return(D_TELL_STATUS_ERROR);

} /* if */

*absolute_byte_offset = pos;

return(D_TELL_STATUS_OK);

} /* tell_callback */

static d_length_status_t length_callback(

const decoder_t *decoder,

FLAC__uint64 *stream_length,

void *client_data)

{

flac_t *f = (flac_t *) client_data;

if (f->sample->flags & SOUND_SAMPLEFLAG_CANSEEK)

{

*stream_length = f->stream_length;

return(D_LENGTH_STATUS_OK);

} /* if */

return(D_LENGTH_STATUS_ERROR);

} /* length_callback */

static FLAC__bool eof_callback(

const decoder_t *decoder,

void *client_data)

{

flac_t *f = (flac_t *) client_data;

/* Maybe we could check for SOUND_SAMPLEFLAG_EOF here instead? */

pos = SDL_RWtell(f->rw);

if (pos >= 0 && pos >= f->stream_length)

{

return(true);

} /* if */

return(false);

} /* eof_callback */

static int FLAC_init(void)

{

return(1); /* always succeeds. */

} /* FLAC_init */

static void FLAC_quit(void)

{

/* it's a no-op. */

} /* FLAC_quit */

#define FLAC_MAGIC 0x43614C66 /* "fLaC" in ASCII. */

static int FLAC_open(Sound_Sample *sample, const char *ext)

{

Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;

SDL_RWops *rw = internal->rw;

/*

* If the extension is "flac", we'll believe that this is really meant

* to be a FLAC stream, and will try to grok it from existing metadata.

* metadata searching can be a very expensive operation, however, so

* unless the user swears that it is a FLAC stream through the extension,

* we decide what to do based on the existance of a 32-bit magic number.

*/

for (i = 0; extensions_flac[i] != NULL; i++)

{

if (__Sound_strcasecmp(ext, extensions_flac[i]) == 0)

{

has_extension = 1;

break;

} /* if */

} /* for */

if (!has_extension)

{

int rc;

Uint32 flac_magic = SDL_ReadLE32(rw);

BAIL_IF_MACRO(flac_magic != FLAC_MAGIC, "FLAC: Not a FLAC stream.", 0);

/* move back over magic number for metadata scan... */

rc = SDL_RWseek(internal->rw, -sizeof (flac_magic), SEEK_CUR);

BAIL_IF_MACRO(rc < 0, ERR_IO_ERROR, 0);

} /* if */

f = (flac_t *) malloc(sizeof (flac_t));

BAIL_IF_MACRO(f == NULL, ERR_OUT_OF_MEMORY, 0);

if (decoder == NULL)

{

free(f);

} /* if */

d_set_read_callback(decoder, read_callback);

d_set_write_callback(decoder, write_callback);

d_set_metadata_callback(decoder, metadata_callback);

d_set_error_callback(decoder, error_callback);

d_set_seek_callback(decoder, seek_callback);

d_set_tell_callback(decoder, tell_callback);

d_set_length_callback(decoder, length_callback);

d_set_eof_callback(decoder, eof_callback);

f->rw = internal->rw;

f->sample = sample;

f->decoder = decoder;

internal->decoder_private = f;

sample->flags = SOUND_SAMPLEFLAG_NONE;

pos = SDL_RWtell(f->rw);

{

f->stream_length = SDL_RWtell(f->rw);

if (SDL_RWseek(f->rw, pos, SEEK_SET) == -1)

{

free_flac(f);

BAIL_MACRO(ERR_IO_ERROR, 0);

} /* if */

sample->flags = SOUND_SAMPLEFLAG_CANSEEK;

} /* if */

/*

* If we are not sure this is a FLAC stream, check for the STREAMINFO

* and get the sound format from there, but that is not yet

* implemented.

*/

if (!f->is_flac)

/* Still not FLAC? Give up. */

if (!f->is_flac)

{

free_flac(f);

} /* if */

return(1);

} /* FLAC_open */

static void FLAC_close(Sound_Sample *sample)

{

Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;

flac_t *f = (flac_t *) internal->decoder_private;

} /* FLAC_close */

static Uint32 FLAC_read(Sound_Sample *sample)

{

Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;

flac_t *f = (flac_t *) internal->decoder_private;

Uint32 len;

} /* if */

return(0);

} /* if */

/* An error may have been signalled through the error callback. */

if (sample->flags & SOUND_SAMPLEFLAG_ERROR)

return(0);

return(f->frame_size);

} /* FLAC_read */

static int FLAC_rewind(Sound_Sample *sample)

{

} /* FLAC_rewind */

static int FLAC_seek(Sound_Sample *sample, Uint32 ms)

{

Sound_SampleInternal *internal = (Sound_SampleInternal *) sample->opaque;

flac_t *f = (flac_t *) internal->decoder_private;

d_seek_absolute(f->decoder, (ms * sample->actual.rate) / 1000);

return(1);

} /* FLAC_seek */

#endif /* SOUND_SUPPORTS_FLAC */

/* end of flac.c ... */