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");
}
