Datasets:

webxos
/

audioform_dataset

+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>AUDIOFORM: by webXOS</title>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/three.js/r128/three.min.js"></script>
+    <script src="https://cdn.jsdelivr.net/npm/jszip@3.7.1/dist/jszip.min.js"></script>
+    <script src="https://cdnjs.cloudflare.com/ajax/libs/FileSaver.js/2.0.5/FileSaver.min.js"></script>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+            font-family: 'Courier New', monospace;
+        }
+        body {
+            background: #0a0a12;
+            color: #00ff9d;
+            overflow: hidden;
+            height: 100vh;
+            position: relative;
+        }
+        /* Loading Screen */
+        #loading-screen {
+            position: fixed;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            background: #000000;
+            display: flex;
+            flex-direction: column;
+            justify-content: center;
+            align-items: center;
+            z-index: 1000;
+            transition: opacity 1s;
+        }
+        .loading-title {
+            font-size: 3rem;
+            color: #00ff9d;
+            text-shadow: 0 0 10px #00ff9d;
+            margin-bottom: 2rem;
+            letter-spacing: 5px;
+        }
+        .loading-bar {
+            width: 300px;
+            height: 4px;
+            background: #111;
+            border-radius: 2px;
+            overflow: hidden;
+            margin-top: 20px;
+        }
+        .loading-progress {
+            height: 100%;
+            background: #00ff9d;
+            width: 0%;
+            transition: width 0.3s;
+        }
+        /* Main UI */
+        #ui-container {
+            position: absolute;
+            top: 0;
+            left: 0;
+            width: 100%;
+            height: 100%;
+            pointer-events: none;
+            z-index: 10;
+        }
+        .ui-section {
+            position: absolute;
+            background: rgba(5, 5, 15, 0.85);
+            border: 1px solid #00ff9d;
+            border-radius: 5px;
+            padding: 15px;
+            box-shadow: 0 0 15px rgba(0, 255, 157, 0.3);
+            pointer-events: all;
+        }
+        /* Control Panel */
+        #control-panel {
+            top: 20px;
+            left: 20px;
+            width: 320px;
+        }
+        /* Visualization Panel */
+        #viz-panel {
+            bottom: 20px;
+            left: 20px;
+            width: 320px;
+        }
+        /* Export Panel */
+        #export-panel {
+            top: 20px;
+            right: 20px;
+            width: 320px;
+        }
+        /* Title */
+        #title {
+            position: absolute;
+            top: 20px;
+            left: 50%;
+            transform: translateX(-50%);
+            font-size: 2.2rem;
+            color: #00ff9d;
+            text-shadow: 0 0 10px #00ff9d;
+            letter-spacing: 3px;
+            text-align: center;
+            background: rgba(5, 5, 15, 0.7);
+            padding: 10px 30px;
+            border-radius: 5px;
+            border: 1px solid #00ff9d;
+            box-shadow: 0 0 15px rgba(0, 255, 157, 0.3);
+            z-index: 11;
+        }
+        /* Fullscreen Button */
+        #fullscreen-btn {
+            position: absolute;
+            bottom: 20px;
+            right: 20px;
+            width: 50px;
+            height: 50px;
+            background: rgba(5, 5, 15, 0.85);
+            border: 1px solid #00ff9d;
+            border-radius: 50%;
+            color: #00ff9d;
+            font-size: 24px;
+            cursor: pointer;
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            z-index: 11;
+            pointer-events: all;
+            transition: all 0.3s;
+        }
+        #fullscreen-btn:hover {
+            background: rgba(0, 255, 157, 0.2);
+            box-shadow: 0 0 15px #00ff9d;
+        }
+        /* UI Elements */
+        h2 {
+            color: #00ff9d;
+            margin-bottom: 15px;
+            border-bottom: 1px solid #00ff9d;
+            padding-bottom: 5px;
+            font-size: 1.3rem;
+        }
+        .btn {
+            background: #001a0f;
+            color: #00ff9d;
+            border: 1px solid #00ff9d;
+            padding: 10px 15px;
+            border-radius: 3px;
+            cursor: pointer;
+            margin: 5px 0;
+            width: 100%;
+            font-weight: bold;
+            transition: all 0.3s;
+        }
+        .btn:hover {
+            background: #003320;
+            box-shadow: 0 0 10px #00ff9d;
+        }
+        .btn:active {
+            background: #00ff9d;
+            color: #000;
+        }
+        .btn-red {
+            background: #1a0000;
+            border-color: #ff0033;
+            color: #ff0033;
+        }
+        .btn-red:hover {
+            background: #330000;
+            box-shadow: 0 0 10px #ff0033;
+        }
+        .file-input {
+            width: 100%;
+            margin: 10px 0;
+            padding: 8px;
+            background: #000;
+            color: #00ff9d;
+            border: 1px solid #00ff9d;
+            border-radius: 3px;
+        }
+        .slider-container {
+            margin: 15px 0;
+        }
+        .slider-label {
+            display: flex;
+            justify-content: space-between;
+            margin-bottom: 5px;
+        }
+        .slider {
+            width: 100%;
+            -webkit-appearance: none;
+            height: 6px;
+            background: #001a0f;
+            border-radius: 3px;
+            outline: none;
+        }
+        .slider::-webkit-slider-thumb {
+            -webkit-appearance: none;
+            width: 18px;
+            height: 18px;
+            background: #00ff9d;
+            border-radius: 50%;
+            cursor: pointer;
+        }
+        .toggle {
+            display: flex;
+            align-items: center;
+            margin: 10px 0;
+        }
+        .toggle input {
+            display: none;
+        }
+        .toggle-slider {
+            width: 50px;
+            height: 24px;
+            background: #001a0f;
+            border-radius: 12px;
+            margin-right: 10px;
+            position: relative;
+            cursor: pointer;
+            border: 1px solid #00ff9d;
+        }
+        .toggle-slider:after {
+            content: '';
+            position: absolute;
+            width: 20px;
+            height: 20px;
+            background: #00ff9d;
+            border-radius: 50%;
+            top: 1px;
+            left: 1px;
+            transition: 0.3s;
+        }
+        .toggle input:checked + .toggle-slider:after {
+            transform: translateX(26px);
+        }
+        .info-text {
+            font-size: 0.85rem;
+            color: #00cc7a;
+            margin-top: 10px;
+            line-height: 1.4;
+        }
+        /* Canvas */
+        #canvas-container {
+            width: 100%;
+            height: 100%;
+        }
+        canvas {
+            display: block;
+        }
+        /* Metrics Display */
+        .metrics {
+            background: rgba(0, 0, 0, 0.7);
+            padding: 10px;
+            border-radius: 3px;
+            margin-top: 15px;
+            border: 1px solid #ff0033;
+        }
+        .metric-row {
+            display: flex;
+            justify-content: space-between;
+            margin: 5px 0;
+            font-size: 0.9rem;
+        }
+        .metric-value {
+            color: #ff0033;
+        }
+    </style>
+</head>
+<body>
+    <!-- Loading Screen -->
+    <div id="loading-screen">
+        <div class="loading-title">AUDIOFORM</div>
+        <div>Initializing 3D Audio Visualization System...</div>
+        <div class="loading-bar">
+            <div class="loading-progress" id="loading-progress"></div>
+        </div>
+    </div>
+    <!-- Main UI -->
+    <div id="ui-container">
+        <div id="title">AUDIOFORM by webXOS</div>
+        <div class="ui-section" id="control-panel">
+            <h2>Audio Input</h2>
+            <input type="file" id="audio-upload" accept=".wav" class="file-input">
+            <button id="load-sample" class="btn">Load Sample Audio</button>
+            <h2>Synthetic Noise Generator</h2>
+            <div class="toggle">
+                <input type="checkbox" id="noise-toggle">
+                <label for="noise-toggle" class="toggle-slider"></label>
+                <label for="noise-toggle">Enable 8-bit Tone Generation</label>
+            </div>
+            <div class="slider-container">
+                <div class="slider-label">
+                    <span>Tone Frequency</span>
+                    <span id="freq-value">440 Hz</span>
+                </div>
+                <input type="range" min="50" max="2000" value="440" class="slider" id="freq-slider">
+            </div>
+            <div class="slider-container">
+                <div class="slider-label">
+                    <span>Time Scaling</span>
+                    <span id="time-value">1.0x</span>
+                </div>
+                <input type="range" min="0.1" max="5" step="0.1" value="1" class="slider" id="time-slider">
+            </div>
+            <button id="generate-noise" class="btn">Generate Synthetic Audio</button>
+            <div class="info-text">
+                Synthetic mode generates 8-bit tones with timelapse time-scaling for dataset creation.
+            </div>
+        </div>
+        <div class="ui-section" id="viz-panel">
+            <h2>Visualization Controls</h2>
+            <div class="slider-container">
+                <div class="slider-label">
+                    <span>Waveform Scale</span>
+                    <span id="scale-value">1.0</span>
+                </div>
+                <input type="range" min="0.1" max="3" step="0.1" value="1" class="slider" id="scale-slider">
+            </div>
+            <div class="slider-container">
+                <div class="slider-label">
+                    <span>Rotation Speed</span>
+                    <span id="rotation-value">0.5</span>
+                </div>
+                <input type="range" min="0" max="2" step="0.1" value="0.5" class="slider" id="rotation-slider">
+            </div>
+            <div class="toggle">
+                <input type="checkbox" id="auto-rotate" checked>
+                <label for="auto-rotate" class="toggle-slider"></label>
+                <label for="auto-rotate">Auto-Rotate Visualization</label>
+            </div>
+            <button id="capture-frame" class="btn">Capture Current Frame</button>
+            <div class="metrics">
+                <div class="metric-row">
+                    <span>Frames Captured:</span>
+                    <span class="metric-value" id="frame-count">0</span>
+                </div>
+                <div class="metric-row">
+                    <span>Audio Duration:</span>
+                    <span class="metric-value" id="audio-duration">0.0s</span>
+                </div>
+                <div class="metric-row">
+                    <span>Current Time:</span>
+                    <span class="metric-value" id="current-time">0.0s</span>
+                </div>
+            </div>
+        </div>
+        <div class="ui-section" id="export-panel">
+            <h2>Dataset Export</h2>
+            <input type="text" id="dataset-name" placeholder="Dataset Name" class="file-input" value="audioform_dataset">
+            <div class="slider-container">
+                <div class="slider-label">
+                    <span>Frames to Capture</span>
+                    <span id="capture-count-value">10</span>
+                </div>
+                <input type="range" min="5" max="100" value="10" class="slider" id="capture-count-slider">
+            </div>
+            <button id="start-capture" class="btn">Start Timelapse Capture</button>
+            <button id="export-dataset" class="btn">Export Dataset (.zip)</button>
+            <button id="reset-captures" class="btn btn-red">Reset All Captures</button>
+            <div class="info-text">
+                Exports Hugging Face formatted .zip with README.md, images, and classification CSV.
+            </div>
+        </div>
+        <div id="fullscreen-btn">⛶</div>
+    </div>
+    <!-- Three.js Canvas Container -->
+    <div id="canvas-container"></div>
+    <script>
+        // Main Application
+        document.addEventListener('DOMContentLoaded', function() {
+            // Simulate loading progress
+            let progress = 0;
+            const progressInterval = setInterval(() => {
+                progress += Math.random() * 15;
+                if (progress >= 100) {
+                    progress = 100;
+                    clearInterval(progressInterval);
+                    setTimeout(() => {
+                        document.getElementById('loading-screen').style.opacity = '0';
+                        setTimeout(() => {
+                            document.getElementById('loading-screen').style.display = 'none';
+                        }, 1000);
+                    }, 500);
+                }
+                document.getElementById('loading-progress').style.width = `${progress}%`;
+            }, 150);
+            // Global variables
+            let scene, camera, renderer, audioContext, audioSource, analyser;
+            let waveformGeometry, waveformMaterial, waveformMesh;
+            let capturedFrames = [];
+            let isPlaying = false;
+            let isNoiseMode = false;
+            let currentAudioBuffer = null;
+            let startTime = 0;
+            let rotationSpeed = 0.5;
+            let autoRotate = true;
+            let timeScale = 1.0;
+            let noiseFrequency = 440;
+            let frameCaptureCount = 0;
+            // Initialize Three.js scene
+            function initThreeJS() {
+                // Create scene
+                scene = new THREE.Scene();
+                scene.background = new THREE.Color(0x000000);
+                // Create camera
+                camera = new THREE.PerspectiveCamera(75, window.innerWidth / window.innerHeight, 0.1, 1000);
+                camera.position.z = 15;
+                camera.position.y = 5;
+                // Create renderer
+                renderer = new THREE.WebGLRenderer({ antialias: true });
+                renderer.setSize(window.innerWidth, window.innerHeight);
+                renderer.setPixelRatio(window.devicePixelRatio);
+                document.getElementById('canvas-container').appendChild(renderer.domElement);
+                // Add lights
+                const ambientLight = new THREE.AmbientLight(0x222222);
+                scene.add(ambientLight);
+                const directionalLight = new THREE.DirectionalLight(0x00ff9d, 1);
+                directionalLight.position.set(10, 10, 5);
+                scene.add(directionalLight);
+                const redLight = new THREE.DirectionalLight(0xff0033, 0.5);
+                redLight.position.set(-10, 5, -5);
+                scene.add(redLight);
+                // Create initial waveform visualization
+                createWaveformVisualization();
+                // Add grid helper
+                const gridHelper = new THREE.GridHelper(30, 30, 0x00aa00, 0x003300);
+                gridHelper.position.y = -5;
+                scene.add(gridHelper);
+                // Add axes helper
+                const axesHelper = new THREE.AxesHelper(10);
+                scene.add(axesHelper);
+                // Handle window resize
+                window.addEventListener('resize', onWindowResize);
+            }
+            // Create waveform visualization
+            function createWaveformVisualization() {
+                // Create geometry for waveform visualization
+                const geometry = new THREE.BufferGeometry();
+                const pointCount = 512;
+                const positions = new Float32Array(pointCount * 3);
+                // Initialize with flat line
+                for (let i = 0; i < pointCount; i++) {
+                    positions[i * 3] = (i - pointCount / 2) * 0.05;
+                    positions[i * 3 + 1] = 0;
+                    positions[i * 3 + 2] = 0;
+                }
+                geometry.setAttribute('position', new THREE.BufferAttribute(positions, 3));
+                // Create material with neon green color
+                const material = new THREE.LineBasicMaterial({
+                    color: 0x00ff9d,
+                    linewidth: 2
+                });
+                // Create mesh and add to scene
+                waveformMesh = new THREE.Line(geometry, material);
+                scene.add(waveformMesh);
+                // Also create a particle system for additional visualization
+                const particleGeometry = new THREE.BufferGeometry();
+                const particlePositions = new Float32Array(pointCount * 3);
+                const particleColors = new Float32Array(pointCount * 3);
+                for (let i = 0; i < pointCount; i++) {
+                    particlePositions[i * 3] = (i - pointCount / 2) * 0.05;
+                    particlePositions[i * 3 + 1] = 0;
+                    particlePositions[i * 3 + 2] = 0;
+                    // Green color for particles
+                    particleColors[i * 3] = 0.0;     // R
+                    particleColors[i * 3 + 1] = 1.0; // G
+                    particleColors[i * 3 + 2] = 0.0; // B
+                }
+                particleGeometry.setAttribute('position', new THREE.BufferAttribute(particlePositions, 3));
+                particleGeometry.setAttribute('color', new THREE.BufferAttribute(particleColors, 3));
+                const particleMaterial = new THREE.PointsMaterial({
+                    size: 0.05,
+                    vertexColors: true,
+                    transparent: true
+                });
+                const particles = new THREE.Points(particleGeometry, particleMaterial);
+                waveformMesh.add(particles);
+                waveformGeometry = geometry;
+            }
+            // Update waveform visualization based on audio data
+            function updateWaveform(dataArray) {
+                if (!waveformGeometry) return;
+                const positions = waveformGeometry.attributes.position.array;
+                const pointCount = positions.length / 3;
+                for (let i = 0; i < pointCount; i++) {
+                    // Get audio data value (normalized)
+                    const value = dataArray[i] / 128.0;
+                    // Update Y position based on audio data
+                    positions[i * 3 + 1] = value * 5;
+                    // Add some Z variation for 3D effect
+                    positions[i * 3 + 2] = Math.sin(i * 0.05 + Date.now() * 0.001) * value;
+                }
+                waveformGeometry.attributes.position.needsUpdate = true;
+            }
+            // Initialize audio context
+            function initAudio() {
+                audioContext = new (window.AudioContext || window.webkitAudioContext)();
+                analyser = audioContext.createAnalyser();
+                analyser.fftSize = 512;
+                analyser.smoothingTimeConstant = 0.8;
+            }
+            // Load and play audio file
+            function loadAudioFile(file) {
+                if (!audioContext) initAudio();
+                const reader = new FileReader();
+                reader.onload = function(e) {
+                    audioContext.decodeAudioData(e.target.result, function(buffer) {
+                        playAudioBuffer(buffer);
+                    }, function(e) {
+                        console.error("Error decoding audio data", e);
+                    });
+                };
+                reader.readAsArrayBuffer(file);
+            }
+            // Play audio buffer
+            function playAudioBuffer(buffer) {
+                stopAudio();
+                currentAudioBuffer = buffer;
+                audioSource = audioContext.createBufferSource();
+                audioSource.buffer = buffer;
+                audioSource.connect(analyser);
+                analyser.connect(audioContext.destination);
+                // Set playback rate based on time scaling
+                audioSource.playbackRate.value = timeScale;
+                audioSource.start(0);
+                isPlaying = true;
+                startTime = audioContext.currentTime;
+                // Update duration display
+                document.getElementById('audio-duration').textContent = `${buffer.duration.toFixed(2)}s`;
+                // Start animation loop
+                animate();
+            }
+            // Generate synthetic 8-bit tone
+            function generateSyntheticNoise() {
+                if (!audioContext) initAudio();
+                stopAudio();
+                // Create oscillator for 8-bit tone
+                const oscillator = audioContext.createOscillator();
+                oscillator.type = 'square'; // Square wave for 8-bit sound
+                oscillator.frequency.setValueAtTime(noiseFrequency, audioContext.currentTime);
+                // Create gain node for volume control
+                const gainNode = audioContext.createGain();
+                gainNode.gain.setValueAtTime(0.1, audioContext.currentTime);
+                // Connect nodes
+                oscillator.connect(gainNode);
+                gainNode.connect(analyser);
+                analyser.connect(audioContext.destination);
+                // Create buffer source for continuous playback
+                const bufferLength = 2; // 2 seconds buffer
+                const buffer = audioContext.createBuffer(1, audioContext.sampleRate * bufferLength, audioContext.sampleRate);
+                const channelData = buffer.getChannelData(0);
+                // Fill buffer with 8-bit style square wave
+                for (let i = 0; i < channelData.length; i++) {
+                    const time = i / audioContext.sampleRate;
+                    const frequency = noiseFrequency;
+                    // Square wave calculation
+                    channelData[i] = Math.sign(Math.sin(2 * Math.PI * frequency * time));
+                    // Add some noise for "8-bit" character
+                    channelData[i] += (Math.random() - 0.5) * 0.1;
+                    // Clamp to prevent distortion
+                    channelData[i] = Math.max(-0.8, Math.min(0.8, channelData[i]));
+                }
+                // Play the buffer
+                audioSource = audioContext.createBufferSource();
+                audioSource.buffer = buffer;
+                audioSource.loop = true;
+                audioSource.playbackRate.value = timeScale;
+                audioSource.connect(analyser);
+                analyser.connect(audioContext.destination);
+                audioSource.start(0);
+                isPlaying = true;
+                startTime = audioContext.currentTime;
+                // Update duration display for synthetic audio
+                document.getElementById('audio-duration').textContent = `∞ (synthetic)`;
+                // Start animation loop
+                animate();
+            }
+            // Stop audio playback
+            function stopAudio() {
+                if (audioSource) {
+                    audioSource.stop();
+                    audioSource.disconnect();
+                    isPlaying = false;
+                }
+            }
+            // Capture current frame as image
+            function captureFrame() {
+                // Render the current frame to a data URL
+                renderer.render(scene, camera);
+                const dataURL = renderer.domElement.toDataURL('image/png');
+                // Create frame object
+                const frame = {
+                    id: frameCaptureCount,
+                    timestamp: audioContext ? (audioContext.currentTime - startTime).toFixed(3) : '0.000',
+                    dataURL: dataURL,
+                    frequency: isNoiseMode ? noiseFrequency : 0,
+                    timeScale: timeScale,
+                    date: new Date().toISOString()
+                };
+                capturedFrames.push(frame);
+                frameCaptureCount++;
+                // Update UI
+                document.getElementById('frame-count').textContent = frameCaptureCount;
+                // Add visual feedback
+                waveformMesh.material.color.setHex(0xff0033);
+                setTimeout(() => {
+                    waveformMesh.material.color.setHex(0x00ff9d);
+                }, 100);
+                return frame;
+            }
+            // Start timelapse capture
+            function startTimelapseCapture() {
+                const totalFrames = parseInt(document.getElementById('capture-count-slider').value);
+                const interval = 0.5; // Capture every 0.5 seconds
+                let framesCaptured = 0;
+                const captureInterval = setInterval(() => {
+                    if (framesCaptured >= totalFrames) {
+                        clearInterval(captureInterval);
+                        alert(`Timelapse capture complete! Captured ${totalFrames} frames.`);
+                        return;
+                    }
+                    captureFrame();
+                    framesCaptured++;
+                }, interval * 1000);
+            }
+            // Export dataset as Hugging Face formatted zip
+            async function exportDataset() {
+                if (capturedFrames.length === 0) {
+                    alert('No frames captured yet! Capture some frames before exporting.');
+                    return;
+                }
+                const datasetName = document.getElementById('dataset-name').value || 'audioform_dataset';
+                const zip = new JSZip();
+                // Create dataset folder structure
+                const datasetFolder = zip.folder(datasetName);
+                const imagesFolder = datasetFolder.folder('images');
+                // Create metadata CSV with REQUIRED file_name column for Hugging Face compatibility
+                let csvContent = 'file_name,frame_id,timestamp,frequency,time_scale,capture_date\n';
+                // Add images to zip and build CSV simultaneously
+                capturedFrames.forEach((frame, index) => {
+                    // Convert dataURL to blob
+                    const data = frame.dataURL.split(',')[1];
+                    const blob = b64toBlob(data, 'image/png');
+                    // Add image to zip
+                    const imageName = `frame_${String(index).padStart(4, '0')}.png`;
+                    imagesFolder.file(imageName, blob);
+                    // Add to CSV with file_name column (required by Hugging Face ImageFolder)
+                    csvContent += `images/${imageName},${frame.id},${frame.timestamp},${frame.frequency},${frame.timeScale},${frame.date}\n`;
+                });
+                datasetFolder.file('metadata.csv', csvContent);
+                // Create README.md
+                const readmeContent = `# ${datasetName}
+## Dataset Description
+This dataset was generated using AUDIOFORM, a 3D audio visualization system.
+- **Total Frames**: ${capturedFrames.length}
+- **Generation Date**: ${new Date().toISOString().split('T')[0]}
+- **Audio Type**: ${isNoiseMode ? 'Synthetic 8-bit Tone' : 'Uploaded WAV File'}
+- **Time Scaling**: ${timeScale}x
+## Dataset Structure
+- \`images/\`: Contains all captured frames in PNG format
+- \`metadata.csv\`: Contains classification data for each frame
+## Metadata Columns
+- \`file_name\`: Relative path to the image file (e.g., images/frame_0001.png) - **REQUIRED for Hugging Face**
+- \`frame_id\`: Unique identifier for each frame
+- \`timestamp\`: Time in seconds when frame was captured
+- \`frequency\`: Audio frequency at capture time (Hz)
+- \`time_scale\`: Playback speed multiplier
+- \`capture_date\`: ISO date string of capture
+## Intended Use
+This dataset is intended for training machine learning models on audio visualization patterns, waveform classification, or generative AI tasks.
+## Generation Details
+Generated with AUDIOFORM v1.0 - A Three.js based audio visualization dataset generator.
+`;
+                datasetFolder.file('README.md', readmeContent);
+                // Generate and download zip file
+                const zipBlob = await zip.generateAsync({type: 'blob'});
+                saveAs(zipBlob, `${datasetName}.zip`);
+                alert(`Dataset exported successfully as ${datasetName}.zip\n\nThe dataset includes the required 'file_name' column for Hugging Face compatibility.`);
+            }
+            // Helper function to convert base64 to blob
+            function b64toBlob(b64Data, contentType = '', sliceSize = 512) {
+                const byteCharacters = atob(b64Data);
+                const byteArrays = [];
+                for (let offset = 0; offset < byteCharacters.length; offset += sliceSize) {
+                    const slice = byteCharacters.slice(offset, offset + sliceSize);
+                    const byteNumbers = new Array(slice.length);
+                    for (let i = 0; i < slice.length; i++) {
+                        byteNumbers[i] = slice.charCodeAt(i);
+                    }
+                    const byteArray = new Uint8Array(byteNumbers);
+                    byteArrays.push(byteArray);
+                }
+                const blob = new Blob(byteArrays, {type: contentType});
+                return blob;
+            }
+            // Reset all captured frames
+            function resetCaptures() {
+                if (capturedFrames.length > 0 && !confirm('Are you sure you want to reset all captured frames?')) {
+                    return;
+                }
+                capturedFrames = [];
+                frameCaptureCount = 0;
+                document.getElementById('frame-count').textContent = '0';
+            }
+            // Animation loop
+            function animate() {
+                requestAnimationFrame(animate);
+                // Update audio visualization if playing
+                if (isPlaying && analyser) {
+                    const dataArray = new Uint8Array(analyser.frequencyBinCount);
+                    analyser.getByteFrequencyData(dataArray);
+                    updateWaveform(dataArray);
+                    // Update current time display
+                    if (audioContext) {
+                        const currentTime = audioContext.currentTime - startTime;
+                        document.getElementById('current-time').textContent = `${currentTime.toFixed(2)}s`;
+                    }
+                }
+                // Auto-rotate visualization
+                if (autoRotate && waveformMesh) {
+                    waveformMesh.rotation.y += 0.005 * rotationSpeed;
+                    waveformMesh.rotation.x += 0.002 * rotationSpeed;
+                }
+                // Render scene
+                renderer.render(scene, camera);
+            }
+            // Handle window resize
+            function onWindowResize() {
+                camera.aspect = window.innerWidth / window.innerHeight;
+                camera.updateProjectionMatrix();
+                renderer.setSize(window.innerWidth, window.innerHeight);
+            }
+            // Toggle fullscreen mode
+            function toggleFullscreen() {
+                if (!document.fullscreenElement) {
+                    document.documentElement.requestFullscreen().catch(err => {
+                        console.error(`Error attempting to enable fullscreen: ${err.message}`);
+                    });
+                } else {
+                    if (document.exitFullscreen) {
+                        document.exitFullscreen();
+                    }
+                }
+            }
+            // Load sample audio
+            function loadSampleAudio() {
+                // Create a simple 8-bit style sample audio
+                if (!audioContext) initAudio();
+                // Create a buffer with multiple frequencies
+                const buffer = audioContext.createBuffer(1, audioContext.sampleRate * 3, audioContext.sampleRate);
+                const channelData = buffer.getChannelData(0);
+                // Generate a sample with varying frequencies
+                for (let i = 0; i < channelData.length; i++) {
+                    const time = i / audioContext.sampleRate;
+                    // Vary frequency over time
+                    const freq = 200 + Math.sin(time * 2) * 100;
+                    // Square wave
+                    channelData[i] = Math.sign(Math.sin(2 * Math.PI * freq * time));
+                    // Add some noise
+                    channelData[i] += (Math.random() - 0.5) * 0.05;
+                    // Clamp
+                    channelData[i] = Math.max(-0.8, Math.min(0.8, channelData[i]));
+                }
+                playAudioBuffer(buffer);
+            }
+            // Setup event listeners
+            function setupEventListeners() {
+                // File upload
+                document.getElementById('audio-upload').addEventListener('change', function(e) {
+                    if (e.target.files.length > 0) {
+                        loadAudioFile(e.target.files[0]);
+                        isNoiseMode = false;
+                    }
+                });
+                // Sample audio button
+                document.getElementById('load-sample').addEventListener('click', loadSampleAudio);
+                // Noise generator toggle
+                document.getElementById('noise-toggle').addEventListener('change', function(e) {
+                    isNoiseMode = e.target.checked;
+                });
+                // Generate synthetic noise
+                document.getElementById('generate-noise').addEventListener('click', generateSyntheticNoise);
+                // Frequency slider
+                const freqSlider = document.getElementById('freq-slider');
+                const freqValue = document.getElementById('freq-value');
+                freqSlider.addEventListener('input', function() {
+                    noiseFrequency = parseInt(this.value);
+                    freqValue.textContent = `${noiseFrequency} Hz`;
+                    // Regenerate noise if currently playing in noise mode
+                    if (isPlaying && isNoiseMode) {
+                        generateSyntheticNoise();
+                    }
+                });
+                // Time scaling slider
+                const timeSlider = document.getElementById('time-slider');
+                const timeValue = document.getElementById('time-value');
+                timeSlider.addEventListener('input', function() {
+                    timeScale = parseFloat(this.value);
+                    timeValue.textContent = `${timeScale.toFixed(1)}x`;
+                    // Update playback rate if audio is playing
+                    if (audioSource && isPlaying) {
+                        audioSource.playbackRate.value = timeScale;
+                    }
+                });
+                // Waveform scale slider
+                const scaleSlider = document.getElementById('scale-slider');
+                const scaleValue = document.getElementById('scale-value');
+                scaleSlider.addEventListener('input', function() {
+                    const scale = parseFloat(this.value);
+                    scaleValue.textContent = scale.toFixed(1);
+                    if (waveformMesh) {
+                        waveformMesh.scale.y = scale;
+                    }
+                });
+                // Rotation speed slider
+                const rotationSlider = document.getElementById('rotation-slider');
+                const rotationValue = document.getElementById('rotation-value');
+                rotationSlider.addEventListener('input', function() {
+                    rotationSpeed = parseFloat(this.value);
+                    rotationValue.textContent = rotationSpeed.toFixed(1);
+                });
+                // Auto-rotate toggle
+                document.getElementById('auto-rotate').addEventListener('change', function(e) {
+                    autoRotate = e.target.checked;
+                });
+                // Capture frame button
+                document.getElementById('capture-frame').addEventListener('click', captureFrame);
+                // Capture count slider
+                const captureCountSlider = document.getElementById('capture-count-slider');
+                const captureCountValue = document.getElementById('capture-count-value');
+                captureCountSlider.addEventListener('input', function() {
+                    captureCountValue.textContent = this.value;
+                });
+                // Start timelapse capture
+                document.getElementById('start-capture').addEventListener('click', startTimelapseCapture);
+                // Export dataset
+                document.getElementById('export-dataset').addEventListener('click', exportDataset);
+                // Reset captures
+                document.getElementById('reset-captures').addEventListener('click', resetCaptures);
+                // Fullscreen button
+                document.getElementById('fullscreen-btn').addEventListener('click', toggleFullscreen);
+                // Handle fullscreen change
+                document.addEventListener('fullscreenchange', function() {
+                    const fullscreenBtn = document.getElementById('fullscreen-btn');
+                    if (document.fullscreenElement) {
+                        fullscreenBtn.textContent = '⛶';
+                    } else {
+                        fullscreenBtn.textContent = '⛶';
+                    }
+                });
+            }
+            // Initialize everything
+            initThreeJS();
+            initAudio();
+            setupEventListeners();
+            // Start animation loop
+            animate();
+            // Show a welcome message
+            setTimeout(() => {
+                console.log('AUDIOFORM initialized. Ready to generate audio visualization datasets.');
+            }, 1000);
+        });
+    </script>
+</body>
+</html>