#include <assert.h>

#include <algorithm>

#include <cstring>

#include <fstream>

#include <iostream>

#include <iterator>

#include <map>

#include <random>

#include <regex>

#include <set>

#include <sstream>

#include <string>

#include <unordered_map>

#include <vector>

#include "ggml/ggml.h"

#include "stable-diffusion.h"

static SDLogLevel log_level = SDLogLevel::INFO;

#define __FILENAME__ "stable-diffusion.cpp"

#define SD_LOG(level, format, ...) \

do { \

if (level < log_level) { \

break; \

} \

if (level == SDLogLevel::DEBUG) { \

printf("[DEBUG] %s:%-4d - " format "\n", __FILENAME__, __LINE__, ##__VA_ARGS__); \

} else if (level == SDLogLevel::INFO) { \

printf("[INFO] %s:%-4d - " format "\n", __FILENAME__, __LINE__, ##__VA_ARGS__); \

} else if (level == SDLogLevel::WARN) { \

fprintf(stderr, "[WARN] %s:%-4d - " format "\n", __FILENAME__, __LINE__, ##__VA_ARGS__); \

} else if (level == SDLogLevel::ERROR) { \

fprintf(stderr, "[ERROR] %s:%-4d - " format "\n", __FILENAME__, __LINE__, ##__VA_ARGS__); \

} \

} while (0)

#define LOG_DEBUG(format, ...) SD_LOG(SDLogLevel::DEBUG, format, ##__VA_ARGS__)

#define LOG_INFO(format, ...) SD_LOG(SDLogLevel::INFO, format, ##__VA_ARGS__)

#define LOG_WARN(format, ...) SD_LOG(SDLogLevel::WARN, format, ##__VA_ARGS__)

#define LOG_ERROR(format, ...) SD_LOG(SDLogLevel::ERROR, format, ##__VA_ARGS__)

#define GGML_FILE_MAGIC 0x67676d6c

#define TIMESTEPS 1000

void set_sd_log_level(SDLogLevel level) {

log_level = level;

}

std::string sd_get_system_info() {

}

ggml_tensor* load_tensor_from_file(ggml_context* ctx, const std::string& file_path) {

std::ifstream file(file_path, std::ios::binary);

if (!file.is_open()) {

LOG_ERROR("failed to open '%s'", file_path.c_str());

return NULL;

}

int32_t n_dims;

int32_t length;

int32_t ttype;

file.read(reinterpret_cast<char*>(&n_dims), sizeof(n_dims));

file.read(reinterpret_cast<char*>(&length), sizeof(length));

file.read(reinterpret_cast<char*>(&ttype), sizeof(ttype));

if (file.eof()) {

LOG_ERROR("incomplete file '%s'", file_path.c_str());

return NULL;

}

int32_t nelements = 1;

int32_t ne[4] = {1, 1, 1, 1};

for (int i = 0; i < n_dims; ++i) {

file.read(reinterpret_cast<char*>(&ne[i]), sizeof(ne[i]));

nelements *= ne[i];

}

std::string name(length, 0);

file.read(&name[0], length);

ggml_tensor* tensor = ggml_new_tensor_4d(ctx, (ggml_type)ttype, ne[0], ne[1], ne[2], ne[3]);

const size_t bpe = ggml_type_size(ggml_type(ttype));

file.read(reinterpret_cast<char*>(tensor->data), ggml_nbytes(tensor));

return tensor;

}

static std::default_random_engine generator;

void set_random_seed(int seed) {

generator.seed(seed);

}

void ggml_tensor_set_f32_randn(struct ggml_tensor* tensor) {

}

void ggml_tensor_set_f32(struct ggml_tensor* tensor, float value, int l, int k = 0, int j = 0, int i = 0) {

GGML_ASSERT(tensor->nb[0] == sizeof(float));

*(float*)((char*)(tensor->data) + i * tensor->nb[3] + j * tensor->nb[2] + k * tensor->nb[1] + l * tensor->nb[0]) = value;

}

float ggml_tensor_get_f32(const ggml_tensor* tensor, int l, int k = 0, int j = 0, int i = 0) {

GGML_ASSERT(tensor->nb[0] == sizeof(float));

return *(float*)((char*)(tensor->data) + i * tensor->nb[3] + j * tensor->nb[2] + k * tensor->nb[1] + l * tensor->nb[0]);

}

void print_ggml_tensor(struct ggml_tensor* tensor, bool shape_only = false) {

}

void copy_ggml_tensor(

}

void set_timestep_embedding(struct ggml_tensor* timesteps, struct ggml_tensor* embedding, int dim, int max_period = 10000) {

}

struct ggml_tensor* new_timestep_embedding(struct ggml_context* ctx, struct ggml_tensor* timesteps, int dim, int max_period = 10000) {

// timesteps: [N,]

// embedding: [(dim + 1)/2, N]

int acutual_dim = dim;

if (dim % 2 != 0) {

acutual_dim = dim + 1;

}

struct ggml_tensor* embedding = ggml_new_tensor_2d(ctx, GGML_TYPE_F32, acutual_dim, timesteps->ne[0]);

if (!ggml_get_no_alloc(ctx)) {

set_timestep_embedding(timesteps, embedding, dim, max_period);

}

return embedding;

}

std::vector<uint8_t> ggml_to_image_vec(struct ggml_tensor* t) {

}

void image_vec_to_ggml(const std::vector<uint8_t>& vec,

}

const std::string UNK_TOKEN = "<|endoftext|>";

const std::string BOS_TOKEN = "<|startoftext|>";

const std::string EOS_TOKEN = "<|endoftext|>";

const std::string PAD_TOEKN = "<|endoftext|>";

const int UNK_TOKEN_ID = 49407;

const int BOS_TOKEN_ID = 49406;

const int EOS_TOKEN_ID = 49407;

const int PAD_TOKEN_ID = 49407;

class CLIPTokenizer {

};

struct ResidualAttentionBlock {

};

struct CLIPTextModel {

};

struct FrozenCLIPEmbedder {

};

struct ResBlock {

};

struct SpatialTransformer {