merge from srs2.

README.md

@@ -348,6 +348,7 @@ Remark:
 
 ### SRS 2.0 history
 
+* v2.0, 2015-06-10, fix [#424](https://github.com/simple-rtmp-server/srs/issues/424) fix aggregate timestamp bug. 2.0.174
 * v2.0, 2015-06-06, fix [#421](https://github.com/simple-rtmp-server/srs/issues/421) drop video for unkown RTMP header.
 * v2.0, 2015-06-05, fix [#420](https://github.com/simple-rtmp-server/srs/issues/420) remove ts for hls ram mode.
 * v2.0, 2015-05-30, fix [#209](https://github.com/simple-rtmp-server/srs/issues/209) cleanup hls when stop and timeout. 2.0.173.

trunk/auto/generate-srs-librtmp-single.sh

@@ -80,7 +80,7 @@ function build_module_hpp()
 }
 SRS_LIBRTMP_OBJS="${CORE_OBJS[@]}" && build_module_hpp
 SRS_LIBRTMP_OBJS="${KERNEL_OBJS[@]}" && build_module_hpp
-SRS_LIBRTMP_OBJS="${RTMP_OBJS[@]}" && build_module_hpp
+SRS_LIBRTMP_OBJS="${PROTOCOL_OBJS[@]}" && build_module_hpp
 SRS_LIBRTMP_OBJS="${LIBS_OBJS[@]}" && build_module_hpp
 # module to cpp files.
 function build_module_cpp()
@@ -99,7 +99,7 @@ function build_module_cpp()
 }
 SRS_LIBRTMP_OBJS="${CORE_OBJS[@]}" && build_module_cpp
 SRS_LIBRTMP_OBJS="${KERNEL_OBJS[@]}" && build_module_cpp
-SRS_LIBRTMP_OBJS="${RTMP_OBJS[@]}" && build_module_cpp
+SRS_LIBRTMP_OBJS="${PROTOCOL_OBJS[@]}" && build_module_cpp
 SRS_LIBRTMP_OBJS="${LIBS_OBJS[@]}" && build_module_cpp
 
 # create example.cpp

trunk/src/app/srs_app_rtmp_conn.cpp

@@ -88,6 +88,7 @@ SrsRtmpConn::SrsRtmpConn(SrsServer* svr, st_netfd_t c)
     duration = 0;
     kbps = new SrsKbps();
     kbps->set_io(skt, skt);
+    wakable = NULL;
     
     mw_sleep = SRS_PERF_MW_SLEEP;
     mw_enabled = false;
@@ -110,6 +111,16 @@ SrsRtmpConn::~SrsRtmpConn()
     srs_freep(kbps);
 }
 
+void SrsRtmpConn::dispose()
+{
+    SrsConnection::dispose();
+    
+    // wakeup the handler which need to notice.
+    if (wakable) {
+        wakable->wakeup();
+    }
+}
+
 // TODO: return detail message when error for client.
 int SrsRtmpConn::do_cycle()
 {
@@ -597,7 +608,9 @@ int SrsRtmpConn::playing(SrsSource* source)
     }
     
     // delivery messages for clients playing stream.
+    wakable = consumer;
     ret = do_playing(source, consumer, &trd);
+    wakable = NULL;
     
     // stop isolate recv thread
     trd.stop();

trunk/src/app/srs_app_rtmp_conn.hpp

@@ -53,6 +53,7 @@ class SrsSharedPtrMessage;
 class SrsQueueRecvThread;
 class SrsPublishRecvThread;
 class SrsSecurity;
+class ISrsWakable;
 
 /**
 * the client provides the main logic control for RTMP clients.
@@ -70,6 +71,8 @@ private:
     SrsRefer* refer;
     SrsBandwidth* bandwidth;
     SrsSecurity* security;
+    // the wakable handler, maybe NULL.
+    ISrsWakable* wakable;
     // elapse duration in ms
     // for live play duration, for instance, rtmpdump to record.
     // @see https://github.com/simple-rtmp-server/srs/issues/47
@@ -85,6 +88,8 @@ private:
 public:
     SrsRtmpConn(SrsServer* svr, st_netfd_t c);
     virtual ~SrsRtmpConn();
+public:
+    virtual void dispose();
 protected:
     virtual int do_cycle();
 // interface ISrsReloadHandler

trunk/src/app/srs_app_source.cpp

@@ -92,7 +92,7 @@ int SrsRtmpJitter::correct(SrsSharedPtrMessage* msg, int tba, int tbv, SrsRtmpJi
         if (ag == SrsRtmpJitterAlgorithmZERO) {
             // for the first time, last_pkt_correct_time is zero.
             // while when timestamp overflow, the timestamp become smaller, reset the last_pkt_correct_time.
-            if (last_pkt_correct_time <= 0 || last_pkt_correct_time > msg->timestamp) {
+            if (last_pkt_correct_time <= 0 || msg->timestamp < last_pkt_correct_time) {
                 last_pkt_correct_time = msg->timestamp;
             }
             msg->timestamp -= last_pkt_correct_time;
@@ -423,6 +423,14 @@ void SrsMessageQueue::clear()
     av_start_time = av_end_time = -1;
 }
 
+ISrsWakable::ISrsWakable()
+{
+}
+
+ISrsWakable::~ISrsWakable()
+{
+}
+
 SrsConsumer::SrsConsumer(SrsSource* _source)
 {
     source = _source;
@@ -551,14 +559,6 @@ void SrsConsumer::wait(int nb_msgs, int duration)
     // use cond block wait for high performance mode.
     st_cond_wait(mw_wait);
 }
-
-void SrsConsumer::wakeup()
-{
-    if (mw_waiting) {
-        st_cond_signal(mw_wait);
-        mw_waiting = false;
-    }
-}
 #endif
 
 int SrsConsumer::on_play_client_pause(bool is_pause)
@@ -571,6 +571,16 @@ int SrsConsumer::on_play_client_pause(bool is_pause)
     return ret;
 }
 
+void SrsConsumer::wakeup()
+{
+#ifdef SRS_PERF_QUEUE_COND_WAIT
+    if (mw_waiting) {
+        st_cond_signal(mw_wait);
+        mw_waiting = false;
+    }
+#endif
+}
+
 SrsGopCache::SrsGopCache()
 {
     cached_video_count = 0;
@@ -1912,7 +1922,8 @@ int SrsSource::on_aggregate(SrsCommonMessage* msg)
         timestamp &= 0x7FFFFFFF;
         
         // adjust abs timestamp in aggregate msg.
-        if (delta < 0) {
+        // only -1 means uninitialized delta.
+        if (delta == -1) {
             delta = (int)msg->header.timestamp - (int)timestamp;
         }
         timestamp += delta;

trunk/src/app/srs_app_source.hpp

@@ -196,10 +196,28 @@ private:
     virtual void clear();
 };
 
+/**
+ * the wakable used for some object
+ * which is waiting on cond.
+ */
+class ISrsWakable
+{
+public:
+    ISrsWakable();
+    virtual ~ISrsWakable();
+public:
+    /**
+     * when the consumer(for player) got msg from recv thread,
+     * it must be processed for maybe it's a close msg, so the cond
+     * wait must be wakeup.
+     */
+    virtual void wakeup() = 0;
+};
+
 /**
 * the consumer for SrsSource, that is a play client.
 */
-class SrsConsumer
+class SrsConsumer : public ISrsWakable
 {
 private:
     SrsRtmpJitter* jitter;
@@ -257,17 +275,19 @@ public:
     * @param duration the messgae duration to wait.
     */
     virtual void wait(int nb_msgs, int duration);
-    /**
-    * when the consumer(for player) got msg from recv thread,
-    * it must be processed for maybe it's a close msg, so the cond
-    * wait must be wakeup.
-    */
-    virtual void wakeup();
 #endif
     /**
     * when client send the pause message.
     */
     virtual int on_play_client_pause(bool is_pause);
+// ISrsWakable
+public:
+    /**
+     * when the consumer(for player) got msg from recv thread,
+     * it must be processed for maybe it's a close msg, so the cond
+     * wait must be wakeup.
+     */
+    virtual void wakeup();
 };
 
 /**