u32 tcp_server(void *par)
{
TCP_Input *input = par;
u32 *timer = input->RAPtimer;
char buffer[MAX_BUF];
unsigned char temp[MAX_BUF];
FILE *fp;
u32 byte_read;
int ret;
GF_Config *gf_config_file;
GF_Socket *TCP_socket;
GF_Socket *conn_socket;
GF_Err e;
int debug = input->debug;
input->status = 1;
TCP_socket = gf_sk_new(GF_SOCK_TYPE_TCP);
e = gf_sk_bind(TCP_socket, NULL, input->port, NULL, 0, 0);
e = gf_sk_listen(TCP_socket, 1);
e = gf_sk_set_block_mode(TCP_socket, 1);
e = gf_sk_server_mode(TCP_socket, 0);
while(input->status == 1)
{
memset(buffer, 0, sizeof(buffer));
e = gf_sk_accept(TCP_socket, &conn_socket);
if (e == GF_OK) {
memset(buffer, 0, sizeof(buffer));
e = gf_sk_receive(conn_socket, buffer, MAX_BUF, 0, &byte_read);
}
switch (e) {
case GF_IP_NETWORK_EMPTY:
gf_sleep(33);
continue;
case GF_OK:
break;
default:
fprintf(stderr, "Error with TCP socket : %s\n", gf_error_to_string(e));
exit(1);
break;
}
if((*(input->config_flag)) == 0)
{
u32 num_retry;
fp = fopen("temp.cfg", "w+");
if (!fp) {
fprintf(stderr, "Error opening temp file for the configuration\n");
exit(1);
}
ret = fwrite(buffer, 1, byte_read, fp);
fclose(fp);
/* parsing config info */
gf_config_file = gf_cfg_new(".", "temp.cfg");
if (!gf_config_file) {
fprintf(stderr, "Error opening the config file %s\n", gf_error_to_string(e));
exit(-1);
}
parse_config(gf_config_file, input->config, debug);
/* Acknowledging the configuration */
gf_sk_send(conn_socket, "OK\n", 3);
memset(temp, 0, sizeof(temp));
fp = fopen(input->config->scene_init_file, "w+");
if (!fp) {
fprintf(stderr, "Error opening temp file for reception of the initial scene\n");
exit(1);
}
num_retry=10;
while (1)
{
GF_Err e = gf_sk_receive(conn_socket, temp, sizeof(temp), 0, &byte_read);
if (e == GF_OK) {
fwrite(temp, 1, byte_read, fp);
} else if (e==GF_IP_NETWORK_EMPTY) {
num_retry--;
if (!num_retry)
break;
gf_sleep(1);
} else {
fprintf(stderr, "Error receiving initial scene: %s\n", gf_error_to_string(e));
break;
}
}
fclose(fp);
*(input->config_flag) = 1;
}
/* we only wait now for the config updates */
if ( (*(input->config_flag)) == 1) {
ret = sscanf(buffer, "DelaiMax=%d\n", timer);
fprintf(stdout, "RAP timer changed, now : %d\n", *timer);
}
gf_sk_del(conn_socket);
}
input->status = 2;
return GF_OK;
}
int main (const int argc, const char** argv)
{
GF_Err e;
Bool run;
/* location of the configuration file: 0 wait for config on a socket, 1 use the given file */
u32 config_flag;
char config_file_name[MAX_BUF];
int dest_port;
unsigned short tcp_port = 0;
/* Should be fine on WIFI network */
unsigned short mtu_size = 1492;
int debug = 0;
TCP_Input *tcp_conf = NULL;
GF_Thread *tcp_thread;
GF_Err th_err_tcp;
GF_Err th_err_rap;
RAP_Input *rap_conf;
GF_Thread *rap_thread;
CONF_Data *conf;
GF_Config *gf_config_file;
GF_Err res;
GF_Socket *UDP_feedback_socket;
u32 socketType_for_updates;
PNC_CallbackData * data;
GF_RTPChannel * chan;
GF_RTPHeader hdr;
u32 timer = -1;
GF_Mutex *carrousel_mutex;
char sdp_fmt[5000];
tcp_thread = NULL;
/* init gpac lib */
gf_sys_init();
gf_log_set_level(GF_LOG_ERROR);
gf_log_set_tools(GF_LOG_NETWORK|GF_LOG_RTP|GF_LOG_SCENE|GF_LOG_PARSER|GF_LOG_AUTHOR|GF_LOG_CODING|GF_LOG_SCRIPT);
GF_SAFEALLOC(conf, CONF_Data);
tcp_port = config_flag = 0;
socketType_for_updates = GF_SOCK_TYPE_UDP;
if (command_line_parsing(argc, argv, &tcp_port, config_file_name, (int *) &config_flag, &mtu_size, &debug, &socketType_for_updates)){
print_usage();
return -1;
}
setDebugMode( debug );
gf_config_file = NULL;
if (config_flag == 1)
{
char *cfg_path;
char *cfg_fname;
char *tmp;
cfg_fname = config_file_name;
cfg_path = config_file_name;
tmp = strrchr(cfg_fname, GF_PATH_SEPARATOR);
if (tmp) {
cfg_fname = tmp+1;
tmp[0] = 0;
} else {
cfg_path = ".";
}
gf_config_file = gf_cfg_new(cfg_path, cfg_fname);
if (!gf_config_file) {
fprintf(stderr, "Cannot open config file %s\n", config_file_name);
return -1;
} else {
dprintf(DEBUG_broadcaster, "Using config file %s.\n", config_file_name);
}
if (parse_config(gf_config_file, conf, debug)) return -1;
tcp_port = atoi(conf->config_input_port);
}
else
{
GF_SAFEALLOC(tcp_conf, TCP_Input);
tcp_conf->config_flag = &config_flag;
tcp_conf->RAPtimer = &timer;
tcp_conf->port = tcp_port;
tcp_conf->config = conf;
tcp_thread = gf_th_new("TCPInterface");
/* Starting the thread which will write the received config in a temporary file */
th_err_tcp = gf_th_run(tcp_thread, tcp_server, tcp_conf);
fprintf(stdout, "Waiting for configuration on port %d...\n", tcp_conf->port);
while(config_flag == 0) {
gf_sleep(1000);
}
fprintf(stdout, "Configuration File received. Starting Streaming ...\n");
}
timer = atoi(conf->rap_timer);
dest_port = atoi(conf->dest_port);
res = PNC_InitRTP(&chan, (char *)conf->dest_ip, dest_port, mtu_size);
if (res != 0) {
fprintf(stderr, "Cannot initialize RTP output (error: %d)\n", res);
exit(1);
}
carrousel_mutex = gf_mx_new("Carrousel");
data = PNC_Init_SceneGenerator(chan, &hdr, (char *) conf->scene_init_file,
socketType_for_updates, (u16) atoi(conf->modif_input_port), debug);
if (!data) {
fprintf(stderr, "Cannot initialize Scene Generator\n");
exit(1);
}
data->carrousel_mutex = carrousel_mutex;
data->RAPsent = 1;
UDP_feedback_socket = gf_sk_new(GF_SOCK_TYPE_UDP);
e = gf_sk_bind(UDP_feedback_socket, NULL, (u16)atoi(conf->feedback_port), (char*)conf->feedback_ip, (u16)atoi(conf->feedback_port), 0);
if (e) {
fprintf(stderr, "Cannot bind socket for bitrate feedback information (%s)\n", gf_error_to_string(e));
} else {
e = gf_sk_set_block_mode(UDP_feedback_socket, 1);
if (e) {
fprintf(stderr, "Cannot set feedback socket block mode (%s)\n", gf_error_to_string(e));
}
}
data->feedback_socket = UDP_feedback_socket;
PNC_InitPacketiser(data, sdp_fmt, mtu_size);
PNC_SendInitScene(data);
GF_SAFEALLOC(rap_conf, RAP_Input);
rap_conf->RAPtimer = &timer;
rap_conf->carrousel_mutex = carrousel_mutex;
rap_conf->data = data;
rap_thread = gf_th_new("RAPGenerator");
th_err_rap = gf_th_run(rap_thread, RAP_send, rap_conf);
sdp_generator(data, (char *)conf->dest_ip, sdp_fmt);
run = 1;
while (run)
{
GF_Err e = PNC_processBIFSGenerator(data);
if (e) {
fprintf(stderr, "Cannot Process BIFS data (%s)\n", gf_error_to_string(e));
break;
}
if (has_input()) {
char c = get_a_char();
switch (c) {
case 'q':
run = 0;
break;
}
}
gf_sleep(10);
}
/* waiting for termination of the RAP thread */
rap_conf->status = 0;
while (rap_conf->status != 2)
gf_sleep(0);
gf_free(rap_conf);
gf_th_del(rap_thread);
/* waiting for termination of the TCP listening thread */
if (tcp_conf) {
tcp_conf->status = 0;
while (tcp_conf->status != 2)
gf_sleep(0);
gf_free(tcp_conf);
gf_th_del(tcp_thread);
}
PNC_Close_SceneGenerator(data);
gf_free(conf);
if (gf_config_file)
gf_cfg_del(gf_config_file);
gf_mx_del(carrousel_mutex);
gf_sys_close();
return 0;
}
int live_session(int argc, char **argv)
{
GF_Err e;
int i;
char *filename = NULL;
char *dst = NULL;
char *ifce_addr = NULL;
char *sdp_name = "session.sdp";
u16 dst_port = 7000;
u32 load_type=0;
u32 check;
u32 ttl = 1;
u32 path_mtu = 1450;
s32 next_time;
u64 last_src_modif, mod_time;
char *src_name = NULL;
Bool run, has_carousel, no_rap;
Bool udp = 0;
u16 sk_port=0;
GF_Socket *sk = NULL;
LiveSession livesess;
RTPChannel *ch;
char *update_buffer = NULL;
u32 update_buffer_size = 0;
u16 aggregate_on_stream;
Bool adjust_carousel_time, force_rap, aggregate_au, discard_pending, signal_rap, version_inc;
Bool update_context;
u32 period, ts_delta, signal_critical;
u16 es_id;
e = GF_OK;
/* souchay : needs to initialize those two vars... */
aggregate_au = 1;
es_id = 0;
no_rap = 0;
gf_sys_init(0);
memset(&livesess, 0, sizeof(LiveSession));
gf_log_set_tool_level(GF_LOG_ALL, GF_LOG_INFO);
for (i=1; i<argc; i++) {
char *arg = argv[i];
if (arg[0] != '-') filename = arg;
else if (!strnicmp(arg, "-dst=", 5)) dst = arg+5;
else if (!strnicmp(arg, "-port=", 6)) dst_port = atoi(arg+6);
else if (!strnicmp(arg, "-sdp=", 5)) sdp_name = arg+5;
else if (!strnicmp(arg, "-mtu=", 5)) path_mtu = atoi(arg+5);
else if (!strnicmp(arg, "-ttl=", 5)) ttl = atoi(arg+5);
else if (!strnicmp(arg, "-ifce=", 6)) ifce_addr = arg+6;
else if (!strnicmp(arg, "-no-rap", 7)) no_rap = 1;
else if (!strnicmp(arg, "-dims", 5)) load_type = GF_SM_LOAD_DIMS;
else if (!strnicmp(arg, "-src=", 5)) src_name = arg+5;
else if (!strnicmp(arg, "-udp=", 5)) { sk_port = atoi(arg+5); udp = 1; }
else if (!strnicmp(arg, "-tcp=", 5)) { sk_port = atoi(arg+5); udp = 0; }
}
if (!filename) {
fprintf(stdout, "Missing filename\n");
PrintLiveUsage();
return 1;
}
if (dst_port && dst) livesess.streams = gf_list_new();
livesess.seng = gf_seng_init(&livesess, filename, load_type, NULL, (load_type == GF_SM_LOAD_DIMS) ? 1 : 0);
if (!livesess.seng) {
fprintf(stdout, "Cannot create scene engine\n");
return 1;
}
if (livesess.streams) live_session_setup(&livesess, dst, dst_port, path_mtu, ttl, ifce_addr, sdp_name);
has_carousel = 0;
last_src_modif = src_name ? gf_file_modification_time(src_name) : 0;
if (sk_port) {
sk = gf_sk_new(udp ? GF_SOCK_TYPE_UDP : GF_SOCK_TYPE_TCP);
if (udp) {
e = gf_sk_bind(sk, NULL, sk_port, NULL, 0, 0);
if (e != GF_OK) {
if (sk) gf_sk_del(sk);
sk = NULL;
}
} else {
}
}
for (i=0; i<argc; i++) {
char *arg = argv[i];
if (!strnicmp(arg, "-rap=", 5)) {
u32 period, id, j;
RTPChannel *ch;
period = id = 0;
if (strchr(arg, ':')) {
sscanf(arg, "-rap=ESID=%u:%u", &id, &period);
e = gf_seng_enable_aggregation(livesess.seng, id, 1);
if (e) {
fprintf(stdout, "Cannot enable aggregation on stream %u: %s\n", id, gf_error_to_string(e));
goto exit;
}
} else {
sscanf(arg, "-rap=%u", &period);
}
j=0;
while (NULL != (ch = gf_list_enum(livesess.streams, &j))) {
if (!id || (ch->ESID==id))
ch->carousel_period = period;
}
has_carousel = 1;
}
}
i=0;
while (NULL != (ch = gf_list_enum(livesess.streams, &i))) {
if (ch->carousel_period) {
has_carousel = 1;
break;
}
}
update_context = 0;
if (has_carousel || !no_rap) {
livesess.carousel_generation = 1;
gf_seng_encode_context(livesess.seng, live_session_callback);
livesess.carousel_generation = 0;
}
live_session_send_carousel(&livesess, NULL);
check = 10;
run = 1;
while (run) {
check--;
if (!check) {
check = 10;
if (gf_prompt_has_input()) {
char c = gf_prompt_get_char();
switch (c) {
case 'q':
run=0;
break;
case 'U':
livesess.critical = 1;
case 'u':
{
GF_Err e;
char szCom[8192];
fprintf(stdout, "Enter command to send:\n");
szCom[0] = 0;
if (1 > scanf("%[^\t\n]", szCom)){
fprintf(stderr, "No command entered properly, aborting.\n");
break;
}
/*stdin flush bug*/
while (getchar()!='\n') {}
e = gf_seng_encode_from_string(livesess.seng, 0, 0, szCom, live_session_callback);
if (e) fprintf(stdout, "Processing command failed: %s\n", gf_error_to_string(e));
e = gf_seng_aggregate_context(livesess.seng, 0);
livesess.critical = 0;
update_context = 1;
}
break;
case 'E':
livesess.critical = 1;
case 'e':
{
GF_Err e;
char szCom[8192];
fprintf(stdout, "Enter command to send:\n");
szCom[0] = 0;
if (1 > scanf("%[^\t\n]", szCom)){
printf("No command entered properly, aborting.\n");
break;
}
/*stdin flush bug*/
while (getchar()!='\n') {}
e = gf_seng_encode_from_string(livesess.seng, 0, 1, szCom, live_session_callback);
if (e) fprintf(stdout, "Processing command failed: %s\n", gf_error_to_string(e));
livesess.critical = 0;
e = gf_seng_aggregate_context(livesess.seng, 0);
}
break;
case 'p':
{
char rad[GF_MAX_PATH];
fprintf(stdout, "Enter output file name - \"std\" for stdout: ");
if (1 > scanf("%s", rad)){
fprintf(stderr, "No ouput file name entered, aborting.\n");
break;
}
e = gf_seng_save_context(livesess.seng, !strcmp(rad, "std") ? NULL : rad);
fprintf(stdout, "Dump done (%s)\n", gf_error_to_string(e));
}
break;
case 'F':
update_context = 1;
case 'f':
livesess.force_carousel = 1;
break;
}
e = GF_OK;
}
}
/*process updates from file source*/
if (src_name) {
mod_time = gf_file_modification_time(src_name);
if (mod_time != last_src_modif) {
FILE *srcf;
char flag_buf[201], *flag;
fprintf(stdout, "Update file modified - processing\n");
last_src_modif = mod_time;
srcf = gf_f64_open(src_name, "rt");
if (!srcf) continue;
/*checks if we have a broadcast config*/
if (!fgets(flag_buf, 200, srcf))
flag_buf[0] = '\0';
fclose(srcf);
aggregate_on_stream = (u16) -1;
adjust_carousel_time = force_rap = discard_pending = signal_rap = signal_critical = 0;
aggregate_au = version_inc = 1;
period = -1;
ts_delta = 0;
es_id = 0;
/*find our keyword*/
flag = strstr(flag_buf, "gpac_broadcast_config ");
if (flag) {
flag += strlen("gpac_broadcast_config ");
/*move to next word*/
while (flag && (flag[0]==' ')) flag++;
while (1) {
char *sep = strchr(flag, ' ');
if (sep) sep[0] = 0;
if (!strnicmp(flag, "esid=", 5)) es_id = atoi(flag+5);
else if (!strnicmp(flag, "period=", 7)) period = atoi(flag+7);
else if (!strnicmp(flag, "ts=", 3)) ts_delta = atoi(flag+3);
else if (!strnicmp(flag, "carousel=", 9)) aggregate_on_stream = atoi(flag+9);
else if (!strnicmp(flag, "restamp=", 8)) adjust_carousel_time = atoi(flag+8);
else if (!strnicmp(flag, "discard=", 8)) discard_pending = atoi(flag+8);
else if (!strnicmp(flag, "aggregate=", 10)) aggregate_au = atoi(flag+10);
else if (!strnicmp(flag, "force_rap=", 10)) force_rap = atoi(flag+10);
else if (!strnicmp(flag, "rap=", 4)) signal_rap = atoi(flag+4);
else if (!strnicmp(flag, "critical=", 9)) signal_critical = atoi(flag+9);
else if (!strnicmp(flag, "vers_inc=", 9)) version_inc = atoi(flag+9);
if (sep) {
sep[0] = ' ';
flag = sep+1;
} else {
break;
}
}
set_broadcast_params(&livesess, es_id, period, ts_delta, aggregate_on_stream, adjust_carousel_time, force_rap, aggregate_au, discard_pending, signal_rap, signal_critical, version_inc);
}
e = gf_seng_encode_from_file(livesess.seng, es_id, aggregate_au ? 0 : 1, src_name, live_session_callback);
if (e) fprintf(stdout, "Processing command failed: %s\n", gf_error_to_string(e));
e = gf_seng_aggregate_context(livesess.seng, 0);
update_context = no_rap ? 0 : 1;
}
}
/*process updates from socket source*/
if (sk) {
char buffer[2049];
u32 bytes_read;
Bool keep_receive;
u32 update_length;
u32 bytes_received;
e = gf_sk_receive(sk, buffer, 2048, 0, &bytes_read);
if (e == GF_OK) {
u32 hdr_length = 0;
u8 cmd_type = buffer[0];
bytes_received = 0;
switch (cmd_type) {
case 0:
{
GF_BitStream *bs = gf_bs_new(buffer, bytes_read, GF_BITSTREAM_READ);
gf_bs_read_u8(bs);
es_id = gf_bs_read_u16(bs);
aggregate_on_stream = gf_bs_read_u16(bs);
if (aggregate_on_stream==0xFFFF) aggregate_on_stream = -1;
adjust_carousel_time = gf_bs_read_int(bs, 1);
force_rap = gf_bs_read_int(bs, 1);
aggregate_au = gf_bs_read_int(bs, 1);
discard_pending = gf_bs_read_int(bs, 1);
signal_rap = gf_bs_read_int(bs, 1);
signal_critical = gf_bs_read_int(bs, 1);
version_inc = gf_bs_read_int(bs, 1);
gf_bs_read_int(bs, 1);
period = gf_bs_read_u16(bs);
if (period==0xFFFF) period = -1;
ts_delta = gf_bs_read_u16(bs);
update_length = gf_bs_read_u32(bs);
hdr_length = 12;
gf_bs_del(bs);
}
set_broadcast_params(&livesess, es_id, period, ts_delta, aggregate_on_stream, adjust_carousel_time, force_rap, aggregate_au, discard_pending, signal_rap, signal_critical, version_inc);
break;
default:
update_length = 0;
break;
}
if (update_buffer_size <= update_length) {
update_buffer = gf_realloc(update_buffer, update_length+1);
update_buffer_size = update_length+1;
}
if (update_length && (bytes_read>hdr_length) ) {
memcpy(update_buffer, buffer+hdr_length, bytes_read-hdr_length);
bytes_received = bytes_read-hdr_length;
}
while (bytes_received<update_length) {
e = gf_sk_receive(sk, buffer, 2048, 0, &bytes_read);
switch (e) {
case GF_IP_NETWORK_EMPTY:
keep_receive = 0;
break;
case GF_OK:
memcpy(update_buffer+bytes_received, buffer, bytes_read);
bytes_received += bytes_read;
break;
default:
keep_receive = 0;
fprintf(stderr, "Error with UDP socket : %s\n", gf_error_to_string(e));
break;
}
}
update_buffer[update_length] = 0;
if (update_length) {
e = gf_seng_encode_from_string(livesess.seng, es_id, aggregate_au ? 0 : 1, update_buffer, live_session_callback);
if (e) fprintf(stdout, "Processing command failed: %s\n", gf_error_to_string(e));
e = gf_seng_aggregate_context(livesess.seng, 0);
update_context = 1;
}
}
}
if (update_context) {
livesess.carousel_generation=1;
e = gf_seng_encode_context(livesess.seng, live_session_callback );
livesess.carousel_generation=0;
update_context = 0;
}
if (livesess.force_carousel) {
live_session_send_carousel(&livesess, NULL);
livesess.force_carousel = 0;
continue;
}
if (!has_carousel) {
gf_sleep(10);
continue;
}
ch = next_carousel(&livesess, &next_time);
if ((ch==NULL) || (next_time > 20)) {
gf_sleep(20);
continue;
}
if (next_time) gf_sleep(next_time);
live_session_send_carousel(&livesess, ch);
}
exit:
live_session_shutdown(&livesess);
if (update_buffer) gf_free(update_buffer);
if (sk) gf_sk_del(sk);
gf_sys_close();
return e ? 1 : 0;
}