Fix ossrs#2570, remove useless audio track info in PMT when no audio

trunk/src/kernel/srs_kernel_ts.cpp

@@ -78,6 +78,8 @@ SrsTsMessage::SrsTsMessage(SrsTsChannel* c, SrsTsPacket* p)
 
     start_pts = 0;
     write_pcr = false;
+    acodec = SrsAudioCodecIdForbidden;
+    vcodec = SrsVideoCodecIdForbidden;
 }
 
 SrsTsMessage::~SrsTsMessage()
@@ -2599,17 +2601,41 @@ SrsTsContextWriter::SrsTsContextWriter(ISrsStreamWriter* w, SrsTsContext* c, Srs
     writer = w;
     context = c;
 
-    acodec = ac;
-    vcodec = vc;
+    acodec = SrsAudioCodecIdForbidden;
+    vcodec = SrsVideoCodecIdForbidden;
+
+    ts_msg_cache_for_verify_codec.clear();
+    ts_cache_msg_verifying_done = false;
 }
 
 SrsTsContextWriter::~SrsTsContextWriter()
 {
+    flush_all_msg();
 }
 
 srs_error_t SrsTsContextWriter::write_audio(SrsTsMessage* audio)
 {
     srs_error_t err = srs_success;
+    if(acodec != audio->acodec) {
+        acodec = audio->acodec;
+    }
+
+    if(!ts_cache_msg_verifying_done) {
+        // video codec is not verified
+        if(vcodec == SrsVideoCodecIdForbidden) {
+            if(ts_msg_cache_for_verify_codec.size() < SRS_CONSTS_TS_MUXER_MSG_CACHE_COUT) {
+                ts_msg_cache_for_verify_codec.push_back(audio->detach());
+                return err;
+            } else {
+                flush_all_msg();
+                ts_cache_msg_verifying_done = true;
+            }
+        } else {
+            //video codec is verified
+            flush_all_msg();
+            ts_cache_msg_verifying_done = true;            
+        }
+    }
 
     srs_info("hls: write audio pts=%" PRId64 ", dts=%" PRId64 ", size=%d",
         audio->pts, audio->dts, audio->PES_packet_length);
@@ -2625,7 +2651,27 @@ srs_error_t SrsTsContextWriter::write_audio(SrsTsMessage* audio)
 srs_error_t SrsTsContextWriter::write_video(SrsTsMessage* video)
 {
     srs_error_t err = srs_success;
-
+    if(vcodec != video->vcodec) {
+        vcodec = video->vcodec;
+    }
+
+    if(!ts_cache_msg_verifying_done) {
+        // audio codec is not verified
+        if(acodec == SrsAudioCodecIdForbidden) {
+            if(ts_msg_cache_for_verify_codec.size() < SRS_CONSTS_TS_MUXER_MSG_CACHE_COUT) {
+                ts_msg_cache_for_verify_codec.push_back(video->detach());
+                return err;
+            } else {
+                flush_all_msg();
+                ts_cache_msg_verifying_done = true;
+            }
+        } else {
+            //video codec is verified
+            flush_all_msg();
+            ts_cache_msg_verifying_done = true;            
+        }
+    }
+
     srs_info("hls: write video pts=%" PRId64 ", dts=%" PRId64 ", size=%d",
         video->pts, video->dts, video->PES_packet_length);
 
@@ -2637,11 +2683,41 @@ srs_error_t SrsTsContextWriter::write_video(SrsTsMessage* video)
     return err;
 }
 
+void SrsTsContextWriter::flush_all_msg()
+{
+    int idx=0;
+    int size = ts_msg_cache_for_verify_codec.size();
+    SrsTsMessage*  msg = NULL;
+    for(idx=0; idx<size; idx++) {
+        msg = ts_msg_cache_for_verify_codec.at(idx);
+        if(msg) {            
+            context->encode(writer, msg, vcodec, acodec);
+            srs_freep(msg);
+        }
+    }
+
+    srs_trace("flush all msg in cache, msg size:%d, the acodec:%d, the vcodec:%d", size, acodec, vcodec);
+    ts_msg_cache_for_verify_codec.clear();
+    return;
+}
+
 SrsVideoCodecId SrsTsContextWriter::video_codec()
 {
     return vcodec;
 }
 
+SrsAudioCodecId SrsTsContextWriter::audio_codec()
+{
+    return acodec;
+}
+
+void SrsTsContextWriter::set_ts_codec_force(SrsAudioCodecId ac, SrsVideoCodecId vc)
+{
+    acodec = ac;
+    vcodec = vc;
+    ts_cache_msg_verifying_done = true;
+}
+
 SrsEncFileWriter::SrsEncFileWriter()
 {
     memset(iv,0,16);
@@ -2761,6 +2837,7 @@ srs_error_t SrsTsMessageCache::cache_audio(SrsAudioFrame* frame, int64_t dts)
     SrsAudioCodecConfig* acodec = frame->acodec();
     srs_assert(acodec->id == SrsAudioCodecIdAAC || acodec->id == SrsAudioCodecIdMP3);
 
+    audio->acodec = acodec->id;
     // write video to cache.
     if (acodec->id == SrsAudioCodecIdAAC) {
         if ((err = do_cache_aac(frame)) != srs_success) {
@@ -2983,6 +3060,7 @@ srs_error_t SrsTsMessageCache::do_cache_avc(SrsVideoFrame* frame)
 
     SrsVideoCodecConfig* codec = frame->vcodec();
     srs_assert(codec);
+    video->vcodec = codec->id;
 
     bool is_sps_pps_appended = false;
 

trunk/src/kernel/srs_kernel_ts.hpp

@@ -35,6 +35,9 @@ class SrsTsContext;
 // The aggregate pure audio for hls, in ts tbn(ms * 90).
 #define SRS_CONSTS_HLS_PURE_AUDIO_AGGREGATE 720 * 90
 
+// The ts muxer cache count for verifying the codec.
+#define SRS_CONSTS_TS_MUXER_MSG_CACHE_COUT 50
+
 // The pid of ts packet,
 // Table 2-3 - PID table, hls-mpeg-ts-iso13818-1.pdf, page 37
 // NOTE - The transport packets with PID values 0x0000, 0x0001, and 0x0010-0x1FFE are allowed to carry a PCR.
@@ -220,6 +223,8 @@ class SrsTsMessage
     // for user to get the channel and packet.
     SrsTsChannel* channel;
     SrsTsPacket* packet;
+    SrsVideoCodecId vcodec;
+    SrsAudioCodecId acodec;
 public:
     // The audio cache buffer start pts, to flush audio if full.
     // @remark the pts is not the adjust one, it's the orignal pts.
@@ -1248,6 +1253,10 @@ class SrsTsContextWriter
     SrsTsContext* context;
     ISrsStreamWriter* writer;
     std::string path;
+    std::vector<SrsTsMessage*> ts_msg_cache_for_verify_codec;
+    bool ts_cache_msg_verifying_done;
+private:
+    virtual void flush_all_msg();
 public:
     SrsTsContextWriter(ISrsStreamWriter* w, SrsTsContext* c, SrsAudioCodecId ac, SrsVideoCodecId vc);
     virtual ~SrsTsContextWriter();
@@ -1259,6 +1268,8 @@ class SrsTsContextWriter
 public:
     // get the video codec of ts muxer.
     virtual SrsVideoCodecId video_codec();
+    virtual SrsAudioCodecId audio_codec();
+    void       set_ts_codec_force(SrsAudioCodecId ac, SrsVideoCodecId vc);
 };
 
 // Used for HLS Encryption