void VTT_load_script(VTTDec *vttdec, GF_SceneGraph *graph)
{
GF_Node *n, *root;
GF_FieldInfo info;
const char *path;
FILE *jsfile;
if (!graph) return;
gf_sg_add_namespace(graph, "http://www.w3.org/2000/svg", NULL);
gf_sg_add_namespace(graph, "http://www.w3.org/1999/xlink", "xlink");
gf_sg_add_namespace(graph, "http://www.w3.org/2001/xml-events", "ev");
gf_sg_set_scene_size_info(graph, 800, 600, GF_TRUE);
/* modify the scene with an Inline/Animation pointing to the VTT Renderer */
n = root = gf_node_new(graph, TAG_SVG_svg);
gf_node_register(root, NULL);
gf_sg_set_root_node(graph, root);
gf_node_get_attribute_by_name(n, "xmlns", 0, GF_TRUE, GF_FALSE, &info);
gf_svg_parse_attribute(n, &info, "http://www.w3.org/2000/svg", 0);
VTT_UpdateSizeInfo(vttdec);
gf_node_init(n);
n = gf_node_new(graph, TAG_SVG_script);
gf_node_register(n, root);
gf_node_list_add_child(&((GF_ParentNode *)root)->children, n);
path = gf_modules_get_option((GF_BaseInterface *)vttdec->module, "WebVTT", "RenderingScript");
if (!path) {
/* try to find the JS renderer in the default GPAC installation folder */
const char *startuppath = gf_modules_get_option((GF_BaseInterface *)vttdec->module, "General", "StartupFile");
path = gf_url_concatenate(startuppath, "webvtt-renderer.js");
jsfile = gf_fopen(path, "rt");
if (jsfile) {
gf_modules_set_option((GF_BaseInterface *)vttdec->module, "WebVTT", "RenderingScript", path);
gf_fclose(jsfile);
} else {
GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("[WebVTT] Cannot find Rendering Script [WebVTT:RenderingScript] - check config file\n"));
return;
}
}
jsfile = gf_fopen(path, "rt");
if (jsfile) {
gf_fclose(jsfile);
gf_node_get_attribute_by_tag(n, TAG_XLINK_ATT_href, GF_TRUE, GF_FALSE, &info);
if (strstr(path, ":\\")) {
gf_svg_parse_attribute(n, &info, (char *) path, 0);
} else {
char szPath[GF_MAX_PATH];
strcpy(szPath, "file://");
strcat(szPath, path);
gf_svg_parse_attribute(n, &info, (char *) szPath, 0);
}
vttdec->has_rendering_script = GF_TRUE;
} else {
GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("[WebVTT] Cannot open Rendering Script - %s\n", path));
return;
}
gf_node_init(n);
}
JNIEXPORT void JNICALL Java_com_enst_mp4box_mp4terminal_run(JNIEnv * env, jobject obj, jstring sCommand)
{
//CAST_HANDLE(wr);
jniLOGV("mp4terminal::start");
/*if (!wr)
{
jniLOGV("mp4terminal::end : aborted");
return;
}*/
jboolean isCopy;
const char * sOriginalCommand = (*env)->GetStringUTFChars(env, sCommand, &isCopy);
jniLOGV("mp4terminal::command get back ok");
jniLOGV(sOriginalCommand);
int iNbArg = 0;
int i = 0;
char** sConvertedCommandLine;
sConvertedCommandLine = ConvertCommandLine( sOriginalCommand, &i );
jniLOGV("Convert command line done");
FILE* ferr = freopen( "/mnt/sdcard/stderrout.txt", "w", stderr );
FILE* fout = freopen( "/mnt/sdcard/stdout.txt", "w", stdout );
mp4boxMain(i, sConvertedCommandLine);
(*env)->ReleaseStringUTFChars(env, sCommand, sOriginalCommand);
jniLOGV("mp4terminal::end");
gf_fclose(ferr);
gf_fclose(fout);
}
static GF_Err ISOW_Open(GF_StreamingCache *mc, GF_ClientService *serv, const char *location_and_name, Bool keep_existing_files)
{
char szRoot[GF_MAX_PATH], szPath[GF_MAX_PATH], *ext;
ISOMReader *cache = (ISOMReader *)mc->priv;
if (cache->mov || cache->service) return GF_BAD_PARAM;
strcpy(szRoot, location_and_name);
ext = strrchr(szRoot, '.');
if (ext) ext[0] = 0;
strcpy(szPath, szRoot);
strcat(szPath, ".mp4");
if (keep_existing_files) {
FILE *f = gf_fopen(szPath, "rb");
if (f) {
u32 i=0;
gf_fclose(f);
while (1) {
sprintf(szPath, "%s_%04d.mp4", szRoot, i);
f = gf_fopen(szPath, "rb");
if (!f) break;
gf_fclose(f);
i++;
}
}
}
/*create a new movie in write mode (eg no editing)*/
cache->mov = gf_isom_open(szPath, GF_ISOM_OPEN_WRITE, NULL);
if (!cache->mov) return gf_isom_last_error(NULL);
cache->service = serv;
return GF_OK;
}
void RP_SDPFromFile(RTPClient *rtp, char *file_name, RTPStream *stream)
{
FILE *_sdp;
char *sdp_buf;
u32 sdp_size;
sdp_buf = NULL;
if (file_name && strstr(file_name, "file://")) file_name += strlen("file://");
if (!file_name || !(_sdp = gf_fopen(file_name, "rt")) ) {
gf_service_connect_ack(rtp->service, NULL, GF_URL_ERROR);
return;
}
gf_fseek(_sdp, 0, SEEK_END);
sdp_size = (u32) gf_ftell(_sdp);
gf_fseek(_sdp, 0, SEEK_SET);
sdp_buf = (char*)gf_malloc(sdp_size);
if (1 > fread(sdp_buf, 1, sdp_size, _sdp)) {
gf_service_connect_ack(rtp->service, NULL, GF_URL_ERROR);
} else {
RP_LoadSDP(rtp, sdp_buf, sdp_size, stream);
}
gf_fclose(_sdp);
gf_free(sdp_buf);
}
static GF_Err AC3_ConnectService(GF_InputService *plug, GF_ClientService *serv, const char *url)
{
char szURL[2048];
char *ext;
GF_Err reply;
AC3Reader *read = (AC3Reader*)plug->priv;
read->service = serv;
if (read->dnload) gf_service_download_del(read->dnload);
read->dnload = NULL;
strcpy(szURL, url);
ext = strrchr(szURL, '#');
if (ext) ext[0] = 0;
/*remote fetch*/
read->is_remote = !ac3_is_local(szURL);
if (read->is_remote) {
ac3_download_file(plug, (char *) szURL);
return GF_OK;
}
reply = GF_OK;
read->stream = gf_fopen(szURL, "rb");
if (!read->stream) {
reply = GF_URL_ERROR;
} else if (!AC3_ConfigureFromFile(read)) {
gf_fclose(read->stream);
read->stream = NULL;
reply = GF_NOT_SUPPORTED;
}
gf_service_connect_ack(serv, NULL, reply);
if (!reply && read->is_inline ) AC3_SetupObject(read);
return GF_OK;
}
static GF_Err gf_text_guess_format(char *filename, u32 *fmt)
{
char szLine[2048], szTest[10];
u32 val;
FILE *test = gf_fopen(filename, "rt");
if (!test) return GF_URL_ERROR;
while (fgets(szLine, 2048, test) != NULL) {
REM_TRAIL_MARKS(szLine, "\r\n\t ")
if (strlen(szLine)) break;
}
*fmt = GF_TEXT_IMPORT_NONE;
if ((szLine[0]=='{') && strstr(szLine, "}{")) *fmt = GF_TEXT_IMPORT_SUB;
else if (sscanf(szLine, "%u", &val)==1) {
sprintf(szTest, "%u", val);
if (!strcmp(szTest, szLine)) *fmt = GF_TEXT_IMPORT_SRT;
}
else if (!strnicmp(szLine, "<?xml ", 6)) {
char *ext = strrchr(filename, '.');
if (!strnicmp(ext, ".ttxt", 5)) *fmt = GF_TEXT_IMPORT_TTXT;
ext = strstr(szLine, "?>");
if (ext) ext += 2;
if (!ext[0]) {
if (!fgets(szLine, 2048, test))
szLine[0] = '\0';
}
if (strstr(szLine, "x-quicktime-tx3g")) *fmt = GF_TEXT_IMPORT_TEXML;
}
gf_fclose(test);
return GF_OK;
}
GF_EXPORT
GF_Err gf_cfg_save(GF_Config *iniFile)
{
u32 i, j;
IniSection *sec;
IniKey *key;
FILE *file;
if (!iniFile->hasChanged) return GF_OK;
if (iniFile->skip_changes) return GF_OK;
if (!iniFile->fileName) return GF_OK;
file = gf_fopen(iniFile->fileName, "wt");
if (!file) return GF_IO_ERR;
i = 0;
while ((sec = (IniSection *)gf_list_enum(iniFile->sections, &i))) {
/*Temporary sections are not saved*/
if (!strnicmp(sec->section_name, "Temp", 4)) continue;
fprintf(file, "[%s]\n", sec->section_name);
j = 0;
while ((key = (IniKey *)gf_list_enum(sec->keys, &j))) {
fprintf(file, "%s=%s\n", key->name, key->value);
}
/* end of section */
fprintf(file, "\n");
}
gf_fclose(file);
return GF_OK;
}
static GF_Err FFD_CloseService(GF_InputService *plug)
{
FFDemux *ffd = (FFDemux*)plug->priv;
ffd->is_running = 0;
#if FF_API_CLOSE_INPUT_FILE
if (ffd->ctx) av_close_input_file(ffd->ctx);
#else
if (ffd->ctx) avformat_close_input(&ffd->ctx);
#endif
ffd->ctx = NULL;
ffd->audio_ch = ffd->video_ch = NULL;
ffd->audio_run = ffd->video_run = GF_FALSE;
if (ffd->dnload) {
if (ffd->is_running) {
while (!ffd->is_running) gf_sleep(1);
ffd->is_running = 0;
}
gf_service_download_del(ffd->dnload);
ffd->dnload = NULL;
}
if (ffd->buffer) gf_free(ffd->buffer);
ffd->buffer = NULL;
gf_service_disconnect_ack(ffd->service, NULL, GF_OK);
#ifdef FFMPEG_DUMP_REMOTE
if (ffd->outdbg) gf_fclose(ffd->outdbg);
#endif
return GF_OK;
}
static GF_Err ISMA_GetGPAC_KMS(ISMAEAPriv *priv, GF_Channel *ch, const char *kms_url)
{
GF_Err e;
FILE *t;
GF_DownloadSession * sess;
if (!strnicmp(kms_url, "(ipmp)", 6)) return GF_NOT_SUPPORTED;
else if (!strnicmp(kms_url, "(uri)", 5)) kms_url += 5;
else if (!strnicmp(kms_url, "file://", 7)) kms_url += 7;
/*try local*/
t = (strstr(kms_url, "://") == NULL) ? gf_fopen(kms_url, "r") : NULL;
if (t) {
gf_fclose(t);
return gf_ismacryp_gpac_get_info(ch->esd->ESID, (char *)kms_url, priv->key, priv->salt);
}
/*note that gpac doesn't have TLS support -> not really usefull. As a general remark, ISMACryp
is supported as a proof of concept, crypto and IPMP being the last priority on gpac...*/
GF_LOG(GF_LOG_INFO, GF_LOG_MEDIA, ("[CENC/ISMA] Fetching ISMACryp key for channel %d\n", ch->esd->ESID) );
sess = gf_service_download_new(ch->service, kms_url, 0, ISMA_KMS_NetIO, ch);
if (!sess) return GF_IO_ERR;
/*start our download (threaded)*/
gf_dm_sess_process(sess);
while (1) {
e = gf_dm_sess_get_stats(sess, NULL, NULL, NULL, NULL, NULL, NULL);
if (e) break;
}
if (e==GF_EOS) {
e = gf_ismacryp_gpac_get_info(ch->esd->ESID, (char *) gf_dm_sess_get_cache_name(sess), priv->key, priv->salt);
}
gf_service_download_del(sess);
return e;
}
GF_EXPORT
GF_Err gf_isom_extract_meta_xml(GF_ISOFile *file, Bool root_meta, u32 track_num, char *outName, Bool *is_binary)
{
u32 i, count;
FILE *didfile;
GF_XMLBox *xml = NULL;
GF_MetaBox *meta = gf_isom_get_meta(file, root_meta, track_num);
if (!meta) return GF_BAD_PARAM;
/*Find XMLBox*/
count = gf_list_count(meta->other_boxes);
for (i = 0; i <count; i++) {
GF_Box *a = (GF_Box *)gf_list_get(meta->other_boxes, i);
if ((a->type == GF_ISOM_BOX_TYPE_XML) || (a->type == GF_ISOM_BOX_TYPE_BXML) ) {
xml = (GF_XMLBox *)a;
break;
}
}
if (!xml || !xml->xml || !xml->xml_length) return GF_BAD_PARAM;
didfile = gf_fopen(outName, "wb");
if (!didfile) return GF_IO_ERR;
gf_fwrite(xml->xml, xml->xml_length, 1, didfile);
gf_fclose(didfile);
if (is_binary) *is_binary = (xml->type==GF_ISOM_BOX_TYPE_BXML) ? 1 : 0;
return GF_OK;
}
void IMG_NetIO(void *cbk, GF_NETIO_Parameter *param)
{
GF_Err e;
const char *szCache;
IMGLoader *read = (IMGLoader *) cbk;
if (!read->dnload) return;
/*handle service message*/
gf_service_download_update_stats(read->dnload);
e = param->error;
/*wait to get the whole file*/
if (!e && (param->msg_type!=GF_NETIO_DATA_TRANSFERED)) return;
if ((e==GF_EOS) && (param->msg_type==GF_NETIO_DATA_EXCHANGE)) return;
if (param->msg_type==GF_NETIO_DATA_TRANSFERED) {
szCache = gf_dm_sess_get_cache_name(read->dnload);
if (!szCache) e = GF_IO_ERR;
else {
if (read->stream) gf_fclose(read->stream);
read->stream = gf_fopen((char *) szCache, "rb");
if (!read->stream) e = GF_SERVICE_ERROR;
else {
e = GF_OK;
gf_fseek(read->stream, 0, SEEK_END);
read->data_size = (u32) gf_ftell(read->stream);
gf_fseek(read->stream, 0, SEEK_SET);
}
}
}
/*OK confirm*/
gf_service_connect_ack(read->service, NULL, e);
if (!e) IMG_SetupObject(read);
}
GF_EXPORT
char *gf_rtp_streamer_format_sdp_header(char *app_name, char *ip_dest, char *session_name, char *iod64)
{
u64 size;
char *sdp, *tmp_fn = NULL;
FILE *tmp = gf_temp_file_new(&tmp_fn);
if (!tmp) return NULL;
/* write SDP header*/
fprintf(tmp, "v=0\n");
fprintf(tmp, "o=%s 3326096807 1117107880000 IN IP%d %s\n", app_name, gf_net_is_ipv6(ip_dest) ? 6 : 4, ip_dest);
fprintf(tmp, "s=%s\n", (session_name ? session_name : "GPAC Scene Streaming Session"));
fprintf(tmp, "c=IN IP%d %s\n", gf_net_is_ipv6(ip_dest) ? 6 : 4, ip_dest);
fprintf(tmp, "t=0 0\n");
if (iod64) fprintf(tmp, "a=mpeg4-iod:\"data:application/mpeg4-iod;base64,%s\"\n", iod64);
gf_fseek(tmp, 0, SEEK_END);
size = gf_ftell(tmp);
gf_fseek(tmp, 0, SEEK_SET);
sdp = (char*)gf_malloc(sizeof(char) * (size_t)(size+1));
size = fread(sdp, 1, (size_t)size, tmp);
sdp[size] = 0;
gf_fclose(tmp);
gf_delete_file(tmp_fn);
gf_free(tmp_fn);
return sdp;
}
void EndFile(FILE *f, u32 type)
{
if (!type) {
fprintf(f, "#ifdef __cplusplus\n}\n#endif\n\n");
fprintf(f, "\n\n#endif\t\t/*_GF_X3D_NODES_H*/\n\n");
}
gf_fclose(f);
}
GF_EXPORT
GF_Config *gf_cfg_init(const char *file, Bool *new_cfg)
{
GF_Config *cfg;
char szPath[GF_MAX_PATH];
if (new_cfg) *new_cfg = GF_FALSE;
if (file) {
cfg = gf_cfg_new(NULL, file);
/*force creation of a new config*/
if (!cfg) {
FILE *fcfg = gf_fopen(file, "wt");
if (fcfg) {
gf_fclose(fcfg);
cfg = gf_cfg_new(NULL, file);
if (new_cfg) *new_cfg = GF_TRUE;
}
}
if (cfg) {
check_modules_dir(cfg);
return cfg;
}
}
if (!get_default_install_path(szPath, GF_PATH_CFG)) {
fprintf(stderr, "Fatal error: Cannot create a configuration file in application or user home directory - no write access\n");
return NULL;
}
cfg = gf_cfg_new(szPath, CFG_FILE_NAME);
if (!cfg) {
fprintf(stderr, "GPAC config file %s not found in %s - creating new file\n", CFG_FILE_NAME, szPath);
cfg = create_default_config(szPath);
}
if (!cfg) {
fprintf(stderr, "\nCannot create config file %s in %s directory\n", CFG_FILE_NAME, szPath);
return NULL;
}
#ifndef GPAC_IPHONE
fprintf(stderr, "Using config file in %s directory\n", szPath);
#endif
check_modules_dir(cfg);
if (!gf_cfg_get_key(cfg, "General", "StorageDirectory")) {
get_default_install_path(szPath, GF_PATH_CFG);
strcat(szPath, "/Storage");
if (!gf_dir_exists(szPath)) gf_mkdir(szPath);
gf_cfg_set_key(cfg, "General", "StorageDirectory", szPath);
}
if (new_cfg) *new_cfg = GF_TRUE;
return cfg;
}
int main(int argc, char **argv)
{
char data[188];
u32 size, fsize, fdone;
GF_M2TS_Demuxer *ts;
FILE *src = gf_fopen(argv[1], "rb");
ts = gf_m2ts_demux_new();
ts->on_event = on_m2ts_event;
fseek(src, 0, SEEK_END);
fsize = ftell(src);
fseek(src, 0, SEEK_SET);
fdone = 0;
while (!feof(src)) {
size = fread(data, 1, 188, src);
if (size<188) break;
gf_m2ts_process_data(ts, data, size);
if (has_seen_pat) break;
}
dest = gf_fopen("pes.mp3", "wb");
gf_m2ts_reset_parsers(ts);
gf_fseek(src, 0, SEEK_SET);
fdone = 0;
while (!feof(src)) {
size = fread(data, 1, 188, src);
if (size<188) break;
gf_m2ts_process_data(ts, data, size);
fdone += size;
gf_set_progress("MPEG-2 TS Parsing", fdone, fsize);
}
gf_set_progress("MPEG-2 TS Parsing", fsize, fsize);
gf_fclose(src);
gf_m2ts_demux_del(ts);
if (dest) gf_fclose(dest);
return 0;
}
GF_EXPORT
Bool gf_file_exists(const char *fileName)
{
FILE *f = gf_fopen(fileName, "r");
if (f) {
gf_fclose(f);
return GF_TRUE;
}
return GF_FALSE;
}
void write_bmp(GF_VideoSurface *fb, char *rad_name, u32 img_num)
{
char str[GF_MAX_PATH];
BITMAPFILEHEADER fh;
BITMAPINFOHEADER fi;
FILE *fout;
u32 j, i;
char *ptr;
if (img_num<10) {
sprintf(str, "%s_00%d.bmp", rad_name, img_num);
} else if (img_num<100) {
sprintf(str, "%s_0%d.bmp", rad_name, img_num);
} else {
sprintf(str, "%s_%d.bmp", rad_name, img_num);
}
fout = gf_fopen(str, "wb");
if (!fout) return;
memset(&fh, 0, sizeof(fh));
fh.bfType = 19778;
fh.bfOffBits = 14 + 40;
memset(&fi, 0, sizeof(char)*40);
fi.biSize = sizeof(char)*40;
fi.biWidth = fb->width;
fi.biHeight = fb->height;
fi.biPlanes = 1;
fi.biBitCount = 24;
fi.biCompression = BI_RGB;
fi.biSizeImage = fb->pitch * fb->height;
/*NOT ALIGNED!!*/
gf_fwrite(&fh.bfType, 2, 1, fout);
gf_fwrite(&fh.bfSize, 4, 1, fout);
gf_fwrite(&fh.bfReserved1, 2, 1, fout);
gf_fwrite(&fh.bfReserved2, 2, 1, fout);
gf_fwrite(&fh.bfOffBits, 4, 1, fout);
gf_fwrite(&fi, 1, 40, fout);
for (j=fb->height; j>0; j--) {
ptr = fb->video_buffer + (j-1)*fb->pitch;
//gf_fwrite(ptr, 1, fb->width * 3, fout);
for (i=0; i<fb->width; i++) {
fputc(ptr[2], fout);
fputc(ptr[1], fout);
fputc(ptr[0], fout);
ptr+=3;
}
}
gf_fclose(fout);
}
GF_EXPORT
GF_Err gf_webvtt_dump_iso_track(GF_MediaExporter *dumper, char *szName, u32 track, Bool merge, Bool box_dump)
{
#ifdef GPAC_DISABLE_MEDIA_IMPORT
return GF_NOT_SUPPORTED;
#else
GF_Err e;
u32 i;
u32 count;
u32 timescale;
FILE *out;
u32 di;
u64 duration;
GF_WebVTTParser *parser;
out = szName ? gf_fopen(szName, "wt") : (dumper->dump_file ? dumper->dump_file : stdout);
if (!out) return GF_IO_ERR;// gf_export_message(dumper, GF_IO_ERR, "Error opening %s for writing - check disk access & permissions", szName);
parser = gf_webvtt_parser_new();
parser->user = out;
parser->on_cue_read = gf_webvtt_dump_cue;
if (box_dump)
fprintf(out, "<WebVTTTrack trackID=\"%d\">\n", gf_isom_get_track_id(dumper->file, track) );
e = gf_webvtt_dump_header(out, dumper->file, track, box_dump, 1);
if (e) goto exit;
timescale = gf_isom_get_media_timescale(dumper->file, track);
count = gf_isom_get_sample_count(dumper->file, track);
for (i=0; i<count; i++) {
GF_ISOSample *samp = gf_isom_get_sample(dumper->file, track, i+1, &di);
if (!samp) {
e = gf_isom_last_error(dumper->file);
goto exit;
}
e = gf_webvtt_parse_iso_sample(parser, timescale, samp, merge, box_dump);
if (e) {
goto exit;
}
gf_isom_sample_del(&samp);
}
duration = gf_isom_get_media_duration(dumper->file, track);
gf_webvtt_parser_dump_finalize(parser, duration);
if (box_dump)
fprintf(out, "</WebVTTTrack>\n");
exit:
gf_webvtt_parser_del(parser);
if (szName) gf_fclose(out);
return e;
#endif
}
static void live_session_setup(LiveSession *livesess, char *ip, u16 port, u32 path_mtu, u32 ttl, char *ifce_addr, char *sdp_name)
{
RTPChannel *rtpch;
u32 count = gf_seng_get_stream_count(livesess->seng);
u32 i;
char *iod64 = gf_seng_get_base64_iod(livesess->seng);
char *sdp = gf_rtp_streamer_format_sdp_header("GPACSceneStreamer", ip, NULL, iod64);
if (iod64) gf_free(iod64);
for (i=0; i<count; i++) {
u16 ESID;
u32 st, oti, ts;
char *config = NULL;
u32 config_len;
gf_seng_get_stream_config(livesess->seng, i, &ESID, &config, &config_len, &st, &oti, &ts);
GF_SAFEALLOC(rtpch, RTPChannel);
rtpch->timescale = ts;
rtpch->init_time = gf_sys_clock();
switch (st) {
case GF_STREAM_OD:
case GF_STREAM_SCENE:
rtpch->rtp = gf_rtp_streamer_new_extended(st, oti, ts, ip, port, path_mtu, ttl, ifce_addr,
GP_RTP_PCK_SYSTEMS_CAROUSEL, (char *) config, config_len,
96, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4);
if (rtpch->rtp) {
gf_rtp_streamer_disable_auto_rtcp(rtpch->rtp);
rtpch->manual_rtcp = 1;
}
break;
default:
rtpch->rtp = gf_rtp_streamer_new(st, oti, ts, ip, port, path_mtu, ttl, ifce_addr, GP_RTP_PCK_SIGNAL_RAP, (char *) config, config_len);
break;
}
rtpch->ESID = ESID;
rtpch->adjust_carousel_time = 1;
gf_list_add(livesess->streams, rtpch);
gf_rtp_streamer_append_sdp(rtpch->rtp, ESID, (char *) config, config_len, NULL, &sdp);
/*fetch initial config of the broadcast*/
gf_seng_get_stream_carousel_info(livesess->seng, ESID, &rtpch->carousel_period, &rtpch->aggregate_on_stream);
port += 2;
}
if (sdp) {
FILE *out = gf_fopen(sdp_name, "wt");
fprintf(out, "%s", sdp);
gf_fclose(out);
gf_free(sdp);
}
}
/* Checks that the file is fully downloaded
requires that the file_size is given in the DecoderSpecificInfo */
static Bool vtt_check_download(VTTDec *vttdec)
{
u64 size;
FILE *f = gf_fopen(vttdec->file_name, "rt");
if (!f) return GF_FALSE;
gf_fseek(f, 0, SEEK_END);
size = gf_ftell(f);
gf_fclose(f);
if (size==vttdec->file_size) return GF_TRUE;
return GF_FALSE;
}
void wxPlaylist::OpenPlaylist(wxString filename)
{
FILE *pl;
PLEntry *ple;
Bool load_m3u, go;
char szLine[GF_MAX_PATH];
pl = gf_fopen(filename.mb_str(wxConvUTF8) , "rt");
if (!pl) return;
ple = NULL;
load_m3u = 1;
while (!feof(pl)) {
fgets(szLine, GF_MAX_PATH, pl);
go = 1;
while (go) {
switch (szLine[strlen(szLine)-1]) {
case '\n':
case '\r':
case ' ':
szLine[strlen(szLine)-1] = 0;
break;
default:
go = 0;
break;
}
}
if (!strlen(szLine)) continue;
if (!stricmp(szLine, "[playlist]")) {
load_m3u = 0;
} else if (load_m3u) {
ple = new PLEntry(wxString(szLine, wxConvUTF8) );
gf_list_add(m_entries, ple);
} else if (!strnicmp(szLine, "file", 4)) {
char *st = strchr(szLine, '=');
if (!st) ple = NULL;
else {
ple = new PLEntry(wxString(st + 1, wxConvUTF8) );
gf_list_add(m_entries, ple);
}
} else if (ple && !strnicmp(szLine, "Length", 6)) {
char *st = strchr(szLine, '=');
s32 d = atoi(st + 1);
if (d>0) ple->m_duration = d;
} else if (ple && !strnicmp(szLine, "Title", 5)) {
char *st = strchr(szLine, '=');
gf_free(ple->m_disp_name);
ple->m_disp_name = gf_strdup(st + 6);
}
}
gf_fclose(pl);
m_all_dead_entries = -1;
m_cur_entry = -1;
RefreshList();
}
static GF_Err AC3_CloseService(GF_InputService *plug)
{
AC3Reader *read = (AC3Reader*)plug->priv;
if (read->stream) gf_fclose(read->stream);
read->stream = NULL;
if (read->dnload) gf_service_download_del(read->dnload);
read->dnload = NULL;
if (read->data) gf_free(read->data);
read->data = NULL;
gf_service_disconnect_ack(read->service, NULL, GF_OK);
return GF_OK;
}
int Osmo4::ExitInstance()
{
if (m_term) gf_term_del(m_term);
if (m_user.modules) gf_modules_del(m_user.modules);
if (m_user.config) gf_cfg_del(m_user.config);
gf_sys_close();
/*last instance*/
if (m_hMutex) {
CloseHandle(m_hMutex);
static_gpac_hwnd = NULL;
}
if (m_logs) gf_fclose(m_logs);
return CWinApp::ExitInstance();
}
static GF_Err IMG_CloseService(GF_InputService *plug)
{
IMGLoader *read;
if (!plug)
return GF_BAD_PARAM;
read = (IMGLoader *)plug->priv;
if (!read)
return GF_BAD_PARAM;
if (read->stream) gf_fclose(read->stream);
read->stream = NULL;
if (read->dnload) gf_service_download_del(read->dnload);
read->dnload = NULL;
if (read->service)
gf_service_disconnect_ack(read->service, NULL, GF_OK);
return GF_OK;
}
void main(int argc, char **argv)
{
FILE *in;
GF_BitStream *bs;
/* generation d'un TS aléatoire */
/*
if ((in=gf_fopen(argv[1], "wb")) == NULL) {
printf( "Impossible d'ouvrir %s en lecture.\n", argv[1]);
}
{
char buffer[188];
u32 j, i, nb_packets = 300;
for (i = 0; i < nb_packets; i++) {
buffer[0] = 0x47;
for (j = 1; j <188; j++) {
buffer[j] = rand();//j;
}
gf_fwrite(buffer, 1, 188, in);
}
}
gf_fclose(in);
if ((in=gf_fopen(argv[1], "rb")) == NULL) {
printf( "Impossible d'ouvrir %s en lecture.\n", argv[1]);
}
bs = gf_bs_from_file(in, GF_BITSTREAM_READ);
if (bs == NULL) return;
RS_Interleaver(bs, argv[2]);
gf_fclose(in);
gf_bs_del(bs);
*/
if ((in=gf_fopen(argv[1], "rb")) == NULL) {
printf( "Impossible d'ouvrir %s en lecture.\n", argv[1]);
}
bs = gf_bs_from_file(in, GF_BITSTREAM_READ);
if (bs == NULL) return;
RS_Deinterleaver(bs, argv[2]);
gf_fclose(in);
gf_bs_del(bs);
}
void write_raw(GF_VideoSurface *fb, char *rad_name, u32 img_num)
{
char str[GF_MAX_PATH];
FILE *fout;
if (img_num<10) {
sprintf(str, "%s_00%d.raw", rad_name, img_num);
} else if (img_num<100) {
sprintf(str, "%s_0%d.raw", rad_name, img_num);
} else {
sprintf(str, "%s_%d.raw", rad_name, img_num);
}
fout = gf_fopen(str, "wb");
if (!fout) return;
gf_fwrite(fb->video_buffer , fb->height*fb->pitch, 1, fout);
gf_fclose(fout);
}
/*Dummy input just send a file name, no multitrack to handle so we don't need to check sub_url nor expected type*/
static GF_Descriptor *DC_GetServiceDesc(GF_InputService *plug, u32 expect_type, const char *sub_url)
{
u32 size = 0;
char *uri;
GF_ESD *esd;
GF_BitStream *bs;
DCReader *read = (DCReader *) plug->priv;
GF_InitialObjectDescriptor *iod = (GF_InitialObjectDescriptor *) gf_odf_desc_new(GF_ODF_IOD_TAG);
iod->scene_profileAndLevel = 1;
iod->graphics_profileAndLevel = 1;
iod->OD_profileAndLevel = 1;
iod->audio_profileAndLevel = 0xFE;
iod->visual_profileAndLevel = 0xFE;
iod->objectDescriptorID = 1;
if (read->is_views_url) {
iod->URLString = gf_strdup(read->url);
return (GF_Descriptor *)iod;
}
esd = gf_odf_desc_esd_new(0);
esd->slConfig->timestampResolution = 1000;
esd->slConfig->useTimestampsFlag = 1;
esd->ESID = 0xFFFE;
esd->decoderConfig->streamType = GF_STREAM_PRIVATE_SCENE;
esd->decoderConfig->objectTypeIndication = read->oti;
if (read->dnload) {
uri = (char *) gf_dm_sess_get_cache_name(read->dnload);
gf_dm_sess_get_stats(read->dnload, NULL, NULL, &size, NULL, NULL, NULL);
} else {
FILE *f = gf_fopen(read->url, "rt");
gf_fseek(f, 0, SEEK_END);
size = (u32) gf_ftell(f);
gf_fclose(f);
uri = read->url;
}
bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
gf_bs_write_u32(bs, size);
gf_bs_write_data(bs, uri, (u32) strlen(uri));
gf_bs_get_content(bs, &esd->decoderConfig->decoderSpecificInfo->data, &esd->decoderConfig->decoderSpecificInfo->dataLength);
gf_bs_del(bs);
gf_list_add(iod->ESDescriptors, esd);
return (GF_Descriptor *)iod;
}
void gf_webvtt_parser_reset(GF_WebVTTParser *parser)
{
if (parser) {
while (gf_list_count(parser->samples)) {
gf_webvtt_sample_del((GF_WebVTTSample *)gf_list_get(parser->samples, 0));
gf_list_rem(parser->samples, 0);
}
if (parser->vtt_in) gf_fclose(parser->vtt_in);
parser->file_size = 0;
parser->last_duration = 0;
parser->on_header_parsed = NULL;
parser->on_sample_parsed = NULL;
parser->report_message = NULL;
parser->state = WEBVTT_PARSER_STATE_WAITING_SIGNATURE;
parser->unicode_type = 0;
parser->user = NULL;
parser->vtt_in = NULL;
}
}
GF_Err gf_webvtt_dump_iso_track(GF_MediaExporter *dumper, char *szName, u32 track, Bool merge)
{
GF_Err e;
u32 i;
u32 count;
u32 timescale;
FILE *out;
u32 di;
u64 duration;
GF_WebVTTParser *parser;
out = szName ? gf_fopen(szName, "wt") : stdout;
if (!out) return GF_IO_ERR;// gf_export_message(dumper, GF_IO_ERR, "Error opening %s for writing - check disk access & permissions", szName);
parser = gf_webvtt_parser_new();
parser->user = out;
parser->on_cue_read = gf_webvtt_dump_cue;
e = gf_webvtt_dump_header(out, dumper->file, track, 1);
if (e) goto exit;
timescale = gf_isom_get_media_timescale(dumper->file, track);
count = gf_isom_get_sample_count(dumper->file, track);
for (i=0; i<count; i++) {
GF_ISOSample *samp = gf_isom_get_sample(dumper->file, track, i+1, &di);
if (!samp) {
e = gf_isom_last_error(dumper->file);
goto exit;
}
e = gf_webvtt_parse_iso_sample(parser, timescale, samp, merge);
if (e) goto exit;
//gf_webvtt_dump_iso_sample(out, timescale, samp);
}
duration = gf_isom_get_media_duration(dumper->file, track);
gf_webvtt_parser_dump_finalize(parser, duration);
exit:
gf_webvtt_parser_del(parser);
if (szName) gf_fclose(out);
return e;
}
GF_EXPORT
GF_Err gf_isom_set_meta_xml(GF_ISOFile *file, Bool root_meta, u32 track_num, char *XMLFileName, Bool IsBinaryXML)
{
GF_Err e;
FILE *xmlfile;
GF_XMLBox *xml;
GF_MetaBox *meta;
e = CanAccessMovie(file, GF_ISOM_OPEN_WRITE);
if (e) return e;
meta = gf_isom_get_meta(file, root_meta, track_num);
if (!meta) return GF_BAD_PARAM;
e = gf_isom_remove_meta_xml(file, root_meta, track_num);
if (e) return e;
xml = (GF_XMLBox *)xml_New();
if (!xml) return GF_OUT_OF_MEM;
gf_list_add(meta->other_boxes, xml);
if (IsBinaryXML) xml->type = GF_ISOM_BOX_TYPE_BXML;
/*assume 32bit max size = 4Go should be sufficient for a DID!!*/
xmlfile = gf_fopen(XMLFileName, "rb");
if (!xmlfile) return GF_URL_ERROR;
gf_fseek(xmlfile, 0, SEEK_END);
assert(gf_ftell(xmlfile) < 1<<31);
xml->xml_length = (u32) gf_ftell(xmlfile);
gf_fseek(xmlfile, 0, SEEK_SET);
xml->xml = (char*)gf_malloc(sizeof(unsigned char)*xml->xml_length);
xml->xml_length = (u32) fread(xml->xml, 1, sizeof(unsigned char)*xml->xml_length, xmlfile);
if (ferror(xmlfile)) {
gf_free(xml->xml);
xml->xml = NULL;
return GF_BAD_PARAM;
}
gf_fclose(xmlfile);
return GF_OK;
}