void ices_metadata_set(const char* artist, const char* title) {
ices_util_free(Artist);
Artist = NULL;
ices_util_free(Title);
Title = NULL;
if (artist && *artist)
Artist = ices_util_strdup(artist);
if (title && *title)
Title = ices_util_strdup(title);
}
/* Place hardcoded defaults into an ices_stream_t object */
void
ices_setup_parse_stream_defaults (ices_stream_t* stream)
{
stream->conn = NULL;
stream->host = ices_util_strdup (ICES_DEFAULT_HOST);
stream->port = ICES_DEFAULT_PORT;
stream->password = ices_util_strdup (ICES_DEFAULT_PASSWORD);
stream->protocol = ICES_DEFAULT_PROTOCOL;
stream->mount = ices_util_strdup (ICES_DEFAULT_MOUNT);
stream->dumpfile = NULL;
stream->name = ices_util_strdup (ICES_DEFAULT_NAME);
stream->genre = ices_util_strdup (ICES_DEFAULT_GENRE);
stream->description = ices_util_strdup (ICES_DEFAULT_DESCRIPTION);
stream->url = ices_util_strdup (ICES_DEFAULT_URL);
stream->ispublic = ICES_DEFAULT_ISPUBLIC;
stream->bitrate = ICES_DEFAULT_BITRATE;
stream->reencode = ICES_DEFAULT_REENCODE;
stream->out_numchannels = -1;
stream->out_samplerate = -1;
stream->encoder_state = NULL;
stream->connect_delay = 0;
stream->next = NULL;
}
/* Function for placing hardcoded defaults in the
* options object (ices_config) */
static void
ices_setup_parse_defaults (ices_config_t *ices_config)
{
ices_config->configfile = ices_util_strdup (ICES_DEFAULT_CONFIGFILE);
ices_config->daemon = ICES_DEFAULT_DAEMON;
ices_config->base_directory = ices_util_strdup (ICES_DEFAULT_BASE_DIRECTORY);
ices_config->verbose = ICES_DEFAULT_VERBOSE;
ices_config->reencode = 0;
ices_config->pm.playlist_file =
ices_util_strdup (ICES_DEFAULT_PLAYLIST_FILE);
ices_config->pm.module = ices_util_strdup (ICES_DEFAULT_MODULE);
ices_config->pm.randomize = ICES_DEFAULT_RANDOMIZE_PLAYLIST;
ices_config->pm.playlist_type = ICES_DEFAULT_PLAYLIST_TYPE;
ices_config->streams = (ices_stream_t*) malloc (sizeof (ices_stream_t));
ices_setup_parse_stream_defaults (ices_config->streams);
}
/* Call python function to get next file to play */
char *
interpreter_playlist_python_get_next (void)
{
PyObject *res = (PyObject *)interpreter_python_eval_function ("ices_python_get_next");
if (res && PyString_Check (res))
return ices_util_strdup (PyString_AsString (res));
ices_log_error ("Execution of 'ices_python_get_next()' in ices.py failed");
return NULL;
}
void ices_metadata_set_file(const char* filename) {
char buf[1024];
ices_util_free(Filename);
Filename = NULL;
if (filename && *filename) {
metadata_clean_filename(filename, buf, sizeof(buf));
Filename = ices_util_strdup(buf);
}
}
/* Call python function to get next file to play */
static char *playlist_python_get_next(void) {
PyObject* res;
char* rc = NULL;
if ((res = python_eval(pl_get_next_hook)) && PyString_Check(res))
rc = ices_util_strdup(PyString_AsString(res));
else
ices_log_error("ices_get_next failed");
Py_XDECREF(res);
return rc;
}
/*
* Here be magic...
* man perlcall gave me the following steps, to be
* able to handle getting return values from the
* embedded perl calls.
*/
static char*pl_perl_eval(const char *functionname) {
int retcount = 0;
char *retstr = NULL;
dSP; /* initialize stack pointer */
ices_log_debug("Interpreting [%s]", functionname);
ENTER; /* everything created after here */
SAVETMPS; /* ...is a temporary variable. */
PUSHMARK(SP); /* remember the stack pointer */
PUTBACK; /* make local stack pointer global */
/* G_SCALAR: get a scalar return | G_EVAL: Trap errors */
retcount = perl_call_pv(functionname, G_SCALAR | G_EVAL);
SPAGAIN; /* refresh stack pointer */
/* Check for errors in execution */
if (SvTRUE(ERRSV)) {
STRLEN n_a;
ices_log_debug("perl error: %s", SvPV(ERRSV, n_a));
(void) POPs;
} else if (retcount) {
/* we're calling strdup here, free() this later! */
retstr = ices_util_strdup(POPp); /* pop the return value from stack */
ices_log_debug("perl [%s] returned %d values, last [%s]", functionname, retcount, retstr);
} else
ices_log_debug("Perl call returned nothing");
PUTBACK;
FREETMPS; /* free that return value */
LEAVE; /* ...and the XPUSHed "mortal" args.*/
ices_log_debug("Done interpreting [%s]", functionname);
return retstr;
}
/* Mutator for the cue filename */
void
ices_cue_set_filename (const char *filename)
{
ices_cue_filename = ices_util_strdup (filename);
}
ssize_t
id3v2_read_frame (input_stream_t* source, id3v2_tag* tag)
{
char hdr[10];
size_t len, len2;
ssize_t rlen;
char* buf;
if (source->read (source, hdr, ID3V2_FRAME_LEN(tag)) != ID3V2_FRAME_LEN(tag)) {
ices_log ("Error reading ID3v2 frame");
return -1;
}
tag->pos += ID3V2_FRAME_LEN(tag);
if (hdr[0] == '\0')
return 0;
if (tag->major_version < 3) {
len = id3v2_decode_synchsafe3 (hdr + 3);
hdr[3] = '\0';
} else if (tag->major_version == 3) {
len = id3v2_decode_unsafe (hdr + 4);
hdr[4] = '\0';
} else {
len = id3v2_decode_synchsafe (hdr + 4);
hdr[4] = '\0';
}
if (len > tag->len - tag->pos) {
ices_log ("Error parsing ID3v2 frame header: Frame too large (%d bytes)", len);
return -1;
}
/* ices_log_debug("ID3v2: Frame type [%s] found, %d bytes", hdr, len); */
if (!strcmp (hdr, ID3V2_ARTIST_TAG(tag)) || !strcmp (hdr, ID3V2_TITLE_TAG(tag))) {
if (! (buf = malloc(len+1))) {
ices_log ("Error allocating memory while reading ID3v2 frame");
return -1;
}
len2 = len;
while (len2) {
if ((rlen = source->read (source, buf, len)) < 0) {
ices_log ("Error reading ID3v2 frame data");
free (buf);
return -1;
}
tag->pos += rlen;
len2 -= rlen;
}
/* skip encoding */
if (!strcmp (hdr, ID3V2_TITLE_TAG(tag))) {
buf[len] = '\0';
ices_log_debug ("ID3v2: Title found: %s", buf + 1);
tag->title = ices_util_strdup (buf + 1);
} else {
buf[len] = '\0';
ices_log_debug ("ID3v2: Artist found: %s", buf + 1);
tag->artist = ices_util_strdup (buf + 1);
}
free (buf);
} else if (id3v2_skip_data (source, tag, len))
return -1;
return len + ID3V2_FRAME_LEN(tag);
}
