void OutputIceCast::applyStreamInfo()
{
int r;
r = shout_set_name(_shout, _csi.name.toStdString().c_str());
if (r != SHOUTERR_SUCCESS) {
emit error(QString("unable to set name: ") + shout_get_error(_shout));
}
r = shout_set_genre(_shout, _csi.genre.toStdString().c_str());
if (r != SHOUTERR_SUCCESS) {
emit error(QString("unable to set genre: ") + shout_get_error(_shout));
}
r = shout_set_url(_shout, _csi.url.toStdString().c_str());
if (r != SHOUTERR_SUCCESS) {
emit error(QString("unable to set url: ") + shout_get_error(_shout));
}
r = shout_set_agent(_shout, _csi.agent.toStdString().c_str());
if (r != SHOUTERR_SUCCESS) {
emit error(QString("unable to set agent: ") + shout_get_error(_shout));
}
r = shout_set_description(_shout, _csi.description.toStdString().c_str());
if (r != SHOUTERR_SUCCESS) {
emit error(QString("unable to set description: ") + shout_get_error(_shout));
}
r = shout_set_public(_shout, static_cast<int>(_csi.isPublic));
if (r != SHOUTERR_SUCCESS) {
emit error(QString("unable to set description: ") + shout_get_error(_shout));
}
// TODO set metadata
//shout_set_metadata
}
bool Shouter::initialize() {
source->initialize();
shout_init();
if (!(shout = shout_new())) {
printf("Could not allocate shout_t\n");
return 0;
}
if (shout_set_host(shout, hostname.c_str()) != SHOUTERR_SUCCESS) {
printf("Error setting hostname: %s\n", shout_get_error(shout));
return 0;
}
if (shout_set_protocol(shout, protocol) != SHOUTERR_SUCCESS) {
printf("Error setting protocol: %s\n", shout_get_error(shout));
return 0;
}
if (shout_set_port(shout, port) != SHOUTERR_SUCCESS) {
printf("Error setting port: %s\n", shout_get_error(shout));
return 0;
}
if (shout_set_password(shout, password.c_str()) != SHOUTERR_SUCCESS) {
printf("Error setting password: %s\n", shout_get_error(shout));
return 0;
}
if (shout_set_mount(shout, mountpoint.c_str()) != SHOUTERR_SUCCESS) {
printf("Error setting mount: %s\n", shout_get_error(shout));
return 0;
}
if (shout_set_user(shout, user_name.c_str()) != SHOUTERR_SUCCESS) {
printf("Error setting user: %s\n", shout_get_error(shout));
return 0;
}
if (shout_set_format(shout, format) != SHOUTERR_SUCCESS) {
printf("Error setting user: %s\n", shout_get_error(shout));
return 0;
}
shout_set_agent(shout,"Shouter");
shout_set_description(shout, stream_description.c_str());
shout_set_genre(shout, stream_genre.c_str());
shout_set_name(shout, stream_name.c_str());
shout_set_url(shout, stream_url.c_str());
}
/*****************************************************************************
* Open: open the shout connection
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
sout_access_out_t *p_access = (sout_access_out_t*)p_this;
sout_access_out_sys_t *p_sys;
shout_t *p_shout;
long i_ret;
char *psz_val;
char *psz_name;
char *psz_description;
char *psz_genre;
char *psz_url;
vlc_url_t url;
config_ChainParse( p_access, SOUT_CFG_PREFIX, ppsz_sout_options, p_access->p_cfg );
if( !p_access->psz_path )
{
msg_Err( p_access,
"please specify url=user:password@host:port/mountpoint" );
return VLC_EGENERIC;
}
vlc_UrlParse( &url , p_access->psz_path, 0 );
if( url.i_port <= 0 )
url.i_port = 8000;
p_sys = p_access->p_sys = malloc( sizeof( sout_access_out_sys_t ) );
if( !p_sys )
{
vlc_UrlClean( &url );
return VLC_ENOMEM;
}
psz_name = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "name" );
psz_description = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "description" );
psz_genre = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "genre" );
psz_url = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "url" );
p_shout = p_sys->p_shout = shout_new();
if( !p_shout
|| shout_set_host( p_shout, url.psz_host ) != SHOUTERR_SUCCESS
|| shout_set_protocol( p_shout, SHOUT_PROTOCOL_ICY ) != SHOUTERR_SUCCESS
|| shout_set_port( p_shout, url.i_port ) != SHOUTERR_SUCCESS
|| shout_set_password( p_shout, url.psz_password ) != SHOUTERR_SUCCESS
|| shout_set_mount( p_shout, url.psz_path ) != SHOUTERR_SUCCESS
|| shout_set_user( p_shout, url.psz_username ) != SHOUTERR_SUCCESS
|| shout_set_agent( p_shout, "VLC media player " VERSION ) != SHOUTERR_SUCCESS
|| shout_set_name( p_shout, psz_name ) != SHOUTERR_SUCCESS
|| shout_set_description( p_shout, psz_description ) != SHOUTERR_SUCCESS
|| shout_set_genre( p_shout, psz_genre ) != SHOUTERR_SUCCESS
|| shout_set_url( p_shout, psz_url ) != SHOUTERR_SUCCESS
/* || shout_set_nonblocking( p_shout, 1 ) != SHOUTERR_SUCCESS */
)
{
msg_Err( p_access, "failed to initialize shout streaming to %s:%i/%s",
url.psz_host, url.i_port, url.psz_path );
free( psz_name );
free( psz_description );
free( psz_genre );
free( psz_url );
goto error;
}
free( psz_name );
free( psz_description );
free( psz_genre );
free( psz_url );
i_ret = shout_set_format( p_shout, var_GetBool( p_access, SOUT_CFG_PREFIX "mp3" ) ?
SHOUT_FORMAT_MP3 : SHOUT_FORMAT_OGG );
if( i_ret != SHOUTERR_SUCCESS )
{
msg_Err( p_access, "failed to set the shoutcast streaming format" );
goto error;
}
/* Don't force bitrate to 0 but only use when specified. This will otherwise
show an empty field on icecast directory listing instead of NA */
psz_val = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "bitrate" );
if( psz_val )
{
i_ret = shout_set_audio_info( p_shout, SHOUT_AI_BITRATE, psz_val );
free( psz_val );
if( i_ret != SHOUTERR_SUCCESS )
{
msg_Err( p_access, "failed to set the information about the bitrate" );
goto error;
}
}
else
{
/* Bitrate information is used for icecast/shoutcast servers directory
listings (sorting, stream info etc.) */
msg_Warn( p_access, "no bitrate information specified (required for listing " \
"the server as public on the shoutcast website)" );
}
/* Information about samplerate, channels and quality will not be propagated
through the YP protocol for icecast to the public directory listing when
the icecast server is operating in shoutcast compatibility mode */
psz_val = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "samplerate" );
if( psz_val )
{
i_ret = shout_set_audio_info( p_shout, SHOUT_AI_SAMPLERATE, psz_val );
free( psz_val );
if( i_ret != SHOUTERR_SUCCESS )
{
msg_Err( p_access, "failed to set the information about the samplerate" );
goto error;
}
}
psz_val = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "channels" );
if( psz_val )
{
i_ret = shout_set_audio_info( p_shout, SHOUT_AI_CHANNELS, psz_val );
free( psz_val );
if( i_ret != SHOUTERR_SUCCESS )
{
msg_Err( p_access, "failed to set the information about the number of channels" );
goto error;
}
}
psz_val = var_GetNonEmptyString( p_access, SOUT_CFG_PREFIX "quality" );
if( psz_val )
{
i_ret = shout_set_audio_info( p_shout, SHOUT_AI_QUALITY, psz_val );
free( psz_val );
if( i_ret != SHOUTERR_SUCCESS )
{
msg_Err( p_access, "failed to set the information about Ogg Vorbis quality" );
goto error;
}
}
if( var_GetBool( p_access, SOUT_CFG_PREFIX "public" ) )
{
i_ret = shout_set_public( p_shout, 1 );
if( i_ret != SHOUTERR_SUCCESS )
{
msg_Err( p_access, "failed to set the server status setting to public" );
goto error;
}
}
/* Connect at startup. Cycle through the possible protocols. */
i_ret = shout_get_connected( p_shout );
while ( i_ret != SHOUTERR_CONNECTED )
{
/* Shout parameters cannot be changed on an open connection */
i_ret = shout_close( p_shout );
if( i_ret == SHOUTERR_SUCCESS )
{
i_ret = SHOUTERR_UNCONNECTED;
}
/* Re-initialize for Shoutcast using ICY protocol. Not needed for initial connection
but it is when we are reconnecting after other protocol was tried. */
i_ret = shout_set_protocol( p_shout, SHOUT_PROTOCOL_ICY );
if( i_ret != SHOUTERR_SUCCESS )
{
msg_Err( p_access, "failed to set the protocol to 'icy'" );
goto error;
}
i_ret = shout_open( p_shout );
if( i_ret == SHOUTERR_SUCCESS )
{
i_ret = SHOUTERR_CONNECTED;
msg_Dbg( p_access, "connected using 'icy' (shoutcast) protocol" );
}
else
{
msg_Warn( p_access, "failed to connect using 'icy' (shoutcast) protocol" );
/* Shout parameters cannot be changed on an open connection */
i_ret = shout_close( p_shout );
if( i_ret == SHOUTERR_SUCCESS )
{
i_ret = SHOUTERR_UNCONNECTED;
}
/* IceCAST using HTTP protocol */
i_ret = shout_set_protocol( p_shout, SHOUT_PROTOCOL_HTTP );
if( i_ret != SHOUTERR_SUCCESS )
{
msg_Err( p_access, "failed to set the protocol to 'http'" );
goto error;
}
i_ret = shout_open( p_shout );
if( i_ret == SHOUTERR_SUCCESS )
{
i_ret = SHOUTERR_CONNECTED;
msg_Dbg( p_access, "connected using 'http' (icecast 2.x) protocol" );
}
else
msg_Warn( p_access, "failed to connect using 'http' (icecast 2.x) protocol " );
}
/*
for non-blocking, use:
while( i_ret == SHOUTERR_BUSY )
{
sleep( 1 );
i_ret = shout_get_connected( p_shout );
}
*/
if ( i_ret != SHOUTERR_CONNECTED )
{
msg_Warn( p_access, "unable to establish connection, retrying..." );
msleep( 30000000 );
}
}
if( i_ret != SHOUTERR_CONNECTED )
{
msg_Err( p_access, "failed to open shout stream to %s:%i/%s: %s",
url.psz_host, url.i_port, url.psz_path, shout_get_error(p_shout) );
goto error;
}
p_access->pf_write = Write;
p_access->pf_seek = Seek;
p_access->pf_control = Control;
msg_Dbg( p_access, "shout access output opened (%s@%s:%i/%s)",
url.psz_username, url.psz_host, url.i_port, url.psz_path );
vlc_UrlClean( &url );
return VLC_SUCCESS;
error:
if( p_sys->p_shout )
shout_free( p_sys->p_shout );
vlc_UrlClean( &url );
free( p_sys );
return VLC_EGENERIC;
}
void EngineShoutcast::updateFromPreferences() {
qDebug() << "EngineShoutcast: updating from preferences";
m_pUpdateShoutcastFromPrefs->slotSet(0.0f);
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;
// Convert a bunch of QStrings to QByteArrays so we can get regular C char*
// strings to pass to libshout.
QString codec = m_pConfig->getValueString(ConfigKey(SHOUTCAST_PREF_KEY, "metadata_charset"));
QByteArray baCodec = codec.toLatin1();
m_pTextCodec = QTextCodec::codecForName(baCodec);
if (!m_pTextCodec) {
qDebug() << "Couldn't find shoutcast metadata codec for codec:" << codec
<< " defaulting to ISO-8859-1.";
}
// Indicates our metadata is in the provided charset.
shout_metadata_add(m_pShoutMetaData, "charset", baCodec.constData());
// Host, server type, port, mountpoint, login, password should be latin1.
QByteArray baHost = m_pConfig->getValueString(
ConfigKey(SHOUTCAST_PREF_KEY, "host")).toLatin1();
QByteArray baServerType = m_pConfig->getValueString(
ConfigKey(SHOUTCAST_PREF_KEY, "servertype")).toLatin1();
QByteArray baPort = m_pConfig->getValueString(
ConfigKey(SHOUTCAST_PREF_KEY, "port")).toLatin1();
QByteArray baMountPoint = m_pConfig->getValueString(
ConfigKey(SHOUTCAST_PREF_KEY, "mountpoint")).toLatin1();
QByteArray baLogin = m_pConfig->getValueString(
ConfigKey(SHOUTCAST_PREF_KEY, "login")).toLatin1();
QByteArray baPassword = m_pConfig->getValueString(
ConfigKey(SHOUTCAST_PREF_KEY, "password")).toLatin1();
QByteArray baFormat = m_pConfig->getValueString(
ConfigKey(SHOUTCAST_PREF_KEY, "format")).toLatin1();
QByteArray baBitrate = m_pConfig->getValueString(
ConfigKey(SHOUTCAST_PREF_KEY, "bitrate")).toLatin1();
// Encode metadata like stream name, website, desc, genre, title/author with
// the chosen TextCodec.
QByteArray baStreamName = encodeString(m_pConfig->getValueString(
ConfigKey(SHOUTCAST_PREF_KEY, "stream_name")));
QByteArray baStreamWebsite = encodeString(m_pConfig->getValueString(
ConfigKey(SHOUTCAST_PREF_KEY, "stream_website")));
QByteArray baStreamDesc = encodeString(m_pConfig->getValueString(
ConfigKey(SHOUTCAST_PREF_KEY, "stream_desc")));
QByteArray baStreamGenre = encodeString(m_pConfig->getValueString(
ConfigKey(SHOUTCAST_PREF_KEY, "stream_genre")));
QByteArray baStreamPublic = encodeString(m_pConfig->getValueString(
ConfigKey(SHOUTCAST_PREF_KEY, "stream_public")));
// Dynamic Ogg metadata update
m_ogg_dynamic_update = (bool)m_pConfig->getValueString(
ConfigKey(SHOUTCAST_PREF_KEY,"ogg_dynamicupdate")).toInt();
m_custom_metadata = (bool)m_pConfig->getValueString(
ConfigKey(SHOUTCAST_PREF_KEY, "enable_metadata")).toInt();
m_customTitle = m_pConfig->getValueString(
ConfigKey(SHOUTCAST_PREF_KEY, "custom_title"));
m_customArtist = m_pConfig->getValueString(
ConfigKey(SHOUTCAST_PREF_KEY, "custom_artist"));
int format;
int protocol;
if (shout_set_host(m_pShout, baHost.constData()) != SHOUTERR_SUCCESS) {
errorDialog(tr("Error setting hostname!"), shout_get_error(m_pShout));
return;
}
// WTF? Why SHOUT_PROTOCOL_HTTP and not.. the chosen protocol?
if (shout_set_protocol(m_pShout, SHOUT_PROTOCOL_HTTP) != SHOUTERR_SUCCESS) {
errorDialog(tr("Error setting protocol!"), shout_get_error(m_pShout));
return;
}
if (shout_set_port(m_pShout, baPort.toUInt()) != SHOUTERR_SUCCESS) {
errorDialog(tr("Error setting port!"), shout_get_error(m_pShout));
return;
}
if (shout_set_password(m_pShout, baPassword.constData()) != SHOUTERR_SUCCESS) {
errorDialog(tr("Error setting password!"), shout_get_error(m_pShout));
return;
}
if (shout_set_mount(m_pShout, baMountPoint.constData()) != SHOUTERR_SUCCESS) {
errorDialog(tr("Error setting mount!"), shout_get_error(m_pShout));
return;
}
if (shout_set_user(m_pShout, baLogin.constData()) != SHOUTERR_SUCCESS) {
errorDialog(tr("Error setting username!"), shout_get_error(m_pShout));
return;
}
if (shout_set_name(m_pShout, baStreamName.constData()) != SHOUTERR_SUCCESS) {
errorDialog(tr("Error setting stream name!"), shout_get_error(m_pShout));
return;
}
if (shout_set_description(m_pShout, baStreamDesc.constData()) != SHOUTERR_SUCCESS) {
errorDialog(tr("Error setting stream description!"), shout_get_error(m_pShout));
return;
}
if (shout_set_genre(m_pShout, baStreamGenre.constData()) != SHOUTERR_SUCCESS) {
errorDialog(tr("Error setting stream genre!"), shout_get_error(m_pShout));
return;
}
if (shout_set_url(m_pShout, baStreamWebsite.constData()) != SHOUTERR_SUCCESS) {
errorDialog(tr("Error setting stream url!"), shout_get_error(m_pShout));
return;
}
m_format_is_mp3 = !qstrcmp(baFormat.constData(), SHOUTCAST_FORMAT_MP3);
m_format_is_ov = !qstrcmp(baFormat.constData(), SHOUTCAST_FORMAT_OV);
if (m_format_is_mp3) {
format = SHOUT_FORMAT_MP3;
} else if (m_format_is_ov) {
format = SHOUT_FORMAT_OGG;
} else {
qDebug() << "Error: unknown format:" << baFormat.constData();
return;
}
if (shout_set_format(m_pShout, format) != SHOUTERR_SUCCESS) {
errorDialog("Error setting soutcast format!", shout_get_error(m_pShout));
return;
}
bool bitrate_is_int = false;
int iBitrate = baBitrate.toInt(&bitrate_is_int);
if (!bitrate_is_int) {
qDebug() << "Error: unknown bitrate:" << baBitrate.constData();
}
int iMasterSamplerate = m_pMasterSamplerate->get();
if (m_format_is_ov && iMasterSamplerate == 96000) {
errorDialog(tr("Broadcasting at 96kHz with Ogg Vorbis is not currently "
"supported. Please try a different sample-rate or switch "
"to a different encoding."),
tr("See https://bugs.launchpad.net/mixxx/+bug/686212 for more "
"information."));
return;
}
if (shout_set_audio_info(m_pShout, SHOUT_AI_BITRATE, baBitrate.constData()) != SHOUTERR_SUCCESS) {
errorDialog(tr("Error setting bitrate"), shout_get_error(m_pShout));
return;
}
m_protocol_is_icecast2 = !qstricmp(baServerType.constData(), SHOUTCAST_SERVER_ICECAST2);
m_protocol_is_shoutcast = !qstricmp(baServerType.constData(), SHOUTCAST_SERVER_SHOUTCAST);
m_protocol_is_icecast1 = !qstricmp(baServerType.constData(), SHOUTCAST_SERVER_ICECAST1);
if (m_protocol_is_icecast2) {
protocol = SHOUT_PROTOCOL_HTTP;
} else if (m_protocol_is_shoutcast) {
protocol = SHOUT_PROTOCOL_ICY;
} else if (m_protocol_is_icecast1) {
protocol = SHOUT_PROTOCOL_XAUDIOCAST;
} else {
errorDialog(tr("Error: unknown server protocol!"), shout_get_error(m_pShout));
return;
}
if (m_protocol_is_shoutcast && !m_format_is_mp3) {
errorDialog(tr("Error: libshout only supports Shoutcast with MP3 format!"),
shout_get_error(m_pShout));
return;
}
if (shout_set_protocol(m_pShout, protocol) != SHOUTERR_SUCCESS) {
errorDialog(tr("Error setting protocol!"), shout_get_error(m_pShout));
return;
}
// Initialize m_encoder
if (m_encoder) {
// delete m_encoder if it has been initalized (with maybe) different bitrate
delete m_encoder;
m_encoder = NULL;
}
if (m_format_is_mp3) {
m_encoder = new EncoderMp3(this);
} else if (m_format_is_ov) {
m_encoder = new EncoderVorbis(this);
} else {
qDebug() << "**** Unknown Encoder Format";
return;
}
if (m_encoder->initEncoder(iBitrate, iMasterSamplerate) < 0) {
//e.g., if lame is not found
//init m_encoder itself will display a message box
qDebug() << "**** Encoder init failed";
delete m_encoder;
m_encoder = NULL;
}
}
shout_t *
stream_setup(const char *host, unsigned short port, const char *mount)
{
shout_t *shout = NULL;
if ((shout = shout_new()) == NULL) {
printf("%s: shout_new(): %s", __progname, strerror(ENOMEM));
return (NULL);
}
if (shout_set_host(shout, host) != SHOUTERR_SUCCESS) {
printf("%s: shout_set_host(): %s\n", __progname,
shout_get_error(shout));
shout_free(shout);
return (NULL);
}
if (shout_set_protocol(shout, SHOUT_PROTOCOL_HTTP) != SHOUTERR_SUCCESS) {
printf("%s: shout_set_protocol(): %s\n", __progname,
shout_get_error(shout));
shout_free(shout);
return (NULL);
}
if (shout_set_port(shout, port) != SHOUTERR_SUCCESS) {
printf("%s: shout_set_port: %s\n", __progname,
shout_get_error(shout));
shout_free(shout);
return (NULL);
}
if (shout_set_password(shout, pezConfig->password) != SHOUTERR_SUCCESS) {
printf("%s: shout_set_password(): %s\n", __progname,
shout_get_error(shout));
shout_free(shout);
return (NULL);
}
if (shout_set_mount(shout, mount) != SHOUTERR_SUCCESS) {
printf("%s: shout_set_mount(): %s\n", __progname,
shout_get_error(shout));
shout_free(shout);
return (NULL);
}
if (shout_set_user(shout, "source") != SHOUTERR_SUCCESS) {
printf("%s: shout_set_user(): %s\n", __progname,
shout_get_error(shout));
shout_free(shout);
return (NULL);
}
if (!strcmp(pezConfig->format, MP3_FORMAT) &&
shout_set_format(shout, SHOUT_FORMAT_MP3) != SHOUTERR_SUCCESS) {
printf("%s: shout_set_format(MP3): %s\n",
__progname, shout_get_error(shout));
shout_free(shout);
return (NULL);
}
if ((!strcmp(pezConfig->format, VORBIS_FORMAT) ||
!strcmp(pezConfig->format, THEORA_FORMAT)) &&
shout_set_format(shout, SHOUT_FORMAT_OGG) != SHOUTERR_SUCCESS) {
printf("%s: shout_set_format(OGG): %s\n",
__progname, shout_get_error(shout));
shout_free(shout);
return (NULL);
}
if (pezConfig->username &&
shout_set_user(shout, pezConfig->username) != SHOUTERR_SUCCESS) {
printf("%s: shout_set_user(): %s\n",
__progname, shout_get_error(shout));
shout_free(shout);
return (NULL);
}
if (pezConfig->serverName &&
shout_set_name(shout, pezConfig->serverName) != SHOUTERR_SUCCESS) {
printf("%s: shout_set_name(): %s\n",
__progname, shout_get_error(shout));
shout_free(shout);
return (NULL);
}
if (pezConfig->serverURL &&
shout_set_url(shout, pezConfig->serverURL) != SHOUTERR_SUCCESS) {
printf("%s: shout_set_url(): %s\n",
__progname, shout_get_error(shout));
shout_free(shout);
return (NULL);
}
if (pezConfig->serverGenre &&
shout_set_genre(shout, pezConfig->serverGenre) != SHOUTERR_SUCCESS) {
printf("%s: shout_set_genre(): %s\n",
__progname, shout_get_error(shout));
shout_free(shout);
return (NULL);
}
if (pezConfig->serverDescription &&
shout_set_description(shout, pezConfig->serverDescription) != SHOUTERR_SUCCESS) {
printf("%s: shout_set_description(): %s\n",
__progname, shout_get_error(shout));
shout_free(shout);
return (NULL);
}
if (pezConfig->serverBitrate &&
shout_set_audio_info(shout, SHOUT_AI_BITRATE, pezConfig->serverBitrate) != SHOUTERR_SUCCESS) {
printf("%s: shout_set_audio_info(AI_BITRATE): %s\n",
__progname, shout_get_error(shout));
shout_free(shout);
return (NULL);
}
if (pezConfig->serverChannels &&
shout_set_audio_info(shout, SHOUT_AI_CHANNELS, pezConfig->serverChannels) != SHOUTERR_SUCCESS) {
printf("%s: shout_set_audio_info(AI_CHANNELS): %s\n",
__progname, shout_get_error(shout));
shout_free(shout);
return (NULL);
}
if (pezConfig->serverSamplerate &&
shout_set_audio_info(shout, SHOUT_AI_SAMPLERATE, pezConfig->serverSamplerate) != SHOUTERR_SUCCESS) {
printf("%s: shout_set_audio_info(AI_SAMPLERATE): %s\n",
__progname, shout_get_error(shout));
shout_free(shout);
return (NULL);
}
if (pezConfig->serverQuality &&
shout_set_audio_info(shout, SHOUT_AI_QUALITY, pezConfig->serverQuality) != SHOUTERR_SUCCESS) {
printf("%s: shout_set_audio_info(AI_QUALITY): %s\n",
__progname, shout_get_error(shout));
shout_free(shout);
return (NULL);
}
if (shout_set_public(shout, (unsigned int)pezConfig->serverPublic) != SHOUTERR_SUCCESS) {
printf("%s: shout_set_public(): %s\n",
__progname, shout_get_error(shout));
shout_free(shout);
return (NULL);
}
return (shout);
}
static SCM open_vorbis_stream(SCM server, SCM port, SCM password,
SCM mount, SCM config) {
SCM smob;
double qual;
char stream_name[32];
VORBIS_STREAM *stream;
stream = (VORBIS_STREAM *)my_gc_malloc(sizeof(VORBIS_STREAM),
"vorbis_stream", "vorbis stream");
stream->header.shutdown = vorbis_shutdown;
vorbis_info_init(&(stream->vi));
SCM quality = get_property(config, "quality");
if (scm_is_number(quality)) qual = scm_to_double(quality);
else qual = 0.6;
scm_remember_upto_here_1(quality);
stream->header.shoutbuf = NULL;
stream->header.shoutbuf_size = 0;
stream->header.rb_size = sizeof(sample_t) * RB_SECS * sampling_rate
* QMX_CHANNELS + 0.5;
stream->header.ringbuf = jack_ringbuffer_create(stream->header.rb_size);
if (vorbis_encode_init_vbr(&(stream->vi), QMX_CHANNELS,
sampling_rate, qual) != 0) {
log_msg("vorbis init failed\n");
return SCM_BOOL_F;
}
if ((stream->header.shout = shout_new()) == NULL) {
log_msg("can't create shout instance\n");
return SCM_BOOL_F;
}
vorbis_analysis_init(&(stream->vd), &(stream->vi));
vorbis_block_init(&(stream->vd), &(stream->vb));
ogg_stream_init(&(stream->os), rand());
vorbis_comment_init(&(stream->vc));
vorbis_comment_add_tag(&(stream->vc), "ENCODER", "QMX");
shout_set_protocol(stream->header.shout, SHOUT_PROTOCOL_HTTP);
shout_set_format(stream->header.shout, SHOUT_FORMAT_OGG);
char *server_s = scm_to_locale_string(server); // server
shout_set_host(stream->header.shout, server_s);
free(server_s);
shout_set_port(stream->header.shout, scm_to_int(port)); // port
shout_set_user(stream->header.shout, "source"); // user
char *password_s = scm_to_locale_string(password); // password
shout_set_password(stream->header.shout, password_s);
free(password_s);
char *mount_s = scm_to_locale_string(mount); // mount pt
shout_set_mount(stream->header.shout, mount_s);
SCM title = get_property(config, "title");
if (scm_is_string(title)) {
char *title_s = scm_to_locale_string(title);
if (strlen(title_s) > 0)
vorbis_comment_add_tag(&(stream->vc), "TITLE", title_s);
free(title_s);
}
scm_remember_upto_here_1(title);
SCM name = get_property(config, "name");
stream_name[0] = '\0';
if (scm_is_string(name)) {
char *name_s = scm_to_locale_string(name);
shout_set_name(stream->header.shout, name_s);
snprintf(stream_name, sizeof(stream_name), "'%s' ", name_s);
free(name_s);
}
scm_remember_upto_here_1(name);
SCM description = get_property(config, "description");
if (scm_is_string(description)) {
char *description_s = scm_to_locale_string(description);
shout_set_description(stream->header.shout, description_s);
free(description_s);
}
scm_remember_upto_here_1(description);
SCM genre = get_property(config, "genre");
if (scm_is_string(genre)) {
char *genre_s = scm_to_locale_string(genre);
shout_set_genre(stream->header.shout, genre_s);
free(genre_s);
}
scm_remember_upto_here_1(genre);
shout_set_audio_info(stream->header.shout,
SHOUT_AI_CHANNELS, encode_int(QMX_CHANNELS));
shout_set_audio_info(stream->header.shout,
SHOUT_AI_SAMPLERATE, encode_int(sampling_rate));
if (shout_open(stream->header.shout) == SHOUTERR_SUCCESS) {
log_msg("vorbis stream %smounted at %s\n", stream_name, mount_s);
free(mount_s);
}
else {
log_msg("vorbis stream %sfailed to open: %s\n", stream_name,
shout_get_error(stream->header.shout));
free(mount_s);
shout_free(stream->header.shout);
return SCM_BOOL_F;
}
vorbis_streams += 1;
stream->header.eos = 0;
SCM_NEWSMOB(smob, vorbis_stream_tag, stream);
streams = link_in(streams, smob);
stream->header.do_prep = need_prepper;
need_prepper = 0;
stream->header.bookmark = 0;
add_outbuf_client(load_frames, process_frames, (void *)stream,
"Ogg-Vorbis stream");
spawn_detached_thread(shout_thread, (void *)&(stream->header));
scm_remember_upto_here_1(smob);
return smob;
}
/* The main loop for each instance. Gets data passed to it from the stream
* manager (which gets it from the input module), and streams it to the
* specified server
*/
void *ices_instance_stream(void *arg)
{
int ret, shouterr;
ref_buffer *buffer;
char *connip;
stream_description *sdsc = arg;
instance_t *stream = sdsc->stream;
input_module_t *inmod = sdsc->input;
int reencoding = (inmod->type == ICES_INPUT_VORBIS) && stream->encode;
int encoding = (inmod->type == ICES_INPUT_PCM) && stream->encode;
char *stream_name = NULL, *stream_genre = NULL, *stream_description = NULL;
char *user = NULL;
vorbis_comment_init(&sdsc->vc);
sdsc->shout = shout_new();
/* we only support the ice protocol and vorbis streams currently */
shout_set_format(sdsc->shout, SHOUT_FORMAT_VORBIS);
//shout_set_protocol(sdsc->shout, SHOUT_PROTOCOL_ICE);
shout_set_protocol(sdsc->shout, SHOUT_PROTOCOL_HTTP);
signal(SIGPIPE, signal_hup_handler);
connip = malloc(16);
if(!resolver_getip(stream->hostname, connip, 16))
{
LOG_ERROR1("Could not resolve hostname \"%s\"", stream->hostname);
free(connip);
stream->died = 1;
return NULL;
}
if (!(shout_set_host(sdsc->shout, connip)) == SHOUTERR_SUCCESS) {
LOG_ERROR1("libshout error: %s\n", shout_get_error(sdsc->shout));
free(connip);
stream->died = 1;
return NULL;
}
shout_set_port(sdsc->shout, stream->port);
if (!(shout_set_password(sdsc->shout, stream->password)) == SHOUTERR_SUCCESS) {
LOG_ERROR1("libshout error: %s\n", shout_get_error(sdsc->shout));
free(connip);
stream->died = 1;
return NULL;
}
if (stream->user)
user = stream->user;
else
user = "******";
if(shout_set_user(sdsc->shout, user) != SHOUTERR_SUCCESS) {
LOG_ERROR1("libshout error: %s\n", shout_get_error(sdsc->shout));
free(connip);
stream->died = 1;
return NULL;
}
if (!(shout_set_agent(sdsc->shout, VERSIONSTRING)) == SHOUTERR_SUCCESS) {
LOG_ERROR1("libshout error: %s\n", shout_get_error(sdsc->shout));
free(connip);
stream->died = 1;
return NULL;
}
if (!(shout_set_mount(sdsc->shout, stream->mount)) == SHOUTERR_SUCCESS) {
LOG_ERROR1("libshout error: %s\n", shout_get_error(sdsc->shout));
free(connip);
stream->died = 1;
return NULL;
}
/* set the metadata for the stream */
if(stream->stream_name)
stream_name = stream->stream_name;
else if (ices_config->stream_name)
stream_name = ices_config->stream_name;
if(stream->stream_description)
stream_description = stream->stream_description;
else if (ices_config->stream_description)
stream_description = ices_config->stream_description;
if(stream->stream_genre)
stream_genre = stream->stream_genre;
else if (ices_config->stream_genre)
stream_genre = ices_config->stream_genre;
if(stream_name)
if (!(shout_set_name(sdsc->shout, stream_name)) == SHOUTERR_SUCCESS) {
LOG_ERROR1("libshout error: %s\n", shout_get_error(sdsc->shout));
free(connip);
stream->died = 1;
return NULL;
}
if (stream_genre)
if (!(shout_set_genre(sdsc->shout, stream_genre)) == SHOUTERR_SUCCESS) {
LOG_ERROR1("libshout error: %s\n", shout_get_error(sdsc->shout));
free(connip);
stream->died = 1;
return NULL;
}
if (stream_description)
if (!(shout_set_description(sdsc->shout, stream_description)) == SHOUTERR_SUCCESS) {
LOG_ERROR1("libshout error: %s\n", shout_get_error(sdsc->shout));
free(connip);
stream->died = 1;
return NULL;
}
if(stream->downmix && encoding && stream->channels == 1) {
stream->channels = 1;
sdsc->downmix = downmix_initialise();
}
if(stream->resampleinrate && stream->resampleoutrate && encoding) {
stream->samplerate = stream->resampleoutrate;
sdsc->resamp = resample_initialise(stream->channels,
stream->resampleinrate, stream->resampleoutrate);
}
if(encoding)
{
if(inmod->metadata_update)
inmod->metadata_update(inmod->internal, &sdsc->vc);
sdsc->enc = encode_initialise(stream->channels, stream->samplerate,
stream->managed, stream->min_br, stream->nom_br, stream->max_br,
stream->quality, stream->serial++, &sdsc->vc);
if(!sdsc->enc) {
LOG_ERROR0("Failed to configure encoder");
stream->died = 1;
return NULL; /* FIXME: probably leaking some memory here */
}
}
else if(reencoding)
sdsc->reenc = reencode_init(stream);
if(stream->savefilename != NULL)
{
stream->savefile = fopen(stream->savefilename, "wb");
if(!stream->savefile)
LOG_ERROR2("Failed to open stream save file %s: %s",
stream->savefilename, strerror(errno));
else
LOG_INFO1("Saving stream to file %s", stream->savefilename);
}
if((shouterr = shout_open(sdsc->shout)) == SHOUTERR_SUCCESS)
{
LOG_INFO3("Connected to server: %s:%d%s",
shout_get_host(sdsc->shout), shout_get_port(sdsc->shout), shout_get_mount(sdsc->shout));
while(1)
{
if(stream->buffer_failures > MAX_ERRORS)
{
LOG_WARN0("Too many errors, shutting down");
break;
}
buffer = stream_wait_for_data(stream);
/* buffer being NULL means that either a fatal error occured,
* or we've been told to shut down
*/
if(!buffer)
break;
/* If data is NULL or length is 0, we should just skip this one.
* Probably, we've been signalled to shut down, and that'll be
* caught next iteration. Add to the error count just in case,
* so that we eventually break out anyway
*/
if(!buffer->buf || !buffer->len)
{
LOG_WARN0("Bad buffer dequeued!");
stream->buffer_failures++;
continue;
}
if(stream->wait_for_critical)
{
LOG_INFO0("Trying restart on new substream");
stream->wait_for_critical = 0;
}
ret = process_and_send_buffer(sdsc, buffer);
/* No data produced, do nothing */
if(ret == -1)
;
/* Fatal error */
else if(ret == -2)
{
LOG_ERROR0("Serious error, waiting to restart on "
"next substream. Stream temporarily suspended.");
/* Set to wait until a critical buffer comes through (start of
* a new substream, typically), and flush existing queue.
*/
thread_mutex_lock(&ices_config->flush_lock);
stream->wait_for_critical = 1;
input_flush_queue(stream->queue, 0);
thread_mutex_unlock(&ices_config->flush_lock);
}
/* Non-fatal shout error */
else if(ret == 0)
{
LOG_ERROR2("Send error: %s (%s)",
shout_get_error(sdsc->shout), strerror(errno));
if(shout_get_errno(sdsc->shout) == SHOUTERR_SOCKET)
{
int i=0;
/* While we're trying to reconnect, don't receive data
* to this instance, or we'll overflow once reconnect
* succeeds
*/
thread_mutex_lock(&ices_config->flush_lock);
stream->skip = 1;
/* Also, flush the current queue */
input_flush_queue(stream->queue, 1);
thread_mutex_unlock(&ices_config->flush_lock);
while((i < stream->reconnect_attempts ||
stream->reconnect_attempts==-1) &&
!ices_config->shutdown)
{
i++;
LOG_WARN0("Trying reconnect after server socket error");
shout_close(sdsc->shout);
if((shouterr = shout_open(sdsc->shout)) == SHOUTERR_SUCCESS)
{
LOG_INFO3("Connected to server: %s:%d%s",
shout_get_host(sdsc->shout), shout_get_port(sdsc->shout),
shout_get_mount(sdsc->shout));
/* This stream can't restart until the next
* logical stream comes along, since the
* server won't have any cached headers for
* this source/connection. So, don't continue
* yet.
*/
thread_mutex_lock(&ices_config->flush_lock);
stream->wait_for_critical = 1;
input_flush_queue(stream->queue, 0);
thread_mutex_unlock(&ices_config->flush_lock);
break;
}
else
{
LOG_ERROR3("Failed to reconnect to %s:%d (%s)",
shout_get_host(sdsc->shout),shout_get_port(sdsc->shout),
shout_get_error(sdsc->shout));
if(i==stream->reconnect_attempts)
{
LOG_ERROR0("Reconnect failed too many times, "
"giving up.");
/* We want to die now */
stream->buffer_failures = MAX_ERRORS+1;
}
else /* Don't try again too soon */
sleep(stream->reconnect_delay);
}
}
stream->skip = 0;
}
stream->buffer_failures++;
}
stream_release_buffer(buffer);
}
}
else
{
LOG_ERROR3("Failed initial connect to %s:%d (%s)",
shout_get_host(sdsc->shout),shout_get_port(sdsc->shout), shout_get_error(sdsc->shout));
}
shout_close(sdsc->shout);
if(stream->savefile != NULL)
fclose(stream->savefile);
shout_free(sdsc->shout);
encode_clear(sdsc->enc);
reencode_clear(sdsc->reenc);
downmix_clear(sdsc->downmix);
resample_clear(sdsc->resamp);
vorbis_comment_clear(&sdsc->vc);
stream->died = 1;
return NULL;
}
int main (int argc, char * argv[]) {
int rate = 44100;
int bits = 16;
int channels = 2;
int codec = ROAR_CODEC_OGG_VORBIS;
char * server = NULL;
char * k;
char * s_server = NULL;
char * s_mount = NULL;
char * s_pw = NULL;
int s_port = -1;
char * s_desc = NULL;
char * s_genre = NULL;
char * s_name = NULL;
char * s_url = NULL;
int s_public = 0;
int fh;
int i;
char buf[BUFSIZE];
shout_t * shout;
for (i = 1; i < argc; i++) {
k = argv[i];
if ( strcmp(k, "--server") == 0 ) {
server = argv[++i];
} else if ( strcmp(k, "--rate") == 0 ) {
rate = atoi(argv[++i]);
} else if ( strcmp(k, "--bits") == 0 ) {
bits = atoi(argv[++i]);
} else if ( strcmp(k, "--channels") == 0 || strcmp(k, "--chans") == 0 ) {
channels = atoi(argv[++i]);
} else if ( strcmp(k, "--codec") == 0 ) {
codec = roar_str2codec(argv[++i]);
} else if ( strcmp(k, "-p") == 0 || strcmp(k, "--public") == 0 ) {
s_public = 1;
} else if ( strcmp(k, "-d") == 0 ) {
s_desc = argv[++i];
} else if ( strcmp(k, "-g") == 0 ) {
s_genre = argv[++i];
} else if ( strcmp(k, "-n") == 0 ) {
s_name = argv[++i];
} else if ( strcmp(k, "-u") == 0 ) {
s_url = argv[++i];
} else if ( strcmp(k, "-h") == 0 || strcmp(k, "--help") == 0 ) {
usage();
return 0;
} else if ( s_server == NULL ) {
s_server = k;
} else if ( s_port == -1 ) {
s_port = atoi(k);
} else if ( s_pw == NULL ) {
s_pw = k;
} else if ( s_mount == NULL ) {
s_mount = k;
} else {
fprintf(stderr, "Error: unknown argument: %s\n", k);
usage();
return 1;
}
}
if ( s_server == NULL )
s_server = "localhost";
if ( s_mount == NULL )
s_mount = "/roar.ogg";
if ( s_pw == NULL )
s_pw = "hackme";
if ( s_port == -1 )
s_port = 8000;
shout_init();
if (!(shout = shout_new())) {
ROAR_ERR("Can not create shout object");
return 1;
}
if (shout_set_host(shout, s_server) != SHOUTERR_SUCCESS) {
ROAR_ERR("Error setting hostname: %s", shout_get_error(shout));
return 1;
}
if (shout_set_protocol(shout, SHOUT_PROTOCOL_HTTP) != SHOUTERR_SUCCESS) {
ROAR_ERR("Error setting protocol: %s", shout_get_error(shout));
return 1;
}
if (shout_set_port(shout, s_port) != SHOUTERR_SUCCESS) {
ROAR_ERR("Error setting port: %s", shout_get_error(shout));
return 1;
}
if (shout_set_password(shout, s_pw) != SHOUTERR_SUCCESS) {
ROAR_ERR("Error setting password: %s", shout_get_error(shout));
return 1;
}
if (shout_set_mount(shout, s_mount) != SHOUTERR_SUCCESS) {
ROAR_ERR("Error setting mount: %s", shout_get_error(shout));
return 1;
}
if (shout_set_user(shout, "source") != SHOUTERR_SUCCESS) {
ROAR_ERR("Error setting user: %s", shout_get_error(shout));
return 1;
}
if (shout_set_format(shout, SHOUT_FORMAT_OGG) != SHOUTERR_SUCCESS) {
ROAR_ERR("Error setting format: %s", shout_get_error(shout));
return 1;
}
shout_set_public(shout, s_public);
if (s_desc != NULL)
shout_set_description(shout, s_desc);
if (s_genre != NULL)
shout_set_genre(shout, s_genre);
if (s_name != NULL)
shout_set_name(shout, s_name);
if (s_url != NULL)
shout_set_url(shout, s_url);
if ( (fh = roar_simple_monitor(rate, channels, bits, codec, server, "roarshout")) == -1 ) {
fprintf(stderr, "Error: can not start monitoring\n");
return 1;
}
if (shout_open(shout) != SHOUTERR_SUCCESS) {
ROAR_ERR("Can not open connection via libshout!");
return -1;
}
while((i = read(fh, buf, BUFSIZE)))
if (shout_send(shout, (unsigned char*)buf, i) != SHOUTERR_SUCCESS)
break;
roar_simple_close(fh);
shout_sync(shout);
shout_close(shout);
shout_shutdown();
return 0;
}
static gboolean
gst_shout2send_start (GstBaseSink * basesink)
{
GstShout2send *sink = GST_SHOUT2SEND (basesink);
const gchar *cur_prop;
gshort proto = 3;
gchar *version_string;
GST_DEBUG_OBJECT (sink, "starting");
sink->conn = shout_new ();
switch (sink->protocol) {
case SHOUT2SEND_PROTOCOL_XAUDIOCAST:
proto = SHOUT_PROTOCOL_XAUDIOCAST;
break;
case SHOUT2SEND_PROTOCOL_ICY:
proto = SHOUT_PROTOCOL_ICY;
break;
case SHOUT2SEND_PROTOCOL_HTTP:
proto = SHOUT_PROTOCOL_HTTP;
break;
}
cur_prop = "protocol";
GST_DEBUG_OBJECT (sink, "setting protocol: %d", sink->protocol);
if (shout_set_protocol (sink->conn, proto) != SHOUTERR_SUCCESS)
goto set_failed;
/* --- FIXME: shout requires an ip, and fails if it is given a host. */
/* may want to put convert_to_ip(shout2send->ip) here */
cur_prop = "ip";
GST_DEBUG_OBJECT (sink, "setting ip: %s", sink->ip);
if (shout_set_host (sink->conn, sink->ip) != SHOUTERR_SUCCESS)
goto set_failed;
cur_prop = "port";
GST_DEBUG_OBJECT (sink, "setting port: %u", sink->port);
if (shout_set_port (sink->conn, sink->port) != SHOUTERR_SUCCESS)
goto set_failed;
cur_prop = "password";
GST_DEBUG_OBJECT (sink, "setting password: %s", sink->password);
if (shout_set_password (sink->conn, sink->password) != SHOUTERR_SUCCESS)
goto set_failed;
cur_prop = "public";
GST_DEBUG_OBJECT (sink, "setting %s: %u", cur_prop, sink->ispublic);
if (shout_set_public (sink->conn,
(sink->ispublic ? 1 : 0)) != SHOUTERR_SUCCESS)
goto set_failed;
cur_prop = "streamname";
GST_DEBUG_OBJECT (sink, "setting %s: %s", cur_prop, sink->streamname);
if (shout_set_name (sink->conn, sink->streamname) != SHOUTERR_SUCCESS)
goto set_failed;
cur_prop = "description";
GST_DEBUG_OBJECT (sink, "setting %s: %s", cur_prop, sink->description);
if (shout_set_description (sink->conn, sink->description) != SHOUTERR_SUCCESS)
goto set_failed;
cur_prop = "genre";
GST_DEBUG_OBJECT (sink, "setting %s: %s", cur_prop, sink->genre);
if (shout_set_genre (sink->conn, sink->genre) != SHOUTERR_SUCCESS)
goto set_failed;
cur_prop = "mount";
GST_DEBUG_OBJECT (sink, "setting %s: %s", cur_prop, sink->mount);
if (shout_set_mount (sink->conn, sink->mount) != SHOUTERR_SUCCESS)
goto set_failed;
cur_prop = "username";
GST_DEBUG_OBJECT (sink, "setting %s: %s", cur_prop, "source");
if (shout_set_user (sink->conn, sink->username) != SHOUTERR_SUCCESS)
goto set_failed;
version_string = gst_version_string ();
cur_prop = "agent";
GST_DEBUG_OBJECT (sink, "setting %s: %s", cur_prop, version_string);
if (shout_set_agent (sink->conn, version_string) != SHOUTERR_SUCCESS) {
g_free (version_string);
goto set_failed;
}
g_free (version_string);
return TRUE;
/* ERROR */
set_failed:
{
GST_ELEMENT_ERROR (sink, LIBRARY, SETTINGS, (NULL),
("Error setting %s: %s", cur_prop, shout_get_error (sink->conn)));
return FALSE;
}
}