static void DestroyBackground(GF_Node *node) { BackgroundStack *ptr = (BackgroundStack *) gf_node_get_private(node); PreDestroyBindable(node, ptr->reg_stacks); gf_list_del(ptr->reg_stacks); if (ptr->sky_mesh) mesh_free(ptr->sky_mesh); if (ptr->ground_mesh) mesh_free(ptr->ground_mesh); gf_sg_vrml_mf_reset(&ptr->ground_ang, GF_SG_VRML_MFFLOAT); gf_sg_vrml_mf_reset(&ptr->sky_ang, GF_SG_VRML_MFFLOAT); gf_sg_vrml_mf_reset(&ptr->ground_col, GF_SG_VRML_MFCOLOR); gf_sg_vrml_mf_reset(&ptr->sky_col, GF_SG_VRML_MFCOLOR); mesh_free(ptr->front_mesh); mesh_free(ptr->back_mesh); mesh_free(ptr->top_mesh); mesh_free(ptr->bottom_mesh); mesh_free(ptr->left_mesh); mesh_free(ptr->right_mesh); gf_sc_texture_destroy(&ptr->txh_front); gf_sc_texture_destroy(&ptr->txh_back); gf_sc_texture_destroy(&ptr->txh_top); gf_sc_texture_destroy(&ptr->txh_bottom); gf_sc_texture_destroy(&ptr->txh_left); gf_sc_texture_destroy(&ptr->txh_right); gf_free(ptr); }
static void animationstream_check_url(AnimationStreamStack *stack, M_AnimationStream *as) { if (!stack->stream) { gf_sg_vrml_mf_reset(&stack->current_url, GF_SG_VRML_MFURL); gf_sg_vrml_field_copy(&stack->current_url, &as->url, GF_SG_VRML_MFURL); stack->stream = gf_mo_register((GF_Node *)as, &as->url, 0, 0); gf_sc_invalidate(stack->compositor, NULL); /*if changed while playing trigger*/ if (as->isActive) { gf_mo_play(stack->stream, 0, -1, 0); gf_mo_set_speed(stack->stream, as->speed); } return; } /*check change*/ if (gf_mo_url_changed(stack->stream, &as->url)) { gf_sg_vrml_mf_reset(&stack->current_url, GF_SG_VRML_MFURL); gf_sg_vrml_field_copy(&stack->current_url, &as->url, GF_SG_VRML_MFURL); /*if changed while playing stop old source*/ if (as->isActive) { gf_mo_set_flag(stack->stream, GF_MO_DISPLAY_REMOVE, 1); gf_mo_stop(stack->stream); } gf_mo_unregister((GF_Node *)as, stack->stream); stack->stream = gf_mo_register((GF_Node *)as, &as->url, 0, 0); /*if changed while playing play new source*/ if (as->isActive) { gf_mo_play(stack->stream, 0, -1, 0); gf_mo_set_speed(stack->stream, as->speed); } gf_sc_invalidate(stack->compositor, NULL); } }
GF_Err gf_bifs_dec_field(GF_BifsDecoder * codec, GF_BitStream *bs, GF_Node *node, GF_FieldInfo *field, Bool is_mem_com) { GF_Err e; u8 flag; // if (codec->LastError) return codec->LastError; assert(node); // if (field->fieldType == GF_SG_VRML_UNKNOWN) return GF_NON_COMPLIANT_BITSTREAM; if (gf_sg_vrml_is_sf_field(field->fieldType)) { e = gf_bifs_dec_sf_field(codec, bs, node, field, is_mem_com); if (e) return e; } else { /*clean up the eventIn field if not done*/ if (field->eventType == GF_SG_EVENT_IN) { if (field->fieldType == GF_SG_VRML_MFNODE) { gf_node_unregister_children(node, * (GF_ChildNodeItem **)field->far_ptr); * (GF_ChildNodeItem **)field->far_ptr = NULL; } else { //remove all items of the MFField gf_sg_vrml_mf_reset(field->far_ptr, field->fieldType); } } /*predictiveMFField*/ if (codec->info->config.UsePredictiveMFField) { flag = gf_bs_read_int(bs, 1); if (flag) { GF_LOG(GF_LOG_WARNING, GF_LOG_CODING, ("[BIFS] Stream uses Predictive Field Coding!\n")); #ifdef GPAC_ENABLE_BIFS_PMF return gf_bifs_dec_pred_mf_field(codec, bs, node, field); #else return GF_NOT_SUPPORTED; #endif } } /*reserved*/ flag = gf_bs_read_int(bs, 1); if (!flag) { /*destroy the field content...*/ if (field->fieldType != GF_SG_VRML_MFNODE) { e = gf_sg_vrml_mf_reset(field->far_ptr, field->fieldType); if (e) return e; } /*List description - alloc is dynamic*/ flag = gf_bs_read_int(bs, 1); if (flag) { e = BD_DecMFFieldList(codec, bs, node, field, is_mem_com); } else { e = BD_DecMFFieldVec(codec, bs, node, field, is_mem_com); } if (e) return e; } } return GF_OK; }
static void build_indexed_triangle_strip_set(GF_Node *node, Drawable3D *stack, GF_TraverseState *tr_state) { MFInt32 stripList; u32 i, nb_strips; X_IndexedTriangleStripSet *itss = (X_IndexedTriangleStripSet *)node; if (!itss->coord) return; stripList.count = 0; stripList.vals = NULL; nb_strips = 0; for (i=0; i<itss->index.count; i++) { if (itss->index.vals[i]==-1) { if (nb_strips>=3) { u32 *out_nb; gf_sg_vrml_mf_append(&stripList, GF_SG_VRML_MFINT32, (void **) &out_nb); *out_nb = nb_strips; } nb_strips = 0; } else { nb_strips++; } } if (nb_strips>=3) { u32 *out_nb; gf_sg_vrml_mf_append(&stripList, GF_SG_VRML_MFINT32, (void **) &out_nb); *out_nb = nb_strips; } BuildTriangleStripSet(stack->mesh, itss->coord, itss->color, itss->texCoord, itss->normal, &stripList, &itss->index, itss->normalPerVertex, itss->ccw, itss->solid); gf_sg_vrml_mf_reset(&stripList, GF_SG_VRML_MFINT32); }
void gf_sg_vrml_copy_mfurl(MFURL *dst, MFURL *src) { u32 i; gf_sg_vrml_mf_reset(dst, GF_SG_VRML_MFURL); dst->count = src->count; dst->vals = gf_malloc(sizeof(SFURL)*src->count); for (i=0; i<src->count; i++) { dst->vals[i].OD_ID = src->vals[i].OD_ID; dst->vals[i].url = src->vals[i].url ? gf_strdup(src->vals[i].url) : NULL; } }
/* Creates a subscene from the xlink:href */ static GF_Scene *gf_svg_get_subscene(GF_Node *elt, XLinkAttributesPointers *xlinkp, SMILSyncAttributesPointers *syncp, Bool use_sync, Bool primary_resource) { MFURL url; Bool lock_timelines = 0; GF_MediaObject *mo; GF_SceneGraph *graph = gf_node_get_graph(elt); GF_Scene *scene = (GF_Scene *)gf_sg_get_private(graph); if (!scene) return NULL; if (use_sync && syncp) { switch ((syncp->syncBehavior?*syncp->syncBehavior:SMIL_SYNCBEHAVIOR_DEFAULT)) { case SMIL_SYNCBEHAVIOR_LOCKED: case SMIL_SYNCBEHAVIOR_CANSLIP: lock_timelines = 1; break; case SMIL_SYNCBEHAVIOR_DEFAULT: { #if 0 if (svg && syncp) { switch ((syncp->syncBehaviorDefault ? *syncp->syncBehaviorDefault : SMIL_SYNCBEHAVIOR_LOCKED)) { case SMIL_SYNCBEHAVIOR_LOCKED: case SMIL_SYNCBEHAVIOR_CANSLIP: lock_timelines = 1; break; default: break; } } #endif } default: break; } } memset(&url, 0, sizeof(MFURL)); if (!xlinkp->href) return NULL; gf_term_get_mfurl_from_xlink(elt, &url); while (scene->secondary_resource && scene->root_od->parentscene) scene = scene->root_od->parentscene; mo = gf_scene_get_media_object_ex(scene, &url, GF_MEDIA_OBJECT_SCENE, lock_timelines, NULL, primary_resource, elt); gf_sg_vrml_mf_reset(&url, GF_SG_VRML_MFURL); if (!mo || !mo->odm) return NULL; mo->odm->subscene->secondary_resource = primary_resource ? 0 : 1; return mo->odm->subscene; }
static void media_sensor_activate(MediaSensorStack *media_sens, GF_Segment *desc) { 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"*/); }
static void animationstream_destroy(GF_Node *node, void *rs, Bool is_destroy) { if (is_destroy) { M_AnimationStream *as = (M_AnimationStream *)node; AnimationStreamStack *st = (AnimationStreamStack *) gf_node_get_private(node); if (st->time_handle.is_registered) { gf_sc_unregister_time_node(st->compositor, &st->time_handle); } if (st->stream && as->isActive) { gf_mo_set_flag(st->stream, GF_MO_DISPLAY_REMOVE, 1); gf_mo_stop(st->stream); } gf_sg_vrml_mf_reset(&st->current_url, GF_SG_VRML_MFURL); gf_free(st); } }
void compositor_svg_video_modified(GF_Compositor *compositor, GF_Node *node) { /*if href has been modified, stop the video (and associated audio if any) right away - we cannot wait for next traversal to process this as the video could be in a hidden subtree not traversed*/ if (gf_node_dirty_get(node) & GF_SG_SVG_XLINK_HREF_DIRTY) { SVG_video_stack *st = (SVG_video_stack *)gf_node_get_private(node); /*WARNING - stack may be NULL at this point when inserting the video from script*/ if (st && st->txh.is_open) { if (st->audio) { svg_audio_smil_evaluate_ex(NULL, 0, SMIL_TIMING_EVAL_REMOVE, st->audio, st->txh.owner); gf_node_unregister(st->audio, NULL); st->audio = NULL; } /*reset cached URL to avoid reopening the resource in the smil timing callback*/ gf_sg_vrml_mf_reset(&st->txurl, GF_SG_VRML_MFURL); gf_sc_texture_stop(&st->txh); } } gf_node_dirty_set(node, 0, GF_FALSE); /*and force a redraw of next frame*/ gf_sc_next_frame_state(compositor, GF_SC_DRAW_FRAME); }
GF_EXPORT GF_Err gf_term_get_mfurl_from_xlink(GF_Node *node, MFURL *mfurl) { u32 stream_id = 0; GF_Err e = GF_OK; SFURL *sfurl = NULL; GF_FieldInfo info; XMLRI *iri; GF_Scene *scene = gf_sg_get_private(gf_node_get_graph(node)); if (!scene) return GF_BAD_PARAM; gf_sg_vrml_mf_reset(mfurl, GF_SG_VRML_MFURL); e = gf_node_get_attribute_by_tag(node, TAG_XLINK_ATT_href, 0, 0, &info); if (e) return e; iri = (XMLRI*)info.far_ptr; if (iri->type==XMLRI_STREAMID) { stream_id = iri->lsr_stream_id; } else if (!iri->string) return GF_OK; mfurl->count = 1; GF_SAFEALLOC(mfurl->vals, SFURL) sfurl = mfurl->vals; sfurl->OD_ID = stream_id; if (stream_id) return GF_OK; if (!strncmp(iri->string, "data:", 5)) { const char *cache_dir = gf_cfg_get_key(scene->root_od->term->user->config, "General", "CacheDirectory"); e = gf_node_store_embedded_data(iri, cache_dir, "embedded_"); if (e) return e; sfurl->url = gf_strdup(iri->string); return GF_OK; } sfurl->url = gf_term_resolve_xlink(node, iri->string); return e; }
GF_EXPORT GF_Err gf_sg_vrml_mf_alloc(void *mf, u32 FieldType, u32 NbItems) { u32 FieldSize; GenMFField *mffield = (GenMFField *)mf; if (gf_sg_vrml_is_sf_field(FieldType)) return GF_BAD_PARAM; if (FieldType == GF_SG_VRML_MFNODE) return GF_BAD_PARAM; FieldSize = gf_sg_vrml_get_sf_size(FieldType); //field we can't copy if (!FieldSize) return GF_BAD_PARAM; if (NbItems>MAX_MFFIELD_ALLOC) return GF_IO_ERR; if (mffield->count==NbItems) return GF_OK; gf_sg_vrml_mf_reset(mf, FieldType); if (NbItems) { mffield->array = (char*)gf_malloc(sizeof(char)*FieldSize*NbItems); memset(mffield->array, 0, sizeof(char)*FieldSize*NbItems); } mffield->count = NbItems; return GF_OK; }
static void ILS2D_SetColorIndex(GF_Node *node, GF_Route *route) { M_IndexedLineSet2D *ils2D = (M_IndexedLineSet2D *)node; gf_sg_vrml_field_copy(&ils2D->colorIndex, &ils2D->set_colorIndex, GF_SG_VRML_MFINT32); gf_sg_vrml_mf_reset(&ils2D->set_colorIndex, GF_SG_VRML_MFINT32); }
GF_EXPORT void gf_sg_vrml_field_clone(void *dest, void *orig, u32 field_type, GF_SceneGraph *inScene) { u32 size, i, sf_type; void *dst_field, *orig_field; if (!dest || !orig) return; switch (field_type) { case GF_SG_VRML_SFBOOL: memcpy(dest, orig, sizeof(SFBool)); break; case GF_SG_VRML_SFCOLOR: memcpy(dest, orig, sizeof(SFColor)); break; case GF_SG_VRML_SFFLOAT: memcpy(dest, orig, sizeof(SFFloat)); break; case GF_SG_VRML_SFINT32: memcpy(dest, orig, sizeof(SFInt32)); break; case GF_SG_VRML_SFROTATION: memcpy(dest, orig, sizeof(SFRotation)); break; case GF_SG_VRML_SFTIME: memcpy(dest, orig, sizeof(SFTime)); break; case GF_SG_VRML_SFVEC2F: memcpy(dest, orig, sizeof(SFVec2f)); break; case GF_SG_VRML_SFVEC3F: memcpy(dest, orig, sizeof(SFVec3f)); break; case GF_SG_VRML_SFATTRREF: memcpy(dest, orig, sizeof(SFAttrRef)); break; case GF_SG_VRML_SFSTRING: if ( ((SFString*)dest)->buffer) gf_free(((SFString*)dest)->buffer); if ( ((SFString*)orig)->buffer ) ((SFString*)dest)->buffer = gf_strdup(((SFString*)orig)->buffer); else ((SFString*)dest)->buffer = NULL; break; case GF_SG_VRML_SFURL: if ( ((SFURL *)dest)->url ) gf_free( ((SFURL *)dest)->url ); ((SFURL *)dest)->OD_ID = ((SFURL *)orig)->OD_ID; if (((SFURL *)orig)->url) ((SFURL *)dest)->url = gf_strdup(((SFURL *)orig)->url); else ((SFURL *)dest)->url = NULL; break; case GF_SG_VRML_SFIMAGE: if (((SFImage *)dest)->pixels) gf_free(((SFImage *)dest)->pixels); ((SFImage *)dest)->width = ((SFImage *)orig)->width; ((SFImage *)dest)->height = ((SFImage *)orig)->height; ((SFImage *)dest)->numComponents = ((SFImage *)orig)->numComponents; size = ((SFImage *)dest)->width * ((SFImage *)dest)->height * ((SFImage *)dest)->numComponents; ((SFImage *)dest)->pixels = (u8*)gf_malloc(sizeof(char)*size); memcpy(((SFImage *)dest)->pixels, ((SFImage *)orig)->pixels, sizeof(char)*size); break; case GF_SG_VRML_SFCOMMANDBUFFER: { SFCommandBuffer *cb_dst = (SFCommandBuffer *)dest; SFCommandBuffer *cb_src = (SFCommandBuffer *)orig; cb_dst->bufferSize = cb_src->bufferSize; if (cb_dst->bufferSize && !gf_list_count(cb_src->commandList) ) { cb_dst->buffer = (u8*)gf_realloc(cb_dst->buffer, sizeof(char)*cb_dst->bufferSize); memcpy(cb_dst->buffer, cb_src->buffer, sizeof(char)*cb_src->bufferSize); } else { u32 j, c2; if (cb_dst->buffer) gf_free(cb_dst->buffer); cb_dst->buffer = NULL; /*clone command list*/ c2 = gf_list_count(cb_src->commandList); for (j=0; j<c2;j++) { GF_Command *sub_com = (GF_Command *)gf_list_get(cb_src->commandList, j); GF_Command *new_com = gf_sg_vrml_command_clone(sub_com, inScene, 0); gf_list_add(cb_dst->commandList, new_com); } } } break; /*simply copy text string*/ case GF_SG_VRML_SFSCRIPT: if (((SFScript*)dest)->script_text) gf_free(((SFScript*)dest)->script_text); ((SFScript*)dest)->script_text = NULL; if ( ((SFScript*)orig)->script_text) ((SFScript *)dest)->script_text = (char *)gf_strdup( (char*) ((SFScript*)orig)->script_text ); break; //simple MFFields, do a memcpy case GF_SG_VRML_MFBOOL: case GF_SG_VRML_MFFLOAT: case GF_SG_VRML_MFTIME: case GF_SG_VRML_MFINT32: case GF_SG_VRML_MFVEC3F: case GF_SG_VRML_MFVEC2F: case GF_SG_VRML_MFCOLOR: case GF_SG_VRML_MFROTATION: case GF_SG_VRML_MFATTRREF: size = gf_sg_vrml_get_sf_size(field_type) * ((GenMFField *)orig)->count; if (((GenMFField *)orig)->count != ((GenMFField *)dest)->count) { ((GenMFField *)dest)->array = gf_realloc(((GenMFField *)dest)->array, size); ((GenMFField *)dest)->count = ((GenMFField *)orig)->count; } memcpy(((GenMFField *)dest)->array, ((GenMFField *)orig)->array, size); break; //complex MFFields case GF_SG_VRML_MFSTRING: case GF_SG_VRML_MFIMAGE: case GF_SG_VRML_MFURL: case GF_SG_VRML_MFSCRIPT: size = ((GenMFField *)orig)->count; gf_sg_vrml_mf_reset(dest, field_type); gf_sg_vrml_mf_alloc(dest, field_type, size); sf_type = gf_sg_vrml_get_sf_type(field_type); //duplicate all items for (i=0; i<size; i++) { gf_sg_vrml_mf_get_item(dest, field_type, &dst_field, i); gf_sg_vrml_mf_get_item(orig, field_type, &orig_field, i); gf_sg_vrml_field_copy(dst_field, orig_field, sf_type); } break; } }
GF_EXPORT void gf_sg_vrml_field_copy(void *dest, void *orig, u32 field_type) { u32 size, i, sf_type; void *dst_field, *orig_field; if (!dest || !orig) return; switch (field_type) { case GF_SG_VRML_SFBOOL: memcpy(dest, orig, sizeof(SFBool)); break; case GF_SG_VRML_SFCOLOR: memcpy(dest, orig, sizeof(SFColor)); break; case GF_SG_VRML_SFFLOAT: memcpy(dest, orig, sizeof(SFFloat)); break; case GF_SG_VRML_SFINT32: memcpy(dest, orig, sizeof(SFInt32)); break; case GF_SG_VRML_SFROTATION: memcpy(dest, orig, sizeof(SFRotation)); break; case GF_SG_VRML_SFTIME: memcpy(dest, orig, sizeof(SFTime)); break; case GF_SG_VRML_SFVEC2F: memcpy(dest, orig, sizeof(SFVec2f)); break; case GF_SG_VRML_SFVEC3F: memcpy(dest, orig, sizeof(SFVec3f)); break; case GF_SG_VRML_SFSTRING: if ( ((SFString*)dest)->buffer) free(((SFString*)dest)->buffer); if ( ((SFString*)orig)->buffer ) ((SFString*)dest)->buffer = strdup(((SFString*)orig)->buffer); else ((SFString*)dest)->buffer = NULL; break; case GF_SG_VRML_SFURL: if ( ((SFURL *)dest)->url ) free( ((SFURL *)dest)->url ); ((SFURL *)dest)->OD_ID = ((SFURL *)orig)->OD_ID; if (((SFURL *)orig)->url) ((SFURL *)dest)->url = strdup(((SFURL *)orig)->url); else ((SFURL *)dest)->url = NULL; break; case GF_SG_VRML_SFIMAGE: if (((SFImage *)dest)->pixels) free(((SFImage *)dest)->pixels); ((SFImage *)dest)->width = ((SFImage *)orig)->width; ((SFImage *)dest)->height = ((SFImage *)orig)->height; ((SFImage *)dest)->numComponents = ((SFImage *)orig)->numComponents; size = ((SFImage *)dest)->width * ((SFImage *)dest)->height * ((SFImage *)dest)->numComponents; ((SFImage *)dest)->pixels = (u8*)malloc(sizeof(char)*size); memcpy(((SFImage *)dest)->pixels, ((SFImage *)orig)->pixels, sizeof(char)*size); break; case GF_SG_VRML_SFCOMMANDBUFFER: gf_sg_sfcommand_del( *(SFCommandBuffer *)dest); ((SFCommandBuffer *)dest)->commandList = gf_list_new(); ((SFCommandBuffer *)dest)->bufferSize = ((SFCommandBuffer *)orig)->bufferSize; if (((SFCommandBuffer *)dest)->bufferSize) { ((SFCommandBuffer *)dest)->buffer = (u8*)malloc(sizeof(char)*((SFCommandBuffer *)orig)->bufferSize); memcpy(((SFCommandBuffer *)dest)->buffer, ((SFCommandBuffer *)orig)->buffer, sizeof(char)*((SFCommandBuffer *)orig)->bufferSize); } else { ((SFCommandBuffer *)dest)->buffer = NULL; } break; /*simply copy text string*/ case GF_SG_VRML_SFSCRIPT: if (((SFScript*)dest)->script_text) free(((SFScript*)dest)->script_text); ((SFScript*)dest)->script_text = NULL; if ( ((SFScript*)orig)->script_text) ((SFScript *)dest)->script_text = (u8*)strdup( (char*) ((SFScript*)orig)->script_text ); break; //MFFields case GF_SG_VRML_MFBOOL: case GF_SG_VRML_MFFLOAT: case GF_SG_VRML_MFTIME: case GF_SG_VRML_MFINT32: case GF_SG_VRML_MFSTRING: case GF_SG_VRML_MFVEC3F: case GF_SG_VRML_MFVEC2F: case GF_SG_VRML_MFCOLOR: case GF_SG_VRML_MFROTATION: case GF_SG_VRML_MFIMAGE: case GF_SG_VRML_MFURL: case GF_SG_VRML_MFSCRIPT: size = ((GenMFField *)orig)->count; gf_sg_vrml_mf_reset(dest, field_type); gf_sg_vrml_mf_alloc(dest, field_type, size); sf_type = gf_sg_vrml_get_sf_type(field_type); //duplicate all items for (i=0; i<size; i++) { gf_sg_vrml_mf_get_item(dest, field_type, &dst_field, i); gf_sg_vrml_mf_get_item(orig, field_type, &orig_field, i); gf_sg_vrml_field_copy(dst_field, orig_field, sf_type); } break; } }
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)); } } } }
static void Extrusion_SetOrientation(GF_Node *node, GF_Route *route) { M_Extrusion *eg = (M_Extrusion *)node; gf_sg_vrml_field_copy(&eg->orientation, &eg->set_orientation, GF_SG_VRML_MFROTATION); gf_sg_vrml_mf_reset(&eg->set_orientation, GF_SG_VRML_MFROTATION); }
static void ElevationGrid_SetHeight(GF_Node *node, GF_Route *route) { M_ElevationGrid *eg = (M_ElevationGrid *)node; gf_sg_vrml_field_copy(&eg->height, &eg->set_height, GF_SG_VRML_MFFLOAT); gf_sg_vrml_mf_reset(&eg->set_height, GF_SG_VRML_MFFLOAT); }
static void TTD_NewTextChunk(TTDPriv *priv, GF_TextSampleDescriptor *tsd, M_Form *form, u16 *utf16_txt, TTDTextChunk *tc) { GF_Node *txt_model, *n2, *txt_material; M_Text *text; M_FontStyle *fs; char *fontName; char szStyle[1024]; u32 fontSize, styleFlags, color, i, start_char; if (!tc->srec) { fontName = TTD_FindFont(tsd, tsd->default_style.fontID); fontSize = tsd->default_style.font_size; styleFlags = tsd->default_style.style_flags; color = tsd->default_style.text_color; } else { fontName = TTD_FindFont(tsd, tc->srec->fontID); fontSize = tc->srec->font_size; styleFlags = tc->srec->style_flags; color = tc->srec->text_color; } /*create base model for text node. It will then be cloned for each text item*/ txt_model = ttd_create_node(priv, TAG_MPEG4_Shape, NULL); gf_node_register(txt_model, NULL); n2 = ttd_create_node(priv, TAG_MPEG4_Appearance, NULL); ((M_Shape *)txt_model)->appearance = n2; gf_node_register(n2, txt_model); txt_material = ttd_create_node(priv, TAG_MPEG4_Material2D, NULL); ((M_Appearance *)n2)->material = txt_material; gf_node_register(txt_material, n2); ((M_Material2D *)txt_material)->filled = 1; ((M_Material2D *)txt_material)->transparency = FIX_ONE - INT2FIX((color>>24) & 0xFF) / 255; ((M_Material2D *)txt_material)->emissiveColor.red = INT2FIX((color>>16) & 0xFF) / 255; ((M_Material2D *)txt_material)->emissiveColor.green = INT2FIX((color>>8) & 0xFF) / 255; ((M_Material2D *)txt_material)->emissiveColor.blue = INT2FIX((color) & 0xFF) / 255; /*force 0 lineWidth if blinking (the stupid MPEG-4 default values once again..)*/ if (tc->has_blink) { ((M_Material2D *)txt_material)->lineProps = ttd_create_node(priv, TAG_MPEG4_LineProperties, NULL); ((M_LineProperties *)((M_Material2D *)txt_material)->lineProps)->width = 0; gf_node_register(((M_Material2D *)txt_material)->lineProps, txt_material); } n2 = ttd_create_node(priv, TAG_MPEG4_Text, NULL); ((M_Shape *)txt_model)->geometry = n2; gf_node_register(n2, txt_model); text = (M_Text *) n2; fs = (M_FontStyle *) ttd_create_node(priv, TAG_MPEG4_FontStyle, NULL); gf_free(fs->family.vals[0]); /*translate default fonts to MPEG-4/VRML names*/ if (!stricmp(fontName, "Serif")) fs->family.vals[0] = gf_strdup("SERIF"); else if (!stricmp(fontName, "Sans-Serif")) fs->family.vals[0] = gf_strdup("SANS"); else if (!stricmp(fontName, "Monospace")) fs->family.vals[0] = gf_strdup("TYPEWRITER"); else fs->family.vals[0] = gf_strdup(fontName); fs->size = INT2FIX(fontSize); gf_free(fs->style.buffer); strcpy(szStyle, ""); if (styleFlags & GF_TXT_STYLE_BOLD) { if (styleFlags & GF_TXT_STYLE_ITALIC) strcpy(szStyle, "BOLDITALIC"); else strcpy(szStyle, "BOLD"); } else if (styleFlags & GF_TXT_STYLE_ITALIC) strcat(szStyle, "ITALIC"); if (!strlen(szStyle)) strcpy(szStyle, "PLAIN"); /*also underline for URLs*/ if ((styleFlags & GF_TXT_STYLE_UNDERLINED) || (tc->hlink && tc->hlink->URL)) strcat(szStyle, " UNDERLINED"); if (tc->is_hilight) { if (tc->hilight_col) { char szTxt[50]; sprintf(szTxt, " HIGHLIGHT#%x", tc->hilight_col); strcat(szStyle, szTxt); } else { strcat(szStyle, " HIGHLIGHT#RV"); } } /*a better way would be to draw the entire text box in a composite texture & bitmap but we can't really rely on text box size (in MP4Box, it actually defaults to the entire video area) and drawing a too large texture & bitmap could slow down rendering*/ if (priv->use_texture) strcat(szStyle, " TEXTURED"); if (priv->outline) strcat(szStyle, " OUTLINED"); fs->style.buffer = gf_strdup(szStyle); fs->horizontal = (tsd->displayFlags & GF_TXT_VERTICAL) ? 0 : 1; text->fontStyle = (GF_Node *) fs; gf_node_register((GF_Node *)fs, (GF_Node *)text); gf_sg_vrml_mf_reset(&text->string, GF_SG_VRML_MFSTRING); if (tc->hlink && tc->hlink->URL) { SFURL *s; M_Anchor *anc = (M_Anchor *) ttd_create_node(priv, TAG_MPEG4_Anchor, NULL); gf_sg_vrml_mf_append(&anc->url, GF_SG_VRML_MFURL, (void **) &s); s->OD_ID = 0; s->url = gf_strdup(tc->hlink->URL); if (tc->hlink->URL_hint) anc->description.buffer = gf_strdup(tc->hlink->URL_hint); gf_node_list_add_child(& anc->children, txt_model); gf_node_register(txt_model, (GF_Node *)anc); txt_model = (GF_Node *)anc; gf_node_register((GF_Node *)anc, NULL); } start_char = tc->start_char; for (i=tc->start_char; i<tc->end_char; i++) { Bool new_line = 0; if ((utf16_txt[i] == '\n') || (utf16_txt[i] == '\r') || (utf16_txt[i] == 0x85) || (utf16_txt[i] == 0x2028) || (utf16_txt[i] == 0x2029)) new_line = 1; if (new_line || (i+1==tc->end_char) ) { SFString *st; if (i+1==tc->end_char) i++; if (i!=start_char) { char szLine[5000]; u32 len; s16 wsChunk[5000], *sp; /*spliting lines, duplicate node*/ n2 = gf_node_clone(priv->sg, txt_model, NULL, "", 1); if (tc->hlink && tc->hlink->URL) { GF_Node *t = ((M_Anchor *)n2)->children->node; text = (M_Text *) ((M_Shape *)t)->geometry; txt_material = ((M_Appearance *) ((M_Shape *)t)->appearance)->material; } else { text = (M_Text *) ((M_Shape *)n2)->geometry; txt_material = ((M_Appearance *) ((M_Shape *)n2)->appearance)->material; } gf_sg_vrml_mf_reset(&text->string, GF_SG_VRML_MFSTRING); gf_node_list_add_child( &form->children, n2); gf_node_register(n2, (GF_Node *) form); ttd_add_item(form); /*clone node always register by default*/ gf_node_unregister(n2, NULL); if (tc->has_blink && txt_material) gf_list_add(priv->blink_nodes, txt_material); memcpy(wsChunk, &utf16_txt[start_char], sizeof(s16)*(i-start_char)); wsChunk[i-start_char] = 0; sp = &wsChunk[0]; len = gf_utf8_wcstombs(szLine, 5000, (const unsigned short **) &sp); szLine[len] = 0; gf_sg_vrml_mf_append(&text->string, GF_SG_VRML_MFSTRING, (void **) &st); st->buffer = gf_strdup(szLine); } start_char = i+1; if (new_line) { ttd_add_line(form); if ((utf16_txt[i]=='\r') && (utf16_txt[i+1]=='\n')) i++; } } } gf_node_unregister(txt_model, NULL); return; }
void gf_inline_on_modified(GF_Node *node) { u32 ODID; GF_MediaObject *mo; M_Inline *pInline = (M_Inline *) node; GF_Scene *scene = (GF_Scene *)gf_node_get_private(node); ODID = gf_mo_get_od_id(&pInline->url); if (scene) { mo = (scene->root_od) ? scene->root_od->mo : NULL; /*disconnect current inline if we're the last one using it (same as regular OD session leave/join)*/ if (mo) { Bool changed = 1; if (ODID != GF_MEDIA_EXTERNAL_ID) { if (ODID && (ODID==scene->root_od->OD->objectDescriptorID)) changed = 0; } else { if (gf_mo_is_same_url(mo, &pInline->url, NULL, 0) ) changed = 0; } if (mo->num_open) { if (!changed) return; gf_scene_notify_event(scene, GF_EVENT_UNLOAD, node, NULL, GF_OK); gf_node_dirty_parents(node); gf_list_del_item(mo->nodes, node); /*reset the scene pointer as it may get destroyed*/ switch (gf_node_get_tag(node)) { case TAG_MPEG4_Inline: #ifndef GPAC_DISABLE_X3D case TAG_X3D_Inline: #endif gf_node_set_private(node, NULL); break; } mo->num_open --; if (!mo->num_open) { if (ODID == GF_MEDIA_EXTERNAL_ID) { GF_Scene *parent = scene->root_od->parentscene; /*!!! THIS WILL DESTROY THE INLINE SCENE OBJECT !!!*/ gf_odm_disconnect(scene->root_od, 1); /*and force removal of the media object*/ if (parent) { if (gf_list_del_item(parent->scene_objects, mo)>=0) { gf_sg_vrml_mf_reset(&mo->URLs, GF_SG_VRML_MFURL); gf_list_del(mo->nodes); gf_free(mo); } } } else { gf_term_lock_media_queue(scene->root_od->term, 1); /*external media are completely unloaded*/ if (scene->root_od->OD->objectDescriptorID==GF_MEDIA_EXTERNAL_ID) { scene->root_od->action_type = GF_ODM_ACTION_DELETE; } else { scene->root_od->action_type = GF_ODM_ACTION_STOP; } if (gf_list_find(scene->root_od->term->media_queue, scene->root_od)<0) gf_list_add(scene->root_od->term->media_queue, scene->root_od); gf_term_lock_media_queue(scene->root_od->term, 0); } } } } } else { gf_node_dirty_parents(node); } if (ODID) gf_inline_set_scene(pInline); }
static void gf_storage_load(M_Storage *storage) { const char *opt; char szID[20]; u32 i, count; u32 sec, exp, frac; GF_Config *cfg = storage_get_cfg(storage); char *section = storage_get_section(storage); if (!cfg || !section) return; if (!gf_cfg_get_key_count(cfg, section)) { gf_free(section); return; } opt = gf_cfg_get_key(cfg, section, "expireAfterNTP"); gf_net_get_ntp(&sec, &frac); sscanf(opt, "%u", &exp); if (exp && (exp<=sec)) { gf_cfg_del_section(cfg, section); gf_free(section); return; } count = gf_cfg_get_key_count(cfg, section)-1; if (!count || (count!=storage->storageList.count)) { gf_cfg_del_section(cfg, section); gf_free(section); return; } for (i=0; i<count; i++) { GF_FieldInfo info; sprintf(szID, "%d", i); opt = gf_cfg_get_key(cfg, section, szID); if (!opt) break; if (!storage->storageList.vals[i].node) break; if (gf_node_get_field(storage->storageList.vals[i].node, storage->storageList.vals[i].fieldIndex, &info) != GF_OK) break; if (gf_sg_vrml_is_sf_field(info.fieldType)) { storage_parse_sf(info.far_ptr, info.fieldType, (char *) opt); } else { u32 sftype = gf_sg_vrml_get_sf_type(info.fieldType); char *sep, *val; void *slot; gf_sg_vrml_mf_reset(info.far_ptr, info.fieldType); while (1) { val = strchr(opt, '\''); sep = val ? strchr(val+1, '\'') : NULL; if (!val || !sep) break; sep[0] = 0; gf_sg_vrml_mf_append(info.far_ptr, info.fieldType, &slot); storage_parse_sf(slot, sftype, val+1); sep[0] = '\''; opt = sep+1; } } gf_node_changed(storage->storageList.vals[i].node, &info); } gf_free(section); }
static void gf_inline_traverse(GF_Node *n, void *rs, Bool is_destroy) { MFURL *current_url; GF_Scene *scene = (GF_Scene *)gf_node_get_private(n); if (is_destroy) { GF_MediaObject *mo; if (!scene) return; mo = scene->root_od ? scene->root_od->mo : NULL; gf_scene_notify_event(scene, GF_EVENT_UNLOAD, n, NULL, GF_OK); if (!mo) return; gf_list_del_item(mo->nodes, n); /*disconnect current inline if we're the last one using it (same as regular OD session leave/join)*/ if (mo->num_open) { mo->num_open --; if (!mo->num_open) { gf_term_lock_media_queue(scene->root_od->term, 1); /*this is unspecified in the spec: whenever an inline not using the OD framework is destroyed, destroy the associated resource*/ if (mo->OD_ID == GF_MEDIA_EXTERNAL_ID) { /*get parent scene and remove MediaObject in case the ressource gets re-requested later on*/ GF_Scene *parent_scene = (GF_Scene *)gf_sg_get_private(gf_node_get_graph((GF_Node *) n) ); if (gf_list_del_item(parent_scene->scene_objects, mo)>=0) { gf_sg_vrml_mf_reset(&mo->URLs, GF_SG_VRML_MFURL); gf_list_del(mo->nodes); if (mo->odm) mo->odm->mo = NULL; gf_free(mo); } scene->root_od->action_type = GF_ODM_ACTION_DELETE; gf_list_add(scene->root_od->term->media_queue, scene->root_od); } else { scene->root_od->action_type = GF_ODM_ACTION_SCENE_DISCONNECT; gf_list_add(scene->root_od->term->media_queue, scene->root_od); } gf_term_lock_media_queue(scene->root_od->term, 0); } } return; } //if no private scene is associated get the node parent graph, retrieve the IS and find the OD if (!scene) { M_Inline *inl = (M_Inline *)n; gf_inline_set_scene(inl); scene = (GF_Scene *)gf_node_get_private(n); if (!scene) { /*just like protos, we must invalidate parent graph until attached*/ if (inl->url.count) { if (!inl->url.vals[0].OD_ID && (!inl->url.vals[0].url || !strlen(inl->url.vals[0].url) ) ) { gf_sg_vrml_mf_reset(&inl->url, GF_SG_VRML_MFURL); } else { gf_node_dirty_set(n, 0, 1); } } return; } } gf_inline_check_restart(scene); /*if we need to restart, shutdown graph and do it*/ if (scene->needs_restart) { /*special case: scene change*/ if (scene->needs_restart==2) { scene->needs_restart = 0; gf_inline_on_modified(n); return; } scene->needs_restart = 0; gf_term_lock_media_queue(scene->root_od->term, 1); scene->root_od->action_type = GF_ODM_ACTION_SCENE_INLINE_RESTART; gf_list_add(scene->root_od->term->media_queue, scene->root_od); gf_term_lock_media_queue(scene->root_od->term, 0); gf_node_dirty_set(n, 0, 1); return; } /*if not attached return (attaching the graph cannot be done in render since render is not called while unattached :) */ if (!scene->graph_attached) { /*just like protos, we must invalidate parent graph until attached*/ gf_node_dirty_set(n, 0, 1); return; } /*clear dirty flags for any sub-inlines, bitmaps or protos*/ gf_node_dirty_clear(n, 0); current_url = scene->current_url; scene->current_url = & ((M_Inline*)n)->url; gf_sc_traverse_subscene(scene->root_od->term->compositor, n, scene->graph, rs); scene->current_url = current_url; }
GF_EXPORT GF_Err gf_sg_command_apply(GF_SceneGraph *graph, GF_Command *com, Double time_offset) { GF_Err e; GF_CommandField *inf; GF_FieldInfo field; GF_Node *def, *node; void *slot_ptr; if (!com || !graph) return GF_BAD_PARAM; e = GF_OK; switch (com->tag) { case GF_SG_SCENE_REPLACE: /*unregister root*/ gf_node_unregister(graph->RootNode, NULL); /*remove all protos and routes*/ while (gf_list_count(graph->routes_to_activate)) gf_list_rem(graph->routes_to_activate, 0); /*destroy all routes*/ while (gf_list_count(graph->Routes)) { GF_Route *r = (GF_Route *)gf_list_get(graph->Routes, 0); /*this will unregister the route from the graph, so don't delete the chain entry*/ gf_sg_route_del(r); } /*destroy all proto*/ while (gf_list_count(graph->protos)) { GF_Proto *p = (GF_Proto*)gf_list_get(graph->protos, 0); /*this will unregister the proto from the graph, so don't delete the chain entry*/ gf_sg_proto_del(p); } /*DO NOT TOUCH node registry*/ /*DO NOT TOUCH UNREGISTERED PROTOS*/ /*move all protos in graph*/ while (gf_list_count(com->new_proto_list)) { GF_Proto *p = (GF_Proto*)gf_list_get(com->new_proto_list, 0); gf_list_rem(com->new_proto_list, 0); gf_list_del_item(graph->unregistered_protos, p); gf_list_add(graph->protos, p); } /*assign new root (no need to register/unregister)*/ graph->RootNode = com->node; com->node = NULL; break; case GF_SG_NODE_REPLACE: if (!gf_list_count(com->command_fields)) return GF_OK; inf = (GF_CommandField*)gf_list_get(com->command_fields, 0); e = gf_node_replace(com->node, inf->new_node, 0); if (inf->new_node) gf_node_register(inf->new_node, NULL); break; case GF_SG_MULTIPLE_REPLACE: case GF_SG_FIELD_REPLACE: { u32 j; GF_ChildNodeItem *list, *cur, *prev; j=0; while ((inf = (GF_CommandField*)gf_list_enum(com->command_fields, &j))) { e = gf_node_get_field(com->node, inf->fieldIndex, &field); if (e) return e; switch (field.fieldType) { case GF_SG_VRML_SFNODE: { node = *((GF_Node **) field.far_ptr); e = gf_node_unregister(node, com->node); *((GF_Node **) field.far_ptr) = inf->new_node; if (!e) gf_node_register(inf->new_node, com->node); break; } case GF_SG_VRML_MFNODE: gf_node_unregister_children(com->node, * ((GF_ChildNodeItem **) field.far_ptr)); * ((GF_ChildNodeItem **) field.far_ptr) = NULL; list = * ((GF_ChildNodeItem **) inf->field_ptr); prev=NULL; while (list) { cur = malloc(sizeof(GF_ChildNodeItem)); cur->next = NULL; cur->node = list->node; if (prev) { prev->next = cur; } else { * ((GF_ChildNodeItem **) field.far_ptr) = cur; } gf_node_register(list->node, com->node); prev = cur; list = list->next; } break; default: /*this is a regular field, reset it and clone - we cannot switch pointers since the original fields are NOT pointers*/ if (!gf_sg_vrml_is_sf_field(field.fieldType)) { e = gf_sg_vrml_mf_reset(field.far_ptr, field.fieldType); } if (e) return e; gf_sg_vrml_field_copy(field.far_ptr, inf->field_ptr, field.fieldType); if (field.fieldType==GF_SG_VRML_SFTIME) *(SFTime *)field.far_ptr = *(SFTime *)field.far_ptr + time_offset; break; } SG_CheckFieldChange(com->node, &field); } break; } case GF_SG_MULTIPLE_INDEXED_REPLACE: case GF_SG_INDEXED_REPLACE: { u32 sftype, i=0; while ((inf = (GF_CommandField*)gf_list_enum(com->command_fields, &i))) { e = gf_node_get_field(com->node, inf->fieldIndex, &field); if (e) return e; /*if MFNode remove the child and set new node*/ if (field.fieldType == GF_SG_VRML_MFNODE) { /*we must remove the node before in case the new node uses the same ID (not forbidden) and this command removes the last instance of the node with the same ID*/ gf_node_replace_child(com->node, (GF_ChildNodeItem**) field.far_ptr, inf->pos, inf->new_node); if (inf->new_node) gf_node_register(inf->new_node, NULL); } /*erase the field item*/ else { if ((inf->pos < 0) || ((u32) inf->pos >= ((GenMFField *) field.far_ptr)->count) ) { inf->pos = ((GenMFField *)field.far_ptr)->count - 1; /*may happen with text and default value*/ if (inf->pos < 0) { inf->pos = 0; gf_sg_vrml_mf_alloc(field.far_ptr, field.fieldType, 1); } } e = gf_sg_vrml_mf_get_item(field.far_ptr, field.fieldType, & slot_ptr, inf->pos); if (e) return e; sftype = gf_sg_vrml_get_sf_type(field.fieldType); gf_sg_vrml_field_copy(slot_ptr, inf->field_ptr, sftype); /*note we don't add time offset, since there's no MFTime*/ } SG_CheckFieldChange(com->node, &field); } break; } case GF_SG_ROUTE_REPLACE: { GF_Route *r; char *name; r = gf_sg_route_find(graph, com->RouteID); def = gf_sg_find_node(graph, com->fromNodeID); node = gf_sg_find_node(graph, com->toNodeID); if (!node || !def) return GF_SG_UNKNOWN_NODE; name = NULL; if (r) { name = r->name; r->name = NULL; gf_sg_route_del(r); } r = gf_sg_route_new(graph, def, com->fromFieldIndex, node, com->toFieldIndex); gf_sg_route_set_id(r, com->RouteID); if (name) { gf_sg_route_set_name(r, name); free(name); } break; } case GF_SG_NODE_DELETE_EX: case GF_SG_NODE_DELETE: { if (com->node) gf_node_replace(com->node, NULL, (com->tag==GF_SG_NODE_DELETE_EX) ? 1 : 0); break; } case GF_SG_ROUTE_DELETE: { return gf_sg_route_del_by_id(graph, com->RouteID); } case GF_SG_INDEXED_DELETE: { if (!gf_list_count(com->command_fields)) return GF_OK; inf = (GF_CommandField*)gf_list_get(com->command_fields, 0); e = gf_node_get_field(com->node, inf->fieldIndex, &field); if (e) return e; if (gf_sg_vrml_is_sf_field(field.fieldType)) return GF_NON_COMPLIANT_BITSTREAM; /*then we need special handling in case of a node*/ if (gf_sg_vrml_get_sf_type(field.fieldType) == GF_SG_VRML_SFNODE) { e = gf_node_replace_child(com->node, (GF_ChildNodeItem **) field.far_ptr, inf->pos, NULL); } else { if ((inf->pos < 0) || ((u32) inf->pos >= ((GenMFField *) field.far_ptr)->count) ) { inf->pos = ((GenMFField *)field.far_ptr)->count - 1; } /*this is a regular MFField, just remove the item (realloc)*/ e = gf_sg_vrml_mf_remove(field.far_ptr, field.fieldType, inf->pos); } /*deletion -> node has changed*/ if (!e) SG_CheckFieldChange(com->node, &field); break; } case GF_SG_NODE_INSERT: { if (!gf_list_count(com->command_fields)) return GF_OK; inf = (GF_CommandField*)gf_list_get(com->command_fields, 0); e = gf_node_insert_child(com->node, inf->new_node, inf->pos); if (!e) gf_node_register(inf->new_node, com->node); if (!e) gf_node_event_out(com->node, inf->fieldIndex); if (!e) gf_node_changed(com->node, NULL); break; } case GF_SG_ROUTE_INSERT: { GF_Route *r; def = gf_sg_find_node(graph, com->fromNodeID); node = gf_sg_find_node(graph, com->toNodeID); if (!node || !def) return GF_SG_UNKNOWN_NODE; r = gf_sg_route_new(graph, def, com->fromFieldIndex, node, com->toFieldIndex); if (com->RouteID) gf_sg_route_set_id(r, com->RouteID); if (com->def_name) { gf_sg_route_set_name(r, com->def_name); free(com->def_name); com->def_name = NULL; } break; } case GF_SG_INDEXED_INSERT: { u32 sftype; if (!gf_list_count(com->command_fields)) return GF_OK; inf = (GF_CommandField*)gf_list_get(com->command_fields, 0); e = gf_node_get_field(com->node, inf->fieldIndex, &field); if (e) return e; /*rescale the MFField and parse the SFField*/ if (field.fieldType != GF_SG_VRML_MFNODE) { if (inf->pos == -1) { e = gf_sg_vrml_mf_append(field.far_ptr, field.fieldType, & slot_ptr); } else { e = gf_sg_vrml_mf_insert(field.far_ptr, field.fieldType, & slot_ptr, inf->pos); } if (e) return e; sftype = gf_sg_vrml_get_sf_type(field.fieldType); gf_sg_vrml_field_copy(slot_ptr, inf->field_ptr, sftype); } else { if (inf->new_node) { if (inf->pos == -1) { gf_node_list_add_child( (GF_ChildNodeItem **) field.far_ptr, inf->new_node); } else { gf_node_list_insert_child((GF_ChildNodeItem **) field.far_ptr, inf->new_node, inf->pos); } gf_node_register(inf->new_node, com->node); } } if (!e) SG_CheckFieldChange(com->node, &field); break; } case GF_SG_PROTO_INSERT: /*destroy all proto*/ while (gf_list_count(com->new_proto_list)) { GF_Proto *p = (GF_Proto*)gf_list_get(com->new_proto_list, 0); gf_list_rem(com->new_proto_list, 0); gf_list_del_item(graph->unregistered_protos, p); gf_list_add(graph->protos, p); } return GF_OK; case GF_SG_PROTO_DELETE: { u32 i; for (i=0; i<com->del_proto_list_size; i++) { /*note this will check for unregistered protos, but since IDs are unique we are sure we will not destroy an unregistered one*/ GF_Proto *proto = gf_sg_find_proto(graph, com->del_proto_list[i], NULL); if (proto) gf_sg_proto_del(proto); } } return GF_OK; case GF_SG_PROTO_DELETE_ALL: /*destroy all proto*/ while (gf_list_count(graph->protos)) { GF_Proto *p = (GF_Proto*)gf_list_get(graph->protos, 0); gf_list_rem(graph->protos, 0); /*this will unregister the proto from the graph, so don't delete the chain entry*/ gf_sg_proto_del(p); } /*DO NOT TOUCH UNREGISTERED PROTOS*/ return GF_OK; /*only used by BIFS*/ case GF_SG_GLOBAL_QUANTIZER: return GF_OK; #ifndef GPAC_DISABLE_SVG /*laser commands*/ case GF_SG_LSR_NEW_SCENE: /*DO NOT TOUCH node registry*/ /*assign new root (no need to register/unregister)*/ graph->RootNode = com->node; com->node = NULL; break; case GF_SG_LSR_DELETE: if (!com->node) return GF_NON_COMPLIANT_BITSTREAM; if (!gf_list_count(com->command_fields)) { gf_node_replace(com->node, NULL, 0); gf_node_deactivate(com->node); return GF_OK; } inf = (GF_CommandField*)gf_list_get(com->command_fields, 0); node = gf_node_list_get_child(((SVG_Element *)com->node)->children, inf->pos); if (node) { e = gf_node_replace_child(com->node, &((SVG_Element *)com->node)->children, inf->pos, NULL); gf_node_deactivate(node); } break; case GF_SG_LSR_INSERT: inf = (GF_CommandField*)gf_list_get(com->command_fields, 0); if (!com->node || !inf) return GF_NON_COMPLIANT_BITSTREAM; if (inf->new_node) { if (inf->pos<0) gf_node_list_add_child(& ((SVG_Element *)com->node)->children, inf->new_node); else gf_node_list_insert_child(& ((SVG_Element *)com->node)->children, inf->new_node, inf->pos); gf_node_register(inf->new_node, com->node); gf_node_activate(inf->new_node); gf_node_changed(com->node, NULL); } else { /*NOT SUPPORTED*/ GF_LOG(GF_LOG_ERROR, GF_LOG_CODEC, ("[LASeR] VALUE INSERTION NOT SUPPORTED\n")); } break; case GF_SG_LSR_ADD: case GF_SG_LSR_REPLACE: inf = (GF_CommandField*)gf_list_get(com->command_fields, 0); if (!com->node || !inf) return GF_NON_COMPLIANT_BITSTREAM; if (inf->new_node) { if (inf->pos<0) { /*if fieldIndex (eg attributeName) is set, this is children replacement*/ if (inf->fieldIndex>0) { gf_node_unregister_children_deactivate(com->node, ((SVG_Element *)com->node)->children); ((SVG_Element *)com->node)->children = NULL; gf_node_list_add_child(& ((SVG_Element *)com->node)->children, inf->new_node); gf_node_register(inf->new_node, com->node); gf_node_activate(inf->new_node); } else { e = gf_node_replace(com->node, inf->new_node, 0); gf_node_activate(inf->new_node); } } else { node = gf_node_list_get_child( ((SVG_Element *)com->node)->children, inf->pos); gf_node_replace_child(com->node, & ((SVG_Element *)com->node)->children, inf->pos, inf->new_node); gf_node_register(inf->new_node, com->node); if (node) gf_node_deactivate(node); gf_node_activate(inf->new_node); } /*signal node modif*/ gf_node_changed(com->node, NULL); return e; } else if (inf->node_list) { GF_ChildNodeItem *child, *cur, *prev; gf_node_unregister_children_deactivate(com->node, ((SVG_Element *)com->node)->children); ((SVG_Element *)com->node)->children = NULL; prev = NULL; child = inf->node_list; while (child) { cur = (GF_ChildNodeItem*)malloc(sizeof(GF_ChildNodeItem)); cur->next = NULL; cur->node = child->node; gf_node_register(child->node, com->node); gf_node_activate(child->node); if (prev) prev->next = cur; else ((SVG_Element *)com->node)->children = cur; prev = cur; child = child->next; } /*signal node modif*/ gf_node_changed(com->node, NULL); return GF_OK; } /*attribute modif*/ else if (inf->field_ptr) { GF_FieldInfo a, b; if (inf->fieldIndex==(u32) -2) { GF_Point2D scale, translate; Fixed rotate; GF_Matrix2D *dest; gf_node_get_field_by_name(com->node, "transform", &a); dest = (GF_Matrix2D*)a.far_ptr; if (com->tag==GF_SG_LSR_REPLACE) { if (gf_mx2d_decompose(dest, &scale, &rotate, &translate)) { gf_mx2d_init(*dest); if (inf->fieldType==SVG_TRANSFORM_SCALE) scale = *(GF_Point2D *)inf->field_ptr; else if (inf->fieldType==SVG_TRANSFORM_TRANSLATE) translate = *(GF_Point2D *)inf->field_ptr; else if (inf->fieldType==SVG_TRANSFORM_ROTATE) rotate = ((SVG_Point_Angle*)inf->field_ptr)->angle; gf_mx2d_add_scale(dest, scale.x, scale.y); gf_mx2d_add_rotation(dest, 0, 0, rotate); gf_mx2d_add_translation(dest, translate.x, translate.y); } } else { GF_Point2D *pt = (GF_Point2D *)inf->field_ptr; if (inf->fieldType==SVG_TRANSFORM_SCALE) gf_mx2d_add_scale(dest, pt->x, pt->y); else if (inf->fieldType==SVG_TRANSFORM_TRANSLATE) gf_mx2d_add_translation(dest, pt->x, pt->y); else if (inf->fieldType == SVG_TRANSFORM_ROTATE) gf_mx2d_add_rotation(dest, 0, 0, ((SVG_Point_Angle*)inf->field_ptr)->angle); } } else { if ((inf->fieldIndex==(u32) -1) && (inf->fieldType==SVG_String_datatype)) { char *str = *(SVG_String*)inf->field_ptr; if (com->tag == GF_SG_LSR_REPLACE) { GF_DOMText *t = ((SVG_Element*)com->node)->children ? (GF_DOMText*) ((SVG_Element*)com->node)->children->node :NULL; if (t && (t->sgprivate->tag==TAG_DOMText)) { if (t->textContent) free(t->textContent); t->textContent = NULL; if (str) t->textContent = strdup(str); } } else { if (str) gf_dom_add_text_node(com->node, strdup(str)); } } else if ((inf->fieldIndex==TAG_LSR_ATT_scale) || (inf->fieldIndex==TAG_LSR_ATT_translation) || (inf->fieldIndex==TAG_LSR_ATT_rotation) ) { SVG_Transform *mx; gf_svg_get_attribute_by_tag(com->node, TAG_SVG_ATT_transform, 1, 0, &a); mx = a.far_ptr; if (com->tag == GF_SG_LSR_REPLACE) { GF_Point2D scale, translate; SVG_Point_Angle rotate; if (gf_mx2d_decompose(&mx->mat, &scale, &rotate.angle, &translate)) { gf_mx2d_init(mx->mat); if (inf->fieldIndex==TAG_LSR_ATT_scale) scale = *(GF_Point2D *)inf->field_ptr; else if (inf->fieldIndex==TAG_LSR_ATT_translation) translate = *(GF_Point2D *)inf->field_ptr; else if (inf->fieldIndex==TAG_LSR_ATT_rotation) rotate = *(SVG_Point_Angle*)inf->field_ptr; gf_mx2d_add_scale(&mx->mat, scale.x, scale.y); gf_mx2d_add_rotation(&mx->mat, 0, 0, rotate.angle); gf_mx2d_add_translation(&mx->mat, translate.x, translate.y); } } else { if (inf->fieldIndex==TAG_LSR_ATT_scale) gf_mx2d_add_scale(&mx->mat, ((GF_Point2D*)inf->field_ptr)->x, ((GF_Point2D*)inf->field_ptr)->y); if (inf->fieldIndex==TAG_LSR_ATT_translation) gf_mx2d_add_translation(&mx->mat, ((GF_Point2D*)inf->field_ptr)->x, ((GF_Point2D*)inf->field_ptr)->y); if (inf->fieldIndex==TAG_LSR_ATT_rotation) gf_mx2d_add_rotation(&mx->mat, 0, 0, ((SVG_Point_Angle*)inf->field_ptr)->angle); } } else if (gf_svg_get_attribute_by_tag(com->node, inf->fieldIndex, 1, 0, &a) == GF_OK) { b = a; b.far_ptr = inf->field_ptr; if (com->tag == GF_SG_LSR_REPLACE) { gf_svg_attributes_copy(&a, &b, 0); } else { gf_svg_attributes_add(&a, &b, &a, 0); } } b = a; b.far_ptr = inf->field_ptr; } /*signal node modif*/ gf_node_changed(com->node, &a); } else if (com->fromNodeID) { GF_FieldInfo a, b; GF_Node *fromNode = gf_sg_find_node(graph, com->fromNodeID); if (!fromNode) return GF_NON_COMPLIANT_BITSTREAM; if (gf_node_get_field(fromNode, com->fromFieldIndex, &b) != GF_OK) return GF_NON_COMPLIANT_BITSTREAM; if ((inf->fieldIndex==(u32) -1) && (inf->fieldType==SVG_String_datatype)) { char *str = *(SVG_String*)inf->field_ptr; if (com->tag == GF_SG_LSR_REPLACE) { GF_DOMText *t = ((SVG_Element*)com->node)->children ? (GF_DOMText*) ((SVG_Element*)com->node)->children->node :NULL; if (t && (t->sgprivate->tag==TAG_DOMText)) { if (t->textContent) free(t->textContent); t->textContent = NULL; if (str) t->textContent = strdup(str); } } else { if (str) gf_dom_add_text_node(com->node, strdup(str)); } } else { gf_node_get_field(com->node, inf->fieldIndex, &a); if (com->tag == GF_SG_LSR_REPLACE) { e = gf_svg_attributes_copy(&a, &b, 0); } else { e = gf_svg_attributes_add(&a, &b, &a, 0); } } gf_node_changed(com->node, &a); return e; } else { return GF_NON_COMPLIANT_BITSTREAM; } break; case GF_SG_LSR_ACTIVATE: gf_node_activate(com->node); break; case GF_SG_LSR_DEACTIVATE: gf_node_deactivate(com->node); gf_node_changed(com->node, NULL); break; #endif default: return GF_NOT_SUPPORTED; } if (e) return e; if (com->scripts_to_load) { while (gf_list_count(com->scripts_to_load)) { GF_Node *script = (GF_Node *)gf_list_get(com->scripts_to_load, 0); gf_list_rem(com->scripts_to_load, 0); gf_sg_script_load(script); } gf_list_del(com->scripts_to_load); com->scripts_to_load = NULL; } return GF_OK; }
static void ITSS_SetIndex(GF_Node *node, GF_Route *route) { X_IndexedTriangleStripSet *itss = (X_IndexedTriangleStripSet*)node; gf_sg_vrml_field_copy(&itss->index, &itss->set_index, GF_SG_VRML_MFINT32); gf_sg_vrml_mf_reset(&itss->set_index, GF_SG_VRML_MFINT32); }
static void IFS_SetTexCoordIndex(GF_Node *node, GF_Route *route) { M_IndexedFaceSet *ifs = (M_IndexedFaceSet *)node; gf_sg_vrml_field_copy(&ifs->texCoordIndex, &ifs->set_texCoordIndex, GF_SG_VRML_MFINT32); gf_sg_vrml_mf_reset(&ifs->set_texCoordIndex, GF_SG_VRML_MFINT32); }
static void ILS_SetCoordIndex(GF_Node *node, GF_Route *route) { M_IndexedLineSet *ils = (M_IndexedLineSet *)node; gf_sg_vrml_field_copy(&ils->coordIndex, &ils->set_coordIndex, GF_SG_VRML_MFINT32); gf_sg_vrml_mf_reset(&ils->set_coordIndex, GF_SG_VRML_MFINT32); }
static void TraversePlanarExtrusion(GF_Node *node, void *rs, Bool is_destroy) { PlanarExtrusion plane_ext; Drawable *stack_2d; u32 i, j, k; MFVec3f spine_vec; SFVec3f d; Fixed spine_len; GF_Rect bounds; GF_Path *geo, *spine; GF_TraverseState *tr_state = (GF_TraverseState *)rs; Drawable3D *stack = (Drawable3D *)gf_node_get_private(node); if (is_destroy) { drawable_3d_del(node); return; } if (!PlanarExtrusion_GetNode(node, &plane_ext)) return; if (!plane_ext.geometry || !plane_ext.spine) return; if (gf_node_dirty_get(node)) { u32 cur, nb_pts; u32 mode = tr_state->traversing_mode; geo = spine = NULL; tr_state->traversing_mode = TRAVERSE_GET_BOUNDS; gf_node_traverse(plane_ext.geometry, tr_state); gf_node_traverse(plane_ext.spine, tr_state); tr_state->traversing_mode = mode; switch (gf_node_get_tag(plane_ext.geometry) ) { case TAG_MPEG4_Circle: case TAG_MPEG4_Ellipse: case TAG_MPEG4_Rectangle: case TAG_MPEG4_Curve2D: case TAG_MPEG4_XCurve2D: case TAG_MPEG4_IndexedFaceSet2D: case TAG_MPEG4_IndexedLineSet2D: stack_2d = (Drawable*)gf_node_get_private(plane_ext.geometry); if (stack_2d) geo = stack_2d->path; break; default: return; } switch (gf_node_get_tag(plane_ext.spine) ) { case TAG_MPEG4_Circle: case TAG_MPEG4_Ellipse: case TAG_MPEG4_Rectangle: case TAG_MPEG4_Curve2D: case TAG_MPEG4_XCurve2D: case TAG_MPEG4_IndexedFaceSet2D: case TAG_MPEG4_IndexedLineSet2D: stack_2d = (Drawable*)gf_node_get_private(plane_ext.spine); if (stack_2d) spine = stack_2d->path; break; default: return; } if (!geo || !spine) return; mesh_reset(stack->mesh); gf_path_flatten(spine); gf_path_get_bounds(spine, &bounds); gf_path_flatten(geo); gf_path_get_bounds(geo, &bounds); cur = 0; for (i=0; i<spine->n_contours; i++) { nb_pts = 1 + spine->contours[i] - cur; spine_vec.vals = NULL; gf_sg_vrml_mf_alloc(&spine_vec, GF_SG_VRML_MFVEC3F, nb_pts); spine_len = 0; for (j=cur; j<nb_pts; j++) { spine_vec.vals[j].x = spine->points[j].x; spine_vec.vals[j].y = spine->points[j].y; spine_vec.vals[j].z = 0; if (j) { gf_vec_diff(d, spine_vec.vals[j], spine_vec.vals[j-1]); spine_len += gf_vec_len(d); } } cur += nb_pts; if (!plane_ext.orientation->count && !plane_ext.scale->count) { mesh_extrude_path_ext(stack->mesh, geo, &spine_vec, plane_ext.creaseAngle, bounds.x, bounds.y-bounds.height, bounds.width, bounds.height, plane_ext.beginCap, plane_ext.endCap, NULL, NULL, plane_ext.txAlongSpine); } /*interpolate orientation and scale along subpath line*/ else { MFRotation ori; MFVec2f scale; Fixed cur_len, frac; ori.vals = NULL; gf_sg_vrml_mf_alloc(&ori, GF_SG_VRML_MFROTATION, nb_pts); scale.vals = NULL; gf_sg_vrml_mf_alloc(&scale, GF_SG_VRML_MFVEC2F, nb_pts); cur_len = 0; if (!plane_ext.orientation->count) ori.vals[0].y = FIX_ONE; if (!plane_ext.scale->count) scale.vals[0].x = scale.vals[0].y = FIX_ONE; for (j=0; j<nb_pts; j++) { if (j) { gf_vec_diff(d, spine_vec.vals[j], spine_vec.vals[j-1]); cur_len += gf_vec_len(d); ori.vals[j] = ori.vals[j-1]; scale.vals[j] = scale.vals[j-1]; } if (plane_ext.orientation->count && (plane_ext.orientation->count == plane_ext.orientationKeys->count)) { frac = gf_divfix(cur_len , spine_len); if (frac < plane_ext.orientationKeys->vals[0]) ori.vals[j] = plane_ext.orientation->vals[0]; else if (frac >= plane_ext.orientationKeys->vals[plane_ext.orientationKeys->count-1]) ori.vals[j] = plane_ext.orientation->vals[plane_ext.orientationKeys->count-1]; else { for (k=1; k<plane_ext.orientationKeys->count; k++) { Fixed kDiff = plane_ext.orientationKeys->vals[k] - plane_ext.orientationKeys->vals[k-1]; if (!kDiff) continue; if (frac < plane_ext.orientationKeys->vals[k-1]) continue; if (frac > plane_ext.orientationKeys->vals[k]) continue; frac = gf_divfix(frac - plane_ext.orientationKeys->vals[k-1], kDiff); break; } ori.vals[j] = gf_sg_sfrotation_interpolate(plane_ext.orientation->vals[k-1], plane_ext.orientation->vals[k], frac); } } if (plane_ext.scale->count == plane_ext.scaleKeys->count) { frac = gf_divfix(cur_len , spine_len); if (frac <= plane_ext.scaleKeys->vals[0]) scale.vals[j] = plane_ext.scale->vals[0]; else if (frac >= plane_ext.scaleKeys->vals[plane_ext.scaleKeys->count-1]) scale.vals[j] = plane_ext.scale->vals[plane_ext.scale->count-1]; else { for (k=1; k<plane_ext.scaleKeys->count; k++) { Fixed kDiff = plane_ext.scaleKeys->vals[k] - plane_ext.scaleKeys->vals[k-1]; if (!kDiff) continue; if (frac < plane_ext.scaleKeys->vals[k-1]) continue; if (frac > plane_ext.scaleKeys->vals[k]) continue; frac = gf_divfix(frac - plane_ext.scaleKeys->vals[k-1], kDiff); break; } scale.vals[j].x = gf_mulfix(plane_ext.scale->vals[k].x - plane_ext.scale->vals[k-1].x, frac) + plane_ext.scale->vals[k-1].x; scale.vals[j].y = gf_mulfix(plane_ext.scale->vals[k].y - plane_ext.scale->vals[k-1].y, frac) + plane_ext.scale->vals[k-1].y; } } } mesh_extrude_path_ext(stack->mesh, geo, &spine_vec, plane_ext.creaseAngle, bounds.x, bounds.y-bounds.height, bounds.width, bounds.height, plane_ext.beginCap, plane_ext.endCap, &ori, &scale, plane_ext.txAlongSpine); gf_sg_vrml_mf_reset(&ori, GF_SG_VRML_MFROTATION); gf_sg_vrml_mf_reset(&scale, GF_SG_VRML_MFVEC2F); } gf_sg_vrml_mf_reset(&spine_vec, GF_SG_VRML_MFVEC3F); } mesh_update_bounds(stack->mesh); gf_mesh_build_aabbtree(stack->mesh); } if (tr_state->traversing_mode==TRAVERSE_DRAW_3D) { visual_3d_draw(tr_state, stack->mesh); } else if (tr_state->traversing_mode==TRAVERSE_GET_BOUNDS) { tr_state->bbox = stack->mesh->bounds; } }
static void Extrusion_SetCrossSection(GF_Node *node, GF_Route *route) { M_Extrusion *eg = (M_Extrusion *)node; gf_sg_vrml_field_copy(&eg->crossSection, &eg->set_crossSection, GF_SG_VRML_MFVEC2F); gf_sg_vrml_mf_reset(&eg->set_crossSection, GF_SG_VRML_MFVEC2F); }
/*import cubic QTVR to mp4*/ GF_Err gf_sm_load_init_qt(GF_SceneLoader *load) { u32 i, di, w, h, tk, nb_samp; Bool has_qtvr; GF_ISOSample *samp; GF_ISOFile *src; GF_StreamContext *st; GF_AUContext *au; GF_Command *com; M_Background *back; M_NavigationInfo *ni; M_Group *gr; GF_ODUpdate *odU; GF_SceneGraph *sg; GF_ObjectDescriptor *od; GF_ESD *esd; if (!load->ctx) return GF_NOT_SUPPORTED; src = gf_isom_open(load->fileName, GF_ISOM_OPEN_READ, NULL); if (!src) return gf_qt_report(load, GF_URL_ERROR, "Opening file %s failed", load->fileName); w = h = tk = 0; nb_samp = 0; has_qtvr = 0; for (i=0; i<gf_isom_get_track_count(src); i++) { switch (gf_isom_get_media_type(src, i+1)) { case GF_ISOM_MEDIA_VISUAL: if (gf_isom_get_media_subtype(src, i+1, 1) == GF_4CC('j', 'p', 'e', 'g')) { GF_GenericSampleDescription *udesc = gf_isom_get_generic_sample_description(src, i+1, 1); if ((udesc->width>w) || (udesc->height>h)) { w = udesc->width; h = udesc->height; tk = i+1; nb_samp = gf_isom_get_sample_count(src, i+1); } if (udesc->extension_buf) gf_free(udesc->extension_buf); gf_free(udesc); } break; case GF_4CC('q','t','v','r'): has_qtvr = 1; break; } } if (!has_qtvr) { gf_isom_delete(src); return gf_qt_report(load, GF_NOT_SUPPORTED, "QTVR not found - no conversion available for this QuickTime movie"); } if (!tk) { gf_isom_delete(src); return gf_qt_report(load, GF_NON_COMPLIANT_BITSTREAM, "No associated visual track with QTVR movie"); } if (nb_samp!=6) { gf_isom_delete(src); return gf_qt_report(load, GF_NOT_SUPPORTED, "Movie %s doesn't look a Cubic QTVR - sorry...", load->fileName); } GF_LOG(GF_LOG_INFO, GF_LOG_PARSER, ("QT: Importing Cubic QTVR Movie")); /*create scene*/ sg = load->ctx->scene_graph; gr = (M_Group *) gf_node_new(sg, TAG_MPEG4_Group); gf_node_register((GF_Node *)gr, NULL); st = gf_sm_stream_new(load->ctx, 1, GF_STREAM_SCENE, 1); au = gf_sm_stream_au_new(st, 0, 0, 1); com = gf_sg_command_new(load->ctx->scene_graph, GF_SG_SCENE_REPLACE); gf_list_add(au->commands, com); com->node = (GF_Node *)gr; back = (M_Background *) gf_node_new(sg, TAG_MPEG4_Background); gf_node_list_add_child( &gr->children, (GF_Node*)back); gf_node_register((GF_Node *)back, (GF_Node *)gr); gf_sg_vrml_mf_alloc(&back->leftUrl, GF_SG_VRML_MFURL, 1); back->leftUrl.vals[0].OD_ID = 2; gf_sg_vrml_mf_alloc(&back->frontUrl, GF_SG_VRML_MFURL, 1); back->frontUrl.vals[0].OD_ID = 3; gf_sg_vrml_mf_alloc(&back->rightUrl, GF_SG_VRML_MFURL, 1); back->rightUrl.vals[0].OD_ID = 4; gf_sg_vrml_mf_alloc(&back->backUrl, GF_SG_VRML_MFURL, 1); back->backUrl.vals[0].OD_ID = 5; gf_sg_vrml_mf_alloc(&back->topUrl, GF_SG_VRML_MFURL, 1); back->topUrl.vals[0].OD_ID = 6; gf_sg_vrml_mf_alloc(&back->bottomUrl, GF_SG_VRML_MFURL, 1); back->bottomUrl.vals[0].OD_ID = 7; ni = (M_NavigationInfo *) gf_node_new(sg, TAG_MPEG4_NavigationInfo); gf_node_list_add_child(&gr->children, (GF_Node*)ni); gf_node_register((GF_Node *)ni, (GF_Node *)gr); gf_sg_vrml_mf_reset(&ni->type, GF_SG_VRML_MFSTRING); gf_sg_vrml_mf_alloc(&ni->type, GF_SG_VRML_MFSTRING, 1); ni->type.vals[0] = gf_strdup("QTVR"); /*create ODs*/ st = gf_sm_stream_new(load->ctx, 2, GF_STREAM_OD, 1); au = gf_sm_stream_au_new(st, 0, 0, 1); odU = (GF_ODUpdate*) gf_odf_com_new(GF_ODF_OD_UPDATE_TAG); gf_list_add(au->commands, odU); for (i=0; i<6; i++) { GF_MuxInfo *mi; FILE *img; char szName[1024]; od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG); od->objectDescriptorID = 2+i; esd = gf_odf_desc_esd_new(2); esd->decoderConfig->streamType = GF_STREAM_VISUAL; esd->decoderConfig->objectTypeIndication = GPAC_OTI_IMAGE_JPEG; esd->ESID = 3+i; /*extract image and remember it*/ mi = (GF_MuxInfo *) gf_odf_desc_new(GF_ODF_MUXINFO_TAG); gf_list_add(esd->extensionDescriptors, mi); mi->delete_file = 1; sprintf(szName, "%s_img%d.jpg", load->fileName, esd->ESID); mi->file_name = gf_strdup(szName); gf_list_add(od->ESDescriptors, esd); gf_list_add(odU->objectDescriptors, od); samp = gf_isom_get_sample(src, tk, i+1, &di); img = gf_f64_open(mi->file_name, "wb"); fwrite(samp->data, samp->dataLength, 1, img); fclose(img); gf_isom_sample_del(&samp); } gf_isom_delete(src); return GF_OK; }
static void Extrusion_SetSpine(GF_Node *node, GF_Route *route) { M_Extrusion *eg = (M_Extrusion *)node; gf_sg_vrml_field_copy(&eg->spine, &eg->set_spine, GF_SG_VRML_MFVEC3F); gf_sg_vrml_mf_reset(&eg->set_spine, GF_SG_VRML_MFVEC3F); }
void gf_inline_on_modified(GF_Node *node) { u32 ODID; GF_MediaObject *mo; M_Inline *pInline = (M_Inline *) node; GF_Scene *scene = (GF_Scene *)gf_node_get_private(node); ODID = gf_mo_get_od_id(&pInline->url); if (scene) { mo = (scene->root_od) ? scene->root_od->mo : NULL; /*disconnect current inline if we're the last one using it (same as regular OD session leave/join)*/ if (mo) { Bool changed = GF_TRUE; if (ODID != GF_MEDIA_EXTERNAL_ID) { if (ODID && (ODID==scene->root_od->OD->objectDescriptorID)) changed = GF_FALSE; } else { if (gf_mo_is_same_url(mo, &pInline->url, NULL, 0) ) changed = GF_FALSE; } if (mo->num_open) { if (!changed) return; gf_scene_notify_event(scene, GF_EVENT_UNLOAD, node, NULL, GF_OK, GF_TRUE); gf_node_dirty_parents(node); gf_mo_event_target_remove_by_node(mo, node); /*reset the scene pointer as it may get destroyed*/ switch (gf_node_get_tag(node)) { case TAG_MPEG4_Inline: #ifndef GPAC_DISABLE_X3D case TAG_X3D_Inline: #endif gf_node_set_private(node, NULL); break; } mo->num_open --; if (!mo->num_open) { if (ODID == GF_MEDIA_EXTERNAL_ID) { GF_Scene *parent = scene->root_od->parentscene; /*!!! THIS WILL DESTROY THE INLINE SCENE OBJECT !!!*/ gf_odm_disconnect(scene->root_od, GF_TRUE); /*and force removal of the media object*/ if (parent) { if (gf_list_del_item(parent->scene_objects, mo)>=0) { gf_sg_vrml_mf_reset(&mo->URLs, GF_SG_VRML_MFURL); gf_mo_del(mo); } } } else { gf_term_lock_media_queue(scene->root_od->term, GF_TRUE); /*external media are completely unloaded, except addons which are only declared once */ if (!scene->root_od->addon && (scene->root_od->OD->objectDescriptorID==GF_MEDIA_EXTERNAL_ID)) { scene->root_od->action_type = GF_ODM_ACTION_DELETE; } else { scene->root_od->action_type = GF_ODM_ACTION_STOP; } if (gf_list_find(scene->root_od->term->media_queue, scene->root_od)<0) gf_list_add(scene->root_od->term->media_queue, scene->root_od); gf_term_lock_media_queue(scene->root_od->term, GF_FALSE); } } } } } /*force a redraw and load scene at next pass - we cannot load the scene now because - we can be in a JS call (eg JS mutex blocked) - locating scene objects matching the new url needs exclusive access to the MediaObject list, achieved with the term net mutex - another service may already be setting up objects (eg exclusive access to the net mutex grabbed), which can trigger event forwarding - some event forwarders may request JS context (eg access to JS mutex) In such a case we would end up in a deadlock - this needs urgent fixing ... */ if (ODID) { /*if no parent we must process the url change as we may not be traversed later on (not in the scene tree)*/ if (gf_node_get_parent(node, 0)==NULL) { gf_inline_set_scene(pInline); } else { gf_node_dirty_parents(node); } } }