noobs 0.0.6

package/include/media-io/video-frame.h

@@ -0,0 +1,64 @@
+/******************************************************************************
+    Copyright (C) 2023 by Lain Bailey <lain@obsproject.com>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+******************************************************************************/
+
+#pragma once
+
+#include "../util/bmem.h"
+#include "video-io.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct video_frame {
+	uint8_t *data[MAX_AV_PLANES];
+	uint32_t linesize[MAX_AV_PLANES];
+};
+
+EXPORT void video_frame_init(struct video_frame *frame, enum video_format format, uint32_t width, uint32_t height);
+
+static inline void video_frame_free(struct video_frame *frame)
+{
+	if (frame) {
+		bfree(frame->data[0]);
+		memset(frame, 0, sizeof(struct video_frame));
+	}
+}
+
+static inline struct video_frame *video_frame_create(enum video_format format, uint32_t width, uint32_t height)
+{
+	struct video_frame *frame;
+
+	frame = (struct video_frame *)bzalloc(sizeof(struct video_frame));
+	video_frame_init(frame, format, width, height);
+	return frame;
+}
+
+static inline void video_frame_destroy(struct video_frame *frame)
+{
+	if (frame) {
+		bfree(frame->data[0]);
+		bfree(frame);
+	}
+}
+
+EXPORT void video_frame_copy(struct video_frame *dst, const struct video_frame *src, enum video_format format,
+			     uint32_t height);
+
+#ifdef __cplusplus
+}
+#endif

package/include/media-io/video-io.h

@@ -0,0 +1,338 @@
+/******************************************************************************
+    Copyright (C) 2023 by Lain Bailey <lain@obsproject.com>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+******************************************************************************/
+
+#pragma once
+
+#include "media-io-defs.h"
+#include "../util/c99defs.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct video_frame;
+
+/* Base video output component.  Use this to create a video output track. */
+
+struct video_output;
+typedef struct video_output video_t;
+
+enum video_format {
+	VIDEO_FORMAT_NONE,
+
+	/* planar 4:2:0 formats */
+	VIDEO_FORMAT_I420, /* three-plane */
+	VIDEO_FORMAT_NV12, /* two-plane, luma and packed chroma */
+
+	/* packed 4:2:2 formats */
+	VIDEO_FORMAT_YVYU,
+	VIDEO_FORMAT_YUY2, /* YUYV */
+	VIDEO_FORMAT_UYVY,
+
+	/* packed uncompressed formats */
+	VIDEO_FORMAT_RGBA,
+	VIDEO_FORMAT_BGRA,
+	VIDEO_FORMAT_BGRX,
+	VIDEO_FORMAT_Y800, /* grayscale */
+
+	/* planar 4:4:4 */
+	VIDEO_FORMAT_I444,
+
+	/* more packed uncompressed formats */
+	VIDEO_FORMAT_BGR3,
+
+	/* planar 4:2:2 */
+	VIDEO_FORMAT_I422,
+
+	/* planar 4:2:0 with alpha */
+	VIDEO_FORMAT_I40A,
+
+	/* planar 4:2:2 with alpha */
+	VIDEO_FORMAT_I42A,
+
+	/* planar 4:4:4 with alpha */
+	VIDEO_FORMAT_YUVA,
+
+	/* packed 4:4:4 with alpha */
+	VIDEO_FORMAT_AYUV,
+
+	/* planar 4:2:0 format, 10 bpp */
+	VIDEO_FORMAT_I010, /* three-plane */
+	VIDEO_FORMAT_P010, /* two-plane, luma and packed chroma */
+
+	/* planar 4:2:2 format, 10 bpp */
+	VIDEO_FORMAT_I210,
+
+	/* planar 4:4:4 format, 12 bpp */
+	VIDEO_FORMAT_I412,
+
+	/* planar 4:4:4:4 format, 12 bpp */
+	VIDEO_FORMAT_YA2L,
+
+	/* planar 4:2:2 format, 16 bpp */
+	VIDEO_FORMAT_P216, /* two-plane, luma and packed chroma */
+
+	/* planar 4:4:4 format, 16 bpp */
+	VIDEO_FORMAT_P416, /* two-plane, luma and packed chroma */
+
+	/* packed 4:2:2 format, 10 bpp */
+	VIDEO_FORMAT_V210,
+
+	/* packed uncompressed 10-bit format */
+	VIDEO_FORMAT_R10L,
+};
+
+enum video_trc {
+	VIDEO_TRC_DEFAULT,
+	VIDEO_TRC_SRGB,
+	VIDEO_TRC_PQ,
+	VIDEO_TRC_HLG,
+};
+
+enum video_colorspace {
+	VIDEO_CS_DEFAULT,
+	VIDEO_CS_601,
+	VIDEO_CS_709,
+	VIDEO_CS_SRGB,
+	VIDEO_CS_2100_PQ,
+	VIDEO_CS_2100_HLG,
+};
+
+enum video_range_type {
+	VIDEO_RANGE_DEFAULT,
+	VIDEO_RANGE_PARTIAL,
+	VIDEO_RANGE_FULL,
+};
+
+struct video_data {
+	uint8_t *data[MAX_AV_PLANES];
+	uint32_t linesize[MAX_AV_PLANES];
+	uint64_t timestamp;
+};
+
+struct video_output_info {
+	const char *name;
+
+	enum video_format format;
+	uint32_t fps_num;
+	uint32_t fps_den;
+	uint32_t width;
+	uint32_t height;
+	size_t cache_size;
+
+	enum video_colorspace colorspace;
+	enum video_range_type range;
+};
+
+static inline bool format_is_yuv(enum video_format format)
+{
+	switch (format) {
+	case VIDEO_FORMAT_I420:
+	case VIDEO_FORMAT_NV12:
+	case VIDEO_FORMAT_I422:
+	case VIDEO_FORMAT_I210:
+	case VIDEO_FORMAT_YVYU:
+	case VIDEO_FORMAT_YUY2:
+	case VIDEO_FORMAT_UYVY:
+	case VIDEO_FORMAT_I444:
+	case VIDEO_FORMAT_I412:
+	case VIDEO_FORMAT_I40A:
+	case VIDEO_FORMAT_I42A:
+	case VIDEO_FORMAT_YUVA:
+	case VIDEO_FORMAT_YA2L:
+	case VIDEO_FORMAT_AYUV:
+	case VIDEO_FORMAT_I010:
+	case VIDEO_FORMAT_P010:
+	case VIDEO_FORMAT_P216:
+	case VIDEO_FORMAT_P416:
+	case VIDEO_FORMAT_V210:
+		return true;
+	case VIDEO_FORMAT_NONE:
+	case VIDEO_FORMAT_RGBA:
+	case VIDEO_FORMAT_BGRA:
+	case VIDEO_FORMAT_BGRX:
+	case VIDEO_FORMAT_Y800:
+	case VIDEO_FORMAT_BGR3:
+	case VIDEO_FORMAT_R10L:
+		return false;
+	}
+
+	return false;
+}
+
+static inline const char *get_video_format_name(enum video_format format)
+{
+	switch (format) {
+	case VIDEO_FORMAT_I420:
+		return "I420";
+	case VIDEO_FORMAT_NV12:
+		return "NV12";
+	case VIDEO_FORMAT_I422:
+		return "I422";
+	case VIDEO_FORMAT_I210:
+		return "I210";
+	case VIDEO_FORMAT_YVYU:
+		return "YVYU";
+	case VIDEO_FORMAT_YUY2:
+		return "YUY2";
+	case VIDEO_FORMAT_UYVY:
+		return "UYVY";
+	case VIDEO_FORMAT_RGBA:
+		return "RGBA";
+	case VIDEO_FORMAT_BGRA:
+		return "BGRA";
+	case VIDEO_FORMAT_BGRX:
+		return "BGRX";
+	case VIDEO_FORMAT_I444:
+		return "I444";
+	case VIDEO_FORMAT_I412:
+		return "I412";
+	case VIDEO_FORMAT_Y800:
+		return "Y800";
+	case VIDEO_FORMAT_BGR3:
+		return "BGR3";
+	case VIDEO_FORMAT_I40A:
+		return "I40A";
+	case VIDEO_FORMAT_I42A:
+		return "I42A";
+	case VIDEO_FORMAT_YUVA:
+		return "YUVA";
+	case VIDEO_FORMAT_YA2L:
+		return "YA2L";
+	case VIDEO_FORMAT_AYUV:
+		return "AYUV";
+	case VIDEO_FORMAT_I010:
+		return "I010";
+	case VIDEO_FORMAT_P010:
+		return "P010";
+	case VIDEO_FORMAT_P216:
+		return "P216";
+	case VIDEO_FORMAT_P416:
+		return "P416";
+	case VIDEO_FORMAT_V210:
+		return "v210";
+	case VIDEO_FORMAT_R10L:
+		return "R10l";
+	case VIDEO_FORMAT_NONE:;
+	}
+
+	return "None";
+}
+
+static inline const char *get_video_colorspace_name(enum video_colorspace cs)
+{
+	switch (cs) {
+	case VIDEO_CS_DEFAULT:
+	case VIDEO_CS_709:
+		return "Rec. 709";
+	case VIDEO_CS_SRGB:
+		return "sRGB";
+	case VIDEO_CS_601:
+		return "Rec. 601";
+	case VIDEO_CS_2100_PQ:
+		return "Rec. 2100 (PQ)";
+	case VIDEO_CS_2100_HLG:
+		return "Rec. 2100 (HLG)";
+	}
+
+	return "Unknown";
+}
+
+static inline enum video_range_type resolve_video_range(enum video_format format, enum video_range_type range)
+{
+	if (range == VIDEO_RANGE_DEFAULT) {
+		range = format_is_yuv(format) ? VIDEO_RANGE_PARTIAL : VIDEO_RANGE_FULL;
+	}
+
+	return range;
+}
+
+static inline const char *get_video_range_name(enum video_format format, enum video_range_type range)
+{
+	range = resolve_video_range(format, range);
+	return range == VIDEO_RANGE_FULL ? "Full" : "Partial";
+}
+
+enum video_scale_type {
+	VIDEO_SCALE_DEFAULT,
+	VIDEO_SCALE_POINT,
+	VIDEO_SCALE_FAST_BILINEAR,
+	VIDEO_SCALE_BILINEAR,
+	VIDEO_SCALE_BICUBIC,
+};
+
+struct video_scale_info {
+	enum video_format format;
+	uint32_t width;
+	uint32_t height;
+	enum video_range_type range;
+	enum video_colorspace colorspace;
+};
+
+EXPORT enum video_format video_format_from_fourcc(uint32_t fourcc);
+
+EXPORT bool video_format_get_parameters(enum video_colorspace color_space, enum video_range_type range,
+					float matrix[16], float min_range[3], float max_range[3]);
+EXPORT bool video_format_get_parameters_for_format(enum video_colorspace color_space, enum video_range_type range,
+						   enum video_format format, float matrix[16], float min_range[3],
+						   float max_range[3]);
+
+#define VIDEO_OUTPUT_SUCCESS 0
+#define VIDEO_OUTPUT_INVALIDPARAM -1
+#define VIDEO_OUTPUT_FAIL -2
+
+EXPORT int video_output_open(video_t **video, struct video_output_info *info);
+EXPORT void video_output_close(video_t *video);
+
+EXPORT bool video_output_connect(video_t *video, const struct video_scale_info *conversion,
+				 void (*callback)(void *param, struct video_data *frame), void *param);
+EXPORT bool video_output_connect2(video_t *video, const struct video_scale_info *conversion,
+				  uint32_t frame_rate_divisor, void (*callback)(void *param, struct video_data *frame),
+				  void *param);
+EXPORT void video_output_disconnect(video_t *video, void (*callback)(void *param, struct video_data *frame),
+				    void *param);
+EXPORT bool video_output_disconnect2(video_t *video, void (*callback)(void *param, struct video_data *frame),
+				     void *param);
+
+EXPORT bool video_output_active(const video_t *video);
+
+EXPORT const struct video_output_info *video_output_get_info(const video_t *video);
+EXPORT bool video_output_lock_frame(video_t *video, struct video_frame *frame, int count, uint64_t timestamp);
+EXPORT void video_output_unlock_frame(video_t *video);
+EXPORT uint64_t video_output_get_frame_time(const video_t *video);
+EXPORT void video_output_stop(video_t *video);
+EXPORT bool video_output_stopped(video_t *video);
+
+EXPORT enum video_format video_output_get_format(const video_t *video);
+EXPORT uint32_t video_output_get_width(const video_t *video);
+EXPORT uint32_t video_output_get_height(const video_t *video);
+EXPORT double video_output_get_frame_rate(const video_t *video);
+
+EXPORT uint32_t video_output_get_skipped_frames(const video_t *video);
+EXPORT uint32_t video_output_get_total_frames(const video_t *video);
+
+extern void video_output_inc_texture_encoders(video_t *video);
+extern void video_output_dec_texture_encoders(video_t *video);
+extern void video_output_inc_texture_frames(video_t *video);
+extern void video_output_inc_texture_skipped_frames(video_t *video);
+
+extern video_t *video_output_create_with_frame_rate_divisor(video_t *video, uint32_t divisor);
+extern void video_output_free_frame_rate_divisor(video_t *video);
+
+#ifdef __cplusplus
+}
+#endif

package/include/media-io/video-scaler.h

@@ -0,0 +1,43 @@
+/******************************************************************************
+    Copyright (C) 2023 by Lain Bailey <lain@obsproject.com>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+******************************************************************************/
+
+#pragma once
+
+#include "../util/c99defs.h"
+#include "video-io.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct video_scaler;
+typedef struct video_scaler video_scaler_t;
+
+#define VIDEO_SCALER_SUCCESS 0
+#define VIDEO_SCALER_BAD_CONVERSION -1
+#define VIDEO_SCALER_FAILED -2
+
+EXPORT int video_scaler_create(video_scaler_t **scaler, const struct video_scale_info *dst,
+			       const struct video_scale_info *src, enum video_scale_type type);
+EXPORT void video_scaler_destroy(video_scaler_t *scaler);
+
+EXPORT bool video_scaler_scale(video_scaler_t *scaler, uint8_t *output[], const uint32_t out_linesize[],
+			       const uint8_t *const input[], const uint32_t in_linesize[]);
+
+#ifdef __cplusplus
+}
+#endif

package/include/obs-audio-controls.h

@@ -0,0 +1,250 @@
+/*
+Copyright (C) 2014 by Leonhard Oelke <leonhard@in-verted.de>
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#pragma once
+
+#include "obs.h"
+
+/**
+ * @file
+ * @brief header for audio controls
+ *
+ * @brief Audio controls for use in GUIs
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief Fader types
+ */
+enum obs_fader_type {
+	/**
+	 * @brief A simple cubic fader for controlling audio levels
+	 *
+	 * This is a very common type of software fader since it yields good
+	 * results while being quite performant.
+	 * The input value is mapped to mul values with the simple formula x^3.
+	 */
+	OBS_FADER_CUBIC,
+	/**
+	 * @brief A fader compliant to IEC 60-268-18
+	 *
+	 * This type of fader has several segments with different slopes that
+	 * map deflection linearly to dB values. The segments are defined as
+	 * in the following table:
+	 *
+	@code
+	Deflection           | Volume
+	------------------------------------------
+	[ 100   %, 75   % ]  | [   0 dB,   -9 dB ]
+	[  75   %, 50   % ]  | [  -9 dB,  -20 dB ]
+	[  50   %, 30   % ]  | [ -20 dB,  -30 dB ]
+	[  30   %, 15   % ]  | [ -30 dB,  -40 dB ]
+	[  15   %,  7.5 % ]  | [ -40 dB,  -50 dB ]
+	[   7.5 %,  2.5 % ]  | [ -50 dB,  -60 dB ]
+	[   2.5 %,  0   % ]  | [ -60 dB, -inf dB ]
+	@endcode
+	 */
+	OBS_FADER_IEC,
+	/**
+	 * @brief Logarithmic fader
+	 */
+	OBS_FADER_LOG
+};
+
+/**
+ * @brief Peak meter types
+ */
+enum obs_peak_meter_type {
+	/**
+	 * @brief A simple peak meter measuring the maximum of all samples.
+	 *
+	 * This was a very common type of peak meter used for audio, but
+	 * is not very accurate with regards to further audio processing.
+	 */
+	SAMPLE_PEAK_METER,
+
+	/**
+	 * @brief An accurate peak meter measure the maximum of inter-samples.
+	 *
+	 * This meter is more computational intensive due to 4x oversampling
+	 * to determine the true peak to an accuracy of +/- 0.5 dB.
+	 */
+	TRUE_PEAK_METER
+};
+
+/**
+ * @brief Create a fader
+ * @param type the type of the fader
+ * @return pointer to the fader object
+ *
+ * A fader object is used to map input values from a gui element to dB and
+ * subsequently multiplier values used by libobs to mix audio.
+ * The current "position" of the fader is internally stored as dB value.
+ */
+EXPORT obs_fader_t *obs_fader_create(enum obs_fader_type type);
+
+/**
+ * @brief Destroy a fader
+ * @param fader pointer to the fader object
+ *
+ * Destroy the fader and free all related data
+ */
+EXPORT void obs_fader_destroy(obs_fader_t *fader);
+
+/**
+ * @brief Set the fader dB value
+ * @param fader pointer to the fader object
+ * @param db new dB value
+ * @return true if value was set without clamping
+ */
+EXPORT bool obs_fader_set_db(obs_fader_t *fader, const float db);
+
+/**
+ * @brief Get the current fader dB value
+ * @param fader pointer to the fader object
+ * @return current fader dB value
+ */
+EXPORT float obs_fader_get_db(obs_fader_t *fader);
+
+/**
+ * @brief Set the fader value from deflection
+ * @param fader pointer to the fader object
+ * @param def new deflection
+ * @return true if value was set without clamping
+ *
+ * This sets the new fader value from the supplied deflection, in case the
+ * resulting value was clamped due to limits this function will return false.
+ * The deflection is typically in the range [0.0, 1.0] but may be higher in
+ * order to provide some amplification. In order for this to work the high dB
+ * limit has to be set.
+ */
+EXPORT bool obs_fader_set_deflection(obs_fader_t *fader, const float def);
+
+/**
+ * @brief Get the current fader deflection
+ * @param fader pointer to the fader object
+ * @return current fader deflection
+ */
+EXPORT float obs_fader_get_deflection(obs_fader_t *fader);
+
+/**
+ * @brief Set the fader value from multiplier
+ * @param fader pointer to the fader object
+ * @return true if the value was set without clamping
+ */
+EXPORT bool obs_fader_set_mul(obs_fader_t *fader, const float mul);
+
+/**
+ * @brief Get the current fader multiplier value
+ * @param fader pointer to the fader object
+ * @return current fader multiplier
+ */
+EXPORT float obs_fader_get_mul(obs_fader_t *fader);
+
+/**
+ * @brief Attach the fader to a source
+ * @param fader pointer to the fader object
+ * @param source pointer to the source object
+ * @return true on success
+ *
+ * When the fader is attached to a source it will automatically sync it's state
+ * to the volume of the source.
+ */
+EXPORT bool obs_fader_attach_source(obs_fader_t *fader, obs_source_t *source);
+
+/**
+ * @brief Detach the fader from the currently attached source
+ * @param fader pointer to the fader object
+ */
+EXPORT void obs_fader_detach_source(obs_fader_t *fader);
+
+typedef void (*obs_fader_changed_t)(void *param, float db);
+
+EXPORT void obs_fader_add_callback(obs_fader_t *fader, obs_fader_changed_t callback, void *param);
+EXPORT void obs_fader_remove_callback(obs_fader_t *fader, obs_fader_changed_t callback, void *param);
+
+/**
+ * @brief Create a volume meter
+ * @param type the mapping type to use for the volume meter
+ * @return pointer to the volume meter object
+ *
+ * A volume meter object is used to prepare the sound levels reported by audio
+ * sources for display in a GUI.
+ * It will automatically take source volume into account and map the levels
+ * to a range [0.0f, 1.0f].
+ */
+EXPORT obs_volmeter_t *obs_volmeter_create(enum obs_fader_type type);
+
+/**
+ * @brief Destroy a volume meter
+ * @param volmeter pointer to the volmeter object
+ *
+ * Destroy the volume meter and free all related data
+ */
+EXPORT void obs_volmeter_destroy(obs_volmeter_t *volmeter);
+
+/**
+ * @brief Attach the volume meter to a source
+ * @param volmeter pointer to the volume meter object
+ * @param source pointer to the source object
+ * @return true on success
+ *
+ * When the volume meter is attached to a source it will start to listen to
+ * volume updates on the source and after preparing the data emit its own
+ * signal.
+ */
+EXPORT bool obs_volmeter_attach_source(obs_volmeter_t *volmeter, obs_source_t *source);
+
+/**
+ * @brief Detach the volume meter from the currently attached source
+ * @param volmeter pointer to the volume meter object
+ */
+EXPORT void obs_volmeter_detach_source(obs_volmeter_t *volmeter);
+
+/**
+ * @brief Set the peak meter type for the volume meter
+ * @param volmeter pointer to the volume meter object
+ * @param peak_meter_type set if true-peak needs to be measured.
+ */
+EXPORT void obs_volmeter_set_peak_meter_type(obs_volmeter_t *volmeter, enum obs_peak_meter_type peak_meter_type);
+
+/**
+ * @brief Get the number of channels which are configured for this source.
+ * @param volmeter pointer to the volume meter object
+ */
+EXPORT int obs_volmeter_get_nr_channels(obs_volmeter_t *volmeter);
+
+typedef void (*obs_volmeter_updated_t)(void *param, const float magnitude[MAX_AUDIO_CHANNELS],
+				       const float peak[MAX_AUDIO_CHANNELS],
+				       const float input_peak[MAX_AUDIO_CHANNELS]);
+
+EXPORT void obs_volmeter_add_callback(obs_volmeter_t *volmeter, obs_volmeter_updated_t callback, void *param);
+EXPORT void obs_volmeter_remove_callback(obs_volmeter_t *volmeter, obs_volmeter_updated_t callback, void *param);
+
+EXPORT float obs_mul_to_db(float mul);
+EXPORT float obs_db_to_mul(float db);
+
+typedef float (*obs_fader_conversion_t)(const float val);
+
+EXPORT obs_fader_conversion_t obs_fader_db_to_def(obs_fader_t *fader);
+
+#ifdef __cplusplus
+}
+#endif