Shouter::Shouter()
: Entry() {
/*
int vermaj,vermin,verpat;
shout_version(&vermaj,&vermin,&verpat);
func("Shouter::Shouter() using libshout version %i.%i.%i",vermaj,vermin,verpat);
*/
ice = shout_new();
// to do this, more of the code must be changed
// shout_set_nonblocking(ice,1);
running = false;
retry = 0;
errors = 0;
/* setup defaults */
host("localhost");
ip("127.0.0.1");
port(8000);
pass("hackme");
mount("live");
login(SHOUT_PROTOCOL_HTTP); // defaults to icecast 2 login now
name("Streaming with MuSE");
url("http://muse.dyne.org");
desc("Free Software Multiple Streaming Engine");
bps("24000");
freq("22050");
channels("1");
profile_changed = true;
}
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;
}
}
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());
}
VideoEncoder::VideoEncoder()
: Entry(), JSyncThread() {
initialized = false;
encbuf = NULL;
use_audio = false;
write_to_disk = false;
write_to_stream = false;
filedump_fd = NULL;
status = NULL;
audio_kbps = 0;
video_kbps = 0;
bytes_encoded = 0;
m_ElapsedTime = 0;
m_Streamed = 0;
enc_y = enc_u = enc_v = NULL;
fps = new FPS();
fps->init(25); // default FPS
// initialize the encoded data pipe
// TODO: set the size to width * height * 4 * nframes (3-4)
ringbuffer = ringbuffer_create(1048 * 2096);
shout_init();
if((ice = shout_new()) != NULL) {
if(shout_set_protocol(ice, SHOUT_PROTOCOL_HTTP))
error("shout_set_protocol: %s", shout_get_error(ice));
if(shout_set_format(ice, SHOUT_FORMAT_OGG))
error("shout_set_format: %s", shout_get_error(ice));
if(shout_set_agent(ice, "FreeJ - freej.dyne.org"))
error("shout_set_agent: %s", shout_get_error(ice));
if(shout_set_public(ice, 1))
error("shout_set_public: %s", shout_get_error(ice));
}
func("init picture_yuv for colorspace conversion (avcodec)");
gettimeofday(&m_OldTime, NULL);
//uncomment this and beyond to see how long it takes between two frames
/* m_OldTime.tv_sec = m_lastTime.tv_sec;
m_OldTime.tv_usec = m_lastTime.tv_usec;*/
}
bool OutputIceCast::init()
{
//shout_init();
_shout = shout_new();
if (!_shout)
return false;
if (!applyConnection())
return false;
_state = READY;
emit stateChanged(READY);
emit stateChanged("ready");
emit message("libshout initialized");
emit message("Version: " + getVersion());
return true;
}
static PyObject* pshoutobj_new(PyObject* self, PyObject* args) {
ShoutObject* me;
if (!PyArg_ParseTuple(args, ""))
return NULL;
if (!(me = PyObject_New(ShoutObject, &ShoutObject_Type)))
return NULL;
me->attr = NULL;
if (!(me->conn = shout_new())) {
PyErr_NoMemory();
PyObject_Del(self);
return NULL;
}
return (PyObject*)me;
}
/* Top level initialization function for ices.
* It will parse options, initialize modules,
* and if requested, become a daemon. */
void
ices_setup_initialize (void)
{
ices_stream_t* stream;
shout_init();
/* Setup signal handlers */
ices_signals_setup ();
/* Parse the options in the config file, and the command line */
ices_setup_parse_options (&ices_config);
if (ices_config.daemon)
ices_setup_daemonize ();
/* Open logfiles */
ices_log_initialize ();
/* Initialize the libshout structure */
for (stream = ices_config.streams; stream; stream = stream->next) {
if (!(stream->conn = shout_new ())) {
ices_log ("Could not create shout interface");
ices_setup_shutdown ();
}
}
ices_setup_activate_libshout_changes (&ices_config);
/* Initialize the playlist handler */
ices_playlist_initialize ();
#ifdef HAVE_LIBLAME
/* Initialize liblame for reeencoding */
ices_reencode_initialize ();
#endif
}
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);
}
int main()
{
shout_t *shout;
char buff[4096];
long read, ret, total;
shout_init();
if (!(shout = shout_new())) {
printf("Could not allocate shout_t\n");
return 1;
}
if (shout_set_host(shout, "127.0.0.1") != SHOUTERR_SUCCESS) {
printf("Error setting hostname: %s\n", shout_get_error(shout));
return 1;
}
if (shout_set_protocol(shout, SHOUT_PROTOCOL_HTTP) != SHOUTERR_SUCCESS) {
printf("Error setting protocol: %s\n", shout_get_error(shout));
return 1;
}
if (shout_set_port(shout, 8000) != SHOUTERR_SUCCESS) {
printf("Error setting port: %s\n", shout_get_error(shout));
return 1;
}
if (shout_set_password(shout, "hackme") != SHOUTERR_SUCCESS) {
printf("Error setting password: %s\n", shout_get_error(shout));
return 1;
}
if (shout_set_mount(shout, "/example.ogg") != SHOUTERR_SUCCESS) {
printf("Error setting mount: %s\n", shout_get_error(shout));
return 1;
}
if (shout_set_user(shout, "source") != SHOUTERR_SUCCESS) {
printf("Error setting user: %s\n", shout_get_error(shout));
return 1;
}
if (shout_set_format(shout, SHOUT_FORMAT_OGG) != SHOUTERR_SUCCESS) {
printf("Error setting user: %s\n", shout_get_error(shout));
return 1;
}
if (shout_open(shout) == SHOUTERR_SUCCESS) {
printf("Connected to server...\n");
total = 0;
while (1) {
read = fread(buff, 1, sizeof(buff), stdin);
total = total + read;
if (read > 0) {
ret = shout_send(shout, buff, read);
if (ret != SHOUTERR_SUCCESS) {
printf("DEBUG: Send error: %s\n", shout_get_error(shout));
break;
}
} else {
break;
}
shout_sync(shout);
}
} else {
printf("Error connecting: %s\n", shout_get_error(shout));
}
shout_close(shout);
shout_shutdown();
return 0;
}
/* 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;
}
}
/*****************************************************************************
* 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;
}
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;
}
static switch_status_t shout_file_open(switch_file_handle_t *handle, const char *path)
{
shout_context_t *context;
char *host, *file;
char *username, *password, *port;
char *err = NULL;
const char *mpg123err = NULL;
int portno = 0;
if ((context = switch_core_alloc(handle->memory_pool, sizeof(*context))) == 0) {
return SWITCH_STATUS_MEMERR;
}
if (!handle->samplerate) {
handle->samplerate = 8000;
}
context->memory_pool = handle->memory_pool;
context->samplerate = handle->samplerate;
context->handle = handle;
switch_thread_rwlock_create(&(context->rwlock), context->memory_pool);
switch_thread_rwlock_rdlock(context->rwlock);
switch_mutex_init(&context->audio_mutex, SWITCH_MUTEX_NESTED, context->memory_pool);
if (switch_test_flag(handle, SWITCH_FILE_FLAG_READ)) {
if (switch_buffer_create_dynamic(&context->audio_buffer, TC_BUFFER_SIZE, TC_BUFFER_SIZE * 2, 0) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Memory Error!\n");
goto error;
}
context->mh = our_mpg123_new(NULL, NULL);
if (mpg123_format_all(context->mh) != MPG123_OK) {
MPGERROR();
}
if (mpg123_param(context->mh, MPG123_FORCE_RATE, context->samplerate, 0) != MPG123_OK) {
MPGERROR();
}
if (handle->handler) {
if (mpg123_param(context->mh, MPG123_FLAGS, MPG123_SEEKBUFFER | MPG123_MONO_MIX, 0) != MPG123_OK) {
MPGERROR();
}
if (mpg123_open_feed(context->mh) != MPG123_OK) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error opening mpg feed\n");
mpg123err = mpg123_strerror(context->mh);
goto error;
}
context->stream_url = switch_core_sprintf(context->memory_pool, "http://%s", path);
context->prebuf = handle->prebuf;
launch_read_stream_thread(context);
} else {
handle->seekable = 1;
if (mpg123_param(context->mh, MPG123_FLAGS, MPG123_MONO_MIX, 0) != MPG123_OK) {
MPGERROR();
}
if (mpg123_open(context->mh, path) != MPG123_OK) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error opening %s\n", path);
mpg123err = mpg123_strerror(context->mh);
goto error;
}
}
} else if (switch_test_flag(handle, SWITCH_FILE_FLAG_WRITE)) {
if (switch_test_flag(handle, SWITCH_FILE_WRITE_APPEND)) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Appending to MP3 not supported.\n");
}
if (!(context->gfp = lame_init())) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not allocate lame\n");
goto error;
}
if (!handle->handler) {
id3tag_init(context->gfp);
id3tag_v2_only(context->gfp);
id3tag_pad_v2(context->gfp);
}
context->channels = handle->channels;
lame_set_brate(context->gfp, 16 * (handle->samplerate / 8000) * handle->channels);
lame_set_num_channels(context->gfp, handle->channels);
lame_set_in_samplerate(context->gfp, handle->samplerate);
lame_set_out_samplerate(context->gfp, handle->samplerate);
if (handle->channels == 2) {
lame_set_mode(context->gfp, STEREO);
} else {
lame_set_mode(context->gfp, MONO);
}
lame_set_quality(context->gfp, 2); /* 2=high 5 = medium 7=low */
lame_set_errorf(context->gfp, log_error);
lame_set_debugf(context->gfp, log_debug);
lame_set_msgf(context->gfp, log_msg);
if (handle->handler) {
if (switch_buffer_create_dynamic(&context->audio_buffer, MY_BLOCK_SIZE, MY_BUF_LEN, 0) != SWITCH_STATUS_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Memory Error!\n");
goto error;
}
lame_set_bWriteVbrTag(context->gfp, 0);
lame_mp3_tags_fid(context->gfp, NULL);
username = switch_core_strdup(handle->memory_pool, path);
if (!(password = strchr(username, ':'))) {
err = "invalid url";
goto error;
}
*password++ = '\0';
if (!(host = strchr(password, '@'))) {
err = "invalid url";
goto error;
}
*host++ = '\0';
if ((file = strchr(host, '/'))) {
*file++ = '\0';
} else {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Invalid URL: %s\n", path);
goto error;
}
if ((port = strchr(host, ':'))) {
*port++ = '\0';
if (port) {
portno = atoi(port);
}
}
if (!portno) {
portno = 8000;
}
if (!(context->shout = shout_new())) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Could not allocate shout_t\n");
goto error;
}
if (shout_set_host(context->shout, host) != SHOUTERR_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting hostname: %s\n", shout_get_error(context->shout));
goto error;
}
if (shout_set_protocol(context->shout, SHOUT_PROTOCOL_HTTP) != SHOUTERR_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting protocol: %s\n", shout_get_error(context->shout));
goto error;
}
if (shout_set_port(context->shout, portno) != SHOUTERR_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting port: %s\n", shout_get_error(context->shout));
goto error;
}
if (shout_set_password(context->shout, password) != SHOUTERR_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting password: %s\n", shout_get_error(context->shout));
goto error;
}
if (shout_set_mount(context->shout, file) != SHOUTERR_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting mount: %s\n", shout_get_error(context->shout));
goto error;
}
if (shout_set_user(context->shout, username) != SHOUTERR_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting user: %s\n", shout_get_error(context->shout));
goto error;
}
if (shout_set_url(context->shout, "http://www.freeswitch.org") != SHOUTERR_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting name: %s\n", shout_get_error(context->shout));
goto error;
}
if (shout_set_description(context->shout, "FreeSWITCH mod_shout Broadcasting Module") != SHOUTERR_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting description: %s\n", shout_get_error(context->shout));
goto error;
}
if (shout_set_audio_info(context->shout, "bitrate", "24000") != SHOUTERR_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting bitrate: %s\n", shout_get_error(context->shout));
goto error;
}
if (shout_set_format(context->shout, SHOUT_FORMAT_MP3) != SHOUTERR_SUCCESS) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error setting format: %s\n", shout_get_error(context->shout));
goto error;
}
} else {
/* lame being lame and all has FILE * coded into it's API for some functions so we gotta use it */
if (!(context->fp = fopen(path, "wb+"))) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error opening %s\n", path);
goto error;
}
}
}
handle->samples = 0;
handle->format = 0;
handle->sections = 0;
handle->speed = 0;
handle->private_info = context;
switch_thread_rwlock_unlock(context->rwlock);
return SWITCH_STATUS_SUCCESS;
error:
switch_thread_rwlock_unlock(context->rwlock);
if (err) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error: %s\n", err);
}
if (mpg123err) {
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error from mpg123: %s\n", mpg123err);
}
free_context(context);
return SWITCH_STATUS_GENERR;
}
/*****************************************************************************
* 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;
unsigned int i_port;
vlc_value_t val;
char *psz_accessname = NULL;
char *psz_parser = NULL;
char *psz_user = NULL;
char *psz_pass = NULL;
char *psz_host = NULL;
char *psz_mount = NULL;
char *psz_name = NULL;
char *psz_description = NULL;
char *tmp_port = NULL;
sout_CfgParse( p_access, SOUT_CFG_PREFIX, ppsz_sout_options, p_access->p_cfg );
psz_accessname = psz_parser = strdup( p_access->psz_name );
if( !p_access->psz_name )
{
msg_Err( p_access,
"please specify url=user:password@host:port/mountpoint" );
return VLC_EGENERIC;
}
/* Parse connection data user:pwd@host:port/mountpoint */
psz_user = psz_parser;
while( psz_parser[0] && psz_parser[0] != ':' ) psz_parser++;
if( psz_parser[0] ) { psz_parser[0] = 0; psz_parser++; }
psz_pass = psz_parser;
while( psz_parser[0] && psz_parser[0] != '@' ) psz_parser++;
if( psz_parser[0] ) { psz_parser[0] = 0; psz_parser++; }
psz_host = psz_parser;
while( psz_parser[0] && psz_parser[0] != ':' ) psz_parser++;
if( psz_parser[0] ) { psz_parser[0] = 0; psz_parser++; }
tmp_port = psz_parser;
while( psz_parser[0] && psz_parser[0] != '/' ) psz_parser++;
if( psz_parser[0] ) { psz_parser[0] = 0; psz_parser++; }
psz_mount = psz_parser;
i_port = atoi( tmp_port );
p_sys = p_access->p_sys = malloc( sizeof( sout_access_out_sys_t ) );
if( !p_sys )
{
msg_Err( p_access, "out of memory" );
free( psz_accessname );
return VLC_ENOMEM;
}
var_Get( p_access, SOUT_CFG_PREFIX "name", &val );
if( *val.psz_string )
psz_name = val.psz_string;
else
free( val.psz_string );
var_Get( p_access, SOUT_CFG_PREFIX "description", &val );
if( *val.psz_string )
psz_description = val.psz_string;
else
free( val.psz_string );
p_shout = p_sys->p_shout = shout_new();
if( !p_shout
|| shout_set_host( p_shout, psz_host ) != SHOUTERR_SUCCESS
|| shout_set_protocol( p_shout, SHOUT_PROTOCOL_ICY ) != SHOUTERR_SUCCESS
|| shout_set_port( p_shout, i_port ) != SHOUTERR_SUCCESS
|| shout_set_password( p_shout, psz_pass ) != SHOUTERR_SUCCESS
|| shout_set_mount( p_shout, psz_mount ) != SHOUTERR_SUCCESS
|| shout_set_user( p_shout, psz_user ) != 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_nonblocking( p_shout, 1 ) != SHOUTERR_SUCCESS */
)
{
msg_Err( p_access, "failed to initialize shout streaming to %s:%i/%s",
psz_host, i_port, psz_mount );
free( p_access->p_sys );
free( psz_accessname );
return VLC_EGENERIC;
}
if( psz_name ) free( psz_name );
if( psz_description ) free( psz_description );
var_Get( p_access, SOUT_CFG_PREFIX "mp3", &val );
if( val.b_bool == VLC_TRUE )
i_ret = shout_set_format( p_shout, SHOUT_FORMAT_MP3 );
else
i_ret = shout_set_format( p_shout, SHOUT_FORMAT_OGG );
if( i_ret != SHOUTERR_SUCCESS )
{
msg_Err( p_access, "failed to set the shoutcast streaming format" );
free( p_access->p_sys );
free( psz_accessname );
return VLC_EGENERIC;
}
/* Shoutcast using ICY protocol */
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'" );
free( p_access->p_sys );
free( psz_accessname );
return VLC_EGENERIC;
}
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_Err( p_access, "failed to open shout stream to %s:%i/%s: %s",
psz_host, i_port, psz_mount, shout_get_error(p_shout) );
free( p_access->p_sys );
free( psz_accessname );
return VLC_EGENERIC;
}
p_access->pf_write = Write;
p_access->pf_read = Read;
p_access->pf_seek = Seek;
msg_Dbg( p_access, "shout access output opened (%s@%s:%i/%s)",
psz_user, psz_host, i_port, psz_mount );
/* Update pace control flag */
if( p_access->psz_access && !strcmp( p_access->psz_access, "stream" ) )
{
p_access->p_sout->i_out_pace_nocontrol++;
}
free( psz_accessname );
return VLC_SUCCESS;
}