myvtm/Module/mod_mediacontroller/capture.h

#pragma once

#include "SpBase.h"
#include "../include/EventCode.h"

#include "../../Other/libaudioqueue/libaudioqueue.h"
#include "../../Other/libvideoqueue/libvideoqueue.h"
#include "../..//Other/libvideoframework/videoutil.h"

#ifdef RVC_OS_WIN
#include <portaudio.h>
#include "../../Other/libvideoframework/videoframework.h"
#else
#include "../../Other/libmediadeviceinfo/imediadeviceinfo.h"
#include "videocapobj.h"
#include "audiocapobj.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>
}

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

	typedef struct capture_config_t {
		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 strVideoEnv;
		CSimpleStringA strVideoOpt;
		volatile LONG *ref_env_capture_count;
		volatile LONG *ref_opt_capture_count;
		volatile LONG *ref_envopt_capture_count;
#ifdef RVC_OS_WIN
#else
		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;


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

#ifndef CAPTURE_CLOCK
#define CAPTURE_CLOCK		8000
#endif


	extern DeviceTypeEnum g_eDeviceType;

	//PCM音频包处理类型
	enum eRvcPCMTransType{
		eUnKnown,					// 未知类型，不做处理
		eSingleWriteLocal,			// 只写到本地
		eSingleSendRemote,			// 只发送到远端
		eWriteAndSend				// 写到本地并且发送到远端
	};

	typedef struct audio_capture_t {
#ifdef RVC_OS_WIN
		PaStream* stream;
#else
		AudioCapObj* paudiocap;
		char* paudio_buffer;
		size_t uaudiolen;
#endif
		
		Clibaudioqueue *shm_queue;
		Clibaudioqueue* handfree_shm_queue;		// 远程连线时免提音频队列
		Clibaudioqueue *salesol_shm_queue;		// 在线双录音频队列
		//PaStream *sales_stream;				// 现场销售录像音频流
		//Clibaudioqueue *sales_shm_queue;		// 现场销售录像音频队列
		capture_t *parent;

		//dev real open param
		int dev_bitspersample;
		int dev_channels;
		int dev_samplespersec;
	}audio_capture_t;

	//音频采集结构体
	typedef struct rvc_audio_capture_s{
#ifdef RVC_OS_WIN
		PaStream* stream;
#else
		AudioCapObj* paudiocap;
#endif
		Clibaudioqueue *audio_shm_queue;					// 音频包存储队列
		rvc_sales_audio_capture_t *parent;

		//dev real open param
		int dev_bitspersample;
		int dev_channels;
		int dev_samplespersec;
		//setting param
		int iaudio_capture_samplerate;						// 音频采样率,默认值为8K
		int iaudio_capture_peroid;							// 音频采样率周期，默认20ms，每秒50个包
		int iseriesnumber;									// 音频包序号
		eRvcPCMTransType eType;								// pcm音频包处理类型
		void *pdata;										// 可变参数,写本地为对应文件名，发远端为对方地址
	}rvc_audio_capture_t;

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


	struct capture_t
	{
		capture_config_t config;
		audio_capture_t *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;
	};


	typedef struct
	{
		CSimpleStringA strFriendlyName;
		CSimpleStringA strDevPath;
		CSimpleStringA strMd5Val;
	}camera_names_t;


	typedef struct write_local_info_s{
		FILE*	pFile;
	}write_local_info_t;

	typedef struct send_remote_info_s{
		char	strIP[MAX_PATH];
		size_t	uPort;
	}send_remote_info_t;

	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_detect_camera_bug(capture_t *cap, int *env_n, int *opt_n,BOOL IsPad);
	int capture_get_last_frametime(capture_t *cap,  DWORD *env_n,  DWORD *opt_n,BOOL IsPad);

	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);

	int capture_lib_init();
	int videocap_optdev_fetch(CSimpleStringA frontcam,CSimpleStringA ewscam,CAutoArray<CSimpleStringA> &hspcams,CSimpleStringA &rearcam);
	int videocap_innerdev_fetch(CSimpleStringA &frontcam,CSimpleStringA &rearcam);
	int videocap_outerdev_fetch(CSimpleStringA envcam,CSimpleStringA optcam,CSimpleStringA ewscam,CAutoArray<CSimpleStringA> &hspcams,CSimpleStringA &outercam);
	void capture_lib_term();

#ifdef RVC_OS_WIN
	int capture_get_audio_device_id(bool in_direction, const char* dev_name);
#endif
	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);
}