#ifndef _library_opus_hpp_included_
#define _library_opus_hpp_included_

#include <cstdint>
#include <cstdlib>
#include <stdexcept>
#include <vector>
#include <functional>

namespace loadlib
{
class module;
}

namespace opus
{
void load_libopus(const loadlib::module& lib);
bool libopus_loaded();
size_t add_callback(std::function<void()> fun);
void cancel_callback(size_t handle);

struct bad_argument : public std::runtime_error { bad_argument(); };
struct buffer_too_small : public std::runtime_error { buffer_too_small(); };
struct internal_error : public std::runtime_error { internal_error(); };
struct invalid_packet : public std::runtime_error { invalid_packet(); };
struct unimplemented : public std::runtime_error { unimplemented(); };
struct invalid_state : public std::runtime_error { invalid_state(); };
struct not_loaded : public std::runtime_error { not_loaded(); };

class encoder;
class decoder;
class multistream_encoder;
class multistream_decoder;
class surround_encoder;

template<typename T> struct generic_eget
{
	typedef T erettype;
	T operator()(encoder& e) const;
	T errordefault() const;
};

template<typename T> struct generic_meget : public generic_eget<T>
{
	using generic_eget<T>::operator();
	T operator()(multistream_encoder& e) const;
	T operator()(surround_encoder& e) const;
};

template<typename T> struct generic_get
{
	typedef T drettype;
	typedef T erettype;
	T operator()(decoder& e) const;
	T operator()(encoder& e) const;
	T errordefault() const;
};

template<typename T> struct generic_mget : public generic_get<T>
{
	using generic_get<T>::operator();
	T operator()(multistream_decoder& e) const;
	T operator()(multistream_encoder& e) const;
	T operator()(surround_encoder& e) const;
};

template<typename T> struct generic_dget
{
	typedef T drettype;
	T operator()(decoder& e) const;
	T errordefault() const;
};

template<typename T> struct generic_mdget : public generic_dget<T>
{
	using generic_dget<T>::operator();
	T operator()(multistream_decoder& e) const;
};

struct samplerate
{
	samplerate(int32_t _fs) { fs = _fs; }
	static samplerate r8k;
	static samplerate r12k;
	static samplerate r16k;
	static samplerate r24k;
	static samplerate r48k;
	operator int32_t() { return fs; }
	typedef samplerate erettype;
	samplerate operator()(encoder& e) const;
	samplerate operator()(multistream_encoder& e) const;
	samplerate operator()(decoder& e) const;
	samplerate operator()(multistream_decoder& e) const;
	samplerate errordefault() const { return samplerate(0); }
private:
	int32_t fs;
};

struct complexity
{
	complexity(int32_t _c) { c = _c; }
	operator int32_t() { return c; }
	static generic_meget<complexity> get;
	typedef void erettype;
	void operator()(encoder& e) const;
	void operator()(multistream_encoder& e) const;
	void operator()(surround_encoder& e) const;
	void errordefault() const {}
private:
	int32_t c;
};

struct bitrate
{
	bitrate(int32_t _b) { b = _b; }
	static bitrate _auto;
	static bitrate max;
	operator int32_t() { return b; }
	static generic_meget<bitrate> get;
	typedef void erettype;
	void operator()(encoder& e) const;
	void operator()(multistream_encoder& e) const;
	void operator()(surround_encoder& e) const;
	void errordefault() const {}
private:
	int32_t b;
};

struct vbr
{
	vbr(bool _v) { v = _v; }
	static vbr cbr;
	static vbr _vbr;
	operator bool() { return v; }
	static generic_meget<vbr> get;
	typedef void erettype;
	void operator()(encoder& e) const;
	void operator()(multistream_encoder& e) const;
	void operator()(surround_encoder& e) const;
	void errordefault() const {}
private:
	bool v;
};

struct vbr_constraint
{
	vbr_constraint(bool _c) { c = _c; }
	static vbr_constraint unconstrained;
	static vbr_constraint constrained;
	operator bool() { return c; }
	static generic_meget<vbr_constraint> get;
	typedef void erettype;
	void operator()(encoder& e) const;
	void operator()(multistream_encoder& e) const;
	void operator()(surround_encoder& e) const;
	void errordefault() const {}
private:
	bool c;
};

struct force_channels
{
	force_channels(int32_t _f) { f = _f; }
	static force_channels _auto;
	static force_channels mono;
	static force_channels stereo;
	operator int32_t() { return f; }
	static generic_meget<force_channels> get;
	typedef void erettype;
	void operator()(encoder& e) const;
	void operator()(multistream_encoder& e) const;
	void operator()(surround_encoder& e) const;
	void errordefault() const {}
private:
	int32_t f;
};

struct max_bandwidth
{
	max_bandwidth(int32_t _bw) { bw = _bw; }
	static max_bandwidth narrow;
	static max_bandwidth medium;
	static max_bandwidth wide;
	static max_bandwidth superwide;
	static max_bandwidth full;
	operator int32_t() { return bw; }
	static generic_eget<max_bandwidth> get;
	typedef void erettype;
	void operator()(encoder& e) const;
	void errordefault() const {}
private:
	int32_t bw;
};

struct bandwidth
{
	bandwidth(int32_t _bw) { bw = _bw; }
	static bandwidth _auto;
	static bandwidth narrow;
	static bandwidth medium;
	static bandwidth wide;
	static bandwidth superwide;
	static bandwidth full;
	operator int32_t() { return bw; }
	static generic_mget<bandwidth> get;
	typedef void erettype;
	void operator()(encoder& e) const;
	void operator()(multistream_encoder& e) const;
	void operator()(surround_encoder& e) const;
	void errordefault() const {}
private:
	int32_t bw;
};

struct signal
{
	signal(int32_t _s) { s = _s; }
	static signal _auto;
	static signal music;
	static signal voice;
	operator int32_t() { return s; }
	static generic_meget<signal> get;
	typedef void erettype;
	void operator()(encoder& e) const;
	void operator()(multistream_encoder& e) const;
	void operator()(surround_encoder& e) const;
	void errordefault() const {}
private:
	int32_t s;
};

struct application
{
	application(int32_t _app) { app = _app; };
	static application audio;
	static application voice;
	static application lowdelay;
	operator int32_t() { return app; }
	static generic_meget<application> get;
	typedef void erettype;
	void operator()(encoder& e) const;
	void operator()(multistream_encoder& e) const;
	void operator()(surround_encoder& e) const;
	void errordefault() const {}
private:
	int32_t app;
};

struct _lookahead
{
	_lookahead() { l = 0; }
	_lookahead(uint32_t _l) { l = _l; }
	operator uint32_t() { return l; }
	typedef _lookahead erettype;
	_lookahead operator()(encoder& e) const;
	_lookahead operator()(multistream_encoder& e) const;
	void operator()(surround_encoder& e) const;
	_lookahead errordefault() const { return _lookahead(0);}
private:
	uint32_t l;
};
extern _lookahead lookahead;

struct fec
{
	fec(bool _f) { f = _f; }
	static fec disabled;
	static fec enabled;
	operator bool() { return f; }
	static generic_meget<fec> get;
	typedef void erettype;
	void operator()(encoder& e) const;
	void operator()(multistream_encoder& e) const;
	void operator()(surround_encoder& e) const;
	void errordefault() const {}
private:
	bool f;
};

struct lossperc
{
	lossperc(uint32_t _loss) { loss = _loss; };
	operator uint32_t() { return loss; }
	static generic_meget<lossperc> get;
	typedef void erettype;
	void operator()(encoder& e) const;
	void operator()(multistream_encoder& e) const;
	void operator()(surround_encoder& e) const;
	void errordefault() const {}
private:
	uint32_t loss;
};

struct dtx
{
	dtx(bool _d) { d = _d; }
	static dtx disabled;
	static dtx enabled;
	operator bool() { return d; }
	static generic_meget<dtx> get;
	typedef void erettype;
	void operator()(encoder& e) const;
	void operator()(multistream_encoder& e) const;
	void operator()(surround_encoder& e) const;
	void errordefault() const {}
private:
	bool d;
};

struct lsbdepth
{
	lsbdepth(uint32_t _depth) { depth = _depth; };
	static lsbdepth d8;
	static lsbdepth d16;
	static lsbdepth d24;
	operator uint32_t() { return depth; }
	static generic_meget<lsbdepth> get;
	typedef void erettype;
	void operator()(encoder& e) const;
	void operator()(multistream_encoder& e) const;
	void operator()(surround_encoder& e) const;
	void errordefault() const {}
private:
	uint32_t depth;
};

struct _pktduration
{
	_pktduration() { d = 0; }
	_pktduration(uint32_t _d) { d = _d; }
	operator uint32_t() { return d; }
	typedef _pktduration drettype;
	_pktduration operator()(decoder& e) const;
	_pktduration operator()(multistream_decoder& e) const;
	void operator()(surround_encoder& e) const;
	_pktduration errordefault() const; /*{ return _pktduration(0); }*/
private:
	uint32_t d;
};
extern _pktduration pktduration;

struct _reset
{
	typedef void drettype;
	typedef void erettype;
	void operator()(decoder& e) const;
	void operator()(encoder& e) const;
	void operator()(multistream_decoder& e) const;
	void operator()(multistream_encoder& e) const;
	void operator()(surround_encoder& e) const;
	void errordefault() const {}
};
extern _reset reset;

struct _finalrange
{
	_finalrange() { f = 0; }
	_finalrange(uint32_t _f) { f = _f; }
	operator uint32_t() { return f; }
	typedef _finalrange drettype;
	typedef _finalrange erettype;
	_finalrange operator()(decoder& e) const;
	_finalrange operator()(encoder& e) const;
	_finalrange operator()(multistream_decoder& e) const;
	_finalrange operator()(multistream_encoder& e) const;
	_finalrange operator()(surround_encoder& e) const;
	_finalrange errordefault() const { return _finalrange(0); }
private:
	uint32_t f;
};
extern _finalrange finalrange;

struct _pitch
{
	_pitch() { p = 0; }
	_pitch(uint32_t _p) { p = _p; }
	operator uint32_t() { return p; }
	typedef _pitch drettype;
	typedef _pitch erettype;
	_pitch operator()(encoder& e) const;
	_pitch operator()(decoder& e) const;
	_pitch errordefault() const { return _pitch(0); }
private:
	uint32_t p;
};
extern _pitch pitch;

struct gain
{
	gain(int32_t _g) { g = _g; };
	operator int32_t() { return g; }
	static generic_mdget<gain> get;
	typedef void drettype;
	void operator()(decoder& d) const;
	void operator()(multistream_decoder& d) const;
	gain errordefault() const { return gain(0); }
private:
	int32_t g;
};

struct prediction_disabled
{
	prediction_disabled(bool _d) { d = _d; }
	static prediction_disabled disabled;
	static prediction_disabled enabled;
	operator bool() { return d; }
	static generic_meget<prediction_disabled> get;
	typedef void erettype;
	void operator()(encoder& e) const;
	void operator()(multistream_encoder& e) const;
	void operator()(surround_encoder& e) const;
	void errordefault() const { }
private:
	bool d;
};

struct frame_duration
{
	frame_duration(int32_t _v) { v = _v; }
	static frame_duration argument;
	static frame_duration variable;
	static frame_duration l2ms;	//Really 2.5ms.
	static frame_duration l5ms;
	static frame_duration l10ms;
	static frame_duration l20ms;
	static frame_duration l40ms;
	static frame_duration l60ms;
	operator int32_t() { return v; }
	static generic_meget<frame_duration> get;
	typedef void erettype;
	void operator()(encoder& e) const;
	void operator()(multistream_encoder& e) const;
	void operator()(surround_encoder& e) const;
	void errordefault() const { }
private:
	int32_t v;
};

struct _last_packet_duration
{
	_last_packet_duration() { p = 0; }
	_last_packet_duration(uint32_t _p) { p = _p; }
	operator uint32_t() { return p; }
	typedef _last_packet_duration drettype;
	_last_packet_duration operator()(decoder& e) const;
	_last_packet_duration operator()(multistream_decoder& e) const;
	_last_packet_duration errordefault() const { return _last_packet_duration(0); }
private:
	uint32_t p;
};
extern _last_packet_duration last_packet_duration;



struct set_control_int
{
	set_control_int(int32_t _ctl, int32_t _val) { ctl = _ctl; val = _val; }
	typedef void drettype;
	typedef void erettype;
	void operator()(encoder& e) const;
	void operator()(decoder& e) const;
	void operator()(multistream_encoder& e) const;
	void operator()(multistream_decoder& e) const;
	void operator()(surround_encoder& e) const;
	void errordefault() const {}
private:
	int32_t ctl;
	int32_t val;
};

struct get_control_int
{
	get_control_int(int32_t _ctl) { ctl = _ctl; }
	typedef int32_t drettype;
	typedef int32_t erettype;
	int32_t operator()(encoder& e) const;
	int32_t operator()(decoder& e) const;
	int32_t operator()(multistream_encoder& e) const;
	int32_t operator()(multistream_decoder& e) const;
	int32_t operator()(surround_encoder& e) const;
	int32_t errordefault() const { return -1; }
private:
	int32_t ctl;
};

class encoder
{
public:
	encoder(samplerate rate, bool stereo, application app, char* memory = NULL);
	encoder(void* state, bool _stereo);
	~encoder();
	encoder(const encoder& e);
	encoder(const encoder& e, char* memory);
	static size_t size(bool stereo);
	size_t size() const { return size(stereo); }
	encoder& operator=(const encoder& e);
	template<typename T> typename T::erettype ctl(const T& c) { return c(*this); }
	template<typename T> typename T::erettype ctl_quiet(const T& c)
	{
		try { return c(*this); } catch(...) { return c.errordefault(); }
	}
	size_t encode(const int16_t* in, uint32_t inframes, unsigned char* out, uint32_t maxout);
	size_t encode(const float* in, uint32_t inframes, unsigned char* out, uint32_t maxout);
	bool is_stereo() { return stereo; }
	void* getmem() { return memory; }
private:
	void* memory;
	bool stereo;
	bool user;
};

class decoder
{
public:
	decoder(samplerate rate, bool stereo, char* memory = NULL);
	decoder(void* state, bool _stereo);
	~decoder();
	decoder(const decoder& e);
	decoder(const decoder& e, char* memory);
	static size_t size(bool stereo);
	size_t size() const { return size(stereo); }
	decoder& operator=(const decoder& e);
	template<typename T> typename T::drettype ctl(const T& c) { return c(*this); }
	template<typename T> typename T::drettype ctl_quiet(const T& c)
	{
		try { return c(*this); } catch(...) { return c.errordefault(); }
	}
	size_t decode(const unsigned char* in, uint32_t insize, int16_t* out, uint32_t maxframes,
		bool decode_fec = false);
	size_t decode(const unsigned char* in, uint32_t insize, float* out, uint32_t maxframes,
		bool decode_fec = false);
	uint32_t get_nb_samples(const unsigned char* buf, size_t bufsize);
	bool is_stereo() { return stereo; }
	void* getmem() { return memory; }
private:
	void* memory;
	bool stereo;
	bool user;
};

class repacketizer
{
public:
	repacketizer(char* memory = NULL);
	repacketizer(const repacketizer& rp);
	repacketizer(const repacketizer& rp, char* memory);
	repacketizer& operator=(const repacketizer& rp);
	~repacketizer();
	static size_t size();
	void cat(const unsigned char* data, size_t len);
	size_t out(unsigned char* data, size_t maxlen);
	size_t out(unsigned char* data, size_t maxlen, unsigned begin, unsigned end);
	unsigned get_nb_frames();
	void* getmem() { return memory; }
private:
	void* memory;
	bool user;
};

class multistream_encoder
{
public:
	multistream_encoder(samplerate rate, unsigned channels, unsigned streams,
		unsigned coupled_streams, const unsigned char* mapping, application app, char* memory = NULL);
	static size_t size(unsigned streams, unsigned coupled_streams);
	size_t size() const { return size(streams, coupled); }
	multistream_encoder(const multistream_encoder& e);
	multistream_encoder(const multistream_encoder& e, char* memory);
	multistream_encoder& operator=(const multistream_encoder& e);
	~multistream_encoder();
	encoder& operator[](size_t idx);
	size_t encode(const int16_t* in, uint32_t inframes, unsigned char* out, uint32_t maxout);
	size_t encode(const float* in, uint32_t inframes, unsigned char* out, uint32_t maxout);
	template<typename T> typename T::erettype ctl(const T& c) { return c(*this); }
	template<typename T> typename T::erettype ctl_quiet(const T& c)
	{
		try { return c(*this); } catch(...) { return c.errordefault(); }
	}
	uint8_t get_channels() { return channels; }
	uint8_t get_streams() { return streams; }
	void* getmem() { return memory + offset; }
private:
	void init_copy(const multistream_encoder& e, char* memory);
	char* substream(size_t idx);
	void init_structures(unsigned _channels, unsigned _streams, unsigned _coupled);
	char* memory;
	bool user;
	uint8_t channels;
	uint8_t streams;
	uint8_t coupled;
	size_t offset;
	size_t opussize;
};

class surround_encoder
{
public:
	struct stream_format
	{
		unsigned family;
		unsigned channels;
		unsigned streams;
		unsigned coupled;
		unsigned char mapping[256];
	};
	surround_encoder(samplerate rate, unsigned channels, unsigned family, application app,
		stream_format& format, char* memory = NULL);
	static size_t size(unsigned channels, unsigned family);
	size_t size() const { return size(channels, family); }
	surround_encoder(const surround_encoder& e);
	surround_encoder(const surround_encoder& e, char* memory);
	surround_encoder& operator=(const surround_encoder& e);
	~surround_encoder();
	encoder& operator[](size_t idx);
	size_t encode(const int16_t* in, uint32_t inframes, unsigned char* out, uint32_t maxout);
	size_t encode(const float* in, uint32_t inframes, unsigned char* out, uint32_t maxout);
	template<typename T> typename T::erettype ctl(const T& c) { return c(*this); }
	template<typename T> typename T::erettype ctl_quiet(const T& c)
	{
		try { return c(*this); } catch(...) { return c.errordefault(); }
	}
	uint8_t get_channels() { return channels; }
	uint8_t get_streams() { return streams; }
	void* getmem() { return memory + offset; }
private:
	void init_copy(const surround_encoder& e, char* memory);
	char* substream(size_t idx);
	void init_structures(unsigned _channels, unsigned _streams, unsigned _coupled, unsigned _family);
	char* memory;
	bool user;
	uint8_t channels;
	uint8_t streams;
	uint8_t coupled;
	uint8_t family;
	size_t offset;
	size_t opussize;
};

class multistream_decoder
{
public:
	multistream_decoder(samplerate rate, unsigned channels, unsigned streams,
		unsigned coupled_streams, const unsigned char* mapping, char* memory = NULL);
	static size_t size(unsigned streams, unsigned coupled_streams);
	size_t size() const { return size(streams, coupled); }
	multistream_decoder(const multistream_decoder& e);
	multistream_decoder(const multistream_decoder& e, char* memory);
	multistream_decoder& operator=(const multistream_decoder& e);
	~multistream_decoder();
	decoder& operator[](size_t idx);
	template<typename T> typename T::drettype ctl(const T& c) { return c(*this); }
	template<typename T> typename T::drettype ctl_quiet(const T& c)
	{
		try { return c(*this); } catch(...) { return c.errordefault(); }
	}
	size_t decode(const unsigned char* in, uint32_t insize, int16_t* out, uint32_t maxframes,
		bool decode_fec = false);
	size_t decode(const unsigned char* in, uint32_t insize, float* out, uint32_t maxframes,
		bool decode_fec = false);
	uint8_t get_channels() { return channels; }
	uint8_t get_streams() { return streams; }
	void* getmem() { return memory + offset; }
private:
	void init_copy(const multistream_decoder& e, char* memory);
	char* substream(size_t idx);
	void init_structures(unsigned _channels, unsigned _streams, unsigned _coupled);
	char* memory;
	bool user;
	uint8_t channels;
	uint8_t streams;
	uint8_t coupled;
	size_t offset;
	size_t opussize;
};

struct parsed_frame
{
	const unsigned char* ptr;
	short size;
};

struct parsed_packet
{
	unsigned char toc;
	std::vector<parsed_frame> frames;
	uint32_t payload_offset;
};

uint32_t packet_get_nb_frames(const unsigned char* packet, size_t len);
uint32_t packet_get_samples_per_frame(const unsigned char* data, samplerate fs);
uint32_t packet_get_nb_samples(const unsigned char* packet, size_t len, samplerate fs);
uint32_t packet_get_nb_channels(const unsigned char* packet);
bandwidth packet_get_bandwidth(const unsigned char* packet);
parsed_packet packet_parse(const unsigned char* packet, size_t len);
std::string version();

/**
 * Get tick (2.5ms) count from opus packet.
 *
 * Parameter packet: The packet data.
 * Parameter packetsize: The size of packet.
 *
 * Note: Guaranteed not to read more than 2 bytes from the packet.
 */
uint8_t packet_tick_count(const uint8_t* packet, size_t packetsize);
}
#endif