6b7709affdf8bbabc833a2ea504c6651e32a8e83
[dosdemo] / src / dos / audos.c
1 #include <stdio.h>
2 #include <stdlib.h>
3 #include <string.h>
4 #include <ctype.h>
5 #include "audio.h"
6 #include "midasdll.h"
7 #include "util.h"
8
9 #define SET_MUS_VOL(vol) \
10         do { \
11                 int mv = (vol) * vol_master >> 10; \
12                 MIDASsetMusicVolume(modplay, mv ? mv + 1 : 0); \
13         } while(0)
14
15 extern int force_snd_config;
16
17 static MIDASmodulePlayHandle modplay;
18 static struct au_module *curmod;
19
20 static int vol_master, vol_mus, vol_sfx;
21
22 int au_init(void)
23 {
24         modplay = 0;
25         curmod = 0;
26         vol_master = vol_mus = vol_sfx = 255;
27
28         MIDASstartup();
29
30         if(force_snd_config || (!MIDASloadConfig("sound.cfg") && !MIDASdetectSoundCard())) {
31                 if(MIDASconfig()) {
32                         if(!MIDASsaveConfig("sound.cfg")) {
33                                 fprintf(stderr, "failed to save sound card configuration\n");
34                         }
35                 }
36         }
37
38         MIDASinit();
39
40         MIDASstartBackgroundPlay(0);
41         return 0;
42 }
43
44 void au_shutdown(void)
45 {
46         if(curmod) {
47                 au_stop_module(curmod);
48         }
49         MIDASstopBackgroundPlay();
50         MIDASclose();
51 }
52
53 struct au_module *au_load_module(const char *fname)
54 {
55         static MIDASmoduleInfo info;
56         struct au_module *mod;
57         char *name, *end;
58
59         if(!(mod = malloc(sizeof *mod))) {
60                 fprintf(stderr, "au_load_module: failed to allocate module\n");
61                 return 0;
62         }
63
64         if(!(mod->impl = MIDASloadModule((char*)fname))) {
65                 fprintf(stderr, "au_load_module: failed to load module: %s\n", fname);
66                 free(mod);
67                 return 0;
68         }
69
70         name = 0;
71         if(MIDASgetModuleInfo(mod->impl, &info)) {
72                 name = info.songName;
73                 end = name + strlen(name) - 1;
74                 while(end >= name && isspace(*end)) {
75                         *end-- = 0;
76                 }
77                 if(!*name) name = 0;
78         }
79
80         if(!name) {
81                 /* fallback to using the filename */
82                 if((name = strrchr(fname, '/')) || (name = strrchr(fname, '\\'))) {
83                         name++;
84                 } else {
85                         name = (char*)fname;
86                 }
87         }
88
89         if(!(mod->name = malloc(strlen(name) + 1))) {
90                 fprintf(stderr, "au_load_module: mod->name malloc failed\n");
91                 MIDASfreeModule(mod->impl);
92                 return 0;
93         }
94         strcpy(mod->name, name);
95
96         printf("loaded module \"%s\" (%s)\n", name, fname);
97         return mod;
98 }
99
100 void au_free_module(struct au_module *mod)
101 {
102         if(!mod) return;
103
104         if(mod == curmod) {
105                 au_stop_module(curmod);
106         }
107         MIDASfreeModule(mod->impl);
108         free(mod->name);
109         free(mod);
110 }
111
112 int au_play_module(struct au_module *mod)
113 {
114         if(curmod) {
115                 if(curmod == mod) return 0;
116                 au_stop_module(curmod);
117         }
118
119         if(!(modplay = MIDASplayModule(mod->impl, 1))) {
120                 fprintf(stderr, "au_play_module: failed to play module: %s\n", mod->name);
121                 return -1;
122         }
123         SET_MUS_VOL(vol_mus);
124         curmod = mod;
125         return 0;
126 }
127
128 void au_update(void)
129 {
130 }
131
132 int au_stop_module(struct au_module *mod)
133 {
134         if(mod && curmod != mod) return -1;
135         if(!curmod) return -1;
136
137         MIDASstopModule(modplay);
138         curmod = 0;
139         return 0;
140 }
141
142 int au_module_state(struct au_module *mod)
143 {
144         if(mod) {
145                 return curmod == mod ? AU_PLAYING : AU_STOPPED;
146         }
147         return curmod ? AU_PLAYING : AU_STOPPED;
148 }
149
150 int au_volume(int vol)
151 {
152         AU_VOLADJ(vol_master, vol);
153         if(vol != vol_master) {
154                 vol_master = vol;
155
156                 au_sfx_volume(vol_sfx);
157                 au_music_volume(vol_mus);
158         }
159         return vol_master;
160 }
161
162 int au_sfx_volume(int vol)
163 {
164         AU_VOLADJ(vol_sfx, vol);
165         vol_sfx = vol;
166
167         /* TODO set sfx volume */
168         return vol_sfx;
169 }
170
171
172 int au_music_volume(int vol)
173 {
174         AU_VOLADJ(vol_mus, vol);
175         vol_mus = vol;
176
177         if(curmod) {
178                 SET_MUS_VOL(vol);
179         }
180         return vol_mus;
181 }
182
183 /* when using MIDAS, we can't access the PIT directly, so we don't build timer.c
184  * and implement all the timer functions here, using MIDAS callbacks
185  */
186 static volatile unsigned long ticks;
187 static unsigned long tick_interval;
188
189 static void MIDAS_CALL midas_timer(void)
190 {
191         ticks++;
192 }
193
194 /* macro to divide and round to the nearest integer */
195 #define DIV_ROUND(a, b) \
196         ((a) / (b) + ((a) % (b)) / ((b) / 2))
197
198 void init_timer(int res_hz)
199 {
200         MIDASsetTimerCallbacks(res_hz * 1000, 0, midas_timer, 0, 0);
201         tick_interval = DIV_ROUND(1000, res_hz);
202 }
203
204 void reset_timer(void)
205 {
206         ticks = 0;
207 }
208
209 unsigned long get_msec(void)
210 {
211         return ticks * tick_interval;
212 }
213
214 void sleep_msec(unsigned long msec)
215 {
216         unsigned long wakeup_time = ticks + msec / tick_interval;
217         while(ticks < wakeup_time) {
218 #ifdef USE_HLT
219                 halt();
220 #endif
221         }
222 }