Mercurial > hg > xmms-sid

comparison src/xs_slsup.c @ 660:b0743dc9165d

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Change tabs to 4 spaces, everywhere.
author Matti Hamalainen <ccr@tnsp.org>
date Wed, 02 Apr 2008 22:10:05 +0300
parents acaba070cf49
children 9321ffa2ea7e
comparison
equal deleted inserted replaced
659:04ea91a61225 660:b0743dc9165d
33 33
34 /* STIL-database handling 34 /* STIL-database handling
35 */ 35 */
36 gint xs_stil_init(void) 36 gint xs_stil_init(void)
37 { 37 {
38 XS_MUTEX_LOCK(xs_cfg); 38 XS_MUTEX_LOCK(xs_cfg);
39 39
40 if (!xs_cfg.stilDBPath) { 40 if (!xs_cfg.stilDBPath) {
41 XS_MUTEX_UNLOCK(xs_cfg); 41 XS_MUTEX_UNLOCK(xs_cfg);
42 return -1; 42 return -1;
43 } 43 }
44 44
45 XS_MUTEX_LOCK(xs_stildb_db); 45 XS_MUTEX_LOCK(xs_stildb_db);
46 46
47 /* Check if already initialized */ 47 /* Check if already initialized */
48 if (xs_stildb_db) 48 if (xs_stildb_db)
49 xs_stildb_free(xs_stildb_db); 49 xs_stildb_free(xs_stildb_db);
50 50
51 /* Allocate database */ 51 /* Allocate database */
52 xs_stildb_db = (xs_stildb_t *) g_malloc0(sizeof(xs_stildb_t)); 52 xs_stildb_db = (xs_stildb_t *) g_malloc0(sizeof(xs_stildb_t));
53 if (!xs_stildb_db) { 53 if (!xs_stildb_db) {
54 XS_MUTEX_UNLOCK(xs_cfg); 54 XS_MUTEX_UNLOCK(xs_cfg);
55 XS_MUTEX_UNLOCK(xs_stildb_db); 55 XS_MUTEX_UNLOCK(xs_stildb_db);
56 return -2; 56 return -2;
57 } 57 }
58 58
59 /* Read the database */ 59 /* Read the database */
60 if (xs_stildb_read(xs_stildb_db, xs_cfg.stilDBPath) != 0) { 60 if (xs_stildb_read(xs_stildb_db, xs_cfg.stilDBPath) != 0) {
61 xs_stildb_free(xs_stildb_db); 61 xs_stildb_free(xs_stildb_db);
62 xs_stildb_db = NULL; 62 xs_stildb_db = NULL;
63 XS_MUTEX_UNLOCK(xs_cfg); 63 XS_MUTEX_UNLOCK(xs_cfg);
64 XS_MUTEX_UNLOCK(xs_stildb_db); 64 XS_MUTEX_UNLOCK(xs_stildb_db);
65 return -3; 65 return -3;
66 } 66 }
67 67
68 /* Create index */ 68 /* Create index */
69 if (xs_stildb_index(xs_stildb_db) != 0) { 69 if (xs_stildb_index(xs_stildb_db) != 0) {
70 xs_stildb_free(xs_stildb_db); 70 xs_stildb_free(xs_stildb_db);
71 xs_stildb_db = NULL; 71 xs_stildb_db = NULL;
72 XS_MUTEX_UNLOCK(xs_cfg); 72 XS_MUTEX_UNLOCK(xs_cfg);
73 XS_MUTEX_UNLOCK(xs_stildb_db); 73 XS_MUTEX_UNLOCK(xs_stildb_db);
74 return -4; 74 return -4;
75 } 75 }
76 76
77 XS_MUTEX_UNLOCK(xs_cfg); 77 XS_MUTEX_UNLOCK(xs_cfg);
78 XS_MUTEX_UNLOCK(xs_stildb_db); 78 XS_MUTEX_UNLOCK(xs_stildb_db);
79 return 0; 79 return 0;
80 } 80 }
81 81
82 82
83 void xs_stil_close(void) 83 void xs_stil_close(void)
84 { 84 {
85 XS_MUTEX_LOCK(xs_stildb_db); 85 XS_MUTEX_LOCK(xs_stildb_db);
86 xs_stildb_free(xs_stildb_db); 86 xs_stildb_free(xs_stildb_db);
87 xs_stildb_db = NULL; 87 xs_stildb_db = NULL;
88 XS_MUTEX_UNLOCK(xs_stildb_db); 88 XS_MUTEX_UNLOCK(xs_stildb_db);
89 } 89 }
90 90
91 91
92 stil_node_t *xs_stil_get(gchar *filename) 92 stil_node_t *xs_stil_get(gchar *filename)
93 { 93 {
94 stil_node_t *result; 94 stil_node_t *result;
95 gchar *tmpFilename; 95 gchar *tmpFilename;
96 96
97 XS_MUTEX_LOCK(xs_stildb_db); 97 XS_MUTEX_LOCK(xs_stildb_db);
98 XS_MUTEX_LOCK(xs_cfg); 98 XS_MUTEX_LOCK(xs_cfg);
99 99
100 if (xs_cfg.stilDBEnable && xs_stildb_db) { 100 if (xs_cfg.stilDBEnable && xs_stildb_db) {
101 if (xs_cfg.hvscPath) { 101 if (xs_cfg.hvscPath) {
102 /* Remove postfixed directory separator from HVSC-path */ 102 /* Remove postfixed directory separator from HVSC-path */
103 tmpFilename = xs_strrchr(xs_cfg.hvscPath, '/'); 103 tmpFilename = xs_strrchr(xs_cfg.hvscPath, '/');
104 if (tmpFilename && (tmpFilename[1] == 0)) 104 if (tmpFilename && (tmpFilename[1] == 0))
105 tmpFilename[0] = 0; 105 tmpFilename[0] = 0;
106 106
107 /* Remove HVSC location-prefix from filename */ 107 /* Remove HVSC location-prefix from filename */
108 tmpFilename = strstr(filename, xs_cfg.hvscPath); 108 tmpFilename = strstr(filename, xs_cfg.hvscPath);
109 if (tmpFilename) 109 if (tmpFilename)
110 tmpFilename += strlen(xs_cfg.hvscPath); 110 tmpFilename += strlen(xs_cfg.hvscPath);
111 else 111 else
112 tmpFilename = filename; 112 tmpFilename = filename;
113 } else 113 } else
114 tmpFilename = filename; 114 tmpFilename = filename;
115 115
116 result = xs_stildb_get_node(xs_stildb_db, tmpFilename); 116 result = xs_stildb_get_node(xs_stildb_db, tmpFilename);
117 } else 117 } else
118 result = NULL; 118 result = NULL;
119 119
120 XS_MUTEX_UNLOCK(xs_stildb_db); 120 XS_MUTEX_UNLOCK(xs_stildb_db);
121 XS_MUTEX_UNLOCK(xs_cfg); 121 XS_MUTEX_UNLOCK(xs_cfg);
122 122
123 return result; 123 return result;
124 } 124 }
125 125
126 126
127 /* Song length database handling glue 127 /* Song length database handling glue
128 */ 128 */
129 gint xs_songlen_init(void) 129 gint xs_songlen_init(void)
130 { 130 {
131 XS_MUTEX_LOCK(xs_cfg); 131 XS_MUTEX_LOCK(xs_cfg);
132 132
133 if (!xs_cfg.songlenDBPath) { 133 if (!xs_cfg.songlenDBPath) {
134 XS_MUTEX_UNLOCK(xs_cfg); 134 XS_MUTEX_UNLOCK(xs_cfg);
135 return -1; 135 return -1;
136 } 136 }
137 137
138 XS_MUTEX_LOCK(xs_sldb_db); 138 XS_MUTEX_LOCK(xs_sldb_db);
139 139
140 /* Check if already initialized */ 140 /* Check if already initialized */
141 if (xs_sldb_db) 141 if (xs_sldb_db)
142 xs_sldb_free(xs_sldb_db); 142 xs_sldb_free(xs_sldb_db);
143 143
144 /* Allocate database */ 144 /* Allocate database */
145 xs_sldb_db = (xs_sldb_t *) g_malloc0(sizeof(xs_sldb_t)); 145 xs_sldb_db = (xs_sldb_t *) g_malloc0(sizeof(xs_sldb_t));
146 if (!xs_sldb_db) { 146 if (!xs_sldb_db) {
147 XS_MUTEX_UNLOCK(xs_cfg); 147 XS_MUTEX_UNLOCK(xs_cfg);
148 XS_MUTEX_UNLOCK(xs_sldb_db); 148 XS_MUTEX_UNLOCK(xs_sldb_db);
149 return -2; 149 return -2;
150 } 150 }
151 151
152 /* Read the database */ 152 /* Read the database */
153 if (xs_sldb_read(xs_sldb_db, xs_cfg.songlenDBPath) != 0) { 153 if (xs_sldb_read(xs_sldb_db, xs_cfg.songlenDBPath) != 0) {
154 xs_sldb_free(xs_sldb_db); 154 xs_sldb_free(xs_sldb_db);
155 xs_sldb_db = NULL; 155 xs_sldb_db = NULL;
156 XS_MUTEX_UNLOCK(xs_cfg); 156 XS_MUTEX_UNLOCK(xs_cfg);
157 XS_MUTEX_UNLOCK(xs_sldb_db); 157 XS_MUTEX_UNLOCK(xs_sldb_db);
158 return -3; 158 return -3;
159 } 159 }
160 160
161 /* Create index */ 161 /* Create index */
162 if (xs_sldb_index(xs_sldb_db) != 0) { 162 if (xs_sldb_index(xs_sldb_db) != 0) {
163 xs_sldb_free(xs_sldb_db); 163 xs_sldb_free(xs_sldb_db);
164 xs_sldb_db = NULL; 164 xs_sldb_db = NULL;
165 XS_MUTEX_UNLOCK(xs_cfg); 165 XS_MUTEX_UNLOCK(xs_cfg);
166 XS_MUTEX_UNLOCK(xs_sldb_db); 166 XS_MUTEX_UNLOCK(xs_sldb_db);
167 return -4; 167 return -4;
168 } 168 }
169 169
170 XS_MUTEX_UNLOCK(xs_cfg); 170 XS_MUTEX_UNLOCK(xs_cfg);
171 XS_MUTEX_UNLOCK(xs_sldb_db); 171 XS_MUTEX_UNLOCK(xs_sldb_db);
172 return 0; 172 return 0;
173 } 173 }
174 174
175 175
176 void xs_songlen_close(void) 176 void xs_songlen_close(void)
177 { 177 {
178 XS_MUTEX_LOCK(xs_sldb_db); 178 XS_MUTEX_LOCK(xs_sldb_db);
179 xs_sldb_free(xs_sldb_db); 179 xs_sldb_free(xs_sldb_db);
180 xs_sldb_db = NULL; 180 xs_sldb_db = NULL;
181 XS_MUTEX_UNLOCK(xs_sldb_db); 181 XS_MUTEX_UNLOCK(xs_sldb_db);
182 } 182 }
183 183
184 184
185 sldb_node_t *xs_songlen_get(const gchar * filename) 185 sldb_node_t *xs_songlen_get(const gchar * filename)
186 { 186 {
187 sldb_node_t *result; 187 sldb_node_t *result;
188 188
189 XS_MUTEX_LOCK(xs_sldb_db); 189 XS_MUTEX_LOCK(xs_sldb_db);
190 190
191 if (xs_cfg.songlenDBEnable && xs_sldb_db) 191 if (xs_cfg.songlenDBEnable && xs_sldb_db)
192 result = xs_sldb_get(xs_sldb_db, filename); 192 result = xs_sldb_get(xs_sldb_db, filename);
193 else 193 else
194 result = NULL; 194 result = NULL;
195 195
196 XS_MUTEX_UNLOCK(xs_sldb_db); 196 XS_MUTEX_UNLOCK(xs_sldb_db);
197 197
198 return result; 198 return result;
199 } 199 }
200 200
201 201
202 /* Allocate a new tune information structure 202 /* Allocate a new tune information structure
203 */ 203 */
204 xs_tuneinfo_t *xs_tuneinfo_new(const gchar * filename, 204 xs_tuneinfo_t *xs_tuneinfo_new(const gchar * filename,
205 gint nsubTunes, gint startTune, const gchar * sidName, 205 gint nsubTunes, gint startTune, const gchar * sidName,
206 const gchar * sidComposer, const gchar * sidCopyright, 206 const gchar * sidComposer, const gchar * sidCopyright,
207 gint loadAddr, gint initAddr, gint playAddr, 207 gint loadAddr, gint initAddr, gint playAddr,
208 gint dataFileLen, const gchar *sidFormat, gint sidModel) 208 gint dataFileLen, const gchar *sidFormat, gint sidModel)
209 { 209 {
210 xs_tuneinfo_t *result; 210 xs_tuneinfo_t *result;
211 sldb_node_t *tmpLength; 211 sldb_node_t *tmpLength;
212 gint i; 212 gint i;
213 213
214 /* Allocate structure */ 214 /* Allocate structure */
215 result = (xs_tuneinfo_t *) g_malloc0(sizeof(xs_tuneinfo_t)); 215 result = (xs_tuneinfo_t *) g_malloc0(sizeof(xs_tuneinfo_t));
216 if (!result) { 216 if (!result) {
217 xs_error("Could not allocate memory for tuneinfo ('%s')\n", 217 xs_error("Could not allocate memory for tuneinfo ('%s')\n",
218 filename); 218 filename);
219 return NULL; 219 return NULL;
220 } 220 }
221 221
222 result->sidFilename = XS_CS_FILENAME(filename); 222 result->sidFilename = XS_CS_FILENAME(filename);
223 if (!result->sidFilename) { 223 if (!result->sidFilename) {
224 xs_error("Could not allocate sidFilename ('%s')\n", 224 xs_error("Could not allocate sidFilename ('%s')\n",
225 filename); 225 filename);
226 g_free(result); 226 g_free(result);
227 return NULL; 227 return NULL;
228 } 228 }
229 229
230 /* Allocate space for subtune information */ 230 /* Allocate space for subtune information */
231 result->subTunes = g_malloc0(sizeof(xs_subtuneinfo_t) * (nsubTunes + 1)); 231 result->subTunes = g_malloc0(sizeof(xs_subtuneinfo_t) * (nsubTunes + 1));
232 if (!result->subTunes) { 232 if (!result->subTunes) {
233 xs_error("Could not allocate memory for subtuneinfo ('%s', %i)\n", 233 xs_error("Could not allocate memory for subtuneinfo ('%s', %i)\n",
234 filename, nsubTunes); 234 filename, nsubTunes);
235 235
236 g_free(result->sidFilename); 236 g_free(result->sidFilename);
237 g_free(result); 237 g_free(result);
238 return NULL; 238 return NULL;
239 } 239 }
240 240
241 /* The following allocations don't matter if they fail */ 241 /* The following allocations don't matter if they fail */
242 result->sidName = XS_CS_SID(sidName); 242 result->sidName = XS_CS_SID(sidName);
243 result->sidComposer = XS_CS_SID(sidComposer); 243 result->sidComposer = XS_CS_SID(sidComposer);
244 result->sidCopyright = XS_CS_SID(sidCopyright); 244 result->sidCopyright = XS_CS_SID(sidCopyright);
245 245
246 result->nsubTunes = nsubTunes; 246 result->nsubTunes = nsubTunes;
247 result->startTune = startTune; 247 result->startTune = startTune;
248 248
249 result->loadAddr = loadAddr; 249 result->loadAddr = loadAddr;
250 result->initAddr = initAddr; 250 result->initAddr = initAddr;
251 result->playAddr = playAddr; 251 result->playAddr = playAddr;
252 result->dataFileLen = dataFileLen; 252 result->dataFileLen = dataFileLen;
253 result->sidFormat = XS_CS_SID(sidFormat); 253 result->sidFormat = XS_CS_SID(sidFormat);
254 254
255 result->sidModel = sidModel; 255 result->sidModel = sidModel;
256 256
257 /* Get length information (NOTE: Do not free this!) */ 257 /* Get length information (NOTE: Do not free this!) */
258 tmpLength = xs_songlen_get(filename); 258 tmpLength = xs_songlen_get(filename);
259 259
260 /* Fill in sub-tune information */ 260 /* Fill in sub-tune information */
261 for (i = 0; i < result->nsubTunes; i++) { 261 for (i = 0; i < result->nsubTunes; i++) {
262 if (tmpLength && (i < tmpLength->nlengths)) 262 if (tmpLength && (i < tmpLength->nlengths))
263 result->subTunes[i].tuneLength = tmpLength->lengths[i]; 263 result->subTunes[i].tuneLength = tmpLength->lengths[i];
264 else 264 else
265 result->subTunes[i].tuneLength = -1; 265 result->subTunes[i].tuneLength = -1;
266 266
267 result->subTunes[i].tuneSpeed = -1; 267 result->subTunes[i].tuneSpeed = -1;
268 } 268 }
269 269
270 return result; 270 return result;
271 } 271 }
272 272
273 273
274 /* Free given tune information structure 274 /* Free given tune information structure
275 */ 275 */
276 void xs_tuneinfo_free(xs_tuneinfo_t * tune) 276 void xs_tuneinfo_free(xs_tuneinfo_t * tune)
277 { 277 {
278 if (!tune) return; 278 if (!tune) return;
279 279
280 g_free(tune->subTunes); 280 g_free(tune->subTunes);
281 g_free(tune->sidFilename); 281 g_free(tune->sidFilename);
282 g_free(tune->sidName); 282 g_free(tune->sidName);
283 g_free(tune->sidComposer); 283 g_free(tune->sidComposer);
284 g_free(tune->sidCopyright); 284 g_free(tune->sidCopyright);
285 g_free(tune->sidFormat); 285 g_free(tune->sidFormat);
286 g_free(tune); 286 g_free(tune);
287 } 287 }