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

replay_gain: no CamelCase

Browse Source 
Renamed functions and variables.
This commit is contained in:
Max Kellermann 2008-11-11 15:55:34 +01:00
parent 54ad08ab37
commit 114b3c1e78
13 changed files with 119 additions and 111 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/decoder/_flac_common.c
View File

@ -70,21 +70,21 @@ static void flacParseReplayGain(const FLAC__StreamMetadata * block,
int found = 0;
if (data->replayGainInfo)
freeReplayGainInfo(data->replayGainInfo);
replay_gain_info_free(data->replayGainInfo);
data->replayGainInfo = newReplayGainInfo();
data->replayGainInfo = replay_gain_info_new();
found |= flacFindVorbisCommentFloat(block, "replaygain_album_gain",
&data->replayGainInfo->albumGain);
&data->replayGainInfo->album_gain);
found |= flacFindVorbisCommentFloat(block, "replaygain_album_peak",
&data->replayGainInfo->albumPeak);
&data->replayGainInfo->album_peak);
found |= flacFindVorbisCommentFloat(block, "replaygain_track_gain",
&data->replayGainInfo->trackGain);
&data->replayGainInfo->track_gain);
found |= flacFindVorbisCommentFloat(block, "replaygain_track_peak",
&data->replayGainInfo->trackPeak);
&data->replayGainInfo->track_peak);
if (!found) {
freeReplayGainInfo(data->replayGainInfo);
replay_gain_info_free(data->replayGainInfo);
data->replayGainInfo = NULL;
}
}

2
src/decoder/_flac_common.h
View File

@ -145,7 +145,7 @@ typedef struct {
FLAC__uint64 position;
struct decoder *decoder;
struct input_stream *inStream;
ReplayGainInfo *replayGainInfo;
struct replay_gain_info *replayGainInfo;
struct tag *tag;
} FlacData;

2
src/decoder/flac_plugin.c
View File

@ -368,7 +368,7 @@ flac_decode_internal(struct decoder * decoder, struct input_stream *inStream,
fail:
if (data.replayGainInfo)
freeReplayGainInfo(data.replayGainInfo);
replay_gain_info_free(data.replayGainInfo);
if (flacDec)
flac_delete(flacDec);

47
src/decoder/mp3_plugin.c
View File

@ -204,16 +204,17 @@ mp3_fill_buffer(struct mp3_data *data)
}
#ifdef HAVE_ID3TAG
static ReplayGainInfo *parse_id3_replay_gain_info(struct id3_tag *tag)
static struct replay_gain_info *
parse_id3_replay_gain_info(struct id3_tag *tag)
{
int i;
char *key;
char *value;
struct id3_frame *frame;
bool found = false;
ReplayGainInfo *replay_gain_info;
struct replay_gain_info *replay_gain_info;
replay_gain_info = newReplayGainInfo();
replay_gain_info = replay_gain_info_new();
for (i = 0; (frame = id3_tag_findframe(tag, "TXXX", i)); i++) {
if (frame->nfields < 3)
@ -227,16 +228,16 @@ static ReplayGainInfo *parse_id3_replay_gain_info(struct id3_tag *tag)
(&frame->fields[2]));
if (strcasecmp(key, "replaygain_track_gain") == 0) {
replay_gain_info->trackGain = atof(value);
replay_gain_info->track_gain = atof(value);
found = true;
} else if (strcasecmp(key, "replaygain_album_gain") == 0) {
replay_gain_info->albumGain = atof(value);
replay_gain_info->album_gain = atof(value);
found = true;
} else if (strcasecmp(key, "replaygain_track_peak") == 0) {
replay_gain_info->trackPeak = atof(value);
replay_gain_info->track_peak = atof(value);
found = true;
} else if (strcasecmp(key, "replaygain_album_peak") == 0) {
replay_gain_info->albumPeak = atof(value);
replay_gain_info->album_peak = atof(value);
found = true;
}
@ -246,7 +247,7 @@ static ReplayGainInfo *parse_id3_replay_gain_info(struct id3_tag *tag)
if (found)
return replay_gain_info;
freeReplayGainInfo(replay_gain_info);
replay_gain_info_free(replay_gain_info);
return NULL;
}
#endif
@ -254,7 +255,7 @@ static ReplayGainInfo *parse_id3_replay_gain_info(struct id3_tag *tag)
#ifdef HAVE_ID3TAG
static void mp3_parse_id3(struct mp3_data *data, size_t tagsize,
struct tag **mpd_tag,
ReplayGainInfo **replay_gain_info_r)
struct replay_gain_info **replay_gain_info_r)
{
struct id3_tag *id3_tag = NULL;
id3_length_t count;
@ -307,10 +308,11 @@ static void mp3_parse_id3(struct mp3_data *data, size_t tagsize,
}
if (replay_gain_info_r) {
ReplayGainInfo *tmp_rgi = parse_id3_replay_gain_info(id3_tag);
struct replay_gain_info *tmp_rgi =
parse_id3_replay_gain_info(id3_tag);
if (tmp_rgi != NULL) {
if (*replay_gain_info_r)
freeReplayGainInfo(*replay_gain_info_r);
replay_gain_info_free(*replay_gain_info_r);
*replay_gain_info_r = tmp_rgi;
}
}
@ -323,7 +325,7 @@ static void mp3_parse_id3(struct mp3_data *data, size_t tagsize,
static enum mp3_action
decode_next_frame_header(struct mp3_data *data, struct tag **tag,
ReplayGainInfo **replay_gain_info_r)
struct replay_gain_info **replay_gain_info_r)
{
enum mad_layer layer;
@ -698,7 +700,7 @@ mp3_filesize_to_song_length(struct mp3_data *data)
static bool
mp3_decode_first_frame(struct mp3_data *data, struct tag **tag,
ReplayGainInfo **replay_gain_info_r)
struct replay_gain_info **replay_gain_info_r)
{
struct decoder *decoder = data->decoder;
struct xing xing;
@ -758,9 +760,9 @@ mp3_decode_first_frame(struct mp3_data *data, struct tag **tag,
* parse_lame() for details. -- jat */
if (replay_gain_info_r && !*replay_gain_info_r &&
lame.track_gain) {
*replay_gain_info_r = newReplayGainInfo();
(*replay_gain_info_r)->trackGain = lame.track_gain;
(*replay_gain_info_r)->trackPeak = lame.peak;
*replay_gain_info_r = replay_gain_info_new();
(*replay_gain_info_r)->track_gain = lame.track_gain;
(*replay_gain_info_r)->track_peak = lame.peak;
}
}
}
@ -813,7 +815,7 @@ static int mp3_total_file_time(const char *file)
static bool
mp3_open(struct input_stream *is, struct mp3_data *data,
struct decoder *decoder, struct tag **tag,
ReplayGainInfo **replay_gain_info_r)
struct replay_gain_info **replay_gain_info_r)
{
mp3_data_init(data, decoder, is);
*tag = NULL;
@ -877,7 +879,7 @@ mp3_update_timer_next_frame(struct mp3_data *data)
*/
static enum decoder_command
mp3_send_pcm(struct mp3_data *data, unsigned i, unsigned pcm_length,
ReplayGainInfo *replay_gain_info)
struct replay_gain_info *replay_gain_info)
{
unsigned max_samples;
@ -916,7 +918,8 @@ mp3_send_pcm(struct mp3_data *data, unsigned i, unsigned pcm_length,
* Synthesize the current frame and send it via decoder_data().
*/
static enum decoder_command
mp3_synth_and_send(struct mp3_data *data, ReplayGainInfo *replay_gain_info)
mp3_synth_and_send(struct mp3_data *data,
struct replay_gain_info *replay_gain_info)
{
unsigned i, pcm_length;
enum decoder_command cmd;
@ -971,7 +974,7 @@ mp3_synth_and_send(struct mp3_data *data, ReplayGainInfo *replay_gain_info)
}
static bool
mp3_read(struct mp3_data *data, ReplayGainInfo **replay_gain_info_r)
mp3_read(struct mp3_data *data, struct replay_gain_info **replay_gain_info_r)
{
struct decoder *decoder = data->decoder;
int ret;
@ -1052,7 +1055,7 @@ mp3_decode(struct decoder *decoder, struct input_stream *input_stream)
{
struct mp3_data data;
struct tag *tag = NULL;
ReplayGainInfo *replay_gain_info = NULL;
struct replay_gain_info *replay_gain_info = NULL;
struct audio_format audio_format;
if (!mp3_open(input_stream, &data, decoder, &tag, &replay_gain_info)) {
@ -1077,7 +1080,7 @@ mp3_decode(struct decoder *decoder, struct input_stream *input_stream)
while (mp3_read(&data, &replay_gain_info)) ;
if (replay_gain_info)
freeReplayGainInfo(replay_gain_info);
replay_gain_info_free(replay_gain_info);
if (decoder_get_command(decoder) == DECODE_COMMAND_SEEK &&
data.mute_frame == MUTEFRAME_SEEK)

14
src/decoder/mpc_plugin.c
View File

@ -120,7 +120,7 @@ mpc_decode(struct decoder *mpd_decoder, struct input_stream *inStream)
mpc_uint32_t vbrUpdateBits;
float total_time;
int i;
ReplayGainInfo *replayGainInfo = NULL;
struct replay_gain_info *replayGainInfo = NULL;
data.inStream = inStream;
data.decoder = mpd_decoder;
@ -156,11 +156,11 @@ mpc_decode(struct decoder *mpd_decoder, struct input_stream *inStream)
audio_format.channels = info.channels;
audio_format.sample_rate = info.sample_freq;
replayGainInfo = newReplayGainInfo();
replayGainInfo->albumGain = info.gain_album * 0.01;
replayGainInfo->albumPeak = info.peak_album / 32767.0;
replayGainInfo->trackGain = info.gain_title * 0.01;
replayGainInfo->trackPeak = info.peak_title / 32767.0;
replayGainInfo = replay_gain_info_new();
replayGainInfo->album_gain = info.gain_album * 0.01;
replayGainInfo->album_peak = info.peak_album / 32767.0;
replayGainInfo->track_gain = info.gain_title * 0.01;
replayGainInfo->track_peak = info.peak_title / 32767.0;
decoder_initialized(mpd_decoder, &audio_format,
inStream->seekable,
@ -231,7 +231,7 @@ mpc_decode(struct decoder *mpd_decoder, struct input_stream *inStream)
replayGainInfo);
}
freeReplayGainInfo(replayGainInfo);
replay_gain_info_free(replayGainInfo);
return true;
}

2
src/decoder/oggflac_plugin.c
View File

@ -31,7 +31,7 @@ static void oggflac_cleanup(FlacData * data,
OggFLAC__SeekableStreamDecoder * decoder)
{
if (data->replayGainInfo)
freeReplayGainInfo(data->replayGainInfo);
replay_gain_info_free(data->replayGainInfo);
if (decoder)
OggFLAC__seekable_stream_decoder_delete(decoder);
}

22
src/decoder/oggvorbis_plugin.c
View File

@ -93,31 +93,33 @@ static const char *ogg_parseComment(const char *comment, const char *needle)
return NULL;
}
static void ogg_getReplayGainInfo(char **comments, ReplayGainInfo ** infoPtr)
static void
ogg_getReplayGainInfo(char **comments,
struct replay_gain_info **infoPtr)
{
const char *temp;
bool found = false;
if (*infoPtr)
freeReplayGainInfo(*infoPtr);
*infoPtr = newReplayGainInfo();
replay_gain_info_free(*infoPtr);
*infoPtr = replay_gain_info_new();
while (*comments) {
if ((temp =
ogg_parseComment(*comments, "replaygain_track_gain"))) {
(*infoPtr)->trackGain = atof(temp);
(*infoPtr)->track_gain = atof(temp);
found = true;
} else if ((temp = ogg_parseComment(*comments,
"replaygain_album_gain"))) {
(*infoPtr)->albumGain = atof(temp);
(*infoPtr)->album_gain = atof(temp);
found = true;
} else if ((temp = ogg_parseComment(*comments,
"replaygain_track_peak"))) {
(*infoPtr)->trackPeak = atof(temp);
(*infoPtr)->track_peak = atof(temp);
found = true;
} else if ((temp = ogg_parseComment(*comments,
"replaygain_album_peak"))) {
(*infoPtr)->albumPeak = atof(temp);
(*infoPtr)->album_peak = atof(temp);
found = true;
}
@ -125,7 +127,7 @@ static void ogg_getReplayGainInfo(char **comments, ReplayGainInfo ** infoPtr)
}
if (!found) {
freeReplayGainInfo(*infoPtr);
replay_gain_info_free(*infoPtr);
*infoPtr = NULL;
}
}
@ -209,7 +211,7 @@ oggvorbis_decode(struct decoder *decoder, struct input_stream *inStream)
int chunkpos = 0;
long bitRate = 0;
long test;
ReplayGainInfo *replayGainInfo = NULL;
struct replay_gain_info *replayGainInfo = NULL;
char **comments;
const char *errorStr;
bool initialized = false;
@ -324,7 +326,7 @@ oggvorbis_decode(struct decoder *decoder, struct input_stream *inStream)
}
if (replayGainInfo)
freeReplayGainInfo(replayGainInfo);
replay_gain_info_free(replayGainInfo);
ov_clear(&vf);
return true;

22
src/decoder/wavpack_plugin.c
View File

@ -121,7 +121,7 @@ format_samples_float(mpd_unused int bytes_per_sample, void *buffer,
*/
static void
wavpack_decode(struct decoder * decoder, WavpackContext *wpc, bool canseek,
ReplayGainInfo *replayGainInfo)
struct replay_gain_info *replayGainInfo)
{
struct audio_format audio_format;
void (*format_samples)(int bytes_per_sample,
@ -229,43 +229,43 @@ wavpack_tag(WavpackContext *wpc, char *key)
return value;
}
static ReplayGainInfo *
static struct replay_gain_info *
wavpack_replaygain(WavpackContext *wpc)
{
static char replaygain_track_gain[] = "replaygain_track_gain";
static char replaygain_album_gain[] = "replaygain_album_gain";
static char replaygain_track_peak[] = "replaygain_track_peak";
static char replaygain_album_peak[] = "replaygain_album_peak";
ReplayGainInfo *replay_gain_info;
struct replay_gain_info *replay_gain_info;
bool found = false;
char *value;
replay_gain_info = newReplayGainInfo();
replay_gain_info = replay_gain_info_new();
value = wavpack_tag(wpc, replaygain_track_gain);
if (value) {
replay_gain_info->trackGain = atof(value);
replay_gain_info->track_gain = atof(value);
free(value);
found = true;
}
value = wavpack_tag(wpc, replaygain_album_gain);
if (value) {
replay_gain_info->albumGain = atof(value);
replay_gain_info->album_gain = atof(value);
free(value);
found = true;
}
value = wavpack_tag(wpc, replaygain_track_peak);
if (value) {
replay_gain_info->trackPeak = atof(value);
replay_gain_info->track_peak = atof(value);
free(value);
found = true;
}
value = wavpack_tag(wpc, replaygain_album_peak);
if (value) {
replay_gain_info->albumPeak = atof(value);
replay_gain_info->album_peak = atof(value);
free(value);
found = true;
}
@ -275,7 +275,7 @@ wavpack_replaygain(WavpackContext *wpc)
return replay_gain_info;
}
freeReplayGainInfo(replay_gain_info);
replay_gain_info_free(replay_gain_info);
return NULL;
}
@ -537,7 +537,7 @@ wavpack_filedecode(struct decoder *decoder, const char *fname)
{
char error[ERRORLEN];
WavpackContext *wpc;
ReplayGainInfo *replay_gain_info;
struct replay_gain_info *replay_gain_info;
wpc = WavpackOpenFileInput(fname, error,
OPEN_TAGS | OPEN_WVC |
@ -553,7 +553,7 @@ wavpack_filedecode(struct decoder *decoder, const char *fname)
wavpack_decode(decoder, wpc, true, replay_gain_info);
if (replay_gain_info) {
freeReplayGainInfo(replay_gain_info);
replay_gain_info_free(replay_gain_info);
}
WavpackCloseFile(wpc);

6
src/decoder_api.c
View File

@ -175,7 +175,7 @@ decoder_data(struct decoder *decoder,
struct input_stream *is,
void *_data, size_t length,
float data_time, uint16_t bitRate,
ReplayGainInfo *replay_gain_info)
struct replay_gain_info *replay_gain_info)
{
static char *conv_buffer;
static size_t conv_buffer_size;
@ -234,8 +234,8 @@ decoder_data(struct decoder *decoder,
data, &decoder->conv_state);
}
if (replay_gain_info != NULL && (replayGainState != REPLAYGAIN_OFF))
doReplayGain(replay_gain_info, data, length,
if (replay_gain_info != NULL && (replay_gain_mode != REPLAY_GAIN_OFF))
replay_gain_apply(replay_gain_info, data, length,
&dc.out_audio_format);
else if (normalizationEnabled)
normalizeData(data, length, &dc.out_audio_format);

2
src/decoder_api.h
View File

@ -143,7 +143,7 @@ enum decoder_command
decoder_data(struct decoder *decoder,
struct input_stream *inStream,
void *data, size_t datalen, float data_time, uint16_t bitRate,
ReplayGainInfo * replayGainInfo);
struct replay_gain_info *replay_gain_info);
/**
* This function is called by the decoder plugin when it has

2
src/main.c
View File

@ -429,7 +429,7 @@ int main(int argc, char *argv[])
initAudioDriver();
initVolume();
client_manager_init();
initReplayGainState();
replay_gain_global_init();
initNormalization();
input_stream_global_init();

61
src/replay_gain.c
View File

@ -26,11 +26,11 @@
#include "os_compat.h"
/* Added 4/14/2004 by AliasMrJones */
int replayGainState = REPLAYGAIN_OFF;
int replay_gain_mode = REPLAY_GAIN_OFF;
static float replayGainPreamp = 1.0;
static float replay_gain_preamp = 1.0;
void initReplayGainState(void)
void replay_gain_global_init(void)
{
ConfigParam *param = getConfigParam(CONF_REPLAYGAIN);
@ -38,9 +38,9 @@ void initReplayGainState(void)
return;
if (strcmp(param->value, "track") == 0) {
replayGainState = REPLAYGAIN_TRACK;
replay_gain_mode = REPLAY_GAIN_TRACK;
} else if (strcmp(param->value, "album") == 0) {
replayGainState = REPLAYGAIN_ALBUM;
replay_gain_mode = REPLAY_GAIN_ALBUM;
} else {
FATAL("replaygain value \"%s\" at line %i is invalid\n",
param->value, param->line);
@ -62,18 +62,18 @@ void initReplayGainState(void)
"15 at line %i\n", param->value, param->line);
}
replayGainPreamp = pow(10, f / 20.0);
replay_gain_preamp = pow(10, f / 20.0);
}
}
static float computeReplayGainScale(float gain, float peak)
static float calc_replay_gain_scale(float gain, float peak)
{
float scale;
if (gain == 0.0)
return (1);
scale = pow(10.0, gain / 20.0);
scale *= replayGainPreamp;
scale *= replay_gain_preamp;
if (scale > 15.0)
scale = 15.0;
@ -83,28 +83,29 @@ static float computeReplayGainScale(float gain, float peak)
return (scale);
}
ReplayGainInfo *newReplayGainInfo(void)
struct replay_gain_info *replay_gain_info_new(void)
{
ReplayGainInfo *ret = xmalloc(sizeof(ReplayGainInfo));
struct replay_gain_info *ret = xmalloc(sizeof(*ret));
ret->albumGain = 0.0;
ret->albumPeak = 0.0;
ret->album_gain = 0.0;
ret->album_peak = 0.0;
ret->trackGain = 0.0;
ret->trackPeak = 0.0;
ret->track_gain = 0.0;
ret->track_peak = 0.0;
/* set to -1 so that we know in doReplayGain to compute the scale */
/* set to -1 so that we know in replay_gain_apply to compute the scale */
ret->scale = -1.0;
return ret;
}
void freeReplayGainInfo(ReplayGainInfo * info)
void replay_gain_info_free(struct replay_gain_info *info)
{
free(info);
}
void doReplayGain(ReplayGainInfo * info, char *buffer, int bufferSize,
void
replay_gain_apply(struct replay_gain_info *info, char *buffer, int size,
const struct audio_format *format)
{
int16_t *buffer16;
@ -112,22 +113,22 @@ void doReplayGain(ReplayGainInfo * info, char *buffer, int bufferSize,
int32_t temp32;
float scale;
if (replayGainState == REPLAYGAIN_OFF || !info)
if (replay_gain_mode == REPLAY_GAIN_OFF || !info)
return;
if (info->scale < 0) {
switch (replayGainState) {
case REPLAYGAIN_TRACK:
switch (replay_gain_mode) {
case REPLAY_GAIN_TRACK:
DEBUG("computing ReplayGain track scale with gain %f, "
"peak %f\n", info->trackGain, info->trackPeak);
info->scale = computeReplayGainScale(info->trackGain,
info->trackPeak);
"peak %f\n", info->track_gain, info->track_peak);
info->scale = calc_replay_gain_scale(info->track_gain,
info->track_peak);
break;
default:
DEBUG("computing ReplayGain album scale with gain %f, "
"peak %f\n", info->albumGain, info->albumPeak);
info->scale = computeReplayGainScale(info->albumGain,
info->albumPeak);
"peak %f\n", info->album_gain, info->album_peak);
info->scale = calc_replay_gain_scale(info->album_gain,
info->album_peak);
break;
}
}
@ -142,23 +143,23 @@ void doReplayGain(ReplayGainInfo * info, char *buffer, int bufferSize,
switch (format->bits) {
case 16:
while (bufferSize > 0) {
while (size > 0) {
temp32 = *buffer16;
temp32 *= scale;
*buffer16 = temp32 > 32767 ? 32767 :
(temp32 < -32768 ? -32768 : temp32);
buffer16++;
bufferSize -= 2;
size -= 2;
}
break;
case 8:
while (bufferSize > 0) {
while (size > 0) {
temp32 = *buffer8;
temp32 *= scale;
*buffer8 = temp32 > 127 ? 127 :
(temp32 < -128 ? -128 : temp32);
buffer8++;
bufferSize--;
size--;
}
break;
default:

34
src/replay_gain.h
View File

@ -17,34 +17,36 @@
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef MPD_REPLAYGAIN_H
#define MPD_REPLAYGAIN_H
#ifndef MPD_REPLAY_GAIN_H
#define MPD_REPLAY_GAIN_H
#define REPLAYGAIN_OFF 0
#define REPLAYGAIN_TRACK 1
#define REPLAYGAIN_ALBUM 2
#define REPLAY_GAIN_OFF 0
#define REPLAY_GAIN_TRACK 1
#define REPLAY_GAIN_ALBUM 2
struct audio_format;
extern int replayGainState;
extern int replay_gain_mode;
typedef struct _ReplayGainInfo {
float albumGain;
float albumPeak;
float trackGain;
float trackPeak;
struct replay_gain_info {
float album_gain;
float album_peak;
float track_gain;
float track_peak;
/* used internally by mpd, to mess with it */
float scale;
} ReplayGainInfo;
};
ReplayGainInfo *newReplayGainInfo(void);
struct replay_gain_info *
replay_gain_info_new(void);
void freeReplayGainInfo(ReplayGainInfo * info);
void replay_gain_info_free(struct replay_gain_info *info);
void initReplayGainState(void);
void replay_gain_global_init(void);
void doReplayGain(ReplayGainInfo * info, char *buffer, int bufferSize,
void
replay_gain_apply(struct replay_gain_info *info, char *buffer, int bufferSize,
const struct audio_format *format);
#endif