Implement encoder usage with outputs

 - Make it so that encoders can be assigned to outputs.  If an encoder
   is destroyed, it will automatically remove itself from that output.
   I specifically didn't want to do reference counting because it leaves
   too much potential for unchecked references and it just felt like it
   would be more trouble than it's worth.

 - Add a 'flags' value to the output definition structure.  This lets
   the output specify if it uses video/audio, and whether the output is
   meant to be used with OBS encoders or not.

 - Remove boilerplate code for outputs.  This makes it easier to program
   outputs.  The boilerplate code involved before was mostly just
   involving connecting to the audio/video data streams directly in each
   output plugin.

   Instead of doing that, simply add plugin callback functions for
   receiving video/audio (either encoded or non-encoded, whichever it's
   set to use), and then call obs_output_begin_data_capture and
   obs_output_end_data_capture to automatically handle setting up
   connections to raw or encoded video/audio streams for the plugin.

 - Remove 'active' function from output callbacks, as it's no longer
   really needed now that the libobs output context automatically knows
   when the output is active or not.

 - Make it so that an encoder cannot be destroyed until all data
   connections to the encoder have been removed.

 - Change the 'start' and 'stop' functions in the encoder interface to
   just an 'initialize' callback, which initializes the encoder.

 - Make it so that the encoder must be initialized first before the data
   stream can be started.  The reason why initialization was separated
   from starting the encoder stream was because we need to be able to
   check that the settings used with the encoder *can* be used first.

   This problem was especially annoying if you had both video/audio
   encoding.  Before, you'd have to check the return value from
   obs_encoder_start, and if that second encoder fails, then you
   basically had to stop the first encoder again, making for
   unnecessary boilerplate code whenever starting up two encoders.

libobs/obs-encoder.c

@@ -39,8 +39,13 @@ const char *obs_encoder_getdisplayname(const char *id, const char *locale)
 static bool init_encoder(struct obs_encoder *encoder, const char *name,
 		obs_data_t settings)
 {
+	pthread_mutex_init_value(&encoder->callbacks_mutex);
+	pthread_mutex_init_value(&encoder->outputs_mutex);
+
 	if (pthread_mutex_init(&encoder->callbacks_mutex, NULL) != 0)
 		return false;
+	if (pthread_mutex_init(&encoder->outputs_mutex, NULL) != 0)
+		return false;
 
 	encoder->settings = obs_data_newref(settings);
 	if (encoder->info.defaults)
@@ -64,7 +69,7 @@ static bool init_encoder(struct obs_encoder *encoder, const char *name,
 
 static struct obs_encoder *create_encoder(const char *id,
 		enum obs_encoder_type type, const char *name,
-		obs_data_t settings, void *output,
+		obs_data_t settings, void *media,
 		uint32_t timebase_num, uint32_t timebase_den)
 {
 	struct obs_encoder *encoder;
@@ -76,7 +81,7 @@ static struct obs_encoder *create_encoder(const char *id,
 
 	encoder = bzalloc(sizeof(struct obs_encoder));
 	encoder->info         = *ei;
-	encoder->output       = output;
+	encoder->media        = media;
 	encoder->timebase_num = timebase_num;
 	encoder->timebase_den = timebase_den;
 
@@ -147,51 +152,70 @@ static void add_connection(struct obs_encoder *encoder)
 		struct audio_convert_info *info = NULL;
 
 		info = get_audio_info(encoder, &audio_info);
-		audio_output_connect(encoder->output, info, receive_audio,
+		audio_output_connect(encoder->media, info, receive_audio,
 				encoder);
 	} else {
 		struct video_scale_info *info = NULL;
 
 		info = get_video_info(encoder, &video_info);
-		video_output_connect(encoder->output, info, receive_video,
+		video_output_connect(encoder->media, info, receive_video,
 				encoder);
 	}
+
+	encoder->active = true;
 }
 
 static void remove_connection(struct obs_encoder *encoder)
 {
 	if (encoder->info.type == OBS_ENCODER_AUDIO)
-		audio_output_disconnect(encoder->output, receive_audio,
+		audio_output_disconnect(encoder->media, receive_audio,
 				encoder);
 	else
-		video_output_disconnect(encoder->output, receive_video,
+		video_output_disconnect(encoder->media, receive_video,
 				encoder);
+
+	encoder->active = false;
 }
 
-static void full_stop(struct obs_encoder *encoder)
+static void obs_encoder_actually_destroy(obs_encoder_t encoder)
 {
 	if (encoder) {
-		pthread_mutex_lock(&encoder->callbacks_mutex);
-		da_free(encoder->callbacks);
-		remove_connection(encoder);
-		pthread_mutex_unlock(&encoder->callbacks_mutex);
+		pthread_mutex_lock(&encoder->outputs_mutex);
+		for (size_t i = 0; i < encoder->outputs.num; i++) {
+			struct obs_output *output = encoder->outputs.array[i];
+			obs_output_remove_encoder(output, encoder);
+		}
+		da_free(encoder->outputs);
+		pthread_mutex_unlock(&encoder->outputs_mutex);
+
+		encoder->info.destroy(encoder->data);
+		obs_data_release(encoder->settings);
+		pthread_mutex_destroy(&encoder->callbacks_mutex);
+		pthread_mutex_destroy(&encoder->outputs_mutex);
+		bfree(encoder->name);
+		bfree(encoder);
 	}
 }
 
+/* does not actually destroy the encoder until all connections to it have been
+ * removed. (full reference counting really would have been superfluous) */
 void obs_encoder_destroy(obs_encoder_t encoder)
 {
 	if (encoder) {
-		full_stop(encoder);
+		bool destroy;
 
 		pthread_mutex_lock(&obs->data.encoders_mutex);
 		da_erase_item(obs->data.encoders, &encoder);
 		pthread_mutex_unlock(&obs->data.encoders_mutex);
 
-		encoder->info.destroy(encoder->data);
-		obs_data_release(encoder->settings);
-		pthread_mutex_destroy(&encoder->callbacks_mutex);
-		bfree(encoder->name);
-		bfree(encoder);
+		pthread_mutex_lock(&encoder->callbacks_mutex);
+		destroy = encoder->callbacks.num == 0;
+		if (!destroy)
+			encoder->destroy_on_stop = true;
+		pthread_mutex_unlock(&encoder->callbacks_mutex);
+
+		if (destroy)
+			obs_encoder_actually_destroy(encoder);
 	}
 }
 
@@ -250,6 +274,18 @@ obs_data_t obs_encoder_get_settings(obs_encoder_t encoder)
 	return encoder->settings;
 }
 
+bool obs_encoder_initialize(obs_encoder_t encoder)
+{
+	if (!encoder) return false;
+
+	if (encoder->active)
+		return true;
+
+	encoder->initialized = encoder->info.initialize(encoder,
+			encoder->settings);
+	return encoder->initialized;
+}
+
 static inline size_t get_callback_idx(
 		struct obs_encoder *encoder,
 		void (*new_packet)(void *param, struct encoder_packet *packet),
@@ -265,7 +301,7 @@ static inline size_t get_callback_idx(
 	return DARRAY_INVALID;
 }
 
-bool obs_encoder_start(obs_encoder_t encoder,
+void obs_encoder_start(obs_encoder_t encoder,
 		void (*new_packet)(void *param, struct encoder_packet *packet),
 		void *param)
 {
@@ -273,13 +309,11 @@ bool obs_encoder_start(obs_encoder_t encoder,
 	bool success = true;
 	bool first   = false;
 
-	if (!encoder || !new_packet) return false;
+	if (!encoder || !new_packet || !encoder->initialized) return;
 
 	pthread_mutex_lock(&encoder->callbacks_mutex);
 
 	first = (encoder->callbacks.num == 0);
-	if (first)
-		success = encoder->info.start(encoder->data, encoder->settings);
 
 	if (success) {
 		size_t idx = get_callback_idx(encoder, new_packet, param);
@@ -295,8 +329,6 @@ bool obs_encoder_start(obs_encoder_t encoder,
 		encoder->cur_pts = 0;
 		add_connection(encoder);
 	}
-
-	return success;
 }
 
 void obs_encoder_stop(obs_encoder_t encoder,
@@ -314,27 +346,28 @@ void obs_encoder_stop(obs_encoder_t encoder,
 	if (idx != DARRAY_INVALID) {
 		da_erase(encoder->callbacks, idx);
 		last = (encoder->callbacks.num == 0);
-
-		if (last)
-			encoder->info.stop(encoder->data);
 	}
 
 	pthread_mutex_unlock(&encoder->callbacks_mutex);
 
-	if (last)
+	if (last) {
 		remove_connection(encoder);
+
+		if (encoder->destroy_on_stop)
+			obs_encoder_actually_destroy(encoder);
+	}
 }
 
 video_t obs_encoder_video(obs_encoder_t encoder)
 {
 	return (encoder && encoder->info.type == OBS_ENCODER_VIDEO) ?
-		encoder->output : NULL;
+		encoder->media : NULL;
 }
 
 audio_t obs_encoder_audio(obs_encoder_t encoder)
 {
 	return (encoder && encoder->info.type == OBS_ENCODER_AUDIO) ?
-		encoder->output : NULL;
+		encoder->media : NULL;
 }
 
 static inline bool get_sei(struct obs_encoder *encoder,
@@ -387,6 +420,16 @@ static inline void send_packet(struct obs_encoder *encoder,
 		cb->new_packet(cb->param, packet);
 }
 
+static void full_stop(struct obs_encoder *encoder)
+{
+	if (encoder) {
+		pthread_mutex_lock(&encoder->callbacks_mutex);
+		da_free(encoder->callbacks);
+		remove_connection(encoder);
+		pthread_mutex_unlock(&encoder->callbacks_mutex);
+	}
+}
+
 static inline void do_encode(struct obs_encoder *encoder,
 		struct encoder_frame *frame, struct encoder_packet *packet)
 {
@@ -447,7 +490,7 @@ static void receive_audio(void *param, struct audio_data *data)
 
 	memset(&enc_frame, 0, sizeof(struct encoder_frame));
 
-	data_size = audio_output_blocksize(encoder->output) * data->frames;
+	data_size = audio_output_blocksize(encoder->media) * data->frames;
 
 	for (size_t i = 0; i < MAX_AV_PLANES; i++) {
 		if (data->data[i]) {
@@ -463,3 +506,23 @@ static void receive_audio(void *param, struct audio_data *data)
 
 	encoder->cur_pts += data->frames;
 }
+
+void obs_encoder_add_output(struct obs_encoder *encoder,
+		struct obs_output *output)
+{
+	if (!encoder) return;
+
+	pthread_mutex_lock(&encoder->outputs_mutex);
+	da_push_back(encoder->outputs, &output);
+	pthread_mutex_unlock(&encoder->outputs_mutex);
+}
+
+void obs_encoder_remove_output(struct obs_encoder *encoder,
+		struct obs_output *output)
+{
+	if (!encoder) return;
+
+	pthread_mutex_lock(&encoder->outputs_mutex);
+	da_erase_item(encoder->outputs, &output);
+	pthread_mutex_unlock(&encoder->outputs_mutex);
+}

libobs/obs-encoder.h

@@ -118,13 +118,14 @@ struct obs_encoder_info {
 	void (*destroy)(void *data);
 
 	/**
-	 * Starts the encoder
+	 * Initializes the encoder with the specified settings
 	 *
 	 * @param  data      Data associated with this encoder context
 	 * @param  settings  Settings for the encoder
-	 * @return           true if successful, false otherwise
+	 * @return           true if the encoder settings are valid and the
+	 *                   encoder is ready to be used, false otherwise
 	 */
-	bool (*start)(void *data, obs_data_t settings);
+	bool (*initialize)(void *data, obs_data_t settings);
 
 	/**
 	 * Encodes frame(s), and outputs encoded packets as they become
@@ -151,13 +152,6 @@ struct obs_encoder_info {
 	 */
 	void (*defaults)(obs_data_t settings);
 
-	/**
-	 * Stops the encoder
-	 *
-	 * @param  data  Data associated with this encoder context
-	 */
-	void (*stop)(void *data);
-
 	/** 
 	 * Gets the property information of this encoder
 	 *

libobs/obs-internal.h

@@ -268,9 +268,23 @@ struct obs_output {
 	signal_handler_t                signals;
 	proc_handler_t                  procs;
 
+	bool                            active;
+	video_t                         video;
+	audio_t                         audio;
+	obs_encoder_t                   video_encoder;
+	obs_encoder_t                   audio_encoder;
+
+	bool                            video_conversion_set;
+	bool                            audio_conversion_set;
+	struct video_scale_info         video_conversion;
+	struct audio_convert_info       audio_conversion;
+
 	bool                            valid;
 };
 
+extern void obs_output_remove_encoder(struct obs_output *output,
+		struct obs_encoder *encoder);
+
 
 /* ------------------------------------------------------------------------- */
 /* encoders  */
@@ -287,13 +301,27 @@ struct obs_encoder {
 	struct obs_encoder_info         info;
 	obs_data_t                      settings;
 
+	bool                            initialized;
+	bool                            active;
+
 	uint32_t                        timebase_num;
 	uint32_t                        timebase_den;
 
 	int64_t                         cur_pts;
 
-	void                            *output;
+	pthread_mutex_t                 outputs_mutex;
+	DARRAY(obs_output_t)            outputs;
+
+	bool                            destroy_on_stop;
+
+	/* stores the video/audio media output pointer.  video_t or audio_t */
+	void                            *media;
 
 	pthread_mutex_t                 callbacks_mutex;
 	DARRAY(struct encoder_callback) callbacks;
 };
+
+extern void obs_encoder_add_output(struct obs_encoder *encoder,
+		struct obs_output *output);
+extern void obs_encoder_remove_output(struct obs_encoder *encoder,
+		struct obs_output *output);

libobs/obs-module.c

@@ -198,7 +198,24 @@ void obs_register_output(const struct obs_output_info *info)
 	CHECK_REQUIRED_VAL(info, destroy, obs_register_output);
 	CHECK_REQUIRED_VAL(info, start,   obs_register_output);
 	CHECK_REQUIRED_VAL(info, stop,    obs_register_output);
-	CHECK_REQUIRED_VAL(info, active,  obs_register_output);
+
+	if (info->flags & OBS_OUTPUT_ENCODED) {
+		if (info->flags & OBS_OUTPUT_VIDEO)
+			CHECK_REQUIRED_VAL(info, encoded_video,
+					obs_register_output);
+
+		if (info->flags & OBS_OUTPUT_AUDIO)
+			CHECK_REQUIRED_VAL(info, encoded_audio,
+					obs_register_output);
+	} else {
+		if (info->flags & OBS_OUTPUT_VIDEO)
+			CHECK_REQUIRED_VAL(info, raw_video,
+					obs_register_output);
+
+		if (info->flags & OBS_OUTPUT_AUDIO)
+			CHECK_REQUIRED_VAL(info, raw_audio,
+					obs_register_output);
+	}
 
 	REGISTER_OBS_DEF(cur_output_info_size, obs_output_info,
 			obs->output_types, info);
@@ -206,11 +223,11 @@ void obs_register_output(const struct obs_output_info *info)
 
 void obs_register_encoder(const struct obs_encoder_info *info)
 {
-	CHECK_REQUIRED_VAL(info, getname,   obs_register_encoder);
-	CHECK_REQUIRED_VAL(info, create,    obs_register_encoder);
-	CHECK_REQUIRED_VAL(info, destroy,   obs_register_encoder);
-	CHECK_REQUIRED_VAL(info, start,     obs_register_encoder);
-	CHECK_REQUIRED_VAL(info, encode,    obs_register_encoder);
+	CHECK_REQUIRED_VAL(info, getname,    obs_register_encoder);
+	CHECK_REQUIRED_VAL(info, create,     obs_register_encoder);
+	CHECK_REQUIRED_VAL(info, destroy,    obs_register_encoder);
+	CHECK_REQUIRED_VAL(info, initialize, obs_register_encoder);
+	CHECK_REQUIRED_VAL(info, encode,     obs_register_encoder);
 
 	REGISTER_OBS_DEF(cur_encoder_info_size, obs_encoder_info,
 			obs->encoder_types, info);

libobs/obs-output.c

@@ -49,12 +49,14 @@ obs_output_t obs_output_create(const char *id, const char *name,
 	if (!output->procs)
 		goto fail;
 
-	output->info      = *info;
-	output->settings  = obs_data_newref(settings);
+	output->info     = *info;
+	output->video    = obs_video();
+	output->audio    = obs_audio();
+	output->settings = obs_data_newref(settings);
 	if (output->info.defaults)
 		output->info.defaults(output->settings);
 
-	output->data      = info->create(output->settings, output);
+	output->data = info->create(output->settings, output);
 	if (!output->data)
 		goto fail;
 
@@ -77,10 +79,8 @@ void obs_output_destroy(obs_output_t output)
 {
 	if (output) {
 		if (output->valid) {
-			if (output->info.active) {
-				if (output->info.active(output->data))
-					output->info.stop(output->data);
-			}
+			if (output->active)
+				output->info.stop(output->data);
 
 			pthread_mutex_lock(&obs->data.outputs_mutex);
 			da_erase_item(obs->data.outputs, &output);
@@ -112,7 +112,7 @@ void obs_output_stop(obs_output_t output)
 
 bool obs_output_active(obs_output_t output)
 {
-	return (output != NULL) ? output->info.active(output) : false;
+	return (output != NULL) ? output->active : false;
 }
 
 obs_data_t obs_output_defaults(const char *id)
@@ -182,3 +182,209 @@ proc_handler_t obs_output_prochandler(obs_output_t output)
 {
 	return output ? output->procs : NULL;
 }
+
+void obs_output_set_media(obs_output_t output, video_t video, audio_t audio)
+{
+	if (!output)
+		return;
+
+	output->video = video;
+	output->audio = audio;
+}
+
+video_t obs_output_video(obs_output_t output)
+{
+	return output ? output->video : NULL;
+}
+
+audio_t obs_output_audio(obs_output_t output)
+{
+	return output ? output->audio : NULL;
+}
+
+void obs_output_remove_encoder(struct obs_output *output,
+		struct obs_encoder *encoder)
+{
+	if (!output) return;
+
+	if (output->video_encoder == encoder)
+		output->video_encoder = NULL;
+	else if (output->audio_encoder == encoder)
+		output->audio_encoder = NULL;
+}
+
+void obs_output_set_video_encoder(obs_output_t output, obs_encoder_t encoder)
+{
+	if (!output) return;
+	if (output->video_encoder == encoder) return;
+	if (encoder && encoder->info.type != OBS_ENCODER_VIDEO) return;
+
+	obs_encoder_remove_output(encoder, output);
+	obs_encoder_add_output(encoder, output);
+	output->video_encoder = encoder;
+}
+
+void obs_output_set_audio_encoder(obs_output_t output, obs_encoder_t encoder)
+{
+	if (!output) return;
+	if (output->audio_encoder == encoder) return;
+	if (encoder && encoder->info.type != OBS_ENCODER_AUDIO) return;
+
+	obs_encoder_remove_output(encoder, output);
+	obs_encoder_add_output(encoder, output);
+	output->audio_encoder = encoder;
+}
+
+obs_encoder_t obs_output_get_video_encoder(obs_output_t output)
+{
+	return output ? output->video_encoder : NULL;
+}
+
+obs_encoder_t obs_output_get_audio_encoder(obs_output_t output)
+{
+	return output ? output->audio_encoder : NULL;
+}
+
+void obs_output_set_video_conversion(obs_output_t output,
+		const struct video_scale_info *conversion)
+{
+	if (!output || !conversion) return;
+
+	output->video_conversion = *conversion;
+	output->video_conversion_set = true;
+}
+
+void obs_output_set_audio_conversion(obs_output_t output,
+		const struct audio_convert_info *conversion)
+{
+	if (!output || !conversion) return;
+
+	output->audio_conversion = *conversion;
+	output->audio_conversion_set = true;
+}
+
+static bool can_begin_data_capture(struct obs_output *output, bool encoded,
+		bool has_video, bool has_audio)
+{
+	if (has_video) {
+		if (encoded) {
+			if (!output->video_encoder)
+				return false;
+		} else {
+			if (!output->video)
+				return false;
+		}
+	}
+
+	if (has_audio) {
+		if (encoded) {
+			if (!output->audio_encoder)
+				return false;
+		} else {
+			if (!output->audio)
+				return false;
+		}
+	}
+
+	return true;
+}
+
+static inline struct video_scale_info *get_video_conversion(
+		struct obs_output *output)
+{
+	return output->video_conversion_set ? &output->video_conversion : NULL;
+}
+
+static inline struct audio_convert_info *get_audio_conversion(
+		struct obs_output *output)
+{
+	return output->audio_conversion_set ? &output->audio_conversion : NULL;
+}
+
+static void hook_data_capture(struct obs_output *output, bool encoded,
+		bool has_video, bool has_audio)
+{
+	if (encoded) {
+		if (has_video)
+			obs_encoder_start(output->video_encoder,
+					output->info.encoded_video,
+					output->data);
+		if (has_audio)
+			obs_encoder_start(output->audio_encoder,
+					output->info.encoded_audio,
+					output->data);
+	} else {
+		if (has_video)
+			video_output_connect(output->video,
+					get_video_conversion(output),
+					output->info.raw_video,
+					output->data);
+		if (has_audio)
+			audio_output_connect(output->audio,
+					get_audio_conversion(output),
+					output->info.raw_audio,
+					output->data);
+	}
+}
+
+static inline void convert_flags(struct obs_output *output, uint32_t flags,
+		bool *encoded, bool *has_video, bool *has_audio)
+{
+	*encoded = (output->info.flags & OBS_OUTPUT_ENCODED) != 0;
+	if (!flags)
+		flags = output->info.flags;
+	else
+		flags &= output->info.flags;
+
+	*has_video = (flags & OBS_OUTPUT_VIDEO) != 0;
+	*has_audio = (flags & OBS_OUTPUT_AUDIO) != 0;
+}
+
+bool obs_output_begin_data_capture(obs_output_t output, uint32_t flags)
+{
+	bool encoded, has_video, has_audio;
+
+	if (!output) return false;
+	if (output->active) return false;
+
+	convert_flags(output, flags, &encoded, &has_video, &has_audio);
+
+	if (!can_begin_data_capture(output, encoded, has_video, has_audio))
+		return false;
+
+	hook_data_capture(output, encoded, has_video, has_audio);
+	output->active = true;
+	return true;
+}
+
+void obs_output_end_data_capture(obs_output_t output)
+{
+	bool encoded, has_video, has_audio;
+
+	if (!output) return;
+	if (!output->active) return;
+
+	convert_flags(output, 0, &encoded, &has_video, &has_audio);
+
+	if (encoded) {
+		if (has_video)
+			obs_encoder_stop(output->video_encoder,
+					output->info.encoded_video,
+					output->data);
+		if (has_audio)
+			obs_encoder_stop(output->audio_encoder,
+					output->info.encoded_audio,
+					output->data);
+	} else {
+		if (has_video)
+			video_output_disconnect(output->video,
+					output->info.raw_video,
+					output->data);
+		if (has_audio)
+			audio_output_disconnect(output->audio,
+					output->info.raw_audio,
+					output->data);
+	}
+
+	output->active = false;
+}

libobs/obs-output.h

@@ -17,10 +17,19 @@
 
 #pragma once
 
+#define OBS_OUTPUT_VIDEO       (1<<0)
+#define OBS_OUTPUT_AUDIO       (1<<1)
+#define OBS_OUTPUT_AV          (OBS_OUTPUT_VIDEO | OBS_OUTPUT_AUDIO)
+#define OBS_OUTPUT_ENCODED     (1<<2)
+
+struct encoder_packet;
+
 struct obs_output_info {
 	/* required */
 	const char *id;
 
+	uint32_t flags;
+
 	const char *(*getname)(const char *locale);
 
 	void *(*create)(obs_data_t settings, obs_output_t output);
@@ -29,7 +38,11 @@ struct obs_output_info {
 	bool (*start)(void *data);
 	void (*stop)(void *data);
 
-	bool (*active)(void *data);
+	void (*raw_video)(void *data, struct video_data *frame);
+	void (*raw_audio)(void *data, struct audio_data *frames);
+
+	void (*encoded_video)(void *data, struct encoder_packet *packet);
+	void (*encoded_audio)(void *data, struct encoder_packet *packet);
 
 	/* optional */
 	void (*update)(void *data, obs_data_t settings);

libobs/obs.h

@@ -697,6 +697,73 @@ EXPORT signal_handler_t obs_output_signalhandler(obs_output_t output);
 /** Returns the procedure handler for an output */
 EXPORT proc_handler_t obs_output_prochandler(obs_output_t output);
 
+/**
+ * Sets the current video media context associated with this output,
+ * required for non-encoded outputs
+ */
+EXPORT void obs_output_set_video(obs_output_t output, video_t video);
+
+/**
+ * Sets the current audio/video media contexts associated with this output,
+ * required for non-encoded outputs.  Can be null.
+ */
+EXPORT void obs_output_set_media(obs_output_t output,
+		video_t video, audio_t audio);
+
+/** Returns the video media context associated with this output */
+EXPORT video_t obs_output_video(obs_output_t output);
+
+/** Returns the audio media context associated with this output */
+EXPORT audio_t obs_output_audio(obs_output_t output);
+
+/**
+ * Sets the current video encoder associated with this output,
+ * required for encoded outputs
+ */
+EXPORT void obs_output_set_video_encoder(obs_output_t output,
+		obs_encoder_t encoder);
+
+/**
+ * Sets the current audio encoder associated with this output,
+ * required for encoded outputs
+ */
+EXPORT void obs_output_set_audio_encoder(obs_output_t output,
+		obs_encoder_t encoder);
+
+/** Returns the current video encoder associated with this output */
+EXPORT obs_encoder_t obs_output_get_video_encoder(obs_output_t output);
+
+/** Returns the current audio encoder associated with this output */
+EXPORT obs_encoder_t obs_output_get_audio_encoder(obs_output_t output);
+
+/* ------------------------------------------------------------------------- */
+/* Functions used by outputs */
+
+/** Optionally sets the video conversion info.  Used only for raw output */
+EXPORT void obs_output_set_video_conversion(obs_output_t output,
+		const struct video_scale_info *conversion);
+
+/** Optionally sets the audio conversion info.  Used only for raw output */
+EXPORT void obs_output_set_audio_conversion(obs_output_t output,
+		const struct audio_convert_info *conversion);
+
+/**
+ * Begins data capture from media/encoders.
+ *
+ * @param  output  Output context
+ * @param  flags   Set this to 0 to use default output flags set in the
+ *                 obs_output_info structure, otherwise set to a either
+ *                 OBS_OUTPUT_VIDEO or OBS_OUTPUT_AUDIO to specify whether to
+ *                 connect audio or video.  This is useful for things like
+ *                 ffmpeg which may or may not always want to use both audio
+ *                 and video.
+ * @return         true if successful, false otherwise.
+ */
+EXPORT bool obs_output_begin_data_capture(obs_output_t output, uint32_t flags);
+
+/** Ends data capture from media/encoders */
+EXPORT void obs_output_end_data_capture(obs_output_t output);
+
 
 /* ------------------------------------------------------------------------- */
 /* Encoders */
@@ -731,6 +798,12 @@ EXPORT obs_encoder_t obs_encoder_create_audio(const char *id, const char *name,
 /** Destroys an encoder context */
 EXPORT void obs_encoder_destroy(obs_encoder_t encoder);
 
+/**
+ * Initializes the encoder and returns whether settings are valid.
+ * Must be called before obs_encoder_start
+ */
+EXPORT bool obs_encoder_initialize(obs_encoder_t encoder);
+
 /**
  * Starts encoding.  This function can be called more than once, and each
  * callback will receive the same encoder data.
@@ -739,7 +812,7 @@ EXPORT void obs_encoder_destroy(obs_encoder_t encoder);
  * @param  new_packet  Callback that receives encoded packets
  * @param  param       Callback parameter
  */
-EXPORT bool obs_encoder_start(obs_encoder_t encoder,
+EXPORT void obs_encoder_start(obs_encoder_t encoder,
 		void (*new_packet)(void *param, struct encoder_packet *packet),
 		void *param);
 

plugins/obs-ffmpeg/obs-ffmpeg-output.c

@@ -741,19 +741,11 @@ static void *write_thread(void *data)
 
 static bool try_connect(struct ffmpeg_output *output)
 {
-	video_t video = obs_video();
-	audio_t audio = obs_audio();
 	const char *filename_test;
 	obs_data_t settings;
 	int audio_bitrate, video_bitrate;
 	int ret;
 
-	if (!video || !audio) {
-		blog(LOG_WARNING, "ffmpeg_output_start: audio and video must "
-		                  "both be active (as of this writing)");
-		return false;
-	}
-
 	settings = obs_output_get_settings(output->output);
 	filename_test = obs_data_getstring(settings, "filename");
 	video_bitrate = (int)obs_data_getint(settings, "video_bitrate");
@@ -785,8 +777,9 @@ static bool try_connect(struct ffmpeg_output *output)
 		return false;
 	}
 
-	video_output_connect(video, &vsi, receive_video, output);
-	audio_output_connect(audio, &aci, receive_audio, output);
+	obs_output_set_video_conversion(output->output, &vsi);
+	obs_output_set_audio_conversion(output->output, &aci);
+	obs_output_begin_data_capture(output->output, 0);
 	output->write_thread_active = true;
 	return true;
 }
@@ -826,8 +819,7 @@ static void ffmpeg_output_stop(void *data)
 	struct ffmpeg_output *output = data;
 
 	if (output->active) {
-		video_output_disconnect(obs_video(), receive_video, data);
-		audio_output_disconnect(obs_audio(), receive_audio, data);
+		obs_output_end_data_capture(output->output);
 
 		if (output->write_thread_active) {
 			os_event_signal(output->stop_event);
@@ -848,18 +840,14 @@ static void ffmpeg_output_stop(void *data)
 	}
 }
 
-static bool ffmpeg_output_active(void *data)
-{
-	struct ffmpeg_output *output = data;
-	return output->active;
-}
-
 struct obs_output_info ffmpeg_output = {
-	.id      = "ffmpeg_output",
-	.getname = ffmpeg_output_getname,
-	.create  = ffmpeg_output_create,
-	.destroy = ffmpeg_output_destroy,
-	.start   = ffmpeg_output_start,
-	.stop    = ffmpeg_output_stop,
-	.active  = ffmpeg_output_active
+	.id        = "ffmpeg_output",
+	.flags     = OBS_OUTPUT_AUDIO | OBS_OUTPUT_VIDEO,
+	.getname   = ffmpeg_output_getname,
+	.create    = ffmpeg_output_create,
+	.destroy   = ffmpeg_output_destroy,
+	.start     = ffmpeg_output_start,
+	.stop      = ffmpeg_output_stop,
+	.raw_video = receive_video,
+	.raw_audio = receive_audio,
 };

plugins/obs-x264/obs-x264.c

@@ -47,12 +47,25 @@ static const char *obs_x264_getname(const char *locale)
 
 static void obs_x264_stop(void *data);
 
+static void clear_data(struct obs_x264 *obsx264)
+{
+	if (obsx264->context) {
+		x264_encoder_close(obsx264->context);
+		bfree(obsx264->sei);
+		bfree(obsx264->extra_data);
+
+		obsx264->context    = NULL;
+		obsx264->sei        = NULL;
+		obsx264->extra_data = NULL;
+	}
+}
+
 static void obs_x264_destroy(void *data)
 {
 	struct obs_x264 *obsx264 = data;
 
 	if (obsx264) {
-		obs_x264_stop(obsx264);
+		clear_data(obsx264);
 		da_free(obsx264->packet_data);
 		bfree(obsx264);
 	}
@@ -318,12 +331,11 @@ static void load_headers(struct obs_x264 *obsx264)
 	obsx264->sei_size        = sei.num;
 }
 
-static bool obs_x264_start(void *data, obs_data_t settings)
+static bool obs_x264_initialize(void *data, obs_data_t settings)
 {
 	struct obs_x264 *obsx264 = data;
 
-	assert(obsx264->context == NULL);
-	obs_x264_stop(data);
+	clear_data(data);
 
 	if (update_settings(obsx264, settings)) {
 		obsx264->context = x264_encoder_open(&obsx264->params);
@@ -339,25 +351,12 @@ static bool obs_x264_start(void *data, obs_data_t settings)
 	return obsx264->context != NULL;
 }
 
-static void obs_x264_stop(void *data)
-{
-	struct obs_x264 *obsx264 = data;
-
-	if (obsx264->context) {
-		x264_encoder_close(obsx264->context);
-		bfree(obsx264->sei);
-		bfree(obsx264->extra_data);
-
-		obsx264->context    = NULL;
-		obsx264->sei        = NULL;
-		obsx264->extra_data = NULL;
-	}
-}
-
 static void *obs_x264_create(obs_data_t settings, obs_encoder_t encoder)
 {
 	struct obs_x264 *data = bzalloc(sizeof(struct obs_x264));
 	data->encoder = encoder;
+
+	UNUSED_PARAMETER(settings);
 	return data;
 }
 
@@ -428,10 +427,11 @@ static bool obs_x264_encode(void *data, struct encoder_frame *frame,
 	if (!frame || !packet || !received_packet)
 		return false;
 
-	init_pic_data(obsx264, &pic, frame);
+	if (frame)
+		init_pic_data(obsx264, &pic, frame);
 
-	ret = x264_encoder_encode(obsx264->context, &nals, &nal_count, &pic,
-			&pic_out);
+	ret = x264_encoder_encode(obsx264->context, &nals, &nal_count,
+			(frame ? &pic : NULL), &pic_out);
 	if (ret < 0) {
 		blog(LOG_WARNING, "x264 encode failed");
 		return false;
@@ -492,8 +492,7 @@ struct obs_encoder_info obs_x264_encoder = {
 	.getname    = obs_x264_getname,
 	.create     = obs_x264_create,
 	.destroy    = obs_x264_destroy,
-	.start      = obs_x264_start,
-	.stop       = obs_x264_stop,
+	.initialize = obs_x264_initialize,
 	.encode     = obs_x264_encode,
 	.properties = obs_x264_props,
 	.defaults   = obs_x264_defaults,