OSDN Git Service

stop using trunk directory in rectool
[rec10/rec10-git.git] / tstools / DtsEdit / src / gpac / internal / compositor_dev.h
1 /*\r
2  *                      GPAC - Multimedia Framework C SDK\r
3  *\r
4  *                      Copyright (c) Jean Le Feuvre 2000-2005 \r
5  *                                      All rights reserved\r
6  *\r
7  *  This file is part of GPAC / Scene Rendering sub-project\r
8  *\r
9  *  GPAC is free software; you can redistribute it and/or modify\r
10  *  it under the terms of the GNU Lesser General Public License as published by\r
11  *  the Free Software Foundation; either version 2, or (at your option)\r
12  *  any later version.\r
13  *   \r
14  *  GPAC is distributed in the hope that it will be useful,\r
15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of\r
16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
17  *  GNU Lesser General Public License for more details.\r
18  *   \r
19  *  You should have received a copy of the GNU Lesser General Public\r
20  *  License along with this library; see the file COPYING.  If not, write to\r
21  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. \r
22  *\r
23  */\r
24 \r
25 #ifndef _COMPOSITOR_DEV_H_\r
26 #define _COMPOSITOR_DEV_H_\r
27 \r
28 \r
29 #include <gpac/compositor.h>\r
30 /*include scene graph API*/\r
31 #include <gpac/thread.h>\r
32 /*bridge between the rendering engine and the systems media engine*/\r
33 #include <gpac/mediaobject.h>\r
34 \r
35 /*raster2D API*/\r
36 #include <gpac/modules/raster2d.h>\r
37 /*font engine API*/\r
38 #include <gpac/modules/font.h>\r
39 /*AV hardware API*/\r
40 #include <gpac/modules/video_out.h>\r
41 #include <gpac/modules/audio_out.h>\r
42 \r
43 /*SVG properties*/\r
44 #ifndef GPAC_DISABLE_SVG\r
45 #include <gpac/scenegraph_svg.h>\r
46 #endif\r
47 \r
48 \r
49 /*if defined, events are queued before being processed, otherwise they are handled whenever triggered*/\r
50 //#define GF_SR_EVENT_QUEUE     \r
51 \r
52 \r
53 /*use 2D caching for groups*/\r
54 //#define GF_SR_USE_VIDEO_CACHE\r
55 \r
56 \r
57 /*FPS computed on this number of frame*/\r
58 #define GF_SR_FPS_COMPUTE_SIZE  30\r
59 \r
60 enum\r
61 {\r
62         GF_SR_CFG_OVERRIDE_SIZE = 1,\r
63         GF_SR_CFG_SET_SIZE = 1<<1,\r
64         GF_SR_CFG_AR = 1<<2,\r
65         GF_SR_CFG_FULLSCREEN = 1<<3,\r
66         /*flag is set whenever we're reconfiguring visual. This will discard all UI\r
67         messages during this phase in order to avoid any deadlocks*/\r
68         GF_SR_IN_RECONFIG = 1<<4,\r
69         /*special flag indicating the set size is actually due to a notif by the plugin*/\r
70         GF_SR_CFG_WINDOWSIZE_NOTIF = 1<<10,\r
71 };\r
72 \r
73 \r
74 \r
75 /*forward definition of the visual manager*/\r
76 typedef struct _visual_manager GF_VisualManager;\r
77 typedef struct _draw_aspect_2d DrawAspect2D;\r
78 typedef struct _traversing_state GF_TraverseState;\r
79 typedef struct _gf_ft_mgr GF_FontManager;\r
80 \r
81 #ifndef GPAC_DISABLE_3D\r
82 #include <gpac/internal/camera.h>\r
83 #include <gpac/internal/mesh.h>\r
84 \r
85 #ifdef WIN32\r
86 #include <windows.h>\r
87 typedef void (APIENTRY * PFNGLARBMULTITEXTUREPROC)(unsigned int target);\r
88 #else\r
89 typedef void (*PFNGLARBMULTITEXTUREPROC) (unsigned int target);\r
90 #endif\r
91 \r
92 typedef struct \r
93 {\r
94         Bool multisample;\r
95         Bool bgra_texture;\r
96         Bool abgr_texture;\r
97         Bool npot_texture;\r
98         Bool rect_texture;\r
99         u32 yuv_texture;\r
100         PFNGLARBMULTITEXTUREPROC glActiveTextureARB;\r
101         PFNGLARBMULTITEXTUREPROC glClientActiveTextureARB;\r
102 } GLCaps;\r
103 \r
104 #endif\r
105 \r
106 #define DOUBLECLICK_TIME_MS             250\r
107 \r
108 enum\r
109 {\r
110         /*no text selection*/\r
111         GF_SC_TSEL_NONE = 0,\r
112         /*text selection in progress*/\r
113         GF_SC_TSEL_ACTIVE,\r
114         /*text selection frozen*/\r
115         GF_SC_TSEL_FROZEN,\r
116         /*text selection has just been released*/\r
117         GF_SC_TSEL_RELEASED,\r
118 };\r
119 \r
120 struct __tag_compositor\r
121 {\r
122         /*the main user*/\r
123         GF_User *user;\r
124         /*terminal - only used for InputSensor*/\r
125         GF_Terminal *term;\r
126 \r
127         /*audio renderer*/\r
128         struct _audio_render *audio_renderer;\r
129         /*video out*/\r
130         GF_VideoOutput *video_out;\r
131         /*2D rasterizer*/\r
132         GF_Raster2D *rasterizer;\r
133 \r
134         /*visual rendering thread if used*/\r
135         GF_Thread *VisualThread;\r
136         /*0: not init, 1: running, 2: exit requested, 3: done*/\r
137         u32 video_th_state;\r
138 \r
139         /*compositor exclusive access to the scene and display*/\r
140         GF_Mutex *mx;\r
141 \r
142         /*the main scene graph*/\r
143         GF_SceneGraph *scene;\r
144         /*extra scene graphs (OSD, etc), always registered in draw order. That's the module responsability\r
145         to draw them*/\r
146         GF_List *extra_scenes;\r
147 \r
148         u32 inherit_type_3d;\r
149         \r
150         /*all time nodes registered*/\r
151         GF_List *time_nodes;\r
152         /*all textures (texture handlers)*/\r
153         GF_List *textures;\r
154 \r
155 #ifdef GF_SR_EVENT_QUEUE\r
156         /*event queue*/\r
157         GF_List *events;\r
158         GF_Mutex *ev_mx;\r
159 #endif\r
160 \r
161         /*simulation frame rate*/\r
162         Double frame_rate;\r
163         u32 frame_duration;\r
164         u32 frame_time[GF_SR_FPS_COMPUTE_SIZE];\r
165         u32 current_frame;\r
166 \r
167         u32 last_click_time;\r
168 \r
169         /*display size*/\r
170         u32 display_width, display_height;\r
171 \r
172         /*visual output location on window (we may draw background color outside of it) \r
173                 vp_x & vp_y: horizontal & vertical offset of the drawing area in the video output\r
174                 vp_width & vp_height: width & height of the drawing area\r
175                         * in scalable mode, this is the display size\r
176                         * in not scalable mode, this is the final drawing area size (dst_w & dst_h of the blit)\r
177         */\r
178         u32 vp_x, vp_y, vp_width, vp_height;\r
179         /*backbuffer size - in scalable mode, matches display size, otherwise matches scene size*/\r
180         u32 output_width, output_height;\r
181 \r
182         /*scene size if any*/\r
183         u32 scene_width, scene_height;\r
184         Bool has_size_info;\r
185         Bool fullscreen;\r
186         /*!! paused will not stop display (this enables pausing a VRML world and still examining it)*/\r
187         Bool paused, step_mode;\r
188         Bool draw_next_frame;\r
189         /*freeze_display prevents any screen updates - needed when output driver uses direct video memory access*/\r
190         Bool is_hidden, freeze_display;\r
191 \r
192         /*current frame number*/\r
193         u32 frame_number;\r
194         /*count number of initialized sensors*/\r
195         u32 interaction_sensors;\r
196 \r
197         /*set whenever 3D HW ctx changes (need to rebuild dlists/textures if any used)*/\r
198         Bool reset_graphics;\r
199 \r
200         /*font engine*/\r
201         GF_FontManager *font_manager;\r
202         /*set whenever a new font has been received*/\r
203         Bool reset_fonts;\r
204 \r
205         /*options*/\r
206         u32 aspect_ratio, antiAlias, texture_text_mode;\r
207         Bool high_speed, stress_mode;\r
208         Bool force_opengl_2d;\r
209 \r
210         /*key modif*/\r
211         u32 key_states;\r
212         u32 interaction_level;\r
213 \r
214         /*size override when no size info is present\r
215                 flags:  1: size override is requested (cfg)\r
216                                 2: size override has been applied\r
217         */\r
218         u32 override_size_flags;\r
219 \r
220         /*any of the above flags - reseted at each simulation tick*/\r
221         u32 msg_type;\r
222         /*for size*/\r
223         u32 new_width, new_height;\r
224 \r
225         /*current background color*/\r
226         u32 back_color;\r
227 \r
228         /*bounding box draw type: none, unit box/rect and sphere (3D only)*/\r
229         u32 draw_bvol;\r
230 \r
231         /*list of system colors*/\r
232         u32 sys_colors[28];\r
233 \r
234         /*all visual managers created*/\r
235         GF_List *visuals;\r
236         /*all outlines cached*/\r
237         GF_List *strike_bank;\r
238 \r
239         /*main visual manager - the one managing the primary video output*/\r
240         GF_VisualManager *visual;\r
241         /*set to false whenever a new scene is attached to compositor*/\r
242         Bool root_visual_setup;\r
243         \r
244         /*indicates whether the aspect ratio shall be recomputed:\r
245                 1: AR changed\r
246                 2: AR changed and root visual type changed between 2D and 3D\r
247         */\r
248         u32 recompute_ar;\r
249 \r
250         Bool zoom_changed;\r
251 \r
252         /*traversing context*/\r
253         struct _traversing_state *traverse_state;\r
254 \r
255         /*current picked node if any*/\r
256         GF_Node *grab_node;\r
257         /*current picked node's parent use if any*/\r
258         GF_Node *grab_use;\r
259         /*current focus node if any*/\r
260         GF_Node *focus_node;\r
261         /*parent use node of the current focus node if any*/\r
262         GF_Node *focus_used;\r
263         /*current parent focus node if any - needed to navigate within PROTOs*/\r
264         GF_List *focus_ancestors;\r
265         GF_List *focus_use_stack;\r
266         /*focus node uses dom events*/\r
267         Bool focus_uses_dom_events;\r
268         /*current sensor type*/\r
269         u32 sensor_type;\r
270         /*list of VRML sensors active before the picking phase (eg active at the previous pass)*/\r
271         GF_List *previous_sensors;\r
272         /*list of VRML sensors active after the picking phase*/\r
273         GF_List *sensors;\r
274         /*indicates a sensor is currently active*/\r
275         Bool grabbed_sensor;\r
276 \r
277         /*hardware handle for 2D screen access - currently only used with win32 (HDC) */\r
278         void *hw_context;\r
279         /*indicates whether HW is locked*/\r
280         Bool hw_locked;\r
281         /*screen buffer for direct access*/\r
282         GF_VideoSurface hw_surface;\r
283         /*output buffer is configured in video memory*/\r
284         Bool video_memory;\r
285         /*indicate if overlays were prezsent in the previous frame*/\r
286         Bool last_had_overlays;\r
287 \r
288         /*options*/\r
289         Bool scalable_zoom;\r
290         Bool enable_yuv_hw;\r
291         /*disables partial hardware blit (eg during dirty rect) to avoid artefacts*/\r
292         Bool disable_partial_hw_blit;\r
293 \r
294         /*user navigation mode*/\r
295         u32 navigate_mode;\r
296         /*set if content doesn't allow navigation*/\r
297         Bool navigation_disabled;\r
298 \r
299         /*user mouse navigation state:\r
300          0: not active\r
301          1: pre-active phase: mouse has been clicked and waiting for mouse move to confirm. This allows\r
302                 for clicking on objects in the navigation mode\r
303          2: navigation is grabbed\r
304         */\r
305         u32 navigation_state;\r
306         /*navigation x & y grab point in scene coord system*/\r
307         Fixed grab_x, grab_y;\r
308         /*aspect ratio scale factor*/\r
309         Fixed scale_x, scale_y;\r
310         /*user zoom level*/\r
311         Fixed zoom;\r
312         /*user pan*/\r
313         Fixed trans_x, trans_y;\r
314         /*user rotation angle - ALWAYS CENTERED*/\r
315         Fixed rotation;\r
316 \r
317         Bool skip_flush;\r
318 #ifndef GPAC_DISABLE_SVG\r
319         u32 num_clicks;\r
320 #endif\r
321 \r
322         /*a dedicated drawable for focus highlight */\r
323         struct _drawable *focus_highlight;\r
324         /*highlight fill and stroke colors (ARGB)*/\r
325         u32 highlight_fill, highlight_stroke;\r
326 \r
327         /*picking info*/\r
328 \r
329         /*picked node*/\r
330         GF_Node *hit_node;\r
331         /*appearance at hit point - used for composite texture*/\r
332         GF_Node *hit_appear;\r
333         /*parent use stack - SVG only*/\r
334         GF_List *hit_use_stack, *prev_hit_use_stack;\r
335         /*picked node uses DOM event or VRML events ?*/\r
336         Bool hit_use_dom_events;\r
337 \r
338         /*world->local and local->world transform at hit point*/\r
339         GF_Matrix hit_world_to_local, hit_local_to_world;\r
340         /*hit point in local coord & world coord*/\r
341         SFVec3f hit_local_point, hit_world_point;\r
342         /*tex coords at hit point*/\r
343         SFVec2f hit_texcoords;\r
344         /*picking ray in world coord system*/\r
345         GF_Ray hit_world_ray;\r
346         /*normal at hit point, local coord system*/\r
347         SFVec3f hit_normal;\r
348         /*distance from ray origin used to discards further hits - FIXME: may not properly work with transparent layer3D*/\r
349         Fixed hit_square_dist;\r
350 \r
351         /*text selection and edition*/\r
352 \r
353         /*the active parent text node under selection*/\r
354         GF_Node *text_selection;\r
355         /*text selection start/end in world coord system*/\r
356         SFVec2f start_sel, end_sel;     \r
357         /*text selection state*/ \r
358         u32 store_text_state;\r
359         /*parent text node when a text is hit (to handle tspan selection)*/\r
360         GF_Node *hit_text;\r
361         u32 sel_buffer_len, sel_buffer_alloc;\r
362         u16 *sel_buffer;\r
363         u8 *selected_text;\r
364         /*text selection color - reverse video not yet supported*/\r
365         u32 text_sel_color;\r
366 \r
367         /*set whenever the focus node is a text node*/\r
368         u32 focus_text_type;\r
369         Bool edit_is_tspan;\r
370         /*pointer to edited text*/\r
371         char **edited_text;\r
372         u32 caret_pos, dom_text_pos;\r
373 \r
374 #ifndef GPAC_DISABLE_3D\r
375         /*options*/\r
376         /*emulate power-of-2 for video texturing by using a po2 texture and texture scaling. If any textureTransform\r
377         is applied to this texture, black stripes will appear on the borders.\r
378         If not set video is written through glDrawPixels with bitmap (slow scaling), or converted to\r
379         po2 texture*/\r
380         Bool emul_pow2;\r
381         /*use openGL for outline rather than vectorial ones*/\r
382         Bool raster_outlines;\r
383         /*disable RECT extensions (except for Bitmap...)*/\r
384         Bool disable_rect_ext;\r
385         /*disable RECT extensions (except for Bitmap...)*/\r
386         Bool bitmap_use_pixels;\r
387         /*disable RECT extensions (except for Bitmap...)*/\r
388         u32 draw_normals;\r
389         /*backface cull type: 0 off, 1: on, 2: on with transparency*/\r
390         u32 backcull;\r
391         /*polygon atialiasing*/\r
392         Bool poly_aa;\r
393         /*disable gluScaleImage*/\r
394         Bool disable_glu_scale;\r
395         /*wireframe/solid mode*/\r
396         u32 wiremode;\r
397         /*collision detection mode*/\r
398         u32 collide_mode;\r
399         /*gravity enabled*/\r
400         Bool gravity_on;\r
401         /*AABB tree-based culling is disabled*/\r
402         Bool disable_gl_cull;\r
403         /*YUV textures in OpenGL are disabled (soft YUV->RGB )*/\r
404         Bool disable_yuvgl;\r
405 \r
406         /*unit box (1.0 size) and unit sphere (1.0 radius)*/\r
407         GF_Mesh *unit_bbox;\r
408 \r
409         /*active layer3D for layer navigation - may be NULL*/\r
410         GF_Node *active_layer;\r
411 \r
412         GLCaps gl_caps;\r
413 \r
414         u32 offscreen_width, offscreen_height;\r
415 \r
416 #ifdef GPAC_USE_TINYGL\r
417         void *tgl_ctx;\r
418 #endif\r
419 \r
420 #endif\r
421         \r
422         u32 networks_time;\r
423         u32 decoders_time;\r
424 \r
425         u32 visual_config_time;\r
426         u32 traverse_setup_time;\r
427         u32 traverse_and_direct_draw_time;\r
428         u32 indirect_draw_time;\r
429 \r
430 #ifdef GF_SR_USE_VIDEO_CACHE\r
431         /*video cache size / max size in kbytes*/\r
432         u32 video_cache_current_size, video_cache_max_size;\r
433         u32 cache_scale, cache_tolerance;\r
434         /*sorted list (by cache priority) of cached groups - permanent for the lifetime of the scene/cache object*/\r
435         GF_List *cached_groups;\r
436         /*list of groups being cached in one frame */\r
437         GF_List *cached_groups_queue;\r
438 #endif\r
439 \r
440         /*used for -depth dump*/\r
441         Fixed OGLDepthGain; /*gain applied to OpenGL depth buffer, a float [0..1])*/\r
442         Fixed OGLDepthOffset; /*offset applied to OpenGL depth buffer*/\r
443         \r
444 #ifdef GPAC_TRISCOPE_MODE\r
445         void *RenoirHandler;\r
446 #endif\r
447         \r
448 };\r
449 \r
450 \r
451 /*base stack for timed nodes (nodes that activate themselves at given times)\r
452         @UpdateTimeNode: shall be setup by the node handler and is called once per simulation frame\r
453         @is_registerd: all handlers indicate store their state if wanted (provided for conveniency but not inspected by the compositor)\r
454         @needs_unregister: all handlers indicate they can be removed from the list of active time nodes\r
455 in order to save time. THIS IS INSPECTED by the compositor at each simulation tick after calling UpdateTimeNode\r
456 and if set, the node is removed right away from the list\r
457 */\r
458 typedef struct _time_node\r
459 {\r
460         void (*UpdateTimeNode)(struct _time_node *);\r
461         Bool is_registered, needs_unregister;\r
462         /*user data*/\r
463         void *udta;\r
464 } GF_TimeNode;\r
465 \r
466 void gf_sc_register_time_node(GF_Compositor *sr, GF_TimeNode *tn);\r
467 void gf_sc_unregister_time_node(GF_Compositor *sr, GF_TimeNode *tn);\r
468 \r
469 enum\r
470 {\r
471         /*texture repeat along s*/\r
472         GF_SR_TEXTURE_REPEAT_S = (1<<0),\r
473         /*texture repeat along t*/\r
474         GF_SR_TEXTURE_REPEAT_T = (1<<1),\r
475         /*texture is a matte texture*/\r
476         GF_SR_TEXTURE_MATTE = (1<<2),\r
477         /*texture doesn't need vertical flip for OpenGL*/\r
478         GF_SR_TEXTURE_NO_GL_FLIP = (1<<3),\r
479         /*Set durin a composition cycle. If not set at the end of the cycle, \r
480         the hardware binding is released*/\r
481         GF_SR_TEXTURE_USED = (1<<4),\r
482 };\r
483 \r
484 typedef struct _gf_sc_texture_handler\r
485 {\r
486         GF_Node *owner;\r
487         GF_Compositor *compositor;\r
488         /*low-level texture object - this is not exposed out of libgpac*/\r
489         struct __texture_wrapper *tx_io;\r
490         /*media stream*/\r
491         GF_MediaObject *stream;\r
492         /*texture is open (for DEF/USE)*/\r
493         Bool is_open;\r
494         /*this is needed in case the Url is changed - note that media nodes cannot point to different\r
495         URLs (when they could in VRML), the MF is only holding media segment descriptions*/\r
496         MFURL current_url;\r
497         /*to override by each texture node*/\r
498         void (*update_texture_fcnt)(struct _gf_sc_texture_handler *txh);\r
499         /*needs_release if a visual frame is grabbed (not used by modules)*/\r
500         Bool needs_release;\r
501         /*stream_finished: indicates stream is over (not used by modules)*/\r
502         Bool stream_finished;\r
503         /*needs_refresh: indicates texture content has been changed - needed by modules performing tile drawing*/\r
504         Bool needs_refresh;\r
505         /*needed to discard same frame fetch*/\r
506         u32 last_frame_time;\r
507         /*active display in the texture (0, 0 == top, left)*/\r
508         //GF_Rect active_window;\r
509         /*texture is transparent*/              \r
510         Bool transparent;\r
511         /*flags for user - the repeatS and repeatT are set upon creation, the rest is NEVER touched by compositor*/\r
512         u32 flags;\r
513         /*gradients are relative to the object bounds, therefore a gradient is not the same if used on 2 different\r
514         objects - since we don't want to build an offscreen texture for the gradient, gradients have to be updated \r
515         at each draw - the matrix shall be updated to the gradient transformation in the local system\r
516         MUST be set for gradient textures*/\r
517         void (*compute_gradient_matrix)(struct _gf_sc_texture_handler *txh, GF_Rect *bounds, GF_Matrix2D *mat, Bool for_3d);\r
518 \r
519         /*image data for natural media*/\r
520         char *data;\r
521         u32 width, height, stride, pixelformat, pixel_ar;\r
522         /*if set texture has been transformed by MatteTexture -> disable blit*/\r
523         Bool has_cmat;\r
524 \r
525         /*matteTexture parent if any*/\r
526         GF_Node *matteTexture;\r
527         \r
528 \r
529 #ifdef GPAC_TRISCOPE_MODE\r
530 \r
531         void *RenoirObject;\r
532         \r
533 #endif\r
534         \r
535         \r
536 } GF_TextureHandler;\r
537 \r
538 /*setup texturing object*/\r
539 void gf_sc_texture_setup(GF_TextureHandler *hdl, GF_Compositor *sr, GF_Node *owner);\r
540 /*destroy texturing object*/\r
541 void gf_sc_texture_destroy(GF_TextureHandler *txh);\r
542 \r
543 /*return texture handle for built-in textures (movieTexture, ImageTexture and PixelTexture)*/\r
544 GF_TextureHandler *gf_sc_texture_get_handler(GF_Node *n);\r
545 \r
546 /*these ones are needed by modules only for Background(2D) handling*/\r
547 \r
548 /*returns 1 if url changed from current one*/\r
549 Bool gf_sc_texture_check_url_change(GF_TextureHandler *txh, MFURL *url);\r
550 /*starts associated object*/\r
551 GF_Err gf_sc_texture_play(GF_TextureHandler *txh, MFURL *url);\r
552 GF_Err gf_sc_texture_play_from_to(GF_TextureHandler *txh, MFURL *url, Double start_offset, Double end_offset, Bool can_loop, Bool lock_scene_timeline);\r
553 /*stops associated object*/\r
554 void gf_sc_texture_stop(GF_TextureHandler *txh);\r
555 /*restarts associated object - DO NOT CALL stop/start*/\r
556 void gf_sc_texture_restart(GF_TextureHandler *txh);\r
557 /*common routine for all video texture: fetches a frame and update the 2D texture object */\r
558 void gf_sc_texture_update_frame(GF_TextureHandler *txh, Bool disable_resync);\r
559 /*release video memory if needed*/\r
560 void gf_sc_texture_release_stream(GF_TextureHandler *txh);\r
561 \r
562 \r
563 \r
564 /*sensor node handler - this is not defined as a stack because Anchor is both a grouping node and a \r
565 sensor node, and we DO need the groupingnode stack...*/\r
566 typedef struct _sensor_handler\r
567 {\r
568         /*sensor enabled or not ?*/\r
569         Bool (*IsEnabled)(GF_Node *node);\r
570         /*user input on sensor:\r
571         is_over: pointing device is over a shape the sensor is attached to\r
572         evt_type: mouse event type\r
573         compositor: pointer to compositor - hit info is stored at compositor level\r
574         */\r
575         void (*OnUserEvent)(struct _sensor_handler *sh, Bool is_over, GF_Event *ev, GF_Compositor *compositor);\r
576         /*pointer to the sensor node*/\r
577         GF_Node *sensor;\r
578 } GF_SensorHandler;\r
579 \r
580 /*returns TRUE if the node is a pointing device sensor node that can be stacked during traversing (all sensor except anchor)*/\r
581 Bool compositor_mpeg4_is_sensor_node(GF_Node *node);\r
582 /*returns associated sensor handler from traversable stack (the node handler is always responsible for creation/deletion)\r
583 returns NULL if not a sensor or sensor is not activated*/\r
584 GF_SensorHandler *compositor_mpeg4_get_sensor_handler(GF_Node *n);\r
585 \r
586 /*rendering modes*/\r
587 enum\r
588 {\r
589         /*regular traversing mode for z-sorting:\r
590                 - 2D mode: builds the display list (may draw directly if requested)\r
591                 - 3D mode: sort & queue transparent objects\r
592         */\r
593         TRAVERSE_SORT = 0,\r
594         /*explicit draw routine used when flushing 2D display list*/\r
595         TRAVERSE_DRAW_2D,\r
596         /*pick routine*/\r
597         TRAVERSE_PICK,\r
598         /*get bounds routine: returns bounds in local coord system (including node transform if any)*/\r
599         TRAVERSE_GET_BOUNDS,\r
600         /*set to signal bindable render - only called on bindable stack top if present.\r
601         for background (drawing request), viewports/viewpoints fog and navigation (setup)\r
602         all other nodes SHALL NOT RESPOND TO THIS CALL\r
603         */\r
604         TRAVERSE_BINDABLE,\r
605 \r
606         /*writes the text selection into the compositor buffer - we need a traversing mode for this operation\r
607         to handle properly text and tspans*/\r
608         TRAVERSE_GET_TEXT,\r
609 \r
610 #ifndef GPAC_DISABLE_3D\r
611         /*explicit draw routine used when flushing 3D display list*/\r
612         TRAVERSE_DRAW_3D,\r
613         /*set global lights on. Since the model_matrix is not pushed to the target in this \r
614         pass, global lights shall not forget to do it (cf lighting.c)*/\r
615         TRAVERSE_LIGHTING,\r
616         /*collision routine*/\r
617         TRAVERSE_COLLIDE,\r
618 #endif\r
619 };\r
620 \r
621 \r
622 typedef struct _group_cache_candidate GF_CacheCandidate;\r
623 \r
624 \r
625 \r
626 #define MAX_USER_CLIP_PLANES            4\r
627 \r
628 /*the traversing context: set_up at top-level and passed through SFNode_Render. Each node is responsible for \r
629 restoring the context state before returning*/\r
630 struct _traversing_state\r
631 {\r
632         struct _audio_group *audio_parent;\r
633         struct _soundinterface *sound_holder;\r
634 \r
635 #ifndef GPAC_DISABLE_SVG\r
636         SVGPropertiesPointers *svg_props;\r
637         u32 svg_flags;\r
638 #endif\r
639 \r
640         /*current traversing mode*/\r
641         u32 traversing_mode;\r
642         /*for 2D drawing, indicates objects are to be drawn as soon as traversed, at each frame*/\r
643         Bool direct_draw;\r
644         /*current subtree is part of a switched-off subtree (needed for audio)*/\r
645         Bool switched_off;\r
646         /*set by the traversed subtree to indicate no cull shall be performed*/\r
647         Bool disable_cull;\r
648 \r
649         /*indicates if we are in a layer or not*/\r
650         Bool is_layer;\r
651         /*current graph traversed is in pixel metrics*/\r
652         Bool pixel_metrics;\r
653         /*minimal half-dimension (w/2, h/2)*/\r
654         Fixed min_hsize;\r
655 \r
656         /*indicates if the current subtree is fliped compared to the target visual*/\r
657         Bool fliped_coords;\r
658 \r
659         /*current size of viewport being traverse (root scene, layers)*/\r
660         SFVec2f vp_size;\r
661 \r
662         /*the one and only visual manager currently being traversed*/\r
663         GF_VisualManager *visual;\r
664         \r
665         /*current background and viewport stacks*/\r
666         GF_List *backgrounds;\r
667         GF_List *viewpoints;\r
668 \r
669         /*current transformation from top-level*/\r
670         GF_Matrix2D transform;\r
671         /*current color transformation from top-level*/\r
672         GF_ColorMatrix color_mat;\r
673         /* Contains the viewbox transform, used for svg ref() transform */\r
674         GF_Matrix2D vb_transform;\r
675 \r
676         /*if set all nodes shall be redrawn - set only at specific places in the tree*/\r
677         Bool invalidate_all;\r
678 \r
679         /*text splitting: 0: no splitting, 1: word by word, 2:letter by letter*/\r
680         u32 text_split_mode;\r
681         /*1-based idx of text element drawn*/\r
682         u32 text_split_idx;\r
683 \r
684         /*all VRML sensors for the current level*/\r
685         GF_List *vrml_sensors;\r
686 \r
687         /*current appearance when traversing geometry nodes*/\r
688         GF_Node *appear;\r
689         /*parent group for composition: can be Form, Layout or Layer2D*/\r
690         struct _parent_node_2d *parent;\r
691 \r
692         /*group/object bounds in local coordinate system*/\r
693         GF_Rect bounds;\r
694 \r
695         /*node for which bounds should be fetched - SVG only*/\r
696         GF_Node *for_node;\r
697         Bool abort_bounds_traverse;\r
698         GF_Matrix2D mx_at_node;\r
699         Bool ignore_strike;\r
700         \r
701         GF_List *use_stack;\r
702         /* Styling Property and others for SVG context */\r
703 #ifndef GPAC_DISABLE_SVG\r
704         SVG_Number *parent_use_opacity;\r
705         SVGAllAttributes *parent_anim_atts;\r
706 \r
707         /*SVG text rendering state*/\r
708         Bool in_svg_text;\r
709         Bool in_svg_text_area;\r
710 \r
711         /* current chunk & position of last placed text chunk*/\r
712         u32 chunk_index;\r
713         Fixed text_end_x, text_end_y;\r
714 \r
715         /* text & tspan state*/\r
716         GF_List *x_anchors;\r
717         SVG_Coordinates *text_x, *text_y, *text_rotate;\r
718         u32 count_x, count_y, count_rotate, idx_rotate;\r
719 \r
720         /* textArea state*/\r
721         Fixed max_length, max_height;\r
722         Fixed base_x, base_y;\r
723         Fixed line_spacing;\r
724         Fixed base_shift;\r
725         /*quick and dirty hack to try to solve xml:space across text and tspans without \r
726         flattening the DOMText nodes\r
727         0: first block of text\r
728         1: previous block of text ended with a space\r
729         2: previous block of text did NOT end with a space\r
730         */\r
731         u32 last_char_type;\r
732         /*in textArea, indicates that the children bounds must be refreshed due to a baseline adjustment*/\r
733         u32 refresh_children_bounds;\r
734 #endif\r
735         GF_Node *text_parent;\r
736 \r
737         /*current context to be drawn - only set when drawing in 2D mode or 3D for SVG*/\r
738         struct _drawable_context *ctx;\r
739 \r
740         /*world ray for picking - in 2D, orig is 2D mouse pos and direction is -z*/\r
741         GF_Ray ray;\r
742 \r
743         /*we have 2 clippers, one for regular clipping (layout, form if clipping) which is maintained in world coord system\r
744         and one for layer2D which is maintained in parent coord system (cf layer rendering). The layer clipper\r
745         is used only when cascading layers - layer3D doesn't use clippers*/\r
746         Bool has_clip, has_layer_clip;\r
747         /*active clipper in world coord system */\r
748         GF_Rect clipper, layer_clipper;\r
749 \r
750         \r
751         /*set when traversing a cached group during offscreen bitmap construction.*/\r
752         Bool in_group_cache;\r
753 \r
754 \r
755 #ifndef GPAC_DISABLE_3D\r
756         /*the current camera*/\r
757         GF_Camera *camera;\r
758 \r
759         /*current object (model) transformation from top-level, view is NOT included*/\r
760         GF_Matrix model_matrix;\r
761 \r
762         /*fog bind stack*/\r
763         GF_List *fogs; /*holds fogs info*/\r
764         /*navigation bind stack*/\r
765         GF_List *navigations;\r
766 \r
767         /*when drawing, signals the mesh is transparent (enables blending)*/\r
768         Bool mesh_is_transparent;\r
769         /*when drawing, signals the number of textures used by the mesh*/\r
770         u32 mesh_num_textures;\r
771 \r
772         /*bounds for TRAVERSE_GET_BOUNDS and background rendering*/\r
773         GF_BBox bbox;\r
774 \r
775         /*cull flag (used to skip culling of children when parent bbox is completely inside/outside frustum)*/\r
776         u32 cull_flag;\r
777 \r
778         /*toggle local lights on/off - field is ONLY valid in TRAVERSE_RENDER mode, and local lights\r
779         are always set off in reverse order as when set on*/\r
780         Bool local_light_on;\r
781         /*current directional ligths contexts - only valid in TRAVERSE_RENDER*/\r
782         GF_List *local_lights;\r
783 \r
784         /*clip planes in world coords*/\r
785         GF_Plane clip_planes[MAX_USER_CLIP_PLANES];\r
786         u32 num_clip_planes;\r
787 \r
788 \r
789         /*layer traversal state:\r
790                 set to the first traversed layer3D when picking\r
791                 set to the current layer3D traversed when rendering 3D to an offscreen bitmap. This alows other \r
792                         nodes (typically bindables) seting the layer dirty flags to force a redraw \r
793         */\r
794         GF_Node *layer3d;\r
795 #endif\r
796 \r
797         \r
798         /*depth z-axis info for 2D scenes in triscope mode*/\r
799         Fixed depth;\r
800 \r
801 #ifdef GF_SR_USE_VIDEO_CACHE\r
802         /*set to 1 if cache evaluation can be skipped - this is only set when there is not enough memory \r
803         to cache a sub-group, in which case the group cannot be cached (we're caching in display coordinates)*/\r
804         Bool cache_too_small;\r
805 #endif\r
806 };\r
807 \r
808 /*\r
809         Audio mixer - MAX 6 CHANNELS SUPPORTED\r
810 */\r
811 \r
812 /*the audio object as used by the mixer. All audio nodes need to implement this interface*/\r
813 typedef struct _audiointerface\r
814 {\r
815         /*fetch audio data for a given audio delay (~soundcard drift) - if delay is 0 sync should not be performed \r
816         (eg intermediate mix) */\r
817         char *(*FetchFrame) (void *callback, u32 *size, u32 audio_delay_ms);\r
818         /*release a number of bytes in the indicated frame (ts)*/\r
819         void (*ReleaseFrame) (void *callback, u32 nb_bytes);\r
820         /*get media speed*/\r
821         Fixed (*GetSpeed)(void *callback);\r
822         /*gets volume for each channel - vol = Fixed[6]. returns 1 if volume shall be changed (!= 1.0)*/\r
823         Bool (*GetChannelVolume)(void *callback, Fixed *vol);\r
824         /*returns 1 if muted*/\r
825         Bool (*IsMuted)(void *callback);\r
826         /*user callback*/\r
827         void *callback;\r
828         /*returns 0 if config is not known yet or changed, \r
829         otherwise AND IF @for_reconf is set, updates member var below and return TRUE\r
830         You may return 0 to force parent user invalidation*/\r
831         Bool (*GetConfig)(struct _audiointerface *ai, Bool for_reconf);\r
832         /*updated cfg, or 0 otherwise*/\r
833         u32 chan, bps, samplerate, ch_cfg;\r
834 } GF_AudioInterface;\r
835 \r
836 typedef struct __audiomix GF_AudioMixer;\r
837 \r
838 /*create mixer - ar is NULL for any sub-mixers, or points to the main audio renderer (mixer outputs to sound driver)*/\r
839 GF_AudioMixer *gf_mixer_new(struct _audio_render *ar);\r
840 void gf_mixer_del(GF_AudioMixer *am);\r
841 void gf_mixer_remove_all(GF_AudioMixer *am);\r
842 void gf_mixer_add_input(GF_AudioMixer *am, GF_AudioInterface *src);\r
843 void gf_mixer_remove_input(GF_AudioMixer *am, GF_AudioInterface *src);\r
844 void gf_mixer_lock(GF_AudioMixer *am, Bool lockIt);\r
845 /*mix inputs in buffer, return number of bytes written to output*/\r
846 u32 gf_mixer_get_output(GF_AudioMixer *am, void *buffer, u32 buffer_size);\r
847 /*reconfig all sources if needed - returns TRUE if main audio config changed\r
848 NOTE: this is called at each gf_mixer_get_output by the mixer. To call externally for audio hardware\r
849 reconfiguration only*/\r
850 Bool gf_mixer_reconfig(GF_AudioMixer *am);\r
851 /*retrieves mixer cfg*/\r
852 void gf_mixer_get_config(GF_AudioMixer *am, u32 *outSR, u32 *outCH, u32 *outBPS, u32 *outChCfg);\r
853 /*called by audio renderer in case the hardware used a different setup than requested*/\r
854 void gf_mixer_set_config(GF_AudioMixer *am, u32 outSR, u32 outCH, u32 outBPS, u32 ch_cfg);\r
855 Bool gf_mixer_is_src_present(GF_AudioMixer *am, GF_AudioInterface *ifce);\r
856 u32 gf_mixer_get_src_count(GF_AudioMixer *am);\r
857 void gf_mixer_force_chanel_out(GF_AudioMixer *am, u32 num_channels);\r
858 u32 gf_mixer_get_block_align(GF_AudioMixer *am);\r
859 Bool gf_mixer_must_reconfig(GF_AudioMixer *am);\r
860 Bool gf_mixer_empty(GF_AudioMixer *am);\r
861 \r
862 /*the audio renderer*/\r
863 typedef struct _audio_render\r
864 {\r
865         GF_AudioOutput *audio_out;\r
866 \r
867         Bool disable_resync;\r
868         Bool disable_multichannel;\r
869 \r
870         /*startup time (the audio renderer is used when present as the system clock)*/\r
871         u32 startTime;\r
872         /*frozen time counter if set*/\r
873         Bool Frozen;\r
874         u32 FreezeTime;\r
875         \r
876         /*final output*/\r
877         GF_AudioMixer *mixer;\r
878         Bool need_reconfig;\r
879         /*client*/\r
880         GF_User *user;\r
881 \r
882         /*audio thread if output not self-threaded*/\r
883         GF_Thread *th;\r
884         /*thread state: 0: not intit, 1: running, 2: waiting for stop, 3: done*/\r
885         u32 audio_th_state;\r
886 \r
887         u32 audio_delay, volume, pan;\r
888 } GF_AudioRenderer;\r
889 \r
890 /*creates audio renderer*/\r
891 GF_AudioRenderer *gf_sc_ar_load(GF_User *user);\r
892 /*deletes audio renderer*/\r
893 void gf_sc_ar_del(GF_AudioRenderer *ar);\r
894 /*control audio renderer - CtrlType:\r
895         0: pause\r
896         1: resume\r
897         2: clean HW buffer and play\r
898 */\r
899 void gf_sc_ar_control(GF_AudioRenderer *ar, u32 CtrlType);\r
900 /*set volume and pan*/\r
901 void gf_sc_ar_set_volume(GF_AudioRenderer *ar, u32 Volume);\r
902 void gf_sc_ar_set_pan(GF_AudioRenderer *ar, u32 Balance);\r
903 /*set audio priority*/\r
904 void gf_sc_ar_set_priority(GF_AudioRenderer *ar, u32 priority);\r
905 /*gets time in msec - this is the only clock used by the whole ESM system - depends on the audio driver*/\r
906 u32 gf_sc_ar_get_clock(GF_AudioRenderer *ar);\r
907 /*reset all input nodes*/\r
908 void gf_sc_ar_reset(GF_AudioRenderer *ar);\r
909 /*add audio node*/\r
910 void gf_sc_ar_add_src(GF_AudioRenderer *ar, GF_AudioInterface *source);\r
911 /*remove audio node*/\r
912 void gf_sc_ar_remove_src(GF_AudioRenderer *ar, GF_AudioInterface *source);\r
913 /*reconfig audio hardware if needed*/\r
914 void gf_sc_ar_reconfig(GF_AudioRenderer *ar);\r
915 u32 gf_sc_ar_get_delay(GF_AudioRenderer *ar);\r
916 \r
917 /*the sound node interface for intensity & spatialization*/\r
918 typedef struct _soundinterface\r
919 {\r
920         /*gets volume for each channel - vol = Fixed[6]. returns 1 if volume shall be changed (!= 1.0)\r
921         if NULL channels are always at full intensity*/\r
922         Bool (*GetChannelVolume)(GF_Node *owner, Fixed *vol);\r
923         /*get sound priority (0: min, 255: max) - used by mixer to determine*/\r
924         u8 (*GetPriority) (GF_Node *owner);\r
925         /*node owning the structure*/\r
926         GF_Node *owner;\r
927 } GF_SoundInterface;\r
928 \r
929 /*audio common to AudioClip and AudioSource*/\r
930 typedef struct\r
931 {\r
932         GF_Node *owner;\r
933         GF_Compositor *compositor;\r
934         GF_AudioInterface input_ifce;\r
935         /*can be NULL if the audio node generates its output from other input*/\r
936         GF_MediaObject *stream;\r
937         /*object speed and intensity*/\r
938         Fixed speed, intensity;\r
939         Bool stream_finished;\r
940         Bool need_release;\r
941         MFURL url;\r
942         u32 is_open;\r
943         Bool is_muted;\r
944         Bool register_with_renderer, register_with_parent;\r
945 \r
946         GF_SoundInterface *snd;\r
947 } GF_AudioInput;\r
948 /*setup interface with audio renderer - overwrite any functions needed after setup EXCEPT callback object*/\r
949 void gf_sc_audio_setup(GF_AudioInput *ai, GF_Compositor *sr, GF_Node *node);\r
950 /*open audio object*/\r
951 GF_Err gf_sc_audio_open(GF_AudioInput *ai, MFURL *url, Double clipBegin, Double clipEnd);\r
952 /*closes audio object*/\r
953 void gf_sc_audio_stop(GF_AudioInput *ai);\r
954 /*restarts audio object (cf note in MediaObj)*/\r
955 void gf_sc_audio_restart(GF_AudioInput *ai);\r
956 \r
957 Bool gf_sc_audio_check_url(GF_AudioInput *ai, MFURL *url);\r
958 \r
959 /*base grouping audio node (nodes with several audio sources as children)*/\r
960 #define AUDIO_GROUP_NODE        \\r
961         GF_AudioInput output;           \\r
962         void (*add_source)(struct _audio_group *_this, GF_AudioInput *src);     \\r
963 \r
964 typedef struct _audio_group\r
965 {\r
966         AUDIO_GROUP_NODE\r
967 } GF_AudioGroup;\r
968 \r
969 \r
970 /*register audio node with parent audio renderer (mixer or main renderer)*/\r
971 void gf_sc_audio_register(GF_AudioInput *ai, GF_TraverseState *tr_state);\r
972 void gf_sc_audio_unregister(GF_AudioInput *ai);\r
973 \r
974 \r
975 #ifndef GPAC_DISABLE_SVG\r
976 GF_Err gf_term_get_mfurl_from_xlink(GF_Node *node, MFURL *mfurl);\r
977 Fixed gf_sc_svg_convert_length_to_display(GF_Compositor *sr, SVG_Length *length);\r
978 \r
979 char *gf_term_resolve_xlink(GF_Node *node, char *the_url);\r
980 #endif\r
981 \r
982 GF_Err compositor_2d_set_aspect_ratio(GF_Compositor *sr);\r
983 void compositor_2d_set_user_transform(GF_Compositor *sr, Fixed zoom, Fixed tx, Fixed ty, Bool is_resize) ;\r
984 GF_Err compositor_2d_get_video_access(GF_VisualManager *surf);\r
985 void compositor_2d_release_video_access(GF_VisualManager *surf);\r
986 Bool compositor_2d_draw_bitmap(GF_VisualManager *visual, GF_TraverseState *tr_state, struct _drawable_context *ctx, GF_ColorKey *col_key);\r
987 GF_Rect compositor_2d_update_clipper(GF_TraverseState *tr_state, GF_Rect this_clip, Bool *need_restore, GF_Rect *original, Bool for_layer);\r
988 \r
989 Bool compositor_get_2d_plane_intersection(GF_Ray *ray, SFVec3f *res);\r
990 \r
991 void compositor_send_resize_event(GF_Compositor *compositor, Fixed old_z, Fixed old_tx, Fixed old_ty, Bool is_resize);\r
992 \r
993 void compositor_set_cache_memory(GF_Compositor *compositor, u32 memory);\r
994 /*checks whether the background node is transparent or not*/\r
995 Bool compositor_background_transparent(GF_Node *node);\r
996 \r
997 #ifndef GPAC_DISABLE_3D\r
998 \r
999 GF_Err compositor_3d_set_aspect_ratio(GF_Compositor *sr);\r
1000 GF_Camera *compositor_3d_get_camera(GF_Compositor *sr);\r
1001 void compositor_3d_reset_camera(GF_Compositor *sr);\r
1002 GF_Camera *compositor_layer3d_get_camera(GF_Node *node);\r
1003 void compositor_layer3d_bind_camera(GF_Node *node, Bool do_bind, u32 nav_value);\r
1004 void compositor_3d_draw_bitmap(struct _drawable *stack, DrawAspect2D *asp, GF_TraverseState *tr_state, Fixed width, Fixed height, Fixed bmp_scale_x, Fixed bmp_scale_y);\r
1005 \r
1006 GF_Err compositor_3d_get_screen_buffer(GF_Compositor *sr, GF_VideoSurface *fb, Bool depth_buffer);\r
1007 GF_Err compositor_3d_release_screen_buffer(GF_Compositor *sr, GF_VideoSurface *framebuffer);\r
1008 \r
1009 void gf_sc_load_opengl_extensions(GF_Compositor *sr);\r
1010 \r
1011 #endif\r
1012 \r
1013 Bool gf_sc_exec_event(GF_Compositor *sr, GF_Event *evt);\r
1014 void gf_sc_get_nodes_bounds(GF_Node *self, GF_ChildNodeItem *children, GF_TraverseState *tr_state, s32 *child_idx);\r
1015 \r
1016 \r
1017 void gf_sc_visual_register(GF_Compositor *sr, GF_VisualManager *surf);\r
1018 void gf_sc_visual_unregister(GF_Compositor *sr, GF_VisualManager *surf);\r
1019 Bool gf_sc_visual_is_registered(GF_Compositor *sr, GF_VisualManager *surf);\r
1020 \r
1021 Bool gf_sc_pick_in_clipper(GF_TraverseState *tr_state, GF_Rect *clip);\r
1022 \r
1023 void compositor_gradient_update(GF_TextureHandler *txh);\r
1024 void compositor_set_ar_scale(GF_Compositor *sr, Fixed scaleX, Fixed scaleY);\r
1025 \r
1026 /*reset focus if node being deleted has the focus - must be called for each focusable node (internally called for 2D & 3D drawable nodes)*/\r
1027 void gf_sc_check_focus_upon_destroy(GF_Node *n);\r
1028 \r
1029 #ifndef GPAC_DISABLE_SVG\r
1030 \r
1031 void compositor_svg_build_gradient_texture(GF_TextureHandler *txh);\r
1032 \r
1033 /*base routine fo all svg elements:\r
1034         - check for conditional processing (requiredXXX, ...)\r
1035         - apply animation and inheritance\r
1036 \r
1037         returns 0 if the node shall not be traversed due to conditional processing\r
1038 */\r
1039 Bool compositor_svg_traverse_base(GF_Node *node, SVGAllAttributes *all_atts, GF_TraverseState *tr_state, SVGPropertiesPointers *backup_props, u32 *backup_flags);\r
1040 Bool compositor_svg_is_display_off(SVGPropertiesPointers *props);\r
1041 void compositor_svg_apply_local_transformation(GF_TraverseState *tr_state, SVGAllAttributes *atts, GF_Matrix2D *backup_matrix_2d, GF_Matrix *backup_matrix);\r
1042 void compositor_svg_restore_parent_transformation(GF_TraverseState *tr_state, GF_Matrix2D *backup_matrix_2d, GF_Matrix *backup_matrix);\r
1043 \r
1044 void compositor_svg_traverse_children(GF_ChildNodeItem *children, GF_TraverseState *tr_state);\r
1045 \r
1046 Bool compositor_svg_evaluate_conditional(GF_Compositor *compositor, SVGAllAttributes *all_atts);\r
1047 \r
1048 /*returns the node associated with the given xlink - this is not always the target node of the xlink structure due\r
1049 to async restart of animation nodes*/\r
1050 GF_Node *compositor_svg_get_xlink_resource_node(GF_Node *node, XMLRI *xlink);\r
1051 \r
1052 #endif\r
1053 \r
1054 /*Text handling*/\r
1055 \r
1056 typedef struct _gf_font GF_Font;\r
1057 \r
1058 struct _gf_font \r
1059 {\r
1060         /*fonts are linked within the font manager*/\r
1061         GF_Font *next;\r
1062         /*list of glyphs in the font*/\r
1063         GF_Glyph *glyph;\r
1064 \r
1065         char *name;\r
1066         u32 em_size;\r
1067         u32 styles;\r
1068         /*font uits in em size*/\r
1069         s32 ascent, descent, underline, line_spacing, max_advance_h, max_advance_v;\r
1070         s32 baseline;\r
1071 \r
1072         /*only set for embedded font engines (SVG fonts)*/\r
1073         GF_Font *(*get_alias)(void *udta);\r
1074         GF_Err (*get_glyphs)(void *udta, const char *utf_string, u32 *glyph_ids_buffer, u32 *io_glyph_ids_buffer_size, const char *xml_lang, Bool *is_rtl);\r
1075         GF_Glyph *(*load_glyph)(void *udta, u32 glyph_name);\r
1076         void *udta;\r
1077 \r
1078         Bool not_loaded;\r
1079 \r
1080         struct _gf_ft_mgr *ft_mgr;\r
1081         /*list of spans currently using the font - this is needed to allow for dynamic discard of the font*/\r
1082         GF_List *spans;\r
1083 };\r
1084 \r
1085 enum \r
1086 {\r
1087         /*span direction is horizontal*/\r
1088         GF_TEXT_SPAN_HORIZONTAL = 1,\r
1089         /*span is underlined*/\r
1090         GF_TEXT_SPAN_UNDERLINE = 1<<1,\r
1091         /*span is fliped (coord systems with Y-axis pointing downwards like SVG)*/\r
1092         GF_TEXT_SPAN_FLIP = 1<<2,\r
1093         /*span is in the current text selection*/\r
1094         GF_TEXT_SPAN_RIGHT_TO_LEFT = 1<<3,\r
1095         /*span is in the current text selection*/\r
1096         GF_TEXT_SPAN_SELECTED = 1<<4\r
1097 };\r
1098 \r
1099 typedef struct __text_span\r
1100 {\r
1101         GF_Font *font;\r
1102         \r
1103         GF_Glyph **glyphs;\r
1104         u32 nb_glyphs;\r
1105 \r
1106         u32 flags;\r
1107 \r
1108         Fixed font_size;\r
1109 \r
1110         /*scale to apply to get to requested font size*/\r
1111         Fixed font_scale;\r
1112         GF_Rect bounds;\r
1113 \r
1114         /*MPEG-4 span scaling (length & maxExtend)*/\r
1115         Fixed x_scale, y_scale;\r
1116         /*x (resp. y) offset in local coord system. Ignored if per-glyph dx (resp dy) are specified*/\r
1117         Fixed off_x, off_y;\r
1118 \r
1119         /*per-glyph positioning - when allocated, this is the same number as the glyphs*/\r
1120         Fixed *dx, *dy, *rot;\r
1121 \r
1122         /*span language*/\r
1123 //      const char *lang;\r
1124 \r
1125         /*span texturing and 3D tools*/\r
1126         struct _span_internal *ext;\r
1127 \r
1128         /*SVG stuff :(*/\r
1129         GF_Node *anchor;\r
1130         GF_Node *user;\r
1131 } GF_TextSpan;\r
1132 \r
1133 GF_FontManager *gf_font_manager_new(GF_User *user);\r
1134 void gf_font_manager_del(GF_FontManager *fm);\r
1135 \r
1136 GF_Font *gf_font_manager_set_font(GF_FontManager *fm, char **alt_fonts, u32 nb_fonts, u32 styles);\r
1137 GF_Font *gf_font_manager_set_font_ex(GF_FontManager *fm, char **alt_fonts, u32 nb_fonts, u32 styles, Bool check_only);\r
1138 \r
1139 GF_TextSpan *gf_font_manager_create_span(GF_FontManager *fm, GF_Font *font, char *span, Fixed font_size, Bool needs_x_offset, Bool needs_y_offset, Bool needs_rotate, const char *lang, Bool fliped_text, u32 styles, GF_Node *user);\r
1140 void gf_font_manager_delete_span(GF_FontManager *fm, GF_TextSpan *tspan);\r
1141 \r
1142 GF_Err gf_font_manager_register_font(GF_FontManager *fm, GF_Font *font);\r
1143 GF_Err gf_font_manager_unregister_font(GF_FontManager *fm, GF_Font *font);\r
1144 \r
1145 void gf_font_manager_refresh_span_bounds(GF_TextSpan *span);\r
1146 GF_Path *gf_font_span_create_path(GF_TextSpan *span);\r
1147 \r
1148 \r
1149 void gf_font_spans_draw_2d(GF_List *spans, GF_TraverseState *tr_state, u32 hl_color, Bool force_texture_text, GF_Rect *bounds);\r
1150 void gf_font_spans_draw_3d(GF_List *spans, GF_TraverseState *tr_state, DrawAspect2D *asp, u32 text_hl, Bool force_texturing);\r
1151 void gf_font_spans_pick(GF_Node *node, GF_List *spans, GF_TraverseState *tr_state, GF_Rect *node_bounds, Bool use_dom_events, struct _drawable *drawable);\r
1152 void gf_font_spans_get_selection(GF_Node *node, GF_List *spans, GF_TraverseState *tr_state);\r
1153 \r
1154 GF_Font *gf_compositor_svg_set_font(GF_FontManager *fm, char *a_font, u32 styles, Bool check_only);\r
1155 \r
1156 \r
1157 GF_SceneGraph *gf_sc_get_subscene(GF_Node *inline_node);\r
1158 GF_Node *gf_sc_get_subscene_root(GF_Node *inline_node);\r
1159 \r
1160 #endif  /*_COMPOSITOR_DEV_H_*/\r
1161 \r