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