extern struct gl_windowinfo *gl_windowinfo_create(struct gs_init_data *info)
{
struct gl_windowinfo *wi = bzalloc(sizeof(struct gl_windowinfo));
wi->id = info->window.id;
wi->display = info->window.display;
return wi;
}
static void *rtmp_common_create(obs_data_t settings, obs_service_t service)
{
struct rtmp_common *data = bzalloc(sizeof(struct rtmp_common));
rtmp_common_update(data, settings);
UNUSED_PARAMETER(service);
return data;
}
static void *image_source_create(obs_data_t *settings, obs_source_t *source)
{
struct image_source *context = bzalloc(sizeof(struct image_source));
context->source = source;
image_source_update(context, settings);
return context;
}
xcursor_t *xcursor_init(Display *dpy) {
xcursor_t *data = bzalloc(sizeof(xcursor_t));
data->dpy = dpy;
xcursor_tick(data);
return data;
}
static void *obs_qsv_create(obs_data_t *settings, obs_encoder_t *encoder)
{
InitializeCriticalSection(&g_QsvCs);
struct obs_qsv *obsqsv = bzalloc(sizeof(struct obs_qsv));
obsqsv->encoder = encoder;
if (update_settings(obsqsv, settings)) {
EnterCriticalSection(&g_QsvCs);
obsqsv->context = qsv_encoder_open(&obsqsv->params);
LeaveCriticalSection(&g_QsvCs);
if (obsqsv->context == NULL)
warn("qsv failed to load");
else
load_headers(obsqsv);
} else {
warn("bad settings specified");
}
qsv_encoder_version(&g_verMajor, &g_verMinor);
blog(LOG_INFO, "\tmajor: %d\n"
"\tminor: %d",
g_verMajor, g_verMinor);
// MSDK 1.6 or less doesn't have automatic DTS calculation
// including early SandyBridge.
// Need to add manual DTS from PTS.
if (g_verMajor == 1 && g_verMinor < 7) {
int64_t interval = obsqsv->params.nbFrames + 1;
int64_t GopPicSize = (int64_t)(obsqsv->params.nKeyIntSec *
obsqsv->params.nFpsNum /
(float)obsqsv->params.nFpsDen);
g_pts2dtsShift = GopPicSize - (GopPicSize / interval) *
interval;
blog(LOG_INFO, "\tinterval: %d\n"
"\tGopPictSize: %d\n"
"\tg_pts2dtsShift: %d",
interval, GopPicSize, g_pts2dtsShift);
}
else
g_pts2dtsShift = -1;
if (!obsqsv->context) {
bfree(obsqsv);
return NULL;
}
obsqsv->performance_token =
os_request_high_performance("qsv encoding");
g_bFirst = true;
return obsqsv;
}
int_fast32_t jack_init(struct jack_data* data)
{
pthread_mutex_lock(&data->jack_mutex);
if (data->jack_client != NULL)
goto good;
jack_options_t jack_option = data->start_jack_server ?
JackNullOption : JackNoStartServer;
data->jack_client = jack_client_open(data->device, jack_option, 0);
if (data->jack_client == NULL) {
blog(LOG_ERROR,
"jack_client_open Error:"
"Could not create JACK client! %s",
data->device);
goto error;
}
data->jack_ports = (jack_port_t**)bzalloc(
sizeof(jack_port_t*) * data->channels);
for (unsigned int i = 0; i < data->channels; ++i) {
char port_name[10] = {'\0'};
snprintf(port_name, sizeof(port_name), "in_%d", i+1);
data->jack_ports[i] = jack_port_register(data->jack_client,
port_name, JACK_DEFAULT_AUDIO_TYPE, JackPortIsInput, 0);
if (data->jack_ports[i] == NULL) {
blog(LOG_ERROR,
"jack_port_register Error:"
"Could not create JACK port! %s",
port_name);
goto error;
}
}
if (jack_set_process_callback(data->jack_client,
jack_process_callback, data) != 0) {
blog(LOG_ERROR, "jack_set_process_callback Error");
goto error;
}
if (jack_activate(data->jack_client) != 0) {
blog(LOG_ERROR,
"jack_activate Error:"
"Could not activate JACK client!");
goto error;
}
good:
pthread_mutex_unlock(&data->jack_mutex);
return 0;
error:
pthread_mutex_unlock(&data->jack_mutex);
return 1;
}
/**
* Create the capture
*/
static void *xshm_create(obs_data_t *settings, obs_source_t *source)
{
struct xshm_data *data = bzalloc(sizeof(struct xshm_data));
data->source = source;
xshm_update(data, settings);
return data;
}
obs_service_t *obs_service_create(const char *id, const char *name,
obs_data_t *settings, obs_data_t *hotkey_data)
{
const struct obs_service_info *info = find_service(id);
struct obs_service *service;
if (!info) {
blog(LOG_ERROR, "Service '%s' not found", id);
return NULL;
}
service = bzalloc(sizeof(struct obs_service));
if (!obs_context_data_init(&service->context, settings, name,
hotkey_data)) {
bfree(service);
return NULL;
}
if (!info) {
blog(LOG_ERROR, "Service ID '%s' not found", id);
service->info.id = bstrdup(id);
service->owns_info_id = true;
} else {
service->info = *info;
}
if (info)
service->context.data = service->info.create(
service->context.settings, service);
if (!service->context.data)
blog(LOG_ERROR, "Failed to create service '%s'!", name);
service->control = bzalloc(sizeof(obs_weak_service_t));
service->control->service = service;
obs_context_data_insert(&service->context,
&obs->data.services_mutex,
&obs->data.first_service);
blog(LOG_INFO, "service '%s' (%s) created", name, id);
return service;
}
gs_texrender_t gs_texrender_create(enum gs_color_format format,
enum gs_zstencil_format zsformat)
{
struct gs_texture_render *texrender;
texrender = bzalloc(sizeof(struct gs_texture_render));
texrender->format = format;
texrender->zsformat = zsformat;
return texrender;
}
int os_sem_init(os_sem_t *sem, int value)
{
HANDLE handle = CreateSemaphore(NULL, (LONG)value, 0x7FFFFFFF, NULL);
if (!handle)
return -1;
*sem = bzalloc(sizeof(struct os_sem_data));
(*sem)->handle = handle;
return 0;
}
static void *color_grade_filter_create(
obs_data_t *settings, obs_source_t *context)
{
struct lut_filter_data *filter =
bzalloc(sizeof(struct lut_filter_data));
filter->context = context;
obs_source_update(context, settings);
return filter;
}
static void *ffmpeg_source_create(obs_data_t *settings, obs_source_t *source)
{
UNUSED_PARAMETER(settings);
struct ffmpeg_source *s = bzalloc(sizeof(struct ffmpeg_source));
s->source = source;
ffmpeg_source_update(s, settings);
return s;
}
static void *monitor_capture_create(obs_data_t *settings, obs_source_t *source)
{
struct monitor_capture *capture;
capture = bzalloc(sizeof(struct monitor_capture));
capture->source = source;
update_settings(capture, settings);
return capture;
}
/**
* Create the plugin object
*/
static void *pulse_create(obs_data_t *settings, obs_source_t *source)
{
struct pulse_data *data = bzalloc(sizeof(struct pulse_data));
data->source = source;
pulse_init();
pulse_update(data, settings);
return data;
}
obs_view_t *obs_view_create(void)
{
struct obs_view *view = bzalloc(sizeof(struct obs_view));
if (!obs_view_init(view)) {
bfree(view);
view = NULL;
}
return view;
}
obs_display_t obs_display_create(struct gs_init_data *graphics_data)
{
struct obs_display *display = bzalloc(sizeof(struct obs_display));
if (!obs_display_init(display, graphics_data)) {
obs_display_destroy(display);
display = NULL;
}
return display;
}
static struct obs_encoder *create_encoder(const char *id,
enum obs_encoder_type type, const char *name,
obs_data_t *settings, size_t mixer_idx, obs_data_t *hotkey_data)
{
struct obs_encoder *encoder;
struct obs_encoder_info *ei = find_encoder(id);
bool success;
if (ei && ei->type != type)
return NULL;
encoder = bzalloc(sizeof(struct obs_encoder));
encoder->mixer_idx = mixer_idx;
if (!ei) {
blog(LOG_ERROR, "Encoder ID '%s' not found", id);
encoder->info.id = bstrdup(id);
encoder->info.type = type;
encoder->owns_info_id = true;
} else {
encoder->info = *ei;
}
success = init_encoder(encoder, name, settings, hotkey_data);
if (!success) {
blog(LOG_ERROR, "creating encoder '%s' (%s) failed", name, id);
obs_encoder_destroy(encoder);
return NULL;
}
encoder->control = bzalloc(sizeof(obs_weak_encoder_t));
encoder->control->encoder = encoder;
obs_context_data_insert(&encoder->context,
&obs->data.encoders_mutex,
&obs->data.first_encoder);
blog(LOG_INFO, "encoder '%s' (%s) created", name, id);
return encoder;
}
/**
* We need to check for the xfixes version in order to initialize it ?
*/
xcb_xcursor_t *xcb_xcursor_init(xcb_connection_t *xcb)
{
xcb_xcursor_t *data = bzalloc(sizeof(xcb_xcursor_t));
xcb_xfixes_query_version_cookie_t xfix_c;
xfix_c = xcb_xfixes_query_version_unchecked(xcb,
XCB_XFIXES_MAJOR_VERSION, XCB_XFIXES_MINOR_VERSION);
free(xcb_xfixes_query_version_reply(xcb, xfix_c, NULL));
return data;
}
void list_add_source(py_source* src)
{
blog(LOG_INFO, "LIST_ADD_SOURCE");
if(!py_module.first) {
py_module.first = bzalloc(sizeof(struct python_source));
py_module.first->source = src;
return;
}
struct python_source* current = py_module.first;
while(current->next != NULL) {
current = current->next;
}
current->next = bzalloc(sizeof(struct python_source));
current->next->prev = current;
current->next->source = src;
}
static void *stinger_create(obs_data_t *settings, obs_source_t *source)
{
struct stinger_info *s = bzalloc(sizeof(*s));
s->source = source;
s->mix_a = mix_a_fade_in_out;
s->mix_b = mix_b_fade_in_out;
obs_transition_enable_fixed(s->source, true, 0);
obs_source_update(source, settings);
return s;
}
gs_samplerstate_t device_samplerstate_create(gs_device_t device,
struct gs_sampler_info *info)
{
struct gs_sampler_state *sampler;
sampler = bzalloc(sizeof(struct gs_sampler_state));
sampler->device = device;
sampler->ref = 1;
convert_sampler_info(sampler, info);
return sampler;
}
static void *expander_create(obs_data_t *settings, obs_source_t *filter)
{
struct expander_data *cd = bzalloc(sizeof(struct expander_data));
cd->context = filter;
cd->runave = 0;
cd->is_gate = false;
const char *presets = obs_data_get_string(settings, S_PRESETS);
if (strcmp(presets, "gate") == 0)
cd->is_gate = true;
expander_update(cd, settings);
return cd;
}
config_t *config_create(const char *file)
{
struct config_data *config;
FILE *f;
f = os_fopen(file, "wb");
if (!f)
return NULL;
fclose(f);
config = bzalloc(sizeof(struct config_data));
return config;
}
int video_scaler_create(video_scaler_t **scaler_out,
const struct video_scale_info *dst,
const struct video_scale_info *src,
enum video_scale_type type)
{
enum AVPixelFormat format_src = get_ffmpeg_video_format(src->format);
enum AVPixelFormat format_dst = get_ffmpeg_video_format(dst->format);
int scale_type = get_ffmpeg_scale_type(type);
const int *coeff_src = get_ffmpeg_coeffs(src->colorspace);
const int *coeff_dst = get_ffmpeg_coeffs(dst->colorspace);
int range_src = get_ffmpeg_range_type(src->range);
int range_dst = get_ffmpeg_range_type(dst->range);
struct video_scaler *scaler;
int ret;
if (!scaler_out)
return VIDEO_SCALER_FAILED;
if (format_src == AV_PIX_FMT_NONE ||
format_dst == AV_PIX_FMT_NONE)
return VIDEO_SCALER_BAD_CONVERSION;
scaler = bzalloc(sizeof(struct video_scaler));
scaler->src_height = src->height;
scaler->swscale = sws_getCachedContext(NULL,
src->width, src->height, format_src,
dst->width, dst->height, format_dst,
scale_type, NULL, NULL, NULL);
if (!scaler->swscale) {
blog(LOG_ERROR, "video_scaler_create: Could not create "
"swscale");
goto fail;
}
ret = sws_setColorspaceDetails(scaler->swscale,
coeff_src, range_src,
coeff_dst, range_dst,
0, FIXED_1_0, FIXED_1_0);
if (ret < 0) {
blog(LOG_DEBUG, "video_scaler_create: "
"sws_setColorspaceDetails failed, ignoring");
}
*scaler_out = scaler;
return VIDEO_SCALER_SUCCESS;
fail:
video_scaler_destroy(scaler);
return VIDEO_SCALER_FAILED;
}
static void *monitor_capture_create(obs_data_t settings, obs_source_t source)
{
struct monitor_capture *capture;
effect_t opaque_effect = create_opaque_effect();
if (!opaque_effect)
return NULL;
capture = bzalloc(sizeof(struct monitor_capture));
capture->opaque_effect = opaque_effect;
update_settings(capture, settings);
return capture;
}
obs_output_t obs_output_create(const char *id, const char *name,
obs_data_t settings)
{
const struct obs_output_info *info = find_output(id);
struct obs_output *output;
int ret;
if (!info) {
blog(LOG_ERROR, "Output '%s' not found", id);
return NULL;
}
output = bzalloc(sizeof(struct obs_output));
pthread_mutex_init_value(&output->interleaved_mutex);
if (pthread_mutex_init(&output->interleaved_mutex, NULL) != 0)
goto fail;
if (!init_output_handlers(output, name, settings))
goto fail;
output->info = *info;
output->video = obs_get_video();
output->audio = obs_get_audio();
if (output->info.get_defaults)
output->info.get_defaults(output->context.settings);
ret = os_event_init(&output->reconnect_stop_event,
OS_EVENT_TYPE_MANUAL);
if (ret < 0)
goto fail;
output->context.data = info->create(output->context.settings, output);
if (!output->context.data)
goto fail;
output->reconnect_retry_sec = 2;
output->reconnect_retry_max = 20;
output->valid = true;
obs_context_data_insert(&output->context,
&obs->data.outputs_mutex,
&obs->data.first_output);
blog(LOG_INFO, "output '%s' (%s) created", name, id);
return output;
fail:
obs_output_destroy(output);
return NULL;
}
os_cpu_usage_info_t os_cpu_usage_info_start(void)
{
struct os_cpu_usage_info *info = bzalloc(sizeof(*info));
SYSTEM_INFO si;
FILETIME dummy;
GetSystemInfo(&si);
GetSystemTimeAsFileTime(&info->last_time.ft);
GetProcessTimes(GetCurrentProcess(), &dummy, &dummy,
&info->last_sys_time.ft, &info->last_user_time.ft);
info->core_count = si.dwNumberOfProcessors;
return info;
}
static struct gl_windowinfo *gl_windowinfo_bare(const struct gs_init_data *info)
{
struct gl_windowinfo *wi = bzalloc(sizeof(struct gl_windowinfo));
wi->hwnd = info->window.hwnd;
wi->hdc = GetDC(wi->hwnd);
if (!wi->hdc) {
blog(LOG_ERROR, "Unable to get device context from window");
bfree(wi);
return NULL;
}
return wi;
}
static void *aac_create(obs_data_t settings, obs_encoder_t encoder)
{
struct aac_encoder *enc;
int bitrate = (int)obs_data_getint(settings, "bitrate");
audio_t audio = obs_encoder_audio(encoder);
if (!bitrate) {
aac_warn("aac_create", "Invalid bitrate specified");
return NULL;
}
avcodec_register_all();
enc = bzalloc(sizeof(struct aac_encoder));
enc->encoder = encoder;
enc->aac = avcodec_find_encoder(AV_CODEC_ID_AAC);
if (!enc->aac) {
aac_warn("aac_create", "Couldn't find encoder");
goto fail;
}
blog(LOG_INFO, "Using ffmpeg \"%s\" aac encoder", enc->aac->name);
enc->context = avcodec_alloc_context3(enc->aac);
if (!enc->context) {
aac_warn("aac_create", "Failed to create codec context");
goto fail;
}
enc->context->bit_rate = bitrate * 1000;
enc->context->channels = (int)audio_output_channels(audio);
enc->context->sample_rate = audio_output_samplerate(audio);
enc->context->sample_fmt = enc->aac->sample_fmts ?
enc->aac->sample_fmts[0] : AV_SAMPLE_FMT_FLTP;
init_sizes(enc, audio);
/* enable experimental FFmpeg encoder if the only one available */
enc->context->strict_std_compliance = -2;
enc->context->flags = CODEC_FLAG_GLOBAL_HEADER;
if (initialize_codec(enc))
return enc;
fail:
aac_destroy(enc);
return NULL;
}
static void *scale_filter_create(obs_data_t *settings, obs_source_t *context)
{
struct scale_filter_data *filter =
bzalloc(sizeof(struct scale_filter_data));
struct gs_sampler_info sampler_info = {0};
filter->context = context;
obs_enter_graphics();
filter->point_sampler = gs_samplerstate_create(&sampler_info);
obs_leave_graphics();
scale_filter_update(filter, settings);
return filter;
}
