#pragma once

// NOTE : The following MIT license applies to this file ONLY and not to the SDK as a whole. Please review
// the SDK documentation for the description of the full license terms, which are also provided in the file
// "NDI License Agreement.pdf" within the SDK or online at http://ndi.link/ndisdk_license. Your use of any
// part of this SDK is acknowledgment that you agree to the SDK license terms. The full NDI SDK may be
// downloaded at http://ndi.video/
//
//***********************************************************************************************************
//
// Copyright (C) 2023-2024 Vizrt NDI AB. All rights reserved.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
// associated documentation files(the "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and / or sell
// copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the
// following conditions :
//
// The above copyright notice and this permission notice shall be included in all copies or substantial
// portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT
// LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
// EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
// IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR
// THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//***********************************************************************************************************

// Because many applications like submitting 16-bit interleaved audio, these functions will convert in and
// out of that format. It is important to note that the NDI SDK does define fully audio levels, something
// that most applications that you use do not. Specifically, the floating-point range, -1.0 to +1.0, is
// defined as a professional audio reference level of +4 dBU. If we take 16-bit audio and scale it into this
// range it is almost always correct for sending and will cause no problems. For receiving however it is not
// at all uncommon that the user has audio that exceeds reference level and in this case it is likely that
// audio exceeds the reference level and so if you are not careful you will end up having audio clipping when
// you use the 16-bit range.

// This describes an audio frame.
typedef struct NDIlib_audio_frame_interleaved_16s_t {
	// The sample-rate of this buffer.
	int sample_rate;

	// The number of audio channels.
	int no_channels;

	// The number of audio samples per channel.
	int no_samples;

	// The timecode of this frame in 100-nanosecond intervals.
	int64_t timecode;

	// The audio reference level in dB. This specifies how many dB above the reference level (+4 dBU) is the
	// full range of 16-bit audio. If you do not understand this and want to just use numbers:
	// - If you are sending audio, specify +0 dB. Most common applications produce audio at reference level.
	// - If receiving audio, specify +20 dB. This means that the full 16-bit range corresponds to
	//   professional level audio with 20 dB of headroom. Note that if you are writing it into a file it
	//   might sound soft because you have 20 dB of headroom before clipping.
	int reference_level;

	// The audio data, interleaved 16-bit samples.
	int16_t* p_data;

#if NDILIB_CPP_DEFAULT_CONSTRUCTORS
	NDIlib_audio_frame_interleaved_16s_t(
		int sample_rate_ = 48000, int no_channels_ = 2, int no_samples_ = 0,
		int64_t timecode_ = NDIlib_send_timecode_synthesize,
		int reference_level_ = 0,
		int16_t* p_data_ = NULL
	);
#endif // NDILIB_CPP_DEFAULT_CONSTRUCTORS
} NDIlib_audio_frame_interleaved_16s_t;

// This describes an audio frame.
typedef struct NDIlib_audio_frame_interleaved_32s_t {
	// The sample-rate of this buffer.
	int sample_rate;

	// The number of audio channels.
	int no_channels;

	// The number of audio samples per channel.
	int no_samples;

	// The timecode of this frame in 100-nanosecond intervals.
	int64_t timecode;

	// The audio reference level in dB. This specifies how many dB above the reference level (+4 dBU) is the
	// full range of 32-bit audio. If you do not understand this and want to just use numbers:
	// - If you are sending audio, specify +0 dB. Most common applications produce audio at reference level.
	// - If receiving audio, specify +20 dB. This means that the full 32-bit range corresponds to
	//   professional level audio with 20 dB of headroom. Note that if you are writing it into a file it
	//   might sound soft because you have 20 dB of headroom before clipping.
	int reference_level;

	// The audio data, interleaved 32-bit samples.
	int32_t* p_data;

#if NDILIB_CPP_DEFAULT_CONSTRUCTORS
	NDIlib_audio_frame_interleaved_32s_t(
		int sample_rate_ = 48000, int no_channels_ = 2, int no_samples_ = 0,
		int64_t timecode_ = NDIlib_send_timecode_synthesize,
		int reference_level_ = 0,
		int32_t* p_data_ = NULL
	);
#endif // NDILIB_CPP_DEFAULT_CONSTRUCTORS
} NDIlib_audio_frame_interleaved_32s_t;

// This describes an audio frame.
typedef struct NDIlib_audio_frame_interleaved_32f_t {
	// The sample-rate of this buffer.
	int sample_rate;

	// The number of audio channels.
	int no_channels;

	// The number of audio samples per channel.
	int no_samples;

	// The timecode of this frame in 100-nanosecond intervals.
	int64_t timecode;

	// The audio data, interleaved 32-bit floating-point samples.
	float* p_data;

#if NDILIB_CPP_DEFAULT_CONSTRUCTORS
	NDIlib_audio_frame_interleaved_32f_t(
		int sample_rate_ = 48000, int no_channels_ = 2, int no_samples_ = 0,
		int64_t timecode_ = NDIlib_send_timecode_synthesize,
		float* p_data_ = NULL
	);
#endif // NDILIB_CPP_DEFAULT_CONSTRUCTORS
} NDIlib_audio_frame_interleaved_32f_t;

// This will add an audio frame in interleaved 16-bit.
PROCESSINGNDILIB_API
void NDIlib_util_send_send_audio_interleaved_16s(
	NDIlib_send_instance_t p_instance,
	const NDIlib_audio_frame_interleaved_16s_t* p_audio_data
);

// This will add an audio frame in interleaved 32-bit.
PROCESSINGNDILIB_API
void NDIlib_util_send_send_audio_interleaved_32s(
	NDIlib_send_instance_t p_instance,
	const NDIlib_audio_frame_interleaved_32s_t* p_audio_data
);

// This will add an audio frame in interleaved floating point.
PROCESSINGNDILIB_API
void NDIlib_util_send_send_audio_interleaved_32f(
	NDIlib_send_instance_t p_instance,
	const NDIlib_audio_frame_interleaved_32f_t* p_audio_data
);

// Convert to interleaved 16-bit.
PROCESSINGNDILIB_API
void NDIlib_util_audio_to_interleaved_16s_v2(
	const NDIlib_audio_frame_v2_t* p_src,
	NDIlib_audio_frame_interleaved_16s_t* p_dst
);

// Convert to interleaved 16-bit. The FourCC of the source audio frame must be NDIlib_FourCC_audio_type_FLTP.
// Returns true if the conversion was successful.
PROCESSINGNDILIB_API
bool NDIlib_util_audio_to_interleaved_16s_v3(
	const NDIlib_audio_frame_v3_t* p_src,
	NDIlib_audio_frame_interleaved_16s_t* p_dst
);

// Convert from interleaved 16-bit.
PROCESSINGNDILIB_API
void NDIlib_util_audio_from_interleaved_16s_v2(
	const NDIlib_audio_frame_interleaved_16s_t* p_src,
	NDIlib_audio_frame_v2_t* p_dst
);

// Convert from interleaved 16-bit. The FourCC of the destination audio frame must be
// NDIlib_FourCC_audio_type_FLTP and its p_data allocated accordingly.
// Returns true if the conversion was successful.
PROCESSINGNDILIB_API
bool NDIlib_util_audio_from_interleaved_16s_v3(
	const NDIlib_audio_frame_interleaved_16s_t* p_src,
	NDIlib_audio_frame_v3_t* p_dst
);

// Convert to interleaved 32-bit.
PROCESSINGNDILIB_API
void NDIlib_util_audio_to_interleaved_32s_v2(
	const NDIlib_audio_frame_v2_t* p_src,
	NDIlib_audio_frame_interleaved_32s_t* p_dst
);

// Convert to interleaved 32-bit. The FourCC of the source audio frame must be NDIlib_FourCC_audio_type_FLTP.
// Returns true if the conversion was successful.
PROCESSINGNDILIB_API
bool NDIlib_util_audio_to_interleaved_32s_v3(
	const NDIlib_audio_frame_v3_t* p_src,
	NDIlib_audio_frame_interleaved_32s_t* p_dst
);

// Convert from interleaved 32-bit.
PROCESSINGNDILIB_API
void NDIlib_util_audio_from_interleaved_32s_v2(
	const NDIlib_audio_frame_interleaved_32s_t* p_src,
	NDIlib_audio_frame_v2_t* p_dst
);

// Convert from interleaved 32-bit. The FourCC of the destination audio frame must be
// NDIlib_FourCC_audio_type_FLTP and its p_data allocated accordingly.
// Returns true if the conversion was successful.
PROCESSINGNDILIB_API
bool NDIlib_util_audio_from_interleaved_32s_v3(
	const NDIlib_audio_frame_interleaved_32s_t* p_src,
	NDIlib_audio_frame_v3_t* p_dst
);

// Convert to interleaved floating point.
PROCESSINGNDILIB_API
void NDIlib_util_audio_to_interleaved_32f_v2(
	const NDIlib_audio_frame_v2_t* p_src,
	NDIlib_audio_frame_interleaved_32f_t* p_dst
);

// Convert to interleaved floating point. The FourCC of the source audio frame must be
// NDIlib_FourCC_audio_type_FLTP. Returns true if the conversion was successful.
PROCESSINGNDILIB_API
bool NDIlib_util_audio_to_interleaved_32f_v3(
	const NDIlib_audio_frame_v3_t* p_src,
	NDIlib_audio_frame_interleaved_32f_t* p_dst
);

// Convert from interleaved floating point.
PROCESSINGNDILIB_API
void NDIlib_util_audio_from_interleaved_32f_v2(
	const NDIlib_audio_frame_interleaved_32f_t* p_src,
	NDIlib_audio_frame_v2_t* p_dst
);

// Convert from interleaved floating point. The FourCC of the destination audio frame must be
// NDIlib_FourCC_audio_type_FLTP and its p_data allocated accordingly.
// Returns true if the conversion was successful.
PROCESSINGNDILIB_API
bool NDIlib_util_audio_from_interleaved_32f_v3(
	const NDIlib_audio_frame_interleaved_32f_t* p_src,
	NDIlib_audio_frame_v3_t* p_dst
);

// This is a helper function that you may use to convert from 10-bit packed UYVY into 16-bit semi-planar. The
// FourCC on the source is ignored in this function since we do not define a V210 format in NDI. You must
// make sure that there is memory and a stride allocated in p_dst.
PROCESSINGNDILIB_API
void NDIlib_util_V210_to_P216(const NDIlib_video_frame_v2_t* p_src_v210, NDIlib_video_frame_v2_t* p_dst_p216);

// This converts from 16-bit semi-planar to 10-bit. You must make sure that there is memory and a stride
// allocated in p_dst.
PROCESSINGNDILIB_API
void NDIlib_util_P216_to_V210(const NDIlib_video_frame_v2_t* p_src_p216, NDIlib_video_frame_v2_t* p_dst_v210);