X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/fa458113395a4b8da3954b656dbe6c55b30f224a..b3c4891fe653d87333ada5cb14c0bf102ac7b27a:/lib/base/filepush.cpp diff --git a/lib/base/filepush.cpp b/lib/base/filepush.cpp index 76e01ea0..e3e2a13a 100644 --- a/lib/base/filepush.cpp +++ b/lib/base/filepush.cpp @@ -6,13 +6,16 @@ #define PVR_COMMIT 1 -eFilePushThread::eFilePushThread(int io_prio_class, int io_prio_level) +//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_send_pvr_commit = 0; m_stream_mode = 0; + m_blocksize = blocksize; flush(); enablePVRCommit(0); CONNECT(m_messagepump.recv_msg, eFilePushThread::recvEvent); @@ -26,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; @@ -34,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. */ @@ -44,22 +46,67 @@ 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) { /* 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); +// fwrite(m_buffer + m_buf_start, 1, m_buf_end - m_buf_start, f); // eDebug("wrote %d bytes", w); if (w <= 0) { - if (errno == EINTR) + if (errno == EINTR || errno == EAGAIN || errno == EBUSY) continue; eDebug("eFilePushThread WRITE ERROR"); sendEvent(evtWriteError); @@ -88,29 +135,32 @@ void eFilePushThread::thread() if (m_sg && !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); + m_sg->getNextSourceSpan(m_current_position, bytes_read, current_span_offset, current_span_remaining); + ASSERT(!(current_span_remaining % m_blocksize)); + 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 */ if (m_sg && maxread > current_span_remaining) maxread = current_span_remaining; + /* align to blocksize */ + maxread -= maxread % m_blocksize; + 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) { m_buf_end = 0; - if (errno == EINTR) + if (errno == EINTR || errno == EBUSY || errno == EAGAIN) continue; if (errno == EOVERFLOW) { @@ -119,18 +169,32 @@ void eFilePushThread::thread() } 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_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"); - 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 @@ -145,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); } @@ -169,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 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 source = f; + if (f->open(file) < 0) return -1; + start(source, fd_dest); + return 0; +} + +void eFilePushThread::start(ePtr &source, int fd_dest) +{ + m_source = source; m_fd_dest = fd_dest; + m_current_position = 0; resume(); - return 0; } void eFilePushThread::stop() @@ -193,15 +258,9 @@ 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 - while(!sendSignal(SIGUSR1)) - { - eDebug("send SIGUSR1 to thread context"); - usleep(5000); // wait msek - } - kill(); + eDebug("stopping thread."); /* just do it ONCE. it won't help to do this more than once. */ + sendSignal(SIGUSR1); + kill(0); } void eFilePushThread::pause() @@ -209,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; @@ -222,7 +276,7 @@ void eFilePushThread::resume() 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) @@ -250,8 +304,7 @@ void eFilePushThread::recvEvent(const int &evt) m_event(evt); } -void eFilePushThread::filterRecordData(const unsigned char *data, int len) +int eFilePushThread::filterRecordData(const unsigned char *data, int len, size_t ¤t_span_remaining) { - /* do nothing */ + return len; } -