/*************************************************************************************** * * IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING. * * By downloading, copying, installing or using the software you agree to this license. * If you do not agree to this license, do not download, install, * copy or use the software. * * Copyright (C) 2014-2024, Happytimesoft Corporation, all rights reserved. * * Redistribution and use in binary forms, with or without modification, are permitted. * * Unless required by applicable law or agreed to in writing, software distributed * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR * CONDITIONS OF ANY KIND, either express or implied. See the License for the specific * language governing permissions and limitations under the License. * ****************************************************************************************/ #ifndef RTSP_CLN_H #define RTSP_CLN_H #include "sys_buf.h" #include "rtsp_rcua.h" #include "media_format.h" #include "h264_rtp_rx.h" #include "mjpeg_rtp_rx.h" #include "h265_rtp_rx.h" #include "mpeg4_rtp_rx.h" #include "aac_rtp_rx.h" #include "pcm_rtp_rx.h" typedef int (*notify_cb)(int, void *); typedef int (*video_cb)(uint8 *, int, uint32, uint16, void *); typedef int (*audio_cb)(uint8 *, int, uint32, uint16, void *); typedef int (*rtcp_cb)(uint8 *, int, int, void *); typedef int (*metadata_cb)(uint8 *, int, uint32, uint16, void *); #define RTSP_EVE_STOPPED 0 // stopped #define RTSP_EVE_CONNECTING 1 // connecting #define RTSP_EVE_CONNFAIL 2 // connect failed #define RTSP_EVE_CONNSUCC 3 // connect success #define RTSP_EVE_NOSIGNAL 4 // no signal #define RTSP_EVE_RESUME 5 // resume #define RTSP_EVE_AUTHFAILED 6 // authentication failed #define RTSP_EVE_NODATA 7 // No data received within the timeout period #define RTSP_RX_FAIL -1 // rtsp data receive failed #define RTSP_RX_TIMEOUT 1 // rtsp data receive timeout #define RTSP_RX_SUCC 2 // rtsp data receive success #define RTSP_PARSE_FAIL -1 // rtsp message parse failed #define RTSP_PARSE_MOREDATA 0 // need more data to parse rtsp message #define RTSP_PARSE_SUCC 1 // rtsp message parse success class CRtspClient { public: CRtspClient(void); ~CRtspClient(void); public: BOOL rtsp_start(const char * suffix, const char * ip, int port, const char * user, const char * pass); BOOL rtsp_start(const char * url, const char * user, const char * pass); BOOL rtsp_play(int npt_start = 0); BOOL rtsp_stop(); BOOL rtsp_pause(); BOOL rtsp_close(); RCUA * get_rua() {return &m_rua;} char * get_url() {return m_url;} char * get_ip() {return m_ip;} int get_port() {return m_nport;} char * get_user() {return m_rua.auth_info.auth_name;} char * get_pass() {return m_rua.auth_info.auth_pwd;} void set_notify_cb(notify_cb notify, void * userdata); void set_video_cb(video_cb cb); void set_audio_cb(audio_cb cb); void set_metadata_cb(metadata_cb cb); void set_rtcp_cb(rtcp_cb cb); /** * @desc : set channel flags * @params : * channel: * AV_VIDEO_CH : video channel * AV_AUDIO_CH : audio channel * AV_METADATA_CH : metadata channel * AV_BACK_CH : audio back channel * * flag : 1 - If the SDP description has the channel information, then SETUP this channel, * 0 - DO NOT SETUP THIS CHANNEL * * note : All channels are setup by default */ void set_channel(int channel, int flag); /** * @desc : Set rtp multicast * @params : * flag : 1 - enable rtp multcast, 0 - disable rtp multcast */ void set_rtp_multicast(int flag); /** * @desc : Set rtp over udp * @params : * flag : 1 - enable rtp over udp, 0 - disable rtp over udp */ void set_rtp_over_udp(int flag); /** * @desc : Set rtsp over http * @params : * flag : 1 - enable rtsp over http, 0 - disable rtsp over http * port : if flag = 1, specify the http port */ void set_rtsp_over_http(int flag, int port); /** * @desc : Set rtsp over websocket * @params : * flag : 1 - enable rtsp over websocket, 0 - disable rtsp over websocket * ws_uri : if flag = 1, specify the websocket port */ void set_rtsp_over_ws(int flag, int port); /** * @desc : Set the data rx timeout, if the data is not received within the specified time, * send RTSP_EVE_NODATA notification * @params : * timeout : Timeout value, unit is second */ void set_rx_timeout(int timeout); /** * @desc : Set the connect timeout * @params : * timeout : Timeout value, unit is second */ void set_conn_timeout(int timeout); /** * @desc : Get H264, SPS, PPS parameters, and return through the video callback function */ void get_h264_params(); /** * @desc : Get H264, SPS, PPS parameters * @params * p_sps : Receive H264 SPS data, the buffer size is not less than 256 * sps_len : Receive H264 SPS buffer length * p_pps : Receive H264 PPS data, the buffer size is not less than 256 * pps_len : Receive H264 PPS buffer length */ BOOL get_h264_params(uint8 * p_sps, int * sps_len, uint8 * p_pps, int * pps_len); /** * @desc : Get H265, VPS, SPS, PPS parameters, and return through the video callback function */ void get_h265_params(); /** * @desc : Get H265, VPS, SPS, PPS parameters * @params * p_sps : Receive H264 SPS data, the buffer size is not less than 256 * sps_len : Receive H264 SPS buffer length * p_pps : Receive H264 PPS data, the buffer size is not less than 256 * pps_len : Receive H264 PPS buffer length * p_vps : Receive H264 VPS data, the buffer size is not less than 256 * vps_len : Receive H264 VPS buffer length */ BOOL get_h265_params(uint8 * p_sps, int * sps_len, uint8 * p_pps, int * pps_len, uint8 * p_vps, int * vps_len); /** * @desc : If the describe request response returned by the server has an H264 SDP description, get the H264 SDP description * @params * p_sdp : Receive H264 SDP description * max_len : Maximum length of buffer p_sdp */ BOOL get_h264_sdp_desc(char * p_sdp, int max_len); /** * @desc : If the describe request response returned by the server has an H265 SDP description, get the H265 SDP description * @params * p_sdp : Receive H265 SDP description * max_len : Maximum length of buffer p_sdp */ BOOL get_h265_sdp_desc(char * p_sdp, int max_len); /** * @desc : If the describe request response returned by the server has an H265 SDP description, get the MP4 SDP description * @params * p_sdp : Receive MP4 SDP description * max_len : Maximum length of buffer p_sdp */ BOOL get_mp4_sdp_desc(char * p_sdp, int max_len); /** * @desc : If the describe request response returned by the server has an H265 SDP description, get the AAC SDP description * @params * p_sdp : Receive AAC SDP description * max_len : Maximum length of buffer p_sdp */ BOOL get_aac_sdp_desc(char * p_sdp, int max_len); /** * @desc : Get video codec * @retrun : reference the media_format.h, VIDEO_CODEC_H264, ... */ int audio_codec() {return m_rua.audio_codec;} /** * @desc : Get audio codec * @retrun : reference the media_format.h, AUDIO_CODEC_AAC, ... */ int video_codec() {return m_rua.video_codec;} /** * @desc : Get audio sample rate */ int get_audio_samplerate() {return m_rua.sample_rate;} /** * @desc : Get audio channel numbers */ int get_audio_channels() {return m_rua.audio_channels;} /** * @desc : Get audio bits per sample, for G726 decoder */ int get_audio_bitpersample() {return m_rua.bit_per_sample;} /** * @desc : Get audio config data, for AAC */ uint8 * get_audio_config() {return m_rua.audio_spec;} /** * @desc : Get audio config data length, for AAC */ int get_audio_config_len() {return m_rua.audio_spec_len;} /** * @desc : get the audio backchannel flag */ int get_bc_flag(); /** * @desc : set the audio backchannel flag * @params * flag : 1 - enable audio backchannel; 0 - disable audio backchannel */ void set_bc_flag(int flag); /** * @desc : get the audio backchannel data sending flag */ int get_bc_data_flag(); /** * @desc : set the audio backchannel data sending flag * @params * flag : 1 - enable audio backchannel data sending; 0 - disable audio backchannel data sending */ void set_bc_data_flag(int flag); /** * @desc : set the audio backchannel audio capture device index * @params * index : audio capture device index */ void set_audio_device(int index); /** * @desc : get the replay flag */ int get_replay_flag(); /** * @desc : set the replay flag * @params * flag : 1 - enable replay; 0 - disable replay */ void set_replay_flag(int flag); /** * @desc : set the scale info * @params * scale : when not set the rata control flag, the scale is valid. * It shall be either 1.0 or -1.0, to indicate forward or reverse playback respectively. * If it is not present, forward playback is assumed */ void set_scale(double scale); /** * @desc : set the rate control flag * @params * flag : * 1-the stream is delivered in real time using standard RTP timing mechanisms * 0-the stream is delivered as fast as possible, using only the flow control provided by the transport to limit the delivery rate */ void set_rate_control_flag(int flag); /** * @desc : set the immediate flag * @params * flag : * 1 - immediately start playing from the new location, cancelling any existing PLAY command. * The first packet sent from the new location shall have the D (discontinuity) bit set in its RTP extension header. */ void set_immediate_flag(int flag); /** * @desc : set the frame flag * @params * flag : * 0 - all frames * 1 - I-frame and P-frame * 2 - I-frame * interval : * when flag = 2, set the I-frame interval */ void set_frames_flag(int flag, int interval); /** * @desc : set replay range * @params * start : the replay start timestamp * end : the replay end timestamp */ void set_replay_range(time_t start, time_t end); void tcp_rx_thread(); void udp_rx_thread(); void rtsp_video_data_cb(uint8 * p_data, int len, uint32 ts, uint32 seq); void rtsp_audio_data_cb(uint8 * p_data, int len, uint32 ts, uint32 seq); void rtsp_meta_data_cb(uint8 * p_data, int len, uint32 ts, uint32 seq); private: void set_default(); BOOL rtsp_client_start(); void rtsp_client_stop(RCUA * p_rua); BOOL rtsp_client_state(RCUA * p_rua, HRTSP_MSG * rx_msg); int rtsp_epoll_rx(); int rtsp_tcp_data_rx(RCUA * p_rua); int rtsp_over_tcp_rx(RCUA * p_rua); int rtsp_tcp_rx(); int rtsp_udp_rx(); int rtsp_msg_parser(RCUA * p_rua); void rtsp_keep_alive(); BOOL rtsp_setup_channel(RCUA * p_rua, int av_t); BOOL make_prepare_play(); BOOL rtsp_unauth_res(RCUA * p_rua, HRTSP_MSG * rx_msg); BOOL rtsp_options_res(RCUA * p_rua, HRTSP_MSG * rx_msg); BOOL rtsp_describe_res(RCUA * p_rua, HRTSP_MSG * rx_msg); BOOL rtsp_setup_res(RCUA * p_rua, HRTSP_MSG * rx_msg, int av_t); BOOL rtsp_play_res(RCUA * p_rua, HRTSP_MSG * rx_msg); BOOL rtsp_init_backchannel(RCUA * p_rua); BOOL rtsp_get_bc_media_info(); void send_notify(int event); BOOL rtsp_get_transport_info(RCUA * p_rua, HRTSP_MSG * rx_msg, int av_type); void rtsp_get_video_size(int * w, int * h); BOOL rtsp_get_video_media_info(); BOOL rtsp_get_audio_media_info(); void tcp_data_rx(uint8 * lpData, int rlen); void udp_data_rx(uint8 * lpData, int rlen, int type); void rtcp_data_rx(uint8 * lpData, int rlen, int type); void rtsp_send_h264_params(RCUA * p_rua); void rtsp_send_h265_params(RCUA * p_rua); void rtsp_get_mpeg4_config(RCUA * p_rua); void rtsp_get_aac_config(RCUA * p_rua); int rtsp_build_http_get_req(void * p_user, char * bufs, int buflen, char * cookie); int rtsp_build_http_post_req(void * p_user, char * bufs, int buflen, char * cookie); BOOL rtsp_over_http_start(); int rtsp_over_http_rx(RCUA * p_rua); int rtsp_build_ws_req(void * p_user, char * bufs, int buflen); BOOL rtsp_over_ws_start(); BOOL rtsp_ws_ping_process(RCUA * p_rua, char * p_buff, int len); BOOL rtsp_ws_rtsp_process(RCUA * p_rua, char * p_buff, int len); BOOL rtsp_ws_data_process(RCUA * p_rua); int rtsp_over_ws_rx(RCUA * p_rua); private: RCUA m_rua; char m_url[256]; char m_ip[128]; char m_suffix[128]; int m_nport; int m_ep_fd; struct epoll_event * m_ep_events; int m_ep_event_num; notify_cb m_pNotify; void * m_pUserdata; video_cb m_pVideoCB; audio_cb m_pAudioCB; rtcp_cb m_pRtcpCB; metadata_cb m_pMetadataCB; void * m_pMutex; int m_nRxTimeout; int m_nConnTimeout; int m_nWidth; int m_nHeight; union { H264RXI h264rxi; H265RXI h265rxi; MJPEGRXI mjpegrxi; MPEG4RXI mpeg4rxi; }; union { AACRXI aacrxi; PCMRXI pcmrxi; }; PCMRXI metadatarxi; BOOL m_bRunning; pthread_t m_tcpRxTid; pthread_t m_udpRxTid; }; #endif // RTSP_CLN_H