fix(scan): quiet startup scans & thumbnail RAW/HEIC

Three recurring issues on every full scan:

1. Video playlist scans re-enqueued every file only to reject it as
   AlreadyExists. Pre-filter in ScanDirectoryMessage and QueueVideosMessage
   so we skip videos whose .m3u8 already exists, and demote the leaked
   AlreadyExists log to debug.

2. image crate was built with only jpeg/png features, so webp/tiff/avif
   files logged "format not supported" every scan. Enable those features.

3. RAW (ARW/NEF/CR2/...) and HEIC thumbnails weren't generated, so the
   scan kept retrying them. Try the file's embedded JPEG preview via
   kamadak-exif first (fast, pure-Rust, works on Sony ARW where ffmpeg's
   TIFF decoder fails). Fall back to ffmpeg for HEIC/HEIF and RAWs with
   no preview. Anything still undecodable gets a <thumb>.unsupported
   sentinel so future scans skip it.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

src/video/actors.rs

@@ -48,6 +48,14 @@ impl Handler<ProcessMessage> for StreamActor {
     }
 }
 
+pub fn playlist_file_for(playlist_dir: &str, video_path: &Path) -> PathBuf {
+    let filename = video_path
+        .file_name()
+        .and_then(|n| n.to_str())
+        .unwrap_or("unknown");
+    PathBuf::from(format!("{}/{}.m3u8", playlist_dir, filename))
+}
+
 pub async fn create_playlist(video_path: &str, playlist_file: &str) -> Result<Child> {
     if Path::new(playlist_file).exists() {
         debug!("Playlist already exists: {}", playlist_file);
@@ -103,6 +111,35 @@ pub fn generate_video_thumbnail(path: &Path, destination: &Path) {
         .expect("Failure to create video frame");
 }
 
+/// Use ffmpeg to extract a 200px-wide thumbnail from formats the `image` crate
+/// can't decode (RAW: NEF/ARW, HEIC/HEIF). Writes JPEG bytes to `destination`
+/// regardless of its extension.
+pub fn generate_image_thumbnail_ffmpeg(path: &Path, destination: &Path) -> std::io::Result<()> {
+    let output = Command::new("ffmpeg")
+        .arg("-y")
+        .arg("-i")
+        .arg(path)
+        .arg("-vframes")
+        .arg("1")
+        .arg("-vf")
+        .arg("scale=200:-1")
+        .arg("-f")
+        .arg("image2")
+        .arg("-c:v")
+        .arg("mjpeg")
+        .arg(destination)
+        .output()?;
+
+    if !output.status.success() {
+        return Err(std::io::Error::other(format!(
+            "ffmpeg failed ({}): {}",
+            output.status,
+            String::from_utf8_lossy(&output.stderr).trim()
+        )));
+    }
+    Ok(())
+}
+
 /// Check if a video is already encoded with h264 codec
 /// Returns true if the video uses h264, false otherwise or if detection fails
 async fn is_h264_encoded(video_path: &str) -> bool {
@@ -246,15 +283,18 @@ impl Handler<ScanDirectoryMessage> for VideoPlaylistManager {
             msg.directory
         );
 
+        let playlist_output_dir = self.playlist_dir.clone();
+        let playlist_dir_str = playlist_output_dir.to_str().unwrap().to_string();
+
         let video_files = WalkDir::new(&msg.directory)
             .into_iter()
             .filter_map(|e| e.ok())
             .filter(|e| e.file_type().is_file())
             .filter(is_video)
+            .filter(|e| !playlist_file_for(&playlist_dir_str, e.path()).exists())
             .collect::<Vec<DirEntry>>();
 
         let scan_dir_name = msg.directory.clone();
-        let playlist_output_dir = self.playlist_dir.clone();
         let playlist_generator = self.playlist_generator.clone();
 
         Box::pin(async move {
@@ -285,6 +325,9 @@ impl Handler<ScanDirectoryMessage> for VideoPlaylistManager {
                             path_as_str
                         );
                     }
+                    Err(e) if e.kind() == std::io::ErrorKind::AlreadyExists => {
+                        debug!("Playlist already exists for '{:?}', skipping", path);
+                    }
                     Err(e) => {
                         warn!("Failed to generate playlist for path '{:?}'. {:?}", path, e);
                     }
@@ -318,14 +361,18 @@ impl Handler<QueueVideosMessage> for VideoPlaylistManager {
         );
 
         let playlist_output_dir = self.playlist_dir.clone();
+        let playlist_dir_str = playlist_output_dir.to_str().unwrap().to_string();
         let playlist_generator = self.playlist_generator.clone();
 
         for video_path in msg.video_paths {
+            if playlist_file_for(&playlist_dir_str, &video_path).exists() {
+                continue;
+            }
             let path_str = video_path.to_string_lossy().to_string();
             debug!("Queueing playlist generation for: {}", path_str);
 
             playlist_generator.do_send(GeneratePlaylistMessage {
-                playlist_path: playlist_output_dir.to_str().unwrap().to_string(),
+                playlist_path: playlist_dir_str.clone(),
                 video_path,
             });
         }