{

bool skip_unet = false;

bool skip_vae = false;

bool skip_text_encoders = false;

ggml_backend_t backend = NULL; // general backend

ggml_backend_t clip_backend = NULL;

ggml_backend_t control_net_backend = NULL;

ggml_backend_t vae_backend = NULL;

ggml_type model_wtype = GGML_TYPE_COUNT;

ggml_type conditioner_wtype = GGML_TYPE_COUNT;

ggml_type diffusion_model_wtype = GGML_TYPE_COUNT;

ggml_type vae_wtype = GGML_TYPE_COUNT;

SDVersion version;

bool vae_decode_only = false;

bool free_params_immediately = false;

std::shared_ptr<RNG> rng = std::make_shared<STDDefaultRNG>();

int n_threads = -1;

float scale_factor = 0.18215f;

std::shared_ptr<Conditioner> cond_stage_model;

std::shared_ptr<FrozenCLIPVisionEmbedder> clip_vision; // for svd

std::shared_ptr<DiffusionModel> diffusion_model;

std::shared_ptr<AutoEncoderKL> first_stage_model;

std::shared_ptr<TinyAutoEncoder> tae_first_stage;

std::shared_ptr<ControlNet> control_net;

std::shared_ptr<PhotoMakerIDEncoder> pmid_model;

std::shared_ptr<LoraModel> pmid_lora;

std::shared_ptr<PhotoMakerIDEmbed> pmid_id_embeds;

std::string taesd_path;

bool use_tiny_autoencoder = false;

bool vae_tiling = false;

bool stacked_id = false;

std::map<std::string, struct ggml_tensor*> tensors;

std::string lora_model_dir;

// lora_name => multiplier

std::unordered_map<std::string, float> curr_lora_state;

std::shared_ptr<Denoiser> denoiser = std::make_shared<CompVisDenoiser>();

StableDiffusionGGML() = default;

StableDiffusionGGML(int n_threads,

bool vae_decode_only,

bool free_params_immediately,

std::string lora_model_dir,

rng_type_t rng_type);

~StableDiffusionGGML() ;

bool load_from_file(const std::string& model_path,

const std::string& clip_l_path,

const std::string& clip_g_path,

const std::string& t5xxl_path,

const std::string& diffusion_model_path,

const std::string& vae_path,

const std::string control_net_path,

const std::string embeddings_path,

const std::string id_embeddings_path,

const std::string& taesd_path,

bool vae_tiling_,

ggml_type wtype,

schedule_t schedule,

bool clip_on_cpu,

bool control_net_cpu,

bool vae_on_cpu,

bool diffusion_flash_attn,

StableDiffusionLoadConfiguration details = StableDiffusionLoadConfiguration());

bool is_using_v_parameterization_for_sd2(ggml_context* work_ctx, bool is_inpaint = false);

void apply_lora(const std::string& lora_name, float multiplier);

void apply_loras(const std::unordered_map<std::string, float>& lora_state);

ggml_tensor* id_encoder(ggml_context* work_ctx,

ggml_tensor* init_img,

ggml_tensor* prompts_embeds,

ggml_tensor* id_embeds,

std::vector<bool>& class_tokens_mask);

SDCondition get_svd_condition(ggml_context* work_ctx,

sd_image_t init_image,

int width,

int height,

int fps = 6,

int motion_bucket_id = 127,

float augmentation_level = 0.f,

bool force_zero_embeddings = false);

ggml_tensor* sample(ggml_context* work_ctx,

ggml_tensor* init_latent,

ggml_tensor* noise,

SDCondition cond,

SDCondition uncond,

ggml_tensor* control_hint,

float control_strength,

float min_cfg,

float cfg_scale,

float guidance,

float eta,

sample_method_t method,

const std::vector<float>& sigmas,

int start_merge_step,

SDCondition id_cond,

std::vector<int> skip_layers = {},

float slg_scale = 0,

float skip_layer_start = 0.01,

float skip_layer_end = 0.2,

ggml_tensor* noise_mask = nullptr);

// ldm.models.diffusion.ddpm.LatentDiffusion.get_first_stage_encoding

ggml_tensor* get_first_stage_encoding(ggml_context* work_ctx, ggml_tensor* moments);

ggml_tensor* compute_first_stage(ggml_context* work_ctx, ggml_tensor* x, bool decode);

ggml_tensor* encode_first_stage(ggml_context* work_ctx, ggml_tensor* x);

ggml_tensor* decode_first_stage(ggml_context* work_ctx, ggml_tensor* x);