Fix demo error

Author: wysaid

bindings/rust/examples/capture_callback.rs

@@ -1,96 +1,100 @@
-use ccap::{Provider, Result};
-use std::sync::{Arc, Mutex, mpsc};
+use ccap::{Provider, Result, Utils, PropertyName, PixelFormat, LogLevel};
+use std::sync::{Arc, Mutex};
 use std::thread;
-use std::time::{Duration, Instant};
+use std::time::Duration;
 
 fn main() -> Result<()> {
-    // Create a camera provider
-    let mut provider = Provider::new()?;
+    // Enable verbose log to see debug information
+    Utils::set_log_level(LogLevel::Verbose);
+
+    // Set error callback to receive error notifications
+    Provider::set_error_callback(|error_code, description| {
+        eprintln!("Camera Error - Code: {}, Description: {}", error_code, description);
+    });
+
+    let temp_provider = Provider::new()?;
+    let devices = temp_provider.list_devices()?;
+    if devices.is_empty() {
+        eprintln!("No camera devices found!");
+        return Ok(());
+    }
+
+    for (i, device) in devices.iter().enumerate() {
+        println!("## Found video capture device: {}: {}", i, device);
+    }
+
+    // Select camera device (automatically use first device for testing)
+    let device_index = if devices.len() == 1 {
+        0
+    } else {
+        0 // Just use first device for now
+    };
 
-    // Open the first available device
+    // Create provider with selected device
+    let mut provider = Provider::with_device(device_index as i32)?;
+
+    // Set camera properties
+    let requested_width = 1920;
+    let requested_height = 1080;
+    let requested_fps = 60.0;
+
+    provider.set_property(PropertyName::Width, requested_width as f64)?;
+    provider.set_property(PropertyName::Height, requested_height as f64)?;
+    provider.set_property(PropertyName::PixelFormatOutput, PixelFormat::Bgra32 as u32 as f64)?;
+    provider.set_property(PropertyName::FrameRate, requested_fps)?;
+
+    // Open and start camera
     provider.open()?;
-    println!("Camera opened successfully.");
-    
-    // Start capture
     provider.start()?;
-    println!("Camera capture started.");
-    
+
+    if !provider.is_started() {
+        eprintln!("Failed to start camera!");
+        return Ok(());
+    }
+
+    // Get real camera properties
+    let real_width = provider.get_property(PropertyName::Width)? as i32;
+    let real_height = provider.get_property(PropertyName::Height)? as i32;
+    let real_fps = provider.get_property(PropertyName::FrameRate)?;
+
+    println!("Camera started successfully, requested resolution: {}x{}, real resolution: {}x{}, requested fps {}, real fps: {}",
+             requested_width, requested_height, real_width, real_height, requested_fps, real_fps);
+
+    // Create directory for captures (using std::fs)
+    std::fs::create_dir_all("./image_capture").map_err(|e| ccap::CcapError::FileOperationFailed(e.to_string()))?;
+
     // Statistics tracking
     let frame_count = Arc::new(Mutex::new(0u32));
-    let start_time = Arc::new(Mutex::new(Instant::now()));
-    
-    // Create a channel for communication
-    let (tx, rx) = mpsc::channel();
-    
-    // Spawn a thread to continuously grab frames
     let frame_count_clone = frame_count.clone();
-    let start_time_clone = start_time.clone();
-    
-    thread::spawn(move || {
-        loop {
-            // Check for stop signal
-            match rx.try_recv() {
-                Ok(_) => break,
-                Err(mpsc::TryRecvError::Disconnected) => break,
-                Err(mpsc::TryRecvError::Empty) => {}
-            }
-            
-            // Grab frame with timeout
-            match provider.grab_frame(100) {
-                Ok(Some(frame)) => {
-                    let mut count = frame_count_clone.lock().unwrap();
-                    *count += 1;
-                    
-                    // Print stats every 30 frames
-                    if *count % 30 == 0 {
-                        let elapsed = start_time_clone.lock().unwrap().elapsed();
-                        let fps = *count as f64 / elapsed.as_secs_f64();
-                        
-                        println!("Frame {}: {}x{}, format: {:?}, FPS: {:.1}",
-                            *count,
-                            frame.width(),
-                            frame.height(), 
-                            frame.pixel_format(),
-                            fps
-                        );
-                        
-                        // TODO: Save every 30th frame (saving not yet implemented)
-                        println!("Frame {} captured: {}x{}, format: {:?} (saving not implemented)", 
-                                *count, frame.width(), frame.height(), frame.pixel_format());
-                    }
-                }
-                Ok(None) => {
-                    // No frame available, continue
-                }
-                Err(e) => {
-                    eprintln!("Error grabbing frame: {}", e);
-                    thread::sleep(Duration::from_millis(10));
-                }
-            }
+
+    // Set frame callback
+    provider.set_new_frame_callback(move |frame| {
+        let mut count = frame_count_clone.lock().unwrap();
+        *count += 1;
+
+        println!("VideoFrame {} grabbed: width = {}, height = {}, bytes: {}", 
+                 frame.index(), frame.width(), frame.height(), frame.data_size());
+
+        // Try to save frame to directory
+        if let Ok(filename) = Utils::dump_frame_to_directory(frame, "./image_capture") {
+            println!("VideoFrame saved to: {}", filename);
+        } else {
+            eprintln!("Failed to save frame!");
         }
-        
-        println!("Frame grabbing thread stopped.");
-    });
-    
-    // Run for 10 seconds
-    println!("Capturing frames for 10 seconds...");
-    thread::sleep(Duration::from_secs(10));
-    
-    // Signal stop
-    let _ = tx.send(());
-    
-    // Wait a bit for thread to finish
-    thread::sleep(Duration::from_millis(100));
-    
-    // Print final statistics
+
+        true // no need to retain the frame
+    })?;
+
+    // Wait for 5 seconds to capture frames
+    println!("Capturing frames for 5 seconds...");
+    thread::sleep(Duration::from_secs(5));
+
+    // Get final count
     let final_count = *frame_count.lock().unwrap();
-    let total_time = start_time.lock().unwrap().elapsed();
-    let avg_fps = final_count as f64 / total_time.as_secs_f64();
-    
-    println!("Capture completed:");
-    println!("  Total frames: {}", final_count);
-    println!("  Total time: {:.2}s", total_time.as_secs_f64());
-    println!("  Average FPS: {:.1}", avg_fps);
+    println!("Captured {} frames, stopping...", final_count);
 
+    // Remove callback before dropping
+    let _ = provider.remove_new_frame_callback();
+
     Ok(())
 }

bindings/rust/examples/capture_grab.rs

@@ -1,75 +1,65 @@
-use ccap::{Provider, Result, PixelFormat};
+use ccap::{Provider, Result, PixelFormat, Utils, PropertyName, LogLevel};
+use std::fs;
 
 fn main() -> Result<()> {
+    // Enable verbose log to see debug information
+    Utils::set_log_level(LogLevel::Verbose);
+
+    // Set error callback to receive error notifications
+    Provider::set_error_callback(|error_code, description| {
+        eprintln!("Camera Error - Code: {}, Description: {}", error_code, description);
+    });
+
     // Create a camera provider
     let mut provider = Provider::new()?;
-    
-    // List devices
-    let devices = provider.list_devices()?;
-    if devices.is_empty() {
-        eprintln!("No camera devices found.");
+
+    // Open default device
+    provider.open()?;
+    provider.start_capture()?;
+
+    if !provider.is_started() {
+        eprintln!("Failed to start camera!");
         return Ok(());
     }
-    
-    println!("Found {} camera device(s):", devices.len());
-    for (i, device) in devices.iter().enumerate() {
-        println!("  {}: {}", i, device);
-    }
-    
-    // Open the first device
-    provider.open_device(Some(&devices[0]), true)?;
-    println!("Opened device: {}", devices[0]);
-    
-    // Get device info
-    let device_info = provider.device_info()?;
-    println!("Device info:");
-    println!("  Supported pixel formats: {:?}", device_info.supported_pixel_formats);
-    println!("  Supported resolutions: {:?}", device_info.supported_resolutions);
-    
-    // Try to set a common resolution
-    if let Some(res) = device_info.supported_resolutions.first() {
-        provider.set_resolution(res.width, res.height)?;
-        println!("Set resolution to {}x{}", res.width, res.height);
-    }
-    
-    // Try to set RGB24 format if supported
-    if device_info.supported_pixel_formats.contains(&PixelFormat::Rgb24) {
-        provider.set_pixel_format(PixelFormat::Rgb24)?;
-        println!("Set pixel format to RGB24");
+
+    // Print the real resolution and fps after camera started
+    let real_width = provider.get_property(PropertyName::Width)? as u32;
+    let real_height = provider.get_property(PropertyName::Height)? as u32;
+    let real_fps = provider.get_property(PropertyName::FrameRate)?;
+
+    println!("Camera started successfully, real resolution: {}x{}, real fps: {}",
+           real_width, real_height, real_fps);
+
+    // Create capture directory
+    let capture_dir = "./image_capture";
+    if !std::path::Path::new(capture_dir).exists() {
+        fs::create_dir_all(capture_dir)
+            .map_err(|e| ccap::CcapError::InvalidParameter(format!("Failed to create directory: {}", e)))?;
     }
-    
-    // Print current settings
-    let resolution = provider.resolution()?;
-    let pixel_format = provider.pixel_format()?;
-    let frame_rate = provider.frame_rate()?;
-    
-    println!("Current settings:");
-    println!("  Resolution: {}x{}", resolution.0, resolution.1);
-    println!("  Pixel format: {:?}", pixel_format);
-    println!("  Frame rate: {:.2} fps", frame_rate);
-    
-    // Capture and save a frame
-    println!("Grabbing a frame...");
-    match provider.grab_frame(2000) {
-        Ok(Some(frame)) => {
-            println!("Captured frame: {}x{}, format: {:?}, size: {} bytes",
-                frame.width(), frame.height(), frame.pixel_format(), frame.data_size());
-            
-            // TODO: Add frame saving functionality
-            println!("Frame captured successfully (saving not yet implemented)");
-            
-            // TODO: Add frame conversion functionality
-            if frame.pixel_format() != PixelFormat::Rgb24 {
-                println!("Frame format conversion not yet implemented");
+
+    // Capture frames (3000 ms timeout when grabbing frames)
+    let mut frame_count = 0;
+    while let Some(frame) = provider.grab_frame(3000)? {
+        let frame_info = frame.info()?;
+        println!("VideoFrame {} grabbed: width = {}, height = {}, bytes: {}", 
+            frame_info.frame_index, frame_info.width, frame_info.height, frame_info.size_in_bytes);
+        
+        // Save frame to directory
+        match Utils::dump_frame_to_directory(&frame, capture_dir) {
+            Ok(dump_file) => {
+                println!("VideoFrame saved to: {}", dump_file);
+            }
+            Err(e) => {
+                eprintln!("Failed to save frame: {}", e);
             }
         }
-        Ok(None) => {
-            println!("No frame available (timeout)");
-        }
-        Err(e) => {
-            eprintln!("Error grabbing frame: {}", e);
+
+        frame_count += 1;
+        if frame_count >= 10 {
+            println!("Captured 10 frames, stopping...");
+            break;
         }
     }
-    
+
     Ok(())
 }

bindings/rust/examples/minimal_example.rs

@@ -1,51 +1,46 @@
-use ccap::{Provider, Result};
-use std::thread;
-use std::time::Duration;
+use ccap::{Provider, Result, Utils};
 
 fn main() -> Result<()> {
-    // Create a camera provider and open the first device
-    let mut provider = Provider::new()?;
+    // Set error callback to receive error notifications
+    Provider::set_error_callback(|error_code, description| {
+        eprintln!("Error occurred - Code: {}, Description: {}", error_code, description);
+    });
+
+    let temp_provider = Provider::new()?;
+    let devices = temp_provider.list_devices()?;
+    let camera_index = Utils::select_camera(&devices)?;
 
-    // Open device with auto-start
+    // Use device index instead of name to avoid issues
+    let mut provider = Provider::with_device(camera_index as i32)?;
     provider.open()?;
-    println!("Camera opened successfully.");
-    
-    // Check if capture is started
-    if provider.is_started() {
-        println!("Camera capture started.");
-    } else {
-        println!("Starting camera capture...");
-        provider.start()?;
+    provider.start()?;
+
+    if !provider.is_started() {
+        eprintln!("Failed to start camera!");
+        return Ok(());
     }
-    
-    // Capture a few frames
-    println!("Capturing frames...");
-    for i in 0..5 {
-        match provider.grab_frame(1000) {
+
+    println!("Camera started successfully.");
+
+    // Capture frames
+    for i in 0..10 {
+        match provider.grab_frame(3000) {
             Ok(Some(frame)) => {
-                let width = frame.width();
-                let height = frame.height();
-                let format = frame.pixel_format();
-                let data_size = frame.data_size();
-                
-                println!("Frame {}: {}x{}, format: {:?}, size: {} bytes", 
-                    i + 1, width, height, format, data_size);
+                println!("VideoFrame {} grabbed: width = {}, height = {}, bytes: {}, format: {:?}", 
+                    frame.index(), frame.width(), frame.height(), frame.data_size(), frame.pixel_format());
             }
             Ok(None) => {
-                println!("Frame {}: No frame available (timeout)", i + 1);
+                eprintln!("Failed to grab frame {}!", i);
+                return Ok(());
             }
             Err(e) => {
-                eprintln!("Frame {}: Error grabbing frame: {}", i + 1, e);
+                eprintln!("Error grabbing frame {}: {}", i, e);
+                return Ok(());
             }
         }
-        
-        // Small delay between captures
-        thread::sleep(Duration::from_millis(100));
     }
-    
-    // Stop capture
+
+    println!("Captured 10 frames, stopping...");
     let _ = provider.stop();
-    println!("Camera capture stopped.");
-    
     Ok(())
 }