/*************************************************************************** * __________ __ ___. * Open \______ \ ____ ____ | | _\_ |__ _______ ___ * Source | _// _ \_/ ___\| |/ /| __ \ / _ \ \/ / * Jukebox | | ( <_> ) \___| < | \_\ ( <_> > < < * Firmware |____|_ /\____/ \___ >__|_ \|___ /\____/__/\_ \ * \/ \/ \/ \/ \/ * * Copyright (C) 2005 by Linus Nielsen Feltzing * Copyright (C) 2007 by Christian Gmeiner * Copyright (C) 2013 by Michael Sevakis * * This program 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. * * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY * KIND, either express or implied. * ****************************************************************************/ /* Indicate it's the sound.c file which affects compilation of audiohw.h */ #define AUDIOHW_IS_SOUND_C #include "config.h" #include "system.h" #include "sound.h" #ifndef BOOTLOADER #include "settings.h" /* sound_current */ #endif /* Define sound_setting_entries table */ #define AUDIOHW_SOUND_SETTINGS_ENTRIES #include "audiohw_settings.h" /* Implements sound_val2phys */ #define AUDIOHW_SOUND_SETTINGS_VAL2PHYS #include "audiohw_settings.h" /* Returns current sound settings from global_settings */ #define SOUND_CUR_SET(name, var) \ case SOUND_##name: return var; extern bool audio_is_initialized; static const struct sound_setting_entry * get_setting_entry(int setting) { static const struct sound_settings_info default_info = { "", 0, 0, 0, 0, 0 }; static const struct sound_setting_entry default_entry = { &default_info, NULL }; if ((unsigned)setting >= ARRAYLEN(sound_setting_entries)) return &default_entry; const struct sound_setting_entry *e = &sound_setting_entries[setting]; return e->info ? e : &default_entry; /* setting valid but not in table? */ } static const struct sound_settings_info * get_settings_info(int setting) { return get_setting_entry(setting)->info; } const char * sound_unit(int setting) { return get_settings_info(setting)->unit; } int sound_numdecimals(int setting) { return get_settings_info(setting)->numdecimals; } int sound_steps(int setting) { return get_settings_info(setting)->steps; } int sound_min(int setting) { return get_settings_info(setting)->minval; } int sound_max(int setting) { return get_settings_info(setting)->maxval; } int sound_default(int setting) { return get_settings_info(setting)->defaultval; } sound_set_type * sound_get_fn(int setting) { return get_setting_entry(setting)->function; } void sound_set(int setting, int value) { sound_set_type *sound_set_val = sound_get_fn(setting); if (sound_set_val) sound_set_val(value); } int sound_current(int setting) { switch(setting) { #ifndef BOOTLOADER #ifndef PLATFORM_HAS_VOLUME_CHANGE SOUND_CUR_SET(VOLUME, global_status.volume) #endif #if defined(AUDIOHW_HAVE_BASS) SOUND_CUR_SET(BASS, global_settings.bass) #endif #if defined(AUDIOHW_HAVE_TREBLE) SOUND_CUR_SET(TREBLE, global_settings.treble) #endif SOUND_CUR_SET(BALANCE, global_settings.balance) SOUND_CUR_SET(CHANNELS, global_settings.channel_config) SOUND_CUR_SET(STEREO_WIDTH, global_settings.stereo_width) #if defined(AUDIOHW_HAVE_BASS_CUTOFF) SOUND_CUR_SET(BASS_CUTOFF, global_settings.bass_cutoff) #endif #if defined(AUDIOHW_HAVE_TREBLE_CUTOFF) SOUND_CUR_SET(TREBLE_CUTOFF, global_settings.treble_cutoff) #endif #if defined(AUDIOHW_HAVE_DEPTH_3D) SOUND_CUR_SET(DEPTH_3D, global_settings.depth_3d) #endif #if defined(AUDIOHW_HAVE_FILTER_ROLL_OFF) SOUND_CUR_SET(FILTER_ROLL_OFF, global_settings.roll_off) #endif #if defined(AUDIOHW_HAVE_POWER_MODE) SOUND_CUR_SET(POWER_MODE, global_settings.power_mode) #endif #if 0 /*WRONG -- these need to index the hw_eq_bands[AUDIOHW_EQ_BAND_NUM] struct*/ /* Hardware EQ tone controls */ #if defined(AUDIOHW_HAVE_EQ) SOUND_CUR_SET(EQ_BAND1_GAIN, global_settings.hw_eq_band1_gain) #if defined(AUDIOHW_HAVE_EQ_BAND1_FREQUENCY) SOUND_CUR_SET(EQ_BAND1_FREQUENCY, global_settings.hw_eq_band1_frequency) #endif #if defined(AUDIOHW_HAVE_EQ_BAND2) SOUND_CUR_SET(EQ_BAND2_GAIN, global_settings.hw_eq_band2_gain) #if defined(AUDIOHW_HAVE_EQ_BAND2_FREQUENCY) SOUND_CUR_SET(EQ_BAND2_FREQUENCY, global_settings.hw_eq_band2_frequency) #endif #if defined(AUDIOHW_HAVE_EQ_BAND2_WIDTH) SOUND_CUR_SET(EQ_BAND2_WIDTH, global_settings.hw_eq_band2_width) #endif #endif /* AUDIOHW_HAVE_EQ_BAND2 */ #if defined(AUDIOHW_HAVE_EQ_BAND3) SOUND_CUR_SET(EQ_BAND3_GAIN, global_settings.hw_eq_band3_gain) #if defined(AUDIOHW_HAVE_EQ_BAND3_FREQUENCY) SOUND_CUR_SET(EQ_BAND3_FREQUENCY, global_settings.hw_eq_band3_frequency) #endif #if defined(AUDIOHW_HAVE_EQ_BAND3_WIDTH) SOUND_CUR_SET(EQ_BAND3_WIDTH, global_settings.hw_eq_band3_width) #endif #endif /* AUDIOHW_HAVE_EQ_BAND3 */ #if defined(AUDIOHW_HAVE_EQ_BAND4) SOUND_CUR_SET(EQ_BAND4_GAIN, global_settings.hw_eq_band4_gain) #if defined(AUDIOHW_HAVE_EQ_BAND4_FREQUENCY) SOUND_CUR_SET(EQ_BAND4_FREQUENCY, global_settings.hw_eq_band4_frequency) #endif #if defined(AUDIOHW_HAVE_EQ_BAND4_WIDTH) SOUND_CUR_SET(EQ_BAND4_WIDTH, global_settings.hw_eq_band4_width) #endif #endif /* AUDIOHW_HAVE_EQ_BAND4 */ #if defined(AUDIOHW_HAVE_EQ_BAND5) SOUND_CUR_SET(EQ_BAND5_GAIN, global_settings.hw_eq_band5_gain) #if defined(AUDIOHW_HAVE_EQ_BAND5_FREQUENCY) SOUND_CUR_SET(EQ_BAND5_FREQUENCY, global_settings.hw_eq_band5_frequency) #endif #endif /* AUDIOHW_HAVE_EQ_BAND5 */ #endif /* AUDIOHW_HAVE_EQ */ #endif /*IF 0*/ #endif /*ndef BOOTLOADER*/ #ifdef INT_MIN default: return INT_MIN; #else default: return -32768; #endif } /* switch(setting) */ }/* sound_current */ #if !defined(AUDIOHW_HAVE_CLIPPING) /* * The prescaler compensates for any kind of boosts, to prevent clipping. * * It's basically just a measure to make sure that audio does not clip during * tone controls processing, like if i want to boost bass 12 dB, i can decrease * the audio amplitude by -12 dB before processing, then increase master gain * by 12 dB after processing. */ /* Return the sound value scaled to centibels (tenth-decibels) */ static int sound_value_to_cb(int setting, int value) { int shift = 1 - sound_numdecimals(setting); if (shift < 0) do { value /= 10; } while (++shift); if (shift > 0) do { value *= 10; } while (--shift); return value; } static struct { int volume; /* tenth dB */ int balance; /* percent */ #if defined(AUDIOHW_HAVE_BASS) int bass; /* tenth dB */ #endif #if defined(AUDIOHW_HAVE_TREBLE) int treble; /* tenth dB */ #endif #if defined(AUDIOHW_HAVE_EQ) int eq_gain[AUDIOHW_EQ_BAND_NUM]; /* tenth dB */ #endif } sound_prescaler; #if defined(AUDIOHW_HAVE_BASS) || defined (AUDIOHW_HAVE_TREBLE) \ || defined(AUDIOHW_HAVE_EQ) #define TONE_PRESCALER #endif static void set_prescaled_volume(void) { #if defined(TONE_PRESCALER) || !defined(AUDIOHW_HAVE_MONO_VOLUME) const int minvol = sound_value_to_cb(SOUND_VOLUME, sound_min(SOUND_VOLUME)); #endif int volume = sound_prescaler.volume; #if defined(TONE_PRESCALER) int prescale = 0; /* Note: Having Tone + EQ isn't prohibited */ #if defined(AUDIOHW_HAVE_BASS) && defined(AUDIOHW_HAVE_TREBLE) prescale = MAX(sound_prescaler.bass, sound_prescaler.treble); #endif #if defined(AUDIOHW_HAVE_EQ) for (int i = 0; i < AUDIOHW_EQ_BAND_NUM; i++) prescale = MAX(sound_prescaler.eq_gain[i], prescale); #endif if (prescale < 0) prescale = 0; /* no need to prescale if we don't boost bass, treble or eq band */ /* Gain up the analog volume to compensate the prescale gain reduction, * but if this would push the volume over the top, reduce prescaling * instead (might cause clipping). */ const int maxvol = sound_value_to_cb(SOUND_VOLUME, sound_max(SOUND_VOLUME)); if (volume + prescale > maxvol) prescale = maxvol - volume; audiohw_set_prescaler(prescale); if (volume <= minvol) prescale = 0; /* Make sure the audio gets muted */ #ifndef AUDIOHW_HAVE_MONO_VOLUME /* At the moment, such targets have lousy volume resolution and so minute boost won't work how we'd like */ volume += prescale; #endif #endif /* TONE_PRESCALER */ #if defined(AUDIOHW_HAVE_MONO_VOLUME) audiohw_set_volume(volume); #else /* Stereo volume */ int l = volume, r = volume; /* Balance the channels scaled by the current volume and min volume */ int balance = sound_prescaler.balance; /* percent */ if (balance > 0) { l -= (l - minvol) * balance / 100; } else if (balance < 0) { r += (r - minvol) * balance / 100; } audiohw_set_volume(l, r); #endif /* AUDIOHW_HAVE_MONO_VOLUME */ #if defined(AUDIOHW_HAVE_LINEOUT) /* For now, lineout stays at unity */ audiohw_set_lineout_volume(0, 0); #endif /* AUDIOHW_HAVE_LINEOUT */ } #endif /* AUDIOIHW_HAVE_CLIPPING */ void sound_set_volume(int value) { if (!audio_is_initialized) return; #ifndef BOOTLOADER /* Apply limits */ const int min_vol = sound_min(SOUND_VOLUME); const int max_vol = sound_max(SOUND_VOLUME); if (value < min_vol) value = min_vol; if (value > max_vol) value = max_vol; if (value > global_settings.volume_limit) value = global_settings.volume_limit; global_status.volume = value; #endif #if defined(AUDIOHW_HAVE_CLIPPING) audiohw_set_volume(value); #else sound_prescaler.volume = sound_value_to_cb(SOUND_VOLUME, value); set_prescaled_volume(); #endif } void sound_set_balance(int value) { if (!audio_is_initialized) return; #if defined(AUDIOHW_HAVE_BALANCE) audiohw_set_balance(value); #else sound_prescaler.balance = value; set_prescaled_volume(); #endif } #if defined(AUDIOHW_HAVE_BASS) void sound_set_bass(int value) { if (!audio_is_initialized) return; audiohw_set_bass(value); #if !defined(AUDIOHW_HAVE_CLIPPING) sound_prescaler.bass = sound_value_to_cb(SOUND_BASS, value); set_prescaled_volume(); #endif } #endif /* AUDIOHW_HAVE_BASS */ #if defined(AUDIOHW_HAVE_TREBLE) void sound_set_treble(int value) { if (!audio_is_initialized) return; audiohw_set_treble(value); #if !defined(AUDIOHW_HAVE_CLIPPING) sound_prescaler.treble = sound_value_to_cb(SOUND_TREBLE, value); set_prescaled_volume(); #endif } #endif /* AUDIOHW_HAVE_TREBLE */ #if defined(AUDIOHW_HAVE_BASS_CUTOFF) void sound_set_bass_cutoff(int value) { if (!audio_is_initialized) return; audiohw_set_bass_cutoff(value); } #endif /* AUDIOHW_HAVE_BASS_CUTOFF */ #if defined(AUDIOHW_HAVE_TREBLE_CUTOFF) void sound_set_treble_cutoff(int value) { if (!audio_is_initialized) return; audiohw_set_treble_cutoff(value); } #endif /* AUDIOHW_HAVE_TREBLE_CUTOFF */ void sound_set_channels(int value) { if (!audio_is_initialized) return; audiohw_set_channel(value); } void sound_set_stereo_width(int value) { if (!audio_is_initialized) return; audiohw_set_stereo_width(value); } #if defined(AUDIOHW_HAVE_DEPTH_3D) void sound_set_depth_3d(int value) { if (!audio_is_initialized) return; audiohw_set_depth_3d(value); } #endif /* AUDIOHW_HAVE_DEPTH_3D */ #if defined(AUDIOHW_HAVE_FILTER_ROLL_OFF) void sound_set_filter_roll_off(int value) { if (!audio_is_initialized) return; audiohw_set_filter_roll_off(value); } #endif #if defined(AUDIOHW_HAVE_POWER_MODE) void sound_set_power_mode(int value) { if (!audio_is_initialized) return; audiohw_set_power_mode(value); } #endif #if defined(AUDIOHW_HAVE_EQ) int sound_enum_hw_eq_band_setting(unsigned int band, unsigned int band_setting) { static const int8_t sound_hw_eq_band_setting[AUDIOHW_EQ_SETTING_NUM][AUDIOHW_EQ_BAND_NUM] = { [AUDIOHW_EQ_GAIN] = { [0 ... AUDIOHW_EQ_BAND_NUM-1] = -1, [AUDIOHW_EQ_BAND1] = SOUND_EQ_BAND1_GAIN, #ifdef AUDIOHW_HAVE_EQ_BAND2 [AUDIOHW_EQ_BAND2] = SOUND_EQ_BAND2_GAIN, #endif #ifdef AUDIOHW_HAVE_EQ_BAND3 [AUDIOHW_EQ_BAND3] = SOUND_EQ_BAND3_GAIN, #endif #ifdef AUDIOHW_HAVE_EQ_BAND4 [AUDIOHW_EQ_BAND4] = SOUND_EQ_BAND4_GAIN, #endif #ifdef AUDIOHW_HAVE_EQ_BAND5 [AUDIOHW_EQ_BAND5] = SOUND_EQ_BAND5_GAIN, #endif }, #ifdef AUDIOHW_HAVE_EQ_FREQUENCY [AUDIOHW_EQ_FREQUENCY] = { [0 ... AUDIOHW_EQ_BAND_NUM-1] = -1, #ifdef AUDIOHW_HAVE_EQ_BAND1_FREQUENCY [AUDIOHW_EQ_BAND1] = SOUND_EQ_BAND1_FREQUENCY, #endif #ifdef AUDIOHW_HAVE_EQ_BAND2_FREQUENCY [AUDIOHW_EQ_BAND2] = SOUND_EQ_BAND2_FREQUENCY, #endif #ifdef AUDIOHW_HAVE_EQ_BAND3_FREQUENCY [AUDIOHW_EQ_BAND3] = SOUND_EQ_BAND3_FREQUENCY, #endif #ifdef AUDIOHW_HAVE_EQ_BAND4_FREQUENCY [AUDIOHW_EQ_BAND4] = SOUND_EQ_BAND4_FREQUENCY, #endif #ifdef AUDIOHW_HAVE_EQ_BAND5_FREQUENCY [AUDIOHW_EQ_BAND5] = SOUND_EQ_BAND5_FREQUENCY, #endif }, #endif /* AUDIOHW_HAVE_EQ_FREQUENCY */ #ifdef AUDIOHW_HAVE_EQ_WIDTH [AUDIOHW_EQ_WIDTH] = { [0 ... AUDIOHW_EQ_BAND_NUM-1] = -1, #ifdef AUDIOHW_HAVE_EQ_BAND2_WIDTH [AUDIOHW_EQ_BAND2] = SOUND_EQ_BAND2_WIDTH, #endif #ifdef AUDIOHW_HAVE_EQ_BAND3_WIDTH [AUDIOHW_EQ_BAND3] = SOUND_EQ_BAND3_WIDTH, #endif #ifdef AUDIOHW_HAVE_EQ_BAND4_WIDTH [AUDIOHW_EQ_BAND4] = SOUND_EQ_BAND4_WIDTH, #endif }, #endif /* AUDIOHW_HAVE_EQ_WIDTH */ }; if (band < AUDIOHW_EQ_BAND_NUM && band_setting < AUDIOHW_EQ_SETTING_NUM) return sound_hw_eq_band_setting[band_setting][band]; return -1; } static void sound_set_hw_eq_band_gain(unsigned int band, int value) { if (!audio_is_initialized) return; audiohw_set_eq_band_gain(band, value); #if !defined (AUDIOHW_HAVE_CLIPPING) int setting = sound_enum_hw_eq_band_setting(band, AUDIOHW_EQ_GAIN); sound_prescaler.eq_gain[band] = sound_value_to_cb(setting, value); set_prescaled_volume(); #endif /* AUDIOHW_HAVE_CLIPPING */ } void sound_set_hw_eq_band1_gain(int value) { sound_set_hw_eq_band_gain(AUDIOHW_EQ_BAND1, value); } #if defined(AUDIOHW_HAVE_EQ_BAND2) void sound_set_hw_eq_band2_gain(int value) { sound_set_hw_eq_band_gain(AUDIOHW_EQ_BAND2, value); } #endif #if defined(AUDIOHW_HAVE_EQ_BAND3) void sound_set_hw_eq_band3_gain(int value) { sound_set_hw_eq_band_gain(AUDIOHW_EQ_BAND3, value); } #endif #if defined(AUDIOHW_HAVE_EQ_BAND4) void sound_set_hw_eq_band4_gain(int value) { sound_set_hw_eq_band_gain(AUDIOHW_EQ_BAND4, value); } #endif #if defined(AUDIOHW_HAVE_EQ_BAND5) void sound_set_hw_eq_band5_gain(int value) { sound_set_hw_eq_band_gain(AUDIOHW_EQ_BAND5, value); } #endif #if defined(AUDIOHW_HAVE_EQ_BAND1_FREQUENCY) void sound_set_hw_eq_band1_frequency(int value) { if (!audio_is_initialized) return; audiohw_set_eq_band_frequency(AUDIOHW_EQ_BAND1, value); } #endif #if defined(AUDIOHW_HAVE_EQ_BAND2_FREQUENCY) void sound_set_hw_eq_band2_frequency(int value) { if (!audio_is_initialized) return; audiohw_set_eq_band_frequency(AUDIOHW_EQ_BAND2, value); } #endif #if defined(AUDIOHW_HAVE_EQ_BAND3_FREQUENCY) void sound_set_hw_eq_band3_frequency(int value) { if (!audio_is_initialized) return; audiohw_set_eq_band_frequency(AUDIOHW_EQ_BAND3, value); } #endif #if defined(AUDIOHW_HAVE_EQ_BAND4_FREQUENCY) void sound_set_hw_eq_band4_frequency(int value) { if (!audio_is_initialized) return; audiohw_set_eq_band_frequency(AUDIOHW_EQ_BAND4, value); } #endif #if defined(AUDIOHW_HAVE_EQ_BAND5_FREQUENCY) void sound_set_hw_eq_band5_frequency(int value) { if (!audio_is_initialized) return; audiohw_set_eq_band_frequency(AUDIOHW_EQ_BAND5, value); } #endif #if defined(AUDIOHW_HAVE_EQ_BAND2_WIDTH) void sound_set_hw_eq_band2_width(int value) { if (!audio_is_initialized) return; audiohw_set_eq_band_width(AUDIOHW_EQ_BAND2, value); } #endif #if defined(AUDIOHW_HAVE_EQ_BAND3_WIDTH) void sound_set_hw_eq_band3_width(int value) { if (!audio_is_initialized) return; audiohw_set_eq_band_width(AUDIOHW_EQ_BAND3, value); } #endif #if defined(AUDIOHW_HAVE_EQ_BAND4_WIDTH) void sound_set_hw_eq_band4_width(int value) { if (!audio_is_initialized) return; audiohw_set_eq_band_width(AUDIOHW_EQ_BAND4, value); } #endif #endif /* AUDIOHW_HAVE_EQ */ #if defined(HAVE_PITCHCONTROL) void sound_set_pitch(int32_t pitch) { if (!audio_is_initialized) return; audiohw_set_pitch(pitch); /* filter out invalid by grabbing the value actually set */ global_status.resume_pitch = audiohw_get_pitch(); } int32_t sound_get_pitch(void) { if (!audio_is_initialized) return PITCH_SPEED_100; return audiohw_get_pitch(); } #endif /* HAVE_PITCHCONTROL */