for #299, refine the encoder object name

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.
-*/
-class SrsAacEncoder
+ * Transmux the RTMP packets to AAC stream.
+ */
+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.

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.
-*/
-class SrsFlvEncoder
+ * Transmux RTMP packets to FLV stream.
+ */
+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.

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.
-*/
-class SrsMp3Encoder
+ * Transmux RTMP packet to MP3 stream.
+ */
+class SrsMp3Transmuxer
 {
 private:
     SrsFileWriter* writer;
 private:
     SrsBuffer* tag_stream;
 public:
-    SrsMp3Encoder();
-    virtual ~SrsMp3Encoder();
+    SrsMp3Transmuxer();
+    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(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;
 }

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 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
-*/
-class SrsTsMuxer
+ * Write the TS message to TS context.
+ */
+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.
-*/
-class SrsTsCache
+ * TS messages cache, to group frames to TS message,
+ * for example, we may write multiple AAC RAW frames to a TS message.
+ */
+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.
-*/
-// TODO: FIXME: Rename it.
-class SrsTsEncoder
+ * Transmux the RTMP stream to TS stream.
+ */
+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.