noobs 0.0.6

package/include/graphics/vec4.h

@@ -0,0 +1,241 @@
+/******************************************************************************
+    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 "math-defs.h"
+#include "srgb.h"
+
+#include "../util/sse-intrin.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct vec3;
+struct matrix4;
+
+struct vec4 {
+	union {
+		struct {
+			float x, y, z, w;
+		};
+		float ptr[4];
+		__m128 m;
+	};
+};
+
+static inline void vec4_zero(struct vec4 *v)
+{
+	v->m = _mm_setzero_ps();
+}
+
+static inline void vec4_set(struct vec4 *dst, float x, float y, float z, float w)
+{
+	dst->m = _mm_set_ps(w, z, y, x);
+}
+
+static inline void vec4_copy(struct vec4 *dst, const struct vec4 *v)
+{
+	dst->m = v->m;
+}
+
+EXPORT void vec4_from_vec3(struct vec4 *dst, const struct vec3 *v);
+
+static inline void vec4_add(struct vec4 *dst, const struct vec4 *v1, const struct vec4 *v2)
+{
+	dst->m = _mm_add_ps(v1->m, v2->m);
+}
+
+static inline void vec4_sub(struct vec4 *dst, const struct vec4 *v1, const struct vec4 *v2)
+{
+	dst->m = _mm_sub_ps(v1->m, v2->m);
+}
+
+static inline void vec4_mul(struct vec4 *dst, const struct vec4 *v1, const struct vec4 *v2)
+{
+	dst->m = _mm_mul_ps(v1->m, v2->m);
+}
+
+static inline void vec4_div(struct vec4 *dst, const struct vec4 *v1, const struct vec4 *v2)
+{
+	dst->m = _mm_div_ps(v1->m, v2->m);
+}
+
+static inline void vec4_addf(struct vec4 *dst, const struct vec4 *v, float f)
+{
+	dst->m = _mm_add_ps(v->m, _mm_set1_ps(f));
+}
+
+static inline void vec4_subf(struct vec4 *dst, const struct vec4 *v, float f)
+{
+	dst->m = _mm_sub_ps(v->m, _mm_set1_ps(f));
+}
+
+static inline void vec4_mulf(struct vec4 *dst, const struct vec4 *v, float f)
+{
+	dst->m = _mm_mul_ps(v->m, _mm_set1_ps(f));
+}
+
+static inline void vec4_divf(struct vec4 *dst, const struct vec4 *v, float f)
+{
+	dst->m = _mm_div_ps(v->m, _mm_set1_ps(f));
+}
+
+static inline float vec4_dot(const struct vec4 *v1, const struct vec4 *v2)
+{
+	struct vec4 add;
+	__m128 mul = _mm_mul_ps(v1->m, v2->m);
+	add.m = _mm_add_ps(_mm_movehl_ps(mul, mul), mul);
+	add.m = _mm_add_ps(_mm_shuffle_ps(add.m, add.m, 0x55), add.m);
+	return add.x;
+}
+
+static inline void vec4_neg(struct vec4 *dst, const struct vec4 *v)
+{
+	dst->x = -v->x;
+	dst->y = -v->y;
+	dst->z = -v->z;
+	dst->w = -v->w;
+}
+
+static inline float vec4_len(const struct vec4 *v)
+{
+	float dot_val = vec4_dot(v, v);
+	return (dot_val > 0.0f) ? sqrtf(dot_val) : 0.0f;
+}
+
+static inline float vec4_dist(const struct vec4 *v1, const struct vec4 *v2)
+{
+	struct vec4 temp;
+	float dot_val;
+
+	vec4_sub(&temp, v1, v2);
+	dot_val = vec4_dot(&temp, &temp);
+	return (dot_val > 0.0f) ? sqrtf(dot_val) : 0.0f;
+}
+
+static inline void vec4_norm(struct vec4 *dst, const struct vec4 *v)
+{
+	float dot_val = vec4_dot(v, v);
+	dst->m = (dot_val > 0.0f) ? _mm_mul_ps(v->m, _mm_set1_ps(1.0f / sqrtf(dot_val))) : _mm_setzero_ps();
+}
+
+static inline int vec4_close(const struct vec4 *v1, const struct vec4 *v2, float epsilon)
+{
+	struct vec4 test;
+	vec4_sub(&test, v1, v2);
+	return test.x < epsilon && test.y < epsilon && test.z < epsilon && test.w < epsilon;
+}
+
+static inline void vec4_min(struct vec4 *dst, const struct vec4 *v1, const struct vec4 *v2)
+{
+	dst->m = _mm_min_ps(v1->m, v2->m);
+}
+
+static inline void vec4_minf(struct vec4 *dst, const struct vec4 *v, float f)
+{
+	dst->m = _mm_min_ps(v->m, _mm_set1_ps(f));
+}
+
+static inline void vec4_max(struct vec4 *dst, const struct vec4 *v1, const struct vec4 *v2)
+{
+	dst->m = _mm_max_ps(v1->m, v2->m);
+}
+
+static inline void vec4_maxf(struct vec4 *dst, const struct vec4 *v, float f)
+{
+	dst->m = _mm_max_ps(v->m, _mm_set1_ps(f));
+}
+
+static inline void vec4_abs(struct vec4 *dst, const struct vec4 *v)
+{
+	dst->x = fabsf(v->x);
+	dst->y = fabsf(v->y);
+	dst->z = fabsf(v->z);
+	dst->w = fabsf(v->w);
+}
+
+static inline void vec4_floor(struct vec4 *dst, const struct vec4 *v)
+{
+	dst->x = floorf(v->x);
+	dst->y = floorf(v->y);
+	dst->z = floorf(v->z);
+	dst->w = floorf(v->w);
+}
+
+static inline void vec4_ceil(struct vec4 *dst, const struct vec4 *v)
+{
+	dst->x = ceilf(v->x);
+	dst->y = ceilf(v->y);
+	dst->z = ceilf(v->z);
+	dst->w = ceilf(v->w);
+}
+
+static inline uint32_t vec4_to_rgba(const struct vec4 *src)
+{
+	float f[4];
+	memcpy(f, src->ptr, sizeof(f));
+	uint8_t u[4];
+	gs_float4_to_u8x4(u, f);
+	uint32_t val;
+	memcpy(&val, u, sizeof(val));
+	return val;
+}
+
+static inline uint32_t vec4_to_bgra(const struct vec4 *src)
+{
+	float f[4];
+	memcpy(f, src->ptr, sizeof(f));
+	uint8_t u[4];
+	gs_float4_to_u8x4(u, f);
+	uint8_t temp = u[0];
+	u[0] = u[2];
+	u[2] = temp;
+	uint32_t val;
+	memcpy(&val, u, sizeof(val));
+	return val;
+}
+
+static inline void vec4_from_rgba(struct vec4 *dst, uint32_t rgba)
+{
+	uint8_t u[4];
+	memcpy(u, &rgba, sizeof(u));
+	gs_u8x4_to_float4(dst->ptr, u);
+}
+
+static inline void vec4_from_bgra(struct vec4 *dst, uint32_t bgra)
+{
+	uint8_t u[4];
+	memcpy(u, &bgra, sizeof(u));
+	uint8_t temp = u[0];
+	u[0] = u[2];
+	u[2] = temp;
+	gs_u8x4_to_float4(dst->ptr, u);
+}
+
+static inline void vec4_from_rgba_srgb(struct vec4 *dst, uint32_t rgba)
+{
+	vec4_from_rgba(dst, rgba);
+	gs_float3_srgb_nonlinear_to_linear(dst->ptr);
+}
+
+EXPORT void vec4_transform(struct vec4 *dst, const struct vec4 *v, const struct matrix4 *m);
+
+#ifdef __cplusplus
+}
+#endif

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

@@ -0,0 +1,228 @@
+/******************************************************************************
+    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"
+#include "../util/util_uint64.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MAX_AUDIO_MIXES 6
+#define MAX_AUDIO_CHANNELS 8
+#define MAX_DEVICE_INPUT_CHANNELS 64
+#define AUDIO_OUTPUT_FRAMES 1024
+
+#define TOTAL_AUDIO_SIZE (MAX_AUDIO_MIXES * MAX_AUDIO_CHANNELS * AUDIO_OUTPUT_FRAMES * sizeof(float))
+
+/*
+ * Base audio output component.  Use this to create an audio output track
+ * for the media.
+ */
+
+struct audio_output;
+typedef struct audio_output audio_t;
+
+enum audio_format {
+	AUDIO_FORMAT_UNKNOWN,
+
+	AUDIO_FORMAT_U8BIT,
+	AUDIO_FORMAT_16BIT,
+	AUDIO_FORMAT_32BIT,
+	AUDIO_FORMAT_FLOAT,
+
+	AUDIO_FORMAT_U8BIT_PLANAR,
+	AUDIO_FORMAT_16BIT_PLANAR,
+	AUDIO_FORMAT_32BIT_PLANAR,
+	AUDIO_FORMAT_FLOAT_PLANAR,
+};
+
+/**
+ * The speaker layout describes where the speakers are located in the room.
+ * For OBS it dictates:
+ *  *  how many channels are available and
+ *  *  which channels are used for which speakers.
+ *
+ * Standard channel layouts where retrieved from ffmpeg documentation at:
+ *     https://trac.ffmpeg.org/wiki/AudioChannelManipulation
+ */
+enum speaker_layout {
+	SPEAKERS_UNKNOWN,     /**< Unknown setting, fallback is stereo. */
+	SPEAKERS_MONO,        /**< Channels: MONO */
+	SPEAKERS_STEREO,      /**< Channels: FL, FR */
+	SPEAKERS_2POINT1,     /**< Channels: FL, FR, LFE */
+	SPEAKERS_4POINT0,     /**< Channels: FL, FR, FC, RC */
+	SPEAKERS_4POINT1,     /**< Channels: FL, FR, FC, LFE, RC */
+	SPEAKERS_5POINT1,     /**< Channels: FL, FR, FC, LFE, RL, RR */
+	SPEAKERS_7POINT1 = 8, /**< Channels: FL, FR, FC, LFE, RL, RR, SL, SR */
+};
+
+struct audio_data {
+	uint8_t *data[MAX_AV_PLANES];
+	uint32_t frames;
+	uint64_t timestamp;
+};
+
+struct audio_output_data {
+	float *data[MAX_AUDIO_CHANNELS];
+};
+
+typedef bool (*audio_input_callback_t)(void *param, uint64_t start_ts, uint64_t end_ts, uint64_t *new_ts,
+				       uint32_t active_mixers, struct audio_output_data *mixes);
+
+struct audio_output_info {
+	const char *name;
+
+	uint32_t samples_per_sec;
+	enum audio_format format;
+	enum speaker_layout speakers;
+
+	audio_input_callback_t input_callback;
+	void *input_param;
+};
+
+struct audio_convert_info {
+	uint32_t samples_per_sec;
+	enum audio_format format;
+	enum speaker_layout speakers;
+	bool allow_clipping;
+};
+
+static inline uint32_t get_audio_channels(enum speaker_layout speakers)
+{
+	switch (speakers) {
+	case SPEAKERS_MONO:
+		return 1;
+	case SPEAKERS_STEREO:
+		return 2;
+	case SPEAKERS_2POINT1:
+		return 3;
+	case SPEAKERS_4POINT0:
+		return 4;
+	case SPEAKERS_4POINT1:
+		return 5;
+	case SPEAKERS_5POINT1:
+		return 6;
+	case SPEAKERS_7POINT1:
+		return 8;
+	case SPEAKERS_UNKNOWN:
+		return 0;
+	}
+
+	return 0;
+}
+
+static inline size_t get_audio_bytes_per_channel(enum audio_format format)
+{
+	switch (format) {
+	case AUDIO_FORMAT_U8BIT:
+	case AUDIO_FORMAT_U8BIT_PLANAR:
+		return 1;
+
+	case AUDIO_FORMAT_16BIT:
+	case AUDIO_FORMAT_16BIT_PLANAR:
+		return 2;
+
+	case AUDIO_FORMAT_FLOAT:
+	case AUDIO_FORMAT_FLOAT_PLANAR:
+	case AUDIO_FORMAT_32BIT:
+	case AUDIO_FORMAT_32BIT_PLANAR:
+		return 4;
+
+	case AUDIO_FORMAT_UNKNOWN:
+		return 0;
+	}
+
+	return 0;
+}
+
+static inline bool is_audio_planar(enum audio_format format)
+{
+	switch (format) {
+	case AUDIO_FORMAT_U8BIT:
+	case AUDIO_FORMAT_16BIT:
+	case AUDIO_FORMAT_32BIT:
+	case AUDIO_FORMAT_FLOAT:
+		return false;
+
+	case AUDIO_FORMAT_U8BIT_PLANAR:
+	case AUDIO_FORMAT_FLOAT_PLANAR:
+	case AUDIO_FORMAT_16BIT_PLANAR:
+	case AUDIO_FORMAT_32BIT_PLANAR:
+		return true;
+
+	case AUDIO_FORMAT_UNKNOWN:
+		return false;
+	}
+
+	return false;
+}
+
+static inline size_t get_audio_planes(enum audio_format format, enum speaker_layout speakers)
+{
+	return (is_audio_planar(format) ? get_audio_channels(speakers) : 1);
+}
+
+static inline size_t get_audio_size(enum audio_format format, enum speaker_layout speakers, uint32_t frames)
+{
+	bool planar = is_audio_planar(format);
+
+	return (planar ? 1 : get_audio_channels(speakers)) * get_audio_bytes_per_channel(format) * frames;
+}
+
+static inline size_t get_total_audio_size(enum audio_format format, enum speaker_layout speakers, uint32_t frames)
+{
+	return get_audio_channels(speakers) * get_audio_bytes_per_channel(format) * frames;
+}
+
+static inline uint64_t audio_frames_to_ns(size_t sample_rate, uint64_t frames)
+{
+	return util_mul_div64(frames, 1000000000ULL, sample_rate);
+}
+
+static inline uint64_t ns_to_audio_frames(size_t sample_rate, uint64_t frames)
+{
+	return util_mul_div64(frames, sample_rate, 1000000000ULL);
+}
+
+#define AUDIO_OUTPUT_SUCCESS 0
+#define AUDIO_OUTPUT_INVALIDPARAM -1
+#define AUDIO_OUTPUT_FAIL -2
+
+EXPORT int audio_output_open(audio_t **audio, struct audio_output_info *info);
+EXPORT void audio_output_close(audio_t *audio);
+
+typedef void (*audio_output_callback_t)(void *param, size_t mix_idx, struct audio_data *data);
+
+EXPORT bool audio_output_connect(audio_t *video, size_t mix_idx, const struct audio_convert_info *conversion,
+				 audio_output_callback_t callback, void *param);
+EXPORT void audio_output_disconnect(audio_t *video, size_t mix_idx, audio_output_callback_t callback, void *param);
+
+EXPORT bool audio_output_active(const audio_t *audio);
+
+EXPORT size_t audio_output_get_block_size(const audio_t *audio);
+EXPORT size_t audio_output_get_planes(const audio_t *audio);
+EXPORT size_t audio_output_get_channels(const audio_t *audio);
+EXPORT uint32_t audio_output_get_sample_rate(const audio_t *audio);
+EXPORT const struct audio_output_info *audio_output_get_info(const audio_t *audio);
+
+#ifdef __cplusplus
+}
+#endif

package/include/media-io/audio-math.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 <math.h>
+
+#ifdef _MSC_VER
+#include <float.h>
+
+#pragma warning(push)
+#pragma warning(disable : 4056)
+#pragma warning(disable : 4756)
+#endif
+
+static inline float mul_to_db(const float mul)
+{
+	return (mul == 0.0f) ? -INFINITY : (20.0f * log10f(mul));
+}
+
+static inline float db_to_mul(const float db)
+{
+	return isfinite((double)db) ? powf(10.0f, db / 20.0f) : 0.0f;
+}
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif

package/include/media-io/audio-resampler.h

@@ -0,0 +1,44 @@
+/******************************************************************************
+    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 "audio-io.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct audio_resampler;
+typedef struct audio_resampler audio_resampler_t;
+
+struct resample_info {
+	uint32_t samples_per_sec;
+	enum audio_format format;
+	enum speaker_layout speakers;
+};
+
+EXPORT audio_resampler_t *audio_resampler_create(const struct resample_info *dst, const struct resample_info *src);
+EXPORT void audio_resampler_destroy(audio_resampler_t *resampler);
+
+EXPORT bool audio_resampler_resample(audio_resampler_t *resampler, uint8_t *output[], uint32_t *out_frames,
+				     uint64_t *ts_offset, const uint8_t *const input[], uint32_t in_frames);
+
+#ifdef __cplusplus
+}
+#endif

package/include/media-io/format-conversion.h

@@ -0,0 +1,50 @@
+/******************************************************************************
+    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"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/*
+ * Functions for converting to and from packed 444 YUV
+ */
+
+EXPORT void compress_uyvx_to_i420(const uint8_t *input, uint32_t in_linesize, uint32_t start_y, uint32_t end_y,
+				  uint8_t *output[], const uint32_t out_linesize[]);
+
+EXPORT void compress_uyvx_to_nv12(const uint8_t *input, uint32_t in_linesize, uint32_t start_y, uint32_t end_y,
+				  uint8_t *output[], const uint32_t out_linesize[]);
+
+EXPORT void convert_uyvx_to_i444(const uint8_t *input, uint32_t in_linesize, uint32_t start_y, uint32_t end_y,
+				 uint8_t *output[], const uint32_t out_linesize[]);
+
+EXPORT void decompress_nv12(const uint8_t *const input[], const uint32_t in_linesize[], uint32_t start_y,
+			    uint32_t end_y, uint8_t *output, uint32_t out_linesize);
+
+EXPORT void decompress_420(const uint8_t *const input[], const uint32_t in_linesize[], uint32_t start_y, uint32_t end_y,
+			   uint8_t *output, uint32_t out_linesize);
+
+EXPORT void decompress_422(const uint8_t *input, uint32_t in_linesize, uint32_t start_y, uint32_t end_y,
+			   uint8_t *output, uint32_t out_linesize, bool leading_lum);
+
+#ifdef __cplusplus
+}
+#endif

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

@@ -0,0 +1,29 @@
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct media_frames_per_second {
+	uint32_t numerator;
+	uint32_t denominator;
+};
+
+static inline double media_frames_per_second_to_frame_interval(struct media_frames_per_second fps)
+{
+	return (double)fps.denominator / fps.numerator;
+}
+
+static inline double media_frames_per_second_to_fps(struct media_frames_per_second fps)
+{
+	return (double)fps.numerator / fps.denominator;
+}
+
+static inline bool media_frames_per_second_is_valid(struct media_frames_per_second fps)
+{
+	return fps.numerator && fps.denominator;
+}
+
+#ifdef __cplusplus
+}
+#endif

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

@@ -0,0 +1,20 @@
+/******************************************************************************
+    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
+
+#define MAX_AV_PLANES 8

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

@@ -0,0 +1,37 @@
+/******************************************************************************
+    Copyright (C) 2014 by Ruwen Hahn <palana@stunned.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/>.
+******************************************************************************/
+
+#include "../util/c99defs.h"
+
+#pragma once
+
+struct media_remux_job;
+typedef struct media_remux_job *media_remux_job_t;
+
+typedef bool(media_remux_progress_callback)(void *data, float percent);
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+EXPORT bool media_remux_job_create(media_remux_job_t *job, const char *in_filename, const char *out_filename);
+EXPORT bool media_remux_job_process(media_remux_job_t job, media_remux_progress_callback callback, void *data);
+EXPORT void media_remux_job_destroy(media_remux_job_t job);
+
+#ifdef __cplusplus
+}
+#endif