stv0g/tvheadend
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity
tvheadend/src/dvr/dvr_timerec.c

669 lines
16 KiB
C
Raw Blame History

/*
* tvheadend, Automatic time-based recording
* Copyright (C) 2014 Jaroslav Kysela <perex@perex.cz>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <pthread.h>
#include <ctype.h>
#include <assert.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <errno.h>
#include <math.h>
#include <time.h>
#include "tvheadend.h"
#include "settings.h"
#include "dvr.h"
#include "epg.h"
struct dvr_timerec_entry_queue timerec_entries;
static gtimer_t dvr_timerec_timer;
/**
*
*/
static time_t
dvr_timerec_timecorrection(time_t clk, int hm, struct tm *tm)
{
time_t r;
int isdst;
localtime_r(&clk, tm);
tm->tm_min = hm % 60;
tm->tm_hour = hm / 60;
tm->tm_sec = 0;
isdst = tm->tm_isdst;
r = mktime(tm);
if (tm->tm_isdst != isdst) {
tm->tm_min = hm % 60;
tm->tm_hour = hm / 60;
tm->tm_sec = 0;
r = mktime(tm);
}
return r;
}
/**
* Unlink - and remove any unstarted
*/
static void
dvr_timerec_purge_spawn(dvr_timerec_entry_t *dte, int delconf)
{
dvr_entry_t *de = dte->dte_spawn;
if (de && de->de_timerec) {
dte->dte_spawn = NULL;
de->de_timerec = NULL;
if (delconf) {
if (de->de_sched_state == DVR_SCHEDULED)
dvr_entry_cancel(de);
else
dvr_entry_save(de);
}
}
}
/**
* Title
*/
static const char *
dvr_timerec_title(dvr_timerec_entry_t *dte, struct tm *start)
{
static char buf[256];
size_t len;
if (dte->dte_title == NULL)
return "Unknown";
len = strftime(buf, sizeof(buf) - 1, dte->dte_title, start);
buf[len] = '\0';
return buf;
}
/**
* handle the timerec entry
*/
void
dvr_timerec_check(dvr_timerec_entry_t *dte)
{
dvr_entry_t *de;
time_t start, stop, limit;
struct tm tm_start, tm_stop;
const char *title;
char buf[200];
if(dte->dte_enabled == 0 || dte->dte_weekdays == 0)
goto fail;
if(dte->dte_start < 0 || dte->dte_start >= 24*60 ||
dte->dte_stop < 0 || dte->dte_stop >= 24*60)
goto fail;
if(dte->dte_channel == NULL)
goto fail;
limit = dispatch_clock - 600;
start = dvr_timerec_timecorrection(dispatch_clock, dte->dte_start, &tm_start);
stop = dvr_timerec_timecorrection(dispatch_clock, dte->dte_stop, &tm_stop);
if (start < limit && stop < limit) {
/* next day */
start = dvr_timerec_timecorrection(dispatch_clock + 24*60*60,
dte->dte_start,
&tm_start);
stop = dvr_timerec_timecorrection(dispatch_clock + 24*60*60,
dte->dte_stop,
&tm_stop);
}
/* day boundary correction */
if (start > stop)
stop += 24 * 60 * 60;
assert(start < stop);
if(dte->dte_weekdays != 0x7f) {
localtime_r(&start, &tm_start);
if(!((1 << ((tm_start.tm_wday ?: 7) - 1)) & dte->dte_weekdays))
goto fail;
}
/* purge the old entry */
de = dte->dte_spawn;
if (de) {
if (de->de_start == start && de->de_stop == stop)
return;
dvr_timerec_purge_spawn(dte, 1);
}
title = dvr_timerec_title(dte, &tm_start);
snprintf(buf, sizeof(buf), "Time recording%s%s",
dte->dte_creator ? " by: " : "",
dte->dte_creator ?: "");
de = dvr_entry_create_(idnode_uuid_as_str(&dte->dte_config->dvr_id),
NULL, dte->dte_channel,
start, stop, 0, 0, title,
NULL, NULL, NULL, buf,
NULL, dte, dte->dte_pri, dte->dte_retention);
return;
fail:
dvr_timerec_purge_spawn(dte, 1);
}
/**
*
*/
dvr_timerec_entry_t *
dvr_timerec_create(const char *uuid, htsmsg_t *conf)
{
dvr_timerec_entry_t *dte;
dte = calloc(1, sizeof(*dte));
if (idnode_insert(&dte->dte_id, uuid, &dvr_timerec_entry_class, 0)) {
if (uuid)
tvhwarn("dvr", "invalid timerec entry uuid '%s'", uuid);
free(dte);
return NULL;
}
dte->dte_title = strdup("Time-%x-%R");
dte->dte_weekdays = 0x7f;
dte->dte_pri = DVR_PRIO_NORMAL;
dte->dte_start = -1;
dte->dte_stop = -1;
dte->dte_config = dvr_config_find_by_name_default(NULL);
LIST_INSERT_HEAD(&dte->dte_config->dvr_timerec_entries, dte, dte_config_link);
TAILQ_INSERT_TAIL(&timerec_entries, dte, dte_link);
idnode_load(&dte->dte_id, conf);
return dte;
}
/**
*
*/
static void
timerec_entry_destroy(dvr_timerec_entry_t *dte, int delconf)
{
dvr_timerec_purge_spawn(dte, delconf);
if (delconf)
hts_settings_remove("dvr/timerec/%s", idnode_uuid_as_str(&dte->dte_id));
TAILQ_REMOVE(&timerec_entries, dte, dte_link);
idnode_unlink(&dte->dte_id);
if(dte->dte_config != NULL)
LIST_REMOVE(dte, dte_config_link);
free(dte->dte_name);
free(dte->dte_title);
free(dte->dte_creator);
free(dte->dte_comment);
if(dte->dte_channel != NULL)
LIST_REMOVE(dte, dte_channel_link);
free(dte);
}
/**
*
*/
void
dvr_timerec_save(dvr_timerec_entry_t *dte)
{
htsmsg_t *m = htsmsg_create_map();
lock_assert(&global_lock);
idnode_save(&dte->dte_id, m);
hts_settings_save(m, "dvr/timerec/%s", idnode_uuid_as_str(&dte->dte_id));
htsmsg_destroy(m);
}
/* **************************************************************************
* DVR Autorec Entry Class definition
* **************************************************************************/
static void
dvr_timerec_entry_class_save(idnode_t *self)
{
dvr_timerec_entry_t *dte = (dvr_timerec_entry_t *)self;
dvr_timerec_save(dte);
dvr_timerec_check(dte);
}
static void
dvr_timerec_entry_class_delete(idnode_t *self)
{
timerec_entry_destroy((dvr_timerec_entry_t *)self, 1);
}
static const char *
dvr_timerec_entry_class_get_title (idnode_t *self)
{
dvr_timerec_entry_t *dte = (dvr_timerec_entry_t *)self;
const char *s = "";
if (dte->dte_name && dte->dte_name[0] != '\0')
s = dte->dte_name;
else if (dte->dte_comment && dte->dte_comment[0] != '\0')
s = dte->dte_comment;
return s;
}
static int
dvr_timerec_entry_class_channel_set(void *o, const void *v)
{
dvr_timerec_entry_t *dte = (dvr_timerec_entry_t *)o;
channel_t *ch = v ? channel_find_by_uuid(v) : NULL;
if (ch == NULL) ch = v ? channel_find_by_name(v) : NULL;
if (ch == NULL) {
if (dte->dte_channel) {
LIST_REMOVE(dte, dte_channel_link);
dte->dte_channel = NULL;
return 1;
}
} else if (dte->dte_channel != ch) {
if (dte->dte_channel)
LIST_REMOVE(dte, dte_channel_link);
dte->dte_channel = ch;
LIST_INSERT_HEAD(&ch->ch_timerecs, dte, dte_channel_link);
return 1;
}
return 0;
}
static const void *
dvr_timerec_entry_class_channel_get(void *o)
{
static const char *ret;
dvr_timerec_entry_t *dte = (dvr_timerec_entry_t *)o;
if (dte->dte_channel)
ret = idnode_uuid_as_str(&dte->dte_channel->ch_id);
else
ret = "";
return &ret;
}
static char *
dvr_timerec_entry_class_channel_rend(void *o)
{
dvr_timerec_entry_t *dte = (dvr_timerec_entry_t *)o;
if (dte->dte_channel)
return strdup(channel_get_name(dte->dte_channel));
return NULL;
}
static int
dvr_timerec_entry_class_time_set(void *o, const void *v, int *tm)
{
const char *s = v;
int t;
if(s == NULL || s[0] == '\0' || !isdigit(s[0]))
t = -1;
else if(strchr(s, ':') != NULL)
// formatted time string - convert
t = (atoi(s) * 60) + atoi(s + 3);
else {
t = atoi(s);
}
if (t >= 24 * 60)
t = -1;
if (t != *tm) {
*tm = t;
return 1;
}
return 0;
}
static int
dvr_timerec_entry_class_start_set(void *o, const void *v)
{
dvr_timerec_entry_t *dte = (dvr_timerec_entry_t *)o;
return dvr_timerec_entry_class_time_set(o, v, &dte->dte_start);
}
static int
dvr_timerec_entry_class_stop_set(void *o, const void *v)
{
dvr_timerec_entry_t *dte = (dvr_timerec_entry_t *)o;
return dvr_timerec_entry_class_time_set(o, v, &dte->dte_stop);
}
static const void *
dvr_timerec_entry_class_time_get(void *o, int tm)
{
static const char *ret;
static char buf[16];
if (tm >= 0)
snprintf(buf, sizeof(buf), "%02d:%02d", tm / 60, tm % 60);
else
strcpy(buf, "Any");
ret = buf;
return &ret;
}
static const void *
dvr_timerec_entry_class_start_get(void *o)
{
dvr_timerec_entry_t *dte = (dvr_timerec_entry_t *)o;
return dvr_timerec_entry_class_time_get(o, dte->dte_start);
}
static const void *
dvr_timerec_entry_class_stop_get(void *o)
{
dvr_timerec_entry_t *dte = (dvr_timerec_entry_t *)o;
return dvr_timerec_entry_class_time_get(o, dte->dte_stop);
}
static htsmsg_t *
dvr_timerec_entry_class_time_list(void *o)
{
return dvr_autorec_entry_class_time_list(o, "Invalid");
}
static int
dvr_timerec_entry_class_config_name_set(void *o, const void *v)
{
dvr_timerec_entry_t *dte = (dvr_timerec_entry_t *)o;
dvr_config_t *cfg = v ? dvr_config_find_by_uuid(v) : NULL;
if (cfg == NULL) cfg = v ? dvr_config_find_by_name_default(v): NULL;
if (cfg == NULL && dte->dte_config) {
dte->dte_config = NULL;
LIST_REMOVE(dte, dte_config_link);
return 1;
} else if (cfg != dte->dte_config) {
if (dte->dte_config)
LIST_REMOVE(dte, dte_config_link);
LIST_INSERT_HEAD(&cfg->dvr_timerec_entries, dte, dte_config_link);
dte->dte_config = cfg;
return 1;
}
return 0;
}
static const void *
dvr_timerec_entry_class_config_name_get(void *o)
{
static const char *buf;
dvr_timerec_entry_t *dte = (dvr_timerec_entry_t *)o;
if (dte->dte_config)
buf = idnode_uuid_as_str(&dte->dte_config->dvr_id);
else
buf = "";
return &buf;
}
static char *
dvr_timerec_entry_class_config_name_rend(void *o)
{
dvr_timerec_entry_t *dte = (dvr_timerec_entry_t *)o;
if (dte->dte_config)
return strdup(dte->dte_config->dvr_config_name);
return NULL;
}
static int
dvr_timerec_entry_class_weekdays_set(void *o, const void *v)
{
dvr_timerec_entry_t *dte = (dvr_timerec_entry_t *)o;
htsmsg_field_t *f;
uint32_t u32, bits = 0;
HTSMSG_FOREACH(f, (htsmsg_t *)v)
if (!htsmsg_field_get_u32(f, &u32) && u32 > 0 && u32 < 8)
bits |= (1 << (u32 - 1));
if (bits != dte->dte_weekdays) {
dte->dte_weekdays = bits;
return 1;
}
return 0;
}
static const void *
dvr_timerec_entry_class_weekdays_get(void *o)
{
dvr_timerec_entry_t *dte = (dvr_timerec_entry_t *)o;
return dvr_autorec_entry_class_weekdays_get(dte->dte_weekdays);
}
static htsmsg_t *
dvr_timerec_entry_class_weekdays_default(void)
{
return dvr_autorec_entry_class_weekdays_get(0x7f);
}
static char *
dvr_timerec_entry_class_weekdays_rend(void *o)
{
dvr_timerec_entry_t *dte = (dvr_timerec_entry_t *)o;
return dvr_autorec_entry_class_weekdays_rend(dte->dte_weekdays);
}
const idclass_t dvr_timerec_entry_class = {
.ic_class = "dvrtimerec",
.ic_caption = "DVR Time-Record Entry",
.ic_event = "dvrtimerec",
.ic_save = dvr_timerec_entry_class_save,
.ic_get_title = dvr_timerec_entry_class_get_title,
.ic_delete = dvr_timerec_entry_class_delete,
.ic_properties = (const property_t[]) {
{
.type = PT_BOOL,
.id = "enabled",
.name = "Enabled",
.off = offsetof(dvr_timerec_entry_t, dte_enabled),
},
{
.type = PT_STR,
.id = "name",
.name = "Name",
.off = offsetof(dvr_timerec_entry_t, dte_name),
},
{
.type = PT_STR,
.id = "title",
.name = "Title",
.off = offsetof(dvr_timerec_entry_t, dte_title),
.def.s = "Time-%x-%R",
},
{
.type = PT_STR,
.id = "channel",
.name = "Channel",
.set = dvr_timerec_entry_class_channel_set,
.get = dvr_timerec_entry_class_channel_get,
.rend = dvr_timerec_entry_class_channel_rend,
.list = channel_class_get_list,
},
{
.type = PT_STR,
.id = "start",
.name = "Start",
.set = dvr_timerec_entry_class_start_set,
.get = dvr_timerec_entry_class_start_get,
.list = dvr_timerec_entry_class_time_list,
.def.s = "12:00",
.opts = PO_SORTKEY,
},
{
.type = PT_STR,
.id = "stop",
.name = "Stop",
.set = dvr_timerec_entry_class_stop_set,
.get = dvr_timerec_entry_class_stop_get,
.list = dvr_timerec_entry_class_time_list,
.def.s = "12:00",
.opts = PO_SORTKEY,
},
{
.type = PT_U32,
.islist = 1,
.id = "weekdays",
.name = "Week Days",
.set = dvr_timerec_entry_class_weekdays_set,
.get = dvr_timerec_entry_class_weekdays_get,
.list = dvr_autorec_entry_class_weekdays_list,
.rend = dvr_timerec_entry_class_weekdays_rend,
.def.list = dvr_timerec_entry_class_weekdays_default
},
{
.type = PT_U32,
.id = "pri",
.name = "Priority",
.list = dvr_entry_class_pri_list,
.def.i = DVR_PRIO_NORMAL,
.off = offsetof(dvr_timerec_entry_t, dte_pri),
.opts = PO_SORTKEY,
},
{
.type = PT_INT,
.id = "retention",
.name = "Retention",
.off = offsetof(dvr_timerec_entry_t, dte_retention),
},
{
.type = PT_STR,
.id = "config_name",
.name = "DVR Configuration",
.set = dvr_timerec_entry_class_config_name_set,
.get = dvr_timerec_entry_class_config_name_get,
.rend = dvr_timerec_entry_class_config_name_rend,
.list = dvr_entry_class_config_name_list,
},
{
.type = PT_STR,
.id = "creator",
.name = "Creator",
.off = offsetof(dvr_timerec_entry_t, dte_creator),
.opts = PO_RDONLY,
},
{
.type = PT_STR,
.id = "comment",
.name = "Comment",
.off = offsetof(dvr_timerec_entry_t, dte_comment),
},
{}
}
};
/**
*
*/
void
dvr_timerec_init(void)
{
htsmsg_t *l, *c;
htsmsg_field_t *f;
TAILQ_INIT(&timerec_entries);
if((l = hts_settings_load("dvr/timerec")) != NULL) {
HTSMSG_FOREACH(f, l) {
if((c = htsmsg_get_map_by_field(f)) == NULL)
continue;
(void)dvr_timerec_create(f->hmf_name, c);
}
htsmsg_destroy(l);
}
}
void
dvr_timerec_done(void)
{
dvr_timerec_entry_t *dte;
pthread_mutex_lock(&global_lock);
while ((dte = TAILQ_FIRST(&timerec_entries)) != NULL)
timerec_entry_destroy(dte, 0);
pthread_mutex_unlock(&global_lock);
}
static void
dvr_timerec_timer_cb(void *aux)
{
dvr_timerec_entry_t *dte;
tvhtrace("dvr", "timerec update");
/* check all entries */
TAILQ_FOREACH(dte, &timerec_entries, dte_link)
dvr_timerec_check(dte);
/* load the timer */
gtimer_arm(&dvr_timerec_timer, dvr_timerec_timer_cb, NULL, 3550);
}
void
dvr_timerec_update(void)
{
/* check all timerec entries and load the timer */
dvr_timerec_timer_cb(NULL);
}
/**
*
*/
void
timerec_destroy_by_channel(channel_t *ch, int delconf)
{
dvr_timerec_entry_t *dte;
while((dte = LIST_FIRST(&ch->ch_timerecs)) != NULL)
timerec_entry_destroy(dte, delconf);
}
/**
*
*/
void
timerec_destroy_by_id(const char *id, int delconf)
{
dvr_timerec_entry_t *dte;
dte = dvr_timerec_find_by_uuid(id);
if (dte)
timerec_entry_destroy(dte, delconf);
}
/**
*
*/
void
timerec_destroy_by_config(dvr_config_t *kcfg, int delconf)
{
dvr_timerec_entry_t *dte;
dvr_config_t *cfg = NULL;
while((dte = LIST_FIRST(&kcfg->dvr_timerec_entries)) != NULL) {
LIST_REMOVE(dte, dte_config_link);
if (cfg == NULL && delconf)
cfg = dvr_config_find_by_name_default(NULL);
if (cfg)
LIST_INSERT_HEAD(&cfg->dvr_timerec_entries, dte, dte_config_link);
dte->dte_config = cfg;
if (delconf)
dvr_timerec_save(dte);
}
}
Reference in a new issue View git blame Copy permalink