677 lines
29 KiB
Rust
677 lines
29 KiB
Rust
//! File I/O for .beam project files
|
|
//!
|
|
//! This module handles saving and loading Lightningbeam projects in the .beam format,
|
|
//! which is a ZIP archive containing:
|
|
//! - project.json (compressed) - Project metadata and structure
|
|
//! - media/ directory (uncompressed) - Embedded media files (FLAC for audio)
|
|
|
|
use crate::document::Document;
|
|
use daw_backend::audio::pool::AudioPoolEntry;
|
|
use daw_backend::audio::project::Project as AudioProject;
|
|
use serde::{Deserialize, Serialize};
|
|
use std::fs::File;
|
|
use std::io::{Read, Write};
|
|
use std::path::{Path, PathBuf};
|
|
use zip::write::FileOptions;
|
|
use zip::{CompressionMethod, ZipArchive, ZipWriter};
|
|
use flacenc::error::Verify;
|
|
use base64::{Engine as _, engine::general_purpose::STANDARD as BASE64_STANDARD};
|
|
|
|
/// File format version
|
|
pub const BEAM_VERSION: &str = "1.0.0";
|
|
|
|
/// Default buffer size for audio processing (512 samples = ~10.7ms at 48kHz)
|
|
pub const DEFAULT_BUFFER_SIZE: usize = 512;
|
|
|
|
/// Complete .beam project structure for serialization
|
|
#[derive(Serialize, Deserialize)]
|
|
pub struct BeamProject {
|
|
/// File format version
|
|
pub version: String,
|
|
|
|
/// Project creation timestamp (ISO 8601)
|
|
pub created: String,
|
|
|
|
/// Last modified timestamp (ISO 8601)
|
|
pub modified: String,
|
|
|
|
/// UI state (Document from lightningbeam-core)
|
|
pub ui_state: Document,
|
|
|
|
/// Audio backend state
|
|
pub audio_backend: SerializedAudioBackend,
|
|
}
|
|
|
|
/// Serialized audio backend state
|
|
#[derive(Serialize, Deserialize)]
|
|
pub struct SerializedAudioBackend {
|
|
/// Sample rate for audio processing
|
|
pub sample_rate: u32,
|
|
|
|
/// Audio project (tracks, MIDI clips, etc.)
|
|
pub project: AudioProject,
|
|
|
|
/// Audio pool entries (metadata and paths for audio files)
|
|
/// Note: embedded_data field from daw-backend is ignored; embedded files
|
|
/// are stored as FLAC in the ZIP's media/audio/ directory instead
|
|
pub audio_pool_entries: Vec<AudioPoolEntry>,
|
|
|
|
/// Mapping from UI layer UUIDs to backend TrackIds
|
|
/// Preserves the connection between UI layers and audio engine tracks across save/load
|
|
#[serde(default)]
|
|
pub layer_to_track_map: std::collections::HashMap<uuid::Uuid, u32>,
|
|
|
|
}
|
|
|
|
/// Settings for saving a project
|
|
#[derive(Debug, Clone)]
|
|
pub struct SaveSettings {
|
|
/// Automatically embed files smaller than this size (in bytes)
|
|
pub auto_embed_threshold_bytes: u64,
|
|
|
|
/// Force embedding all media files
|
|
pub force_embed_all: bool,
|
|
|
|
/// Force linking all media files (don't embed any)
|
|
pub force_link_all: bool,
|
|
}
|
|
|
|
impl Default for SaveSettings {
|
|
fn default() -> Self {
|
|
Self {
|
|
auto_embed_threshold_bytes: 10_000_000, // 10 MB
|
|
force_embed_all: false,
|
|
force_link_all: false,
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Result of loading a project
|
|
pub struct LoadedProject {
|
|
/// Deserialized document
|
|
pub document: Document,
|
|
|
|
/// Deserialized audio project
|
|
pub audio_project: AudioProject,
|
|
|
|
/// Mapping from UI layer UUIDs to backend TrackIds (empty for old files)
|
|
pub layer_to_track_map: std::collections::HashMap<uuid::Uuid, u32>,
|
|
|
|
/// Loaded audio pool entries
|
|
pub audio_pool_entries: Vec<AudioPoolEntry>,
|
|
|
|
/// List of files that couldn't be found
|
|
pub missing_files: Vec<MissingFileInfo>,
|
|
}
|
|
|
|
/// Information about a missing file
|
|
#[derive(Debug, Clone)]
|
|
pub struct MissingFileInfo {
|
|
/// Index in the audio pool
|
|
pub pool_index: usize,
|
|
|
|
/// Original file path
|
|
pub original_path: PathBuf,
|
|
|
|
/// Type of media file
|
|
pub file_type: MediaFileType,
|
|
}
|
|
|
|
/// Type of media file
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
|
pub enum MediaFileType {
|
|
Audio,
|
|
Video,
|
|
Image,
|
|
}
|
|
|
|
/// Save a project to a .beam file
|
|
///
|
|
/// This function:
|
|
/// 1. Prepares audio project for save (saves AudioGraph presets)
|
|
/// 2. Serializes project data to JSON
|
|
/// 3. Creates ZIP archive with compressed project.json
|
|
/// 4. Embeds media files as FLAC (for audio) in media/ directory
|
|
///
|
|
/// # Arguments
|
|
/// * `path` - Path to save the .beam file
|
|
/// * `document` - UI document state
|
|
/// * `audio_project` - Audio backend project
|
|
/// * `audio_pool_entries` - Serialized audio pool entries
|
|
/// * `settings` - Save settings (embedding preferences)
|
|
///
|
|
/// # Returns
|
|
/// Ok(()) on success, or error message
|
|
pub fn save_beam(
|
|
path: &Path,
|
|
document: &Document,
|
|
audio_project: &mut AudioProject,
|
|
audio_pool_entries: Vec<AudioPoolEntry>,
|
|
layer_to_track_map: &std::collections::HashMap<uuid::Uuid, u32>,
|
|
_settings: &SaveSettings,
|
|
) -> Result<(), String> {
|
|
let fn_start = std::time::Instant::now();
|
|
eprintln!("📊 [SAVE_BEAM] Starting save_beam()...");
|
|
|
|
// 1. Create backup if file exists and open it for reading old audio files
|
|
let step1_start = std::time::Instant::now();
|
|
let mut old_zip = if path.exists() {
|
|
let backup_path = path.with_extension("beam.backup");
|
|
std::fs::copy(path, &backup_path)
|
|
.map_err(|e| format!("Failed to create backup: {}", e))?;
|
|
|
|
// Open the backup as a ZIP archive for reading
|
|
match File::open(&backup_path) {
|
|
Ok(file) => match ZipArchive::new(file) {
|
|
Ok(archive) => {
|
|
eprintln!("📊 [SAVE_BEAM] Step 1: Create backup and open for reading took {:.2}ms", step1_start.elapsed().as_secs_f64() * 1000.0);
|
|
Some(archive)
|
|
}
|
|
Err(e) => {
|
|
eprintln!("⚠️ [SAVE_BEAM] Failed to open backup as ZIP: {}, will not copy old audio files", e);
|
|
eprintln!("📊 [SAVE_BEAM] Step 1: Create backup took {:.2}ms", step1_start.elapsed().as_secs_f64() * 1000.0);
|
|
None
|
|
}
|
|
},
|
|
Err(e) => {
|
|
eprintln!("⚠️ [SAVE_BEAM] Failed to open backup: {}, will not copy old audio files", e);
|
|
eprintln!("📊 [SAVE_BEAM] Step 1: Create backup took {:.2}ms", step1_start.elapsed().as_secs_f64() * 1000.0);
|
|
None
|
|
}
|
|
}
|
|
} else {
|
|
eprintln!("📊 [SAVE_BEAM] Step 1: No backup needed (new file)");
|
|
None
|
|
};
|
|
|
|
// 2. Graph presets are already populated by the engine thread (in GetProject handler)
|
|
// before cloning. Do NOT call prepare_for_save() here — the cloned project has
|
|
// default empty graphs (AudioTrack::clone() doesn't copy the graph), so calling
|
|
// prepare_for_save() would overwrite the good presets with empty ones.
|
|
let step2_start = std::time::Instant::now();
|
|
eprintln!("📊 [SAVE_BEAM] Step 2: (graph presets already prepared) took {:.2}ms", step2_start.elapsed().as_secs_f64() * 1000.0);
|
|
|
|
// 3. Create ZIP writer
|
|
let step3_start = std::time::Instant::now();
|
|
let file = File::create(path)
|
|
.map_err(|e| format!("Failed to create file: {}", e))?;
|
|
let mut zip = ZipWriter::new(file);
|
|
eprintln!("📊 [SAVE_BEAM] Step 3: Create ZIP writer took {:.2}ms", step3_start.elapsed().as_secs_f64() * 1000.0);
|
|
|
|
// 4. Process audio pool entries and write embedded audio files to ZIP
|
|
// Priority: old ZIP file > external file > encode PCM as FLAC
|
|
let step4_start = std::time::Instant::now();
|
|
let mut modified_entries = Vec::new();
|
|
let mut flac_encode_time = 0.0;
|
|
let mut zip_write_time = 0.0;
|
|
let project_dir = path.parent().unwrap_or_else(|| Path::new("."));
|
|
|
|
for entry in &audio_pool_entries {
|
|
let mut modified_entry = entry.clone();
|
|
|
|
// Try to get audio data from various sources (in priority order)
|
|
let audio_source: Option<(Vec<u8>, String)> = if let Some(ref rel_path) = entry.relative_path {
|
|
// Priority 1: Check if file is in the old ZIP
|
|
if rel_path.starts_with("media/audio/") {
|
|
if let Some(ref mut old_zip_archive) = old_zip {
|
|
match old_zip_archive.by_name(rel_path) {
|
|
Ok(mut file) => {
|
|
let mut bytes = Vec::new();
|
|
if file.read_to_end(&mut bytes).is_ok() {
|
|
let extension = rel_path.split('.').last().unwrap_or("bin").to_string();
|
|
eprintln!("📊 [SAVE_BEAM] Copying from old ZIP: {}", rel_path);
|
|
Some((bytes, extension))
|
|
} else {
|
|
eprintln!("⚠️ [SAVE_BEAM] Failed to read {} from old ZIP", rel_path);
|
|
None
|
|
}
|
|
}
|
|
Err(_) => {
|
|
eprintln!("⚠️ [SAVE_BEAM] File {} not found in old ZIP", rel_path);
|
|
None
|
|
}
|
|
}
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
// Priority 2: Check external filesystem
|
|
else {
|
|
let full_path = project_dir.join(rel_path);
|
|
if full_path.exists() {
|
|
match std::fs::read(&full_path) {
|
|
Ok(bytes) => {
|
|
let extension = full_path.extension()
|
|
.and_then(|e| e.to_str())
|
|
.unwrap_or("bin")
|
|
.to_string();
|
|
eprintln!("📊 [SAVE_BEAM] Using external file: {:?}", full_path);
|
|
Some((bytes, extension))
|
|
}
|
|
Err(e) => {
|
|
eprintln!("⚠️ [SAVE_BEAM] Failed to read {:?}: {}", full_path, e);
|
|
None
|
|
}
|
|
}
|
|
} else {
|
|
eprintln!("⚠️ [SAVE_BEAM] External file not found: {:?}", full_path);
|
|
None
|
|
}
|
|
}
|
|
} else {
|
|
None
|
|
};
|
|
|
|
if let Some((audio_bytes, extension)) = audio_source {
|
|
// We have the original file - copy it directly
|
|
let zip_filename = format!("media/audio/{}.{}", entry.pool_index, extension);
|
|
|
|
let file_options = FileOptions::default()
|
|
.compression_method(CompressionMethod::Stored);
|
|
|
|
zip.start_file(&zip_filename, file_options)
|
|
.map_err(|e| format!("Failed to create {} in ZIP: {}", zip_filename, e))?;
|
|
|
|
let write_start = std::time::Instant::now();
|
|
zip.write_all(&audio_bytes)
|
|
.map_err(|e| format!("Failed to write {}: {}", zip_filename, e))?;
|
|
zip_write_time += write_start.elapsed().as_secs_f64() * 1000.0;
|
|
|
|
// Update entry to point to ZIP file
|
|
modified_entry.embedded_data = None;
|
|
modified_entry.relative_path = Some(zip_filename);
|
|
|
|
} else if let Some(ref embedded_data) = entry.embedded_data {
|
|
// Priority 3: No original file - encode PCM as FLAC
|
|
eprintln!("📊 [SAVE_BEAM] Encoding PCM to FLAC for pool {} (no original file)", entry.pool_index);
|
|
// Embedded data is always PCM - encode as FLAC
|
|
let audio_bytes = BASE64_STANDARD.decode(&embedded_data.data_base64)
|
|
.map_err(|e| format!("Failed to decode base64 audio data for pool index {}: {}", entry.pool_index, e))?;
|
|
|
|
let zip_filename = format!("media/audio/{}.flac", entry.pool_index);
|
|
|
|
let file_options = FileOptions::default()
|
|
.compression_method(CompressionMethod::Stored);
|
|
|
|
zip.start_file(&zip_filename, file_options)
|
|
.map_err(|e| format!("Failed to create {} in ZIP: {}", zip_filename, e))?;
|
|
|
|
// Encode PCM samples to FLAC
|
|
let flac_start = std::time::Instant::now();
|
|
|
|
// The audio_bytes are raw PCM samples (interleaved f32 little-endian)
|
|
let samples: Vec<f32> = audio_bytes
|
|
.chunks_exact(4)
|
|
.map(|chunk| f32::from_le_bytes([chunk[0], chunk[1], chunk[2], chunk[3]]))
|
|
.collect();
|
|
|
|
// Convert f32 samples to i32 for FLAC encoding
|
|
let samples_i32: Vec<i32> = samples
|
|
.iter()
|
|
.map(|&s| {
|
|
let clamped = s.clamp(-1.0, 1.0);
|
|
(clamped * 8388607.0) as i32
|
|
})
|
|
.collect();
|
|
|
|
// Configure FLAC encoder
|
|
let config = flacenc::config::Encoder::default()
|
|
.into_verified()
|
|
.map_err(|(_, e)| format!("FLAC encoder config error: {:?}", e))?;
|
|
|
|
let source = flacenc::source::MemSource::from_samples(
|
|
&samples_i32,
|
|
entry.channels as usize,
|
|
24,
|
|
entry.sample_rate as usize,
|
|
);
|
|
|
|
// Encode to FLAC
|
|
let flac_stream = flacenc::encode_with_fixed_block_size(
|
|
&config,
|
|
source,
|
|
config.block_size,
|
|
).map_err(|e| format!("FLAC encoding failed: {:?}", e))?;
|
|
|
|
// Convert stream to bytes
|
|
use flacenc::component::BitRepr;
|
|
let mut sink = flacenc::bitsink::ByteSink::new();
|
|
flac_stream.write(&mut sink)
|
|
.map_err(|e| format!("Failed to write FLAC stream: {:?}", e))?;
|
|
let flac_bytes = sink.as_slice();
|
|
|
|
flac_encode_time += flac_start.elapsed().as_secs_f64() * 1000.0;
|
|
|
|
let write_start = std::time::Instant::now();
|
|
zip.write_all(flac_bytes)
|
|
.map_err(|e| format!("Failed to write {}: {}", zip_filename, e))?;
|
|
zip_write_time += write_start.elapsed().as_secs_f64() * 1000.0;
|
|
|
|
// Update entry to point to ZIP file instead of embedding data
|
|
modified_entry.embedded_data = None;
|
|
modified_entry.relative_path = Some(zip_filename);
|
|
}
|
|
|
|
modified_entries.push(modified_entry);
|
|
}
|
|
eprintln!("📊 [SAVE_BEAM] Step 4: Process audio pool ({} entries) took {:.2}ms",
|
|
audio_pool_entries.len(), step4_start.elapsed().as_secs_f64() * 1000.0);
|
|
if flac_encode_time > 0.0 {
|
|
eprintln!("📊 [SAVE_BEAM] - FLAC encoding: {:.2}ms", flac_encode_time);
|
|
}
|
|
if zip_write_time > 0.0 {
|
|
eprintln!("📊 [SAVE_BEAM] - ZIP writing: {:.2}ms", zip_write_time);
|
|
}
|
|
|
|
// 4b. Write raster layer PNG buffers to ZIP (media/raster/<keyframe-uuid>.png)
|
|
let step4b_start = std::time::Instant::now();
|
|
let raster_file_options = FileOptions::default()
|
|
.compression_method(CompressionMethod::Stored); // PNG is already compressed
|
|
let mut raster_count = 0usize;
|
|
for layer in &document.root.children {
|
|
if let crate::layer::AnyLayer::Raster(rl) = layer {
|
|
for kf in &rl.keyframes {
|
|
if !kf.raw_pixels.is_empty() {
|
|
// Encode raw RGBA to PNG for storage
|
|
let img = crate::brush_engine::image_from_raw(
|
|
kf.raw_pixels.clone(), kf.width, kf.height,
|
|
);
|
|
match crate::brush_engine::encode_png(&img) {
|
|
Ok(png_bytes) => {
|
|
let zip_path = kf.media_path.clone();
|
|
zip.start_file(&zip_path, raster_file_options)
|
|
.map_err(|e| format!("Failed to create {} in ZIP: {}", zip_path, e))?;
|
|
zip.write_all(&png_bytes)
|
|
.map_err(|e| format!("Failed to write {}: {}", zip_path, e))?;
|
|
raster_count += 1;
|
|
}
|
|
Err(e) => eprintln!("⚠️ [SAVE_BEAM] Failed to encode raster PNG {}: {}", kf.media_path, e),
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
eprintln!("📊 [SAVE_BEAM] Step 4b: Write {} raster PNG buffers took {:.2}ms",
|
|
raster_count, step4b_start.elapsed().as_secs_f64() * 1000.0);
|
|
|
|
// 5. Build BeamProject structure with modified entries
|
|
let step5_start = std::time::Instant::now();
|
|
let now = chrono::Utc::now().to_rfc3339();
|
|
let beam_project = BeamProject {
|
|
version: BEAM_VERSION.to_string(),
|
|
created: now.clone(),
|
|
modified: now,
|
|
ui_state: document.clone(),
|
|
audio_backend: SerializedAudioBackend {
|
|
sample_rate: 48000, // TODO: Get from audio engine
|
|
project: audio_project.clone(),
|
|
audio_pool_entries: modified_entries,
|
|
layer_to_track_map: layer_to_track_map.clone(),
|
|
},
|
|
};
|
|
eprintln!("📊 [SAVE_BEAM] Step 5: Build BeamProject structure took {:.2}ms", step5_start.elapsed().as_secs_f64() * 1000.0);
|
|
|
|
// 6. Write project.json (compressed with DEFLATE)
|
|
let step6_start = std::time::Instant::now();
|
|
let json_options = FileOptions::default()
|
|
.compression_method(CompressionMethod::Deflated)
|
|
.compression_level(Some(6));
|
|
|
|
zip.start_file("project.json", json_options)
|
|
.map_err(|e| format!("Failed to create project.json in ZIP: {}", e))?;
|
|
|
|
let json = serde_json::to_string_pretty(&beam_project)
|
|
.map_err(|e| format!("JSON serialization failed: {}", e))?;
|
|
|
|
zip.write_all(json.as_bytes())
|
|
.map_err(|e| format!("Failed to write project.json: {}", e))?;
|
|
eprintln!("📊 [SAVE_BEAM] Step 6: Write project.json ({} bytes) took {:.2}ms", json.len(), step6_start.elapsed().as_secs_f64() * 1000.0);
|
|
|
|
// 7. Finalize ZIP
|
|
let step7_start = std::time::Instant::now();
|
|
zip.finish()
|
|
.map_err(|e| format!("Failed to finalize ZIP: {}", e))?;
|
|
eprintln!("📊 [SAVE_BEAM] Step 7: Finalize ZIP took {:.2}ms", step7_start.elapsed().as_secs_f64() * 1000.0);
|
|
|
|
eprintln!("📊 [SAVE_BEAM] ✅ Total save_beam() time: {:.2}ms", fn_start.elapsed().as_secs_f64() * 1000.0);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Load a project from a .beam file
|
|
///
|
|
/// This function:
|
|
/// 1. Opens ZIP archive and reads project.json
|
|
/// 2. Deserializes project data
|
|
/// 3. Loads embedded media files from archive
|
|
/// 4. Attempts to load external media files
|
|
/// 5. Rebuilds AudioGraphs from presets with correct sample_rate
|
|
///
|
|
/// # Arguments
|
|
/// * `path` - Path to the .beam file
|
|
///
|
|
/// # Returns
|
|
/// LoadedProject on success (with missing_files list), or error message
|
|
pub fn load_beam(path: &Path) -> Result<LoadedProject, String> {
|
|
let fn_start = std::time::Instant::now();
|
|
eprintln!("📊 [LOAD_BEAM] Starting load_beam()...");
|
|
|
|
// 1. Open ZIP archive
|
|
let step1_start = std::time::Instant::now();
|
|
let file = File::open(path)
|
|
.map_err(|e| format!("Failed to open file: {}", e))?;
|
|
let mut zip = ZipArchive::new(file)
|
|
.map_err(|e| format!("Failed to open ZIP archive: {}", e))?;
|
|
eprintln!("📊 [LOAD_BEAM] Step 1: Open ZIP archive took {:.2}ms", step1_start.elapsed().as_secs_f64() * 1000.0);
|
|
|
|
// 2. Read project.json
|
|
let step2_start = std::time::Instant::now();
|
|
let mut project_file = zip.by_name("project.json")
|
|
.map_err(|e| format!("Failed to find project.json in archive: {}", e))?;
|
|
|
|
let mut json_data = String::new();
|
|
project_file.read_to_string(&mut json_data)
|
|
.map_err(|e| format!("Failed to read project.json: {}", e))?;
|
|
eprintln!("📊 [LOAD_BEAM] Step 2: Read project.json ({} bytes) took {:.2}ms", json_data.len(), step2_start.elapsed().as_secs_f64() * 1000.0);
|
|
|
|
// 3. Deserialize BeamProject
|
|
let step3_start = std::time::Instant::now();
|
|
let beam_project: BeamProject = serde_json::from_str(&json_data)
|
|
.map_err(|e| format!("Failed to deserialize project.json: {}", e))?;
|
|
eprintln!("📊 [LOAD_BEAM] Step 3: Deserialize BeamProject took {:.2}ms", step3_start.elapsed().as_secs_f64() * 1000.0);
|
|
|
|
// 4. Check version compatibility
|
|
if beam_project.version != BEAM_VERSION {
|
|
return Err(format!(
|
|
"Unsupported file version: {} (expected {})",
|
|
beam_project.version, BEAM_VERSION
|
|
));
|
|
}
|
|
|
|
// 5. Extract document and audio backend state
|
|
let step5_start = std::time::Instant::now();
|
|
let mut document = beam_project.ui_state;
|
|
let mut audio_project = beam_project.audio_backend.project;
|
|
let audio_pool_entries = beam_project.audio_backend.audio_pool_entries;
|
|
let layer_to_track_map = beam_project.audio_backend.layer_to_track_map;
|
|
eprintln!("📊 [LOAD_BEAM] Step 5: Extract document and audio state took {:.2}ms", step5_start.elapsed().as_secs_f64() * 1000.0);
|
|
|
|
// 6. Rebuild AudioGraphs from presets
|
|
let step6_start = std::time::Instant::now();
|
|
audio_project.rebuild_audio_graphs(DEFAULT_BUFFER_SIZE)
|
|
.map_err(|e| format!("Failed to rebuild audio graphs: {}", e))?;
|
|
eprintln!("📊 [LOAD_BEAM] Step 6: Rebuild AudioGraphs took {:.2}ms", step6_start.elapsed().as_secs_f64() * 1000.0);
|
|
|
|
// 7. Extract embedded audio files from ZIP and restore to entries
|
|
let step7_start = std::time::Instant::now();
|
|
drop(project_file); // Close project.json file handle
|
|
let mut restored_entries = Vec::new();
|
|
let mut flac_decode_time = 0.0;
|
|
|
|
for entry in &audio_pool_entries {
|
|
let mut restored_entry = entry.clone();
|
|
|
|
// Check if this entry has a file in the ZIP (relative_path starts with "media/audio/")
|
|
if let Some(ref rel_path) = entry.relative_path {
|
|
if rel_path.starts_with("media/audio/") {
|
|
// Extract file from ZIP
|
|
match zip.by_name(rel_path) {
|
|
Ok(mut audio_file) => {
|
|
let mut audio_bytes = Vec::new();
|
|
audio_file.read_to_end(&mut audio_bytes)
|
|
.map_err(|e| format!("Failed to read {} from ZIP: {}", rel_path, e))?;
|
|
|
|
// Determine format from filename
|
|
let format = rel_path.split('.').last()
|
|
.unwrap_or("flac")
|
|
.to_string();
|
|
|
|
// For lossless formats, decode back to PCM f32 samples
|
|
// For lossy formats, store the original bytes
|
|
let embedded_data = if format == "flac" {
|
|
// Decode FLAC to PCM f32 samples
|
|
let flac_decode_start = std::time::Instant::now();
|
|
|
|
let cursor = std::io::Cursor::new(&audio_bytes);
|
|
let mut reader = claxon::FlacReader::new(cursor)
|
|
.map_err(|e| format!("Failed to create FLAC reader: {:?}", e))?;
|
|
|
|
let stream_info = reader.streaminfo();
|
|
let bits_per_sample = stream_info.bits_per_sample;
|
|
let max_value = (1i64 << (bits_per_sample - 1)) as f32;
|
|
|
|
// Read all samples and convert to f32
|
|
let mut samples_f32 = Vec::new();
|
|
for sample_result in reader.samples() {
|
|
let sample = sample_result
|
|
.map_err(|e| format!("Failed to read FLAC sample: {:?}", e))?;
|
|
samples_f32.push(sample as f32 / max_value);
|
|
}
|
|
|
|
// Encode f32 samples as a proper WAV file (with RIFF header)
|
|
let channels = entry.channels;
|
|
let sample_rate = entry.sample_rate;
|
|
let num_samples = samples_f32.len();
|
|
let bytes_per_sample = 4u32; // 32-bit float
|
|
let data_size = num_samples * bytes_per_sample as usize;
|
|
let file_size = 36 + data_size;
|
|
|
|
let mut wav_data = Vec::with_capacity(44 + data_size);
|
|
wav_data.extend_from_slice(b"RIFF");
|
|
wav_data.extend_from_slice(&(file_size as u32).to_le_bytes());
|
|
wav_data.extend_from_slice(b"WAVE");
|
|
wav_data.extend_from_slice(b"fmt ");
|
|
wav_data.extend_from_slice(&16u32.to_le_bytes());
|
|
wav_data.extend_from_slice(&3u16.to_le_bytes()); // IEEE float
|
|
wav_data.extend_from_slice(&(channels as u16).to_le_bytes());
|
|
wav_data.extend_from_slice(&sample_rate.to_le_bytes());
|
|
wav_data.extend_from_slice(&(sample_rate * channels * bytes_per_sample).to_le_bytes());
|
|
wav_data.extend_from_slice(&((channels * bytes_per_sample) as u16).to_le_bytes());
|
|
wav_data.extend_from_slice(&32u16.to_le_bytes());
|
|
wav_data.extend_from_slice(b"data");
|
|
wav_data.extend_from_slice(&(data_size as u32).to_le_bytes());
|
|
for &sample in &samples_f32 {
|
|
wav_data.extend_from_slice(&sample.to_le_bytes());
|
|
}
|
|
|
|
flac_decode_time += flac_decode_start.elapsed().as_secs_f64() * 1000.0;
|
|
|
|
Some(daw_backend::audio::pool::EmbeddedAudioData {
|
|
data_base64: BASE64_STANDARD.encode(&wav_data),
|
|
format: "wav".to_string(),
|
|
})
|
|
} else {
|
|
// Lossy format - store as-is
|
|
Some(daw_backend::audio::pool::EmbeddedAudioData {
|
|
data_base64: BASE64_STANDARD.encode(&audio_bytes),
|
|
format: format.clone(),
|
|
})
|
|
};
|
|
|
|
restored_entry.embedded_data = embedded_data;
|
|
restored_entry.relative_path = None; // Clear ZIP path
|
|
}
|
|
Err(_) => {
|
|
// File not found in ZIP, treat as external reference
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
restored_entries.push(restored_entry);
|
|
}
|
|
eprintln!("📊 [LOAD_BEAM] Step 7: Extract embedded audio ({} entries) took {:.2}ms",
|
|
audio_pool_entries.len(), step7_start.elapsed().as_secs_f64() * 1000.0);
|
|
if flac_decode_time > 0.0 {
|
|
eprintln!("📊 [LOAD_BEAM] - FLAC decoding: {:.2}ms", flac_decode_time);
|
|
}
|
|
|
|
// 7b. Load raster layer PNG buffers from ZIP
|
|
let step7b_start = std::time::Instant::now();
|
|
let mut raster_load_count = 0usize;
|
|
for layer in document.root.children.iter_mut() {
|
|
if let crate::layer::AnyLayer::Raster(rl) = layer {
|
|
for kf in &mut rl.keyframes {
|
|
if !kf.media_path.is_empty() {
|
|
match zip.by_name(&kf.media_path) {
|
|
Ok(mut png_file) => {
|
|
let mut png_bytes = Vec::new();
|
|
let _ = png_file.read_to_end(&mut png_bytes);
|
|
// Decode PNG into raw RGBA pixels for fast in-memory access
|
|
match crate::brush_engine::decode_png(&png_bytes) {
|
|
Ok(rgba) => {
|
|
kf.raw_pixels = rgba.into_raw();
|
|
raster_load_count += 1;
|
|
}
|
|
Err(e) => eprintln!("⚠️ [LOAD_BEAM] Failed to decode raster PNG {}: {}", kf.media_path, e),
|
|
}
|
|
}
|
|
Err(_) => {
|
|
// Keyframe PNG not in ZIP yet (new keyframe); leave raw_pixels empty
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
eprintln!("📊 [LOAD_BEAM] Step 7b: Load {} raster PNG buffers took {:.2}ms",
|
|
raster_load_count, step7b_start.elapsed().as_secs_f64() * 1000.0);
|
|
|
|
// 8. Check for missing external files
|
|
// An entry is missing if it has a relative_path (external reference)
|
|
// but no embedded_data and the file doesn't exist
|
|
let step8_start = std::time::Instant::now();
|
|
let project_dir = path.parent().unwrap_or_else(|| Path::new("."));
|
|
let missing_files: Vec<MissingFileInfo> = restored_entries
|
|
.iter()
|
|
.enumerate()
|
|
.filter_map(|(idx, entry)| {
|
|
// Check if this entry references an external file that doesn't exist
|
|
if entry.embedded_data.is_none() {
|
|
if let Some(ref rel_path) = entry.relative_path {
|
|
let full_path = project_dir.join(rel_path);
|
|
if !full_path.exists() {
|
|
return Some(MissingFileInfo {
|
|
pool_index: idx,
|
|
original_path: full_path,
|
|
file_type: MediaFileType::Audio,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
None
|
|
})
|
|
.collect();
|
|
eprintln!("📊 [LOAD_BEAM] Step 8: Check missing files took {:.2}ms", step8_start.elapsed().as_secs_f64() * 1000.0);
|
|
|
|
eprintln!("📊 [LOAD_BEAM] ✅ Total load_beam() time: {:.2}ms", fn_start.elapsed().as_secs_f64() * 1000.0);
|
|
|
|
Ok(LoadedProject {
|
|
document,
|
|
audio_project,
|
|
layer_to_track_map,
|
|
audio_pool_entries: restored_entries,
|
|
missing_files,
|
|
})
|
|
}
|