CStdString MythProgramInfo::Title()
{
char* title = cmyth_proginfo_title(*m_proginfo_t);
CStdString retval(title);
ref_release(title);
return retval;
}
static void
parse_progs(struct myth_conn *c)
{
int i, j, count;
struct prog_map *progs;
count = cmyth_proglist_get_count(c->list);
progs = ref_alloc(sizeof(*progs)*count);
for (i=0; i<count; i++) {
cmyth_proginfo_t prog;
char *title, *subtitle;
prog = cmyth_proglist_get_item(c->list, i);
title = cmyth_proginfo_title(prog);
subtitle = cmyth_proginfo_subtitle(prog);
progs[i].prog = ref_hold(prog);
progs[i].suffix = 0;
for (j=0; j<i; j++) {
char *t, *s;
t = cmyth_proginfo_title(progs[j].prog);
s = cmyth_proginfo_subtitle(progs[j].prog);
if ((strcmp(title, t) == 0) &&
(strcmp(subtitle, s) == 0)) {
progs[i].suffix++;
}
ref_release(t);
ref_release(s);
}
ref_release(title);
ref_release(subtitle);
ref_release(prog);
}
for (i=0; i<c->nprogs; i++) {
ref_release(c->progs[i].prog);
}
ref_release(c->progs);
c->progs = progs;
}
int
cmyth_chain_switch_to_locked(cmyth_chain_t chain, int index)
{
int rc = -1;
if ((index >= 0) && (index < (int)chain->chain_count)) {
cmyth_conn_t conn;
cmyth_file_t file;
cmyth_proginfo_t prog;
char *path, *title;
if (chain->chain_list[index]->file != NULL) {
chain->chain_current = index;
return 0;
}
prog = chain->chain_list[index]->prog;
if (prog == NULL) {
return -1;
}
conn = cmyth_conn_connect_ctrl(prog->proginfo_hostname,
prog->proginfo_port,
16*1024, 4096);
if (conn == NULL) {
return -1;
}
path = cmyth_proginfo_pathname(prog);
title = cmyth_proginfo_title(prog);
cmyth_dbg(CMYTH_DBG_DEBUG, "%s(): connect to file %s [%s]\n",
__FUNCTION__, path, title);
ref_release(path);
ref_release(title);
file = cmyth_conn_connect_file(prog, conn, 128*1024, 128*1024);
if (file) {
chain->chain_current = index;
chain->chain_list[index]->file = file;
}
ref_release(conn);
rc = 0;
}
return rc;
}
CStdString MythProgramInfo::Title(bool subtitleEncoded)
{
char* title = cmyth_proginfo_title(*m_proginfo_t);
CStdString retval(title);
ref_release(title);
if (subtitleEncoded)
{
CStdString subtitle = Subtitle();
if (!subtitle.empty())
retval.Format("%s - %s", retval, subtitle);
}
return retval;
}
static int ga_all(struct path_info *info, struct stat *stbuf)
{
cmyth_conn_t control;
cmyth_proglist_t list;
int count;
int i;
pthread_mutex_lock(&mutex);
if ((i=lookup_server(info->host)) < 0) {
pthread_mutex_unlock(&mutex);
return -ENOENT;
}
control = ref_hold(conn[i].control);
if (conn[i].list == NULL) {
list = cmyth_proglist_get_all_recorded(control);
conn[i].list = list;
} else {
list = conn[i].list;
}
list = ref_hold(list);
pthread_mutex_unlock(&mutex);
stbuf->st_mode = S_IFLNK | 0444;
stbuf->st_nlink = 1;
count = cmyth_proglist_get_count(list);
debug("%s(): file '%s'\n", __FUNCTION__, info->file);
for (i=0; i<count; i++) {
cmyth_proginfo_t prog;
long long len;
char *title, *s;
char tmp[512];
prog = cmyth_proglist_get_item(list, i);
title = cmyth_proginfo_title(prog);
s = cmyth_proginfo_subtitle(prog);
snprintf(tmp, sizeof(tmp), "%s - %s.nuv", title, s);
if (strcmp(tmp, info->file) == 0) {
cmyth_timestamp_t ts;
time_t t;
char *pn;
len = cmyth_proginfo_length(prog);
pn = cmyth_proginfo_pathname(prog);
debug("%s(): file '%s' len %lld\n",
__FUNCTION__, tmp, len);
stbuf->st_size = strlen(pn) + 8;
ts = cmyth_proginfo_rec_end(prog);
t = cmyth_timestamp_to_unixtime(ts);
stbuf->st_atime = t;
stbuf->st_mtime = t;
stbuf->st_ctime = t;
ref_release(pn);
ref_release(prog);
ref_release(ts);
ref_release(title);
ref_release(s);
ref_release(control);
ref_release(list);
return 0;
}
ref_release(prog);
ref_release(title);
ref_release(s);
}
ref_release(control);
ref_release(list);
return -ENOENT;
}
static int
rd_all(struct path_info *info, void *buf, fuse_fill_dir_t filler,
off_t offset, struct fuse_file_info *fi)
{
int i;
cmyth_conn_t control;
cmyth_proglist_t list;
int count;
pthread_mutex_lock(&mutex);
if ((i=lookup_server(info->host)) < 0) {
pthread_mutex_unlock(&mutex);
return 0;
}
control = ref_hold(conn[i].control);
if (conn[i].list == NULL) {
list = cmyth_proglist_get_all_recorded(control);
conn[i].list = list;
} else {
list = conn[i].list;
}
list = ref_hold(list);
pthread_mutex_unlock(&mutex);
count = cmyth_proglist_get_count(list);
for (i=0; i<count; i++) {
cmyth_proginfo_t prog;
long long len;
char *fn, *pn, *t, *s;
struct stat st;
char tmp[512];
prog = cmyth_proglist_get_item(list, i);
pn = cmyth_proginfo_pathname(prog);
t = cmyth_proginfo_title(prog);
s = cmyth_proginfo_subtitle(prog);
len = cmyth_proginfo_length(prog);
snprintf(tmp, sizeof(tmp), "%s - %s.nuv", t, s);
fn = pn+1;
memset(&st, 0, sizeof(st));
st.st_mode = S_IFLNK | 0444;
st.st_size = strlen(pn) + 8;
debug("%s(): file '%s' len %lld\n", __FUNCTION__, fn, len);
filler(buf, tmp, &st, 0);
ref_release(prog);
ref_release(pn);
ref_release(t);
ref_release(s);
}
ref_release(control);
ref_release(list);
return 0;
}
static int myth_readlink(const char *path, char *buf, size_t size)
{
struct path_info info;
int n;
int i;
cmyth_conn_t control;
cmyth_proglist_t list;
int count;
debug("%s(): path '%s' size %lld\n", __FUNCTION__, path,
(long long)size);
memset(&info, 0, sizeof(info));
if (lookup_path(path, &info) < 0) {
return -ENOENT;
}
if (strcmp(info.dir, "all") != 0) {
return -ENOENT;
}
pthread_mutex_lock(&mutex);
if ((i=lookup_server(info.host)) < 0) {
pthread_mutex_unlock(&mutex);
return -ENOENT;
}
control = ref_hold(conn[i].control);
if (conn[i].list == NULL) {
list = cmyth_proglist_get_all_recorded(control);
conn[i].list = list;
} else {
list = conn[i].list;
}
list = ref_hold(list);
pthread_mutex_unlock(&mutex);
count = cmyth_proglist_get_count(list);
for (i=0; i<count; i++) {
cmyth_proginfo_t prog;
char tmp[512];
char *t, *s, *pn;
prog = cmyth_proglist_get_item(list, i);
t = cmyth_proginfo_title(prog);
s = cmyth_proginfo_subtitle(prog);
pn = cmyth_proginfo_pathname(prog);
snprintf(tmp, sizeof(tmp), "%s - %s.nuv", t, s);
if (strcmp(tmp, info.file) == 0) {
snprintf(tmp, sizeof(tmp), "../files%s", pn);
n = (strlen(tmp) > size) ? size : strlen(tmp);
strncpy(buf, tmp, n);
debug("%s(): link '%s' %d bytes\n", __FUNCTION__,
tmp, n);
ref_release(t);
ref_release(s);
ref_release(pn);
ref_release(prog);
ref_release(control);
ref_release(list);
return 0;
}
ref_release(t);
ref_release(s);
ref_release(pn);
ref_release(prog);
}
ref_release(control);
ref_release(list);
return -ENOENT;
}
static int
show_proglist(cmyth_proglist_t episodes, int level, int show_card)
{
int count, i;
if (episodes == NULL) {
return -1;
}
count = cmyth_proglist_get_count(episodes);
for (i=0; i<count; i++) {
char *title;
char *subtitle=NULL, *channel = NULL;
char *description=NULL, *category=NULL, *recgroup=NULL;
char *pathname=NULL;
cmyth_proginfo_t prog;
int rec;
prog = cmyth_proglist_get_item(episodes, i);
title = cmyth_proginfo_title(prog);
rec = cmyth_proginfo_check_recording(control, prog);
if (level > 2) {
subtitle = cmyth_proginfo_subtitle(prog);
channel = cmyth_proginfo_channame(prog);
}
if (level > 3) {
description = cmyth_proginfo_description(prog);
category = cmyth_proginfo_category(prog);
recgroup = cmyth_proginfo_recgroup(prog);
}
if (level > 4) {
pathname = cmyth_proginfo_pathname(prog);
}
if (channel) {
printf("\tChannel: %s\n", channel);
}
if (title) {
printf("\tTitle: %s\n", title);
if (rec > 0) {
cmyth_timestamp_t end;
char str[32];
end = cmyth_proginfo_rec_end(prog);
cmyth_timestamp_to_string(str, end);
printf("\t RECORDING on %d until %s\n",
rec, str);
ref_release(end);
}
}
if (subtitle) {
printf("\tSubtitle: %s\n", subtitle);
}
if (description) {
printf("\tDescription: %s\n", description);
}
if (category) {
printf("\tCategory: %s\n", category);
}
if (recgroup) {
printf("\tRecording Group: %s\n", recgroup);
}
if (pathname) {
printf("\tPathname: %s\n", pathname);
}
if (level > 4) {
printf("\tBytes: %lld\n",
cmyth_proginfo_length(prog));
}
if (level > 1 && show_card) {
long card = cmyth_proginfo_card_id(prog);
if (card == 0) {
printf("\tRecorder: will not record\n");
} else {
printf("\tRecorder: %ld\n", card);
}
}
ref_release(channel);
ref_release(title);
ref_release(subtitle);
ref_release(description);
ref_release(category);
ref_release(recgroup);
ref_release(pathname);
ref_release(prog);
}
ref_release(episodes);
return count;
}
static int
get_recorders(int level)
{
int i, j;
for (i=0; i<=32; i++) {
cmyth_recorder_t rec;
int state;
rec = cmyth_conn_get_recorder(control, i);
if (rec == NULL) {
continue;
}
state = cmyth_recorder_is_recording(rec);
if (state == 0) {
printf("Recorder %d is idle\n", i);
} else if (state == 1) {
cmyth_proginfo_t prog;
cmyth_timestamp_t end;
char str[32];
char *title;
prog = cmyth_recorder_get_cur_proginfo(rec);
end = cmyth_proginfo_rec_end(prog);
cmyth_timestamp_to_string(str, end);
printf("Recorder %d is recording until %s\n", i, str);
if (prog && (level > 0)) {
title = cmyth_proginfo_title(prog);
if (title) {
printf("\tTitle: %s\n",
title);
}
ref_release(title);
}
ref_release(prog);
ref_release(end);
} else {
printf("Recorder %d is in an unknown state\n", i);
}
if (level > 1) {
cmyth_chanlist_t cl;
cmyth_channel_t chan;
char *name;
cl = cmyth_recorder_get_chanlist(rec);
for (j=0; j<cmyth_chanlist_get_count(cl); j++) {
chan = cmyth_chanlist_get_item(cl, j);
name = cmyth_channel_string(chan);
printf("\tChannel: %s\n", name);
ref_release(name);
ref_release(chan);
}
ref_release(cl);
}
ref_release(rec);
}
return 0;
}
static int
rd_all(struct path_info *info, void *buf, fuse_fill_dir_t filler,
off_t offset, struct fuse_file_info *fi)
{
int i;
cmyth_conn_t control;
cmyth_proglist_t list;
int count;
struct myth_conn *mc;
pthread_mutex_lock(&mutex);
if ((i=lookup_server(info->host)) < 0) {
pthread_mutex_unlock(&mutex);
return 0;
}
control = ref_hold(conn[i].control);
if (conn[i].list == NULL) {
list = cmyth_proglist_get_all_recorded(control);
conn[i].list = list;
parse_progs(conn+i);
} else {
list = conn[i].list;
}
mc = conn+i;
list = ref_hold(list);
pthread_mutex_unlock(&mutex);
count = cmyth_proglist_get_count(list);
char *name[count];
for (i=0; i<count; i++) {
cmyth_proginfo_t prog;
long long len;
char *fn, *pn, *t, *s;
prog = cmyth_proglist_get_item(list, i);
pn = cmyth_proginfo_pathname(prog);
t = cmyth_proginfo_title(prog);
s = cmyth_proginfo_subtitle(prog);
len = cmyth_proginfo_length(prog);
if (mc->progs[i].suffix == 0) {
name[i] = ref_sprintf("%s - %s.nuv", t, s);
} else {
name[i] = ref_sprintf("%s - %s (%d).nuv", t, s,
mc->progs[i].suffix);
}
fn = pn+1;
debug("%s(): file '%s' len %lld\n", __FUNCTION__, fn, len);
filler(buf, name[i], NULL, 0);
ref_release(prog);
ref_release(pn);
ref_release(t);
ref_release(s);
}
for (i=0; i<count; i++) {
ref_release(name[i]);
}
ref_release(control);
ref_release(list);
return 0;
}
static int
rd_shows(struct path_info *info, void *buf, fuse_fill_dir_t filler,
off_t offset, struct fuse_file_info *fi)
{
int i;
cmyth_conn_t control;
cmyth_proglist_t list;
int count;
pthread_mutex_lock(&mutex);
if ((i=lookup_server(info->host)) < 0) {
pthread_mutex_unlock(&mutex);
return 0;
}
control = ref_hold(conn[i].control);
if (conn[i].list == NULL) {
list = cmyth_proglist_get_all_recorded(control);
conn[i].list = list;
} else {
list = conn[i].list;
}
list = ref_hold(list);
pthread_mutex_unlock(&mutex);
count = cmyth_proglist_get_count(list);
if(info->subdir) {
for (i=0; i<count; i++) {
cmyth_proginfo_t prog;
long long len;
char *fn, *pn, *t, *s;
struct stat st;
char tmp[512];
prog = cmyth_proglist_get_item(list, i);
t = cmyth_proginfo_title(prog);
if(strcmp(t, info->subdir) == 0) {
pn = cmyth_proginfo_pathname(prog);
s = cmyth_proginfo_subtitle(prog);
len = cmyth_proginfo_length(prog);
fn = pn+1;
snprintf(tmp, sizeof(tmp), "%s.nuv", s);
memset(&st, 0, sizeof(st));
st.st_mode = S_IFLNK | 0444;
st.st_size = strlen(pn) + 8;
debug("%s(): file '%s' len %lld\n", __FUNCTION__, fn, len);
filler(buf, tmp, &st, 0);
snprintf(tmp, sizeof(tmp), "%s.nuv.png", s);
memset(&st, 0, sizeof(st));
st.st_mode = S_IFLNK | 0444;
st.st_size = strlen(pn) + 8;
debug("%s(): file '%s' len %lld\n", __FUNCTION__, fn, len);
filler(buf, tmp, &st, 0);
ref_release(pn);
ref_release(s);
}
ref_release(prog);
ref_release(t);
}
} else {
char** seen = malloc(sizeof(char*) * count);
int seen_counter, k;
seen_counter = 0;
memset(seen, count, sizeof(char*));
for (i=0; i<count; i++) {
cmyth_proginfo_t prog;
char *t;
struct stat st;
char found;
prog = cmyth_proglist_get_item(list, i);
t = cmyth_proginfo_title(prog);
found = 0;
for(k=0; k<seen_counter; k++) {
if(strcmp(seen[k], t) == 0) {
found = 1;
break;
}
}
if(!found) {
seen[seen_counter] = strdup(t);
seen_counter++;
st.st_mode = S_IFDIR | 0555;
st.st_nlink = 2;
debug("%s(): dir '%s'\n", __FUNCTION__, t);
filler(buf, t, &st, 0);
}
ref_release(prog);
ref_release(t);
}
for(i=0; i<seen_counter; i++) {
free(seen[i]);
}
free(seen);
}
ref_release(control);
ref_release(list);
return 0;
}