external/srs
1
0
Fork 0
mirror of https://github.com/ossrs/srs.git synced 2025-03-09 15:49:59 +00:00
Code Issues Releases Wiki Activity

rename SrsStream to SrsBuffer

Browse source
This commit is contained in:
winlin 2015-09-22 08:57:31 +08:00
parent ca3577e11b
commit 0e52fc6d5b
42 changed files with 440 additions and 440 deletions
Download patch file Download diff file Expand all files Collapse all files

4
trunk/src/app/srs_app_dvr.cpp
View file

@ -212,7 +212,7 @@ int SrsFlvSegment::write_metadata(SrsSharedPtrMessage* metadata)
return ret;
}
SrsStream stream;
SrsBuffer stream;
if ((ret = stream.initialize(metadata->payload, metadata->size)) != ERROR_SUCCESS) {
return ret;
}
@ -357,7 +357,7 @@ int SrsFlvSegment::update_flv_metadata()
char* buf = new char[SrsAmf0Size::number()];
SrsAutoFree(char, buf);
SrsStream stream;
SrsBuffer stream;
if ((ret = stream.initialize(buf, SrsAmf0Size::number())) != ERROR_SUCCESS) {
return ret;
}

2
trunk/src/app/srs_app_dvr.hpp
View file

@ -36,7 +36,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
class SrsSource;
class SrsRequest;
class SrsStream;
class SrsBuffer;
class SrsRtmpJitter;
class SrsOnMetaDataPacket;
class SrsSharedPtrMessage;

6
trunk/src/app/srs_app_hds.cpp
View file

@ -57,7 +57,7 @@ char flv_header[] = {'F', 'L', 'V',
string serialFlv(SrsSharedPtrMessage *msg)
{
SrsStream *stream = new SrsStream;
SrsBuffer *stream = new SrsBuffer;
int size = 15 + msg->size;
char *byte = new char[size];
@ -147,7 +147,7 @@ public:
}
char box_header[8];
SrsStream ss;
SrsBuffer ss;
ss.initialize(box_header, 8);
ss.write_4bytes(8 + data.size());
ss.write_string("mdat");
@ -477,7 +477,7 @@ int SrsHds::flush_bootstrap()
{
int ret = ERROR_SUCCESS;
SrsStream abst;
SrsBuffer abst;
int size = 1024*100;

50
trunk/src/app/srs_app_http_stream.cpp
View file

@ -60,7 +60,7 @@ using namespace std;
#ifdef SRS_AUTO_HTTP_SERVER
SrsStreamCache::SrsStreamCache(SrsSource* s, SrsRequest* r)
SrsBufferCache::SrsBufferCache(SrsSource* s, SrsRequest* r)
{
req = r->copy();
source = s;
@ -71,7 +71,7 @@ SrsStreamCache::SrsStreamCache(SrsSource* s, SrsRequest* r)
fast_cache = _srs_config->get_vhost_http_remux_fast_cache(req->vhost);
}
SrsStreamCache::~SrsStreamCache()
SrsBufferCache::~SrsBufferCache()
{
srs_freep(pthread);
@ -79,12 +79,12 @@ SrsStreamCache::~SrsStreamCache()
srs_freep(req);
}
int SrsStreamCache::start()
int SrsBufferCache::start()
{
return pthread->start();
}
int SrsStreamCache::dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter)
int SrsBufferCache::dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter)
{
int ret = ERROR_SUCCESS;
@ -104,7 +104,7 @@ int SrsStreamCache::dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jit
return ret;
}
int SrsStreamCache::cycle()
int SrsBufferCache::cycle()
{
int ret = ERROR_SUCCESS;
@ -167,11 +167,11 @@ int SrsStreamCache::cycle()
return ret;
}
ISrsStreamEncoder::ISrsStreamEncoder()
ISrsBufferEncoder::ISrsBufferEncoder()
{
}
ISrsStreamEncoder::~ISrsStreamEncoder()
ISrsBufferEncoder::~ISrsBufferEncoder()
{
}
@ -185,7 +185,7 @@ SrsTsStreamEncoder::~SrsTsStreamEncoder()
srs_freep(enc);
}
int SrsTsStreamEncoder::initialize(SrsFileWriter* w, SrsStreamCache* /*c*/)
int SrsTsStreamEncoder::initialize(SrsFileWriter* w, SrsBufferCache* /*c*/)
{
int ret = ERROR_SUCCESS;
@ -233,7 +233,7 @@ SrsFlvStreamEncoder::~SrsFlvStreamEncoder()
srs_freep(enc);
}
int SrsFlvStreamEncoder::initialize(SrsFileWriter* w, SrsStreamCache* /*c*/)
int SrsFlvStreamEncoder::initialize(SrsFileWriter* w, SrsBufferCache* /*c*/)
{
int ret = ERROR_SUCCESS;
@ -302,7 +302,7 @@ SrsAacStreamEncoder::~SrsAacStreamEncoder()
srs_freep(enc);
}
int SrsAacStreamEncoder::initialize(SrsFileWriter* w, SrsStreamCache* c)
int SrsAacStreamEncoder::initialize(SrsFileWriter* w, SrsBufferCache* c)
{
int ret = ERROR_SUCCESS;
@ -354,7 +354,7 @@ SrsMp3StreamEncoder::~SrsMp3StreamEncoder()
srs_freep(enc);
}
int SrsMp3StreamEncoder::initialize(SrsFileWriter* w, SrsStreamCache* c)
int SrsMp3StreamEncoder::initialize(SrsFileWriter* w, SrsBufferCache* c)
{
int ret = ERROR_SUCCESS;
@ -399,35 +399,35 @@ int SrsMp3StreamEncoder::dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorith
return cache->dump_cache(consumer, jitter);
}
SrsStreamWriter::SrsStreamWriter(ISrsHttpResponseWriter* w)
SrsBufferWriter::SrsBufferWriter(ISrsHttpResponseWriter* w)
{
writer = w;
}
SrsStreamWriter::~SrsStreamWriter()
SrsBufferWriter::~SrsBufferWriter()
{
}
int SrsStreamWriter::open(std::string /*file*/)
int SrsBufferWriter::open(std::string /*file*/)
{
return ERROR_SUCCESS;
}
void SrsStreamWriter::close()
void SrsBufferWriter::close()
{
}
bool SrsStreamWriter::is_open()
bool SrsBufferWriter::is_open()
{
return true;
}
int64_t SrsStreamWriter::tellg()
int64_t SrsBufferWriter::tellg()
{
return 0;
}
int SrsStreamWriter::write(void* buf, size_t count, ssize_t* pnwrite)
int SrsBufferWriter::write(void* buf, size_t count, ssize_t* pnwrite)
{
if (pnwrite) {
*pnwrite = count;
@ -435,12 +435,12 @@ int SrsStreamWriter::write(void* buf, size_t count, ssize_t* pnwrite)
return writer->write((char*)buf, (int)count);
}
int SrsStreamWriter::writev(iovec* iov, int iovcnt, ssize_t* pnwrite)
int SrsBufferWriter::writev(iovec* iov, int iovcnt, ssize_t* pnwrite)
{
return writer->writev(iov, iovcnt, pnwrite);
}
SrsLiveStream::SrsLiveStream(SrsSource* s, SrsRequest* r, SrsStreamCache* c)
SrsLiveStream::SrsLiveStream(SrsSource* s, SrsRequest* r, SrsBufferCache* c)
{
source = s;
cache = c;
@ -456,7 +456,7 @@ int SrsLiveStream::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
{
int ret = ERROR_SUCCESS;
ISrsStreamEncoder* enc = NULL;
ISrsBufferEncoder* enc = NULL;
srs_assert(entry);
if (srs_string_ends_with(entry->pattern, ".flv")) {
@ -480,7 +480,7 @@ int SrsLiveStream::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
srs_error("http: unsupported pattern %s", entry->pattern.c_str());
return ret;
}
SrsAutoFree(ISrsStreamEncoder, enc);
SrsAutoFree(ISrsBufferEncoder, enc);
// create consumer of souce, ignore gop cache, use the audio gop cache.
SrsConsumer* consumer = NULL;
@ -504,7 +504,7 @@ int SrsLiveStream::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
}
// the memory writer.
SrsStreamWriter writer(w);
SrsBufferWriter writer(w);
if ((ret = enc->initialize(&writer, cache)) != ERROR_SUCCESS) {
srs_error("http: initialize stream encoder failed. ret=%d", ret);
return ret;
@ -577,7 +577,7 @@ int SrsLiveStream::serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r)
return ret;
}
int SrsLiveStream::streaming_send_messages(ISrsStreamEncoder* enc, SrsSharedPtrMessage** msgs, int nb_msgs)
int SrsLiveStream::streaming_send_messages(ISrsBufferEncoder* enc, SrsSharedPtrMessage** msgs, int nb_msgs)
{
int ret = ERROR_SUCCESS;
@ -811,7 +811,7 @@ int SrsHttpStreamServer::http_mount(SrsSource* s, SrsRequest* r)
entry = new SrsLiveEntry(mount, tmpl->hstrs);
entry->cache = new SrsStreamCache(s, r);
entry->cache = new SrsBufferCache(s, r);
entry->stream = new SrsLiveStream(s, r, entry->cache);
// TODO: FIXME: maybe refine the logic of http remux service.

48
trunk/src/app/srs_app_http_stream.hpp
View file

@ -39,7 +39,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
* for example, the audio stream cache to make android(weixin) happy.
* we start a thread to shrink the queue.
*/
class SrsStreamCache : public ISrsEndlessThreadHandler
class SrsBufferCache : public ISrsEndlessThreadHandler
{
private:
double fast_cache;
@ -49,8 +49,8 @@ private:
SrsRequest* req;
SrsEndlessThread* pthread;
public:
SrsStreamCache(SrsSource* s, SrsRequest* r);
virtual ~SrsStreamCache();
SrsBufferCache(SrsSource* s, SrsRequest* r);
virtual ~SrsBufferCache();
public:
virtual int start();
virtual int dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorithm jitter);
@ -62,18 +62,18 @@ public:
/**
* the stream encoder in some codec, for example, flv or aac.
*/
class ISrsStreamEncoder
class ISrsBufferEncoder
{
public:
ISrsStreamEncoder();
virtual ~ISrsStreamEncoder();
ISrsBufferEncoder();
virtual ~ISrsBufferEncoder();
public:
/**
* initialize the encoder with file writer(to http response) and stream cache.
* @param w the writer to write to http response.
* @param c the stream cache for audio stream fast startup.
*/
virtual int initialize(SrsFileWriter* w, SrsStreamCache* c) = 0;
virtual int initialize(SrsFileWriter* w, SrsBufferCache* c) = 0;
/**
* write rtmp video/audio/metadata.
*/
@ -96,7 +96,7 @@ public:
/**
* the flv stream encoder, remux rtmp stream to flv stream.
*/
class SrsFlvStreamEncoder : public ISrsStreamEncoder
class SrsFlvStreamEncoder : public ISrsBufferEncoder
{
protected:
SrsFlvEncoder* enc;
@ -104,7 +104,7 @@ public:
SrsFlvStreamEncoder();
virtual ~SrsFlvStreamEncoder();
public:
virtual int initialize(SrsFileWriter* w, SrsStreamCache* c);
virtual int initialize(SrsFileWriter* w, SrsBufferCache* c);
virtual int write_audio(int64_t timestamp, char* data, int size);
virtual int write_video(int64_t timestamp, char* data, int size);
virtual int write_metadata(int64_t timestamp, char* data, int size);
@ -134,7 +134,7 @@ public:
/**
* the ts stream encoder, remux rtmp stream to ts stream.
*/
class SrsTsStreamEncoder : public ISrsStreamEncoder
class SrsTsStreamEncoder : public ISrsBufferEncoder
{
private:
SrsTsEncoder* enc;
@ -142,7 +142,7 @@ public:
SrsTsStreamEncoder();
virtual ~SrsTsStreamEncoder();
public:
virtual int initialize(SrsFileWriter* w, SrsStreamCache* c);
virtual int initialize(SrsFileWriter* w, SrsBufferCache* c);
virtual int write_audio(int64_t timestamp, char* data, int size);
virtual int write_video(int64_t timestamp, char* data, int size);
virtual int write_metadata(int64_t timestamp, char* data, int size);
@ -154,16 +154,16 @@ public:
/**
* the aac stream encoder, remux rtmp stream to aac stream.
*/
class SrsAacStreamEncoder : public ISrsStreamEncoder
class SrsAacStreamEncoder : public ISrsBufferEncoder
{
private:
SrsAacEncoder* enc;
SrsStreamCache* cache;
SrsBufferCache* cache;
public:
SrsAacStreamEncoder();
virtual ~SrsAacStreamEncoder();
public:
virtual int initialize(SrsFileWriter* w, SrsStreamCache* c);
virtual int initialize(SrsFileWriter* w, SrsBufferCache* c);
virtual int write_audio(int64_t timestamp, char* data, int size);
virtual int write_video(int64_t timestamp, char* data, int size);
virtual int write_metadata(int64_t timestamp, char* data, int size);
@ -175,16 +175,16 @@ public:
/**
* the mp3 stream encoder, remux rtmp stream to mp3 stream.
*/
class SrsMp3StreamEncoder : public ISrsStreamEncoder
class SrsMp3StreamEncoder : public ISrsBufferEncoder
{
private:
SrsMp3Encoder* enc;
SrsStreamCache* cache;
SrsBufferCache* cache;
public:
SrsMp3StreamEncoder();
virtual ~SrsMp3StreamEncoder();
public:
virtual int initialize(SrsFileWriter* w, SrsStreamCache* c);
virtual int initialize(SrsFileWriter* w, SrsBufferCache* c);
virtual int write_audio(int64_t timestamp, char* data, int size);
virtual int write_video(int64_t timestamp, char* data, int size);
virtual int write_metadata(int64_t timestamp, char* data, int size);
@ -196,13 +196,13 @@ public:
/**
* write stream to http response direclty.
*/
class SrsStreamWriter : public SrsFileWriter
class SrsBufferWriter : public SrsFileWriter
{
private:
ISrsHttpResponseWriter* writer;
public:
SrsStreamWriter(ISrsHttpResponseWriter* w);
virtual ~SrsStreamWriter();
SrsBufferWriter(ISrsHttpResponseWriter* w);
virtual ~SrsBufferWriter();
public:
virtual int open(std::string file);
virtual void close();
@ -223,14 +223,14 @@ class SrsLiveStream : public ISrsHttpHandler
private:
SrsRequest* req;
SrsSource* source;
SrsStreamCache* cache;
SrsBufferCache* cache;
public:
SrsLiveStream(SrsSource* s, SrsRequest* r, SrsStreamCache* c);
SrsLiveStream(SrsSource* s, SrsRequest* r, SrsBufferCache* c);
virtual ~SrsLiveStream();
public:
virtual int serve_http(ISrsHttpResponseWriter* w, ISrsHttpMessage* r);
private:
virtual int streaming_send_messages(ISrsStreamEncoder* enc, SrsSharedPtrMessage** msgs, int nb_msgs);
virtual int streaming_send_messages(ISrsBufferEncoder* enc, SrsSharedPtrMessage** msgs, int nb_msgs);
};
/**
@ -254,7 +254,7 @@ public:
bool hstrs;
SrsLiveStream* stream;
SrsStreamCache* cache;
SrsBufferCache* cache;
SrsLiveEntry(std::string m, bool h);
void reset_hstrs(bool h);

8
trunk/src/app/srs_app_mpegts_udp.cpp
View file

@ -126,7 +126,7 @@ SrsSharedPtrMessage* SrsMpegtsQueue::dequeue()
SrsMpegtsOverUdp::SrsMpegtsOverUdp(SrsConfDirective* c)
{
stream = new SrsStream();
stream = new SrsBuffer();
context = new SrsTsContext();
buffer = new SrsSimpleBuffer();
output = _srs_config->get_stream_caster_output(c);
@ -317,7 +317,7 @@ int SrsMpegtsOverUdp::on_ts_message(SrsTsMessage* msg)
}
// parse the stream.
SrsStream avs;
SrsBuffer avs;
if ((ret = avs.initialize(msg->payload->bytes(), msg->payload->length())) != ERROR_SUCCESS) {
srs_error("mpegts: initialize av stream failed. ret=%d", ret);
return ret;
@ -335,7 +335,7 @@ int SrsMpegtsOverUdp::on_ts_message(SrsTsMessage* msg)
return ret;
}
int SrsMpegtsOverUdp::on_ts_video(SrsTsMessage* msg, SrsStream* avs)
int SrsMpegtsOverUdp::on_ts_video(SrsTsMessage* msg, SrsBuffer* avs)
{
int ret = ERROR_SUCCESS;
@ -494,7 +494,7 @@ int SrsMpegtsOverUdp::write_h264_ipb_frame(char* frame, int frame_size, u_int32_
return rtmp_write_packet(SrsCodecFlvTagVideo, timestamp, flv, nb_flv);
}
int SrsMpegtsOverUdp::on_ts_audio(SrsTsMessage* msg, SrsStream* avs)
int SrsMpegtsOverUdp::on_ts_audio(SrsTsMessage* msg, SrsBuffer* avs)
{
int ret = ERROR_SUCCESS;

8
trunk/src/app/srs_app_mpegts_udp.hpp
View file

@ -36,7 +36,7 @@ struct sockaddr_in;
#include <string>
#include <map>
class SrsStream;
class SrsBuffer;
class SrsTsContext;
class SrsConfDirective;
class SrsSimpleBuffer;
@ -80,7 +80,7 @@ class SrsMpegtsOverUdp : virtual public ISrsTsHandler
, virtual public ISrsUdpHandler
{
private:
SrsStream* stream;
SrsBuffer* stream;
SrsTsContext* context;
SrsSimpleBuffer* buffer;
std::string output;
@ -115,10 +115,10 @@ private:
public:
virtual int on_ts_message(SrsTsMessage* msg);
private:
virtual int on_ts_video(SrsTsMessage* msg, SrsStream* avs);
virtual int on_ts_video(SrsTsMessage* msg, SrsBuffer* avs);
virtual int write_h264_sps_pps(u_int32_t dts, u_int32_t pts);
virtual int write_h264_ipb_frame(char* frame, int frame_size, u_int32_t dts, u_int32_t pts);
virtual int on_ts_audio(SrsTsMessage* msg, SrsStream* avs);
virtual int on_ts_audio(SrsTsMessage* msg, SrsBuffer* avs);
virtual int write_audio_raw_frame(char* frame, int frame_size, SrsRawAacStreamCodec* codec, u_int32_t dts);
private:
virtual int rtmp_write_packet(char type, u_int32_t timestamp, char* data, int size);

2
trunk/src/app/srs_app_rtsp.cpp
View file

@ -80,7 +80,7 @@ int SrsRtpConn::on_udp_packet(sockaddr_in* from, char* buf, int nb_buf)
pprint->elapse();
if (true) {
SrsStream stream;
SrsBuffer stream;
if ((ret = stream.initialize(buf, nb_buf)) != ERROR_SUCCESS) {
return ret;

14
trunk/src/app/srs_app_server.cpp
View file

@ -128,17 +128,17 @@ SrsListenerType SrsListener::listen_type()
return type;
}
SrsStreamListener::SrsStreamListener(SrsServer* svr, SrsListenerType t) : SrsListener(svr, t)
SrsBufferListener::SrsBufferListener(SrsServer* svr, SrsListenerType t) : SrsListener(svr, t)
{
listener = NULL;
}
SrsStreamListener::~SrsStreamListener()
SrsBufferListener::~SrsBufferListener()
{
srs_freep(listener);
}
int SrsStreamListener::listen(string i, int p)
int SrsBufferListener::listen(string i, int p)
{
int ret = ERROR_SUCCESS;
@ -162,7 +162,7 @@ int SrsStreamListener::listen(string i, int p)
return ret;
}
int SrsStreamListener::on_tcp_client(st_netfd_t stfd)
int SrsBufferListener::on_tcp_client(st_netfd_t stfd)
{
int ret = ERROR_SUCCESS;
@ -1087,7 +1087,7 @@ int SrsServer::listen_rtmp()
close_listeners(SrsListenerRtmpStream);
for (int i = 0; i < (int)ip_ports.size(); i++) {
SrsListener* listener = new SrsStreamListener(this, SrsListenerRtmpStream);
SrsListener* listener = new SrsBufferListener(this, SrsListenerRtmpStream);
listeners.push_back(listener);
std::string ip;
@ -1110,7 +1110,7 @@ int SrsServer::listen_http_api()
#ifdef SRS_AUTO_HTTP_API
close_listeners(SrsListenerHttpApi);
if (_srs_config->get_http_api_enabled()) {
SrsListener* listener = new SrsStreamListener(this, SrsListenerHttpApi);
SrsListener* listener = new SrsBufferListener(this, SrsListenerHttpApi);
listeners.push_back(listener);
std::string ep = _srs_config->get_http_api_listen();
@ -1136,7 +1136,7 @@ int SrsServer::listen_http_stream()
#ifdef SRS_AUTO_HTTP_SERVER
close_listeners(SrsListenerHttpStream);
if (_srs_config->get_http_stream_enabled()) {
SrsListener* listener = new SrsStreamListener(this, SrsListenerHttpStream);
SrsListener* listener = new SrsBufferListener(this, SrsListenerHttpStream);
listeners.push_back(listener);
std::string ep = _srs_config->get_http_stream_listen();

6
trunk/src/app/srs_app_server.hpp
View file

@ -96,13 +96,13 @@ public:
/**
* tcp listener.
*/
class SrsStreamListener : virtual public SrsListener, virtual public ISrsTcpHandler
class SrsBufferListener : virtual public SrsListener, virtual public ISrsTcpHandler
{
private:
SrsTcpListener* listener;
public:
SrsStreamListener(SrsServer* server, SrsListenerType type);
virtual ~SrsStreamListener();
SrsBufferListener(SrsServer* server, SrsListenerType type);
virtual ~SrsBufferListener();
public:
virtual int listen(std::string ip, int port);
// ISrsTcpHandler

6
trunk/src/app/srs_app_source.cpp
View file

@ -926,7 +926,7 @@ SrsSource::SrsSource()
play_edge = new SrsPlayEdge();
publish_edge = new SrsPublishEdge();
gop_cache = new SrsGopCache();
aggregate_stream = new SrsStream();
aggregate_stream = new SrsBuffer();
ng_exec = new SrsNgExec();
is_monotonically_increase = false;
@ -1322,7 +1322,7 @@ int SrsSource::on_dvr_request_sh()
char* payload = cache_metadata->payload;
int size = cache_metadata->size;
SrsStream stream;
SrsBuffer stream;
if ((ret = stream.initialize(payload, size)) != ERROR_SUCCESS) {
srs_error("dvr decode metadata stream failed. ret=%d", ret);
return ret;
@ -1919,7 +1919,7 @@ int SrsSource::on_aggregate(SrsCommonMessage* msg)
{
int ret = ERROR_SUCCESS;
SrsStream* stream = aggregate_stream;
SrsBuffer* stream = aggregate_stream;
if ((ret = stream->initialize(msg->payload, msg->size)) != ERROR_SUCCESS) {
return ret;
}

4
trunk/src/app/srs_app_source.hpp
View file

@ -61,7 +61,7 @@ class SrsDvr;
#ifdef SRS_AUTO_TRANSCODE
class SrsEncoder;
#endif
class SrsStream;
class SrsBuffer;
class ISrsHlsHandler;
#ifdef SRS_AUTO_HDS
class SrsHds;
@ -497,7 +497,7 @@ private:
// to forward stream to other servers
std::vector<SrsForwarder*> forwarders;
// for aggregate message
SrsStream* aggregate_stream;
SrsBuffer* aggregate_stream;
// the event handler.
ISrsSourceHandler* handler;
private:

4
trunk/src/app/srs_app_thread.hpp
View file

@ -37,8 +37,8 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
* the step to create a thread never stop:
* 1. create SrsEndlessThread field.
* for example:
* class SrsStreamCache : public ISrsEndlessThreadHandler {
* public: SrsStreamCache() { pthread = new SrsEndlessThread("http-stream", this); }
* class SrsBufferCache : public ISrsEndlessThreadHandler {
* public: SrsBufferCache() { pthread = new SrsEndlessThread("http-stream", this); }
* public: virtual int cycle() {
* // do some work never end.
* }

2
trunk/src/app/srs_app_utility.hpp
View file

@ -40,7 +40,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include <srs_app_st.hpp>
class SrsKbps;
class SrsStream;
class SrsBuffer;
class SrsJsonObject;
// client open socket and connect to server.