askrobots / dbbasic-sound
Public
Generates royalty-free sound effects in Python: bells, buzzers, doorbells, notifications and more.
sound_generator.py · 36.7 KB · 1031 lines
| 1 | """ |
| 2 | Royalty-Free Sound Generator |
| 3 | Generate various sound effects for web and desktop applications. |
| 4 | """ |
| 5 | |
| 6 | import numpy as np |
| 7 | import wave |
| 8 | import struct |
| 9 | from typing import Tuple, Optional |
| 10 | from pathlib import Path |
| 11 | |
| 12 | |
| 13 | class 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 |