stv0g/tvheadend
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

First stab at adding the DVR code back in. Very much WIP and no attempt to add clever stuff at this stage.

Browse source
This commit is contained in:
Adam Sutton 2012-05-25 16:19:29 +01:00
parent 75d18af17b
commit fc6061bb43
11 changed files with 152 additions and 174 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
src/dvb/dvb_tables.c
View file

@ -448,7 +448,7 @@ static int
dvb_eit_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
uint8_t tableid, void *opaque)
{
#if TODO
#ifdef TODO_EIT_GRABBER
service_t *t;
channel_t *ch;
th_dvb_adapter_t *tda = tdmi->tdmi_adapter;
@ -469,8 +469,6 @@ dvb_eit_callback(th_dvb_mux_instance_t *tdmi, uint8_t *ptr, int len,
char extitem[5000];
char exttext[5000];
event_t *e;
lock_assert(&global_lock);
// printf("EIT!, tid = %x\n", tableid);

23
src/dvr/dvr.h
View file

@ -124,11 +124,13 @@ typedef struct dvr_entry {
dvr_prio_t de_pri;
epg_episode_t de_episode;
uint8_t de_content_type;
uint32_t de_dont_reschedule;
/**
* EPG information / links
*/
epg_broadcast_t *de_bcast;
/**
* Major State
*/
@ -188,6 +190,8 @@ typedef struct dvr_autorec_entry {
char *dae_creator;
char *dae_comment;
// TODO: EPG linking for proper series recording
char *dae_title;
regex_t dae_title_preg;
@ -228,10 +232,10 @@ const char *dvr_entry_status(dvr_entry_t *de);
const char *dvr_entry_schedstatus(dvr_entry_t *de);
void dvr_entry_create_by_autorec(event_t *e, dvr_autorec_entry_t *dae);
void dvr_entry_create_by_autorec(epg_broadcast_t *e, dvr_autorec_entry_t *dae);
dvr_entry_t *dvr_entry_create_by_event(const char *dvr_config_name,
event_t *e, const char *creator,
epg_broadcast_t *e, const char *creator,
dvr_autorec_entry_t *dae,
dvr_prio_t pri);
@ -239,7 +243,6 @@ dvr_entry_t *dvr_entry_create(const char *dvr_config_name,
channel_t *ch, time_t start, time_t stop,
const char *title, const char *description,
const char *creator, dvr_autorec_entry_t *dae,
epg_episode_t *ee, uint8_t content_type,
dvr_prio_t pri);
dvr_entry_t *dvr_entry_update(dvr_entry_t *de, const char* de_title, int de_start, int de_stop);
@ -254,13 +257,13 @@ void dvr_rec_subscribe(dvr_entry_t *de);
void dvr_rec_unsubscribe(dvr_entry_t *de, int stopcode);
void dvr_event_replaced(event_t *e, event_t *new_e);
void dvr_event_replaced(epg_broadcast_t *e, epg_broadcast_t *new_e);
dvr_entry_t *dvr_entry_find_by_id(int id);
dvr_entry_t *dvr_entry_find_by_event(event_t *e);
dvr_entry_t *dvr_entry_find_by_event(epg_broadcast_t *e);
dvr_entry_t *dvr_entry_find_by_event_fuzzy(event_t *e);
dvr_entry_t *dvr_entry_find_by_event_fuzzy(epg_broadcast_t *e);
off_t dvr_get_filesize(dvr_entry_t *de);
@ -305,7 +308,7 @@ void dvr_autorec_add(const char *dvr_config_name,
const char *tag, uint8_t content_type,
const char *creator, const char *comment);
void dvr_autorec_check_event(event_t *e);
void dvr_autorec_check_event(epg_broadcast_t *e);
void autorec_destroy_by_channel(channel_t *ch);

28
src/dvr/dvr_autorec.c
View file

@ -62,10 +62,11 @@ dvr_autorec_purge_spawns(dvr_autorec_entry_t *dae)
* return 1 if the event 'e' is matched by the autorec rule 'dae'
*/
static int
autorec_cmp(dvr_autorec_entry_t *dae, event_t *e)
autorec_cmp(dvr_autorec_entry_t *dae, epg_broadcast_t *e)
{
channel_tag_mapping_t *ctm;
if (!e->channel || !e->channel->channel) return 0;
if(dae->dae_enabled == 0 || dae->dae_weekdays == 0)
return 0;
@ -76,33 +77,34 @@ autorec_cmp(dvr_autorec_entry_t *dae, event_t *e)
return 0; // Avoid super wildcard match
if(dae->dae_channel != NULL &&
dae->dae_channel != e->e_channel)
dae->dae_channel != e->channel->channel)
return 0;
if(dae->dae_channel_tag != NULL) {
LIST_FOREACH(ctm, &dae->dae_channel_tag->ct_ctms, ctm_tag_link)
if(ctm->ctm_channel == e->e_channel)
if(ctm->ctm_channel == e->channel->channel)
break;
if(ctm == NULL)
return 0;
}
#if TODO_GENRE_SUPPORT
if(dae->dae_content_type != 0 &&
dae->dae_content_type != e->e_content_type)
return 0;
#endif
if(dae->dae_title != NULL) {
if(e->e_title == NULL ||
regexec(&dae->dae_title_preg, e->e_title, 0, NULL, 0))
if(e->episode->title == NULL ||
regexec(&dae->dae_title_preg, e->episode->title, 0, NULL, 0))
return 0;
}
if(dae->dae_approx_time != 0) {
struct tm a_time;
struct tm ev_time;
localtime_r(&e->e_start, &a_time);
localtime_r(&e->e_start, &ev_time);
localtime_r(&e->start, &a_time);
localtime_r(&e->start, &ev_time);
a_time.tm_min = dae->dae_approx_time % 60;
a_time.tm_hour = dae->dae_approx_time / 60;
if(abs(mktime(&a_time) - mktime(&ev_time)) > 900)
@ -111,7 +113,7 @@ autorec_cmp(dvr_autorec_entry_t *dae, event_t *e)
if(dae->dae_weekdays != 0x7f) {
struct tm tm;
localtime_r(&e->e_start, &tm);
localtime_r(&e->start, &tm);
if(!((1 << ((tm.tm_wday ?: 7) - 1)) & dae->dae_weekdays))
return 0;
}
@ -489,7 +491,7 @@ dvr_autorec_add(const char *config_name,
*
*/
void
dvr_autorec_check_event(event_t *e)
dvr_autorec_check_event(epg_broadcast_t *e)
{
dvr_autorec_entry_t *dae;
dvr_entry_t *existingde;
@ -498,8 +500,8 @@ dvr_autorec_check_event(event_t *e)
if(autorec_cmp(dae, e)) {
existingde = dvr_entry_find_by_event_fuzzy(e);
if (existingde != NULL) {
tvhlog(LOG_DEBUG, "dvr", "Updating existing DVR entry for %s", e->e_title);
dvr_entry_update(existingde, e->e_title, e->e_start, e->e_stop);
tvhlog(LOG_DEBUG, "dvr", "Updating existing DVR entry for %s", e->episode->title);
dvr_entry_update(existingde, e->episode->title, e->start, e->stop);
} else
dvr_entry_create_by_autorec(e, dae);
}
@ -511,7 +513,7 @@ dvr_autorec_check_event(event_t *e)
static void
dvr_autorec_changed(dvr_autorec_entry_t *dae)
{
#if TODO_DVR
#if TODO_DVR_AUTOREC
channel_t *ch;
event_t *e;

146
src/dvr/dvr_db.c
View file

@ -30,7 +30,7 @@
#include "htsp.h"
#include "streaming.h"
//static int de_tally;
static int de_tally;
int dvr_iov_max;
@ -40,9 +40,7 @@ struct dvr_entry_list dvrentries;
static void dvr_entry_save(dvr_entry_t *de);
static void dvr_timer_expire(void *aux);
#if 0
static void dvr_timer_start_recording(void *aux);
#endif
/**
* Return printable status for a dvr entry
@ -155,7 +153,6 @@ dvr_entry_notify(dvr_entry_t *de)
/**
*
*/
#if TODO
static void
dvr_make_title(char *output, size_t outlen, dvr_entry_t *de)
{
@ -185,16 +182,11 @@ dvr_make_title(char *output, size_t outlen, dvr_entry_t *de)
}
if(cfg->dvr_flags & DVR_EPISODE_IN_TITLE) {
if(de->de_episode.ee_season && de->de_episode.ee_episode)
snprintf(output + strlen(output), outlen - strlen(output),
".S%02dE%02d",
de->de_episode.ee_season, de->de_episode.ee_episode);
else if(de->de_episode.ee_episode)
snprintf(output + strlen(output), outlen - strlen(output),
".E%02d",
de->de_episode.ee_episode);
if(de->de_bcast)
epg_episode_number_format(de->de_bcast->episode,
output + strlen(output),
outlen - strlen(output),
".", "S%02d", NULL, "E%02d", NULL);
}
if(cfg->dvr_flags & DVR_CLEAN_TITLE) {
@ -210,13 +202,10 @@ dvr_make_title(char *output, size_t outlen, dvr_entry_t *de)
}
}
}
#endif
/**
*
*/
#if TODO
static void
dvr_entry_link(dvr_entry_t *de)
{
@ -251,20 +240,17 @@ dvr_entry_link(dvr_entry_t *de)
}
htsp_dvr_entry_add(de);
}
#endif
/**
*
* Create the event
*/
dvr_entry_t *
dvr_entry_create(const char *config_name,
channel_t *ch, time_t start, time_t stop,
const char *title, const char *description,
const char *creator, dvr_autorec_entry_t *dae,
epg_episode_t *ee, uint8_t content_type, dvr_prio_t pri)
static dvr_entry_t *_dvr_entry_create (
const char *config_name, epg_broadcast_t *e,
channel_t *ch, time_t start, time_t stop,
const char *title, const char *description,
const char *creator, dvr_autorec_entry_t *dae,
dvr_prio_t pri)
{
#if TODO
dvr_entry_t *de;
char tbuf[30];
struct tm tm;
@ -297,14 +283,9 @@ dvr_entry_create(const char *config_name,
de->de_title = strdup(title);
de->de_desc = description ? strdup(description) : NULL;
if(ee != NULL) {
de->de_episode.ee_season = ee->ee_season;
de->de_episode.ee_episode = ee->ee_episode;
de->de_episode.ee_part = ee->ee_part;
tvh_str_set(&de->de_episode.ee_onscreen, ee->ee_onscreen);
}
#if TODO_GENRE_SUPPORT
de->de_content_type = content_type;
#endif
dvr_entry_link(de);
@ -324,52 +305,40 @@ dvr_entry_create(const char *config_name,
dvrdb_changed();
dvr_entry_save(de);
return de;
#endif
return NULL;
}
/**
*
*/
#if TODO
static const char *
longest_string(const char *a, const char *b)
{
if(b == NULL)
return a;
if(a == NULL)
return b;
return strlen(a) > strlen(b) ? a : b;
}
#endif
/**
*
*/
dvr_entry_t *
dvr_entry_create_by_event(const char *config_name,
event_t *e, const char *creator,
dvr_autorec_entry_t *dae, dvr_prio_t pri)
dvr_entry_create(const char *config_name,
channel_t *ch, time_t start, time_t stop,
const char *title, const char *description,
const char *creator, dvr_autorec_entry_t *dae, dvr_prio_t pri)
{
#if TODO
const char *desc = NULL;
if(e->e_channel == NULL || e->e_title == NULL)
return _dvr_entry_create(config_name, NULL,
ch, start, stop, title, description,
creator, dae, pri);
}
/**
*
*/
dvr_entry_t *
dvr_entry_create_by_event(const char *config_name,
epg_broadcast_t *e, const char *creator,
dvr_autorec_entry_t *dae, dvr_prio_t pri)
{
if(e->channel == NULL || e->channel->channel || e->episode->title == NULL)
return NULL;
// Try to find best description
desc = longest_string(e->e_desc, e->e_ext_desc);
desc = longest_string(desc, e->e_ext_item);
desc = longest_string(desc, e->e_ext_text);
return dvr_entry_create(config_name,
e->e_channel, e->e_start, e->e_stop,
e->e_title, desc, creator, dae, &e->e_episode,
e->e_content_type, pri);
#endif
return NULL;
return _dvr_entry_create(config_name, e,
e->channel->channel, e->start, e->stop,
e->episode->title,
e->episode->description ? e->episode->description
: e->episode->summary,
creator, dae, pri);
}
@ -377,7 +346,7 @@ dvr_entry_create_by_event(const char *config_name,
*
*/
void
dvr_entry_create_by_autorec(event_t *e, dvr_autorec_entry_t *dae)
dvr_entry_create_by_autorec(epg_broadcast_t *e, dvr_autorec_entry_t *dae)
{
char buf[200];
@ -396,7 +365,6 @@ dvr_entry_create_by_autorec(event_t *e, dvr_autorec_entry_t *dae)
void
dvr_entry_dec_ref(dvr_entry_t *de)
{
#if TODO
lock_assert(&global_lock);
if(de->de_refcnt > 1) {
@ -413,10 +381,7 @@ dvr_entry_dec_ref(dvr_entry_t *de)
free(de->de_ititle);
free(de->de_desc);
free(de->de_episode.ee_onscreen);
free(de);
#endif
}
@ -653,19 +618,24 @@ dvr_entry_update(dvr_entry_t *de, const char* de_title, int de_start, int de_sto
/**
* Used to notify the DVR that an event has been replaced in the EPG
*
* TODO: I think this will record the title slot event if its now a
* completely different episode etc...
*/
void
dvr_event_replaced(event_t *e, event_t *new_e)
dvr_event_replaced(epg_broadcast_t *e, epg_broadcast_t *new_e)
{
dvr_entry_t *de, *ude;
if ( e == new_e ) return;
de = dvr_entry_find_by_event(e);
if (de != NULL) {
ude = dvr_entry_find_by_event_fuzzy(new_e);
if (ude == NULL && de->de_sched_state == DVR_SCHEDULED)
dvr_entry_cancel(de);
else if(new_e->e_title != NULL)
dvr_entry_update(de, new_e->e_title, new_e->e_start, new_e->e_stop);
else if(new_e->episode->title != NULL)
dvr_entry_update(de, new_e->episode->title, new_e->start, new_e->stop);
// TODO: need to actually replace the event?
}
@ -701,20 +671,17 @@ dvr_stop_recording(dvr_entry_t *de, int stopcode)
/**
*
*/
#if TODO
static void
dvr_timer_stop_recording(void *aux)
{
dvr_stop_recording(aux, 0);
}
#endif
/**
*
*/
#if 0
static void
dvr_timer_start_recording(void *aux)
{
@ -733,7 +700,6 @@ dvr_timer_start_recording(void *aux)
gtimer_arm_abs(&de->de_timer, dvr_timer_stop_recording, de,
de->de_stop + (60 * de->de_stop_extra));
}
#endif
/**
@ -754,14 +720,12 @@ dvr_entry_find_by_id(int id)
*
*/
dvr_entry_t *
dvr_entry_find_by_event(event_t *e)
dvr_entry_find_by_event(epg_broadcast_t *e)
{
dvr_entry_t *de;
LIST_FOREACH(de, &e->e_channel->ch_dvrs, de_channel_link)
if(de->de_start == e->e_start &&
de->de_stop == e->e_stop)
return de;
LIST_FOREACH(de, &e->channel->channel->ch_dvrs, de_channel_link)
if(de->de_bcast == e) return de;
return NULL;
}
@ -769,15 +733,15 @@ dvr_entry_find_by_event(event_t *e)
* Find dvr entry using 'fuzzy' search
*/
dvr_entry_t *
dvr_entry_find_by_event_fuzzy(event_t *e)
dvr_entry_find_by_event_fuzzy(epg_broadcast_t *e)
{
dvr_entry_t *de;
if (e->e_title == NULL)
if (e->episode->title == NULL)
return NULL;
LIST_FOREACH(de, &e->e_channel->ch_dvrs, de_channel_link)
if ((abs(de->de_start - e->e_start) < 600) && (abs(de->de_stop - e->e_stop) < 600)) {
LIST_FOREACH(de, &e->channel->channel->ch_dvrs, de_channel_link)
if ((abs(de->de_start - e->start) < 600) && (abs(de->de_stop - e->stop) < 600)) {
return de;
}
return NULL;

39
src/dvr/mkmux.c
View file

@ -441,6 +441,7 @@ build_tag_string(const char *name, const char *value,
/**
*
*/
#if TODO_EP_NUMBER
static htsbuf_queue_t *
build_tag_int(const char *name, int value,
int targettype, const char *targettypename)
@ -449,6 +450,7 @@ build_tag_int(const char *name, int value,
snprintf(str, sizeof(str), "%d", value);
return build_tag_string(name, str, targettype, targettypename);
}
#endif
/**
@ -470,7 +472,7 @@ mk_build_metadata(const dvr_entry_t *de)
htsbuf_queue_t *q = htsbuf_queue_alloc(0);
char datestr[64];
struct tm tm;
#if TODO
#if TODO_GENRE_SUPPORT
const char *ctype;
#endif
localtime_r(&de->de_start, &tm);
@ -489,7 +491,7 @@ mk_build_metadata(const dvr_entry_t *de)
addtag(q, build_tag_string("ORIGINAL_MEDIA_TYPE", "TV", 0, NULL));
#if TODO
#if TODO_GENRE_SUPPORT
if(de->de_content_type) {
ctype = epg_content_group_get_name(de->de_content_type);
if(ctype != NULL)
@ -500,7 +502,7 @@ mk_build_metadata(const dvr_entry_t *de)
if(de->de_channel != NULL)
addtag(q, build_tag_string("TVCHANNEL", de->de_channel->ch_name, 0, NULL));
#if TODO
#if TODO_EP_NUMBER
if(de->de_episode.ee_onscreen)
addtag(q, build_tag_string("SYNOPSIS",
de->de_episode.ee_onscreen, 0, NULL));
@ -509,7 +511,7 @@ mk_build_metadata(const dvr_entry_t *de)
if(de->de_desc != NULL)
addtag(q, build_tag_string("SUMMARY", de->de_desc, 0, NULL));
#if TODO
#if TODO_EP_NUMBER
if(de->de_episode.ee_season)
addtag(q, build_tag_int("PART_NUMBER", de->de_episode.ee_season,
60, "SEASON"));
@ -528,15 +530,16 @@ mk_build_metadata(const dvr_entry_t *de)
static htsbuf_queue_t *
mk_build_metadata2(const event_t *e)
mk_build_metadata2(const epg_broadcast_t *e)
{
htsbuf_queue_t *q = htsbuf_queue_alloc(0);
epg_episode_t *ee = e->episode;
char datestr[64];
struct tm tm;
#if TODO
#if TODO_GENRE_SUPPORT
const char *ctype;
#endif
localtime_r(&e->e_start, &tm);
localtime_r(&e->start, &tm);
snprintf(datestr, sizeof(datestr),
"%04d-%02d-%02d %02d:%02d:%02d",
@ -552,7 +555,7 @@ mk_build_metadata2(const event_t *e)
addtag(q, build_tag_string("ORIGINAL_MEDIA_TYPE", "TV", 0, NULL));
#if TODO
#if TODO_GENRE_SUPPORT
if(e->e_content_type) {
ctype = epg_content_group_get_name(e->e_content_type);
if(ctype != NULL)
@ -560,19 +563,22 @@ mk_build_metadata2(const event_t *e)
}
#endif
if(e->e_channel != NULL)
addtag(q, build_tag_string("TVCHANNEL", e->e_channel->ch_name, 0, NULL));
if(e->channel->channel != NULL)
addtag(q, build_tag_string("TVCHANNEL", e->channel->channel->ch_name, 0, NULL));
if(e->e_title != NULL)
addtag(q, build_tag_string("TITLE", e->e_title, 0, NULL));
if(ee->title != NULL)
addtag(q, build_tag_string("TITLE", ee->title, 0, NULL));
if(ee->description)
addtag(q, build_tag_string("SUMMARY", ee->description, 0, NULL));
else if(ee->summary)
addtag(q, build_tag_string("SUMMARY", ee->summary, 0, NULL));
#if TODO_EP_NUMBER
if(e->e_episode.ee_onscreen)
addtag(q, build_tag_string("SYNOPSIS",
e->e_episode.ee_onscreen, 0, NULL));
if(e->e_desc != NULL)
addtag(q, build_tag_string("SUMMARY", e->e_desc, 0, NULL));
if(e->e_episode.ee_season)
addtag(q, build_tag_int("PART_NUMBER", e->e_episode.ee_season,
60, "SEASON"));
@ -584,6 +590,7 @@ mk_build_metadata2(const event_t *e)
if(e->e_episode.ee_part)
addtag(q, build_tag_int("PART_NUMBER", e->e_episode.ee_part,
40, "PART"));
#endif
return q;
}
@ -796,7 +803,7 @@ mk_close_cluster(mk_mux_t *mkm)
*
*/
int
mk_mux_append_meta(mk_mux_t *mkm, event_t *e)
mk_mux_append_meta(mk_mux_t *mkm, epg_broadcast_t *e)
{
htsbuf_queue_t q;

2
src/dvr/mkmux.h
View file

@ -38,7 +38,7 @@ mk_mux_t *mk_mux_stream_create(int fd,
int mk_mux_write_pkt(mk_mux_t *mkm, struct th_pkt *pkt);
int mk_mux_append_meta(mk_mux_t *mkm, struct event *e);
int mk_mux_append_meta(mk_mux_t *mkm, struct epg_broadcast *e);
void mk_mux_close(mk_mux_t *mk_mux);

25
src/epg.c
View file

@ -815,17 +815,26 @@ static void _epg_episode_rem_broadcast
RB_REMOVE(&episode->broadcasts, broadcast, elink);
}
int epg_episode_get_number_onscreen
( epg_episode_t *episode, char *buf, int len )
size_t epg_episode_number_format
( epg_episode_t *episode, char *buf, size_t len,
const char *pre, const char *sfmt,
const char *sep, const char *efmt,
const char *cfmt )
{
int i = 0;
size_t i = 0;
if ( episode->number ) {
// TODO: add counts
if ( episode->season && episode->season->number ) {
i += snprintf(&buf[i], len-i, "Season %d ",
episode->season->number);
if (pre) i += snprintf(&buf[i], len-i, "%s", pre);
if ( sfmt && episode->season && episode->season->number ) {
i += snprintf(&buf[i], len-i, sfmt, episode->season->number);
if ( cfmt && episode->brand && episode->brand->season_count )
i += snprintf(&buf[i], len-i, cfmt,
episode->brand->season_count);
if (sep) i += snprintf(&buf[i], len-i, "%s", sep);
}
i += snprintf(&buf[i], len-i, "Episode %d", episode->number);
i += snprintf(&buf[i], len-i, efmt, episode->number);
if ( cfmt && episode->season && episode->season->episode_count)
i+= snprintf(&buf[i], len-i, cfmt, episode->season->episode_count);
}
return i;
}

20
src/epg.h
View file

@ -200,8 +200,21 @@ int epg_episode_set_brand ( epg_episode_t *e, epg_brand_t *b )
int epg_episode_set_season ( epg_episode_t *e, epg_season_t *s )
__attribute__((warn_unused_result));
/* Acessors */
int epg_episode_get_number_onscreen ( epg_episode_t *e, char *b, int c );
/* EpNum format helper */
// output string will be:
// if (episode_num)
// ret = pre
// if (season_num) ret += sprintf(sfmt, season_num)
// if (season_cnt && cnt) ret += sprintf(cnt, season_cnt)
// ret += sep
// ret += sprintf(efmt, episode_num)
// if (episode_cnt) ret += sprintf(cfmt, episode_cnt)
// and will return num chars written
size_t epg_episode_number_format
( epg_episode_t *e, char *buf, size_t len,
const char *pre, const char *sfmt,
const char *sep, const char *efmt,
const char *cfmt );
/* Serialization */
htsmsg_t *epg_episode_serialize ( epg_episode_t *b );
@ -342,7 +355,8 @@ void epg_updated (void);
* Compatibility code
* ***********************************************************************/
#ifndef TODO_REMOVE_EPG_COMPAT
//#define TODO_EPG_COMPAT
#ifdef TODO_EPG_COMPAT
typedef struct _epg_episode {

2
src/tvheadend.h
View file

@ -104,8 +104,6 @@ LIST_HEAD(th_subscription_list, th_subscription);
RB_HEAD(channel_tree, channel);
TAILQ_HEAD(channel_queue, channel);
LIST_HEAD(channel_list, channel);
LIST_HEAD(event_list, event);
RB_HEAD(event_tree, event);
LIST_HEAD(dvr_config_list, dvr_config);
LIST_HEAD(dvr_entry_list, dvr_entry);
TAILQ_HEAD(ref_update_queue, ref_update);

35
src/webui/extjs.c
View file

@ -728,19 +728,8 @@ extjs_epg(http_connection_t *hc, const char *remain, void *opaque)
else if(ee->summary != NULL)
htsmsg_add_str(m, "description", ee->summary);
if (epg_episode_get_number_onscreen(ee, buf, 100))
htsmsg_add_str(m, "episode", strdup(buf));
#if TODO_REMOVE_THIS_QQ
if(e->e_ext_desc != NULL)
htsmsg_add_str(m, "ext_desc", e->e_ext_desc);
if(e->e_ext_item != NULL)
htsmsg_add_str(m, "ext_item", e->e_ext_item);
if(e->e_ext_text != NULL)
htsmsg_add_str(m, "ext_text", e->e_ext_text);
#endif
if (epg_episode_number_format(ee, buf, 100, NULL, "Season %d", ".", "Episode %d", "/%d"))
htsmsg_add_str(m, "episode", buf);
htsmsg_add_u32(m, "id", e->_.id);
htsmsg_add_u32(m, "start", e->start);
@ -752,11 +741,9 @@ extjs_epg(http_connection_t *hc, const char *remain, void *opaque)
htsmsg_add_str(m, "contentgrp", s);
#endif
#if TODO_UPDATE_DVR_CODE
dvr_entry_t *de;
if((de = dvr_entry_find_by_event(e)) != NULL)
htsmsg_add_str(m, "schedstate", dvr_entry_schedstatus(de));
#endif
htsmsg_add_msg(array, NULL, m);
}
@ -824,8 +811,8 @@ extjs_epgrelated(http_connection_t *hc, const char *remain, void *opaque)
htsmsg_add_str(m, "uri", ee2->_.uri);
htsmsg_add_str(m, "title", ee2->title);
if (ee2->subtitle) htsmsg_add_str(m, "title", ee2->subtitle);
if (epg_episode_get_number_onscreen(ee2, buf, 100))
htsmsg_add_str(m, "episode", strdup(buf));
if (epg_episode_number_format(ee, buf, 100, NULL, "Season %d", ".", "Episode %d", "/%d"))
htsmsg_add_str(m, "episode", buf);
htsmsg_add_msg(array, NULL, m);
}
} else if (ee->season) {
@ -837,8 +824,8 @@ extjs_epgrelated(http_connection_t *hc, const char *remain, void *opaque)
htsmsg_add_str(m, "uri", ee2->_.uri);
htsmsg_add_str(m, "title", ee2->title);
if (ee2->subtitle) htsmsg_add_str(m, "title", ee2->subtitle);
if (epg_episode_get_number_onscreen(ee2, buf, 100))
htsmsg_add_str(m, "episode", strdup(buf));
if (epg_episode_number_format(ee, buf, 100, NULL, "Season %d", ".", "Episode %d", "/%d"))
htsmsg_add_str(m, "episode", buf);
htsmsg_add_msg(array, NULL, m);
}
}
@ -864,11 +851,11 @@ extjs_dvr(http_connection_t *hc, const char *remain, void *opaque)
htsbuf_queue_t *hq = &hc->hc_reply;
const char *op = http_arg_get(&hc->hc_req_args, "op");
htsmsg_t *out, *r;
//TODO:event_t *e;
dvr_entry_t *de;
const char *s;
int flags = 0;
dvr_config_t *cfg;
epg_broadcast_t *e;
if(op == NULL)
op = "loadSettings";
@ -882,11 +869,10 @@ extjs_dvr(http_connection_t *hc, const char *remain, void *opaque)
if(!strcmp(op, "recordEvent")) {
#if TODO_DVR
const char *config_name = http_arg_get(&hc->hc_req_args, "config_name");
s = http_arg_get(&hc->hc_req_args, "eventId");
if((e = epg_event_find_by_id(atoi(s))) == NULL) {
if((e = epg_broadcast_find_by_id(atoi(s), NULL)) == NULL) {
pthread_mutex_unlock(&global_lock);
return HTTP_STATUS_BAD_REQUEST;
}
@ -906,7 +892,6 @@ extjs_dvr(http_connection_t *hc, const char *remain, void *opaque)
dvr_entry_create_by_event(config_name,
e, hc->hc_representative, NULL, DVR_PRIO_NORMAL);
#endif
out = htsmsg_create_map();
htsmsg_add_u32(out, "success", 1);
@ -990,13 +975,13 @@ extjs_dvr(http_connection_t *hc, const char *remain, void *opaque)
dvr_entry_create(config_name,
ch, start, stop, title, NULL, hc->hc_representative,
NULL, NULL, 0, dvr_pri2val(pri));
NULL, dvr_pri2val(pri));
out = htsmsg_create_map();
htsmsg_add_u32(out, "success", 1);
} else if(!strcmp(op, "createAutoRec")) {
#if TODO_DVR
#if TODO_DVR_AUTOREC
const char *cgrp = http_arg_get(&hc->hc_req_args, "contentgrp");

2
src/webui/simpleui.c
View file

@ -209,7 +209,6 @@ page_einfo(http_connection_t *hc, const char *remain, void *opaque)
return 404;
}
#if TODO_DVR
de = dvr_entry_find_by_event(e);
if((http_arg_get(&hc->hc_req_args, "rec")) != NULL) {
@ -218,7 +217,6 @@ page_einfo(http_connection_t *hc, const char *remain, void *opaque)
} else if(de != NULL && (http_arg_get(&hc->hc_req_args, "cancel")) != NULL) {
de = dvr_entry_cancel(de);
}
#endif
htsbuf_qprintf(hq, "<html>");
htsbuf_qprintf(hq, "<body>");