Function run_chunked_model_step

app/workflow/workflow.cpp:716–901

    }
    std::ofstream out(output);
    out << srt;
    context.values[id + ".srt_path"] = output.string();
    std::cout << "workflow_step=" << id << "\n";
    std::cout << "srt_out=" << output.string() << "\n";
}

void run_chunked_model_step(
    const engine::runtime::ModelRegistry & registry,
    const engine::io::json::Value & step,
    const WorkflowRunOptions & options,
    WorkflowContext & context) {
    const std::string id = workflow_string(step, "id");
    const auto request_value = step.find("request");
    if (request_value == nullptr || request_value->is_null()) {
        throw std::runtime_error("chunked_model step requires request object: " + id);
    }
    const std::string audio_key = workflow_string_or(step, "audio_key", "audio");
    engine::audio::WavData input_wav;
    if (workflow_has_field(*request_value, "audio_data")) {
        auto input_audio_data = workflow_buffer(*request_value, "audio_data");
        input_wav = engine::audio::read_wav_f32(input_audio_data);
    } else {
        const auto input_audio_path = resolve_workflow_path(workflow_string(*request_value, audio_key), context);
        input_wav = engine::audio::read_wav_f32(input_audio_path);
    }
    if (input_wav.channels <= 0 || input_wav.sample_rate <= 0 || input_wav.samples.empty()) {
        throw std::runtime_error("chunked_model input audio is invalid: " + id);
    }
    const int64_t total_frames = static_cast<int64_t>(input_wav.samples.size() / static_cast<size_t>(input_wav.channels));
    const double chunk_seconds = workflow_optional_number(step, "chunk_seconds").value_or(30.0);
    const double overlap_seconds = workflow_optional_number(step, "overlap_seconds").value_or(0.0);
    if (!(chunk_seconds > 0.0) || overlap_seconds != 0.0) {
        throw std::runtime_error("chunked_model requires chunk_seconds > 0 and overlap_seconds == 0");
    }
    const int64_t chunk_frames = static_cast<int64_t>(chunk_seconds * static_cast<double>(input_wav.sample_rate));
    const int64_t step_frames = chunk_frames;
    if (chunk_frames <= 0 || step_frames <= 0) {
        throw std::runtime_error("chunked_model computed invalid chunk frame count");
    }
    std::optional<engine::audio::WavData> timing_wav;
    if (const auto timing_audio = workflow_optional_string(step, "timing_audio")) {
        timing_wav = engine::audio::read_wav_f32(resolve_workflow_path(*timing_audio, context));
        if (timing_wav->sample_rate != input_wav.sample_rate || timing_wav->channels != input_wav.channels) {
            throw std::runtime_error("chunked_model timing_audio must match the source sample rate and channel count");
        }
        const int64_t timing_frames =
            static_cast<int64_t>(timing_wav->samples.size() / static_cast<size_t>(timing_wav->channels));
        if (timing_frames < total_frames) {
            throw std::runtime_error("chunked_model timing_audio is shorter than the source audio");
        }
    }
    const bool use_timing_repaint_window = workflow_optional_bool(step, "set_repaint_window_from_timing", false);
    if (use_timing_repaint_window && !timing_wav.has_value()) {
        throw std::runtime_error("chunked_model set_repaint_window_from_timing requires timing_audio");
    }
    const float timing_threshold_dbfs =
        static_cast<float>(workflow_optional_number(step, "timing_threshold_dbfs").value_or(-40.0));
    const double timing_window_seconds = workflow_optional_number(step, "timing_window_seconds").value_or(0.1);