/*
* Receive data
*/
static void timeshift_input
( void *opaque, streaming_message_t *sm )
{
int type = sm->sm_type;
timeshift_t *ts = opaque;
th_pkt_t *pkt, *pkt2;
if (ts->exit)
return;
/* Control */
if (type == SMT_SKIP) {
timeshift_write_skip(ts->rd_pipe.wr, sm->sm_data);
streaming_msg_free(sm);
} else if (type == SMT_SPEED) {
timeshift_write_speed(ts->rd_pipe.wr, sm->sm_code);
streaming_msg_free(sm);
} else {
/* Change PTS/DTS offsets */
if (ts->packet_mode && ts->start_pts && type == SMT_PACKET) {
pkt = sm->sm_data;
pkt2 = pkt_copy_shallow(pkt);
pkt_ref_dec(pkt);
sm->sm_data = pkt2;
pkt2->pkt_pts += ts->start_pts;
pkt2->pkt_dts += ts->start_pts;
}
/* Check for exit */
else if (type == SMT_EXIT ||
(type == SMT_STOP && sm->sm_code != SM_CODE_SOURCE_RECONFIGURED))
ts->exit = 1;
else if (type == SMT_MPEGTS)
ts->packet_mode = 0;
/* Send to the writer thread */
if (ts->packet_mode) {
sm->sm_time = ts->last_wr_time;
if ((type == SMT_PACKET) && !timeshift_packet(ts, sm))
goto _exit;
} else {
if (ts->ref_time == 0) {
ts->ref_time = getfastmonoclock();
sm->sm_time = 0;
} else {
sm->sm_time = getfastmonoclock() - ts->ref_time;
}
}
streaming_target_deliver2(&ts->wr_queue.sq_st, sm);
/* Exit/Stop */
_exit:
if (ts->exit)
timeshift_write_exit(ts->rd_pipe.wr);
}
}
static void
tsfix_input_packet(tsfix_t *tf, streaming_message_t *sm)
{
th_pkt_t *pkt = pkt_copy_shallow(sm->sm_data);
tfstream_t *tfs = tfs_find(tf, pkt);
streaming_msg_free(sm);
if(tfs == NULL || dispatch_clock < tf->tf_start_time) {
pkt_ref_dec(pkt);
return;
}
if(tf->tf_tsref == PTS_UNSET &&
(!tf->tf_hasvideo ||
(SCT_ISVIDEO(tfs->tfs_type) && pkt->pkt_frametype == PKT_I_FRAME))) {
tf->tf_tsref = pkt->pkt_dts & PTS_MASK;
tsfixprintf("reference clock set to %"PRId64"\n", tf->tf_tsref);
}
if(pkt->pkt_dts == PTS_UNSET) {
int pdur = pkt->pkt_duration >> pkt->pkt_field;
if(tfs->tfs_last_dts_in == PTS_UNSET) {
pkt_ref_dec(pkt);
return;
}
pkt->pkt_dts = (tfs->tfs_last_dts_in + pdur) & PTS_MASK;
tsfixprintf("TSFIX: %-12s DTS set to last %"PRId64" +%d == %"PRId64"\n",
streaming_component_type2txt(tfs->tfs_type),
tfs->tfs_last_dts_in, pdur, pkt->pkt_dts);
}
static void
timeshift_packet_flush ( timeshift_t *ts, int64_t time, int deliver )
{
streaming_message_t *lowest, *sm;
struct streaming_message_queue *sq;
int i;
while (1) {
lowest = NULL;
for (i = 0; i < ts->backlog_max; i++) {
sq = &ts->backlog[i];
sm = TAILQ_FIRST(sq);
if (sm && sm->sm_time + MAX_TIME_DELTA < time)
if (lowest == NULL || lowest->sm_time > sm->sm_time)
lowest = sm;
}
if (!lowest)
break;
TAILQ_REMOVE(sq, lowest, sm_link);
if (deliver)
timeshift_packet_deliver(ts, lowest);
else
streaming_msg_free(lowest);
}
}
static void
tsfix_input_packet(tsfix_t *tf, streaming_message_t *sm)
{
th_pkt_t *pkt = pkt_copy_shallow(sm->sm_data);
tfstream_t *tfs = tfs_find(tf, pkt);
streaming_msg_free(sm);
if(tfs == NULL || dispatch_clock < tf->tf_start_time) {
pkt_ref_dec(pkt);
return;
}
if(tf->tf_tsref == PTS_UNSET &&
(!tf->tf_hasvideo ||
(SCT_ISVIDEO(tfs->tfs_type) && pkt->pkt_frametype == PKT_I_FRAME))) {
tf->tf_tsref = pkt->pkt_dts & PTS_MASK;
tsfixprintf("reference clock set to %"PRId64"\n", tf->tf_tsref);
} else {
/* For teletext, the encoders might use completely different timestamps */
/* If the difference is greater than 2 seconds, use the actual dts value */
if (tfs->tfs_type == SCT_TELETEXT && tfs->tfs_local_ref == PTS_UNSET &&
tf->tf_tsref != PTS_UNSET && pkt->pkt_dts != PTS_UNSET) {
int64_t diff = tsfix_ts_diff(tf->tf_tsref, pkt->pkt_dts);
if (diff > 2 * 90000) {
tfstream_t *tfs2;
tvhwarn("parser", "The timediff for TELETEXT is big (%"PRId64"), using current dts", diff);
tfs->tfs_local_ref = pkt->pkt_dts;
/* Text subtitles extracted from teletext have same timebase */
LIST_FOREACH(tfs2, &tf->tf_streams, tfs_link)
if(tfs2->tfs_type == SCT_TEXTSUB)
tfs2->tfs_local_ref = pkt->pkt_dts;
} else {
void
streaming_target_deliver2(streaming_target_t *st, streaming_message_t *sm)
{
if (st->st_reject_filter & SMT_TO_MASK(sm->sm_type))
streaming_msg_free(sm);
else
streaming_target_deliver(st, sm);
}
void
streaming_queue_clear(struct streaming_message_queue *q)
{
streaming_message_t *sm;
while((sm = TAILQ_FIRST(q)) != NULL) {
TAILQ_REMOVE(q, sm, sm_link);
streaming_msg_free(sm);
}
}
static void* timeshift_reaper_callback ( void *p )
{
char *dpath;
timeshift_file_t *tsf;
timeshift_index_iframe_t *ti;
timeshift_index_data_t *tid;
streaming_message_t *sm;
pthread_mutex_lock(×hift_reaper_lock);
while (timeshift_reaper_run) {
/* Get next */
tsf = TAILQ_FIRST(×hift_reaper_list);
if (!tsf) {
pthread_cond_wait(×hift_reaper_cond, ×hift_reaper_lock);
continue;
}
TAILQ_REMOVE(×hift_reaper_list, tsf, link);
pthread_mutex_unlock(×hift_reaper_lock);
#ifdef TSHFT_TRACE
tvhlog(LOG_DEBUG, "timeshift", "remove file %s", tsf->path);
#endif
/* Remove */
unlink(tsf->path);
dpath = dirname(tsf->path);
if (rmdir(dpath) == -1)
if (errno != ENOTEMPTY)
tvhlog(LOG_ERR, "timeshift", "failed to remove %s [e=%s]",
dpath, strerror(errno));
pthread_mutex_lock(×hift_size_lock);
assert(tsf->size <= timeshift_total_size);
timeshift_total_size -= tsf->size;
pthread_mutex_unlock(×hift_size_lock);
/* Free memory */
while ((ti = TAILQ_FIRST(&tsf->iframes))) {
TAILQ_REMOVE(&tsf->iframes, ti, link);
free(ti);
}
while ((tid = TAILQ_FIRST(&tsf->sstart))) {
TAILQ_REMOVE(&tsf->sstart, tid, link);
sm = tid->data;
streaming_msg_free(sm);
free(tid);
}
free(tsf->path);
free(tsf);
}
pthread_mutex_unlock(×hift_reaper_lock);
#ifdef TSHFT_TRACE
tvhlog(LOG_DEBUG, "timeshift", "reaper thread exit");
#endif
return NULL;
}
static void* timeshift_reaper_callback ( void *p )
{
char *dpath;
timeshift_file_t *tsf;
timeshift_index_iframe_t *ti;
timeshift_index_data_t *tid;
streaming_message_t *sm;
pthread_mutex_lock(×hift_reaper_lock);
while (timeshift_reaper_run) {
/* Get next */
tsf = TAILQ_FIRST(×hift_reaper_list);
if (!tsf) {
pthread_cond_wait(×hift_reaper_cond, ×hift_reaper_lock);
continue;
}
TAILQ_REMOVE(×hift_reaper_list, tsf, link);
pthread_mutex_unlock(×hift_reaper_lock);
if (tsf->path) {
tvhtrace("timeshift", "remove file %s", tsf->path);
/* Remove */
unlink(tsf->path);
dpath = dirname(tsf->path);
if (rmdir(dpath) == -1)
if (errno != ENOTEMPTY)
tvhlog(LOG_ERR, "timeshift", "failed to remove %s [e=%s]",
dpath, strerror(errno));
} else {
tvhtrace("timeshift", "remove RAM segment (time %li)", (long)tsf->time);
}
/* Free memory */
while ((ti = TAILQ_FIRST(&tsf->iframes))) {
TAILQ_REMOVE(&tsf->iframes, ti, link);
free(ti);
}
while ((tid = TAILQ_FIRST(&tsf->sstart))) {
TAILQ_REMOVE(&tsf->sstart, tid, link);
sm = tid->data;
streaming_msg_free(sm);
free(tid);
}
free(tsf->path);
free(tsf->ram);
free(tsf);
pthread_mutex_lock(×hift_reaper_lock);
}
pthread_mutex_unlock(×hift_reaper_lock);
tvhtrace("timeshift", "reaper thread exit");
return NULL;
}
static void _process_msg
( timeshift_t *ts, streaming_message_t *sm, int *run )
{
int err;
timeshift_file_t *tsf;
/* Process */
switch (sm->sm_type) {
/* Terminate */
case SMT_EXIT:
if (run) *run = 0;
break;
case SMT_STOP:
if (sm->sm_code == 0 && run)
*run = 0;
break;
/* Timeshifting */
case SMT_SKIP:
case SMT_SPEED:
break;
/* Status */
case SMT_GRACE:
case SMT_NOSTART:
case SMT_NOSTART_WARN:
case SMT_SERVICE_STATUS:
case SMT_TIMESHIFT_STATUS:
break;
/* Store */
case SMT_SIGNAL_STATUS:
case SMT_START:
case SMT_MPEGTS:
case SMT_PACKET:
pthread_mutex_lock(&ts->rdwr_mutex);
if ((tsf = timeshift_filemgr_get(ts, 1)) && (tsf->wfd >= 0 || tsf->ram)) {
if ((err = _process_msg0(ts, tsf, &sm)) < 0) {
timeshift_filemgr_close(tsf);
tsf->bad = 1;
ts->full = 1; ///< Stop any more writing
}
tsf->refcount--;
}
pthread_mutex_unlock(&ts->rdwr_mutex);
break;
}
/* Next */
if (sm)
streaming_msg_free(sm);
}
/*
* Receive data
*/
static void timeshift_input
( void *opaque, streaming_message_t *sm )
{
int exit = 0;
timeshift_t *ts = opaque;
pthread_mutex_lock(&ts->state_mutex);
/* Control */
if (sm->sm_type == SMT_SKIP) {
if (ts->state >= TS_LIVE)
timeshift_write_skip(ts->rd_pipe.wr, sm->sm_data);
} else if (sm->sm_type == SMT_SPEED) {
if (ts->state >= TS_LIVE)
timeshift_write_speed(ts->rd_pipe.wr, sm->sm_code);
}
else {
/* Start */
if (sm->sm_type == SMT_START && ts->state == TS_INIT) {
ts->state = TS_LIVE;
}
/* Pass-thru */
if (ts->state <= TS_LIVE) {
streaming_target_deliver2(ts->output, streaming_msg_clone(sm));
}
/* Check for exit */
if (sm->sm_type == SMT_EXIT ||
(sm->sm_type == SMT_STOP && sm->sm_code == 0))
exit = 1;
/* Buffer to disk */
if ((ts->state > TS_LIVE) || (!ts->ondemand && (ts->state == TS_LIVE))) {
sm->sm_time = getmonoclock();
streaming_target_deliver2(&ts->wr_queue.sq_st, sm);
} else
streaming_msg_free(sm);
/* Exit/Stop */
if (exit) {
timeshift_write_exit(ts->rd_pipe.wr);
ts->state = TS_EXIT;
}
}
pthread_mutex_unlock(&ts->state_mutex);
}
static void
streaming_queue_deliver(void *opauqe, streaming_message_t *sm)
{
streaming_queue_t *sq = opauqe;
pthread_mutex_lock(&sq->sq_mutex);
/* queue size protection */
if (sq->sq_maxsize && sq->sq_maxsize < sq->sq_size) {
streaming_msg_free(sm);
} else {
TAILQ_INSERT_TAIL(&sq->sq_queue, sm, sm_link);
sq->sq_size += streaming_message_data_size(sm);
}
tvh_cond_signal(&sq->sq_cond, 0);
pthread_mutex_unlock(&sq->sq_mutex);
}
static void
streaming_queue_deliver(void *opauqe, streaming_message_t *sm)
{
streaming_queue_t *sq = opauqe;
pthread_mutex_lock(&sq->sq_mutex);
/* queue size protection */
// TODO: would be better to update size as we go, but this would
// require updates elsewhere to ensure all removals from the queue
// are covered (new function)
if (sq->sq_maxsize && streaming_queue_size(&sq->sq_queue) >= sq->sq_maxsize)
streaming_msg_free(sm);
else
TAILQ_INSERT_TAIL(&sq->sq_queue, sm, sm_link);
pthread_cond_signal(&sq->sq_cond);
pthread_mutex_unlock(&sq->sq_mutex);
}
void
streaming_pad_deliver(streaming_pad_t *sp, streaming_message_t *sm)
{
streaming_target_t *st, *next, *run = NULL;
for (st = LIST_FIRST(&sp->sp_targets); st; st = next) {
next = LIST_NEXT(st, st_link);
assert(next != st);
if (st->st_reject_filter & SMT_TO_MASK(sm->sm_type))
continue;
if (run)
streaming_target_deliver(run, streaming_msg_clone(sm));
run = st;
}
if (run)
streaming_target_deliver(run, sm);
else
streaming_msg_free(sm);
}
/*
* Timeshift thread
*/
void *timeshift_reader ( void *p )
{
timeshift_t *ts = p;
int nfds, end, run = 1, wait = -1, state;
timeshift_seek_t *seek = &ts->seek;
timeshift_file_t *tmp_file;
int cur_speed = 100, keyframe_mode = 0;
int64_t mono_now, mono_play_time = 0, mono_last_status = 0;
int64_t deliver, deliver0, pause_time = 0, last_time = 0, skip_time = 0;
int64_t i64;
streaming_message_t *sm = NULL, *ctrl = NULL;
streaming_skip_t *skip = NULL;
tvhpoll_t *pd;
tvhpoll_event_t ev = { 0 };
pd = tvhpoll_create(1);
ev.fd = ts->rd_pipe.rd;
ev.events = TVHPOLL_IN;
tvhpoll_add(pd, &ev, 1);
/* Output */
while (run) {
// Note: Previously we allowed unlimited wait, but we now must wake periodically
// to output status message
if (wait < 0 || wait > 1000)
wait = 1000;
/* Wait for data */
if(wait)
nfds = tvhpoll_wait(pd, &ev, 1, wait);
else
nfds = 0;
wait = -1;
end = 0;
skip = NULL;
mono_now = getfastmonoclock();
/* Control */
pthread_mutex_lock(&ts->state_mutex);
if (nfds == 1) {
if (_read_msg(NULL, ts->rd_pipe.rd, &ctrl) > 0) {
/* Exit */
if (ctrl->sm_type == SMT_EXIT) {
tvhtrace(LS_TIMESHIFT, "ts %d read exit request", ts->id);
run = 0;
streaming_msg_free(ctrl);
ctrl = NULL;
/* Speed */
} else if (ctrl->sm_type == SMT_SPEED) {
int speed = ctrl->sm_code;
int keyframe;
/* Bound it */
if (speed > 3200) speed = 3200;
if (speed < -3200) speed = -3200;
/* Ignore negative */
if (!ts->dobuf && (speed < 0))
speed = seek->file ? speed : 0;
/* Process */
if (cur_speed != speed) {
/* Live playback */
state = ts->state;
if (state == TS_LIVE) {
/* Reject */
if (speed >= 100) {
tvhdebug(LS_TIMESHIFT, "ts %d reject 1x+ in live mode", ts->id);
speed = 100;
/* Set position */
} else {
tvhdebug(LS_TIMESHIFT, "ts %d enter timeshift mode", ts->id);
ts->dobuf = 1;
_seek_reset(seek);
tmp_file = timeshift_filemgr_newest(ts);
if (tmp_file != NULL) {
i64 = tmp_file->last;
timeshift_file_put(tmp_file);
} else {
i64 = ts->buf_time;
}
seek->file = timeshift_filemgr_get(ts, i64);
if (seek->file != NULL) {
seek->file->roff = seek->file->size;
pause_time = seek->file->last;
last_time = pause_time;
} else {
pause_time = i64;
last_time = pause_time;
}
}
}
/* Check keyframe mode */
keyframe = (speed < 0) || (speed > 400);
if (keyframe != keyframe_mode) {
tvhdebug(LS_TIMESHIFT, "using keyframe mode? %s", keyframe ? "yes" : "no");
keyframe_mode = keyframe;
if (keyframe)
seek->frame = NULL;
}
/* Update */
if (speed != 100 || state != TS_LIVE) {
ts->state = speed == 0 ? TS_PAUSE : TS_PLAY;
tvhtrace(LS_TIMESHIFT, "reader - set %s", speed == 0 ? "TS_PAUSE" : "TS_PLAY");
}
if ((ts->state == TS_PLAY && state != TS_PLAY) || (speed != cur_speed)) {
mono_play_time = mono_now;
tvhtrace(LS_TIMESHIFT, "update play time TS_LIVE - %"PRId64" play buffer from %"PRId64,
mono_now, pause_time);
if (speed != cur_speed)
pause_time = last_time;
} else if (ts->state == TS_PAUSE && state != TS_PAUSE) {
pause_time = last_time;
}
cur_speed = speed;
tvhdebug(LS_TIMESHIFT, "ts %d change speed %d", ts->id, speed);
}
/* Send on the message */
ctrl->sm_code = speed;
streaming_target_deliver2(ts->output, ctrl);
ctrl = NULL;
/* Skip/Seek */
} else if (ctrl->sm_type == SMT_SKIP) {
skip = ctrl->sm_data;
switch (skip->type) {
case SMT_SKIP_LIVE:
if (ts->state != TS_LIVE) {
/* Reset */
if (ts->full) {
timeshift_filemgr_flush(ts, NULL);
_seek_reset(seek);
ts->full = 0;
}
/* Release */
if (sm)
streaming_msg_free(sm);
/* Find end */
skip_time = 0x7fffffffffffffffLL;
// TODO: change this sometime!
}
break;
case SMT_SKIP_ABS_TIME:
/* -fallthrough */
case SMT_SKIP_REL_TIME:
/* Convert */
skip_time = ts_rescale(skip->time, 1000000);
tvhdebug(LS_TIMESHIFT, "ts %d skip %"PRId64" requested %"PRId64, ts->id, skip_time, skip->time);
/* Live playback (stage1) */
if (ts->state == TS_LIVE) {
_seek_reset(seek);
tmp_file = timeshift_filemgr_newest(ts);
if (tmp_file) {
i64 = tmp_file->last;
timeshift_file_put(tmp_file);
}
if (tmp_file && (seek->file = timeshift_filemgr_get(ts, i64)) != NULL) {
seek->file->roff = seek->file->size;
last_time = seek->file->last;
} else {
last_time = ts->buf_time;
}
}
/* May have failed */
if (skip->type == SMT_SKIP_REL_TIME)
skip_time += last_time;
tvhdebug(LS_TIMESHIFT, "ts %d skip time %"PRId64, ts->id, skip_time);
/* Live (stage2) */
if (ts->state == TS_LIVE) {
if (skip_time >= ts->buf_time - TIMESHIFT_PLAY_BUF) {
tvhdebug(LS_TIMESHIFT, "ts %d skip ignored, already live", ts->id);
skip = NULL;
} else {
ts->state = TS_PLAY;
ts->dobuf = 1;
tvhtrace(LS_TIMESHIFT, "reader - set TS_PLAY");
}
}
/* OK */
if (skip) {
/* seek */
seek->frame = NULL;
end = _timeshift_do_skip(ts, skip_time, last_time, seek);
if (seek->frame) {
pause_time = seek->frame->time;
tvhtrace(LS_TIMESHIFT, "ts %d skip - play buffer from %"PRId64" last_time %"PRId64,
ts->id, pause_time, last_time);
/* Adjust time */
if (mono_play_time != mono_now)
tvhtrace(LS_TIMESHIFT, "ts %d update play time skip - %"PRId64, ts->id, mono_now);
mono_play_time = mono_now;
/* Clear existing packet */
if (sm) {
streaming_msg_free(sm);
sm = NULL;
}
} else {
skip = NULL;
}
}
break;
default:
tvherror(LS_TIMESHIFT, "ts %d invalid/unsupported skip type: %d", ts->id, skip->type);
skip = NULL;
break;
}
/* Error */
if (!skip) {
((streaming_skip_t*)ctrl->sm_data)->type = SMT_SKIP_ERROR;
streaming_target_deliver2(ts->output, ctrl);
ctrl = NULL;
}
/* Ignore */
} else {
streaming_msg_free(ctrl);
ctrl = NULL;
}
}
}
/* Done */
if (!run || !seek->file || ((ts->state != TS_PLAY && !skip))) {
if (mono_now >= (mono_last_status + sec2mono(1))) {
timeshift_status(ts, last_time);
mono_last_status = mono_now;
}
pthread_mutex_unlock(&ts->state_mutex);
continue;
}
/* Calculate delivery time */
deliver0 = (mono_now - mono_play_time) + TIMESHIFT_PLAY_BUF;
deliver = (deliver0 * cur_speed) / 100;
deliver = (deliver + pause_time);
tvhtrace(LS_TIMESHIFT, "speed %d now %"PRId64" play_time %"PRId64" deliver %"PRId64" deliver0 %"PRId64,
cur_speed, mono_now, mono_play_time, deliver, deliver0);
/* Determine next packet */
if (!sm) {
/* Rewind or Fast forward (i-frame only) */
if (skip || keyframe_mode) {
int64_t req_time;
/* Time */
if (!skip)
req_time = last_time + ((cur_speed < 0) ? -1 : 1);
else
req_time = skip_time;
end = _timeshift_do_skip(ts, req_time, last_time, seek);
}
/* Clear old message */
if (sm) {
streaming_msg_free(sm);
sm = NULL;
}
/* Find packet */
if (_timeshift_read(ts, seek, &sm, &wait) == -1) {
pthread_mutex_unlock(&ts->state_mutex);
break;
}
}
/* Send skip response */
if (skip) {
if (sm) {
/* Status message */
skip->time = ts_rescale_inv(sm->sm_time, 1000000);
skip->type = SMT_SKIP_ABS_TIME;
tvhdebug(LS_TIMESHIFT, "ts %d skip to pts %"PRId64" ok", ts->id, sm->sm_time);
/* Update timeshift status */
timeshift_fill_status(ts, &skip->timeshift, sm->sm_time);
mono_last_status = mono_now;
} else {
/* Report error */
skip->type = SMT_SKIP_ERROR;
skip = NULL;
tvhdebug(LS_TIMESHIFT, "ts %d skip failed (%d)", ts->id, sm ? sm->sm_type : -1);
}
streaming_target_deliver2(ts->output, ctrl);
} else {
streaming_msg_free(ctrl);
}
ctrl = NULL;
/* Deliver */
if (sm && (skip ||
(((cur_speed < 0) && (sm->sm_time >= deliver)) ||
((cur_speed > 0) && (sm->sm_time <= deliver))))) {
last_time = sm->sm_time;
if (!skip && keyframe_mode) /* always send status on keyframe mode */
timeshift_status(ts, last_time);
timeshift_packet_log("out", ts, sm);
streaming_target_deliver2(ts->output, sm);
sm = NULL;
wait = 0;
} else if (sm) {
if (cur_speed > 0)
wait = (sm->sm_time - deliver) / 1000;
else
wait = (deliver - sm->sm_time) / 1000;
if (wait == 0) wait = 1;
tvhtrace(LS_TIMESHIFT, "ts %d wait %d speed %d sm_time %"PRId64" deliver %"PRId64,
ts->id, wait, cur_speed, sm->sm_time, deliver);
}
/* Periodic timeshift status */
if (mono_now >= (mono_last_status + sec2mono(1))) {
timeshift_status(ts, last_time);
mono_last_status = mono_now;
}
/* Terminate */
if (!seek->file || end != 0) {
/* Back to live (unless buffer is full) */
if ((end == 1 && !ts->full) || !seek->file) {
tvhdebug(LS_TIMESHIFT, "ts %d eob revert to live mode", ts->id);
cur_speed = 100;
ctrl = streaming_msg_create_code(SMT_SPEED, cur_speed);
streaming_target_deliver2(ts->output, ctrl);
ctrl = NULL;
tvhtrace(LS_TIMESHIFT, "reader - set TS_LIVE");
/* Flush timeshift buffer to live */
if (_timeshift_flush_to_live(ts, seek, &wait) == -1) {
pthread_mutex_unlock(&ts->state_mutex);
break;
}
ts->state = TS_LIVE;
/* Close file (if open) */
_read_close(seek);
/* Pause */
} else {
if (cur_speed <= 0) {
cur_speed = 0;
tvhtrace(LS_TIMESHIFT, "reader - set TS_PAUSE");
ts->state = TS_PAUSE;
} else {
cur_speed = 100;
tvhtrace(LS_TIMESHIFT, "reader - set TS_PLAY");
if (ts->state != TS_PLAY) {
ts->state = TS_PLAY;
ts->dobuf = 1;
if (mono_play_time != mono_now)
tvhtrace(LS_TIMESHIFT, "update play time (pause) - %"PRId64, mono_now);
mono_play_time = mono_now;
}
}
tvhdebug(LS_TIMESHIFT, "ts %d sob speed %d last time %"PRId64, ts->id, cur_speed, last_time);
pause_time = last_time;
ctrl = streaming_msg_create_code(SMT_SPEED, cur_speed);
streaming_target_deliver2(ts->output, ctrl);
ctrl = NULL;
}
}
pthread_mutex_unlock(&ts->state_mutex);
}
/* Cleanup */
tvhpoll_destroy(pd);
_read_close(seek);
if (sm) streaming_msg_free(sm);
if (ctrl) streaming_msg_free(ctrl);
tvhtrace(LS_TIMESHIFT, "ts %d exit reader thread", ts->id);
return NULL;
}
/*
* Receive data
*/
static void timeshift_input
( void *opaque, streaming_message_t *sm )
{
int exit = 0, type = sm->sm_type;
timeshift_t *ts = opaque;
th_pkt_t *pkt = sm->sm_data, *pkt2;
pthread_mutex_lock(&ts->state_mutex);
/* Control */
if (type == SMT_SKIP) {
if (ts->state >= TS_LIVE)
timeshift_write_skip(ts->rd_pipe.wr, sm->sm_data);
streaming_msg_free(sm);
} else if (type == SMT_SPEED) {
if (ts->state >= TS_LIVE)
timeshift_write_speed(ts->rd_pipe.wr, sm->sm_code);
streaming_msg_free(sm);
}
else {
/* Start */
if (type == SMT_START && ts->state == TS_INIT)
ts->state = TS_LIVE;
/* Change PTS/DTS offsets */
if (ts->packet_mode && ts->start_pts && type == SMT_PACKET) {
pkt2 = pkt_copy_shallow(pkt);
pkt_ref_dec(pkt);
sm->sm_data = pkt = pkt2;
pkt->pkt_pts += ts->start_pts;
pkt->pkt_dts += ts->start_pts;
}
/* Pass-thru */
if (ts->state <= TS_LIVE) {
if (type == SMT_START) {
if (ts->smt_start)
streaming_start_unref(ts->smt_start);
ts->smt_start = sm->sm_data;
atomic_add(&ts->smt_start->ss_refcount, 1);
if (ts->packet_mode) {
timeshift_packet_flush(ts, ts->last_time + MAX_TIME_DELTA + 1000, ts->dobuf);
if (ts->last_time)
ts->start_pts = ts->last_time + 1000;
}
}
streaming_target_deliver2(ts->output, streaming_msg_clone(sm));
}
/* Check for exit */
if (type == SMT_EXIT ||
(type == SMT_STOP && sm->sm_code != SM_CODE_SOURCE_RECONFIGURED))
exit = 1;
if (type == SMT_MPEGTS)
ts->packet_mode = 0;
/* Buffer to disk */
if ((ts->state > TS_LIVE) || (ts->dobuf && (ts->state == TS_LIVE))) {
if (ts->packet_mode) {
sm->sm_time = ts->last_time;
if (type == SMT_PACKET) {
timeshift_packet(ts, pkt, 1);
goto msg_free;
}
} else {
if (ts->ref_time == 0) {
ts->ref_time = getmonoclock();
sm->sm_time = 0;
} else {
sm->sm_time = getmonoclock() - ts->ref_time;
}
}
streaming_target_deliver2(&ts->wr_queue.sq_st, sm);
} else {
if (type == SMT_PACKET) {
timeshift_packet(ts, pkt, 0);
tvhtrace("timeshift",
"ts %d pkt in - stream %d type %c pts %10"PRId64
" dts %10"PRId64" dur %10d len %6zu",
ts->id,
pkt->pkt_componentindex,
pkt_frametype_to_char(pkt->pkt_frametype),
ts_rescale(pkt->pkt_pts, 1000000),
ts_rescale(pkt->pkt_dts, 1000000),
pkt->pkt_duration,
pktbuf_len(pkt->pkt_payload));
}
msg_free:
streaming_msg_free(sm);
}
/* Exit/Stop */
if (exit) {
timeshift_write_exit(ts->rd_pipe.wr);
ts->state = TS_EXIT;
}
}
pthread_mutex_unlock(&ts->state_mutex);
}
static void *
serviceprobe_thread(void *aux)
{
service_t *t;
th_subscription_t *s;
int was_doing_work = 0;
streaming_queue_t sq;
streaming_message_t *sm;
// transport_feed_status_t status;
int run;
const char *err;
channel_t *ch;
uint32_t checksubscr;
pthread_mutex_lock(&global_lock);
streaming_queue_init(&sq, 0);
err = NULL;
while(1) {
while((t = TAILQ_FIRST(&serviceprobe_queue)) == NULL) {
if(was_doing_work) {
tvhlog(LOG_INFO, "serviceprobe", "Now idle");
was_doing_work = 0;
}
pthread_cond_wait(&serviceprobe_cond, &global_lock);
}
if(!was_doing_work) {
tvhlog(LOG_INFO, "serviceprobe", "Starting");
was_doing_work = 1;
}
if (t->s_dvb_mux_instance)
checksubscr = !t->s_dvb_mux_instance->tdmi_adapter->tda_skip_checksubscr;
else
checksubscr = 1;
if (checksubscr) {
tvhlog(LOG_INFO, "serviceprobe", "%20s: checking...",
t->s_svcname);
s = subscription_create_from_service(t, "serviceprobe", &sq.sq_st, 0,
NULL, NULL, "serviceprobe");
if(s == NULL) {
t->s_sp_onqueue = 0;
TAILQ_REMOVE(&serviceprobe_queue, t, s_sp_link);
tvhlog(LOG_INFO, "serviceprobe", "%20s: could not subscribe",
t->s_svcname);
continue;
}
}
service_ref(t);
pthread_mutex_unlock(&global_lock);
if (checksubscr) {
run = 1;
pthread_mutex_lock(&sq.sq_mutex);
while(run) {
while((sm = TAILQ_FIRST(&sq.sq_queue)) == NULL)
pthread_cond_wait(&sq.sq_cond, &sq.sq_mutex);
TAILQ_REMOVE(&sq.sq_queue, sm, sm_link);
pthread_mutex_unlock(&sq.sq_mutex);
if(sm->sm_type == SMT_SERVICE_STATUS) {
int status = sm->sm_code;
if(status & TSS_PACKETS) {
run = 0;
err = NULL;
} else if(status & (TSS_GRACEPERIOD | TSS_ERRORS)) {
run = 0;
err = service_tss2text(status);
}
}
streaming_msg_free(sm);
pthread_mutex_lock(&sq.sq_mutex);
}
streaming_queue_clear(&sq.sq_queue);
pthread_mutex_unlock(&sq.sq_mutex);
} else {
err = NULL;
}
pthread_mutex_lock(&global_lock);
if (checksubscr) {
subscription_unsubscribe(s);
}
if(t->s_status != SERVICE_ZOMBIE) {
if(err != NULL) {
tvhlog(LOG_INFO, "serviceprobe", "%20s: skipped: %s",
t->s_svcname, err);
} else if(t->s_ch == NULL) {
int channum = t->s_channel_number;
const char *str;
if (!channum && t->s_dvb_mux_instance->tdmi_adapter->tda_sidtochan)
channum = t->s_dvb_service_id;
ch = channel_find_by_name(t->s_svcname, 1, channum);
service_map_channel(t, ch, 1);
tvhlog(LOG_INFO, "serviceprobe", "%20s: mapped to channel \"%s\"",
t->s_svcname, t->s_svcname);
if(service_is_tv(t)) {
channel_tag_map(ch, channel_tag_find_by_name("TV channels", 1), 1);
tvhlog(LOG_INFO, "serviceprobe", "%20s: joined tag \"%s\"",
t->s_svcname, "TV channels");
}
switch(t->s_servicetype) {
case ST_SDTV:
case ST_AC_SDTV:
case ST_EX_SDTV:
case ST_DN_SDTV:
case ST_SK_SDTV:
case ST_NE_SDTV:
str = "SDTV";
break;
case ST_HDTV:
case ST_AC_HDTV:
case ST_EX_HDTV:
case ST_EP_HDTV:
case ST_ET_HDTV:
case ST_DN_HDTV:
str = "HDTV";
break;
case ST_RADIO:
str = "Radio";
break;
default:
str = NULL;
}
if(str != NULL) {
channel_tag_map(ch, channel_tag_find_by_name(str, 1), 1);
tvhlog(LOG_INFO, "serviceprobe", "%20s: joined tag \"%s\"",
t->s_svcname, str);
}
if(t->s_provider != NULL) {
channel_tag_map(ch, channel_tag_find_by_name(t->s_provider, 1), 1);
tvhlog(LOG_INFO, "serviceprobe", "%20s: joined tag \"%s\"",
t->s_svcname, t->s_provider);
}
channel_save(ch);
}
t->s_sp_onqueue = 0;
TAILQ_REMOVE(&serviceprobe_queue, t, s_sp_link);
}
service_unref(t);
}
return NULL;
}
static ssize_t _read_msg ( timeshift_file_t *tsf, int fd, streaming_message_t **sm )
{
ssize_t r, cnt = 0;
size_t sz;
streaming_message_type_t type;
int64_t time;
void *data;
int code;
/* Clear */
*sm = NULL;
/* Size */
r = _read_buf(tsf, fd, &sz, sizeof(sz));
if (r < 0) return -1;
if (r != sizeof(sz)) return 0;
cnt += r;
/* EOF */
if (sz == 0) return cnt;
/* Wrong data size */
if (sz > 1024 * 1024) return -1;
/* Type */
r = _read_buf(tsf, fd, &type, sizeof(type));
if (r < 0) return -1;
if (r != sizeof(type)) return 0;
cnt += r;
/* Time */
r = _read_buf(tsf, fd, &time, sizeof(time));
if (r < 0) return -1;
if (r != sizeof(time)) return 0;
cnt += r;
/* Adjust size */
sz -= sizeof(type) + sizeof(time);
cnt += sz;
/* Standard messages */
switch (type) {
/* Unhandled */
case SMT_START:
case SMT_NOSTART:
case SMT_NOSTART_WARN:
case SMT_SERVICE_STATUS:
case SMT_DESCRAMBLE_INFO:
return -1;
break;
/* Code */
case SMT_STOP:
case SMT_EXIT:
case SMT_SPEED:
if (sz != sizeof(code)) return -1;
r = _read_buf(tsf, fd, &code, sz);
if (r != sz) {
if (r < 0) return -1;
return 0;
}
*sm = streaming_msg_create_code(type, code);
break;
/* Data */
case SMT_SKIP:
case SMT_SIGNAL_STATUS:
case SMT_MPEGTS:
case SMT_PACKET:
data = malloc(sz);
r = _read_buf(tsf, fd, data, sz);
if (r != sz) {
free(data);
if (r < 0) return -1;
return 0;
}
if (type == SMT_PACKET) {
th_pkt_t *pkt = data;
pkt->pkt_payload = pkt->pkt_meta = NULL;
pkt->pkt_refcount = 0;
*sm = streaming_msg_create_pkt(pkt);
r = _read_pktbuf(tsf, fd, &pkt->pkt_meta);
if (r < 0) {
streaming_msg_free(*sm);
return r;
}
cnt += r;
r = _read_pktbuf(tsf, fd, &pkt->pkt_payload);
if (r < 0) {
streaming_msg_free(*sm);
return r;
}
cnt += r;
} else {
*sm = streaming_msg_create_data(type, data);
}
(*sm)->sm_time = time;
break;
default:
return -1;
}
/* OK */
return cnt;
}
/*
* Timeshift thread
*/
void *timeshift_reader ( void *p )
{
timeshift_t *ts = p;
int nfds, end, run = 1, wait = -1;
timeshift_file_t *cur_file = NULL;
int cur_speed = 100, keyframe_mode = 0;
int64_t pause_time = 0, play_time = 0, last_time = 0;
int64_t now, deliver, skip_time = 0;
streaming_message_t *sm = NULL, *ctrl = NULL;
timeshift_index_iframe_t *tsi = NULL;
streaming_skip_t *skip = NULL;
time_t last_status = 0;
tvhpoll_t *pd;
tvhpoll_event_t ev = { 0 };
pd = tvhpoll_create(1);
ev.fd = ts->rd_pipe.rd;
ev.events = TVHPOLL_IN;
tvhpoll_add(pd, &ev, 1);
/* Output */
while (run) {
// Note: Previously we allowed unlimited wait, but we now must wake periodically
// to output status message
if (wait < 0 || wait > 1000)
wait = 1000;
/* Wait for data */
if(wait)
nfds = tvhpoll_wait(pd, &ev, 1, wait);
else
nfds = 0;
wait = -1;
end = 0;
skip = NULL;
now = getmonoclock();
/* Control */
pthread_mutex_lock(&ts->state_mutex);
if (nfds == 1) {
if (_read_msg(NULL, ts->rd_pipe.rd, &ctrl) > 0) {
/* Exit */
if (ctrl->sm_type == SMT_EXIT) {
tvhtrace("timeshift", "ts %d read exit request", ts->id);
run = 0;
streaming_msg_free(ctrl);
ctrl = NULL;
/* Speed */
} else if (ctrl->sm_type == SMT_SPEED) {
int speed = ctrl->sm_code;
int keyframe;
/* Bound it */
if (speed > 3200) speed = 3200;
if (speed < -3200) speed = -3200;
/* Ignore negative */
if (ts->ondemand && (speed < 0))
speed = cur_file ? speed : 0;
/* Process */
if (cur_speed != speed) {
/* Live playback */
if (ts->state == TS_LIVE) {
/* Reject */
if (speed >= 100) {
tvhlog(LOG_DEBUG, "timeshift", "ts %d reject 1x+ in live mode",
ts->id);
speed = 100;
/* Set position */
} else {
tvhlog(LOG_DEBUG, "timeshift", "ts %d enter timeshift mode",
ts->id);
timeshift_writer_flush(ts);
pthread_mutex_lock(&ts->rdwr_mutex);
if ((cur_file = timeshift_filemgr_get(ts, 1))) {
cur_file->roff = cur_file->size;
pause_time = cur_file->last;
last_time = pause_time;
}
pthread_mutex_unlock(&ts->rdwr_mutex);
}
/* Buffer playback */
} else if (ts->state == TS_PLAY) {
pause_time = last_time;
/* Paused */
} else {
}
/* Check keyframe mode */
keyframe = (speed < 0) || (speed > 400);
if (keyframe != keyframe_mode) {
tvhlog(LOG_DEBUG, "timeshift", "using keyframe mode? %s",
keyframe ? "yes" : "no");
keyframe_mode = keyframe;
if (keyframe) {
tsi = NULL;
}
}
/* Update */
play_time = getmonoclock();
cur_speed = speed;
if (speed != 100 || ts->state != TS_LIVE)
ts->state = speed == 0 ? TS_PAUSE : TS_PLAY;
tvhlog(LOG_DEBUG, "timeshift", "ts %d change speed %d",
ts->id, speed);
}
/* Send on the message */
ctrl->sm_code = speed;
streaming_target_deliver2(ts->output, ctrl);
ctrl = NULL;
/* Skip/Seek */
} else if (ctrl->sm_type == SMT_SKIP) {
skip = ctrl->sm_data;
switch (skip->type) {
case SMT_SKIP_LIVE:
if (ts->state != TS_LIVE) {
/* Reset */
if (ts->full) {
pthread_mutex_lock(&ts->rdwr_mutex);
timeshift_filemgr_flush(ts, NULL);
ts->full = 0;
pthread_mutex_unlock(&ts->rdwr_mutex);
}
/* Release */
if (sm)
streaming_msg_free(sm);
/* Find end */
skip_time = 0x7fffffffffffffffLL;
// TODO: change this sometime!
}
break;
case SMT_SKIP_ABS_TIME:
if (ts->pts_delta == 0) {
tvhlog(LOG_ERR, "timeshift", "ts %d abs skip not possible no PTS delta", ts->id);
skip = NULL;
break;
}
/* -fallthrough */
case SMT_SKIP_REL_TIME:
/* Convert */
skip_time = ts_rescale(skip->time, 1000000);
tvhlog(LOG_DEBUG, "timeshift", "ts %d skip %"PRId64" requested %"PRId64, ts->id, skip_time, skip->time);
/* Live playback (stage1) */
if (ts->state == TS_LIVE) {
pthread_mutex_lock(&ts->rdwr_mutex);
if ((cur_file = timeshift_filemgr_get(ts, !ts->ondemand))) {
cur_file->roff = cur_file->size;
last_time = cur_file->last;
} else {
tvhlog(LOG_ERR, "timeshift", "ts %d failed to get current file", ts->id);
skip = NULL;
}
pthread_mutex_unlock(&ts->rdwr_mutex);
}
/* May have failed */
if (skip) {
skip_time += (skip->type == SMT_SKIP_ABS_TIME) ? ts->pts_delta : last_time;
tvhlog(LOG_DEBUG, "timeshift", "ts %d skip last_time %"PRId64" pts_delta %"PRId64,
ts->id, skip_time - ts->pts_delta, ts->pts_delta);
/* Live (stage2) */
if (ts->state == TS_LIVE) {
if (skip_time >= now) {
tvhlog(LOG_DEBUG, "timeshift", "ts %d skip ignored, already live", ts->id);
skip = NULL;
} else {
ts->state = TS_PLAY;
}
}
}
/* OK */
if (skip) {
/* Adjust time */
play_time = now;
pause_time = skip_time;
tsi = NULL;
/* Clear existing packet */
if (sm)
streaming_msg_free(sm);
sm = NULL;
}
break;
default:
tvhlog(LOG_ERR, "timeshift", "ts %d invalid/unsupported skip type: %d", ts->id, skip->type);
skip = NULL;
break;
}
/* Error */
if (!skip) {
((streaming_skip_t*)ctrl->sm_data)->type = SMT_SKIP_ERROR;
streaming_target_deliver2(ts->output, ctrl);
ctrl = NULL;
}
/* Ignore */
} else {
streaming_msg_free(ctrl);
ctrl = NULL;
}
}
}
/* Status message */
if (now >= (last_status + 1000000)) {
streaming_message_t *tsm;
timeshift_status_t *status;
timeshift_index_iframe_t *fst, *lst;
status = calloc(1, sizeof(timeshift_status_t));
fst = _timeshift_first_frame(ts);
lst = _timeshift_last_frame(ts);
status->full = ts->full;
status->shift = ts->state <= TS_LIVE ? 0 : ts_rescale_i(now - last_time, 1000000);
if (lst && fst && lst != fst && ts->pts_delta != PTS_UNSET) {
status->pts_start = ts_rescale_i(fst->time - ts->pts_delta, 1000000);
status->pts_end = ts_rescale_i(lst->time - ts->pts_delta, 1000000);
} else {
status->pts_start = PTS_UNSET;
status->pts_end = PTS_UNSET;
}
tsm = streaming_msg_create_data(SMT_TIMESHIFT_STATUS, status);
streaming_target_deliver2(ts->output, tsm);
last_status = now;
}
/* Done */
if (!run || !cur_file || ((ts->state != TS_PLAY && !skip))) {
pthread_mutex_unlock(&ts->state_mutex);
continue;
}
/* Calculate delivery time */
deliver = (now - play_time) + TIMESHIFT_PLAY_BUF;
deliver = (deliver * cur_speed) / 100;
deliver = (deliver + pause_time);
/* Determine next packet */
if (!sm) {
/* Rewind or Fast forward (i-frame only) */
if (skip || keyframe_mode) {
timeshift_file_t *tsf = NULL;
int64_t req_time;
/* Time */
if (!skip)
req_time = last_time + ((cur_speed < 0) ? -1 : 1);
else
req_time = skip_time;
tvhlog(LOG_DEBUG, "timeshift", "ts %d skip to %"PRId64" from %"PRId64,
ts->id, req_time - ts->pts_delta, last_time - ts->pts_delta);
/* Find */
pthread_mutex_lock(&ts->rdwr_mutex);
end = _timeshift_skip(ts, req_time, last_time,
cur_file, &tsf, &tsi);
pthread_mutex_unlock(&ts->rdwr_mutex);
if (tsi)
tvhlog(LOG_DEBUG, "timeshift", "ts %d skip found pkt @ %"PRId64,
ts->id, tsi->time - ts->pts_delta);
/* File changed (close) */
if ((tsf != cur_file) && cur_file && cur_file->rfd >= 0) {
close(cur_file->rfd);
cur_file->rfd = -1;
}
/* Position */
if (cur_file)
cur_file->refcount--;
if ((cur_file = tsf) != NULL) {
if (tsi)
cur_file->roff = tsi->pos;
else
cur_file->roff = 0;
}
}
/* Find packet */
if (_timeshift_read(ts, &cur_file, &sm, &wait) == -1) {
pthread_mutex_unlock(&ts->state_mutex);
break;
}
}
/* Send skip response */
if (skip) {
if (sm && sm->sm_type == SMT_PACKET) {
th_pkt_t *pkt = sm->sm_data;
skip->time = pkt->pkt_pts;
skip->type = SMT_SKIP_ABS_TIME;
tvhlog(LOG_DEBUG, "timeshift", "ts %d skip to pts %"PRId64" ok, time %"PRId64,
ts->id, ts_rescale(skip->time, 1000000), sm->sm_time - ts->pts_delta);
} else {
/* Report error */
skip->type = SMT_SKIP_ERROR;
skip = NULL;
tvhlog(LOG_DEBUG, "timeshift", "ts %d skip failed (%d)", ts->id, sm ? sm->sm_type : -1);
}
streaming_target_deliver2(ts->output, ctrl);
ctrl = NULL;
}
/* Deliver */
if (sm && (skip ||
(((cur_speed < 0) && (sm->sm_time >= deliver)) ||
((cur_speed > 0) && (sm->sm_time <= deliver))))) {
if (sm->sm_type == SMT_PACKET && tvhtrace_enabled()) {
th_pkt_t *pkt = sm->sm_data;
tvhtrace("timeshift",
"ts %d pkt out - stream %d type %c pts %10"PRId64
" dts %10"PRId64 " dur %10d len %6zu time %14"PRItime_t,
ts->id,
pkt->pkt_componentindex,
pkt_frametype_to_char(pkt->pkt_frametype),
ts_rescale(pkt->pkt_pts, 1000000),
ts_rescale(pkt->pkt_dts, 1000000),
pkt->pkt_duration,
pktbuf_len(pkt->pkt_payload), sm->sm_time - ts->pts_delta);
}
last_time = sm->sm_time;
streaming_target_deliver2(ts->output, sm);
sm = NULL;
wait = 0;
} else if (sm) {
if (cur_speed > 0)
wait = (sm->sm_time - deliver) / 1000;
else
wait = (deliver - sm->sm_time) / 1000;
if (wait == 0) wait = 1;
tvhtrace("timeshift", "ts %d wait %d",
ts->id, wait);
}
/* Terminate */
if (!cur_file || end != 0) {
if (!end)
end = (cur_speed > 0) ? 1 : -1;
/* Back to live (unless buffer is full) */
if (end == 1 && !ts->full) {
tvhlog(LOG_DEBUG, "timeshift", "ts %d eob revert to live mode", ts->id);
ts->state = TS_LIVE;
cur_speed = 100;
ctrl = streaming_msg_create_code(SMT_SPEED, cur_speed);
streaming_target_deliver2(ts->output, ctrl);
ctrl = NULL;
/* Flush timeshift buffer to live */
if (_timeshift_flush_to_live(ts, &cur_file, &sm, &wait) == -1)
break;
/* Close file (if open) */
if (cur_file && cur_file->rfd >= 0) {
close(cur_file->rfd);
cur_file->rfd = -1;
}
/* Flush ALL files */
if (ts->ondemand)
timeshift_filemgr_flush(ts, NULL);
/* Pause */
} else {
if (cur_speed <= 0) {
cur_speed = 0;
ts->state = TS_PAUSE;
} else {
cur_speed = 100;
ts->state = TS_PLAY;
play_time = now;
}
tvhlog(LOG_DEBUG, "timeshift", "ts %d sob speed %d", ts->id, cur_speed);
pause_time = last_time;
ctrl = streaming_msg_create_code(SMT_SPEED, cur_speed);
streaming_target_deliver2(ts->output, ctrl);
ctrl = NULL;
}
/* Flush unwanted */
} else if (ts->ondemand && cur_file) {
pthread_mutex_lock(&ts->rdwr_mutex);
timeshift_filemgr_flush(ts, cur_file);
pthread_mutex_unlock(&ts->rdwr_mutex);
}
pthread_mutex_unlock(&ts->state_mutex);
}
/* Cleanup */
tvhpoll_destroy(pd);
if (cur_file && cur_file->rfd >= 0) {
close(cur_file->rfd);
cur_file->rfd = -1;
}
if (sm) streaming_msg_free(sm);
if (ctrl) streaming_msg_free(ctrl);
tvhtrace("timeshift", "ts %d exit reader thread", ts->id);
return NULL;
}
/*
* Receive data
*/
static void timeshift_input
( void *opaque, streaming_message_t *sm )
{
int exit = 0;
timeshift_t *ts = opaque;
pthread_mutex_lock(&ts->state_mutex);
/* Control */
if (sm->sm_type == SMT_SKIP) {
if (ts->state >= TS_LIVE)
timeshift_write_skip(ts->rd_pipe.wr, sm->sm_data);
} else if (sm->sm_type == SMT_SPEED) {
if (ts->state >= TS_LIVE)
timeshift_write_speed(ts->rd_pipe.wr, sm->sm_code);
}
else {
/* Start */
if (sm->sm_type == SMT_START && ts->state == TS_INIT) {
ts->state = TS_LIVE;
}
/* Pass-thru */
if (ts->state <= TS_LIVE) {
if (sm->sm_type == SMT_START) {
if (ts->smt_start)
streaming_start_unref(ts->smt_start);
ts->smt_start = sm->sm_data;
atomic_add(&ts->smt_start->ss_refcount, 1);
}
streaming_target_deliver2(ts->output, streaming_msg_clone(sm));
}
/* Check for exit */
if (sm->sm_type == SMT_EXIT ||
(sm->sm_type == SMT_STOP && sm->sm_code == 0))
exit = 1;
/* Record (one-off) PTS delta */
if (sm->sm_type == SMT_PACKET && ts->pts_delta == PTS_UNSET) {
th_pkt_t *pkt = sm->sm_data;
if (pkt->pkt_pts != PTS_UNSET)
ts->pts_delta = getmonoclock() - ts_rescale(pkt->pkt_pts, 1000000);
}
/* Buffer to disk */
if ((ts->state > TS_LIVE) || (!ts->ondemand && (ts->state == TS_LIVE))) {
sm->sm_time = getmonoclock();
streaming_target_deliver2(&ts->wr_queue.sq_st, sm);
} else
streaming_msg_free(sm);
/* Exit/Stop */
if (exit) {
timeshift_write_exit(ts->rd_pipe.wr);
ts->state = TS_EXIT;
}
}
pthread_mutex_unlock(&ts->state_mutex);
}
/*
* Receive data
*/
static void timeshift_input
( void *opaque, streaming_message_t *sm )
{
int exit = 0;
timeshift_t *ts = opaque;
th_pkt_t *pkt = sm->sm_data;
pthread_mutex_lock(&ts->state_mutex);
/* Control */
if (sm->sm_type == SMT_SKIP) {
if (ts->state >= TS_LIVE)
timeshift_write_skip(ts->rd_pipe.wr, sm->sm_data);
} else if (sm->sm_type == SMT_SPEED) {
if (ts->state >= TS_LIVE)
timeshift_write_speed(ts->rd_pipe.wr, sm->sm_code);
}
else {
/* Start */
if (sm->sm_type == SMT_START && ts->state == TS_INIT) {
ts->state = TS_LIVE;
}
if (sm->sm_type == SMT_PACKET) {
tvhtrace("timeshift",
"ts %d pkt in - stream %d type %c pts %10"PRId64
" dts %10"PRId64" dur %10d len %zu",
ts->id,
pkt->pkt_componentindex,
pkt_frametype_to_char(pkt->pkt_frametype),
ts_rescale(pkt->pkt_pts, 1000000),
ts_rescale(pkt->pkt_dts, 1000000),
pkt->pkt_duration,
pktbuf_len(pkt->pkt_payload));
}
/* Pass-thru */
if (ts->state <= TS_LIVE) {
if (sm->sm_type == SMT_START) {
if (ts->smt_start)
streaming_start_unref(ts->smt_start);
ts->smt_start = sm->sm_data;
atomic_add(&ts->smt_start->ss_refcount, 1);
}
streaming_target_deliver2(ts->output, streaming_msg_clone(sm));
}
/* Check for exit */
if (sm->sm_type == SMT_EXIT ||
(sm->sm_type == SMT_STOP && sm->sm_code == 0))
exit = 1;
/* Record (one-off) PTS delta */
if (sm->sm_type == SMT_PACKET && ts->pts_delta == PTS_UNSET)
timeshift_set_pts_delta(ts, pkt->pkt_pts);
/* Buffer to disk */
if ((ts->state > TS_LIVE) || (!ts->ondemand && (ts->state == TS_LIVE))) {
sm->sm_time = getmonoclock();
if (sm->sm_type == SMT_PACKET) {
tvhtrace("timeshift",
"ts %d pkt buf - stream %d type %c pts %10"PRId64
" dts %10"PRId64" dur %10d len %zu",
ts->id,
pkt->pkt_componentindex,
pkt_frametype_to_char(pkt->pkt_frametype),
ts_rescale(pkt->pkt_pts, 1000000),
ts_rescale(pkt->pkt_dts, 1000000),
pkt->pkt_duration,
pktbuf_len(pkt->pkt_payload));
}
streaming_target_deliver2(&ts->wr_queue.sq_st, sm);
} else
streaming_msg_free(sm);
/* Exit/Stop */
if (exit) {
timeshift_write_exit(ts->rd_pipe.wr);
ts->state = TS_EXIT;
}
}
pthread_mutex_unlock(&ts->state_mutex);
}
static void _process_msg
( timeshift_t *ts, streaming_message_t *sm, int *run )
{
int err;
timeshift_file_t *tsf;
/* Process */
switch (sm->sm_type) {
/* Terminate */
case SMT_EXIT:
if (run) *run = 0;
break;
case SMT_STOP:
if (sm->sm_code != SM_CODE_SOURCE_RECONFIGURED && run)
*run = 0;
goto live;
/* Timeshifting */
case SMT_SKIP:
case SMT_SPEED:
break;
/* Status */
case SMT_GRACE:
case SMT_NOSTART:
case SMT_NOSTART_WARN:
case SMT_SERVICE_STATUS:
case SMT_TIMESHIFT_STATUS:
case SMT_DESCRAMBLE_INFO:
goto live;
/* Store */
case SMT_SIGNAL_STATUS:
case SMT_START:
case SMT_MPEGTS:
case SMT_PACKET:
pthread_mutex_lock(&ts->state_mutex);
ts->buf_time = sm->sm_time;
if (ts->state == TS_LIVE) {
streaming_target_deliver2(ts->output, streaming_msg_clone(sm));
if (sm->sm_type == SMT_PACKET)
timeshift_packet_log("liv", ts, sm);
}
if (sm->sm_type == SMT_START)
_update_smt_start(ts, (streaming_start_t *)sm->sm_data);
if (ts->dobuf) {
if ((tsf = timeshift_filemgr_get(ts, sm->sm_time)) != NULL) {
if (tsf->wfd >= 0 || tsf->ram) {
if ((err = _process_msg0(ts, tsf, sm)) < 0) {
timeshift_filemgr_close(tsf);
tsf->bad = 1;
ts->full = 1; ///< Stop any more writing
} else {
timeshift_packet_log("sav", ts, sm);
}
}
timeshift_file_put(tsf);
}
}
pthread_mutex_unlock(&ts->state_mutex);
break;
}
/* Next */
streaming_msg_free(sm);
return;
live:
pthread_mutex_lock(&ts->state_mutex);
if (ts->state == TS_LIVE)
streaming_target_deliver2(ts->output, sm);
else
streaming_msg_free(sm);
pthread_mutex_unlock(&ts->state_mutex);
}
