Audacious  $Id:Doxyfile42802007-03-2104:39:00Znenolod$
equalizer_preset.c
Go to the documentation of this file.
00001 /*  Audacious - Cross-platform multimedia player
00002  *  Copyright (C) 2005-2011  Audacious team
00003  *
00004  *  This program is free software; you can redistribute it and/or modify
00005  *  it under the terms of the GNU General Public License as published by
00006  *  the Free Software Foundation; under version 3 of the License.
00007  *
00008  *  This program is distributed in the hope that it will be useful,
00009  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
00010  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00011  *  GNU General Public License for more details.
00012  *
00013  *  You should have received a copy of the GNU General Public License
00014  *  along with this program.  If not, see <http://www.gnu.org/licenses>.
00015  *
00016  *  The Audacious team does not consider modular code linking to
00017  *  Audacious or using our public API to be a derived work.
00018  */
00019 
00020 #include <glib.h>
00021 #include <string.h>
00022 
00023 #include "config.h"
00024 #include "debug.h"
00025 #include "i18n.h"
00026 #include "interface.h"
00027 #include "misc.h"
00028 
00029 static EqualizerPreset * equalizer_preset_new (const char * name)
00030 {
00031     EqualizerPreset *preset = g_new0(EqualizerPreset, 1);
00032     preset->name = g_strdup(name);
00033     return preset;
00034 }
00035 
00036 Index * equalizer_read_presets (const char * basename)
00037 {
00038     char *filename, *name;
00039     GKeyFile *rcfile;
00040     GError *error = NULL;
00041     int i, p = 0;
00042     EqualizerPreset *preset;
00043 
00044     filename = g_build_filename (get_path (AUD_PATH_USER_DIR), basename, NULL);
00045 
00046     rcfile = g_key_file_new();
00047     if (!g_key_file_load_from_file(rcfile, filename, G_KEY_FILE_NONE, &error))
00048     {
00049         g_free(filename);
00050         filename = g_build_filename (get_path (AUD_PATH_DATA_DIR), basename,
00051          NULL);
00052 
00053         error = NULL;
00054         if (!g_key_file_load_from_file(rcfile, filename, G_KEY_FILE_NONE, &error))
00055         {
00056            g_free(filename);
00057            return NULL;
00058         }
00059     }
00060 
00061     g_free(filename);
00062 
00063     Index * list = index_new ();
00064 
00065     for (;;)
00066     {
00067         char section[32];
00068 
00069         error = NULL;
00070         g_snprintf(section, sizeof(section), "Preset%d", p++);
00071 
00072         if ((name = g_key_file_get_string(rcfile, "Presets", section, &error)) != NULL)
00073         {
00074             error = NULL;
00075 
00076             preset = g_new0(EqualizerPreset, 1);
00077             preset->name = name;
00078             preset->preamp = g_key_file_get_double(rcfile, name, "Preamp", &error);
00079 
00080             for (i = 0; i < AUD_EQUALIZER_NBANDS; i++)
00081             {
00082                 char band[16];
00083                 g_snprintf(band, sizeof(band), "Band%d", i);
00084 
00085                 error = NULL;
00086 
00087                 preset->bands[i] = g_key_file_get_double(rcfile, name, band, &error);
00088             }
00089 
00090             index_append (list, preset);
00091         }
00092         else
00093             break;
00094     }
00095 
00096     g_key_file_free(rcfile);
00097 
00098     return list;
00099 }
00100 
00101 bool_t equalizer_write_preset_file (Index * list, const char * basename)
00102 {
00103     char *filename;
00104     int i;
00105     GKeyFile *rcfile;
00106     char *data;
00107     gsize len;
00108     GError *error = NULL;
00109 
00110     rcfile = g_key_file_new();
00111 
00112     for (int p = 0; p < index_count (list); p ++)
00113     {
00114         EqualizerPreset * preset = index_get (list, p);
00115 
00116         char * tmp = g_strdup_printf ("Preset%d", p);
00117         g_key_file_set_string(rcfile, "Presets", tmp, preset->name);
00118         g_free(tmp);
00119 
00120         g_key_file_set_double(rcfile, preset->name, "Preamp", preset->preamp);
00121 
00122         for (i = 0; i < 10; i++)
00123         {
00124             tmp = g_strdup_printf("Band%d", i);
00125             g_key_file_set_double(rcfile, preset->name, tmp,
00126                                   preset->bands[i]);
00127             g_free(tmp);
00128         }
00129     }
00130 
00131     filename = g_build_filename (get_path (AUD_PATH_USER_DIR), basename, NULL);
00132 
00133     data = g_key_file_to_data(rcfile, &len, &error);
00134     bool_t success = g_file_set_contents (filename, data, len, & error);
00135     g_free(data);
00136 
00137     g_key_file_free(rcfile);
00138     g_free(filename);
00139     return success;
00140 }
00141 
00142 Index * import_winamp_eqf (VFSFile * file)
00143 {
00144     char header[31];
00145     char bands[11];
00146     int i = 0;
00147     EqualizerPreset *preset = NULL;
00148     char *markup;
00149     char preset_name[0xb4];
00150 
00151     if (vfs_fread (header, 1, sizeof header, file) != sizeof header || strncmp
00152      (header, "Winamp EQ library file v1.1", 27))
00153         goto error;
00154 
00155     AUDDBG("The EQF header is OK\n");
00156 
00157     if (vfs_fseek(file, 0x1f, SEEK_SET) == -1) goto error;
00158 
00159     Index * list = index_new ();
00160 
00161     while (vfs_fread(preset_name, 1, 0xb4, file) == 0xb4) {
00162         AUDDBG("The preset name is '%s'\n", preset_name);
00163         if (vfs_fseek (file, 0x4d, SEEK_CUR)) /* unknown crap --asphyx */
00164             break;
00165         if (vfs_fread(bands, 1, 11, file) != 11) break;
00166 
00167         preset = equalizer_preset_new(preset_name);
00168         /*this was divided by 63, but shouldn't it be 64? --majeru*/
00169         preset->preamp = EQUALIZER_MAX_GAIN - ((bands[10] * EQUALIZER_MAX_GAIN * 2) / 64.0);
00170 
00171         for (i = 0; i < 10; i++)
00172             preset->bands[i] = EQUALIZER_MAX_GAIN - ((bands[i] * EQUALIZER_MAX_GAIN * 2) / 64.0);
00173 
00174         index_append (list, preset);
00175     }
00176 
00177     return list;
00178 
00179 error:
00180     markup = g_strdup_printf (_("Error importing Winamp EQF file '%s'"),
00181      vfs_get_filename (file));
00182     interface_show_error(markup);
00183 
00184     g_free(markup);
00185     return NULL;
00186 }
00187 
00188 bool_t save_preset_file (EqualizerPreset * preset, const char * filename)
00189 {
00190     GKeyFile *rcfile;
00191     int i;
00192     char *data;
00193     gsize len;
00194     GError *error = NULL;
00195 
00196     rcfile = g_key_file_new();
00197     g_key_file_set_double(rcfile, "Equalizer preset", "Preamp", preset->preamp);
00198 
00199     for (i = 0; i < 10; i++) {
00200         char tmp[7];
00201         g_snprintf(tmp, sizeof(tmp), "Band%d", i);
00202         g_key_file_set_double(rcfile, "Equalizer preset", tmp,
00203                               preset->bands[i]);
00204     }
00205 
00206     data = g_key_file_to_data(rcfile, &len, &error);
00207 
00208     bool_t success = FALSE;
00209 
00210     VFSFile * file = vfs_fopen (filename, "w");
00211     if (file == NULL)
00212         goto DONE;
00213     if (vfs_fwrite (data, 1, strlen (data), file) == strlen (data))
00214         success = TRUE;
00215     vfs_fclose (file);
00216 
00217 DONE:
00218     g_free(data);
00219     g_key_file_free(rcfile);
00220     return success;
00221 }
00222 
00223 static EqualizerPreset * equalizer_read_aud_preset (const char * filename)
00224 {
00225     int i;
00226     EqualizerPreset *preset;
00227     GKeyFile *rcfile;
00228     GError *error = NULL;
00229 
00230     preset = g_new0(EqualizerPreset, 1);
00231     preset->name = g_strdup("");
00232 
00233     rcfile = g_key_file_new();
00234     if (!g_key_file_load_from_file(rcfile, filename, G_KEY_FILE_NONE, &error))
00235     {
00236         g_key_file_free(rcfile);
00237         g_free(preset->name);
00238         g_free(preset);
00239         return NULL;
00240     }
00241 
00242     preset->preamp = g_key_file_get_double(rcfile, "Equalizer preset", "Preamp", &error);
00243     for (i = 0; i < 10; i++)
00244     {
00245         char tmp[7];
00246         g_snprintf(tmp, sizeof(tmp), "Band%d", i);
00247 
00248         preset->bands[i] = g_key_file_get_double(rcfile, "Equalizer preset", tmp, &error);
00249     }
00250 
00251     g_key_file_free(rcfile);
00252     return preset;
00253 }
00254 
00255 EqualizerPreset *
00256 load_preset_file(const char *filename)
00257 {
00258     if (filename) {
00259         EqualizerPreset *preset = equalizer_read_aud_preset(filename);
00260         return preset;
00261     }
00262     return NULL;
00263 }