oysteikt/mpd
0
0
Fork 0
Code Issues Pull Requests Releases Activity

wavpack: renamed variables and modified coding style slightly

Browse Source
This commit is contained in:
László Áshin 2008-11-14 15:21:44 +01:00 committed by Max Kellermann
parent 7b7340f703
commit ed6f60460d
1 changed files with 111 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

189
src/decoder/wavpack_plugin.c
View File

@ -46,13 +46,19 @@ static struct {
{ "disc", TAG_ITEM_DISC }, { "disc", TAG_ITEM_DISC },
}; };
/** A pointer type for format converter function. */
typedef void (*format_samples_t)(
int bytes_per_sample,
void *buffer, uint32_t count
);
/* /*
* This function has been borrowed from the tiny player found on * This function has been borrowed from the tiny player found on
* wavpack.com. Modifications were required because mpd only handles * wavpack.com. Modifications were required because mpd only handles
* max 24-bit samples. * max 24-bit samples.
*/ */
static void static void
format_samples_int(int bytes_per_sample, void *buffer, uint32_t samcnt) format_samples_int(int bytes_per_sample, void *buffer, uint32_t count)
{ {
int32_t *src = buffer; int32_t *src = buffer;
@ -68,7 +74,7 @@ format_samples_int(int bytes_per_sample, void *buffer, uint32_t samcnt)
assert(sizeof(uchar) <= sizeof(uint32_t)); assert(sizeof(uchar) <= sizeof(uint32_t));
/* pass through and align 8-bit samples */ /* pass through and align 8-bit samples */
while (samcnt--) { while (count--) {
*dst++ = *src++; *dst++ = *src++;
} }
break; break;
@ -78,7 +84,7 @@ format_samples_int(int bytes_per_sample, void *buffer, uint32_t samcnt)
assert(sizeof(uint16_t) <= sizeof(uint32_t)); assert(sizeof(uint16_t) <= sizeof(uint32_t));
/* pass through and align 16-bit samples */ /* pass through and align 16-bit samples */
while (samcnt--) { while (count--) {
*dst++ = *src++; *dst++ = *src++;
} }
break; break;
@ -91,7 +97,7 @@ format_samples_int(int bytes_per_sample, void *buffer, uint32_t samcnt)
assert(sizeof(uint32_t) <= sizeof(uint32_t)); assert(sizeof(uint32_t) <= sizeof(uint32_t));
/* downsample to 24-bit */ /* downsample to 24-bit */
while (samcnt--) { while (count--) {
*dst++ = *src++ >> 8; *dst++ = *src++ >> 8;
} }
break; break;
@ -104,13 +110,13 @@ format_samples_int(int bytes_per_sample, void *buffer, uint32_t samcnt)
*/ */
static void static void
format_samples_float(mpd_unused int bytes_per_sample, void *buffer, format_samples_float(mpd_unused int bytes_per_sample, void *buffer,
uint32_t samcnt) uint32_t count)
{ {
int32_t *dst = buffer; int32_t *dst = buffer;
float *src = buffer; float *src = buffer;
assert(sizeof(int32_t) <= sizeof(float)); assert(sizeof(int32_t) <= sizeof(float));
while (samcnt--) { while (count--) {
*dst++ = (int32_t)(*src++ + 0.5f); *dst++ = (int32_t)(*src++ + 0.5f);
} }
} }
@ -120,18 +126,16 @@ format_samples_float(mpd_unused int bytes_per_sample, void *buffer,
* Requires an already opened WavpackContext. * Requires an already opened WavpackContext.
*/ */
static void static void
wavpack_decode(struct decoder * decoder, WavpackContext *wpc, bool canseek, wavpack_decode(struct decoder *decoder, WavpackContext *wpc, bool can_seek,
struct replay_gain_info *replayGainInfo) struct replay_gain_info *replay_gain_info)
{ {
struct audio_format audio_format; struct audio_format audio_format;
void (*format_samples)(int bytes_per_sample, format_samples_t format_samples;
void *buffer, uint32_t samcnt);
char chunk[CHUNK_SIZE]; char chunk[CHUNK_SIZE];
float file_time; int samples_requested, samples_got;
int samplesreq, samplesgot; float total_time, current_time;
int allsamples; int bytes_per_sample, output_sample_size;
int position, outsamplesize; int position;
int bytes_per_sample;
audio_format.sample_rate = WavpackGetSampleRate(wpc); audio_format.sample_rate = WavpackGetSampleRate(wpc);
audio_format.channels = WavpackGetReducedChannels(wpc); audio_format.channels = WavpackGetReducedChannels(wpc);
@ -150,26 +154,30 @@ wavpack_decode(struct decoder * decoder, WavpackContext *wpc, bool canseek,
format_samples = format_samples_int; format_samples = format_samples_int;
} }
allsamples = WavpackGetNumSamples(wpc); total_time = WavpackGetNumSamples(wpc);
total_time /= audio_format.sample_rate;
bytes_per_sample = WavpackGetBytesPerSample(wpc); bytes_per_sample = WavpackGetBytesPerSample(wpc);
outsamplesize = audio_format_frame_size(&audio_format); output_sample_size = bytes_per_sample;
if (output_sample_size == 3) {
output_sample_size = 4;
}
output_sample_size *= audio_format.channels;
/* wavpack gives us all kind of samples in a 32-bit space */ /* wavpack gives us all kind of samples in a 32-bit space */
samplesreq = sizeof(chunk) / (4 * audio_format.channels); samples_requested = sizeof(chunk) / (4 * audio_format.channels);
decoder_initialized(decoder, &audio_format, canseek, decoder_initialized(decoder, &audio_format, can_seek, total_time);
(float)allsamples / audio_format.sample_rate);
position = 0; position = 0;
do { do {
if (decoder_get_command(decoder) == DECODE_COMMAND_SEEK) { if (decoder_get_command(decoder) == DECODE_COMMAND_SEEK) {
if (canseek) { if (can_seek) {
int where; int where;
where = decoder_seek_where(decoder) * where = decoder_seek_where(decoder);
audio_format.sample_rate; where *= audio_format.sample_rate;
if (WavpackSeekSample(wpc, where)) { if (WavpackSeekSample(wpc, where)) {
position = where; position = where;
decoder_command_finished(decoder); decoder_command_finished(decoder);
@ -185,23 +193,29 @@ wavpack_decode(struct decoder * decoder, WavpackContext *wpc, bool canseek,
break; break;
} }
samplesgot = WavpackUnpackSamples(wpc, samples_got = WavpackUnpackSamples(
(int32_t *)chunk, samplesreq); wpc, (int32_t *)chunk, samples_requested
if (samplesgot > 0) { );
if (samples_got > 0) {
int bitrate = (int)(WavpackGetInstantBitrate(wpc) / int bitrate = (int)(WavpackGetInstantBitrate(wpc) /
1000 + 0.5); 1000 + 0.5);
position += samplesgot; position += samples_got;
file_time = (float)position / audio_format.sample_rate; current_time = position;
current_time /= audio_format.sample_rate;
format_samples(bytes_per_sample, chunk, format_samples(
samplesgot * audio_format.channels); bytes_per_sample, chunk,
samples_got * audio_format.channels
);
decoder_data(decoder, NULL, chunk, decoder_data(
samplesgot * outsamplesize, decoder, NULL, chunk,
file_time, bitrate, samples_got * output_sample_size,
replayGainInfo); current_time, bitrate,
replay_gain_info
);
} }
} while (samplesgot == samplesreq); } while (samples_got != samples_requested);
} }
/** /**
@ -230,17 +244,22 @@ wavpack_replaygain(WavpackContext *wpc)
replay_gain_info = replay_gain_info_new(); replay_gain_info = replay_gain_info_new();
found = wavpack_tag_float(wpc, "replaygain_track_gain", found |= wavpack_tag_float(
&replay_gain_info->tuples[REPLAY_GAIN_TRACK].gain) wpc, "replaygain_track_gain",
|| &replay_gain_info->tuples[REPLAY_GAIN_TRACK].gain
wavpack_tag_float(wpc, "replaygain_track_peak", );
&replay_gain_info->tuples[REPLAY_GAIN_TRACK].peak) found |= wavpack_tag_float(
|| wpc, "replaygain_track_peak",
wavpack_tag_float(wpc, "replaygain_album_gain", &replay_gain_info->tuples[REPLAY_GAIN_TRACK].peak
&replay_gain_info->tuples[REPLAY_GAIN_ALBUM].gain) );
|| found |= wavpack_tag_float(
wavpack_tag_float(wpc, "replaygain_album_peak", wpc, "replaygain_album_gain",
&replay_gain_info->tuples[REPLAY_GAIN_ALBUM].peak); &replay_gain_info->tuples[REPLAY_GAIN_ALBUM].gain
);
found |= wavpack_tag_float(
wpc, "replaygain_album_peak",
&replay_gain_info->tuples[REPLAY_GAIN_ALBUM].peak
);
if (found) { if (found) {
return replay_gain_info; return replay_gain_info;
@ -261,38 +280,39 @@ wavpack_tagdup(const char *fname)
struct tag *tag; struct tag *tag;
char error[ERRORLEN]; char error[ERRORLEN];
char *s; char *s;
int ssize; int size, allocated_size;
int j;
wpc = WavpackOpenFileInput(fname, error, OPEN_TAGS, 0); wpc = WavpackOpenFileInput(fname, error, OPEN_TAGS, 0);
if (wpc == NULL) { if (wpc == NULL) {
g_warning("failed to open WavPack file \"%s\": %s\n", g_warning(
fname, error); "failed to open WavPack file \"%s\": %s\n",
fname, error
);
return NULL; return NULL;
} }
tag = tag_new(); tag = tag_new();
tag->time = tag->time = WavpackGetNumSamples(wpc);
(float)WavpackGetNumSamples(wpc) / WavpackGetSampleRate(wpc); tag->time /= WavpackGetSampleRate(wpc);
ssize = 0; allocated_size = 0;
s = NULL; s = NULL;
for (unsigned i = 0; i < G_N_ELEMENTS(tagtypes); ++i) { for (unsigned i = 0; i < G_N_ELEMENTS(tagtypes); ++i) {
j = WavpackGetTagItem(wpc, tagtypes[i].name, NULL, 0); size = WavpackGetTagItem(wpc, tagtypes[i].name, NULL, 0);
if (j > 0) { if (size > 0) {
++j; ++size; /* EOS */
if (s == NULL) { if (s == NULL) {
s = g_malloc(j); s = g_malloc(size);
ssize = j; allocated_size = size;
} else if (j > ssize) { } else if (size > allocated_size) {
char *t = (char *)g_realloc(s, j); char *t = (char *)g_realloc(s, size);
ssize = j; allocated_size = size;
s = t; s = t;
} }
WavpackGetTagItem(wpc, tagtypes[i].name, s, j); WavpackGetTagItem(wpc, tagtypes[i].name, s, size);
tag_add_item(tag, tagtypes[i].type, s); tag_add_item(tag, tagtypes[i].type, s);
} }
} }
@ -342,8 +362,9 @@ wavpack_input_read_bytes(void *id, void *data, int32_t bcount)
/* wavpack fails if we return a partial read, so we just wait /* wavpack fails if we return a partial read, so we just wait
until the buffer is full */ until the buffer is full */
while (bcount > 0) { while (bcount > 0) {
size_t nbytes = decoder_read(wpin(id)->decoder, wpin(id)->is, size_t nbytes = decoder_read(
buf, bcount); wpin(id)->decoder, wpin(id)->is, buf, bcount
);
if (nbytes == 0) { if (nbytes == 0) {
/* EOF, error or a decoder command */ /* EOF, error or a decoder command */
break; break;
@ -450,8 +471,9 @@ wavpack_open_wvc(struct decoder *decoder, struct input_stream *is_wvc,
* And we try to buffer in order to get know * And we try to buffer in order to get know
* about a possible 404 error. * about a possible 404 error.
*/ */
nbytes = decoder_read(decoder, is_wvc, nbytes = decoder_read(
&first_byte, sizeof(first_byte)); decoder, is_wvc, &first_byte, sizeof(first_byte)
);
if (nbytes == 0) { if (nbytes == 0) {
input_stream_close(is_wvc); input_stream_close(is_wvc);
return false; return false;
@ -474,23 +496,24 @@ wavpack_streamdecode(struct decoder * decoder, struct input_stream *is)
struct input_stream is_wvc; struct input_stream is_wvc;
int open_flags = OPEN_2CH_MAX | OPEN_NORMALIZE /*| OPEN_STREAMING*/; int open_flags = OPEN_2CH_MAX | OPEN_NORMALIZE /*| OPEN_STREAMING*/;
struct wavpack_input isp, isp_wvc; struct wavpack_input isp, isp_wvc;
bool canseek = is->seekable; bool can_seek = is->seekable;
if (wavpack_open_wvc(decoder, &is_wvc, &isp_wvc)) { if (wavpack_open_wvc(decoder, &is_wvc, &isp_wvc)) {
open_flags |= OPEN_WVC; open_flags |= OPEN_WVC;
canseek &= is_wvc.seekable; can_seek &= is_wvc.seekable;
} }
wavpack_input_init(&isp, decoder, is); wavpack_input_init(&isp, decoder, is);
wpc = WavpackOpenFileInputEx(&mpd_is_reader, &isp, &isp_wvc, error, wpc = WavpackOpenFileInputEx(
open_flags, 23); &mpd_is_reader, &isp, &isp_wvc, error, open_flags, 23
);
if (wpc == NULL) { if (wpc == NULL) {
g_warning("failed to open WavPack stream: %s\n", error); g_warning("failed to open WavPack stream: %s\n", error);
return; return;
} }
wavpack_decode(decoder, wpc, canseek, NULL); wavpack_decode(decoder, wpc, can_seek, NULL);
WavpackCloseFile(wpc); WavpackCloseFile(wpc);
if (open_flags & OPEN_WVC) { if (open_flags & OPEN_WVC) {
@ -508,12 +531,15 @@ wavpack_filedecode(struct decoder *decoder, const char *fname)
WavpackContext *wpc; WavpackContext *wpc;
struct replay_gain_info *replay_gain_info; struct replay_gain_info *replay_gain_info;
wpc = WavpackOpenFileInput(fname, error, wpc = WavpackOpenFileInput(
OPEN_TAGS | OPEN_WVC | fname, error,
OPEN_2CH_MAX | OPEN_NORMALIZE, 23); OPEN_TAGS | OPEN_WVC | OPEN_2CH_MAX | OPEN_NORMALIZE, 23
);
if (wpc == NULL) { if (wpc == NULL) {
g_warning("failed to open WavPack file \"%s\": %s\n", g_warning(
fname, error); "failed to open WavPack file \"%s\": %s\n",
fname, error
);
return; return;
} }
@ -528,8 +554,15 @@ wavpack_filedecode(struct decoder *decoder, const char *fname)
WavpackCloseFile(wpc); WavpackCloseFile(wpc);
} }
static char const *const wavpack_suffixes[] = { "wv", NULL }; static char const *const wavpack_suffixes[] = {
static char const *const wavpack_mime_types[] = { "audio/x-wavpack", NULL }; "wv",
NULL
};
static char const *const wavpack_mime_types[] = {
"audio/x-wavpack",
NULL
};
const struct decoder_plugin wavpack_plugin = { const struct decoder_plugin wavpack_plugin = {
.name = "wavpack", .name = "wavpack",