(API Change) media-io: Improve naming consistency

Renamed:                        To:
-----------------------------------------------------------
audio_output_blocksize          audio_output_get_block_size
audio_output_planes             audio_output_get_planes
audio_output_channels           audio_output_get_channels
audio_output_samplerate         audio_output_get_sample_rate
audio_output_getinfo            audio_output_get_info
audio_output_createline         audio_output_create_line
video_output_getinfo            video_output_get_info
video_gettime                   video_output_get_time
video_getframetime              video_output_get_frame_time
video_output_width              video_output_get_width
video_output_height             video_output_get_height
video_output_framerate          video_output_get_frame_rate
video_output_num_skipped_frames video_output_get_skipped_frames
video_output_total_frames       video_output_get_total_frames

libobs/media-io/audio-io.c

@@ -551,7 +551,7 @@ void audio_output_close(audio_t audio)
 	bfree(audio);
 }
 
-audio_line_t audio_output_createline(audio_t audio, const char *name)
+audio_line_t audio_output_create_line(audio_t audio, const char *name)
 {
 	if (!audio) return NULL;
 
@@ -582,7 +582,7 @@ audio_line_t audio_output_createline(audio_t audio, const char *name)
 	return line;
 }
 
-const struct audio_output_info *audio_output_getinfo(audio_t audio)
+const struct audio_output_info *audio_output_get_info(audio_t audio)
 {
 	return audio ? &audio->info : NULL;
 }
@@ -603,22 +603,22 @@ bool audio_output_active(audio_t audio)
 	return audio->inputs.num != 0;
 }
 
-size_t audio_output_blocksize(audio_t audio)
+size_t audio_output_get_block_size(audio_t audio)
 {
 	return audio ? audio->block_size : 0;
 }
 
-size_t audio_output_planes(audio_t audio)
+size_t audio_output_get_planes(audio_t audio)
 {
 	return audio ? audio->planes : 0;
 }
 
-size_t audio_output_channels(audio_t audio)
+size_t audio_output_get_channels(audio_t audio)
 {
 	return audio ? audio->channels : 0;
 }
 
-uint32_t audio_output_samplerate(audio_t audio)
+uint32_t audio_output_get_sample_rate(audio_t audio)
 {
 	return audio ? audio->info.samples_per_sec : 0;
 }

libobs/media-io/audio-io.h

@@ -182,13 +182,13 @@ EXPORT void audio_output_disconnect(audio_t video,
 
 EXPORT bool audio_output_active(audio_t audio);
 
-EXPORT size_t audio_output_blocksize(audio_t audio);
-EXPORT size_t audio_output_planes(audio_t audio);
-EXPORT size_t audio_output_channels(audio_t audio);
-EXPORT uint32_t audio_output_samplerate(audio_t audio);
-EXPORT const struct audio_output_info *audio_output_getinfo(audio_t audio);
+EXPORT size_t audio_output_get_block_size(audio_t audio);
+EXPORT size_t audio_output_get_planes(audio_t audio);
+EXPORT size_t audio_output_get_channels(audio_t audio);
+EXPORT uint32_t audio_output_get_sample_rate(audio_t audio);
+EXPORT const struct audio_output_info *audio_output_get_info(audio_t audio);
 
-EXPORT audio_line_t audio_output_createline(audio_t audio, const char *name);
+EXPORT audio_line_t audio_output_create_line(audio_t audio, const char *name);
 EXPORT void audio_line_destroy(audio_line_t line);
 EXPORT void audio_line_output(audio_line_t line, const struct audio_data *data);
 

libobs/media-io/video-io.c

@@ -346,7 +346,7 @@ bool video_output_active(video_t video)
 	return video->inputs.num != 0;
 }
 
-const struct video_output_info *video_output_getinfo(video_t video)
+const struct video_output_info *video_output_get_info(video_t video)
 {
 	return video ? &video->info : NULL;
 }
@@ -369,12 +369,12 @@ bool video_output_wait(video_t video)
 	return os_event_try(video->stop_event) == EAGAIN;
 }
 
-uint64_t video_getframetime(video_t video)
+uint64_t video_output_get_frame_time(video_t video)
 {
 	return video ? video->frame_time : 0;
 }
 
-uint64_t video_gettime(video_t video)
+uint64_t video_output_get_time(video_t video)
 {
 	return video ? video->cur_video_time : 0;
 }
@@ -394,17 +394,17 @@ void video_output_stop(video_t video)
 	}
 }
 
-uint32_t video_output_width(video_t video)
+uint32_t video_output_get_width(video_t video)
 {
 	return video ? video->info.width : 0;
 }
 
-uint32_t video_output_height(video_t video)
+uint32_t video_output_get_height(video_t video)
 {
 	return video ? video->info.height : 0;
 }
 
-double video_output_framerate(video_t video)
+double video_output_get_frame_rate(video_t video)
 {
 	if (!video)
 		return 0.0;
@@ -412,12 +412,12 @@ double video_output_framerate(video_t video)
 	return (double)video->info.fps_num / (double)video->info.fps_den;
 }
 
-uint32_t video_output_num_skipped_frames(video_t video)
+uint32_t video_output_get_skipped_frames(video_t video)
 {
 	return video->skipped_frames;
 }
 
-uint32_t video_output_total_frames(video_t video)
+uint32_t video_output_get_total_frames(video_t video)
 {
 	return video->total_frames;
 }

libobs/media-io/video-io.h

@@ -132,19 +132,19 @@ EXPORT void video_output_disconnect(video_t video,
 
 EXPORT bool video_output_active(video_t video);
 
-EXPORT const struct video_output_info *video_output_getinfo(video_t video);
+EXPORT const struct video_output_info *video_output_get_info(video_t video);
 EXPORT void video_output_swap_frame(video_t video, struct video_data *frame);
 EXPORT bool video_output_wait(video_t video);
-EXPORT uint64_t video_getframetime(video_t video);
-EXPORT uint64_t video_gettime(video_t video);
+EXPORT uint64_t video_output_get_frame_time(video_t video);
+EXPORT uint64_t video_output_get_time(video_t video);
 EXPORT void video_output_stop(video_t video);
 
-EXPORT uint32_t video_output_width(video_t video);
-EXPORT uint32_t video_output_height(video_t video);
-EXPORT double video_output_framerate(video_t video);
+EXPORT uint32_t video_output_get_width(video_t video);
+EXPORT uint32_t video_output_get_height(video_t video);
+EXPORT double video_output_get_frame_rate(video_t video);
 
-EXPORT uint32_t video_output_num_skipped_frames(video_t video);
-EXPORT uint32_t video_output_total_frames(video_t video);
+EXPORT uint32_t video_output_get_skipped_frames(video_t video);
+EXPORT uint32_t video_output_get_total_frames(video_t video);
 
 
 #ifdef __cplusplus

libobs/obs-encoder.c

@@ -104,7 +104,7 @@ static inline struct audio_convert_info *get_audio_info(
 		struct obs_encoder *encoder, struct audio_convert_info *info)
 {
 	const struct audio_output_info *aoi;
-	aoi = audio_output_getinfo(encoder->media);
+	aoi = audio_output_get_info(encoder->media);
 	memset(info, 0, sizeof(struct audio_convert_info));
 
 	if (encoder->info.get_audio_info)
@@ -417,7 +417,7 @@ void obs_encoder_set_video(obs_encoder_t encoder, video_t video)
 	if (!video || !encoder || encoder->info.type != OBS_ENCODER_VIDEO)
 		return;
 
-	voi = video_output_getinfo(video);
+	voi = video_output_get_info(video);
 
 	encoder->media        = video;
 	encoder->timebase_num = voi->fps_den;
@@ -431,7 +431,7 @@ void obs_encoder_set_audio(obs_encoder_t encoder, audio_t audio)
 
 	encoder->media        = audio;
 	encoder->timebase_num = 1;
-	encoder->timebase_den = audio_output_samplerate(audio);
+	encoder->timebase_den = audio_output_get_sample_rate(audio);
 }
 
 video_t obs_encoder_video(obs_encoder_t encoder)

libobs/obs-source.c

@@ -122,7 +122,7 @@ bool obs_source_init(struct obs_source *source,
 		return false;
 
 	if (info && info->output_flags & OBS_SOURCE_AUDIO) {
-		source->audio_line = audio_output_createline(obs->audio.audio,
+		source->audio_line = audio_output_create_line(obs->audio.audio,
 				source->context.name);
 		if (!source->audio_line) {
 			blog(LOG_ERROR, "Failed to create audio line for "
@@ -509,7 +509,7 @@ void obs_source_video_tick(obs_source_t source, float seconds)
 static inline uint64_t conv_frames_to_time(size_t frames)
 {
 	const struct audio_output_info *info;
-	info = audio_output_getinfo(obs->audio.audio);
+	info = audio_output_get_info(obs->audio.audio);
 
 	return (uint64_t)frames * 1000000000ULL /
 		(uint64_t)info->samples_per_sec;
@@ -560,8 +560,8 @@ static void calc_volume_levels(struct obs_source *source, float *array,
 	float rms_val = 0.0f;
 
 	audio_t        audio          = obs_get_audio();
-	const uint32_t sample_rate    = audio_output_samplerate(audio);
-	const size_t   channels       = audio_output_channels(audio);
+	const uint32_t sample_rate    = audio_output_get_sample_rate(audio);
+	const size_t   channels       = audio_output_get_channels(audio);
 	const size_t   count          = frames * channels;
 	const size_t   vol_peak_delay = sample_rate * 3;
 	const float    alpha          = 0.15f;
@@ -1380,7 +1380,7 @@ static inline void reset_resampler(obs_source_t source,
 	const struct audio_output_info *obs_info;
 	struct resample_info output_info;
 
-	obs_info = audio_output_getinfo(obs->audio.audio);
+	obs_info = audio_output_get_info(obs->audio.audio);
 
 	output_info.format           = obs_info->format;
 	output_info.samples_per_sec  = obs_info->samples_per_sec;
@@ -1409,8 +1409,8 @@ static inline void reset_resampler(obs_source_t source,
 static inline void copy_audio_data(obs_source_t source,
 		const uint8_t *const data[], uint32_t frames, uint64_t ts)
 {
-	size_t planes    = audio_output_planes(obs->audio.audio);
-	size_t blocksize = audio_output_blocksize(obs->audio.audio);
+	size_t planes    = audio_output_get_planes(obs->audio.audio);
+	size_t blocksize = audio_output_get_block_size(obs->audio.audio);
 	size_t size      = (size_t)frames * blocksize;
 	bool   resize    = source->audio_storage_size < size;
 

libobs/obs-video.c

@@ -28,7 +28,9 @@ static uint64_t tick_sources(uint64_t cur_time, uint64_t last_time)
 	float                seconds;
 
 	if (!last_time)
-		last_time = cur_time - video_getframetime(obs->video.video);
+		last_time = cur_time -
+			video_output_get_frame_time(obs->video.video);
+
 	delta_time = cur_time - last_time;
 	seconds = (float)((double)delta_time / 1000000000.0);
 
@@ -386,7 +388,7 @@ static inline void output_video_data(struct obs_core_video *video,
 		struct video_data *frame, int cur_texture)
 {
 	const struct video_output_info *info;
-	info = video_output_getinfo(video->video);
+	info = video_output_get_info(video->video);
 
 	if (video->gpu_conversion) {
 		if (!set_gpu_converted_data(video, frame, cur_texture))
@@ -430,7 +432,7 @@ void *obs_video_thread(void *param)
 	uint64_t last_time = 0;
 
 	while (video_output_wait(obs->video.video)) {
-		uint64_t cur_time = video_gettime(obs->video.video);
+		uint64_t cur_time = video_output_get_time(obs->video.video);
 
 		last_time = tick_sources(cur_time, last_time);
 

libobs/obs.c

@@ -314,9 +314,10 @@ static void obs_free_video(void)
 	struct obs_core_video *video = &obs->video;
 
 	if (video->video) {
-		uint32_t total_frames = video_output_total_frames(video->video);
+		uint32_t total_frames =
+			video_output_get_total_frames(video->video);
 		uint32_t skipped_frames =
-			video_output_num_skipped_frames(video->video);
+			video_output_get_skipped_frames(video->video);
 		double percentage_skipped =
 			(double)skipped_frames / (double)total_frames * 100.0;
 
@@ -720,7 +721,7 @@ bool obs_get_video_info(struct obs_video_info *ovi)
 	if (!obs || !video->graphics)
 		return false;
 
-	info = video_output_getinfo(video->video);
+	info = video_output_get_info(video->video);
 
 	memset(ovi, 0, sizeof(struct obs_video_info));
 	ovi->base_width    = video->base_width;
@@ -742,7 +743,7 @@ bool obs_get_audio_info(struct audio_output_info *aoi)
 	if (!obs || !audio->audio)
 		return false;
 
-	info = audio_output_getinfo(audio->audio);
+	info = audio_output_get_info(audio->audio);
 	memcpy(aoi, info, sizeof(struct audio_output_info));
 
 	return true;

plugins/obs-ffmpeg/obs-ffmpeg-aac.c

@@ -114,7 +114,7 @@ static void init_sizes(struct aac_encoder *enc, audio_t audio)
 	const struct audio_output_info *aoi;
 	enum audio_format format;
 
-	aoi    = audio_output_getinfo(audio);
+	aoi    = audio_output_get_info(audio);
 	format = convert_ffmpeg_sample_format(enc->context->sample_fmt);
 
 	enc->audio_planes = get_audio_planes(format, aoi->speakers);
@@ -151,8 +151,8 @@ static void *aac_create(obs_data_t settings, obs_encoder_t encoder)
 	}
 
 	enc->context->bit_rate    = bitrate * 1000;
-	enc->context->channels    = (int)audio_output_channels(audio);
-	enc->context->sample_rate = audio_output_samplerate(audio);
+	enc->context->channels    = (int)audio_output_get_channels(audio);
+	enc->context->sample_rate = audio_output_get_sample_rate(audio);
 	enc->context->sample_fmt  = enc->aac->sample_fmts ?
 		enc->aac->sample_fmts[0] : AV_SAMPLE_FMT_FLTP;
 

plugins/obs-libfdk/obs-libfdk.c

@@ -106,8 +106,8 @@ static void *libfdk_create(obs_data_t settings, obs_encoder_t encoder)
 	enc = bzalloc(sizeof(libfdk_encoder_t));
 	enc->encoder = encoder;
 
-	enc->channels = (int)audio_output_channels(audio);
-	enc->sample_rate = audio_output_samplerate(audio);
+	enc->channels = (int)audio_output_get_channels(audio);
+	enc->sample_rate = audio_output_get_sample_rate(audio);
 
 	switch(enc->channels) {
 	case 1:

plugins/obs-outputs/flv-mux.c

@@ -76,21 +76,22 @@ static void build_flv_meta_data(obs_output_t context,
 	enc_num_val(&enc, end, "duration", 0.0);
 	enc_num_val(&enc, end, "fileSize", 0.0);
 
-	enc_num_val(&enc, end, "width",  (double)video_output_width(video));
-	enc_num_val(&enc, end, "height", (double)video_output_height(video));
+	enc_num_val(&enc, end, "width", (double)video_output_get_width(video));
+	enc_num_val(&enc, end, "height",(double)video_output_get_height(video));
 	enc_str_val(&enc, end, "videocodecid", "avc1");
 	enc_num_val(&enc, end, "videodatarate", encoder_bitrate(vencoder));
-	enc_num_val(&enc, end, "framerate", video_output_framerate(video));
+	enc_num_val(&enc, end, "framerate", video_output_get_frame_rate(video));
 
 	enc_str_val(&enc, end, "audiocodecid", "mp4a");
 	enc_num_val(&enc, end, "audiodatarate", encoder_bitrate(aencoder));
 	enc_num_val(&enc, end, "audiosamplerate",
-			(double)audio_output_samplerate(audio));
+			(double)audio_output_get_sample_rate(audio));
 	enc_num_val(&enc, end, "audiosamplesize", 16.0);
 	enc_num_val(&enc, end, "audiochannels",
-			(double)audio_output_channels(audio));
+			(double)audio_output_get_channels(audio));
 
-	enc_bool_val(&enc, end, "stereo", audio_output_channels(audio) == 2);
+	enc_bool_val(&enc, end, "stereo",
+			audio_output_get_channels(audio) == 2);
 
 	dstr_printf(&encoder_name, "%s (libobs version ",
 			MODULE_NAME);

plugins/obs-x264/obs-x264.c

@@ -235,7 +235,7 @@ static void update_params(struct obs_x264 *obsx264, obs_data_t settings,
 		char **params)
 {
 	video_t video = obs_encoder_video(obsx264->encoder);
-	const struct video_output_info *voi = video_output_getinfo(video);
+	const struct video_output_info *voi = video_output_get_info(video);
 
 	int bitrate      = (int)obs_data_get_int(settings, "bitrate");
 	int buffer_size  = (int)obs_data_get_int(settings, "buffer_size");
@@ -496,7 +496,7 @@ static bool obs_x264_video_info(void *data, struct video_scale_info *info)
 {
 	struct obs_x264 *obsx264 = data;
 	video_t video = obs_encoder_video(obsx264->encoder);
-	const struct video_output_info *vid_info = video_output_getinfo(video);
+	const struct video_output_info *vid_info = video_output_get_info(video);
 
 	if (vid_info->format == VIDEO_FORMAT_I420 ||
 	    vid_info->format == VIDEO_FORMAT_NV12)