static void qtwebkit_get_defaults(obs_data_t *settings) { obs_data_set_default_string(settings, "url", "http://www.obsproject.com"); obs_data_set_default_int(settings, "width", 800); obs_data_set_default_int(settings, "height", 600); obs_data_set_default_int(settings, "fps", 30); }
static void rtmp_stream_defaults(obs_data_t *defaults) { obs_data_set_default_int(defaults, OPT_DROP_THRESHOLD, 500); obs_data_set_default_int(defaults, OPT_PFRAME_DROP_THRESHOLD, 800); obs_data_set_default_int(defaults, OPT_MAX_SHUTDOWN_TIME_SEC, 30); obs_data_set_default_string(defaults, OPT_BIND_IP, "default"); }
static void color_filter_defaults(obs_data_t *settings) { obs_data_set_default_int(settings, SETTING_COLOR, 0xFFFFFF); obs_data_set_default_int(settings, SETTING_OPACITY, 100); 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_GAMMA, 0.0); }
static void noise_gate_defaults(obs_data_t *s) { obs_data_set_default_double(s, S_OPEN_THRESHOLD, -26.0); obs_data_set_default_double(s, S_CLOSE_THRESHOLD, -32.0); obs_data_set_default_int (s, S_ATTACK_TIME, 25); obs_data_set_default_int (s, S_HOLD_TIME, 200); obs_data_set_default_int (s, S_RELEASE_TIME, 150); }
static void rtmp_stream_defaults(obs_data_t *defaults) { obs_data_set_default_int(defaults, OPT_DROP_THRESHOLD, 700); obs_data_set_default_int(defaults, OPT_PFRAME_DROP_THRESHOLD, 900); obs_data_set_default_int(defaults, OPT_MAX_SHUTDOWN_TIME_SEC, 30); obs_data_set_default_string(defaults, OPT_BIND_IP, "default"); obs_data_set_default_bool(defaults, OPT_NEWSOCKETLOOP_ENABLED, false); obs_data_set_default_bool(defaults, OPT_LOWLATENCY_ENABLED, false); }
void XCompcapMain::defaults(obs_data_t settings) { obs_data_set_default_string(settings, "capture_window", ""); obs_data_set_default_int(settings, "cut_top", 0); obs_data_set_default_int(settings, "cut_left", 0); obs_data_set_default_int(settings, "cut_right", 0); obs_data_set_default_int(settings, "cut_bot", 0); obs_data_set_default_bool(settings, "swap_redblue", false); obs_data_set_default_bool(settings, "lock_x", false); }
static void color_key_defaults(obs_data_t *settings) { obs_data_set_default_int(settings, SETTING_OPACITY, 100); 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_GAMMA, 0.0); obs_data_set_default_int(settings, SETTING_KEY_COLOR, 0x00FF00); obs_data_set_default_string(settings, SETTING_COLOR_TYPE, "green"); obs_data_set_default_int(settings, SETTING_SIMILARITY, 80); obs_data_set_default_int(settings, SETTING_SMOOTHNESS, 50); }
void XCompcapMain::defaults(obs_data_t *settings) { obs_data_set_default_string(settings, "capture_window", ""); obs_data_set_default_int(settings, "cut_top", 0); obs_data_set_default_int(settings, "cut_left", 0); obs_data_set_default_int(settings, "cut_right", 0); obs_data_set_default_int(settings, "cut_bot", 0); obs_data_set_default_bool(settings, "swap_redblue", false); obs_data_set_default_bool(settings, "lock_x", false); obs_data_set_default_bool(settings, "show_cursor", true); obs_data_set_default_bool(settings, "include_border", false); obs_data_set_default_bool(settings, "exclude_alpha", false); }
static void obs_x264_defaults(obs_data_t *settings) { obs_data_set_default_int (settings, "bitrate", 2500); obs_data_set_default_bool (settings, "use_bufsize", false); obs_data_set_default_int (settings, "buffer_size", 2500); obs_data_set_default_int (settings, "keyint_sec", 0); obs_data_set_default_int (settings, "crf", 23); obs_data_set_default_bool (settings, "vfr", false); obs_data_set_default_bool (settings, "cbr", true); obs_data_set_default_string(settings, "preset", "veryfast"); obs_data_set_default_string(settings, "profile", ""); obs_data_set_default_string(settings, "tune", ""); obs_data_set_default_string(settings, "x264opts", ""); }
static void expander_defaults(obs_data_t *s) { const char *presets = obs_data_get_string(s, S_PRESETS); bool is_expander_preset = true; if (strcmp(presets, "gate") == 0) is_expander_preset = false; obs_data_set_default_string(s, S_PRESETS, is_expander_preset ? "expander" : "gate"); obs_data_set_default_double(s, S_RATIO, is_expander_preset ? 2.0 : 10.0); obs_data_set_default_double(s, S_THRESHOLD, -40.0f); obs_data_set_default_int(s, S_ATTACK_TIME, 10); obs_data_set_default_int(s, S_RELEASE_TIME, is_expander_preset ? 50 : 125); obs_data_set_default_double(s, S_OUTPUT_GAIN, 0.0); obs_data_set_default_string(s, S_DETECTOR, "RMS"); }
static void vaapi_defaults(obs_data_t *settings) { obs_data_set_default_string( settings, "vaapi_device", "/dev/dri/renderD128"); obs_data_set_default_int(settings, "vaapi_codec", AV_CODEC_ID_H264); obs_data_set_default_int(settings, "profile", FF_PROFILE_H264_CONSTRAINED_BASELINE); obs_data_set_default_int(settings, "level", 40); obs_data_set_default_int(settings, "bitrate", 2500); obs_data_set_default_int(settings, "keyint_sec", 0); obs_data_set_default_int(settings, "bf", 0); obs_data_set_default_int(settings, "qp", 20); obs_data_set_default_int(settings, "quality", 0); obs_data_set_default_int(settings, "rendermode", 0); }
static void ffmpeg_source_defaults(obs_data_t *settings) { obs_data_set_default_bool(settings, "is_local_file", true); obs_data_set_default_bool(settings, "looping", false); obs_data_set_default_bool(settings, "clear_on_media_end", true); obs_data_set_default_bool(settings, "restart_on_activate", true); #if defined(_WIN32) obs_data_set_default_bool(settings, "hw_decode", true); #endif obs_data_set_default_int(settings, "buffering_mb", 2); }
static void *ft2_source_create(obs_data_t settings, obs_source_t source) { struct ft2_source *srcdata = bzalloc(sizeof(struct ft2_source)); obs_data_t font_obj = obs_data_create(); srcdata->src = source; srcdata->font_size = 32; obs_data_set_default_string(font_obj, "face", DEFAULT_FACE); obs_data_set_default_int(font_obj, "size", 32); obs_data_set_default_obj(settings, "font", font_obj); obs_data_set_default_int(settings, "color1", 0xFFFFFFFF); obs_data_set_default_int(settings, "color2", 0xFFFFFFFF); obs_data_set_default_string(settings, "text", "The lazy snake jumps over the happy MASKEN."); ft2_source_update(srcdata, settings); obs_data_release(font_obj); return srcdata; }
static void v4l2_defaults(obs_data_t *settings) { obs_data_set_default_int(settings, "input", -1); obs_data_set_default_int(settings, "pixelformat", -1); obs_data_set_default_int(settings, "standard", -1); obs_data_set_default_int(settings, "dv_timing", -1); obs_data_set_default_int(settings, "resolution", -1); obs_data_set_default_int(settings, "framerate", -1); obs_data_set_default_bool(settings, "buffering", true); }
static void scene_load_item(struct obs_scene *scene, obs_data_t *item_data) { const char *name = obs_data_get_string(item_data, "name"); obs_source_t *source = obs_get_source_by_name(name); struct obs_scene_item *item; bool visible; if (!source) { blog(LOG_WARNING, "[scene_load_item] Source %s not found!", name); return; } item = obs_scene_add(scene, source); if (!item) { blog(LOG_WARNING, "[scene_load_item] Could not add source '%s' " "to scene '%s'!", name, obs_source_get_name(scene->source)); obs_source_release(source); return; } obs_data_set_default_int(item_data, "align", OBS_ALIGN_TOP | OBS_ALIGN_LEFT); item->rot = (float)obs_data_get_double(item_data, "rot"); item->align = (uint32_t)obs_data_get_int(item_data, "align"); visible = obs_data_get_bool(item_data, "visible"); obs_data_get_vec2(item_data, "pos", &item->pos); obs_data_get_vec2(item_data, "scale", &item->scale); set_visibility(item, visible); item->bounds_type = (enum obs_bounds_type)obs_data_get_int(item_data, "bounds_type"); item->bounds_align = (uint32_t)obs_data_get_int(item_data, "bounds_align"); obs_data_get_vec2(item_data, "bounds", &item->bounds); obs_source_release(source); update_item_transform(item); }
static void rtmp_stream_defaults(obs_data_t defaults) { obs_data_set_default_int(defaults, "drop_threshold", 600000); }
static void obs_qsv_defaults(obs_data_t *settings) { obs_data_set_default_string(settings, "target_usage", "balanced"); obs_data_set_default_int(settings, "bitrate", 2500); obs_data_set_default_int(settings, "max_bitrate", 3000); obs_data_set_default_string(settings, "profile", "main"); obs_data_set_default_int(settings, "async_depth", 4); obs_data_set_default_string(settings, "rate_control", "CBR"); obs_data_set_default_int(settings, "accuracy", 1000); obs_data_set_default_int(settings, "convergence", 1); obs_data_set_default_int(settings, "qpi", 23); obs_data_set_default_int(settings, "qpp", 23); obs_data_set_default_int(settings, "qpb", 23); obs_data_set_default_int(settings, "icq_quality", 23); obs_data_set_default_int(settings, "la_depth", 40); obs_data_set_default_int(settings, "keyint_sec", 3); }
static void libfdk_defaults(obs_data_t settings) { obs_data_set_default_int(settings, "bitrate", 128); obs_data_set_default_bool(settings, "afterburner", true); }
// Assign defaults to whatever data we need for this source static void destiny_detail_get_defaults(obs_data_t *settings) { obs_data_set_default_int(settings, "account_id", 1); }
static void decklink_get_defaults(obs_data_t *settings) { obs_data_set_default_bool(settings, BUFFERING, true); obs_data_set_default_int(settings, PIXEL_FORMAT, bmdFormat8BitYUV); obs_data_set_default_int(settings, CHANNEL_FORMAT, SPEAKERS_STEREO); }
/* * 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 };
static void monitor_capture_defaults(obs_data_t settings) { obs_data_set_default_int(settings, "monitor", 0); obs_data_set_default_bool(settings, "capture_cursor", true); obs_data_set_default_bool(settings, "compatibility", false); }
static void scene_load_item(struct obs_scene *scene, obs_data_t *item_data) { const char *name = obs_data_get_string(item_data, "name"); obs_source_t *source = obs_get_source_by_name(name); const char *scale_filter_str; struct obs_scene_item *item; bool visible; if (!source) { blog(LOG_WARNING, "[scene_load_item] Source %s not found!", name); return; } item = obs_scene_add(scene, source); if (!item) { blog(LOG_WARNING, "[scene_load_item] Could not add source '%s' " "to scene '%s'!", name, obs_source_get_name(scene->source)); obs_source_release(source); return; } obs_data_set_default_int(item_data, "align", OBS_ALIGN_TOP | OBS_ALIGN_LEFT); item->rot = (float)obs_data_get_double(item_data, "rot"); item->align = (uint32_t)obs_data_get_int(item_data, "align"); visible = obs_data_get_bool(item_data, "visible"); obs_data_get_vec2(item_data, "pos", &item->pos); obs_data_get_vec2(item_data, "scale", &item->scale); set_visibility(item, visible); item->bounds_type = (enum obs_bounds_type)obs_data_get_int(item_data, "bounds_type"); item->bounds_align = (uint32_t)obs_data_get_int(item_data, "bounds_align"); obs_data_get_vec2(item_data, "bounds", &item->bounds); item->crop.left = (uint32_t)obs_data_get_int(item_data, "crop_left"); item->crop.top = (uint32_t)obs_data_get_int(item_data, "crop_top"); item->crop.right = (uint32_t)obs_data_get_int(item_data, "crop_right"); item->crop.bottom = (uint32_t)obs_data_get_int(item_data, "crop_bottom"); scale_filter_str = obs_data_get_string(item_data, "scale_filter"); item->scale_filter = OBS_SCALE_DISABLE; if (scale_filter_str) { if (astrcmpi(scale_filter_str, "point") == 0) item->scale_filter = OBS_SCALE_POINT; else if (astrcmpi(scale_filter_str, "bilinear") == 0) item->scale_filter = OBS_SCALE_BILINEAR; else if (astrcmpi(scale_filter_str, "bicubic") == 0) item->scale_filter = OBS_SCALE_BICUBIC; else if (astrcmpi(scale_filter_str, "lanczos") == 0) item->scale_filter = OBS_SCALE_LANCZOS; } if (item->item_render && !item_texture_enabled(item)) { obs_enter_graphics(); gs_texrender_destroy(item->item_render); item->item_render = NULL; obs_leave_graphics(); } else if (!item->item_render && item_texture_enabled(item)) { obs_enter_graphics(); item->item_render = gs_texrender_create(GS_RGBA, GS_ZS_NONE); obs_leave_graphics(); } obs_source_release(source); update_item_transform(item); }
/** * Get the default settings for the capture */ static void xshm_defaults(obs_data_t defaults) { obs_data_set_default_int(defaults, "screen", 0); obs_data_set_default_bool(defaults, "show_cursor", true); }
static void rtmp_stream_defaults(obs_data_t *defaults) { obs_data_set_default_int(defaults, OPT_DROP_THRESHOLD, 600); obs_data_set_default_int(defaults, OPT_MAX_SHUTDOWN_TIME_SEC, 5); }
static void aac_defaults(obs_data_t settings) { obs_data_set_default_int(settings, "bitrate", 128); }
static void duplicator_capture_defaults(obs_data_t *settings) { obs_data_set_default_int(settings, "monitor", 0); obs_data_set_default_bool(settings, "capture_cursor", true); }
static void rtmp_stream_defaults(obs_data_t *defaults) { obs_data_set_default_int(defaults, OPT_DROP_THRESHOLD, 600); }