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; }