void gf_mse_source_buffer_del(GF_HTML_SourceBuffer *sb)
{
GF_HTML_TrackList tlist;
gf_html_timeranges_del(sb->buffered);
gf_mse_reset_input_buffer(sb->input_buffer);
gf_list_del(sb->input_buffer);
if (sb->prev_buffer) gf_arraybuffer_del((GF_HTML_ArrayBuffer *)sb->prev_buffer, GF_FALSE);
tlist.tracks = sb->tracks;
gf_html_tracklist_del(&tlist);
{
u32 i, count;
count = gf_list_count(sb->threads);
for(i = 0; i < count; i++) {
GF_Thread *t = (GF_Thread *)gf_list_get(sb->threads, i);
gf_th_del(t);
}
gf_list_del(sb->threads);
}
gf_th_del(sb->parser_thread);
gf_th_del(sb->remove_thread);
if (sb->service_desc) gf_odf_desc_del((GF_Descriptor *)sb->service_desc);
gf_free(sb);
}
void avr_delete ( GF_BaseInterface *ifce )
{
GF_TermExt *dr = ( GF_TermExt * ) ifce;
GF_AVRedirect *avr = dr->udta;
avr->is_running = 0;
/* Ensure encoding is finished */
gf_mx_p(avr->frameMutex);
gf_mx_v(avr->frameMutex);
gf_sleep(200);
gf_th_stop(avr->encodingThread);
gf_mx_del(avr->frameMutex);
avr->frameMutex = NULL;
gf_th_del(avr->encodingThread);
avr->encodingThread = NULL;
gf_mx_del(avr->encodingMutex);
avr->encodingMutex = NULL;
if ( avr->ts_implementation )
{
ts_amux_del(avr->ts_implementation);
avr->ts_implementation = NULL;
}
avr->videoCodec = NULL;
if ( avr->YUVpicture )
{
av_free ( avr->YUVpicture );
}
if ( avr->yuv_data )
av_free ( avr->yuv_data );
avr->yuv_data = NULL;
avr->YUVpicture = NULL;
if ( avr->RGBpicture )
{
av_free ( avr->RGBpicture );
}
avr->RGBpicture = NULL;
if ( avr->swsContext )
sws_freeContext ( avr->swsContext );
avr->swsContext = NULL;
if ( avr->videoOutbuf )
gf_free ( avr->videoOutbuf );
avr->videoOutbuf = NULL;
if ( avr->pcmAudio )
gf_ringbuffer_del(avr->pcmAudio);
avr->pcmAudio = NULL;
gf_global_resource_unlock(avr->globalLock);
avr->globalLock = NULL;
if (avr->audioEncodingThread){
gf_th_stop(avr->audioEncodingThread);
gf_th_del(avr->audioEncodingThread);
}
avr->audioEncodingThread = NULL;
gf_free ( avr );
gf_free ( dr );
}
void gf_term_stop_scheduler(GF_Terminal *term)
{
if (term->mm_thread) {
u32 count, i;
term->flags &= ~GF_TERM_RUNNING;
while (!(term->flags & GF_TERM_DEAD) )
gf_sleep(2);
count = gf_list_count(term->codecs);
for (i=0; i<count; i++) {
CodecEntry *ce = gf_list_get(term->codecs, i);
if (ce->flags & GF_MM_CE_DISCARDED) {
gf_free(ce);
gf_list_rem(term->codecs, i);
count--;
i--;
}
}
assert(! gf_list_count(term->codecs));
gf_th_del(term->mm_thread);
}
gf_list_del(term->codecs);
gf_mx_del(term->mm_mx);
}
void RTP_Delete(GF_BaseInterface *bi)
{
RTPClient *rtp;
u32 retry;
GF_InputService *plug = (GF_InputService *) bi;
rtp = (RTPClient *)plug->priv;
/*shutdown thread*/
if (rtp->th_state==1) rtp->th_state = 0;
retry = 20;
while ((rtp->th_state==1) && retry) {
gf_sleep(10);
retry--;
}
assert(retry);
if (rtp->session_state_data) gf_free(rtp->session_state_data);
RP_cleanup(rtp);
gf_th_del(rtp->th);
gf_mx_del(rtp->mx);
gf_list_del(rtp->sessions);
gf_list_del(rtp->channels);
gf_free(rtp);
gf_free(bi);
}
void gf_term_remove_codec(GF_Terminal *term, GF_Codec *codec)
{
u32 i;
Bool locked;
CodecEntry *ce;
GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("[Terminal] Unregistering codec %s\n", codec->decio ? codec->decio->module_name : "RAW"));
/*cf note above*/
locked = gf_mx_try_lock(term->mm_mx);
i=0;
while ((ce = (CodecEntry*)gf_list_enum(term->codecs, &i))) {
if (ce->dec != codec) continue;
if (ce->thread) {
if (ce->flags & GF_MM_CE_RUNNING) {
ce->flags &= ~GF_MM_CE_RUNNING;
while (! (ce->flags & GF_MM_CE_DEAD)) gf_sleep(10);
ce->flags &= ~GF_MM_CE_DEAD;
}
gf_th_del(ce->thread);
gf_mx_del(ce->mx);
}
if (locked) {
gf_free(ce);
gf_list_rem(term->codecs, i-1);
} else {
ce->flags |= GF_MM_CE_DISCARDED;
}
break;
}
if (locked) gf_mx_v(term->mm_mx);
return;
}
void gf_sc_ar_del(GF_AudioRenderer *ar)
{
if (!ar) return;
GF_LOG(GF_LOG_DEBUG, GF_LOG_AUDIO, ("[AudioRender] Destroying compositor\n"));
/*resume if paused (might cause deadlock otherwise)*/
if (ar->Frozen) gf_sc_ar_control(ar, GF_SC_AR_RESUME);
/*stop and shutdown*/
if (ar->audio_out) {
/*kill audio thread*/
if (!ar->audio_out->SelfThreaded) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_AUDIO, ("[AudioRender] stopping audio thread\n"));
ar->audio_th_state = 2;
while (ar->audio_th_state != 3) {
gf_sleep(33);
}
GF_LOG(GF_LOG_DEBUG, GF_LOG_AUDIO, ("[AudioRender] audio thread stopped\n"));
gf_th_del(ar->th);
GF_LOG(GF_LOG_DEBUG, GF_LOG_AUDIO, ("[AudioRender] audio thread destroyed\n"));
}
/*lock access before shutdown and emulate a reconfig (avoids mixer lock from self-threaded modules)*/
ar->need_reconfig = GF_TRUE;
gf_mixer_lock(ar->mixer, GF_TRUE);
if (ar->audio_out->SelfThreaded) ar->audio_out->Shutdown(ar->audio_out);
gf_modules_close_interface((GF_BaseInterface *)ar->audio_out);
ar->audio_out = NULL;
gf_mixer_lock(ar->mixer, GF_FALSE);
}
gf_mixer_del(ar->mixer);
if (ar->audio_listeners) gf_list_del(ar->audio_listeners);
gf_afc_unload(&ar->filter_chain);
gf_free(ar);
GF_LOG(GF_LOG_DEBUG, GF_LOG_AUDIO, ("[AudioRender] Renderer destroyed\n"));
}
static GF_Err FM_FAKE_PULL_Disconnect(GF_HYBMEDIA *self)
{
FM_FAKE_PULL *priv = (FM_FAKE_PULL*)self->private_data;
self->owner = NULL;
#ifdef EXT_MEDIA_LOAD_THREADED
gf_th_del(priv->media_th);
#endif
return GF_OK;
}
void SDL_DeleteVideo(void *ifce)
{
GF_VideoOutput *dr = (GF_VideoOutput *)ifce;
SDLVID();
#ifdef SDL_WINDOW_THREAD
gf_th_del(ctx->sdl_th);
#endif
gf_mx_del(ctx->evt_mx);
gf_free(ctx);
gf_free(dr);
}
void gf_sr_del(GF_Renderer *sr)
{
if (!sr) return;
GF_LOG(GF_LOG_DEBUG, GF_LOG_RENDER, ("[Render] Destroying Renderer\n"));
gf_sr_lock(sr, 1);
if (sr->VisualThread) {
sr->video_th_state = 2;
while (sr->video_th_state!=3) gf_sleep(10);
gf_th_del(sr->VisualThread);
}
if (sr->video_out) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_RENDER, ("[Render] Closing video output\n"));
sr->video_out->Shutdown(sr->video_out);
gf_modules_close_interface((GF_BaseInterface *)sr->video_out);
}
GF_LOG(GF_LOG_DEBUG, GF_LOG_RENDER, ("[Render] Closing visual renderer\n"));
sr->visual_renderer->UnloadRenderer(sr->visual_renderer);
GF_LOG(GF_LOG_DEBUG, GF_LOG_RENDER, ("[Render] Unloading visual renderer module\n"));
gf_modules_close_interface((GF_BaseInterface *)sr->visual_renderer);
GF_LOG(GF_LOG_DEBUG, GF_LOG_RENDER, ("[Render] visual renderer module unloaded\n"));
if (sr->audio_renderer) gf_sr_ar_del(sr->audio_renderer);
#ifdef GF_SR_EVENT_QUEUE
gf_mx_p(sr->ev_mx);
while (gf_list_count(sr->events)) {
GF_Event *ev = (GF_Event *)gf_list_get(sr->events, 0);
gf_list_rem(sr->events, 0);
free(ev);
}
gf_mx_v(sr->ev_mx);
gf_mx_del(sr->ev_mx);
gf_list_del(sr->events);
#endif
if (sr->font_engine) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_RENDER, ("[Render] Closing font engine\n"));
sr->font_engine->shutdown_font_engine(sr->font_engine);
gf_modules_close_interface((GF_BaseInterface *)sr->font_engine);
}
gf_list_del(sr->textures);
gf_list_del(sr->time_nodes);
gf_list_del(sr->extra_scenes);
gf_sr_lock(sr, 0);
gf_mx_del(sr->mx);
free(sr);
GF_LOG(GF_LOG_DEBUG, GF_LOG_RENDER, ("[Render] Renderer destroyed\n"));
}
void MPEGVS_Stop(struct __input_device * dr)
{
MPEGVSCTX;
if ( rc->trd )
{
rc->stop = 1;
while ( gf_th_status(rc->trd) == GF_THREAD_STATUS_RUN )
gf_sleep(5);
gf_th_del(rc->trd);
rc->trd = NULL;
rc->stop = 0;
}
}
void ISDec_Delete(GF_BaseDecoder *plug)
{
ISPriv *priv = (ISPriv *)plug->privateStack;
gf_list_del(priv->is_nodes);
while (gf_list_count(priv->ddf)) {
GF_FieldInfo *fi = (GF_FieldInfo *)gf_list_get(priv->ddf, 0);
gf_list_rem(priv->ddf, 0);
gf_sg_vrml_field_pointer_del(fi->far_ptr, fi->fieldType);
free(fi);
}
gf_list_del(priv->ddf);
#if GPAC_HTK_DEMO
gf_th_del(priv->th);
#endif
free(priv);
free(plug);
}
void Delete_FFMPEG_Demux(void *ifce)
{
FFDemux *ffd;
GF_InputService *ptr = (GF_InputService *)ifce;
if (!ptr)
return;
ffd = ptr->priv;
if (ffd) {
if (ffd->thread)
gf_th_del(ffd->thread);
ffd->thread = NULL;
if (ffd->mx)
gf_mx_del(ffd->mx);
ffd->mx = NULL;
gf_free(ffd);
ptr->priv = NULL;
}
gf_free(ptr);
}
void DD_ShutdownWindow(GF_VideoOutput *dr)
{
DDContext *ctx = (DDContext *)dr->opaque;
if (ctx->owns_hwnd) {
PostMessage(ctx->os_hwnd, WM_DESTROY, 0, 0);
} else if (ctx->orig_wnd_proc) {
/*restore window proc*/
//SetWindowLong(ctx->os_hwnd, GWL_WNDPROC, ctx->orig_wnd_proc);
ctx->orig_wnd_proc = 0L;
}
PostMessage(ctx->fs_hwnd, WM_DESTROY, 0, 0);
while (ctx->th_state!=2) gf_sleep(10);
UnregisterClass("GPAC DirectDraw Output", GetModuleHandle("gm_dx_hw.dll"));
gf_th_del(ctx->th);
ctx->th = NULL;
ctx->os_hwnd = NULL;
ctx->fs_hwnd = NULL;
the_video_output = NULL;
}
static GF_Err SAF_CloseService(GF_InputService *plug)
{
SAFIn *read = (SAFIn *)plug->priv;
if (read->th) {
if (read->run_state == 1) {
read->run_state=0;
while (read->run_state!=2) gf_sleep(2);
}
gf_th_del(read->th);
read->th = NULL;
}
if (read->stream) fclose(read->stream);
read->stream = NULL;
if (read->dnload) gf_service_download_del(read->dnload);
read->dnload = NULL;
gf_service_disconnect_ack(read->service, NULL, GF_OK);
return GF_OK;
}
void *New_FFMPEG_Demux()
{
GF_InputService *ffd;
FFDemux *priv;
GF_SAFEALLOC(ffd, GF_InputService);
if (!ffd) return NULL;
GF_SAFEALLOC(priv, FFDemux);
if (!priv) {
gf_free(ffd);
return NULL;
}
GF_LOG(GF_LOG_INFO, GF_LOG_CONTAINER, ("[FFMPEG Demuxer] Registering all ffmpeg plugins...\n") );
/* register all codecs, demux and protocols */
av_register_all();
avformat_network_init();
GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("[FFMPEG Demuxer] Registering all ffmpeg plugins DONE.\n") );
ffd->RegisterMimeTypes = FFD_RegisterMimeTypes;
ffd->CanHandleURL = FFD_CanHandleURL;
ffd->CloseService = FFD_CloseService;
ffd->ConnectChannel = FFD_ConnectChannel;
ffd->ConnectService = FFD_ConnectService;
ffd->DisconnectChannel = FFD_DisconnectChannel;
ffd->GetServiceDescriptor = FFD_GetServiceDesc;
ffd->ServiceCommand = FFD_ServiceCommand;
ffd->CanHandleURLInService = FFD_CanHandleURLInService;
priv->thread = gf_th_new("FFMPEG Demux");
priv->mx = gf_mx_new("FFMPEG Demux");
if (!priv->thread || !priv->mx) {
if (priv->thread) gf_th_del(priv->thread);
if (priv->mx) gf_mx_del(priv->mx);
gf_free(priv);
return NULL;
}
GF_REGISTER_MODULE_INTERFACE(ffd, GF_NET_CLIENT_INTERFACE, "FFMPEG Demuxer", "gpac distribution");
ffd->priv = priv;
return ffd;
}
void Delete_FFMPEG_Demux(void *ifce)
{
FFDemux *ffd;
GF_InputService *ptr = (GF_InputService *)ifce;
if (!ptr)
return;
ffd = (FFDemux*)ptr->priv;
if (ffd) {
if (ffd->thread)
gf_th_del(ffd->thread);
ffd->thread = NULL;
if (ffd->mx)
gf_mx_del(ffd->mx);
#ifndef USE_PRE_0_7
if (ffd->options) av_dict_free(&ffd->options);
#endif
ffd->mx = NULL;
gf_free(ffd);
ptr->priv = NULL;
}
gf_free(ptr);
}
void gf_dm_sess_del(GF_DownloadSession *sess)
{
const char *opt;
/*self-destruction, let the download manager destroy us*/
if (sess->th && sess->in_callback) {
sess->destroy = 1;
return;
}
gf_dm_disconnect(sess);
/*if threaded wait for thread exit*/
if (sess->th) {
while (!(sess->flags & GF_DOWNLOAD_SESSION_THREAD_DEAD))
gf_sleep(1);
gf_th_del(sess->th);
gf_mx_del(sess->mx);
}
gf_list_del_item(sess->dm->sessions, sess);
if (sess->cache_name) {
opt = gf_cfg_get_key(sess->dm->cfg, "Downloader", "CleanCache");
if (opt && !stricmp(opt, "yes")) gf_delete_file(sess->cache_name);
free(sess->cache_name);
}
if (sess->server_name) free(sess->server_name);
if (sess->remote_path) free(sess->remote_path);
if (sess->user) free(sess->user);
if (sess->passwd) free(sess->passwd);
if (sess->mime_type) free(sess->mime_type);
if (sess->cache) fclose(sess->cache);
if (sess->init_data) free(sess->init_data);
free(sess);
}
int main(int argc, char **argv)
{
/* The ISO progressive reader */
ISOProgressiveReader reader;
/* Error indicator */
GF_Err e;
/* input file to be read in the data buffer */
FILE *input;
/* number of bytes read from the file at each read operation */
u32 read_bytes;
/* number of bytes read from the file (total) */
u64 total_read_bytes;
/* size of the input file */
u64 file_size;
/* number of bytes required to finish the current ISO Box reading (not used here)*/
u64 missing_bytes;
/* Thread used to run the ISO parsing in */
GF_Thread *reading_thread;
/* Return value for the program */
int ret = 0;
/* Usage */
if (argc != 2) {
fprintf(stdout, "Usage: %s filename\n", argv[0]);
return 1;
}
/* Initializing GPAC framework */
/* Enables GPAC memory tracking in debug mode only */
#if defined(DEBUG) || defined(_DEBUG)
gf_sys_init(GF_MemTrackerSimple);
gf_log_set_tool_level(GF_LOG_ALL, GF_LOG_WARNING);
gf_log_set_tool_level(GF_LOG_MEMORY, GF_LOG_INFO);
#else
gf_sys_init(GF_MemTrackerNone);
gf_log_set_tool_level(GF_LOG_ALL, GF_LOG_WARNING);
#endif
/* This is an input file to read data from. Could be replaced by any other method to retrieve the data (e.g. JavaScript, socket, ...)*/
input = gf_fopen(argv[1], "rb");
if (!input) {
fprintf(stdout, "Could not open file %s for reading.\n", argv[1]);
gf_sys_close();
return 1;
}
gf_fseek(input, 0, SEEK_END);
file_size = gf_ftell(input);
gf_fseek(input, 0, SEEK_SET);
/* Initializing the progressive reader */
memset(&reader, 0, sizeof(ISOProgressiveReader));
reading_thread = gf_th_new("ISO reading thread");
reader.mutex = gf_mx_new("ISO Segment");
reader.do_run = GF_TRUE;
/* we want to parse the first track */
reader.track_id = 1;
/* start the async parsing */
gf_th_run(reading_thread, iso_progressive_read_thread, &reader);
/* start the data reading */
reader.data_size = BUFFER_BLOCK_SIZE;
reader.data = (u8 *)gf_malloc(reader.data_size);
reader.valid_data_size = 0;
total_read_bytes = 0;
while (1) {
/* block the parser until we are done manipulating the data buffer */
gf_mx_p(reader.mutex);
if (reader.valid_data_size + BUFFER_BLOCK_SIZE > MAX_BUFFER_SIZE) {
/* regulate the reader to limit the max buffer size and let some time to the parser to release buffer data */
fprintf(stdout, "Buffer full (%d/%d)- waiting to read next data \r", reader.valid_data_size, reader.data_size);
gf_mx_v(reader.mutex);
//gf_sleep(10);
} else {
/* make sure we have enough space in the buffer to read the next bloc of data */
if (reader.valid_data_size + BUFFER_BLOCK_SIZE > reader.data_size) {
reader.data = (u8 *)gf_realloc(reader.data, reader.data_size + BUFFER_BLOCK_SIZE);
reader.data_size += BUFFER_BLOCK_SIZE;
}
/* read the next bloc of data and update the data buffer url */
read_bytes = fread(reader.data+reader.valid_data_size, 1, BUFFER_BLOCK_SIZE, input);
total_read_bytes += read_bytes;
fprintf(stdout, "Read "LLD" bytes of "LLD" bytes from input file %s (buffer status: %5d/%5d)\r", total_read_bytes, file_size, argv[1], reader.valid_data_size, reader.data_size);
if (read_bytes) {
reader.valid_data_size += read_bytes;
sprintf(reader.data_url, "gmem://%d@%p", reader.valid_data_size, reader.data);
} else {
/* end of file we can quit */
gf_mx_v(reader.mutex);
break;
}
/* if the file is not yet opened (no movie), open it in progressive mode (to update its data later on) */
if (!reader.movie) {
/* let's initialize the parser */
e = gf_isom_open_progressive(reader.data_url, 0, 0, &reader.movie, &missing_bytes);
if (reader.movie) {
gf_isom_set_single_moof_mode(reader.movie, GF_TRUE);
}
/* we can let parser try to work now */
gf_mx_v(reader.mutex);
if ((e == GF_OK || e == GF_ISOM_INCOMPLETE_FILE) && reader.movie) {
/* nothing to do, this is normal */
} else {
fprintf(stdout, "Error opening fragmented mp4 in progressive mode: %s (missing "LLD" bytes)\n", gf_error_to_string(e), missing_bytes);
ret = 1;
goto exit;
}
} else {
/* let inform the parser that the buffer has been updated with new data */
e = gf_isom_refresh_fragmented(reader.movie, &missing_bytes, reader.data_url);
/* we can let parser try to work now */
gf_mx_v(reader.mutex);
if (e != GF_OK && e != GF_ISOM_INCOMPLETE_FILE) {
fprintf(stdout, "Error refreshing fragmented mp4: %s (missing "LLD" bytes)\n", gf_error_to_string(e), missing_bytes);
ret = 1;
goto exit;
}
}
//gf_sleep(1);
}
}
exit:
/* stop the parser */
reader.do_run = GF_FALSE;
gf_th_stop(reading_thread);
/* clean structures */
gf_th_del(reading_thread);
gf_mx_del(reader.mutex);
gf_free(reader.data);
gf_isom_close(reader.movie);
gf_fclose(input);
gf_sys_close();
return ret;
}
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;
}
void gf_term_set_threading(GF_Terminal *term, u32 mode)
{
u32 i;
Bool thread_it, restart_it;
CodecEntry *ce;
switch (mode) {
case GF_TERM_THREAD_SINGLE:
if (term->flags & GF_TERM_SINGLE_THREAD) return;
term->flags &= ~GF_TERM_MULTI_THREAD;
term->flags |= GF_TERM_SINGLE_THREAD;
break;
case GF_TERM_THREAD_MULTI:
if (term->flags & GF_TERM_MULTI_THREAD) return;
term->flags &= ~GF_TERM_SINGLE_THREAD;
term->flags |= GF_TERM_MULTI_THREAD;
break;
default:
if (!(term->flags & (GF_TERM_MULTI_THREAD | GF_TERM_SINGLE_THREAD) ) ) return;
term->flags &= ~GF_TERM_SINGLE_THREAD;
term->flags &= ~GF_TERM_MULTI_THREAD;
break;
}
gf_mx_p(term->mm_mx);
i=0;
while ((ce = (CodecEntry*)gf_list_enum(term->codecs, &i))) {
thread_it = 0;
/*free mode, decoder wants threading - do */
if ((mode == GF_TERM_THREAD_FREE) && (ce->flags & GF_MM_CE_REQ_THREAD)) thread_it = 1;
else if (mode == GF_TERM_THREAD_MULTI) thread_it = 1;
if (thread_it && (ce->flags & GF_MM_CE_THREADED)) continue;
if (!thread_it && !(ce->flags & GF_MM_CE_THREADED)) continue;
restart_it = 0;
if (ce->flags & GF_MM_CE_RUNNING) {
restart_it = 1;
ce->flags &= ~GF_MM_CE_RUNNING;
}
if (ce->flags & GF_MM_CE_THREADED) {
/*wait for thread to die*/
while (!(ce->flags & GF_MM_CE_DEAD)) gf_sleep(1);
ce->flags &= ~GF_MM_CE_DEAD;
gf_th_del(ce->thread);
ce->thread = NULL;
gf_mx_del(ce->mx);
ce->mx = NULL;
ce->flags &= ~GF_MM_CE_THREADED;
} else {
term->cumulated_priority -= ce->dec->Priority+1;
}
if (thread_it) {
ce->flags |= GF_MM_CE_THREADED;
ce->thread = gf_th_new(ce->dec->decio->module_name);
ce->mx = gf_mx_new(ce->dec->decio->module_name);
}
if (restart_it) {
ce->flags |= GF_MM_CE_RUNNING;
if (ce->thread) {
gf_th_run(ce->thread, RunSingleDec, ce);
gf_th_set_priority(ce->thread, term->priority);
} else {
term->cumulated_priority += ce->dec->Priority+1;
}
}
}
gf_mx_v(term->mm_mx);
}
