void eFilePushThread::thread() { ignore_but_report_signals(); hasStarted(); /* "start()" blocks until we get here */ setIoPrio(prio_class, prio); eDebug("FILEPUSH THREAD START"); do { int eofcount = 0; int buf_end = 0; size_t bytes_read = 0; off_t current_span_offset = 0; size_t current_span_remaining = 0; #if defined(__sh__) // opens video device for the reverse playback workaround // Changes in this file are cause e2 doesnt tell the player to play reverse int fd_video = open("/dev/dvb/adapter0/video0", O_RDONLY); // Fix to ensure that event evtEOF is called at end of playbackl part 1/3 bool already_empty = false; #endif while (!m_stop) { if (m_sg && !current_span_remaining) { #if defined (__sh__) // tells the player to play in reverse #define VIDEO_DISCONTINUITY _IO('o', 84) #define DVB_DISCONTINUITY_SKIP 0x01 #define DVB_DISCONTINUITY_CONTINUOUS_REVERSE 0x02 if ((m_sg->getSkipMode() != 0)) { // inform the player about the jump in the stream data // this only works if the video device allows the discontinuity ioctl in read-only mode (patched) int param = DVB_DISCONTINUITY_SKIP; // | DVB_DISCONTINUITY_CONTINUOUS_REVERSE; int rc = ioctl(fd_video, VIDEO_DISCONTINUITY, (void*)param); } #endif 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 = m_buffersize; /* 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; if (maxread) { #ifdef SHOW_WRITE_TIME struct timeval starttime; struct timeval now; gettimeofday(&starttime, NULL); #endif buf_end = m_source->read(m_current_position, m_buffer, maxread); #ifdef SHOW_WRITE_TIME gettimeofday(&now, NULL); suseconds_t diff = (1000000 * (now.tv_sec - starttime.tv_sec)) + now.tv_usec - starttime.tv_usec; eDebug("[eFilePushThread] read %d bytes time: %9u us", buf_end, (unsigned int)diff); #endif } else buf_end = 0; if (buf_end < 0) { buf_end = 0; /* Check m_stop after interrupted syscall. */ if (m_stop) { break; } if (errno == EINTR || errno == EBUSY || errno == EAGAIN) continue; if (errno == EOVERFLOW) { eWarning("OVERFLOW while playback?"); continue; } eDebug("eFilePushThread *read error* (%m) - not yet handled"); } /* a read might be mis-aligned in case of a short read. */ int d = buf_end % m_blocksize; if (d) buf_end -= d; if (buf_end == 0) { /* on EOF, try COMMITting once. */ if (m_send_pvr_commit) { 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"); #if defined(__sh__) // Fix to ensure that event evtEOF is called at end of playbackl part 2/3 if (already_empty) { break; } else { already_empty = true; continue; } #else continue; #endif case 1: eDebug("wait for driver eof ok"); break; default: eDebug("wait for driver eof aborted by signal"); /* Check m_stop after interrupted syscall. */ if (m_stop) break; continue; } } if (m_stop) break; /* in stream_mode, we are sending EOF events over and over until somebody responds. in stream_mode, think of evtEOF as "buffer underrun occurred". */ sendEvent(evtEOF); if (m_stream_mode) { eDebug("reached EOF, but we are in stream mode. delaying 1 second."); sleep(1); continue; } else if (++eofcount < 10) { eDebug("reached EOF, but the file may grow. delaying 1 second."); sleep(1); continue; } break; } else { /* Write data to mux */ int buf_start = 0; filterRecordData(m_buffer, buf_end); while ((buf_start != buf_end) && !m_stop) { int w = write(m_fd_dest, m_buffer + buf_start, buf_end - buf_start); if (w <= 0) { /* Check m_stop after interrupted syscall. */ if (m_stop) { w = 0; buf_start = 0; buf_end = 0; break; } if (w < 0 && (errno == EINTR || errno == EAGAIN || errno == EBUSY)) { #if HAVE_CPULOADFIX sleep(2); #endif continue; } eDebug("eFilePushThread WRITE ERROR"); sendEvent(evtWriteError); break; } buf_start += w; } eofcount = 0; #if defined(__sh__) // Fix to ensure that event evtEOF is called at end of playbackl part 3/3 already_empty = false; #endif m_current_position += buf_end; bytes_read += buf_end; if (m_sg) current_span_remaining -= buf_end; } } #if defined(__sh__) // closes video device for the reverse playback workaround close(fd_video); #endif sendEvent(evtStopped); { /* mutex lock scope */ eSingleLocker lock(m_run_mutex); m_run_state = 0; m_run_cond.signal(); /* Tell them we're here */ while (m_stop == 2) { eDebug("FILEPUSH THREAD PAUSED"); m_run_cond.wait(m_run_mutex); } if (m_stop == 0) m_run_state = 1; } } while (m_stop == 0); eDebug("FILEPUSH THREAD STOP"); }
void eFilePushThread::thread() { int eofcount = 0; setIoPrio(prio_class, prio); int buf_end = 0; size_t bytes_read = 0; off_t current_span_offset = 0; size_t current_span_remaining = 0; eDebug("FILEPUSH THREAD START"); /* 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(); while (!m_stop) { if (m_sg && !current_span_remaining) { 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 = m_buffersize; /* 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; if (maxread) { #ifdef SHOW_WRITE_TIME struct timeval starttime; struct timeval now; gettimeofday(&starttime, NULL); #endif buf_end = m_source->read(m_current_position, m_buffer, maxread); #ifdef SHOW_WRITE_TIME gettimeofday(&now, NULL); suseconds_t diff = (1000000 * (now.tv_sec - starttime.tv_sec)) + now.tv_usec - starttime.tv_usec; eDebug("[eFilePushThread] read %d bytes time: %9u us", buf_end, (unsigned int)diff); #endif } else buf_end = 0; if (buf_end < 0) { buf_end = 0; /* Check m_stop after interrupted syscall. */ if (m_stop) { break; } if (errno == EINTR || errno == EBUSY || errno == EAGAIN) continue; if (errno == EOVERFLOW) { eWarning("OVERFLOW while playback?"); continue; } eDebug("eFilePushThread *read error* (%m) - not yet handled"); } /* a read might be mis-aligned in case of a short read. */ int d = buf_end % m_blocksize; if (d) buf_end -= d; if (buf_end == 0) { /* on EOF, try COMMITting once. */ if (m_send_pvr_commit) { 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"); /* Check m_stop after interrupted syscall. */ if (m_stop) break; continue; } } if (m_stop) break; /* in stream_mode, we are sending EOF events over and over until somebody responds. in stream_mode, think of evtEOF as "buffer underrun occurred". */ sendEvent(evtEOF); if (m_stream_mode) { eDebug("reached EOF, but we are in stream mode. delaying 1 second."); sleep(1); continue; } else if (++eofcount < 10) { eDebug("reached EOF, but the file may grow. delaying 1 second."); sleep(1); continue; } break; } else { /* Write data to mux */ int buf_start = 0; filterRecordData(m_buffer, buf_end); while ((buf_start != buf_end) && !m_stop) { int w = write(m_fd_dest, m_buffer + buf_start, buf_end - buf_start); if (w <= 0) { /* Check m_stop after interrupted syscall. */ if (m_stop) { w = 0; buf_start = 0; buf_end = 0; break; } if (w < 0 && (errno == EINTR || errno == EAGAIN || errno == EBUSY)) continue; eDebug("eFilePushThread WRITE ERROR"); sendEvent(evtWriteError); break; } buf_start += w; } eofcount = 0; m_current_position += buf_end; bytes_read += buf_end; if (m_sg) current_span_remaining -= buf_end; } } sendEvent(evtStopped); eDebug("FILEPUSH THREAD STOP"); }
void eFilePushThread::thread() { setIoPrio(prio_class, prio); off_t dest_pos = 0, source_pos = 0; size_t bytes_read = 0; off_t current_span_offset = 0; size_t current_span_remaining = 0; size_t written_since_last_sync = 0; eDebug("FILEPUSH THREAD START"); /* 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. */ while (!m_stop) { /* first try flushing the bufptr */ if (m_buf_start != m_buf_end) { /* 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 || errno == EAGAIN || errno == EBUSY) continue; eDebug("eFilePushThread WRITE ERROR"); sendEvent(evtWriteError); break; // ... we would stop the thread } 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; } // printf("FILEPUSH: wrote %d bytes\n", w); m_buf_start += w; continue; } /* now fill our buffer. */ 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); 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); if (m_buf_end < 0) { m_buf_end = 0; if (errno == EINTR || errno == EBUSY || errno == EAGAIN) continue; if (errno == EOVERFLOW) { eWarning("OVERFLOW while recording"); continue; } 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_send_pvr_commit) { 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); 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)) { eDebug("(looping)"); continue; } #endif break; } else { source_pos += m_buf_end; bytes_read += m_buf_end; if (m_sg) current_span_remaining -= m_buf_end; } // printf("FILEPUSH: read %d bytes\n", m_buf_end); } fdatasync(m_fd_dest); eDebug("FILEPUSH THREAD STOP"); }
void eFilePushThread::thread() { ignore_but_report_signals(); hasStarted(); /* "start()" blocks until we get here */ setIoPrio(IOPRIO_CLASS_BE, 0); eDebug("[eFilePushThread] START thread"); do { int eofcount = 0; int buf_end = 0; size_t bytes_read = 0; off_t current_span_offset = 0; size_t current_span_remaining = 0; while (!m_stop) { if (m_sg && !current_span_remaining) { m_sg->getNextSourceSpan(m_current_position, bytes_read, current_span_offset, current_span_remaining, m_blocksize); ASSERT(!(current_span_remaining % m_blocksize)); m_current_position = current_span_offset; bytes_read = 0; } size_t maxread = m_buffersize; /* 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; if (maxread) { #ifdef SHOW_WRITE_TIME struct timeval starttime; struct timeval now; gettimeofday(&starttime, NULL); #endif buf_end = m_source->read(m_current_position, m_buffer, maxread); #ifdef SHOW_WRITE_TIME gettimeofday(&now, NULL); suseconds_t diff = (1000000 * (now.tv_sec - starttime.tv_sec)) + now.tv_usec - starttime.tv_usec; eDebug("[eFilePushThread] read %d bytes time: %9u us", buf_end, (unsigned int)diff); #endif } else buf_end = 0; if (buf_end < 0) { buf_end = 0; /* Check m_stop after interrupted syscall. */ if (m_stop) { break; } if (errno == EINTR || errno == EBUSY || errno == EAGAIN) continue; if (errno == EOVERFLOW) { eWarning("[eFilePushThread] OVERFLOW while playback?"); continue; } eDebug("[eFilePushThread] read error: %m"); } /* a read might be mis-aligned in case of a short read. */ int d = buf_end % m_blocksize; if (d) buf_end -= d; if (buf_end == 0) { /* on EOF, try COMMITting once. */ if (m_send_pvr_commit) { struct pollfd pfd; pfd.fd = m_fd_dest; pfd.events = POLLIN; switch (poll(&pfd, 1, 250)) // wait for 250ms { case 0: eDebug("[eFilePushThread] wait for driver eof timeout"); continue; case 1: eDebug("[eFilePushThread] wait for driver eof ok"); break; default: eDebug("[eFilePushThread] wait for driver eof aborted by signal"); /* Check m_stop after interrupted syscall. */ if (m_stop) break; continue; } } if (m_stop) break; /* in stream_mode, we are sending EOF events over and over until somebody responds. in stream_mode, think of evtEOF as "buffer underrun occurred". */ sendEvent(evtEOF); if (m_stream_mode) { eDebug("[eFilePushThread] reached EOF, but we are in stream mode. delaying 1 second."); sleep(1); continue; } else if (++eofcount < 10) { eDebug("[eFilePushThread] reached EOF, but the file may grow. delaying 1 second."); sleep(1); continue; } break; } else { /* Write data to mux */ int buf_start = 0; filterRecordData(m_buffer, buf_end); while ((buf_start != buf_end) && !m_stop) { int w = write(m_fd_dest, m_buffer + buf_start, buf_end - buf_start); if (w <= 0) { /* Check m_stop after interrupted syscall. */ if (m_stop) { w = 0; buf_start = 0; buf_end = 0; break; } if (w < 0 && (errno == EINTR || errno == EAGAIN || errno == EBUSY)) continue; eDebug("[eFilePushThread] write: %m"); sendEvent(evtWriteError); break; } buf_start += w; } eofcount = 0; m_current_position += buf_end; bytes_read += buf_end; if (m_sg) current_span_remaining -= buf_end; } } sendEvent(evtStopped); { /* mutex lock scope */ eSingleLocker lock(m_run_mutex); m_run_state = 0; m_run_cond.signal(); /* Tell them we're here */ while (m_stop == 2) { eDebug("[eFilePushThread] PAUSED"); m_run_cond.wait(m_run_mutex); } if (m_stop == 0) m_run_state = 1; } } while (m_stop == 0); eDebug("[eFilePushThread] STOP"); }