[*] refactor: video-editor

Author: heng30

lib/video-editor/src/commands/segment.rs

@@ -787,3 +787,221 @@ impl Command for UpdateTrackMetadataCommand {
         format!("Update track {} metadata", self.track_index)
     }
 }
+
+pub struct DetachAudioTracksCommand {
+    track_index: usize,
+    old_metadata: Option<Arc<Metadata>>,
+    detached_track_indices: Option<Vec<usize>>,
+}
+
+impl DetachAudioTracksCommand {
+    pub fn new(track_index: usize) -> Self {
+        Self {
+            track_index,
+            old_metadata: None,
+            detached_track_indices: None,
+        }
+    }
+}
+
+impl Command for DetachAudioTracksCommand {
+    fn execute(&mut self, manager: &mut Manager) -> Result<()> {
+        execute_detach(
+            manager,
+            self.track_index,
+            DetachType::Audio,
+            &mut self.old_metadata,
+            &mut self.detached_track_indices,
+        )
+    }
+
+    fn undo(&mut self, manager: &mut Manager) -> Result<()> {
+        undo_detach(
+            manager,
+            self.track_index,
+            &mut self.old_metadata,
+            &mut self.detached_track_indices,
+        )
+    }
+
+    fn describe(&self) -> String {
+        format!("Detach audio tracks from track {}", self.track_index)
+    }
+}
+
+pub struct DetachSubtitleTracksCommand {
+    track_index: usize,
+    old_metadata: Option<Arc<Metadata>>,
+    detached_track_indices: Option<Vec<usize>>,
+}
+
+impl DetachSubtitleTracksCommand {
+    pub fn new(track_index: usize) -> Self {
+        Self {
+            track_index,
+            old_metadata: None,
+            detached_track_indices: None,
+        }
+    }
+}
+
+impl Command for DetachSubtitleTracksCommand {
+    fn execute(&mut self, manager: &mut Manager) -> Result<()> {
+        execute_detach(
+            manager,
+            self.track_index,
+            DetachType::Subtitle,
+            &mut self.old_metadata,
+            &mut self.detached_track_indices,
+        )
+    }
+
+    fn undo(&mut self, manager: &mut Manager) -> Result<()> {
+        undo_detach(
+            manager,
+            self.track_index,
+            &mut self.old_metadata,
+            &mut self.detached_track_indices,
+        )
+    }
+
+    fn describe(&self) -> String {
+        format!("Detach subtitle tracks from track {}", self.track_index)
+    }
+}
+
+#[derive(Clone, Copy)]
+enum DetachType {
+    Audio,
+    Subtitle,
+}
+
+fn execute_detach(
+    manager: &mut Manager,
+    track_index: usize,
+    detach_type: DetachType,
+    old_metadata: &mut Option<Arc<Metadata>>,
+    detached_track_indices: &mut Option<Vec<usize>>,
+) -> Result<()> {
+    let manager_len = manager.len();
+    if track_index >= manager_len {
+        return Err(Error::IndexOutOfBounds(track_index, manager_len));
+    }
+
+    let track = manager
+        .get(track_index)
+        .ok_or_else(|| Error::IndexOutOfBounds(track_index, manager_len))?;
+
+    let video_track = match track {
+        Track::Video(vt) => vt,
+        _ => {
+            return Err(Error::InvalidConfig(format!(
+                "Only video tracks can have detached {}",
+                match detach_type {
+                    DetachType::Audio => "audio",
+                    DetachType::Subtitle => "subtitles",
+                }
+            )));
+        }
+    };
+
+    let has_streams = match detach_type {
+        DetachType::Audio => !video_track.track.metadata.audios.is_empty(),
+        DetachType::Subtitle => !video_track.track.metadata.subtitles.is_empty(),
+    };
+
+    if !has_streams {
+        return Err(Error::InvalidConfig(format!(
+            "Video track has no {} streams to detach",
+            match detach_type {
+                DetachType::Audio => "audio",
+                DetachType::Subtitle => "subtitle",
+            }
+        )));
+    }
+
+    let mut video_track_mut = video_track.as_ref().clone();
+    *old_metadata = Some(video_track.track.metadata.clone());
+
+    let detached_tracks: Vec<Track> = match detach_type {
+        DetachType::Audio => video_track_mut
+            .detach_audio_tracks()
+            .into_iter()
+            .map(|at| Track::Audio(Arc::new(at)))
+            .collect(),
+        DetachType::Subtitle => video_track_mut
+            .detach_subtitle_tracks()
+            .into_iter()
+            .map(|st| Track::Subtitle(Arc::new(st)))
+            .collect(),
+    };
+
+    if detached_tracks.is_empty() {
+        return Err(Error::InvalidConfig(format!(
+            "No {} tracks were created{}",
+            match detach_type {
+                DetachType::Audio => "audio",
+                DetachType::Subtitle => "subtitle",
+            },
+            match detach_type {
+                DetachType::Audio => "",
+                DetachType::Subtitle => " (extraction may have failed)",
+            }
+        )));
+    }
+
+    // Update video track metadata
+    let new_metadata = video_track_mut.track.metadata.clone();
+    let track = manager
+        .get_mut(track_index)
+        .ok_or_else(|| Error::IndexOutOfBounds(track_index, manager_len))?;
+
+    if let Track::Video(vt) = track {
+        let vt = Arc::make_mut(vt);
+        vt.track.metadata = new_metadata;
+    }
+
+    // Insert detached tracks
+    let mut inserted_indices = Vec::new();
+    for (i, track) in detached_tracks.into_iter().enumerate() {
+        let insert_idx = track_index + 1 + i;
+        manager.insert_track(insert_idx, track)?;
+        inserted_indices.push(insert_idx);
+    }
+
+    *detached_track_indices = Some(inserted_indices);
+    Ok(())
+}
+
+fn undo_detach(
+    manager: &mut Manager,
+    track_index: usize,
+    old_metadata: &mut Option<Arc<Metadata>>,
+    detached_track_indices: &mut Option<Vec<usize>>,
+) -> Result<()> {
+    let old_meta = old_metadata
+        .take()
+        .ok_or_else(|| Error::InvalidConfig("Command not yet executed".into()))?;
+
+    let detached_indices = detached_track_indices
+        .take()
+        .ok_or_else(|| Error::InvalidConfig("Command not yet executed".into()))?;
+
+    // Remove detached tracks in reverse order
+    for idx in detached_indices.into_iter().rev() {
+        manager.remove_track(idx)?;
+    }
+
+    // Restore original metadata
+    let manager_len = manager.len();
+    let track = manager
+        .get_mut(track_index)
+        .ok_or_else(|| Error::IndexOutOfBounds(track_index, manager_len))?;
+
+    if let Track::Video(vt) = track {
+        let vt = Arc::make_mut(vt);
+        vt.track.metadata = old_meta;
+    }
+
+    Ok(())
+}

lib/video-editor/src/commands/track.rs

@@ -165,6 +165,97 @@ impl VideoTrack {
         audio_tracks
     }
 
+    /// Detach subtitle tracks from a specific segment within the video track.
+    /// This creates new subtitle tracks from the segment's subtitle streams.
+    pub fn detach_segment_subtitle_tracks(&mut self, segment_index: usize) -> Vec<SubtitleTrack> {
+        let segment = match self.track.segments.get(segment_index) {
+            Some(seg) => seg.clone(),
+            None => return Vec::new(),
+        };
+
+        let metadata = &segment.metadata;
+        if metadata.subtitles.is_empty() {
+            return Vec::new();
+        }
+
+        let mut subtitle_tracks = Vec::new();
+
+        for subtitle_meta in &metadata.subtitles {
+            let entries = match extract_subtitles(&metadata.path, subtitle_meta.index) {
+                Ok(entries) => entries,
+                Err(e) => {
+                    log::warn!(
+                        "Failed to extract subtitles from stream {}: {}",
+                        subtitle_meta.index,
+                        e
+                    );
+                    continue;
+                }
+            };
+
+            if entries.is_empty() {
+                continue;
+            }
+
+            let subtitle_metadata = Arc::new(crate::metadata::Metadata {
+                path: metadata.path.clone(),
+                size: metadata.size,
+                bitrate: metadata.bitrate,
+                duration: metadata.duration,
+                format: metadata.format.clone(),
+                videos: Vec::new(),
+                audios: Vec::new(),
+                subtitles: vec![subtitle_meta.clone()],
+            });
+
+            // Filter entries to only include those within the segment's time range
+            let segment_start = segment.source_offset;
+            let segment_end = segment_start + segment.duration;
+            let filtered_entries: Vec<crate::filters::SubtitleEntry> = entries
+                .into_iter()
+                .filter(|entry| {
+                    entry.start >= segment_start && entry.end <= segment_end
+                })
+                .collect();
+
+            if filtered_entries.is_empty() {
+                continue;
+            }
+
+            let segments: Vec<Arc<Segment>> = filtered_entries
+                .iter()
+                .map(|entry| {
+                    let segment_duration = entry.end.saturating_sub(entry.start);
+                    Arc::new(Segment::new_with_source_offset(
+                        entry.start,      // timeline_offset
+                        entry.start,      // source_offset
+                        segment_duration, // duration
+                        subtitle_metadata.clone(),
+                    ))
+                })
+                .collect();
+
+            let subtitle_track = SubtitleTrack {
+                name: String::default(),
+                hiding: false,
+                subtitles: filtered_entries,
+                track: InnerTrack {
+                    metadata: subtitle_metadata,
+                    duration: segment.duration,
+                    segments,
+                },
+            };
+            subtitle_tracks.push(subtitle_track);
+        }
+
+        // Remove subtitle metadata from segment
+        let segment = Arc::make_mut(&mut self.track.segments[segment_index]);
+        let segment_metadata = Arc::make_mut(&mut segment.metadata);
+        segment_metadata.subtitles.clear();
+
+        subtitle_tracks
+    }
+
     // 将视频轨道中的所有字幕轨道分离出来，并移除视频轨道中字幕轨道的信息
     pub fn detach_subtitle_tracks(&mut self) -> Vec<SubtitleTrack> {
         let metadata = &self.track.metadata;