Merge branch 'development' into LTS_development

# Conflicts:
#	src/output/output.cpp
#	src/output/output_http_internal.cpp

lib/mp4_generic.cpp

@@ -3460,67 +3460,67 @@ namespace MP4 {
     return getInt32(4);
   }
 
-  void ELST::setSegmentDuration(uint64_t newVal) {
+  void ELST::setSegmentDuration(uint32_t cnt, uint64_t newVal) {
     if (getVersion() == 1) {
-      setInt64(newVal, 8);
+      setInt64(newVal, 28*cnt+8);
     } else {
-      setInt32(newVal, 8);
+      setInt32(newVal, 20*cnt+8);
     }
   }
 
-  uint64_t ELST::getSegmentDuration() {
+  uint64_t ELST::getSegmentDuration(uint32_t cnt) {
     if (getVersion() == 1) {
-      return getInt64(8);
+      return getInt64(28*cnt+8);
     } else {
-      return getInt32(8);
+      return getInt32(20*cnt+8);
     }
   }
 
-  void ELST::setMediaTime(uint64_t newVal) {
+  void ELST::setMediaTime(uint32_t cnt, uint64_t newVal) {
     if (getVersion() == 1) {
-      setInt64(newVal, 16);
+      setInt64(newVal, 28*cnt+16);
     } else {
-      setInt32(newVal, 12);
+      setInt32(newVal, 20*cnt+12);
     }
   }
 
-  uint64_t ELST::getMediaTime() {
+  uint64_t ELST::getMediaTime(uint32_t cnt) {
     if (getVersion() == 1) {
-      return getInt64(16);
+      return getInt64(28*cnt+16);
     } else {
-      return getInt32(12);
+      return getInt32(20*cnt+12);
     }
   }
 
-  void ELST::setMediaRateInteger(uint16_t newVal) {
+  void ELST::setMediaRateInteger(uint32_t cnt, uint16_t newVal) {
     if (getVersion() == 1) {
-      setInt16(newVal, 24);
+      setInt16(newVal, 28*cnt+24);
     } else {
-      setInt16(newVal, 16);
+      setInt16(newVal, 20*cnt+16);
     }
   }
 
-  uint16_t ELST::getMediaRateInteger() {
+  uint16_t ELST::getMediaRateInteger(uint32_t cnt) {
     if (getVersion() == 1) {
-      return getInt16(24);
+      return getInt16(28*cnt+24);
     } else {
-      return getInt16(16);
+      return getInt16(20*cnt+16);
     }
   }
 
-  void ELST::setMediaRateFraction(uint16_t newVal) {
+  void ELST::setMediaRateFraction(uint32_t cnt, uint16_t newVal) {
     if (getVersion() == 1) {
-      setInt16(newVal, 26);
+      setInt16(newVal, 28*cnt+26);
     } else {
-      setInt16(newVal, 18);
+      setInt16(newVal, 20*cnt+18);
     }
   }
 
-  uint16_t ELST::getMediaRateFraction() {
+  uint16_t ELST::getMediaRateFraction(uint32_t cnt) {
     if (getVersion() == 1) {
-      return getInt16(26);
+      return getInt16(28*cnt+26);
     } else {
-      return getInt16(18);
+      return getInt16(20*cnt+18);
     }
   }
 
@@ -3528,11 +3528,15 @@ namespace MP4 {
     std::stringstream r;
     r << std::string(indent, ' ') << "[elst] Edit List Box (" << boxedSize() << ")" << std::endl;
     r << fullBox::toPrettyString(indent);
-    r << std::string(indent + 1, ' ') << "Count: " << getCount() << std::endl;
+    uint32_t cnt = getCount();
-    r << std::string(indent + 1, ' ') << "SegmentDuration: " << getSegmentDuration() << std::endl;
+    r << std::string(indent + 1, ' ') << "Count: " << cnt << std::endl;
-    r << std::string(indent + 1, ' ') << "MediaTime: " << getMediaTime() << std::endl;
+    for (uint32_t i = 0; i < cnt; ++i){
-    r << std::string(indent + 1, ' ') << "MediaRateInteger: " << getMediaRateInteger() << std::endl;
+      r << std::string(indent + 1, ' ') << "[Entry " << i << "] " << std::endl;
-    r << std::string(indent + 1, ' ') << "MediaRateFraction: " << getMediaRateFraction() << std::endl;
+      r << std::string(indent + 2, ' ') << "SegmentDuration: " << getSegmentDuration(i) << std::endl;
+      r << std::string(indent + 2, ' ') << "MediaTime: " << getMediaTime(i) << std::endl;
+      r << std::string(indent + 2, ' ') << "MediaRateInteger: " << getMediaRateInteger(i) << std::endl;
+      r << std::string(indent + 2, ' ') << "MediaRateFraction: " << getMediaRateFraction(i) << std::endl;
+    }
     return r.str();
   }
 }

lib/mp4_generic.h

@@ -783,14 +783,14 @@ namespace MP4 {
       ELST();
       void setCount(uint32_t newVal);
       uint32_t getCount();
-      void setSegmentDuration(uint64_t newVal);
+      void setSegmentDuration(uint32_t cnt, uint64_t newVal);
-      uint64_t getSegmentDuration();
+      uint64_t getSegmentDuration(uint32_t cnt);
-      void setMediaTime(uint64_t newVal);
+      void setMediaTime(uint32_t cnt, uint64_t newVal);
-      uint64_t getMediaTime();
+      uint64_t getMediaTime(uint32_t cnt);
-      void setMediaRateInteger(uint16_t newVal);
+      void setMediaRateInteger(uint32_t cnt, uint16_t newVal);
-      uint16_t getMediaRateInteger();
+      uint16_t getMediaRateInteger(uint32_t cnt);
-      void setMediaRateFraction(uint16_t newVal);
+      void setMediaRateFraction(uint32_t cnt, uint16_t newVal);
-      uint16_t getMediaRateFraction();
+      uint16_t getMediaRateFraction(uint32_t cnt);
       std::string toPrettyString(uint32_t indent = 0);
   };
 }

lib/shared_memory.cpp

@@ -807,11 +807,15 @@ namespace IPC {
 
   ///\brief Creates the next page with the correct size
   void sharedServer::newPage() {
-    sharedPage tmp(std::string(baseName.substr(1) + (char)(myPages.size() + (int)'A')), std::min(((8192 * 2) << myPages.size()), (32 * 1024 * 1024)), true);
+    sharedPage tmp(std::string(baseName.substr(1) + (char)(myPages.size() + (int)'A')), std::min(((8192 * 2) << myPages.size()), (32 * 1024 * 1024)), false);
-    myPages.push_back(tmp);
+    if (!tmp.mapped){
+      tmp.init(std::string(baseName.substr(1) + (char)(myPages.size() + (int)'A')), std::min(((8192 * 2) << myPages.size()), (32 * 1024 * 1024)), true);
       tmp.master = false;
-    DEBUG_MSG(DLVL_VERYHIGH, "Created a new page: %s", tmp.name.c_str());
+    }
-    amount += tmp.len / (payLen + (hasCounter ? 1 : 0)) - 1;
+    myPages.push_back(tmp);
+    myPages.back().master = true;
+    VERYHIGH_MSG("Created a new page: %s", tmp.name.c_str());
+    amount += (32 * 1024 * 1024)*myPages.size();//assume maximum load - we don't want to miss any entries
   }
 
   ///\brief Deletes the highest allocated page
@@ -982,12 +986,12 @@ namespace IPC {
             if (countNum == 127 || countNum == 126){
               semGuard tmpGuard(&mySemaphore);
               if (disconCallback){
-                disconCallback(it->mapped + offset + 1, payLen, id);
+                disconCallback(counter + 1, payLen, id);
               }
-              memset(it->mapped + offset + 1, 0, payLen);
+              memset(counter + 1, 0, payLen);
-              it->mapped[offset] = 0;
+              *counter = 0;
             } else {
-              it->mapped[offset] ++;
+              ++(*counter);
             }
           } else {
             //stop if we're past the amount counted and we're empty

src/input/input.cpp

@@ -338,6 +338,10 @@ namespace Mist {
       getNext();
       nProxy.userClient.keepAlive();
     }
+    std::string reason = "Unknown";
+    if (!thisPacket){reason = "Invalid packet";}
+    if (!config->is_active){reason = "received deactivate signal";}
+    if (!nProxy.userClient.isAlive()){reason = "buffer shutdown";}
 
     closeStreamSource();
 
@@ -346,7 +350,7 @@ namespace Mist {
     pullLock.post();
     pullLock.close();
     pullLock.unlink();
-    INFO_MSG("Stream input %s closing clean", streamName.c_str());
+    INFO_MSG("Stream input %s closing clean; reason: %s", streamName.c_str(), reason.c_str());
     return;
   }
 

src/input/input_dtsc.cpp

@@ -248,6 +248,7 @@ namespace Mist {
   void inputDTSC::getNext(bool smart) {
     if (!needsLock()){
       thisPacket.reInit(srcConn);
+      while (config->is_active){
         if (thisPacket.getVersion() == DTSC::DTCM){
           nProxy.userClient.keepAlive();
           std::string cmd;
@@ -284,16 +285,14 @@ namespace Mist {
                 INFO_MSG("Reset: deleting track %d", *it);
                 myMeta.tracks.erase(*it);
               }
-
+              thisPacket.reInit(srcConn);//read the next packet before continuing
-            //Read next packet before returning
-            return getNext(smart);
             }else{
               myMeta = DTSC::Meta();
             }
           }else{
-          //Read next packet before returning
+            thisPacket.reInit(srcConn);//read the next packet before continuing
-          thisPacket.reInit(srcConn);
           }
+          continue;//parse the next packet before returning
         }else if (thisPacket.getVersion() == DTSC::DTSC_HEAD){
           DTSC::Meta newMeta;
           newMeta.reinit(thisPacket);
@@ -309,7 +308,19 @@ namespace Mist {
             myMeta.tracks[*it] = newMeta.tracks[*it];
             continueNegotiate(*it, true);
           }
-        return getNext(smart);
+          thisPacket.reInit(srcConn);//read the next packet before continuing
+          continue;//parse the next packet before returning
+        }
+        //We now know we have either a data packet, or an error.
+        if (!thisPacket.getTrackId()){
+          if (thisPacket.getVersion() == DTSC::DTSC_V2){
+            WARN_MSG("Received bad packet for stream %s: %llu@%llu", streamName.c_str(), thisPacket.getTrackId(), thisPacket.getTime());
+          }else{
+            //All types except data packets are handled above, so if it's not a V2 data packet, we assume corruption
+            WARN_MSG("Invalid packet header for stream %s", streamName.c_str());
+          }
+        }
+        return;//we have a packet
       }
     }else{
       if (smart) {

src/output/output.cpp

@@ -20,10 +20,6 @@
 #include <netdb.h>
 /*LTS-END*/
 
-#ifndef MIN_DELAY
-#define MIN_DELAY 2500
-#endif
-
 namespace Mist{
   JSON::Value Output::capa = JSON::Value();
 
@@ -50,7 +46,7 @@ namespace Mist{
     sought = false;
     isInitialized = false;
     isBlocking = false;
-    completeKeysOnly = false;
+    needsLookAhead = 0;
     lastStats = 0;
     maxSkipAhead = 7500;
     minSkipAhead = 5000;
@@ -751,7 +747,7 @@ namespace Mist{
 
   /// This function decides where in the stream initial playback starts.
   /// The default implementation calls seek(0) for VoD.
-  /// For live, it seeks to the last sync'ed keyframe of the main track, no closer than MIN_DELAY ms from the end.
+  /// For live, it seeks to the last sync'ed keyframe of the main track, no closer than needsLookAhead ms from the end.
   /// Unless lastms < 5000, then it seeks to the first keyframe of the main track.
   /// Aborts if there is no main track or it has no keyframes.
   void Output::initialSeek(){
@@ -767,7 +763,7 @@ namespace Mist{
         bool good = true;
         //check if all tracks have data for this point in time
         for (std::set<unsigned long>::iterator ti = selectedTracks.begin(); ti != selectedTracks.end(); ++ti){
-          if (myMeta.tracks[*ti].lastms < seekPos+MIN_DELAY){good = false; break;}
+          if (myMeta.tracks[*ti].lastms < seekPos+needsLookAhead){good = false; break;}
           if (mainTrack == *ti){continue;}//skip self
           if (!myMeta.tracks.count(*ti)){
             HIGH_MSG("Skipping track %lu, not in tracks", *ti);
@@ -854,41 +850,32 @@ namespace Mist{
               }
             }
 
-            //delay the stream until its current keyframe is complete, if only complete keys wanted
+            //delay the stream until metadata has caught up, if needed
-            if (completeKeysOnly){
+            if (needsLookAhead){
-              bool completeKeyReady = false;
+              //we sleep in 250ms increments, or less if the lookahead time itself is less
-              int timeoutTries = 40;//wait default 250ms*40=10 seconds
+              uint32_t sleepTime = std::min((uint32_t)250, needsLookAhead);
-              for (std::map<unsigned int, DTSC::Track>::iterator it = myMeta.tracks.begin(); it != myMeta.tracks.end(); it++){
+              //wait at most double the look ahead time, plus ten seconds
-                if (it->second.keys.size() >1){
+              uint32_t timeoutTries = (needsLookAhead / sleepTime) * 2 + (10000/sleepTime);
-                  int thisTimeoutTries = ((it->second.lastms - it->second.firstms) / (it->second.keys.size()-1)) / 125;
+              uint64_t needsTime = thisPacket.getTime() + needsLookAhead; 
-                  if (thisTimeoutTries > timeoutTries) timeoutTries = thisTimeoutTries;
+              while(--timeoutTries){
+                bool lookReady = true;
+                for (std::set<long unsigned int>::iterator it = selectedTracks.begin(); it != selectedTracks.end(); it++){
+                  if (myMeta.tracks[*it].lastms <= needsTime){
+                    if (timeoutTries == 1){
+                      WARN_MSG("Track %lu: %llu <= %llu", *it, myMeta.tracks[*it].lastms, needsTime);
                     }
-              }
+                    lookReady = false;
-              unsigned int mTrack = getMainSelectedTrack();
-              while(!completeKeyReady && timeoutTries>0){
-                if (!myMeta.tracks[mTrack].keys.size() || myMeta.tracks[mTrack].keys.rbegin()->getTime() <= thisPacket.getTime()){
-                  completeKeyReady = false;
-                }else{
-                  DTSC::Key & mustHaveKey = myMeta.tracks[mTrack].getKey(getKeyForTime(mTrack, thisPacket.getTime()));
-                  unsigned long long mustHaveTime = mustHaveKey.getTime() + mustHaveKey.getLength(); 
-                  completeKeyReady = true;
-                  for (std::set<unsigned long>::iterator it = selectedTracks.begin(); it != selectedTracks.end(); it++){
-                    if (myMeta.tracks[*it].lastms < mustHaveTime){
-                      completeKeyReady = false;
                     break;
                   }
                 }
-                }
+                if (lookReady){break;}
-                if (!completeKeyReady){
+                Util::wait(sleepTime);
-                  timeoutTries--;//we count down
                 stats();
-                  Util::wait(250);
                 updateMeta();
               }
-              }
+              if (!timeoutTries){
-              if (timeoutTries<=0){
+                WARN_MSG("Waiting for lookahead timed out - resetting lookahead!");
-                WARN_MSG("Waiting for key frame timed out");
+                needsLookAhead = 0;
-                completeKeysOnly = false;
               }
             }
 

src/output/output.h

@@ -114,7 +114,7 @@ namespace Mist {
       unsigned int maxSkipAhead;///< Maximum ms that we will go ahead of the intended timestamps.
       unsigned int minSkipAhead;///< Minimum ms that we will go ahead of the intended timestamps.
       unsigned int realTime;///< Playback speed in ms of data per second. eg: 0 is infinite, 1000 real-time, 5000 is 0.2X speed, 500 = 2X speed.
-      bool completeKeysOnly;///< Bool if we send whole keys only, so the metadata is complete and the output knows in advance what will be sent.
+      uint32_t needsLookAhead;///< Amount of millis we need to be able to look ahead in the metadata
 
       //Read/write status variables
       Socket::Connection & myConn;///< Connection to the client.

src/output/output_http_internal.cpp

@@ -32,6 +32,11 @@ namespace Mist {
   }
   
   void OutHTTP::onFail(){
+    // send logo icon
+    if (H.url.length() > 4 && H.url.substr(H.url.length() - 4, 4) == ".ico"){
+      sendIcon();
+      return;
+    }
     INFO_MSG("Failing: %s", H.url.c_str());
     if (H.url.size() >= 3 && H.url.substr(H.url.size() - 3) == ".js"){
       if (H.url.size() >= 5 && H.url.substr(0, 5) == "/json"){
@@ -258,36 +263,7 @@ namespace Mist {
     }
     // send logo icon
     if (H.url.length() > 4 && H.url.substr(H.url.length() - 4, 4) == ".ico"){
-      /*LTS-START*/
+      sendIcon();
-      if (H.GetVar("s").size() && H.GetVar("s") == SUPER_SECRET){
-        H.Clean();
-        H.SetHeader("Server", "mistserver/" PACKAGE_VERSION);
-        H.setCORSHeaders();
-        if(method == "OPTIONS" || method == "HEAD"){
-          H.SendResponse("200", "OK", myConn);
-          H.Clean();
-          return;
-        }
-        H.SetBody("Yup");
-        H.SendResponse("200", "OK", myConn);
-        H.Clean();
-        return;
-      }
-      /*LTS-END*/
-      H.Clean();
-      #include "../icon.h"
-      H.SetHeader("Content-Type", "image/x-icon");
-      H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
-      H.SetHeader("Content-Length", icon_len);
-      H.setCORSHeaders();
-      if(method == "OPTIONS" || method == "HEAD"){
-        H.SendResponse("200", "OK", myConn);
-        H.Clean();
-        return;
-      }
-      H.SendResponse("200", "OK", myConn);
-      myConn.SendNow((const char*)icon_data, icon_len);
-      H.Clean();
       return;
     }
     
@@ -646,4 +622,40 @@ namespace Mist {
       return;
     }
   }
+
+  void OutHTTP::sendIcon(){
+    std::string method = H.method;
+    /*LTS-START*/
+    if (H.GetVar("s").size() && H.GetVar("s") == SUPER_SECRET){
+      H.Clean();
+      H.SetHeader("Server", "mistserver/" PACKAGE_VERSION);
+      H.setCORSHeaders();
+      if(method == "OPTIONS" || method == "HEAD"){
+        H.SendResponse("200", "OK", myConn);
+        H.Clean();
+        return;
       }
+      H.SetBody("Yup");
+      H.SendResponse("200", "OK", myConn);
+      H.Clean();
+      return;
+    }
+    /*LTS-END*/
+    H.Clean();
+    #include "../icon.h"
+    H.SetHeader("Content-Type", "image/x-icon");
+    H.SetHeader("Server", "MistServer/" PACKAGE_VERSION);
+    H.SetHeader("Content-Length", icon_len);
+    H.setCORSHeaders();
+    if(method == "OPTIONS" || method == "HEAD"){
+      H.SendResponse("200", "OK", myConn);
+      H.Clean();
+      return;
+    }
+    H.SendResponse("200", "OK", myConn);
+    myConn.SendNow((const char*)icon_data, icon_len);
+    H.Clean();
+  }
+
+}
+

src/output/output_http_internal.h

@@ -11,6 +11,7 @@ namespace Mist {
       virtual void onFail();
       void onHTTP();
       bool isReadyForPlay();
+      void sendIcon();
   };
 }