libobs: Add null debug messages for base obs funcs

libobs/obs-encoder.c

@@ -259,12 +259,14 @@ void obs_encoder_destroy(obs_encoder_t *encoder)
 
 const char *obs_encoder_get_name(const obs_encoder_t *encoder)
 {
-	return encoder ? encoder->context.name : NULL;
+	return obs_encoder_valid(encoder, "obs_encoder_get_name") ?
+		encoder->context.name : NULL;
 }
 
 void obs_encoder_set_name(obs_encoder_t *encoder, const char *name)
 {
-	if (!encoder) return;
+	if (!obs_encoder_valid(encoder, "obs_encoder_set_name"))
+		return;
 
 	if (name && *name && strcmp(name, encoder->context.name) != 0)
 		obs_context_data_setname(&encoder->context, name);
@@ -301,7 +303,10 @@ obs_properties_t *obs_get_encoder_properties(const char *id)
 
 obs_properties_t *obs_encoder_properties(const obs_encoder_t *encoder)
 {
-	if (encoder && encoder->info.get_properties) {
+	if (!obs_encoder_valid(encoder, "obs_encoder_properties"))
+		return NULL;
+
+	if (encoder->info.get_properties) {
 		obs_properties_t *props;
 		props = encoder->info.get_properties(encoder->context.data);
 		obs_properties_apply_settings(props, encoder->context.settings);
@@ -312,7 +317,8 @@ obs_properties_t *obs_encoder_properties(const obs_encoder_t *encoder)
 
 void obs_encoder_update(obs_encoder_t *encoder, obs_data_t *settings)
 {
-	if (!encoder) return;
+	if (!obs_encoder_valid(encoder, "obs_encoder_update"))
+		return;
 
 	obs_data_apply(encoder->context.settings, settings);
 
@@ -324,7 +330,10 @@ void obs_encoder_update(obs_encoder_t *encoder, obs_data_t *settings)
 bool obs_encoder_get_extra_data(const obs_encoder_t *encoder,
 		uint8_t **extra_data, size_t *size)
 {
-	if (encoder && encoder->info.get_extra_data && encoder->context.data)
+	if (!obs_encoder_valid(encoder, "obs_encoder_get_extra_data"))
+		return false;
+
+	if (encoder->info.get_extra_data && encoder->context.data)
 		return encoder->info.get_extra_data(encoder->context.data,
 				extra_data, size);
 
@@ -333,7 +342,8 @@ bool obs_encoder_get_extra_data(const obs_encoder_t *encoder,
 
 obs_data_t *obs_encoder_get_settings(const obs_encoder_t *encoder)
 {
-	if (!encoder) return NULL;
+	if (!obs_encoder_valid(encoder, "obs_encoder_get_settings"))
+		return NULL;
 
 	obs_data_addref(encoder->context.settings);
 	return encoder->context.settings;
@@ -417,7 +427,12 @@ void obs_encoder_start(obs_encoder_t *encoder,
 	struct encoder_callback cb = {false, new_packet, param};
 	bool first   = false;
 
-	if (!encoder || !new_packet || !encoder->context.data) return;
+	if (!obs_encoder_valid(encoder, "obs_encoder_start"))
+		return;
+	if (!obs_ptr_valid(new_packet, "obs_encoder_start"))
+		return;
+	if (!encoder->context.data)
+		return;
 
 	pthread_mutex_lock(&encoder->callbacks_mutex);
 
@@ -442,7 +457,7 @@ void obs_encoder_stop(obs_encoder_t *encoder,
 	bool   last = false;
 	size_t idx;
 
-	if (!encoder) return;
+	if (!obs_encoder_valid(encoder, "obs_encoder_stop")) return;
 
 	pthread_mutex_lock(&encoder->callbacks_mutex);
 
@@ -464,7 +479,8 @@ void obs_encoder_stop(obs_encoder_t *encoder,
 
 const char *obs_encoder_get_codec(const obs_encoder_t *encoder)
 {
-	return encoder ? encoder->info.codec : NULL;
+	return obs_encoder_valid(encoder, "obs_encoder_get_codec") ?
+		encoder->info.codec : NULL;
 }
 
 const char *obs_get_encoder_codec(const char *id)
@@ -475,7 +491,8 @@ const char *obs_get_encoder_codec(const char *id)
 
 enum obs_encoder_type obs_encoder_get_type(const obs_encoder_t *encoder)
 {
-	return encoder ? encoder->info.type : OBS_ENCODER_AUDIO;
+	return obs_encoder_valid(encoder, "obs_encoder_get_type") ?
+		encoder->info.type : OBS_ENCODER_AUDIO;
 }
 
 enum obs_encoder_type obs_get_encoder_type(const char *id)
@@ -487,9 +504,14 @@ enum obs_encoder_type obs_get_encoder_type(const char *id)
 void obs_encoder_set_scaled_size(obs_encoder_t *encoder, uint32_t width,
 		uint32_t height)
 {
-	if (!encoder || encoder->info.type != OBS_ENCODER_VIDEO)
+	if (!obs_encoder_valid(encoder, "obs_encoder_set_scaled_size"))
 		return;
-
+	if (encoder->info.type != OBS_ENCODER_VIDEO) {
+		blog(LOG_WARNING, "obs_encoder_set_scaled_size: "
+				"encoder '%s' is not a video encoder",
+				obs_encoder_get_name(encoder));
+		return;
+	}
 	if (encoder->active) {
 		blog(LOG_WARNING, "encoder '%s': Cannot set the scaled "
 		                  "resolution while the encoder is active",
@@ -503,8 +525,15 @@ void obs_encoder_set_scaled_size(obs_encoder_t *encoder, uint32_t width,
 
 uint32_t obs_encoder_get_width(const obs_encoder_t *encoder)
 {
-	if (!encoder || !encoder->media ||
-	    encoder->info.type != OBS_ENCODER_VIDEO)
+	if (!obs_encoder_valid(encoder, "obs_encoder_get_width"))
+		return 0;
+	if (encoder->info.type != OBS_ENCODER_VIDEO) {
+		blog(LOG_WARNING, "obs_encoder_get_width: "
+				"encoder '%s' is not a video encoder",
+				obs_encoder_get_name(encoder));
+		return 0;
+	}
+	if (!encoder->media)
 		return 0;
 
 	return encoder->scaled_width != 0 ?
@@ -514,8 +543,15 @@ uint32_t obs_encoder_get_width(const obs_encoder_t *encoder)
 
 uint32_t obs_encoder_get_height(const obs_encoder_t *encoder)
 {
-	if (!encoder || !encoder->media ||
-	    encoder->info.type != OBS_ENCODER_VIDEO)
+	if (!obs_encoder_valid(encoder, "obs_encoder_get_height"))
+		return 0;
+	if (encoder->info.type != OBS_ENCODER_VIDEO) {
+		blog(LOG_WARNING, "obs_encoder_get_height: "
+				"encoder '%s' is not a video encoder",
+				obs_encoder_get_name(encoder));
+		return 0;
+	}
+	if (!encoder->media)
 		return 0;
 
 	return encoder->scaled_width != 0 ?
@@ -525,8 +561,15 @@ uint32_t obs_encoder_get_height(const obs_encoder_t *encoder)
 
 uint32_t obs_encoder_get_sample_rate(const obs_encoder_t *encoder)
 {
-	if (!encoder || !encoder->media ||
-	    encoder->info.type != OBS_ENCODER_AUDIO)
+	if (!obs_encoder_valid(encoder, "obs_encoder_get_sample_rate"))
+		return 0;
+	if (encoder->info.type != OBS_ENCODER_AUDIO) {
+		blog(LOG_WARNING, "obs_encoder_get_sample_rate: "
+				"encoder '%s' is not an audio encoder",
+				obs_encoder_get_name(encoder));
+		return 0;
+	}
+	if (!encoder->media)
 		return 0;
 
 	return encoder->samplerate != 0 ?
@@ -538,7 +581,15 @@ void obs_encoder_set_video(obs_encoder_t *encoder, video_t *video)
 {
 	const struct video_output_info *voi;
 
-	if (!video || !encoder || encoder->info.type != OBS_ENCODER_VIDEO)
+	if (!obs_encoder_valid(encoder, "obs_encoder_set_video"))
+		return;
+	if (encoder->info.type != OBS_ENCODER_VIDEO) {
+		blog(LOG_WARNING, "obs_encoder_set_video: "
+				"encoder '%s' is not a video encoder",
+				obs_encoder_get_name(encoder));
+		return;
+	}
+	if (!video)
 		return;
 
 	voi = video_output_get_info(video);
@@ -550,7 +601,15 @@ void obs_encoder_set_video(obs_encoder_t *encoder, video_t *video)
 
 void obs_encoder_set_audio(obs_encoder_t *encoder, audio_t *audio)
 {
-	if (!audio || !encoder || encoder->info.type != OBS_ENCODER_AUDIO)
+	if (!obs_encoder_valid(encoder, "obs_encoder_set_audio"))
+		return;
+	if (encoder->info.type != OBS_ENCODER_AUDIO) {
+		blog(LOG_WARNING, "obs_encoder_set_audio: "
+				"encoder '%s' is not an audio encoder",
+				obs_encoder_get_name(encoder));
+		return;
+	}
+	if (!audio)
 		return;
 
 	encoder->media        = audio;
@@ -560,19 +619,36 @@ void obs_encoder_set_audio(obs_encoder_t *encoder, audio_t *audio)
 
 video_t *obs_encoder_video(const obs_encoder_t *encoder)
 {
-	return (encoder && encoder->info.type == OBS_ENCODER_VIDEO) ?
-		encoder->media : NULL;
+	if (!obs_encoder_valid(encoder, "obs_encoder_video"))
+		return NULL;
+	if (encoder->info.type != OBS_ENCODER_VIDEO) {
+		blog(LOG_WARNING, "obs_encoder_set_video: "
+				"encoder '%s' is not a video encoder",
+				obs_encoder_get_name(encoder));
+		return NULL;
+	}
+
+	return encoder->media;
 }
 
 audio_t *obs_encoder_audio(const obs_encoder_t *encoder)
 {
-	return (encoder && encoder->info.type == OBS_ENCODER_AUDIO) ?
-		encoder->media : NULL;
+	if (!obs_encoder_valid(encoder, "obs_encoder_audio"))
+		return NULL;
+	if (encoder->info.type != OBS_ENCODER_AUDIO) {
+		blog(LOG_WARNING, "obs_encoder_set_audio: "
+				"encoder '%s' is not an audio encoder",
+				obs_encoder_get_name(encoder));
+		return NULL;
+	}
+
+	return encoder->media;
 }
 
 bool obs_encoder_active(const obs_encoder_t *encoder)
 {
-	return encoder ? encoder->active : false;
+	return obs_encoder_valid(encoder, "obs_encoder_active") ?
+		encoder->active : false;
 }
 
 static inline bool get_sei(const struct obs_encoder *encoder,

libobs/obs-output.c

@@ -172,7 +172,8 @@ void obs_output_destroy(obs_output_t *output)
 
 const char *obs_output_get_name(const obs_output_t *output)
 {
-	return output ? output->context.name : NULL;
+	return obs_output_valid(output, "obs_output_get_name") ?
+		output->context.name : NULL;
 }
 
 bool obs_output_actual_start(obs_output_t *output)
@@ -335,6 +336,9 @@ obs_properties_t *obs_get_output_properties(const char *id)
 
 obs_properties_t *obs_output_properties(const obs_output_t *output)
 {
+	if (!obs_output_valid(output, "obs_output_properties"))
+		return NULL;
+
 	if (output && output->info.get_properties) {
 		obs_properties_t *props;
 		props = output->info.get_properties(output->context.data);
@@ -347,7 +351,8 @@ obs_properties_t *obs_output_properties(const obs_output_t *output)
 
 void obs_output_update(obs_output_t *output, obs_data_t *settings)
 {
-	if (!output) return;
+	if (!obs_output_valid(output, "obs_output_update"))
+		return;
 
 	obs_data_apply(output->context.settings, settings);
 
@@ -358,7 +363,7 @@ void obs_output_update(obs_output_t *output, obs_data_t *settings)
 
 obs_data_t *obs_output_get_settings(const obs_output_t *output)
 {
-	if (!output)
+	if (!obs_output_valid(output, "obs_output_get_settings"))
 		return NULL;
 
 	obs_data_addref(output->context.settings);
@@ -367,28 +372,34 @@ obs_data_t *obs_output_get_settings(const obs_output_t *output)
 
 bool obs_output_canpause(const obs_output_t *output)
 {
-	return output ? (output->info.pause != NULL) : false;
+	return obs_output_valid(output, "obs_output_canpause") ?
+		(output->info.pause != NULL) : false;
 }
 
 void obs_output_pause(obs_output_t *output)
 {
-	if (output && output->info.pause)
+	if (!obs_output_valid(output, "obs_output_pause"))
+		return;
+
+	if (output->info.pause)
 		output->info.pause(output->context.data);
 }
 
 signal_handler_t *obs_output_get_signal_handler(const obs_output_t *output)
 {
-	return output ? output->context.signals : NULL;
+	return obs_output_valid(output, "obs_output_get_signal_handler") ?
+		output->context.signals : NULL;
 }
 
 proc_handler_t *obs_output_get_proc_handler(const obs_output_t *output)
 {
-	return output ? output->context.procs : NULL;
+	return obs_output_valid(output, "obs_output_get_proc_handler") ?
+		output->context.procs : NULL;
 }
 
 void obs_output_set_media(obs_output_t *output, video_t *video, audio_t *audio)
 {
-	if (!output)
+	if (!obs_output_valid(output, "obs_output_set_media"))
 		return;
 
 	output->video = video;
@@ -397,17 +408,19 @@ void obs_output_set_media(obs_output_t *output, video_t *video, audio_t *audio)
 
 video_t *obs_output_video(const obs_output_t *output)
 {
-	return output ? output->video : NULL;
+	return obs_output_valid(output, "obs_output_video") ?
+		output->video : NULL;
 }
 
 audio_t *obs_output_audio(const obs_output_t *output)
 {
-	return output ? output->audio : NULL;
+	return obs_output_valid(output, "obs_output_audio") ?
+		output->audio : NULL;
 }
 
 void obs_output_set_mixer(obs_output_t *output, size_t mixer_idx)
 {
-	if (!output)
+	if (!obs_output_valid(output, "obs_output_set_mixer"))
 		return;
 
 	if (!output->active)
@@ -416,13 +429,15 @@ void obs_output_set_mixer(obs_output_t *output, size_t mixer_idx)
 
 size_t obs_output_get_mixer(const obs_output_t *output)
 {
-	return output ? output->mixer_idx : 0;
+	return obs_output_valid(output, "obs_output_get_mixer") ?
+		output->mixer_idx : 0;
 }
 
 void obs_output_remove_encoder(struct obs_output *output,
 		struct obs_encoder *encoder)
 {
-	if (!output) return;
+	if (!obs_output_valid(output, "obs_output_remove_encoder"))
+		return;
 
 	if (output->video_encoder == encoder) {
 		output->video_encoder = NULL;
@@ -436,9 +451,15 @@ void obs_output_remove_encoder(struct obs_output *output,
 
 void obs_output_set_video_encoder(obs_output_t *output, obs_encoder_t *encoder)
 {
-	if (!output) return;
+	if (!obs_output_valid(output, "obs_output_set_video_encoder"))
+		return;
+	if (encoder && encoder->info.type != OBS_ENCODER_VIDEO) {
+		blog(LOG_WARNING, "obs_output_set_video_encoder: "
+				"encoder passed is not a video encoder");
+		return;
+	}
+
 	if (output->video_encoder == encoder) return;
-	if (encoder && encoder->info.type != OBS_ENCODER_VIDEO) return;
 
 	obs_encoder_remove_output(output->video_encoder, output);
 	obs_encoder_add_output(encoder, output);
@@ -453,8 +474,13 @@ void obs_output_set_video_encoder(obs_output_t *output, obs_encoder_t *encoder)
 void obs_output_set_audio_encoder(obs_output_t *output, obs_encoder_t *encoder,
 		size_t idx)
 {
-	if (!output) return;
-	if (encoder && encoder->info.type != OBS_ENCODER_AUDIO) return;
+	if (!obs_output_valid(output, "obs_output_set_audio_encoder"))
+		return;
+	if (encoder && encoder->info.type != OBS_ENCODER_AUDIO) {
+		blog(LOG_WARNING, "obs_output_set_audio_encoder: "
+				"encoder passed is not an audio encoder");
+		return;
+	}
 
 	if ((output->info.flags & OBS_OUTPUT_MULTI_TRACK) != 0) {
 		if (idx >= MAX_AUDIO_MIXES) {
@@ -475,13 +501,15 @@ void obs_output_set_audio_encoder(obs_output_t *output, obs_encoder_t *encoder,
 
 obs_encoder_t *obs_output_get_video_encoder(const obs_output_t *output)
 {
-	return output ? output->video_encoder : NULL;
+	return obs_output_valid(output, "obs_output_get_video_encoder") ?
+		output->video_encoder : NULL;
 }
 
 obs_encoder_t *obs_output_get_audio_encoder(const obs_output_t *output,
 		size_t idx)
 {
-	if (!output) return NULL;
+	if (!obs_output_valid(output, "obs_output_get_audio_encoder"))
+		return NULL;
 
 	if ((output->info.flags & OBS_OUTPUT_MULTI_TRACK) != 0) {
 		if (idx >= MAX_AUDIO_MIXES) {
@@ -498,7 +526,10 @@ obs_encoder_t *obs_output_get_audio_encoder(const obs_output_t *output,
 
 void obs_output_set_service(obs_output_t *output, obs_service_t *service)
 {
-	if (!output || output->active || !service || service->active) return;
+	if (!obs_output_valid(output, "obs_output_set_service"))
+		return;
+	if (output->active || !service || service->active)
+		return;
 
 	if (service->output)
 		service->output->service = NULL;
@@ -509,13 +540,15 @@ void obs_output_set_service(obs_output_t *output, obs_service_t *service)
 
 obs_service_t *obs_output_get_service(const obs_output_t *output)
 {
-	return output ? output->service : NULL;
+	return obs_output_valid(output, "obs_output_get_service") ?
+		output->service : NULL;
 }
 
 void obs_output_set_reconnect_settings(obs_output_t *output,
 		int retry_count, int retry_sec)
 {
-	if (!output) return;
+	if (!obs_output_valid(output, "obs_output_set_reconnect_settings"))
+		return;
 
 	output->reconnect_retry_max = retry_count;
 	output->reconnect_retry_sec = retry_sec;
@@ -523,7 +556,9 @@ void obs_output_set_reconnect_settings(obs_output_t *output,
 
 uint64_t obs_output_get_total_bytes(const obs_output_t *output)
 {
-	if (!output || !output->info.get_total_bytes)
+	if (!obs_output_valid(output, "obs_output_get_total_bytes"))
+		return 0;
+	if (!output->info.get_total_bytes)
 		return 0;
 
 	if (output->delay_active && !output->delay_capturing)
@@ -534,7 +569,9 @@ uint64_t obs_output_get_total_bytes(const obs_output_t *output)
 
 int obs_output_get_frames_dropped(const obs_output_t *output)
 {
-	if (!output || !output->info.get_dropped_frames)
+	if (!obs_output_valid(output, "obs_output_get_frames_dropped"))
+		return 0;
+	if (!output->info.get_dropped_frames)
 		return 0;
 
 	return output->info.get_dropped_frames(output->context.data);
@@ -542,13 +579,16 @@ int obs_output_get_frames_dropped(const obs_output_t *output)
 
 int obs_output_get_total_frames(const obs_output_t *output)
 {
-	return output ? output->total_frames : 0;
+	return obs_output_valid(output, "obs_output_get_total_frames") ?
+		output->total_frames : 0;
 }
 
 void obs_output_set_preferred_size(obs_output_t *output, uint32_t width,
 		uint32_t height)
 {
-	if (!output || (output->info.flags & OBS_OUTPUT_VIDEO) == 0)
+	if (!obs_output_valid(output, "obs_output_set_preferred_size"))
+		return;
+	if ((output->info.flags & OBS_OUTPUT_VIDEO) == 0)
 		return;
 
 	if (output->active) {
@@ -570,7 +610,9 @@ void obs_output_set_preferred_size(obs_output_t *output, uint32_t width,
 
 uint32_t obs_output_get_width(const obs_output_t *output)
 {
-	if (!output || (output->info.flags & OBS_OUTPUT_VIDEO) == 0)
+	if (!obs_output_valid(output, "obs_output_get_width"))
+		return 0;
+	if ((output->info.flags & OBS_OUTPUT_VIDEO) == 0)
 		return 0;
 
 	if (output->info.flags & OBS_OUTPUT_ENCODED)
@@ -583,7 +625,9 @@ uint32_t obs_output_get_width(const obs_output_t *output)
 
 uint32_t obs_output_get_height(const obs_output_t *output)
 {
-	if (!output || (output->info.flags & OBS_OUTPUT_VIDEO) == 0)
+	if (!obs_output_valid(output, "obs_output_get_height"))
+		return 0;
+	if ((output->info.flags & OBS_OUTPUT_VIDEO) == 0)
 		return 0;
 
 	if (output->info.flags & OBS_OUTPUT_ENCODED)
@@ -597,7 +641,10 @@ uint32_t obs_output_get_height(const obs_output_t *output)
 void obs_output_set_video_conversion(obs_output_t *output,
 		const struct video_scale_info *conversion)
 {
-	if (!output || !conversion) return;
+	if (!obs_output_valid(output, "obs_output_set_video_conversion"))
+		return;
+	if (!obs_ptr_valid(conversion, "obs_output_set_video_conversion"))
+		return;
 
 	output->video_conversion = *conversion;
 	output->video_conversion_set = true;
@@ -606,7 +653,10 @@ void obs_output_set_video_conversion(obs_output_t *output,
 void obs_output_set_audio_conversion(obs_output_t *output,
 		const struct audio_convert_info *conversion)
 {
-	if (!output || !conversion) return;
+	if (!obs_output_valid(output, "obs_output_set_audio_conversion"))
+		return;
+	if (!obs_ptr_valid(conversion, "obs_output_set_audio_conversion"))
+		return;
 
 	output->audio_conversion = *conversion;
 	output->audio_conversion_set = true;
@@ -1160,7 +1210,9 @@ bool obs_output_can_begin_data_capture(const obs_output_t *output,
 {
 	bool encoded, has_video, has_audio, has_service;
 
-	if (!output) return false;
+	if (!obs_output_valid(output, "obs_output_can_begin_data_capture"))
+		return false;
+
 	if (output->delay_active) return true;
 	if (output->active) return false;
 
@@ -1206,7 +1258,9 @@ bool obs_output_initialize_encoders(obs_output_t *output, uint32_t flags)
 	bool encoded, has_video, has_audio, has_service;
 	size_t num_mixes = num_audio_mixes(output);
 
-	if (!output) return false;
+	if (!obs_output_valid(output, "obs_output_initialize_encoders"))
+		return false;
+
 	if (output->active) return output->delay_active;
 
 	convert_flags(output, flags, &encoded, &has_video, &has_audio,
@@ -1254,7 +1308,9 @@ bool obs_output_begin_data_capture(obs_output_t *output, uint32_t flags)
 {
 	bool encoded, has_video, has_audio, has_service;
 
-	if (!output) return false;
+	if (!obs_output_valid(output, "obs_output_begin_data_capture"))
+		return false;
+
 	if (output->delay_active) return begin_delayed_capture(output);
 	if (output->active) return false;
 
@@ -1305,7 +1361,8 @@ void obs_output_end_data_capture(obs_output_t *output)
 	bool encoded, has_video, has_audio, has_service;
 	encoded_callback_t encoded_callback;
 
-	if (!output) return;
+	if (!obs_output_valid(output, "obs_output_end_data_capture"))
+		return;
 
 	if (output->delay_active) {
 		output->delay_capturing = false;
@@ -1415,7 +1472,7 @@ static void output_reconnect(struct obs_output *output)
 
 void obs_output_signal_stop(obs_output_t *output, int code)
 {
-	if (!output)
+	if (!obs_output_valid(output, "obs_output_signal_stop"))
 		return;
 
 	obs_output_end_data_capture(output);

libobs/obs-service.c

@@ -110,7 +110,8 @@ void obs_service_destroy(obs_service_t *service)
 
 const char *obs_service_get_name(const obs_service_t *service)
 {
-	return service ? service->context.name : NULL;
+	return obs_service_valid(service, "obs_service_get_name") ?
+		service->context.name : NULL;
 }
 
 static inline obs_data_t *get_defaults(const struct obs_service_info *info)
@@ -144,7 +145,10 @@ obs_properties_t *obs_get_service_properties(const char *id)
 
 obs_properties_t *obs_service_properties(const obs_service_t *service)
 {
-	if (service && service->info.get_properties) {
+	if (!obs_service_valid(service, "obs_service_properties"))
+		return NULL;
+
+	if (service->info.get_properties) {
 		obs_properties_t *props;
 		props = service->info.get_properties(service->context.data);
 		obs_properties_apply_settings(props, service->context.settings);
@@ -156,12 +160,14 @@ obs_properties_t *obs_service_properties(const obs_service_t *service)
 
 const char *obs_service_get_type(const obs_service_t *service)
 {
-	return service ? service->info.id : NULL;
+	return obs_service_valid(service, "obs_service_get_type") ?
+		service->info.id : NULL;
 }
 
 void obs_service_update(obs_service_t *service, obs_data_t *settings)
 {
-	if (!service) return;
+	if (!obs_service_valid(service, "obs_service_update"))
+		return;
 
 	obs_data_apply(service->context.settings, settings);
 
@@ -172,7 +178,7 @@ void obs_service_update(obs_service_t *service, obs_data_t *settings)
 
 obs_data_t *obs_service_get_settings(const obs_service_t *service)
 {
-	if (!service)
+	if (!obs_service_valid(service, "obs_service_get_settings"))
 		return NULL;
 
 	obs_data_addref(service->context.settings);
@@ -181,41 +187,64 @@ obs_data_t *obs_service_get_settings(const obs_service_t *service)
 
 signal_handler_t *obs_service_get_signal_handler(const obs_service_t *service)
 {
-	return service ? service->context.signals : NULL;
+	return obs_service_valid(service, "obs_service_get_signal_handler") ?
+		service->context.signals : NULL;
 }
 
 proc_handler_t *obs_service_get_proc_handler(const obs_service_t *service)
 {
-	return service ? service->context.procs : NULL;
+	return obs_service_valid(service, "obs_service_get_proc_handler") ?
+		service->context.procs : NULL;
 }
 
 const char *obs_service_get_url(const obs_service_t *service)
 {
-	if (!service || !service->info.get_url) return NULL;
+	if (!obs_service_valid(service, "obs_service_get_url"))
+		return NULL;
+
+	if (!service->info.get_url) return NULL;
 	return service->info.get_url(service->context.data);
 }
 
 const char *obs_service_get_key(const obs_service_t *service)
 {
-	if (!service || !service->info.get_key) return NULL;
+	if (!obs_service_valid(service, "obs_service_get_key"))
+		return NULL;
+
+	if (!service->info.get_key) return NULL;
 	return service->info.get_key(service->context.data);
 }
 
 const char *obs_service_get_username(const obs_service_t *service)
 {
-	if (!service || !service->info.get_username) return NULL;
+	if (!obs_service_valid(service, "obs_service_get_username"))
+		return NULL;
+
+	if (!service->info.get_username) return NULL;
 	return service->info.get_username(service->context.data);
 }
 
 const char *obs_service_get_password(const obs_service_t *service)
 {
-	if (!service || !service->info.get_password) return NULL;
+	if (!obs_service_valid(service, "obs_service_get_password"))
+		return NULL;
+
+	if (!service->info.get_password) return NULL;
 	return service->info.get_password(service->context.data);
 }
 
 void obs_service_activate(struct obs_service *service)
 {
-	if (!service || !service->output || service->active) return;
+	if (!obs_service_valid(service, "obs_service_activate"))
+		return;
+	if (!service->output) {
+		blog(LOG_WARNING, "obs_service_deactivate: service '%s' "
+				"is not assigned to an output",
+				obs_service_get_name(service));
+		return;
+	}
+	if (service->active)
+		return;
 
 	if (service->info.activate)
 		service->info.activate(service->context.data,
@@ -225,7 +254,16 @@ void obs_service_activate(struct obs_service *service)
 
 void obs_service_deactivate(struct obs_service *service, bool remove)
 {
-	if (!service || !service->output || !service->active) return;
+	if (!obs_service_valid(service, "obs_service_deactivate"))
+		return;
+	if (!service->output) {
+		blog(LOG_WARNING, "obs_service_deactivate: service '%s' "
+				"is not assigned to an output",
+				obs_service_get_name(service));
+		return;
+	}
+
+	if (!service->active) return;
 
 	if (service->info.deactivate)
 		service->info.deactivate(service->context.data);
@@ -240,7 +278,9 @@ void obs_service_deactivate(struct obs_service *service, bool remove)
 bool obs_service_initialize(struct obs_service *service,
 		struct obs_output *output)
 {
-	if (!service || !output)
+	if (!obs_service_valid(service, "obs_service_initialize"))
+		return false;
+	if (!obs_output_valid(output, "obs_service_initialize"))
 		return false;
 
 	if (service->info.initialize)
@@ -252,7 +292,9 @@ void obs_service_apply_encoder_settings(obs_service_t *service,
 		obs_data_t *video_encoder_settings,
 		obs_data_t *audio_encoder_settings)
 {
-	if (!service || !service->info.apply_encoder_settings)
+	if (!obs_service_valid(service, "obs_service_apply_encoder_settings"))
+		return;
+	if (!service->info.apply_encoder_settings)
 		return;
 
 	if (video_encoder_settings || audio_encoder_settings)

libobs/obs-source.c

@@ -312,7 +312,7 @@ void obs_source_frame_init(struct obs_source_frame *frame,
 {
 	struct video_frame vid_frame;
 
-	if (!frame)
+	if (!obs_ptr_valid(frame, "obs_source_frame_init"))
 		return;
 
 	video_frame_init(&vid_frame, format, width, height);
@@ -339,7 +339,7 @@ void obs_source_destroy(struct obs_source *source)
 {
 	size_t i;
 
-	if (!source)
+	if (!obs_source_valid(source, "obs_source_destroy"))
 		return;
 
 	if (source->info.type == OBS_SOURCE_TYPE_TRANSITION)
@@ -479,9 +479,12 @@ void obs_source_remove(obs_source_t *source)
 	size_t id;
 	bool   exists;
 
+	if (!obs_source_valid(source, "obs_source_remove"))
+		return;
+
 	pthread_mutex_lock(&data->sources_mutex);
 
-	if (!source || source->removed) {
+	if (source->removed) {
 		pthread_mutex_unlock(&data->sources_mutex);
 		return;
 	}
@@ -507,7 +510,8 @@ void obs_source_remove(obs_source_t *source)
 
 bool obs_source_removed(const obs_source_t *source)
 {
-	return source ? source->removed : true;
+	return obs_source_valid(source, "obs_source_removed") ?
+		source->removed : true;
 }
 
 static inline obs_data_t *get_defaults(const struct obs_source_info *info)
@@ -564,7 +568,8 @@ obs_properties_t *obs_source_properties(const obs_source_t *source)
 
 uint32_t obs_source_get_output_flags(const obs_source_t *source)
 {
-	return source ? source->info.output_flags : 0;
+	return obs_source_valid(source, "obs_source_get_output_flags") ?
+		source->info.output_flags : 0;
 }
 
 uint32_t obs_get_source_output_flags(enum obs_source_type type, const char *id)
@@ -584,7 +589,8 @@ static void obs_source_deferred_update(obs_source_t *source)
 
 void obs_source_update(obs_source_t *source, obs_data_t *settings)
 {
-	if (!source) return;
+	if (!obs_source_valid(source, "obs_source_update"))
+		return;
 
 	if (settings)
 		obs_data_apply(source->context.settings, settings);
@@ -601,7 +607,8 @@ void obs_source_update_properties(obs_source_t *source)
 {
 	calldata_t calldata;
 
-	if (!source) return;
+	if (!obs_source_valid(source, "obs_source_update_properties"))
+		return;
 
 	calldata_init(&calldata);
 	calldata_set_ptr(&calldata, "source", source);
@@ -617,7 +624,7 @@ void obs_source_send_mouse_click(obs_source_t *source,
 		int32_t type, bool mouse_up,
 		uint32_t click_count)
 {
-	if (!source)
+	if (!obs_source_valid(source, "obs_source_send_mouse_click"))
 		return;
 
 	if (source->info.output_flags & OBS_SOURCE_INTERACTION) {
@@ -631,7 +638,7 @@ void obs_source_send_mouse_click(obs_source_t *source,
 void obs_source_send_mouse_move(obs_source_t *source,
 		const struct obs_mouse_event *event, bool mouse_leave)
 {
-	if (!source)
+	if (!obs_source_valid(source, "obs_source_send_mouse_move"))
 		return;
 
 	if (source->info.output_flags & OBS_SOURCE_INTERACTION) {
@@ -645,7 +652,7 @@ void obs_source_send_mouse_move(obs_source_t *source,
 void obs_source_send_mouse_wheel(obs_source_t *source,
 		const struct obs_mouse_event *event, int x_delta, int y_delta)
 {
-	if (!source)
+	if (!obs_source_valid(source, "obs_source_send_mouse_wheel"))
 		return;
 
 	if (source->info.output_flags & OBS_SOURCE_INTERACTION) {
@@ -658,7 +665,7 @@ void obs_source_send_mouse_wheel(obs_source_t *source,
 
 void obs_source_send_focus(obs_source_t *source, bool focus)
 {
-	if (!source)
+	if (!obs_source_valid(source, "obs_source_send_focus"))
 		return;
 
 	if (source->info.output_flags & OBS_SOURCE_INTERACTION) {
@@ -671,7 +678,7 @@ void obs_source_send_focus(obs_source_t *source, bool focus)
 void obs_source_send_key_click(obs_source_t *source,
 		const struct obs_key_event *event, bool key_up)
 {
-	if (!source)
+	if (!obs_source_valid(source, "obs_source_send_key_click"))
 		return;
 
 	if (source->info.output_flags & OBS_SOURCE_INTERACTION) {
@@ -746,7 +753,8 @@ static void hide_tree(obs_source_t *parent, obs_source_t *child, void *param)
 
 void obs_source_activate(obs_source_t *source, enum view_type type)
 {
-	if (!source) return;
+	if (!obs_source_valid(source, "obs_source_activate"))
+		return;
 
 	if (os_atomic_inc_long(&source->show_refs) == 1) {
 		obs_source_enum_tree(source, show_tree, NULL);
@@ -761,7 +769,8 @@ void obs_source_activate(obs_source_t *source, enum view_type type)
 
 void obs_source_deactivate(obs_source_t *source, enum view_type type)
 {
-	if (!source) return;
+	if (!obs_source_valid(source, "obs_source_deactivate"))
+		return;
 
 	if (os_atomic_dec_long(&source->show_refs) == 0) {
 		obs_source_enum_tree(source, hide_tree, NULL);
@@ -783,7 +792,8 @@ void obs_source_video_tick(obs_source_t *source, float seconds)
 {
 	bool now_showing, now_active;
 
-	if (!source) return;
+	if (!obs_source_valid(source, "obs_source_video_tick"))
+		return;
 
 	if ((source->info.output_flags & OBS_SOURCE_ASYNC) != 0) {
 		uint64_t sys_time = obs->video.video_time;
@@ -1398,7 +1408,8 @@ static bool ready_async_frame(obs_source_t *source, uint64_t sys_time);
 
 void obs_source_video_render(obs_source_t *source)
 {
-	if (!source) return;
+	if (!obs_source_valid(source, "obs_source_video_render"))
+		return;
 
 	if (source->info.type != OBS_SOURCE_TYPE_FILTER &&
 	    (source->info.output_flags & OBS_SOURCE_VIDEO) == 0)
@@ -1519,19 +1530,23 @@ uint32_t obs_source_get_base_height(obs_source_t *source)
 
 obs_source_t *obs_filter_get_parent(const obs_source_t *filter)
 {
-	return filter ? filter->filter_parent : NULL;
+	return obs_ptr_valid(filter, "obs_filter_get_parent") ?
+		filter->filter_parent : NULL;
 }
 
 obs_source_t *obs_filter_get_target(const obs_source_t *filter)
 {
-	return filter ? filter->filter_target : NULL;
+	return obs_ptr_valid(filter, "obs_filter_get_target") ?
+		filter->filter_target : NULL;
 }
 
 void obs_source_filter_add(obs_source_t *source, obs_source_t *filter)
 {
 	struct calldata cd = {0};
 
-	if (!source || !filter)
+	if (!obs_source_valid(source, "obs_source_filter_add"))
+		return;
+	if (!obs_ptr_valid(filter, "obs_source_filter_add"))
 		return;
 
 	pthread_mutex_lock(&source->filter_mutex);
@@ -1567,9 +1582,6 @@ static bool obs_source_filter_remove_refless(obs_source_t *source,
 	struct calldata cd = {0};
 	size_t idx;
 
-	if (!source || !filter)
-		return false;
-
 	pthread_mutex_lock(&source->filter_mutex);
 
 	idx = da_find(source->filters, &filter, 0);
@@ -1605,6 +1617,11 @@ static bool obs_source_filter_remove_refless(obs_source_t *source,
 
 void obs_source_filter_remove(obs_source_t *source, obs_source_t *filter)
 {
+	if (!obs_source_valid(source, "obs_source_filter_remove"))
+		return;
+	if (!obs_ptr_valid(filter, "obs_source_filter_remove"))
+		return;
+
 	if (obs_source_filter_remove_refless(source, filter))
 		obs_source_release(filter);
 }
@@ -1695,7 +1712,10 @@ void obs_source_filter_set_order(obs_source_t *source, obs_source_t *filter,
 		enum obs_order_movement movement)
 {
 	bool success;
-	if (!source || !filter)
+
+	if (!obs_source_valid(source, "obs_source_filter_set_order"))
+		return;
+	if (!obs_ptr_valid(filter, "obs_source_filter_set_order"))
 		return;
 
 	pthread_mutex_lock(&source->filter_mutex);
@@ -1708,7 +1728,8 @@ void obs_source_filter_set_order(obs_source_t *source, obs_source_t *filter,
 
 obs_data_t *obs_source_get_settings(const obs_source_t *source)
 {
-	if (!source) return NULL;
+	if (!obs_source_valid(source, "obs_source_get_settings"))
+		return NULL;
 
 	obs_data_addref(source->context.settings);
 	return source->context.settings;
@@ -1909,7 +1930,7 @@ static inline struct obs_source_frame *cache_video(struct obs_source *source,
 void obs_source_output_video(obs_source_t *source,
 		const struct obs_source_frame *frame)
 {
-	if (!source)
+	if (!obs_source_valid(source, "obs_source_output_video"))
 		return;
 
 	if (!frame) {
@@ -2074,7 +2095,9 @@ void obs_source_output_audio(obs_source_t *source,
 {
 	struct obs_audio_data *output;
 
-	if (!source || !audio)
+	if (!obs_source_valid(source, "obs_source_output_audio"))
+		return;
+	if (!obs_ptr_valid(audio, "obs_source_output_audio"))
 		return;
 
 	process_audio(source, audio);
@@ -2239,7 +2262,7 @@ struct obs_source_frame *obs_source_get_frame(obs_source_t *source)
 {
 	struct obs_source_frame *frame = NULL;
 
-	if (!source)
+	if (!obs_source_valid(source, "obs_source_get_frame"))
 		return NULL;
 
 	pthread_mutex_lock(&source->async_mutex);
@@ -2259,7 +2282,7 @@ struct obs_source_frame *obs_source_get_frame(obs_source_t *source)
 void obs_source_release_frame(obs_source_t *source,
 		struct obs_source_frame *frame)
 {
-	if (!frame)
+	if (!obs_ptr_valid(frame, "obs_source_release_frame"))
 		return;
 
 	if (!source) {
@@ -2278,12 +2301,14 @@ void obs_source_release_frame(obs_source_t *source,
 
 const char *obs_source_get_name(const obs_source_t *source)
 {
-	return source ? source->context.name : NULL;
+	return obs_source_valid(source, "obs_source_get_name") ?
+		source->context.name : NULL;
 }
 
 void obs_source_set_name(obs_source_t *source, const char *name)
 {
-	if (!source) return;
+	if (!obs_source_valid(source, "obs_source_set_name"))
+		return;
 
 	if (!name || !*name || strcmp(name, source->context.name) != 0) {
 		struct calldata data;
@@ -2303,12 +2328,14 @@ void obs_source_set_name(obs_source_t *source, const char *name)
 
 enum obs_source_type obs_source_get_type(const obs_source_t *source)
 {
-	return source ? source->info.type : OBS_SOURCE_TYPE_INPUT;
+	return obs_source_valid(source, "obs_source_get_type") ?
+		source->info.type : OBS_SOURCE_TYPE_INPUT;
 }
 
 const char *obs_source_get_id(const obs_source_t *source)
 {
-	return source ? source->info.id : NULL;
+	return obs_source_valid(source, "obs_source_get_id") ?
+		source->info.id : NULL;
 }
 
 static inline void render_filter_bypass(obs_source_t *target,
@@ -2365,7 +2392,8 @@ void obs_source_process_filter_begin(obs_source_t *filter,
 	int          cx, cy;
 	bool         use_matrix;
 
-	if (!filter) return;
+	if (!obs_ptr_valid(filter, "obs_source_process_filter_begin"))
+		return;
 
 	target       = obs_filter_get_target(filter);
 	parent       = obs_filter_get_parent(filter);
@@ -2420,7 +2448,8 @@ void obs_source_process_filter_end(obs_source_t *filter, gs_effect_t *effect,
 	uint32_t     target_flags, parent_flags;
 	bool         use_matrix;
 
-	if (!filter) return;
+	if (!obs_ptr_valid(filter, "obs_source_process_filter_end"))
+		return;
 
 	target       = obs_filter_get_target(filter);
 	parent       = obs_filter_get_parent(filter);
@@ -2443,7 +2472,8 @@ void obs_source_skip_video_filter(obs_source_t *filter)
 	uint32_t parent_flags;
 	bool use_matrix;
 
-	if (!filter) return;
+	if (!obs_ptr_valid(filter, "obs_source_skip_video_filter"))
+		return;
 
 	target = obs_filter_get_target(filter);
 	parent = obs_filter_get_parent(filter);
@@ -2467,17 +2497,19 @@ void obs_source_skip_video_filter(obs_source_t *filter)
 
 signal_handler_t *obs_source_get_signal_handler(const obs_source_t *source)
 {
-	return source ? source->context.signals : NULL;
+	return obs_source_valid(source, "obs_source_get_signal_handler") ?
+		source->context.signals : NULL;
 }
 
 proc_handler_t *obs_source_get_proc_handler(const obs_source_t *source)
 {
-	return source ? source->context.procs : NULL;
+	return obs_source_valid(source, "obs_source_get_proc_handler") ?
+		source->context.procs : NULL;
 }
 
 void obs_source_set_volume(obs_source_t *source, float volume)
 {
-	if (source) {
+	if (obs_source_valid(source, "obs_source_set_volume")) {
 		struct calldata data = {0};
 		calldata_set_ptr(&data, "source", source);
 		calldata_set_float(&data, "volume", volume);
@@ -2503,23 +2535,25 @@ static void set_tree_preset_vol(obs_source_t *parent, obs_source_t *child,
 
 void obs_source_set_present_volume(obs_source_t *source, float volume)
 {
-	if (source)
+	if (obs_source_valid(source, "obs_source_set_present_volume"))
 		source->present_volume = volume;
 }
 
 float obs_source_get_volume(const obs_source_t *source)
 {
-	return source ? source->user_volume : 0.0f;
+	return obs_source_valid(source, "obs_source_get_volume") ?
+		source->user_volume : 0.0f;
 }
 
 float obs_source_get_present_volume(const obs_source_t *source)
 {
-	return source ? source->present_volume : 0.0f;
+	return obs_source_valid(source, "obs_source_get_present_volume") ?
+		source->present_volume : 0.0f;
 }
 
 void obs_source_set_sync_offset(obs_source_t *source, int64_t offset)
 {
-	if (source) {
+	if (obs_source_valid(source, "obs_source_set_sync_offset")) {
 		struct calldata data = {0};
 
 		calldata_set_ptr(&data, "source", source);
@@ -2535,7 +2569,8 @@ void obs_source_set_sync_offset(obs_source_t *source, int64_t offset)
 
 int64_t obs_source_get_sync_offset(const obs_source_t *source)
 {
-	return source ? source->sync_offset : 0;
+	return obs_source_valid(source, "obs_source_get_sync_offset") ?
+		source->sync_offset : 0;
 }
 
 struct source_enum_data {
@@ -2610,7 +2645,15 @@ static void check_descendant(obs_source_t *parent, obs_source_t *child,
 bool obs_source_add_child(obs_source_t *parent, obs_source_t *child)
 {
 	struct descendant_info info = {false, parent};
-	if (!parent || !child || parent == child) return false;
+
+	if (!obs_ptr_valid(parent, "obs_source_add_child"))
+		return false;
+	if (!obs_ptr_valid(parent, "obs_source_add_child"))
+		return false;
+	if (parent == child) {
+		blog(LOG_WARNING, "obs_source_add_child: parent == child");
+		return false;
+	}
 
 	obs_source_enum_tree(child, check_descendant, &info);
 	if (info.exists)
@@ -2627,7 +2670,10 @@ bool obs_source_add_child(obs_source_t *parent, obs_source_t *child)
 
 void obs_source_remove_child(obs_source_t *parent, obs_source_t *child)
 {
-	if (!parent || !child) return;
+	if (!obs_ptr_valid(parent, "obs_source_remove_child"))
+		return;
+	if (!obs_ptr_valid(parent, "obs_source_remove_child"))
+		return;
 
 	for (int i = 0; i < parent->show_refs; i++) {
 		enum view_type type;
@@ -2658,12 +2704,14 @@ void obs_source_load(obs_source_t *source)
 
 bool obs_source_active(const obs_source_t *source)
 {
-	return source ? source->activate_refs != 0 : false;
+	return obs_source_valid(source, "obs_source_active") ?
+		source->activate_refs != 0 : false;
 }
 
 bool obs_source_showing(const obs_source_t *source)
 {
-	return source ? source->show_refs != 0 : false;
+	return obs_source_valid(source, "obs_source_showing") ?
+		source->show_refs != 0 : false;
 }
 
 static inline void signal_flags_updated(obs_source_t *source)
@@ -2680,7 +2728,8 @@ static inline void signal_flags_updated(obs_source_t *source)
 
 void obs_source_set_flags(obs_source_t *source, uint32_t flags)
 {
-	if (!source) return;
+	if (!obs_source_valid(source, "obs_source_set_flags"))
+		return;
 
 	if (flags != source->flags) {
 		source->flags = flags;
@@ -2690,14 +2739,16 @@ void obs_source_set_flags(obs_source_t *source, uint32_t flags)
 
 void obs_source_set_default_flags(obs_source_t *source, uint32_t flags)
 {
-	if (!source) return;
+	if (!obs_source_valid(source, "obs_source_set_default_flags"))
+		return;
 
 	source->default_flags = flags;
 }
 
 uint32_t obs_source_get_flags(const obs_source_t *source)
 {
-	return source ? source->flags : 0;
+	return obs_source_valid(source, "obs_source_get_flags") ?
+		source->flags : 0;
 }
 
 void obs_source_set_audio_mixers(obs_source_t *source, uint32_t mixers)
@@ -2705,8 +2756,10 @@ void obs_source_set_audio_mixers(obs_source_t *source, uint32_t mixers)
 	struct calldata data = {0};
 	uint32_t cur_mixers;
 
-	if (!source) return;
-	if ((source->info.output_flags & OBS_SOURCE_AUDIO) == 0) return;
+	if (!obs_source_valid(source, "obs_source_set_audio_mixers"))
+		return;
+	if ((source->info.output_flags & OBS_SOURCE_AUDIO) == 0)
+		return;
 
 	cur_mixers = audio_line_get_mixers(source->audio_line);
 	if (cur_mixers == mixers)
@@ -2725,8 +2778,10 @@ void obs_source_set_audio_mixers(obs_source_t *source, uint32_t mixers)
 
 uint32_t obs_source_get_audio_mixers(const obs_source_t *source)
 {
-	if (!source) return 0;
-	if ((source->info.output_flags & OBS_SOURCE_AUDIO) == 0) return 0;
+	if (!obs_source_valid(source, "obs_source_get_audio_mixers"))
+		return 0;
+	if ((source->info.output_flags & OBS_SOURCE_AUDIO) == 0)
+		return 0;
 
 	return audio_line_get_mixers(source->audio_line);
 }
@@ -2747,16 +2802,13 @@ void obs_source_draw_set_color_matrix(const struct matrix4 *color_matrix,
 	gs_eparam_t *range_max;
 
 	if (!effect) {
-		blog(LOG_WARNING, "obs_source_draw_set_color_matrix: NULL "
-				"effect");
+		blog(LOG_WARNING, "obs_source_draw_set_color_matrix: no "
+				"active effect!");
 		return;
 	}
 
-	if (!color_matrix) {
-		blog(LOG_WARNING, "obs_source_draw_set_color_matrix: NULL "
-				"color_matrix");
+	if (!obs_ptr_valid(color_matrix, "obs_source_draw_set_color_matrix"))
 		return;
-	}
 
 	if (!color_range_min)
 		color_range_min = &color_range_min_def;
@@ -2780,14 +2832,12 @@ void obs_source_draw(gs_texture_t *texture, int x, int y, uint32_t cx,
 	gs_eparam_t *image;
 
 	if (!effect) {
-		blog(LOG_WARNING, "obs_source_draw: NULL effect");
+		blog(LOG_WARNING, "obs_source_draw: no active effect!");
 		return;
 	}
 
-	if (!texture) {
-		blog(LOG_WARNING, "obs_source_draw: NULL texture");
+	if (!obs_ptr_valid(texture, "obs_source_draw"))
 		return;
-	}
 
 	image = gs_effect_get_param_by_name(effect, "image");
 	gs_effect_set_texture(image, texture);
@@ -2851,7 +2901,14 @@ static void get_source_base_vol(obs_source_t *parent, obs_source_t *child,
 float obs_source_get_target_volume(obs_source_t *source, obs_source_t *target)
 {
 	struct base_vol_enum_info info = {target, 0.0f};
-	bool transition = source->info.type == OBS_SOURCE_TYPE_TRANSITION;
+	bool transition;
+
+	if (!obs_source_valid(source, "obs_source_get_target_volume"))
+		return 0.0f;
+	if (!obs_ptr_valid(target, "obs_source_get_target_volume"))
+		return 0.0f;
+
+	transition = source->info.type == OBS_SOURCE_TYPE_TRANSITION;
 
 	if (source == target)
 		return 1.0f;
@@ -2869,18 +2926,22 @@ float obs_source_get_target_volume(obs_source_t *source, obs_source_t *target)
 
 void obs_source_inc_showing(obs_source_t *source)
 {
-	obs_source_activate(source, AUX_VIEW);
+	if (obs_source_valid(source, "obs_source_inc_showing"))
+		obs_source_activate(source, AUX_VIEW);
 }
 
 void obs_source_dec_showing(obs_source_t *source)
 {
-	obs_source_deactivate(source, AUX_VIEW);
+	if (obs_source_valid(source, "obs_source_dec_showing"))
+		obs_source_deactivate(source, AUX_VIEW);
 }
 
 void obs_source_enum_filters(obs_source_t *source,
 		obs_source_enum_proc_t callback, void *param)
 {
-	if (!source || !callback)
+	if (!obs_source_valid(source, "obs_source_enum_filters"))
+		return;
+	if (!obs_ptr_valid(callback, "obs_source_enum_filters"))
 		return;
 
 	pthread_mutex_lock(&source->filter_mutex);
@@ -2898,7 +2959,9 @@ obs_source_t *obs_source_get_filter_by_name(obs_source_t *source,
 {
 	obs_source_t *filter = NULL;
 
-	if (!source || !name)
+	if (!obs_source_valid(source, "obs_source_get_filter_by_name"))
+		return NULL;
+	if (!obs_ptr_valid(name, "obs_source_get_filter_by_name"))
 		return NULL;
 
 	pthread_mutex_lock(&source->filter_mutex);
@@ -2919,14 +2982,15 @@ obs_source_t *obs_source_get_filter_by_name(obs_source_t *source,
 
 bool obs_source_enabled(const obs_source_t *source)
 {
-	return source ? source->enabled : false;
+	return obs_source_valid(source, "obs_source_enabled") ?
+		source->enabled : false;
 }
 
 void obs_source_set_enabled(obs_source_t *source, bool enabled)
 {
 	struct calldata data = {0};
 
-	if (!source)
+	if (!obs_source_valid(source, "obs_source_set_enabled"))
 		return;
 
 	source->enabled = enabled;
@@ -2941,14 +3005,15 @@ void obs_source_set_enabled(obs_source_t *source, bool enabled)
 
 bool obs_source_muted(const obs_source_t *source)
 {
-	return source ? source->muted : false;
+	return obs_source_valid(source, "obs_source_muted") ?
+		source->muted : false;
 }
 
 void obs_source_set_muted(obs_source_t *source, bool muted)
 {
 	struct calldata data = {0};
 
-	if (!source)
+	if (!obs_source_valid(source, "obs_source_set_muted"))
 		return;
 
 	source->muted = muted;
@@ -2988,7 +3053,8 @@ static void source_signal_push_to_delay(obs_source_t *source,
 bool obs_source_push_to_mute_enabled(obs_source_t *source)
 {
 	bool enabled;
-	if (!source) return false;
+	if (!obs_source_valid(source, "obs_source_push_to_mute_enabled"))
+		return false;
 
 	pthread_mutex_lock(&source->audio_mutex);
 	enabled = source->push_to_mute_enabled;
@@ -2999,7 +3065,8 @@ bool obs_source_push_to_mute_enabled(obs_source_t *source)
 
 void obs_source_enable_push_to_mute(obs_source_t *source, bool enabled)
 {
-	if (!source) return;
+	if (!obs_source_valid(source, "obs_source_enable_push_to_mute"))
+		return;
 
 	pthread_mutex_lock(&source->audio_mutex);
 	bool changed = source->push_to_mute_enabled != enabled;
@@ -3019,7 +3086,8 @@ void obs_source_enable_push_to_mute(obs_source_t *source, bool enabled)
 uint64_t obs_source_get_push_to_mute_delay(obs_source_t *source)
 {
 	uint64_t delay;
-	if (!source) return 0;
+	if (!obs_source_valid(source, "obs_source_get_push_to_mute_delay"))
+		return 0;
 
 	pthread_mutex_lock(&source->audio_mutex);
 	delay = source->push_to_mute_delay;
@@ -3030,7 +3098,8 @@ uint64_t obs_source_get_push_to_mute_delay(obs_source_t *source)
 
 void obs_source_set_push_to_mute_delay(obs_source_t *source, uint64_t delay)
 {
-	if (!source) return;
+	if (!obs_source_valid(source, "obs_source_set_push_to_mute_delay"))
+		return;
 
 	pthread_mutex_lock(&source->audio_mutex);
 	source->push_to_mute_delay = delay;
@@ -3042,7 +3111,8 @@ void obs_source_set_push_to_mute_delay(obs_source_t *source, uint64_t delay)
 bool obs_source_push_to_talk_enabled(obs_source_t *source)
 {
 	bool enabled;
-	if (!source) return false;
+	if (!obs_source_valid(source, "obs_source_push_to_talk_enabled"))
+		return false;
 
 	pthread_mutex_lock(&source->audio_mutex);
 	enabled = source->push_to_talk_enabled;
@@ -3053,7 +3123,8 @@ bool obs_source_push_to_talk_enabled(obs_source_t *source)
 
 void obs_source_enable_push_to_talk(obs_source_t *source, bool enabled)
 {
-	if (!source) return;
+	if (!obs_source_valid(source, "obs_source_enable_push_to_talk"))
+		return;
 
 	pthread_mutex_lock(&source->audio_mutex);
 	bool changed = source->push_to_talk_enabled != enabled;
@@ -3073,7 +3144,8 @@ void obs_source_enable_push_to_talk(obs_source_t *source, bool enabled)
 uint64_t obs_source_get_push_to_talk_delay(obs_source_t *source)
 {
 	uint64_t delay;
-	if (!source) return 0;
+	if (!obs_source_valid(source, "obs_source_get_push_to_talk_delay"))
+		return 0;
 
 	pthread_mutex_lock(&source->audio_mutex);
 	delay = source->push_to_talk_delay;
@@ -3084,7 +3156,8 @@ uint64_t obs_source_get_push_to_talk_delay(obs_source_t *source)
 
 void obs_source_set_push_to_talk_delay(obs_source_t *source, uint64_t delay)
 {
-	if (!source) return;
+	if (!obs_source_valid(source, "obs_source_set_push_to_talk_delay"))
+		return;
 
 	pthread_mutex_lock(&source->audio_mutex);
 	source->push_to_talk_delay = delay;