Method prepare

src/models/stable_audio/session.cpp:227–268

}

void StableAudioSession::prepare(const runtime::SessionPreparationRequest & request) {
    if (!conditioner_inputs_) {
        conditioner_inputs_ = std::make_unique<StableAudioConditionerInputs>(assets_);
    }
    if (!conditioner_runtime_) {
        conditioner_runtime_ = std::make_unique<StableAudioConditionerRuntime>(
            execution_context(),
            assets_,
            weight_storage_type_,
            max_batch_);
    }
    if (!rf_dit_) {
        rf_dit_ = std::make_unique<StableAudioRfDitRuntime>(
            execution_context(),
            assets_,
            weight_storage_type_);
    }
    if (!same_) {
        same_ = std::make_unique<StableAudioSameRuntime>(
            execution_context(),
            assets_,
            weight_storage_type_);
    }
    conditioner_runtime_->prepare();
    if (request.text.has_value() || !request.options.empty()) {
        runtime::TaskRequest task_request;
        task_request.text_input = request.text;
        task_request.options = request.options;
        const StableAudioRequest parsed = clamp_request_to_model_limit(
            parse_stable_audio_request(task_request),
            assets_->config);
        const auto rng_policy = engine::sampling::resolve_torch_cuda_sampling_policy(
            execution_context().backend_type(),
            execution_context().config().device,
            "stable_audio.rng",
            "Stable Audio");
        const StableAudioSamplingState sampling = prepare_stable_audio_sampling_state(assets_->config, parsed, rng_policy);
        rf_dit_->prepare(sampling, parsed.guidance_scale);
        same_->prepare_decode(sampling.batch, sampling.latent_sample_size, parsed.chunked_decode);
    }
    mark_prepared();
}

runtime::TaskResult StableAudioSession::run(const runtime::TaskRequest & request) {
    require_prepared("Stable Audio run");