z-web-audio-stream/dist/AudioChunkStore.d.ts

iOS Safari-safe Web Audio streaming with separated download/storage optimization, instant playback, and memory management

export interface AudioMetadata {
    trackId: string;
    name: string;
    duration: number;
    sampleRate: number;
    numberOfChannels: number;
    totalChunks: number;
    lastAccessed: number;
    fileSize: number;
    url: string;
}
export interface AudioChunk {
    id: string;
    trackId: string;
    chunkIndex: number;
    sampleRate: number;
    length: number;
    channels: Float32Array[];
}
export interface StoredChunk {
    id: string;
    trackId: string;
    chunkIndex: number;
    sampleRate: number;
    length: number;
    channels: string[];
}
export interface ProgressCallback {
    (loaded: number, total: number, canStartPlayback: boolean): void;
}
export interface InstantChunkConfig {
    initialChunkSize: number;
    subsequentChunkSize: number;
    enableInstantMode: boolean;
}
/**
 * iOS Safari-safe audio chunk storage with progressive loading
 *
 * Key features:
 * - Memory-safe chunk sizing to prevent iOS page reloads
 * - Safari-specific IndexedDB retry logic
 * - Progressive audio loading for instant playback
 * - Automatic cleanup and storage management
 * - Simple obfuscation for privacy
 */
export declare class AudioChunkStore {
    private db;
    private audioContext;
    private chunkSizeBytes;
    private initialized;
    private readonly dbName;
    private readonly dbVersion;
    private instantChunkConfig;
    private readonly obfuscationKey;
    private readonly maxStorageSize;
    private readonly maxAge;
    private readonly minChunksForPlayback;
    constructor(audioContext: AudioContext, instantConfig?: Partial<InstantChunkConfig>, obfuscationKey?: string);
    private obfuscateString;
    private deobfuscateString;
    private obfuscateMetadata;
    private deobfuscateMetadata;
    private isSafariIOS;
    private withTimeout;
    private openDatabase;
    initialize(): Promise<void>;
    storeAudio(url: string, trackId: string, name: string, progressCallback?: ProgressCallback): Promise<AudioMetadata>;
    getAudioBuffer(trackId: string, startChunk?: number, chunkCount?: number): Promise<AudioBuffer | null>;
    isStored(trackId: string): Promise<boolean>;
    getAvailableChunks(trackId: string): Promise<number[]>;
    private audioBufferToChunks;
    private mergeChunks;
    private float32ArrayToString;
    private stringToFloat32Array;
    private saveMetadata;
    getMetadata(trackId: string): Promise<AudioMetadata | null>;
    private updateLastAccessed;
    private saveChunk;
    private getChunk;
    cleanup(): Promise<void>;
    private getAllMetadata;
    removeTrack(trackId: string): Promise<void>;
    storeAudioForInstantPlayback(url: string, trackId: string, name: string, progressCallback?: ProgressCallback): Promise<AudioMetadata>;
    private audioBufferToInstantChunks;
    getFirstChunk(trackId: string): Promise<AudioBuffer | null>;
    getProgressiveChunks(trackId: string, startChunk?: number, maxChunks?: number): Promise<AudioBuffer | null>;
    configureInstantMode(config: Partial<InstantChunkConfig>): void;
    storeAudioStreaming(url: string, trackId: string, name: string, options?: {
        initialChunkSize?: number;
        subsequentChunkSize?: number;
        useRangeRequests?: boolean;
        progressCallback?: ProgressCallback;
    }): Promise<AudioMetadata>;
    private checkRangeSupport;
    private storeAudioWithRangeRequests;
    private getFileSize;
    private audioBufferToSingleChunk;
    private loadRemainingChunksInBackground;
    /**
     * Store assembly chunks from streaming assembler
     */
    storeAssemblyChunks(trackId: string, name: string, assemblyChunks: import('./StreamingAssembler.js').AssemblyChunk[], progressCallback?: ProgressCallback): Promise<AudioMetadata>;
    /**
     * Convert an AudioBuffer to a storage chunk
     */
    private audioBufferToStorageChunk;
    /**
     * Get first chunk for instant playback (optimized for assembly chunks)
     */
    getFirstChunkBuffer(trackId: string): Promise<AudioBuffer | null>;
    getStorageInfo(): Promise<{
        totalTracks: number;
        totalSize: number;
        oldestTrack: number;
        newestTrack: number;
        instantModeEnabled: boolean;
        chunkSizeConfig: {
            initialChunkSize: number;
            subsequentChunkSize: number;
        };
    }>;
    getInstantPlaybackMetrics(): {
        initialChunkSize: number;
        subsequentChunkSize: number;
        estimatedInitialLoadTime: number;
        optimalForInstantPlayback: boolean;
    };
}
//# sourceMappingURL=AudioChunkStore.d.ts.map