int main(int argc, char *argv[])
{
int i, w=1024, h=600, fps = 30;
g_log_set_handler(G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, g_log_default_handler, NULL);
streamer_set_input_callback(on_streamer_input);
streamer_set_output_callback(on_streamer_output);
streamer_set_ready_callback(on_streamer_ready);
streamer_set_eos_callback(on_streamer_eos);
streamer_init();
if(!streamer_run(fps, w / 2, h/ 2, "app"))
return EXIT_FAILURE;
g_usleep(1000*1000*10);
streamer_stop();
return EXIT_SUCCESS;
}
int main (int argc, const char **argv)
{
#ifdef WIN32
{
// set the console to accept escape sequences (Win10+)
HANDLE console = GetStdHandle(STD_OUTPUT_HANDLE);
if (console != INVALID_HANDLE_VALUE)
{
DWORD consoleMode = 0;
GetConsoleMode(console, &consoleMode);
consoleMode |= 4; // ENABLE_VIRTUAL_TERMINAL_PROCESSING; but that isn't available in our current SDK target
SetConsoleMode(console, consoleMode);
}
}
#endif
int exit_code = EXIT_SUCCESS;
try {
// Experiment with floating point masks.
// #ifdef FE_NOMASK_ENV
// feenableexcept(FE_INVALID);
// feenableexcept(FE_DIVBYZERO | FE_INVALID);
// #endif
bgl = new BackgroundLoader();
size_t winid = gfx_init(cb);
debug_drawer = new BulletDebugDrawer(ogre_sm); // FIXME: hack
#ifdef WIN32
mouse = new MouseDirectInput8(winid);
bool use_dinput = getenv("GRIT_DINPUT")!=NULL;
keyboard = use_dinput ? (Keyboard *)new KeyboardDirectInput8(winid)
: (Keyboard *)new KeyboardWinAPI(winid);
#else
mouse = new MouseX11(winid);
keyboard = new KeyboardX11(winid);
#endif
clipboard_init();
physics_init();
net_init();
core_option_init();
streamer_init();
navigation_init();
// audio_init(getenv("GRIT_AUDIO_DEV"));
audio_init(NULL);
std::vector<std::string> args;
for (int i=0 ; i<argc ; i++) {
args.push_back(argv[i]);
}
try {
const char *init_file = getenv("GRIT_INIT");
if (init_file == nullptr) init_file = "/system/init.lua";
init_lua(init_file, args, core_L);
} catch (Exception &e) {
CERR << "Fatal error: " << e << std::endl;
exit_code = EXIT_FAILURE;
}
// Lua returns - we quit.
CVERB << "Shutting down Lua net subsystem..." << std::endl;
net_shutdown(core_L);
navigation_shutdown();
object_all_del(core_L); // Will remove all demands from background loader.
CVERB << "Shutting down Lua graphics subsystem..." << std::endl;
gfx_shutdown_lua(core_L);
CVERB << "Shutting down Background Loader..." << std::endl;
bgl->shutdown();
CVERB << "Shutting down Mouse & Keyboard..." << std::endl;
if (mouse) delete mouse;
if (keyboard) delete keyboard;
CVERB << "Shutting down clipboard..." << std::endl;
clipboard_shutdown();
CVERB << "Shutting down Lua VM..." << std::endl;
if (core_L) shutdown_lua(core_L);
CVERB << "Shutting down audio subsystem..." << std::endl;
audio_shutdown(); //close AL device
CVERB << "Shutting down physics subsystem..." << std::endl;
physics_shutdown();
CVERB << "Shutting down the physics debug drawer..." << std::endl;
if (debug_drawer) delete debug_drawer;
CVERB << "Shutting down the Graphics subsystem..." << std::endl;
gfx_shutdown();
delete bgl;
} catch (Exception &e) {
std::cerr << "TOP LEVEL ERROR: " << e << std::endl;
return EXIT_FAILURE;
}
return exit_code;
}
void OIUC::prepare() {
/*---------------- ICS -----------------*/
ics_pool_init(&app_data.ics);
ics_pjsua_init(&app_data.ics);
ics_init(&app_data.ics);
//qDebug() << "INIT DONE";
#if 1
SET_LOG_LEVEL(4);
pj_log_set_level(3);
ics_set_default_callback(&on_reg_start_default);
ics_set_reg_start_callback(&on_reg_start_impl);
ics_set_reg_state_callback(&on_reg_state_impl);
ics_set_incoming_call_callback(&on_incoming_call_impl);
ics_set_call_state_callback(&on_call_state_impl);
ics_set_call_transfer_callback(&on_call_transfer_impl);
ics_set_call_media_state_callback(&on_call_media_state_impl);
ics_start(&app_data.ics);
config->getPortAsterisk(); // Don't need anymore, now set default bind to any port
ics_connect(&app_data.ics, config->getPortAsterisk());
qDebug() << "ICS STARTED";
#endif
/*---------------- PTTC -----------------*/
#if 0
pttc_init(&app_data.serial, &app_data.pttc, on_pttc_ptt, app_data.ics.pool);
pttc_start(&app_data.serial, config->getSerialFile().toLocal8Bit().data());
#endif
/*---------------- NODE -----------------*/
#if 1
memset(&app_data.node, 0, sizeof(app_data.node));
gm_cs = "udp:" + config->getArbiterIP() + ":" + QString::number(config->getPortSendToArbiter());
gmc_cs = "udp:" + config->getOIUCIP() + ":" + QString::number(config->getPortOIUCListen());
adv_cs = "udp:0.0.0.0:2015";
init_adv_server(&app_data, adv_cs.toLocal8Bit().data(), &app_data.node, app_data.ics.pool);
app_data.node.on_leaving_server_f = &on_leaving_server;
node_init(&app_data.node,
config->getOIUCName().toLocal8Bit().data(),
config->getLocation().toLocal8Bit().data(),
config->getOIUCDescription().toLocal8Bit().data(),
-1,
gm_cs.toLocal8Bit().data(),
gmc_cs.toLocal8Bit().data(),
app_data.ics.pool);
node_add_adv_server(&app_data.node, &app_data.adv_server);
qDebug() << "NODE INIT DONE";
#endif
/*---------------- GB -----------------*/
#if 1
memset(&app_data.gr, 0, sizeof(app_data.gr));
app_data.gr.on_online_report_f = &on_online_report;
app_data.gr.on_tx_report_f = &on_tx_report;
app_data.gr.on_rx_report_f = &on_rx_report;
app_data.gr.on_sq_report_f = &on_sq_report;
gb_receiver_init(&app_data.gr, (char *)GB_CS, app_data.ics.pool);
qDebug() << "GB DONE";
#endif
/*---------------- STREAM -----------------*/
#if 1
node_media_config(&app_data.node, &app_data.streamer, &app_data.receiver);
app_data.node.streamer->pool = app_data.node.receiver->pool = app_data.ics.pool;
app_data.node.streamer->ep = app_data.node.receiver->ep = pjsua_get_pjmedia_endpt();
pjmedia_codec_g711_init(app_data.node.streamer->ep);
pjmedia_codec_g711_init(app_data.node.receiver->ep);
streamer_init(app_data.node.streamer, app_data.node.streamer->ep, app_data.node.streamer->pool);
receiver_init(app_data.node.receiver, app_data.node.receiver->ep, app_data.node.receiver->pool, config->getNumberChannels());
streamer_config_dev_source(app_data.node.streamer, config->getSoundStreamerIdx());
receiver_config_dev_sink(app_data.node.receiver, config->getSoundReceiverIdx());
//streamer_config_dev_source(app_data.node.streamer, 2);
//receiver_config_dev_sink(app_data.node.receiver, 2);
//qDebug() << "STREAM INIT...DONE\n";
#endif
}
int main(int argc, char *argv[]) {
char temp[10];
pj_caching_pool cp;
pj_pool_t *pool;
pjmedia_endpt *ep;
pjmedia_stream *stream;
pjmedia_codec_info *ci;
int rport = 5321;
char *rhost = "239.1.0.2";
//char *rhost = "192.168.2.50";
if (argc < 3) {
usage(argv[0]);
}
#if 1
int lport;
lport = atoi(argv[1]);
char *file = argv[2];
#endif
#if 0
int lport = 2345;
#endif
pj_init();
pj_log_set_level(5);
pj_caching_pool_init(&cp, NULL, 1024);
streamer.pool = pj_pool_create(&cp.factory, "pool1", 1024, 1024, NULL);
pjmedia_endpt_create(&cp.factory, NULL, 1, &streamer.ep);
pjmedia_codec_g711_init(streamer.ep);
streamer_init(&streamer, streamer.ep, streamer.pool);
streamer_config_stream(&streamer, lport, rhost, rport);
streamer_config_file_source(&streamer, file);
//streamer_config_dev_source(&streamer, 2);
streamer_start(&streamer);
fprintf(stdout, "Local port: %d, File: %s\n", lport, file);
while(1) {
fprintf(stdout, "s=Stop - r=Resume: ");
fflush(stdout);
if (fgets(temp, sizeof(temp), stdin) == NULL)
exit(-1);
fprintf(stdout, "%s\n",temp);
switch(temp[0]) {
case 's':
case 'S':
streamer_stop(&streamer);
break;
case 'r':
case 'R':
streamer_start(&streamer);
break;
case '+':
rport++;
streamer_stop(&streamer);
streamer_config_stream(&streamer, lport, rhost, rport);
streamer_start(&streamer);
break;
case '-':
rport--;
streamer_stop(&streamer);
streamer_config_stream(&streamer, lport, rhost, rport);
streamer_start(&streamer);
break;
case 'v':
streamer_update_stats(&streamer);
fprintf(stdout, "rtt:%d - delay:%d - pkt:%d - lost: %d - discard:%d\n",
streamer.streams[0].delay.mean_rtt_us, streamer.streams[0].delay.mean_delay_ms,
streamer.streams[0].drop.pkt, streamer.streams[0].drop.lost, streamer.streams[0].drop.discard);
break;
}
pj_thread_sleep(5*100);
}
return 0;
}
int main(int argc, char **argv)
{
size_t c;
int status;
// Default values.
arguments.verbose = DEBUG_LEVEL_INFO;
arguments.port = 0;
arguments.channel = 0;
arguments.channel2 = arguments.channel + 1;
arguments.packetsize = 1024;
arguments.period_size = 512;
arguments.nb_periods = 2;
// number of extra frames to buffer on top of the
// nb_periods x period_size. adds to the latency
arguments.frame_slack = 0;
// number of extra ISO packet descriptors to queue,
// doesn't add to the latency.
arguments.iso_slack = 0;
arguments.startoncycle = -1;
arguments.countdown = 4;
arguments.printinterval = 100;
arguments.rtprio = 0;
// Parse our arguments; every option seen by `parse_opt' will
// be reflected in `arguments'.
if ( argp_parse ( &argp, argc, argv, 0, 0, &arguments ) ) {
debugError("Could not parse command line\n" );
return -1;
}
// utility file descriptor
char *device = NULL;
if(asprintf(&device, "/dev/fw%zd", arguments.port) < 0) {
debugError("Failed create device string\n");
exit(-1);
}
// open the specified port
debugOutput(DEBUG_LEVEL_INFO, "Open device %s...\n", device);
int util_fd = open( device, O_RDWR );
if(util_fd < 0) {
debugError("Failed to open %s\n", device);
free(device);
exit(-1);
}
free(device);
setDebugLevel(arguments.verbose);
// AM824 settings
struct am824_settings stream_settings;
stream_settings.syt_interval = 8;
// connection settings
struct stream_settings settings;
settings.type = STREAM_TYPE_RECEIVE;
settings.channel = 0;
settings.port = arguments.port;
settings.max_packet_size = arguments.packetsize;
settings.client_data = &stream_settings;
settings.process_header = NULL;
settings.process_payload = receive_am824_packet_data;
settings.packet_size_for_sync = FRAMES_PER_PACKET;
// setup the streamer
streamer_t strm = streamer_new();
if(strm == NULL) {
debugError("Could not allocate streamer\n");
exit(-1);
}
__u32 conn_ids[16];
if(streamer_init(strm, arguments.port,
arguments.period_size,
arguments.nb_periods,
arguments.frame_slack,
arguments.iso_slack,
FRAMES_PER_SECOND) < 0) {
debugError("Failed to init streamer\n");
close(util_fd);
exit(-1);
}
#if 0
settings.channel = arguments.channel;
settings.type = STREAM_TYPE_TRANSMIT;
settings.process_header = NULL;
settings.process_payload = transmit_am824_packet_data;
#else
settings.channel = 0;
settings.type = STREAM_TYPE_RECEIVE;
settings.process_header = NULL;
settings.process_payload = receive_am824_packet_data;
#endif
status = streamer_add_stream(strm, &settings);
if(status < 0) {
debugError("Failed to add connection\n");
streamer_free(strm);
close(util_fd);
exit(-1);
}
conn_ids[0] = status;
#if 1
settings.channel = arguments.channel2;
settings.type = STREAM_TYPE_TRANSMIT;
settings.process_header = NULL;
settings.process_payload = transmit_am824_packet_data;
#else
settings.channel = 1;
settings.type = STREAM_TYPE_RECEIVE;
settings.process_header = NULL;
settings.process_payload = receive_am824_packet_data;
#endif
status = streamer_add_stream(strm, &settings);
if(status < 0) {
debugError("Failed to add connection\n");
streamer_free(strm);
close(util_fd);
exit(-1);
}
conn_ids[1] = status;
#if 0
settings.channel = 12;
settings.type = STREAM_TYPE_TRANSMIT;
settings.process_header = NULL;
settings.process_payload = transmit_am824_packet_data;
#else
settings.channel = arguments.channel;
settings.type = STREAM_TYPE_RECEIVE;
settings.process_header = NULL;
settings.process_payload = receive_am824_packet_data;
#endif
status = streamer_add_stream(strm, &settings);
if(status < 0) {
debugError("Failed to add connection\n");
streamer_free(strm);
close(util_fd);
exit(-1);
}
conn_ids[2] = status;
streamer_start_connection(strm, conn_ids[0], -1);
streamer_set_sync_connection(strm, conn_ids[0]);
int nruns = arguments.countdown;
// start the streamer
if(streamer_start(strm) < 0) {
debugError("Could not start streamer\n");
return -1;
}
do {
// debugOutput(DEBUG_LEVEL_INFO,
debugWarning(
">>>>>>>>>> Run %d <<<<<<<<<<\n",
(int)(arguments.countdown - nruns));
if(arguments.countdown - nruns == 10) {
streamer_start_connection(strm, conn_ids[1], -1);
}
if(arguments.countdown - nruns == 20) {
streamer_start_connection(strm, conn_ids[2], -1);
}
if(arguments.countdown - nruns == 30) {
settings.channel = 3;
settings.type = STREAM_TYPE_RECEIVE;
settings.process_header = NULL;
settings.process_payload = receive_am824_packet_data;
status = streamer_add_stream(strm, &settings);
if(status < 0) {
debugError("Failed to add connection\n");
streamer_free(strm);
close(util_fd);
exit(-1);
}
conn_ids[3] = status;
}
if(arguments.countdown - nruns == 40) {
streamer_start_connection(strm, conn_ids[3], -1);
}
if(arguments.countdown - nruns == 50) {
streamer_set_sync_connection(strm, conn_ids[3]);
}
/* ============================== *
* WAIT *
* ============================== */
if(streamer_wait_for_period(strm) < 0) {
debugError("Failed to wait for period\n");
goto out;
}
/* ============================== *
* READ *
* ============================== */
streamer_read_frames(strm);
/* ============================== *
* PROCESS *
* ============================== */
/* ============================== *
* WRITE *
* ============================== */
streamer_write_frames(strm);
/* ============================== *
* REQUEUE *
* ============================== */
if(streamer_queue_next_period(strm) < 0) {
debugError("queue failed\n");
goto out;
}
} while(--nruns);
out:
if(streamer_stop(strm) < 0) {
debugError("Could not stop streamer\n");
return -1;
}
streamer_free(strm);
close(util_fd);
return 0;
}
int main(int argc, char *argv[]) {
if (argc < 3) {
usage(argv[0]);
}
/*------------ CONFIG VARIABLES ------------*/
sqlite3 *db;
char *sql, sql_cmd[100];
sqlite3_stmt *stmt;
char id[10], location[30], desc[50];
char gm_cs[50], gmc_cs[50], adv_cs[50], gb_cs[50];
char gm_cs_tmp[50], gmc_cs_tmp[50], adv_cs_tmp[50];
int snd_dev_r0, snd_dev_r1, snd_dev_r2, snd_dev_r3;
int adv_port = ADV_PORT;
int gb_port = GB_PORT;
/*------------ INIT & STREAM VARIABLES ------------*/
pj_caching_pool cp;
pj_pool_t *pool;
pjmedia_endpt *ep;
endpoint_t streamers[MAX_NODE];
endpoint_t receivers[MAX_NODE];
adv_server_t adv_server;
/*------------ OTHER VARIABLES ------------*/
pthread_t thread;
char *dummy, option[10];
int i, n, input, f_quit = 0;
int snd_dev[4];
/*-----------------------------------------*/
SET_LOG_LEVEL(4);
/*------------ START ------------*/
#if 1
SHOW_LOG(3, "Press '1': Set sound devices configure\nPress 's': Show databases\nPress 'Space': Load databases\nPress 'q': Quit\n");
CALL_SQLITE (open (argv[2], &db));
while(!f_quit) {
dummy = fgets(option, sizeof(option), stdin);
switch(option[0]) {
case '1':
SHOW_LOG(3, "Set device index for each radio...\n");
for (i = 0; i < MAX_NODE; i++){
SHOW_LOG(3, "Radio %d: ", i);
dummy = fgets(option, sizeof(option), stdin);
input = atoi(&option[0]);
n = sprintf(sql_cmd, "UPDATE riuc_config SET snd_dev_r%d =(?)", i);
sql_cmd[n] = '\0';
CALL_SQLITE (prepare_v2 (db, sql_cmd, strlen (sql_cmd) + 1, & stmt, NULL));
CALL_SQLITE (bind_int (stmt, 1, input));
CALL_SQLITE_EXPECT (step (stmt), DONE);
}
SHOW_LOG(3, "Config completed\n");
f_quit = 1;
break;
case 's':
sql = "SELECT *FROM riuc_config";
CALL_SQLITE (prepare_v2 (db, sql, strlen (sql) + 1, &stmt, NULL));
while (sqlite3_step(stmt) == SQLITE_ROW) {
printf("ID: %s\n", sqlite3_column_text(stmt, 0));
printf("Location: %s\n", sqlite3_column_text(stmt, 1));
printf("Desc: %s\n", sqlite3_column_text(stmt, 2));
printf("GM_CS: %s\n", sqlite3_column_text(stmt, 3));
printf("GMC_CS: %s\n", sqlite3_column_text(stmt, 4));
printf("snd_dev_r0: %u\n", sqlite3_column_int(stmt, 5));
printf("snd_dev_r1: %u\n", sqlite3_column_int(stmt, 6));
printf("snd_dev_r2: %u\n", sqlite3_column_int(stmt, 7));
printf("snd_dev_r3: %u\n", sqlite3_column_int(stmt, 8));
}
break;
case ' ':
f_quit = 1;
break;
case 'q':
return 0;
default:
SHOW_LOG(3, "Unknown option\n");
}
}
f_quit = 0;
#endif
/*------------ LOAD CONFIG ------------*/
//CALL_SQLITE (open ("databases/riuc.db", &db));
sql = "SELECT * FROM riuc_config";
CALL_SQLITE (prepare_v2 (db, sql, strlen (sql) + 1, &stmt, NULL));
//WARNING: MAX NUMBER OF SOUND DEV = 4
while (sqlite3_step(stmt) == SQLITE_ROW) {
strcpy(id, sqlite3_column_text(stmt, 0));
strcpy(location, sqlite3_column_text(stmt, 1));
strcpy(desc, sqlite3_column_text(stmt, 2));
strcpy(gm_cs, sqlite3_column_text(stmt, 3));
strcpy(gmc_cs, sqlite3_column_text(stmt, 4));
snd_dev_r0 = sqlite3_column_int(stmt, 5);
snd_dev_r1 = sqlite3_column_int(stmt, 6);
snd_dev_r2 = sqlite3_column_int(stmt, 7);
snd_dev_r3 = sqlite3_column_int(stmt, 8);
auto_invite = sqlite3_column_int(stmt, 9);
}
snd_dev[0] = snd_dev_r0;
snd_dev[1] = snd_dev_r1;
snd_dev[2] = snd_dev_r2;
snd_dev[3] = snd_dev_r3;
n = sprintf(adv_cs, "udp:0.0.0.0:%d", adv_port);
adv_cs[n] = '\0';
n = sprintf(gb_cs, "udp:%s:%d",GB_MIP, gb_port);
gb_cs[n] = '\0';
SHOW_LOG(3, "========= LOADED CONFIG ========\n");
SHOW_LOG(3, "ID: %s\nDesc: %s\nGM_CS: %s\nGMC_CS: %s\nADV_CS: %s\nGB_CS: %s\nsnd_r0: %d\nsnd_r1: %d\nsnd_r2: %d\nsnd_r3: %dAuto invite: %d\n", id, desc, gm_cs, gmc_cs, adv_cs, gm_cs, snd_dev_r0, snd_dev_r1, snd_dev_r2, snd_dev_r3, auto_invite);
SHOW_LOG(3, "================================\n");
/*------------ INIT ------------*/
pj_init();
pj_caching_pool_init(&cp, NULL, 10000);
pool = pj_pool_create(&cp.factory, "pool1", 1024, 1024, NULL);
SHOW_LOG(2, "INIT CP AND POOL...DONE\n");
/*------------ NODE ------------*/
#if 1
init_adv_server(&adv_server, adv_cs, pool);
for (i = 0;i < MAX_NODE; i++) {
memset(gm_cs_tmp, 0, sizeof(gm_cs_tmp));
memset(gmc_cs_tmp, 0, sizeof(gmc_cs_tmp));
memset(adv_cs_tmp, 0, sizeof(adv_cs_tmp));
ansi_copy_str(gm_cs_tmp, gm_cs);
ansi_copy_str(adv_cs_tmp, adv_cs);
ansi_copy_str(gmc_cs_tmp, gmc_cs);
n = strlen(gmc_cs);
gmc_cs_tmp[n-1] = i + 1+ '0';
memset(&riuc_data.node[i], 0, sizeof(riuc_data.node[i]));
riuc_data.node[i].on_leaving_server_f = &on_leaving_server;
node_init(&riuc_data.node[i], id, location, desc, i, gm_cs_tmp, gmc_cs_tmp, pool);
node_add_adv_server(&riuc_data.node[i], &adv_server);
}
SHOW_LOG(2, "INIT NODE...DONE\n");
#endif
/*----------- GB --------------*/
#if 1
memset(&riuc_data.gb_sender, 0, sizeof(riuc_data.gb_sender));
n = sprintf(gb_cs, "udp:%s:%d", GB_MIP, GB_PORT);
gb_cs[n] = '\0';
gb_sender_create(&riuc_data.gb_sender, gb_cs);
SHOW_LOG(2, "INIT GB SENDER...DONE\n");
#endif
/*----------- RIUC4 --------------*/
#if 1
memset(riuc_data.serial_file, 0, sizeof(riuc_data.serial_file));
strncpy(riuc_data.serial_file, argv[1], strlen(argv[1]));
riuc4_init(&riuc_data.serial, &riuc_data.riuc4, &on_riuc4_status, pool);
riuc4_start(&riuc_data.serial, riuc_data.serial_file);
SHOW_LOG(2, "INIT RIUC4...DONE\n");
#if 1
for (i = 0; i < MAX_NODE; i++) {
riuc4_enable_rx(&riuc_data.riuc4, i);
usleep(250*1000);
riuc4_enable_tx(&riuc_data.riuc4, i);
usleep(250*1000);
}
#endif
SHOW_LOG(2, "ENABLE TX & RX...DONE\n");
#endif
/*----------- STREAM --------------*/
#if 1
SHOW_LOG(3, "INIT STREAM...START\n");
pjmedia_endpt_create(&cp.factory, NULL, 1, &ep);
#if 1
SHOW_LOG(3, "CODEC INIT\n");
pjmedia_codec_g711_init(ep);
for (i = 0; i < MAX_NODE; i++) {
SHOW_LOG(3, "NODE MEDIA CONFIG\n");
node_media_config(&riuc_data.node[i], &streamers[i], &receivers[i]);
SHOW_LOG(3, "SET POOL\n");
riuc_data.node[i].streamer->pool = pool;
riuc_data.node[i].receiver->pool = pool;
SHOW_LOG(3, "SET ENDPOINT\n");
riuc_data.node[i].receiver->ep = ep;
riuc_data.node[i].streamer->ep = ep;
SHOW_LOG(3, "INIT STREAMER & RECEIVER FOR NODE %d\n", i);
streamer_init(riuc_data.node[i].streamer, riuc_data.node[i].streamer->ep, riuc_data.node[i].receiver->pool);
receiver_init(riuc_data.node[i].receiver, riuc_data.node[i].receiver->ep, riuc_data.node[i].receiver->pool, 2);
}
SHOW_LOG(3, "CONFIG SOUND DEVICE\n");
for (i = 0; i < MAX_NODE; i++) {
streamer_config_dev_source(riuc_data.node[i].streamer, snd_dev[i]);
receiver_config_dev_sink(riuc_data.node[i].receiver, snd_dev[i]);
}
SHOW_LOG(2, "INIT STREAM...DONE\n");
/*---------------------------------*/
pthread_create(&thread, NULL, auto_register, &riuc_data);
#endif
#endif
while(!f_quit) {
dummy = fgets(option, sizeof(option), stdin);
switch(option[0]) {
case 'c':
for (i = 0; i < MAX_NODE; i++){
SHOW_LOG(3, "Set device index for each radio...\nRadio %d: ", i);
dummy = fgets(option, sizeof(option), stdin);
input = atoi(&option[0]);
n = sprintf(sql_cmd, "UPDATE riuc_config SET snd_dev_r%d =(?)", i);
sql_cmd[n] = '\0';
CALL_SQLITE (prepare_v2 (db, sql_cmd, strlen (sql_cmd) + 1, & stmt, NULL));
CALL_SQLITE (bind_int (stmt, 1, input));
CALL_SQLITE_EXPECT (step (stmt), DONE);
streamer_config_dev_source(riuc_data.node[i].streamer, input);
receiver_config_dev_sink(riuc_data.node[i].receiver, input);
}
SHOW_LOG(3, "Config completed\n");
break;
case 's':
sql = "SELECT *FROM riuc_config";
CALL_SQLITE (prepare_v2 (db, sql, strlen (sql) + 1, &stmt, NULL));
while (sqlite3_step(stmt) == SQLITE_ROW) {
printf("ID: %s\n", sqlite3_column_text(stmt, 0));
printf("Location: %s\n", sqlite3_column_text(stmt, 1));
printf("Desc: %s\n", sqlite3_column_text(stmt, 2));
printf("GM_CS: %s\n", sqlite3_column_text(stmt, 3));
printf("GMC_CS: %s\n", sqlite3_column_text(stmt, 4));
printf("snd_dev_r0: %u\n", sqlite3_column_int(stmt, 5));
printf("snd_dev_r1: %u\n", sqlite3_column_int(stmt, 6));
printf("snd_dev_r2: %u\n", sqlite3_column_int(stmt, 7));
printf("snd_dev_r3: %u\n", sqlite3_column_int(stmt, 8));
}
break;
case 't':
node_start_session(&riuc_data.node[0]);
break;
case 'y':
node_stop_session(&riuc_data.node[0]);
break;
case 'j':
node_invite(&riuc_data.node[0], "FTW");
break;
case 'l':
node_repulse(&riuc_data.node[0], "FTW");
break;
case 'q':
f_quit = 1;
break;
default:
SHOW_LOG(3, "Unknown option\n");
break;
}
}
SHOW_LOG(3, "Quiting...\n");
//pthread_join(thread, NULL);
sqlite3_finalize(stmt);
sqlite3_close(db);
return 0;
}
int
main (int argc, char *argv[]) {
int portable = 0;
#if STATICLINK
int staticlink = 1;
#else
int staticlink = 0;
#endif
#if PORTABLE
portable = 1;
if (!realpath (argv[0], dbinstalldir)) {
strcpy (dbinstalldir, argv[0]);
}
char *e = strrchr (dbinstalldir, '/');
if (e) {
*e = 0;
}
else {
fprintf (stderr, "couldn't determine install folder from path %s\n", argv[0]);
exit (-1);
}
#else
if (!realpath (argv[0], dbinstalldir)) {
strcpy (dbinstalldir, argv[0]);
}
char *e = strrchr (dbinstalldir, '/');
if (e) {
*e = 0;
struct stat st;
char checkpath[PATH_MAX];
snprintf (checkpath, sizeof (checkpath), "%s/.ddb_portable", dbinstalldir);
if (!stat (checkpath, &st)) {
if (S_ISREG (st.st_mode)) {
portable = 1;
}
}
}
if (!portable) {
strcpy (dbinstalldir, PREFIX);
}
#endif
#ifdef __GLIBC__
signal (SIGSEGV, sigsegv_handler);
#endif
setlocale (LC_ALL, "");
setlocale (LC_NUMERIC, "C");
#ifdef ENABLE_NLS
// fprintf (stderr, "enabling gettext support: package=" PACKAGE ", dir=" LOCALEDIR "...\n");
if (portable) {
char localedir[PATH_MAX];
snprintf (localedir, sizeof (localedir), "%s/locale", dbinstalldir);
bindtextdomain (PACKAGE, localedir);
}
else {
bindtextdomain (PACKAGE, LOCALEDIR);
}
bind_textdomain_codeset (PACKAGE, "UTF-8");
textdomain (PACKAGE);
#endif
fprintf (stderr, "starting deadbeef " VERSION "%s%s\n", staticlink ? " [static]" : "", portable ? " [portable]" : "");
srand (time (NULL));
#ifdef __linux__
prctl (PR_SET_NAME, "deadbeef-main", 0, 0, 0, 0);
#endif
#if PORTABLE_FULL
if (snprintf (confdir, sizeof (confdir), "%s/config", dbinstalldir) > sizeof (confdir)) {
fprintf (stderr, "fatal: too long install path %s\n", dbinstalldir);
return -1;
}
strcpy (dbconfdir, confdir);
#else
char *homedir = getenv ("HOME");
if (!homedir) {
fprintf (stderr, "unable to find home directory. stopping.\n");
return -1;
}
char *xdg_conf_dir = getenv ("XDG_CONFIG_HOME");
if (xdg_conf_dir) {
if (snprintf (confdir, sizeof (confdir), "%s", xdg_conf_dir) > sizeof (confdir)) {
fprintf (stderr, "fatal: XDG_CONFIG_HOME value is too long: %s\n", xdg_conf_dir);
return -1;
}
}
else {
if (snprintf (confdir, sizeof (confdir), "%s/.config", homedir) > sizeof (confdir)) {
fprintf (stderr, "fatal: HOME value is too long: %s\n", homedir);
return -1;
}
}
if (snprintf (dbconfdir, sizeof (dbconfdir), "%s/deadbeef", confdir) > sizeof (dbconfdir)) {
fprintf (stderr, "fatal: out of memory while configuring\n");
return -1;
}
mkdir (confdir, 0755);
#endif
if (portable) {
if (snprintf (dbdocdir, sizeof (dbdocdir), "%s/doc", dbinstalldir) > sizeof (dbdocdir)) {
fprintf (stderr, "fatal: too long install path %s\n", dbinstalldir);
return -1;
}
#ifdef HAVE_COCOAUI
char respath[PATH_MAX];
cocoautil_get_resources_path (respath, sizeof (respath));
if (snprintf (dbplugindir, sizeof (dbplugindir), "%s", respath) > sizeof (dbplugindir)) {
fprintf (stderr, "fatal: too long install path %s\n", dbinstalldir);
return -1;
}
#else
if (snprintf (dbplugindir, sizeof (dbplugindir), "%s/plugins", dbinstalldir) > sizeof (dbplugindir)) {
fprintf (stderr, "fatal: too long install path %s\n", dbinstalldir);
return -1;
}
#endif
if (snprintf (dbpixmapdir, sizeof (dbpixmapdir), "%s/pixmaps", dbinstalldir) > sizeof (dbpixmapdir)) {
fprintf (stderr, "fatal: too long install path %s\n", dbinstalldir);
return -1;
}
mkdir (dbplugindir, 0755);
}
else {
if (snprintf (dbdocdir, sizeof (dbdocdir), "%s", DOCDIR) > sizeof (dbdocdir)) {
fprintf (stderr, "fatal: too long install path %s\n", dbinstalldir);
return -1;
}
if (snprintf (dbplugindir, sizeof (dbplugindir), "%s/deadbeef", LIBDIR) > sizeof (dbplugindir)) {
fprintf (stderr, "fatal: too long install path %s\n", dbinstalldir);
return -1;
}
if (snprintf (dbpixmapdir, sizeof (dbpixmapdir), "%s/share/deadbeef/pixmaps", PREFIX) > sizeof (dbpixmapdir)) {
fprintf (stderr, "fatal: too long install path %s\n", dbinstalldir);
return -1;
}
}
for (int i = 1; i < argc; i++) {
// help, version and nowplaying are executed with any filter
if (!strcmp (argv[i], "--help") || !strcmp (argv[i], "-h")) {
print_help ();
return 0;
}
else if (!strcmp (argv[i], "--version")) {
fprintf (stderr, "DeaDBeeF " VERSION " Copyright © 2009-2013 Alexey Yakovenko\n");
return 0;
}
else if (!strcmp (argv[i], "--gui")) {
if (i == argc-1) {
break;
}
i++;
strncpy (use_gui_plugin, argv[i], sizeof(use_gui_plugin) - 1);
use_gui_plugin[sizeof(use_gui_plugin) - 1] = 0;
}
}
trace ("installdir: %s\n", dbinstalldir);
trace ("confdir: %s\n", confdir);
trace ("docdir: %s\n", dbdocdir);
trace ("plugindir: %s\n", dbplugindir);
trace ("pixmapdir: %s\n", dbpixmapdir);
mkdir (dbconfdir, 0755);
int size = 0;
char *cmdline = prepare_command_line (argc, argv, &size);
// try to connect to remote player
int s, len;
struct sockaddr_un remote;
if ((s = socket(AF_UNIX, SOCK_STREAM, 0)) == -1) {
perror("socket");
exit(1);
}
memset (&remote, 0, sizeof (remote));
remote.sun_family = AF_UNIX;
#if USE_ABSTRACT_SOCKET_NAME
memcpy (remote.sun_path, server_id, sizeof (server_id));
len = offsetof(struct sockaddr_un, sun_path) + sizeof (server_id)-1;
#else
char *socketdirenv = getenv ("DDB_SOCKET_DIR");
snprintf (remote.sun_path, sizeof (remote.sun_path), "%s/socket", socketdirenv ? socketdirenv : dbconfdir);
len = offsetof(struct sockaddr_un, sun_path) + strlen (remote.sun_path);
#endif
if (connect(s, (struct sockaddr *)&remote, len) == 0) {
// pass args to remote and exit
if (send(s, cmdline, size, 0) == -1) {
perror ("send");
exit (-1);
}
// end of message
shutdown(s, SHUT_WR);
int sz = -1;
char *out = read_entire_message(s, &sz);
if (sz == -1) {
fprintf (stderr, "failed to pass args to remote!\n");
exit (-1);
}
else {
// check if that's nowplaying response
const char np[] = "nowplaying ";
const char err[] = "error ";
if (!strncmp (out, np, sizeof (np)-1)) {
const char *prn = &out[sizeof (np)-1];
fwrite (prn, 1, strlen (prn), stdout);
}
else if (!strncmp (out, err, sizeof (err)-1)) {
const char *prn = &out[sizeof (err)-1];
fwrite (prn, 1, strlen (prn), stderr);
}
else if (sz > 0 && out[0]) {
fprintf (stderr, "%s\n", out);
}
}
if (out) {
free (out);
}
close (s);
exit (0);
}
// else {
// perror ("INFO: failed to connect to existing session:");
// }
close(s);
// become a server
if (server_start () < 0) {
exit (-1);
}
// hack: report nowplaying
if (!strcmp (cmdline, "--nowplaying")) {
char nothing[] = "nothing";
fwrite (nothing, 1, sizeof (nothing)-1, stdout);
return 0;
}
pl_init ();
conf_init ();
conf_load (); // required by some plugins at startup
if (use_gui_plugin[0]) {
conf_set_str ("gui_plugin", use_gui_plugin);
}
conf_set_str ("deadbeef_version", VERSION);
volume_set_db (conf_get_float ("playback.volume", 0)); // volume need to be initialized before plugins start
messagepump_init (); // required to push messages while handling commandline
if (plug_load_all ()) { // required to add files to playlist from commandline
exit (-1);
}
pl_load_all ();
plt_set_curr_idx (conf_get_int ("playlist.current", 0));
// execute server commands in local context
int noloadpl = 0;
if (argc > 1) {
int res = server_exec_command_line (cmdline, size, NULL, 0);
// some of the server commands ran on 1st instance should terminate it
if (res == 2) {
noloadpl = 1;
}
else if (res > 0) {
exit (0);
}
else if (res < 0) {
exit (-1);
}
}
free (cmdline);
#if 0
signal (SIGTERM, sigterm_handler);
atexit (atexit_handler); // helps to save in simple cases
#endif
streamer_init ();
plug_connect_all ();
messagepump_push (DB_EV_PLUGINSLOADED, 0, 0, 0);
if (!noloadpl) {
restore_resume_state ();
}
server_tid = thread_start (server_loop, NULL);
mainloop_tid = thread_start (mainloop_thread, NULL);
DB_plugin_t *gui = plug_get_gui ();
if (gui) {
gui->start ();
}
fprintf (stderr, "gui plugin has quit; waiting for mainloop thread to finish\n");
thread_join (mainloop_tid);
// terminate server and wait for completion
if (server_tid) {
server_terminate = 1;
thread_join (server_tid);
server_tid = 0;
}
// save config
pl_save_all ();
conf_save ();
// delete legacy session file
{
char sessfile[1024]; // $HOME/.config/deadbeef/session
if (snprintf (sessfile, sizeof (sessfile), "%s/deadbeef/session", confdir) < sizeof (sessfile)) {
unlink (sessfile);
}
}
// stop receiving messages from outside
server_close ();
// plugins might still hold references to playitems,
// and query configuration in background
// so unload everything 1st before final cleanup
plug_disconnect_all ();
plug_unload_all ();
// at this point we can simply do exit(0), but let's clean up for debugging
pl_free (); // may access conf_*
conf_free ();
fprintf (stderr, "messagepump_free\n");
messagepump_free ();
fprintf (stderr, "plug_cleanup\n");
plug_cleanup ();
fprintf (stderr, "hej-hej!\n");
return 0;
}
