int icecast_init(char *error, int errsize)
{
(void)error;
(void)errsize;
(void)this_module;
shout_init();
return MSERV_SUCCESS;
}
static void *
my_shout_init_driver(const struct audio_format *audio_format,
const struct config_param *param,
GError **error)
{
struct shout_data *sd;
char *test;
unsigned port;
char *host;
char *mount;
char *passwd;
const char *encoding;
const struct encoder_plugin *encoder_plugin;
unsigned shout_format;
unsigned protocol;
const char *user;
char *name;
const char *value;
struct block_param *block_param;
int public;
if (audio_format == NULL ||
!audio_format_fully_defined(audio_format)) {
g_set_error(error, shout_output_quark(), 0,
"Need full audio format specification");
return NULL;
}
sd = new_shout_data();
if (shout_init_count == 0)
shout_init();
shout_init_count++;
check_block_param("host");
host = block_param->value;
check_block_param("mount");
mount = block_param->value;
port = config_get_block_unsigned(param, "port", 0);
if (port == 0) {
g_set_error(error, shout_output_quark(), 0,
"shout port must be configured");
return NULL;
}
check_block_param("password");
passwd = block_param->value;
check_block_param("name");
name = block_param->value;
public = config_get_block_bool(param, "public", false);
OutputIceCast::OutputIceCast()
: _shout(0),
_state(INVALID),
_timer(new QTimer(this))
{
_timer->setInterval(5000);
_timer->setSingleShot(false);
connect(_timer, SIGNAL(timeout()), this, SLOT(connectStream()));
connect(this, SIGNAL(requestReconnect()), this, SLOT(reconnectStream()), Qt::QueuedConnection);
shout_init();
}
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;*/
}
void init_stream(void) {
time_t now;
shout_init();
streams = SCM_EOL;
now = time(NULL);
srand(now);
init_stream_flac();
init_stream_vorbis();
init_stream_mp3();
init_stream_opus();
shout_wait.tv_sec = (int)SHOUT_WAIT_TIME;
shout_wait.tv_nsec = (SHOUT_WAIT_TIME - shout_wait.tv_sec) * 1000000000;
scm_c_define_gsubr("stream-stop", 1, 0, 0, stop_stream);
log_msg("libshout version %s\n", shout_version(NULL, NULL, NULL));
return;
}
int main( void )
{
/* greeting */
puts("OpenPONIKO 3.0 - Compiled on " __DATE__ " " __TIME__);
/* shoutbot */
if ( shout_init() )
return bail("Couldn't init shoutbot core\n");
/* activity */
if ( lseen_init() )
return bail("Couldn't init lastseen core\n");
/* load config */
if ( loadcfg() )
return bail("Couldn't load configuration\n");
if ( ircopen() )
return bail("Couldn't connect to default irc server\n");
while ( active )
process();
return (ircclose()||shout_quit()||lseen_quit())!=0;
}
/* 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
}
int
main(int argc, char *argv[])
{
int c;
char *configFile = NULL;
char *host = NULL;
unsigned short port = 0;
char *mount = NULL;
shout_t *shout;
extern char *optarg;
extern int optind;
#ifdef HAVE_SIGNALS
struct sigaction act;
unsigned int i;
#endif
#ifdef XALLOC_DEBUG
xalloc_initialize_debug(2, NULL);
#else
xalloc_initialize();
#endif /* XALLOC_DEBUG */
playlist_init();
shout_init();
__progname = getProgname(argv[0]);
pezConfig = getEZConfig();
mFlag = 0;
nFlag = 0;
qFlag = 0;
vFlag = 0;
while ((c = local_getopt(argc, argv, "c:hmnqsVv")) != -1) {
switch (c) {
case 'c':
if (configFile != NULL) {
printf("Error: multiple -c arguments given\n");
usage();
return (ez_shutdown(2));
}
configFile = xstrdup(optarg);
break;
case 'h':
usage();
usageHelp();
return (ez_shutdown(0));
case 'm':
mFlag = 1;
break;
case 'n':
nFlag = 1;
break;
case 'q':
qFlag = 1;
break;
case 's':
sFlag = 1;
break;
case 'V':
printf("%s\n", PACKAGE_STRING);
return (ez_shutdown(0));
case 'v':
vFlag++;
break;
case '?':
usage();
return (ez_shutdown(2));
default:
break;
}
}
argc -= optind;
argv += optind;
if (sFlag) {
playlist_t *pl;
const char *entry;
switch (argc) {
case 0:
pl = playlist_read(NULL);
if (pl == NULL)
return (ez_shutdown(1));
break;
case 1:
pl = playlist_read(argv[0]);
if (pl == NULL)
return (ez_shutdown(1));
break;
default:
printf("Error: Too many arguments.\n");
return (ez_shutdown(2));
}
playlist_shuffle(pl);
while ((entry = playlist_get_next(pl)) != NULL)
printf("%s\n", entry);
playlist_free(&pl);
return (ez_shutdown(0));
}
if (configFile == NULL) {
printf("You must supply a config file with the -c argument.\n");
usage();
return (ez_shutdown(2));
} else {
/*
* Attempt to open configFile here for a more meaningful error
* message. Where possible, do it with stat() and check for
* safe config file permissions.
*/
#ifdef HAVE_STAT
struct stat st;
if (stat(configFile, &st) == -1) {
printf("%s: %s\n", configFile, strerror(errno));
usage();
return (ez_shutdown(2));
}
if (vFlag && (st.st_mode & (S_IRGRP | S_IROTH)))
printf("%s: Warning: %s is group and/or world readable\n",
__progname, configFile);
if (st.st_mode & (S_IWGRP | S_IWOTH)) {
printf("%s: Error: %s is group and/or world writeable\n",
__progname, configFile);
return (ez_shutdown(2));
}
#else
FILE *tmp;
if ((tmp = fopen(configFile, "r")) == NULL) {
printf("%s: %s\n", configFile, strerror(errno));
usage();
return (ez_shutdown(2));
}
fclose(tmp);
#endif /* HAVE_STAT */
}
if (!parseConfig(configFile))
return (ez_shutdown(2));
if (pezConfig->URL == NULL) {
printf("%s: Error: Missing <url>\n", configFile);
return (ez_shutdown(2));
}
if (!urlParse(pezConfig->URL, &host, &port, &mount)) {
printf("Must be of the form ``http://server:port/mountpoint''\n");
return (ez_shutdown(2));
}
if (strlen(host) == 0) {
printf("%s: Error: Invalid <url>: Missing server:\n", configFile);
printf("Must be of the form ``http://server:port/mountpoint''\n");
return (ez_shutdown(2));
}
if (strlen(mount) == 0) {
printf("%s: Error: Invalid <url>: Missing mountpoint:\n", configFile);
printf("Must be of the form ``http://server:port/mountpoint''\n");
return (ez_shutdown(2));
}
if (pezConfig->password == NULL) {
printf("%s: Error: Missing <sourcepassword>\n", configFile);
return (ez_shutdown(2));
}
if (pezConfig->fileName == NULL) {
printf("%s: Error: Missing <filename>\n", configFile);
return (ez_shutdown(2));
}
if (pezConfig->format == NULL) {
printf("%s: Warning: Missing <format>:\n", configFile);
printf("Specify a stream format of either MP3, VORBIS or THEORA\n");
}
xfree(configFile);
if ((shout = stream_setup(host, port, mount)) == NULL)
return (ez_shutdown(1));
if (pezConfig->metadataProgram != NULL)
metadataFromProgram = 1;
else
metadataFromProgram = 0;
#ifdef HAVE_SIGNALS
memset(&act, 0, sizeof(act));
act.sa_handler = sig_handler;
# ifdef SA_RESTART
act.sa_flags = SA_RESTART;
# endif
for (i = 0; i < sizeof(ezstream_signals) / sizeof(int); i++) {
if (sigaction(ezstream_signals[i], &act, NULL) == -1) {
printf("%s: sigaction(): %s\n",
__progname, strerror(errno));
return (ez_shutdown(1));
}
}
/*
* Ignore SIGPIPE, which has been seen to give a long-running ezstream
* process trouble. EOF and/or EPIPE are also easier to handle.
*/
act.sa_handler = SIG_IGN;
if (sigaction(SIGPIPE, &act, NULL) == -1) {
printf("%s: sigaction(): %s\n",
__progname, strerror(errno));
return (ez_shutdown(1));
}
#endif /* HAVE_SIGNALS */
if (shout_open(shout) == SHOUTERR_SUCCESS) {
int ret;
printf("%s: Connected to http://%s:%hu%s\n", __progname,
host, port, mount);
if (pezConfig->fileNameIsProgram ||
strrcasecmp(pezConfig->fileName, ".m3u") == 0 ||
strrcasecmp(pezConfig->fileName, ".txt") == 0)
playlistMode = 1;
else
playlistMode = 0;
if (vFlag && pezConfig->fileNameIsProgram)
printf("%s: Using program '%s' to get filenames for streaming\n",
__progname, pezConfig->fileName);
do {
if (playlistMode) {
ret = streamPlaylist(shout,
pezConfig->fileName);
} else {
ret = streamFile(shout, pezConfig->fileName);
}
if (quit)
break;
if (pezConfig->streamOnce)
break;
} while (ret);
shout_close(shout);
} else
printf("%s: Connection to http://%s:%hu%s failed: %s\n", __progname,
host, port, mount, shout_get_error(shout));
if (quit)
printf("\r%s: SIGINT or SIGTERM received\n", __progname);
if (vFlag)
printf("%s: Exiting ...\n", __progname);
xfree(host);
xfree(mount);
playlist_free(&playlist);
return (ez_shutdown(0));
}
int main(int argc, char **argv)
{
char logpath[FILENAME_MAX];
int log;
if (argc != 2)
{
fprintf(stderr, PACKAGE_STRING "\n"
" (c) Copyright 2001-2004 The IceS Development Team <*****@*****.**>\n"
" Michael Smith <*****@*****.**>\n"
" Karl Heyes <*****@*****.**>\n"
" and others\n"
"\n"
"Usage: \"ices config.xml\"\n");
return 1;
}
config_initialize();
if (config_read(argv[1]) <= 0)
{
fprintf(stderr, "Failed to read config file \"%s\"\n", argv[1]);
goto fail;
}
if (ices_config->background)
{
#ifndef _WIN32
int ret = 0;
/* Start up new session, to lose old session and process group */
switch (fork())
{
case 0: break; /* child continues */
case -1: perror ("fork"); ret = -1;
default:
exit (ret);
}
/* Disassociate process group and controlling terminal */
setsid();
/* Become a NON-session leader so that a */
/* control terminal can't be reacquired */
switch (fork())
{
case 0: break; /* child continues */
case -1: perror ("fork"); ret = -1;
default:
exit (ret);
}
#else
FreeConsole();
#endif
}
log_initialize();
thread_initialize();
shout_init();
encode_init();
#ifndef _WIN32
signals_setup();
#endif
snprintf(logpath, FILENAME_MAX, "%s/%s", ices_config->logpath,
ices_config->logfile);
if(ices_config->log_stderr)
log = log_open_file(stderr);
else
{
log = log_open(logpath);
if (log < 0)
fprintf (stderr, "unable to open log %s\n", logpath);
log_set_trigger (log, ices_config->logsize);
}
/* Set the log level, if requested - defaults to 2 (WARN) otherwise */
if (ices_config->loglevel)
log_set_level(log, ices_config->loglevel);
ices_config->log_id = log;
LOG_INFO0(PACKAGE_STRING " started...");
if (ices_config->pidfile != NULL)
{
FILE *f = fopen (ices_config->pidfile, "w");
if (f)
{
fprintf (f, "%i", getpid());
fclose (f);
}
else
{
LOG_WARN1("pidfile \"%s\" cannot be written to", ices_config->pidfile);
xmlFree (ices_config->pidfile);
ices_config->pidfile = NULL;
}
}
/* Start the core streaming loop */
input_loop();
if (ices_config->pidfile)
remove (ices_config->pidfile);
LOG_INFO0("Shutdown complete");
log_close(log);
fail:
encode_close();
shout_shutdown();
config_shutdown();
thread_shutdown();
log_shutdown();
return 0;
}
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;
}
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;
}
