Ejemplos de compositor_init_svg_audio en C++ (Cpp)

Ejemplo n.º 1

Archivo: compositor_node_init.c Proyecto: fcsteagu/gpac-1

void gf_sc_on_node_init(GF_Compositor *compositor, GF_Node *node)
{
	switch (gf_node_get_tag(node)) {
#ifndef GPAC_DISABLE_VRML
	case TAG_MPEG4_AnimationStream: compositor_init_animationstream(compositor, node); break;
	case TAG_MPEG4_AudioBuffer: compositor_init_audiobuffer(compositor, node); break;
	case TAG_MPEG4_AudioSource: compositor_init_audiosource(compositor, node); break;
	case TAG_MPEG4_AudioClip:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_AudioClip:
#endif
		compositor_init_audioclip(compositor, node); break;
	case TAG_MPEG4_TimeSensor:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_TimeSensor:
#endif
		compositor_init_timesensor(compositor, node); break;
	case TAG_MPEG4_ImageTexture:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_ImageTexture:
#endif
	case TAG_MPEG4_CacheTexture:
		compositor_init_imagetexture(compositor, node); break;

	case TAG_MPEG4_PixelTexture:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_PixelTexture:
#endif
		compositor_init_pixeltexture(compositor, node); break;
	case TAG_MPEG4_MovieTexture:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_MovieTexture:
#endif
		compositor_init_movietexture(compositor, node); break;

	case TAG_MPEG4_Background2D: compositor_init_background2d(compositor, node); break;
	case TAG_MPEG4_Bitmap: compositor_init_bitmap(compositor, node); break;
	case TAG_MPEG4_ColorTransform: compositor_init_colortransform(compositor, node); break;
	case TAG_MPEG4_Circle: compositor_init_circle(compositor, node); break;
	case TAG_MPEG4_Curve2D: compositor_init_curve2d(compositor, node); break;
	case TAG_MPEG4_XCurve2D: compositor_init_curve2d(compositor, node); break;
	case TAG_MPEG4_Ellipse: compositor_init_ellipse(compositor, node); break;
	case TAG_MPEG4_OrderedGroup: compositor_init_orderedgroup(compositor, node); break;
	case TAG_MPEG4_PointSet2D: compositor_init_pointset2d(compositor, node); break;
	case TAG_MPEG4_Transform2D: compositor_init_transform2d(compositor, node); break;
	case TAG_MPEG4_TransformMatrix2D: compositor_init_transformmatrix2d(compositor, node); break;
	case TAG_MPEG4_LineProperties: compositor_init_lineprops(compositor, node); break;
	case TAG_MPEG4_XLineProperties: compositor_init_lineprops(compositor, node); break;
	case TAG_MPEG4_Viewport: compositor_init_viewport(compositor, node); break;

	case TAG_MPEG4_IndexedLineSet2D: compositor_init_indexed_line_set2d(compositor, node); break;
	case TAG_MPEG4_IndexedFaceSet2D: compositor_init_indexed_face_set2d(compositor, node); break;

	case TAG_MPEG4_Sound2D: compositor_init_sound2d(compositor, node); break;

	case TAG_MPEG4_LinearGradient: compositor_init_linear_gradient(compositor, node); break;
	case TAG_MPEG4_RadialGradient: compositor_init_radial_gradient(compositor, node); break;

	case TAG_MPEG4_CompositeTexture2D: compositor_init_compositetexture2d(compositor, node); break;
	case TAG_MPEG4_MatteTexture: compositor_init_mattetexture(compositor, node); break;

	case TAG_MPEG4_Form: compositor_init_form(compositor, node); break;
	case TAG_MPEG4_Layer2D: compositor_init_layer2d(compositor, node); break;
	case TAG_MPEG4_Layout: compositor_init_layout(compositor, node); break;
	case TAG_MPEG4_PathLayout: compositor_init_path_layout(compositor, node); break;


	/*sensors*/
	case TAG_MPEG4_Anchor:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_Anchor:
#endif
		compositor_init_anchor(compositor, node); break;
	case TAG_MPEG4_DiscSensor: compositor_init_disc_sensor(compositor, node); break;
	case TAG_MPEG4_PlaneSensor2D: compositor_init_plane_sensor2d(compositor, node); break;
	case TAG_MPEG4_ProximitySensor2D: compositor_init_proximity_sensor2d(compositor, node); break;
	case TAG_MPEG4_TouchSensor:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_TouchSensor:
#endif
		compositor_init_touch_sensor(compositor, node); break;

	case TAG_MPEG4_Group:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_Group:
#endif
		compositor_init_group(compositor, node); break;
	case TAG_MPEG4_Rectangle:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_Rectangle2D:
#endif
		compositor_init_rectangle(compositor, node); break;
	case TAG_MPEG4_Shape:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_Shape:
#endif
		compositor_init_shape(compositor, node); break;
	case TAG_MPEG4_Switch:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_Switch:
#endif
		compositor_init_switch(compositor, node); break;

	case TAG_MPEG4_Text:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_Text:
#endif
		compositor_init_text(compositor, node); break;

#ifndef GPAC_DISABLE_3D
	case TAG_MPEG4_Background:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_Background:
#endif
		compositor_init_background(compositor, node);
		break;
	case TAG_MPEG4_CylinderSensor:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_CylinderSensor:
#endif
		compositor_init_cylinder_sensor(compositor, node);
		break;
	case TAG_MPEG4_PlaneSensor:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_PlaneSensor:
#endif
		compositor_init_plane_sensor(compositor, node);
		break;
	case TAG_MPEG4_ProximitySensor:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_ProximitySensor:
#endif
		compositor_init_proximity_sensor(compositor, node);
		break;
	case TAG_MPEG4_SphereSensor:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_SphereSensor:
#endif
		compositor_init_sphere_sensor(compositor, node);
		break;
	case TAG_MPEG4_VisibilitySensor:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_VisibilitySensor:
#endif
		compositor_init_visibility_sensor(compositor, node);
		break;
	case TAG_MPEG4_Box:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_Box:
#endif
		compositor_init_box(compositor, node);
		break;
	case TAG_MPEG4_Cone:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_Cone:
#endif
		compositor_init_cone(compositor, node);
		break;
	case TAG_MPEG4_Cylinder:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_Cylinder:
#endif
		compositor_init_cylinder(compositor, node);
		break;
	case TAG_MPEG4_ElevationGrid:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_ElevationGrid:
#endif
		compositor_init_elevation_grid(compositor, node);
		break;
	case TAG_MPEG4_Extrusion:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_Extrusion:
#endif
		compositor_init_extrusion(compositor, node);
		break;
	case TAG_MPEG4_IndexedFaceSet:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_IndexedFaceSet:
#endif
		compositor_init_ifs(compositor, node);
		break;
	case TAG_MPEG4_IndexedLineSet:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_IndexedLineSet:
#endif
		compositor_init_ils(compositor, node);
		break;
	case TAG_MPEG4_PointSet:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_PointSet:
#endif
		compositor_init_point_set(compositor, node);
		break;
	case TAG_MPEG4_Sphere:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_Sphere:
#endif
		compositor_init_sphere(compositor, node);
		break;
	case TAG_MPEG4_Billboard:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_Billboard:
#endif
		compositor_init_billboard(compositor, node);
		break;
	case TAG_MPEG4_Collision:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_Collision:
#endif
		compositor_init_collision(compositor, node);
		break;
	case TAG_MPEG4_LOD:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_LOD:
#endif
		compositor_init_lod(compositor, node);
		break;
	case TAG_MPEG4_Transform:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_Transform:
#endif
		compositor_init_transform(compositor, node);
		break;
	case TAG_MPEG4_Sound:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_Sound:
#endif
		compositor_init_sound(compositor, node);
		break;
	case TAG_MPEG4_Viewpoint:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_Viewpoint:
#endif
		compositor_init_viewpoint(compositor, node);
		break;
	case TAG_MPEG4_NavigationInfo:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_NavigationInfo:
#endif
		compositor_init_navigation_info(compositor, node);
		break;
	case TAG_MPEG4_Fog:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_Fog:
#endif
		compositor_init_fog(compositor, node);
		break;
	case TAG_MPEG4_DirectionalLight:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_DirectionalLight:
#endif
		compositor_init_directional_light(compositor, node);
		break;
	case TAG_MPEG4_PointLight:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_PointLight:
#endif
		compositor_init_point_light(compositor, node);
		break;
	case TAG_MPEG4_SpotLight:
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_SpotLight:
#endif
		compositor_init_spot_light(compositor, node);
		break;

	case TAG_MPEG4_NonLinearDeformer:
		compositor_init_non_linear_deformer(compositor, node);
		break;

	case TAG_MPEG4_Layer3D:
		compositor_init_layer3d(compositor, node);
		break;
	case TAG_MPEG4_CompositeTexture3D:
		compositor_init_compositetexture3d(compositor, node);
		break;

	case TAG_MPEG4_EnvironmentTest:
		compositor_init_envtest(compositor, node);
		break;
#endif


	/*X3D nodes*/
#ifndef GPAC_DISABLE_X3D
	case TAG_X3D_StaticGroup: compositor_init_static_group(compositor, node); break;
	case TAG_X3D_Disk2D: compositor_init_disk2d(compositor, node); break;
	case TAG_X3D_Arc2D: case TAG_X3D_ArcClose2D: compositor_init_arc2d(compositor, node); break;
	case TAG_X3D_Polyline2D: compositor_init_polyline2d(compositor, node); break;
	case TAG_X3D_TriangleSet2D: compositor_init_triangle_set2d(compositor, node); break;

#ifndef GPAC_DISABLE_3D
	case TAG_X3D_Polypoint2D: compositor_init_polypoint2d(compositor, node); break;
	case TAG_X3D_LineSet: compositor_init_lineset(compositor, node); break;
	case TAG_X3D_TriangleSet: compositor_init_triangle_set(compositor, node); break;
	case TAG_X3D_TriangleStripSet: compositor_init_triangle_strip_set(compositor, node); break;
	case TAG_X3D_TriangleFanSet: compositor_init_triangle_fan_set(compositor, node); break;
	case TAG_X3D_IndexedTriangleFanSet: compositor_init_indexed_triangle_fan_set(compositor, node); break;
	case TAG_X3D_IndexedTriangleStripSet: compositor_init_indexed_triangle_strip_set(compositor, node); break;
	case TAG_X3D_IndexedTriangleSet: compositor_init_indexed_triangle_set(compositor, node); break;
#endif

#endif /*GPAC_DISABLE_X3D*/

	case TAG_ProtoNode: compositor_init_hardcoded_proto(compositor, node); break;

	case TAG_MPEG4_SBVCAnimation:
		compositor_init_afx_node(compositor, node, & ((M_SBVCAnimation *)node)->url);
		break;
	case TAG_MPEG4_BitWrapper:
		compositor_init_afx_node(compositor, node, & ((M_BitWrapper *)node)->url);
		break;

#endif /*GPAC_DISABLE_VRML*/

#ifndef GPAC_DISABLE_SVG
	/* SVG Part */
	case TAG_SVG_svg:				compositor_init_svg_svg(compositor, node); break;
	case TAG_SVG_g:					compositor_init_svg_g(compositor, node); break;
	case TAG_SVG_switch:			compositor_init_svg_switch(compositor, node); break;
	case TAG_SVG_rect:				compositor_init_svg_rect(compositor, node); break;
	case TAG_SVG_path:				compositor_init_svg_path(compositor, node); break;
	case TAG_SVG_circle:			compositor_init_svg_circle(compositor, node); break;
	case TAG_SVG_ellipse:			compositor_init_svg_ellipse(compositor, node); break;
	case TAG_SVG_line:				compositor_init_svg_line(compositor, node); break;
	case TAG_SVG_polyline:			compositor_init_svg_polyline(compositor, node); break;
	case TAG_SVG_polygon:			compositor_init_svg_polygon(compositor, node); break;
	case TAG_SVG_a:					compositor_init_svg_a(compositor, node); break;

	case TAG_SVG_linearGradient:	compositor_init_svg_linearGradient(compositor, node); break;
	case TAG_SVG_radialGradient:	compositor_init_svg_radialGradient(compositor, node); break;
	case TAG_SVG_solidColor:		compositor_init_svg_solidColor(compositor, node); break;
	case TAG_SVG_stop:				compositor_init_svg_stop(compositor, node); break;

	case TAG_SVG_text:				compositor_init_svg_text(compositor, node); break;
	case TAG_SVG_tspan:				compositor_init_svg_tspan(compositor, node); break;
	case TAG_SVG_textArea:			compositor_init_svg_textarea(compositor, node); break;
	case TAG_SVG_tbreak:			compositor_init_svg_tbreak(compositor, node); break;

	case TAG_SVG_image:				compositor_init_svg_image(compositor, node); break;
	case TAG_SVG_video:				compositor_init_svg_video(compositor, node); break;
	case TAG_SVG_audio:				compositor_init_svg_audio(compositor, node, 0); break;

	/*SVG font support - note that we initialize the font when parsing the font-face element, not the font element*/
	case TAG_SVG_font_face:			compositor_init_svg_font(compositor, node); break;
	case TAG_SVG_missing_glyph:
	case TAG_SVG_glyph:
		compositor_init_svg_glyph(compositor, node);
		break;
	case TAG_SVG_font_face_uri:
		compositor_init_svg_font_face_uri(compositor, node); break;

	case TAG_SVG_use:				compositor_init_svg_use(compositor, node); break;
	case TAG_SVG_animation:			compositor_init_svg_animation(compositor, node); break;
	case TAG_SVG_foreignObject:		compositor_init_svg_foreign_object(compositor, node); break;

	case TAG_SVG_filter:			compositor_init_svg_filter(compositor, node); break;

	case TAG_LSR_updates:			compositor_init_svg_updates(compositor, node); break;
#endif

	default:
		GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[Compositor] node %s will not be rendered\n", gf_node_get_class_name(node)));
		break;
	}
}

Ejemplo n.º 2

Archivo: svg_media.c Proyecto: DmitrySigaev/gpac_hbbtv

static void SVG_Update_video(GF_TextureHandler *txh)
{
	GF_FieldInfo init_vis_info;
	SVG_video_stack *stack = (SVG_video_stack *) gf_node_get_private(txh->owner);
	
	if (!txh->is_open) {
		SVG_InitialVisibility init_vis;
		if (stack->first_frame_fetched) return;

		init_vis = SVG_INITIALVISIBILTY_WHENSTARTED;

		if (gf_node_get_attribute_by_tag(txh->owner, TAG_SVG_ATT_initialVisibility, GF_FALSE, GF_FALSE, &init_vis_info) == GF_OK) {
			init_vis = *(SVG_InitialVisibility *)init_vis_info.far_ptr;
		}

		/*opens stream only at first access to fetch first frame if needed*/
		if (init_vis == SVG_INITIALVISIBILTY_ALWAYS) {
			svg_play_texture((SVG_video_stack*)stack, NULL);
			gf_sc_invalidate(txh->compositor, NULL);
		}
		return;
	} 

	/*when fetching the first frame disable resync*/
	gf_sc_texture_update_frame(txh, GF_FALSE);

	/* only when needs_refresh = 1, first frame is fetched */
	if (!stack->first_frame_fetched) {
		if (txh->needs_refresh) {
			stack->first_frame_fetched = GF_TRUE;
			/*stop stream if needed*/
			if (!gf_smil_timing_is_active(txh->owner)) {
				gf_sc_texture_stop(txh);
				//make sure the refresh flag is not cleared
				txh->needs_refresh = GF_TRUE;
			}
		}
	}

	if (!stack->audio && stack->audio_dirty) {
		u32 res = gf_mo_has_audio(stack->txh.stream);
		if (res != 2) {
			stack->audio_dirty = GF_FALSE;
			if (res) {
				GF_FieldInfo att_vid, att_aud;
				stack->audio = gf_node_new(gf_node_get_graph(stack->txh.owner), TAG_SVG_audio);
				gf_node_register(stack->audio, NULL);
				if (gf_node_get_attribute_by_tag(stack->txh.owner, TAG_XLINK_ATT_href, GF_FALSE, GF_FALSE, &att_vid)==GF_OK) {
					gf_node_get_attribute_by_tag(stack->audio, TAG_XLINK_ATT_href, GF_TRUE, GF_FALSE, &att_aud);
					gf_svg_attributes_copy(&att_aud, &att_vid, GF_FALSE);
				}
				/*BYPASS SMIL TIMING MODULE!!*/
				compositor_init_svg_audio(stack->txh.compositor, stack->audio, GF_TRUE);
			}
		}
	}
	
	/*we have no choice but retraversing the graph until we're inactive since the movie framerate and
	the compositor framerate are likely to be different */
	if (!txh->stream_finished) 
	if (txh->needs_refresh)
		gf_sc_invalidate(txh->compositor, NULL);

	if (stack->stop_requested) {
		stack->stop_requested = GF_FALSE;
		gf_sc_texture_stop(&stack->txh);
	}
}