void
dvr_rec_subscribe(dvr_entry_t *de)
{
char buf[100];
int weight;
dvr_config_t *cfg = dvr_config_find_by_name_default(de->de_config_name);
int matroska = strcmp(cfg->dvr_format, "matroska") == 0;
assert(de->de_s == NULL);
snprintf(buf, sizeof(buf), "DVR: %s", de->de_title);
streaming_queue_init(&de->de_sq,
matroska ? 0 : SMT_TO_MASK(SMT_PACKET));
pthread_create(&de->de_thread, NULL, dvr_thread, de);
if(de->de_pri < 5)
weight = prio2weight[de->de_pri];
else
weight = 300;
tvhlog(LOG_DEBUG, "dvr", "Use %s container", cfg->dvr_format);
if(matroska) {
de->de_gh = globalheaders_create(&de->de_sq.sq_st);
de->de_tsfix = tsfix_create(de->de_gh);
de->de_s = subscription_create_from_channel(de->de_channel, weight,
buf, de->de_tsfix, 0);
// } else if { (Other containers)
// mpegts works like rawts
} else {
de->de_s = subscription_create_from_channel(de->de_channel, weight,
buf, &de->de_sq.sq_st, SUBSCRIPTION_RAW_MPEGTS);
}
}
void
dvr_rec_subscribe(dvr_entry_t *de)
{
char buf[100];
int weight;
streaming_target_t *st;
int flags;
assert(de->de_s == NULL);
if(de->de_pri < 5)
weight = prio2weight[de->de_pri];
else
weight = 300;
snprintf(buf, sizeof(buf), "DVR: %s", lang_str_get(de->de_title, NULL));
if(de->de_mc == MC_PASS) {
streaming_queue_init(&de->de_sq, SMT_PACKET);
de->de_gh = NULL;
de->de_tsfix = NULL;
st = &de->de_sq.sq_st;
flags = SUBSCRIPTION_RAW_MPEGTS;
} else {
streaming_queue_init(&de->de_sq, 0);
de->de_gh = globalheaders_create(&de->de_sq.sq_st);
st = de->de_tsfix = tsfix_create(de->de_gh);
tsfix_set_start_time(de->de_tsfix, de->de_start - (60 * de->de_start_extra));
flags = 0;
}
de->de_s = subscription_create_from_channel(de->de_channel, weight,
buf, st, flags,
NULL, NULL, NULL);
pthread_create(&de->de_thread, NULL, dvr_thread, de);
}
/**
* Create timeshift buffer
*
* max_period of buffer in seconds (0 = unlimited)
* max_size of buffer in bytes (0 = unlimited)
*/
streaming_target_t *timeshift_create
(streaming_target_t *out, time_t max_time)
{
timeshift_t *ts = calloc(1, sizeof(timeshift_t));
memoryinfo_alloc(×hift_memoryinfo, sizeof(timeshift_t));
/* Must hold global lock */
lock_assert(&global_lock);
/* Setup structure */
TAILQ_INIT(&ts->files);
ts->output = out;
ts->path = NULL;
ts->max_time = max_time;
ts->state = TS_LIVE;
ts->exit = 0;
ts->full = 0;
ts->vididx = -1;
ts->id = timeshift_index;
ts->ondemand = timeshift_conf.ondemand;
ts->dobuf = ts->ondemand ? 0 : 1;
ts->packet_mode= 1;
ts->last_wr_time = 0;
ts->buf_time = 0;
ts->start_pts = 0;
ts->ref_time = 0;
ts->seek.file = NULL;
ts->seek.frame = NULL;
ts->ram_segments = 0;
ts->file_segments = 0;
pthread_mutex_init(&ts->state_mutex, NULL);
/* Initialise output */
tvh_pipe(O_NONBLOCK, &ts->rd_pipe);
/* Initialise input */
streaming_queue_init(&ts->wr_queue, 0, 0);
streaming_target_init(&ts->input, ×hift_input_ops, ts, 0);
tvhthread_create(&ts->wr_thread, NULL, timeshift_writer, ts, "tshift-wr");
tvhthread_create(&ts->rd_thread, NULL, timeshift_reader, ts, "tshift-rd");
/* Update index */
timeshift_index++;
return &ts->input;
}
/**
* Create timeshift buffer
*
* max_period of buffer in seconds (0 = unlimited)
* max_size of buffer in bytes (0 = unlimited)
*/
streaming_target_t *timeshift_create
(streaming_target_t *out, time_t max_time)
{
timeshift_t *ts = calloc(1, sizeof(timeshift_t));
int i;
/* Must hold global lock */
lock_assert(&global_lock);
/* Setup structure */
TAILQ_INIT(&ts->files);
ts->output = out;
ts->path = NULL;
ts->max_time = max_time;
ts->state = TS_INIT;
ts->full = 0;
ts->vididx = -1;
ts->id = timeshift_index;
ts->ondemand = timeshift_conf.ondemand;
ts->dobuf = ts->ondemand ? 0 : 1;
ts->packet_mode= 1;
ts->last_time = 0;
ts->start_pts = 0;
ts->ref_time = 0;
for (i = 0; i < TIMESHIFT_BACKLOG_MAX; i++)
TAILQ_INIT(&ts->backlog[i]);
pthread_mutex_init(&ts->rdwr_mutex, NULL);
pthread_mutex_init(&ts->state_mutex, NULL);
/* Initialise output */
tvh_pipe(O_NONBLOCK, &ts->rd_pipe);
/* Initialise input */
streaming_queue_init(&ts->wr_queue, 0, 0);
streaming_target_init(&ts->input, timeshift_input, ts, 0);
tvhthread_create(&ts->wr_thread, NULL, timeshift_writer, ts, "tshift-wr");
tvhthread_create(&ts->rd_thread, NULL, timeshift_reader, ts, "tshift-rd");
/* Update index */
timeshift_index++;
return &ts->input;
}
/**
* Create timeshift buffer
*
* max_period of buffer in seconds (0 = unlimited)
* max_size of buffer in bytes (0 = unlimited)
*/
streaming_target_t *timeshift_create
(streaming_target_t *out, time_t max_time)
{
char buf[512];
timeshift_t *ts = calloc(1, sizeof(timeshift_t));
/* Must hold global lock */
lock_assert(&global_lock);
/* Create directories */
if (timeshift_filemgr_makedirs(timeshift_index, buf, sizeof(buf)))
return NULL;
/* Setup structure */
TAILQ_INIT(&ts->files);
ts->output = out;
ts->path = strdup(buf);
ts->max_time = max_time;
ts->state = TS_INIT;
ts->full = 0;
ts->vididx = -1;
ts->id = timeshift_index;
ts->ondemand = timeshift_ondemand;
pthread_mutex_init(&ts->rdwr_mutex, NULL);
pthread_mutex_init(&ts->state_mutex, NULL);
/* Initialise output */
tvh_pipe(O_NONBLOCK, &ts->rd_pipe);
/* Initialise input */
streaming_queue_init(&ts->wr_queue, 0);
streaming_target_init(&ts->input, timeshift_input, ts, 0);
pthread_create(&ts->wr_thread, NULL, timeshift_writer, ts);
pthread_create(&ts->rd_thread, NULL, timeshift_reader, ts);
/* Update index */
timeshift_index++;
return &ts->input;
}
/**
* Create timeshift buffer
*
* max_period of buffer in seconds (0 = unlimited)
* max_size of buffer in bytes (0 = unlimited)
*/
streaming_target_t *timeshift_create
(streaming_target_t *out, time_t max_time)
{
timeshift_t *ts = calloc(1, sizeof(timeshift_t));
int i;
/* Must hold global lock */
lock_assert(&global_lock);
/* Setup structure */
TAILQ_INIT(&ts->files);
ts->output = out;
ts->path = NULL;
ts->max_time = max_time;
ts->state = TS_INIT;
ts->full = 0;
ts->vididx = -1;
ts->id = timeshift_index;
ts->ondemand = timeshift_ondemand;
ts->pts_delta = PTS_UNSET;
for (i = 0; i < ARRAY_SIZE(ts->pts_val); i++)
ts->pts_val[i] = PTS_UNSET;
pthread_mutex_init(&ts->rdwr_mutex, NULL);
pthread_mutex_init(&ts->state_mutex, NULL);
/* Initialise output */
tvh_pipe(O_NONBLOCK, &ts->rd_pipe);
/* Initialise input */
streaming_queue_init(&ts->wr_queue, 0, 0);
streaming_target_init(&ts->input, timeshift_input, ts, 0);
tvhthread_create(&ts->wr_thread, NULL, timeshift_writer, ts);
tvhthread_create(&ts->rd_thread, NULL, timeshift_reader, ts);
/* Update index */
timeshift_index++;
return &ts->input;
}
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;
}
