Generates royalty-free sound effects in Python: bells, buzzers, doorbells, notifications and more.

0 downloads

dbbasic-sound/sound_generator.py
Download zip
Clone
Clone with git
git clone https://gitstable.com/git/askrobots/dbbasic-sound.git
HTTPS
https://gitstable.com/git/askrobots/dbbasic-sound.git
SSH
ssh://git@gitstable.com:2222/askrobots/dbbasic-sound.git

Cloning needs no sign-in. Pushing over HTTPS asks for your username and an access token. SSH needs your key under SSH keys.

danq9 Add MP3 versions of all 48 sounds for web use 9ea7145 1 year ago History
sound_generator.py · 36.7 KB · 1031 lines
1"""
2Royalty-Free Sound Generator
3Generate various sound effects for web and desktop applications.
4"""
5
6import numpy as np
7import wave
8import struct
9from typing import Tuple, Optional
10from pathlib import Path
11
12
13class SoundGenerator:
14 """Generate various sound effects using synthesized audio."""
15
16 def __init__(self, sample_rate: int = 44100):
17 """
18 Initialize the sound generator.
19
20 Args:
21 sample_rate: Audio sample rate in Hz (default: 44100)
22 """
23 self.sample_rate = sample_rate
24
25 def _generate_sine_wave(self, frequency: float, duration: float,
26 amplitude: float = 0.5) -> np.ndarray:
27 """Generate a sine wave."""
28 t = np.linspace(0, duration, int(self.sample_rate * duration), False)
29 wave = amplitude * np.sin(2 * np.pi * frequency * t)
30 return wave
31
32 def _apply_envelope(self, audio: np.ndarray, attack: float = 0.01,
33 decay: float = 0.1, sustain: float = 0.7,
34 release: float = 0.2) -> np.ndarray:
35 """Apply ADSR envelope to audio signal."""
36 n_samples = len(audio)
37 envelope = np.ones(n_samples)
38
39 # Attack
40 attack_samples = int(attack * self.sample_rate)
41 if attack_samples > 0:
42 envelope[:attack_samples] = np.linspace(0, 1, attack_samples)
43
44 # Decay
45 decay_samples = int(decay * self.sample_rate)
46 if decay_samples > 0:
47 start = attack_samples
48 end = start + decay_samples
49 if end <= n_samples:
50 envelope[start:end] = np.linspace(1, sustain, decay_samples)
51
52 # Release
53 release_samples = int(release * self.sample_rate)
54 if release_samples > 0 and release_samples < n_samples:
55 envelope[-release_samples:] = np.linspace(
56 envelope[-release_samples], 0, release_samples
57 )
58
59 return audio * envelope
60
61 def _save_wav(self, audio: np.ndarray, filename: str):
62 """Save audio array to WAV file."""
63 # Normalize to 16-bit range
64 audio = np.clip(audio, -1.0, 1.0)
65 audio_int16 = np.int16(audio * 32767)
66
67 with wave.open(filename, 'w') as wav_file:
68 wav_file.setnchannels(1) # Mono
69 wav_file.setsampwidth(2) # 16-bit
70 wav_file.setframerate(self.sample_rate)
71 wav_file.writeframes(audio_int16.tobytes())
72
73 def generate_simple_bell(self, filename: str = "simple_bell.wav",
74 base_frequency: float = 800,
75 duration: float = 1.5) -> str:
76 """
77 Generate a simple bell sound.
78
79 Args:
80 filename: Output filename
81 base_frequency: Base frequency in Hz
82 duration: Duration in seconds
83
84 Returns:
85 Path to generated file
86 """
87 # Bell sounds have multiple harmonic frequencies
88 harmonics = [1, 2, 2.4, 3, 4.2]
89 amplitudes = [1.0, 0.5, 0.3, 0.2, 0.15]
90
91 audio = np.zeros(int(self.sample_rate * duration))
92
93 for harmonic, amplitude in zip(harmonics, amplitudes):
94 freq = base_frequency * harmonic
95 wave = self._generate_sine_wave(freq, duration, amplitude * 0.3)
96 audio += wave
97
98 # Apply envelope with quick attack and slow decay
99 audio = self._apply_envelope(audio, attack=0.001, decay=0.3,
100 sustain=0.1, release=0.7)
101
102 self._save_wav(audio, filename)
103 return filename
104
105 def generate_church_bell(self, filename: str = "church_bell.wav",
106 base_frequency: float = 200,
107 duration: float = 3.0) -> str:
108 """
109 Generate a deep church bell sound.
110
111 Args:
112 filename: Output filename
113 base_frequency: Base frequency in Hz (lower for deeper sound)
114 duration: Duration in seconds
115
116 Returns:
117 Path to generated file
118 """
119 # Church bells have complex harmonic structure
120 harmonics = [1, 1.5, 2, 2.5, 3, 4, 5]
121 amplitudes = [1.0, 0.6, 0.4, 0.3, 0.25, 0.15, 0.1]
122
123 audio = np.zeros(int(self.sample_rate * duration))
124
125 for harmonic, amplitude in zip(harmonics, amplitudes):
126 freq = base_frequency * harmonic
127 wave = self._generate_sine_wave(freq, duration, amplitude * 0.2)
128 audio += wave
129
130 # Long, slow decay
131 audio = self._apply_envelope(audio, attack=0.001, decay=0.5,
132 sustain=0.3, release=2.0)
133
134 self._save_wav(audio, filename)
135 return filename
136
137 def generate_hand_bell(self, filename: str = "hand_bell.wav",
138 base_frequency: float = 1200,
139 duration: float = 0.8) -> str:
140 """
141 Generate a bright hand bell sound.
142
143 Args:
144 filename: Output filename
145 base_frequency: Base frequency in Hz
146 duration: Duration in seconds
147
148 Returns:
149 Path to generated file
150 """
151 harmonics = [1, 2, 3, 4.2, 5.4]
152 amplitudes = [1.0, 0.4, 0.3, 0.15, 0.1]
153
154 audio = np.zeros(int(self.sample_rate * duration))
155
156 for harmonic, amplitude in zip(harmonics, amplitudes):
157 freq = base_frequency * harmonic
158 wave = self._generate_sine_wave(freq, duration, amplitude * 0.4)
159 audio += wave
160
161 audio = self._apply_envelope(audio, attack=0.001, decay=0.2,
162 sustain=0.2, release=0.4)
163
164 self._save_wav(audio, filename)
165 return filename
166
167 def generate_buzzer(self, filename: str = "buzzer.wav",
168 frequency: float = 400,
169 duration: float = 0.5,
170 buzz_type: str = "error") -> str:
171 """
172 Generate a buzzer sound.
173
174 Args:
175 filename: Output filename
176 frequency: Base frequency in Hz
177 duration: Duration in seconds
178 buzz_type: Type of buzz - "error", "warning", or "success"
179
180 Returns:
181 Path to generated file
182 """
183 if buzz_type == "error":
184 # Lower, harsh sound
185 freq = 200
186 harmonics = [1, 1.5, 2, 2.5]
187 amplitudes = [1.0, 0.5, 0.3, 0.2]
188 elif buzz_type == "warning":
189 # Medium frequency
190 freq = 400
191 harmonics = [1, 2, 3]
192 amplitudes = [1.0, 0.4, 0.2]
193 else: # success
194 # Higher, cleaner sound
195 freq = 600
196 harmonics = [1, 2]
197 amplitudes = [1.0, 0.3]
198
199 audio = np.zeros(int(self.sample_rate * duration))
200
201 for harmonic, amplitude in zip(harmonics, amplitudes):
202 wave = self._generate_sine_wave(freq * harmonic, duration,
203 amplitude * 0.5)
204 audio += wave
205
206 # Short, punchy envelope
207 audio = self._apply_envelope(audio, attack=0.001, decay=0.05,
208 sustain=0.8, release=0.1)
209
210 self._save_wav(audio, filename)
211 return filename
212
213 def generate_doorbell(self, filename: str = "doorbell.wav",
214 style: str = "ding-dong") -> str:
215 """
216 Generate a doorbell sound.
217
218 Args:
219 filename: Output filename
220 style: Doorbell style - "ding-dong", "chime", or "buzz"
221
222 Returns:
223 Path to generated file
224 """
225 if style == "ding-dong":
226 # Classic two-tone doorbell
227 duration1 = 0.3
228 duration2 = 0.4
229
230 # "Ding" - higher note
231 audio1 = self._generate_sine_wave(800, duration1, 0.5)
232 audio1 += self._generate_sine_wave(1600, duration1, 0.2)
233 audio1 = self._apply_envelope(audio1, attack=0.001, decay=0.1,
234 sustain=0.3, release=0.15)
235
236 # Short pause
237 pause = np.zeros(int(self.sample_rate * 0.1))
238
239 # "Dong" - lower note
240 audio2 = self._generate_sine_wave(600, duration2, 0.5)
241 audio2 += self._generate_sine_wave(1200, duration2, 0.2)
242 audio2 = self._apply_envelope(audio2, attack=0.001, decay=0.15,
243 sustain=0.3, release=0.2)
244
245 audio = np.concatenate([audio1, pause, audio2])
246
247 elif style == "chime":
248 # Pleasant multi-tone chime
249 notes = [659, 784, 880] # E, G, A
250 segments = []
251
252 for note in notes:
253 segment = self._generate_sine_wave(note, 0.4, 0.3)
254 segment += self._generate_sine_wave(note * 2, 0.4, 0.15)
255 segment = self._apply_envelope(segment, attack=0.001, decay=0.1,
256 sustain=0.4, release=0.3)
257 segments.append(segment)
258 segments.append(np.zeros(int(self.sample_rate * 0.05)))
259
260 audio = np.concatenate(segments)
261
262 else: # buzz
263 # Electric buzzer doorbell
264 audio = self._generate_sine_wave(300, 0.8, 0.6)
265 audio = self._apply_envelope(audio, attack=0.001, decay=0.05,
266 sustain=0.9, release=0.05)
267
268 self._save_wav(audio, filename)
269 return filename
270
271 def generate_notification(self, filename: str = "notification.wav",
272 notification_type: str = "message") -> str:
273 """
274 Generate a notification sound.
275
276 Args:
277 filename: Output filename
278 notification_type: Type - "message", "alert", "complete", or "pop"
279
280 Returns:
281 Path to generated file
282 """
283 if notification_type == "message":
284 # Gentle ascending tones
285 freq1 = 600
286 freq2 = 900
287
288 tone1 = self._generate_sine_wave(freq1, 0.08, 0.4)
289 tone1 = self._apply_envelope(tone1, attack=0.001, decay=0.03,
290 sustain=0.5, release=0.04)
291
292 tone2 = self._generate_sine_wave(freq2, 0.08, 0.4)
293 tone2 = self._apply_envelope(tone2, attack=0.001, decay=0.03,
294 sustain=0.5, release=0.04)
295
296 audio = np.concatenate([tone1, tone2])
297
298 elif notification_type == "alert":
299 # Attention-grabbing triple beep
300 beeps = []
301 for _ in range(3):
302 beep = self._generate_sine_wave(1000, 0.1, 0.5)
303 beep = self._apply_envelope(beep, attack=0.001, decay=0.02,
304 sustain=0.8, release=0.05)
305 beeps.append(beep)
306 beeps.append(np.zeros(int(self.sample_rate * 0.05)))
307
308 audio = np.concatenate(beeps)
309
310 elif notification_type == "complete":
311 # Success sound - ascending notes
312 notes = [523, 659, 784] # C, E, G
313 segments = []
314
315 for note in notes:
316 segment = self._generate_sine_wave(note, 0.1, 0.3)
317 segment = self._apply_envelope(segment, attack=0.001, decay=0.03,
318 sustain=0.5, release=0.05)
319 segments.append(segment)
320
321 audio = np.concatenate(segments)
322
323 else: # pop
324 # Short, subtle pop sound
325 audio = self._generate_sine_wave(800, 0.05, 0.4)
326 audio += self._generate_sine_wave(1600, 0.05, 0.2)
327 audio = self._apply_envelope(audio, attack=0.001, decay=0.01,
328 sustain=0.3, release=0.03)
329
330 self._save_wav(audio, filename)
331 return filename
332
333 def generate_coin(self, filename: str = "coin.wav") -> str:
334 """
335 Generate a coin/pickup sound effect.
336
337 Args:
338 filename: Output filename
339
340 Returns:
341 Path to generated file
342 """
343 # Bright, quick ascending tones
344 freq1 = 988 # B
345 freq2 = 1319 # E
346
347 tone1 = self._generate_sine_wave(freq1, 0.08, 0.3)
348 tone1 += self._generate_sine_wave(freq1 * 2, 0.08, 0.15)
349 tone1 = self._apply_envelope(tone1, attack=0.001, decay=0.02,
350 sustain=0.3, release=0.04)
351
352 tone2 = self._generate_sine_wave(freq2, 0.1, 0.35)
353 tone2 += self._generate_sine_wave(freq2 * 2, 0.1, 0.15)
354 tone2 = self._apply_envelope(tone2, attack=0.001, decay=0.03,
355 sustain=0.4, release=0.05)
356
357 audio = np.concatenate([tone1, tone2])
358
359 self._save_wav(audio, filename)
360 return filename
361
362 def generate_click(self, filename: str = "click.wav",
363 click_type: str = "soft") -> str:
364 """
365 Generate a click/button sound.
366
367 Args:
368 filename: Output filename
369 click_type: Type - "soft", "hard", or "mechanical"
370
371 Returns:
372 Path to generated file
373 """
374 if click_type == "soft":
375 duration = 0.03
376 audio = self._generate_sine_wave(1000, duration, 0.3)
377 audio += self._generate_sine_wave(2000, duration, 0.15)
378
379 elif click_type == "hard":
380 duration = 0.02
381 audio = self._generate_sine_wave(1500, duration, 0.5)
382 audio += self._generate_sine_wave(3000, duration, 0.2)
383
384 else: # mechanical
385 duration = 0.04
386 audio = self._generate_sine_wave(800, duration, 0.4)
387 audio += self._generate_sine_wave(400, duration, 0.3)
388
389 audio = self._apply_envelope(audio, attack=0.001, decay=0.005,
390 sustain=0.2, release=0.01)
391
392 self._save_wav(audio, filename)
393 return filename
394
395 def generate_cash_register(self, filename: str = "cash_register.wav",
396 register_type: str = "classic") -> str:
397 """
398 Generate a cash register sound.
399
400 Args:
401 filename: Output filename
402 register_type: Type - "classic", "modern", or "cha-ching"
403
404 Returns:
405 Path to generated file
406 """
407 if register_type == "classic":
408 # Classic mechanical register with bell at the end
409 segments = []
410
411 # Drawer opening sound - low mechanical rumble
412 rumble_duration = 0.3
413 rumble = self._generate_sine_wave(120, rumble_duration, 0.2)
414 rumble += self._generate_sine_wave(180, rumble_duration, 0.15)
415 rumble = self._apply_envelope(rumble, attack=0.01, decay=0.1,
416 sustain=0.6, release=0.1)
417 segments.append(rumble)
418
419 # Brief pause
420 segments.append(np.zeros(int(self.sample_rate * 0.05)))
421
422 # Register bell "cha-ching"
423 # "Cha" - metallic hit
424 cha_duration = 0.15
425 cha = self._generate_sine_wave(800, cha_duration, 0.4)
426 cha += self._generate_sine_wave(1200, cha_duration, 0.3)
427 cha += self._generate_sine_wave(1600, cha_duration, 0.2)
428 cha = self._apply_envelope(cha, attack=0.001, decay=0.05,
429 sustain=0.3, release=0.08)
430 segments.append(cha)
431
432 # "Ching" - bell ring
433 ching_duration = 0.5
434 ching = self._generate_sine_wave(1200, ching_duration, 0.5)
435 ching += self._generate_sine_wave(2400, ching_duration, 0.3)
436 ching += self._generate_sine_wave(3600, ching_duration, 0.2)
437 ching = self._apply_envelope(ching, attack=0.001, decay=0.2,
438 sustain=0.2, release=0.3)
439 segments.append(ching)
440
441 audio = np.concatenate(segments)
442
443 elif register_type == "modern":
444 # Modern electronic register beep
445 segments = []
446
447 # Quick beep
448 beep = self._generate_sine_wave(1000, 0.1, 0.4)
449 beep = self._apply_envelope(beep, attack=0.001, decay=0.02,
450 sustain=0.7, release=0.05)
451 segments.append(beep)
452
453 # Short pause
454 segments.append(np.zeros(int(self.sample_rate * 0.05)))
455
456 # Confirmation tone - ascending notes
457 note1 = self._generate_sine_wave(800, 0.08, 0.3)
458 note1 = self._apply_envelope(note1, attack=0.001, decay=0.02,
459 sustain=0.5, release=0.04)
460 segments.append(note1)
461
462 note2 = self._generate_sine_wave(1200, 0.1, 0.35)
463 note2 = self._apply_envelope(note2, attack=0.001, decay=0.03,
464 sustain=0.5, release=0.05)
465 segments.append(note2)
466
467 audio = np.concatenate(segments)
468
469 else: # cha-ching
470 # Classic "cha-ching" bell sound only
471 segments = []
472
473 # "Cha" - quick metallic percussion
474 cha_duration = 0.1
475 cha = self._generate_sine_wave(900, cha_duration, 0.45)
476 cha += self._generate_sine_wave(1350, cha_duration, 0.35)
477 cha += self._generate_sine_wave(1800, cha_duration, 0.25)
478 cha = self._apply_envelope(cha, attack=0.001, decay=0.03,
479 sustain=0.4, release=0.06)
480 segments.append(cha)
481
482 # Very brief pause
483 segments.append(np.zeros(int(self.sample_rate * 0.02)))
484
485 # "Ching" - resonant bell
486 ching_duration = 0.6
487 ching = self._generate_sine_wave(1400, ching_duration, 0.5)
488 ching += self._generate_sine_wave(2800, ching_duration, 0.35)
489 ching += self._generate_sine_wave(4200, ching_duration, 0.2)
490 ching += self._generate_sine_wave(5600, ching_duration, 0.1)
491 ching = self._apply_envelope(ching, attack=0.001, decay=0.25,
492 sustain=0.15, release=0.35)
493 segments.append(ching)
494
495 audio = np.concatenate(segments)
496
497 self._save_wav(audio, filename)
498 return filename
499
500 def generate_alarm(self, filename: str = "alarm.wav",
501 alarm_type: str = "wake-up") -> str:
502 """
503 Generate an alarm sound.
504
505 Args:
506 filename: Output filename
507 alarm_type: Type - "wake-up", "timer", or "emergency"
508
509 Returns:
510 Path to generated file
511 """
512 if alarm_type == "wake-up":
513 # Gentle escalating alarm
514 segments = []
515
516 # Gradual beeping with increasing intensity
517 for i in range(4):
518 beep_duration = 0.3
519 amplitude = 0.2 + (i * 0.1)
520
521 beep = self._generate_sine_wave(800, beep_duration, amplitude)
522 beep += self._generate_sine_wave(1600, beep_duration, amplitude * 0.5)
523 beep = self._apply_envelope(beep, attack=0.01, decay=0.1,
524 sustain=0.7, release=0.1)
525 segments.append(beep)
526
527 # Pause between beeps (decreasing)
528 pause_duration = 0.5 - (i * 0.1)
529 segments.append(np.zeros(int(self.sample_rate * pause_duration)))
530
531 audio = np.concatenate(segments)
532
533 elif alarm_type == "timer":
534 # Simple repeating beep
535 segments = []
536
537 for _ in range(3):
538 beep = self._generate_sine_wave(1000, 0.2, 0.4)
539 beep = self._apply_envelope(beep, attack=0.01, decay=0.05,
540 sustain=0.8, release=0.05)
541 segments.append(beep)
542 segments.append(np.zeros(int(self.sample_rate * 0.2)))
543
544 audio = np.concatenate(segments)
545
546 else: # emergency
547 # Urgent alternating tones (siren-like)
548 segments = []
549
550 for i in range(6):
551 freq = 800 if i % 2 == 0 else 600
552 tone = self._generate_sine_wave(freq, 0.25, 0.5)
553 tone = self._apply_envelope(tone, attack=0.01, decay=0.05,
554 sustain=0.9, release=0.02)
555 segments.append(tone)
556
557 audio = np.concatenate(segments)
558
559 self._save_wav(audio, filename)
560 return filename
561
562 def generate_phone(self, filename: str = "phone.wav",
563 phone_type: str = "ringtone") -> str:
564 """
565 Generate phone sounds.
566
567 Args:
568 filename: Output filename
569 phone_type: Type - "ringtone", "busy", or "dial-tone"
570
571 Returns:
572 Path to generated file
573 """
574 if phone_type == "ringtone":
575 # Classic phone ring - two bursts
576 segments = []
577
578 for _ in range(2):
579 # Ring burst
580 ring_duration = 0.4
581 ring = self._generate_sine_wave(440, ring_duration, 0.4)
582 ring += self._generate_sine_wave(880, ring_duration, 0.3)
583
584 # Vibrato effect
585 t = np.linspace(0, ring_duration, int(self.sample_rate * ring_duration), False)
586 vibrato = 1 + 0.1 * np.sin(2 * np.pi * 20 * t)
587 ring = ring * vibrato
588
589 ring = self._apply_envelope(ring, attack=0.01, decay=0.1,
590 sustain=0.8, release=0.1)
591 segments.append(ring)
592 segments.append(np.zeros(int(self.sample_rate * 0.2)))
593
594 # Pause before next ring cycle
595 segments.append(np.zeros(int(self.sample_rate * 1.0)))
596
597 audio = np.concatenate(segments)
598
599 elif phone_type == "busy":
600 # Busy signal - alternating on/off
601 segments = []
602
603 for _ in range(4):
604 tone = self._generate_sine_wave(480, 0.25, 0.4)
605 tone += self._generate_sine_wave(620, 0.25, 0.4)
606 segments.append(tone)
607 segments.append(np.zeros(int(self.sample_rate * 0.25)))
608
609 audio = np.concatenate(segments)
610
611 else: # dial-tone
612 # Continuous dual tone
613 duration = 2.0
614 audio = self._generate_sine_wave(350, duration, 0.3)
615 audio += self._generate_sine_wave(440, duration, 0.3)
616
617 self._save_wav(audio, filename)
618 return filename
619
620 def generate_game_sound(self, filename: str = "game.wav",
621 game_type: str = "power-up") -> str:
622 """
623 Generate game sound effects.
624
625 Args:
626 filename: Output filename
627 game_type: Type - "power-up", "level-up", "game-over", "jump", or "laser"
628
629 Returns:
630 Path to generated file
631 """
632 if game_type == "power-up":
633 # Ascending arpeggio
634 notes = [262, 330, 392, 523] # C, E, G, C
635 segments = []
636
637 for note in notes:
638 tone = self._generate_sine_wave(note, 0.08, 0.3)
639 tone += self._generate_sine_wave(note * 2, 0.08, 0.15)
640 tone = self._apply_envelope(tone, attack=0.001, decay=0.02,
641 sustain=0.5, release=0.03)
642 segments.append(tone)
643
644 audio = np.concatenate(segments)
645
646 elif game_type == "level-up":
647 # Triumphant fanfare
648 notes = [523, 659, 784, 1047] # C, E, G, C (higher octave)
649 segments = []
650
651 for i, note in enumerate(notes):
652 duration = 0.15 if i < 3 else 0.3
653 tone = self._generate_sine_wave(note, duration, 0.35)
654 tone += self._generate_sine_wave(note * 2, duration, 0.2)
655 tone = self._apply_envelope(tone, attack=0.001, decay=0.05,
656 sustain=0.7, release=0.1)
657 segments.append(tone)
658
659 audio = np.concatenate(segments)
660
661 elif game_type == "game-over":
662 # Descending sad melody
663 notes = [392, 349, 330, 262] # G, F, E, C
664 segments = []
665
666 for note in notes:
667 tone = self._generate_sine_wave(note, 0.3, 0.3)
668 tone = self._apply_envelope(tone, attack=0.01, decay=0.1,
669 sustain=0.7, release=0.15)
670 segments.append(tone)
671
672 audio = np.concatenate(segments)
673
674 elif game_type == "jump":
675 # Quick rising pitch
676 duration = 0.15
677 t = np.linspace(0, duration, int(self.sample_rate * duration), False)
678
679 # Frequency sweep from 200 to 600 Hz
680 freq_sweep = 200 + 400 * t / duration
681 phase = 2 * np.pi * np.cumsum(freq_sweep) / self.sample_rate
682 audio = 0.3 * np.sin(phase)
683
684 audio = self._apply_envelope(audio, attack=0.001, decay=0.05,
685 sustain=0.3, release=0.08)
686
687 else: # laser
688 # Quick descending pitch with harmonics
689 duration = 0.2
690 t = np.linspace(0, duration, int(self.sample_rate * duration), False)
691
692 # Frequency sweep from 1200 to 300 Hz
693 freq_sweep = 1200 - 900 * t / duration
694 phase = 2 * np.pi * np.cumsum(freq_sweep) / self.sample_rate
695 audio = 0.4 * np.sin(phase)
696
697 # Add harmonic
698 freq_sweep2 = 2400 - 1800 * t / duration
699 phase2 = 2 * np.pi * np.cumsum(freq_sweep2) / self.sample_rate
700 audio += 0.2 * np.sin(phase2)
701
702 audio = self._apply_envelope(audio, attack=0.001, decay=0.05,
703 sustain=0.4, release=0.12)
704
705 self._save_wav(audio, filename)
706 return filename
707
708 def generate_swoosh(self, filename: str = "swoosh.wav",
709 swoosh_type: str = "medium") -> str:
710 """
711 Generate swoosh/whoosh transition sounds.
712
713 Args:
714 filename: Output filename
715 swoosh_type: Type - "short", "medium", or "long"
716
717 Returns:
718 Path to generated file
719 """
720 if swoosh_type == "short":
721 duration = 0.15
722 elif swoosh_type == "medium":
723 duration = 0.3
724 else: # long
725 duration = 0.5
726
727 t = np.linspace(0, duration, int(self.sample_rate * duration), False)
728
729 # Frequency sweep from high to low (whoosh effect)
730 freq_sweep = 2000 - 1500 * t / duration
731 phase = 2 * np.pi * np.cumsum(freq_sweep) / self.sample_rate
732
733 # Create noise-like quality with multiple harmonics
734 audio = 0.2 * np.sin(phase)
735 audio += 0.15 * np.sin(phase * 1.5)
736 audio += 0.1 * np.sin(phase * 2.3)
737
738 # Add some noise
739 noise = np.random.uniform(-0.05, 0.05, len(audio))
740 audio += noise
741
742 # Smooth envelope
743 audio = self._apply_envelope(audio, attack=0.01, decay=0.1,
744 sustain=0.5, release=0.2)
745
746 self._save_wav(audio, filename)
747 return filename
748
749 def generate_system_beep(self, filename: str = "system_beep.wav",
750 beep_type: str = "info") -> str:
751 """
752 Generate system error/warning beeps.
753
754 Args:
755 filename: Output filename
756 beep_type: Type - "info", "warning", "error", or "critical"
757
758 Returns:
759 Path to generated file
760 """
761 if beep_type == "info":
762 # Single pleasant beep
763 audio = self._generate_sine_wave(800, 0.1, 0.3)
764 audio = self._apply_envelope(audio, attack=0.001, decay=0.03,
765 sustain=0.6, release=0.05)
766
767 elif beep_type == "warning":
768 # Double beep
769 beep1 = self._generate_sine_wave(600, 0.08, 0.35)
770 beep1 = self._apply_envelope(beep1, attack=0.001, decay=0.02,
771 sustain=0.7, release=0.04)
772
773 pause = np.zeros(int(self.sample_rate * 0.05))
774
775 beep2 = self._generate_sine_wave(600, 0.08, 0.35)
776 beep2 = self._apply_envelope(beep2, attack=0.001, decay=0.02,
777 sustain=0.7, release=0.04)
778
779 audio = np.concatenate([beep1, pause, beep2])
780
781 elif beep_type == "error":
782 # Low harsh beep
783 audio = self._generate_sine_wave(300, 0.3, 0.4)
784 audio += self._generate_sine_wave(450, 0.3, 0.3)
785 audio = self._apply_envelope(audio, attack=0.01, decay=0.05,
786 sustain=0.8, release=0.1)
787
788 else: # critical
789 # Urgent repeated beeps
790 segments = []
791 for _ in range(3):
792 beep = self._generate_sine_wave(400, 0.1, 0.45)
793 beep = self._apply_envelope(beep, attack=0.001, decay=0.02,
794 sustain=0.8, release=0.03)
795 segments.append(beep)
796 segments.append(np.zeros(int(self.sample_rate * 0.05)))
797
798 audio = np.concatenate(segments)
799
800 self._save_wav(audio, filename)
801 return filename
802
803 def generate_keyboard(self, filename: str = "keyboard.wav",
804 key_type: str = "mechanical") -> str:
805 """
806 Generate keyboard/typing sounds.
807
808 Args:
809 filename: Output filename
810 key_type: Type - "mechanical", "soft", or "typewriter"
811
812 Returns:
813 Path to generated file
814 """
815 if key_type == "mechanical":
816 # Sharp click with resonance
817 duration = 0.03
818 audio = self._generate_sine_wave(1500, duration, 0.3)
819 audio += self._generate_sine_wave(3000, duration, 0.2)
820 audio += self._generate_sine_wave(4500, duration, 0.1)
821
822 # Add noise for texture
823 noise = np.random.uniform(-0.05, 0.05, len(audio))
824 audio += noise
825
826 audio = self._apply_envelope(audio, attack=0.001, decay=0.01,
827 sustain=0.2, release=0.015)
828
829 elif key_type == "soft":
830 # Gentle tap
831 duration = 0.02
832 audio = self._generate_sine_wave(800, duration, 0.2)
833 audio += self._generate_sine_wave(1600, duration, 0.1)
834 audio = self._apply_envelope(audio, attack=0.001, decay=0.005,
835 sustain=0.3, release=0.01)
836
837 else: # typewriter
838 # Classic typewriter clack
839 duration = 0.04
840
841 # Initial impact
842 impact = self._generate_sine_wave(1200, 0.01, 0.4)
843 impact += self._generate_sine_wave(2400, 0.01, 0.2)
844
845 # Resonance
846 resonance = self._generate_sine_wave(800, 0.03, 0.15)
847 resonance = self._apply_envelope(resonance, attack=0.001, decay=0.01,
848 sustain=0.3, release=0.015)
849
850 audio = np.concatenate([impact, resonance])
851
852 self._save_wav(audio, filename)
853 return filename
854
855 def generate_camera_shutter(self, filename: str = "camera_shutter.wav") -> str:
856 """
857 Generate a camera shutter sound.
858
859 Args:
860 filename: Output filename
861
862 Returns:
863 Path to generated file
864 """
865 segments = []
866
867 # Shutter opening - quick mechanical sound
868 open_sound = self._generate_sine_wave(800, 0.03, 0.3)
869 open_sound += self._generate_sine_wave(1200, 0.03, 0.2)
870
871 # Add noise for mechanical texture
872 noise1 = np.random.uniform(-0.1, 0.1, len(open_sound))
873 open_sound += noise1
874
875 open_sound = self._apply_envelope(open_sound, attack=0.001, decay=0.01,
876 sustain=0.3, release=0.015)
877 segments.append(open_sound)
878
879 # Very brief pause
880 segments.append(np.zeros(int(self.sample_rate * 0.02)))
881
882 # Shutter closing
883 close_sound = self._generate_sine_wave(700, 0.025, 0.25)
884 close_sound += self._generate_sine_wave(1100, 0.025, 0.15)
885
886 noise2 = np.random.uniform(-0.08, 0.08, len(close_sound))
887 close_sound += noise2
888
889 close_sound = self._apply_envelope(close_sound, attack=0.001, decay=0.008,
890 sustain=0.2, release=0.012)
891 segments.append(close_sound)
892
893 audio = np.concatenate(segments)
894
895 self._save_wav(audio, filename)
896 return filename
897
898 def generate_lock(self, filename: str = "lock.wav",
899 lock_type: str = "unlock") -> str:
900 """
901 Generate lock/unlock sounds.
902
903 Args:
904 filename: Output filename
905 lock_type: Type - "lock" or "unlock"
906
907 Returns:
908 Path to generated file
909 """
910 segments = []
911
912 if lock_type == "lock":
913 # Descending pitch - closing/locking
914 click = self._generate_sine_wave(1000, 0.05, 0.3)
915 click += self._generate_sine_wave(500, 0.05, 0.2)
916 click = self._apply_envelope(click, attack=0.001, decay=0.015,
917 sustain=0.3, release=0.025)
918 segments.append(click)
919
920 # Mechanical settling
921 settle = self._generate_sine_wave(300, 0.08, 0.15)
922 settle = self._apply_envelope(settle, attack=0.01, decay=0.03,
923 sustain=0.4, release=0.03)
924 segments.append(settle)
925
926 else: # unlock
927 # Ascending pitch - opening/unlocking
928 click = self._generate_sine_wave(500, 0.05, 0.3)
929 click += self._generate_sine_wave(1000, 0.05, 0.25)
930 click = self._apply_envelope(click, attack=0.001, decay=0.015,
931 sustain=0.3, release=0.025)
932 segments.append(click)
933
934 # Release sound
935 release = self._generate_sine_wave(1200, 0.06, 0.2)
936 release = self._apply_envelope(release, attack=0.005, decay=0.02,
937 sustain=0.3, release=0.03)
938 segments.append(release)
939
940 audio = np.concatenate(segments)
941
942 self._save_wav(audio, filename)
943 return filename
944
945 def generate_tick_tock(self, filename: str = "tick_tock.wav",
946 cycles: int = 3) -> str:
947 """
948 Generate tick-tock clock sound.
949
950 Args:
951 filename: Output filename
952 cycles: Number of tick-tock cycles
953
954 Returns:
955 Path to generated file
956 """
957 segments = []
958
959 for _ in range(cycles):
960 # Tick - higher pitch
961 tick = self._generate_sine_wave(1200, 0.02, 0.25)
962 tick += self._generate_sine_wave(2400, 0.02, 0.12)
963 tick = self._apply_envelope(tick, attack=0.001, decay=0.005,
964 sustain=0.2, release=0.01)
965 segments.append(tick)
966
967 # Pause
968 segments.append(np.zeros(int(self.sample_rate * 0.48)))
969
970 # Tock - lower pitch
971 tock = self._generate_sine_wave(1000, 0.02, 0.25)
972 tock += self._generate_sine_wave(2000, 0.02, 0.12)
973 tock = self._apply_envelope(tock, attack=0.001, decay=0.005,
974 sustain=0.2, release=0.01)
975 segments.append(tock)
976
977 # Pause
978 segments.append(np.zeros(int(self.sample_rate * 0.48)))
979
980 audio = np.concatenate(segments)
981
982 self._save_wav(audio, filename)
983 return filename
984
985 def generate_bubble(self, filename: str = "bubble.wav",
986 bubble_type: str = "pop") -> str:
987 """
988 Generate bubble/pop sounds.
989
990 Args:
991 filename: Output filename
992 bubble_type: Type - "pop", "small", or "large"
993
994 Returns:
995 Path to generated file
996 """
997 if bubble_type == "pop":
998 # Quick high-pitched pop
999 duration = 0.08
1000 t = np.linspace(0, duration, int(self.sample_rate * duration), False)
1001
1002 # Quick frequency drop
1003 freq_sweep = 1500 - 1200 * t / duration
1004 phase = 2 * np.pi * np.cumsum(freq_sweep) / self.sample_rate
1005 audio = 0.3 * np.sin(phase)
1006
1007 audio = self._apply_envelope(audio, attack=0.001, decay=0.02,
1008 sustain=0.1, release=0.05)
1009
1010 elif bubble_type == "small":
1011 # Tiny bubble sound
1012 audio = self._generate_sine_wave(2000, 0.05, 0.2)
1013 audio += self._generate_sine_wave(3000, 0.05, 0.1)
1014 audio = self._apply_envelope(audio, attack=0.001, decay=0.01,
1015 sustain=0.2, release=0.03)
1016
1017 else: # large
1018 # Bigger, deeper bubble
1019 duration = 0.12
1020 t = np.linspace(0, duration, int(self.sample_rate * duration), False)
1021
1022 freq_sweep = 800 - 400 * t / duration
1023 phase = 2 * np.pi * np.cumsum(freq_sweep) / self.sample_rate
1024 audio = 0.35 * np.sin(phase)
1025 audio += 0.15 * np.sin(phase * 2)
1026
1027 audio = self._apply_envelope(audio, attack=0.001, decay=0.03,
1028 sustain=0.2, release=0.08)
1029
1030 self._save_wav(audio, filename)
1031 return filename