servicemp3.cpp: more simple/flexible streaming detection

[enigma2.git] / lib / base / filepush.cpp

diff --git a/lib/base/filepush.cpp b/lib/base/filepush.cpp
index b81aec5c8929133a325173f9f01c0161104ac0bd..e3e2a13ad8e060a83678afbcfc9be841af0903da 100644 (file)
--- a/lib/base/filepush.cpp
+++ b/lib/base/filepush.cpp
@@ -29,7 +29,7 @@ void eFilePushThread::thread()
 {
        setIoPrio(prio_class, prio);
 
-       off_t dest_pos = 0, source_pos = 0;
+       off_t dest_pos = 0;
        size_t bytes_read = 0;
        
        off_t current_span_offset = 0;
@@ -37,7 +37,6 @@ void eFilePushThread::thread()
        
        size_t written_since_last_sync = 0;
 
-       int already_empty = 0;
        eDebug("FILEPUSH THREAD START");
        
                /* we set the signal to not restart syscalls, so we can detect our signal. */
@@ -47,9 +46,7 @@ void eFilePushThread::thread()
        sigaction(SIGUSR1, &act, 0);
        
        hasStarted();
-       
-       source_pos = m_raw_source.lseek(0, SEEK_CUR);
-       
+
                /* m_stop must be evaluated after each syscall. */
        while (!m_stop)
        {
@@ -138,14 +135,12 @@ void eFilePushThread::thread()
                        
                if (m_sg && !current_span_remaining)
                {
-                       m_sg->getNextSourceSpan(source_pos, bytes_read, current_span_offset, current_span_remaining);
+                       m_sg->getNextSourceSpan(m_current_position, bytes_read, current_span_offset, current_span_remaining);
                        ASSERT(!(current_span_remaining % m_blocksize));
-
-                       if (source_pos != current_span_offset)
-                               source_pos = m_raw_source.lseek(current_span_offset, SEEK_SET);
+                       m_current_position = current_span_offset;
                        bytes_read = 0;
                }
-               
+
                size_t maxread = sizeof(m_buffer);
                
                        /* if we have a source span, don't read past the end */
@@ -158,9 +153,9 @@ void eFilePushThread::thread()
                m_buf_start = 0;
                m_filter_end = 0;
                m_buf_end = 0;
-               
+
                if (maxread)
-                       m_buf_end = m_raw_source.read(m_buffer, maxread);
+                       m_buf_end = m_source->read(m_current_position, m_buffer, maxread);
 
                if (m_buf_end < 0)
                {
@@ -178,27 +173,28 @@ void eFilePushThread::thread()
                        /* a read might be mis-aligned in case of a short read. */
                int d = m_buf_end % m_blocksize;
                if (d)
-               {
-                       m_raw_source.lseek(-d, SEEK_CUR);
                        m_buf_end -= d;
-               }
 
                if (m_buf_end == 0)
                {
                                /* on EOF, try COMMITting once. */
-                       if (m_send_pvr_commit && !already_empty)
+                       if (m_send_pvr_commit)
                        {
-                               eDebug("sending PVR commit");
-                               
-                               struct pollfd pfd[1] = {m_fd_dest, POLLHUP};
-                               poll(pfd, 1, 10000);
-                               sleep(5); /* HACK to allow ES buffer to drain */
-                               already_empty = 1;
-//                             if (::ioctl(m_fd_dest, PVR_COMMIT) < 0 && errno == EINTR)
-//                                     continue;
-                               eDebug("commit done");
-                                               /* well check again */
-                               continue;
+                               struct pollfd pfd;
+                               pfd.fd = m_fd_dest;
+                               pfd.events = POLLIN;
+                               switch (poll(&pfd, 1, 250)) // wait for 250ms
+                               {
+                                       case 0:
+                                               eDebug("wait for driver eof timeout");
+                                               continue;
+                                       case 1:
+                                               eDebug("wait for driver eof ok");
+                                               break;
+                                       default:
+                                               eDebug("wait for driver eof aborted by signal");
+                                               continue;
+                               }
                        }
                        
                                /* in stream_mode, we are sending EOF events 
@@ -213,22 +209,13 @@ void eFilePushThread::thread()
                                sleep(1);
                                continue;
                        }
-#if 0
-                       eDebug("FILEPUSH: end-of-file! (currently unhandled)");
-                       if (!m_raw_source.lseek(0, SEEK_SET))
-                       {
-                               eDebug("(looping)");
-                               continue;
-                       }
-#endif
                        break;
                } else
                {
-                       source_pos += m_buf_end;
+                       m_current_position += m_buf_end;
                        bytes_read += m_buf_end;
                        if (m_sg)
                                current_span_remaining -= m_buf_end;
-                       already_empty = 0;
                }
 //             printf("FILEPUSH: read %d bytes\n", m_buf_end);
        }
@@ -237,20 +224,30 @@ void eFilePushThread::thread()
        eDebug("FILEPUSH THREAD STOP");
 }
 
-void eFilePushThread::start(int fd_source, int fd_dest)
+void eFilePushThread::start(int fd, int fd_dest)
 {
-       m_raw_source.setfd(fd_source);
-       m_fd_dest = fd_dest;
-       resume();
+       eRawFile *f = new eRawFile();
+       ePtr<iTsSource> source = f;
+       f->setfd(fd);
+       start(source, fd_dest);
 }
 
-int eFilePushThread::start(const char *filename, int fd_dest)
+int eFilePushThread::start(const char *file, int fd_dest)
 {
-       if (m_raw_source.open(filename) < 0)
+       eRawFile *f = new eRawFile();
+       ePtr<iTsSource> source = f;
+       if (f->open(file) < 0)
                return -1;
+       start(source, fd_dest);
+       return 0;
+}
+
+void eFilePushThread::start(ePtr<iTsSource> &source, int fd_dest)
+{
+       m_source = source;
        m_fd_dest = fd_dest;
+       m_current_position = 0;
        resume();
-       return 0;
 }
 
 void eFilePushThread::stop()
@@ -261,10 +258,7 @@ void eFilePushThread::stop()
 
        m_stop = 1;
 
-       // fixmee.. here we need a better solution to ensure
-       // that the thread context take notice of the signal
-       // even when no syscall is in progress
-       eDebug("if enigma hangs here, the filepush thread is non-responsive. FIX THAT DAMN THREAD.");
+       eDebug("stopping thread."); /* just do it ONCE. it won't help to do this more than once. */
        sendSignal(SIGUSR1);
        kill(0);
 }
@@ -274,11 +268,6 @@ void eFilePushThread::pause()
        stop();
 }
 
-void eFilePushThread::seek(int whence, off_t where)
-{
-       m_raw_source.lseek(where, whence);
-}
-
 void eFilePushThread::resume()
 {
        m_stop = 0;