#pragma once

#include "SpBase.h"
#include "EventCode.h"
#include "libaudioqueue.h"
#include "libvideoqueue.h"
#include "rvc_media_common.h"

#ifdef RVC_OS_WIN
#include <portaudio.h>
#include "videoframework.h"
#else
#include "videoutil.h"
#include "imediadeviceinfo.h"
#include "iaudiomgrinterface.h"
#include "ivideocaptureinterface.h"
#endif // RVC_OS_WIN

#ifndef INT64_C
#define INT64_C(c) (c##LL) 
#define UINT64_C(c) (c##UL) 
#endif

#include <stdint.h>
extern "C"{
	#include <libavutil/avutil.h>
	#include <libavcodec/avcodec.h>
	#include <libswscale/swscale.h>
}

#ifndef CAPTURE_FRAME_TIME
#define CAPTURE_FRAME_TIME	20 // 20ms per frame
#endif

#ifndef CAPTURE_CLOCK
#define CAPTURE_CLOCK		8000
#endif

#define  CAMERA_BUG_THRESHOLD   6
#define  CAMERA_TIMEOUT        15
#define  CAMERA_MIN_TIMEOUT	   5
#define  CAMERA_RESTARTNUM     6

#ifndef RVC_MAX_DELAY_TIME
#define RVC_MAX_DELAY_TIME 180
#endif // !RVC_MAX_DELAY_TIME

#ifndef RVC_CAM_INTERVAL_TIME
#define RVC_CAM_INTERVAL_TIME 3000
#endif // !RVC_CAM_INTERVAL_TIME

namespace MediaController {
	typedef struct capture_t capture_t;
	typedef struct rvc_sales_audio_capture_s rvc_sales_audio_capture_t;

	typedef struct capture_config_s {
		int video_env_dev; // -1 means invalid
		int video_opt_dev; // -1 means invalid
		int video_env_rotate; // counter-clockwise degree, ignore currently
		int video_opt_rotate; // counter-clockwise degree
		int video_env_fps;
		int video_opt_fps;
		CSimpleStringA strAudioIn;
		CSimpleStringA strAudioOut;
		CSimpleStringA strAudioState;
		CSimpleStringA strVideoEnv;
		CSimpleStringA strVideoOpt;
		volatile LONG *ref_env_capture_count;
		volatile LONG *ref_opt_capture_count;
		volatile LONG *ref_envopt_capture_count;
		unsigned int uintervaltime;
#ifdef RVC_OS_LINUX
		pthread_mutex_t* env_mutex;
		pthread_mutex_t* opt_mutex;
		pthread_mutex_t* envopt_mutex;
#endif
	}capture_config_t;


	typedef struct rvc_audio_capture_config_s {
		CSimpleStringA strAudioIn;					//收音设备
		CSimpleStringA strAudioOut;					//放音设备

		size_t audio_capture_samplerate;
		size_t audio_capture_period;
	}rvc_audio_capture_config_t;


	extern DeviceTypeEnum g_eDeviceType;

	typedef struct audio_capture_t {
#ifdef RVC_OS_WIN
		PaStream* stream;
#else
		IAudioMgr* paudiocap;
		char* paudio_buffer;
		size_t uaudiolen;
#endif
		Clibaudioqueue *shm_queue;
		Clibaudioqueue *salesol_shm_queue;		
		capture_t *parent;
		int iseriesnumber;
	}audio_capture_t;

	//音频采集结构体
	typedef struct rvc_audio_capture_s{
#ifdef RVC_OS_WIN
		PaStream* stream;
#else
		IAudioMgr* paudiocap;
		char* paudio_buffer;
		size_t uaudiolen;
		bool bputremote;
#endif
		Clibaudioqueue *audio_shm_queue;					// 音频包存储队列
		rvc_sales_audio_capture_t *parent;

		int iaudio_capture_samplerate;						// 音频采样率,默认值为8K
		int iaudio_capture_peroid;							// 音频采样率周期，默认20ms，每秒50个包
		int iseriesnumber;									// 音频包序号
	}rvc_audio_capture_t;

	typedef struct video_capture_t {
#ifdef RVC_OS_WIN
		videocap_t cap;
#else
		IVideoCapture* pVideoCap;
#endif
		Clibvideoqueue *snapshot_shm_queue;
		Clibvideoqueue *preview_shm_queue;
		Clibvideoqueue *rtp_shm_queue;
		capture_t *parent;
		int camera_type; // CAMERA_TYPE_xxx
		int frame_id;
		unsigned int ulastcaptime;
		struct SwsContext *preview_sws_ctx;
		struct SwsContext *rtp_sws_ctx;
		unsigned int ustarttime;
	}video_capture_t;


	struct capture_t{
		capture_config_t config;
		audio_capture_t *handfree_audio;
		video_capture_t *env_video;
		video_capture_t *opt_video;
	};

	struct rvc_sales_audio_capture_s{
		rvc_audio_capture_config_t rvc_audio_config;
		rvc_audio_capture_t *rvc_audio;
	};

	int capture_create(const capture_config_t *config, capture_t **p_cap);
	ErrorCodeEnum capture_create(const capture_config_t *config,capture_t *cap,int nCamera);
	void capture_destroy(capture_t *cap);
	ErrorCodeEnum capture_start(capture_t *cap);
	ErrorCodeEnum start_audio_capture(audio_capture_t *paudio);
	ErrorCodeEnum capture_start(capture_t *cap,int nCamera);
	void capture_stop(capture_t *cap);
	int capture_lib_init(int* ivideonum);

	int capture_detect_camera_bug(capture_t *cap, int *env_n, int *opt_n, bool bsinglecam);
	int capture_get_last_frametime(capture_t *cap, unsigned int* env_n, unsigned int* opt_n);

	int salesaudio_capture_create(rvc_audio_capture_config_t *config, rvc_sales_audio_capture_t **p_cap);
	void salesaudio_capture_destroy(rvc_sales_audio_capture_t *cap);
	ErrorCodeEnum salesrecord_audio_capture_start(rvc_sales_audio_capture_t *cap);
	void salesrecord_audio_capture_stop(rvc_sales_audio_capture_t *cap);

	void capture_lib_term();

	int capture_get_video_device_id(const char *dev_name);
	bool capture_adj_brightness(capture_t *cap,int nvalue,ErrorCodeEnum nCode);
	bool capture_set_autobrightness(capture_t *cap,ErrorCodeEnum nCode);
	int capture_get_brightness(capture_t *cap,ErrorCodeEnum nCode);
	int StopCamera(capture_t *cap,int nCamera);
	void capture_destroy(capture_t *cap,int nCamera);
	//清空抓拍队列里的照片，摄像头故障时调用
	void capture_clearsnapshotvideo(capture_t *cap,int nCamera);
	int get_camera_exception_message(char* pBuffer, size_t uLen, CSimpleStringA strDeviceName, const char* strErrorMessage);
	int capture_get_audio_device_list(bool in_direction, CSimpleStringA& strdevicelist);
	int capture_get_video_device_list(CSimpleStringA& strdevicelist);
}