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; }