void mediasensor_update_timing(GF_ObjectManager *odm, Bool is_eos) { GF_Segment *desc; u32 i, count, j, ms_count; Double time; ms_count = gf_list_count(odm->ms_stack); if (!ms_count) return; time = odm->current_time / 1000.0; for (j=0; j<ms_count; j++) { MediaSensorStack *media_sens = (MediaSensorStack *)gf_list_get(odm->ms_stack, j); if (!media_sens->is_init) continue; count = gf_list_count(media_sens->seg); /*full object controled*/ if (!media_sens->active_seg && !count) { /*check for end of scene (MediaSensor on inline)*/ if (odm->subscene && odm->subscene->duration) { GF_Clock *ck = gf_odm_get_media_clock(odm); if (ck->has_seen_eos && (1000*time>=(Double) (s64)odm->subscene->duration)) { if (media_sens->sensor->isActive) { /*force notification of time (ntify the scene duration rather than the current clock*/ media_sens->sensor->mediaCurrentTime = (Double) odm->subscene->duration; media_sens->sensor->mediaCurrentTime /= 1000; gf_node_event_out((GF_Node *) media_sens->sensor, 1/*"mediaCurrentTime"*/); media_sens->sensor->isActive = 0; gf_node_event_out((GF_Node *) media_sens->sensor, 4/*"isActive"*/); GF_LOG(GF_LOG_DEBUG, GF_LOG_INTERACT, ("[ODM%d] Deactivating media sensor\n", odm->OD->objectDescriptorID)); } continue; } } if (!is_eos && !media_sens->sensor->isActive) { media_sens->sensor->isActive = 1; gf_node_event_out((GF_Node *) media_sens->sensor, 4/*"isActive"*/); if (odm->subscene) { media_sens->sensor->mediaDuration = (Double) (s64)odm->subscene->duration; } else { media_sens->sensor->mediaDuration = (Double) (s64)odm->duration; } if (media_sens->sensor->mediaDuration) media_sens->sensor->mediaDuration /= 1000; else media_sens->sensor->mediaDuration = -FIX_ONE; gf_node_event_out((GF_Node *) media_sens->sensor, 3/*"mediaDuration"*/); } if (is_eos && media_sens->sensor->isActive) { if (media_sens->sensor->mediaDuration>=0) { media_sens->sensor->mediaCurrentTime = media_sens->sensor->mediaDuration; } else { media_sens->sensor->mediaCurrentTime = time; } gf_node_event_out((GF_Node *) media_sens->sensor, 1/*"mediaCurrentTime"*/); media_sens->sensor->isActive = 0; gf_node_event_out((GF_Node *) media_sens->sensor, 4/*"isActive"*/); } else { if (media_sens->sensor->isActive && (media_sens->sensor->mediaCurrentTime != time)) { media_sens->sensor->mediaCurrentTime = time; gf_node_event_out((GF_Node *) media_sens->sensor, 1/*"mediaCurrentTime"*/); } } continue; } /*locate segment*/ for (i=media_sens->active_seg; i<count; i++) { desc = (GF_Segment*)gf_list_get(media_sens->seg, i); /*not controled*/ if (desc->startTime > time) { if (media_sens->sensor->isActive) { media_sens->sensor->isActive = 0; gf_node_event_out((GF_Node *) media_sens->sensor, 4/*"isActive"*/); GF_LOG(GF_LOG_DEBUG, GF_LOG_INTERACT, ("[ODM%d] Deactivating media sensor at time %g - segment %s\n", odm->OD->objectDescriptorID, time, desc->SegmentName)); } break; } if (desc->startTime + desc->Duration < time) continue; if (desc->startTime + desc->Duration == time) { continue; } /*segment switch, force activation (isActive TRUE send at each seg)*/ if (media_sens->active_seg != i) { media_sens->active_seg = i; media_sens->sensor->isActive = 0; } if (!media_sens->sensor->isActive) { media_sens->sensor->isActive = 1; gf_node_event_out((GF_Node *) media_sens->sensor, 4/*"isActive"*/); /*set info*/ gf_sg_vrml_mf_reset(& media_sens->sensor->info, GF_SG_VRML_MFSTRING); gf_sg_vrml_mf_alloc(& media_sens->sensor->info, GF_SG_VRML_MFSTRING, 1); media_sens->sensor->info.vals[0] = desc->SegmentName ? gf_strdup(desc->SegmentName) : NULL; gf_node_event_out((GF_Node *) media_sens->sensor, 5/*"info"*/); /*set duration*/ media_sens->sensor->mediaDuration = desc->Duration; gf_node_event_out((GF_Node *) media_sens->sensor, 3/*"mediaDuration"*/); /*set seg start time*/ media_sens->sensor->streamObjectStartTime = desc->startTime; gf_node_event_out((GF_Node *) media_sens->sensor, 2/*"streamObjectStartTime"*/); GF_LOG(GF_LOG_DEBUG, GF_LOG_INTERACT, ("[ODM%d] Activating media sensor time %g - segment %s\n", odm->OD->objectDescriptorID, time, desc->SegmentName)); } /*set media time - relative to segment start time*/ time -= desc->startTime; if (media_sens->sensor->mediaCurrentTime != time) { media_sens->sensor->mediaCurrentTime = time; gf_node_event_out((GF_Node *) media_sens->sensor, 1/*"mediaCurrentTime"*/); } break; } if (i==count) { /*we're after last segment, deactivate*/ if (media_sens->sensor->isActive) { media_sens->sensor->isActive = 0; gf_node_event_out((GF_Node *) media_sens->sensor, 4/*"isActive"*/); media_sens->active_seg = count; GF_LOG(GF_LOG_DEBUG, GF_LOG_INTERACT, ("[ODM%d] Deactivating media sensor at time %g: no more segments\n", odm->OD->objectDescriptorID, time)); } } } }
int32_t cli_cmd_bricks_parse (const char **words, int wordcount, int brick_index, char **bricks, int *brick_count) { int ret = 0; char *tmp_list = NULL; char brick_list[120000] = {0,}; char *space = " "; char *delimiter = NULL; char *host_name = NULL; char *tmp = NULL; char *free_list_ptr = NULL; char *tmpptr = NULL; int j = 0; int brick_list_len = 0; GF_ASSERT (words); GF_ASSERT (wordcount); GF_ASSERT (bricks); GF_ASSERT (brick_index > 0); GF_ASSERT (brick_index < wordcount); strncpy (brick_list, space, strlen (space)); brick_list_len++; while (brick_index < wordcount) { delimiter = strchr (words[brick_index], ':'); if (!delimiter || delimiter == words[brick_index] || *(delimiter+1) != '/') { cli_out ("wrong brick type: %s, use <HOSTNAME>:" "<export-dir-abs-path>", words[brick_index]); ret = -1; goto out; } else { cli_path_strip_trailing_slashes (delimiter + 1); } if ((brick_list_len + strlen (words[brick_index]) + 1) > sizeof (brick_list)) { gf_log ("cli", GF_LOG_ERROR, "total brick list is larger than a request " "can take (brick_count %d)", *brick_count); ret = -1; goto out; } host_name = gf_strdup (words[brick_index]); if (!host_name) { ret = -1; gf_log("cli",GF_LOG_ERROR, "Unable to allocate " "memory"); goto out; } strtok_r (host_name, ":", &tmp); if (!(strcmp (host_name, "localhost") && strcmp (host_name, "127.0.0.1"))) { cli_out ("Please provide a valid hostname/ip other " "than localhost or 127.0.0.1"); ret = -1; GF_FREE (host_name); goto out; } if (!valid_host_name(host_name, strlen(host_name))) { cli_out ("internet address '%s' does not comform to " "standards", host_name); } GF_FREE (host_name); tmp_list = gf_strdup (brick_list + 1); if (free_list_ptr) { GF_FREE (free_list_ptr); free_list_ptr = NULL; } free_list_ptr = tmp_list; j = 0; while(j < *brick_count) { strtok_r (tmp_list, " ", &tmpptr); if (!(strcmp (tmp_list, words[brick_index]))) { ret = -1; cli_out ("Found duplicate" " exports %s",words[brick_index]); goto out; } tmp_list = tmpptr; j++; } strcat (brick_list, words[brick_index]); strcat (brick_list, " "); brick_list_len += (strlen (words[brick_index]) + 1); ++(*brick_count); ++brick_index; } *bricks = gf_strdup (brick_list); if (!*bricks) ret = -1; out: if (free_list_ptr) GF_FREE (free_list_ptr); return ret; }
GF_EXPORT GF_Err gf_odf_get_text_config(GF_DefaultDescriptor *dsi, u8 oti, GF_TextConfig *cfg) { u32 i, j; Bool has_alt_format, has_sd; GF_Err e; GF_BitStream *bs; if (!dsi || !dsi->data || !dsi->dataLength || !cfg) return GF_BAD_PARAM; if (oti != 0x08) return GF_NOT_SUPPORTED; /*reset*/ ResetTextConfig(cfg); bs = gf_bs_new(dsi->data, dsi->dataLength, GF_BITSTREAM_READ); e = GF_OK; cfg->Base3GPPFormat = gf_bs_read_int(bs, 8); cfg->MPEGExtendedFormat = gf_bs_read_int(bs, 8); cfg->profileLevel = gf_bs_read_int(bs, 8); cfg->timescale = gf_bs_read_int(bs, 24); has_alt_format = gf_bs_read_int(bs, 1); cfg->sampleDescriptionFlags = gf_bs_read_int(bs, 2); has_sd = gf_bs_read_int(bs, 1); cfg->has_vid_info = gf_bs_read_int(bs, 1); gf_bs_read_int(bs, 3); cfg->layer = gf_bs_read_int(bs, 8); cfg->text_width = gf_bs_read_int(bs, 16); cfg->text_height = gf_bs_read_int(bs, 16); if (has_alt_format) { cfg->nb_compatible_formats = gf_bs_read_int(bs, 8); for (i=0; i<cfg->nb_compatible_formats; i++) cfg->compatible_formats[i] = gf_bs_read_int(bs, 8); } #ifndef GPAC_DISABLE_ISOM if (has_sd) { u8 sample_index; GF_TextSampleDescriptor *txdesc; GF_Tx3gSampleEntryBox *a; s64 avail; u32 nb_desc = gf_bs_read_int(bs, 8); /*parse TTU[5]s*/ avail = (s64) gf_bs_available(bs); for (i=0; i<nb_desc; i++) { sample_index = gf_bs_read_int(bs, 8); avail -= 1; e = gf_isom_parse_box((GF_Box **) &a, bs); if (e) goto exit; avail -= (s32) a->size; if (avail<0) { e = GF_NON_COMPLIANT_BITSTREAM; goto exit; } txdesc = (GF_TextSampleDescriptor *)gf_malloc(sizeof(GF_TextSampleDescriptor)); txdesc->sample_index = sample_index; txdesc->displayFlags = a->displayFlags; txdesc->back_color = a->back_color; txdesc->default_pos = a->default_box; txdesc->default_style = a->default_style; txdesc->vert_justif = a->vertical_justification; txdesc->horiz_justif = a->horizontal_justification; txdesc->font_count = a->font_table ? a->font_table->entry_count : 0; if (txdesc->font_count) { txdesc->fonts = (GF_FontRecord*)gf_malloc(sizeof(GF_FontRecord)*txdesc->font_count); for (j=0; j<txdesc->font_count; j++) { txdesc->fonts[j].fontID = a->font_table->fonts[j].fontID; txdesc->fonts[j].fontName = a->font_table->fonts[j].fontName ? gf_strdup(a->font_table->fonts[j].fontName) : NULL; } } gf_list_add(cfg->sample_descriptions, txdesc); gf_isom_box_del((GF_Box *)a); } } #endif if (cfg->has_vid_info) { cfg->video_width = gf_bs_read_int(bs, 16); cfg->video_height = gf_bs_read_int(bs, 16); cfg->horiz_offset = gf_bs_read_int(bs, 16); cfg->vert_offset = gf_bs_read_int(bs, 16); } exit: gf_bs_del(bs); if (e) ResetTextConfig(cfg); return e; }
u32 SFE_LoadExpression(ScriptEnc *sc_enc, u32 *expr_sep) { Bool is_var = 0; u32 close_code, open_code; u32 count = 0; u32 nbExpr = 1; u32 nbIndir = 0; expr_sep[0] = 0; sc_enc->expr_toks_len = 0; while ( (sc_enc->token_code != TOK_SEMICOLON) && (sc_enc->token_code != TOK_RIGHT_CURVE) ) { switch (sc_enc->token_code) { case TOK_CONDTEST: nbIndir ++; break; case TOK_CONDSEP: if (nbIndir > 0) nbIndir--; /*'case'*/ else { goto break_loop; } break; case TOK_IDENTIFIER: case TOK_NUMBER: case TOK_STRING: case TOK_BOOLEAN: gf_list_add(sc_enc->id_buf, gf_strdup(sc_enc->token)); break; case TOK_FUNCTION: goto break_loop; } if (sc_enc->token_code==TOK_VAR) is_var = 1; if (!is_var || (sc_enc->token_code!=TOK_COMMA)) { sc_enc->expr_toks[sc_enc->expr_toks_len] = sc_enc->token_code; sc_enc->expr_toks_len++; } open_code = sc_enc->token_code; close_code = 0; if (sc_enc->token_code == TOK_LEFT_CURVE) close_code = TOK_RIGHT_CURVE; else if (sc_enc->token_code == TOK_LEFT_BRACKET) close_code = TOK_RIGHT_BRACKET; else if (sc_enc->token_code == TOK_LEFT_BRACE) close_code = TOK_RIGHT_BRACE; /*other expr*/ if ((sc_enc->token_code == TOK_COMMA) && (sc_enc->expr_toks[0] != TOK_VAR) ){ expr_sep[nbExpr++] = sc_enc->expr_toks_len - 1; } /*sub-expr*/ else if (close_code) { count++; do { SFE_NextToken(sc_enc); if ((sc_enc->token_code == TOK_IDENTIFIER) || (sc_enc->token_code == TOK_NUMBER) || (sc_enc->token_code == TOK_STRING) || (sc_enc->token_code == TOK_BOOLEAN) ) { gf_list_add(sc_enc->id_buf, gf_strdup(sc_enc->token)); } sc_enc->expr_toks[sc_enc->expr_toks_len] = sc_enc->token_code; sc_enc->expr_toks_len++; if (sc_enc->token_code == open_code) count++; else if (sc_enc->token_code == close_code) count--; } while ( (sc_enc->token_code != close_code) || count); } SFE_NextToken(sc_enc); } break_loop: if (sc_enc->err) { GF_LOG(GF_LOG_ERROR, GF_LOG_CODING, ("[bifs] Script encoding: end of compoundExpression not found\n")); return 0; } expr_sep[nbExpr] = sc_enc->expr_toks_len; if ((sc_enc->token_code == TOK_IDENTIFIER) || (sc_enc->token_code == TOK_NUMBER) || (sc_enc->token_code == TOK_STRING) || (sc_enc->token_code == TOK_BOOLEAN) ) { gf_list_add(sc_enc->id_buf, gf_strdup(sc_enc->token)); } if ((sc_enc->token_code != TOK_CONDSEP) && (sc_enc->token_code != TOK_RIGHT_BRACE) && (sc_enc->expr_toks[0] != TOK_VAR)) { sc_enc->expr_toks[sc_enc->expr_toks_len] = sc_enc->token_code; sc_enc->expr_toks_len++; } return nbExpr; }
static void UpdateODCommand(GF_ISOFile *mp4, GF_ODCom *com) { u32 i, j; const char *szName; char szPath[2048]; szName = gf_isom_get_filename(mp4); if (com->tag == GF_ODF_OD_UPDATE_TAG) { GF_ObjectDescriptor *od; GF_ODUpdate *odU = (GF_ODUpdate *)com; i=0; while ((od = (GF_ObjectDescriptor *)gf_list_enum(odU->objectDescriptors, &i))) { GF_ESD *esd; j=0; while ((esd = (GF_ESD *)gf_list_enum(od->ESDescriptors, &j))) { Bool import = 1; if (esd->URLString) continue; switch (esd->decoderConfig->streamType) { case GF_STREAM_OD: import = 0; break; case GF_STREAM_SCENE: if ((esd->decoderConfig->objectTypeIndication != GPAC_OTI_SCENE_AFX) && (esd->decoderConfig->objectTypeIndication != GPAC_OTI_SCENE_SYNTHESIZED_TEXTURE) ) { import = 0; } break; /*dump the OCR track duration in case the OCR is used by media controls & co*/ case GF_STREAM_OCR: { u32 track; Double dur; GF_MuxInfo *mi = (GF_MuxInfo *) gf_odf_desc_new(GF_ODF_MUXINFO_TAG); gf_list_add(esd->extensionDescriptors, mi); track = gf_isom_get_track_by_id(mp4, esd->ESID); dur = (Double) (s64) gf_isom_get_track_duration(mp4, track); dur /= gf_isom_get_timescale(mp4); mi->duration = (u32) (dur * 1000); import = 0; } break; default: break; } if (import) { GF_MuxInfo *mi = (GF_MuxInfo *) gf_odf_desc_new(GF_ODF_MUXINFO_TAG); gf_list_add(esd->extensionDescriptors, mi); sprintf(szPath, "%s#%d", szName, esd->ESID); mi->file_name = gf_strdup(szPath); mi->streamFormat = gf_strdup("MP4"); } } } return; } if (com->tag == GF_ODF_ESD_UPDATE_TAG) { GF_ESD *esd; GF_ESDUpdate *esdU = (GF_ESDUpdate *)com; i=0; while ((esd = (GF_ESD *)gf_list_enum(esdU->ESDescriptors, &i))) { Bool import = 1; if (esd->URLString) continue; switch (esd->decoderConfig->streamType) { case GF_STREAM_OD: import = 0; break; case GF_STREAM_SCENE: if ((esd->decoderConfig->objectTypeIndication != GPAC_OTI_SCENE_AFX) && (esd->decoderConfig->objectTypeIndication != GPAC_OTI_SCENE_SYNTHESIZED_TEXTURE) ) { import = 0; } break; /*dump the OCR track duration in case the OCR is used by media controls & co*/ case GF_STREAM_OCR: { u32 track; Double dur; GF_MuxInfo *mi = (GF_MuxInfo *) gf_odf_desc_new(GF_ODF_MUXINFO_TAG); gf_list_add(esd->extensionDescriptors, mi); track = gf_isom_get_track_by_id(mp4, esd->ESID); dur = (Double) (s64) gf_isom_get_track_duration(mp4, track); dur /= gf_isom_get_timescale(mp4); mi->duration = (u32) (dur * 1000); import = 0; } break; default: break; } if (import) { GF_MuxInfo *mi = (GF_MuxInfo *) gf_odf_desc_new(GF_ODF_MUXINFO_TAG); gf_list_add(esd->extensionDescriptors, mi); sprintf(szPath, "%s#%d", szName, esd->ESID); mi->file_name = gf_strdup(szPath); mi->streamFormat = gf_strdup("MP4"); } } return; } }
void SDP_ParseAttribute(GF_SDPInfo *sdp, char *buffer, GF_SDPMedia *media) { s32 pos; u32 PayT; char comp[3000]; GF_RTPMap *map; GF_SDP_FMTP *fmtp; GF_X_Attribute *att; pos = gf_token_get(buffer, 0, " :\t\r\n", comp, 3000); if (!strcmp(comp, "cat")) { if (media) return; pos = gf_token_get(buffer, pos, ":\t\r\n", comp, 3000); sdp->a_cat = gf_strdup(comp); return; } if (!strcmp(comp, "keywds")) { if (media) return; pos = gf_token_get(buffer, pos, ":\t\r\n", comp, 3000); sdp->a_keywds = gf_strdup(comp); return; } if (!strcmp(comp, "tool")) { if (media) return; pos = gf_token_get(buffer, pos, ":\r\n", comp, 3000); sdp->a_tool = gf_strdup(comp); return; } if (!strcmp(comp, "ptime")) { if (!media) return; pos = gf_token_get(buffer, pos, ":\r\n", comp, 3000); media->PacketTime = atoi(comp); return; } if (!strcmp(comp, "recvonly")) { if (!media) { sdp->a_SendReceive = 1; } else { media->SendReceive = 1; } return; } if (!strcmp(comp, "sendonly")) { if (!media) { sdp->a_SendReceive = 2; } else { media->SendReceive = 2; } return; } if (!strcmp(comp, "sendrecv")) { if (!media) { sdp->a_SendReceive = 3; } else { media->SendReceive = 3; } return; } if (!strcmp(comp, "orient")) { if (!media || media->Type) return; pos = gf_token_get(buffer, pos, ":\r\n", comp, 3000); media->orientation = gf_strdup(comp); return; } if (!strcmp(comp, "type")) { if (media) return; pos = gf_token_get(buffer, pos, ":\r\n", comp, 3000); sdp->a_type = gf_strdup(comp); return; } if (!strcmp(comp, "charset")) { if (media) return; pos = gf_token_get(buffer, pos, ":\r\n", comp, 3000); sdp->a_charset = gf_strdup(comp); return; } if (!strcmp(comp, "sdplang")) { pos = gf_token_get(buffer, pos, ":\r\n", comp, 3000); if (media) { media->sdplang = gf_strdup(comp); } else { sdp->a_sdplang = gf_strdup(comp); } return; } if (!strcmp(comp, "lang")) { pos = gf_token_get(buffer, pos, ":\r\n", comp, 3000); if (media) { media->lang = gf_strdup(comp); } else { sdp->a_lang = gf_strdup(comp); } return; } if (!strcmp(comp, "framerate")) { //only for video if (!media || (media->Type != 1)) return; pos = gf_token_get(buffer, pos, ":\r\n", comp, 3000); media->FrameRate = atof(comp); return; } if (!strcmp(comp, "quality")) { if (!media) return; pos = gf_token_get(buffer, pos, ":\r\n", comp, 3000); media->Quality = atoi(comp); return; } if (!strcmp(comp, "rtpmap")) { if (!media) return; map = (GF_RTPMap*)gf_malloc(sizeof(GF_RTPMap)); pos = gf_token_get(buffer, pos, ": \r\n", comp, 3000); map->PayloadType = atoi(comp); pos = gf_token_get(buffer, pos, " /\r\n", comp, 3000); map->payload_name = gf_strdup(comp); pos = gf_token_get(buffer, pos, " /\r\n", comp, 3000); map->ClockRate = atoi(comp); pos = gf_token_get(buffer, pos, " /\r\n", comp, 3000); map->AudioChannels = (pos > 0) ? atoi(comp) : 0; gf_list_add(media->RTPMaps, map); return; } //FMTP if (!strcmp(comp, "fmtp")) { if (!media) return; pos = gf_token_get(buffer, pos, ": \r\n", comp, 3000); PayT = atoi(comp); fmtp = SDP_GetFMTPForPayload(media, PayT); if (!fmtp) { fmtp = gf_sdp_fmtp_new(); fmtp->PayloadType = PayT; gf_list_add(media->FMTP, fmtp); } while (1) { pos = gf_token_get(buffer, pos, "; =\r\n", comp, 3000); if (pos <= 0) break; att = (GF_X_Attribute*)gf_malloc(sizeof(GF_X_Attribute)); att->Name = gf_strdup(comp); att->Value = NULL; pos ++; pos = gf_token_get(buffer, pos, ";\r\n", comp, 3000); if (pos > 0) att->Value = gf_strdup(comp); gf_list_add(fmtp->Attributes, att); } return; } //the rest cannot be discarded that way as it may be application-specific //so keep it. //a= <attribute> || <attribute>:<value> //we add <attribute> <value> in case ... pos = gf_token_get(buffer, 0, " :\r\n", comp, 3000); att = (GF_X_Attribute*)gf_malloc(sizeof(GF_X_Attribute)); att->Name = gf_strdup(comp); att->Value = NULL; pos += 1; if (buffer[pos] == ' ') pos += 1; pos = gf_token_get(buffer, pos, "\r\n", comp, 3000); if (pos > 0) att->Value = gf_strdup(comp); if (media) { gf_list_add(media->Attributes, att); } else { gf_list_add(sdp->Attributes, att); } }
GF_Err DC_ConnectService(GF_InputService *plug, GF_ClientService *serv, const char *url) { DCReader *read = (DCReader *) plug->priv; FILE *test; char *tmp, *ext; if (!read || !serv || !url) return GF_BAD_PARAM; if (read->dnload) gf_service_download_del(read->dnload); read->dnload = NULL; read->url = gf_strdup(url); ext = strchr(read->url, '#'); if (ext) { char *anext; ext[0] = 0; anext = strrchr(read->url, '.'); ext[0] = '#'; ext = anext; } else { ext = strrchr(read->url, '.'); } if (ext && !stricmp(ext, ".gz")) { char *anext; ext[0] = 0; anext = strrchr(read->url, '.'); ext[0] = '.'; ext = anext; } read->service = serv; if (!strnicmp(url, "views://", 8)) { read->is_views_url = GF_TRUE; gf_service_connect_ack(serv, NULL, GF_OK); read->is_service_connected = GF_TRUE; return GF_OK; } if (ext) { char *cgi_par = NULL; ext += 1; if (ext) { tmp = strchr(ext, '#'); if (tmp) tmp[0] = 0; /* Warning the '?' sign should not be present in local files but it is convenient to have it to test web content locally */ cgi_par = strchr(ext, '?'); if (cgi_par) cgi_par[0] = 0; } if (!stricmp(ext, "bt") || !stricmp(ext, "btz") || !stricmp(ext, "bt.gz") || !stricmp(ext, "xmta") || !stricmp(ext, "xmt") || !stricmp(ext, "xmt.gz") || !stricmp(ext, "xmtz") || !stricmp(ext, "wrl") || !stricmp(ext, "wrl.gz") || !stricmp(ext, "x3d") || !stricmp(ext, "x3d.gz") || !stricmp(ext, "x3dz") || !stricmp(ext, "x3dv") || !stricmp(ext, "x3dv.gz") || !stricmp(ext, "x3dvz") || !stricmp(ext, "swf") ) read->oti = GPAC_OTI_PRIVATE_SCENE_GENERIC; else if (!stricmp(ext, "svg") || !stricmp(ext, "svgz") || !stricmp(ext, "svg.gz")) { read->oti = GPAC_OTI_PRIVATE_SCENE_SVG; } /*XML LASeR*/ else if (!stricmp(ext, "xsr")) read->oti = GPAC_OTI_PRIVATE_SCENE_LASER; else if (!stricmp(ext, "xbl")) read->oti = GPAC_OTI_PRIVATE_SCENE_XBL; else if (!stricmp(ext, "wgt") || !stricmp(ext, "mgt")) read->oti = GPAC_OTI_PRIVATE_SCENE_WGT; if (cgi_par) cgi_par[0] = '?'; } if (!read->oti && (!strnicmp(url, "file://", 7) || !strstr(url, "://"))) { char *rtype = gf_xml_get_root_type(url, NULL); if (rtype) { if (!strcmp(rtype, "SAFSession")) read->oti = GPAC_OTI_PRIVATE_SCENE_LASER; else if (!strcmp(rtype, "svg")) read->oti = GPAC_OTI_PRIVATE_SCENE_SVG; else if (!strcmp(rtype, "XMT-A")) read->oti = GPAC_OTI_PRIVATE_SCENE_GENERIC; else if (!strcmp(rtype, "X3D")) read->oti = GPAC_OTI_PRIVATE_SCENE_GENERIC; else if (!strcmp(rtype, "bindings")) read->oti = GPAC_OTI_PRIVATE_SCENE_XBL; else if (!strcmp(rtype, "widget")) read->oti = GPAC_OTI_PRIVATE_SCENE_WGT; gf_free(rtype); } } /*remote fetch*/ if (!strnicmp(url, "file://", 7)) { url += 7; } else if (strstr(url, "://")) { DC_DownloadFile(plug, read->url); return GF_OK; } test = gf_fopen(read->url, "rt"); if (!test) { gf_service_connect_ack(serv, NULL, GF_URL_ERROR); return GF_OK; } gf_fclose(test); if (!read->is_service_connected) { gf_service_connect_ack(serv, NULL, GF_OK); read->is_service_connected = GF_TRUE; } return GF_OK; }
void gf_rtsp_set_command_value(GF_RTSPCommand *com, char *Header, char *Value) { char LineBuffer[400]; s32 LinePos; GF_RTSPTransport *trans; GF_X_Attribute *x_Att; if (!stricmp(Header, "Accept")) com->Accept = gf_strdup(Value); else if (!stricmp(Header, "Accept-Encoding")) com->Accept_Encoding = gf_strdup(Value); else if (!stricmp(Header, "Accept-Language")) com->Accept_Language = gf_strdup(Value); else if (!stricmp(Header, "Authorization")) com->Authorization = gf_strdup(Value); else if (!stricmp(Header, "Bandwidth")) sscanf(Value, "%ud", &com->Bandwidth); else if (!stricmp(Header, "Blocksize")) sscanf(Value, "%ud", &com->Blocksize); else if (!stricmp(Header, "Cache-Control")) com->Cache_Control = gf_strdup(Value); else if (!stricmp(Header, "Conference")) com->Conference = gf_strdup(Value); else if (!stricmp(Header, "Connection")) com->Connection = gf_strdup(Value); else if (!stricmp(Header, "Content-Length")) sscanf(Value, "%ud", &com->Content_Length); else if (!stricmp(Header, "CSeq")) sscanf(Value, "%ud", &com->CSeq); else if (!stricmp(Header, "From")) com->From = gf_strdup(Value); else if (!stricmp(Header, "Proxy_Authorization")) com->Proxy_Authorization = gf_strdup(Value); else if (!stricmp(Header, "Proxy_Require")) com->Proxy_Require = gf_strdup(Value); else if (!stricmp(Header, "Range")) com->Range = gf_rtsp_range_parse(Value); else if (!stricmp(Header, "Referer")) com->Referer = gf_strdup(Value); else if (!stricmp(Header, "Scale")) sscanf(Value, "%lf", &com->Scale); else if (!stricmp(Header, "Session")) com->Session = gf_strdup(Value); else if (!stricmp(Header, "Speed")) sscanf(Value, "%lf", &com->Speed); else if (!stricmp(Header, "User_Agent")) com->User_Agent = gf_strdup(Value); //Transports else if (!stricmp(Header, "Transport")) { LinePos = 0; while (1) { LinePos = gf_token_get(Value, LinePos, "\r\n", LineBuffer, 400); if (LinePos <= 0) return; trans = gf_rtsp_transport_parse(Value); if (trans) gf_list_add(com->Transports, trans); } } //eXtensions attributes else if (!strnicmp(Header, "x-", 2)) { x_Att = (GF_X_Attribute*)gf_malloc(sizeof(GF_X_Attribute)); x_Att->Name = gf_strdup(Header+2); x_Att->Value = NULL; if (Value && strlen(Value)) x_Att->Value = gf_strdup(Value); gf_list_add(com->Xtensions, x_Att); } //the rest is ignored }
static int xlator_option_validate_percent_or_sizet (xlator_t *xl, const char *key, const char *value, volume_option_t *opt, char **op_errstr) { int ret = -1; char errstr[256]; double size = 0; gf_boolean_t is_percent = _gf_false; if (gf_string2percent_or_bytesize (value, &size, &is_percent) == 0) { if (is_percent) { if ((size < 0.0) || (size > 100.0)) { snprintf (errstr, sizeof (errstr), "'%lf' in 'option %s %s' is out" " of range [0 - 100]", size, key, value); gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE, "%s", errstr); goto out; } ret = 0; goto out; } /*Input value of size(in byte) should not be fractional*/ ret = xlator_option_validate_fractional_value (value); if (ret) { snprintf (errstr, sizeof (errstr), "'%lf' in 'option %s" " %s' should not be fractional value. Use " "valid unsigned integer value.", size, key, value); gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s", errstr); goto out; } /* Check the range */ if ((opt->min == 0) && (opt->max == 0)) { gf_msg_trace (xl->name, 0, "no range check required " "for 'option %s %s'", key, value); ret = 0; goto out; } if ((size < opt->min) || (size > opt->max)) { snprintf (errstr, 256, "'%lf' in 'option %s %s'" " is out of range [%.0f - %.0f]", size, key, value, opt->min, opt->max); gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE, "%s", errstr); goto out; } ret = 0; goto out; } /* If control reaches here, invalid argument */ snprintf (errstr, 256, "invalid number format \"%s\" in \"option %s\"", value, key); gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s", errstr); out: if (ret && op_errstr) *op_errstr = gf_strdup (errstr); return ret; }
void MP3_NetIO(void *cbk, GF_NETIO_Parameter *param) { GF_Err e; const char *szCache; u32 total_size, bytes_done; MP3Reader *read = (MP3Reader *) cbk; e = param->error; /*done*/ if (param->msg_type==GF_NETIO_DATA_TRANSFERED) { if (read->stream) { read->is_remote = 0; e = GF_EOS; } else { return; } } else if (param->msg_type==GF_NETIO_PARSE_HEADER) { if (!strcmp(param->name, "icy-name")) { if (read->icy_name) gf_free(read->icy_name); read->icy_name = gf_strdup(param->value); } if (!strcmp(param->name, "icy-genre")) { if (read->icy_genre) gf_free(read->icy_genre); read->icy_genre = gf_strdup(param->value); } if (!strcmp(param->name, "icy-meta")) { GF_NetworkCommand com; char *meta; meta = param->value; while (meta && meta[0]) { char *sep = strchr(meta, ';'); if (sep) sep[0] = 0; if (!strnicmp(meta, "StreamTitle=", 12)) { if (read->icy_track_name) gf_free(read->icy_track_name); read->icy_track_name = NULL; read->icy_track_name = gf_strdup(meta+12); if (!strcmp(read->icy_track_name, "''")){ /* On some servers, '' means not track name */ gf_free(read->icy_track_name); read->icy_track_name = NULL; } } if (!sep) break; sep[0] = ';'; meta = sep+1; } com.base.command_type = GF_NET_SERVICE_INFO; gf_term_on_command(read->service, &com, GF_OK); } return; } else { /*handle service message*/ gf_term_download_update_stats(read->dnload); if (param->msg_type!=GF_NETIO_DATA_EXCHANGE) return; } if (e >= GF_OK) { if (read->needs_connection) { gf_dm_sess_get_stats(read->dnload, NULL, NULL, &total_size, NULL, NULL, NULL); if (!total_size) read->is_live = 1; } /*looks like a live stream*/ if (read->is_live) { if (read->liveDataCopySize < param->size){ read->liveDataCopy = gf_realloc(read->liveDataCopy, param->size); } memcpy(read->liveDataCopy, param->data, param->size); if (!e) MP3_OnLiveData(read, read->liveDataCopy, param->size); return; } if (read->stream) return; /*open service*/ szCache = gf_dm_sess_get_cache_name(read->dnload); if (!szCache) e = GF_IO_ERR; else { read->stream = gf_f64_open((char *) szCache, "rb"); if (!read->stream) e = GF_SERVICE_ERROR; else { u32 minSizeToRead = 0; /*if full file at once (in cache) parse duration*/ if (e==GF_EOS) read->is_remote = 0; e = GF_OK; /*not enough data*/ if (!MP3_ConfigureFromFile(read, &minSizeToRead)) { gf_dm_sess_get_stats(read->dnload, NULL, NULL, NULL, &bytes_done, NULL, NULL); /*bad data - there's likely some ID3 around...*/ if (bytes_done>(100*1024 + minSizeToRead)) { e = GF_CORRUPTED_DATA; } else { fclose(read->stream); read->stream = NULL; return; } } } } } /*OK confirm*/ if (read->needs_connection) { read->needs_connection = 0; gf_term_on_connect(read->service, NULL, e); if (!e) mp3_setup_object(read); } }
void AC3_NetIO(void *cbk, GF_NETIO_Parameter *param) { GF_Err e; const char *szCache; u32 total_size, bytes_done; AC3Reader *read = (AC3Reader *) cbk; e = param->error; /*done*/ if (param->msg_type==GF_NETIO_DATA_TRANSFERED) { if (read->stream) { read->is_remote = GF_FALSE; e = GF_EOS; } else if (!read->needs_connection) { return; } } else if (param->msg_type==GF_NETIO_PARSE_HEADER) { if (!strcmp(param->name, "icy-name")) { if (read->icy_name) gf_free(read->icy_name); read->icy_name = gf_strdup(param->value); } if (!strcmp(param->name, "icy-genre")) { if (read->icy_genre) gf_free(read->icy_genre); read->icy_genre = gf_strdup(param->value); } if (!strcmp(param->name, "icy-meta")) { GF_NetworkCommand com; char *meta; if (read->icy_track_name) gf_free(read->icy_track_name); read->icy_track_name = NULL; meta = param->value; while (meta && meta[0]) { char *sep = strchr(meta, ';'); if (sep) sep[0] = 0; if (!strnicmp(meta, "StreamTitle=", 12)) { read->icy_track_name = gf_strdup(meta+12); } if (!sep) break; sep[0] = ';'; meta = sep+1; } com.base.command_type = GF_NET_SERVICE_INFO; gf_service_command(read->service, &com, GF_OK); } return; } else { /*handle service message*/ gf_service_download_update_stats(read->dnload); if (param->msg_type!=GF_NETIO_DATA_EXCHANGE) return; } /*data fetching or EOS*/ if (e >= GF_OK) { if (read->needs_connection) { gf_dm_sess_get_stats(read->dnload, NULL, NULL, &total_size, NULL, NULL, NULL); if (!total_size) read->is_live = GF_TRUE; } if (read->is_live) { if (!e) AC3_OnLiveData(read, param->data, param->size); return; } if (read->stream) return; /*open service*/ szCache = gf_dm_sess_get_cache_name(read->dnload); if (!szCache) e = GF_IO_ERR; else { read->stream = gf_fopen((char *) szCache, "rb"); if (!read->stream) e = GF_SERVICE_ERROR; else { /*if full file at once (in cache) parse duration*/ if (e==GF_EOS) read->is_remote = GF_FALSE; e = GF_OK; /*not enough data*/ if (!AC3_ConfigureFromFile(read)) { /*get amount downloaded and check*/ gf_dm_sess_get_stats(read->dnload, NULL, NULL, NULL, &bytes_done, NULL, NULL); if (bytes_done>10*1024) { e = GF_CORRUPTED_DATA; } else { gf_fclose(read->stream); read->stream = NULL; return; } } } } } /*OK confirm*/ if (read->needs_connection) { read->needs_connection = GF_FALSE; gf_service_connect_ack(read->service, NULL, e); if (!e) AC3_SetupObject(read); } }
GF_Err parse_sub_playlist(const char * file, VariantPlaylist ** playlist, const char * baseURL, Program * in_program, PlaylistElement *sub_playlist) { int len, i, currentLineNumber; FILE * f=NULL; char *m3u8_payload; u32 m3u8_size, m3u8pos; VariantPlaylist * pl; char currentLine[M3U8_BUF_SIZE]; char ** attributes = NULL; s_accumulated_attributes attribs; if (!strncmp(file, "gmem://", 7)) { if (sscanf(file, "gmem://%d@%p", &m3u8_size, &m3u8_payload) != 2) { GF_LOG(GF_LOG_ERROR, GF_LOG_DASH,("[M3U8] Cannot Open m3u8 source %s for reading\n", file)); return GF_SERVICE_ERROR; } } else { f = gf_f64_open(file, "rt"); if (!f) { GF_LOG(GF_LOG_ERROR, GF_LOG_DASH,("[M3U8] Cannot Open m3u8 file %s for reading\n", file)); return GF_SERVICE_ERROR; } } if (*playlist == NULL) { *playlist = variant_playlist_new(); if (!(*playlist)) { if (f) fclose(f); return GF_OUT_OF_MEM; } } pl = *playlist; currentLineNumber = 0; bzero(&attribs, sizeof(s_accumulated_attributes)); attribs.bandwidth = 0; attribs.durationInSeconds = 0; attribs.targetDurationInSeconds = 0; attribs.isVariantPlaylist = 0; attribs.isPlaylistEnded = 0; attribs.minMediaSequence = 0; attribs.currentMediaSequence = 0; m3u8pos=0; while (1) { char * eof; if (f) { if (!fgets(currentLine, sizeof(currentLine), f)) break; } else { u32 __idx=0; if (m3u8pos>=m3u8_size) break; while (1) { currentLine[__idx] = m3u8_payload[m3u8pos]; __idx++; m3u8pos++; if ((currentLine[__idx-1]=='\n') || (currentLine[__idx-1]=='\r')) { currentLine[__idx]=0; break; } } } currentLineNumber++; eof = strchr(currentLine, '\r'); if (eof) eof[0] = '\0'; eof = strchr(currentLine, '\n'); if (eof) eof[0] = '\0'; len = strlen( currentLine); if (len < 1) continue; if (currentLineNumber == 1) { /* Playlist MUST start with #EXTM3U */ /* if (len < 7 || strncmp("#EXTM3U", currentLine, 7)!=0) { fclose(f); variant_playlist_del(pl); GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("Failed to parse M3U8 File, it should start with #EXTM3U, but was : %s\n", currentLine)); return GF_STREAM_NOT_FOUND; } continue; */ } if (currentLine[0] == '#') { /* A comment or a directive */ if (strncmp("#EXT", currentLine, 4)==0) { attributes = parseAttributes(currentLine, &attribs); if (attributes == NULL) { MYLOG(("Comment at line %d : %s\n", currentLineNumber, currentLine)); } else { MYLOG(("Directive at line %d: \"%s\", attributes=", currentLineNumber, currentLine)); i = 0; while (attributes[i] != NULL) { MYLOG((" [%d]='%s'", i, attributes[i])); gf_free(attributes[i]); attributes[i] = NULL; i++; } MYLOG(("\n")); gf_free(attributes); attributes = NULL; } if (attribs.isPlaylistEnded) { pl->playlistNeedsRefresh = 0; } } } else { char * fullURL = currentLine; if (gf_url_is_local(currentLine)) { /* if (gf_url_is_local(baseURL)){ int num_chars = -1; if (baseURL[strlen(baseURL)-1] == '/'){ num_chars = asprintf(&fullURL, "%s%s", baseURL, currentLine); } else { num_chars = asprintf(&fullURL, "%s/%s", baseURL, currentLine); } if (num_chars < 0 || fullURL == NULL){ variant_playlist_del(*playlist); playlist = NULL; return GF_OUT_OF_MEM; } } else */ { fullURL = gf_url_concatenate(baseURL, currentLine); } assert( fullURL ); } { u32 count; PlaylistElement * currentPlayList = sub_playlist; /* First, we have to find the matching program */ Program * program = in_program; if (!in_program) program = variant_playlist_find_matching_program(pl, attribs.programId); /* We did not found the program, we create it */ if (program == NULL) { program = program_new(attribs.programId); if (program == NULL) { /* OUT of memory */ variant_playlist_del(*playlist); if (f) fclose(f); playlist = NULL; return GF_OUT_OF_MEM; } gf_list_add(pl->programs, program); if (pl->currentProgram < 0) pl->currentProgram = program->programId; } /* OK, we have a program, we have to choose the elements with same bandwidth */ assert( program ); assert( program->bitrates); count = gf_list_count( program->bitrates); if (!currentPlayList) { for (i = 0; i < (s32) count; i++) { PlaylistElement * itPlayListElement = gf_list_get(program->bitrates, i); assert( itPlayListElement ); if (itPlayListElement->bandwidth == attribs.bandwidth) { currentPlayList = itPlayListElement; break; } } } if (attribs.isVariantPlaylist) { /* We are the Variant Playlist */ if (currentPlayList != NULL) { /* should not happen, it means we redefine something previsouly added */ //assert( 0 ); } currentPlayList = playlist_element_new( TYPE_UNKNOWN, fullURL, attribs.title, attribs.codecs, attribs.durationInSeconds, attribs.byteRangeStart, attribs.byteRangeEnd); if (currentPlayList == NULL) { /* OUT of memory */ variant_playlist_del(*playlist); playlist = NULL; if (f) fclose(f); return GF_OUT_OF_MEM; } assert( fullURL); currentPlayList->url = gf_strdup(fullURL); currentPlayList->title = attribs.title ? gf_strdup(attribs.title):NULL; currentPlayList->codecs = attribs.codecs ? gf_strdup(attribs.codecs):NULL; gf_list_add(program->bitrates, currentPlayList); currentPlayList->width = attribs.width; currentPlayList->height = attribs.height; } else { /* Normal Playlist */ assert( pl->programs); if (currentPlayList == NULL) { /* This is in facts a "normal" playlist without any element in it */ PlaylistElement * subElement; assert(baseURL); currentPlayList = playlist_element_new( TYPE_PLAYLIST, baseURL, attribs.title, attribs.codecs, attribs.durationInSeconds, attribs.byteRangeStart, attribs.byteRangeEnd); if (currentPlayList == NULL) { /* OUT of memory */ variant_playlist_del(*playlist); playlist = NULL; if (f) fclose(f); return GF_OUT_OF_MEM; } assert(currentPlayList->element.playlist.elements); assert( fullURL); assert( currentPlayList->url); currentPlayList->title = NULL; currentPlayList->codecs = NULL; subElement = playlist_element_new( TYPE_UNKNOWN, fullURL, attribs.title, attribs.codecs, attribs.durationInSeconds, attribs.byteRangeStart, attribs.byteRangeEnd); if (subElement == NULL) { variant_playlist_del(*playlist); playlist_element_del(currentPlayList); playlist = NULL; if (f) fclose(f); return GF_OUT_OF_MEM; } gf_list_add(currentPlayList->element.playlist.elements, subElement); gf_list_add(program->bitrates, currentPlayList); currentPlayList->element.playlist.computed_duration += subElement->durationInfo; assert( program ); assert( program->bitrates); assert( currentPlayList); } else { PlaylistElement * subElement = playlist_element_new( TYPE_UNKNOWN, fullURL, attribs.title, attribs.codecs, attribs.durationInSeconds, attribs.byteRangeStart, attribs.byteRangeEnd); if (currentPlayList->elementType != TYPE_PLAYLIST) { currentPlayList->elementType = TYPE_PLAYLIST; if (!currentPlayList->element.playlist.elements) currentPlayList->element.playlist.elements = gf_list_new(); } if (subElement == NULL) { variant_playlist_del(*playlist); playlist_element_del(currentPlayList); playlist = NULL; if (f) fclose(f); return GF_OUT_OF_MEM; } gf_list_add(currentPlayList->element.playlist.elements, subElement); currentPlayList->element.playlist.computed_duration += subElement->durationInfo; } } currentPlayList->element.playlist.currentMediaSequence = attribs.currentMediaSequence ; /* We first set the default duration for element, aka targetDuration */ if (attribs.targetDurationInSeconds > 0) { currentPlayList->element.playlist.target_duration = attribs.targetDurationInSeconds; currentPlayList->durationInfo = attribs.targetDurationInSeconds; } if (attribs.durationInSeconds) { if (currentPlayList->durationInfo == 0) { /* we set the playlist duration info as the duration of a segment, only if it's not set There are cases of playlist with the last segment with a duration different from the others (example: Apple bipbop test)*/ currentPlayList->durationInfo = attribs.durationInSeconds; } } currentPlayList->element.playlist.mediaSequenceMin = attribs.minMediaSequence; currentPlayList->element.playlist.mediaSequenceMax = attribs.currentMediaSequence++; if (attribs.bandwidth > 1) currentPlayList->bandwidth = attribs.bandwidth; if (attribs.isPlaylistEnded) currentPlayList->element.playlist.is_ended = 1; } /* Cleanup all line-specific fields */ if (attribs.title) { gf_free(attribs.title); attribs.title = NULL; } attribs.durationInSeconds = 0; attribs.bandwidth = 0; attribs.programId = 0; if (attribs.codecs != NULL) { gf_free(attribs.codecs); attribs.codecs = NULL; } if (fullURL != currentLine) { gf_free(fullURL); } } } if (f) fclose(f); for (i=0; i < (int) gf_list_count(pl->programs); i++) { u32 j; Program *prog = gf_list_get(pl->programs, i); prog->computed_duration = 0; for (j=0; j<gf_list_count(prog->bitrates); j++) { PlaylistElement *ple = gf_list_get(prog->bitrates, j); if (ple->elementType==TYPE_PLAYLIST) { if (ple->element.playlist.computed_duration > prog->computed_duration) prog->computed_duration = ple->element.playlist.computed_duration; } } } return GF_OK; }
GF_RTSPTransport *gf_rtsp_transport_parse(char *buffer) { Bool IsFirst; char buf[100], param_name[100], param_val[100]; s32 pos, nPos; u32 v1, v2; GF_RTSPTransport *tmp; pos = 0; if (!buffer) return NULL; //only support for RTP/AVP for now if (strnicmp(buffer, "RTP/AVP", 7) && strnicmp(buffer, "RTP/SAVP", 8)) return NULL; GF_SAFEALLOC(tmp, GF_RTSPTransport); IsFirst = 1; pos = 0; while (1) { pos = gf_token_get(buffer, pos, " ;", buf, 100); if (pos <= 0) break; if (strstr(buf, "=")) { nPos = gf_token_get(buf, 0, "=", param_name, 100); nPos = gf_token_get(buf, nPos, "=", param_val, 100); } else { strcpy(param_name, buf); } //very first param is the profile if (IsFirst) { tmp->Profile = gf_strdup(param_name); IsFirst = 0; continue; } if (!stricmp(param_name, "destination")) { if (tmp->destination) gf_free(tmp->destination); tmp->destination = gf_strdup(param_val); } else if (!stricmp(param_name, "source")) { if (tmp->source) gf_free(tmp->source); tmp->source = gf_strdup(param_val); } else if (!stricmp(param_name, "unicast")) tmp->IsUnicast = 1; else if (!stricmp(param_name, "RECORD")) tmp->IsRecord = 1; else if (!stricmp(param_name, "append")) tmp->Append = 1; else if (!stricmp(param_name, "interleaved")) { u32 rID, rcID; tmp->IsInterleaved = 1; if (sscanf(param_val, "%u-%u", &rID, &rcID) == 1) { sscanf(param_val, "%u", &rID); tmp->rtcpID = tmp->rtpID = (u8) rID; } else { tmp->rtpID = (u8) rID; tmp->rtcpID = (u8) rcID; } } else if (!stricmp(param_name, "layers")) sscanf(param_val, "%u", &tmp->MulticastLayers); else if (!stricmp(param_name, "ttl")) sscanf(param_val, "%c ", &tmp->TTL); else if (!stricmp(param_name, "port")) { sscanf(param_val, "%u-%u", &v1, &v2); tmp->port_first = (u16) v1; tmp->port_last = (u16) v2; } /*do not use %hud here, broken on Win32 (sscanf returns 1)*/ else if (!stricmp(param_name, "server_port")) { sscanf(param_val, "%d-%d", &v1, &v2); tmp->port_first = (u16) v1; tmp->port_last = (u16) v2; } /*do not use %hud here, broken on Win32 (sscanf returns 1)*/ else if (!stricmp(param_name, "client_port")) { sscanf(param_val, "%d-%d", &v1, &v2); tmp->client_port_first = (u16) v1; tmp->client_port_last = (u16) v2; } else if (!stricmp(param_name, "ssrc")) sscanf(param_val, "%X", &tmp->SSRC); } return tmp; }
//Create and parse the movie for READ - EDIT only GF_ISOFile *gf_isom_open_file(const char *fileName, u32 OpenMode, const char *tmp_dir) { GF_Err e; u64 bytes; GF_ISOFile *mov = gf_isom_new_movie(); if (! mov) return NULL; mov->fileName = gf_strdup(fileName); mov->openMode = OpenMode; if ( (OpenMode == GF_ISOM_OPEN_READ) || (OpenMode == GF_ISOM_OPEN_READ_DUMP) ) { //always in read ... mov->openMode = GF_ISOM_OPEN_READ; mov->es_id_default_sync = -1; //for open, we do it the regular way and let the GF_DataMap assign the appropriate struct //this can be FILE (the only one supported...) as well as remote //(HTTP, ...),not suported yet //the bitstream IS PART OF the GF_DataMap //as this is read-only, use a FileMapping. this is the only place where //we use file mapping e = gf_isom_datamap_new(fileName, NULL, GF_ISOM_DATA_MAP_READ_ONLY, &mov->movieFileMap); if (e) { gf_isom_set_last_error(NULL, e); gf_isom_delete_movie(mov); return NULL; } #ifndef GPAC_DISABLE_ISOM_FRAGMENTS if (OpenMode == GF_ISOM_OPEN_READ_DUMP) mov->FragmentsFlags |= GF_ISOM_FRAG_READ_DEBUG; #endif } else { #ifdef GPAC_DISABLE_ISOM_WRITE //not allowed for READ_ONLY lib gf_isom_delete_movie(mov); gf_isom_set_last_error(NULL, GF_ISOM_INVALID_MODE); return NULL; #else //set a default output name for edited file mov->finalName = (char*)gf_malloc(strlen(fileName) + 5); if (!mov->finalName) { gf_isom_set_last_error(NULL, GF_OUT_OF_MEM); gf_isom_delete_movie(mov); return NULL; } strcpy(mov->finalName, "out_"); strcat(mov->finalName, fileName); //open the original file with edit tag e = gf_isom_datamap_new(fileName, NULL, GF_ISOM_DATA_MAP_EDIT, &mov->movieFileMap); //if the file doesn't exist, we assume it's wanted and create one from scratch if (e) { gf_isom_set_last_error(NULL, e); gf_isom_delete_movie(mov); return NULL; } //and create a temp fileName for the edit e = gf_isom_datamap_new("mp4_tmp_edit", tmp_dir, GF_ISOM_DATA_MAP_WRITE, & mov->editFileMap); if (e) { gf_isom_set_last_error(NULL, e); gf_isom_delete_movie(mov); return NULL; } mov->es_id_default_sync = -1; #endif } //OK, let's parse the movie... mov->LastError = gf_isom_parse_movie_boxes(mov, &bytes, 0); if (mov->LastError) { gf_isom_set_last_error(NULL, mov->LastError); gf_isom_delete_movie(mov); return NULL; } if (OpenMode == GF_ISOM_OPEN_CAT_FRAGMENTS) { gf_isom_datamap_del(mov->movieFileMap); /*reopen the movie file map in cat mode*/ e = gf_isom_datamap_new(fileName, tmp_dir, GF_ISOM_DATA_MAP_CAT, & mov->movieFileMap); } return mov; }
static GF_Err RP_ConnectChannel(GF_InputService *plug, LPNETCHANNEL channel, const char *url, Bool upstream) { u32 ESID, i; RTPStream *ch, *next_ch; RTSPSession *sess; char *es_url; RTPClient *priv = (RTPClient *)plug->priv; if (upstream) return GF_NOT_SUPPORTED; GF_LOG(GF_LOG_DEBUG, GF_LOG_RTP, ("[RTP] Connecting channel @%08x - %s\n", channel, url)); ch = RP_FindChannel(priv, channel, 0, (char *) url, 0); if (ch && (ch->status != RTP_Disconnected) ) return GF_SERVICE_ERROR; es_url = NULL; sess = NULL; if (strstr(url, "ES_ID=")) { sscanf(url, "ES_ID=%ud", &ESID); /*first case: simple URL (same namespace)*/ ch = RP_FindChannel(priv, NULL, ESID, NULL, 0); /*this should not happen, the sdp must describe all streams in the service*/ if (!ch) return GF_STREAM_NOT_FOUND; /*search for next stream*/ ch->next_stream = 0; for (i = 0; i < gf_list_count(priv->channels); i++) { next_ch = (RTPStream *)gf_list_get(priv->channels, i); if (next_ch->prev_stream == ch->mid) { ch->next_stream = next_ch->mid; break; } } /*assign app channel*/ ch->channel = channel; sess = ch->rtsp; } /*rtsp url - create a session if needed*/ else if (!strnicmp(url, "rtsp://", 7) || !strnicmp(url, "rtspu://", 8)) { sess = RP_CheckSession(priv, (char *) url); if (!sess) sess = RP_NewSession(priv, (char *) url); es_url = (char *) url; } /*data: url*/ else if (strstr(url, "data:application/mpeg4-od-au;base64") || strstr(url, "data:application/mpeg4-bifs-au;base64") || strstr(url, "data:application/mpeg4-es-au;base64") ) { GF_SAFEALLOC(ch, RTPStream); ch->control = gf_strdup(url); ch->owner = priv; ch->channel = channel; ch->status = RTP_Connected; /*register*/ gf_list_add(priv->channels, ch); RP_ConfirmChannelConnect(ch, GF_OK); return GF_OK; } /*session migration resume - don't send data to the server*/ if (ch->status==RTP_SessionResume) { ch->flags |= RTP_CONNECTED; RP_InitStream(ch, 0); RP_ConfirmChannelConnect(ch, GF_OK); return GF_OK; } /*send a DESCRIBE (not a setup) on the channel. If the channel is already created then the describe is skipped and a SETUP is sent directly, otherwise the channel is first described then setup*/ if (sess) RP_Describe(sess, es_url, channel); /*otherwise confirm channel connection*/ else RP_ConfirmChannelConnect(ch, GF_OK); return GF_OK; }
static int xlator_option_validate_int (xlator_t *xl, const char *key, const char *value, volume_option_t *opt, char **op_errstr) { long long inputll = 0; unsigned long long uinputll = 0; int ret = -1; char errstr[256]; /* Check the range */ if (gf_string2longlong (value, &inputll) != 0) { snprintf (errstr, 256, "invalid number format \"%s\" in option \"%s\"", value, key); gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s", errstr); goto out; } /* Handle '-0' */ if ((inputll == 0) && (gf_string2ulonglong (value, &uinputll) != 0)) { snprintf (errstr, 256, "invalid number format \"%s\" in option \"%s\"", value, key); gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s", errstr); goto out; } if ((opt->min == 0) && (opt->max == 0) && (opt->validate == GF_OPT_VALIDATE_BOTH)) { gf_msg_trace (xl->name, 0, "no range check required for " "'option %s %s'", key, value); ret = 0; goto out; } if (opt->validate == GF_OPT_VALIDATE_MIN) { if (inputll < opt->min) { snprintf (errstr, 256, "'%lld' in 'option %s %s' is smaller than " "minimum value '%.0f'", inputll, key, value, opt->min); gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s", errstr); goto out; } } else if (opt->validate == GF_OPT_VALIDATE_MAX) { if (inputll > opt->max) { snprintf (errstr, 256, "'%lld' in 'option %s %s' is greater than " "maximum value '%.0f'", inputll, key, value, opt->max); gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_INVALID_ENTRY, "%s", errstr); goto out; } } else if ((inputll < opt->min) || (inputll > opt->max)) { snprintf (errstr, 256, "'%lld' in 'option %s %s' is out of range " "[%.0f - %.0f]", inputll, key, value, opt->min, opt->max); gf_msg (xl->name, GF_LOG_ERROR, 0, LG_MSG_OUT_OF_RANGE, "%s", errstr); goto out; } ret = 0; out: if (ret && op_errstr) *op_errstr = gf_strdup (errstr); return ret; }
GF_EXPORT GF_Err gf_sdp_info_parse(GF_SDPInfo *sdp, char *sdp_text, u32 text_size) { GF_SDPBandwidth *bw; GF_SDPConnection *conn; GF_SDPMedia *media; GF_SDPTiming *timing; u32 i; s32 pos, LinePos; char LineBuf[3000], comp[3000]; media = NULL; timing = NULL; if (!sdp) return GF_BAD_PARAM; //Clean SDP info gf_sdp_info_reset(sdp); LinePos = 0; while (1) { LinePos = gf_token_get_line(sdp_text, LinePos, text_size, LineBuf, 3000); if (LinePos <= 0) break; if (!strcmp(LineBuf, "\r\n") || !strcmp(LineBuf, "\n") || !strcmp(LineBuf, "\r")) continue; switch (LineBuf[0]) { case 'v': pos = gf_token_get(LineBuf, 2, "\t\r\n", comp, 3000); sdp->Version = atoi(comp); break; case 'o': pos = gf_token_get(LineBuf, 2, " \t\r\n", comp, 3000); sdp->o_username = gf_strdup(comp); pos = gf_token_get(LineBuf, pos, " \t\r\n", comp, 3000); sdp->o_session_id = gf_strdup(comp); pos = gf_token_get(LineBuf, pos, " \t\r\n", comp, 3000); sdp->o_version = gf_strdup(comp); pos = gf_token_get(LineBuf, pos, " \t\r\n", comp, 3000); sdp->o_net_type = gf_strdup(comp); pos = gf_token_get(LineBuf, pos, " \t\r\n", comp, 3000); sdp->o_add_type = gf_strdup(comp); pos = gf_token_get(LineBuf, pos, " \t\r\n", comp, 3000); sdp->o_address = gf_strdup(comp); break; case 's': pos = gf_token_get(LineBuf, 2, "\t\r\n", comp, 3000); sdp->s_session_name = gf_strdup(comp); break; case 'i': pos = gf_token_get(LineBuf, 2, "\t\r\n", comp, 3000); sdp->i_description = gf_strdup(comp); break; case 'u': pos = gf_token_get(LineBuf, 2, "\t\r\n", comp, 3000); sdp->u_uri = gf_strdup(comp); break; case 'e': pos = gf_token_get(LineBuf, 2, "\t\r\n", comp, 3000); sdp->e_email = gf_strdup(comp); break; case 'p': pos = gf_token_get(LineBuf, 2, "\t\r\n", comp, 3000); sdp->p_phone = gf_strdup(comp); break; case 'c': //if at session level, only 1 is allowed for all SDP if (sdp->c_connection) break; conn = gf_sdp_conn_new(); pos = gf_token_get(LineBuf, 2, " \t\r\n", comp, 3000); conn->net_type = gf_strdup(comp); pos = gf_token_get(LineBuf, pos, " \t\r\n", comp, 3000); conn->add_type = gf_strdup(comp); pos = gf_token_get(LineBuf, pos, " /\r\n", comp, 3000); conn->host = gf_strdup(comp); if (gf_sk_is_multicast_address(conn->host)) { //a valid SDP will have TTL if address is multicast pos = gf_token_get(LineBuf, pos, "/\r\n", comp, 3000); if (pos > 0) { conn->TTL = atoi(comp); //multiple address indication is only valid for media pos = gf_token_get(LineBuf, pos, "/\r\n", comp, 3000); } if (pos > 0) { if (!media) { gf_sdp_conn_del(conn); break; } conn->add_count = atoi(comp); } } if (!media) sdp->c_connection = conn; else gf_list_add(media->Connections, conn); break; case 'b': pos = gf_token_get(LineBuf, 2, ":\r\n", comp, 3000); if (strcmp(comp, "CT") && strcmp(comp, "AS") && (comp[0] != 'X')) break; bw = (GF_SDPBandwidth*)gf_malloc(sizeof(GF_SDPBandwidth)); bw->name = gf_strdup(comp); pos = gf_token_get(LineBuf, pos, ":\r\n", comp, 3000); bw->value = atoi(comp); if (media) { gf_list_add(media->Bandwidths, bw); } else { gf_list_add(sdp->b_bandwidth, bw); } break; case 't': if (media) break; //create a new time structure for each entry GF_SAFEALLOC(timing, GF_SDPTiming); pos = gf_token_get(LineBuf, 2, " \t\r\n", comp, 3000); timing->StartTime = atoi(comp); pos = gf_token_get(LineBuf, pos, "\r\n", comp, 3000); timing->StopTime = atoi(comp); gf_list_add(sdp->Timing, timing); break; case 'r': if (media) break; pos = gf_token_get(LineBuf, 2, " \t\r\n", comp, 3000); timing->RepeatInterval = SDP_MakeSeconds(comp); pos = gf_token_get(LineBuf, pos, " \t\r\n", comp, 3000); timing->ActiveDuration = SDP_MakeSeconds(comp); while (1) { pos = gf_token_get(LineBuf, pos, " \t\r\n", comp, 3000); if (pos <= 0) break; timing->OffsetFromStart[timing->NbRepeatOffsets] = SDP_MakeSeconds(comp); timing->NbRepeatOffsets += 1; } break; case 'z': if (media) break; pos = 2; while (1) { pos = gf_token_get(LineBuf, pos, " \t\r\n", comp, 3000); if (pos <= 0) break; timing->AdjustmentTime[timing->NbZoneOffsets] = atoi(comp); pos = gf_token_get(LineBuf, pos, " \t\r\n", comp, 3000); timing->AdjustmentOffset[timing->NbZoneOffsets] = SDP_MakeSeconds(comp); timing->NbZoneOffsets += 1; } break; case 'k': pos = gf_token_get(LineBuf, 2, ":\t\r\n", comp, 3000); if (media) { media->k_method = gf_strdup(comp); } else { sdp->k_method = gf_strdup(comp); } pos = gf_token_get(LineBuf, pos, ":\r\n", comp, 3000); if (pos > 0) { if (media) { media->k_key = gf_strdup(comp); } else { sdp->k_key = gf_strdup(comp); } } break; case 'a': SDP_ParseAttribute(sdp, LineBuf+2, media); break; case 'm': pos = gf_token_get(LineBuf, 2, " \t\r\n", comp, 3000); if (strcmp(comp, "audio") && strcmp(comp, "data") && strcmp(comp, "control") && strcmp(comp, "video") && strcmp(comp, "text") && strcmp(comp, "application")) { return GF_SERVICE_ERROR; } media = gf_sdp_media_new(); //media type if (!strcmp(comp, "video")) media->Type = 1; else if (!strcmp(comp, "audio")) media->Type = 2; else if (!strcmp(comp, "text")) media->Type = 3; else if (!strcmp(comp, "data")) media->Type = 4; else if (!strcmp(comp, "control")) media->Type = 5; else media->Type = 0; //port numbers gf_token_get(LineBuf, pos, " ", comp, 3000); if (!strstr(comp, "/")) { pos = gf_token_get(LineBuf, pos, " \r\n", comp, 3000); media->PortNumber = atoi(comp); media->NumPorts = 0; } else { pos = gf_token_get(LineBuf, pos, " /\r\n", comp, 3000); media->PortNumber = atoi(comp); pos = gf_token_get(LineBuf, pos, " \r\n", comp, 3000); media->NumPorts = atoi(comp); } //transport Profile pos = gf_token_get(LineBuf, pos, " \r\n", comp, 3000); media->Profile = gf_strdup(comp); pos = gf_token_get(LineBuf, pos, " \r\n", comp, 3000); media->fmt_list = gf_strdup(comp); gf_list_add(sdp->media_desc, media); break; } } //finally rewrite the fmt_list for all media, and remove dynamic payloads //from the list i=0; while ((media = (GF_SDPMedia*)gf_list_enum(sdp->media_desc, &i))) { pos = 0; LinePos = 1; strcpy(LineBuf, ""); while (1) { if (!media->fmt_list) break; pos = gf_token_get(media->fmt_list, pos, " ", comp, 3000); if (pos <= 0) break; if (!SDP_IsDynamicPayload(media, comp)) { if (!LinePos) { strcat(LineBuf, " "); } else { LinePos = 0; } strcat(LineBuf, comp); } gf_free(media->fmt_list); media->fmt_list = NULL; if (strlen(LineBuf)) { media->fmt_list = gf_strdup(LineBuf); } } } return GF_OK; }
GF_EXPORT char *gf_xml_sax_peek_node(GF_SAXParser *parser, char *att_name, char *att_value, char *substitute, char *get_attr, char *end_pattern, Bool *is_substitute) { u32 state, att_len, alloc_size; z_off_t pos; Bool from_buffer; Bool dobreak=0; char szLine1[XML_INPUT_SIZE+2], szLine2[XML_INPUT_SIZE+2], *szLine, *cur_line, *sep, *start, first_c, *result; #define CPYCAT_ALLOC(__str, __is_copy) if ( strlen(__str) + (__is_copy ? 0 : strlen(szLine))>=alloc_size) {\ alloc_size = 1+strlen(__str); \ if (!__is_copy) alloc_size += strlen(szLine); \ szLine = gf_realloc(szLine, alloc_size); \ }\ if (__is_copy) strcpy(szLine, __str); \ else strcat(szLine, __str); \ from_buffer=0; #ifdef NO_GZIP if (!parser->f_in) from_buffer=1; #else if (!parser->gz_in) from_buffer=1; #endif result = NULL; szLine1[0] = szLine2[0] = 0; pos=0; if (!from_buffer) { #ifdef NO_GZIP pos = gf_f64_tell(parser->f_in); #else pos = gztell(parser->gz_in); #endif } att_len = strlen(parser->buffer + parser->att_name_start); if (att_len<2*XML_INPUT_SIZE) att_len = 2*XML_INPUT_SIZE; alloc_size = att_len; szLine = (char *) gf_malloc(sizeof(char)*alloc_size); strcpy(szLine, parser->buffer + parser->att_name_start); cur_line = szLine; att_len = strlen(att_value); state = 0; goto retry; while (1) { u32 read; u8 sep_char; if (!from_buffer) { #ifdef NO_GZIP if (!feof(parser->f_in)) break; #else if (!gzeof(parser->gz_in)) break; #endif } if (dobreak) break; if (cur_line == szLine2) { cur_line = szLine1; } else { cur_line = szLine2; } if (from_buffer) { dobreak=1; } else { #ifdef NO_GZIP read = fread(cur_line, 1, XML_INPUT_SIZE, parser->f_in); #else read = gzread(parser->gz_in, cur_line, XML_INPUT_SIZE); #endif cur_line[read] = cur_line[read+1] = 0; CPYCAT_ALLOC(cur_line, 0); } if (end_pattern) { start = strstr(szLine, end_pattern); if (start) { start[0] = 0; dobreak = 1; } } retry: if (state == 2) goto fetch_attr; sep = strstr(szLine, att_name); if (!sep && !state) { state = 0; start = strrchr(szLine, '<'); if (start) { CPYCAT_ALLOC(start, 1); } else { CPYCAT_ALLOC(cur_line, 1); } continue; } if (!state) { state = 1; /*load next line*/ first_c = sep[0]; sep[0] = 0; start = strrchr(szLine, '<'); if (!start) goto exit; sep[0] = first_c; CPYCAT_ALLOC(start, 1); sep = strstr(szLine, att_name); } sep = strchr(sep, '='); if (!sep) { state = 0; CPYCAT_ALLOC(cur_line, 1); continue; } while (sep[0] && (sep[0] != '\"') && (sep[0] != '\'') ) sep++; if (!sep[0]) continue; sep_char = sep[0]; sep++; while (sep[0] && strchr(" \n\r\t", sep[0]) ) sep++; if (!sep[0]) continue; if (!strchr(sep, sep_char)) continue; /*found*/ if (!strncmp(sep, att_value, att_len)) { u32 pos; sep = szLine + 1; while (strchr(" \t\r\n", sep[0])) sep++; pos = 0; while (!strchr(" \t\r\n", sep[pos])) pos++; first_c = sep[pos]; sep[pos] = 0; state = 2; if (!substitute || !get_attr || strcmp(sep, substitute) ) { if (is_substitute) *is_substitute = 0; result = gf_strdup(sep); goto exit; } sep[pos] = first_c; fetch_attr: sep = strstr(szLine + 1, get_attr); if (!sep) { CPYCAT_ALLOC(cur_line, 1); continue; } sep += strlen(get_attr); while (strchr("= \t\r\n", sep[0])) sep++; sep++; pos = 0; while (!strchr(" \t\r\n/>", sep[pos])) pos++; sep[pos-1] = 0; result = gf_strdup(sep); if (is_substitute) *is_substitute = 1; goto exit; } state = 0; CPYCAT_ALLOC(sep, 1); goto retry; } exit: gf_free(szLine); if (!from_buffer) { #ifdef NO_GZIP gf_f64_seek(parser->f_in, pos, SEEK_SET); #else gzrewind(parser->gz_in); gzseek(parser->gz_in, pos, SEEK_SET); #endif } return result; }
int cli_cmd_volume_info_cbk (struct cli_state *state, struct cli_cmd_word *word, const char **words, int wordcount) { int ret = -1; rpc_clnt_procedure_t *proc = NULL; call_frame_t *frame = NULL; cli_cmd_volume_get_ctx_t ctx = {0,}; cli_local_t *local = NULL; int sent = 0; int parse_error = 0; proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GET_VOLUME]; frame = create_frame (THIS, THIS->ctx->pool); if (!frame) goto out; if ((wordcount == 2) || (wordcount == 3 && !strcmp (words[2], "all"))) { ctx.flags = GF_CLI_GET_NEXT_VOLUME; proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GET_NEXT_VOLUME]; } else if (wordcount == 3) { ctx.flags = GF_CLI_GET_VOLUME; ctx.volname = (char *)words[2]; if (strlen (ctx.volname) > 1024) { cli_out ("Invalid volume name"); goto out; } proc = &cli_rpc_prog->proctable[GLUSTER_CLI_GET_VOLUME]; } else { cli_usage_out (word->pattern); parse_error = 1; return -1; } local = cli_local_get (); if (!local) goto out; local->u.get_vol.flags = ctx.flags; if (ctx.volname) local->u.get_vol.volname = gf_strdup (ctx.volname); frame->local = local; if (proc->fn) { ret = proc->fn (frame, THIS, &ctx); } out: if (ret) { cli_cmd_sent_status_get (&sent); if ((sent == 0) && (parse_error == 0)) cli_out ("Getting Volume information failed!"); } return ret; }
static void on_peek_node_start(void *cbk, const char *name, const char *ns, const GF_XMLAttribute *attributes, u32 nb_attributes) { struct _peek_type *pt = (struct _peek_type*)cbk; pt->res = gf_strdup(name); pt->parser->suspended = 1; }
static GF_Err EncScriptFields(ScriptEnc *sc_enc) { u32 nbFields, nbBits, eType, nbBitsProto, i; Bool use_list; GF_Err e; GF_FieldInfo info; nbFields = gf_node_get_num_fields_in_mode(sc_enc->script, GF_SG_FIELD_CODING_ALL) - 3; use_list = 1; nbBits = gf_get_bit_size(nbFields); if (nbFields+1 > 4 + gf_get_bit_size(nbFields)) use_list = 0; if (!nbFields) { GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, 1, 1, "Script::isList", NULL); GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, 1, 1, "end", NULL); return GF_OK; } GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, use_list ? 1 : 0, 1, "Script::isList", NULL); if (!use_list) { GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, nbBits, 4, "nbBits", NULL); GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, nbFields, nbBits, "count", NULL); } nbBitsProto = 0; if (sc_enc->codec->encoding_proto) nbBitsProto = gf_get_bit_size(gf_sg_proto_get_field_count(sc_enc->codec->encoding_proto) - 1); for (i=0; i<nbFields; i++) { if (use_list) GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, 0, 1, "end", NULL); gf_node_get_field(sc_enc->script, i+3, &info); switch (info.eventType) { case GF_SG_EVENT_IN: eType = GF_SG_SCRIPT_TYPE_EVENT_IN; break; case GF_SG_EVENT_OUT: eType = GF_SG_SCRIPT_TYPE_EVENT_OUT; break; default: eType = GF_SG_SCRIPT_TYPE_FIELD; break; } GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, eType, 2, "eventType", NULL); GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, info.fieldType, 6, "fieldType", NULL); gf_bifs_enc_name(sc_enc->codec, sc_enc->bs, (char *) info.name); /*this is an identifier for script*/ gf_list_add(sc_enc->identifiers, gf_strdup(info.name)); if (sc_enc->codec->encoding_proto) { GF_Route *isedField = gf_bifs_enc_is_field_ised(sc_enc->codec, sc_enc->script, i+3); if (isedField) { GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, 1, 1, "isedField", NULL); if (isedField->ToNode == sc_enc->script) { GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, isedField->FromField.fieldIndex, nbBitsProto, "protoField", NULL); } else { GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, isedField->ToField.fieldIndex, nbBitsProto, "protoField", NULL); } continue; } GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, 0, 1, "isedField", NULL); } /*default value*/ if (eType == GF_SG_SCRIPT_TYPE_FIELD) { GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, (info.far_ptr) ? 1 : 0, 1, "hasInitialValue", NULL); if (info.far_ptr) { e = gf_bifs_enc_field(sc_enc->codec, sc_enc->bs, sc_enc->script, &info); if (e) return e; } } } if (use_list) GF_BIFS_WRITE_INT(sc_enc->codec, sc_enc->bs, 1, 1, "end", NULL); return GF_OK; }
static GF_Err xml_sax_parse(GF_SAXParser *parser, Bool force_parse) { u32 i = 0; Bool is_text, is_end; u8 c; char *elt, sep; u32 cdata_sep; is_text = 0; while (parser->current_pos<parser->line_size) { if (!force_parse && parser->suspended) goto exit; restart: is_text = 0; switch (parser->sax_state) { /*load an XML element*/ case SAX_STATE_TEXT_CONTENT: is_text = 1; case SAX_STATE_ELEMENT: elt = NULL; i=0; while ((c = parser->buffer[parser->current_pos+i]) !='<') { if ((parser->init_state==2) && (c ==']')) { parser->sax_state = SAX_STATE_ATT_NAME; parser->current_pos+=i+1; goto restart; } i++; if (c=='\n') parser->line++; if (parser->current_pos+i==parser->line_size) goto exit; } if (is_text && i) { xml_sax_store_text(parser, i); is_text = 0; parser->sax_state = SAX_STATE_ELEMENT; } else if (i) { parser->current_pos += i; assert(parser->current_pos < parser->line_size); } is_end = 0; i = 0; cdata_sep = 0; while (1) { char c = parser->buffer[parser->current_pos+1+i]; if (!strncmp(parser->buffer+parser->current_pos+1+i, "!--", 3)) { parser->sax_state = SAX_STATE_COMMENT; i += 3; break; } if (!c) { i = 0; goto exit; } if ((c=='\t') || (c=='\r') || (c==' ') ) { if (i) break; else parser->current_pos++; } else if (c=='\n') { parser->line++; if (i) break; else parser->current_pos++; } else if (c=='>') break; else if (c=='=') break; else if (c=='[') { i++; if (!cdata_sep) cdata_sep = 1; else { break; } } else if (c=='/') { is_end = !i ? 1 : 2; i++; } else if (c=='<') { if (parser->sax_state != SAX_STATE_COMMENT) { parser->sax_state = SAX_STATE_SYNTAX_ERROR; return GF_CORRUPTED_DATA; } } else { i++; } /* if ((c=='[') && (parser->buffer[parser->elt_name_start-1 + i-2]=='A') ) break; */ if (parser->current_pos+1+i==parser->line_size) { i=0; goto exit; } } if (i) { parser->elt_name_start = parser->current_pos+1 + 1; if (is_end==1) parser->elt_name_start ++; if (is_end==2) parser->elt_name_end = parser->current_pos+1+i; else parser->elt_name_end = parser->current_pos+1+i + 1; } if (is_end) { xml_sax_flush_text(parser); parser->elt_end_pos = parser->file_pos + parser->current_pos + i; if (is_end==2) { parser->sax_state = SAX_STATE_ELEMENT; xml_sax_node_start(parser); xml_sax_node_end(parser, 0); } else { parser->elt_end_pos += parser->elt_name_end - parser->elt_name_start; xml_sax_node_end(parser, 1); } if (parser->sax_state == SAX_STATE_SYNTAX_ERROR) break; parser->current_pos+=2+i; parser->sax_state = SAX_STATE_TEXT_CONTENT; break; } sep = parser->buffer[parser->elt_name_end-1]; parser->buffer[parser->elt_name_end-1] = 0; elt = parser->buffer + parser->elt_name_start-1; parser->sax_state = SAX_STATE_ATT_NAME; assert(parser->elt_start_pos <= parser->file_pos + parser->current_pos); parser->elt_start_pos = parser->file_pos + parser->current_pos; if (!strncmp(elt, "!--", 3)) { xml_sax_flush_text(parser); parser->sax_state = SAX_STATE_COMMENT; if (i>3) parser->current_pos -= (i-3); } else if (!strcmp(elt, "?xml")) parser->init_state = 1; else if (!strcmp(elt, "!DOCTYPE")) parser->init_state = 2; else if (!strcmp(elt, "!ENTITY")) parser->sax_state = SAX_STATE_ENTITY; else if (!strcmp(elt, "!ATTLIST") || !strcmp(elt, "!ELEMENT")) parser->sax_state = SAX_STATE_SKIP_DOCTYPE; else if (!strcmp(elt, "![CDATA[")) parser->sax_state = SAX_STATE_CDATA; else if (elt[0]=='?') parser->sax_state = SAX_STATE_XML_PROC; /*node found*/ else { xml_sax_flush_text(parser); if (parser->init_state) { parser->init_state = 0; /*that's a bit ugly: since we solve entities when appending text, we need to reparse the current buffer*/ if (gf_list_count(parser->entities)) { char *orig_buf; GF_Err e; parser->buffer[parser->elt_name_end-1] = sep; orig_buf = gf_strdup(parser->buffer + parser->current_pos); parser->current_pos = 0; parser->line_size = 0; parser->elt_start_pos = 0; parser->sax_state = SAX_STATE_TEXT_CONTENT; e = gf_xml_sax_parse_intern(parser, orig_buf); gf_free(orig_buf); return e; } } } parser->current_pos+=1+i; parser->buffer[parser->elt_name_end-1] = sep; break; case SAX_STATE_COMMENT: if (!xml_sax_parse_comments(parser)) { xml_sax_swap(parser); goto exit; } break; case SAX_STATE_ATT_NAME: case SAX_STATE_ATT_VALUE: if (xml_sax_parse_attribute(parser)) goto exit; break; case SAX_STATE_ENTITY: xml_sax_parse_entity(parser); break; case SAX_STATE_SKIP_DOCTYPE: xml_sax_skip_doctype(parser); break; case SAX_STATE_XML_PROC: xml_sax_skip_xml_proc(parser); break; case SAX_STATE_CDATA: xml_sax_cdata(parser); break; case SAX_STATE_SYNTAX_ERROR: return GF_CORRUPTED_DATA; case SAX_STATE_DONE: return GF_EOS; } } exit: #if 0 if (is_text) { if (i) xml_sax_store_text(parser, i); /*DON'T FLUSH TEXT YET, wait for next '<' to do so otherwise we may corrupt xml base entities (', ...)*/ } #endif xml_sax_swap(parser); if (parser->sax_state==SAX_STATE_SYNTAX_ERROR) return GF_CORRUPTED_DATA; else return GF_OK; }
static GF_Descriptor *M2TS_GetServiceDesc(GF_InputService *plug, u32 expect_type, const char *sub_url) { M2TSIn *m2ts = plug->priv; GF_Descriptor *desc = NULL; char *frag; M2TSIn_Prog *prog; if (sub_url && !strnicmp(sub_url, "pid://", 6)) { GF_ObjectDescriptor *od; u32 pid = atoi(sub_url+6); if (pid>=GF_M2TS_MAX_STREAMS) return NULL; od = MP2TS_GetOD(m2ts, (GF_M2TS_PES*) m2ts->ts->ess[pid], NULL, 0, NULL); return (GF_Descriptor *) od; } frag = sub_url ? strrchr(sub_url, '#') : NULL; if (frag) frag++; /* consider the channel name in DVB URL as a fragment */ if (!frag && !strncmp(sub_url, "dvb://", 6)) { frag = (char*)sub_url + 6; } if (!frag) { m2ts->request_all_pids = 1; } else { /*we need exclusive access*/ gf_mx_p(m2ts->mx); if (!strnicmp(frag, "pid=", 4)) { GF_SAFEALLOC(prog, M2TSIn_Prog); prog->pid = atoi(frag+4); gf_list_add(m2ts->ts->requested_pids, prog); } else if (!strnicmp(frag, "EPG", 3)) { m2ts->epg_requested = 1; } else { u32 i, count; count = gf_list_count(m2ts->ts->requested_progs); prog = NULL; for (i=0; i<count; i++) { prog = gf_list_get(m2ts->ts->requested_progs, i); if (!strcmp(prog->fragment, frag)) break; prog = NULL; } if (!prog) { GF_SAFEALLOC(prog, M2TSIn_Prog); gf_list_add(m2ts->ts->requested_progs, prog); prog->fragment = gf_strdup(frag); } } gf_mx_v(m2ts->mx); } /*if type is undefined, check the PMT for an IOD*/ if (expect_type<=GF_MEDIA_OBJECT_SCENE) { if (gf_list_count(m2ts->ts->programs) == 1) { GF_M2TS_Program *prog = gf_list_get(m2ts->ts->programs, 0); if (prog->pmt_iod) { m2ts->request_all_pids = 0; gf_odf_desc_copy((GF_Descriptor *)prog->pmt_iod, &desc); return desc; } } if (m2ts->epg_requested) { GF_ObjectDescriptor *od = M2TS_GenerateEPG_OD(m2ts); m2ts->epg_requested = 0; return (GF_Descriptor *)od; } else { /*returning an empty IOD means "no scene description", let the terminal handle all media objects*/ desc = gf_odf_desc_new(GF_ODF_IOD_TAG); ((GF_ObjectDescriptor *) desc)->objectDescriptorID = 1; return desc; } } /* restart the thread if the same service is reused and if the previous thread terminated */ if (m2ts->ts->run_state == 2) { m2ts->ts->file_regulate = 0; TSDemux_DemuxPlay(m2ts->ts); } return NULL; }
static void gf_m2ts_process_ait(GF_M2TS_Demuxer *ts, GF_M2TS_AIT* ait){ u32 nb_app_desc, k, desc_id, nb_of_app, j; GF_M2TS_CHANNEL_APPLICATION_INFO* ChanAppInfo; char *url_base, *url_appli_path; nb_of_app = gf_list_count(ait->application_decoded); url_base = NULL; url_appli_path = NULL; j=0; /* Link the AIT and the channel */ ChanAppInfo = gf_m2ts_get_channel_application_info(ts->ChannelAppList,ait->service_id); if(!ChanAppInfo){ GF_SAFEALLOC(ChanAppInfo,GF_M2TS_CHANNEL_APPLICATION_INFO); ChanAppInfo->service_id = ait->service_id; ChanAppInfo->Application = gf_list_new(); ChanAppInfo->ait_pid = ait->pid; gf_list_add(ts->ChannelAppList,ChanAppInfo); } ChanAppInfo->nb_application = nb_of_app; GF_LOG(GF_LOG_DEBUG, GF_LOG_CONTAINER, ("[DSMCC] ChanAppInfo->nb_application %d \n",ChanAppInfo->nb_application)); for(j=0 ; j<nb_of_app ; j++){ GF_M2TS_AIT_APPLICATION* Application; GF_M2TS_AIT_APPLICATION_DECODE* application_decoded; GF_SAFEALLOC(Application,GF_M2TS_AIT_APPLICATION); gf_list_add(ChanAppInfo->Application,Application); Application->http_url = NULL; Application->carousel_url = NULL; application_decoded = (GF_M2TS_AIT_APPLICATION_DECODE*)gf_list_get(ait->application_decoded,j); nb_app_desc = gf_list_count(application_decoded->application_descriptors); Application->application_control_code = application_decoded->application_control_code; Application->application_id = application_decoded->application_id; Application->broadband = 0; Application->broadcast = 0; ChanAppInfo->version_number = ait->version_number; k=0; for(k=0 ; k<nb_app_desc ; k++){ desc_id = application_decoded->application_descriptors_id[k]; switch(desc_id){ case APPLICATION_DESCRIPTOR: { GF_M2TS_APPLICATION_DESCRIPTOR* application_descriptor = (GF_M2TS_APPLICATION_DESCRIPTOR*)gf_list_get(application_decoded->application_descriptors,k); Application->priority = application_descriptor->application_priority; Application->application_profile = application_descriptor->application_profile; break; } case APPLICATION_NAME_DESCRIPTOR: { GF_M2TS_APPLICATION_NAME_DESCRIPTOR* name_descriptor = (GF_M2TS_APPLICATION_NAME_DESCRIPTOR*)gf_list_get(application_decoded->application_descriptors,k); Application->appli_name = gf_strdup(name_descriptor->application_name_char); break; } case TRANSPORT_PROTOCOL_DESCRIPTOR: { GF_M2TS_TRANSPORT_PROTOCOL_DESCRIPTOR* protocol_descriptor = (GF_M2TS_TRANSPORT_PROTOCOL_DESCRIPTOR*)gf_list_get(application_decoded->application_descriptors,k); switch(protocol_descriptor->protocol_id){ case CAROUSEL: { GF_Err e; GF_M2TS_OBJECT_CAROUSEL_SELECTOR_BYTE* Carousel_selector_byte = (GF_M2TS_OBJECT_CAROUSEL_SELECTOR_BYTE*)protocol_descriptor->selector_byte; if(ts->process_dmscc){ GF_M2TS_DSMCC_OVERLORD* dsmcc_overlord = gf_m2ts_get_dmscc_overlord(ts->dsmcc_controler,ait->service_id); Application->broadcast = 1; if(!dsmcc_overlord){ char app_url[1024], char_service_id[128]; memset(&app_url,0,1024*sizeof(char)); memset(&char_service_id,0,128*sizeof(char)); dsmcc_overlord = gf_m2ts_init_dsmcc_overlord(ait->service_id); dsmcc_overlord->application_id = Application->application_id; sprintf(char_service_id,"%d",dsmcc_overlord->service_id); dsmcc_overlord->root_dir = (char*)gf_calloc(strlen(ts->dsmcc_root_dir)+2+strlen(char_service_id),sizeof(char)); sprintf(dsmcc_overlord->root_dir,"%s%c%s",ts->dsmcc_root_dir,GF_PATH_SEPARATOR,char_service_id); e = gf_mkdir(dsmcc_overlord->root_dir); if(e){ GF_LOG(GF_LOG_INFO, GF_LOG_CONTAINER, ("[Process DSMCC] Error during the creation of the directory %s \n",dsmcc_overlord->root_dir)); if(e == GF_BAD_PARAM){ gf_cleanup_dir(dsmcc_overlord->root_dir); } } sprintf(app_url,"%s%cindex.html",dsmcc_overlord->root_dir,GF_PATH_SEPARATOR); Application->carousel_url = gf_strdup(app_url); gf_list_add(ts->dsmcc_controler,dsmcc_overlord); } } if(Carousel_selector_byte->remote_connection){ Application->carousel_pid = Carousel_selector_byte->service_id; } Application->component_tag = Carousel_selector_byte->component_tag; break; } case TRANSPORT_HTTP: { GF_M2TS_TRANSPORT_HTTP_SELECTOR_BYTE* Transport_http_selector_byte = (GF_M2TS_TRANSPORT_HTTP_SELECTOR_BYTE*)protocol_descriptor->selector_byte; url_base = Transport_http_selector_byte->URL_base_byte; Application->broadband = 1; } default: { } } break; } case SIMPLE_APPLICATION_LOCATION_DESCRIPTOR: { GF_M2TS_SIMPLE_APPLICATION_LOCATION* Simple_application_location = (GF_M2TS_SIMPLE_APPLICATION_LOCATION*)gf_list_get(application_decoded->application_descriptors,k); url_appli_path = Simple_application_location->initial_path_bytes; break; } case APPLICATION_USAGE_DESCRIPTOR: { break; } default: { GF_LOG(GF_LOG_DEBUG, GF_LOG_MODULE, ("[Process AIT] Descriptor tag %d unknown, ignoring the descriptor \n",desc_id)); } } if((url_base != NULL) && ( url_appli_path != NULL)){ u32 url_length = (strlen(url_base)+strlen(url_appli_path)); Application->http_url = (char*)gf_calloc(url_length + 1,sizeof(char)); sprintf(Application->http_url,"%s%s",url_base,url_appli_path); Application->http_url[url_length]=0; Application->url_received = 1; url_base = NULL; url_appli_path = NULL; GF_LOG(GF_LOG_INFO, GF_LOG_MODULE, ("[Process AIT] SERVICE ID %d URL %s \n",ChanAppInfo->service_id,Application->http_url)); } } } if(ts->process_dmscc){ GF_M2TS_DSMCC_OVERLORD* dsmcc_overlord = gf_m2ts_get_dmscc_overlord(ts->dsmcc_controler,ait->service_id); if(dsmcc_overlord && !gf_m2ts_is_dmscc_app(ChanAppInfo)){ gf_cleanup_dir(dsmcc_overlord->root_dir); gf_rmdir(dsmcc_overlord->root_dir); gf_m2ts_delete_dsmcc_overlord(dsmcc_overlord); } } }
int32_t cli_cmd_volume_create_parse (const char **words, int wordcount, dict_t **options) { dict_t *dict = NULL; char *volname = NULL; int ret = -1; gf1_cluster_type type = GF_CLUSTER_TYPE_NONE; int count = 1; int brick_index = 0; int i = 0; char *trans_type = NULL; int32_t index = 0; char *bricks = NULL; int32_t brick_count = 0; GF_ASSERT (words); GF_ASSERT (options); GF_ASSERT ((strcmp (words[0], "volume")) == 0); GF_ASSERT ((strcmp (words[1], "create")) == 0); dict = dict_new (); if (!dict) goto out; if (wordcount < 3) goto out; volname = (char *)words[2]; GF_ASSERT (volname); /* Validate the volume name here itself */ { if (volname[0] == '-') goto out; if (!strcmp (volname, "all")) { cli_out ("\"all\" cannot be the name of a volume."); goto out; } if (strchr (volname, '/')) goto out; if (strlen (volname) > 512) goto out; for (i = 0; i < strlen (volname); i++) if (!isalnum (volname[i]) && (volname[i] != '_') && (volname[i] != '-')) goto out; } ret = dict_set_str (dict, "volname", volname); if (ret) goto out; if (wordcount < 4) { ret = -1; goto out; } if ((strcasecmp (words[3], "replica")) == 0) { type = GF_CLUSTER_TYPE_REPLICATE; if (wordcount < 5) { ret = -1; goto out; } count = strtol (words[4], NULL, 0); if (!count || (count < 2)) { cli_out ("replica count should be greater than 1"); ret = -1; goto out; } ret = dict_set_int32 (dict, "replica-count", count); if (ret) goto out; brick_index = 5; } else if ((strcasecmp (words[3], "stripe")) == 0) { type = GF_CLUSTER_TYPE_STRIPE; if (wordcount < 5) { ret = -1; goto out; } count = strtol (words[4], NULL, 0); if (!count || (count < 2)) { cli_out ("stripe count should be greater than 1"); ret = -1; goto out; } ret = dict_set_int32 (dict, "stripe-count", count); if (ret) goto out; brick_index = 5; } else { type = GF_CLUSTER_TYPE_NONE; brick_index = 3; } ret = dict_set_int32 (dict, "type", type); if (ret) goto out; if (type) index = 5; else index = 3; if (wordcount < (index + 1)) { ret = -1; goto out; } if (strcasecmp(words[index], "transport") == 0) { brick_index = index+2; if (wordcount < (index + 2)) { ret = -1; goto out; } if ((strcasecmp (words[index+1], "tcp") == 0)) { trans_type = gf_strdup ("tcp"); } else if ((strcasecmp (words[index+1], "rdma") == 0)) { trans_type = gf_strdup ("rdma"); } else if ((strcasecmp (words[index+1], "tcp,rdma") == 0) || (strcasecmp (words[index+1], "rdma,tcp") == 0)) { trans_type = gf_strdup ("tcp,rdma"); } else { gf_log ("", GF_LOG_ERROR, "incorrect transport" " protocol specified"); ret = -1; goto out; } } else { trans_type = gf_strdup ("tcp"); } ret = dict_set_dynstr (dict, "transport", trans_type); if (ret) goto out; ret = cli_cmd_bricks_parse (words, wordcount, brick_index, &bricks, &brick_count); if (ret) goto out; /* If brick-count is not valid when replica or stripe is given, exit here */ if (!brick_count) { cli_out ("No bricks specified"); ret = -1; goto out; } if (brick_count % count) { if (type == GF_CLUSTER_TYPE_STRIPE) cli_out ("number of bricks is not a multiple of " "stripe count"); else if (type == GF_CLUSTER_TYPE_REPLICATE) cli_out ("number of bricks is not a multiple of " "replica count"); ret = -1; goto out; } ret = dict_set_dynstr (dict, "bricks", bricks); if (ret) goto out; ret = dict_set_int32 (dict, "count", brick_count); if (ret) goto out; *options = dict; out: if (ret) { gf_log ("cli", GF_LOG_ERROR, "Unable to parse create volume CLI"); if (dict) dict_destroy (dict); } return ret; }
static GF_Err gf_text_import_srt_bifs(GF_SceneManager *ctx, GF_ESD *src, GF_MuxInfo *mux) { GF_Err e; GF_Node *text, *font; GF_StreamContext *srt; FILE *srt_in; GF_FieldInfo string, style; u32 sh, sm, ss, sms, eh, em, es, ems, start, end; GF_AUContext *au; GF_Command *com; SFString *sfstr; GF_CommandField *inf; Bool italic, underlined, bold; u32 state, curLine, line, i, len; char szLine[2048], szText[2048], *ptr; GF_StreamContext *sc = NULL; if (!ctx->scene_graph) { GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[srt->bifs] base scene not assigned\n")); return GF_BAD_PARAM; } i=0; while ((sc = (GF_StreamContext*)gf_list_enum(ctx->streams, &i))) { if (sc->streamType==GF_STREAM_SCENE) break; sc = NULL; } if (!sc) { GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[srt->bifs] cannot locate base scene\n")); return GF_BAD_PARAM; } if (!mux->textNode) { GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[srt->bifs] Target text node unspecified\n")); return GF_BAD_PARAM; } text = gf_sg_find_node_by_name(ctx->scene_graph, mux->textNode); if (!text) { GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[srt->bifs] cannot find target text node %s\n", mux->textNode)); return GF_BAD_PARAM; } if (gf_node_get_field_by_name(text, "string", &string) != GF_OK) { GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[srt->bifs] Target text node %s doesn't look like text\n", mux->textNode)); return GF_BAD_PARAM; } font = NULL; if (mux->fontNode) { font = gf_sg_find_node_by_name(ctx->scene_graph, mux->fontNode); if (!font) { GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[srt->bifs] cannot find target font node %s\n", mux->fontNode)); return GF_BAD_PARAM; } if (gf_node_get_field_by_name(font, "style", &style) != GF_OK) { GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[srt->bifs] Target font node %s doesn't look like font\n", mux->fontNode)); return GF_BAD_PARAM; } } srt_in = gf_f64_open(mux->file_name, "rt"); if (!srt_in) { GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[srt->bifs] cannot open input file %s\n", mux->file_name)); return GF_URL_ERROR; } srt = gf_sm_stream_new(ctx, src->ESID, GF_STREAM_SCENE, 1); if (!srt) return GF_OUT_OF_MEM; if (!src->slConfig) src->slConfig = (GF_SLConfig *) gf_odf_desc_new(GF_ODF_SLC_TAG); src->slConfig->timestampResolution = 1000; if (!src->decoderConfig) src->decoderConfig = (GF_DecoderConfig *) gf_odf_desc_new(GF_ODF_DCD_TAG); src->decoderConfig->streamType = GF_STREAM_SCENE; src->decoderConfig->objectTypeIndication = GPAC_OTI_SCENE_BIFS; e = GF_OK; state = end = 0; curLine = 0; au = NULL; com = NULL; italic = underlined = bold = 0; inf = NULL; while (1) { char *sOK = fgets(szLine, 2048, srt_in); if (sOK) REM_TRAIL_MARKS(szLine, "\r\n\t ") if (!sOK || !strlen(szLine)) { state = 0; if (au) { /*if italic or underscore do it*/ if (font && (italic || underlined || bold)) { com = gf_sg_command_new(ctx->scene_graph, GF_SG_FIELD_REPLACE); com->node = font; gf_node_register(font, NULL); inf = gf_sg_command_field_new(com); inf->fieldIndex = style.fieldIndex; inf->fieldType = style.fieldType; inf->field_ptr = gf_sg_vrml_field_pointer_new(style.fieldType); sfstr = (SFString *)inf->field_ptr; if (bold && italic && underlined) sfstr->buffer = gf_strdup("BOLDITALIC UNDERLINED"); else if (italic && underlined) sfstr->buffer = gf_strdup("ITALIC UNDERLINED"); else if (bold && underlined) sfstr->buffer = gf_strdup("BOLD UNDERLINED"); else if (underlined) sfstr->buffer = gf_strdup("UNDERLINED"); else if (bold && italic) sfstr->buffer = gf_strdup("BOLDITALIC"); else if (bold) sfstr->buffer = gf_strdup("BOLD"); else sfstr->buffer = gf_strdup("ITALIC"); gf_list_add(au->commands, com); } au = gf_sm_stream_au_new(srt, end, 0, 1); com = gf_sg_command_new(ctx->scene_graph, GF_SG_FIELD_REPLACE); com->node = text; gf_node_register(text, NULL); inf = gf_sg_command_field_new(com); inf->fieldIndex = string.fieldIndex; inf->fieldType = string.fieldType; inf->field_ptr = gf_sg_vrml_field_pointer_new(string.fieldType); gf_list_add(au->commands, com); /*reset font styles so that all AUs are true random access*/ if (font) { com = gf_sg_command_new(ctx->scene_graph, GF_SG_FIELD_REPLACE); com->node = font; gf_node_register(font, NULL); inf = gf_sg_command_field_new(com); inf->fieldIndex = style.fieldIndex; inf->fieldType = style.fieldType; inf->field_ptr = gf_sg_vrml_field_pointer_new(style.fieldType); gf_list_add(au->commands, com); } au = NULL; } inf = NULL; if (!sOK) break; continue; } switch (state) { case 0: if (sscanf(szLine, "%u", &line) != 1) { GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[srt->bifs] bad frame format (src: %s)\n", szLine)); e = GF_CORRUPTED_DATA; goto exit; } if (line != curLine + 1) { GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[srt->bifs] bad frame: previous %d - current %d (src: %s)\n", curLine, line, szLine)); e = GF_CORRUPTED_DATA; goto exit; } curLine = line; state = 1; break; case 1: if (sscanf(szLine, "%u:%u:%u,%u --> %u:%u:%u,%u", &sh, &sm, &ss, &sms, &eh, &em, &es, &ems) != 8) { GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("[srt->bifs] bad frame %u (src: %s)\n", curLine, szLine)); e = GF_CORRUPTED_DATA; goto exit; } start = (3600*sh + 60*sm + ss)*1000 + sms; if (start<end) { GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("[srt->bifs] corrupted frame starts before end of previous one (SRT Frame %d) - adjusting time stamps\n", curLine)); start = end; } end = (3600*eh + 60*em + es)*1000 + ems; /*make stream start at 0 by inserting a fake AU*/ if ((curLine==1) && start>0) { au = gf_sm_stream_au_new(srt, 0, 0, 1); com = gf_sg_command_new(ctx->scene_graph, GF_SG_FIELD_REPLACE); com->node = text; gf_node_register(text, NULL); inf = gf_sg_command_field_new(com); inf->fieldIndex = string.fieldIndex; inf->fieldType = string.fieldType; inf->field_ptr = gf_sg_vrml_field_pointer_new(string.fieldType); gf_list_add(au->commands, com); } au = gf_sm_stream_au_new(srt, start, 0, 1); com = NULL; state = 2; italic = underlined = bold = 0; break; default: ptr = szLine; /*FIXME - other styles posssibles ??*/ while (1) { if (!strnicmp(ptr, "<i>", 3)) { italic = 1; ptr += 3; } else if (!strnicmp(ptr, "<u>", 3)) { underlined = 1; ptr += 3; } else if (!strnicmp(ptr, "<b>", 3)) { bold = 1; ptr += 3; } else break; } /*if style remove end markers*/ while ((strlen(ptr)>4) && (ptr[strlen(ptr) - 4] == '<') && (ptr[strlen(ptr) - 1] == '>')) { ptr[strlen(ptr) - 4] = 0; } if (!com) { com = gf_sg_command_new(ctx->scene_graph, GF_SG_FIELD_REPLACE); com->node = text; gf_node_register(text, NULL); inf = gf_sg_command_field_new(com); inf->fieldIndex = string.fieldIndex; inf->fieldType = string.fieldType; inf->field_ptr = gf_sg_vrml_field_pointer_new(string.fieldType); gf_list_add(au->commands, com); } assert(inf); gf_sg_vrml_mf_append(inf->field_ptr, GF_SG_VRML_MFSTRING, (void **) &sfstr); len = 0; for (i=0; i<strlen(ptr); i++) { /*FIXME - UTF16 support !!*/ if (ptr[i] & 0x80) { /*non UTF8 (likely some win-CP)*/ if ((ptr[i+1] & 0xc0) != 0x80) { szText[len] = 0xc0 | ( (ptr[i] >> 6) & 0x3 ); len++; ptr[i] &= 0xbf; } /*we only handle UTF8 chars on 2 bytes (eg first byte is 0b110xxxxx)*/ else if ((ptr[i] & 0xe0) == 0xc0) { szText[len] = ptr[i]; len++; i++; } } szText[len] = ptr[i]; len++; } szText[len] = 0; sfstr->buffer = gf_strdup(szText); break; }
void gf_rtsp_set_response_value(GF_RTSPResponse *rsp, char *Header, char *Value) { char LineBuffer[400], buf[1000], param_name[100], param_val[1000]; s32 LinePos, Pos, nPos, s_val; GF_RTPInfo *info; GF_RTSPTransport *trans; GF_X_Attribute *x_Att; if (!stricmp(Header, "Accept")) rsp->Accept = gf_strdup(Value); else if (!stricmp(Header, "Accept-Encoding")) rsp->Accept_Encoding = gf_strdup(Value); else if (!stricmp(Header, "Accept-Language")) rsp->Accept_Language = gf_strdup(Value); else if (!stricmp(Header, "Allow")) rsp->Allow = gf_strdup(Value); else if (!stricmp(Header, "Authorization")) rsp->Authorization = gf_strdup(Value); else if (!stricmp(Header, "Bandwidth")) sscanf(Value, "%u", &rsp->Bandwidth); else if (!stricmp(Header, "Blocksize")) sscanf(Value, "%u", &rsp->Blocksize); else if (!stricmp(Header, "Cache-Control")) rsp->Cache_Control = gf_strdup(Value); else if (!stricmp(Header, "Conference")) rsp->Conference = gf_strdup(Value); else if (!stricmp(Header, "Connection")) rsp->Connection = gf_strdup(Value); else if (!stricmp(Header, "Content-Base")) rsp->Content_Base = gf_strdup(Value); else if (!stricmp(Header, "Content-Encoding")) rsp->Content_Encoding = gf_strdup(Value); else if (!stricmp(Header, "Content-Length")) sscanf(Value, "%u", &rsp->Content_Length); else if (!stricmp(Header, "Content-Language")) rsp->Content_Language = gf_strdup(Value); else if (!stricmp(Header, "Content-Location")) rsp->Content_Location = gf_strdup(Value); else if (!stricmp(Header, "Content-Type")) rsp->Content_Type = gf_strdup(Value); else if (!stricmp(Header, "CSeq")) sscanf(Value, "%u", &rsp->CSeq); else if (!stricmp(Header, "Date")) rsp->Date = gf_strdup(Value); else if (!stricmp(Header, "Expires")) rsp->Expires = gf_strdup(Value); else if (!stricmp(Header, "From")) rsp->From = gf_strdup(Value); else if (!stricmp(Header, "Host")) rsp->Host = gf_strdup(Value); else if (!stricmp(Header, "If-Match")) rsp->If_Match = gf_strdup(Value); else if (!stricmp(Header, "If-Modified-Since")) rsp->If_Modified_Since = gf_strdup(Value); else if (!stricmp(Header, "Last-Modified")) rsp->Last_Modified = gf_strdup(Value); else if (!stricmp(Header, "Location")) rsp->Location = gf_strdup(Value); else if (!stricmp(Header, "Proxy-Authenticate")) rsp->Proxy_Authenticate = gf_strdup(Value); else if (!stricmp(Header, "Proxy-Require")) rsp->Proxy_Require = gf_strdup(Value); else if (!stricmp(Header, "Public")) rsp->Public = gf_strdup(Value); else if (!stricmp(Header, "Referer")) rsp->Referer = gf_strdup(Value); else if (!stricmp(Header, "Require")) rsp->Require = gf_strdup(Value); else if (!stricmp(Header, "Retry-After")) rsp->Retry_After = gf_strdup(Value); else if (!stricmp(Header, "Scale")) sscanf(Value, "%lf", &rsp->Scale); else if (!stricmp(Header, "Server")) rsp->Server = gf_strdup(Value); else if (!stricmp(Header, "Speed")) sscanf(Value, "%lf", &rsp->Speed); else if (!stricmp(Header, "Timestamp")) rsp->Timestamp = gf_strdup(Value); else if (!stricmp(Header, "Unsupported")) rsp->Unsupported = gf_strdup(Value); else if (!stricmp(Header, "User-Agent")) rsp->User_Agent = gf_strdup(Value); else if (!stricmp(Header, "Vary")) rsp->Vary = gf_strdup(Value); else if (!stricmp(Header, "Via")) rsp->Vary = gf_strdup(Value); else if (!stricmp(Header, "WWW_Authenticate")) rsp->Vary = gf_strdup(Value); else if (!stricmp(Header, "Transport")) { LinePos = 0; while (1) { LinePos = gf_token_get(Value, LinePos, "\r\n", LineBuffer, 400); if (LinePos <= 0) return; trans = gf_rtsp_transport_parse(Value); if (trans) gf_list_add(rsp->Transports, trans); } } //Session else if (!stricmp(Header, "Session")) { LinePos = gf_token_get(Value, 0, ";\r\n", LineBuffer, 400); rsp->Session = gf_strdup(LineBuffer); //get timeout if any if (Value[LinePos] == ';') { LinePos += 1; /*LinePos = */gf_token_get(Value, LinePos, ";\r\n", LineBuffer, 400); //default rsp->SessionTimeOut = 60; sscanf(LineBuffer, "timeout=%u", &rsp->SessionTimeOut); } } //Range else if (!stricmp(Header, "Range")) rsp->Range = gf_rtsp_range_parse(Value); //RTP-Info else if (!stricmp(Header, "RTP-Info")) { LinePos = 0; while (1) { LinePos = gf_token_get(Value, LinePos, ",\r\n", LineBuffer, 400); if (LinePos <= 0) return; GF_SAFEALLOC(info, GF_RTPInfo); if (!info) return; Pos = 0; while (1) { Pos = gf_token_get(LineBuffer, Pos, " ;", buf, 1000); if (Pos <= 0) break; if (strstr(buf, "=")) { nPos = gf_token_get(buf, 0, "=", param_name, 100); nPos += 1; /*nPos = */gf_token_get(buf, nPos, "", param_val, 1000); } else { strcpy(param_name, buf); } if (!stricmp(param_name, "url")) info->url = gf_strdup(param_val); else if (!stricmp(param_name, "seq")) sscanf(param_val, "%u", &info->seq); else if (!stricmp(param_name, "rtptime")) { sscanf(param_val, "%i", &s_val); info->rtp_time = (s_val>0) ? s_val : 0; } else if (!stricmp(param_name, "ssrc")) { sscanf(param_val, "%i", &s_val); info->ssrc = (s_val>0) ? s_val : 0; } } gf_list_add(rsp->RTP_Infos, info); } } //check for extended attributes else if (!strnicmp(Header, "x-", 2)) { x_Att = (GF_X_Attribute*)gf_malloc(sizeof(GF_X_Attribute)); x_Att->Name = gf_strdup(Header+2); x_Att->Value = NULL; if (Value && strlen(Value)) x_Att->Value = gf_strdup(Value); gf_list_add(rsp->Xtensions, x_Att); } //unknown field - skip it }
GF_Err RP_ConnectServiceEx(GF_InputService *plug, GF_ClientService *serv, const char *url, Bool skip_migration) { char *session_cache; RTSPSession *sess; RTPClient *priv = (RTPClient *)plug->priv; /*store user address*/ priv->service = serv; if (priv->dnload) gf_term_download_del(priv->dnload); priv->dnload = NULL; GF_LOG(GF_LOG_INFO, GF_LOG_RTP, ("[RTP] Opening service %s\n", url)); /*load preferences*/ RT_LoadPrefs(plug, priv); /*start thread*/ gf_th_run(priv->th, RP_Thread, priv); if (!skip_migration) { session_cache = (char *) gf_modules_get_option((GF_BaseInterface *) plug, "Streaming", "SessionMigrationFile"); if (session_cache && session_cache[0]) { FILE *f = gf_f64_open(session_cache, "rb"); if (f) { fclose(f); GF_LOG(GF_LOG_INFO, GF_LOG_RTP, ("[RTP] Restarting RTSP session from %s\n", session_cache)); RP_FetchSDP(priv, (char *) session_cache, NULL, (char *) url); return GF_OK; } if (!strncmp(session_cache, "http://", 7)) { GF_LOG(GF_LOG_INFO, GF_LOG_RTP, ("[RTP] Restarting RTSP session from %s\n", session_cache)); RP_FetchSDP(priv, (char *) session_cache, NULL, (char *) url); return GF_OK; } } } /*local or remote SDP*/ if (strstr(url, "data:application/sdp") || (strnicmp(url, "rtsp", 4) && strstr(url, ".sdp")) ) { RP_FetchSDP(priv, (char *) url, NULL, NULL); return GF_OK; } /*rtsp and rtsp over udp*/ if (!strnicmp(url, "rtsp://", 7) || !strnicmp(url, "rtspu://", 8)) { char *the_url = gf_strdup(url); char *the_ext = strrchr(the_url, '#'); if (the_ext) { if (!stricmp(the_ext, "#audio")) priv->media_type = GF_MEDIA_OBJECT_AUDIO; else if (!stricmp(the_ext, "#video")) priv->media_type = GF_MEDIA_OBJECT_VIDEO; the_ext[0] = 0; } sess = RP_NewSession(priv, (char *) the_url); gf_free(the_url); if (!sess) { gf_term_on_connect(serv, NULL, GF_NOT_SUPPORTED); } else { RP_Describe(sess, 0, NULL); } return GF_OK; } /*direct RTP (no control) or embedded data - this means the service is attached to a single channel (no IOD) reply right away*/ gf_term_on_connect(serv, NULL, GF_OK); RP_SetupObjects(priv); return GF_OK; }
/*special cloning with type-casting from SF/MF strings to URL conversion since proto URL doesn't exist as a field type (it's just a stupid encoding trick) */ void VRML_FieldCopyCast(void *dest, u32 dst_field_type, void *orig, u32 ori_field_type) { SFURL *url; char tmp[50]; u32 size, i, sf_type_ori, sf_type_dst; void *dst_field, *orig_field; if (!dest || !orig) return; switch (dst_field_type) { case GF_SG_VRML_SFSTRING: if (ori_field_type == GF_SG_VRML_SFURL) { url = ((SFURL *)orig); if (url->OD_ID>0) { sprintf(tmp, "%d", url->OD_ID); if ( ((SFString*)dest)->buffer) gf_free(((SFString*)dest)->buffer); ((SFString*)dest)->buffer = gf_strdup(tmp); } else { if ( ((SFString*)dest)->buffer) gf_free(((SFString*)dest)->buffer); ((SFString*)dest)->buffer = url->url ? gf_strdup(url->url) : NULL; } } /*for SFString to MFString cast*/ else if (ori_field_type == GF_SG_VRML_SFSTRING) { if ( ((SFString*)dest)->buffer) gf_free(((SFString*)dest)->buffer); ((SFString*)dest)->buffer = ((SFString*)orig)->buffer ? gf_strdup(((SFString*)orig)->buffer) : NULL; } return; case GF_SG_VRML_SFURL: if (ori_field_type != GF_SG_VRML_SFSTRING) return; url = ((SFURL *)dest); url->OD_ID = 0; if (url->url) gf_free(url->url); if ( ((SFString*)orig)->buffer) url->url = gf_strdup(((SFString*)orig)->buffer); else url->url = NULL; return; case GF_SG_VRML_MFSTRING: case GF_SG_VRML_MFURL: break; default: return; } sf_type_dst = gf_sg_vrml_get_sf_type(dst_field_type); if (gf_sg_vrml_is_sf_field(ori_field_type)) { size = 1; gf_sg_vrml_mf_alloc(dest, dst_field_type, size); gf_sg_vrml_mf_get_item(dest, dst_field_type, &dst_field, 0); VRML_FieldCopyCast(dst_field, sf_type_dst, orig, ori_field_type); return; } size = ((GenMFField *)orig)->count; if (size != ((GenMFField *)dest)->count) gf_sg_vrml_mf_alloc(dest, dst_field_type, size); sf_type_ori = gf_sg_vrml_get_sf_type(ori_field_type); //duplicate all items for (i=0; i<size; i++) { gf_sg_vrml_mf_get_item(dest, dst_field_type, &dst_field, i); gf_sg_vrml_mf_get_item(orig, ori_field_type, &orig_field, i); VRML_FieldCopyCast(dst_field, sf_type_dst, orig_field, sf_type_ori); } return; }
static error_t parse_opts (int key, char *arg, struct argp_state *state) { cmd_args_t *cmd_args = NULL; uint32_t n = 0; double d = 0.0; gf_boolean_t b = _gf_false; char *pwd = NULL; char tmp_buf[2048] = {0,}; cmd_args = state->input; switch (key) { case ARGP_VOLFILE_SERVER_KEY: cmd_args->volfile_server = gf_strdup (arg); break; case ARGP_VOLFILE_MAX_FETCH_ATTEMPTS: n = 0; if (gf_string2uint_base10 (arg, &n) == 0) { cmd_args->max_connect_attempts = n; break; } argp_failure (state, -1, 0, "Invalid limit on connect attempts %s", arg); break; case ARGP_READ_ONLY_KEY: cmd_args->read_only = 1; break; case ARGP_MAC_COMPAT_KEY: if (!arg) arg = "on"; if (gf_string2boolean (arg, &b) == 0) { cmd_args->mac_compat = b; break; } argp_failure (state, -1, 0, "invalid value \"%s\" for mac-compat", arg); break; case ARGP_VOLUME_FILE_KEY: if (cmd_args->volfile) GF_FREE (cmd_args->volfile); if (arg[0] != '/') { pwd = getcwd (NULL, PATH_MAX); if (!pwd) { argp_failure (state, -1, errno, "getcwd failed with error no %d", errno); break; } snprintf (tmp_buf, 1024, "%s/%s", pwd, arg); cmd_args->volfile = gf_strdup (tmp_buf); free (pwd); } else { cmd_args->volfile = gf_strdup (arg); } break; case ARGP_LOG_SERVER_KEY: if (cmd_args->log_server) GF_FREE (cmd_args->log_server); cmd_args->log_server = gf_strdup (arg); break; case ARGP_LOG_LEVEL_KEY: if (strcasecmp (arg, ARGP_LOG_LEVEL_NONE_OPTION) == 0) { cmd_args->log_level = GF_LOG_NONE; break; } if (strcasecmp (arg, ARGP_LOG_LEVEL_CRITICAL_OPTION) == 0) { cmd_args->log_level = GF_LOG_CRITICAL; break; } if (strcasecmp (arg, ARGP_LOG_LEVEL_ERROR_OPTION) == 0) { cmd_args->log_level = GF_LOG_ERROR; break; } if (strcasecmp (arg, ARGP_LOG_LEVEL_WARNING_OPTION) == 0) { cmd_args->log_level = GF_LOG_WARNING; break; } if (strcasecmp (arg, ARGP_LOG_LEVEL_NORMAL_OPTION) == 0) { cmd_args->log_level = GF_LOG_NORMAL; break; } if (strcasecmp (arg, ARGP_LOG_LEVEL_DEBUG_OPTION) == 0) { cmd_args->log_level = GF_LOG_DEBUG; break; } if (strcasecmp (arg, ARGP_LOG_LEVEL_TRACE_OPTION) == 0) { cmd_args->log_level = GF_LOG_TRACE; break; } argp_failure (state, -1, 0, "unknown log level %s", arg); break; case ARGP_LOG_FILE_KEY: cmd_args->log_file = gf_strdup (arg); break; case ARGP_VOLFILE_SERVER_PORT_KEY: n = 0; if (gf_string2uint_base10 (arg, &n) == 0) { cmd_args->volfile_server_port = n; break; } argp_failure (state, -1, 0, "unknown volfile server port %s", arg); break; case ARGP_LOG_SERVER_PORT_KEY: n = 0; if (gf_string2uint_base10 (arg, &n) == 0) { cmd_args->log_server_port = n; break; } argp_failure (state, -1, 0, "unknown log server port %s", arg); break; case ARGP_VOLFILE_SERVER_TRANSPORT_KEY: cmd_args->volfile_server_transport = gf_strdup (arg); break; case ARGP_VOLFILE_ID_KEY: cmd_args->volfile_id = gf_strdup (arg); break; case ARGP_PID_FILE_KEY: cmd_args->pid_file = gf_strdup (arg); break; case ARGP_NO_DAEMON_KEY: cmd_args->no_daemon_mode = ENABLE_NO_DAEMON_MODE; break; case ARGP_RUN_ID_KEY: cmd_args->run_id = gf_strdup (arg); break; case ARGP_DEBUG_KEY: cmd_args->debug_mode = ENABLE_DEBUG_MODE; break; case ARGP_DIRECT_IO_MODE_KEY: if (!arg) arg = "on"; if (gf_string2boolean (arg, &b) == 0) { cmd_args->fuse_direct_io_mode = b; break; } argp_failure (state, -1, 0, "unknown direct I/O mode setting \"%s\"", arg); break; case ARGP_ENTRY_TIMEOUT_KEY: d = 0.0; gf_string2double (arg, &d); if (!(d < 0.0)) { cmd_args->fuse_entry_timeout = d; break; } argp_failure (state, -1, 0, "unknown entry timeout %s", arg); break; case ARGP_ATTRIBUTE_TIMEOUT_KEY: d = 0.0; gf_string2double (arg, &d); if (!(d < 0.0)) { cmd_args->fuse_attribute_timeout = d; break; } argp_failure (state, -1, 0, "unknown attribute timeout %s", arg); break; case ARGP_CLIENT_PID_KEY: if (gf_string2int (arg, &cmd_args->client_pid) == 0) { cmd_args->client_pid_set = 1; break; } argp_failure (state, -1, 0, "unknown client pid %s", arg); break; case ARGP_VOLFILE_CHECK_KEY: cmd_args->volfile_check = 1; break; case ARGP_VOLUME_NAME_KEY: cmd_args->volume_name = gf_strdup (arg); break; case ARGP_XLATOR_OPTION_KEY: gf_remember_xlator_option (&cmd_args->xlator_options, arg); break; case ARGP_KEY_NO_ARGS: break; case ARGP_KEY_ARG: if (state->arg_num >= 1) argp_usage (state); cmd_args->mount_point = gf_strdup (arg); break; case ARGP_DUMP_FUSE_KEY: cmd_args->dump_fuse = gf_strdup (arg); break; case ARGP_BRICK_NAME_KEY: cmd_args->brick_name = gf_strdup (arg); break; case ARGP_BRICK_PORT_KEY: n = 0; if (gf_string2uint_base10 (arg, &n) == 0) { cmd_args->brick_port = n; break; } argp_failure (state, -1, 0, "unknown brick (listen) port %s", arg); break; } return 0; }