static void TraverseDepthViewPoint(GF_Node *node, void *rs, Bool is_destroy)
{
if (!is_destroy && gf_node_dirty_get(node)) {
GF_TraverseState *tr_state = (GF_TraverseState *) rs;
GF_FieldInfo field;
gf_node_dirty_clear(node, 0);
tr_state->visual->depth_vp_position = 0;
tr_state->visual->depth_vp_range = 0;
#ifndef GPAC_DISABLE_3D
if (!tr_state->camera) return;
tr_state->camera->flags |= CAM_IS_DIRTY;
#endif
if (gf_node_get_field(node, 0, &field) != GF_OK) return;
if (field.fieldType != GF_SG_VRML_SFBOOL) return;
if ( *(SFBool *) field.far_ptr) {
if (gf_node_get_field(node, 1, &field) != GF_OK) return;
if (field.fieldType != GF_SG_VRML_SFFLOAT) return;
tr_state->visual->depth_vp_position = *(SFFloat *) field.far_ptr;
if (gf_node_get_field(node, 2, &field) != GF_OK) return;
if (field.fieldType != GF_SG_VRML_SFFLOAT) return;
tr_state->visual->depth_vp_range = *(SFFloat *) field.far_ptr;
}
#ifndef GPAC_DISABLE_3D
if (tr_state->layer3d) gf_node_dirty_set(tr_state->layer3d, GF_SG_NODE_DIRTY, 0);
#endif
gf_sc_invalidate(tr_state->visual->compositor, NULL);
}
}
static Bool IndexedCurve2D_GetNode(GF_Node *node, IndexedCurve2D *ic2d)
{
GF_FieldInfo field;
memset(ic2d, 0, sizeof(IndexedCurve2D));
ic2d->sgprivate = node->sgprivate;
if (gf_node_get_field(node, 0, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_SFNODE) return 0;
ic2d->point = * (GF_Node **) field.far_ptr;
if (gf_node_get_field(node, 1, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_SFFLOAT) return 0;
ic2d->fineness = *(SFFloat *) field.far_ptr;
if (gf_node_get_field(node, 2, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_MFINT32) return 0;
ic2d->type = *(MFInt32 *) field.far_ptr;
if (gf_node_get_field(node, 3, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_MFINT32) return 0;
ic2d->index = *(MFInt32 *) field.far_ptr;
return 1;
}
GF_Err gf_bifs_dec_node_mask(GF_BifsDecoder * codec, GF_BitStream *bs, GF_Node *node, Bool is_proto)
{
u32 i, numFields, numProtoFields, index, flag, nbBits;
GF_Err e;
GF_FieldInfo field;
//proto coding
if (codec->pCurrentProto) {
numFields = gf_node_get_num_fields_in_mode(node, GF_SG_FIELD_CODING_ALL);
numProtoFields = gf_sg_proto_get_field_count(codec->pCurrentProto);
nbBits = gf_get_bit_size(numProtoFields-1);
for (i=0; i<numFields; i++) {
flag = gf_bs_read_int(bs, 1);
if (!flag) continue;
flag = gf_bs_read_int(bs, 1);
//IS'ed field, create route for binding to Proto declaration
if (flag) {
//reference index of our IS'ed proto field
flag = gf_bs_read_int(bs, nbBits);
e = gf_node_get_field(node, i, &field);
if (e) return e;
e = BD_SetProtoISed(codec, flag, node, i);
}
//regular field, parse it (nb: no contextual coding for protos in maskNode,
//all node fields are coded
else {
e = gf_node_get_field(node, i, &field);
if (e) return e;
e = gf_bifs_dec_field(codec, bs, node, &field, 0);
}
if (e) return e;
}
}
//regular coding
else {
numFields = gf_node_get_num_fields_in_mode(node, GF_SG_FIELD_CODING_DEF);
for (i=0; i<numFields; i++) {
flag = gf_bs_read_int(bs, 1);
if (!flag) continue;
gf_bifs_get_field_index(node, i, GF_SG_FIELD_CODING_DEF, &index);
e = gf_node_get_field(node, index, &field);
if (e) return e;
e = gf_bifs_dec_field(codec, bs, node, &field, 0);
if (e) return e;
if (is_proto) gf_sg_proto_mark_field_loaded(node, &field);
}
}
return GF_OK;
}
static Bool PathExtrusion_GetNode(GF_Node *node, PathExtrusion *path_ext)
{
GF_FieldInfo field;
memset(path_ext, 0, sizeof(PathExtrusion));
if (gf_node_get_field(node, 0, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_SFNODE) return 0;
path_ext->geometry = * (GF_Node **) field.far_ptr;
if (gf_node_get_field(node, 1, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_MFVEC3F) return 0;
path_ext->spine = (MFVec3f *) field.far_ptr;
if (gf_node_get_field(node, 2, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_SFBOOL) return 0;
path_ext->beginCap = *(SFBool *) field.far_ptr;
if (gf_node_get_field(node, 3, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_SFBOOL) return 0;
path_ext->endCap = *(SFBool *) field.far_ptr;
if (gf_node_get_field(node, 4, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_SFFLOAT) return 0;
path_ext->creaseAngle = *(SFFloat *) field.far_ptr;
if (gf_node_get_field(node, 5, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_MFROTATION) return 0;
path_ext->orientation = (MFRotation *) field.far_ptr;
if (gf_node_get_field(node, 6, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_MFVEC2F) return 0;
path_ext->scale = (MFVec2f *) field.far_ptr;
if (gf_node_get_field(node, 7, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_SFBOOL) return 0;
path_ext->txAlongSpine = *(SFBool *) field.far_ptr;
return 1;
}
GF_Err gf_bifs_dec_node_list(GF_BifsDecoder * codec, GF_BitStream *bs, GF_Node *node, Bool is_proto)
{
u8 flag;
GF_Err e;
u32 numBitsALL, numBitsDEF, field_all, field_ref, numProtoBits;
GF_FieldInfo field;
e = GF_OK;
numProtoBits = numBitsALL = 0;
if (codec->pCurrentProto) {
numProtoBits = gf_get_bit_size(gf_sg_proto_get_field_count(codec->pCurrentProto) - 1);
numBitsALL = gf_get_bit_size(gf_node_get_num_fields_in_mode(node, GF_SG_FIELD_CODING_ALL)-1);
}
numBitsDEF = gf_get_bit_size(gf_node_get_num_fields_in_mode(node, GF_SG_FIELD_CODING_DEF)-1);
flag = gf_bs_read_int(bs, 1);
while (!flag && (codec->LastError>=0)) {
if (codec->pCurrentProto) {
//IS'ed flag
flag = gf_bs_read_int(bs, 1);
if (flag) {
//get field index in ALL mode for node
field_ref = gf_bs_read_int(bs, numBitsALL);
//get field index in ALL mode for proto
field_all = gf_bs_read_int(bs, numProtoBits);
e = gf_node_get_field(node, field_ref, &field);
if (e) return e;
e = BD_SetProtoISed(codec, field_all, node, field_ref);
if (e) return e;
flag = gf_bs_read_int(bs, 1);
continue;
}
}
//fields are coded in DEF mode
field_ref = gf_bs_read_int(bs, numBitsDEF);
e = gf_bifs_get_field_index(node, field_ref, GF_SG_FIELD_CODING_DEF, &field_all);
if (e) return e;
e = gf_node_get_field(node, field_all, &field);
if (e) return e;
e = gf_bifs_dec_field(codec, bs, node, &field, 0);
if (e) return e;
flag = gf_bs_read_int(bs, 1);
if (is_proto) gf_sg_proto_mark_field_loaded(node, &field);
}
return codec->LastError;
}
GF_Err BE_FieldReplace(GF_BifsEncoder *codec, GF_Command *com, GF_BitStream *bs)
{
GF_Err e;
u32 ind, NumBits;
GF_FieldInfo field;
GF_CommandField *inf;
if (!gf_list_count(com->command_fields)) return GF_OK;
inf = (GF_CommandField *)gf_list_get(com->command_fields, 0);
GF_BIFS_WRITE_INT(codec, bs, gf_node_get_id(com->node) - 1, codec->info->config.NodeIDBits, "NodeID", NULL);
NumBits = gf_get_bit_size(gf_node_get_num_fields_in_mode(com->node, GF_SG_FIELD_CODING_IN)-1);
gf_bifs_field_index_by_mode(com->node, inf->fieldIndex, GF_SG_FIELD_CODING_IN, &ind);
GF_BIFS_WRITE_INT(codec, bs, ind, NumBits, "field", NULL);
e = gf_node_get_field(com->node, inf->fieldIndex, &field);
if (e) return e;
field.far_ptr = inf->field_ptr;
/* Warning: To be changed when proper solution is found */
if (gf_sg_vrml_get_sf_type(field.fieldType) == GF_SG_VRML_SFSCRIPT) codec->is_encoding_command = 1;
e = gf_bifs_enc_field(codec, bs, com->node, &field);
codec->is_encoding_command = 0;
return e;
}
static Bool StyleGroup_GetNode(GF_Node *node, StyleGroup *sg)
{
GF_FieldInfo field;
memset(sg, 0, sizeof(StyleGroup));
sg->sgprivate = node->sgprivate;
if (gf_node_get_field(node, 0, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_MFNODE) return 0;
sg->children = *(GF_ChildNodeItem **) field.far_ptr;
if (gf_node_get_field(node, 1, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_SFNODE) return 0;
sg->appearance = *(GF_Node **)field.far_ptr;
return 1;
}
GF_Err BM_ParseIndexValueReplace(GF_BifsDecoder *codec, GF_BitStream *bs, GF_List *com_list)
{
u32 NodeID, ind, field_ind, NumBits;
s32 type, pos;
GF_Command *com;
GF_Node *node;
GF_Err e;
GF_FieldInfo field, sffield;
GF_CommandField *inf;
/*get the node*/
NodeID = 1 + gf_bs_read_int(bs, codec->info->config.NodeIDBits);
node = gf_sg_find_node(codec->current_graph, NodeID);
if (!node) return GF_NON_COMPLIANT_BITSTREAM;
NumBits = gf_get_bit_size(gf_node_get_num_fields_in_mode(node, GF_SG_FIELD_CODING_IN)-1);
ind = gf_bs_read_int(bs, NumBits);
e = gf_bifs_get_field_index(node, ind, GF_SG_FIELD_CODING_IN, &field_ind);
if (e) return e;
e = gf_node_get_field(node, field_ind, &field);
if (gf_sg_vrml_is_sf_field(field.fieldType)) return GF_NON_COMPLIANT_BITSTREAM;
type = gf_bs_read_int(bs, 2);
switch (type) {
case 0:
pos = gf_bs_read_int(bs, 16);
break;
case 2:
pos = 0;
break;
case 3:
pos = ((GenMFField *) field.far_ptr)->count - 1;
break;
default:
return GF_NON_COMPLIANT_BITSTREAM;
}
com = gf_sg_command_new(codec->current_graph, GF_SG_INDEXED_REPLACE);
BM_SetCommandNode(com, node);
inf = gf_sg_command_field_new(com);
inf->fieldIndex = field.fieldIndex;
inf->pos = pos;
if (field.fieldType == GF_SG_VRML_MFNODE) {
inf->fieldType = GF_SG_VRML_SFNODE;
inf->new_node = gf_bifs_dec_node(codec, bs, field.NDTtype);
inf->field_ptr = &inf->new_node;
if (inf->new_node) gf_node_register(inf->new_node, NULL);
} else {
memcpy(&sffield, &field, sizeof(GF_FieldInfo));
sffield.fieldType = gf_sg_vrml_get_sf_type(field.fieldType);
inf->fieldType = sffield.fieldType;
sffield.far_ptr = inf->field_ptr = gf_sg_vrml_field_pointer_new(sffield.fieldType);
codec->LastError = gf_bifs_dec_sf_field(codec, bs, node, &sffield, 1);
}
gf_list_add(com_list, com);
return codec->LastError;
}
void gf_storage_save(M_Storage *storage)
{
char szID[20];
u32 i;
GF_Config *cfg = storage_get_cfg(storage);
char *section = storage_get_section(storage);
if (!cfg || !section) return;
gf_cfg_del_section(cfg, section);
if (storage->expireAfter) {
u32 sec, frac;
char szNTP[100];
gf_net_get_ntp(&sec, &frac);
sec += storage->expireAfter;
sprintf(szNTP, "%u", sec);
gf_cfg_set_key(cfg, section, "expireAfterNTP", szNTP);
} else {
gf_cfg_set_key(cfg, section, "expireAfterNTP", "0");
}
for (i=0; i<storage->storageList.count; i++) {
char *val;
GF_FieldInfo info;
sprintf(szID, "%d", i);
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)) {
val = storage_serialize_sf(info.far_ptr, info.fieldType);
} else {
//u32 sftype = gf_sg_vrml_get_sf_type(info.fieldType);
char *slotval;
void *slot;
val = NULL;
for (i=0; i<((GenMFField *)info.far_ptr)->count; i++) {
if (gf_sg_vrml_mf_get_item(info.far_ptr, info.fieldType, &slot, i) != GF_OK) break;
slotval = storage_serialize_sf(info.far_ptr, info.fieldType);
if (!slotval) break;
if (val) {
val = gf_realloc(val, strlen(val) + 3 + strlen(slot));
} else {
val = gf_malloc(3 + strlen(slot));
val[0] = 0;
}
strcat(val, "'");
strcat(val, slotval);
strcat(val, "'");
gf_free(slot);
}
}
if (val) {
gf_cfg_set_key(cfg, section, szID, val);
gf_free(val);
}
}
gf_free(section);
}
static Bool PlaneClipper_GetNode(GF_Node *node, PlaneClipper *pc)
{
GF_FieldInfo field;
memset(pc, 0, sizeof(PlaneClipper));
pc->sgprivate = node->sgprivate;
if (gf_node_get_field(node, 0, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_SFVEC3F) return 0;
pc->plane.normal = * (SFVec3f *) field.far_ptr;
if (gf_node_get_field(node, 1, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_SFFLOAT) return 0;
pc->plane.d = * (SFFloat *) field.far_ptr;
if (gf_node_get_field(node, 2, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_MFNODE) return 0;
pc->children = *(GF_ChildNodeItem **) field.far_ptr;
return 1;
}
static void TraverseTextureText(GF_Node *node, void *rs, Bool is_destroy)
{
TextStack *stack;
GF_Node *text;
GF_FieldInfo field;
if (is_destroy) return;
if (gf_node_get_field(node, 0, &field) != GF_OK) return;
if (field.fieldType != GF_SG_VRML_SFNODE) return;
text = *(GF_Node **)field.far_ptr;
if (!text) return;
if (gf_node_get_field(node, 1, &field) != GF_OK) return;
if (field.fieldType != GF_SG_VRML_SFBOOL) return;
if (gf_node_get_tag(text) != TAG_MPEG4_Text) return;
stack = (TextStack *) gf_node_get_private(text);
stack->texture_text_flag = *(SFBool*)field.far_ptr ? 1 : 0;
}
static Bool OffscreenGroup_GetNode(GF_Node *node, OffscreenGroup *og)
{
GF_FieldInfo field;
memset(og, 0, sizeof(OffscreenGroup));
og->sgprivate = node->sgprivate;
if (gf_node_get_field(node, 0, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_MFNODE) return 0;
og->children = *(GF_ChildNodeItem **) field.far_ptr;
if (gf_node_get_field(node, 1, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_SFINT32) return 0;
og->offscreen = * (SFInt32 *) field.far_ptr;
if (gf_node_get_field(node, 2, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_SFFLOAT) return 0;
og->opacity = * (SFFloat *) field.far_ptr;
return 1;
}
void V4StudioTree::Translate(int dX, int dY)
{
if (m_transformNode) {
GF_FieldInfo field;
u32 tag = gf_node_get_tag(m_transformNode);
if (tag == TAG_MPEG4_Transform2D){
gf_node_get_field(m_transformNode, 7, &field);
((SFVec2f *)field.far_ptr)->x += dX;
((SFVec2f *)field.far_ptr)->y += dY;
} else {
gf_node_get_field(m_transformNode, 5, &field);
*((SFFloat *)field.far_ptr) += dX;
gf_node_get_field(m_transformNode, 8, &field);
*((SFFloat *)field.far_ptr) += dY;
}
V4StudioFrame *mainFrame = (V4StudioFrame *)GetParent();
mainFrame->GetFieldView()->SetNode(m_transformNode);
mainFrame->GetFieldView()->Create();
}
}
void V4StudioTree::Scale(int dX, int dY)
{
if (m_transformNode && (dX || dY)) {
GF_FieldInfo field;
u32 tag = gf_node_get_tag(m_transformNode);
if (tag == TAG_MPEG4_Transform2D){
gf_node_get_field(m_transformNode, 5, &field);
if (dX) ((SFVec2f *)field.far_ptr)->x *= (dX>0?1.01:0.99);
if (dY) ((SFVec2f *)field.far_ptr)->y *= (dY>0?1.01:0.99);
} else {
gf_node_get_field(m_transformNode, 3, &field);
if (dX) *((SFFloat *)field.far_ptr) *= (dX>0?1.01:0.99);
gf_node_get_field(m_transformNode, 7, &field);
if (dY) *((SFFloat *)field.far_ptr) *= (dY>0?1.01:0.99);
}
V4StudioFrame *mainFrame = (V4StudioFrame *)GetParent();
mainFrame->GetFieldView()->SetNode(m_transformNode);
mainFrame->GetFieldView()->Create();
}
}
static Bool Untransform_GetNode(GF_Node *node, Untransform *tr)
{
GF_FieldInfo field;
memset(tr, 0, sizeof(Untransform));
tr->sgprivate = node->sgprivate;
if (gf_node_get_field(node, 0, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_MFNODE) return 0;
tr->children = *(GF_ChildNodeItem **) field.far_ptr;
return 1;
}
static Bool TestSensor_GetNode(GF_Node *node, TestSensor *ts)
{
GF_FieldInfo field;
memset(ts, 0, sizeof(TestSensor));
ts->sgprivate = node->sgprivate;
if (gf_node_get_field(node, 0, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_SFBOOL) return 0;
if (field.eventType != GF_SG_EVENT_IN) return 0;
ts->onTrigger = *(SFBool *)field.far_ptr;
if (gf_node_get_field(node, 1, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_SFFLOAT) return 0;
if (field.eventType != GF_SG_EVENT_EXPOSED_FIELD) return 0;
ts->value = *(SFFloat *)field.far_ptr;
if (gf_node_get_field(node, 2, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_SFFLOAT) return 0;
if (field.eventType != GF_SG_EVENT_OUT) return 0;
return 1;
}
static GF_Err BM_ParseMultipleIndexedReplace(GF_BifsDecoder *codec, GF_BitStream *bs, GF_List *com_list)
{
u32 ID, ind, field_ind, NumBits, lenpos, lennum, count;
GF_Node *node;
GF_Err e;
GF_Command *com;
GF_CommandField *inf;
GF_FieldInfo field;
ID = 1 + gf_bs_read_int(bs, codec->info->config.NodeIDBits);
node = gf_sg_find_node(codec->current_graph, ID);
if (!node) return GF_NON_COMPLIANT_BITSTREAM;
NumBits = gf_get_bit_size(gf_node_get_num_fields_in_mode(node, GF_SG_FIELD_CODING_IN)-1);
ind = gf_bs_read_int(bs, NumBits);
e = gf_bifs_get_field_index(node, ind, GF_SG_FIELD_CODING_IN, &field_ind);
if (e) return e;
e = gf_node_get_field(node, field_ind, &field);
if (gf_sg_vrml_is_sf_field(field.fieldType)) return GF_NON_COMPLIANT_BITSTREAM;
lenpos = gf_bs_read_int(bs, 5);
lennum = gf_bs_read_int(bs, 5);
count = gf_bs_read_int(bs, lennum);
com = gf_sg_command_new(codec->current_graph, GF_SG_MULTIPLE_INDEXED_REPLACE);
BM_SetCommandNode(com, node);
field.fieldType = gf_sg_vrml_get_sf_type(field.fieldType);
while (count) {
inf = gf_sg_command_field_new(com);
inf->pos = gf_bs_read_int(bs, lenpos);
inf->fieldIndex = field.fieldIndex;
inf->fieldType = field.fieldType;
if (field.fieldType==GF_SG_VRML_SFNODE) {
inf->new_node = gf_bifs_dec_node(codec, bs, field.NDTtype);
if (codec->LastError) goto err;
inf->field_ptr = &inf->new_node;
gf_node_register(inf->new_node, NULL);
} else {
field.far_ptr = inf->field_ptr = gf_sg_vrml_field_pointer_new(inf->fieldType);
e = gf_bifs_dec_sf_field(codec, bs, node, &field, 1);
if (e) goto err;
}
count--;
}
err:
if (e) gf_sg_command_del(com);
else gf_list_add(com_list, com);
return e;
}
static Bool DepthGroup_GetNode(GF_Node *node, DepthGroup *dg)
{
GF_FieldInfo field;
memset(dg, 0, sizeof(DepthGroup));
dg->sgprivate = node->sgprivate;
if (gf_node_get_field(node, 0, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_MFNODE) return 0;
dg->children = *(GF_ChildNodeItem **) field.far_ptr;
if (gf_node_get_field(node, 1, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_SFINT32) return 0;
if (gf_node_get_field(node, 2, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_SFFLOAT) return 0;
dg->depth_gain = * (SFFloat *) field.far_ptr;
if (gf_node_get_field(node, 3, &field) != GF_OK) return 0;
if (field.fieldType != GF_SG_VRML_SFFLOAT) return 0;
dg->depth_offset = * (SFFloat *) field.far_ptr;
return 1;
}
// Add gen -- adds any element which can be a children of a switch node
void V4SceneManager::AddGen(GF_Node * node) {
// retrieves the chain of children (field number 0 named "choice")
GF_FieldInfo field;
GF_List * list;
gf_node_get_field(dictionnary, 0, &field);
list = *( (GF_List **) field.far_ptr);
// adds a reference to that node in the dictionnary
gf_list_add(list, node);
gf_node_register(node, dictionnary);
}
GF_Err BM_ParseIndexDelete(GF_BifsDecoder *codec, GF_BitStream *bs, GF_List *com_list)
{
u32 NodeID, NumBits, ind, field_ind;
s32 pos;
GF_Command *com;
u8 type;
GF_Node *node;
GF_Err e;
GF_CommandField *inf;
GF_FieldInfo field;
NodeID = 1 + gf_bs_read_int(bs, codec->info->config.NodeIDBits);
node = gf_sg_find_node(codec->current_graph, NodeID);
if (!node) return GF_NON_COMPLIANT_BITSTREAM;
NumBits = gf_get_bit_size(gf_node_get_num_fields_in_mode(node, GF_SG_FIELD_CODING_IN) - 1);
ind = gf_bs_read_int(bs, NumBits);
type = gf_bs_read_int(bs, 2);
switch (type) {
case 0:
pos = (u32) gf_bs_read_int(bs, 16);
break;
case 2:
pos = 0;
break;
case 3:
pos = -1;
break;
default:
return GF_NON_COMPLIANT_BITSTREAM;
}
e = gf_bifs_get_field_index(node, ind, GF_SG_FIELD_CODING_IN, &field_ind);
if (e) return e;
e = gf_node_get_field(node, field_ind, &field);
if (e) return e;
if (gf_sg_vrml_is_sf_field(field.fieldType)) return GF_NON_COMPLIANT_BITSTREAM;
com = gf_sg_command_new(codec->current_graph, GF_SG_INDEXED_DELETE);
BM_SetCommandNode(com, node);
inf = gf_sg_command_field_new(com);
inf->pos = pos;
inf->fieldIndex = field.fieldIndex;
inf->fieldType = gf_sg_vrml_get_sf_type(field.fieldType);
gf_list_add(com_list, com);
return codec->LastError;
}
static GF_Err BE_MultipleReplace(GF_BifsEncoder * codec, GF_Command *com, GF_BitStream *bs)
{
u32 i, j, nbBits, count, numFields, allField;
Bool use_list;
GF_FieldInfo field;
GF_Err e;
gf_bs_write_int(bs, gf_node_get_id(com->node)-1, codec->info->config.NodeIDBits);
count = gf_list_count(com->command_fields);
use_list = 1;
numFields = gf_node_get_num_fields_in_mode(com->node, GF_SG_FIELD_CODING_DEF);
nbBits = gf_get_bit_size(numFields - 1);
if (count < 1+count*(1+nbBits)) use_list = 0;
GF_BIFS_WRITE_INT(codec, bs, use_list ? 0 : 1, 1, "isMask", NULL);
for (i=0; i<numFields; i++) {
GF_CommandField *inf = NULL;
gf_bifs_get_field_index(com->node, i, GF_SG_FIELD_CODING_DEF, &allField);
for (j=0; j<count; j++) {
inf = (GF_CommandField *)gf_list_get(com->command_fields, j);
if (inf->fieldIndex==allField) break;
inf = NULL;
}
if (!inf) {
if (!use_list) GF_BIFS_WRITE_INT(codec, bs, 0, 1, "Mask", NULL);
continue;
}
/*common case*/
gf_node_get_field(com->node, inf->fieldIndex, &field);
if (use_list) {
/*not end flag*/
GF_BIFS_WRITE_INT(codec, bs, 0, 1, "end", NULL);
} else {
/*mask flag*/
GF_BIFS_WRITE_INT(codec, bs, 1, 1, "Mask", NULL);
}
if (use_list) GF_BIFS_WRITE_INT(codec, bs, i, nbBits, "field", (char*)field.name);
field.far_ptr = inf->field_ptr;
e = gf_bifs_enc_field(codec, bs, com->node, &field);
if (e) return e;
}
/*end flag*/
if (use_list) GF_BIFS_WRITE_INT(codec, bs, 1, 1, "end", NULL);
return GF_OK;
}
void TestSensor_OnTrigger(GF_Node *node, struct _route *route)
{
GF_FieldInfo field;
Fixed value;
TestSensorStack *stack = (TestSensorStack *)gf_node_get_private(node);
TestSensor_GetNode(node, &stack->ts);
if (stack->ts.onTrigger) {
value = stack->ts.value;
} else {
value = 1-stack->ts.value;
}
gf_node_get_field(node, 2, &field);
*(SFFloat*)field.far_ptr = value;
gf_node_event_out(node, 2);
}
// MakeChild -- Sets the first node as a child of the second using the given field
void V4SceneManager::MakeChild(GF_Node * child, GF_Node * parent, const u32 fieldIndex) {
// get the field where we have to add the new child
GF_FieldInfo field;
gf_node_get_field(parent, fieldIndex, &field);
// keeps the count of uses up to date
gf_node_register(child, parent);
// if the field is single valued
if (field.fieldType == GF_SG_VRML_SFNODE) {
*((GF_Node **) field.far_ptr) = child;
}
// if the field is multi valued
if (field.fieldType == GF_SG_VRML_MFNODE)
gf_node_list_add_child((GF_ChildNodeItem **)field.far_ptr, child );
}
// CreateDictionnary -- Create the root node of the dictionnary and populates it
void V4SceneManager::CreateDictionnary() {
GF_Node * root = gf_sg_get_root_node(m_pIs->graph);
dictionnary = NewNode(TAG_MPEG4_Switch);
// Insert the dictionnary in the scene and gives it a name
gf_node_insert_child(root, dictionnary, 0);
gf_node_register(dictionnary, root);
gf_node_set_id(dictionnary, gf_sg_get_next_available_node_id(m_pIs->graph), DICTNAME);
// makes the dictionnary invisible
// the number 1 field is the "whichChoice", setting it to -1 makes it display nothing
GF_FieldInfo field;
gf_node_get_field(dictionnary, 1, &field);
frame->GetFieldView()->SetFieldValue(field, &wxString("-1"), -1); // TODO : maybe put the method SetFieldValue somewhere more accessible
// populates dictionnary with the root node of the scene
AddToDictionnary(root);
}
GF_Err BE_IndexInsert(GF_BifsEncoder *codec, GF_Command *com, GF_BitStream *bs)
{
GF_Err e;
u32 NumBits, ind;
GF_FieldInfo field, sffield;
GF_CommandField *inf;
if (!gf_list_count(com->command_fields)) return GF_OK;
inf = (GF_CommandField *)gf_list_get(com->command_fields, 0);
GF_BIFS_WRITE_INT(codec, bs, gf_node_get_id(com->node) - 1, codec->info->config.NodeIDBits, "NodeID", NULL);
/*index insertion uses IN mode for field index*/
NumBits = gf_get_bit_size(gf_node_get_num_fields_in_mode(com->node, GF_SG_FIELD_CODING_IN)-1);
gf_bifs_field_index_by_mode(com->node, inf->fieldIndex, GF_SG_FIELD_CODING_IN, &ind);
GF_BIFS_WRITE_INT(codec, bs, ind, NumBits, "field", NULL);
switch (inf->pos) {
case 0:
GF_BIFS_WRITE_INT(codec, bs, 2, 2, "FIRST", "idx");
break;
case -1:
GF_BIFS_WRITE_INT(codec, bs, 3, 2, "LAST", "idx");
break;
default:
GF_BIFS_WRITE_INT(codec, bs, 0, 2, "pos", "idx");
GF_BIFS_WRITE_INT(codec, bs, inf->pos, 16, "pos", NULL);
break;
}
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;
memcpy(&sffield, &field, sizeof(GF_FieldInfo));
sffield.fieldType = gf_sg_vrml_get_sf_type(field.fieldType);
sffield.far_ptr = inf->field_ptr;
/*rescale the MFField and parse the SFField*/
if (field.fieldType==GF_SG_VRML_MFNODE) {
return gf_bifs_enc_node(codec, inf->new_node, field.NDTtype, bs);
} else {
return gf_bifs_enc_sf_field(codec, bs, com->node, &sffield);
}
}
static void UpdateTimeNode(GF_BifsDecoder * codec, GF_Node *node)
{
switch (gf_node_get_tag(node)) {
case TAG_MPEG4_AnimationStream:
BD_OffsetSFTime(codec, & ((M_AnimationStream*)node)->startTime);
BD_OffsetSFTime(codec, & ((M_AnimationStream*)node)->stopTime);
break;
case TAG_MPEG4_AudioBuffer:
BD_OffsetSFTime(codec, & ((M_AudioBuffer*)node)->startTime);
BD_OffsetSFTime(codec, & ((M_AudioBuffer*)node)->stopTime);
break;
case TAG_MPEG4_AudioClip:
BD_OffsetSFTime(codec, & ((M_AudioClip*)node)->startTime);
BD_OffsetSFTime(codec, & ((M_AudioClip*)node)->stopTime);
break;
case TAG_MPEG4_AudioSource:
BD_OffsetSFTime(codec, & ((M_AudioSource*)node)->startTime);
BD_OffsetSFTime(codec, & ((M_AudioSource*)node)->stopTime);
break;
case TAG_MPEG4_MovieTexture:
BD_OffsetSFTime(codec, & ((M_MovieTexture*)node)->startTime);
BD_OffsetSFTime(codec, & ((M_MovieTexture*)node)->stopTime);
break;
case TAG_MPEG4_TimeSensor:
BD_OffsetSFTime(codec, & ((M_TimeSensor*)node)->startTime);
BD_OffsetSFTime(codec, & ((M_TimeSensor*)node)->stopTime);
break;
case TAG_ProtoNode:
{
u32 i, nbFields;
GF_FieldInfo inf;
nbFields = gf_node_get_num_fields_in_mode(node, GF_SG_FIELD_CODING_ALL);
for (i=0; i<nbFields; i++) {
gf_node_get_field(node, i, &inf);
if (inf.fieldType != GF_SG_VRML_SFTIME) continue;
BD_CheckSFTimeOffset(codec, node, &inf);
}
}
break;
}
}
static GF_Err BE_MultipleIndexedReplace(GF_BifsEncoder * codec, GF_Command *com, GF_BitStream *bs)
{
u32 i,nbBits, count, maxPos, nbBitsPos;
GF_FieldInfo field;
GF_Err e;
GF_CommandField *inf;
if (!gf_list_count(com->command_fields)) return GF_OK;
inf = (GF_CommandField *)gf_list_get(com->command_fields, 0);
gf_bs_write_int(bs, gf_node_get_id(com->node)-1, codec->info->config.NodeIDBits);
nbBits = gf_get_bit_size(gf_node_get_num_fields_in_mode(com->node, GF_SG_FIELD_CODING_IN)-1);
gf_bifs_field_index_by_mode(com->node, inf->fieldIndex, GF_SG_FIELD_CODING_IN, &i);
GF_BIFS_WRITE_INT(codec, bs, i, nbBits, "field", NULL);
gf_node_get_field(com->node, inf->fieldIndex, &field);
field.fieldType = inf->fieldType;
count = gf_list_count(com->command_fields);
maxPos = 0;
for (i=0; i<count; i++) {
inf = (GF_CommandField *)gf_list_get(com->command_fields, i);
if (maxPos < (u32) inf->pos) maxPos = inf->pos;
}
nbBitsPos = gf_get_bit_size(maxPos);
GF_BIFS_WRITE_INT(codec, bs, nbBitsPos, 5, "nbBitsPos", NULL);
nbBits = gf_get_bit_size(count);
GF_BIFS_WRITE_INT(codec, bs, nbBits, 5, "nbBits", NULL);
GF_BIFS_WRITE_INT(codec, bs, count, nbBits, "count", NULL);
for (i=0; i<count; i++) {
inf = (GF_CommandField *)gf_list_get(com->command_fields, i);
GF_BIFS_WRITE_INT(codec, bs, inf->pos, nbBitsPos, "idx", NULL);
field.far_ptr = inf->field_ptr;
e = gf_bifs_enc_field(codec, bs, com->node, &field);
if (e) return e;
}
return GF_OK;
}
// AddRecursive -- recursively adds items with an ID to the dictionnary
void V4SceneManager::AddRecursive(GF_Node * node, bool parentAdded) {
// skips empty nodes
if (!node) return;
// skips the dictionnary
const char * c = gf_node_get_name(node);
if ( (c != NULL) && (!strcmp(c, DICTNAME)) ) return;
// if node as an id adds it to the dictionnary and the node pool
u32 id = gf_node_get_id(node);
if (id) {
pools.Add(node);
// children of added node are not added to the dictionnary
if (!parentAdded) AddEffective(node);
parentAdded = true;
}
GF_FieldInfo field;
GF_ChildNodeItem * list;
int count = gf_node_get_field_count(node);
// tests all fields, if a field is a node then adds it and process its children recursively
for (int i=0; i<count; i++) {
gf_node_get_field(node, i, &field);
// single value node field
if (field.fieldType == GF_SG_VRML_SFNODE)
AddRecursive( * ((GF_Node **) field.far_ptr), parentAdded );
// multiple value node field
if (field.fieldType == GF_SG_VRML_MFNODE) {
list = *( (GF_ChildNodeItem **) field.far_ptr);
for (u32 j=0; j<gf_node_list_get_count(list); j++)
AddRecursive( (GF_Node *) gf_node_list_get_child(list, j), parentAdded );
}
}
}
GF_Err BM_ParseFieldReplace(GF_BifsDecoder *codec, GF_BitStream *bs, GF_List *com_list)
{
GF_Err e;
GF_Command *com;
u32 NodeID, ind, field_ind, NumBits;
GF_Node *node;
GF_FieldInfo field;
GF_CommandField *inf;
NodeID = 1 + gf_bs_read_int(bs, codec->info->config.NodeIDBits);
node = gf_sg_find_node(codec->current_graph, NodeID);
if (!node) return GF_NON_COMPLIANT_BITSTREAM;
NumBits = gf_get_bit_size(gf_node_get_num_fields_in_mode(node, GF_SG_FIELD_CODING_IN)-1);
ind = gf_bs_read_int(bs, NumBits);
e = gf_bifs_get_field_index(node, ind, GF_SG_FIELD_CODING_IN, &field_ind);
if (e) return e;
e = gf_node_get_field(node, field_ind, &field);
com = gf_sg_command_new(codec->current_graph, GF_SG_FIELD_REPLACE);
BM_SetCommandNode(com, node);
inf = gf_sg_command_field_new(com);
inf->fieldIndex = field_ind;
inf->fieldType = field.fieldType;
if (inf->fieldType == GF_SG_VRML_SFNODE) {
field.far_ptr = inf->field_ptr = &inf->new_node;
} else if (inf->fieldType == GF_SG_VRML_MFNODE) {
field.far_ptr = inf->field_ptr = &inf->node_list;
} else {
field.far_ptr = inf->field_ptr = gf_sg_vrml_field_pointer_new(field.fieldType);
}
/*parse the field*/
codec->LastError = gf_bifs_dec_field(codec, bs, node, &field, 1);
gf_list_add(com_list, com);
return codec->LastError;
}
GF_Node *CloneNodeForEditing(GF_SceneGraph *inScene, GF_Node *orig) //, GF_Node *cloned_parent)
{
u32 i, j, count;
GF_Node *node, *child, *tmp;
GF_List *list, *list2;
GF_FieldInfo field_orig, field;
/*this is not a mistake*/
if (!orig) return NULL;
/*check for DEF/USE
if (orig->sgprivate->NodeID) {
node = gf_sg_find_node(inScene, orig->sgprivate->NodeID);
//node already created, USE
if (node) {
gf_node_register(node, cloned_parent);
return node;
}
}
*/
/*create a node*/
/*
if (orig->sgprivate->tag == TAG_MPEG4_ProtoNode) {
proto_node = ((GF_ProtoInstance *)orig)->proto_interface;
//create the instance but don't load the code -c we MUST wait for ISed routes to be cloned before
node = gf_sg_proto_create_node(inScene, proto_node, (GF_ProtoInstance *) orig);
} else {
*/
node = gf_node_new(inScene, gf_node_get_tag(orig));
// }
count = gf_node_get_field_count(orig);
/*copy each field*/
for (i=0; i<count; i++) {
gf_node_get_field(orig, i, &field_orig);
/*get target ptr*/
gf_node_get_field(node, i, &field);
assert(field.eventType==field_orig.eventType);
assert(field.fieldType==field_orig.fieldType);
/*duplicate it*/
switch (field.fieldType) {
case GF_SG_VRML_SFNODE:
child = CloneNodeForEditing(inScene, (GF_Node *) (* ((GF_Node **) field_orig.far_ptr)));//, node);
*((GF_Node **) field.far_ptr) = child;
break;
case GF_SG_VRML_MFNODE:
list = *( (GF_List **) field_orig.far_ptr);
list2 = *( (GF_List **) field.far_ptr);
for (j=0; j<gf_list_count(list); j++) {
tmp = (GF_Node *)gf_list_get(list, j);
child = CloneNodeForEditing(inScene, tmp);//, node);
gf_list_add(list2, child);
}
break;
default:
gf_sg_vrml_field_copy(field.far_ptr, field_orig.far_ptr, field.fieldType);
break;
}
}
/*register node
if (orig->sgprivate->NodeID) {
Node_SetID(node, orig->sgprivate->NodeID);
gf_node_register(node, cloned_parent);
}*/
/*init node before creating ISed routes so the eventIn handler are in place*/
if (gf_node_get_tag(node) != TAG_ProtoNode) gf_node_init(node);
return node;
}
