GF_BaseDecoder *NewODDec() { GF_SceneDecoder *tmp; ODPriv *priv; GF_SAFEALLOC(tmp, GF_SceneDecoder); if (!tmp) return NULL; GF_SAFEALLOC(priv, ODPriv); tmp->privateStack = priv; tmp->AttachStream = ODF_AttachStream; tmp->DetachStream = ODF_DetachStream; tmp->GetCapabilities = ODF_GetCapabilities; tmp->SetCapabilities = ODF_SetCapabilities; tmp->ProcessData = ODF_ProcessData; tmp->AttachScene = ODF_AttachScene; tmp->CanHandleStream = ODF_CanHandleStream; GF_REGISTER_MODULE_INTERFACE(tmp, GF_SCENE_DECODER_INTERFACE, "GPAC OD Decoder", "gpac distribution") return (GF_BaseDecoder *) tmp; }
void svg_sani_init_linearGradient(Render2D *sr, GF_Node *node) { SVG_SANI_GradientStack *st; GF_SAFEALLOC(st, SVG_SANI_GradientStack); gf_sr_texture_setup(&st->txh, sr->compositor, node); st->txh.update_texture_fcnt = svg_sani_UpdateLinearGradient; st->txh.compute_gradient_matrix = svg_sani_LG_ComputeMatrix; gf_node_set_private(node, st); gf_node_set_callback_function(node, svg_sani_render_PaintServer); }
void InitMediaSensor(GF_Scene *scene, GF_Node *node) { MediaSensorStack *st; GF_SAFEALLOC(st, MediaSensorStack); st->parent = scene; st->sensor = (M_MediaSensor *)node; st->seg = gf_list_new(); gf_node_set_callback_function(node, RenderMediaSensor); gf_node_set_private(node, st); }
GF_EXPORT GF_Command *gf_sg_command_new(GF_SceneGraph *graph, u32 tag) { GF_Command *ptr; GF_SAFEALLOC(ptr, GF_Command); if (!ptr) return NULL; ptr->tag = tag; ptr->in_scene = graph; ptr->command_fields = gf_list_new(); if (tag < GF_SG_LAST_BIFS_COMMAND) ptr->new_proto_list = gf_list_new(); return ptr; }
void compositor_init_untransform(GF_Compositor *compositor, GF_Node *node) { Untransform tr; if (Untransform_GetNode(node, &tr)) { UntransformStack *stack; GF_SAFEALLOC(stack, UntransformStack); gf_node_set_private(node, stack); gf_node_set_callback_function(node, TraverseUntransform); stack->untr = tr; gf_node_proto_set_grouping(node); } }
GF_BaseDecoder *NewLSRDec() { LSRPriv *priv; GF_SceneDecoder *tmp; GF_SAFEALLOC(tmp, GF_SceneDecoder); if (!tmp) return NULL; GF_SAFEALLOC(priv, LSRPriv); priv->codec = NULL; tmp->privateStack = priv; tmp->AttachStream = LSR_AttachStream; tmp->DetachStream = LSR_DetachStream; tmp->GetCapabilities = LSR_GetCapabilities; tmp->SetCapabilities = LSR_SetCapabilities; tmp->ProcessData = LSR_ProcessData; tmp->AttachScene = LSR_AttachScene; tmp->CanHandleStream = LSR_CanHandleStream; tmp->ReleaseScene = LSR_ReleaseScene; GF_REGISTER_MODULE_INTERFACE(tmp, GF_SCENE_DECODER_INTERFACE, "GPAC LASeR Decoder", "gpac distribution") return (GF_BaseDecoder *) tmp; }
void compositor_init_layer2d(GF_Compositor *compositor, GF_Node *node) { Layer2DStack *stack; GF_SAFEALLOC(stack, Layer2DStack); stack->backs = gf_list_new(); stack->views = gf_list_new(); stack->first = 1; gf_node_set_private(node, stack); gf_node_set_callback_function(node, TraverseLayer2D); }
GF_BaseDecoder *NewOSVCDec() { GF_MediaDecoder *ifcd; OSVCDec *dec; GF_SAFEALLOC(ifcd, GF_MediaDecoder); GF_SAFEALLOC(dec, OSVCDec); GF_REGISTER_MODULE_INTERFACE(ifcd, GF_MEDIA_DECODER_INTERFACE, "OpenSVC Decoder", "gpac distribution") ifcd->privateStack = dec; /*setup our own interface*/ ifcd->AttachStream = OSVC_AttachStream; ifcd->DetachStream = OSVC_DetachStream; ifcd->GetCapabilities = OSVC_GetCapabilities; ifcd->SetCapabilities = OSVC_SetCapabilities; ifcd->GetName = OSVC_GetCodecName; ifcd->CanHandleStream = OSVC_CanHandleStream; ifcd->ProcessData = OSVC_ProcessData; return (GF_BaseDecoder *) ifcd; }
GF_EXPORT GF_SceneManager *gf_sm_new(GF_SceneGraph *graph) { GF_SceneManager *tmp; if (!graph) return NULL; GF_SAFEALLOC(tmp, GF_SceneManager); if (!tmp) return NULL; tmp->streams = gf_list_new(); tmp->scene_graph = graph; return tmp; }
GF_BaseDecoder *NewFAADDec() { GF_MediaDecoder *ifce; FAADDec *dec; GF_SAFEALLOC(ifce, GF_MediaDecoder); GF_SAFEALLOC(dec, FAADDec); GF_REGISTER_MODULE_INTERFACE(ifce, GF_MEDIA_DECODER_INTERFACE, "FAAD2 Decoder", "gpac distribution") ifce->privateStack = dec; /*setup our own interface*/ ifce->AttachStream = FAAD_AttachStream; ifce->DetachStream = FAAD_DetachStream; ifce->GetCapabilities = FAAD_GetCapabilities; ifce->SetCapabilities = FAAD_SetCapabilities; ifce->ProcessData = FAAD_ProcessData; ifce->CanHandleStream = FAAD_CanHandleStream; ifce->GetName = FAAD_GetCodecName; return (GF_BaseDecoder *) ifce; }
GF_InputService *NewSAFReader() { SAFIn *reader; GF_InputService *plug; GF_SAFEALLOC(plug, GF_InputService); GF_REGISTER_MODULE_INTERFACE(plug, GF_NET_CLIENT_INTERFACE, "GPAC SAF Reader", "gpac distribution") plug->RegisterMimeTypes = SAF_RegisterMimeTypes; plug->CanHandleURL = SAF_CanHandleURL; plug->ConnectService = SAF_ConnectService; plug->CloseService = SAF_CloseService; plug->GetServiceDescriptor = SAF_GetServiceDesc; plug->ConnectChannel = SAF_ConnectChannel; plug->DisconnectChannel = SAF_DisconnectChannel; plug->ServiceCommand = SAF_ServiceCommand; GF_SAFEALLOC(reader, SAFIn); reader->channels = gf_list_new(); plug->priv = reader; return plug; }
void compositor_init_offscreen_group(GF_Compositor *compositor, GF_Node *node) { OffscreenGroup og; if (OffscreenGroup_GetNode(node, &og)) { OffscreenGroupStack *stack; GF_SAFEALLOC(stack, OffscreenGroupStack); gf_node_set_private(node, stack); gf_node_set_callback_function(node, TraverseOffscreenGroup); stack->og = og; if (og.offscreen) stack->flags |= GROUP_IS_CACHED; gf_node_proto_set_grouping(node); } }
void compositor_init_hc_flashshape(GF_Compositor *compositor, GF_Node *node) { FSStack *stack; GF_SAFEALLOC(stack, FSStack); stack->drawable = drawable_new(); stack->drawable->node = node; stack->drawable->flags = DRAWABLE_USE_TRAVERSE_DRAW; stack->items = gf_list_new(); gf_node_set_private(node, stack); gf_node_set_callback_function(node, fs_traverse); }
void compositor_init_animationstream(GF_Compositor *compositor, GF_Node *node) { AnimationStreamStack *st; GF_SAFEALLOC(st, AnimationStreamStack); st->compositor = compositor; st->time_handle.UpdateTimeNode = animationstream_update_time; st->time_handle.udta = node; gf_node_set_private(node, st); gf_node_set_callback_function(node, animationstream_destroy); gf_sc_register_time_node(compositor, &st->time_handle); }
GF_SURFACE evg_surface_new(GF_Raster2D *_dr, Bool center_coords) { EVGSurface *_this; GF_SAFEALLOC(_this, EVGSurface); if (_this) { _this->center_coords = center_coords; _this->texture_filter = GF_TEXTURE_FILTER_DEFAULT; _this->ftparams.source = &_this->ftoutline; _this->ftparams.user = _this; _this->raster = evg_raster_new(); } return _this; }
void *NewAudioFilter() { FilterContext *ctx; GF_AudioFilter *mod; GF_SAFEALLOC(ctx, FilterContext); if(!ctx) return NULL; GF_SAFEALLOC(mod, GF_AudioFilter); if(!mod) { gf_free(ctx); return NULL; } mod->udta = ctx; mod->SetFilter = SetFilter; mod->Configure = Configure; mod->Process = ProcessIdentity; mod->SetOption = SetOption; mod->Reset = Reset; GF_REGISTER_MODULE_INTERFACE(mod, GF_AUDIO_FILTER_INTERFACE, "Sample Audio Filter", "gpac distribution"); return mod; }
GF_EXPORT GF_SDPMedia *gf_sdp_media_new() { GF_SDPMedia *tmp; GF_SAFEALLOC(tmp, GF_SDPMedia); tmp->FMTP = gf_list_new(); tmp->RTPMaps = gf_list_new(); tmp->Attributes = gf_list_new(); tmp->Connections = gf_list_new(); tmp->Bandwidths = gf_list_new(); tmp->Quality = -1; return tmp; }
GF_TermExt *validator_new() { GF_TermExt *dr; GF_Validator *validator; dr = (GF_TermExt*)gf_malloc(sizeof(GF_TermExt)); memset(dr, 0, sizeof(GF_TermExt)); GF_REGISTER_MODULE_INTERFACE(dr, GF_TERM_EXT_INTERFACE, "GPAC Test Validator", "gpac distribution"); GF_SAFEALLOC(validator, GF_Validator); dr->process = validator_process; dr->udta = validator; return dr; }
GF_TermExt *uir_new() { GF_TermExt *dr; GF_UIRecord *uir; dr = (GF_TermExt*)gf_malloc(sizeof(GF_TermExt)); memset(dr, 0, sizeof(GF_TermExt)); GF_REGISTER_MODULE_INTERFACE(dr, GF_TERM_EXT_INTERFACE, "GPAC UI Recorder", "gpac distribution"); GF_SAFEALLOC(uir, GF_UIRecord); dr->process = uir_process; dr->udta = uir; return dr; }
GF_EXPORT GF_AUContext *gf_sm_stream_au_new(GF_StreamContext *stream, u64 timing, Double time_sec, Bool isRap) { u32 i; GF_AUContext *tmp; u64 tmp_timing; tmp_timing = timing ? timing : (u64) (time_sec*1000); if (stream->imp_exp_time >= tmp_timing) { /*look for existing AU*/ i=0; while ((tmp = (GF_AUContext *)gf_list_enum(stream->AUs, &i))) { if (timing && (tmp->timing==timing)) return tmp; else if (time_sec && (tmp->timing_sec == time_sec)) return tmp; else if (!time_sec && !timing && !tmp->timing && !tmp->timing_sec) return tmp; /*insert AU*/ else if ((time_sec && time_sec<tmp->timing_sec) || (timing && timing<tmp->timing)) { GF_SAFEALLOC(tmp, GF_AUContext); tmp->commands = gf_list_new(); if (isRap) tmp->flags = GF_SM_AU_RAP; tmp->timing = timing; tmp->timing_sec = time_sec; tmp->owner = stream; gf_list_insert(stream->AUs, tmp, i-1); return tmp; } } } GF_SAFEALLOC(tmp, GF_AUContext); tmp->commands = gf_list_new(); if (isRap) tmp->flags = GF_SM_AU_RAP; tmp->timing = timing; tmp->timing_sec = time_sec; tmp->owner = stream; if (stream->disable_aggregation) tmp->flags |= GF_SM_AU_NOT_AGGREGATED; gf_list_add(stream->AUs, tmp); stream->imp_exp_time = tmp_timing; return tmp; }
void InitAnimationStream(GF_Renderer *sr, GF_Node *node) { AnimationStreamStack *st; GF_SAFEALLOC(st, AnimationStreamStack); gf_sr_traversable_setup(st, node, sr); st->time_handle.UpdateTimeNode = AS_UpdateTime; st->time_handle.obj = node; gf_node_set_private(node, st); gf_node_set_callback_function(node, DestroyAnimationStream); gf_sr_register_time_node(sr, &st->time_handle); }
static void StatNode(GF_SceneStatistics *stat, GF_Node *n, Bool isUsed, Bool isDelete, GF_Node *prev) { u32 i; GF_NodeStats *ptr = NULL; if (!stat) return; if (n->sgprivate->tag == TAG_ProtoNode) { #ifndef GPAC_DISABLE_VRML GF_ProtoInstance *pr = (GF_ProtoInstance *)n; i=0; while ((ptr = (GF_NodeStats *)gf_list_enum(stat->proto_stats, &i))) { if (pr->proto_interface->ID == ptr->tag) break; ptr = NULL; } if (!ptr) { GF_SAFEALLOC(ptr, GF_NodeStats); ptr->tag = pr->proto_interface->ID; ptr->name = gf_sg_proto_get_class_name(pr->proto_interface); gf_list_add(stat->proto_stats, ptr); } #endif } else { i=0; while ((ptr = (GF_NodeStats *)gf_list_enum(stat->node_stats, &i))) { if (n->sgprivate->tag == ptr->tag) break; ptr = NULL; } if (!ptr) { GF_SAFEALLOC(ptr, GF_NodeStats); ptr->tag = n->sgprivate->tag; ptr->name = gf_node_get_class_name(n); gf_list_add(stat->node_stats, ptr); } } if (isDelete) ptr->nb_del += n->sgprivate->num_instances; else if (isUsed) ptr->nb_used += 1; /*this is because the node passes twice in the stat, once on DumpNode and once in replaceALL*/ else ptr->nb_created += prev ? (prev->sgprivate->num_instances - 1) : 1; }
void compositor_init_depth_group(GF_Compositor *compositor, GF_Node *node) { DepthGroup dg; if (DepthGroup_GetNode(node, &dg)) { DepthGroupStack *stack; GF_SAFEALLOC(stack, DepthGroupStack); gf_node_set_private(node, stack); gf_node_set_callback_function(node, TraverseDepthGroup); stack->dg = dg; gf_node_proto_set_grouping(node); } else GF_LOG(GF_LOG_DEBUG, GF_LOG_COMPOSE, ("[Compositor2D] Unable to initialize depth group \n")); }
void R2D_InitRadialGradient(Render2D *sr, GF_Node *node) { GradientStack *st; GF_SAFEALLOC(st, GradientStack); gf_sr_texture_setup(&st->txh, sr->compositor, node); st->txh.update_texture_fcnt = UpdateRadialGradient; st->txh.compute_gradient_matrix = RG_ComputeMatrix; gf_node_set_private(node, st); gf_node_set_callback_function(node, DestroyRadialGradient); }
static void b2D_new_status(Background2DStack *bck, M_Background2D*back) { BackgroundStatus *status; GF_SAFEALLOC(status, BackgroundStatus); gf_mx2d_init(status->ctx.transform); status->ctx.drawable = bck->drawable; status->ctx.flags = CTX_IS_BACKGROUND; status->ctx.bi = &status->bi; status->ctx.aspect.fill_color = GF_COL_ARGB_FIXED(FIX_ONE, back->backColor.red, back->backColor.green, back->backColor.blue); status->ctx.aspect.fill_texture = &bck->txh; gf_list_add(bck->status_stack, status); }
GF_TermExt *osd_new() { GF_TermExt *dr; GF_OSD *osd; dr = (GF_TermExt*)gf_malloc(sizeof(GF_TermExt)); memset(dr, 0, sizeof(GF_TermExt)); GF_REGISTER_MODULE_INTERFACE(dr, GF_TERM_EXT_INTERFACE, "GPAC OnSscreen Display", "gpac distribution"); GF_SAFEALLOC(osd, GF_OSD); dr->process = osd_process; dr->udta = osd; return dr; }
GF_EXPORT void gf_mixer_add_input(GF_AudioMixer *am, GF_AudioInterface *src) { MixerInput *in; if (gf_mixer_is_src_present(am, src)) return; gf_mixer_lock(am, GF_TRUE); GF_SAFEALLOC(in, MixerInput); in->src = src; gf_list_add(am->sources, in); am->must_reconfig = GF_TRUE; am->isEmpty = GF_FALSE; gf_mixer_lock(am, GF_FALSE); }
static void on_dom_text_content(void *cbk, const char *content, Bool is_cdata) { GF_DOMParser *par = (GF_DOMParser *)cbk; GF_XMLNode *node; GF_XMLNode *last = (GF_XMLNode *)gf_list_last(par->stack); if (!last) return; assert(last->content); GF_SAFEALLOC(node, GF_XMLNode); node->type = is_cdata ? GF_XML_CDATA_TYPE : GF_XML_TEXT_TYPE; node->name = gf_strdup(content); gf_list_add(last->content, node); }
void compositor_init_audiosource(GF_Compositor *compositor, GF_Node *node) { AudioSourceStack *st; GF_SAFEALLOC(st, AudioSourceStack); gf_sc_audio_setup(&st->input, compositor, node); st->time_handle.UpdateTimeNode = audiosource_update_time; st->time_handle.udta = node; gf_node_set_private(node, st); gf_node_set_callback_function(node, audiosource_traverse); gf_sc_register_time_node(compositor, &st->time_handle); }
GF_Codec *gf_codec_use_codec(GF_Codec *codec, GF_ObjectManager *odm) { GF_Codec *tmp; if (!codec->decio) return NULL; GF_SAFEALLOC(tmp, GF_Codec); tmp->type = codec->type; tmp->inChannels = gf_list_new(); tmp->Status = GF_ESM_CODEC_STOP; tmp->odm = odm; tmp->flags = codec->flags | GF_ESM_CODEC_IS_USE; tmp->decio = codec->decio; return tmp; }