myvtm/Other/libaudiomgr/linux/libaudiomgr_linux.h

#pragma once

#include "../iaudiomgrinterface.h"
#include <pthread.h>
#include <stdint.h>
#include <assert.h>
#include <pulse/pulseaudio.h>
#include <pulse/sample.h>
#include <stdio.h>
#include <errno.h>

#include "audiodevicepulse.h"

#ifndef MAX_PATH_EX
#define MAX_PATH_EX 512
#endif

#ifndef MAX_PATH
#define MAX_PATH 260
#endif

#ifndef NSEC_PER_SEC
#define NSEC_PER_SEC 1000000000LL
#endif

/*Audio stream flag*/
#define AUDIO_STRM_ON       (1)
#define AUDIO_STRM_OFF      (0)

/*Audio Buffer flags*/
#define AUDIO_BUFF_FREE     (0)
#define AUDIO_BUFF_USED     (1)

#define __THREAD_TYPE pthread_t
#define __THREAD_CREATE(t,f,d) (pthread_create(t,NULL,f,d))
#define __THREAD_CREATE_ATTRIB(t,a,f,d) (pthread_create(t,a,f,d))
#define __THREAD_JOIN(t) (pthread_join(t, NULL))

#define __ATTRIB_TYPE pthread_attr_t
#define __INIT_ATTRIB(t) (pthread_attr_init(t))
#define __ATTRIB_JOINABLE(t) (pthread_attr_setdetachstate(t, PTHREAD_CREATE_JOINABLE))
#define __CLOSE_ATTRIB(t) (pthread_attr_destroy(t))

#define __MUTEX_TYPE pthread_mutex_t
#define __STATIC_MUTEX_INIT PTHREAD_MUTEX_INITIALIZER
#define __INIT_MUTEX(m) ( pthread_mutex_init(m, NULL) )
#define __CLOSE_MUTEX(m) ( pthread_mutex_destroy(m) )
#define __LOCK_MUTEX(m) ( pthread_mutex_lock(m) )
#define __UNLOCK_MUTEX(m) ( pthread_mutex_unlock(m) )

#define __COND_TYPE pthread_cond_t
#define __INIT_COND(c)  ( pthread_cond_init (c, NULL) )
#define __CLOSE_COND(c) ( pthread_cond_destroy(c) )
#define __COND_BCAST(c) ( pthread_cond_broadcast(c) )
#define __COND_SIGNAL(c) ( pthread_cond_signal(c) )
#define __COND_TIMED_WAIT(c,m,t) ( pthread_cond_timedwait(c,m,t) )

/*next index of ring buffer with size elements*/
#define NEXT_IND(ind,size) ind++;if(ind>=size) ind=0

/*internally is always float*/
typedef int16_t sample_t;

typedef struct rvc_audio_device_s
{
	int id;							/*audo device id*/
	int channels;					/*max channels*/
	int samprate;					/*default samplerate*/
	double low_latency;				/*default low latency*/
	double high_latency;			/*default high latency*/
	char name[MAX_PATH_EX];         /*device name*/
	char description[MAX_PATH];		/*device description*/
} rvc_audio_device_t;

typedef struct rvc_audio_context_s
{
	int num_input_dev;            /*number of audio input devices in list*/
	rvc_audio_device_t* list_input_devices; /*audio input devices list*/

	int num_output_dev;
	rvc_audio_device_t* list_output_devices; /*audio output devices list*/

	int device;                   /*current device list index*/
	int channels;                 /*channels*/
	int samprate;                 /*sample rate*/
	double latency;               /*current sugested latency*/
	pa_sample_format_t eformat;

	/*all ts are monotonic based: both real and generated*/
	int64_t current_ts;           /*current buffer generated timestamp*/
	int64_t last_ts;              /*last real timestamp (in nanosec)*/
	int64_t snd_begintime;        /*sound capture start ref time*/
	int64_t ts_drift;             /*drift between real and generated ts*/

	sample_t* capture_buff;       /*pointer to capture data*/
	int capture_buff_size;        /*capture buffer size (bytes)*/
	float capture_buff_level[2];  /*capture buffer channels level*/

	volatile int stream_flag;              /*stream flag*/

	audiocap_param_t audio_param;
}rvc_audio_context_t;


typedef struct  rvc_audio_volume_s{
	int volume_flag;
	char strdevicename[MAX_PATH];
	pa_cvolume cvolumes;
}rvc_audio_volume_t;

typedef struct  rvc_volume_set_s {
	int volume_flag;
	char strdevicename[MAX_PATH];
	int ivolume;
}rvc_volume_set_t;


class AudioMgrImpl : public IAudioMgr
{
public:
	AudioMgrImpl(audiomgr_callback_t* pCallback);
	~AudioMgrImpl();

	int audio_mgr_initialize();
	int audio_mgr_terminate();
	int audio_get_device_count(bool binput);
	int audio_get_device_name(char* pstrbuf, size_t ulen, bool binput, int index);
	int audio_get_device_id(const char* pstrname, bool binput);

	int audio_get_device_volume(int* ivolume, const char* pstrname, bool binput);
	int audiopulse_get_device_volume(int* ivolume, const char* pstrname, bool binput);
	int audio_set_device_volume(int ivolume, const char* pstrname, bool binput);
	int audiopulse_set_device_volume(int ivolume, const char* pstrname, bool binput);

	int set_audio_capture_params(audiocap_param_t* param);
	int start_audio_capture();
	int stop_audio_capture();
	int audio_mgr_destroy();

	rvc_audio_context_t* audio_get_context();
	audiomgr_callback_t* audio_get_callback();
	void audiolog(const char* fmt, ...);

private:
	int audio_init_pulseaudio();
	int pa_get_devicelist();
	int audio_close_pulseaudio();
	rvc_audio_device_t* audio_get_input_device(int index);
	rvc_audio_device_t* audio_get_output_device(int index);
	int audio_set_pulseaudio_device(int index);
	int audio_set_pulsecap_params(audiocap_param_t* param);
	void audio_set_latency(double latency);

private:
	rvc_audio_context_t* m_audio_context;
	audiomgr_callback_t m_callback;
	__THREAD_TYPE m_readthread;
};