Fix seek bug on file-transcoding.

diff --git a/src/Logger.cpp b/src/Logger.cpp
index 963a783..dc05d3a 100644 (file)
--- a/src/Logger.cpp
+++ b/src/Logger.cpp
@@ -111,7 +111,7 @@ bool Logger::init(const char* aName, int aLogLevel, bool aWithTimestamp)
        else sprintf(path, "%s.log", aName);
        if (!(mLogHandle = fopen(path, "a+"))) {
                mLogHandle = 0;
-               printf("fail to open logger [%s].", path);
+//             printf("fail to open logger [%s].", path);
                return false;
        }
 

diff --git a/src/Mpeg.cpp b/src/Mpeg.cpp
index 2426dff..a1e74b4 100644 (file)
--- a/src/Mpeg.cpp
+++ b/src/Mpeg.cpp
@@ -13,6 +13,7 @@
 
 void Mpeg::seek(HttpHeader &header)
 {
+#ifdef USE_EXTERNAL_SEEK_TIME
        try {
                std::string position = header.page_params["position"];
                std::string relative = header.page_params["relative"];
@@ -42,6 +43,7 @@ void Mpeg::seek(HttpHeader &header)
                        else {
                                position_offset = Util::strtollu(position);
                        }
+
                        if (is_time_seekable && position_offset > 0) {
                                DEBUG("seek to position_offset %ds", position_offset);
                                seek_time((position_offset * 1000) + first_pcr_ms);
@@ -52,6 +54,46 @@ void Mpeg::seek(HttpHeader &header)
        catch (const trap &e) {
                WARNING("Exception : %s", e.what());
        }
+#else
+       try {
+               off_t byte_offset = 0;
+               std::string position = header.page_params["position"];
+               std::string relative = header.page_params["relative"];
+               if (position.empty() && relative.empty()) {
+                       std::string range = header.params["Range"];
+                       DEBUG("Range : %s", range.c_str());
+                       if((range.length() > 7) && (range.substr(0, 6) == "bytes=")) {
+                               range = range.substr(6);
+                               if(range.find('-') == (range.length() - 1)) {
+                                       byte_offset = Util::strtollu(range);
+                                       DEBUG("Range To : %s -> %llu", range.c_str(), byte_offset);
+                               }
+                       }
+               }
+               else {
+                       off_t position_offset;
+                       if (!relative.empty()) {
+                               int dur = duration();
+                               DEBUG("duration : %d", dur);
+                               position_offset = (dur * Util::strtollu(relative)) / 100;
+                       }
+                       else {
+                               position_offset = Util::strtollu(position);
+                       }
+                       position_offset *= 90000;
+                       get_offset(byte_offset, position_offset, -1);
+               }
+
+               DEBUG("seek to byte_offset %llu", byte_offset);
+               if (byte_offset > 0) {
+                       seek_absolute(byte_offset);
+                       DEBUG("seek ok");
+               }
+       }
+       catch (...) {
+               WARNING("seek fail.");
+       }
+#endif
 }
 //----------------------------------------------------------------------
 
@@ -103,12 +145,14 @@ int Mpeg::switch_offset(off_t off)
                int filenr = off / m_splitsize;
                if (filenr >= m_nrfiles)
                        filenr = m_nrfiles - 1;
-//             if (filenr != m_current_file) {
-//                     close();
-//                     m_fd = open(filenr);
-//                     m_last_offset = m_base_offset = m_splitsize * filenr;
-//                     m_current_file = filenr;
-//             }
+#if 0
+               if (filenr != m_current_file) {
+                       close();
+                       m_fd = open(filenr);
+                       m_last_offset = m_base_offset = m_splitsize * filenr;
+                       m_current_file = filenr;
+               }
+#endif
        }
        else m_base_offset = 0;
 
@@ -172,8 +216,6 @@ void Mpeg::calc_end()
 int Mpeg::fix_pts(const off_t &offset, pts_t &now)
 {
        /* for the simple case, we assume one epoch, with up to one wrap around in the middle. */
-       printf("%s : %d\n", __FUNCTION__, __LINE__);
-
        calc_begin();
        if (!m_begin_valid) {
                return -1;
@@ -193,6 +235,175 @@ int Mpeg::fix_pts(const off_t &offset, pts_t &now)
 }
 //----------------------------------------------------------------------
 
+void Mpeg::take_samples()
+{
+       m_samples_taken = 1;
+       m_samples.clear();
+       int retries=2;
+       pts_t dummy = duration();
+
+       if (dummy <= 0)
+               return;
+
+       int nr_samples = 30;
+       off_t bytes_per_sample = (m_offset_end - m_offset_begin) / (long long)nr_samples;
+       if (bytes_per_sample < 40*1024*1024)
+               bytes_per_sample = 40*1024*1024;
+
+       bytes_per_sample -= bytes_per_sample % 188;
+
+       DEBUG("samples step %lld, pts begin %llx, pts end %llx, offs begin %lld, offs end %lld:",
+                       bytes_per_sample, m_pts_begin, m_pts_end, m_offset_begin, m_offset_end);
+
+       for (off_t offset = m_offset_begin; offset < m_offset_end;) {
+               pts_t p;
+               if (take_sample(offset, p) && retries--)
+                       continue;
+               retries = 2;
+               offset += bytes_per_sample;
+       }
+       m_samples[0] = m_offset_begin;
+       m_samples[m_pts_end - m_pts_begin] = m_offset_end;
+}
+//----------------------------------------------------------------------
+
+/* returns 0 when a sample was taken. */
+int Mpeg::take_sample(off_t off, pts_t &p)
+{
+       off_t offset_org = off;
+
+       if (!get_pts(off, p, 1)) {
+               /* as we are happily mixing PTS and PCR values (no comment, please), we might
+                  end up with some "negative" segments.
+                  so check if this new sample is between the previous and the next field*/
+               std::map<pts_t, off_t>::const_iterator l = m_samples.lower_bound(p);
+               std::map<pts_t, off_t>::const_iterator u = l;
+
+               if (l != m_samples.begin()) {
+                       --l;
+                       if (u != m_samples.end()) {
+                               if ((l->second > off) || (u->second < off)) {
+                                       DEBUG("ignoring sample %lld %lld %lld (%llx %llx %llx)", l->second, off, u->second, l->first, p, u->first);
+                                       return 1;
+                               }
+                       }
+               }
+
+               DEBUG("adding sample %lld: pts 0x%llx -> pos %lld (diff %lld bytes)", offset_org, p, off, off-offset_org);
+               m_samples[p] = off;
+               return 0;
+       }
+       return -1;
+}
+//----------------------------------------------------------------------
+
+int Mpeg::calc_bitrate()
+{
+       calc_begin(); calc_end();
+       if (!(m_begin_valid && m_end_valid))
+               return -1;
+
+       pts_t len_in_pts = m_pts_end - m_pts_begin;
+
+       /* wrap around? */
+       if (len_in_pts < 0)
+               len_in_pts += 0x200000000LL;
+       off_t len_in_bytes = m_offset_end - m_offset_begin;
+
+       if (!len_in_pts)
+               return -1;
+
+       unsigned long long bitrate = len_in_bytes * 90000 * 8 / len_in_pts;
+       if ((bitrate < 10000) || (bitrate > 100000000))
+               return -1;
+
+       return bitrate;
+}
+//----------------------------------------------------------------------
+
+int Mpeg::get_offset(off_t &offset, pts_t &pts, int marg)
+{
+       calc_begin(); calc_end();
+
+       if (!m_begin_valid)
+               return -1;
+       if (!m_end_valid)
+               return -1;
+
+       if (!m_samples_taken)
+               take_samples();
+
+       if (!m_samples.empty()) {
+               int maxtries = 5;
+               pts_t p = -1;
+
+               while (maxtries--) {
+                       /* search entry before and after */
+                       std::map<pts_t, off_t>::const_iterator l = m_samples.lower_bound(pts);
+                       std::map<pts_t, off_t>::const_iterator u = l;
+
+                       if (l != m_samples.begin())
+                               --l;
+
+                       /* we could have seeked beyond the end */
+                       if (u == m_samples.end()) {
+                               /* use last segment for interpolation. */
+                               if (l != m_samples.begin()) {
+                                       --u;
+                                       --l;
+                               }
+                       }
+
+                       /* if we don't have enough points */
+                       if (u == m_samples.end())
+                               break;
+
+                       pts_t pts_diff = u->first - l->first;
+                       off_t offset_diff = u->second - l->second;
+
+                       if (offset_diff < 0) {
+                               DEBUG("something went wrong when taking samples.");
+                               m_samples.clear();
+                               take_samples();
+                               continue;
+                       }
+                       DEBUG("using: %llx:%llx -> %llx:%llx", l->first, u->first, l->second, u->second);
+
+                       int bitrate = (pts_diff) ? (offset_diff * 90000 * 8 / pts_diff) : 0;
+                       offset = l->second;
+                       offset += ((pts - l->first) * (pts_t)bitrate) / 8ULL / 90000ULL;
+                       offset -= offset % 188;
+                       p = pts;
+
+                       if (!take_sample(offset, p)) {
+                               int diff = (p - pts) / 90;
+                               DEBUG("calculated diff %d ms", diff);
+
+                               if (::abs(diff) > 300) {
+                                       DEBUG("diff to big, refining");
+                                       continue;
+                               }
+                       }
+                       else DEBUG("no sample taken, refinement not possible.");
+                       break;
+               }
+
+               if (p != -1) {
+                       pts = p;
+                       DEBUG("aborting. Taking %llx as offset for %lld", offset, pts);
+                       return 0;
+               }
+       }
+
+       int bitrate = calc_bitrate();
+       offset = pts * (pts_t)bitrate / 8ULL / 90000ULL;
+       DEBUG("fallback, bitrate=%d, results in %016llx", bitrate, offset);
+       offset -= offset % 188;
+
+       return 0;
+}
+//----------------------------------------------------------------------
+
 int Mpeg::get_pts(off_t &offset, pts_t &pts, int fixed)
 {
        int left = 256*1024;

diff --git a/src/Mpeg.h b/src/Mpeg.h
index 5877f85..4bda815 100644 (file)
--- a/src/Mpeg.h
+++ b/src/Mpeg.h
@@ -29,6 +29,9 @@ private:
 
        int m_begin_valid, m_end_valid, m_futile;
 
+       std::map<pts_t, off_t> m_samples;
+       int m_samples_taken;
+
        void scan();
        int switch_offset(off_t off);
 
@@ -42,6 +45,11 @@ private:
        off_t lseek(off_t offset, int whence);
        ssize_t read(off_t offset, void *buf, size_t count);
 
+       int get_offset(off_t &offset, pts_t &pts, int marg);
+       int take_sample(off_t off, pts_t &p);
+       void take_samples();
+
+       int calc_bitrate();
 public:
        Mpeg(std::string file, bool request_time_seek) throw (trap)
                : MpegTS(file, request_time_seek)
@@ -51,6 +59,8 @@ public:
 
                m_pts_begin = m_pts_end = m_offset_begin = m_offset_end = 0;
                m_last_filelength = m_begin_valid = m_end_valid = m_futile =0;
+
+               m_samples_taken = 0;
        }
 
        virtual ~Mpeg() throw () {}

diff --git a/src/main.cpp b/src/main.cpp
index 3749d06..b8474e0 100644 (file)
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -40,6 +40,8 @@ int streaming_write(const char *buffer, size_t buffer_len, bool enable_log = fal
 //----------------------------------------------------------------------
 
 static bool is_terminated = true;
+static int source_thread_id, stream_thread_id;
+static pthread_t source_thread_handle, stream_thread_handle;
 //----------------------------------------------------------------------
 
 int main(int argc, char **argv)
@@ -54,10 +56,6 @@ int main(int argc, char **argv)
        signal(SIGINT, signal_handler);
 
        HttpHeader header;
-
-       int source_thread_id, stream_thread_id;
-       pthread_t source_thread_handle, stream_thread_handle;
-
        std::string req = HttpHeader::read_request();
 
        DEBUG("request head :\n%s", req.c_str());
@@ -85,7 +83,7 @@ int main(int argc, char **argv)
                case HttpHeader::TRANSCODING_FILE:
                        try {
                                std::string uri = UriDecoder().decode(header.page_params["file"].c_str());
-                               Mpeg *ts = new Mpeg(uri, true);
+                               Mpeg *ts = new Mpeg(uri, false);
                                pmt_pid   = ts->pmt_pid;
                                video_pid = ts->video_pid;
                                audio_pid = ts->audio_pid;