static obs_properties_t *chroma_key_properties(void *data)
{
obs_properties_t *props = obs_properties_create();
obs_property_t *p = obs_properties_add_list(props,
SETTING_COLOR_TYPE, TEXT_COLOR_TYPE,
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
obs_property_list_add_string(p, obs_module_text("Green"), "green");
obs_property_list_add_string(p, obs_module_text("Blue"), "blue");
obs_property_list_add_string(p, obs_module_text("Magenta"), "magenta");
obs_property_list_add_string(p, obs_module_text("Custom"), "custom");
obs_property_set_modified_callback(p, key_type_changed);
obs_properties_add_color(props, SETTING_KEY_COLOR, TEXT_KEY_COLOR);
obs_properties_add_int_slider(props, SETTING_SIMILARITY,
TEXT_SIMILARITY, 1, 1000, 1);
obs_properties_add_int_slider(props, SETTING_SMOOTHNESS,
TEXT_SMOOTHNESS, 1, 1000, 1);
obs_properties_add_int_slider(props, SETTING_SPILL,
TEXT_SPILL, 1, 1000, 1);
obs_properties_add_int(props, SETTING_OPACITY, TEXT_OPACITY, 0, 100, 1);
obs_properties_add_float_slider(props, SETTING_CONTRAST,
TEXT_CONTRAST, -1.0, 1.0, 0.01);
obs_properties_add_float_slider(props, SETTING_BRIGHTNESS,
TEXT_BRIGHTNESS, -1.0, 1.0, 0.01);
obs_properties_add_float_slider(props, SETTING_GAMMA,
TEXT_GAMMA, -1.0, 1.0, 0.01);
UNUSED_PARAMETER(data);
return props;
}
static obs_properties_t *color_grade_filter_properties(void *data)
{
struct lut_filter_data *s = data;
struct dstr path = {0};
const char *slash;
obs_properties_t *props = obs_properties_create();
struct dstr filter_str = {0};
dstr_cat(&filter_str, "(*.png)");
if (s && s->file && *s->file) {
dstr_copy(&path, s->file);
} else {
dstr_copy(&path, obs_module_file("LUTs"));
dstr_cat_ch(&path, '/');
}
dstr_replace(&path, "\\", "/");
slash = strrchr(path.array, '/');
if (slash)
dstr_resize(&path, slash - path.array + 1);
obs_properties_add_path(props, SETTING_IMAGE_PATH, TEXT_IMAGE_PATH,
OBS_PATH_FILE, filter_str.array, path.array);
obs_properties_add_float_slider(props, SETTING_CLUT_AMOUNT,
TEXT_AMOUNT, 0, 1, 0.01);
dstr_free(&filter_str);
UNUSED_PARAMETER(data);
return props;
}
static obs_properties_t *color_filter_properties(void *data)
{
obs_properties_t *props = obs_properties_create();
obs_properties_add_color(props, SETTING_COLOR, TEXT_COLOR);
obs_properties_add_int(props, SETTING_OPACITY, TEXT_OPACITY,
0, 100, 1);
obs_properties_add_float_slider(props, SETTING_CONTRAST,
TEXT_CONTRAST, -1.0, 1.0, 0.01);
obs_properties_add_float_slider(props, SETTING_BRIGHTNESS,
TEXT_BRIGHTNESS, -1.0, 1.0, 0.01);
obs_properties_add_float_slider(props, SETTING_GAMMA,
TEXT_GAMMA, -1.0, 1.0, 0.01);
UNUSED_PARAMETER(data);
return props;
}
static obs_properties_t *noise_gate_properties(void *data)
{
obs_properties_t *ppts = obs_properties_create();
obs_properties_add_float_slider(ppts, S_CLOSE_THRESHOLD,
TEXT_CLOSE_THRESHOLD, VOL_MIN, VOL_MAX, 1.0);
obs_properties_add_float_slider(ppts, S_OPEN_THRESHOLD,
TEXT_OPEN_THRESHOLD, VOL_MIN, VOL_MAX, 1.0);
obs_properties_add_int(ppts, S_ATTACK_TIME, TEXT_ATTACK_TIME,
0, 10000, 1);
obs_properties_add_int(ppts, S_HOLD_TIME, TEXT_HOLD_TIME,
0, 10000, 1);
obs_properties_add_int(ppts, S_RELEASE_TIME, TEXT_RELEASE_TIME,
0, 10000, 1);
UNUSED_PARAMETER(data);
return ppts;
}
static obs_properties_t *sharpness_properties(void *data)
{
obs_properties_t *props = obs_properties_create();
obs_properties_add_float_slider(props, "sharpness",
"Sharpness", 0.0f, 1.0f, 0.01f);
UNUSED_PARAMETER(data);
return props;
}
static obs_properties_t *gain_properties(void *data)
{
obs_properties_t *ppts = obs_properties_create();
obs_properties_add_float_slider(ppts, S_GAIN_DB, TEXT_GAIN_DB,
-30.0, 30.0, 0.1);
UNUSED_PARAMETER(data);
return ppts;
}
static obs_properties_t *expander_properties(void *data)
{
struct expander_data *cd = data;
obs_properties_t *props = obs_properties_create();
obs_source_t *parent = NULL;
if (cd)
parent = obs_filter_get_parent(cd->context);
obs_property_t *presets = obs_properties_add_list(props, S_PRESETS,
TEXT_PRESETS, OBS_COMBO_TYPE_LIST,
OBS_COMBO_FORMAT_STRING);
obs_property_list_add_string(presets, TEXT_PRESETS_EXP, "expander");
obs_property_list_add_string(presets, TEXT_PRESETS_GATE, "gate");
obs_property_set_modified_callback(presets, presets_changed);
obs_properties_add_float_slider(props, S_RATIO,
TEXT_RATIO, MIN_RATIO, MAX_RATIO, 0.1);
obs_properties_add_float_slider(props, S_THRESHOLD,
TEXT_THRESHOLD, MIN_THRESHOLD_DB, MAX_THRESHOLD_DB,
0.1);
obs_properties_add_int_slider(props, S_ATTACK_TIME,
TEXT_ATTACK_TIME, MIN_ATK_RLS_MS, MAX_ATK_MS, 1);
obs_properties_add_int_slider(props, S_RELEASE_TIME,
TEXT_RELEASE_TIME, MIN_ATK_RLS_MS, MAX_RLS_MS, 1);
obs_properties_add_float_slider(props, S_OUTPUT_GAIN,
TEXT_OUTPUT_GAIN, MIN_OUTPUT_GAIN_DB,
MAX_OUTPUT_GAIN_DB, 0.1);
obs_property_t *detect = obs_properties_add_list(props, S_DETECTOR,
TEXT_DETECTOR, OBS_COMBO_TYPE_LIST,
OBS_COMBO_FORMAT_STRING);
obs_property_list_add_string(detect, TEXT_RMS, "RMS");
obs_property_list_add_string(detect, TEXT_PEAK, "peak");
obs_property_list_add_string(detect, TEXT_NONE, "none");
UNUSED_PARAMETER(data);
return props;
}
/*
* This function is called (see bottom of this file for more details)
* whenever the OBS filter interface changes. So when the user is messing
* with a slider this function is called to update the internal settings
* in OBS, and hence the settings being passed to the CPU/GPU.
*/
static void color_correction_filter_update(void *data, obs_data_t *settings)
{
struct color_correction_filter_data *filter = data;
/* Build our Gamma numbers. */
double gamma = obs_data_get_double(settings, SETTING_GAMMA);
gamma = (gamma < 0.0) ? (-gamma + 1.0) : (1.0 / (gamma + 1.0));
vec3_set(&filter->gamma, (float)gamma, (float)gamma, (float)gamma);
/* Build our contrast number. */
filter->contrast = (float)obs_data_get_double(settings,
SETTING_CONTRAST) + 1.0f;
float one_minus_con = (1.0f - filter->contrast) / 2.0f;
/* Now let's build our Contrast matrix. */
filter->con_matrix = (struct matrix4)
{
filter->contrast, 0.0f, 0.0f, 0.0f,
0.0f, filter->contrast, 0.0f, 0.0f,
0.0f, 0.0f, filter->contrast, 0.0f,
one_minus_con, one_minus_con, one_minus_con, 1.0f
};
/* Build our brightness number. */
filter->brightness = (float)obs_data_get_double(settings,
SETTING_BRIGHTNESS);
/*
* Now let's build our Brightness matrix.
* Earlier (in the function color_correction_filter_create) we set
* this matrix to the identity matrix, so now we only need
* to set the 3 variables that have changed.
*/
filter->bright_matrix.t.x = filter->brightness;
filter->bright_matrix.t.y = filter->brightness;
filter->bright_matrix.t.z = filter->brightness;
/* Build our Saturation number. */
filter->saturation = (float)obs_data_get_double(settings,
SETTING_SATURATION) + 1.0f;
/* Factor in the selected color weights. */
float one_minus_sat = (1.0f - filter->saturation) / 3.0f;
float sat_val = one_minus_sat + filter->saturation;
/* Now we build our Saturation matrix. */
filter->sat_matrix = (struct matrix4)
{
sat_val, one_minus_sat, one_minus_sat, 0.0f,
one_minus_sat, sat_val, one_minus_sat, 0.0f,
one_minus_sat, one_minus_sat, sat_val, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f
};
/* Build our Hue number. */
filter->hue_shift = (float)obs_data_get_double(settings,
SETTING_HUESHIFT);
/* Build our Transparency number. */
filter->opacity = (float)obs_data_get_int(settings,
SETTING_OPACITY) * 0.01f;
/* Hue is the radian of 0 to 360 degrees. */
float half_angle = 0.5f * (float)(filter->hue_shift / (180.0f / M_PI));
/* Pseudo-Quaternion To Matrix. */
float rot_quad1 = root3 * (float)sin(half_angle);
vec3_set(&filter->rot_quaternion, rot_quad1, rot_quad1,
rot_quad1);
filter->rot_quaternion_w = (float)cos(half_angle);
vec3_mul(&filter->cross, &filter->rot_quaternion,
&filter->rot_quaternion);
vec3_mul(&filter->square, &filter->rot_quaternion,
&filter->rot_quaternion);
vec3_mulf(&filter->wimag, &filter->rot_quaternion,
filter->rot_quaternion_w);
vec3_mulf(&filter->square, &filter->square, 2.0f);
vec3_sub(&filter->diag, &filter->half_unit, &filter->square);
vec3_add(&filter->a_line, &filter->cross, &filter->wimag);
vec3_sub(&filter->b_line, &filter->cross, &filter->wimag);
/* Now we build our Hue and Opacity matrix. */
filter->hue_op_matrix = (struct matrix4)
{
filter->diag.x * 2.0f,
filter->b_line.z * 2.0f,
filter->a_line.y * 2.0f,
0.0f,
filter->a_line.z * 2.0f,
filter->diag.y * 2.0f,
filter->b_line.x * 2.0f,
0.0f,
filter->b_line.y * 2.0f,
filter->a_line.x * 2.0f,
filter->diag.z * 2.0f,
0.0f,
0.0f, 0.0f, 0.0f, filter->opacity
};
/* Now get the overlay color data. */
uint32_t color = (uint32_t)obs_data_get_int(settings,
SETTING_COLOR);
vec4_from_rgba(&filter->color, color);
/*
* Now let's build our Color 'overlay' matrix.
* Earlier (in the function color_correction_filter_create) we set
* this matrix to the identity matrix, so now we only need
* to set the 6 variables that have changed.
*/
filter->color_matrix.x.x = filter->color.x;
filter->color_matrix.y.y = filter->color.y;
filter->color_matrix.z.z = filter->color.z;
filter->color_matrix.t.x = filter->color.w *
filter->color.x;
filter->color_matrix.t.y = filter->color.w *
filter->color.y;
filter->color_matrix.t.z = filter->color.w *
filter->color.z;
/* First we apply the Contrast & Brightness matrix. */
matrix4_mul(&filter->final_matrix, &filter->bright_matrix,
&filter->con_matrix);
/* Now we apply the Saturation matrix. */
matrix4_mul(&filter->final_matrix, &filter->final_matrix,
&filter->sat_matrix);
/* Next we apply the Hue+Opacity matrix. */
matrix4_mul(&filter->final_matrix, &filter->final_matrix,
&filter->hue_op_matrix);
/* Lastly we apply the Color Wash matrix. */
matrix4_mul(&filter->final_matrix, &filter->final_matrix,
&filter->color_matrix);
}
/*
* Since this is C we have to be careful when destroying/removing items from
* OBS. Jim has added several useful functions to help keep memory leaks to
* a minimum, and handle the destruction and construction of these filters.
*/
static void color_correction_filter_destroy(void *data)
{
struct color_correction_filter_data *filter = data;
if (filter->effect) {
obs_enter_graphics();
gs_effect_destroy(filter->effect);
obs_leave_graphics();
}
bfree(data);
}
/*
* When you apply a filter OBS creates it, and adds it to the source. OBS also
* starts rendering it immediately. This function doesn't just 'create' the
* filter, it also calls the render function (farther below) that contains the
* actual rendering code.
*/
static void *color_correction_filter_create(obs_data_t *settings,
obs_source_t *context)
{
/*
* Because of limitations of pre-c99 compilers, you can't create an
* array that doesn't have a known size at compile time. The below
* function calculates the size needed and allocates memory to
* handle the source.
*/
struct color_correction_filter_data *filter =
bzalloc(sizeof(struct color_correction_filter_data));
/*
* By default the effect file is stored in the ./data directory that
* your filter resides in.
*/
char *effect_path = obs_module_file("color_correction_filter.effect");
filter->context = context;
/* Set/clear/assign for all necessary vectors. */
vec3_set(&filter->half_unit, 0.5f, 0.5f, 0.5f);
matrix4_identity(&filter->bright_matrix);
matrix4_identity(&filter->color_matrix);
/* Here we enter the GPU drawing/shader portion of our code. */
obs_enter_graphics();
/* Load the shader on the GPU. */
filter->effect = gs_effect_create_from_file(effect_path, NULL);
/* If the filter is active pass the parameters to the filter. */
if (filter->effect) {
filter->gamma_param = gs_effect_get_param_by_name(
filter->effect, SETTING_GAMMA);
filter->final_matrix_param = gs_effect_get_param_by_name(
filter->effect, "color_matrix");
}
obs_leave_graphics();
bfree(effect_path);
/*
* If the filter has been removed/deactivated, destroy the filter
* and exit out so we don't crash OBS by telling it to update
* values that don't exist anymore.
*/
if (!filter->effect) {
color_correction_filter_destroy(filter);
return NULL;
}
/*
* It's important to call the update function here. If we don't
* we could end up with the user controlled sliders and values
* updating, but the visuals not updating to match.
*/
color_correction_filter_update(filter, settings);
return filter;
}
/* This is where the actual rendering of the filter takes place. */
static void color_correction_filter_render(void *data, gs_effect_t *effect)
{
struct color_correction_filter_data *filter = data;
if (!obs_source_process_filter_begin(filter->context, GS_RGBA,
OBS_ALLOW_DIRECT_RENDERING))
return;
/* Now pass the interface variables to the .effect file. */
gs_effect_set_vec3(filter->gamma_param, &filter->gamma);
gs_effect_set_matrix4(filter->final_matrix_param, &filter->final_matrix);
obs_source_process_filter_end(filter->context, filter->effect, 0, 0);
UNUSED_PARAMETER(effect);
}
/*
* This function sets the interface. the types (add_*_Slider), the type of
* data collected (int), the internal name, user-facing name, minimum,
* maximum and step values. While a custom interface can be built, for a
* simple filter like this it's better to use the supplied functions.
*/
static obs_properties_t *color_correction_filter_properties(void *data)
{
obs_properties_t *props = obs_properties_create();
obs_properties_add_float_slider(props, SETTING_GAMMA,
TEXT_GAMMA, -3.0f, 3.0f, 0.01f);
obs_properties_add_float_slider(props, SETTING_CONTRAST,
TEXT_CONTRAST, -2.0f, 2.0f, 0.01f);
obs_properties_add_float_slider(props, SETTING_BRIGHTNESS,
TEXT_BRIGHTNESS, -1.0f, 1.0f, 0.01f);
obs_properties_add_float_slider(props, SETTING_SATURATION,
TEXT_SATURATION, -1.0f, 5.0f, 0.01f);
obs_properties_add_float_slider(props, SETTING_HUESHIFT,
TEXT_HUESHIFT, -180.0f, 180.0f, 0.01f);
obs_properties_add_int_slider(props, SETTING_OPACITY,
TEXT_OPACITY, 0, 100, 1);
obs_properties_add_color(props, SETTING_COLOR, TEXT_COLOR);
UNUSED_PARAMETER(data);
return props;
}
/*
* As the functions' namesake, this provides the default settings for any
* options you wish to provide a default for. Try to select defaults that
* make sense to the end user, or that don't effect the data.
* *NOTE* this function is completely optional, as is providing a default
* for any particular setting.
*/
static void color_correction_filter_defaults(obs_data_t *settings)
{
obs_data_set_default_double(settings, SETTING_GAMMA, 0.0);
obs_data_set_default_double(settings, SETTING_CONTRAST, 0.0);
obs_data_set_default_double(settings, SETTING_BRIGHTNESS, 0.0);
obs_data_set_default_double(settings,
SETTING_SATURATION, 0.0);
obs_data_set_default_double(settings, SETTING_HUESHIFT, 0.0);
obs_data_set_default_double(settings, SETTING_OPACITY, 100.0);
obs_data_set_default_int(settings, SETTING_COLOR, 0xFFFFFF);
}
/*
* So how does OBS keep track of all these plug-ins/filters? How does OBS know
* which function to call when it needs to update a setting? Or a source? Or
* what type of source this is?
*
* OBS does it through the obs_source_info_struct. Notice how variables are
* assigned the name of a function? Notice how the function name has the
* variable name in it? While not mandatory, it helps a ton for you (and those
* reading your code) to follow this convention.
*/
struct obs_source_info color_filter = {
.id = "color_filter",
.type = OBS_SOURCE_TYPE_FILTER,
.output_flags = OBS_SOURCE_VIDEO,
.get_name = color_correction_filter_name,
.create = color_correction_filter_create,
.destroy = color_correction_filter_destroy,
.video_render = color_correction_filter_render,
.update = color_correction_filter_update,
.get_properties = color_correction_filter_properties,
.get_defaults = color_correction_filter_defaults
};