static void ep_write_func(struct effect_parser *ep, struct dstr *shader,
struct ep_func *func, struct darray *used_params)
{
size_t i;
func->written = true;
ep_write_func_param_deps(ep, shader, func, used_params);
ep_write_func_sampler_deps(ep, shader, func);
ep_write_func_struct_deps(ep, shader, func);
ep_write_func_func_deps(ep, shader, func, used_params);
/* ------------------------------------ */
dstr_cat(shader, func->ret_type);
dstr_cat(shader, " ");
dstr_cat(shader, func->name);
dstr_cat(shader, "(");
for (i = 0; i < func->param_vars.num; i++) {
struct ep_var *var = func->param_vars.array+i;
if (i)
dstr_cat(shader, ", ");
ep_write_var(shader, var);
}
dstr_cat(shader, ")\n");
dstr_cat_dstr(shader, &func->contents);
dstr_cat(shader, "\n");
}
static void ep_write_main(struct effect_parser *ep, struct dstr *shader,
struct ep_func *func, struct dstr *call_str)
{
struct dstr param_str;
struct dstr adjusted_call;
dstr_init(¶m_str);
dstr_init_copy_dstr(&adjusted_call, call_str);
dstr_cat(shader, "\n");
dstr_cat(shader, func->ret_type);
dstr_cat(shader, " main(");
ep_write_main_params(ep, shader, ¶m_str, func);
dstr_cat(shader, ")");
if (func->mapping) {
dstr_cat(shader, " : ");
dstr_cat(shader, func->mapping);
}
dstr_cat(shader, "\n{\n\treturn ");
dstr_cat_dstr(shader, &adjusted_call);
dstr_cat(shader, "\n}\n");
dstr_free(&adjusted_call);
dstr_free(¶m_str);
}
static void gl_write_storage_var(struct gl_shader_parser *glsp,
struct shader_var *var, bool input, const char *prefix)
{
struct shader_struct *st = shader_parser_getstruct(&glsp->parser,
var->type);
if (st) {
gl_unwrap_storage_struct(glsp, st, var->name, input, prefix);
} else {
struct gl_parser_attrib attrib;
gl_parser_attrib_init(&attrib);
dstr_cat(&glsp->gl_string, input ? "in " : "out ");
if (prefix)
dstr_cat(&attrib.name, prefix);
dstr_cat(&attrib.name, var->name);
gl_write_type(glsp, var->type);
dstr_cat(&glsp->gl_string, " ");
dstr_cat_dstr(&glsp->gl_string, &attrib.name);
dstr_cat(&glsp->gl_string, ";\n");
attrib.input = input;
attrib.mapping = var->mapping;
da_push_back(glsp->attribs, &attrib);
}
}
static void build_command_line(struct ffmpeg_muxer *stream, struct dstr *cmd)
{
obs_encoder_t *vencoder = obs_output_get_video_encoder(stream->output);
obs_encoder_t *aencoders[MAX_AUDIO_MIXES];
int num_tracks = 0;
for (;;) {
obs_encoder_t *aencoder = obs_output_get_audio_encoder(
stream->output, num_tracks);
if (!aencoder)
break;
aencoders[num_tracks] = aencoder;
num_tracks++;
}
dstr_init_move_array(cmd, obs_module_file(FFMPEG_MUX));
dstr_insert_ch(cmd, 0, '\"');
dstr_cat(cmd, "\" \"");
dstr_cat_dstr(cmd, &stream->path);
dstr_catf(cmd, "\" %d %d ", vencoder ? 1 : 0, num_tracks);
if (vencoder)
add_video_encoder_params(stream, cmd, vencoder);
if (num_tracks) {
dstr_cat(cmd, "aac ");
for (int i = 0; i < num_tracks; i++) {
add_audio_encoder_params(cmd, aencoders[i]);
}
}
}
const char *get_font_path(const char *family, uint16_t size, const char *style,
uint32_t flags, FT_Long *idx)
{
const char *best_path = NULL;
double best_rating = 0.0;
struct dstr face_and_style = {0};
struct dstr style_str = {0};
bool bold = !!(flags & OBS_FONT_BOLD);
bool italic = !!(flags & OBS_FONT_ITALIC);
if (!family || !*family)
return NULL;
if (style) {
dstr_copy(&style_str, style);
dstr_replace(&style_str, "Bold", "");
dstr_replace(&style_str, "Italic", "");
dstr_replace(&style_str, " ", " ");
dstr_depad(&style_str);
}
dstr_copy(&face_and_style, family);
if (!dstr_is_empty(&style_str)) {
dstr_cat(&face_and_style, " ");
dstr_cat_dstr(&face_and_style, &style_str);
}
for (size_t i = 0; i < font_list.num; i++) {
struct font_path_info *info = font_list.array + i;
double rating = (double)get_rating(info, &face_and_style);
if (rating < info->face_len)
continue;
if (info->is_bitmap) {
int best_diff = 1000;
for (size_t j = 0; j < info->num_sizes; j++) {
int diff = abs(info->sizes[j] - size);
if (diff < best_diff)
best_diff = diff;
}
rating /= (double)(best_diff + 1.0);
}
if (info->bold == bold) rating += 1.0;
if (info->italic == italic) rating += 1.0;
if (rating > best_rating) {
best_path = info->path;
*idx = info->index;
best_rating = rating;
}
}
dstr_free(&style_str);
dstr_free(&face_and_style);
return best_path;
}
void dstr_vcatf(struct dstr *dst, const char *format, va_list args)
{
struct dstr temp;
dstr_init(&temp);
dstr_vprintf(&temp, format, args);
dstr_cat_dstr(dst, &temp);
dstr_free(&temp);
}
static inline void write_module_list(struct exception_handler_data *data)
{
dstr_cat(&data->str, "\r\nLoaded modules:\r\n");
#ifdef _WIN64
dstr_cat(&data->str, "Base Address Module\r\n");
#else
dstr_cat(&data->str, "Base Address Module\r\n");
#endif
dstr_cat_dstr(&data->str, &data->module_list);
}
static void gl_write_main_storage_assign(struct gl_shader_parser *glsp,
struct shader_var *var, const char *dst, const char *src,
bool input)
{
struct shader_struct *st;
struct dstr dst_copy = {0};
char ch_left = input ? '.' : '_';
char ch_right = input ? '_' : '.';
if (dst) {
dstr_copy(&dst_copy, dst);
dstr_cat_ch(&dst_copy, ch_left);
} else {
dstr_copy(&dst_copy, "\t");
}
dstr_cat(&dst_copy, var->name);
st = shader_parser_getstruct(&glsp->parser, var->type);
if (st) {
struct dstr src_copy = {0};
size_t i;
if (src)
dstr_copy(&src_copy, src);
dstr_cat(&src_copy, var->name);
dstr_cat_ch(&src_copy, ch_right);
for (i = 0; i < st->vars.num; i++) {
struct shader_var *st_var = st->vars.array+i;
gl_write_main_storage_assign(glsp, st_var,
dst_copy.array, src_copy.array, input);
}
dstr_free(&src_copy);
} else {
if (!dstr_isempty(&dst_copy))
dstr_cat_dstr(&glsp->gl_string, &dst_copy);
dstr_cat(&glsp->gl_string, " = ");
if (src)
dstr_cat(&glsp->gl_string, src);
dstr_cat(&glsp->gl_string, var->name);
dstr_cat(&glsp->gl_string, ";\n");
if (!input)
gl_write_main_interface_assign(glsp, var, src);
}
dstr_free(&dst_copy);
}
static void add_font_path(FT_Face face,
FT_Long idx,
const char *family_in,
const char *style_in,
const char *path)
{
struct dstr face_and_style = {0};
struct font_path_info info;
if (!family_in || !path)
return;
dstr_copy(&face_and_style, family_in);
if (face->style_name) {
struct dstr style = {0};
dstr_copy(&style, style_in);
dstr_replace(&style, "Bold", "");
dstr_replace(&style, "Italic", "");
dstr_replace(&style, " ", " ");
dstr_depad(&style);
if (!dstr_is_empty(&style)) {
dstr_cat(&face_and_style, " ");
dstr_cat_dstr(&face_and_style, &style);
}
dstr_free(&style);
}
info.face_and_style = face_and_style.array;
info.full_len = face_and_style.len;
info.face_len = strlen(family_in);
info.is_bitmap = !!(face->face_flags & FT_FACE_FLAG_FIXED_SIZES);
info.bold = !!(face->style_flags & FT_STYLE_FLAG_BOLD);
info.italic = !!(face->style_flags & FT_STYLE_FLAG_ITALIC);
info.index = idx;
info.path = bstrdup(path);
create_bitmap_sizes(&info, face);
da_push_back(font_list, &info);
/*blog(LOG_DEBUG, "name: %s\n\tstyle: %s\n\tpath: %s\n",
family_in,
style_in,
path);*/
}
void dstr_insert_dstr(struct dstr *dst, const size_t idx,
const struct dstr *str)
{
size_t new_len;
if (!str->len)
return;
if (idx == dst->len) {
dstr_cat_dstr(dst, str);
return;
}
new_len = dst->len + str->len;
dstr_ensure_capacity(dst, (new_len+1));
dst->len = new_len;
memmove(dst->array+idx+str->len, dst->array+idx, dst->len - idx + 1);
memcpy(dst->array+idx, str->array, str->len);
}
static void make_globent(struct os_globent *ent, WIN32_FIND_DATA *wfd,
const char *pattern)
{
struct dstr name = {0};
struct dstr path = {0};
char *slash;
dstr_from_wcs(&name, wfd->cFileName);
dstr_copy(&path, pattern);
slash = strrchr(path.array, '/');
if (slash)
dstr_resize(&path, slash + 1 - path.array);
else
dstr_free(&path);
dstr_cat_dstr(&path, &name);
ent->path = path.array;
ent->directory = is_dir(wfd);
dstr_free(&name);
}
