@newgameplusinc/odyssey-audio-video-sdk-dev 1.0.258 → 1.0.259

package/dist/types/events.d.ts

@@ -0,0 +1,154 @@
+/**
+ * SDK Event Types
+ */
+import { Participant, MediaState, ParticipantSnapshot } from './participant';
+import { Position, Direction } from './position';
+/**
+ * Participants snapshot event from server
+ */
+export interface ParticipantsSnapshotEvent {
+    roomId: string;
+    participants: ParticipantSnapshot[];
+}
+/**
+ * Room joined event data
+ */
+export interface RoomJoinedEvent {
+    roomId: string;
+    participantId: string;
+    participants: Participant[];
+    routerRtpCapabilities: any;
+    iceServers: any[];
+}
+/**
+ * Consumer created event data
+ */
+export interface ConsumerCreatedEvent {
+    participant: Participant;
+    track: MediaStreamTrack;
+    consumer: any;
+    isScreenshare?: boolean;
+    appData?: any;
+}
+/**
+ * Consumer closed event data
+ */
+export interface ConsumerClosedEvent {
+    consumerId: string;
+    participantId: string;
+    kind: string;
+    isScreenshare?: boolean;
+}
+/**
+ * Consumer paused event data
+ */
+export interface ConsumerPausedEvent {
+    consumerId: string;
+    participantId: string;
+}
+/**
+ * Consumer resumed event data
+ */
+export interface ConsumerResumedEvent {
+    consumerId: string;
+    participantId: string;
+}
+/**
+ * Participant joined event data
+ */
+export interface ParticipantJoinedEvent {
+    participantId: string;
+    userId: string;
+    deviceId: string;
+    position: Position;
+    direction: Direction;
+    mediaState: MediaState;
+    bodyHeight?: string;
+    bodyShape?: string;
+    userName?: string;
+    userEmail?: string;
+}
+/**
+ * Participant left event data
+ */
+export interface ParticipantLeftEvent {
+    participantId: string;
+}
+/**
+ * Participant position updated event data
+ */
+export interface ParticipantPositionEvent {
+    participantId: string;
+    conferenceId: string;
+    roomId: string;
+    position: Position;
+    direction: Direction;
+    mediaState: MediaState;
+    consumerIds: string[];
+    timestamp: number;
+    bodyHeight?: string;
+    bodyShape?: string;
+    userName?: string;
+    userEmail?: string;
+    currentChannel?: string;
+    rot?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    pan?: number;
+    dxLocal?: number;
+}
+/**
+ * Mute state changed event data
+ */
+export interface MuteStateChangedEvent {
+    participantId: string;
+    muted: boolean;
+}
+/**
+ * Huddle invite received event data
+ */
+export interface HuddleInviteReceivedEvent {
+    inviteId: string;
+    fromParticipantId: string;
+    fromUserName?: string;
+    huddleId?: string;
+}
+/**
+ * Huddle response event data
+ */
+export interface HuddleResponseEvent {
+    success: boolean;
+    huddleId?: string;
+    channelId?: string;
+    participants?: string[];
+    error?: string;
+}
+/**
+ * All SDK event types
+ */
+export type OdysseyEvent = "connected" | "disconnected" | "room-joined" | "all-participants-update" | "new-participant" | "participant-left" | "producer-created" | "consumer-created" | "consumer-closed" | "participant-media-state-updated" | "participant-position-updated" | "error" | "huddle-invite-received" | "private-huddle-started" | "huddle-updated" | "huddle-invite-rejected" | "huddle-ended" | "participant-channel-changed" | "mute-requested";
+/**
+ * Event map for type-safe event handling
+ */
+export interface OdysseyEventMap {
+    'connected': void;
+    'disconnected': void;
+    'room-joined': RoomJoinedEvent;
+    'all-participants-update': Participant[];
+    'new-participant': Participant;
+    'participant-left': string;
+    'consumer-created': ConsumerCreatedEvent;
+    'consumer-closed': ConsumerClosedEvent;
+    'participant-media-state-updated': Participant;
+    'participant-position-updated': Participant;
+    'error': Error;
+    'huddle-invite-received': HuddleInviteReceivedEvent;
+    'private-huddle-started': HuddleResponseEvent;
+    'huddle-updated': any;
+    'huddle-invite-rejected': any;
+    'huddle-ended': any;
+    'participant-channel-changed': any;
+    'mute-requested': any;
+}

package/dist/{types.js → types/events.js}

@@ -1,2 +1,5 @@
 "use strict";
+/**
+ * SDK Event Types
+ */
 Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Types module - Re-exports all type definitions
+ */
+export * from './position';
+export * from './participant';
+export * from './events';
+export * from './room';

package/dist/types/index.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * Types module - Re-exports all type definitions
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./position"), exports);
+__exportStar(require("./participant"), exports);
+__exportStar(require("./events"), exports);
+__exportStar(require("./room"), exports);

package/dist/types/participant.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Participant Types
+ */
+import { Position, Direction } from './position';
+/**
+ * Media state for a participant
+ */
+export interface MediaState {
+    audio: boolean;
+    video: boolean;
+    sharescreen: boolean;
+}
+/**
+ * Full participant data
+ */
+export interface Participant {
+    participantId: string;
+    userId: string;
+    deviceId: string;
+    name?: string;
+    avatarUrl?: string;
+    isLocal: boolean;
+    audioTrack?: MediaStreamTrack;
+    videoTrack?: MediaStreamTrack;
+    producers: Map<string, any>;
+    consumers: Map<string, any>;
+    position: Position;
+    direction: Direction;
+    mediaState: MediaState;
+    rot?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    pan?: number;
+    dxLocal?: number;
+    bodyHeight?: string;
+    bodyShape?: string;
+    userName?: string;
+    userEmail?: string;
+    currentChannel?: string;
+}
+/**
+ * Participant snapshot from server updates
+ */
+export interface ParticipantSnapshot {
+    participantId: string;
+    userId: string;
+    deviceId: string;
+    position: Position;
+    direction: Direction;
+    rot?: {
+        x: number;
+        y: number;
+        z: number;
+    };
+    pan?: number;
+    dxLocal?: number;
+    bodyHeight: string;
+    bodyShape: string;
+    userName: string;
+    userEmail: string;
+    mediaState: MediaState;
+    currentChannel?: string;
+}

package/dist/types/participant.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Participant Types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/position.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Position and Direction Types
+ *
+ * Coordinate system conventions:
+ * - Unreal Engine: X=forward, Y=right, Z=up (centimeters)
+ * - Standard/WebAudio: X=right, Y=up, Z=forward (meters)
+ */
+/**
+ * 3D position in space
+ */
+export interface Position {
+    x: number;
+    y: number;
+    z: number;
+}
+/**
+ * 3D direction vector (normalized)
+ */
+export interface Direction {
+    x: number;
+    y: number;
+    z: number;
+}
+/**
+ * Rotation in degrees (Euler angles)
+ */
+export interface Rotation {
+    x: number;
+    y: number;
+    z: number;
+}
+/**
+ * Listener right-ear vector (2D projection on XZ plane)
+ * Used for stereo panning calculations
+ */
+export interface ListenerRight {
+    x: number;
+    z: number;
+}
+/**
+ * Position in Unreal Engine coordinates (centimeters)
+ */
+export type UnrealPosition = Position;
+/**
+ * Position in standard coordinates (meters)
+ */
+export type StandardPosition = Position;

package/dist/types/position.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Position and Direction Types
+ *
+ * Coordinate system conventions:
+ * - Unreal Engine: X=forward, Y=right, Z=up (centimeters)
+ * - Standard/WebAudio: X=right, Y=up, Z=forward (meters)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/room.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Room and Transport Types
+ */
+import { Participant } from './participant';
+import { Position, Direction } from './position';
+/**
+ * Room state
+ */
+export interface Room {
+    id: string;
+    participants: Map<string, Participant>;
+}
+/**
+ * Room joined data from server
+ */
+export interface RoomJoinedData {
+    participants: Participant[];
+    routerRtpCapabilities: any;
+    participantId: string;
+    roomId: string;
+    iceServers: any[];
+}
+/**
+ * Join room request data
+ */
+export interface JoinRoomData {
+    roomId: string;
+    userId: string;
+    deviceId: string;
+    participantId?: string;
+    position: Position;
+    direction: Direction;
+    bodyHeight?: string;
+    bodyShape?: string;
+    userName?: string;
+    userEmail?: string;
+}
+/**
+ * Consumer created data from server
+ */
+export interface ConsumerCreatedData {
+    consumerId: string;
+    producerId: string;
+    kind: 'audio' | 'video';
+    rtpParameters: any;
+    participantId: string;
+    conferenceId: string;
+    roomId: string;
+    position: Position;
+    direction: Direction;
+    mediaState: {
+        audio: boolean;
+        video: boolean;
+        sharescreen: boolean;
+    };
+    timestamp: number;
+    bodyHeight?: string;
+    bodyShape?: string;
+    userName?: string;
+    userEmail?: string;
+    appData?: {
+        isScreenshare?: boolean;
+    };
+}
+/**
+ * WebRTC transport options
+ */
+export interface TransportOptions {
+    id: string;
+    iceParameters: any;
+    iceCandidates: any[];
+    dtlsParameters: any;
+}
+/**
+ * Producer options
+ */
+export interface ProducerOptions {
+    track: MediaStreamTrack;
+    appData?: {
+        isScreenshare?: boolean;
+    };
+}

package/dist/types/room.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Room and Transport Types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/audio/clarity-score.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Clarity Score Calculations
+ *
+ * Functions for calculating voice clarity based on distance and direction
+ */
+import { Position } from '../../types/position';
+/**
+ * Calculate clarity score based on distance and direction
+ * Used for adjusting audio quality based on proximity and facing direction
+ *
+ * @param distance Distance to source
+ * @param vectorToSource Vector from listener to source
+ * @param listenerForward Listener's forward direction (optional)
+ * @returns Clarity score from 0 to 1
+ */
+export declare function calculateClarityScore(distance: number, vectorToSource: Position, listenerForward?: Position): number;
+/**
+ * Calculate proximity weight based on distance
+ *
+ * @param distance Distance in meters
+ * @param closeRange Distance for full weight (default: 0.85m)
+ * @param fadeRange Distance for zero weight (default: 18m)
+ * @returns Weight from 0 to 1
+ */
+export declare function calculateProximityWeight(distance: number, closeRange?: number, fadeRange?: number): number;
+/**
+ * Normalize a vector to unit length
+ *
+ * @param vector Vector to normalize
+ * @param fallback Fallback if vector is zero length
+ * @returns Normalized vector
+ */
+export declare function normalizeVector(vector: Position, fallback?: Position): Position;

package/dist/utils/audio/clarity-score.js

@@ -0,0 +1,81 @@
+"use strict";
+/**
+ * Clarity Score Calculations
+ *
+ * Functions for calculating voice clarity based on distance and direction
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateClarityScore = calculateClarityScore;
+exports.calculateProximityWeight = calculateProximityWeight;
+exports.normalizeVector = normalizeVector;
+/**
+ * Calculate clarity score based on distance and direction
+ * Used for adjusting audio quality based on proximity and facing direction
+ *
+ * @param distance Distance to source
+ * @param vectorToSource Vector from listener to source
+ * @param listenerForward Listener's forward direction (optional)
+ * @returns Clarity score from 0 to 1
+ */
+function calculateClarityScore(distance, vectorToSource, listenerForward) {
+    const proximityWeight = calculateProximityWeight(distance);
+    const focusWeight = listenerForward
+        ? calculateDirectionFocus(vectorToSource, listenerForward)
+        : 0.5;
+    return clamp(0.2 + proximityWeight * 0.6 + focusWeight * 0.2, 0, 1);
+}
+/**
+ * Calculate proximity weight based on distance
+ *
+ * @param distance Distance in meters
+ * @param closeRange Distance for full weight (default: 0.85m)
+ * @param fadeRange Distance for zero weight (default: 18m)
+ * @returns Weight from 0 to 1
+ */
+function calculateProximityWeight(distance, closeRange = 0.85, fadeRange = 18) {
+    if (distance <= closeRange) {
+        return 1;
+    }
+    if (distance >= fadeRange) {
+        return 0;
+    }
+    return 1 - (distance - closeRange) / (fadeRange - closeRange);
+}
+/**
+ * Calculate direction focus weight
+ * How much the listener is facing the source
+ *
+ * @param vectorToSource Vector from listener to source
+ * @param listenerForward Listener's forward direction
+ * @returns Focus weight from 0 to 1
+ */
+function calculateDirectionFocus(vectorToSource, listenerForward) {
+    const forward = normalizeVector(listenerForward);
+    const source = normalizeVector(vectorToSource, { x: 0, y: 0, z: 1 });
+    const dot = forward.x * source.x + forward.y * source.y + forward.z * source.z;
+    return clamp((dot + 1) / 2, 0, 1);
+}
+/**
+ * Normalize a vector to unit length
+ *
+ * @param vector Vector to normalize
+ * @param fallback Fallback if vector is zero length
+ * @returns Normalized vector
+ */
+function normalizeVector(vector, fallback = { x: 0, y: 0, z: 1 }) {
+    const length = Math.hypot(vector.x, vector.y, vector.z);
+    if (length < 1e-4) {
+        return { ...fallback };
+    }
+    return {
+        x: vector.x / length,
+        y: vector.y / length,
+        z: vector.z / length,
+    };
+}
+/**
+ * Clamp value between min and max
+ */
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}

package/dist/utils/audio/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Audio utilities - Re-exports all audio utility functions
+ */
+export * from './clarity-score';
+export * from './voice-filter';

package/dist/utils/audio/index.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Audio utilities - Re-exports all audio utility functions
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./clarity-score"), exports);
+__exportStar(require("./voice-filter"), exports);

package/dist/utils/audio/voice-filter.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Voice Filter Calculations
+ *
+ * Functions for adaptive voice filtering
+ */
+/**
+ * Calculate adaptive highpass frequency based on voice characteristics
+ * Analyzes audio spectrum and returns optimal highpass cutoff (85-300Hz)
+ *
+ * @param frequencyData Frequency data from AnalyserNode
+ * @param sampleRate Audio sample rate
+ * @returns Optimal highpass frequency
+ */
+export declare function calculateAdaptiveHighpass(frequencyData: Uint8Array, sampleRate: number): number;
+/**
+ * Voice filter chain configuration
+ */
+export interface VoiceFilterChain {
+    highpass: BiquadFilterNode;
+    lowpass: BiquadFilterNode;
+    voiceBand: BiquadFilterNode;
+    dynamicLowpass: BiquadFilterNode;
+}
+/**
+ * Create a voice-optimized filter chain
+ *
+ * @param audioContext AudioContext
+ * @returns Filter chain nodes
+ */
+export declare function createVoiceFilterChain(audioContext: AudioContext): VoiceFilterChain;

package/dist/utils/audio/voice-filter.js

@@ -0,0 +1,70 @@
+"use strict";
+/**
+ * Voice Filter Calculations
+ *
+ * Functions for adaptive voice filtering
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateAdaptiveHighpass = calculateAdaptiveHighpass;
+exports.createVoiceFilterChain = createVoiceFilterChain;
+/**
+ * Calculate adaptive highpass frequency based on voice characteristics
+ * Analyzes audio spectrum and returns optimal highpass cutoff (85-300Hz)
+ *
+ * @param frequencyData Frequency data from AnalyserNode
+ * @param sampleRate Audio sample rate
+ * @returns Optimal highpass frequency
+ */
+function calculateAdaptiveHighpass(frequencyData, sampleRate) {
+    const bufferLength = frequencyData.length;
+    const nyquist = sampleRate / 2;
+    const binWidth = nyquist / bufferLength;
+    let weightedSum = 0;
+    let totalEnergy = 0;
+    const maxBin = Math.floor(500 / binWidth); // Only analyze up to 500Hz
+    for (let i = 0; i < Math.min(maxBin, bufferLength); i++) {
+        const frequency = i * binWidth;
+        const magnitude = frequencyData[i] / 255.0;
+        weightedSum += frequency * magnitude;
+        totalEnergy += magnitude;
+    }
+    if (totalEnergy > 0.01) {
+        const centroid = weightedSum / totalEnergy;
+        // Map centroid to highpass frequency (85-300Hz)
+        // Lower centroid = deeper voice = use lower highpass (preserve bass)
+        // Higher centroid = higher voice = use higher highpass (remove mud)
+        return Math.max(85, Math.min(300, 85 + (centroid - 100) * 0.5));
+    }
+    // Default frequency if no significant energy
+    return 100;
+}
+/**
+ * Create a voice-optimized filter chain
+ *
+ * @param audioContext AudioContext
+ * @returns Filter chain nodes
+ */
+function createVoiceFilterChain(audioContext) {
+    // HIGHPASS FILTER: Remove low-frequency rumble and plosives
+    const highpass = audioContext.createBiquadFilter();
+    highpass.type = 'highpass';
+    highpass.frequency.value = 100; // Cut below 100Hz
+    highpass.Q.value = 0.5; // Gentle slope
+    // LOWPASS FILTER: Remove high-frequency hiss
+    const lowpass = audioContext.createBiquadFilter();
+    lowpass.type = 'lowpass';
+    lowpass.frequency.value = 10000; // Cut above 10kHz
+    lowpass.Q.value = 0.5;
+    // VOICE BAND EMPHASIS (disabled by default - can cause resonance)
+    const voiceBand = audioContext.createBiquadFilter();
+    voiceBand.type = 'peaking';
+    voiceBand.frequency.value = 180;
+    voiceBand.Q.value = 0.5;
+    voiceBand.gain.value = 0; // Disabled
+    // DYNAMIC LOWPASS for high-frequency control
+    const dynamicLowpass = audioContext.createBiquadFilter();
+    dynamicLowpass.type = 'lowpass';
+    dynamicLowpass.frequency.value = 12000;
+    dynamicLowpass.Q.value = 0.5;
+    return { highpass, lowpass, voiceBand, dynamicLowpass };
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Utils module - Re-exports all utility functions
+ */
+export * from './spatial';
+export * from './position';
+export * from './smoothing';
+export * from './audio';

package/dist/utils/index.js

@@ -0,0 +1,23 @@
+"use strict";
+/**
+ * Utils module - Re-exports all utility functions
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./spatial"), exports);
+__exportStar(require("./position"), exports);
+__exportStar(require("./smoothing"), exports);
+__exportStar(require("./audio"), exports);