void program_deinit(void){
/* Close libnotify */
if(notifing) notify_uninit();
gconfig_shutdown();
online_service_request_unset_selected_update();
online_services_deinit();
proxy_deinit();
ipc_deinit();
www_deinit();
groups_deinit();
images_deinit();
cache_deinit();
xml_parser_deinit();
debug("**NOTICE:** %s exited", GETTEXT_PACKAGE);
debug_deinit();
datetime_locale_deinit();
}/*program_deinit();*/
int
main(int argc, char **argv)
{
int option;
char *configfile;
int background;
int mdns_no_rsp;
int mdns_no_daap;
int loglevel;
char *logdomains;
char *logfile;
char *ffid;
char *pidfile;
const char *gcry_version;
sigset_t sigs;
int sigfd;
#if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
struct kevent ke_sigs[4];
#endif
int ret;
struct option option_map[] =
{
{ "ffid", 1, NULL, 'b' },
{ "debug", 1, NULL, 'd' },
{ "logdomains", 1, NULL, 'D' },
{ "foreground", 0, NULL, 'f' },
{ "config", 1, NULL, 'c' },
{ "pidfile", 1, NULL, 'P' },
{ "version", 0, NULL, 'v' },
{ "mdns-no-rsp", 0, NULL, 512 },
{ "mdns-no-daap", 0, NULL, 513 },
{ NULL, 0, NULL, 0 }
};
configfile = CONFFILE;
pidfile = PIDFILE;
loglevel = -1;
logdomains = NULL;
logfile = NULL;
background = 1;
ffid = NULL;
mdns_no_rsp = 0;
mdns_no_daap = 0;
while ((option = getopt_long(argc, argv, "D:d:c:P:fb:v", option_map, NULL)) != -1)
{
switch (option)
{
case 512:
mdns_no_rsp = 1;
break;
case 513:
mdns_no_daap = 1;
break;
case 'b':
ffid = optarg;
break;
case 'd':
ret = safe_atoi32(optarg, &option);
if (ret < 0)
fprintf(stderr, "Error: loglevel must be an integer in '-d %s'\n", optarg);
else
loglevel = option;
break;
case 'D':
logdomains = optarg;
break;
case 'f':
background = 0;
break;
case 'c':
configfile = optarg;
break;
case 'P':
pidfile = optarg;
break;
case 'v':
version();
return EXIT_SUCCESS;
break;
default:
usage(argv[0]);
return EXIT_FAILURE;
break;
}
}
ret = logger_init(NULL, NULL, (loglevel < 0) ? E_LOG : loglevel);
if (ret != 0)
{
fprintf(stderr, "Could not initialize log facility\n");
return EXIT_FAILURE;
}
ret = conffile_load(configfile);
if (ret != 0)
{
DPRINTF(E_FATAL, L_MAIN, "Config file errors; please fix your config\n");
logger_deinit();
return EXIT_FAILURE;
}
logger_deinit();
/* Reinit log facility with configfile values */
if (loglevel < 0)
loglevel = cfg_getint(cfg_getsec(cfg, "general"), "loglevel");
logfile = cfg_getstr(cfg_getsec(cfg, "general"), "logfile");
ret = logger_init(logfile, logdomains, loglevel);
if (ret != 0)
{
fprintf(stderr, "Could not reinitialize log facility with config file settings\n");
conffile_unload();
return EXIT_FAILURE;
}
/* Set up libevent logging callback */
event_set_log_callback(logger_libevent);
DPRINTF(E_LOG, L_MAIN, "Forked Media Server Version %s taking off\n", VERSION);
ret = av_lockmgr_register(ffmpeg_lockmgr);
if (ret < 0)
{
DPRINTF(E_FATAL, L_MAIN, "Could not register ffmpeg lock manager callback\n");
ret = EXIT_FAILURE;
goto ffmpeg_init_fail;
}
av_register_all();
#if LIBAVFORMAT_VERSION_MAJOR >= 54 || (LIBAVFORMAT_VERSION_MAJOR == 53 && LIBAVFORMAT_VERSION_MINOR >= 13)
avformat_network_init();
#endif
av_log_set_callback(logger_ffmpeg);
#ifdef LASTFM
/* Initialize libcurl */
curl_global_init(CURL_GLOBAL_DEFAULT);
#endif
/* Initialize libgcrypt */
gcry_control(GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread);
gcry_version = gcry_check_version(GCRYPT_VERSION);
if (!gcry_version)
{
DPRINTF(E_FATAL, L_MAIN, "libgcrypt version mismatch\n");
ret = EXIT_FAILURE;
goto gcrypt_init_fail;
}
/* We aren't handling anything sensitive, so give up on secure
* memory, which is a scarce system resource.
*/
gcry_control(GCRYCTL_DISABLE_SECMEM, 0);
gcry_control(GCRYCTL_INITIALIZATION_FINISHED, 0);
DPRINTF(E_DBG, L_MAIN, "Initialized with gcrypt %s\n", gcry_version);
/* Block signals for all threads except the main one */
sigemptyset(&sigs);
sigaddset(&sigs, SIGINT);
sigaddset(&sigs, SIGHUP);
sigaddset(&sigs, SIGCHLD);
sigaddset(&sigs, SIGTERM);
sigaddset(&sigs, SIGPIPE);
ret = pthread_sigmask(SIG_BLOCK, &sigs, NULL);
if (ret != 0)
{
DPRINTF(E_LOG, L_MAIN, "Error setting signal set\n");
ret = EXIT_FAILURE;
goto signal_block_fail;
}
/* Daemonize and drop privileges */
ret = daemonize(background, pidfile);
if (ret < 0)
{
DPRINTF(E_LOG, L_MAIN, "Could not initialize server\n");
ret = EXIT_FAILURE;
goto daemon_fail;
}
/* Initialize libevent (after forking) */
evbase_main = event_init();
DPRINTF(E_LOG, L_MAIN, "mDNS init\n");
ret = mdns_init();
if (ret != 0)
{
DPRINTF(E_FATAL, L_MAIN, "mDNS init failed\n");
ret = EXIT_FAILURE;
goto mdns_fail;
}
/* Initialize the database before starting */
DPRINTF(E_INFO, L_MAIN, "Initializing database\n");
ret = db_init();
if (ret < 0)
{
DPRINTF(E_FATAL, L_MAIN, "Database init failed\n");
ret = EXIT_FAILURE;
goto db_fail;
}
/* Open a DB connection for the main thread */
ret = db_perthread_init();
if (ret < 0)
{
DPRINTF(E_FATAL, L_MAIN, "Could not perform perthread DB init for main\n");
ret = EXIT_FAILURE;
goto db_fail;
}
/* Spawn worker thread */
ret = worker_init();
if (ret != 0)
{
DPRINTF(E_FATAL, L_MAIN, "Worker thread failed to start\n");
ret = EXIT_FAILURE;
goto worker_fail;
}
/* Spawn cache thread */
ret = cache_init();
if (ret != 0)
{
DPRINTF(E_FATAL, L_MAIN, "Cache thread failed to start\n");
ret = EXIT_FAILURE;
goto cache_fail;
}
/* Spawn file scanner thread */
ret = filescanner_init();
if (ret != 0)
{
DPRINTF(E_FATAL, L_MAIN, "File scanner thread failed to start\n");
ret = EXIT_FAILURE;
goto filescanner_fail;
}
#ifdef HAVE_SPOTIFY_H
/* Spawn Spotify thread */
ret = spotify_init();
if (ret < 0)
{
DPRINTF(E_INFO, L_MAIN, "Spotify thread not started\n");;
}
#endif
/* Spawn player thread */
ret = player_init();
if (ret != 0)
{
DPRINTF(E_FATAL, L_MAIN, "Player thread failed to start\n");
ret = EXIT_FAILURE;
goto player_fail;
}
/* Spawn HTTPd thread */
ret = httpd_init();
if (ret != 0)
{
DPRINTF(E_FATAL, L_MAIN, "HTTPd thread failed to start\n");
ret = EXIT_FAILURE;
goto httpd_fail;
}
#ifdef MPD
/* Spawn MPD thread */
ret = mpd_init();
if (ret != 0)
{
DPRINTF(E_FATAL, L_MAIN, "MPD thread failed to start\n");
ret = EXIT_FAILURE;
goto mpd_fail;
}
#endif
/* Start Remote pairing service */
ret = remote_pairing_init();
if (ret != 0)
{
DPRINTF(E_FATAL, L_MAIN, "Remote pairing service failed to start\n");
ret = EXIT_FAILURE;
goto remote_fail;
}
/* Register mDNS services */
ret = register_services(ffid, mdns_no_rsp, mdns_no_daap);
if (ret < 0)
{
ret = EXIT_FAILURE;
goto mdns_reg_fail;
}
#if defined(__linux__)
/* Set up signal fd */
sigfd = signalfd(-1, &sigs, SFD_NONBLOCK | SFD_CLOEXEC);
if (sigfd < 0)
{
DPRINTF(E_FATAL, L_MAIN, "Could not setup signalfd: %s\n", strerror(errno));
ret = EXIT_FAILURE;
goto signalfd_fail;
}
event_set(&sig_event, sigfd, EV_READ, signal_signalfd_cb, NULL);
#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
sigfd = kqueue();
if (sigfd < 0)
{
DPRINTF(E_FATAL, L_MAIN, "Could not setup kqueue: %s\n", strerror(errno));
ret = EXIT_FAILURE;
goto signalfd_fail;
}
EV_SET(&ke_sigs[0], SIGINT, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL);
EV_SET(&ke_sigs[1], SIGTERM, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL);
EV_SET(&ke_sigs[2], SIGHUP, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL);
EV_SET(&ke_sigs[3], SIGCHLD, EVFILT_SIGNAL, EV_ADD, 0, 0, NULL);
ret = kevent(sigfd, ke_sigs, 4, NULL, 0, NULL);
if (ret < 0)
{
DPRINTF(E_FATAL, L_MAIN, "Could not register signal events: %s\n", strerror(errno));
ret = EXIT_FAILURE;
goto signalfd_fail;
}
event_set(&sig_event, sigfd, EV_READ, signal_kqueue_cb, NULL);
#endif
event_base_set(evbase_main, &sig_event);
event_add(&sig_event, NULL);
/* Run the loop */
event_base_dispatch(evbase_main);
DPRINTF(E_LOG, L_MAIN, "Stopping gracefully\n");
ret = EXIT_SUCCESS;
/*
* On a clean shutdown, bring mDNS down first to give a chance
* to the clients to perform a clean shutdown on their end
*/
DPRINTF(E_LOG, L_MAIN, "mDNS deinit\n");
mdns_deinit();
signalfd_fail:
mdns_reg_fail:
DPRINTF(E_LOG, L_MAIN, "Remote pairing deinit\n");
remote_pairing_deinit();
remote_fail:
DPRINTF(E_LOG, L_MAIN, "HTTPd deinit\n");
httpd_deinit();
httpd_fail:
DPRINTF(E_LOG, L_MAIN, "TCPd deinit\n");
#ifdef MPD
DPRINTF(E_LOG, L_MAIN, "MPD deinit\n");
mpd_deinit();
mpd_fail:
#endif
DPRINTF(E_LOG, L_MAIN, "Player deinit\n");
player_deinit();
player_fail:
#ifdef HAVE_SPOTIFY_H
DPRINTF(E_LOG, L_MAIN, "Spotify deinit\n");
spotify_deinit();
#endif
DPRINTF(E_LOG, L_MAIN, "File scanner deinit\n");
filescanner_deinit();
filescanner_fail:
DPRINTF(E_LOG, L_MAIN, "Cache deinit\n");
cache_deinit();
cache_fail:
DPRINTF(E_LOG, L_MAIN, "Worker deinit\n");
worker_deinit();
worker_fail:
DPRINTF(E_LOG, L_MAIN, "Database deinit\n");
db_perthread_deinit();
db_deinit();
db_fail:
if (ret == EXIT_FAILURE)
{
DPRINTF(E_LOG, L_MAIN, "mDNS deinit\n");
mdns_deinit();
}
mdns_fail:
daemon_fail:
if (background)
{
ret = seteuid(0);
if (ret < 0)
DPRINTF(E_LOG, L_MAIN, "seteuid() failed: %s\n", strerror(errno));
else
{
ret = unlink(pidfile);
if (ret < 0)
DPRINTF(E_LOG, L_MAIN, "Could not unlink PID file %s: %s\n", pidfile, strerror(errno));
}
}
signal_block_fail:
gcrypt_init_fail:
#ifdef LASTFM
curl_global_cleanup();
#endif
#if LIBAVFORMAT_VERSION_MAJOR >= 54 || (LIBAVFORMAT_VERSION_MAJOR == 53 && LIBAVFORMAT_VERSION_MINOR >= 13)
avformat_network_deinit();
#endif
av_lockmgr_register(NULL);
ffmpeg_init_fail:
DPRINTF(E_LOG, L_MAIN, "Exiting.\n");
conffile_unload();
logger_deinit();
return ret;
}
int main(int argc, char *argv[])
{
int err;
done = 0;
FILE *sound_in_fd = NULL;
FILE *sound_out_fd = NULL;
int channels;
short *buffer = NULL;
int buffer_l;
int buffer_read;
struct serial_state_t *serial = NULL;
struct ipc_state_t *ipc = NULL;
struct receiver *rx_a = NULL;
struct receiver *rx_b = NULL;
/* open syslog, write an initial log message and read configuration */
open_log(logname, 0);
hlog(LOG_NOTICE, "Starting up...");
if (read_config()) {
hlog(LOG_CRIT, "Initial configuration failed.");
exit(1);
}
/* initialize position cache for timed JSON AIS transmission */
if (uplink_config) {
hlog(LOG_DEBUG, "Initializing cache...");
if (cache_init())
exit(1);
hlog(LOG_DEBUG, "Initializing jsonout...");
if (jsonout_init())
exit(1);
}
/* initialize the AIS decoders */
if (sound_channels != SOUND_CHANNELS_MONO) {
hlog(LOG_DEBUG, "Initializing demodulator A");
rx_a = init_receiver('A', 2, 0,ipc);
hlog(LOG_DEBUG, "Initializing demodulator B");
rx_b = init_receiver('B', 2, 1,ipc);
channels = 2;
} else {
hlog(LOG_DEBUG, "Initializing demodulator A");
rx_a = init_receiver('A', 1, 0,ipc);
channels = 1;
}
printf("HEJ!");
hlog(LOG_NOTICE, "Reading audio from blob.");
buffer_l = 1024;
int extra = buffer_l % 5;
buffer_l -= extra;
buffer = (short *) hmalloc(buffer_l * sizeof(short) * channels);
hlog(LOG_NOTICE, "Started");
int dataoffset = 0;
#define AAA 0
#if AAA
sound_in_fd = fopen("xaa", "rb");
#endif
while (!done) {
printf(".");
#if AAA
buffer_read = fread(buffer, channels * sizeof(short), buffer_l, sound_in_fd);
if (buffer_read <= 0)
done = 1;
#else
memcpy(buffer, staticSoundData + dataoffset, buffer_l * channels * sizeof(short));
dataoffset += buffer_l * channels;
if (dataoffset >= sizeof(staticSoundData) / sizeof(short)) {
done = 1;
}
buffer_read = buffer_l;
#endif
# if 0
printf("buffer_read: %d\n", buffer_read);
int xx;
for (xx = 0; xx < buffer_l * channels; xx++)
printf("%x ", buffer[xx]);
done = 1;
#endif
if (sound_channels == SOUND_CHANNELS_MONO) {
receiver_run(rx_a, buffer, buffer_read);
}
if (sound_channels == SOUND_CHANNELS_BOTH
|| sound_channels == SOUND_CHANNELS_RIGHT) {
/* ch a/0/right */
receiver_run(rx_a, buffer, buffer_read);
}
if (sound_channels == SOUND_CHANNELS_BOTH
|| sound_channels == SOUND_CHANNELS_LEFT) {
/* ch b/1/left */
receiver_run(rx_b, buffer, buffer_read);
}
}
hlog(LOG_NOTICE, "Closing down...");
if (sound_in_fd) {
fclose(sound_in_fd);
}
hfree(buffer);
if (uplink_config)
jsonout_deinit();
if (cache_positions)
cache_deinit();
if (rx_a) {
struct demod_state_t *d = rx_a->decoder;
hlog(LOG_INFO,
"A: Received correctly: %d packets, wrong CRC: %d packets, wrong size: %d packets",
d->receivedframes, d->lostframes,
d->lostframes2);
}
if (rx_b) {
struct demod_state_t *d = rx_b->decoder;
hlog(LOG_INFO,
"B: Received correctly: %d packets, wrong CRC: %d packets, wrong size: %d packets",
d->receivedframes, d->lostframes,
d->lostframes2);
}
free_receiver(rx_a);
free_receiver(rx_b);
free_config();
close_log(0);
return 0;
}
int main(int argc, char** argv) {
CURL *easy;
CURLcode curl_res;
char *tmp;
int res;
struct fuse_args args = FUSE_ARGS_INIT(argc, argv);
/* Initialize curl library before we are a multithreaded program */
curl_global_init(CURL_GLOBAL_ALL);
memset(&ftpfs, 0, sizeof ftpfs);
/* Set some default values */
ftpfs.curl_version = curl_version_info(CURLVERSION_NOW);
ftpfs.safe_nobody = ftpfs.curl_version->version_num > CURLFTPFS_BAD_NOBODY;
ftpfs.blksize = 4096;
ftpfs.disable_epsv = 1;
ftpfs.multiconn = 1;
ftpfs.attached_to_multi = 0;
if (fuse_opt_parse(&args, &ftpfs, ftpfs_opts, ftpfs_opt_proc) == -1)
return 1;
if (!ftpfs.host) {
fprintf(stderr, "missing host\n");
fprintf(stderr, "see `%s -h' for usage\n", argv[0]);
return 1;
}
if (!ftpfs.iocharset) {
ftpfs.iocharset = "UTF8";
}
if (ftpfs.codepage) {
convert_charsets(ftpfs.iocharset, ftpfs.codepage, &ftpfs.host);
}
easy = curl_easy_init();
if (easy == NULL) {
fprintf(stderr, "Error initializing libcurl\n");
return 1;
}
res = cache_parse_options(&args);
if (res == -1)
return 1;
if (!prompt_passwd("host", &ftpfs.user))
return 1;
if (!prompt_passwd("proxy", &ftpfs.proxy_user))
return 1;
if (ftpfs.transform_symlinks && !ftpfs.mountpoint) {
fprintf(stderr, "cannot transform symlinks: no mountpoint given\n");
return 1;
}
if (!ftpfs.transform_symlinks)
ftpfs.symlink_prefix_len = 0;
else if (realpath(ftpfs.mountpoint, ftpfs.symlink_prefix) != NULL)
ftpfs.symlink_prefix_len = strlen(ftpfs.symlink_prefix);
else {
fprintf(stderr, "unable to normalize mount path\n");
return 1;
}
set_common_curl_stuff(easy);
curl_easy_setopt_or_die(easy, CURLOPT_WRITEDATA, NULL);
curl_easy_setopt_or_die(easy, CURLOPT_NOBODY, ftpfs.safe_nobody);
curl_res = curl_easy_perform(easy);
if (curl_res != 0)
ftpfs_curl_easy_perform_abort();
curl_easy_setopt_or_die(easy, CURLOPT_NOBODY, 0);
ftpfs.multi = curl_multi_init();
if (ftpfs.multi == NULL) {
fprintf(stderr, "Error initializing libcurl multi\n");
return 1;
}
ftpfs.connection = easy;
pthread_mutex_init(&ftpfs.lock, NULL);
/* Set the filesystem name to show the current server */
tmp = g_strdup_printf("-ofsname=curlftpfs#%s", ftpfs.host);
fuse_opt_insert_arg(&args, 1, tmp);
g_free(tmp);
res = ftpfs_fuse_main(&args);
cancel_previous_multi();
curl_multi_cleanup(ftpfs.multi);
curl_easy_cleanup(easy);
curl_global_cleanup();
fuse_opt_free_args(&args);
pthread_mutex_destroy(&ftpfs.lock);
cache_deinit();
return res;
}
int main(int argc, char *argv[])
{
int err;
done = 0;
snd_pcm_t *handle;
FILE *sound_in_fd = NULL;
FILE *sound_out_fd = NULL;
int channels;
short *buffer = NULL;
int buffer_l;
int buffer_read;
struct serial_state_t *serial = NULL;
struct ipc_state_t *ipc = NULL;
struct receiver *rx_a = NULL;
struct receiver *rx_b = NULL;
#ifdef HAVE_PULSEAUDIO
pa_simple *pa_dev = NULL;
#endif
/* command line */
parse_cmdline(argc, argv);
/* open syslog, write an initial log message and read configuration */
open_log(logname, 0);
hlog(LOG_NOTICE, "Starting up...");
if (read_config()) {
hlog(LOG_CRIT, "Initial configuration failed.");
exit(1);
}
/* fork a daemon */
if (fork_a_daemon) {
int i = fork();
if (i < 0) {
hlog(LOG_CRIT, "Fork to background failed: %s", strerror(errno));
fprintf(stderr, "Fork to background failed: %s\n", strerror(errno));
exit(1);
} else if (i == 0) {
/* child */
/* write pid file, now that we have our final pid... might fail, which is critical */
hlog(LOG_DEBUG, "Writing pid...");
if (!writepid(pidfile))
exit(1);
} else {
/* parent, quitting */
hlog(LOG_DEBUG, "Forked daemon process %d, parent quitting", i);
exit(0);
}
}
signal(SIGINT, closedown);
signal(SIGPIPE, brokenconnection);
/* initialize position cache for timed JSON AIS transmission */
if (uplink_config) {
hlog(LOG_DEBUG, "Initializing cache...");
if (cache_init())
exit(1);
hlog(LOG_DEBUG, "Initializing jsonout...");
if (jsonout_init())
exit(1);
}
/* initialize serial port for NMEA output */
if (serial_port)
serial = serial_init();
/* initialize Unix domain socket for communication with gnuaisgui */
ipc = gnuais_ipc_init();
if(ipc == 0){
hlog(LOG_ERR, "Could not open Unix Domain Socket");
}
/* initialize the AIS decoders */
if (sound_channels != SOUND_CHANNELS_MONO) {
hlog(LOG_DEBUG, "Initializing demodulator A");
rx_a = init_receiver('A', 2, 0,serial,ipc);
hlog(LOG_DEBUG, "Initializing demodulator B");
rx_b = init_receiver('B', 2, 1,serial,ipc);
channels = 2;
} else {
hlog(LOG_DEBUG, "Initializing demodulator A");
rx_a = init_receiver('A', 1, 0,serial,ipc);
channels = 1;
}
#ifdef HAVE_PULSEAUDIO
if(sound_device != NULL && ((strcmp("pulse",sound_device) == 0) || (strcmp("pulseaudio",sound_device) == 0))){
if((pa_dev = pulseaudio_initialize()) == NULL){
hlog(LOG_CRIT, "Error opening pulseaudio device");
return -1;
}
buffer_l = 1024;
int extra = buffer_l % 5;
buffer_l -= extra;
buffer = (short *) hmalloc(buffer_l * sizeof(short) * channels);
}
else if (sound_device){
#else
if (sound_device){
#endif
if ((err = snd_pcm_open(&handle, sound_device, SND_PCM_STREAM_CAPTURE, 0)) < 0) {
hlog(LOG_CRIT, "Error opening sound device (%s)", sound_device);
return -1;
}
if (input_initialize(handle, &buffer, &buffer_l) < 0)
return -1;
} else if (sound_in_file) {
if ((sound_in_fd = fopen(sound_in_file, "r")) == NULL) {
hlog(LOG_CRIT, "Could not open sound file %s: %s", sound_in_file, strerror(errno));
return -1;
}
hlog(LOG_NOTICE, "Reading audio from file: %s", sound_in_file);
buffer_l = 1024;
int extra = buffer_l % 5;
buffer_l -= extra;
buffer = (short *) hmalloc(buffer_l * sizeof(short) * channels);
} else {
hlog(LOG_CRIT, "Neither sound device or sound file configured.");
return -1;
}
if (sound_out_file) {
if ((sound_out_fd = fopen(sound_out_file, "w")) == NULL) {
hlog(LOG_CRIT, "Could not open sound output file %s: %s", sound_out_file, strerror(errno));
return -1;
}
hlog(LOG_NOTICE, "Recording audio to file: %s", sound_out_file);
}
#ifdef HAVE_MYSQL
if (mysql_db) {
hlog(LOG_DEBUG, "Saving to MySQL database \"%s\"", mysql_db);
if (!(my = myout_init()))
return -1;
if (mysql_keepsmall)
hlog(LOG_DEBUG, "Updating database rows only.");
else
hlog(LOG_DEBUG, "Inserting data to database.");
if (mysql_oldlimit)
hlog(LOG_DEBUG, "Deleting data older than %d seconds", mysql_oldlimit);
}
#endif
hlog(LOG_NOTICE, "Started");
while (!done) {
if (sound_in_fd) {
buffer_read = fread(buffer, channels * sizeof(short), buffer_l, sound_in_fd);
if (buffer_read <= 0)
done = 1;
}
#ifdef HAVE_PULSEAUDIO
else if (pa_dev){
buffer_read = pulseaudio_read(pa_dev, buffer, buffer_l);
}
#endif
else {
buffer_read = input_read(handle, buffer, buffer_l);
//printf("read %d\n", buffer_read);
}
if (buffer_read <= 0)
continue;
if (sound_out_fd) {
fwrite(buffer, channels * sizeof(short), buffer_read, sound_out_fd);
}
if (sound_channels == SOUND_CHANNELS_MONO) {
receiver_run(rx_a, buffer, buffer_read);
}
if (sound_channels == SOUND_CHANNELS_BOTH
|| sound_channels == SOUND_CHANNELS_RIGHT) {
/* ch a/0/right */
receiver_run(rx_a, buffer, buffer_read);
}
if (sound_channels == SOUND_CHANNELS_BOTH
|| sound_channels == SOUND_CHANNELS_LEFT) {
/* ch b/1/left */
receiver_run(rx_b, buffer, buffer_read);
}
}
hlog(LOG_NOTICE, "Closing down...");
if (sound_in_fd) {
fclose(sound_in_fd);
}
#ifdef HAVE_PULSEAUDIO
else if (pa_dev) {
pulseaudio_cleanup(pa_dev);
}
#endif
else {
input_cleanup(handle);
handle = NULL;
}
if (sound_out_fd)
fclose(sound_out_fd);
hfree(buffer);
gnuais_ipc_deinit(ipc);
if (serial)
serial_close(serial);
if (uplink_config)
jsonout_deinit();
if (cache_positions)
cache_deinit();
if (rx_a) {
struct demod_state_t *d = rx_a->decoder;
hlog(LOG_INFO,
"A: Received correctly: %d packets, wrong CRC: %d packets, wrong size: %d packets",
d->receivedframes, d->lostframes,
d->lostframes2);
}
if (rx_b) {
struct demod_state_t *d = rx_b->decoder;
hlog(LOG_INFO,
"B: Received correctly: %d packets, wrong CRC: %d packets, wrong size: %d packets",
d->receivedframes, d->lostframes,
d->lostframes2);
}
free_receiver(rx_a);
free_receiver(rx_b);
free_config();
close_log(0);
return 0;
}
