cacophony 0.1.5 → 0.1.6

package/README.md

@@ -86,9 +86,10 @@ Resumes audio by restoring the global volume to its preceding value.
 
 ### Shared Methods Across Sound Sources
 
-All classes representing sound sources (`Sound`, `Playback`, `Group`) offer the following methods for a consistent interface and user-friendly experience:
+All classes representing sound sources (`Sound`, `Playback`, `Group`) and the `BaseSound` interface offer the following methods for a consistent interface and user-friendly experience:
 
 - `play()`
+- `seek(time: number)`: Seeks the current playback to the specified time in seconds.
 - `stop()`
 - `pause()`
 - `resume()`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cacophony",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Typescript audio library with caching",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -8,7 +8,8 @@
     "build": "npm run clean && tsc --build",
     "clean": "tsc --build --clean",
     "prepublishOnly": "npm run build",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "jest",
+    "ci:test": "jest --no-color --ci"
   },
   "keywords": [
     "audio",
@@ -16,10 +17,21 @@
   ],
   "author": "Christopher Toth",
   "license": "ISC",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ctoth/cacophony.git"
+  },
   "devDependencies": {
+    "@types/jest": "^29.5.8",
+    "jest": "^29.7.0",
     "standardized-audio-context-mock": "^9.6.29",
+    "ts-jest": "^29.1.1",
     "typescript": "^5.1.6"
   },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node"
+  },
   "dependencies": {
     "standardized-audio-context": "^25.3.55"
   }

package/src/cacophony.test.ts

@@ -0,0 +1,23 @@
+import { Cacophony } from './cacophony';
+import { AudioContext } from 'standardized-audio-context-mock';
+
+let cacophony: Cacophony;
+let audioContextMock: AudioContext;
+
+beforeEach(() => {
+    audioContextMock = new AudioContext();
+    cacophony = new Cacophony(audioContextMock);
+});
+
+afterEach(() => {
+    audioContextMock.close();
+});
+
+test('Cacophony is created with the correct context', () => {
+    expect(cacophony.context).toBe(audioContextMock);
+});
+test('createSound creates a sound with the correct buffer', async () => {
+    const buffer = new AudioBuffer({ length: 100, sampleRate: 44100 });
+    const sound = await cacophony.createSound(buffer);
+    expect(sound.buffer).toBe(buffer);
+});

package/src/cacophony.ts

@@ -1,4 +1,4 @@
-import { AudioContext, IAudioBuffer, IAudioBufferSourceNode, IAudioListener, IBiquadFilterNode, IGainNode, IPannerNode } from 'standardized-audio-context';
+import { AudioContext, IAudioBuffer, IAudioBufferSourceNode, IAudioListener, IBiquadFilterNode, IGainNode, IMediaStreamAudioSourceNode, IPannerNode } from 'standardized-audio-context';
 import { CacheManager } from './cache';
 
 
@@ -7,6 +7,7 @@ type BiquadFilterNode = IBiquadFilterNode<AudioContext>;
 
 type AudioBufferSourceNode = IAudioBufferSourceNode<AudioContext>;
 type PannerNode = IPannerNode<AudioContext>;
+type MediaStreamAudioSourceNode = IMediaStreamAudioSourceNode<AudioContext>;
 
 export type Position = [number, number, number];
 
@@ -16,7 +17,8 @@ export type FadeType = 'linear' | 'exponential'
 
 export interface BaseSound {
     // the stuff you should be able to do with anything that makes sound including groups, sounds, and playbacks.
-    play(): Playback[];
+    play(): BaseSound[];
+    seek?(time: number): void;
     stop(): void;
     pause(): void;
     resume(): void;
@@ -24,7 +26,7 @@ export interface BaseSound {
     removeFilter(filter: BiquadFilterNode): void;
     volume: number;
     position: Position;
-    loop(loopCount?: LoopCount): LoopCount;
+    loop?(loopCount?: LoopCount): LoopCount;
 }
 
 export class Cacophony {
@@ -110,6 +112,20 @@ export class Cacophony {
         this.setGlobalVolume(this.prevVolume);
     }
 
+    getMicrophoneStream(): Promise<MicrophoneStream> {
+        return new Promise((resolve, reject) => {
+            navigator.mediaDevices.getUserMedia({ audio: true })
+                .then(stream => {
+                    const microphoneStream = new MicrophoneStream(this.context);
+                    microphoneStream.play();
+                    resolve(microphoneStream);
+                })
+                .catch(err => {
+                    reject(err);
+                });
+        });
+    }
+
 }
 
 
@@ -138,10 +154,14 @@ export class Sound extends FilterManager implements BaseSound {
     buffer: IAudioBuffer;
     context: AudioContext;
     playbacks: Playback[] = [];
-    globalGainNode: GainNode;
+    private globalGainNode: GainNode;
     private _position: Position = [0, 0, 0];
     loopCount: LoopCount = 0;
 
+    seek(time: number): void {
+        this.playbacks.forEach(playback => playback.seek(time));
+    }
+
     constructor(buffer: AudioBuffer, context: AudioContext, globalGainNode: IGainNode<AudioContext>) {
         super();
         this.buffer = buffer;
@@ -165,7 +185,7 @@ export class Sound extends FilterManager implements BaseSound {
 
     play(): Playback[] {
         const playback = this.preplay();
-        playback.forEach(p => p.source!.start());
+        playback.forEach(p => p.play());
         return playback;
     }
 
@@ -199,7 +219,7 @@ export class Sound extends FilterManager implements BaseSound {
             return this.loopCount;
         }
         this.loopCount = loopCount;
-        this.playbacks.forEach(p => p.source!.loop = true);
+        this.playbacks.forEach(p => p.sourceLoop = true);
         return this.loopCount;
     }
 
@@ -224,13 +244,27 @@ export class Sound extends FilterManager implements BaseSound {
 }
 
 class Playback extends FilterManager implements BaseSound {
-    context: AudioContext;
-    source?: AudioBufferSourceNode;
-    gainNode?: GainNode;
-    panner?: PannerNode;
+    private context: AudioContext;
+    private source?: AudioBufferSourceNode;
+    private gainNode?: GainNode;
+    private panner?: PannerNode;
     loopCount: LoopCount = 0;
     currentLoop: number = 0;
-    buffer: IAudioBuffer | null = null;
+    private buffer: IAudioBuffer | null = null;
+
+    seek(time: number): void {
+        if (!this.source || !this.buffer || !this.gainNode || !this.panner) {
+            throw new Error('Cannot seek a sound that has been cleaned up');
+        }
+        // Stop the current playback
+        this.source.stop();
+        // Create a new source to start from the desired time
+        this.source = this.context.createBufferSource();
+        this.source.buffer = this.buffer;
+        this.refreshFilters();
+        this.source.connect(this.panner).connect(this.gainNode);
+        this.source.start(0, time);
+    }
 
     constructor(source: AudioBufferSourceNode, gainNode: GainNode, context: AudioContext, loopCount: LoopCount = 0) {
         super();
@@ -277,6 +311,13 @@ class Playback extends FilterManager implements BaseSound {
         this.gainNode.gain.value = v;
     }
 
+    set sourceLoop(loop: boolean) {
+        if (!this.source) {
+            throw new Error('Cannot set loop on a sound that has been cleaned up');
+        }
+        this.source.loop = loop;
+    }
+
     fadeIn(time: number, fadeType: FadeType = 'linear'): Promise<void> {
         return new Promise(resolve => {
             if (!this.gainNode) {
@@ -429,6 +470,10 @@ export class Group implements BaseSound {
     private _position: Position = [0, 0, 0];
     loopCount: LoopCount = 0;
 
+    seek(time: number): void {
+        this.sounds.forEach(sound => sound.seek(time));
+    }
+
     addSound(sound: Sound): void {
         this.sounds.push(sound);
     }
@@ -498,3 +543,194 @@ export class Group implements BaseSound {
     }
 }
 
+export class StreamPlayback extends FilterManager implements BaseSound {
+    private context: AudioContext;
+    private source?: MediaStreamAudioSourceNode;
+    private gainNode?: GainNode;
+    private panner?: PannerNode;
+    loopCount: LoopCount = 0;
+    currentLoop: number = 0;
+
+    constructor(source: MediaStreamAudioSourceNode, gainNode: GainNode, context: AudioContext, loopCount: LoopCount = 0) {
+        super();
+        this.loopCount = loopCount;
+        this.source = source;
+        this.gainNode = gainNode;
+        this.context = context;
+        this.panner = context.createPanner();
+        source.connect(this.panner).connect(this.gainNode);
+        this.refreshFilters();
+    }
+
+    play() {
+        if (!this.source) {
+            throw new Error('Cannot play a sound that has been cleaned up');
+        }
+        return [this];
+    }
+
+    get volume(): number {
+        if (!this.gainNode) {
+            throw new Error('Cannot get volume of a sound that has been cleaned up');
+        }
+        return this.gainNode.gain.value;
+    }
+
+    set volume(v: number) {
+        if (!this.gainNode) {
+            throw new Error('Cannot set volume of a sound that has been cleaned up');
+        }
+        this.gainNode.gain.value = v;
+    }
+
+    stop(): void {
+        if (!this.source) {
+            throw new Error('Cannot stop a sound that has been cleaned up');
+        }
+        this.source.mediaStream.getTracks().forEach(track => track.stop());
+    }
+
+    pause(): void {
+        if (!this.source) {
+            throw new Error('Cannot pause a sound that has been cleaned up');
+        }
+        this.source.mediaStream.getTracks().forEach(track => track.enabled = false);
+    }
+
+    resume(): void {
+        if (!this.source) {
+            throw new Error('Cannot resume a sound that has been cleaned up');
+        }
+        this.source.mediaStream.getTracks().forEach(track => track.enabled = true);
+    }
+
+    addFilter(filter: BiquadFilterNode): void {
+        super.addFilter(filter);
+        this.refreshFilters();
+    }
+
+    removeFilter(filter: BiquadFilterNode): void {
+        super.removeFilter(filter);
+        this.refreshFilters();
+    }
+
+    set position(position: Position) {
+        if (!this.panner) {
+            throw new Error('Cannot move a sound that has been cleaned up');
+        }
+        const [x, y, z] = position;
+        this.panner.positionX.value = x;
+        this.panner.positionY.value = y;
+        this.panner.positionZ.value = z;
+    }
+
+    get position(): Position {
+        if (!this.panner) {
+            throw new Error('Cannot get position of a sound that has been cleaned up');
+        }
+        return [this.panner.positionX.value, this.panner.positionY.value, this.panner.positionZ.value];
+    }
+
+    private refreshFilters(): void {
+        if (!this.source || !this.gainNode) {
+            throw new Error('Cannot update filters on a sound that has been cleaned up');
+        }
+        let connection = this.source;
+        this.source.disconnect();
+        connection = this.applyFilters(connection);
+        connection.connect(this.gainNode);
+    }
+}
+
+export class MicrophoneStream extends FilterManager implements BaseSound {
+    context: AudioContext;
+    private _position: Position = [0, 0, 0];
+    loopCount: LoopCount = 0;
+    private prevVolume: number = 1;
+    private microphoneGainNode: GainNode;
+    private streamPlayback?: StreamPlayback;
+    private stream: MediaStream | undefined;
+    private streamSource?: MediaStreamAudioSourceNode;
+
+    constructor(context: AudioContext) {
+        super();
+        this.context = context;
+        this.microphoneGainNode = this.context.createGain();
+    }
+
+
+    play(): StreamPlayback[] {
+        if (!this.stream) {
+            navigator.mediaDevices.getUserMedia({ audio: true })
+                .then(stream => {
+                    this.stream = stream;
+                    this.streamSource = this.context.createMediaStreamSource(this.stream);
+                    this.streamPlayback = new StreamPlayback(this.streamSource, this.microphoneGainNode, this.context);
+                    this.streamPlayback.play();
+                })
+                .catch(err => {
+                    console.error('Error initializing microphone stream:', err);
+                });
+        }
+        return this.streamPlayback ? [this.streamPlayback] : [];
+    }
+
+    seek(time: number): void {
+        // Seeking is not applicable for live microphone stream
+    }
+
+    stop(): void {
+        if (this.streamPlayback) {
+            this.streamPlayback.stop();
+            this.streamPlayback = undefined;
+        }
+    }
+
+    pause(): void {
+        if (this.streamPlayback) {
+            this.streamPlayback.pause();
+        }
+    }
+
+    resume(): void {
+        if (this.streamPlayback) {
+            this.streamPlayback.resume();
+        }
+    }
+
+    addFilter(filter: BiquadFilterNode): void {
+        if (this.streamPlayback) {
+            this.streamPlayback.addFilter(filter);
+        }
+    }
+
+    removeFilter(filter: BiquadFilterNode): void {
+        if (this.streamPlayback) {
+            this.streamPlayback.removeFilter(filter);
+        }
+    }
+
+    get volume(): number {
+        return this.streamPlayback ? this.streamPlayback.volume : 0;
+    }
+
+    set volume(volume: number) {
+        if (this.streamPlayback) {
+            this.streamPlayback.volume = volume;
+        }
+    }
+
+    get position(): Position {
+        // Position is not applicable for live microphone stream
+        return [0, 0, 0];
+    }
+
+    set position(position: Position) {
+        // Position is not applicable for live microphone stream
+    }
+
+    loop(loopCount?: LoopCount): LoopCount {
+        // Looping is not applicable for live microphone stream
+        return 0;
+    }
+}