X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/ad2bab318ec1271ae520606259c962382a519f0d..17796962c6e917a4f1e30110a87aba64dc14039a:/lib/base/filepush.cpp diff --git a/lib/base/filepush.cpp b/lib/base/filepush.cpp index b99896fc..92c580c2 100644 --- a/lib/base/filepush.cpp +++ b/lib/base/filepush.cpp @@ -1,4 +1,3 @@ -#include #include #include #include @@ -7,10 +6,13 @@ #define PVR_COMMIT 1 -eFilePushThread::eFilePushThread(): m_messagepump(eApp, 0) +eFilePushThread::eFilePushThread(int io_prio_class, int io_prio_level) + :prio_class(io_prio_class), prio(io_prio_level), m_messagepump(eApp, 0) { m_stop = 0; m_sg = 0; + m_send_pvr_commit = 0; + m_stream_mode = 0; flush(); enablePVRCommit(0); CONNECT(m_messagepump.recv_msg, eFilePushThread::recvEvent); @@ -22,15 +24,18 @@ static void signal_handler(int x) void eFilePushThread::thread() { - off_t dest_pos = 0; + setIoPrio(prio_class, prio); + + off_t dest_pos = 0, source_pos = 0; size_t bytes_read = 0; - off_t current_span_offset; + off_t current_span_offset = 0; size_t current_span_remaining = 0; + size_t written_since_last_sync = 0; + int already_empty = 0; eDebug("FILEPUSH THREAD START"); - // this is a race. FIXME. /* we set the signal to not restart syscalls, so we can detect our signal. */ struct sigaction act; @@ -38,7 +43,10 @@ void eFilePushThread::thread() act.sa_flags = 0; sigaction(SIGUSR1, &act, 0); - dest_pos = lseek(m_fd_dest, 0, SEEK_CUR); + hasStarted(); + + source_pos = m_raw_source.lseek(0, SEEK_CUR); + /* m_stop must be evaluated after each syscall. */ while (!m_stop) { @@ -46,20 +54,29 @@ void eFilePushThread::thread() if (m_buf_start != m_buf_end) { // TODO: take care of boundaries. + filterRecordData(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); // eDebug("wrote %d bytes", w); if (w <= 0) { - if (errno == -EINTR) + if (errno == EINTR) continue; - eDebug("eFilePushThread *write error* (%m) - not yet handled"); + break; // ... we would stop the thread } - /* this should flush all written pages to disk. */ - posix_fadvise(m_fd_dest, dest_pos, w, POSIX_FADV_DONTNEED); + written_since_last_sync += w; + + if (written_since_last_sync >= 512*1024) + { + 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; + } - dest_pos += w; // printf("FILEPUSH: wrote %d bytes\n", w); m_buf_start += w; continue; @@ -69,30 +86,36 @@ void eFilePushThread::thread() if (m_sg && !current_span_remaining) { - m_sg->getNextSourceSpan(bytes_read, current_span_offset, current_span_remaining); + m_sg->getNextSourceSpan(source_pos, bytes_read, current_span_offset, current_span_remaining); + + if (source_pos != current_span_offset) + source_pos = m_raw_source.lseek(current_span_offset, SEEK_SET); bytes_read = 0; } size_t maxread = sizeof(m_buffer); /* if we have a source span, don't read past the end */ - if (m_sg && maxread < current_span_remaining) + if (m_sg && maxread > current_span_remaining) maxread = current_span_remaining; m_buf_start = 0; m_buf_end = 0; if (maxread) - m_buf_end = read(m_fd_source, m_buffer, maxread); - - bytes_read += m_buf_end; + m_buf_end = m_raw_source.read(m_buffer, maxread); if (m_buf_end < 0) { m_buf_end = 0; if (errno == EINTR) continue; - eDebug("eFilePushThread *read error* - not yet handled"); + if (errno == EOVERFLOW) + { + eWarning("OVERFLOW while recording"); + continue; + } + eDebug("eFilePushThread *read error* (%m) - not yet handled"); } if (m_buf_end == 0) { @@ -101,16 +124,28 @@ void eFilePushThread::thread() { eDebug("sending PVR commit"); already_empty = 1; - if (::ioctl(m_fd_dest, PVR_COMMIT) == EINTR) + if (::ioctl(m_fd_dest, PVR_COMMIT) < 0 && errno == EINTR) continue; eDebug("commit done"); /* well check again */ 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); + + 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 (!lseek(m_fd_source, 0, SEEK_SET)) + if (!m_raw_source.lseek(0, SEEK_SET)) { eDebug("(looping)"); continue; @@ -118,26 +153,52 @@ void eFilePushThread::thread() #endif break; } else + { + source_pos += 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); } - + fdatasync(m_fd_dest); + eDebug("FILEPUSH THREAD STOP"); } void eFilePushThread::start(int fd_source, int fd_dest) { - m_fd_source = fd_source; + m_raw_source.setfd(fd_source); + m_fd_dest = fd_dest; + resume(); +} + +int eFilePushThread::start(const char *filename, int fd_dest) +{ + if (m_raw_source.open(filename) < 0) + return -1; m_fd_dest = fd_dest; resume(); + return 0; } void eFilePushThread::stop() { - if (!thread_running()) /* FIXME: races */ + /* if we aren't running, don't bother stopping. */ + if (!sync()) return; + m_stop = 1; - sendSignal(SIGUSR1); + + // 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 + while(!sendSignal(SIGUSR1)) + { + eDebug("send SIGUSR1 to thread context"); + usleep(5000); // wait msek + } kill(); } @@ -148,7 +209,7 @@ void eFilePushThread::pause() void eFilePushThread::seek(int whence, off_t where) { - ::lseek(m_fd_source, where, whence); + m_raw_source.lseek(where, whence); } void eFilePushThread::resume() @@ -167,6 +228,16 @@ void eFilePushThread::enablePVRCommit(int 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::sendEvent(int evt) { m_messagepump.send(evt); @@ -176,3 +247,9 @@ void eFilePushThread::recvEvent(const int &evt) { m_event(evt); } + +void eFilePushThread::filterRecordData(const unsigned char *data, int len) +{ + /* do nothing */ +} +