for #299, refine the encoder object name

trunk/src/app/srs_app_dvr.cpp

@@ -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;

trunk/src/app/srs_app_dvr.hpp

@@ -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.

trunk/src/app/srs_app_hls.cpp

@@ -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 (muxer->pure_audio() && tsmc->audio) {
-        if (pts - ts->audio->start_pts < SRS_CONSTS_HLS_PURE_AUDIO_AGGREGATE) {
+        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;
     }

trunk/src/app/srs_app_hls.hpp

@@ -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_audio(SrsTsMessageCache* cache);
-    virtual int flush_video(SrsTsCache* 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();

trunk/src/app/srs_app_http_conn.hpp

@@ -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;

trunk/src/app/srs_app_http_stream.cpp

@@ -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;
 }
 

trunk/src/app/srs_app_http_stream.hpp

@@ -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
 {

trunk/src/kernel/srs_kernel_aac.cpp

@@ -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;
     

trunk/src/kernel/srs_kernel_aac.hpp

@@ -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();
+    SrsAacTransmuxer();
-    virtual ~SrsAacEncoder();
+    virtual ~SrsAacTransmuxer();
 public:
     /**
     * initialize the underlayer file stream.

trunk/src/kernel/srs_kernel_flv.cpp

@@ -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;
     

trunk/src/kernel/srs_kernel_flv.hpp

@@ -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();
+    SrsFlvTransmuxer();
-    virtual ~SrsFlvEncoder();
+    virtual ~SrsFlvTransmuxer();
 public:
     /**
     * initialize the underlayer file stream.

trunk/src/kernel/srs_kernel_mp3.cpp

@@ -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;
     

trunk/src/kernel/srs_kernel_mp3.hpp

@@ -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();
+    SrsMp3Transmuxer();
-    virtual ~SrsMp3Encoder();
+    virtual ~SrsMp3Transmuxer();
 public:
     /**
     * initialize the underlayer file stream.

trunk/src/kernel/srs_kernel_ts.cpp

@@ -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(tsmc);
-    srs_freep(muxer);
+    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;
 }

trunk/src/kernel/srs_kernel_ts.hpp

@@ -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 SrsTsMessageCache;
-class SrsTSMuxer;
+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.
+ * Write the TS message to TS context.
-* it's a simple object wrapper for utility from nginx-rtmp: SrsMpegtsWriter
  */
-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);
+    SrsTsContextWriter(SrsFileWriter* w, SrsTsContext* c, SrsAudioCodecId ac, SrsVideoCodecId vc);
-    virtual ~SrsTsMuxer();
+    virtual ~SrsTsContextWriter();
 public:
     /**
      * open the writer, donot write the PSI of ts.
@@ -1599,24 +1598,18 @@ public:
 };
 
 /**
-* ts stream cache, 
+ * TS messages cache, to group frames to TS message,
-* use to cache ts stream.
+ * for example, we may write multiple AAC RAW frames to a TS message.
-* 
-* 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.
  */
-class SrsTsCache
+class SrsTsMessageCache
 {
 public:
     // current ts message.
     SrsTsMessage* audio;
     SrsTsMessage* video;
 public:
-    SrsTsCache();
+    SrsTsMessageCache();
-    virtual ~SrsTsCache();
+    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 SrsTsTransmuxer
-class SrsTsEncoder
 {
 private:
     SrsFileWriter* writer;
 private:
     SrsFormat* format;
-    SrsTsCache* cache;
+    SrsTsMessageCache* tsmc;
-    SrsTsMuxer* muxer;
+    SrsTsContextWriter* tscw;
     SrsTsContext* context;
 public:
-    SrsTsEncoder();
+    SrsTsTransmuxer();
-    virtual ~SrsTsEncoder();
+    virtual ~SrsTsTransmuxer();
 public:
     /**
      * initialize the underlayer file stream.

trunk/src/libs/srs_librtmp.cpp

@@ -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)

trunk/src/utest/srs_utest_kernel.cpp

@@ -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+10, SrsFlvTransmuxer::size_tag(10));
-    EXPECT_EQ(11+4+0, SrsFlvEncoder::size_tag(0));
+    EXPECT_EQ(11+4+0, SrsFlvTransmuxer::size_tag(0));
 }
 
 /**