899 lines
30 KiB
C++
899 lines
30 KiB
C++
//
|
|
// Copyright (c) 2013-2025 The SRS Authors
|
|
//
|
|
// SPDX-License-Identifier: MIT
|
|
//
|
|
|
|
#ifndef SRS_UTEST_APP14_HPP
|
|
#define SRS_UTEST_APP14_HPP
|
|
|
|
/*
|
|
#include <srs_utest_app14.hpp>
|
|
*/
|
|
#include <srs_utest.hpp>
|
|
|
|
#include <srs_app_config.hpp>
|
|
#include <srs_app_dvr.hpp>
|
|
#include <srs_app_factory.hpp>
|
|
#include <srs_app_gb28181.hpp>
|
|
#include <srs_app_server.hpp>
|
|
#include <srs_protocol_http_client.hpp>
|
|
#include <srs_protocol_http_stack.hpp>
|
|
#include <srs_protocol_raw_avc.hpp>
|
|
#include <srs_protocol_rtmp_conn.hpp>
|
|
#include <srs_utest_app11.hpp>
|
|
#include <srs_utest_app6.hpp>
|
|
|
|
#ifdef SRS_RTSP
|
|
#include <srs_app_rtsp_conn.hpp>
|
|
#endif
|
|
|
|
// Mock ISrsGbMuxer for testing SrsGbSession
|
|
class MockGbMuxer : public ISrsGbMuxer
|
|
{
|
|
public:
|
|
bool setup_called_;
|
|
std::string setup_output_;
|
|
bool on_ts_message_called_;
|
|
srs_error_t on_ts_message_error_;
|
|
|
|
public:
|
|
MockGbMuxer();
|
|
virtual ~MockGbMuxer();
|
|
|
|
public:
|
|
virtual void setup(std::string output);
|
|
virtual srs_error_t on_ts_message(SrsTsMessage *msg);
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsAppConfig for testing SrsGbSession
|
|
class MockAppConfigForGbSession : public MockAppConfig
|
|
{
|
|
public:
|
|
std::string stream_caster_output_;
|
|
|
|
public:
|
|
MockAppConfigForGbSession();
|
|
virtual ~MockAppConfigForGbSession();
|
|
|
|
public:
|
|
virtual std::string get_stream_caster_output(SrsConfDirective *conf);
|
|
void set_stream_caster_output(const std::string &output);
|
|
};
|
|
|
|
// Mock ISrsPackContext for testing SrsGbSession::on_ps_pack
|
|
class MockPackContext : public ISrsPackContext
|
|
{
|
|
public:
|
|
MockPackContext();
|
|
virtual ~MockPackContext();
|
|
|
|
public:
|
|
virtual srs_error_t on_ts_message(SrsTsMessage *msg);
|
|
virtual void on_recover_mode(int nn_recover);
|
|
};
|
|
|
|
// Mock ISrsGbMediaTcpConn for testing SrsGbSession::on_media_transport
|
|
class MockGbMediaTcpConn : public ISrsGbMediaTcpConn
|
|
{
|
|
public:
|
|
bool set_cid_called_;
|
|
SrsContextId received_cid_;
|
|
bool is_connected_;
|
|
|
|
public:
|
|
MockGbMediaTcpConn();
|
|
virtual ~MockGbMediaTcpConn();
|
|
|
|
public:
|
|
virtual void setup(srs_netfd_t stfd);
|
|
virtual void setup_owner(SrsSharedResource<ISrsGbMediaTcpConn> *wrapper, ISrsInterruptable *owner_coroutine, ISrsContextIdSetter *owner_cid);
|
|
virtual bool is_connected();
|
|
virtual void interrupt();
|
|
virtual void set_cid(const SrsContextId &cid);
|
|
virtual const SrsContextId &get_id();
|
|
virtual std::string desc();
|
|
virtual srs_error_t cycle();
|
|
virtual void on_executor_done(ISrsInterruptable *executor);
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsRtcConnection for testing SrsRtcUdpNetwork
|
|
class MockRtcConnectionForUdpNetwork : public ISrsRtcConnection
|
|
{
|
|
public:
|
|
srs_error_t on_dtls_alert_error_;
|
|
std::string last_alert_type_;
|
|
std::string last_alert_desc_;
|
|
bool on_rtp_cipher_called_;
|
|
bool on_rtp_plaintext_called_;
|
|
bool on_rtcp_called_;
|
|
|
|
public:
|
|
MockRtcConnectionForUdpNetwork();
|
|
virtual ~MockRtcConnectionForUdpNetwork();
|
|
|
|
public:
|
|
// ISrsResource interface
|
|
virtual const SrsContextId &get_id();
|
|
virtual std::string desc();
|
|
virtual void on_disposing(ISrsResource *c);
|
|
|
|
public:
|
|
// ISrsDisposingHandler interface
|
|
virtual void on_before_dispose(ISrsResource *c);
|
|
|
|
public:
|
|
// ISrsExpire interface
|
|
virtual void expire();
|
|
|
|
public:
|
|
// ISrsRtcPacketSender interface
|
|
virtual srs_error_t send_rtcp(char *data, int nb_data);
|
|
virtual srs_error_t do_send_packet(SrsRtpPacket *pkt);
|
|
virtual srs_error_t send_rtcp_rr(uint32_t ssrc, SrsRtpRingBuffer *rtp_queue, const uint64_t &last_send_systime, const SrsNtp &last_send_ntp);
|
|
virtual srs_error_t send_rtcp_xr_rrtr(uint32_t ssrc);
|
|
virtual void check_send_nacks(SrsRtpNackForReceiver *nack, uint32_t ssrc, uint32_t &sent_nacks, uint32_t &timeout_nacks);
|
|
virtual srs_error_t send_rtcp_fb_pli(uint32_t ssrc, const SrsContextId &cid_of_subscriber);
|
|
|
|
public:
|
|
// ISrsRtcPacketReceiver interface
|
|
virtual srs_error_t on_rtp(SrsRtpPacket *pkt);
|
|
virtual srs_error_t on_rtcp(SrsRtcpCommon *rtcp);
|
|
|
|
public:
|
|
// ISrsRtcConnectionNackTimerHandler interface
|
|
virtual srs_error_t do_check_send_nacks();
|
|
|
|
public:
|
|
// ISrsRtcConnection interface
|
|
virtual srs_error_t on_dtls_handshake_done();
|
|
virtual srs_error_t on_dtls_alert(std::string type, std::string desc);
|
|
virtual srs_error_t on_rtp_cipher(char *data, int nb_data);
|
|
virtual srs_error_t on_rtp_plaintext(char *data, int nb_data);
|
|
virtual srs_error_t on_rtcp(char *data, int nb_data);
|
|
virtual srs_error_t on_binding_request(SrsStunPacket *r, std::string &ice_pwd);
|
|
virtual ISrsRtcNetwork *udp();
|
|
virtual ISrsRtcNetwork *tcp();
|
|
virtual void alive();
|
|
virtual bool is_alive();
|
|
virtual bool is_disposing();
|
|
virtual void switch_to_context();
|
|
virtual srs_error_t add_publisher(SrsRtcUserConfig *ruc, SrsSdp &local_sdp);
|
|
virtual srs_error_t add_player(SrsRtcUserConfig *ruc, SrsSdp &local_sdp);
|
|
virtual void set_all_tracks_status(std::string stream_uri, bool is_publish, bool status);
|
|
virtual void set_remote_sdp(const SrsSdp &sdp);
|
|
virtual void set_local_sdp(const SrsSdp &sdp);
|
|
virtual void set_state_as_waiting_stun();
|
|
virtual srs_error_t initialize(ISrsRequest *r, bool dtls, bool srtp, std::string username);
|
|
virtual std::string username();
|
|
virtual std::string token();
|
|
virtual void set_publish_token(SrsSharedPtr<SrsStreamPublishToken> publish_token);
|
|
virtual void simulate_nack_drop(int nn);
|
|
|
|
public:
|
|
void set_on_dtls_alert_error(srs_error_t err);
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsEphemeralDelta for testing SrsRtcUdpNetwork
|
|
class MockEphemeralDelta : public ISrsEphemeralDelta
|
|
{
|
|
public:
|
|
int64_t in_bytes_;
|
|
int64_t out_bytes_;
|
|
|
|
public:
|
|
MockEphemeralDelta();
|
|
virtual ~MockEphemeralDelta();
|
|
|
|
public:
|
|
virtual void add_delta(int64_t in, int64_t out);
|
|
virtual void remark(int64_t *in, int64_t *out);
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsIpListener for testing SrsGbListener::initialize
|
|
class MockIpListener : public ISrsIpListener
|
|
{
|
|
public:
|
|
std::string endpoint_ip_;
|
|
int endpoint_port_;
|
|
std::string label_;
|
|
bool set_endpoint_called_;
|
|
bool set_label_called_;
|
|
|
|
public:
|
|
MockIpListener();
|
|
virtual ~MockIpListener();
|
|
|
|
public:
|
|
virtual ISrsListener *set_endpoint(const std::string &i, int p);
|
|
virtual ISrsListener *set_label(const std::string &label);
|
|
virtual srs_error_t listen();
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsAppConfig for testing SrsGbListener::initialize
|
|
class MockAppConfigForGbListener : public MockAppConfig
|
|
{
|
|
public:
|
|
int stream_caster_listen_port_;
|
|
|
|
public:
|
|
MockAppConfigForGbListener();
|
|
virtual ~MockAppConfigForGbListener();
|
|
|
|
public:
|
|
virtual int get_stream_caster_listen(SrsConfDirective *conf);
|
|
};
|
|
|
|
// Mock ISrsHttpServeMux for testing SrsGbListener::listen_api
|
|
class MockHttpServeMuxForGbListener : public ISrsHttpServeMux
|
|
{
|
|
public:
|
|
bool handle_called_;
|
|
std::string handle_pattern_;
|
|
ISrsHttpHandler *handle_handler_;
|
|
|
|
public:
|
|
MockHttpServeMuxForGbListener();
|
|
virtual ~MockHttpServeMuxForGbListener();
|
|
|
|
public:
|
|
virtual srs_error_t handle(std::string pattern, ISrsHttpHandler *handler);
|
|
virtual srs_error_t serve_http(ISrsHttpResponseWriter *w, ISrsHttpMessage *r);
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsApiServerOwner for testing SrsGbListener::listen_api
|
|
class MockApiServerOwnerForGbListener : public ISrsApiServerOwner
|
|
{
|
|
public:
|
|
ISrsHttpServeMux *mux_;
|
|
|
|
public:
|
|
MockApiServerOwnerForGbListener();
|
|
virtual ~MockApiServerOwnerForGbListener();
|
|
|
|
public:
|
|
virtual ISrsHttpServeMux *api_server();
|
|
};
|
|
|
|
// Mock ISrsIpListener for testing SrsGbListener::listen
|
|
class MockIpListenerForGbListen : public ISrsIpListener
|
|
{
|
|
public:
|
|
bool listen_called_;
|
|
|
|
public:
|
|
MockIpListenerForGbListen();
|
|
virtual ~MockIpListenerForGbListen();
|
|
|
|
public:
|
|
virtual ISrsListener *set_endpoint(const std::string &i, int p);
|
|
virtual ISrsListener *set_label(const std::string &label);
|
|
virtual srs_error_t listen();
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsGbSession for testing SrsGbMediaTcpConn::on_ps_pack
|
|
class MockGbSessionForMediaConn : public ISrsGbSession
|
|
{
|
|
public:
|
|
bool on_ps_pack_called_;
|
|
ISrsPackContext *received_pack_;
|
|
SrsPsPacket *received_ps_;
|
|
std::vector<SrsTsMessage *> received_msgs_;
|
|
bool on_media_transport_called_;
|
|
SrsSharedResource<ISrsGbMediaTcpConn> received_media_;
|
|
|
|
public:
|
|
MockGbSessionForMediaConn();
|
|
virtual ~MockGbSessionForMediaConn();
|
|
|
|
public:
|
|
virtual void setup(SrsConfDirective *conf);
|
|
virtual void setup_owner(SrsSharedResource<ISrsGbSession> *wrapper, ISrsInterruptable *owner_coroutine, ISrsContextIdSetter *owner_cid);
|
|
virtual void on_media_transport(SrsSharedResource<ISrsGbMediaTcpConn> media);
|
|
virtual void on_ps_pack(ISrsPackContext *ctx, SrsPsPacket *ps, const std::vector<SrsTsMessage *> &msgs);
|
|
virtual const SrsContextId &get_id();
|
|
virtual std::string desc();
|
|
virtual srs_error_t cycle();
|
|
virtual void on_executor_done(ISrsInterruptable *executor);
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsResourceManager for testing SrsGbMediaTcpConn::bind_session
|
|
class MockResourceManagerForBindSession : public ISrsResourceManager
|
|
{
|
|
public:
|
|
ISrsResource *session_to_return_;
|
|
|
|
public:
|
|
MockResourceManagerForBindSession();
|
|
virtual ~MockResourceManagerForBindSession();
|
|
|
|
public:
|
|
virtual srs_error_t start();
|
|
virtual bool empty();
|
|
virtual size_t size();
|
|
virtual void add(ISrsResource *conn, bool *exists = NULL);
|
|
virtual void add_with_id(const std::string &id, ISrsResource *conn);
|
|
virtual void add_with_fast_id(uint64_t id, ISrsResource *conn);
|
|
virtual void add_with_name(const std::string &name, ISrsResource *conn);
|
|
virtual ISrsResource *at(int index);
|
|
virtual ISrsResource *find_by_id(std::string id);
|
|
virtual ISrsResource *find_by_fast_id(uint64_t id);
|
|
virtual ISrsResource *find_by_name(std::string name);
|
|
virtual void remove(ISrsResource *c);
|
|
virtual void subscribe(ISrsDisposingHandler *h);
|
|
virtual void unsubscribe(ISrsDisposingHandler *h);
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsBasicRtmpClient for testing SrsGbMuxer
|
|
class MockGbRtmpClient : public ISrsBasicRtmpClient
|
|
{
|
|
public:
|
|
bool connect_called_;
|
|
bool publish_called_;
|
|
bool close_called_;
|
|
srs_error_t connect_error_;
|
|
srs_error_t publish_error_;
|
|
int stream_id_;
|
|
|
|
public:
|
|
MockGbRtmpClient();
|
|
virtual ~MockGbRtmpClient();
|
|
|
|
public:
|
|
virtual srs_error_t connect();
|
|
virtual void close();
|
|
virtual srs_error_t publish(int chunk_size, bool with_vhost = true, std::string *pstream = NULL);
|
|
virtual srs_error_t play(int chunk_size, bool with_vhost = true, std::string *pstream = NULL);
|
|
virtual void kbps_sample(const char *label, srs_utime_t age);
|
|
virtual int sid();
|
|
virtual srs_error_t recv_message(SrsRtmpCommonMessage **pmsg);
|
|
virtual srs_error_t decode_message(SrsRtmpCommonMessage *msg, SrsRtmpCommand **ppacket);
|
|
virtual srs_error_t send_and_free_messages(SrsMediaPacket **msgs, int nb_msgs);
|
|
virtual srs_error_t send_and_free_message(SrsMediaPacket *msg);
|
|
virtual void set_recv_timeout(srs_utime_t timeout);
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsRawAacStream for testing SrsGbMuxer
|
|
class MockGbRawAacStream : public ISrsRawAacStream
|
|
{
|
|
public:
|
|
bool adts_demux_called_;
|
|
bool mux_sequence_header_called_;
|
|
bool mux_aac2flv_called_;
|
|
srs_error_t adts_demux_error_;
|
|
srs_error_t mux_sequence_header_error_;
|
|
srs_error_t mux_aac2flv_error_;
|
|
std::string sequence_header_output_;
|
|
int demux_frame_size_;
|
|
|
|
public:
|
|
MockGbRawAacStream();
|
|
virtual ~MockGbRawAacStream();
|
|
|
|
public:
|
|
virtual srs_error_t adts_demux(SrsBuffer *stream, char **pframe, int *pnb_frame, SrsRawAacStreamCodec &codec);
|
|
virtual srs_error_t mux_sequence_header(SrsRawAacStreamCodec *codec, std::string &sh);
|
|
virtual srs_error_t mux_aac2flv(char *frame, int nb_frame, SrsRawAacStreamCodec *codec, uint32_t dts, char **flv, int *nb_flv);
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsMpegpsQueue for testing SrsGbMuxer
|
|
class MockGbMpegpsQueue : public ISrsMpegpsQueue
|
|
{
|
|
public:
|
|
bool push_called_;
|
|
srs_error_t push_error_;
|
|
int push_count_;
|
|
|
|
public:
|
|
MockGbMpegpsQueue();
|
|
virtual ~MockGbMpegpsQueue();
|
|
|
|
public:
|
|
virtual srs_error_t push(SrsMediaPacket *msg);
|
|
virtual SrsMediaPacket *dequeue();
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsGbSession for testing SrsGbMuxer
|
|
class MockGbSessionForMuxer : public ISrsGbSession
|
|
{
|
|
public:
|
|
std::string device_id_;
|
|
|
|
public:
|
|
MockGbSessionForMuxer();
|
|
virtual ~MockGbSessionForMuxer();
|
|
|
|
public:
|
|
virtual void setup(SrsConfDirective *conf);
|
|
virtual void setup_owner(SrsSharedResource<ISrsGbSession> *wrapper, ISrsInterruptable *owner_coroutine, ISrsContextIdSetter *owner_cid);
|
|
virtual void on_media_transport(SrsSharedResource<ISrsGbMediaTcpConn> media);
|
|
virtual void on_ps_pack(ISrsPackContext *ctx, SrsPsPacket *ps, const std::vector<SrsTsMessage *> &msgs);
|
|
virtual const SrsContextId &get_id();
|
|
virtual std::string desc();
|
|
virtual srs_error_t cycle();
|
|
virtual void on_executor_done(ISrsInterruptable *executor);
|
|
};
|
|
|
|
// Mock ISrsInterruptable for testing SrsRtcTcpConn
|
|
class MockInterruptableForRtcTcpConn : public ISrsInterruptable
|
|
{
|
|
public:
|
|
bool interrupt_called_;
|
|
srs_error_t pull_error_;
|
|
|
|
public:
|
|
MockInterruptableForRtcTcpConn();
|
|
virtual ~MockInterruptableForRtcTcpConn();
|
|
|
|
public:
|
|
virtual void interrupt();
|
|
virtual srs_error_t pull();
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsContextIdSetter for testing SrsRtcTcpConn
|
|
class MockContextIdSetterForRtcTcpConn : public ISrsContextIdSetter
|
|
{
|
|
public:
|
|
bool set_cid_called_;
|
|
SrsContextId received_cid_;
|
|
|
|
public:
|
|
MockContextIdSetterForRtcTcpConn();
|
|
virtual ~MockContextIdSetterForRtcTcpConn();
|
|
|
|
public:
|
|
virtual void set_cid(const SrsContextId &cid);
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsRtcConnection for testing SrsRtcTcpConn
|
|
class MockRtcConnectionForTcpConn : public ISrsRtcConnection
|
|
{
|
|
public:
|
|
MockRtcConnectionForTcpConn();
|
|
virtual ~MockRtcConnectionForTcpConn();
|
|
|
|
public:
|
|
virtual const SrsContextId &get_id();
|
|
virtual std::string desc();
|
|
virtual void on_disposing(ISrsResource *c);
|
|
virtual void on_before_dispose(ISrsResource *c);
|
|
virtual void expire();
|
|
virtual srs_error_t send_rtcp(char *data, int nb_data);
|
|
virtual srs_error_t send_rtcp_rr(uint32_t ssrc, SrsRtpRingBuffer *rtp_queue, const uint64_t &last_send_systime, const SrsNtp &last_send_ntp);
|
|
virtual srs_error_t send_rtcp_xr_rrtr(uint32_t ssrc);
|
|
virtual void check_send_nacks(SrsRtpNackForReceiver *nack, uint32_t ssrc, uint32_t &sent_nacks, uint32_t &timeout_nacks);
|
|
virtual srs_error_t send_rtcp_fb_pli(uint32_t ssrc, const SrsContextId &cid_of_subscriber);
|
|
virtual srs_error_t do_send_packet(SrsRtpPacket *pkt);
|
|
virtual srs_error_t do_check_send_nacks();
|
|
virtual void on_connection_established();
|
|
virtual srs_error_t on_dtls_alert(std::string type, std::string desc);
|
|
virtual srs_error_t on_dtls_handshake_done();
|
|
virtual srs_error_t on_dtls_application_data(const char *data, const int len);
|
|
virtual srs_error_t on_rtp_cipher(char *data, int nb_data);
|
|
virtual srs_error_t on_rtp_plaintext(char *buf, int nb_buf);
|
|
virtual srs_error_t on_rtcp(char *buf, int nb_buf);
|
|
virtual srs_error_t on_binding_request(SrsStunPacket *r, std::string &ice_pwd);
|
|
virtual ISrsRtcNetwork *udp();
|
|
virtual ISrsRtcNetwork *tcp();
|
|
virtual void alive();
|
|
virtual bool is_alive();
|
|
virtual bool is_disposing();
|
|
virtual void switch_to_context();
|
|
virtual srs_error_t add_publisher(SrsRtcUserConfig *ruc, SrsSdp &local_sdp);
|
|
virtual srs_error_t add_player(SrsRtcUserConfig *ruc, SrsSdp &local_sdp);
|
|
virtual void set_all_tracks_status(std::string stream_uri, bool is_publish, bool status);
|
|
virtual void set_remote_sdp(const SrsSdp &sdp);
|
|
virtual void set_local_sdp(const SrsSdp &sdp);
|
|
virtual void set_state_as_waiting_stun();
|
|
virtual srs_error_t initialize(ISrsRequest *r, bool dtls, bool srtp, std::string username);
|
|
virtual std::string username();
|
|
virtual std::string token();
|
|
virtual void set_publish_token(SrsSharedPtr<SrsStreamPublishToken> publish_token);
|
|
virtual void simulate_nack_drop(int nn);
|
|
};
|
|
|
|
// Mock ISrsPsPackHandler for testing SrsPackContext
|
|
class MockPsPackHandler : public ISrsPsPackHandler
|
|
{
|
|
public:
|
|
bool on_ps_pack_called_;
|
|
int on_ps_pack_count_;
|
|
uint32_t last_pack_id_;
|
|
int last_msgs_count_;
|
|
srs_error_t on_ps_pack_error_;
|
|
|
|
public:
|
|
MockPsPackHandler();
|
|
virtual ~MockPsPackHandler();
|
|
|
|
public:
|
|
virtual srs_error_t on_ps_pack(SrsPsPacket *ps, const std::vector<SrsTsMessage *> &msgs);
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsHttpMessage for testing SrsGoApiGbPublish
|
|
class MockHttpMessageForGbPublish : public SrsHttpMessage
|
|
{
|
|
public:
|
|
std::string body_content_;
|
|
MockHttpConn *mock_conn_;
|
|
|
|
public:
|
|
MockHttpMessageForGbPublish();
|
|
virtual ~MockHttpMessageForGbPublish();
|
|
|
|
public:
|
|
virtual srs_error_t body_read_all(std::string &body);
|
|
};
|
|
|
|
// Mock ISrsResourceManager for testing SrsGoApiGbPublish
|
|
class MockResourceManagerForGbPublish : public ISrsResourceManager
|
|
{
|
|
public:
|
|
std::map<std::string, ISrsResource *> id_map_;
|
|
std::map<uint64_t, ISrsResource *> fast_id_map_;
|
|
|
|
public:
|
|
MockResourceManagerForGbPublish();
|
|
virtual ~MockResourceManagerForGbPublish();
|
|
|
|
public:
|
|
virtual srs_error_t start();
|
|
virtual bool empty();
|
|
virtual size_t size();
|
|
virtual void add(ISrsResource *conn, bool *exists = NULL);
|
|
virtual void add_with_id(const std::string &id, ISrsResource *conn);
|
|
virtual void add_with_fast_id(uint64_t id, ISrsResource *conn);
|
|
virtual void add_with_name(const std::string &name, ISrsResource *conn);
|
|
virtual ISrsResource *at(int index);
|
|
virtual ISrsResource *find_by_id(std::string id);
|
|
virtual ISrsResource *find_by_fast_id(uint64_t id);
|
|
virtual ISrsResource *find_by_name(std::string name);
|
|
virtual void remove(ISrsResource *c);
|
|
virtual void subscribe(ISrsDisposingHandler *h);
|
|
virtual void unsubscribe(ISrsDisposingHandler *h);
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsGbSession for testing SrsGoApiGbPublish
|
|
class MockGbSessionForApiPublish : public ISrsGbSession
|
|
{
|
|
public:
|
|
bool setup_called_;
|
|
bool setup_owner_called_;
|
|
SrsConfDirective *setup_conf_;
|
|
ISrsInterruptable *owner_coroutine_;
|
|
|
|
public:
|
|
MockGbSessionForApiPublish();
|
|
virtual ~MockGbSessionForApiPublish();
|
|
|
|
public:
|
|
virtual void setup(SrsConfDirective *conf);
|
|
virtual void setup_owner(SrsSharedResource<ISrsGbSession> *wrapper, ISrsInterruptable *owner_coroutine, ISrsContextIdSetter *owner_cid);
|
|
virtual void on_media_transport(SrsSharedResource<ISrsGbMediaTcpConn> media);
|
|
virtual void on_ps_pack(ISrsPackContext *ctx, SrsPsPacket *ps, const std::vector<SrsTsMessage *> &msgs);
|
|
virtual const SrsContextId &get_id();
|
|
virtual std::string desc();
|
|
virtual srs_error_t cycle();
|
|
virtual void on_executor_done(ISrsInterruptable *executor);
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsAppFactory for testing SrsGoApiGbPublish
|
|
class MockAppFactoryForGbPublish : public ISrsAppFactory
|
|
{
|
|
public:
|
|
MockGbSessionForApiPublish *mock_gb_session_;
|
|
|
|
public:
|
|
MockAppFactoryForGbPublish();
|
|
virtual ~MockAppFactoryForGbPublish();
|
|
|
|
public:
|
|
virtual ISrsFileWriter *create_file_writer();
|
|
virtual ISrsFileWriter *create_enc_file_writer();
|
|
virtual ISrsFileReader *create_file_reader();
|
|
virtual SrsPath *create_path();
|
|
virtual SrsLiveSource *create_live_source();
|
|
virtual ISrsOriginHub *create_origin_hub();
|
|
virtual ISrsHourGlass *create_hourglass(const std::string &name, ISrsHourGlassHandler *handler, srs_utime_t interval);
|
|
virtual ISrsBasicRtmpClient *create_rtmp_client(std::string url, srs_utime_t cto, srs_utime_t sto);
|
|
virtual SrsHttpClient *create_http_client();
|
|
virtual ISrsHttpResponseReader *create_http_response_reader(ISrsHttpResponseReader *r);
|
|
virtual ISrsFileReader *create_http_file_reader(ISrsHttpResponseReader *r);
|
|
virtual ISrsFlvDecoder *create_flv_decoder();
|
|
virtual ISrsBasicRtmpClient *create_basic_rtmp_client(std::string url, srs_utime_t ctm, srs_utime_t stm);
|
|
#ifdef SRS_RTSP
|
|
virtual ISrsRtspSendTrack *create_rtsp_audio_send_track(ISrsRtspConnection *session, SrsRtcTrackDescription *track_desc);
|
|
virtual ISrsRtspSendTrack *create_rtsp_video_send_track(ISrsRtspConnection *session, SrsRtcTrackDescription *track_desc);
|
|
#endif
|
|
virtual ISrsFlvTransmuxer *create_flv_transmuxer();
|
|
virtual ISrsMp4Encoder *create_mp4_encoder();
|
|
virtual SrsDvrFlvSegmenter *create_dvr_flv_segmenter();
|
|
virtual SrsDvrMp4Segmenter *create_dvr_mp4_segmenter();
|
|
virtual ISrsGbMediaTcpConn *create_gb_media_tcp_conn();
|
|
virtual ISrsGbSession *create_gb_session();
|
|
virtual ISrsInitMp4 *create_init_mp4();
|
|
virtual ISrsFragmentWindow *create_fragment_window();
|
|
virtual ISrsFragmentedMp4 *create_fragmented_mp4();
|
|
virtual ISrsIpListener *create_tcp_listener(ISrsTcpHandler *handler);
|
|
virtual ISrsRtcConnection *create_rtc_connection(ISrsExecRtcAsyncTask *exec, const SrsContextId &cid);
|
|
virtual ISrsFFMPEG *create_ffmpeg(std::string ffmpeg_bin);
|
|
virtual ISrsIngesterFFMPEG *create_ingester_ffmpeg();
|
|
// ISrsKernelFactory interface methods
|
|
virtual ISrsCoroutine *create_coroutine(const std::string &name, ISrsCoroutineHandler *handler, SrsContextId cid);
|
|
virtual ISrsTime *create_time();
|
|
virtual ISrsConfig *create_config();
|
|
virtual ISrsCond *create_cond();
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsRtcNetwork for testing SrsRtcNetworks
|
|
class MockRtcNetworkForNetworks : public ISrsRtcNetwork
|
|
{
|
|
public:
|
|
srs_error_t initialize_error_;
|
|
bool initialize_called_;
|
|
SrsSessionConfig *last_cfg_;
|
|
bool last_dtls_;
|
|
bool last_srtp_;
|
|
SrsRtcNetworkState state_;
|
|
bool is_established_;
|
|
|
|
public:
|
|
MockRtcNetworkForNetworks();
|
|
virtual ~MockRtcNetworkForNetworks();
|
|
|
|
public:
|
|
virtual srs_error_t initialize(SrsSessionConfig *cfg, bool dtls, bool srtp);
|
|
virtual void set_state(SrsRtcNetworkState state);
|
|
virtual srs_error_t on_dtls_handshake_done();
|
|
virtual srs_error_t on_dtls_alert(std::string type, std::string desc);
|
|
virtual srs_error_t on_dtls(char *data, int nb_data);
|
|
virtual srs_error_t protect_rtp(void *packet, int *nb_cipher);
|
|
virtual srs_error_t protect_rtcp(void *packet, int *nb_cipher);
|
|
virtual srs_error_t on_stun(SrsStunPacket *r, char *data, int nb_data);
|
|
virtual srs_error_t on_rtp(char *data, int nb_data);
|
|
virtual srs_error_t on_rtcp(char *data, int nb_data);
|
|
virtual bool is_establelished();
|
|
virtual srs_error_t write(void *buf, size_t size, ssize_t *nwrite);
|
|
|
|
public:
|
|
void reset();
|
|
void set_initialize_error(srs_error_t err);
|
|
};
|
|
|
|
// Mock ISrsRtcTransport for testing SrsRtcUdpNetwork RTP/RTCP handling
|
|
class MockRtcTransportForUdpNetwork : public ISrsRtcTransport
|
|
{
|
|
public:
|
|
srs_error_t unprotect_rtp_error_;
|
|
srs_error_t unprotect_rtcp_error_;
|
|
bool unprotect_rtp_called_;
|
|
bool unprotect_rtcp_called_;
|
|
int unprotected_rtp_size_;
|
|
int unprotected_rtcp_size_;
|
|
|
|
public:
|
|
MockRtcTransportForUdpNetwork();
|
|
virtual ~MockRtcTransportForUdpNetwork();
|
|
|
|
public:
|
|
virtual srs_error_t initialize(SrsSessionConfig *cfg);
|
|
virtual srs_error_t start_active_handshake();
|
|
virtual srs_error_t on_dtls(char *data, int nb_data);
|
|
virtual srs_error_t on_dtls_alert(std::string type, std::string desc);
|
|
virtual srs_error_t protect_rtp(void *packet, int *nb_cipher);
|
|
virtual srs_error_t protect_rtcp(void *packet, int *nb_cipher);
|
|
virtual srs_error_t unprotect_rtp(void *packet, int *nb_plaintext);
|
|
virtual srs_error_t unprotect_rtcp(void *packet, int *nb_plaintext);
|
|
// ISrsDtlsCallback interface
|
|
virtual srs_error_t on_dtls_handshake_done();
|
|
virtual srs_error_t on_dtls_application_data(const char *data, const int len);
|
|
virtual srs_error_t write_dtls_data(void *data, int size);
|
|
|
|
public:
|
|
void reset();
|
|
void set_unprotect_rtp_error(srs_error_t err);
|
|
void set_unprotect_rtcp_error(srs_error_t err);
|
|
};
|
|
|
|
// Mock ISrsResourceManager for testing SrsRtcUdpNetwork::update_sendonly_socket
|
|
class MockResourceManagerForUdpNetwork : public ISrsResourceManager
|
|
{
|
|
public:
|
|
std::map<std::string, ISrsResource *> id_map_;
|
|
std::map<uint64_t, ISrsResource *> fast_id_map_;
|
|
|
|
public:
|
|
MockResourceManagerForUdpNetwork();
|
|
virtual ~MockResourceManagerForUdpNetwork();
|
|
|
|
public:
|
|
virtual srs_error_t start();
|
|
virtual bool empty();
|
|
virtual size_t size();
|
|
virtual void add(ISrsResource *conn, bool *exists = NULL);
|
|
virtual void add_with_id(const std::string &id, ISrsResource *conn);
|
|
virtual void add_with_fast_id(uint64_t id, ISrsResource *conn);
|
|
virtual void add_with_name(const std::string &name, ISrsResource *conn);
|
|
virtual ISrsResource *at(int index);
|
|
virtual ISrsResource *find_by_id(std::string id);
|
|
virtual ISrsResource *find_by_fast_id(uint64_t id);
|
|
virtual ISrsResource *find_by_name(std::string name);
|
|
virtual void remove(ISrsResource *c);
|
|
virtual void subscribe(ISrsDisposingHandler *h);
|
|
virtual void unsubscribe(ISrsDisposingHandler *h);
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsUdpMuxSocket for testing SrsRtcUdpNetwork STUN handling
|
|
class MockUdpMuxSocket : public ISrsUdpMuxSocket
|
|
{
|
|
public:
|
|
srs_error_t sendto_error_;
|
|
int sendto_called_count_;
|
|
int last_sendto_size_;
|
|
std::string peer_ip_;
|
|
int peer_port_;
|
|
std::string peer_id_;
|
|
uint64_t fast_id_;
|
|
char *data_;
|
|
int size_;
|
|
|
|
public:
|
|
MockUdpMuxSocket();
|
|
virtual ~MockUdpMuxSocket();
|
|
|
|
public:
|
|
virtual srs_error_t sendto(void *data, int size, srs_utime_t timeout);
|
|
virtual std::string get_peer_ip() const;
|
|
virtual int get_peer_port() const;
|
|
virtual std::string peer_id();
|
|
virtual uint64_t fast_id();
|
|
virtual SrsUdpMuxSocket *copy_sendonly();
|
|
virtual int recvfrom(srs_utime_t timeout);
|
|
virtual char *data();
|
|
virtual int size();
|
|
|
|
public:
|
|
void reset();
|
|
void set_sendto_error(srs_error_t err);
|
|
};
|
|
|
|
// Mock ISrsProtocolReadWriter for testing SrsRtcTcpNetwork write operations
|
|
class MockProtocolReadWriterForTcpNetwork : public ISrsProtocolReadWriter
|
|
{
|
|
public:
|
|
std::vector<std::string> written_data_;
|
|
srs_error_t write_error_;
|
|
int64_t send_bytes_;
|
|
int64_t recv_bytes_;
|
|
srs_utime_t send_timeout_;
|
|
srs_utime_t recv_timeout_;
|
|
std::string read_data_;
|
|
size_t read_pos_;
|
|
|
|
public:
|
|
MockProtocolReadWriterForTcpNetwork();
|
|
virtual ~MockProtocolReadWriterForTcpNetwork();
|
|
|
|
public:
|
|
virtual srs_error_t read_fully(void *buf, size_t size, ssize_t *nread);
|
|
virtual srs_error_t write(void *buf, size_t size, ssize_t *nwrite);
|
|
virtual void set_recv_timeout(srs_utime_t tm);
|
|
virtual srs_utime_t get_recv_timeout();
|
|
virtual int64_t get_recv_bytes();
|
|
virtual void set_send_timeout(srs_utime_t tm);
|
|
virtual srs_utime_t get_send_timeout();
|
|
virtual int64_t get_send_bytes();
|
|
virtual srs_error_t writev(const iovec *iov, int iov_size, ssize_t *nwrite);
|
|
virtual srs_error_t read(void *buf, size_t size, ssize_t *nread);
|
|
|
|
public:
|
|
void reset();
|
|
void set_write_error(srs_error_t err);
|
|
void set_read_data(const std::string &data);
|
|
};
|
|
|
|
// Mock ISrsResourceManager for testing SrsRtcTcpConn::handshake
|
|
class MockResourceManagerForTcpConnHandshake : public ISrsResourceManager
|
|
{
|
|
public:
|
|
ISrsResource *session_to_return_;
|
|
|
|
public:
|
|
MockResourceManagerForTcpConnHandshake();
|
|
virtual ~MockResourceManagerForTcpConnHandshake();
|
|
|
|
public:
|
|
virtual srs_error_t start();
|
|
virtual bool empty();
|
|
virtual size_t size();
|
|
virtual void add(ISrsResource *conn, bool *exists = NULL);
|
|
virtual void add_with_id(const std::string &id, ISrsResource *conn);
|
|
virtual void add_with_fast_id(uint64_t id, ISrsResource *conn);
|
|
virtual void add_with_name(const std::string &name, ISrsResource *conn);
|
|
virtual ISrsResource *at(int index);
|
|
virtual ISrsResource *find_by_id(std::string id);
|
|
virtual ISrsResource *find_by_fast_id(uint64_t id);
|
|
virtual ISrsResource *find_by_name(std::string name);
|
|
virtual void remove(ISrsResource *c);
|
|
virtual void subscribe(ISrsDisposingHandler *h);
|
|
virtual void unsubscribe(ISrsDisposingHandler *h);
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsRtcConnection for testing SrsRtcTcpConn::handshake
|
|
class MockRtcConnectionForTcpConnHandshake : public ISrsRtcConnection
|
|
{
|
|
public:
|
|
ISrsRtcNetwork *tcp_network_;
|
|
std::string ice_pwd_;
|
|
bool switch_to_context_called_;
|
|
bool on_binding_request_called_;
|
|
|
|
public:
|
|
MockRtcConnectionForTcpConnHandshake();
|
|
virtual ~MockRtcConnectionForTcpConnHandshake();
|
|
|
|
public:
|
|
virtual const SrsContextId &get_id();
|
|
virtual std::string desc();
|
|
virtual void on_disposing(ISrsResource *c);
|
|
virtual void on_before_dispose(ISrsResource *c);
|
|
virtual void expire();
|
|
virtual srs_error_t send_rtcp(char *data, int nb_data);
|
|
virtual srs_error_t send_rtcp_rr(uint32_t ssrc, SrsRtpRingBuffer *rtp_queue, const uint64_t &last_send_systime, const SrsNtp &last_send_ntp);
|
|
virtual srs_error_t send_rtcp_xr_rrtr(uint32_t ssrc);
|
|
virtual void check_send_nacks(SrsRtpNackForReceiver *nack, uint32_t ssrc, uint32_t &sent_nacks, uint32_t &timeout_nacks);
|
|
virtual srs_error_t send_rtcp_fb_pli(uint32_t ssrc, const SrsContextId &cid_of_subscriber);
|
|
virtual srs_error_t do_send_packet(SrsRtpPacket *pkt);
|
|
virtual srs_error_t do_check_send_nacks();
|
|
virtual void on_connection_established();
|
|
virtual srs_error_t on_dtls_alert(std::string type, std::string desc);
|
|
virtual srs_error_t on_dtls_handshake_done();
|
|
virtual srs_error_t on_dtls_application_data(const char *data, const int len);
|
|
virtual srs_error_t on_rtp_cipher(char *data, int nb_data);
|
|
virtual srs_error_t on_rtp_plaintext(char *buf, int nb_buf);
|
|
virtual srs_error_t on_rtcp(char *buf, int nb_buf);
|
|
virtual srs_error_t on_binding_request(SrsStunPacket *r, std::string &ice_pwd);
|
|
virtual ISrsRtcNetwork *udp();
|
|
virtual ISrsRtcNetwork *tcp();
|
|
virtual void alive();
|
|
virtual bool is_alive();
|
|
virtual bool is_disposing();
|
|
virtual void switch_to_context();
|
|
virtual srs_error_t add_publisher(SrsRtcUserConfig *ruc, SrsSdp &local_sdp);
|
|
virtual srs_error_t add_player(SrsRtcUserConfig *ruc, SrsSdp &local_sdp);
|
|
virtual void set_all_tracks_status(std::string stream_uri, bool is_publish, bool status);
|
|
virtual void set_remote_sdp(const SrsSdp &sdp);
|
|
virtual void set_local_sdp(const SrsSdp &sdp);
|
|
virtual void set_state_as_waiting_stun();
|
|
virtual srs_error_t initialize(ISrsRequest *r, bool dtls, bool srtp, std::string username);
|
|
virtual std::string username();
|
|
virtual std::string token();
|
|
virtual void set_publish_token(SrsSharedPtr<SrsStreamPublishToken> publish_token);
|
|
virtual void simulate_nack_drop(int nn);
|
|
|
|
public:
|
|
void reset();
|
|
};
|
|
|
|
#endif
|