Merge commit 'origin/bug_202_networkconfig_cleanup' into experimental
[enigma2.git] / lib / base / filepush.cpp
index bbce531dd56f1a03e2d7fa669193f7a7938e81bb..91f24ba064026502d3b69316d89c2409bd133bec 100644 (file)
@@ -6,10 +6,16 @@
 
 #define PVR_COMMIT 1
 
 
 #define PVR_COMMIT 1
 
-eFilePushThread::eFilePushThread(): m_messagepump(eApp, 0)
+//FILE *f = fopen("/log.ts", "wb");
+
+eFilePushThread::eFilePushThread(int io_prio_class, int io_prio_level, int blocksize)
+       :prio_class(io_prio_class), prio(io_prio_level), m_messagepump(eApp, 0)
 {
        m_stop = 0;
        m_sg = 0;
 {
        m_stop = 0;
        m_sg = 0;
+       m_send_pvr_commit = 0;
+       m_stream_mode = 0;
+       m_blocksize = blocksize;
        flush();
        enablePVRCommit(0);
        CONNECT(m_messagepump.recv_msg, eFilePushThread::recvEvent);
        flush();
        enablePVRCommit(0);
        CONNECT(m_messagepump.recv_msg, eFilePushThread::recvEvent);
@@ -21,6 +27,8 @@ static void signal_handler(int x)
 
 void eFilePushThread::thread()
 {
 
 void eFilePushThread::thread()
 {
+       setIoPrio(prio_class, prio);
+
        off_t dest_pos = 0, source_pos = 0;
        size_t bytes_read = 0;
        
        off_t dest_pos = 0, source_pos = 0;
        size_t bytes_read = 0;
        
@@ -28,12 +36,17 @@ void eFilePushThread::thread()
        size_t current_span_remaining = 0;
        
        size_t written_since_last_sync = 0;
        size_t current_span_remaining = 0;
        
        size_t written_since_last_sync = 0;
-       
-       int already_empty = 0;
+
        eDebug("FILEPUSH THREAD START");
        eDebug("FILEPUSH THREAD START");
-               // this is a race. FIXME.
        
        
-       dest_pos = lseek(m_fd_dest, 0, SEEK_CUR);
+               /* we set the signal to not restart syscalls, so we can detect our signal. */
+       struct sigaction act;
+       act.sa_handler = signal_handler; // no, SIG_IGN doesn't do it. we want to receive the -EINTR
+       act.sa_flags = 0;
+       sigaction(SIGUSR1, &act, 0);
+       
+       hasStarted();
+       
        source_pos = m_raw_source.lseek(0, SEEK_CUR);
        
                /* m_stop must be evaluated after each syscall. */
        source_pos = m_raw_source.lseek(0, SEEK_CUR);
        
                /* m_stop must be evaluated after each syscall. */
@@ -42,27 +55,77 @@ void eFilePushThread::thread()
                        /* first try flushing the bufptr */
                if (m_buf_start != m_buf_end)
                {
                        /* first try flushing the bufptr */
                if (m_buf_start != m_buf_end)
                {
-                               // TODO: take care of boundaries.
-                       filterRecordData(m_buffer + m_buf_start, m_buf_end - m_buf_start);
+                               /* filterRecordData wants to work on multiples of blocksize.
+                                  if it returns a negative result, it means that this many bytes should be skipped
+                                  *in front* of the buffer. Then, it will be called again. with the newer, shorter buffer.
+                                  if filterRecordData wants to skip more data then currently available, it must do that internally.
+                                  Skipped bytes will also not be output.
+
+                                  if it returns a positive result, that means that only these many bytes should be used
+                                  in the buffer. 
+                                  
+                                  In either case, current_span_remaining is given as a reference and can be modified. (Of course it 
+                                  doesn't make sense to decrement it to a non-zero value unless you return 0 because that would just
+                                  skip some data). This is probably a very special application for fast-forward, where the current
+                                  span is to be cancelled after a complete iframe has been output.
+
+                                  we always call filterRecordData with our full buffer (otherwise we couldn't easily strip from the end)
+                                  
+                                  we filter data only once, of course, but it might not get immediately written.
+                                  that's what m_filter_end is for - it points to the start of the unfiltered data.
+                               */
+                       
+                       int filter_res;
+                       
+                       do
+                       {
+                               filter_res = filterRecordData(m_buffer + m_filter_end, m_buf_end - m_filter_end, current_span_remaining);
+
+                               if (filter_res < 0)
+                               {
+                                       eDebug("[eFilePushThread] filterRecordData re-syncs and skips %d bytes", -filter_res);
+                                       m_buf_start = m_filter_end + -filter_res;  /* this will also drop unwritten data */
+                                       ASSERT(m_buf_start <= m_buf_end); /* otherwise filterRecordData skipped more data than available. */
+                                       continue; /* try again */
+                               }
+                               
+                                       /* adjust end of buffer to strip dropped tail bytes */
+                               m_buf_end = m_filter_end + filter_res;
+                                       /* mark data as filtered. */
+                               m_filter_end = m_buf_end;
+                       } while (0);
+                       
+                       ASSERT(m_filter_end == m_buf_end);
+                       
+                       if (m_buf_start == m_buf_end)
+                               continue;
+
+                               /* now write out data. it will be 'aligned' (according to filterRecordData). 
+                                  absolutely forbidden is to return EINTR and consume a non-aligned number of bytes. 
+                               */
                        int w = write(m_fd_dest, m_buffer + m_buf_start, m_buf_end - m_buf_start);
                        int w = write(m_fd_dest, m_buffer + m_buf_start, m_buf_end - m_buf_start);
+//                     fwrite(m_buffer + m_buf_start, 1, m_buf_end - m_buf_start, f);
 //                     eDebug("wrote %d bytes", w);
                        if (w <= 0)
                        {
 //                     eDebug("wrote %d bytes", w);
                        if (w <= 0)
                        {
-                               if (errno == EINTR)
+                               if (errno == EINTR || errno == EAGAIN || errno == EBUSY)
                                        continue;
                                        continue;
+                               eDebug("eFilePushThread WRITE ERROR");
+                               sendEvent(evtWriteError);
                                break;
                                // ... we would stop the thread
                        }
 
                                break;
                                // ... we would stop the thread
                        }
 
-//                     posix_fadvise(m_fd_dest, dest_pos, w, POSIX_FADV_DONTNEED);
-
-                       dest_pos += w;
                        written_since_last_sync += w;
                        written_since_last_sync += w;
-                       
-                       if (written_since_last_sync >= 2048*1024)
+
+                       if (written_since_last_sync >= 512*1024)
                        {
                        {
-                               fdatasync(m_fd_dest);
-                               written_since_last_sync = 0;
+                               int toflush = written_since_last_sync > 2*1024*1024 ?
+                                       2*1024*1024 : written_since_last_sync &~ 4095; // write max 2MB at once
+                               dest_pos = lseek(m_fd_dest, 0, SEEK_CUR);
+                               dest_pos -= toflush;
+                               posix_fadvise(m_fd_dest, dest_pos, toflush, POSIX_FADV_DONTNEED);
+                               written_since_last_sync -= toflush;
                        }
 
 //                     printf("FILEPUSH: wrote %d bytes\n", w);
                        }
 
 //                     printf("FILEPUSH: wrote %d bytes\n", w);
@@ -75,6 +138,7 @@ void eFilePushThread::thread()
                if (m_sg && !current_span_remaining)
                {
                        m_sg->getNextSourceSpan(source_pos, bytes_read, current_span_offset, current_span_remaining);
                if (m_sg && !current_span_remaining)
                {
                        m_sg->getNextSourceSpan(source_pos, 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);
 
                        if (source_pos != current_span_offset)
                                source_pos = m_raw_source.lseek(current_span_offset, SEEK_SET);
@@ -87,7 +151,11 @@ void eFilePushThread::thread()
                if (m_sg && maxread > current_span_remaining)
                        maxread = current_span_remaining;
 
                if (m_sg && maxread > current_span_remaining)
                        maxread = current_span_remaining;
 
+                       /* align to blocksize */
+               maxread -= maxread % m_blocksize;
+
                m_buf_start = 0;
                m_buf_start = 0;
+               m_filter_end = 0;
                m_buf_end = 0;
                
                if (maxread)
                m_buf_end = 0;
                
                if (maxread)
@@ -96,7 +164,7 @@ void eFilePushThread::thread()
                if (m_buf_end < 0)
                {
                        m_buf_end = 0;
                if (m_buf_end < 0)
                {
                        m_buf_end = 0;
-                       if (errno == EINTR)
+                       if (errno == EINTR || errno == EBUSY || errno == EAGAIN)
                                continue;
                        if (errno == EOVERFLOW)
                        {
                                continue;
                        if (errno == EOVERFLOW)
                        {
@@ -105,20 +173,49 @@ void eFilePushThread::thread()
                        }
                        eDebug("eFilePushThread *read error* (%m) - not yet handled");
                }
                        }
                        eDebug("eFilePushThread *read error* (%m) - not yet handled");
                }
+
+                       /* 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_buf_end == 0)
                {
                                /* on EOF, try COMMITting once. */
-                       if (m_send_pvr_commit && !already_empty)
+                       if (m_send_pvr_commit)
                        {
                        {
-                               eDebug("sending PVR commit");
-                               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 
+                                  over and over until somebody responds.
+                                  
+                                  in stream_mode, think of evtEOF as "buffer underrun occured". */
                        sendEvent(evtEOF);
                        sendEvent(evtEOF);
+
+                       if (m_stream_mode)
+                       {
+                               eDebug("reached EOF, but we are in stream mode. delaying 1 second.");
+                               sleep(1);
+                               continue;
+                       }
 #if 0
                        eDebug("FILEPUSH: end-of-file! (currently unhandled)");
                        if (!m_raw_source.lseek(0, SEEK_SET))
 #if 0
                        eDebug("FILEPUSH: end-of-file! (currently unhandled)");
                        if (!m_raw_source.lseek(0, SEEK_SET))
@@ -134,11 +231,11 @@ void eFilePushThread::thread()
                        bytes_read += m_buf_end;
                        if (m_sg)
                                current_span_remaining -= 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);
        }
                }
 //             printf("FILEPUSH: read %d bytes\n", m_buf_end);
        }
-       
+       fdatasync(m_fd_dest);
+
        eDebug("FILEPUSH THREAD STOP");
 }
 
        eDebug("FILEPUSH THREAD STOP");
 }
 
@@ -158,28 +255,17 @@ int eFilePushThread::start(const char *filename, int fd_dest)
        return 0;
 }
 
        return 0;
 }
 
-void eFilePushThread::installSigUSR1Handler()
-{
-               /* we set the signal to not restart syscalls, so we can detect our signal. */
-       struct sigaction act;
-       act.sa_handler = signal_handler; // no, SIG_IGN doesn't do it. we want to receive the -EINTR
-       act.sa_flags = 0;
-       sigaction(SIGUSR1, &act, 0);
-}
-
-// called from thread before alive is set to 1
-void eFilePushThread::before_set_thread_alive()
-{
-       installSigUSR1Handler();
-}
-
 void eFilePushThread::stop()
 {
 void eFilePushThread::stop()
 {
-       if (!thread_running()) /* FIXME: races */
+               /* if we aren't running, don't bother stopping. */
+       if (!sync())
                return;
                return;
+
        m_stop = 1;
        m_stop = 1;
+
+       eDebug("stopping thread."); /* just do it ONCE. it won't help to do this more than once. */
        sendSignal(SIGUSR1);
        sendSignal(SIGUSR1);
-       kill();
+       kill(0);
 }
 
 void eFilePushThread::pause()
 }
 
 void eFilePushThread::pause()
@@ -200,7 +286,7 @@ void eFilePushThread::resume()
 
 void eFilePushThread::flush()
 {
 
 void eFilePushThread::flush()
 {
-       m_buf_start = m_buf_end = 0;
+       m_buf_start = m_buf_end = m_filter_end = 0;
 }
 
 void eFilePushThread::enablePVRCommit(int s)
 }
 
 void eFilePushThread::enablePVRCommit(int s)
@@ -208,6 +294,11 @@ void eFilePushThread::enablePVRCommit(int s)
        m_send_pvr_commit = s;
 }
 
        m_send_pvr_commit = s;
 }
 
+void eFilePushThread::setStreamMode(int s)
+{
+       m_stream_mode = s;
+}
+
 void eFilePushThread::setScatterGather(iFilePushScatterGather *sg)
 {
        m_sg = sg;
 void eFilePushThread::setScatterGather(iFilePushScatterGather *sg)
 {
        m_sg = sg;
@@ -223,8 +314,7 @@ void eFilePushThread::recvEvent(const int &evt)
        m_event(evt);
 }
 
        m_event(evt);
 }
 
-void eFilePushThread::filterRecordData(const unsigned char *data, int len)
+int eFilePushThread::filterRecordData(const unsigned char *data, int len, size_t &current_span_remaining)
 {
 {
-       /* do nothing */
+       return len;
 }
 }
-