static void
gst_shout2send_set_metadata (GstShout2send * shout2send)
{
const GstTagList *user_tags;
GstTagList *copy;
char *tempmetadata;
shout_metadata_t *pmetadata;
g_return_if_fail (shout2send != NULL);
user_tags = gst_tag_setter_get_tag_list (GST_TAG_SETTER (shout2send));
if ((shout2send->tags == NULL) && (user_tags == NULL)) {
return;
}
copy = gst_tag_list_merge (user_tags, shout2send->tags,
gst_tag_setter_get_tag_merge_mode (GST_TAG_SETTER (shout2send)));
/* lets get the artist and song tags */
tempmetadata = NULL;
gst_tag_list_foreach ((GstTagList *) copy, set_shout_metadata,
(gpointer) & tempmetadata);
if (tempmetadata) {
pmetadata = shout_metadata_new ();
shout_metadata_add (pmetadata, "song", tempmetadata);
shout_set_metadata (shout2send->conn, pmetadata);
shout_metadata_free (pmetadata);
}
gst_tag_list_unref (copy);
}
void Shouter::do_refresh_metadata() {
shout_metadata_t* metadata = shout_metadata_new();
if(metadata != NULL) {
std::string title = source->get_metadata("title");
std::string artist = source->get_metadata("artist");
std::string length = source->get_metadata("length");
std::string album = source->get_metadata("album");
if(album.empty())
album="NO ALBUM";
if(title.empty())
title="NO TITLE";
if(artist.empty())
artist="NO ARTIST";
std::string song = album + " - " + title + " - " + artist;
shout_metadata_add(metadata,"song", song.c_str());
shout_set_metadata(shout,metadata);
std::cout << "song: " << song << "\n";
shout_metadata_free(metadata);
}
}
static void _setSong() {
shout_metadata_t *metadata = NULL;
if (song == NULL) {
return;
}
metadata = shout_metadata_new();
if (!metadata) {
printf("Failed to allocate MD\n");
exit(1);
}
if (shout_metadata_add(metadata, "song", song) != SHOUTERR_SUCCESS) {
printf("Failed to set MD\n");
exit(1);
}
if (shout_set_metadata(shout, metadata) != SHOUTERR_SUCCESS) {
printf("Failed to associate MD\n");
exit(1);
}
shout_metadata_free(metadata);
}
static PyObject* pshoutobj_set_metadata(ShoutObject* self, PyObject* args) {
shout_metadata_t* metadata;
PyObject* dict;
PyObject* key;
PyObject* val;
const char* skey;
const char* sval;
int i = 0;
int rc;
if (!(metadata = shout_metadata_new())) {
PyErr_NoMemory();
return NULL;
}
if (!PyArg_ParseTuple(args, "O!", &PyDict_Type, &dict))
return NULL;
while (PyDict_Next(dict, &i, &key, &val)) {
if (!PyString_Check(key)) {
PyErr_SetString(PyExc_TypeError, "Dictionary key must be string");
shout_metadata_free(metadata);
return NULL;
}
if (!PyString_Check(val)) {
PyErr_SetString(PyExc_TypeError, "Dictionary value must be string");
shout_metadata_free(metadata);
return NULL;
}
skey = PyString_AsString(key);
sval = PyString_AsString(val);
if ((rc = shout_metadata_add(metadata, skey, sval)) != SHOUTERR_SUCCESS) {
if (rc == SHOUTERR_MALLOC)
PyErr_NoMemory();
else if (rc == SHOUTERR_INSANE)
PyErr_SetString(PyExc_TypeError, "Dictionary key must not be empty");
shout_metadata_free(metadata);
return NULL;
}
}
rc = shout_set_metadata(self->conn, metadata);
shout_metadata_free(metadata);
if (rc != SHOUTERR_SUCCESS) {
PyErr_SetString(ShoutError, "Metadata not supported in this connection");
return NULL;
}
return Py_BuildValue("i", 1);
}
static struct shout_data *new_shout_data(void)
{
struct shout_data *ret = g_new(struct shout_data, 1);
ret->shout_conn = shout_new();
ret->shout_meta = shout_metadata_new();
ret->bitrate = -1;
ret->quality = -2.0;
ret->timeout = DEFAULT_CONN_TIMEOUT;
return ret;
}
EngineShoutcast::EngineShoutcast(ConfigObject<ConfigValue>* _config)
: m_pTextCodec(NULL),
m_pMetaData(),
m_pShout(NULL),
m_pShoutMetaData(NULL),
m_iMetaDataLife(0),
m_iShoutStatus(0),
m_iShoutFailures(0),
m_pConfig(_config),
m_encoder(NULL),
m_pShoutcastNeedUpdateFromPrefs(NULL),
m_pUpdateShoutcastFromPrefs(NULL),
m_pMasterSamplerate(new ControlObjectSlave("[Master]", "samplerate")),
m_pShoutcastStatus(new ControlObject(ConfigKey(SHOUTCAST_PREF_KEY, "status"))),
m_bQuit(false),
m_custom_metadata(false),
m_firstCall(false),
m_format_is_mp3(false),
m_format_is_ov(false),
m_protocol_is_icecast1(false),
m_protocol_is_icecast2(false),
m_protocol_is_shoutcast(false),
m_ogg_dynamic_update(false) {
#ifndef __WINDOWS__
// Ignore SIGPIPE signals that we get when the remote streaming server
// disconnects.
signal(SIGPIPE, SIG_IGN);
#endif
m_pShoutcastStatus->set(SHOUTCAST_DISCONNECTED);
m_pShoutcastNeedUpdateFromPrefs = new ControlObject(
ConfigKey(SHOUTCAST_PREF_KEY,"update_from_prefs"));
m_pUpdateShoutcastFromPrefs = new ControlObjectSlave(
m_pShoutcastNeedUpdateFromPrefs->getKey());
// Initialize libshout
shout_init();
if (!(m_pShout = shout_new())) {
errorDialog(tr("Mixxx encountered a problem"), tr("Could not allocate shout_t"));
return;
}
if (!(m_pShoutMetaData = shout_metadata_new())) {
errorDialog(tr("Mixxx encountered a problem"), tr("Could not allocate shout_metadata_t"));
return;
}
if (shout_set_nonblocking(m_pShout, 1) != SHOUTERR_SUCCESS) {
errorDialog(tr("Error setting non-blocking mode:"), shout_get_error(m_pShout));
return;
}
}
static gboolean
gst_shout2send_connect (GstShout2send * sink)
{
const char *format =
(sink->audio_format == SHOUT_FORMAT_VORBIS) ? "vorbis" :
((sink->audio_format == SHOUT_FORMAT_MP3) ? "mp3" : "unknown");
#ifdef SHOUT_FORMAT_WEBM
if (sink->audio_format == SHOUT_FORMAT_WEBM)
format = "webm";
#endif
GST_DEBUG_OBJECT (sink, "Connection format is: %s", format);
if (shout_set_format (sink->conn, sink->audio_format) != SHOUTERR_SUCCESS)
goto could_not_set_format;
if (shout_open (sink->conn) != SHOUTERR_SUCCESS)
goto could_not_connect;
GST_DEBUG_OBJECT (sink, "connected to server");
sink->connected = TRUE;
/* let's set metadata */
if (sink->songmetadata) {
shout_metadata_t *pmetadata;
GST_DEBUG_OBJECT (sink, "shout metadata now: %s", sink->songmetadata);
pmetadata = shout_metadata_new ();
shout_metadata_add (pmetadata, "song", sink->songmetadata);
shout_set_metadata (sink->conn, pmetadata);
shout_metadata_free (pmetadata);
}
return TRUE;
/* ERRORS */
could_not_set_format:
{
GST_ELEMENT_ERROR (sink, LIBRARY, SETTINGS, (NULL),
("Error setting connection format: %s", shout_get_error (sink->conn)));
return FALSE;
}
could_not_connect:
{
GST_ELEMENT_ERROR (sink, RESOURCE, OPEN_WRITE,
(_("Could not connect to server")),
("shout_open() failed: err=%s", shout_get_error (sink->conn)));
g_signal_emit (sink, gst_shout2send_signals[SIGNAL_CONNECTION_PROBLEM], 0,
shout_get_errno (sink->conn));
return FALSE;
}
}
static gboolean
gst_shout2send_event (GstBaseSink * sink, GstEvent * event)
{
GstShout2send *shout2send;
gboolean ret = TRUE;
shout2send = GST_SHOUT2SEND (sink);
GST_LOG_OBJECT (shout2send, "got %s event", GST_EVENT_TYPE_NAME (event));
switch (GST_EVENT_TYPE (event)) {
case GST_EVENT_TAG:{
/* vorbis audio doesnt need metadata setting on the icecast level, only mp3 */
if (shout2send->tags && shout2send->audio_format == SHOUT_FORMAT_MP3) {
GstTagList *list;
gst_event_parse_tag (event, &list);
GST_DEBUG_OBJECT (shout2send, "tags=%" GST_PTR_FORMAT, list);
gst_tag_list_insert (shout2send->tags,
list,
gst_tag_setter_get_tag_merge_mode (GST_TAG_SETTER (shout2send)));
/* lets get the artist and song tags */
gst_tag_list_foreach ((GstTagList *) list,
set_shout_metadata, shout2send);
if (shout2send->songmetadata && shout2send->connected) {
shout_metadata_t *pmetadata;
GST_DEBUG_OBJECT (shout2send, "metadata now: %s",
shout2send->songmetadata);
pmetadata = shout_metadata_new ();
shout_metadata_add (pmetadata, "song", shout2send->songmetadata);
shout_set_metadata (shout2send->conn, pmetadata);
shout_metadata_free (pmetadata);
}
}
break;
}
default:{
GST_LOG_OBJECT (shout2send, "let base class handle event");
if (GST_BASE_SINK_CLASS (parent_class)->event) {
event = gst_event_ref (event);
ret = GST_BASE_SINK_CLASS (parent_class)->event (sink, event);
}
break;
}
}
return ret;
}
static void metadata_update(int delay) {
ices_stream_t* stream;
shout_metadata_t* metadata;
char song[1024];
char* playlist_metadata;
char* value;
int rc;
if (delay)
usleep(delay);
if (!(playlist_metadata = ices_playlist_get_metadata())) {
if (Title) {
if (Artist)
snprintf(song, sizeof(song), "%s - %s", Artist, Title);
else
snprintf(song, sizeof(song), "%s", Title);
} else
snprintf(song, sizeof(song), "%s", Filename);
value = song;
} else
value = playlist_metadata;
if (!(metadata = shout_metadata_new())) {
ices_log_error("Error allocating metadata structure");
ices_util_free(playlist_metadata);
return;
}
if (shout_metadata_add(metadata, "song", value) != SHOUTERR_SUCCESS) {
ices_log_error_output("Error adding info to metadata structure");
ices_util_free(playlist_metadata);
shout_metadata_free(metadata);
return;
}
for (stream = ices_config.streams; stream; stream = stream->next) {
rc = shout_set_metadata(stream->conn, metadata);
if (rc != SHOUTERR_SUCCESS)
ices_log_error_output("Updating metadata on %s failed.", stream->mount);
else
ices_log_debug("Updated metadata on %s to: %s", stream->mount, value);
}
ices_util_free(playlist_metadata);
shout_metadata_free(metadata);
}
int
setMetadata(shout_t *shout, metadata_t *mdata, char **mdata_copy)
{
shout_metadata_t *shout_mdata = NULL;
char *songInfo;
const char *artist, *title;
int ret = SHOUTERR_SUCCESS;
if (shout == NULL) {
printf("%s: setMetadata(): Internal error: NULL shout_t\n",
__progname);
abort();
}
if (mFlag)
return (SHOUTERR_SUCCESS);
if (mdata == NULL)
return 1;
if ((shout_mdata = shout_metadata_new()) == NULL) {
printf("%s: shout_metadata_new(): %s\n", __progname,
strerror(ENOMEM));
exit(1);
}
artist = metadata_get_artist(mdata);
title = metadata_get_title(mdata);
/*
* We can do this, because we know how libshout works. This adds
* "charset=UTF-8" to the HTTP metadata update request and has the
* desired effect of letting newer-than-2.3.1 versions of Icecast know
* which encoding we're using.
*/
if (shout_metadata_add(shout_mdata, "charset", "UTF-8") != SHOUTERR_SUCCESS) {
/* Assume SHOUTERR_MALLOC */
printf("%s: shout_metadata_add(): %s\n", __progname,
strerror(ENOMEM));
exit(1);
}
if ((songInfo = getMetadataString(pezConfig->metadataFormat, mdata)) == NULL) {
if (artist[0] == '\0' && title[0] == '\0')
songInfo = xstrdup(metadata_get_string(mdata));
else
songInfo = metadata_assemble_string(mdata);
if (artist[0] != '\0' && title[0] != '\0') {
if (shout_metadata_add(shout_mdata, "artist", artist) != SHOUTERR_SUCCESS) {
printf("%s: shout_metadata_add(): %s\n", __progname,
strerror(ENOMEM));
exit(1);
}
if (shout_metadata_add(shout_mdata, "title", title) != SHOUTERR_SUCCESS) {
printf("%s: shout_metadata_add(): %s\n", __progname,
strerror(ENOMEM));
exit(1);
}
} else {
if (shout_metadata_add(shout_mdata, "song", songInfo) != SHOUTERR_SUCCESS) {
printf("%s: shout_metadata_add(): %s\n", __progname,
strerror(ENOMEM));
exit(1);
}
}
} else if (shout_metadata_add(shout_mdata, "song", songInfo) != SHOUTERR_SUCCESS) {
printf("%s: shout_metadata_add(): %s\n", __progname,
strerror(ENOMEM));
exit(1);
}
if ((ret = shout_set_metadata(shout, shout_mdata)) != SHOUTERR_SUCCESS)
printf("%s: shout_set_metadata(): %s\n",
__progname, shout_get_error(shout));
shout_metadata_free(shout_mdata);
if (ret == SHOUTERR_SUCCESS) {
if (mdata_copy != NULL && *mdata_copy == NULL)
*mdata_copy = xstrdup(songInfo);
}
xfree(songInfo);
return (ret);
}
int feed_x_pad(uint8_t *data_ptr, uint8_t ci_flag, ni2http_channel_t *chan, uint8_t x_pad_ind, int start_pos)
{
int ret=0;
if(x_pad_ind == 1) {
/* short X-PAD */
if(data_ptr[0] == 0x00 && data_ptr[1] == 0x00 && data_ptr[2] == 0x00 && data_ptr[3] == 0x00)
return 0;
if(fill_dls_pad(data_ptr, ci_flag ? 3 : 4, data_ptr[3] == 0x02 && ci_flag, chan)){
INFO("chan[%d] song: %s", chan->sid, chan->pad_data);
shout_metadata_t *metadata = shout_metadata_new();
shout_metadata_add(metadata, "song", (char *) chan->pad_data);
shout_set_metadata(chan->shout, metadata);
shout_metadata_free(metadata);
}
}
if(x_pad_ind != 2)
return 0;
if(ci_flag) {
if(data_ptr[0] == 0x00 && data_ptr[1] == 0x00 && data_ptr[2] == 0x00 && data_ptr[3] == 0x00)
return 0;
//uint8_t subchLen = data_ptr[3] & 0x07;
//uint8_t appTyp = data_ptr[3] >> 3;
//WARN("FEED_X_PAD: CI=%d: %02x %02x %02x %02x", ci_flag, data_ptr[0], data_ptr[1], data_ptr[2], data_ptr[3]);
//print_bytes((char*)data_ptr+4-32, 32);
int data_pos = 3, subfield_idx=0;
uint8_t sizes[4] = {0,0,0,0};
uint8_t types[4] = {0,0,0,0};
uint8_t appTyp, subfieldLen;
do {
appTyp = data_ptr[data_pos] & 0x1f;
subfieldLen = data_ptr[data_pos] >> 5;
data_pos--;
if(appTyp == 0x1f) {
appTyp = data_ptr[data_pos];
data_pos--;
}
if(appTyp != 0) {
types[subfield_idx] = appTyp;
sizes[subfield_idx] = pad_sizes_idx[subfieldLen];
subfield_idx++;
}
//WARN("FEED_X_PAD[%d|%d]: appTyp=%d, subchLen=%d", data_pos, subfield_idx, appTyp, pad_sizes_idx[subfieldLen]);
} while (data_pos >=0 && appTyp != 0);
//WARN("FEED_X_PAD bytes left=%d", data_pos);
int idx;
uint8_t *pad_data_subch_start = data_ptr + (data_pos) + 1; //data_ptr + data_pos;
for(idx=0;idx<subfield_idx;idx++) {
pad_data_subch_start -= sizes[idx]; //may be -1;
if(pad_data_subch_start < data_ptr-start_pos) {
WARN("X_PAD: BAD pad_data_subch_start: %p, data_ptr=%p, pos=%d, start==%p", pad_data_subch_start, data_ptr, start_pos, data_ptr-start_pos);
break;
}
//FIXME: if next subfield is dls again, then this may not work fine.
switch(types[idx]) {
case 0x02:
case 0x03:
//WARN("FEED_X_PAD[%d]: appTyp=%d, subchLen=%d:", idx, types[idx], sizes[idx]);
//print_bytes((char*)pad_data_subch_start, sizes[idx]);
if(fill_dls_pad(pad_data_subch_start, sizes[idx], types[idx] == 0x02, chan)) {
INFO("chan[%d] song: %s", chan->sid, chan->pad_data);
shout_metadata_t *metadata = shout_metadata_new();
shout_metadata_add(metadata, "song", (char *) chan->pad_data);
shout_set_metadata(chan->shout, metadata);
shout_metadata_free(metadata);
}
break;
default:
//WARN("FEED_X_PAD[%d]: UNUSED appTyp=%d, subchLen=%d:", idx, types[idx], sizes[idx]);
//print_bytes((char*)pad_data_subch_start, sizes[idx]);
break;
}
}
} else {
*/
static void raise_nonspecific_shout_error(int errno) {
rb_raise(cShoutError, "%d", errno);
}
/*
------------------- ShoutMetadata ---------------------
*/
static VALUE cShoutMetadata;
static VALUE _sh_metadata_new(VALUE class) {
shout_metadata_t *m;
VALUE meta;
m = shout_metadata_new();
meta = Data_Wrap_Struct(class, 0, shout_metadata_free, m);
rb_obj_call_init(meta, 0, 0);
return meta;
}
static VALUE _sh_metadata_add(VALUE self, VALUE name, VALUE value) {
shout_metadata_t *m;
int err;
Data_Get_Struct(self, shout_metadata_t, m);
err = shout_metadata_add(m, STR2CSTR(name), STR2CSTR(value));