--- /dev/null
+/*\r
+ * GPAC - Multimedia Framework C SDK\r
+ *\r
+ * Copyright (c) Jean Le Feuvre 2000-2005 \r
+ * All rights reserved\r
+ *\r
+ * This file is part of GPAC / Stream Management sub-project\r
+ *\r
+ * GPAC is free software; you can redistribute it and/or modify\r
+ * it under the terms of the GNU Lesser General Public License as published by\r
+ * the Free Software Foundation; either version 2, or (at your option)\r
+ * any later version.\r
+ * \r
+ * GPAC is distributed in the hope that it will be useful,\r
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
+ * GNU Lesser General Public License for more details.\r
+ * \r
+ * You should have received a copy of the GNU Lesser General Public\r
+ * License along with this library; see the file COPYING. If not, write to\r
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. \r
+ *\r
+ */\r
+\r
+#ifndef _GF_TERMINAL_DEV_H_\r
+#define _GF_TERMINAL_DEV_H_\r
+\r
+#ifdef __cplusplus\r
+extern "C" {\r
+#endif\r
+\r
+\r
+#include <gpac/terminal.h>\r
+#include <gpac/mpeg4_odf.h>\r
+\r
+#include <gpac/modules/service.h>\r
+#include <gpac/modules/codec.h>\r
+#include <gpac/modules/ipmp.h>\r
+#include <gpac/mediaobject.h>\r
+#include <gpac/thread.h>\r
+\r
+typedef struct _inline_scene GF_InlineScene;\r
+typedef struct _media_manager GF_MediaManager;\r
+typedef struct _object_clock GF_Clock;\r
+typedef struct _es_channel GF_Channel;\r
+typedef struct _generic_codec GF_Codec;\r
+typedef struct _composition_memory GF_CompositionMemory;\r
+\r
+\r
+struct _net_service\r
+{\r
+ /*the module handling this service - must be declared first to typecast with GF_DownlaodSession upon deletion*/\r
+ GF_InputService *ifce;\r
+\r
+ /*the terminal*/\r
+ struct _tag_terminal *term;\r
+ /*service url*/\r
+ char *url;\r
+ /*od_manager owning service, NULL for services created for remote channels*/\r
+ struct _od_manager *owner;\r
+ /*number of attached remote channels ODM (ESD URLs)*/\r
+ u32 nb_ch_users;\r
+ /*number of attached remote ODM (OD URLs)*/\r
+ u32 nb_odm_users;\r
+ \r
+ /*clock objects. Kept at service level since ESID namespace is the service one*/\r
+ GF_List *Clocks;\r
+ /*all downloaders objects used in this service*/\r
+ GF_List *dnloads;\r
+ /*cache asscoiated with service, if any*/\r
+ GF_StreamingCache *cache;\r
+};\r
+\r
+\r
+/*opens service - performs URL concatenation if parent service specified*/\r
+GF_ClientService *gf_term_service_new(GF_Terminal *term, GF_ObjectManager *owner, const char *url, const char *parent_url, GF_Err *ret_code);\r
+/*destroy service*/\r
+void gf_term_service_del(GF_ClientService *nets);\r
+\r
+/*access to the module interfaces - cf net_api.h GF_InputService for details*/\r
+GF_Err gf_term_service_command(GF_ClientService *ns, GF_NetworkCommand *com);\r
+Bool gf_term_service_can_handle_url(GF_ClientService *ns, char *url);\r
+\r
+GF_Err gf_term_channel_get_sl_packet(GF_ClientService *ns, LPNETCHANNEL channel, char **out_data_ptr, u32 *out_data_size, GF_SLHeader *out_sl_hdr, Bool *is_compressed, GF_Err *out_reception_status, Bool *is_new_data);\r
+GF_Err gf_term_channel_release_sl_packet(GF_ClientService *ns, LPNETCHANNEL channel);\r
+\r
+/*cache open/close*/\r
+GF_Err gf_term_service_cache_load(GF_ClientService *ns);\r
+GF_Err gf_term_service_cache_close(GF_ClientService *ns, Bool no_save);\r
+\r
+/*forwards all clocks of the given amount of time. Can only be used when terminal is in paused mode\r
+this is mainly designed for movie dumping in MP4Client*/\r
+GF_Err gf_term_step_clocks(GF_Terminal * term, u32 ms_diff);\r
+\r
+void gf_term_sample_clocks(GF_Terminal *term);\r
+\r
+/*\r
+ Inline scene stuff\r
+*/\r
+struct _inline_scene\r
+{\r
+ /*root OD of the subscene, ALWAYS namespace of the parent scene*/\r
+ struct _od_manager *root_od;\r
+ /*scene codec: top level decoder decoding/generating the scene - can be BIFS, VRML parser, etc*/\r
+ struct _generic_codec *scene_codec;\r
+ /*OD codec - specific to MPEG-4, only present at the inline level (media ressources are always scoped here)*/\r
+ struct _generic_codec *od_codec;\r
+\r
+ /*struct _od_managers used, namespace of this scene. The chain does not have the root_od\r
+ it only contains OD sent through OD UPDATE in the OD stream(s) attached \r
+ to this scene. Remote ODs are not added, only there parents are*/\r
+ GF_List *ODlist;\r
+ /*list of MOs (links between OD and nodes)*/\r
+ GF_List *media_objects;\r
+ /*list of externproto libraries*/\r
+ GF_List *extern_protos;\r
+ /*list of nodes using this inline*/\r
+ GF_List *inline_nodes;\r
+ /*list of extra scene graphs (text streams, generic OSDs, ...)*/\r
+ GF_List *extra_scenes;\r
+ /*inline scene graph*/\r
+ GF_SceneGraph *graph;\r
+ /*graph state - if not attached, no traversing of inline\r
+ 0: not attached\r
+ 1: attached\r
+ 2: temp graph attached. The temp graph is generated when waiting for the first scene AU to be processed\r
+ */\r
+ u32 graph_attached;\r
+ /*togles inline restart - needed because the restart may be triggered from inside the scene or from\r
+ parent scene, hence 2 render passes must be used\r
+ special value 2 means scene URL changes (for anchor navigation*/\r
+ u32 needs_restart;\r
+ /*duration of inline scene*/\r
+ u64 duration;\r
+ /*if not 0, all objects in the scene will run on this clock. Needed in GPAC when clock references do not\r
+ respect object graph (eg IOD depending on external stream for clock)*/\r
+ u16 force_sub_clock_id;\r
+ /*world info node or title node*/\r
+ void *world_info;\r
+\r
+ Bool is_dynamic_scene;\r
+ /*clock for dynamic scene - current assumption is that all selected streams are synchronized in the dyn scene*/\r
+ GF_Clock *dyn_ck;\r
+ /*URLs of current video, audio and subs (we can't store objects since they may be destroyed when seeking)*/\r
+ SFURL visual_url, audio_url, text_url;\r
+ /*set to 1 when single time-line presentation with ONE OD AU is detected - the goal is to prevent\r
+ OD shutdown/startup when seeking. This will also remove unneeded net traffic for AddChannel/RemoveChannel\r
+ like RTSP TEARDOWN/SETUP*/\r
+ Bool static_media_ressources;\r
+\r
+ /*current simulation time of the compositor*/\r
+ Double simulation_time;\r
+\r
+ /*current IRI fragment if any*/\r
+ char *fragment_uri;\r
+\r
+ /*secondary resource scene*/\r
+ Bool secondary_resource;\r
+\r
+ char *redirect_xml_base;\r
+};\r
+\r
+GF_InlineScene *gf_inline_new(GF_InlineScene *parentScene);\r
+void gf_inline_del(GF_InlineScene *is);\r
+struct _od_manager *gf_inline_find_odm(GF_InlineScene *is, u16 OD_ID);\r
+void gf_inline_disconnect(GF_InlineScene *is, Bool for_shutdown);\r
+void gf_inline_remove_object(GF_InlineScene *is, GF_ObjectManager *odm, Bool for_shutdown);\r
+/*browse all (media) channels and send buffering info to the app*/\r
+void gf_inline_buffering_info(GF_InlineScene *is);\r
+void gf_inline_attach_to_compositor(GF_InlineScene *is);\r
+struct _mediaobj *gf_inline_get_media_object(GF_InlineScene *is, MFURL *url, u32 obj_type_hint, Bool lock_timelines);\r
+struct _mediaobj *gf_inline_get_media_object_ex(GF_InlineScene *is, MFURL *url, u32 obj_type_hint, Bool lock_timelines, struct _mediaobj *sync_ref, Bool always_load_new, GF_Node *node_ptr);\r
+void gf_inline_setup_object(GF_InlineScene *is, GF_ObjectManager *odm);\r
+/*restarts inline scene - care has to be taken not to remove the scene while it is traversed*/\r
+void gf_inline_restart(GF_InlineScene *is);\r
+/*updates scene duration based on settings*/\r
+void gf_inline_set_duration(GF_InlineScene *is);\r
+/*locate media object by ODID (non dynamic ODs) or URL (dynamic ODs)*/\r
+struct _mediaobj *gf_inline_find_object(GF_InlineScene *is, u16 ODID, char *url);\r
+/*returns scene time in sec - exact meaning of time depends on standard used*/\r
+Double gf_inline_get_time(void *_is);\r
+/*returns true if the given node DEF name is the url target view (eg blabla#myview)*/\r
+Bool gf_inline_default_scene_viewpoint(GF_Node *node);\r
+/*register extra scene graph for on-screen display*/\r
+void gf_inline_register_extra_graph(GF_InlineScene *is, GF_SceneGraph *extra_scene, Bool do_remove);\r
+/*forces scene size info (without changing pixel metrics) - this may be needed by modules using extra graphs (like timedtext)*/\r
+void gf_inline_force_scene_size(GF_InlineScene *is, u32 width, u32 height);\r
+/*regenerate a scene graph based on available objects - can only be called for dynamic OD streams*/\r
+void gf_inline_regenerate(GF_InlineScene *is);\r
+/*selects given ODM for dynamic scenes*/\r
+void gf_inline_select_object(GF_InlineScene *is, GF_ObjectManager *odm);\r
+/*restarts dynamic scene from given time: scene graph is not reseted, objects are just restarted\r
+instead of closed and reopened. If a media control is present on inline, from_time is overriden by MC range*/\r
+void gf_inline_restart_dynamic(GF_InlineScene *is, u64 from_time);\r
+/*owner inline node has been modified*/\r
+void gf_inline_on_modified(GF_Node *node);\r
+/*returns scene graph associated with an externProto lib - exported for VRML/X3D loaded*/\r
+GF_SceneGraph *gf_inline_get_proto_lib(void *_is, MFURL *lib_url);\r
+/*exported for compositor: handles filtering of "self" parameter indicating anchor only acts on container inline scene\r
+not root one. Returns 1 if handled (cf user.h, navigate event)*/\r
+Bool gf_inline_process_anchor(GF_Node *caller, GF_Event *evt);\r
+/*extern proto fetcher*/\r
+GF_SceneGraph *gf_inline_get_proto_lib(void *SceneCallback, MFURL *lib_url);\r
+void gf_inline_force_scene_size_video(GF_InlineScene *is, GF_MediaObject *mo);\r
+void gf_inline_sample_time(GF_InlineScene *is);\r
+/*compares object URL with another URL - ONLY USE THIS WITH DYNAMIC ODs*/\r
+Bool gf_mo_is_same_url(GF_MediaObject *obj, MFURL *inline_url);\r
+\r
+void gf_mo_update_caps(GF_MediaObject *mo);\r
+\r
+\r
+const char *gf_inline_get_fragment_uri(GF_Node *node);\r
+void gf_inline_set_fragment_uri(GF_Node *node, const char *uri);\r
+\r
+enum\r
+{\r
+ /*threading up to decoder*/\r
+ GF_TERM_THREAD_FREE,\r
+ /*single thread for all decoders*/\r
+ GF_TERM_THREAD_SINGLE,\r
+ /*all media (image, video, audio) decoders are threaded*/\r
+ GF_TERM_THREAD_MULTI,\r
+};\r
+\r
+enum\r
+{\r
+ GF_TERM_RUNNING= 1,\r
+ GF_TERM_DEAD = 1<<1,\r
+ GF_TERM_SINGLE_THREAD = 1<<2,\r
+ GF_TERM_MULTI_THREAD = 1<<3,\r
+ GF_TERM_SYSDEC_RESYNC = 1<<4,\r
+ GF_TERM_SINGLE_CLOCK = 1<<5,\r
+ GF_TERM_DRAW_FRAME = 1<<6\r
+};\r
+\r
+\r
+\r
+struct _tag_terminal\r
+{\r
+ u32 flags;\r
+\r
+ /*callback to user application*/ \r
+ GF_User *user;\r
+ /*scene compositor*/\r
+ struct __tag_compositor *compositor;\r
+ /*file downloader*/\r
+ GF_DownloadManager *downloader;\r
+ /*top level scene*/\r
+ GF_InlineScene *root_scene;\r
+\r
+ /*Media manager*/\r
+ GF_List *codecs;\r
+ /*mutex for decoder access*/\r
+ GF_Mutex *mm_mx;\r
+ /*decoding thread*/\r
+ GF_Thread *mm_thread;\r
+ /*last codec used in mm loop*/\r
+ u32 last_codec;\r
+ /*thread priority*/\r
+ s32 priority;\r
+ u32 cumulated_priority;\r
+ /*frame duration*/\r
+ u32 frame_duration;\r
+\r
+ /*net services*/\r
+ GF_List *net_services;\r
+ /*net services to be destroyed*/\r
+ GF_List *net_services_to_remove;\r
+ /*channels waiting for service CONNECT ack to be setup*/\r
+ GF_List *channels_pending;\r
+ /*media objects pending for stop/play*/\r
+ GF_List *media_queue;\r
+ /*network lock*/\r
+ GF_Mutex *net_mx;\r
+ /*all X3D key/mouse/string sensors*/\r
+ GF_List *x3d_sensors;\r
+ /*all input stream decoders*/\r
+ GF_List *input_streams;\r
+ \r
+ /*options (cf config doc)*/\r
+ Bool enable_cache;\r
+ /*data timeout for network buffering in ms - if no data is received within this timeout\r
+ the initial buffering aborts. */\r
+ u32 net_data_timeout;\r
+\r
+ u32 play_state;\r
+\r
+ u32 reload_state;\r
+ char *reload_url;\r
+\r
+ /*special list used by nodes needing a call to RenderNode but not in the traverese scene graph (VRML/MPEG-4 protos only). \r
+ For these nodes, the traverse effect passed will be NULL. This is only used by InputSensor node at the moment*/\r
+ GF_List *nodes_pending;\r
+\r
+ /*root node of the user prefs*/\r
+ GF_SceneGraph *dcci_doc;\r
+\r
+ GF_List *extensions;\r
+ GF_List *unthreaded_extensions;\r
+};\r
+\r
+\r
+\r
+GF_Err gf_term_init_scheduler(GF_Terminal *term, u32 threading_mode);\r
+void gf_term_stop_scheduler(GF_Terminal *term);\r
+void gf_term_add_codec(GF_Terminal *term, GF_Codec *codec);\r
+void gf_term_remove_codec(GF_Terminal *term, GF_Codec *codec);\r
+void gf_term_start_codec(GF_Codec *codec);\r
+void gf_term_stop_codec(GF_Codec *codec);\r
+void gf_term_set_threading(GF_Terminal *term, u32 mode);\r
+void gf_term_set_priority(GF_Terminal *term, s32 Priority);\r
+\r
+\r
+/*error report function*/\r
+void gf_term_message(GF_Terminal *app, const char *service, const char *message, GF_Err error);\r
+/*creates service for given OD / URL*/\r
+void gf_term_connect_object(GF_Terminal *app, GF_ObjectManager *odm, char *serviceURL, char *parent_url);\r
+/*creates service for given channel / URL*/\r
+GF_Err gf_term_connect_remote_channel(GF_Terminal *app, GF_Channel *ch, char *URL);\r
+\r
+/*called by media manager to perform service maintenance:\r
+servive shutdown: this is needed because service handler may be asynchronous\r
+object Play: this is needed to properly handle multiplexed sources (all channels must be connected before play)\r
+service restart\r
+*/\r
+void gf_term_handle_services(GF_Terminal *app);\r
+/*close service and queue for delete*/\r
+void gf_term_close_services(GF_Terminal *app, GF_ClientService *service);\r
+\r
+/*locks net manager*/\r
+void gf_term_lock_net(GF_Terminal *app, Bool LockIt);\r
+\r
+\r
+/*locks scene compositor*/\r
+void gf_term_lock_compositor(GF_Terminal *app, Bool LockIt);\r
+/*get scene compositor time - FIXME this is not flexible enough for SMIL/Multiple time containers*/\r
+u32 gf_term_get_time(GF_Terminal *term);\r
+/*forces scene composition*/\r
+void gf_term_invalidate_compositor(GF_Terminal *term);\r
+\r
+/*callbacks for scene graph library so that all related ESM nodes are properly instanciated*/\r
+void gf_term_node_callback(void *_is, u32 type, GF_Node *node, void *param);\r
+\r
+/*add/rem node requiring a call to render without being present in traversed graph (VRML/MPEG-4 protos). \r
+For these nodes, the traverse effect passed will be NULL.*/\r
+void gf_term_queue_node_traverse(GF_Terminal *term, GF_Node *node);\r
+void gf_term_unqueue_node_traverse(GF_Terminal *term, GF_Node *node);\r
+\r
+\r
+\r
+/*clock*/\r
+struct _object_clock \r
+{\r
+ u16 clockID; \r
+ GF_Terminal *term;\r
+ GF_Mutex *mx;\r
+ /*no_time_ctrl : set if ANY stream running on this clock has no time control capabilities - this avoids applying\r
+ mediaControl and others that would break stream dependencies*/\r
+ Bool use_ocr, clock_init, has_seen_eos, no_time_ctrl;\r
+ u32 init_time, StartTime, PauseTime, Paused;\r
+ /*the number of streams buffering on this clock*/\r
+ u32 Buffering;\r
+ /*associated media control if any*/\r
+ struct _media_control *mc;\r
+ /*for MC only (no FlexTime)*/\r
+ Fixed speed;\r
+ u32 discontinuity_time;\r
+ s32 drift;\r
+};\r
+\r
+/*destroys clock*/\r
+void gf_clock_del(GF_Clock *ck);\r
+/*finds a clock by ID or by ES_ID*/\r
+GF_Clock *gf_clock_find(GF_List *Clocks, u16 clockID, u16 ES_ID);\r
+/*attach clock returns a new clock or the clock this stream (ES_ID) depends on (OCR_ES_ID)\r
+hasOCR indicates whether the stream being attached carries object clock references\r
+@clocks: list of clocks in ES namespace (service)\r
+@is: inline scene to solve clock dependencies\r
+*/\r
+GF_Clock *gf_clock_attach(GF_List *clocks, GF_InlineScene *is, u16 OCR_ES_ID, u16 ES_ID, s32 hasOCR);\r
+/*reset clock (only called by channel owning clock)*/\r
+void gf_clock_reset(GF_Clock *ck);\r
+/*stops clock (only called for scene clock)*/\r
+void gf_clock_stop(GF_Clock *ck);\r
+/*return clock time in ms*/\r
+u32 gf_clock_time(GF_Clock *ck);\r
+/*return ellapsed time in ms since start of the clock*/\r
+u32 gf_clock_ellapse_time(GF_Clock *ck);\r
+/*sets clock time - FIXME: drift updates for OCRs*/\r
+void gf_clock_set_time(GF_Clock *ck, u32 TS);\r
+/*return clock time in ms without drift adjustment - used by audio objects only*/\r
+u32 gf_clock_real_time(GF_Clock *ck);\r
+/*pause the clock*/\r
+void gf_clock_pause(GF_Clock *ck);\r
+/*resume the clock*/\r
+void gf_clock_resume(GF_Clock *ck);\r
+/*returns true if clock started*/\r
+Bool gf_clock_is_started(GF_Clock *ck);\r
+/*toggles buffering on (clock is paused at the first stream buffering) */\r
+void gf_clock_buffer_on(GF_Clock *ck);\r
+/*toggles buffering off (clock is paused at the last stream restarting) */\r
+void gf_clock_buffer_off(GF_Clock *ck);\r
+/*set clock speed scaling factor*/\r
+void gf_clock_set_speed(GF_Clock *ck, Fixed speed);\r
+/*set clock drift - used to resync audio*/\r
+void gf_clock_adjust_drift(GF_Clock *ck, s32 ms_drift);\r
+\r
+enum\r
+{\r
+ /*channel is setup and waits for connection request*/\r
+ GF_ESM_ES_SETUP = 0,\r
+ /*waiting for server reply*/\r
+ GF_ESM_ES_WAIT_FOR_ACK,\r
+ /*connection OK*/\r
+ GF_ESM_ES_CONNECTED,\r
+ /*data exchange on this service/channel*/\r
+ GF_ESM_ES_RUNNING,\r
+ /*deconnection OK - a download channel can automatically disconnect when download is done*/\r
+ GF_ESM_ES_DISCONNECTED,\r
+ /*service/channel is not (no longer) available/found and should be removed*/\r
+ GF_ESM_ES_UNAVAILABLE\r
+};\r
+\r
+/*data channel (elementary stream)*/\r
+struct _es_channel \r
+{\r
+ /*security check on channel*/\r
+ u32 chan_id;\r
+ /*service this channel belongs to*/\r
+ GF_ClientService *service;\r
+ /*stream descriptor*/\r
+ GF_ESD *esd;\r
+ /*parent OD for this stream*/\r
+ struct _od_manager *odm;\r
+ u32 es_state;\r
+ Bool is_pulling;\r
+ u32 media_padding_bytes;\r
+ /*IO mutex*/\r
+ GF_Mutex *mx;\r
+ u32 AU_Count;\r
+ /*decoding buffers for push mode*/\r
+ struct _decoding_buffer * AU_buffer_first, * AU_buffer_last;\r
+ /*static decoding buffer for pull mode*/\r
+ struct _decoding_buffer * AU_buffer_pull;\r
+ /*channel buffer flag*/\r
+ Bool BufferOn;\r
+ /*min level to trigger buffering on, max to trigger it off. */\r
+ u32 MinBuffer, MaxBuffer;\r
+ /*amount of buffered media - this is the DTS of the last received AU minus the onject clock time, to make sure\r
+ we always have MaxBuffer ms ready for composition when resuming the clock*/\r
+ s32 BufferTime;\r
+ /*last received AU time - if exceeding a certain time and buffering is on, buffering is turned off.\r
+ This is needed for streams with very short duration (less than buffer time) and stream with only one AU (BIFS/OD)*/\r
+ u32 last_au_time;\r
+ /*Current reassemnbling buffer - currently packets are NOT reordered, only AUs are*/\r
+ char *buffer;\r
+ u32 len, allocSize;\r
+ /*only for last packet of an AU*/\r
+ u8 padingBits;\r
+ Bool IsEndOfStream;\r
+ /* SL reassembler */\r
+ /*current AU TSs*/\r
+ u32 DTS, CTS;\r
+ /*AU and Packet seq num info*/\r
+ u32 au_sn, pck_sn;\r
+ u32 max_au_sn, max_pck_sn;\r
+ /*the AU length indicated in the SL Header. */\r
+ u32 AULength;\r
+ /*state indicator: 0 OK, 1: not tuned in, 2: has error and needs RAP*/\r
+ u32 stream_state;\r
+ /*the AU in reception is RAP*/\r
+ Bool IsRap;\r
+ /*signal that next AU is an AU start*/\r
+ Bool NextIsAUStart;\r
+ /*if codec resilient, packet drops are not considered as fatal for AU reconstruction (eg no wait for RAP)*/\r
+ Bool codec_resilient;\r
+ /*when starting a channel, the first AU is ALWAYS fetched when buffering - this forces\r
+ BIFS and OD to be decoded and first frame render, in order to detect media objects that would also need\r
+ buffering - note this doesn't affect the clock, it is still paused if buffering*/\r
+ Bool first_au_fetched;\r
+\r
+ /* used in Carousel, to skip packets until the end of AU */ \r
+ Bool skip_carousel_au;\r
+ \r
+ /* TimeStamp to Media Time mapping*/\r
+ /*TS (in TSResolution) corresponding to the SeedTime of the decoder. Delivered by net, otherwise 0*/\r
+ u64 seed_ts;\r
+ /*media time offset corresponding to SeedTS. This is needed when the channel doesn't own the clock*/\r
+ u32 ts_offset;\r
+ /*scaling factors to remap to timestamps in milliseconds*/\r
+ u64 ts_res;\r
+ Double ocr_scale;\r
+ /*clock driving this stream - currently only CTS is supported (no OCR)*/\r
+ struct _object_clock *clock;\r
+ /*flag for clock init. Only a channel owning the clock will set this flag on clock init*/\r
+ Bool IsClockInit;\r
+\r
+ /*duration of last received AU if any, 0 if not known (most of the time)*/\r
+ u32 au_duration;\r
+ /*A channel with this flag set considers each incoming packet as a complete AU and assigns timestamps \r
+ upon reception matching the reception time, then dispatching it into the decoding buffer (only tested\r
+ with audi video). This flag is turned on by setting esd->slconfig->predefined to 'SLPredef_SkipSL' */\r
+ Bool skip_sl;\r
+\r
+ /*indicates that decoding can be called directly when receiving a complete AU on this channel\r
+ This is used by systems streams in non-seekable (eg broadcast/multicast, MPEG-2 TS multiplexes) to \r
+ make sure resources are setup as fast as possible. If the AU is too early, it will be kept in the \r
+ decoding buffer*/\r
+ Bool dispatch_after_db;\r
+\r
+ /*indicates that decoding is called directly when receiving a packet on this channel\r
+ This is used to bypass SL defragmenting and decoding buffer for EIT internal streams*/\r
+ Bool bypass_sl_and_db;\r
+\r
+ GF_IPMPTool *ipmp_tool;\r
+ Bool is_protected;\r
+\r
+ /*TSs as received from network - these are used for cache storage*/\r
+ u64 net_dts, net_cts;\r
+};\r
+\r
+/*creates a new channel for this stream*/\r
+GF_Channel *gf_es_new(GF_ESD *esd);\r
+/*destroys channel*/\r
+void gf_es_del(GF_Channel *ch);\r
+/*(un)locks channel*/\r
+void gf_es_lock(GF_Channel *ch, u32 LockIt);\r
+/*setup channel for reception of data*/\r
+GF_Err gf_es_start(GF_Channel *ch);\r
+/*stop channel from receiving data*/\r
+GF_Err gf_es_stop(GF_Channel *ch);\r
+/*handles reception of an SL PDU*/\r
+void gf_es_receive_sl_packet(GF_ClientService *serv, GF_Channel *ch, char *StreamBuf, u32 StreamLength, GF_SLHeader *header, GF_Err reception_status);\r
+/*signals end of stream on the channel*/\r
+void gf_es_on_eos(GF_Channel *ch);\r
+/*fetches first AU available for decoding on this channel*/\r
+struct _decoding_buffer *gf_es_get_au(GF_Channel *ch);\r
+/*drops first AU on this channel*/\r
+void gf_es_drop_au(GF_Channel *ch);\r
+/*performs final setup upon connection confirm*/\r
+void gf_es_on_connect(GF_Channel *ch);\r
+/*reconfigure SL for this channel*/\r
+void gf_es_reconfig_sl(GF_Channel *ch, GF_SLConfig *slc);\r
+/*hack for streaming: whenever a time map (media time <-> TS time) event is received on the channel reset decoding buffer\r
+this is needed because all server tested resend packets on already running channel*/\r
+void gf_es_map_time(GF_Channel *ch, Bool reset);\r
+/*dummy channels are used by scene decoders which don't use ESM but load directly the scene graph themselves\r
+these channels are ALWAYS pulling ones, and this function will init the channel clock if needed*/\r
+void gf_es_init_dummy(GF_Channel *ch);\r
+/*setup DRM info*/\r
+void gf_es_config_drm(GF_Channel *ch, GF_NetComDRMConfig *isma_cryp);\r
+\r
+/*\r
+ decoder stuff\r
+*/\r
+enum\r
+{\r
+ /*stop: the decoder is not playing*/\r
+ GF_ESM_CODEC_STOP = 0,\r
+ /*stop: the decoder is playing*/\r
+ GF_ESM_CODEC_PLAY = 1,\r
+ /*End Of Stream: when the base layer signals it's done, this triggers media-specific\r
+ handling of the CB. \r
+ For video, the output is kept alive, For audio, the output is reseted (don't want audio loop ;)*/\r
+ GF_ESM_CODEC_EOS = 2,\r
+ /*pause: the decoder is stoped but the CB is kept intact\r
+ THIS IS NOT USED AS A CODEC STATUS, but only for signaling that the CB shouldn't \r
+ be reseted - the real status of a "paused" decoder is STOP*/\r
+ GF_ESM_CODEC_PAUSE = 3,\r
+ /*Buffer: transition state: the decoder runs (fetch data/decode) but the clock\r
+ is not running (no composition). This is used for rebuffering channels (rtp...)*/\r
+ GF_ESM_CODEC_BUFFER = 4\r
+};\r
+\r
+enum\r
+{\r
+ GF_ESM_CODEC_HAS_UPSTREAM = 1,\r
+ /*the codec uses the interface from another codec (only used by private scene streams to handle\r
+ any intern sprite/animation streams)*/\r
+ GF_ESM_CODEC_IS_USE = 1<<1,\r
+ /*set for OD codec when static (ressources are declared in OD stream esd a la ISMA*/\r
+ GF_ESM_CODEC_IS_STATIC_OD = 1<<2,\r
+};\r
+\r
+struct _generic_codec \r
+{\r
+ /*codec type (streamType from base layer)*/\r
+ u32 type;\r
+ u32 flags;\r
+ /*current decoder interface */\r
+ GF_BaseDecoder *decio;\r
+ /*composition memory for media streams*/\r
+ struct _composition_memory *CB;\r
+ /*input media channles*/\r
+ GF_List *inChannels;\r
+ /*a pointer to the OD that owns the decoder.*/\r
+ struct _od_manager *odm;\r
+ u32 Status;\r
+ Bool Muted;\r
+ struct _object_clock *ck;\r
+ /*priority of this media object. This is ALWAYS the base layer priority\r
+ PriorityBoost is set when the CB is under critical limit (for now only audio uses the feature)\r
+ and results in a bigger time slice for the codec. Only on/off value for now*/\r
+ u32 Priority, PriorityBoost;\r
+ /*last processed DTS - sanity check for scalability*/\r
+ u32 last_unit_dts;\r
+ /*last processed CTS on base layer - seeking detection*/\r
+ u32 last_unit_cts;\r
+ /*in case the codec performs temporal re-ordering itself*/\r
+ Bool is_reordering;\r
+ u32 prev_au_size;\r
+ u32 bytes_per_sec;\r
+ Double fps;\r
+\r
+ /*statistics*/\r
+ u32 last_stat_start, cur_bit_size;\r
+ u32 avg_bit_rate, max_bit_rate;\r
+ u32 total_dec_time, nb_dec_frames, max_dec_time;\r
+ /*number of droped frames*/\r
+ u32 nb_droped;\r
+\r
+ /*for CTS reconstruction (channels not using SL): we cannot just update timing at each frame, not precise enough \r
+ since we use ms and not microsec TSs*/\r
+ u32 cur_audio_bytes, cur_video_frames;\r
+};\r
+\r
+GF_Codec *gf_codec_new(GF_ObjectManager *odm, GF_ESD *base_layer, s32 PL, GF_Err *e);\r
+void gf_codec_del(GF_Codec *codec);\r
+GF_Err gf_codec_add_channel(GF_Codec *codec, GF_Channel *ch);\r
+/*returns TRUE if stream was present, false otherwise*/\r
+Bool gf_codec_remove_channel(GF_Codec *codec, GF_Channel *ch);\r
+GF_Err gf_codec_process(GF_Codec *codec, u32 TimeAvailable);\r
+GF_Err gf_codec_get_capability(GF_Codec *codec, GF_CodecCapability *cap);\r
+GF_Err gf_codec_set_capability(GF_Codec *codec, GF_CodecCapability cap);\r
+void gf_codec_set_status(GF_Codec *codec, u32 Status);\r
+/*returns a new codec using an existing loaded decoder - only used by private scene to handle != timelines, for \r
+instance when loading a BT with an animation stream*/\r
+GF_Codec *gf_codec_use_codec(GF_Codec *codec, GF_ObjectManager *odm);\r
+\r
+/*OD manager*/\r
+\r
+enum\r
+{\r
+ /*flag set if object cannot be time-controloed*/\r
+ GF_ODM_NO_TIME_CTRL = (1<<1),\r
+ /*flag set if subscene uses parent scene timeline*/\r
+ GF_ODM_INHERIT_TIMELINE = (1<<2),\r
+ /*flag set if object has been redirected*/\r
+ GF_ODM_REMOTE_OD = (1<<3),\r
+ /*flag set if object has profile indications*/\r
+ GF_ODM_HAS_PROFILES = (1<<4),\r
+ /*flag set if object governs profile of inline subscenes*/\r
+ GF_ODM_INLINE_PROFILES = (1<<5),\r
+ /*flag set if object declared by network service, not from OD stream*/\r
+ GF_ODM_NOT_IN_OD_STREAM = (1<<6),\r
+\r
+ /*dynamic flags*/\r
+ \r
+ /*flag set if associated subscene must be regenerated*/\r
+ GF_ODM_REGENERATE_SCENE = (1<<10),\r
+};\r
+\r
+enum\r
+{\r
+ GF_ODM_STATE_STOP,\r
+ GF_ODM_STATE_PLAY,\r
+ GF_ODM_STATE_IN_SETUP,\r
+ GF_ODM_STATE_BLOCKED,\r
+};\r
+\r
+struct _od_manager\r
+{\r
+ /*pointer to terminal*/\r
+ struct _tag_terminal *term;\r
+ /*the service used by this ODM. If the service private data is this ODM, then the service was created for this ODM*/\r
+ GF_ClientService *net_service;\r
+ /*parent scene or NULL for root scene*/\r
+ struct _inline_scene *parentscene;\r
+ /*channels associated with this object (media channels, OCR, IPMP, OCI, etc)*/\r
+ GF_List *channels;\r
+ /*sub scene for inline/animation or NULL */\r
+ struct _inline_scene *subscene;\r
+ /*object codec (media or BIFS for AnimationStream) attached if any*/\r
+ struct _generic_codec *codec;\r
+ /*OCI codec attached if any*/\r
+ struct _generic_codec *oci_codec;\r
+ /*OCR codec attached if any*/\r
+ struct _generic_codec *ocr_codec;\r
+\r
+ /*MPEG-4 object descriptor*/\r
+ GF_ObjectDescriptor *OD;\r
+\r
+ /*exclusive access is required since rendering and media management don't always take place in the same thread*/\r
+ GF_Mutex *mx;\r
+\r
+ u32 flags;\r
+\r
+ /*PLs*/\r
+ u8 Audio_PL, Graphics_PL, OD_PL, Scene_PL, Visual_PL;\r
+ \r
+ /*interface with scene rendering*/\r
+ struct _mediaobj *mo;\r
+ \r
+ /*number of channels with connection not yet acknowledge*/\r
+ u32 pending_channels;\r
+ u32 state;\r
+ /* during playback: timing as evaluated by the composition memory or the scene codec */\r
+ u32 current_time;\r
+ /*full object duration 0 if unknown*/\r
+ u64 duration;\r
+ /*\r
+ upon start: media start time as requested by scene compositor (eg not media control)\r
+ set to -1 upon stop to postpone stop request\r
+ */\r
+ u64 media_start_time, media_stop_time;\r
+\r
+ /*the one and only media control currently attached to this object*/\r
+ struct _media_control *media_ctrl;\r
+ /*the list of media control controling the object*/\r
+ GF_List *mc_stack;\r
+ /*the media sensor(s) attached to this object*/\r
+ GF_List *ms_stack;\r
+};\r
+\r
+\r
+GF_ObjectManager *gf_odm_new();\r
+void gf_odm_del(GF_ObjectManager *ODMan);\r
+void gf_odm_lock(GF_ObjectManager *odm, u32 LockIt);\r
+\r
+/*setup service entry point*/\r
+void gf_odm_setup_entry_point(GF_ObjectManager *odm, const char *sub_url);\r
+/*setup OD*/\r
+void gf_odm_setup_object(GF_ObjectManager *odm, GF_ClientService *parent_serv);\r
+/*disctonnect OD and removes it if desired (otherwise only STOP is propagated)*/\r
+void gf_odm_disconnect(GF_ObjectManager *odman, Bool do_remove);\r
+/*setup an ESD*/\r
+GF_Err gf_odm_setup_es(GF_ObjectManager *odm, GF_ESD *esd, GF_ClientService *service, GF_MediaObject *sync_ref);\r
+/*removes an ESD (this destroys associated channel if any)*/\r
+void gf_odm_remove_es(GF_ObjectManager *odm, u16 ES_ID);\r
+/*set stream duration - updates object duration accordingly*/\r
+void gf_odm_set_duration(GF_ObjectManager *odm, GF_Channel *, u64 stream_duration);\r
+/*signals end of stream on channels*/\r
+void gf_odm_on_eos(GF_ObjectManager *odm, GF_Channel *);\r
+/*start Object streams and queue object for network PLAY*/\r
+void gf_odm_start(GF_ObjectManager *odm);\r
+/*stop OD streams*/\r
+void gf_odm_stop(GF_ObjectManager *odm, Bool force_close);\r
+/*send PLAY request to network - needed to properly handle multiplexed inputs \r
+ONLY called by service handler (media manager thread)*/\r
+void gf_odm_play(GF_ObjectManager *odm);\r
+\r
+/*returns 1 if this is a segment switch, 0 otherwise - takes care of object restart if segment switch*/\r
+Bool gf_odm_check_segment_switch(GF_ObjectManager *odm);\r
+/*pause object (mediaControl use only)*/\r
+void gf_odm_pause(GF_ObjectManager *odm);\r
+/*resume object (mediaControl use only)*/\r
+void gf_odm_resume(GF_ObjectManager *odm);\r
+/*set object speed*/\r
+void gf_odm_set_speed(GF_ObjectManager *odm, Fixed speed);\r
+/*returns the clock of the media stream (video, audio or bifs), NULL otherwise */\r
+struct _object_clock *gf_odm_get_media_clock(GF_ObjectManager *odm);\r
+/*adds segment descriptors targeted by the URL to the list and sort them - the input list must be empty*/\r
+void gf_odm_init_segments(GF_ObjectManager *odm, GF_List *list, MFURL *url);\r
+/*returns true if this OD depends on the given clock*/\r
+Bool gf_odm_shares_clock(GF_ObjectManager *odm, struct _object_clock *ock);\r
+\r
+GF_Segment *gf_odm_find_segment(GF_ObjectManager *odm, char *descName);\r
+/*locks ODM with destruction check - returns 0 if object manager is not attached to object*/\r
+Bool gf_odm_lock_mo(struct _mediaobj *mo);\r
+\r
+\r
+/*GF_MediaObject: link between real object manager and scene. although there is a one-to-one mapping between a \r
+MediaObject and an ObjectManager, we have to keep them seperated in order to handle OD remove commands which destroy\r
+ObjectManagers. */\r
+struct _mediaobj\r
+{\r
+ /*type is as defined in constants.h # GF_MEDIA_OBJECT_* */\r
+ u32 type;\r
+ /*one of the above flags*/\r
+ u32 flags;\r
+\r
+\r
+ /* private to ESM*/\r
+\r
+ /*media object manager - private to the sync engine*/\r
+ struct _od_manager *odm;\r
+ /*OD ID of the object*/\r
+ u32 OD_ID;\r
+ /*OD URL for object not using MPEG4 OD urls*/\r
+ MFURL URLs;\r
+ /*session join*/\r
+ u32 num_open;\r
+ /*shared object restart handling*/\r
+ u32 num_to_restart, num_restart;\r
+ Fixed speed;\r
+\r
+ /*shared object info: if 0 a new frame will be checked, otherwise current is returned*/\r
+ u32 nb_fetch;\r
+ /*frame presentation time*/\r
+ u32 timestamp;\r
+ /*data frame size*/\r
+ u32 framesize;\r
+ /*pointer to data frame */\r
+ char *frame;\r
+ /*nodes currently registered with the media object - used to dispatch MediaAccessEvents*/\r
+ GF_List *nodes;\r
+ /*pointer to the node responsible for the creation of this media object\r
+ ONLY used for scene media type (animationStreams) \r
+ Reset upon creation of the decoder.\r
+ */\r
+ void *node_ptr;\r
+};\r
+\r
+GF_MediaObject *gf_mo_new();\r
+\r
+\r
+/*used for delayed channel setup*/\r
+typedef struct \r
+{\r
+ struct _generic_codec *dec;\r
+ struct _es_channel *ch; \r
+} GF_ChannelSetup;\r
+\r
+/*post-poned channel connect*/\r
+GF_Err gf_odm_post_es_setup(struct _es_channel *ch, struct _generic_codec *dec, GF_Err err);\r
+\r
+/*\r
+ special entry point: specify directly a service interface for service input\r
+*/\r
+void gf_term_attach_service(GF_Terminal *term, GF_InputService *service_hdl);\r
+\r
+/*media access events */\r
+void gf_term_service_media_event(GF_ObjectManager *odm, u32 event_type);\r
+\r
+u32 URL_GetODID(MFURL *url);\r
+\r
+#ifdef __cplusplus\r
+}\r
+#endif\r
+\r
+\r
+#endif /*_GF_TERMINAL_DEV_H_*/\r
+\r
+\r
OSDN Git Service
