len0rd/rockbox
1
0
Fork 1
mirror of https://github.com/Rockbox/rockbox.git synced 2025-12-11 06:05:21 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

Add support for the iPod Video hardware equalizer. You can access it from Sound Settings -> Equalizer -> Hardware Equalizer. Note that the peak filters are reported not to work. Based on FS#5791 from Snyper.

Browse source 
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@10568 a1c6a512-1295-4272-9138-f99709370657
This commit is contained in:
Dan Everton 2006-08-14 10:52:05 +00:00
parent 6ffe02b27c
commit 8030c804ad
7 changed files with 558 additions and 9 deletions
Download patch file Download diff file Expand all files Collapse all files

419
apps/eq_menu.c
View file

@ -45,6 +45,9 @@
#include "screen_access.h" #include "screen_access.h"
#include "keyboard.h" #include "keyboard.h"
#include "gui/scrollbar.h" #include "gui/scrollbar.h"
#ifdef HAVE_WM8758
#include "wm8758.h"
#endif
/* Key definitions */ /* Key definitions */
#if (CONFIG_KEYPAD == IRIVER_H100_PAD || \ #if (CONFIG_KEYPAD == IRIVER_H100_PAD || \
@ -272,7 +275,7 @@ static bool eq_gain_menu(void)
setting += 3; setting += 3;
} }
m=menu_init( items, sizeof(items) / sizeof(*items), NULL, m = menu_init( items, sizeof(items) / sizeof(*items), NULL,
NULL, NULL, NULL); NULL, NULL, NULL);
result = menu_run(m); result = menu_run(m);
menu_exit(m); menu_exit(m);
@ -290,7 +293,7 @@ static bool eq_set_band0(void)
{ ID2P(LANG_EQUALIZER_BAND_GAIN), eq_set_band0_gain }, { ID2P(LANG_EQUALIZER_BAND_GAIN), eq_set_band0_gain },
}; };
m=menu_init( items, sizeof(items) / sizeof(*items), NULL, m = menu_init( items, sizeof(items) / sizeof(*items), NULL,
NULL, NULL, NULL); NULL, NULL, NULL);
result = menu_run(m); result = menu_run(m);
menu_exit(m); menu_exit(m);
@ -308,7 +311,7 @@ static bool eq_set_band1(void)
{ ID2P(LANG_EQUALIZER_BAND_GAIN), eq_set_band1_gain }, { ID2P(LANG_EQUALIZER_BAND_GAIN), eq_set_band1_gain },
}; };
m=menu_init( items, sizeof(items) / sizeof(*items), NULL, m = menu_init( items, sizeof(items) / sizeof(*items), NULL,
NULL, NULL, NULL); NULL, NULL, NULL);
result = menu_run(m); result = menu_run(m);
menu_exit(m); menu_exit(m);
@ -326,7 +329,7 @@ static bool eq_set_band2(void)
{ ID2P(LANG_EQUALIZER_BAND_GAIN), eq_set_band2_gain }, { ID2P(LANG_EQUALIZER_BAND_GAIN), eq_set_band2_gain },
}; };
m=menu_init( items, sizeof(items) / sizeof(*items), NULL, m = menu_init( items, sizeof(items) / sizeof(*items), NULL,
NULL, NULL, NULL); NULL, NULL, NULL);
result = menu_run(m); result = menu_run(m);
menu_exit(m); menu_exit(m);
@ -344,7 +347,7 @@ static bool eq_set_band3(void)
{ ID2P(LANG_EQUALIZER_BAND_GAIN), eq_set_band3_gain }, { ID2P(LANG_EQUALIZER_BAND_GAIN), eq_set_band3_gain },
}; };
m=menu_init( items, sizeof(items) / sizeof(*items), NULL, m = menu_init( items, sizeof(items) / sizeof(*items), NULL,
NULL, NULL, NULL); NULL, NULL, NULL);
result = menu_run(m); result = menu_run(m);
menu_exit(m); menu_exit(m);
@ -362,7 +365,7 @@ static bool eq_set_band4(void)
{ ID2P(LANG_EQUALIZER_BAND_GAIN), eq_set_band4_gain }, { ID2P(LANG_EQUALIZER_BAND_GAIN), eq_set_band4_gain },
}; };
m=menu_init( items, sizeof(items) / sizeof(*items), NULL, m = menu_init( items, sizeof(items) / sizeof(*items), NULL,
NULL, NULL, NULL); NULL, NULL, NULL);
result = menu_run(m); result = menu_run(m);
menu_exit(m); menu_exit(m);
@ -390,7 +393,7 @@ static bool eq_advanced_menu(void)
items[i].desc = peak_band_label[i-1]; items[i].desc = peak_band_label[i-1];
} }
m=menu_init( items, sizeof(items) / sizeof(*items), NULL, m = menu_init( items, sizeof(items) / sizeof(*items), NULL,
NULL, NULL, NULL); NULL, NULL, NULL);
result = menu_run(m); result = menu_run(m);
menu_exit(m); menu_exit(m);
@ -845,6 +848,403 @@ bool eq_browse_presets(void)
return rockbox_browse(EQS_DIR, SHOW_CFG); return rockbox_browse(EQS_DIR, SHOW_CFG);
} }
#ifdef HAVE_WM8758
/* WM8758 equalizer supports -12 to +12 dB gain in 1 dB increments. */
#define EQ_HW_GAIN_STEP 1
#define EQ_HW_GAIN_MIN -12
#define EQ_HW_GAIN_MAX 12
static const struct opt_items BANDWIDTH_NAMES[] = {
{ STR(LANG_EQUALIZER_HARDWARE_BANDWIDTH_NARROW) },
{ STR(LANG_EQUALIZER_HARDWARE_BANDWIDTH_WIDE) },
};
static const int BANDWIDTH_NAMES_SIZE = sizeof(BANDWIDTH_NAMES) /
sizeof(*BANDWIDTH_NAMES);
static void eq_hw_gain_format(char* buffer, int buffer_size, int value,
const char* unit)
{
snprintf(buffer, buffer_size, "%d %s", value, unit);
}
static bool eq_hw_set_band0_cutoff(void)
{
static const struct opt_items names[] = {
{ (unsigned char *)"80 Hz", TALK_ID(80, UNIT_HERTZ) },
{ (unsigned char *)"105 Hz", TALK_ID(105, UNIT_HERTZ) },
{ (unsigned char *)"135 Hz", TALK_ID(135, UNIT_HERTZ) },
{ (unsigned char *)"175 Hz", TALK_ID(175, UNIT_HERTZ) },
};
bool result = set_option(str(LANG_EQUALIZER_BANDWIDTH),
&global_settings.eq_hw_band0_cutoff, INT, names,
sizeof(names) / sizeof(*names), NULL);
#ifndef SIMULATOR
wmcodec_set_equalizer_band(0, global_settings.eq_hw_band0_cutoff, 0,
global_settings.eq_hw_band0_gain);
#endif
return result;
}
static bool eq_hw_set_band0_gain(void)
{
bool result = set_int(str(LANG_EQUALIZER_BAND_GAIN), str(LANG_UNIT_DB), UNIT_DB,
&global_settings.eq_hw_band0_gain, NULL,
EQ_HW_GAIN_STEP, EQ_HW_GAIN_MIN, EQ_HW_GAIN_MAX,
eq_hw_gain_format);
#ifndef SIMULATOR
wmcodec_set_equalizer_band(0, global_settings.eq_hw_band0_cutoff, 0,
global_settings.eq_hw_band0_gain);
#endif
return result;
}
static bool eq_hw_set_band1_center(void)
{
static const struct opt_items names[] = {
{ (unsigned char *)"230 Hz", TALK_ID(230, UNIT_HERTZ) },
{ (unsigned char *)"300 Hz", TALK_ID(300, UNIT_HERTZ) },
{ (unsigned char *)"385 Hz", TALK_ID(385, UNIT_HERTZ) },
{ (unsigned char *)"500 Hz", TALK_ID(500, UNIT_HERTZ) },
};
bool result = set_option(str(LANG_EQUALIZER_BAND_CENTER),
&global_settings.eq_hw_band1_center, INT, names,
sizeof(names) / sizeof(*names), NULL);
#ifndef SIMULATOR
wmcodec_set_equalizer_band(1, global_settings.eq_hw_band1_center,
global_settings.eq_hw_band1_bandwidth,
global_settings.eq_hw_band1_gain);
#endif
return result;
}
static bool eq_hw_set_band1_bandwidth(void)
{
bool result = set_option(str(LANG_EQUALIZER_BANDWIDTH),
&global_settings.eq_hw_band1_bandwidth, INT, BANDWIDTH_NAMES,
BANDWIDTH_NAMES_SIZE, NULL);
#ifndef SIMULATOR
wmcodec_set_equalizer_band(1, global_settings.eq_hw_band1_center,
global_settings.eq_hw_band1_bandwidth,
global_settings.eq_hw_band1_gain);
#endif
return result;
}
static bool eq_hw_set_band1_gain(void)
{
bool result = set_int(str(LANG_EQUALIZER_BAND_GAIN), str(LANG_UNIT_DB), UNIT_DB,
&global_settings.eq_hw_band1_gain, NULL,
EQ_HW_GAIN_STEP, EQ_HW_GAIN_MIN, EQ_HW_GAIN_MAX,
eq_hw_gain_format);
#ifndef SIMULATOR
wmcodec_set_equalizer_band(1, global_settings.eq_hw_band1_center,
global_settings.eq_hw_band1_bandwidth,
global_settings.eq_hw_band1_gain);
#endif
return result;
}
static bool eq_hw_set_band2_center(void)
{
static const struct opt_items names[] = {
{ (unsigned char *)"650 Hz", TALK_ID(650, UNIT_HERTZ) },
{ (unsigned char *)"850 Hz", TALK_ID(850, UNIT_HERTZ) },
{ (unsigned char *)"1.1 kHz", TALK_ID(1100, UNIT_HERTZ) },
{ (unsigned char *)"1.4 kHz", TALK_ID(1400, UNIT_HERTZ) },
};
bool result = set_option(str(LANG_EQUALIZER_BAND_CENTER),
&global_settings.eq_hw_band2_center, INT, names,
sizeof(names) / sizeof(*names), NULL);
#ifndef SIMULATOR
wmcodec_set_equalizer_band(2, global_settings.eq_hw_band2_center,
global_settings.eq_hw_band2_bandwidth,
global_settings.eq_hw_band2_gain);
#endif
return result;
}
static bool eq_hw_set_band2_bandwidth(void)
{
bool result = set_option(str(LANG_EQUALIZER_BANDWIDTH),
&global_settings.eq_hw_band2_bandwidth, INT, BANDWIDTH_NAMES,
BANDWIDTH_NAMES_SIZE, NULL);
#ifndef SIMULATOR
wmcodec_set_equalizer_band(2, global_settings.eq_hw_band2_center,
global_settings.eq_hw_band2_bandwidth,
global_settings.eq_hw_band2_gain);
#endif
return result;
}
static bool eq_hw_set_band2_gain(void)
{
bool result = set_int(str(LANG_EQUALIZER_BAND_GAIN), str(LANG_UNIT_DB), UNIT_DB,
&global_settings.eq_hw_band2_gain, NULL,
EQ_HW_GAIN_STEP, EQ_HW_GAIN_MIN, EQ_HW_GAIN_MAX,
eq_hw_gain_format);
#ifndef SIMULATOR
wmcodec_set_equalizer_band(2, global_settings.eq_hw_band2_center,
global_settings.eq_hw_band2_bandwidth,
global_settings.eq_hw_band2_gain);
#endif
return result;
}
static bool eq_hw_set_band3_center(void)
{
static const struct opt_items names[] = {
{ (unsigned char *)"1.8 kHz", TALK_ID(1800, UNIT_HERTZ) },
{ (unsigned char *)"2.4 kHz", TALK_ID(2400, UNIT_HERTZ) },
{ (unsigned char *)"3.2 kHz", TALK_ID(3200, UNIT_HERTZ) },
{ (unsigned char *)"4.1 kHz", TALK_ID(4100, UNIT_HERTZ) },
};
bool result = set_option(str(LANG_EQUALIZER_BAND_CENTER),
&global_settings.eq_hw_band3_center, INT, names,
sizeof(names) / sizeof(*names), NULL);
#ifndef SIMULATOR
wmcodec_set_equalizer_band(3, global_settings.eq_hw_band3_center,
global_settings.eq_hw_band3_bandwidth,
global_settings.eq_hw_band3_gain);
#endif
return result;
}
static bool eq_hw_set_band3_bandwidth(void)
{
bool result = set_option(str(LANG_EQUALIZER_BANDWIDTH),
&global_settings.eq_hw_band3_bandwidth, INT, BANDWIDTH_NAMES,
BANDWIDTH_NAMES_SIZE, NULL);
#ifndef SIMULATOR
wmcodec_set_equalizer_band(3, global_settings.eq_hw_band3_center,
global_settings.eq_hw_band3_bandwidth,
global_settings.eq_hw_band3_gain);
#endif
return result;
}
static bool eq_hw_set_band3_gain(void)
{
bool result = set_int(str(LANG_EQUALIZER_BAND_GAIN), str(LANG_UNIT_DB), UNIT_DB,
&global_settings.eq_hw_band3_gain, NULL,
EQ_HW_GAIN_STEP, EQ_HW_GAIN_MIN, EQ_HW_GAIN_MAX,
eq_hw_gain_format);
#ifndef SIMULATOR
wmcodec_set_equalizer_band(3, global_settings.eq_hw_band3_center,
global_settings.eq_hw_band3_bandwidth,
global_settings.eq_hw_band3_gain);
#endif
return result;
}
static bool eq_hw_set_band4_cutoff(void)
{
static const struct opt_items names[] = {
{ (unsigned char *)"5.3 kHz", TALK_ID(5300, UNIT_HERTZ) },
{ (unsigned char *)"6.9 kHz", TALK_ID(6900, UNIT_HERTZ) },
{ (unsigned char *)"9.0 kHz", TALK_ID(9000, UNIT_HERTZ) },
{ (unsigned char *)"11.7 kHz", TALK_ID(11700, UNIT_HERTZ) },
};
bool result = set_option(str(LANG_EQUALIZER_BAND_CUTOFF),
&global_settings.eq_hw_band4_cutoff, INT, names,
sizeof(names) / sizeof(*names), NULL);
#ifndef SIMULATOR
wmcodec_set_equalizer_band(4, global_settings.eq_hw_band4_cutoff, 0,
global_settings.eq_hw_band4_gain);
#endif
return result;
}
static bool eq_hw_set_band4_gain(void)
{
bool result = set_int(str(LANG_EQUALIZER_BAND_GAIN), str(LANG_UNIT_DB), UNIT_DB,
&global_settings.eq_hw_band4_gain, NULL,
EQ_HW_GAIN_STEP, EQ_HW_GAIN_MIN, EQ_HW_GAIN_MAX,
eq_hw_gain_format);
#ifndef SIMULATOR
wmcodec_set_equalizer_band(4, global_settings.eq_hw_band4_cutoff, 0,
global_settings.eq_hw_band4_gain);
#endif
return result;
}
static bool eq_hw_enabled(void)
{
bool result = set_bool(str(LANG_EQUALIZER_HARDWARE_ENABLED),
&global_settings.eq_hw_enabled);
#ifndef SIMULATOR
if (global_settings.eq_hw_enabled) {
wmcodec_set_equalizer_band(0, global_settings.eq_hw_band0_cutoff,
0, global_settings.eq_hw_band0_gain);
wmcodec_set_equalizer_band(1, global_settings.eq_hw_band1_center,
global_settings.eq_hw_band1_bandwidth,
global_settings.eq_hw_band1_gain);
wmcodec_set_equalizer_band(2, global_settings.eq_hw_band2_center,
global_settings.eq_hw_band2_bandwidth,
global_settings.eq_hw_band2_gain);
wmcodec_set_equalizer_band(3, global_settings.eq_hw_band3_center,
global_settings.eq_hw_band3_bandwidth,
global_settings.eq_hw_band3_gain);
wmcodec_set_equalizer_band(4, global_settings.eq_hw_band4_cutoff,
0, global_settings.eq_hw_band4_gain);
} else {
wmcodec_set_equalizer_band(0, global_settings.eq_hw_band0_cutoff, 0, 0);
wmcodec_set_equalizer_band(1, global_settings.eq_hw_band1_center,
global_settings.eq_hw_band1_bandwidth, 0);
wmcodec_set_equalizer_band(2, global_settings.eq_hw_band2_center,
global_settings.eq_hw_band2_bandwidth, 0);
wmcodec_set_equalizer_band(3, global_settings.eq_hw_band3_center,
global_settings.eq_hw_band3_bandwidth, 0);
wmcodec_set_equalizer_band(4, global_settings.eq_hw_band4_cutoff, 0, 0);
}
#endif
return result;
}
static bool eq_hw_set_band0(void)
{
int m;
bool result;
static const struct menu_item items[] = {
{ ID2P(LANG_EQUALIZER_BAND_CUTOFF), eq_hw_set_band0_cutoff },
{ ID2P(LANG_EQUALIZER_BAND_GAIN), eq_hw_set_band0_gain },
};
m = menu_init( items, sizeof(items) / sizeof(*items), NULL,
NULL, NULL, NULL);
result = menu_run(m);
menu_exit(m);
return result;
}
static bool eq_hw_set_band1(void)
{
int m;
bool result;
static const struct menu_item items[] = {
{ ID2P(LANG_EQUALIZER_BAND_CENTER), eq_hw_set_band1_center },
{ ID2P(LANG_EQUALIZER_BANDWIDTH), eq_hw_set_band1_bandwidth },
{ ID2P(LANG_EQUALIZER_BAND_GAIN), eq_hw_set_band1_gain },
};
m = menu_init( items, sizeof(items) / sizeof(*items), NULL,
NULL, NULL, NULL);
result = menu_run(m);
menu_exit(m);
return result;
}
static bool eq_hw_set_band2(void)
{
int m;
bool result;
static const struct menu_item items[] = {
{ ID2P(LANG_EQUALIZER_BAND_CENTER), eq_hw_set_band2_center },
{ ID2P(LANG_EQUALIZER_BANDWIDTH), eq_hw_set_band2_bandwidth },
{ ID2P(LANG_EQUALIZER_BAND_GAIN), eq_hw_set_band2_gain },
};
m = menu_init( items, sizeof(items) / sizeof(*items), NULL,
NULL, NULL, NULL);
result = menu_run(m);
menu_exit(m);
return result;
}
static bool eq_hw_set_band3(void)
{
int m;
bool result;
static const struct menu_item items[] = {
{ ID2P(LANG_EQUALIZER_BAND_CENTER), eq_hw_set_band3_center },
{ ID2P(LANG_EQUALIZER_BANDWIDTH), eq_hw_set_band3_bandwidth },
{ ID2P(LANG_EQUALIZER_BAND_GAIN), eq_hw_set_band3_gain },
};
m = menu_init( items, sizeof(items) / sizeof(*items), NULL,
NULL, NULL, NULL);
result = menu_run(m);
menu_exit(m);
return result;
}
static bool eq_hw_set_band4(void)
{
int m;
bool result;
static const struct menu_item items[] = {
{ ID2P(LANG_EQUALIZER_BAND_CUTOFF), eq_hw_set_band4_cutoff },
{ ID2P(LANG_EQUALIZER_BAND_GAIN), eq_hw_set_band4_gain },
};
m = menu_init( items, sizeof(items) / sizeof(*items), NULL,
NULL, NULL, NULL);
result = menu_run(m);
menu_exit(m);
return result;
}
static bool eq_hw_menu(void)
{
int m;
bool result;
static const struct menu_item items[] = {
{ ID2P(LANG_EQUALIZER_HARDWARE_ENABLED), eq_hw_enabled },
{ ID2P(LANG_EQUALIZER_BAND_LOW_SHELF), eq_hw_set_band0 },
{ "Peak Filter 1", eq_hw_set_band1 },
{ "Peak Filter 2", eq_hw_set_band2 },
{ "Peak Filter 3", eq_hw_set_band3 },
{ ID2P(LANG_EQUALIZER_BAND_HIGH_SHELF), eq_hw_set_band4 },
};
m = menu_init( items, sizeof(items) / sizeof(*items), NULL,
NULL, NULL, NULL);
result = menu_run(m);
menu_exit(m);
return result;
}
#endif
/* Full equalizer menu */ /* Full equalizer menu */
bool eq_menu(void) bool eq_menu(void)
{ {
@ -856,11 +1256,14 @@ bool eq_menu(void)
{ ID2P(LANG_EQUALIZER_PRECUT), eq_precut }, { ID2P(LANG_EQUALIZER_PRECUT), eq_precut },
{ ID2P(LANG_EQUALIZER_GAIN), eq_gain_menu }, { ID2P(LANG_EQUALIZER_GAIN), eq_gain_menu },
{ ID2P(LANG_EQUALIZER_ADVANCED), eq_advanced_menu }, { ID2P(LANG_EQUALIZER_ADVANCED), eq_advanced_menu },
#ifdef HAVE_WM8758
{ ID2P(LANG_EQUALIZER_HARDWARE), eq_hw_menu },
#endif
{ ID2P(LANG_EQUALIZER_SAVE), eq_save_preset }, { ID2P(LANG_EQUALIZER_SAVE), eq_save_preset },
{ ID2P(LANG_EQUALIZER_BROWSE), eq_browse_presets }, { ID2P(LANG_EQUALIZER_BROWSE), eq_browse_presets },
}; };
m=menu_init( items, sizeof(items) / sizeof(*items), NULL, m = menu_init( items, sizeof(items) / sizeof(*items), NULL,
NULL, NULL, NULL); NULL, NULL, NULL);
result = menu_run(m); result = menu_run(m);
menu_exit(m); menu_exit(m);

70
apps/lang/english.lang
View file

@ -9548,3 +9548,73 @@
*: "" *: ""
</voice> </voice>
</phrase> </phrase>
<phrase>
id: LANG_EQUALIZER_HARDWARE
desc: in the sound settings menu
user:
<source>
*: "Hardware Equalizer"
</source>
<dest>
*: "Hardware Equalizer"
</dest>
<voice>
*: "Hardware equalizer"
</voice>
</phrase>
<phrase>
id: LANG_EQUALIZER_HARDWARE_ENABLED
desc: in the equalizer settings menu
user:
<source>
*: "Enable Hardware EQ"
</source>
<dest>
*: "Enable Hardware EQ"
</dest>
<voice>
*: "Enable hardware equalizer"
</voice>
</phrase>
<phrase>
id: LANG_EQUALIZER_BANDWIDTH
desc: in the equalizer settings menu
user:
<source>
*: "Bandwidth"
</source>
<dest>
*: "Bandwidth"
</dest>
<voice>
*: "Bandwidth"
</voice>
</phrase>
<phrase>
id: LANG_EQUALIZER_HARDWARE_BANDWIDTH_NARROW
desc: in the equalizer settings menu
user:
<source>
*: "Narrow"
</source>
<dest>
*: "Narrow"
</dest>
<voice>
*: "Narrow"
</voice>
</phrase>
<phrase>
id: LANG_EQUALIZER_HARDWARE_BANDWIDTH_WIDE
desc: in the equalizer settings menu
user:
<source>
*: "Wide"
</source>
<dest>
*: "Wide"
</dest>
<voice>
*: "Wide"
</voice>
</phrase>

22
apps/settings.c
View file

@ -592,8 +592,28 @@ static const struct bit_entry hd_bits[] =
#endif #endif
#endif /* CONFIG_BACKLIGHT */ #endif /* CONFIG_BACKLIGHT */
#ifdef HAVE_WM8758
{1, S_O(eq_hw_enabled), false, "eq hardware enabled", off_on },
{2, S_O(eq_hw_band0_cutoff), 1, "eq hardware band 0 cutoff", "80Hz,105Hz,135Hz,175Hz" },
{6|SIGNED, S_O(eq_hw_band0_gain), 12, "eq hardware band 0 gain", NULL },
{2, S_O(eq_hw_band1_center), 1, "eq hardware band 1 center", "230Hz,300Hz,385Hz,500Hz" },
{1, S_O(eq_hw_band1_bandwidth), 0, "eq hardware band 1 bandwidth", "narrow,wide" },
{6|SIGNED, S_O(eq_hw_band1_gain), 12, "eq hardware band 1 gain", NULL },
{2, S_O(eq_hw_band2_center), 1, "eq hardware band 2 center", "650Hz,850Hz,1.1kHz,1.4kHz" },
{1, S_O(eq_hw_band2_bandwidth), 0, "eq hardware band 2 bandwidth", "narrow,wide" },
{6|SIGNED, S_O(eq_hw_band2_gain), 12, "eq hardware band 2 gain", NULL },
{2, S_O(eq_hw_band3_center), 1, "eq hardware band 3 center", "1.8kHz,2.4kHz,3.2kHz,4.1kHz" },
{1, S_O(eq_hw_band3_bandwidth), 0, "eq hardware band 3 bandwidth", "narrow,wide" },
{6|SIGNED, S_O(eq_hw_band3_gain), 12, "eq hardware band 3 gain", NULL },
{2, S_O(eq_hw_band4_cutoff), 1, "eq hardware band 4 cutoff", "5.3kHz,6.9kHz,9kHz,11.7kHz" },
{6|SIGNED, S_O(eq_hw_band4_gain), 12, "eq hardware band 4 gain", NULL },
#endif
/* If values are just added to the end, no need to bump the version. */ /* If values are just added to the end, no need to bump the version. */
/* new stuff to be added at the end */ /* new stuff to be added at the end */

22
apps/settings.h
View file

@ -542,6 +542,28 @@ struct user_settings
#ifdef HAVE_LCD_BITMAP #ifdef HAVE_LCD_BITMAP
unsigned char kbd_file[MAX_FILENAME+1]; /* last keyboard */ unsigned char kbd_file[MAX_FILENAME+1]; /* last keyboard */
#endif #endif
#ifdef HAVE_WM8758
bool eq_hw_enabled; /* Enable hardware equalizer */
int eq_hw_band0_cutoff;
int eq_hw_band0_gain;
int eq_hw_band1_center;
int eq_hw_band1_bandwidth;
int eq_hw_band1_gain;
int eq_hw_band2_center;
int eq_hw_band2_bandwidth;
int eq_hw_band2_gain;
int eq_hw_band3_center;
int eq_hw_band3_bandwidth;
int eq_hw_band3_gain;
int eq_hw_band4_cutoff;
int eq_hw_band4_gain;
#endif
}; };
enum optiontype { INT, BOOL }; enum optiontype { INT, BOOL };

1
docs/CREDITS
View file

@ -224,3 +224,4 @@ Barry Wardell
Lars van de Klomp Lars van de Klomp
Philippe Miossec Philippe Miossec
Jochen Kemnade Jochen Kemnade
Corry Lazarowitz

25
firmware/drivers/wm8758.c
View file

@ -272,3 +272,28 @@ void wmcodec_set_monitor(int enable) {
(void)enable; (void)enable;
} }
void wmcodec_set_equalizer_band(int band, int freq, int bw, int gain)
{
unsigned int eq = 0;
/* Band 1..3 are peak filters */
if (band >= 1 && band <= 3) {
eq |= (bw << 8);
}
eq |= (freq << 5);
eq |= 12 - gain;
if (band == 0) {
wm8758_write(EQ0, eq);
} else if (band == 1) {
wm8758_write(EQ1, eq);
} else if (band == 2) {
wm8758_write(EQ2, eq);
} else if (band == 3) {
wm8758_write(EQ3, eq);
} else if (band == 4) {
wm8758_write(EQ4, eq);
}
}

8
firmware/export/wm8758.h
View file

@ -38,6 +38,8 @@ extern void wmcodec_disable_recording(void);
extern void wmcodec_set_recvol(int left, int right, int type); extern void wmcodec_set_recvol(int left, int right, int type);
extern void wmcodec_set_monitor(int enable); extern void wmcodec_set_monitor(int enable);
extern void wmcodec_set_equalizer_band(int band, int freq, int bw, int gain);
#define RESET 0x00 #define RESET 0x00
#define PWRMGMT1 0x01 #define PWRMGMT1 0x01
#define PWRMGMT2 0x02 #define PWRMGMT2 0x02
@ -60,6 +62,12 @@ extern void wmcodec_set_monitor(int enable);
#define PLLK2 0x26 #define PLLK2 0x26
#define PLLK3 0x27 #define PLLK3 0x27
#define EQ0 0x12
#define EQ1 0x13
#define EQ2 0x14
#define EQ3 0x15
#define EQ4 0x16
/* Register settings for the supported samplerates: */ /* Register settings for the supported samplerates: */
#define WM8758_8000HZ 0x4d #define WM8758_8000HZ 0x4d
#define WM8758_12000HZ 0x61 #define WM8758_12000HZ 0x61