external/srs
1
0
Fork 0
mirror of https://github.com/ossrs/srs.git synced 2025-02-13 11:51:57 +00:00
Code Issues Releases Wiki Activity

for #299, refine the encoder object name

Browse source
This commit is contained in:
winlin 2017-02-12 21:50:02 +08:00
parent 2a4f57a587
commit 2fcd3972c1
17 changed files with 152 additions and 158 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -277,7 +277,7 @@ int SrsDvrSegmenter::on_reload_vhost_dvr(std::string vhost)
SrsDvrFlvSegmenter::SrsDvrFlvSegmenter()
{
enc = new SrsFlvEncoder();
enc = new SrsFlvTransmuxer();
duration_offset = 0;
filesize_offset = 0;
@ -357,7 +357,7 @@ int SrsDvrFlvSegmenter::open_encoder()
filesize_offset = 0;
srs_freep(enc);
enc = new SrsFlvEncoder();
enc = new SrsFlvTransmuxer();
if ((ret = enc->initialize(fs)) != ERROR_SUCCESS) {
return ret;

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

@ -39,7 +39,7 @@ class SrsBuffer;
class SrsRtmpJitter;
class SrsSharedPtrMessage;
class SrsFileWriter;
class SrsFlvEncoder;
class SrsFlvTransmuxer;
class SrsDvrPlan;
class SrsJsonAny;
class SrsJsonObject;
@ -129,7 +129,7 @@ class SrsDvrFlvSegmenter : public SrsDvrSegmenter
{
private:
// The FLV encoder, for FLV target.
SrsFlvEncoder* enc;
SrsFlvTransmuxer* enc;
private:
// The offset of file for duration value.
// The next 8 bytes is the double value.

46
trunk/src/app/srs_app_hls.cpp
View file

@ -69,12 +69,12 @@ SrsHlsSegment::SrsHlsSegment(SrsTsContext* c, SrsAudioCodecId ac, SrsVideoCodecI
segment_start_dts = 0;
is_sequence_header = false;
writer = new SrsFileWriter();
muxer = new SrsTsMuxer(writer, c, ac, vc);
tscw = new SrsTsContextWriter(writer, c, ac, vc);
}
SrsHlsSegment::~SrsHlsSegment()
{
srs_freep(muxer);
srs_freep(tscw);
srs_freep(writer);
}
@ -473,7 +473,7 @@ int SrsHlsMuxer::segment_open(int64_t segment_start_dts)
// open temp ts file.
std::string tmp_file = current->full_path + ".tmp";
if ((ret = current->muxer->open(tmp_file.c_str())) != ERROR_SUCCESS) {
if ((ret = current->tscw->open(tmp_file.c_str())) != ERROR_SUCCESS) {
srs_error("open hls muxer failed. ret=%d", ret);
return ret;
}
@ -537,10 +537,10 @@ bool SrsHlsMuxer::is_segment_absolutely_overflow()
bool SrsHlsMuxer::pure_audio()
{
return current && current->muxer && current->muxer->video_codec() == SrsVideoCodecIdDisabled;
return current && current->tscw && current->tscw->video_codec() == SrsVideoCodecIdDisabled;
}
int SrsHlsMuxer::flush_audio(SrsTsCache* cache)
int SrsHlsMuxer::flush_audio(SrsTsMessageCache* cache)
{
int ret = ERROR_SUCCESS;
@ -557,7 +557,7 @@ int SrsHlsMuxer::flush_audio(SrsTsCache* cache)
// update the duration of segment.
current->update_duration(cache->audio->pts);
if ((ret = current->muxer->write_audio(cache->audio)) != ERROR_SUCCESS) {
if ((ret = current->tscw->write_audio(cache->audio)) != ERROR_SUCCESS) {
return ret;
}
@ -567,7 +567,7 @@ int SrsHlsMuxer::flush_audio(SrsTsCache* cache)
return ret;
}
int SrsHlsMuxer::flush_video(SrsTsCache* cache)
int SrsHlsMuxer::flush_video(SrsTsMessageCache* cache)
{
int ret = ERROR_SUCCESS;
@ -586,7 +586,7 @@ int SrsHlsMuxer::flush_video(SrsTsCache* cache)
// update the duration of segment.
current->update_duration(cache->video->dts);
if ((ret = current->muxer->write_video(cache->video)) != ERROR_SUCCESS) {
if ((ret = current->tscw->write_video(cache->video)) != ERROR_SUCCESS) {
return ret;
}
@ -639,7 +639,7 @@ int SrsHlsMuxer::segment_close(string log_desc)
current->segment_start_dts);
// close the muxer of finished segment.
srs_freep(current->muxer);
srs_freep(current->tscw);
std::string full_path = current->full_path;
current = NULL;
@ -827,14 +827,14 @@ int SrsHlsMuxer::_refresh_m3u8(string m3u8_file)
SrsHlsController::SrsHlsController()
{
ts = new SrsTsCache();
tsmc = new SrsTsMessageCache();
muxer = new SrsHlsMuxer();
}
SrsHlsController::~SrsHlsController()
{
srs_freep(muxer);
srs_freep(ts);
srs_freep(tsmc);
}
int SrsHlsController::initialize()
@ -920,7 +920,7 @@ int SrsHlsController::on_unpublish()
{
int ret = ERROR_SUCCESS;
if ((ret = muxer->flush_audio(ts)) != ERROR_SUCCESS) {
if ((ret = muxer->flush_audio(tsmc)) != ERROR_SUCCESS) {
srs_error("m3u8 muxer flush audio failed. ret=%d", ret);
return ret;
}
@ -948,7 +948,7 @@ int SrsHlsController::write_audio(SrsAudioFrame* frame, int64_t pts)
int ret = ERROR_SUCCESS;
// write audio to cache.
if ((ret = ts->cache_audio(frame, pts)) != ERROR_SUCCESS) {
if ((ret = tsmc->cache_audio(frame, pts)) != ERROR_SUCCESS) {
return ret;
}
@ -960,16 +960,16 @@ int SrsHlsController::write_audio(SrsAudioFrame* frame, int64_t pts)
// @see https://github.com/ossrs/srs/issues/151
// we use absolutely overflow of segment to make jwplayer/ffplay happy
// @see https://github.com/ossrs/srs/issues/151#issuecomment-71155184
if (ts->audio && muxer->is_segment_absolutely_overflow()) {
if (tsmc->audio && muxer->is_segment_absolutely_overflow()) {
srs_info("hls: absolute audio reap segment.");
if ((ret = reap_segment("audio", ts->audio->pts)) != ERROR_SUCCESS) {
if ((ret = reap_segment("audio", tsmc->audio->pts)) != ERROR_SUCCESS) {
return ret;
}
}
// for pure audio, aggregate some frame to one.
if (muxer->pure_audio() &&ts->audio) {
if (pts - ts->audio->start_pts < SRS_CONSTS_HLS_PURE_AUDIO_AGGREGATE) {
if (muxer->pure_audio() && tsmc->audio) {
if (pts - tsmc->audio->start_pts < SRS_CONSTS_HLS_PURE_AUDIO_AGGREGATE) {
return ret;
}
}
@ -978,7 +978,7 @@ int SrsHlsController::write_audio(SrsAudioFrame* frame, int64_t pts)
// it's ok for the hls overload, or maybe cause the audio corrupt,
// which introduced by aggregate the audios to a big one.
// @see https://github.com/ossrs/srs/issues/512
if ((ret = muxer->flush_audio(ts)) != ERROR_SUCCESS) {
if ((ret = muxer->flush_audio(tsmc)) != ERROR_SUCCESS) {
return ret;
}
@ -990,7 +990,7 @@ int SrsHlsController::write_video(SrsVideoFrame* frame, int64_t dts)
int ret = ERROR_SUCCESS;
// write video to cache.
if ((ret = ts->cache_video(frame, dts)) != ERROR_SUCCESS) {
if ((ret = tsmc->cache_video(frame, dts)) != ERROR_SUCCESS) {
return ret;
}
@ -1001,14 +1001,14 @@ int SrsHlsController::write_video(SrsVideoFrame* frame, int64_t dts)
// b. always reap when not wait keyframe.
if (!muxer->wait_keyframe() || frame->frame_type == SrsVideoAvcFrameTypeKeyFrame) {
// reap the segment, which will also flush the video.
if ((ret = reap_segment("video", ts->video->dts)) != ERROR_SUCCESS) {
if ((ret = reap_segment("video", tsmc->video->dts)) != ERROR_SUCCESS) {
return ret;
}
}
}
// flush video when got one
if ((ret = muxer->flush_video(ts)) != ERROR_SUCCESS) {
if ((ret = muxer->flush_video(tsmc)) != ERROR_SUCCESS) {
srs_error("m3u8 muxer flush video failed. ret=%d", ret);
return ret;
}
@ -1036,7 +1036,7 @@ int SrsHlsController::reap_segment(string log_desc, int64_t segment_start_dts)
}
// segment open, flush video first.
if ((ret = muxer->flush_video(ts)) != ERROR_SUCCESS) {
if ((ret = muxer->flush_video(tsmc)) != ERROR_SUCCESS) {
srs_error("m3u8 muxer flush video failed. ret=%d", ret);
return ret;
}
@ -1044,7 +1044,7 @@ int SrsHlsController::reap_segment(string log_desc, int64_t segment_start_dts)
// segment open, flush the audio.
// @see: ngx_rtmp_hls_open_fragment
/* start fragment with audio to make iPhone happy */
if ((ret = muxer->flush_audio(ts)) != ERROR_SUCCESS) {
if ((ret = muxer->flush_audio(tsmc)) != ERROR_SUCCESS) {
srs_error("m3u8 muxer flush audio failed. ret=%d", ret);
return ret;
}

18
trunk/src/app/srs_app_hls.hpp
View file

@ -40,7 +40,7 @@ class SrsFormat;
class SrsSharedPtrMessage;
class SrsAmf0Object;
class SrsRtmpJitter;
class SrsTsMuxer;
class SrsTsContextWriter;
class SrsRequest;
class SrsPithyPrint;
class SrsSource;
@ -48,9 +48,8 @@ class SrsOriginHub;
class SrsFileWriter;
class SrsSimpleStream;
class SrsTsAacJitter;
class SrsTsCache;
class SrsTsMessageCache;
class SrsHlsSegment;
class SrsTsCache;
class SrsTsContext;
/**
@ -70,9 +69,10 @@ public:
std::string uri;
// ts full file to write.
std::string full_path;
// the muxer to write ts.
// the underlayer file writer.
SrsFileWriter* writer;
SrsTsMuxer* muxer;
// The TS context writer to write TS to file.
SrsTsContextWriter* tscw;
// current segment start dts for m3u8
int64_t segment_start_dts;
// whether current segement is sequence header.
@ -228,8 +228,8 @@ public:
* whether current hls muxer is pure audio mode.
*/
virtual bool pure_audio();
virtual int flush_audio(SrsTsCache* cache);
virtual int flush_video(SrsTsCache* cache);
virtual int flush_audio(SrsTsMessageCache* cache);
virtual int flush_video(SrsTsMessageCache* cache);
/**
* close segment(ts).
* @param log_desc the description for log.
@ -261,10 +261,10 @@ class SrsHlsController
{
private:
// The HLS muxer to reap ts and m3u8.
// The TS is cached to SrsTsCache then flush to ts segment.
// The TS is cached to SrsTsMessageCache then flush to ts segment.
SrsHlsMuxer* muxer;
// The TS cache
SrsTsCache* ts;
SrsTsMessageCache* tsmc;
public:
SrsHlsController();
virtual ~SrsHlsController();

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

@ -47,10 +47,6 @@ class SrsSource;
class SrsRequest;
class SrsConsumer;
class SrsStSocket;
class SrsTsEncoder;
class SrsAacEncoder;
class SrsMp3Encoder;
class SrsFlvEncoder;
class SrsHttpParser;
class ISrsHttpMessage;
class SrsHttpHandler;

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

@ -182,7 +182,7 @@ ISrsBufferEncoder::~ISrsBufferEncoder()
SrsTsStreamEncoder::SrsTsStreamEncoder()
{
enc = new SrsTsEncoder();
enc = new SrsTsTransmuxer();
}
SrsTsStreamEncoder::~SrsTsStreamEncoder()
@ -230,7 +230,7 @@ int SrsTsStreamEncoder::dump_cache(SrsConsumer* /*consumer*/, SrsRtmpJitterAlgor
SrsFlvStreamEncoder::SrsFlvStreamEncoder()
{
enc = new SrsFlvEncoder();
enc = new SrsFlvTransmuxer();
}
SrsFlvStreamEncoder::~SrsFlvStreamEncoder()
@ -298,7 +298,7 @@ int SrsFastFlvStreamEncoder::write_tags(SrsSharedPtrMessage** msgs, int count)
SrsAacStreamEncoder::SrsAacStreamEncoder()
{
enc = new SrsAacEncoder();
enc = new SrsAacTransmuxer();
cache = NULL;
}
@ -350,7 +350,7 @@ int SrsAacStreamEncoder::dump_cache(SrsConsumer* consumer, SrsRtmpJitterAlgorith
SrsMp3StreamEncoder::SrsMp3StreamEncoder()
{
enc = new SrsMp3Encoder();
enc = new SrsMp3Transmuxer();
cache = NULL;
}

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

@ -32,6 +32,11 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include <srs_app_http_conn.hpp>
class SrsAacTransmuxer;
class SrsMp3Transmuxer;
class SrsFlvTransmuxer;
class SrsTsTransmuxer;
/**
* for the srs http stream cache,
* for example, the audio stream cache to make android(weixin) happy.
@ -98,7 +103,7 @@ public:
class SrsFlvStreamEncoder : public ISrsBufferEncoder
{
protected:
SrsFlvEncoder* enc;
SrsFlvTransmuxer* enc;
public:
SrsFlvStreamEncoder();
virtual ~SrsFlvStreamEncoder();
@ -136,7 +141,7 @@ public:
class SrsTsStreamEncoder : public ISrsBufferEncoder
{
private:
SrsTsEncoder* enc;
SrsTsTransmuxer* enc;
public:
SrsTsStreamEncoder();
virtual ~SrsTsStreamEncoder();
@ -156,7 +161,7 @@ public:
class SrsAacStreamEncoder : public ISrsBufferEncoder
{
private:
SrsAacEncoder* enc;
SrsAacTransmuxer* enc;
SrsBufferCache* cache;
public:
SrsAacStreamEncoder();
@ -177,7 +182,7 @@ public:
class SrsMp3StreamEncoder : public ISrsBufferEncoder
{
private:
SrsMp3Encoder* enc;
SrsMp3Transmuxer* enc;
SrsBufferCache* cache;
public:
SrsMp3StreamEncoder();
@ -266,6 +271,7 @@ public:
* the http stream server instance,
* serve http stream, for example, flv/ts/mp3/aac live stream.
*/
// TODO: Support multiple stream.
class SrsHttpStreamServer : virtual public ISrsReloadHandler
, virtual public ISrsHttpMatchHijacker
{

8
trunk/src/kernel/srs_kernel_aac.cpp
View file

@ -40,7 +40,7 @@ using namespace std;
#include <srs_kernel_file.hpp>
#include <srs_kernel_codec.hpp>
SrsAacEncoder::SrsAacEncoder()
SrsAacTransmuxer::SrsAacTransmuxer()
{
_fs = NULL;
got_sequence_header = false;
@ -48,12 +48,12 @@ SrsAacEncoder::SrsAacEncoder()
aac_object = SrsAacObjectTypeReserved;
}
SrsAacEncoder::~SrsAacEncoder()
SrsAacTransmuxer::~SrsAacTransmuxer()
{
srs_freep(tag_stream);
}
int SrsAacEncoder::initialize(SrsFileWriter* fs)
int SrsAacTransmuxer::initialize(SrsFileWriter* fs)
{
int ret = ERROR_SUCCESS;
@ -70,7 +70,7 @@ int SrsAacEncoder::initialize(SrsFileWriter* fs)
return ret;
}
int SrsAacEncoder::write_audio(int64_t timestamp, char* data, int size)
int SrsAacTransmuxer::write_audio(int64_t timestamp, char* data, int size)
{
int ret = ERROR_SUCCESS;

8
trunk/src/kernel/srs_kernel_aac.hpp
View file

@ -40,9 +40,9 @@ class SrsFileWriter;
class SrsFileReader;
/**
* encode data to aac file.
* Transmux the RTMP packets to AAC stream.
*/
class SrsAacEncoder
class SrsAacTransmuxer
{
private:
SrsFileWriter* _fs;
@ -54,8 +54,8 @@ private:
private:
SrsBuffer* tag_stream;
public:
SrsAacEncoder();
virtual ~SrsAacEncoder();
SrsAacTransmuxer();
virtual ~SrsAacTransmuxer();
public:
/**
* initialize the underlayer file stream.

30
trunk/src/kernel/srs_kernel_flv.cpp
View file

@ -344,7 +344,7 @@ SrsSharedPtrMessage* SrsSharedPtrMessage::copy()
return copy;
}
SrsFlvEncoder::SrsFlvEncoder()
SrsFlvTransmuxer::SrsFlvTransmuxer()
{
writer = NULL;
tag_stream = new SrsBuffer();
@ -359,7 +359,7 @@ SrsFlvEncoder::SrsFlvEncoder()
#endif
}
SrsFlvEncoder::~SrsFlvEncoder()
SrsFlvTransmuxer::~SrsFlvTransmuxer()
{
srs_freep(tag_stream);
@ -370,14 +370,14 @@ SrsFlvEncoder::~SrsFlvEncoder()
#endif
}
int SrsFlvEncoder::initialize(ISrsWriter* fw)
int SrsFlvTransmuxer::initialize(ISrsWriter* fw)
{
srs_assert(fw);
writer = fw;
return ERROR_SUCCESS;
}
int SrsFlvEncoder::write_header()
int SrsFlvTransmuxer::write_header()
{
int ret = ERROR_SUCCESS;
@ -401,7 +401,7 @@ int SrsFlvEncoder::write_header()
return ret;
}
int SrsFlvEncoder::write_header(char flv_header[9])
int SrsFlvTransmuxer::write_header(char flv_header[9])
{
int ret = ERROR_SUCCESS;
@ -420,7 +420,7 @@ int SrsFlvEncoder::write_header(char flv_header[9])
return ret;
}
int SrsFlvEncoder::write_metadata(char type, char* data, int size)
int SrsFlvTransmuxer::write_metadata(char type, char* data, int size)
{
int ret = ERROR_SUCCESS;
@ -440,7 +440,7 @@ int SrsFlvEncoder::write_metadata(char type, char* data, int size)
return ret;
}
int SrsFlvEncoder::write_audio(int64_t timestamp, char* data, int size)
int SrsFlvTransmuxer::write_audio(int64_t timestamp, char* data, int size)
{
int ret = ERROR_SUCCESS;
@ -460,7 +460,7 @@ int SrsFlvEncoder::write_audio(int64_t timestamp, char* data, int size)
return ret;
}
int SrsFlvEncoder::write_video(int64_t timestamp, char* data, int size)
int SrsFlvTransmuxer::write_video(int64_t timestamp, char* data, int size)
{
int ret = ERROR_SUCCESS;
@ -478,14 +478,14 @@ int SrsFlvEncoder::write_video(int64_t timestamp, char* data, int size)
return ret;
}
int SrsFlvEncoder::size_tag(int data_size)
int SrsFlvTransmuxer::size_tag(int data_size)
{
srs_assert(data_size >= 0);
return SRS_FLV_TAG_HEADER_SIZE + data_size + SRS_FLV_PREVIOUS_TAG_SIZE;
}
#ifdef SRS_PERF_FAST_FLV_ENCODER
int SrsFlvEncoder::write_tags(SrsSharedPtrMessage** msgs, int count)
int SrsFlvTransmuxer::write_tags(SrsSharedPtrMessage** msgs, int count)
{
int ret = ERROR_SUCCESS;
@ -567,7 +567,7 @@ int SrsFlvEncoder::write_tags(SrsSharedPtrMessage** msgs, int count)
}
#endif
int SrsFlvEncoder::write_metadata_to_cache(char type, char* data, int size, char* cache)
int SrsFlvTransmuxer::write_metadata_to_cache(char type, char* data, int size, char* cache)
{
int ret = ERROR_SUCCESS;
@ -595,7 +595,7 @@ int SrsFlvEncoder::write_metadata_to_cache(char type, char* data, int size, char
return ret;
}
int SrsFlvEncoder::write_audio_to_cache(int64_t timestamp, char* data, int size, char* cache)
int SrsFlvTransmuxer::write_audio_to_cache(int64_t timestamp, char* data, int size, char* cache)
{
int ret = ERROR_SUCCESS;
@ -626,7 +626,7 @@ int SrsFlvEncoder::write_audio_to_cache(int64_t timestamp, char* data, int size,
return ret;
}
int SrsFlvEncoder::write_video_to_cache(int64_t timestamp, char* data, int size, char* cache)
int SrsFlvTransmuxer::write_video_to_cache(int64_t timestamp, char* data, int size, char* cache)
{
int ret = ERROR_SUCCESS;
@ -657,7 +657,7 @@ int SrsFlvEncoder::write_video_to_cache(int64_t timestamp, char* data, int size,
return ret;
}
int SrsFlvEncoder::write_pts_to_cache(int size, char* cache)
int SrsFlvTransmuxer::write_pts_to_cache(int size, char* cache)
{
int ret = ERROR_SUCCESS;
@ -669,7 +669,7 @@ int SrsFlvEncoder::write_pts_to_cache(int size, char* cache)
return ret;
}
int SrsFlvEncoder::write_tag(char* header, int header_size, char* tag, int tag_size)
int SrsFlvTransmuxer::write_tag(char* header, int header_size, char* tag, int tag_size)
{
int ret = ERROR_SUCCESS;

8
trunk/src/kernel/srs_kernel_flv.hpp
View file

@ -438,9 +438,9 @@ public:
};
/**
* encode data to flv file.
* Transmux RTMP packets to FLV stream.
*/
class SrsFlvEncoder
class SrsFlvTransmuxer
{
private:
ISrsWriter* writer;
@ -448,8 +448,8 @@ private:
SrsBuffer* tag_stream;
char tag_header[SRS_FLV_TAG_HEADER_SIZE];
public:
SrsFlvEncoder();
virtual ~SrsFlvEncoder();
SrsFlvTransmuxer();
virtual ~SrsFlvTransmuxer();
public:
/**
* initialize the underlayer file stream.

10
trunk/src/kernel/srs_kernel_mp3.cpp
View file

@ -40,18 +40,18 @@ using namespace std;
#include <srs_kernel_file.hpp>
#include <srs_kernel_codec.hpp>
SrsMp3Encoder::SrsMp3Encoder()
SrsMp3Transmuxer::SrsMp3Transmuxer()
{
writer = NULL;
tag_stream = new SrsBuffer();
}
SrsMp3Encoder::~SrsMp3Encoder()
SrsMp3Transmuxer::~SrsMp3Transmuxer()
{
srs_freep(tag_stream);
}
int SrsMp3Encoder::initialize(SrsFileWriter* fw)
int SrsMp3Transmuxer::initialize(SrsFileWriter* fw)
{
int ret = ERROR_SUCCESS;
@ -68,7 +68,7 @@ int SrsMp3Encoder::initialize(SrsFileWriter* fw)
return ret;
}
int SrsMp3Encoder::write_header()
int SrsMp3Transmuxer::write_header()
{
char id3[] = {
(char)0x49, (char)0x44, (char)0x33, // ID3
@ -83,7 +83,7 @@ int SrsMp3Encoder::write_header()
return writer->write(id3, sizeof(id3), NULL);
}
int SrsMp3Encoder::write_audio(int64_t timestamp, char* data, int size)
int SrsMp3Transmuxer::write_audio(int64_t timestamp, char* data, int size)
{
int ret = ERROR_SUCCESS;

8
trunk/src/kernel/srs_kernel_mp3.hpp
View file

@ -37,17 +37,17 @@ class SrsBuffer;
class SrsFileWriter;
/**
* encode data to aac file.
* Transmux RTMP packet to MP3 stream.
*/
class SrsMp3Encoder
class SrsMp3Transmuxer
{
private:
SrsFileWriter* writer;
private:
SrsBuffer* tag_stream;
public:
SrsMp3Encoder();
virtual ~SrsMp3Encoder();
SrsMp3Transmuxer();
virtual ~SrsMp3Transmuxer();
public:
/**
* initialize the underlayer file stream.

68
trunk/src/kernel/srs_kernel_ts.cpp
View file

@ -2708,7 +2708,7 @@ int SrsTsPayloadPMT::psi_encode(SrsBuffer* stream)
return ret;
}
SrsTsMuxer::SrsTsMuxer(SrsFileWriter* w, SrsTsContext* c, SrsAudioCodecId ac, SrsVideoCodecId vc)
SrsTsContextWriter::SrsTsContextWriter(SrsFileWriter* w, SrsTsContext* c, SrsAudioCodecId ac, SrsVideoCodecId vc)
{
writer = w;
context = c;
@ -2717,12 +2717,12 @@ SrsTsMuxer::SrsTsMuxer(SrsFileWriter* w, SrsTsContext* c, SrsAudioCodecId ac, Sr
vcodec = vc;
}
SrsTsMuxer::~SrsTsMuxer()
SrsTsContextWriter::~SrsTsContextWriter()
{
close();
}
int SrsTsMuxer::open(string p)
int SrsTsContextWriter::open(string p)
{
int ret = ERROR_SUCCESS;
@ -2740,7 +2740,7 @@ int SrsTsMuxer::open(string p)
return ret;
}
int SrsTsMuxer::write_audio(SrsTsMessage* audio)
int SrsTsContextWriter::write_audio(SrsTsMessage* audio)
{
int ret = ERROR_SUCCESS;
@ -2756,7 +2756,7 @@ int SrsTsMuxer::write_audio(SrsTsMessage* audio)
return ret;
}
int SrsTsMuxer::write_video(SrsTsMessage* video)
int SrsTsContextWriter::write_video(SrsTsMessage* video)
{
int ret = ERROR_SUCCESS;
@ -2772,29 +2772,29 @@ int SrsTsMuxer::write_video(SrsTsMessage* video)
return ret;
}
void SrsTsMuxer::close()
void SrsTsContextWriter::close()
{
writer->close();
}
SrsVideoCodecId SrsTsMuxer::video_codec()
SrsVideoCodecId SrsTsContextWriter::video_codec()
{
return vcodec;
}
SrsTsCache::SrsTsCache()
SrsTsMessageCache::SrsTsMessageCache()
{
audio = NULL;
video = NULL;
}
SrsTsCache::~SrsTsCache()
SrsTsMessageCache::~SrsTsMessageCache()
{
srs_freep(audio);
srs_freep(video);
}
int SrsTsCache::cache_audio(SrsAudioFrame* frame, int64_t dts)
int SrsTsMessageCache::cache_audio(SrsAudioFrame* frame, int64_t dts)
{
int ret = ERROR_SUCCESS;
@ -2828,7 +2828,7 @@ int SrsTsCache::cache_audio(SrsAudioFrame* frame, int64_t dts)
return ret;
}
int SrsTsCache::cache_video(SrsVideoFrame* frame, int64_t dts)
int SrsTsMessageCache::cache_video(SrsVideoFrame* frame, int64_t dts)
{
int ret = ERROR_SUCCESS;
@ -2851,7 +2851,7 @@ int SrsTsCache::cache_video(SrsVideoFrame* frame, int64_t dts)
return ret;
}
int SrsTsCache::do_cache_mp3(SrsAudioFrame* frame)
int SrsTsMessageCache::do_cache_mp3(SrsAudioFrame* frame)
{
int ret = ERROR_SUCCESS;
@ -2865,7 +2865,7 @@ int SrsTsCache::do_cache_mp3(SrsAudioFrame* frame)
return ret;
}
int SrsTsCache::do_cache_aac(SrsAudioFrame* frame)
int SrsTsMessageCache::do_cache_aac(SrsAudioFrame* frame)
{
int ret = ERROR_SUCCESS;
@ -2992,7 +2992,7 @@ void srs_avc_insert_aud(SrsSimpleStream* payload, bool& aud_inserted)
}
}
int SrsTsCache::do_cache_avc(SrsVideoFrame* frame)
int SrsTsMessageCache::do_cache_avc(SrsVideoFrame* frame)
{
int ret = ERROR_SUCCESS;
@ -3075,24 +3075,24 @@ int SrsTsCache::do_cache_avc(SrsVideoFrame* frame)
return ret;
}
SrsTsEncoder::SrsTsEncoder()
SrsTsTransmuxer::SrsTsTransmuxer()
{
writer = NULL;
format = new SrsFormat();
cache = new SrsTsCache();
tsmc = new SrsTsMessageCache();
context = new SrsTsContext();
muxer = NULL;
tscw = NULL;
}
SrsTsEncoder::~SrsTsEncoder()
SrsTsTransmuxer::~SrsTsTransmuxer()
{
srs_freep(format);
srs_freep(cache);
srs_freep(muxer);
srs_freep(tsmc);
srs_freep(tscw);
srs_freep(context);
}
int SrsTsEncoder::initialize(SrsFileWriter* fw)
int SrsTsTransmuxer::initialize(SrsFileWriter* fw)
{
int ret = ERROR_SUCCESS;
@ -3110,18 +3110,18 @@ int SrsTsEncoder::initialize(SrsFileWriter* fw)
writer = fw;
srs_freep(muxer);
srs_freep(tscw);
// TODO: FIXME: Support config the codec.
muxer = new SrsTsMuxer(fw, context, SrsAudioCodecIdAAC, SrsVideoCodecIdAVC);
tscw = new SrsTsContextWriter(fw, context, SrsAudioCodecIdAAC, SrsVideoCodecIdAVC);
if ((ret = muxer->open("")) != ERROR_SUCCESS) {
if ((ret = tscw->open("")) != ERROR_SUCCESS) {
return ret;
}
return ret;
}
int SrsTsEncoder::write_audio(int64_t timestamp, char* data, int size)
int SrsTsTransmuxer::write_audio(int64_t timestamp, char* data, int size)
{
int ret = ERROR_SUCCESS;
@ -3146,7 +3146,7 @@ int SrsTsEncoder::write_audio(int64_t timestamp, char* data, int size)
int64_t dts = timestamp * 90;
// write audio to cache.
if ((ret = cache->cache_audio(format->audio, dts)) != ERROR_SUCCESS) {
if ((ret = tsmc->cache_audio(format->audio, dts)) != ERROR_SUCCESS) {
return ret;
}
@ -3157,7 +3157,7 @@ int SrsTsEncoder::write_audio(int64_t timestamp, char* data, int size)
return flush_audio();
}
int SrsTsEncoder::write_video(int64_t timestamp, char* data, int size)
int SrsTsTransmuxer::write_video(int64_t timestamp, char* data, int size)
{
int ret = ERROR_SUCCESS;
@ -3185,37 +3185,37 @@ int SrsTsEncoder::write_video(int64_t timestamp, char* data, int size)
int64_t dts = timestamp * 90;
// write video to cache.
if ((ret = cache->cache_video(format->video, dts)) != ERROR_SUCCESS) {
if ((ret = tsmc->cache_video(format->video, dts)) != ERROR_SUCCESS) {
return ret;
}
return flush_video();
}
int SrsTsEncoder::flush_audio()
int SrsTsTransmuxer::flush_audio()
{
int ret = ERROR_SUCCESS;
if ((ret = muxer->write_audio(cache->audio)) != ERROR_SUCCESS) {
if ((ret = tscw->write_audio(tsmc->audio)) != ERROR_SUCCESS) {
return ret;
}
// write success, clear and free the ts message.
srs_freep(cache->audio);
srs_freep(tsmc->audio);
return ret;
}
int SrsTsEncoder::flush_video()
int SrsTsTransmuxer::flush_video()
{
int ret = ERROR_SUCCESS;
if ((ret = muxer->write_video(cache->video)) != ERROR_SUCCESS) {
if ((ret = tscw->write_video(tsmc->video)) != ERROR_SUCCESS) {
return ret;
}
// write success, clear and free the ts message.
srs_freep(cache->video);
srs_freep(tsmc->video);
return ret;
}

42
trunk/src/kernel/srs_kernel_ts.hpp
View file

@ -38,8 +38,8 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#include <srs_kernel_codec.hpp>
class SrsBuffer;
class SrsTsCache;
class SrsTSMuxer;
class SrsTsMessageCache;
class SrsTsContextWriter;
class SrsFileWriter;
class SrsFileReader;
class SrsFormat;
@ -1556,10 +1556,9 @@ protected:
};
/**
* write data from frame(header info) and buffer(data) to ts file.
* it's a simple object wrapper for utility from nginx-rtmp: SrsMpegtsWriter
* Write the TS message to TS context.
*/
class SrsTsMuxer
class SrsTsContextWriter
{
private:
// User must config the codec in right way.
@ -1571,8 +1570,8 @@ private:
SrsFileWriter* writer;
std::string path;
public:
SrsTsMuxer(SrsFileWriter* w, SrsTsContext* c, SrsAudioCodecId ac, SrsVideoCodecId vc);
virtual ~SrsTsMuxer();
SrsTsContextWriter(SrsFileWriter* w, SrsTsContext* c, SrsAudioCodecId ac, SrsVideoCodecId vc);
virtual ~SrsTsContextWriter();
public:
/**
* open the writer, donot write the PSI of ts.
@ -1599,24 +1598,18 @@ public:
};
/**
* ts stream cache,
* use to cache ts stream.
*
* about the flv tbn problem:
* flv tbn is 1/1000, ts tbn is 1/90000,
* when timestamp convert to flv tbn, it will loose precise,
* so we must gather audio frame together, and recalc the timestamp @see SrsTsAacJitter,
* we use a aac jitter to correct the audio pts.
* TS messages cache, to group frames to TS message,
* for example, we may write multiple AAC RAW frames to a TS message.
*/
class SrsTsCache
class SrsTsMessageCache
{
public:
// current ts message.
SrsTsMessage* audio;
SrsTsMessage* video;
public:
SrsTsCache();
virtual ~SrsTsCache();
SrsTsMessageCache();
virtual ~SrsTsMessageCache();
public:
/**
* write audio to cache
@ -1633,21 +1626,20 @@ private:
};
/**
* encode data to ts file.
* Transmux the RTMP stream to TS stream.
*/
// TODO: FIXME: Rename it.
class SrsTsEncoder
class SrsTsTransmuxer
{
private:
SrsFileWriter* writer;
private:
SrsFormat* format;
SrsTsCache* cache;
SrsTsMuxer* muxer;
SrsTsMessageCache* tsmc;
SrsTsContextWriter* tscw;
SrsTsContext* context;
public:
SrsTsEncoder();
virtual ~SrsTsEncoder();
SrsTsTransmuxer();
virtual ~SrsTsTransmuxer();
public:
/**
* initialize the underlayer file stream.

4
trunk/src/libs/srs_librtmp.cpp
View file

@ -1680,7 +1680,7 @@ struct FlvContext
{
SrsFileReader reader;
SrsFileWriter writer;
SrsFlvEncoder enc;
SrsFlvTransmuxer enc;
SrsFlvDecoder dec;
};
@ -1829,7 +1829,7 @@ int srs_flv_write_tag(srs_flv_t flv, char type, int32_t time, char* data, int si
int srs_flv_size_tag(int data_size)
{
return SrsFlvEncoder::size_tag(data_size);
return SrsFlvTransmuxer::size_tag(data_size);
}
int64_t srs_flv_tellg(srs_flv_t flv)

14
trunk/src/utest/srs_utest_kernel.cpp
View file

@ -397,7 +397,7 @@ VOID TEST(KernelCodecTest, IsAudioSequenceHeader)
VOID TEST(KernelFlvTest, FlvEncoderStreamClosed)
{
MockSrsFileWriter fs;
SrsFlvEncoder enc;
SrsFlvTransmuxer enc;
// The decoder never check the reader status.
ASSERT_TRUE(ERROR_SUCCESS == enc.initialize(&fs));
}
@ -409,7 +409,7 @@ VOID TEST(KernelFlvTest, FlvEncoderStreamClosed)
VOID TEST(KernelFlvTest, FlvEncoderWriteHeader)
{
MockSrsFileWriter fs;
SrsFlvEncoder enc;
SrsFlvTransmuxer enc;
ASSERT_TRUE(ERROR_SUCCESS == fs.open(""));
ASSERT_TRUE(ERROR_SUCCESS == enc.initialize(&fs));
@ -450,7 +450,7 @@ VOID TEST(KernelFlvTest, FlvEncoderWriteMetadata)
{
MockSrsFileWriter fs;
EXPECT_TRUE(ERROR_SUCCESS == fs.open(""));
SrsFlvEncoder enc;
SrsFlvTransmuxer enc;
ASSERT_TRUE(ERROR_SUCCESS == enc.initialize(&fs));
// 11 bytes tag header
@ -483,7 +483,7 @@ VOID TEST(KernelFlvTest, FlvEncoderWriteMetadata)
VOID TEST(KernelFlvTest, FlvEncoderWriteAudio)
{
MockSrsFileWriter fs;
SrsFlvEncoder enc;
SrsFlvTransmuxer enc;
ASSERT_TRUE(ERROR_SUCCESS == fs.open(""));
ASSERT_TRUE(ERROR_SUCCESS == enc.initialize(&fs));
@ -517,7 +517,7 @@ VOID TEST(KernelFlvTest, FlvEncoderWriteAudio)
VOID TEST(KernelFlvTest, FlvEncoderWriteVideo)
{
MockSrsFileWriter fs;
SrsFlvEncoder enc;
SrsFlvTransmuxer enc;
ASSERT_TRUE(ERROR_SUCCESS == fs.open(""));
ASSERT_TRUE(ERROR_SUCCESS == enc.initialize(&fs));
@ -550,8 +550,8 @@ VOID TEST(KernelFlvTest, FlvEncoderWriteVideo)
*/
VOID TEST(KernelFlvTest, FlvEncoderSizeTag)
{
EXPECT_EQ(11+4+10, SrsFlvEncoder::size_tag(10));
EXPECT_EQ(11+4+0, SrsFlvEncoder::size_tag(0));
EXPECT_EQ(11+4+10, SrsFlvTransmuxer::size_tag(10));
EXPECT_EQ(11+4+0, SrsFlvTransmuxer::size_tag(0));
}
/**