702 lines
23 KiB
C++
702 lines
23 KiB
C++
//
|
|
// Copyright (c) 2013-2025 The SRS Authors
|
|
//
|
|
// SPDX-License-Identifier: MIT
|
|
//
|
|
|
|
#ifndef SRS_UTEST_APP13_HPP
|
|
#define SRS_UTEST_APP13_HPP
|
|
|
|
/*
|
|
#include <srs_utest_app13.hpp>
|
|
*/
|
|
#include <srs_utest.hpp>
|
|
|
|
#include <srs_app_config.hpp>
|
|
#include <srs_app_dvr.hpp>
|
|
#include <srs_app_edge.hpp>
|
|
#include <srs_app_factory.hpp>
|
|
#include <srs_app_rtc_source.hpp>
|
|
#include <srs_app_rtmp_conn.hpp>
|
|
#include <srs_app_rtsp_conn.hpp>
|
|
#include <srs_app_rtsp_source.hpp>
|
|
#include <srs_app_statistic.hpp>
|
|
#include <srs_kernel_balance.hpp>
|
|
#include <srs_kernel_flv.hpp>
|
|
#include <srs_kernel_mp4.hpp>
|
|
#include <srs_protocol_http_client.hpp>
|
|
#include <srs_protocol_http_stack.hpp>
|
|
#include <srs_protocol_json.hpp>
|
|
#include <srs_protocol_rtmp_conn.hpp>
|
|
#include <srs_protocol_rtmp_stack.hpp>
|
|
#include <srs_protocol_rtsp_stack.hpp>
|
|
#include <srs_utest_app12.hpp>
|
|
#include <srs_utest_app6.hpp>
|
|
|
|
// Mock request class for testing edge upstream
|
|
class MockEdgeRequest : public ISrsRequest
|
|
{
|
|
public:
|
|
MockEdgeRequest(std::string vhost = "__defaultVhost__", std::string app = "live", std::string stream = "test");
|
|
virtual ~MockEdgeRequest();
|
|
virtual ISrsRequest *copy();
|
|
virtual std::string get_stream_url();
|
|
virtual void update_auth(ISrsRequest *req);
|
|
virtual void strip();
|
|
virtual ISrsRequest *as_http();
|
|
};
|
|
|
|
// Mock config class for testing edge upstream
|
|
class MockEdgeConfig : public MockAppConfig
|
|
{
|
|
public:
|
|
SrsConfDirective *edge_origin_directive_;
|
|
std::string edge_transform_vhost_;
|
|
int chunk_size_;
|
|
|
|
public:
|
|
MockEdgeConfig();
|
|
virtual ~MockEdgeConfig();
|
|
void reset();
|
|
|
|
public:
|
|
// Override methods needed for edge upstream testing
|
|
virtual SrsConfDirective *get_vhost_edge_origin(std::string vhost);
|
|
virtual std::string get_vhost_edge_transform_vhost(std::string vhost);
|
|
virtual int get_chunk_size(std::string vhost);
|
|
virtual srs_utime_t get_vhost_edge_origin_connect_timeout(std::string vhost);
|
|
virtual srs_utime_t get_vhost_edge_origin_stream_timeout(std::string vhost);
|
|
// DVR methods
|
|
virtual std::string get_dvr_path(std::string vhost);
|
|
virtual int get_dvr_time_jitter(std::string vhost);
|
|
virtual bool get_dvr_wait_keyframe(std::string vhost);
|
|
virtual bool get_dvr_enabled(std::string vhost);
|
|
virtual srs_utime_t get_dvr_duration(std::string vhost);
|
|
virtual SrsConfDirective *get_dvr_apply(std::string vhost);
|
|
virtual std::string get_dvr_plan(std::string vhost);
|
|
};
|
|
|
|
// Mock RTMP client for testing edge upstream
|
|
class MockEdgeRtmpClient : public ISrsBasicRtmpClient
|
|
{
|
|
public:
|
|
bool connect_called_;
|
|
bool play_called_;
|
|
bool close_called_;
|
|
bool recv_message_called_;
|
|
bool decode_message_called_;
|
|
bool set_recv_timeout_called_;
|
|
bool kbps_sample_called_;
|
|
srs_error_t connect_error_;
|
|
srs_error_t play_error_;
|
|
std::string play_stream_;
|
|
srs_utime_t recv_timeout_;
|
|
std::string kbps_label_;
|
|
srs_utime_t kbps_age_;
|
|
|
|
public:
|
|
MockEdgeRtmpClient();
|
|
virtual ~MockEdgeRtmpClient();
|
|
|
|
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);
|
|
};
|
|
|
|
// Mock app factory for testing edge upstream
|
|
class MockEdgeAppFactory : public SrsAppFactory
|
|
{
|
|
public:
|
|
MockEdgeRtmpClient *mock_client_;
|
|
|
|
public:
|
|
MockEdgeAppFactory();
|
|
virtual ~MockEdgeAppFactory();
|
|
|
|
public:
|
|
virtual ISrsBasicRtmpClient *create_rtmp_client(std::string url, srs_utime_t cto, srs_utime_t sto);
|
|
};
|
|
|
|
// Mock HTTP client for testing edge FLV upstream
|
|
class MockEdgeHttpClient : public ISrsHttpClient
|
|
{
|
|
public:
|
|
bool initialize_called_;
|
|
bool get_called_;
|
|
bool set_recv_timeout_called_;
|
|
bool kbps_sample_called_;
|
|
srs_error_t initialize_error_;
|
|
srs_error_t get_error_;
|
|
ISrsHttpMessage *mock_response_;
|
|
std::string schema_;
|
|
std::string host_;
|
|
int port_;
|
|
std::string path_;
|
|
std::string kbps_label_;
|
|
srs_utime_t kbps_age_;
|
|
|
|
public:
|
|
MockEdgeHttpClient();
|
|
virtual ~MockEdgeHttpClient();
|
|
|
|
public:
|
|
virtual srs_error_t initialize(std::string schema, std::string h, int p, srs_utime_t tm);
|
|
virtual srs_error_t get(std::string path, std::string req, ISrsHttpMessage **ppmsg);
|
|
virtual srs_error_t post(std::string path, std::string req, ISrsHttpMessage **ppmsg);
|
|
virtual void set_recv_timeout(srs_utime_t tm);
|
|
virtual void kbps_sample(const char *label, srs_utime_t age);
|
|
};
|
|
|
|
// Mock HTTP message for testing edge FLV upstream
|
|
class MockEdgeHttpMessage : public ISrsHttpMessage
|
|
{
|
|
public:
|
|
int status_code_;
|
|
SrsHttpHeader *header_;
|
|
ISrsHttpResponseReader *body_reader_;
|
|
|
|
public:
|
|
MockEdgeHttpMessage();
|
|
virtual ~MockEdgeHttpMessage();
|
|
|
|
public:
|
|
virtual uint8_t message_type();
|
|
virtual uint8_t method();
|
|
virtual uint16_t status_code();
|
|
virtual std::string method_str();
|
|
virtual bool is_http_get();
|
|
virtual bool is_http_put();
|
|
virtual bool is_http_post();
|
|
virtual bool is_http_delete();
|
|
virtual bool is_http_options();
|
|
virtual std::string uri();
|
|
virtual std::string url();
|
|
virtual std::string host();
|
|
virtual std::string path();
|
|
virtual std::string query();
|
|
virtual std::string ext();
|
|
virtual srs_error_t body_read_all(std::string &body);
|
|
virtual ISrsHttpResponseReader *body_reader();
|
|
virtual int64_t content_length();
|
|
virtual std::string query_get(std::string key);
|
|
virtual SrsHttpHeader *header();
|
|
virtual bool is_jsonp();
|
|
virtual bool is_keep_alive();
|
|
virtual std::string parse_rest_id(std::string pattern);
|
|
};
|
|
|
|
// Mock file reader for testing edge FLV upstream
|
|
class MockEdgeFileReader : public ISrsFileReader
|
|
{
|
|
public:
|
|
char *data_;
|
|
int size_;
|
|
int pos_;
|
|
|
|
public:
|
|
MockEdgeFileReader(const char *data, int size);
|
|
virtual ~MockEdgeFileReader();
|
|
|
|
public:
|
|
virtual srs_error_t open(std::string p);
|
|
virtual void close();
|
|
virtual bool is_open();
|
|
virtual int64_t tellg();
|
|
virtual void skip(int64_t size);
|
|
virtual int64_t seek2(int64_t offset);
|
|
virtual int64_t filesize();
|
|
virtual srs_error_t read(void *buf, size_t count, ssize_t *pnread);
|
|
virtual srs_error_t lseek(off_t offset, int whence, off_t *seeked);
|
|
};
|
|
|
|
// Mock FLV decoder for testing edge FLV upstream
|
|
class MockEdgeFlvDecoder : public ISrsFlvDecoder
|
|
{
|
|
public:
|
|
bool initialize_called_;
|
|
bool read_header_called_;
|
|
bool read_previous_tag_size_called_;
|
|
|
|
public:
|
|
MockEdgeFlvDecoder();
|
|
virtual ~MockEdgeFlvDecoder();
|
|
|
|
public:
|
|
virtual srs_error_t initialize(ISrsReader *fr);
|
|
virtual srs_error_t read_header(char header[9]);
|
|
virtual srs_error_t read_tag_header(char *ptype, int32_t *pdata_size, uint32_t *ptime);
|
|
virtual srs_error_t read_tag_data(char *data, int32_t size);
|
|
virtual srs_error_t read_previous_tag_size(char previous_tag_size[4]);
|
|
};
|
|
|
|
// Mock app factory for testing edge FLV upstream
|
|
class MockEdgeFlvAppFactory : public SrsAppFactory
|
|
{
|
|
public:
|
|
MockEdgeHttpClient *mock_http_client_;
|
|
MockEdgeFileReader *mock_file_reader_;
|
|
MockEdgeFlvDecoder *mock_flv_decoder_;
|
|
|
|
public:
|
|
MockEdgeFlvAppFactory();
|
|
virtual ~MockEdgeFlvAppFactory();
|
|
|
|
public:
|
|
virtual ISrsHttpClient *create_http_client();
|
|
virtual ISrsFileReader *create_http_file_reader(ISrsHttpResponseReader *r);
|
|
virtual ISrsFlvDecoder *create_flv_decoder();
|
|
};
|
|
|
|
// Mock play edge for testing SrsEdgeIngester
|
|
class MockPlayEdge : public ISrsPlayEdge
|
|
{
|
|
public:
|
|
int on_ingest_play_count_;
|
|
srs_error_t on_ingest_play_error_;
|
|
|
|
public:
|
|
MockPlayEdge();
|
|
virtual ~MockPlayEdge();
|
|
|
|
public:
|
|
virtual srs_error_t on_ingest_play();
|
|
void reset();
|
|
};
|
|
|
|
// Mock edge upstream for testing SrsEdgeIngester::process_publish_message
|
|
class MockEdgeUpstreamForIngester : public ISrsEdgeUpstream
|
|
{
|
|
public:
|
|
bool decode_message_called_;
|
|
SrsRtmpCommand *decode_message_packet_;
|
|
srs_error_t decode_message_error_;
|
|
|
|
public:
|
|
MockEdgeUpstreamForIngester();
|
|
virtual ~MockEdgeUpstreamForIngester();
|
|
|
|
public:
|
|
virtual srs_error_t connect(ISrsRequest *r, ISrsLbRoundRobin *lb);
|
|
virtual srs_error_t recv_message(SrsRtmpCommonMessage **pmsg);
|
|
virtual srs_error_t decode_message(SrsRtmpCommonMessage *msg, SrsRtmpCommand **ppacket);
|
|
virtual void close();
|
|
virtual void selected(std::string &server, int &port);
|
|
virtual void set_recv_timeout(srs_utime_t tm);
|
|
virtual void kbps_sample(const char *label, srs_utime_t age);
|
|
void reset();
|
|
};
|
|
|
|
// Mock publish edge for testing SrsEdgeForwarder
|
|
class MockPublishEdge : public ISrsPublishEdge
|
|
{
|
|
public:
|
|
MockPublishEdge();
|
|
virtual ~MockPublishEdge();
|
|
};
|
|
|
|
// Mock edge ingester for testing SrsPlayEdge
|
|
class MockEdgeIngester : public ISrsEdgeIngester
|
|
{
|
|
public:
|
|
bool initialize_called_;
|
|
bool start_called_;
|
|
bool stop_called_;
|
|
srs_error_t initialize_error_;
|
|
srs_error_t start_error_;
|
|
|
|
public:
|
|
MockEdgeIngester();
|
|
virtual ~MockEdgeIngester();
|
|
|
|
public:
|
|
virtual srs_error_t initialize(SrsSharedPtr<SrsLiveSource> s, ISrsPlayEdge *e, ISrsRequest *r);
|
|
virtual srs_error_t start();
|
|
virtual void stop();
|
|
void reset();
|
|
};
|
|
|
|
// Mock edge forwarder for testing SrsPublishEdge
|
|
class MockEdgeForwarder : public ISrsEdgeForwarder
|
|
{
|
|
public:
|
|
bool initialize_called_;
|
|
bool start_called_;
|
|
bool stop_called_;
|
|
bool set_queue_size_called_;
|
|
bool proxy_called_;
|
|
srs_utime_t queue_size_;
|
|
srs_error_t initialize_error_;
|
|
srs_error_t start_error_;
|
|
srs_error_t proxy_error_;
|
|
|
|
public:
|
|
MockEdgeForwarder();
|
|
virtual ~MockEdgeForwarder();
|
|
|
|
public:
|
|
virtual void set_queue_size(srs_utime_t queue_size);
|
|
virtual srs_error_t initialize(SrsSharedPtr<SrsLiveSource> s, ISrsPublishEdge *e, ISrsRequest *r);
|
|
virtual srs_error_t start();
|
|
virtual void stop();
|
|
virtual srs_error_t proxy(SrsRtmpCommonMessage *msg);
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsStatistic for testing SrsRtspPlayStream
|
|
class MockStatisticForRtspPlayStream : public ISrsStatistic
|
|
{
|
|
public:
|
|
int on_client_count_;
|
|
srs_error_t on_client_error_;
|
|
|
|
public:
|
|
MockStatisticForRtspPlayStream();
|
|
virtual ~MockStatisticForRtspPlayStream();
|
|
|
|
public:
|
|
virtual void on_disconnect(std::string id, srs_error_t err);
|
|
virtual srs_error_t on_client(std::string id, ISrsRequest *req, ISrsExpire *conn, SrsRtmpConnType type);
|
|
virtual srs_error_t on_video_info(ISrsRequest *req, SrsVideoCodecId vcodec, int avc_profile, int avc_level, int width, int height);
|
|
virtual srs_error_t on_audio_info(ISrsRequest *req, SrsAudioCodecId acodec, SrsAudioSampleRate asample_rate, SrsAudioChannels asound_type, SrsAacObjectType aac_object);
|
|
virtual void on_stream_publish(ISrsRequest *req, std::string publisher_id);
|
|
virtual void on_stream_close(ISrsRequest *req);
|
|
virtual void kbps_add_delta(std::string id, ISrsKbpsDelta *delta);
|
|
virtual void kbps_sample();
|
|
virtual srs_error_t on_video_frames(ISrsRequest *req, int nb_frames);
|
|
virtual std::string server_id();
|
|
virtual std::string service_id();
|
|
virtual std::string service_pid();
|
|
virtual SrsStatisticVhost *find_vhost_by_id(std::string vid);
|
|
virtual SrsStatisticStream *find_stream(std::string sid);
|
|
virtual SrsStatisticStream *find_stream_by_url(std::string url);
|
|
virtual SrsStatisticClient *find_client(std::string client_id);
|
|
virtual srs_error_t dumps_vhosts(SrsJsonArray *arr);
|
|
virtual srs_error_t dumps_streams(SrsJsonArray *arr, int start, int count);
|
|
virtual srs_error_t dumps_clients(SrsJsonArray *arr, int start, int count);
|
|
virtual srs_error_t dumps_metrics(int64_t &send_bytes, int64_t &recv_bytes, int64_t &nstreams, int64_t &nclients, int64_t &total_nclients, int64_t &nerrs);
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsRtspSourceManager for testing SrsRtspPlayStream
|
|
class MockRtspSourceManager : public ISrsRtspSourceManager
|
|
{
|
|
public:
|
|
int fetch_or_create_count_;
|
|
srs_error_t fetch_or_create_error_;
|
|
SrsSharedPtr<SrsRtspSource> mock_source_;
|
|
|
|
public:
|
|
MockRtspSourceManager();
|
|
virtual ~MockRtspSourceManager();
|
|
|
|
public:
|
|
virtual srs_error_t initialize();
|
|
virtual srs_error_t fetch_or_create(ISrsRequest *r, SrsSharedPtr<SrsRtspSource> &pps);
|
|
virtual SrsSharedPtr<SrsRtspSource> fetch(ISrsRequest *r);
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsRtspSendTrack for testing SrsRtspPlayStream
|
|
class MockRtspSendTrack : public ISrsRtspSendTrack
|
|
{
|
|
public:
|
|
std::string track_id_;
|
|
SrsRtcTrackDescription *track_desc_;
|
|
bool track_status_;
|
|
int on_rtp_count_;
|
|
uint32_t last_ssrc_;
|
|
uint16_t last_sequence_;
|
|
|
|
public:
|
|
MockRtspSendTrack(std::string track_id, SrsRtcTrackDescription *desc);
|
|
virtual ~MockRtspSendTrack();
|
|
|
|
public:
|
|
virtual bool set_track_status(bool active);
|
|
virtual std::string get_track_id();
|
|
virtual SrsRtcTrackDescription *track_desc();
|
|
virtual srs_error_t on_rtp(SrsRtpPacket *pkt);
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsAppFactory for testing SrsRtspPlayStream
|
|
class MockAppFactoryForRtspPlayStream : public SrsAppFactory
|
|
{
|
|
public:
|
|
int create_rtsp_audio_send_track_count_;
|
|
int create_rtsp_video_send_track_count_;
|
|
|
|
public:
|
|
MockAppFactoryForRtspPlayStream();
|
|
virtual ~MockAppFactoryForRtspPlayStream();
|
|
|
|
public:
|
|
virtual ISrsRtspSendTrack *create_rtsp_audio_send_track(ISrsRtspConnection *session, SrsRtcTrackDescription *track_desc);
|
|
virtual ISrsRtspSendTrack *create_rtsp_video_send_track(ISrsRtspConnection *session, SrsRtcTrackDescription *track_desc);
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsRtspStack for testing SrsRtspConnection
|
|
class MockRtspStack : public ISrsRtspStack
|
|
{
|
|
public:
|
|
bool send_message_called_;
|
|
int last_response_seq_;
|
|
std::string last_response_session_;
|
|
std::string last_response_type_; // "OPTIONS", "DESCRIBE", "SETUP", "PLAY", "TEARDOWN"
|
|
srs_error_t send_message_error_;
|
|
|
|
public:
|
|
MockRtspStack();
|
|
virtual ~MockRtspStack();
|
|
|
|
public:
|
|
virtual srs_error_t recv_message(SrsRtspRequest **preq);
|
|
virtual srs_error_t send_message(SrsRtspResponse *res);
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsRtspPlayStream for testing SrsRtspConnection::do_play and do_teardown
|
|
class MockRtspPlayStream : public ISrsRtspPlayStream
|
|
{
|
|
public:
|
|
bool initialize_called_;
|
|
bool start_called_;
|
|
bool stop_called_;
|
|
bool set_all_tracks_status_called_;
|
|
bool set_all_tracks_status_value_;
|
|
srs_error_t initialize_error_;
|
|
srs_error_t start_error_;
|
|
|
|
public:
|
|
MockRtspPlayStream();
|
|
virtual ~MockRtspPlayStream();
|
|
|
|
public:
|
|
virtual srs_error_t initialize(ISrsRequest *request, std::map<uint32_t, SrsRtcTrackDescription *> sub_relations);
|
|
virtual srs_error_t start();
|
|
virtual void stop();
|
|
virtual void set_all_tracks_status(bool status);
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsDvrPlan for testing SrsDvrSegmenter
|
|
class MockDvrPlan : public ISrsDvrPlan
|
|
{
|
|
public:
|
|
bool on_publish_called_;
|
|
bool on_unpublish_called_;
|
|
srs_error_t on_publish_error_;
|
|
|
|
public:
|
|
MockDvrPlan();
|
|
virtual ~MockDvrPlan();
|
|
|
|
public:
|
|
virtual srs_error_t initialize(ISrsOriginHub *h, ISrsDvrSegmenter *s, ISrsRequest *r);
|
|
virtual srs_error_t on_publish(ISrsRequest *r);
|
|
virtual void on_unpublish();
|
|
virtual srs_error_t on_meta_data(SrsMediaPacket *shared_metadata);
|
|
virtual srs_error_t on_audio(SrsMediaPacket *shared_audio, SrsFormat *format);
|
|
virtual srs_error_t on_video(SrsMediaPacket *shared_video, SrsFormat *format);
|
|
virtual srs_error_t on_reap_segment();
|
|
};
|
|
|
|
// Mock ISrsHttpHooks for testing SrsDvrAsyncCallOnDvr
|
|
class MockHttpHooksForDvrAsyncCall : public ISrsHttpHooks
|
|
{
|
|
public:
|
|
struct OnDvrCall {
|
|
SrsContextId cid_;
|
|
std::string url_;
|
|
ISrsRequest *req_;
|
|
std::string file_;
|
|
};
|
|
std::vector<OnDvrCall> on_dvr_calls_;
|
|
int on_dvr_count_;
|
|
srs_error_t on_dvr_error_;
|
|
|
|
public:
|
|
MockHttpHooksForDvrAsyncCall();
|
|
virtual ~MockHttpHooksForDvrAsyncCall();
|
|
|
|
public:
|
|
virtual srs_error_t on_connect(std::string url, ISrsRequest *req);
|
|
virtual void on_close(std::string url, ISrsRequest *req, int64_t send_bytes, int64_t recv_bytes);
|
|
virtual srs_error_t on_publish(std::string url, ISrsRequest *req);
|
|
virtual void on_unpublish(std::string url, ISrsRequest *req);
|
|
virtual srs_error_t on_play(std::string url, ISrsRequest *req);
|
|
virtual void on_stop(std::string url, ISrsRequest *req);
|
|
virtual srs_error_t on_dvr(SrsContextId cid, std::string url, ISrsRequest *req, std::string file);
|
|
virtual srs_error_t on_hls(SrsContextId cid, std::string url, ISrsRequest *req, std::string file, std::string ts_url,
|
|
std::string m3u8, std::string m3u8_url, int sn, srs_utime_t duration);
|
|
virtual srs_error_t on_hls_notify(SrsContextId cid, std::string url, ISrsRequest *req, std::string ts_url, int nb_notify);
|
|
virtual srs_error_t discover_co_workers(std::string url, std::string &host, int &port);
|
|
virtual srs_error_t on_forward_backend(std::string url, ISrsRequest *req, std::vector<std::string> &rtmp_urls);
|
|
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsFlvTransmuxer for testing SrsDvrFlvSegmenter
|
|
class MockFlvTransmuxer : public ISrsFlvTransmuxer
|
|
{
|
|
public:
|
|
bool write_header_called_;
|
|
bool write_metadata_called_;
|
|
char metadata_type_;
|
|
int metadata_size_;
|
|
srs_error_t write_metadata_error_;
|
|
|
|
public:
|
|
MockFlvTransmuxer();
|
|
virtual ~MockFlvTransmuxer();
|
|
|
|
public:
|
|
virtual srs_error_t initialize(ISrsWriter *fw);
|
|
virtual void set_drop_if_not_match(bool v);
|
|
virtual bool drop_if_not_match();
|
|
virtual srs_error_t write_header(bool has_video = true, bool has_audio = true);
|
|
virtual srs_error_t write_header(char flv_header[9]);
|
|
virtual srs_error_t write_metadata(char type, char *data, int size);
|
|
virtual srs_error_t write_audio(int64_t timestamp, char *data, int size);
|
|
virtual srs_error_t write_video(int64_t timestamp, char *data, int size);
|
|
virtual srs_error_t write_tags(SrsMediaPacket **msgs, int count);
|
|
};
|
|
|
|
// Mock ISrsMp4Encoder for testing SrsDvrMp4Segmenter
|
|
class MockMp4Encoder : public ISrsMp4Encoder
|
|
{
|
|
public:
|
|
bool initialize_called_;
|
|
bool write_sample_called_;
|
|
bool flush_called_;
|
|
bool set_audio_codec_called_;
|
|
SrsMp4HandlerType last_handler_type_;
|
|
uint16_t last_frame_type_;
|
|
uint16_t last_codec_type_;
|
|
uint32_t last_dts_;
|
|
uint32_t last_pts_;
|
|
uint32_t last_sample_size_;
|
|
SrsAudioCodecId last_audio_codec_;
|
|
SrsAudioSampleRate last_audio_sample_rate_;
|
|
SrsAudioSampleBits last_audio_sound_bits_;
|
|
SrsAudioChannels last_audio_channels_;
|
|
|
|
public:
|
|
MockMp4Encoder();
|
|
virtual ~MockMp4Encoder();
|
|
|
|
public:
|
|
virtual srs_error_t initialize(ISrsWriteSeeker *ws);
|
|
virtual srs_error_t write_sample(SrsFormat *format, SrsMp4HandlerType ht, uint16_t ft, uint16_t ct,
|
|
uint32_t dts, uint32_t pts, uint8_t *sample, uint32_t nb_sample);
|
|
virtual srs_error_t flush();
|
|
virtual void set_audio_codec(SrsAudioCodecId vcodec, SrsAudioSampleRate sample_rate, SrsAudioSampleBits sound_bits, SrsAudioChannels channels);
|
|
void reset();
|
|
};
|
|
|
|
// Mock ISrsAppFactory for testing SrsDvrMp4Segmenter
|
|
class MockDvrAppFactory : public ISrsAppFactory
|
|
{
|
|
public:
|
|
MockMp4Encoder *mock_mp4_encoder_;
|
|
|
|
public:
|
|
MockDvrAppFactory();
|
|
virtual ~MockDvrAppFactory();
|
|
|
|
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 ISrsHttpClient *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 ISrsDvrSegmenter *create_dvr_flv_segmenter();
|
|
virtual ISrsDvrSegmenter *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);
|
|
// 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();
|
|
};
|
|
|
|
// Mock ISrsDvrSegmenter for testing SrsDvrPlan
|
|
class MockDvrSegmenter : public ISrsDvrSegmenter
|
|
{
|
|
public:
|
|
bool write_metadata_called_;
|
|
bool write_audio_called_;
|
|
bool write_video_called_;
|
|
SrsFragment *fragment_;
|
|
|
|
public:
|
|
MockDvrSegmenter();
|
|
virtual void assemble();
|
|
virtual ~MockDvrSegmenter();
|
|
|
|
public:
|
|
virtual srs_error_t initialize(ISrsDvrPlan *p, ISrsRequest *r);
|
|
virtual SrsFragment *current();
|
|
virtual srs_error_t open();
|
|
virtual srs_error_t write_metadata(SrsMediaPacket *metadata);
|
|
virtual srs_error_t write_audio(SrsMediaPacket *shared_audio, SrsFormat *format);
|
|
virtual srs_error_t write_video(SrsMediaPacket *shared_video, SrsFormat *format);
|
|
virtual srs_error_t close();
|
|
};
|
|
|
|
// Mock ISrsOriginHub for testing SrsDvrSegmentPlan
|
|
class MockOriginHubForDvrSegmentPlan : public ISrsOriginHub
|
|
{
|
|
public:
|
|
int on_dvr_request_sh_count_;
|
|
srs_error_t on_dvr_request_sh_error_;
|
|
|
|
public:
|
|
MockOriginHubForDvrSegmentPlan();
|
|
virtual ~MockOriginHubForDvrSegmentPlan();
|
|
|
|
public:
|
|
virtual srs_error_t initialize(SrsSharedPtr<SrsLiveSource> s, ISrsRequest *r);
|
|
virtual void dispose();
|
|
virtual srs_error_t cycle();
|
|
virtual bool active();
|
|
virtual srs_utime_t cleanup_delay();
|
|
virtual srs_error_t on_meta_data(SrsMediaPacket *shared_metadata, SrsOnMetaDataPacket *packet);
|
|
virtual srs_error_t on_audio(SrsMediaPacket *shared_audio);
|
|
virtual srs_error_t on_video(SrsMediaPacket *shared_video, bool is_sequence_header);
|
|
virtual srs_error_t on_publish();
|
|
virtual void on_unpublish();
|
|
virtual srs_error_t on_dvr_request_sh();
|
|
};
|
|
|
|
#endif
|