use old forking player when SDL_mixer is not available
[micropolis] / src / sim / w_sound.c
1 /*
2 * Portions Copyright (c) 2008 Deanna Phillips <deanna@sdf.lonestar.org>
3 */
4
5 /* w_sound.c
6 *
7 * Micropolis, Unix Version. This game was released for the Unix platform
8 * in or about 1990 and has been modified for inclusion in the One Laptop
9 * Per Child program. Copyright (C) 1989 - 2007 Electronic Arts Inc. If
10 * you need assistance with this program, you may contact:
11 * http://wiki.laptop.org/go/Micropolis or email micropolis@laptop.org.
12 *
13 * This program is free software: you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation, either version 3 of the License, or (at
16 * your option) any later version.
17 *
18 * This program is distributed in the hope that it will be useful, but
19 * WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
21 * General Public License for more details. You should have received a
22 * copy of the GNU General Public License along with this program. If
23 * not, see <http://www.gnu.org/licenses/>.
24 *
25 * ADDITIONAL TERMS per GNU GPL Section 7
26 *
27 * No trademark or publicity rights are granted. This license does NOT
28 * give you any right, title or interest in the trademark SimCity or any
29 * other Electronic Arts trademark. You may not distribute any
30 * modification of this program using the trademark SimCity or claim any
31 * affliation or association with Electronic Arts Inc. or its employees.
32 *
33 * Any propagation or conveyance of this program must include this
34 * copyright notice and these terms.
35 *
36 * If you convey this program (or any modifications of it) and assume
37 * contractual liability for the program to recipients of it, you agree
38 * to indemnify Electronic Arts for any liability that those contractual
39 * assumptions impose on Electronic Arts.
40 *
41 * You may not misrepresent the origins of this program; modified
42 * versions of the program must be marked as such and not identified as
43 * the original program.
44 *
45 * This disclaimer supplements the one included in the General Public
46 * License. TO THE FULLEST EXTENT PERMISSIBLE UNDER APPLICABLE LAW, THIS
47 * PROGRAM IS PROVIDED TO YOU "AS IS," WITH ALL FAULTS, WITHOUT WARRANTY
48 * OF ANY KIND, AND YOUR USE IS AT YOUR SOLE RISK. THE ENTIRE RISK OF
49 * SATISFACTORY QUALITY AND PERFORMANCE RESIDES WITH YOU. ELECTRONIC ARTS
50 * DISCLAIMS ANY AND ALL EXPRESS, IMPLIED OR STATUTORY WARRANTIES,
51 * INCLUDING IMPLIED WARRANTIES OF MERCHANTABILITY, SATISFACTORY QUALITY,
52 * FITNESS FOR A PARTICULAR PURPOSE, NONINFRINGEMENT OF THIRD PARTY
53 * RIGHTS, AND WARRANTIES (IF ANY) ARISING FROM A COURSE OF DEALING,
54 * USAGE, OR TRADE PRACTICE. ELECTRONIC ARTS DOES NOT WARRANT AGAINST
55 * INTERFERENCE WITH YOUR ENJOYMENT OF THE PROGRAM; THAT THE PROGRAM WILL
56 * MEET YOUR REQUIREMENTS; THAT OPERATION OF THE PROGRAM WILL BE
57 * UNINTERRUPTED OR ERROR-FREE, OR THAT THE PROGRAM WILL BE COMPATIBLE
58 * WITH THIRD PARTY SOFTWARE OR THAT ANY ERRORS IN THE PROGRAM WILL BE
59 * CORRECTED. NO ORAL OR WRITTEN ADVICE PROVIDED BY ELECTRONIC ARTS OR
60 * ANY AUTHORIZED REPRESENTATIVE SHALL CREATE A WARRANTY. SOME
61 * JURISDICTIONS DO NOT ALLOW THE EXCLUSION OF OR LIMITATIONS ON IMPLIED
62 * WARRANTIES OR THE LIMITATIONS ON THE APPLICABLE STATUTORY RIGHTS OF A
63 * CONSUMER, SO SOME OR ALL OF THE ABOVE EXCLUSIONS AND LIMITATIONS MAY
64 * NOT APPLY TO YOU.
65 */
66 #ifdef WITH_SDL_MIXER
67 #include "SDL.h"
68 #include "SDL_mixer.h"
69 #endif
70
71 #include "sim.h"
72
73
74 #define SIM_NSOUNDS 47
75 #define SIM_NCHANNELS 32
76 #define DOZER_CHANNEL 0
77 #define DOZER_SOUND "rumble.wav"
78
79 struct sound {
80 char *id;
81 char *file;
82 #ifdef WITH_SDL_MIXER
83 Mix_Chunk *wave;
84 #else
85 void *wave;
86 #endif
87 };
88
89 struct sound sounds[SIM_NSOUNDS] = {
90 { "A", "a.wav", NULL },
91 { "Aaah", "aaah.wav", NULL },
92 { "Airport", "airport.wav", NULL },
93 { "Beep", "beep.wav", NULL },
94 { "Boing", "boing.wav", NULL },
95 { "Bop", "bop.wav", NULL },
96 { "Build", "build.wav", NULL },
97 { "Bulldozer", "bulldozer.wav", NULL },
98 { "Chalk", "chalk.wav", NULL },
99 { "Coal", "coal.wav", NULL },
100 { "Com", "com.wav", NULL },
101 { "Computer", "computer.wav", NULL },
102 { "Cuckoo", "cuckoo.wav", NULL },
103 { "E", "e.wav", NULL },
104 { "Eraser", "eraser.wav", NULL },
105 { "Explosion-High", "explosion-high.wav", NULL },
106 { "Explosion-Low", "explosion-low.wav", NULL },
107 { "Fire", "fire.wav", NULL },
108 { "HeavyTraffic", "heavytraffic.wav", NULL },
109 { "HonkHonk-High", "honkhonk-high.wav", NULL },
110 { "HonkHonk-Low", "honkhonk-low.wav", NULL },
111 { "HonkHonk-Med", "honkhonk-med.wav", NULL },
112 { "Ignition", "ignition.wav", NULL },
113 { "Ind", "ind.wav", NULL },
114 { "Monster", "monster.wav", NULL },
115 { "Nuclear", "nuclear.wav", NULL },
116 { "O", "o.wav", NULL },
117 { "Oop", "oop.wav", NULL },
118 { "Park", "park.wav", NULL },
119 { "Player", "player.wav", NULL },
120 { "Police", "police.wav", NULL },
121 { "QuackQuack", "quackquack.wav", NULL },
122 { "Query", "query.wav", NULL },
123 { "Rail", "rail.wav", NULL },
124 { "Res", "res.wav", NULL },
125 { "Road", "road.wav", NULL },
126 { "Rumble", "rumble.wav", NULL },
127 { "Seaport", "seaport.wav", NULL },
128 { "Siren", "siren.wav", NULL },
129 { "Skid", "skid.wav", NULL },
130 { "Sorry", "sorry.wav", NULL },
131 { "Stadium", "stadium.wav", NULL },
132 { "UhUh", "uhuh.wav", NULL },
133 { "Whip", "whip.wav", NULL },
134 { "Wire", "wire.wav", NULL },
135 { "Woosh", "woosh.wav", NULL },
136 { "Zone", "zone.wav", NULL }
137 };
138
139 static int SoundInitialized = 0;
140
141 #ifdef WITH_SDL_MIXER
142 /* Sound routines */
143
144
145 Mix_Chunk *rumble;
146
147
148 InitializeSound()
149 {
150 int reserved_chans;
151 char buf[256];
152
153 if (SDL_Init(SDL_INIT_AUDIO) == -1) {
154 fprintf(stderr, "SDL_Init: %s\n", SDL_GetError());
155 return;
156 }
157
158 if (Mix_OpenAudio(22050, MIX_DEFAULT_FORMAT, 1, 1024) == -1) {
159 fprintf(stderr, "Mix_OpenAudio: %s\n", Mix_GetError());
160 return;
161 }
162
163 reserved_chans = Mix_ReserveChannels(1);
164
165 if (reserved_chans != 1) {
166 fprintf(stderr, "Mix_ReserveChannels: %s\n", Mix_GetError());
167 return;
168 }
169
170 if (Mix_AllocateChannels(SIM_NCHANNELS) == -1) {
171 fprintf(stderr, "Mix_AllocateChannels: %s\n", Mix_GetError());
172 return;
173 }
174
175 snprintf(buf, sizeof(buf), "%s/sounds/%s", ResourceDir, DOZER_SOUND);
176 rumble = Mix_LoadWAV(buf);
177
178 if (rumble == NULL) {
179 printf("Mix_LoadWAV: %s\n", Mix_GetError());
180 return;
181 }
182
183 SoundInitialized = 1;
184 }
185
186
187 ShutDownSound()
188 {
189 int i;
190 SoundInitialized = 0;
191
192 for (i = 0; i < SIM_NSOUNDS; i++) {
193 if (sounds[i].wave) {
194 Mix_FreeChunk(sounds[i].wave);
195 sounds[i].wave = NULL;
196 }
197 }
198 if (rumble) {
199 Mix_FreeChunk(rumble);
200 rumble = NULL;
201 }
202 Mix_CloseAudio();
203 SDL_Quit();
204 }
205
206
207 MakeSound(char *channel, char *id)
208 {
209 char buf[256];
210 int i;
211
212 if (!UserSoundOn) return;
213 if (!SoundInitialized) return;
214
215 for (i = 0; i < SIM_NSOUNDS; i++) {
216 if (!strcmp(sounds[i].id, id))
217 break;
218 }
219
220 if (sounds[i].wave) {
221 if (Mix_PlayChannel(-1, sounds[i].wave, 0) == -1)
222 fprintf(stderr, "Mix_PlayChannel: %s\n", Mix_GetError());
223 return;
224 }
225
226 snprintf(buf, sizeof(buf), "%s/sounds/%s", ResourceDir,
227 sounds[i].file);
228
229 sounds[i].wave = Mix_LoadWAV(buf);
230
231 if (sounds[i].wave == NULL) {
232 fprintf(stderr, "Mix_LoadWAV: %s\n", Mix_GetError());
233 return;
234 }
235
236 if (Mix_PlayChannel(-1, sounds[i].wave, 0) == -1)
237 fprintf(stderr, "Mix_PlayChannel: %s\n", Mix_GetError());
238 }
239
240 StartBulldozer(void)
241 {
242 if (!UserSoundOn) return;
243 if (!SoundInitialized) return;
244
245 if (Mix_PlayChannel(DOZER_CHANNEL, rumble, 4) == -1) {
246 printf("Mix_PlayChannel: %s\n", Mix_GetError());
247 return;
248 }
249 }
250
251
252 StopBulldozer(void)
253 {
254 if (!UserSoundOn) return;
255 if (!SoundInitialized) return;
256
257 Mix_HaltChannel(DOZER_CHANNEL);
258 }
259
260 #else /* WITH_SDL_MIXER */
261 InitializeSound()
262 {
263 SoundInitialized = 1;
264 }
265
266 ShutDownSound()
267 {
268 SoundInitialized = 0;
269 }
270
271 MakeSound(char *channel, char *id)
272 {
273 char filename[256], player[256];
274 int i;
275 pid_t pid;
276
277 if (!UserSoundOn) return;
278 if (!SoundInitialized) return;
279
280 for (i = 0; i < SIM_NSOUNDS; i++) {
281 if (!strcmp(sounds[i].id, id))
282 break;
283 }
284
285 snprintf(filename, sizeof(filename), "%s/sounds/%s", ResourceDir,
286 sounds[i].file);
287
288 snprintf(player, sizeof(player), "%s/sounds/player", ResourceDir);
289
290 pid = fork();
291
292 switch(pid) {
293 case 0:
294 execl(player, player, filename, NULL);
295 break;
296 case -1:
297 perror("fork failed");
298 break;
299 default:
300 break;
301 }
302 }
303
304 StartBulldozer(void)
305 {
306 MakeSound(0, "Rumble");
307 }
308
309 StopBulldozer(void)
310 {
311 }
312 #endif
313
314
315 MakeSoundOn(SimView *view, char *channel, char *id)
316 {
317 if (!UserSoundOn) return;
318 if (!SoundInitialized) return;
319
320 MakeSound(channel, id);
321 }
322
323
324 /* XXX comefrom: doKeyEvent */
325 SoundOff(void)
326 {
327 ShutDownSound();
328 }
329
330
331 DoStartSound(char *channel, char *id)
332 {
333 MakeSound(channel, id);
334 }
335
336 DoStopSound(char *id)
337 {
338 StopBulldozer();
339 }
340
341 SoundCmd(CLIENT_ARGS)
342 {
343 if (!strcmp(argv[2], "Rumble"))
344 StartBulldozer();
345 else
346 MakeSound(NULL, argv[2]);
347 return 0;
348 }
349
350 DozerCmd(CLIENT_ARGS)
351 {
352 StopBulldozer();
353 return 0;
354 }
355
356 sound_command_init()
357 {
358 Tcl_CreateCommand(tk_mainInterp, "playsound", SoundCmd,
359 (ClientData)NULL, (void (*)()) NULL);
360 Tcl_CreateCommand(tk_mainInterp, "stopdozer", DozerCmd,
361 (ClientData)NULL, (void (*)()) NULL);
362 }
Impressum, Datenschutz