From 36b6f72e271737a87464c34e5a123d22f1ed09be Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Diego=20=27Flameeyes=27=20Petten=C3=B2?= Date: Wed, 24 Jan 2007 04:57:26 +0000 Subject: Create a new wavpack plugin with both the old demuxer and a new decoder. To simplify categorising, I've created a new combined directory to put plugins like wavpack (or libflac) that carries both a demuxer and a decoder in a single bundle -- I expect it being used more in the future. CVS patchset: 8551 CVS date: 2007/01/24 04:57:26 --- src/Makefile.am | 3 +- src/combined/.cvsignore | 6 + src/combined/Makefile.am | 12 ++ src/combined/combined_wavpack.c | 48 +++++ src/combined/combined_wavpack.h | 47 +++++ src/combined/decoder_wavpack.c | 358 +++++++++++++++++++++++++++++++++++ src/combined/demux_wavpack.c | 410 ++++++++++++++++++++++++++++++++++++++++ 7 files changed, 883 insertions(+), 1 deletion(-) create mode 100644 src/combined/.cvsignore create mode 100644 src/combined/Makefile.am create mode 100644 src/combined/combined_wavpack.c create mode 100644 src/combined/combined_wavpack.h create mode 100644 src/combined/decoder_wavpack.c create mode 100644 src/combined/demux_wavpack.c (limited to 'src') diff --git a/src/Makefile.am b/src/Makefile.am index 67fbc38b8..0d5621593 100644 --- a/src/Makefile.am +++ b/src/Makefile.am @@ -30,4 +30,5 @@ SUBDIRS = \ libfaad \ libflac \ libmusepack \ - post + post \ + combined diff --git a/src/combined/.cvsignore b/src/combined/.cvsignore new file mode 100644 index 000000000..7d926a554 --- /dev/null +++ b/src/combined/.cvsignore @@ -0,0 +1,6 @@ +Makefile +Makefile.in +.libs +.deps +*.lo +*.la diff --git a/src/combined/Makefile.am b/src/combined/Makefile.am new file mode 100644 index 000000000..34915b24c --- /dev/null +++ b/src/combined/Makefile.am @@ -0,0 +1,12 @@ +include $(top_srcdir)/misc/Makefile.common + +if HAVE_WAVPACK +xineplug_wavpack = xineplug_wavpack.la +endif + +xineplug_LTLIBRARIES = $(xineplug_wavpack) + +xineplug_wavpack_la_SOURCES = demux_wavpack.c decoder_wavpack.c combined_wavpack.c combined_wavpack.h +xineplug_wavpack_la_CFLAGS = $(WAVPACK_CFLAGS) +xineplug_wavpack_la_LIBADD = $(XINE_LIB) $(WAVPACK_LIBS) +xineplug_wavpack_la_LDFLAGS = -avoid-version -module diff --git a/src/combined/combined_wavpack.c b/src/combined/combined_wavpack.c new file mode 100644 index 000000000..00a1ba85f --- /dev/null +++ b/src/combined/combined_wavpack.c @@ -0,0 +1,48 @@ +/* + * Copyright (C) 2007 the xine project + * + * This file is part of xine, a free video player. + * + * xine is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * xine 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + * + * xine interface to libwavpack by Diego Pettenò + * + * $Id: combined_wavpack.c,v 1.1 2007/01/24 04:57:26 dgp85 Exp $ + */ + +#include "xine_internal.h" + +extern void *demux_wv_init_plugin (xine_t *const xine, void *const data); +extern void *decoder_wavpack_init_plugin (xine_t *xine, void *data); + +static const demuxer_info_t demux_info_wv = { + 0 /* priority */ +}; + +static uint32_t audio_types[] = { + BUF_AUDIO_WAVPACK, 0 + }; + +static const decoder_info_t decoder_info_wv = { + audio_types, /* supported types */ + 7 /* priority */ +}; + +const plugin_info_t xine_plugin_info[] EXPORTED = { + /* type, API, "name", version, special_info, init_function */ + { PLUGIN_DEMUX, 26, "wavpack", XINE_VERSION_CODE, &demux_info_wv, demux_wv_init_plugin }, + { PLUGIN_AUDIO_DECODER, 15, "wavpackdec", XINE_VERSION_CODE, &decoder_info_wv, decoder_wavpack_init_plugin }, + { PLUGIN_NONE, 0, NULL, 0, NULL, NULL } +}; diff --git a/src/combined/combined_wavpack.h b/src/combined/combined_wavpack.h new file mode 100644 index 000000000..7ab8877be --- /dev/null +++ b/src/combined/combined_wavpack.h @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2007 the xine project + * + * This file is part of xine, a free video player. + * + * xine is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * xine 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + * + * xine interface to libwavpack by Diego Pettenò + * + * $Id: combined_wavpack.h,v 1.1 2007/01/24 04:57:27 dgp85 Exp $ + */ + +#include "os_types.h" +#include "bswap.h" + +typedef struct { + uint32_t idcode; /* This should always be the string "wvpk" */ + uint32_t block_size; /* Size of the rest of the frame */ + uint16_t wv_version; /* Version of the wavpack, 0x0403 should be latest */ + uint8_t track; /* Unused, has to be 0 */ + uint8_t index; /* Unused, has to be 0 */ + uint32_t file_samples; /* (uint32_t)-1 if unknown, else the total number + of samples for the file */ + uint32_t samples_index; /* Index of the first sample in block, from the + start of the file */ + uint32_t samples_count; /* Count of samples in the current frame */ + uint32_t flags; /* Misc flags */ + uint32_t decoded_crc32; /* CRC32 of the decoded data */ +} __attribute__((packed)) wvheader_t; + +#ifdef WORDS_BIGENDIAN +static const uint32_t wvpk_signature = ('k' + ('p' << 8) + ('v' << 16) + ('w' << 24)); +#else +static const uint32_t wvpk_signature = ('w' + ('v' << 8) + ('p' << 16) + ('k' << 24)); +#endif diff --git a/src/combined/decoder_wavpack.c b/src/combined/decoder_wavpack.c new file mode 100644 index 000000000..38a1b2bbe --- /dev/null +++ b/src/combined/decoder_wavpack.c @@ -0,0 +1,358 @@ +/* + * Copyright (C) 2007 the xine project + * + * This file is part of xine, a free video player. + * + * xine is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * xine 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + * + * xine interface to libwavpack by Diego Pettenò + * + * $Id: decoder_wavpack.c,v 1.1 2007/01/24 04:57:27 dgp85 Exp $ + */ + +#define LOG_MODULE "decode_wavpack" +#define LOG_VERBOSE + +#include "xine_internal.h" + +#include +#include "combined_wavpack.h" + +typedef struct { + audio_decoder_class_t decoder_class; +} wavpack_class_t; + +typedef struct { + audio_decoder_t audio_decoder; + + xine_stream_t *stream; + + int output_open; + + int sample_rate; + int bits_per_sample; + int channels; + + uint8_t *buf; + size_t buf_size; + size_t buf_pos; +} wavpack_decoder_t; + +#ifndef __unused +# ifdef SUPPORT_ATTRIBUTE_UNUSED +# define __unused __attribute__((unused)) +# else +# define __unused +# endif +#endif + +/* Wrapper functions for Wavpack */ +static int32_t xine_buffer_read_bytes(void *const this_gen, void *const data, + int32_t bcount) { + wavpack_decoder_t *const this = (wavpack_decoder_t*)this_gen; + + if ( bcount <= 0 ) + return 0; + + if ( bcount > (this->buf_size - this->buf_pos) ) + bcount = (this->buf_size - this->buf_pos); + + xine_fast_memcpy(data, this->buf + this->buf_pos, bcount); + this->buf_pos += bcount; + + return bcount; +} + +static uint32_t xine_buffer_get_pos(void *const this_gen) { + wavpack_decoder_t *const this = (wavpack_decoder_t*)this_gen; + return this->buf_pos; +} + +static int xine_buffer_set_pos_rel(void *const this_gen, const int32_t delta, + const int mode) { + wavpack_decoder_t *const this = (wavpack_decoder_t*)this_gen; + + switch(mode) { + case SEEK_SET: + if ( delta < 0 || delta > this->buf_size ) + return -1; + + this->buf_pos = delta; + return 0; + case SEEK_CUR: + if ( (this->buf_pos+delta) < 0 || (this->buf_pos+delta) > this->buf_size ) + return -1; + + this->buf_pos += delta; + return 0; + case SEEK_END: + if ( delta < 0 || delta > this->buf_size ) + return -1; + + this->buf_pos = this->buf_size - delta; + + return 0; + } +} + +static int xine_buffer_set_pos_abs(void *const this_gen, const uint32_t pos) { + return xine_buffer_set_pos_rel(this_gen, pos, SEEK_SET); +} + +static int xine_buffer_push_back_byte(void *const this_gen, const int c) { + if ( ! xine_buffer_set_pos_rel(this_gen, -1, SEEK_CUR) ) + return EOF; + return c; +} + +static uint32_t xine_buffer_get_length(void *const this_gen) { + wavpack_decoder_t *const this = (wavpack_decoder_t*)this_gen; + return this->buf_size; +} + +static int xine_buffer_can_seek(void *const this_gen) { + wavpack_decoder_t *const this = (wavpack_decoder_t*)this_gen; + return 1; +} + +static int32_t xine_buffer_write_bytes(__unused void *const id, + __unused void *const data, + __unused const int32_t bcount) { + lprintf("xine_buffer_write_bytes: acces is read-only.\n"); + return 0; +} + +/* Wavpack plugin functions */ +static void wavpack_reset (audio_decoder_t *const this_gen) +{ + wavpack_decoder_t *const this = (wavpack_decoder_t *) this_gen; + + this->buf_pos = 0; +} + +static void wavpack_discontinuity (audio_decoder_t *const this_gen) +{ + wavpack_decoder_t *this = (wavpack_decoder_t *) this_gen; + + lprintf("Discontinuity!\n"); +} + +static void wavpack_decode_data (audio_decoder_t *const this_gen, buf_element_t *const buf) +{ + wavpack_decoder_t *const this = (wavpack_decoder_t *) this_gen; + int ret = 1; + + /* We are getting the stream header, open up the audio + * device, and collect information about the stream + */ + if (buf->decoder_flags & BUF_FLAG_STDHEADER) + { + int mode = AO_CAP_MODE_MONO; + + this->sample_rate = buf->decoder_info[1]; + this->bits_per_sample = buf->decoder_info[2]; + this->channels = buf->decoder_info[3]; + + mode = _x_ao_channels2mode(this->channels); + + _x_meta_info_set(this->stream, XINE_META_INFO_AUDIOCODEC, + "WavPack"); + + if (!this->output_open) + { + this->output_open = this->stream->audio_out->open ( + this->stream->audio_out, + this->stream, + this->bits_per_sample, + this->sample_rate, + mode); + } + this->buf_pos = 0; + } else if (this->output_open) { + /* This isn't a header frame and we have opened the output device */ + + /* First time, we prepend the header, so that Wavpack library can open it. + * As FFmpeg requires the last 12 bytes of the header for its stream, create + * the rest of the header when the frame ended (so we have its size). + */ + if ( ! this->buf ) + this->buf = xine_xmalloc(this->buf_size = sizeof(wvheader_t)-12); + if ( this->buf_pos == 0 ) + this->buf_pos = sizeof(wvheader_t)-12; + + /* What we have buffered so far, and what is coming in + * is larger than our buffer + */ + if (this->buf_pos + buf->size > this->buf_size) + { + this->buf_size += 2 * buf->size; + this->buf = realloc (this->buf, this->buf_size); + lprintf("reallocating buffer to %zd\n", this->buf_size); + } + + xine_fast_memcpy (&this->buf[this->buf_pos], buf->content, buf->size); + this->buf_pos += buf->size; + + if ( buf->decoder_flags & BUF_FLAG_FRAME_END ) { + static WavpackStreamReader wavpack_buffer_reader = { + .read_bytes = xine_buffer_read_bytes, + .get_pos = xine_buffer_get_pos, + .set_pos_abs = xine_buffer_set_pos_abs, + .set_pos_rel = xine_buffer_set_pos_rel, + .push_back_byte = xine_buffer_push_back_byte, + .get_length = xine_buffer_get_length, + .can_seek = xine_buffer_can_seek, + .write_bytes = xine_buffer_write_bytes + }; + + WavpackContext *ctx = NULL; + char error[256]; /* Current version of wavpack (4.31) does not write more than this */ + int32_t samples_left; uint32_t samples_total; + wvheader_t *header = (wvheader_t*)this->buf; + + header->idcode = wvpk_signature; +#ifdef WORDS_BIGENDIAN + header->block_size = bswap_32(this->buf_size-sizeof(wvheader_t)); + header->wv_version = bswap_16(0x0406); +#else + header->block_size = this->buf_pos-8; + header->wv_version = 0x0406; +#endif + header->track = 0; header->index = 0; + header->file_samples = (uint32_t)-1; + header->samples_index = 0; + + this->buf_pos = 0; + + if ( header->samples_count == 0 ) return; + + ctx = WavpackOpenFileInputEx(&wavpack_buffer_reader, this, NULL, error, OPEN_STREAMING, 0); + if ( ! ctx ) { + lprintf("unable to open the stream: %s\n", error); + this->buf_pos = 0; + return; + } + + samples_left = samples_total = header->samples_count; + while ( samples_left > 0 ) { + uint32_t buf_samples, decoded_count; + audio_buffer_t *audio_buffer = this->stream->audio_out->get_buffer(this->stream->audio_out); + int32_t *decoded; + int i; + + buf_samples = audio_buffer->mem_size / (this->channels * (this->bits_per_sample/8)); + if ( buf_samples > samples_left ) buf_samples = samples_left; + if ( buf_samples > 4096 ) buf_samples = 4096; + + decoded = alloca(buf_samples * this->channels * sizeof(int32_t)); + + decoded_count = WavpackUnpackSamples(ctx, decoded, buf_samples); + if ( decoded_count == 0 && *error ) { + fprintf(stderr, "Error during decode: %s\n", error); + break; + } + + if ( decoded_count == 0 ) { + lprintf("Finished decoding, but still %"PRId64" samples left?\n", samples_left); + break; + } + + lprintf("Decoded %d samples\n", buf_samples); + + samples_left -= decoded_count; + + audio_buffer->num_frames = decoded_count; + audio_buffer->vpts = 0; /* TODO: Fix the pts calculation */ + // audio_buffer->vpts = (buf->pts * (samples_total-samples_left)) / samples_total; + lprintf("Audio buffer with pts %"PRId64"\n", audio_buffer->vpts); + + switch(this->bits_per_sample) { + case 8: { + int8_t *data8 = (int8_t*)audio_buffer->mem; + for(i = 0; i < decoded_count*this->channels; i++) + data8[i] = decoded[i]; + } + break; + case 16: { + int16_t *data16 = (int16_t*)audio_buffer->mem; + for(i = 0; i < decoded_count*this->channels; i++) + data16[i] = decoded[i]; + } + } + + this->stream->audio_out->put_buffer (this->stream->audio_out, audio_buffer, this->stream); + } + + WavpackCloseFile(ctx); + this->buf_pos = 0; + } + } else + return; +} + +static void wavpack_dispose (audio_decoder_t *this_gen) { + wavpack_decoder_t *this = (wavpack_decoder_t *) this_gen; + + if (this->output_open) + this->stream->audio_out->close (this->stream->audio_out, this->stream); + + free(this->buf); + + free (this_gen); +} + +static audio_decoder_t *open_plugin (audio_decoder_class_t *class_gen, xine_stream_t *stream) { + wavpack_decoder_t * const this = (wavpack_decoder_t *) xine_xmalloc (sizeof (wavpack_decoder_t)); + + this->audio_decoder.decode_data = wavpack_decode_data; + this->audio_decoder.reset = wavpack_reset; + this->audio_decoder.discontinuity = wavpack_discontinuity; + this->audio_decoder.dispose = wavpack_dispose; + this->stream = stream; + + this->buf = NULL; + this->buf_size = 0; + + return (audio_decoder_t *) this; +} + +/* + * wavpack plugin class + */ + +static char *get_identifier (audio_decoder_class_t *this) { + return "wavpackdec"; +} + +static char *get_description (audio_decoder_class_t *this) { + return "wavpack audio decoder plugin"; +} + +static void dispose_class (audio_decoder_class_t *this) { + free (this); +} + +void *decoder_wavpack_init_plugin (xine_t *xine, void *data) { + wavpack_class_t *this; + + this = (wavpack_class_t *) xine_xmalloc (sizeof (wavpack_class_t)); + + this->decoder_class.open_plugin = open_plugin; + this->decoder_class.get_identifier = get_identifier; + this->decoder_class.get_description = get_description; + this->decoder_class.dispose = dispose_class; + + return this; +} diff --git a/src/combined/demux_wavpack.c b/src/combined/demux_wavpack.c new file mode 100644 index 000000000..ffb3641f5 --- /dev/null +++ b/src/combined/demux_wavpack.c @@ -0,0 +1,410 @@ +/* + * Copyright (C) 2006-2007 the xine project + * + * This file is part of xine, a free video player. + * + * xine is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * xine 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 General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA + * + * xine interface to libwavpack by Diego Pettenò + * + * $Id: demux_wavpack.c,v 1.1 2007/01/24 04:57:27 dgp85 Exp $ + */ + +#define LOG_MODULE "demux_wavpack" +#define LOG_VERBOSE + +#include "xine_internal.h" +#include "xineutils.h" +#include "demux.h" +#include "bswap.h" +#include "group_audio.h" + +#include + +#include "combined_wavpack.h" + +typedef struct { + demux_plugin_t demux_plugin; + + xine_stream_t *stream; + fifo_buffer_t *audio_fifo; + input_plugin_t *input; + int status; + + union { + wvheader_t wv; + uint8_t buffer[sizeof(wvheader_t)]; + } header; + + uint32_t current_sample; + uint32_t samples; + uint32_t samplerate; + uint32_t bits_per_sample; + uint32_t channels; +} demux_wv_t; + +typedef struct { + demux_class_t demux_class; +} demux_wv_class_t; + +#ifndef __unused +# ifdef SUPPORT_ATTRIBUTE_UNUSED +# define __unused __attribute__((unused)) +# else +# define __unused +# endif +#endif + +static int32_t xine_input_read_bytes(void *const this_gen, void *const data, + const int32_t bcount) { + input_plugin_t *const this = (input_plugin_t*)this_gen; + return this->read(this, data, bcount); +} + +static uint32_t xine_input_get_pos(void *const this_gen) { + input_plugin_t *const this = (input_plugin_t*)this_gen; + return this->get_current_pos(this); +} + +static int xine_input_set_pos_abs(void *const this_gen, const uint32_t pos) { + input_plugin_t *const this = (input_plugin_t*)this_gen; + return this->seek(this, pos, SEEK_SET); +} + +static int xine_input_set_pos_rel(void *const this_gen, const int32_t delta, + const int mode) { + input_plugin_t *const this = (input_plugin_t*)this_gen; + return this->seek(this, delta, mode); +} + +static int xine_input_push_back_byte(void *const this_gen, const int c) { + input_plugin_t *const this = (input_plugin_t*)this_gen; + if ( this->seek(this, -1, SEEK_CUR) ) { + return c; + } else { + lprintf("xine_input_push_back_byte: unable to seek.\n"); + return EOF; + } +} + +static uint32_t xine_input_get_length(void *const this_gen) { + input_plugin_t *const this = (input_plugin_t*)this_gen; + return this->get_length(this); +} + +static int xine_input_can_seek(void *const this_gen) { + input_plugin_t *const this = (input_plugin_t*)this_gen; + return INPUT_IS_SEEKABLE(this); +} + +static int32_t xine_input_write_bytes(__unused void *const id, + __unused void *const data, + __unused const int32_t bcount) { + lprintf("xine_input_write_bytes: acces is read-only.\n"); + return 0; +} + +static WavpackStreamReader wavpack_input_reader = { + .read_bytes = xine_input_read_bytes, + .get_pos = xine_input_get_pos, + .set_pos_abs = xine_input_set_pos_abs, + .set_pos_rel = xine_input_set_pos_rel, + .push_back_byte = xine_input_push_back_byte, + .get_length = xine_input_get_length, + .can_seek = xine_input_can_seek, + .write_bytes = xine_input_write_bytes +}; + +static int open_wv_file(demux_wv_t *const this) { + WavpackContext *ctx = NULL; + char error[256]; /* Current version of wavpack (4.31) does not write more than this */ + + /* Right now we don't support non-seekable streams */ + if (! INPUT_IS_SEEKABLE(this->input) ) { + lprintf("open_wv_file: non-seekable inputs aren't supported yet.\n"); + return 0; + } + + /* Read the file header */ + if (_x_demux_read_header(this->input, this->header.buffer, sizeof(wvheader_t)) != sizeof(wvheader_t)) + return 0; + + /* Validate header, we currently support only Wavpack 4 */ + if ( this->header.wv.idcode != wvpk_signature || (le2me_16(this->header.wv.wv_version) >> 8) != 4 ) + return 0; + + /* Rewind */ + this->input->seek(this->input, 0 - sizeof(wvheader_t), SEEK_CUR); + + ctx = WavpackOpenFileInputEx(&wavpack_input_reader, this->input, NULL, error, 0, 0); + if ( ! ctx ) { + lprintf("xine_open_wavpack_input: unable to open the stream: %s\n", error); + return 0; + } + + this->current_sample = 0; + this->samples = WavpackGetNumSamples(ctx); + lprintf("number of samples: %u\n", this->samples); + this->samplerate = WavpackGetSampleRate(ctx); + lprintf("samplerate: %u Hz\n", this->samplerate); + this->bits_per_sample = WavpackGetBitsPerSample(ctx); + lprintf("bits_per_sample: %u\n", this->bits_per_sample); + this->channels = WavpackGetNumChannels(ctx); + lprintf("channels: %u\n", this->channels); + + _x_stream_info_set(this->stream, XINE_STREAM_INFO_HAS_AUDIO, 1); + _x_stream_info_set(this->stream, XINE_STREAM_INFO_AUDIO_FOURCC, + ME_32(this->header.buffer)); + _x_stream_info_set(this->stream, XINE_STREAM_INFO_AUDIO_CHANNELS, + this->channels); + _x_stream_info_set(this->stream, XINE_STREAM_INFO_AUDIO_SAMPLERATE, + this->samplerate); + _x_stream_info_set(this->stream, XINE_STREAM_INFO_AUDIO_BITS, + this->bits_per_sample); + + WavpackCloseFile(ctx); + this->input->seek(this->input, SEEK_SET, 0); + + return 1; +} + +static int demux_wv_send_chunk(demux_plugin_t *const this_gen) { + demux_wv_t *const this = (demux_wv_t *) this_gen; + uint32_t bytes_to_read; + + /* Check if we've finished */ + if (this->current_sample >= this->samples) { + lprintf("all frames read\n"); + this->status = DEMUX_FINISHED; + return this->status; + } + + lprintf("current sample: %u\n", this->current_sample); + + /* For some reason, FFmpeg requires to send it the latter 12 bytes of the header.. don't ask! */ + if ( this->input->read(this->input, this->header.buffer, sizeof(wvheader_t)-12) != sizeof(wvheader_t)-12 ) { + this->status = DEMUX_FINISHED; + return this->status; + } + + /* The size of the block is «of course» minus 8, and + it also includes the size of the header, but we need + to give FFmpeg the 12 extra bytes (for some reason), + so the amount of bytes to read is the following. + */ + bytes_to_read = le2me_32(this->header.wv.block_size) + 8 - (sizeof(wvheader_t)-12); + + lprintf("demux_wavpack: going to read %u bytes.\n", bytes_to_read); + + while(bytes_to_read) { + off_t bytes_read = 0; + buf_element_t *buf = NULL; + int64_t input_time_guess; + + /* Get a buffer */ + buf = this->audio_fifo->buffer_pool_alloc(this->audio_fifo); + buf->type = BUF_AUDIO_WAVPACK; + buf->decoder_flags = 0; + + /* Set normalised position */ + buf->extra_info->input_normpos = + (int) ((double) this->input->get_current_pos(this->input) * 65535 / + this->input->get_length(this->input)); + + buf->pts = (((this->current_sample) / this->samplerate)-1)*90000; + lprintf("Sending buffer with PTS %d\n", buf->pts); + + /* Set time */ + input_time_guess = this->samples; + input_time_guess /= this->samplerate; + input_time_guess *= 1000; + input_time_guess *= buf->extra_info->input_normpos; + input_time_guess /= 65535; + buf->extra_info->input_time = input_time_guess; + + bytes_read = this->input->read(this->input, buf->content, ( bytes_to_read > buf->max_size ) ? buf->max_size : bytes_to_read); + + buf->size = bytes_read; + + bytes_to_read -= bytes_read; + + if ( bytes_to_read <= 0 ) + buf->decoder_flags |= BUF_FLAG_FRAME_END; + + this->audio_fifo->put(this->audio_fifo, buf); + } + + this->current_sample += this->header.wv.samples_count; + + return this->status; +} + +static void demux_wv_send_headers(demux_plugin_t *const this_gen) { + demux_wv_t *const this = (demux_wv_t *) this_gen; + buf_element_t *buf; + + this->audio_fifo = this->stream->audio_fifo; + + this->status = DEMUX_OK; + + /* Send start buffers */ + _x_demux_control_start(this->stream); + + /* Send header to decoder */ + if (this->audio_fifo) { + buf = this->audio_fifo->buffer_pool_alloc (this->audio_fifo); + + buf->type = BUF_AUDIO_WAVPACK; + buf->decoder_flags = BUF_FLAG_HEADER|BUF_FLAG_STDHEADER|BUF_FLAG_FRAME_END; + buf->decoder_info[0] = this->input->get_length(this->input); + buf->decoder_info[1] = this->samplerate; + buf->decoder_info[2] = this->bits_per_sample; + buf->decoder_info[3] = this->channels; + + /* Copy the header */ + buf->size = sizeof(xine_waveformatex) + sizeof(wvheader_t); + memcpy(buf->content+sizeof(xine_waveformatex), this->header.buffer, buf->size); + + this->audio_fifo->put (this->audio_fifo, buf); + } +} + +static int demux_wv_seek (demux_plugin_t *this_gen, + off_t start_pos, int start_time, int playing) { + demux_wv_t *const this = (demux_wv_t *) this_gen; + + /* If thread is not running, initialize demuxer */ + if( !playing ) { + + /* send new pts */ + _x_demux_control_newpts(this->stream, 0, 0); + + this->status = DEMUX_OK; + + } + + return this->status; +} + +static void demux_wv_dispose (demux_plugin_t *const this_gen) { + demux_wv_t *const this = (demux_wv_t *) this_gen; + + free(this); +} + +static int demux_wv_get_status (demux_plugin_t *const this_gen) { + const demux_wv_t *const this = (const demux_wv_t *) this_gen; + + return this->status; +} + +static int demux_wv_get_stream_length (demux_plugin_t *const this_gen) { + const demux_wv_t *const this = (demux_wv_t *) this_gen; + + return (this->samples*1000) / this->samplerate; +} + +static uint32_t demux_wv_get_capabilities(demux_plugin_t *const this_gen) { + return DEMUX_CAP_NOCAP; +} + +static int demux_wv_get_optional_data(demux_plugin_t *const this_gen, + void *data, const int data_type) { + return DEMUX_OPTIONAL_UNSUPPORTED; +} + +static demux_plugin_t *open_plugin (demux_class_t *const class_gen, + xine_stream_t *const stream, + input_plugin_t *const input) { + demux_wv_t *const this = xine_xmalloc (sizeof (demux_wv_t)); + this->stream = stream; + this->input = input; + + this->demux_plugin.send_headers = demux_wv_send_headers; + this->demux_plugin.send_chunk = demux_wv_send_chunk; + this->demux_plugin.seek = demux_wv_seek; + this->demux_plugin.dispose = demux_wv_dispose; + this->demux_plugin.get_status = demux_wv_get_status; + this->demux_plugin.get_stream_length = demux_wv_get_stream_length; + this->demux_plugin.get_capabilities = demux_wv_get_capabilities; + this->demux_plugin.get_optional_data = demux_wv_get_optional_data; + this->demux_plugin.demux_class = class_gen; + + this->status = DEMUX_FINISHED; + switch (stream->content_detection_method) { + + case METHOD_BY_EXTENSION: { + const char *const mrl = input->get_mrl (input); + const char *const extensions = class_gen->get_extensions (class_gen); + + if (!_x_demux_check_extension (mrl, extensions)) { + free (this); + return NULL; + } + } + /* Falling through is intended */ + + case METHOD_BY_CONTENT: + case METHOD_EXPLICIT: + + if (!open_wv_file(this)) { + free (this); + return NULL; + } + + break; + + default: + free (this); + return NULL; + } + + return &this->demux_plugin; +} + +static const char *get_description (demux_class_t *const this_gen) { + return "Wavpack demux plugin"; +} + +static const char *get_identifier (demux_class_t *const this_gen) { + return "Wavpack"; +} + +static const char *get_extensions (demux_class_t *const this_gen) { + return "wv"; +} + +static const char *get_mimetypes (demux_class_t *const this_gen) { + return NULL; +} + +static void class_dispose (demux_class_t *const this_gen) { + demux_wv_class_t *const this = (demux_wv_class_t *) this_gen; + + free (this); +} + +void *demux_wv_init_plugin (xine_t *const xine, void *const data) { + demux_wv_class_t *const this = xine_xmalloc (sizeof (demux_wv_class_t)); + + this->demux_class.open_plugin = open_plugin; + this->demux_class.get_description = get_description; + this->demux_class.get_identifier = get_identifier; + this->demux_class.get_mimetypes = get_mimetypes; + this->demux_class.get_extensions = get_extensions; + this->demux_class.dispose = class_dispose; + + return this; +} -- cgit v1.2.3