[Bug] can't use indicatif inside progress callback

[thewh1teagle]

When using indicatif in progress callback it crashes

use std::thread;
use std::time::Duration;

use indicatif::ProgressBar;

fn main() {
    let pb = ProgressBar::new(100);
    // setup whisper-rs model
    // tried with move or without
    // register progress callback
    params.set_progress_callback_safe(move |progress| {
        pb.set_position(progress);
    });
    pb.finish_with_message("done");
}

[tazz4843]

Calling enable_steady_tick on the progress bar before doing anything more fixes it for this specific case. I'm tempted to remove set_progress_callback_safe until it can be rewritten after this issue since this is interesting.

[thewh1teagle]

I found this workround
https://github.com/thewh1teagle/vibe/blob/main/core/src/model.rs#L58

[AbduEhab]

Here is my workaround if you're interested:

use std::thread;
use std::time::Duration;
use std::sync::LazyLock;

use indicatif::ProgressBar;

static PROGRESSBAR: LazyLock<ProgressBar> = std::sync::LazyLock::new(|| ProgressBar::new(100 as u64));

fn main() {
    // setup whisper-rs model
    // register progress callback
    params.set_progress_callback_safe(move |progress| {
        PROGRESSBAR.set_position(progress as u64);
    });

    PROGRESSBAR.enable_steady_tick(Duration::new(0, 5000));

    state
        .full(params, &samples[..])
        .expect("handle whisper error!");

    PROGRESSBAR.disable_steady_tick();
    PROGRESSBAR.finish_with_message("done");
}

[tazz4843]

Oh this reminds me, I was able to get a safe Rust callback with user_data working in april-asr-rs

The relevant code is here: https://github.com/tazz4843/april-asr-rs/blob/f9af1695ff245e0bffa5d928a1998ff64155045b/src/april_config.rs#L74-L153

Converting this to whisper-rs would be trivial, the only invariant that might not be upheld between the two is whisper.cpp may call this callback simultaneously. That would need to be audited by searching through upstream's source code.

[akinsella]

I ended up with a quite different solution which seems to work fine but this relies on the unsafe call:

// Simple struct to hold all callback data
struct CallbackData {
    last_progress: AtomicI32,
}

impl CallbackData {
    
    fn new(/* your params */) -> Self {
        // Initialize progress to -1 (to ensure first update is processed)

        let callback_data = Self { 
            last_progress: AtomicI32::new(-1), 
        };

        callback_data.update_progress(0);

        callback_data
    }
    
    // Update progress directly in the callback - only if it changed
    fn update_progress(&self, new_progress: i32) {
        let last = self.last_progress.load(Ordering::SeqCst);
        
        if new_progress != last {
            self.last_progress.store(new_progress, Ordering::SeqCst);
            info!("Progress: {}%", new_progress);
        
            // Do whatever you want
        }
    }

}

...


// Set up the progress callback with user data
fn setup_progress_callback(params: &mut FullParams, callback_data: Arc<CallbackData>) {

    // Create a raw pointer for the callback
    let data_ptr = Arc::into_raw(callback_data) as *mut c_void;
    
    // Set up the callback
    unsafe {
        extern "C" fn trampoline(
            _: *mut whisper_rs_sys::whisper_context,
            _: *mut whisper_rs_sys::whisper_state,
            progress: c_int,
            user_data: *mut c_void,
        ) {
            if !user_data.is_null() {
                // Reconstruct Arc without consuming it
                let data = unsafe { Arc::from_raw(user_data as *const CallbackData) };
                
                // Update progress directly - Redis happens inside
                data.update_progress(progress);
                
                // Don't drop the Arc - just forget the temporary reference
                std::mem::forget(data);
            }
        }
        
        params.set_progress_callback(Some(trampoline));
        params.set_progress_callback_user_data(data_ptr);
    }
}

...

pub fn create_params_from_config<'a>(
    config: &WhisperConfig, 
    language: &'a str, 
    transcription_context: TranscriptionContext, 
) -> FullParams<'a, 'static> {
    let sampling_strategy = match &config.sampling_strategy {
        SamplingStrategyConfig::Greedy { best_of } => SamplingStrategy::Greedy { best_of: *best_of },
        SamplingStrategyConfig::BeamSearch { beam_size } => SamplingStrategy::BeamSearch { beam_size: *beam_size, patience: 0.0 },
    };

    let mut params = FullParams::new(sampling_strategy);

    info!("Setting config: {:?}", config);

    // Edit params as needed.
    params.set_n_threads(config.n_threads);
    params.set_translate(config.translate);
    params.set_language(Some(language));
    ...
    params.set_debug_mode(config.debug_mode);

   setup_progress_callback(&mut params, Arc::new(CallbackData::new(/* Your params */)));

    params
}

I think it can better generalize. I am not 100% sure that this is fully correct regarding the unsafe block, but it works great for my use case. I was able to update data in a redis to make transcription progress available outside of the processing component.

Hope it helps.

[tazz4843]

This should be fixed in #220 now finally (published to crates.io, see v0.14.3 of whisper-rs`