_______________________________________________________________________________________________________________________________________
/*************************************************************************************************************************************/
/* */
/* F O N C T I O N S D E B A S E D ' E D I T I O N D E S I M A G E S */
/* S U I V A N T L A B I B L I O T H E Q U E ' S I L I C O N - G R A P H I C S ' : */
/* */
/* */
/* Definition : */
/* */
/* Ce fichier contient toutes les fonctions */
/* de base d'edition graphique des images raster, */
/* quelle que soit la definition. */
/* */
/* */
/* Author of '$xiidG/fonction.1$FON' : */
/* */
/* Jean-Francois COLONNA (LACTAMME, 19900000000000). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O P P O R T U N I T E D E C O M P I L E R C E M O D U L E : */
/* */
/*************************************************************************************************************************************/
#ifdef __VERSION__COMPILER_LE_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : indicateur de VERSION. */
DEFV(Common,DEFV(Logical,_______VERSION__COMPILER_LE_GRAPHIQUE_SILICON_GRAPHICS));
/* ATTENTION : c'etait "_______VERSION__COMPILER_LE_GRAPHIQUE_SILICON_GRAPHICS`" qui etait */
/* defini ci-dessus par erreur jusqu'au 20060415172733... */
#Aifdef __VERSION__COMPILER_LE_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : indicateur de VERSION. */
#Eifdef __VERSION__COMPILER_LE_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : indicateur de VERSION. */
#ifdef __VERSION__COMPILER_LE_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : compiler sur 'SiliG'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E C L A R A T I O N D E S L I B R A I R I E S U T I L E S : */
/* */
/*************************************************************************************************************************************/
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL /* Common,DEFV(Fonction,) : avec 'GL'... */
DEFV(Common,DEFV(Logical,_______VERSION__UTILISER_LA_BIBLIOTHEQUE_GL));
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL /* Common,DEFV(Fonction,) : avec 'GL'... */
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL /* Common,DEFV(Fonction,) : avec 'GL'... */
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL /* Common,DEFV(Fonction,) : avec 'OpenGL'... */
DEFV(Common,DEFV(Logical,_______VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL));
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL /* Common,DEFV(Fonction,) : avec 'OpenGL'... */
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL /* Common,DEFV(Fonction,) : avec 'OpenGL'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E C L A R A T I O N D E S O P T I O N S P R E S E N T E S : */
/* */
/*************************************************************************************************************************************/
# ifdef __VERSION__COMPILER_L_OPTION_GALILEO_DU_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : options. */
DEFV(Common,DEFV(Logical,_______VERSION__COMPILER_L_OPTION_GALILEO_DU_GRAPHIQUE_SILICON_GRAPHICS));
# Aifdef __VERSION__COMPILER_L_OPTION_GALILEO_DU_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : options. */
# Eifdef __VERSION__COMPILER_L_OPTION_GALILEO_DU_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : options. */
# ifdef __VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_O2_DU_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : options. */
DEFV(Common,DEFV(Logical,_______VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_O2_DU_GRAPHIQUE_SILICON_GRAPHICS));
# Aifdef __VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_O2_DU_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : options. */
# Eifdef __VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_O2_DU_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : options. */
# ifdef __VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : options. */
DEFV(Common,DEFV(Logical,_______VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS));
# Aifdef __VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : options. */
# Eifdef __VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : options. */
# ifdef __VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : options. */
DEFV(Common,DEFV(Logical,_______VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS));
# Aifdef __VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : options. */
# Eifdef __VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : options. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N S D E S " B U G S " P R E S E N T S : */
/* */
/*************************************************************************************************************************************/
# ifdef BUG_SYSTEME_SG_GL_CURSOR_GLOBAL /* Common,DEFV(Fonction,) : bug... */
DEFV(Common,DEFV(Logical,_____BUG_SYSTEME_SG_GL_CURSOR_GLOBAL));
# Aifdef BUG_SYSTEME_SG_GL_CURSOR_GLOBAL /* Common,DEFV(Fonction,) : bug... */
# Eifdef BUG_SYSTEME_SG_GL_CURSOR_GLOBAL /* Common,DEFV(Fonction,) : bug... */
# ifdef BUG_SYSTEME_SG_GL_RAPPORT_DE_ZOOM_TROP_GRAND_DE_rectzoom /* Common,DEFV(Fonction,) : bug... */
DEFV(Common,DEFV(Logical,_____BUG_SYSTEME_SG_GL_RAPPORT_DE_ZOOM_TROP_GRAND_DE_rectzoom));
# Aifdef BUG_SYSTEME_SG_GL_RAPPORT_DE_ZOOM_TROP_GRAND_DE_rectzoom /* Common,DEFV(Fonction,) : bug... */
# Eifdef BUG_SYSTEME_SG_GL_RAPPORT_DE_ZOOM_TROP_GRAND_DE_rectzoom /* Common,DEFV(Fonction,) : bug... */
# ifdef BUG_SYSTEME_SG_GL_RAPPORT_DE_ZOOM_NON_ENTIER_DE_rectzoom /* Common,DEFV(Fonction,) : bug... */
DEFV(Common,DEFV(Logical,_____BUG_SYSTEME_SG_GL_RAPPORT_DE_ZOOM_NON_ENTIER_DE_rectzoom));
# Aifdef BUG_SYSTEME_SG_GL_RAPPORT_DE_ZOOM_NON_ENTIER_DE_rectzoom /* Common,DEFV(Fonction,) : bug... */
# Eifdef BUG_SYSTEME_SG_GL_RAPPORT_DE_ZOOM_NON_ENTIER_DE_rectzoom /* Common,DEFV(Fonction,) : bug... */
# ifdef BUG_SYSTEME_SGIND_VL_INTERFERENCES_ENTRE_X_WINDOW_ET_VL /* Common,DEFV(Fonction,) : bug... */
DEFV(Common,DEFV(Logical,_____BUG_SYSTEME_SGIND_VL_INTERFERENCES_ENTRE_X_WINDOW_ET_VL));
# Aifdef BUG_SYSTEME_SGIND_VL_INTERFERENCES_ENTRE_X_WINDOW_ET_VL /* Common,DEFV(Fonction,) : bug... */
# Eifdef BUG_SYSTEME_SGIND_VL_INTERFERENCES_ENTRE_X_WINDOW_ET_VL /* Common,DEFV(Fonction,) : bug... */
# ifdef BUG_SYSTEME_SGIND_VL_PREMIERE_CONNEXION_VIDEO /* Common,DEFV(Fonction,) : bug... */
DEFV(Common,DEFV(Logical,_____BUG_SYSTEME_SGIND_VL_PREMIERE_CONNEXION_VIDEO));
# Aifdef BUG_SYSTEME_SGIND_VL_PREMIERE_CONNEXION_VIDEO /* Common,DEFV(Fonction,) : bug... */
# Eifdef BUG_SYSTEME_SGIND_VL_PREMIERE_CONNEXION_VIDEO /* Common,DEFV(Fonction,) : bug... */
# ifdef BUG_SYSTEME_SGIND_VL_TAILLE_REELLE_DES_IMAGES /* Common,DEFV(Fonction,) : bug... */
DEFV(Common,DEFV(Logical,_____BUG_SYSTEME_SGIND_VL_TAILLE_REELLE_DES_IMAGES));
# Aifdef BUG_SYSTEME_SGIND_VL_TAILLE_REELLE_DES_IMAGES /* Common,DEFV(Fonction,) : bug... */
# Eifdef BUG_SYSTEME_SGIND_VL_TAILLE_REELLE_DES_IMAGES /* Common,DEFV(Fonction,) : bug... */
# ifdef BUG_SYSTEME_SGIND_VL_PACKING_RGB /* Common,DEFV(Fonction,) : bug... */
DEFV(Common,DEFV(Logical,_____BUG_SYSTEME_SGIND_VL_PACKING_RGB));
# Aifdef BUG_SYSTEME_SGIND_VL_PACKING_RGB /* Common,DEFV(Fonction,) : bug... */
# Eifdef BUG_SYSTEME_SGIND_VL_PACKING_RGB /* Common,DEFV(Fonction,) : bug... */
# ifdef BUG_SYSTEME_SGIND_VL_NOMBRE_DE_BUFFERS_PAR_IMAGE_EN_SORTIE_RVB /* Common,DEFV(Fonction,) : bug... */
DEFV(Common,DEFV(Logical,_____BUG_SYSTEME_SGIND_VL_NOMBRE_DE_BUFFERS_PAR_IMAGE_EN_SORTIE_RVB));
# Aifdef BUG_SYSTEME_SGIND_VL_NOMBRE_DE_BUFFERS_PAR_IMAGE_EN_SORTIE_RVB /* Common,DEFV(Fonction,) : bug... */
# Eifdef BUG_SYSTEME_SGIND_VL_NOMBRE_DE_BUFFERS_PAR_IMAGE_EN_SORTIE_RVB /* Common,DEFV(Fonction,) : bug... */
# ifdef BUG_SYSTEME_SGIND_VL_VLSETCONTROL_VL_SIZE /* Common,DEFV(Fonction,) : bug... */
DEFV(Common,DEFV(Logical,_____BUG_SYSTEME_SGIND_VL_VLSETCONTROL_VL_SIZE));
# Aifdef BUG_SYSTEME_SGIND_VL_VLSETCONTROL_VL_SIZE /* Common,DEFV(Fonction,) : bug... */
# Eifdef BUG_SYSTEME_SGIND_VL_VLSETCONTROL_VL_SIZE /* Common,DEFV(Fonction,) : bug... */
# ifdef BUG_SYSTEME_SGIND_VL_VLDESTROYPATH_ENTREE_VIDEO_TEMPS_REEL /* Common,DEFV(Fonction,) : bug... */
DEFV(Common,DEFV(Logical,_____BUG_SYSTEME_SGIND_VL_VLDESTROYPATH_ENTREE_VIDEO_TEMPS_REEL));
# Aifdef BUG_SYSTEME_SGIND_VL_VLDESTROYPATH_ENTREE_VIDEO_TEMPS_REEL /* Common,DEFV(Fonction,) : bug... */
# Eifdef BUG_SYSTEME_SGIND_VL_VLDESTROYPATH_ENTREE_VIDEO_TEMPS_REEL /* Common,DEFV(Fonction,) : bug... */
# ifdef BUG_SYSTEME_SGIND_VL_ENTREE_VIDEO_TEMPS_REEL_NON_GENLOCKEE /* Common,DEFV(Fonction,) : bug... */
DEFV(Common,DEFV(Logical,_____BUG_SYSTEME_SGIND_VL_ENTREE_VIDEO_TEMPS_REEL_NON_GENLOCKEE));
# Aifdef BUG_SYSTEME_SGIND_VL_ENTREE_VIDEO_TEMPS_REEL_NON_GENLOCKEE /* Common,DEFV(Fonction,) : bug... */
# Eifdef BUG_SYSTEME_SGIND_VL_ENTREE_VIDEO_TEMPS_REEL_NON_GENLOCKEE /* Common,DEFV(Fonction,) : bug... */
# ifdef BUG_SYSTEME_SGIND_VL_AXE_DES_Y_LORS_D_UNE_NUMERISATION_D_IMAGE /* Common,DEFV(Fonction,) : bug... */
DEFV(Common,DEFV(Logical,_____BUG_SYSTEME_SGIND_VL_AXE_DES_Y_LORS_D_UNE_NUMERISATION_D_IMAGE));
# Aifdef BUG_SYSTEME_SGIND_VL_AXE_DES_Y_LORS_D_UNE_NUMERISATION_D_IMAGE /* Common,DEFV(Fonction,) : bug... */
# Eifdef BUG_SYSTEME_SGIND_VL_AXE_DES_Y_LORS_D_UNE_NUMERISATION_D_IMAGE /* Common,DEFV(Fonction,) : bug... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* I N C L U D E S S P E C I F I Q U E S D E ' S I L I C O N - G R A P H I C S ' : */
/* */
/*************************************************************************************************************************************/
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
@ include <gl/addrs.h>
@ include <gl/device.h>
@ include <gl/get.h>
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
/* L'include '<gl/gl.h>' est du uniquement a l'utilisation de la fonction 'getgdesc(...)' */
/* afin de determiner le point 'veritable_coin_bas_gauche' avant l'ouverture d'une fenetre. */
/* Il doit etre mis malgre tout dans '$xiidG/fonction.1$DEF' a cause des definitions */
/* 'XMAXPAL' et 'YMAXPAL' qu'il contient... */
@ include <GL/glx.h>
@ include <GL/gl.h>
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# if ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# if (nSYSTEM_RELEASE < 503000000)
@ include <vl/vl.h>
@ include <vl/dev_ev1.h>
/* L'include '<vl/dev_ev1.h>' correspond aux definitions specifiques a la carte 'Galileo'... */
# Aif (nSYSTEM_RELEASE < 503000000)
# Eif (nSYSTEM_RELEASE < 503000000)
# if (nSYSTEM_RELEASE >= 503000000)
@ ifdef SYSTEME_SGO252VA_IRIX
@ define __STDLIB_H__
/* Afin de ne pas faire un include de '<stdlib.h>' dans les includes de '<dmedia/...>'... */
@ Aifdef SYSTEME_SGO252VA_IRIX
@ Eifdef SYSTEME_SGO252VA_IRIX
@ include <dmedia/vl.h>
@ include <dmedia/vl_ev1.h>
/* De meme pour l'include '<dmedia/vl_ev1.h>'... */
# Aif (nSYSTEM_RELEASE >= 503000000)
# Eif (nSYSTEM_RELEASE >= 503000000)
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# if ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
@ include <gl/cg2vme.h>
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
/* Dans ces fichier se trouvent la plupart des definitions de type '#define' ainsi que */
/* les references externes. Nota : */
/* */
/* @ include <gl/gl.h> */
/* */
/* est exceptionnellement situe dans '$xiidG/fonction$DEF' a cause de 'XMAXPAL' et 'YMAXPAL' */
/* qu'il definit et qui sont utilises pour definir 'XminPal', 'XmaxPal', 'YminPal' et */
/* 'YmaxPal'... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S T Y P E S N E C E S S A I R E S : */
/* */
/*************************************************************************************************************************************/
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
TypedefP(G_Screencoord,Screencoord)
/* Structure definissant les coordonnees sur l'ecran. */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
TypedefP(G_Screencoord,GLint)
/* Structure definissant les coordonnees sur l'ecran. */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# if ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
TypedefP(G_VLServer,VLServer)
/* Structure definissant un serveur video. */
TypedefP(G_VLDevList,VLDevList)
/* Structure definissant la liste des "devices" disponibles sur un serveur video. */
TypedefP(G_VLNode,VLNode)
/* Structure definissant un "noeud" d'un serveur video. */
TypedefP(G_VLPath,VLPath)
/* Structure definissant un "chemin" entre deux "noeuds" d'un serveur video. */
TypedefP(G_VLPathList,VLPathList)
/* Pointeur sur une structure 'G_VLPathList'... */
# define Cast_G_VLPathList(x) \
CAST(G_VLPathList,x) \
/* Pour "caster" un pointeur sur une structure 'G_VLPathList'... */
TypedefP(G_VLControlValue,VLControlValue)
/* Structure definissant les listes de parametrage du controle d'un serveur video. */
TypedefP(G_VLBuffer,VLBuffer)
/* Structure definissant les buffers dans lesquels transitent les images. */
TypedefP(G_VLInfoPtr,VLInfoPtr)
/* Structure definissant les informations de validite du contenu des buffers. */
TypedefP(G_VLEvent,VLEvent)
/* Structure definissant l'identite d'un evenement en attente. */
TypedefP(G_VLTransferDescriptor,VLTransferDescriptor)
/* Structure definissant les descripteurs de transferts entre deux "noeuds". */
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# if ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* R E F E R E N C E S E X T E R N E S : */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N S D E S V E R S I O N S : */
/* */
/*************************************************************************************************************************************/
# ifdef __VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : VidAnal. */
# ifdef GESTION_DE_L_OPTION_GALILEO_VERSION_01 /* Common,DEFV(Fonction,) : avec 'VERSION_01'. */
DEFV(Common,DEFV(Logical,_____GESTION_DE_L_OPTION_GALILEO_VERSION_01));
# Aifdef GESTION_DE_L_OPTION_GALILEO_VERSION_01 /* Common,DEFV(Fonction,) : avec 'VERSION_01'. */
# Eifdef GESTION_DE_L_OPTION_GALILEO_VERSION_01 /* Common,DEFV(Fonction,) : avec 'VERSION_01'. */
# ifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02 /* Common,DEFV(Fonction,) : avec 'VERSION_02'. */
DEFV(Common,DEFV(Logical,_____GESTION_DE_L_OPTION_GALILEO_VERSION_02));
# Aifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02 /* Common,DEFV(Fonction,) : avec 'VERSION_02'. */
# Eifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02 /* Common,DEFV(Fonction,) : avec 'VERSION_02'. */
# Aifdef __VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : VidAnal. */
# Eifdef __VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : VidAnal. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N S L O C A L E S : */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S D I M E N S I O N S D E L A F E N E T R E */
/* E N M O D E " H A U T E - D E F I N I T I O N " : */
/* */
/*************************************************************************************************************************************/
DEFV(Common,DEFV(Int,ZINT(SGI_____XminG_d_une_fenetre_HAUTE_DEFINITION,XminG)));
DEFV(Common,DEFV(Int,ZINT(SGI_____XmaxG_d_une_fenetre_HAUTE_DEFINITION,XmaxG)));
DEFV(Common,DEFV(Int,ZINT(SGI_____YminG_d_une_fenetre_HAUTE_DEFINITION,YminG)));
DEFV(Common,DEFV(Int,ZINT(SGI_____YmaxG_d_une_fenetre_HAUTE_DEFINITION,YmaxG)));
/* Definition de fenetre de type "MODE_HAUTE_DEFINITION"... */
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
DEFV(Common,DEFV(Int,ZINT(SGI_____ZminG_d_une_fenetre_HAUTE_DEFINITION,k___Zmin)));
DEFV(Common,DEFV(Int,ZINT(SGI_____ZmaxG_d_une_fenetre_HAUTE_DEFINITION,k___Zmax)));
/* Definition de fenetre de type "MODE_HAUTE_DEFINITION" (suite...). */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# define dimXG_d_une_fenetre_HAUTE_DEFINITION \
DIMENSION(SGI_____XminG_d_une_fenetre_HAUTE_DEFINITION,SGI_____XmaxG_d_une_fenetre_HAUTE_DEFINITION)
# define dimYG_d_une_fenetre_HAUTE_DEFINITION \
DIMENSION(SGI_____YminG_d_une_fenetre_HAUTE_DEFINITION,SGI_____YmaxG_d_une_fenetre_HAUTE_DEFINITION)
/* Definition de la taille de la fenetre de type "MODE_HAUTE_DEFINITION"... */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# define REDUIRE_dimXYG(Dfenetre,Dimage) \
DIVI(Dfenetre \
,QUOE(Dfenetre,ADD3(Dimage,Dimage,Dimage)) \
) \
/* Le programme 'v $xtc/OpenGL.16$c' montre experimentalement que l'affichage d'une image */ \
/* ne se fait pas si l'une de ses dimensions est inferieure au tiers de la dimension */ \
/* correspondante de la fenetre (d'ou le 'ADD3(...)' qui rappelle qu'il y a l'image au */ \
/* centre, et de part et d'autre deux bandes de meme largeur...). D'ou cette correction */ \
/* qui garantit que le rapport n'est jamais plus grand que 3... Mais en fait, depuis */ \
/* j'ai compris que le probleme venait du "viewport" que je fixai arbitrairement, alors */ \
/* qu'il faut en fait demande a qui de droit sa valeur. Malgre cela je conserve cette */ \
/* fonction qui est plus esthetique... */
# define dimXG_d_une_fenetre_HAUTE_DEFINITION \
REDUIRE_dimXYG(DIMENSION(SGI_____XminG_d_une_fenetre_HAUTE_DEFINITION \
,SGI_____XmaxG_d_une_fenetre_HAUTE_DEFINITION \
) \
,dimX \
)
# define dimYG_d_une_fenetre_HAUTE_DEFINITION \
REDUIRE_dimXYG(DIMENSION(SGI_____YminG_d_une_fenetre_HAUTE_DEFINITION \
,SGI_____YmaxG_d_une_fenetre_HAUTE_DEFINITION \
) \
,dimY \
)
/* Definition de la taille de la fenetre de type "MODE_HAUTE_DEFINITION"... */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D O N N E S D E C O N T R O L E E T D ' I N F O R M A T I O N G L O B A L E S : */
/* */
/*************************************************************************************************************************************/
# if ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# define TEMPORISATION_DES_Tant_D_ETABLISSEMENT_DE_CONNEXION \
GRO1(DIVI(nano_secondes,IMAGES_PAR_SECONDE)) \
/* Temporisation a chaque iteration d'un 'Tant(...)' d'etablissement de connexion. */
# define TEMPORISATION_DES_Tant_ATTENTE_DE_BUFFER \
GRO1(DIVI(nano_secondes,IMAGES_PAR_SECONDE)) \
/* Temporisation a chaque iteration d'un 'Tant(...)' d'atente de buffer. */
# define TAILLE_REELLE_DES_IMAGES_EN_OCTETS \
taille_reelle_des_images_en_octets \
/* Taille "reelle" des images en octets dans les buffers videos... */
# if ( ( (defined(BUG_SYSTEME_SGIND_VL_TAILLE_REELLE_DES_IMAGES)) \
&& (! defined(BUG_SYSTEME_SGIND_VL_PACKING_RGB)) \
) \
)
# undef TAILLE_REELLE_DES_IMAGES_EN_OCTETS
# define TAILLE_REELLE_DES_IMAGES_EN_OCTETS \
SCAL(taille_reelle_des_images_en_octets \
,SIZE(genere_LPositive) \
,NOMBRE_DE_COMPOSANTES_CHROMATIQUES \
) \
/* Taille "reelle" des images en octets dans les buffers videos... On notera la regle de */ \
/* trois, car en effet, il semblerait que 'taille_reelle_des_images_en_octets' donne une */ \
/* taille qui considere qu'un point est code sur 4 octets, alors que l'experience montre */ \
/* qu'en realite dans le cas de cette option, il s'agit en fait de 3 octets consecutifs... */
# Aif ( ( (defined(BUG_SYSTEME_SGIND_VL_TAILLE_REELLE_DES_IMAGES)) \
&& (! defined(BUG_SYSTEME_SGIND_VL_PACKING_RGB)) \
) \
)
# Eif ( ( (defined(BUG_SYSTEME_SGIND_VL_TAILLE_REELLE_DES_IMAGES)) \
&& (! defined(BUG_SYSTEME_SGIND_VL_PACKING_RGB)) \
) \
)
DEFV(Local,DEFV(Logical,INIT(la_connexion_video_pour_une_image_a_pu_etre_etablie,FAUX)));
/* Indique en permanence si la connexion video demandee en mode 'MODE_BASSE_DEFINITION_PAL' */
/* a pu etre etablie ('VRAI') ou pas ('FAUX'). */
DEFV(Local,DEFV(Logical,INIT(la_connexion_video_pour_une_sequence_video_temps_reel_a_pu_etre_etablie,FAUX)));
/* Indique en permanence si la connexion video demandee pour une sequence video temps reel */
/* a pu etre etablie ('VRAI') ou pas ('FAUX'). */
# if ( (defined(BUG_SYSTEME_SGIND_VL_PREMIERE_CONNEXION_VIDEO)) \
)
# define NOMBRE_DE_TENTATIVES_DE_CONNEXION_VIDEO \
TROIS \
/* Nombre de tentatives de connexion video. Ce parametre a valu 'DEUX' pendant longtemps, */ \
/* mais le 1994060400, je lui ai donne la valeur 'TROIS' (voir les commentaires de l'alias */ \
/* 'Ivideo' dans 'v $Fdivers'... */
# Aif ( (defined(BUG_SYSTEME_SGIND_VL_PREMIERE_CONNEXION_VIDEO)) \
)
# define NOMBRE_DE_TENTATIVES_DE_CONNEXION_VIDEO \
UN \
/* Nombre de tentatives de connexion video (une seule doit suffire...). */
# Eif ( (defined(BUG_SYSTEME_SGIND_VL_PREMIERE_CONNEXION_VIDEO)) \
)
# define NOM_DU_SERVEUR_VIDEO_DE_L_OPTION_GALILEO \
C_VIDE \
/* Nom du serveur video utilise... */
DEFV(Local,DEFV(G_VLServer,identite_du_serveur_video));
/* Identite du serveur video utilise. */
# define POINTEUR_SUR_UN_OBJET_GALILEO_INEXISTANT \
ZERO \
/* Valeur renvoyee par differentes fonctions en cas d'erreur... */
# define DEMANDE_D_UN_DEVICE_INDIFFERENT \
MOINS_L_INFINI \
/* Afin de pouvoir selectionner n'importe quel "device"... */
# define NOM_DU_DEVICE_ATTENDU \
"ev1" \
/* Malgre tout, le nom du "device" que l'on doit recuperer est connu... */
DEFV(Local,DEFV(CHAR,POINTERc(nom_du_device_reellement_utilise)));
/* Nom du "device" reellement utilise... */
DEFV(Local,DEFV(G_VLNode,identite_du_noeud_emetteur));
DEFV(Local,DEFV(G_VLNode,identite_du_noeud_device));
DEFV(Local,DEFV(G_VLNode,identite_du_noeud_recepteur));
DEFV(Local,DEFV(G_VLNode,identite_du_noeud_mixage));
DEFV(Local,DEFV(G_VLNode,identite_du_noeud_station));
/* Definition de l'identite des "noeud"s necessaires. */
DEFV(Local,DEFV(G_VLPath,chemin_emetteur_recepteur));
/* Definition du chemin entre les "noeud"s emetteur et recepteur. */
DEFV(Local,DEFV(Int,INIT(nombre_d_images_a_manipuler,UN)));
/* Nombre d'images a manipuler... */
DEFV(Local,DEFV(G_VLBuffer,buffer_des_images));
/* Descripteur du buffer dans lequel transiteront les images a manipuler... */
DEFV(Local,DEFV(CHAR,DdTb1(POINTERc,image_courante,TAILLE_REELLE_DES_IMAGES_EN_OCTETS,CHAINE_UNDEF)));
/* Pointeur vers l'image manipulee courante. ATTENTION, il y avait autrefois : */
/* */
/* DEFV(Local,DEFV(CHAR,INIT(POINTERc(image_courante),CHAINE_UNDEF))); */
/* */
/* avant l'introduction des procedures 'DdTb?(...)' et 'MdTb?(...)'. */
/* */
/* Enfin, on notera l'impossibilite d'implanter un : */
/* */
/* FdTb1(image_courante,TAILLE_REELLE_DES_IMAGES_EN_OCTETS,CHAR,CHAINE_UNDEF); */
/* */
/* car cette image est allouee d'une maniere non standard par 'VLGETACTIVEREGION(...)'. */
DEFV(Local,DEFV(Logical,INIT(il_y_a_le_transfert_d_une_image_en_cours,FAUX)));
/* Afin de savoir s'il y a un transfert d'une image en cours... */
DEFV(Local,DEFV(Logical,INIT(il_y_a_le_transfert_d_une_sequence_video_temps_reel_en_cours,FAUX)));
/* Afin de savoir s'il y a un transfert de sequence video temps reel en cours... */
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# if ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* E T A T D E L A F E N E T R E : */
/* */
/*************************************************************************************************************************************/
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# define FENETRE_PAS_OUVERTE_OU_PROBLEMES_A_L_OUVERTURE \
PROBLEMES \
/* Cette valeur "initiale" est choisie en fonction du code de retour en erreur de la */ \
/* fonction 'winopen(...)'. */
DEFV(Local,DEFV(Int,INIT(identificateur_de_la_fenetre,FENETRE_PAS_OUVERTE_OU_PROBLEMES_A_L_OUVERTURE)));
/* Indique si la fenetre n'est pas ouverte (pas encore, ou bien s'il y a un probleme lors */
/* de l'ouverture). */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# define FENETRE_PAS_OUVERTE_OU_PROBLEMES_A_L_OUVERTURE \
INACTIF \
/* Cette valeur "initiale" est choisie en fonction du code de retour en erreur de la */ \
/* fonction 'IXopen_pour_utiliser_OpenGL(...)'. */
DEFV(Local,DEFV(Logical,INIT(identificateur_de_la_fenetre,FENETRE_PAS_OUVERTE_OU_PROBLEMES_A_L_OUVERTURE)));
/* Indique si la fenetre n'est pas ouverte (pas encore, ou bien s'il y a un probleme lors */
/* de l'ouverture). */
DEFV(Common,DEFV(Logical,ZINT(SGI_____appeler_les_fonctions_X_Window_pour_les_sorties_OpenGL,VRAI)));
/* Indique s'il faut ('VRAI') ou pas ('FAUX') appeler les fonctions 'X-Window' pour 'OpenGL' */
/* ceci n'ayant d'utilite qu'en mode 'MODE_BASSE_DEFINITION_PAL'... */
# define APPEL_D_UNE_FONCTION_X_WINDOW_POUR_OpenGL(action_X_Window,action_alternative) \
Bblock \
Test(IL_FAUT(SGI_____appeler_les_fonctions_X_Window_pour_les_sorties_OpenGL)) \
Bblock \
BLOC(action_X_Window;); \
/* Cas ou la fonction 'X-Window' doit etre appelee par 'OpenGL'. */ \
Eblock \
ATes \
Bblock \
BLOC(action_alternative;); \
/* Cas ou la fonction 'X-Window' ne doit pas etre appelee par 'OpenGL'. */ \
Eblock \
ETes \
Eblock \
/* Fonction permettant d'appeler conditionnellement les fonctions 'X-Window' par 'OpenGL'. */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
DenumeT02(MODE_BASSE_DEFINITION_PAL
,MODE_HAUTE_DEFINITION
,modes_de_fonctionnement
)
DEFV(Local,DEFV(Int,INIT(mode_de_fonctionnement,MODE_HAUTE_DEFINITION)));
/* Cet indicateur precise le mode de fonctionnement : */
/* */
/* MODE_HAUTE_DEFINITION : 1280x1024 60 Hz, */
/* */
/* MODE_BASSE_DEFINITION_PAL : 768x576 50 Hz (uniquement avec la 'Video */
/* Analogique', c'est-a-dire la carte 'Galileo' ou */
/* bien l'option 'Video Analogique O2'), */
/* MODE_BASSE_DEFINITION_PAL : 780x575 50 Hz (uniquement avec 'GenLock', pour */
/* plus d'informations sur les branchements utiles, */
/* voir 'v $xiidP/$Fnota'). */
/* */
DEFV(Local,DEFV(pointI_2D,position_coin_bas_gauche));
DEFV(Local,DEFV(pointI_2D,position_coin_haut_droite));
/* Memorisation des coordonnees des deux coins de reference opposes de la fenetre ouverte. */
/* Ces deux points sont declares en 'Local' afin de pouvoir etre utilises n'importe quand */
/* apres l'ouverture d'une fenetre, et en particulier dans : */
/* */
/* IGattente_de_l_evenement_ButtonPress(...) */
/* IGdisplay(...) */
/* */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* P R O C E D U R E S U T I L E S P O U R P R E V O I R D E S C H A N G E M E N T S D E R E L E A S E S : */
/* */
/*************************************************************************************************************************************/
# if ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# if ( (defined(GESTION_DE_L_OPTION_GALILEO_VERSION_01)) \
|| (defined(GESTION_DE_L_OPTION_GALILEO_VERSION_02)) \
)
/* Liste des fonction disponibles avec la 'GESTION_DE_L_OPTION_GALILEO_VERSION_02' : */
/* */
/* 1-releases anterieures a la 5.3 : */
/* */
/* vlAddCallback */
/* vlAddNode */
/* vlAllocID */
/* vlBeginControlSetting */
/* vlBeginTransfer */
/* vlBufferDone */
/* vlCallCallbacks */
/* vlCheckEvent */
/* vlCloseServer */
/* vlCloseVideo */
/* vlConnectionNumber */
/* vlCreateBuffer */
/* vlCreatePath */
/* vlDefaults */
/* vlDeleteContext */
/* vlDeregisterBuffer */
/* vlDestroyBuffer */
/* vlDestroyPath */
/* vlEndControlSetting */
/* vlEndTransfer */
/* vlEventToName */
/* vlEventsQueued */
/* vlFindContext */
/* vlFractionCount */
/* vlFractionList */
/* vlGetActiveRegion */
/* vlGetBufferInfo */
/* vlGetControl */
/* vlGetControlInfo */
/* vlGetControlList */
/* vlGetDMediaInfo */
/* vlGetDevice */
/* vlGetDeviceList */
/* vlGetImageInfo */
/* vlGetLatestValid */
/* vlGetNextFree */
/* vlGetNextValid */
/* vlGetNode */
/* vlGetTransferSize */
/* vlLastKnownRequestProcessed */
/* vlMainLoop */
/* vlMatchFloat */
/* vlMatchFraction */
/* vlMatchFractionInList */
/* vlNextEvent */
/* vlNextRequest */
/* vlOpenVideo */
/* vlPeekEvent */
/* vlPending */
/* vlPerror */
/* vlPutFree */
/* vlPutValid */
/* vlQLength */
/* vlRegisterBuffer */
/* vlRegisterHandler */
/* vlRemoveAllCallbacks */
/* vlRemoveCallback */
/* vlRemoveHandler */
/* vlRemoveNode */
/* vlRestoreFactoryDefaults */
/* vlRestoreSystemDefaults */
/* vlSaveContext */
/* vlSaveSystemDefaults */
/* vlSelectEvents */
/* vlServerProtocolRevision */
/* vlServerProtocolVersion */
/* vlServerString */
/* vlServerVendor */
/* vlServerVendorRelease */
/* vlSetAuthorization */
/* vlSetControl */
/* vlSetErrorHandler */
/* vlSetIOErrorHandler */
/* vlSetupPaths */
/* vlStrError */
/* vlUniqueContext */
/* */
/* */
/* 2-release 5.3 : */
/* */
/* vlAddCallback */
/* vlAddNode */
/* vlAllocID */
/* vlBeginTransfer */
/* vlBufferAdvise */
/* vlBufferDone */
/* vlBufferGetFd */
/* vlBufferReset */
/* vlCallCallbacks */
/* vlCheckEvent */
/* vlChooseClosestFraction */
/* vlCloseVideo */
/* vlConnectionNumber */
/* vlConversionAdviseFlag */
/* vlConversionAdviseGamma */
/* vlConversionAdviseMatrix */
/* vlCreateBuffer */
/* vlCreatePath */
/* vlDefaults */
/* vlDeregisterBuffer */
/* vlDestroyBuffer */
/* vlDestroyPath */
/* vlEndTransfer */
/* vlErrno */
/* vlEventToName */
/* vlFractionCount */
/* vlFractionList */
/* vlFreeControlInfo */
/* vlFreeControlList */
/* vlGetActiveRegion */
/* vlGetControl */
/* vlGetControlInfo */
/* vlGetControlList */
/* vlGetDMediaInfo */
/* vlGetDevice */
/* vlGetDeviceList */
/* vlGetErrno */
/* vlGetImageInfo */
/* vlGetLatestValid */
/* vlGetNextFree */
/* vlGetNextValid */
/* vlGetNode */
/* vlGetTransferSize */
/* vlLastKnownRequestProcessed */
/* vlMainLoop */
/* vlMatchFloat */
/* vlMatchFraction */
/* vlMatchFractionInList */
/* vlNextEvent */
/* vlNextRequest */
/* vlOpenVideo */
/* vlPeekEvent */
/* vlPending */
/* vlPerror */
/* vlPutFree */
/* vlPutValid */
/* vlQLength */
/* vlRegisterBuffer */
/* vlRegisterHandler */
/* vlRemoveAllCallbacks */
/* vlRemoveCallback */
/* vlRemoveHandler */
/* vlRemoveNode */
/* vlRestoreFactoryDefaults */
/* vlRestoreSystemDefaults */
/* vlSaveSystemDefaults */
/* vlSelectEvents */
/* vlServerProtocolRevision */
/* vlServerProtocolVersion */
/* vlServerString */
/* vlServerVendor */
/* vlServerVendorRelease */
/* vlSetControl */
/* vlSetErrorHandler */
/* vlSetIOErrorHandler */
/* vlSetupPaths */
/* vlStrError */
/* vlerrorstrs */
/* */
# define VLADDNODE(serveur_video,chemin,noeud) \
vlAddNode(serveur_video,chemin,noeud) \
/* Ajout d'un noeud a un chemin. */
# define VLBEGINTRANSFER(serveur_video,chemin,nombre_de_descripteurs,descripteurs_de_transfert_d_images) \
vlBeginTransfer(serveur_video,chemin,nombre_de_descripteurs,descripteurs_de_transfert_d_images) \
/* Lancement d'un transfert. */
# define VLBUFFERDONE(buffer_des_images) \
vlBufferDone(buffer_des_images) \
/* Acces au "flag" associe a un buffer. */
# define VLCLOSEVIDEO(serveur_video) \
vlCloseVideo(serveur_video) \
/* Fermeture d'un serveur video. */
# define VLCREATEBUFFER(serveur_video,chemin,noeud,nombre_d_images_a_manipuler) \
vlCreateBuffer(serveur_video,chemin,noeud,nombre_d_images_a_manipuler) \
/* Creation d'un buffer. */
# define VLCREATEPATH(serveur_video,numero_du_device_a_utiliser,Nemetteur,Nrecepteur) \
vlCreatePath(serveur_video,numero_du_device_a_utiliser,Nemetteur,Nrecepteur) \
/* Creation d'un chemen entre deux noeuds. */
# define VLDEREGISTERBUFFER(serveur_video,chemin,noeud,buffer_des_images) \
vlDeregisterBuffer(serveur_video,chemin,noeud,buffer_des_images) \
/* Desenregistrement d'un buffer. */
# define VLDESTROYBUFFER(serveur_video,buffer_des_images) \
vlDestroyBuffer(serveur_video,buffer_des_images) \
/* Destruction d'un buffer. */
# define VLDESTROYPATH(serveur_video,chemin) \
vlDestroyPath(serveur_video,chemin) \
/* Destruction d'un chemin. */
# define VLENDTRANSFER(serveur_video,chemin) \
vlEndTransfer(serveur_video,chemin) \
/* Fin d'un transfert. */
# define VLGETACTIVEREGION(serveur_video,buffer_des_images,informations_sur_l_image_courante) \
vlGetActiveRegion(serveur_video,buffer_des_images,informations_sur_l_image_courante) \
/* Acces a la region active d'un buffer. */
# define VLGETCONTROL(serveur_video,chemin,noeud,type,parametres_courants) \
vlGetControl(serveur_video,chemin,noeud,type,parametres_courants) \
/* Recuperation d'informations de controle d'un noeud. */
# define VLGETDEVICE(serveur_video,chemin) \
vlGetDevice(serveur_video,chemin) \
/* Acces a un "device". */
# define VLGETDEVICELIST(serveur_video,liste_des_devices_disponibles) \
vlGetDeviceList(serveur_video,liste_des_devices_disponibles) \
/* Acces a la liste des "devices"s disponibles. */
# define VLGETNEXTFREE(serveur_video,buffer_des_images,taille_des_images) \
vlGetNextFree(serveur_video,buffer_des_images,taille_des_images) \
/* Acces au prochain buffer libre (et donc disponible...). */
# define VLGETNEXTVALID(serveur_video,buffer_des_images) \
vlGetNextValid(serveur_video,buffer_des_images) \
/* Acces aux informations valides suivantes. */
# define VLGETNODE(serveur_video,type_du_noeud,classe_du_noeud,numero_du_noeud) \
vlGetNode(serveur_video,type_du_noeud,classe_du_noeud,numero_du_noeud) \
/* Acces a un noeud. */
# define VLGETTRANSFERSIZE(serveur_video,chemin) \
vlGetTransferSize(serveur_video,chemin) \
/* Acces a la taille du transfert a realiser. */
# define VLNEXTEVENT(serveur_video,evenement) \
vlNextEvent(serveur_video,ADRESSE(evenement)) \
/* Acces a l'evenement en attente situe en tete de la liste. */
# define VLOPENVIDEO(nom_du_serveur) \
vlOpenVideo(nom_du_serveur) \
/* Ouverture d'un serveur video. */
# define VLPENDING(serveur_video) \
vlPending(serveur_video) \
/* Acces au nombre d'evenements en attente... */
# define VLPERROR(message_d_erreur) \
vlPerror(message_d_erreur) \
/* Edition d'un message d'erreur "explicite"... */
# define VLPUTFREE(serveur_video,buffer_des_images) \
vlPutFree(serveur_video,buffer_des_images) \
/* Liberation d'un buffer acquis par 'VLGETNEXTVALID(...)'. */
# define VLPUTVALID(serveur_video,buffer_des_images) \
vlPutValid(serveur_video,buffer_des_images) \
/* Mise en place du buffer valide. */
# define VLREGISTERBUFFER(serveur_video,chemin,noeud,buffer_des_images) \
vlRegisterBuffer(serveur_video,chemin,noeud,buffer_des_images) \
/* Enregistrement d'un buffer. */
# define VLRESTOREFACTORYDEFAULTS(serveur_video) \
vlRestoreFactoryDefaults(serveur_video) \
/* Reinitialisation de base... */
# define VLRESTORESYSTEMDEFAULTS(serveur_video) \
vlRestoreSystemDefaults(serveur_video) \
/* Reinitialisation a partir du fichier '/usr/etc/video/videod.defaults'. */
# define VLSELECTEVENTS(serveur_video,chemin,evenements_interessants) \
vlSelectEvents(serveur_video,chemin,evenements_interessants) \
/* Selection des evenements utiles. */
# define VLSETCONTROL(serveur_video,chemin,identite_du_noeud,type_du_parametre,parametres_courants) \
vlSetControl(serveur_video,chemin,identite_du_noeud,type_du_parametre,parametres_courants) \
/* Mise en place de certaines informations de controle d'un noeud. */
# define VLSETUPPATHS(serveur_video,chemin,nombre_de_chemins_a_etablir,usage_controle,controle_flot) \
vlSetupPaths(serveur_video,chemin,nombre_de_chemins_a_etablir,usage_controle,controle_flot) \
/* Etablissement d'un chemin. */
# Aif ( (defined(GESTION_DE_L_OPTION_GALILEO_VERSION_01)) \
|| (defined(GESTION_DE_L_OPTION_GALILEO_VERSION_02)) \
)
# Eif ( (defined(GESTION_DE_L_OPTION_GALILEO_VERSION_01)) \
|| (defined(GESTION_DE_L_OPTION_GALILEO_VERSION_02)) \
)
# define REINITIALISATION_DE_LA_CARTE_GALILEO(serveur_video) \
VLRESTOREFACTORYDEFAULTS(serveur_video) \
/* Reinitialisation de la carte 'Galileo'. Il y a deux possibilites : */ \
/* */ \
/* VLRESTOREFACTORYDEFAULTS(...) : qui parait etre la possibilite la plus logique. */ \
/* Malheureusement, tant que les deux controles */ \
/* 'VL_DEFAULT_SOURCE' et 'VL_SYNC' ne fonctionnent */ \
/* pas correctement, une partie de la programmation */ \
/* de la carte 'Galileo' doit passer par le fichier */ \
/* '/usr/etc/video/videod.defaults' de configuration. */ \
/* */ \
/* VLRESTORESYSTEMDEFAULTS(...) : qui ne devrait pas etre utilisee, car, en effet, */ \
/* toute modification qui pourrait etre apportee au */ \
/* fichier '/usr/etc/video/videod.defaults', par */ \
/* exemple, a l'aide de la commande 'videopanel' se */ \
/* trouverait incluse dans les initialisations qui */ \
/* suivent et pourrait alors rentrer en conflit avec */ \
/* la configuration qui doit etre reellement mise en */ \
/* place... */ \
/* */
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* N E T T O Y A G E D ' U N E F E N E T R E : */
/* */
/*************************************************************************************************************************************/
BFonctionI
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL /* Common,DEFV(Fonction,) : avec 'GL'... */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL /* Common,DEFV(Fonction,) : avec 'GL'... */
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL /* Common,DEFV(Fonction,) : avec 'GL'... */
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL /* Common,DEFV(Fonction,) : avec 'OpenGL'... */
DEFV(Common,DEFV(genere_p,SINT(SGI_____fond_de_la_fenetre_ROUGE,NOIR)));
DEFV(Common,DEFV(genere_p,SINT(SGI_____fond_de_la_fenetre_VERTE,NOIR)));
DEFV(Common,DEFV(genere_p,SINT(SGI_____fond_de_la_fenetre_BLEUE,NOIR)));
DEFV(Common,DEFV(genere_p,SINT(SGI_____fond_de_la_fenetre_ALPHA,BLANC)));
/* Afin de definir le fond de la fenetre... */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL /* Common,DEFV(Fonction,) : avec 'OpenGL'... */
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL /* Common,DEFV(Fonction,) : avec 'OpenGL'... */
DEFV(Common,DEFV(FonctionI,IGclear()))
/* Cette fonction a ete introduite le 19990310141501 afin d'assurer le nettoyage du fond */
/* d'une fenetre apres son retour au premier-plan... */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/* ATTENTION : 'INIT_ERROR' est mis en tete des variables locales au cas ou des couples */
/* ('BDEFV','EDEFV') suivraient... */
/*..............................................................................................................................*/
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
CALS(color(BLACK));
CALS(clear());
/* Nettoyage du plan de travail. */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
CALS(glClearColor(______NORMALISE_NIVEAU(SGI_____fond_de_la_fenetre_ROUGE)
,______NORMALISE_NIVEAU(SGI_____fond_de_la_fenetre_VERTE)
,______NORMALISE_NIVEAU(SGI_____fond_de_la_fenetre_BLEUE)
,______NORMALISE_NIVEAU(SGI_____fond_de_la_fenetre_ALPHA)
)
);
CALS(glClear(GL_COLOR_BUFFER_BIT));
/* Initialisation du contenu de la fenetre. */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* O U V E R T U R E D ' U N E F E N E T R E : */
/* */
/*************************************************************************************************************************************/
BFonctionI
# ifdef __VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : VidAnal. */
# define VL_INDIFFERENT \
ZERO \
/* Valeur qui semble manquer dans <vl/vl$h>... */
# define VL_DOIT_ETRE_NUL \
ZERO \
/* Valeur qui semble manquer dans <vl/vl$h>... */
# define ERREUR_DE_PARAMETRAGE(identite_du_noeud,type_parametre,message_d_erreur,iter) \
Bblock \
VLPERROR(message_d_erreur); \
\
CAL1(Prer1(" nom du 'device'....=%s\n",nom_du_device_reellement_utilise)); \
/* Le nom du 'device' attendu est "ev1"... */ \
CAL1(Prer1(" nature du noeud....=%s\n" \
,COND(IFID(identite_du_noeud,identite_du_noeud_emetteur) \
,"emetteur" \
,COND(IFID(identite_du_noeud,identite_du_noeud_device) \
,"device" \
,COND(IFID(identite_du_noeud,identite_du_noeud_recepteur) \
,"recepteur" \
,"autre" \
) \
) \
) \
) \
); \
CAL1(Prer0(" type du Parametre..=type_parametre\n")); \
/* On notera que l'on n'ecrit pas : */ \
/* */ \
/* CAL1(Prer0(" type du Parametre='type_parametre'\n")); */ \
/* */ \
/* car en effet, la chaine de caractere substituee a 'type_parametre' est suivie de */ \
/* nombreux blancs ; cela ferait alors une mauvaise mise en page... */ \
/* */ \
/* On notera les "..." introduits (ici et ailleurs...) le 20030331171922 afin de garantir */ \
/* la position horizontale des "="s. */ \
\
Test(EST_FAUX(une_erreur_forcant_l_iteration_a_ete_rencontree)) \
Bblock \
EGAL(une_erreur_forcant_l_iteration_a_ete_rencontree,iter); \
/* Dans le cas ou une erreur demandant l'iteration n'a pas ete encore rencontree, on */ \
/* fait ce qu'il faut pour l'erreur courante... */ \
Eblock \
ATes \
Bblock \
/* Dans le cas ou une erreur demandant l'iteration a deja rencontree, on maintient cette */ \
/* demande en ne faisant rien d'autre... */ \
Eblock \
ETes \
Eblock \
/* Edition d'une partie des messages d'erreur de 'PARAMETRAGE_NOEUD_?(...)'. */
# define UNE_ERREUR_ICI_DOIT_FORCER_L_ITERATION \
VRAI
# define UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION \
NOTL(UNE_ERREUR_ICI_DOIT_FORCER_L_ITERATION)
/* Afin de savoir si une erreur dans un 'PARAMETRAGE_NOEUD_?(...)' doit forcer l'iteration */
/* de la fonction 'IGdebut_de_diffusion_ou_de_numerisation_d_une_sequence_video(...)'. Cette */
/* possibilite a ete rajoutee a cause du controle 'VL_MUXSWITCH' (et de ceux qui le suivent) */
/* lorsque par malheur lors du controle 'VL_DEFAULT_SOURCE' qui le precede, il y a eu un */
/* changement de source par defaut (ce qui signifie qu'anterieurement on etait en mode */
/* "digital 1" ou "digital 2"). Alors les controles du type 'VL_MUXSWITCH' sont refuses */
/* avec le message : */
/* */
/* VL: Bad control passed as parameter */
/* */
/* ce qui signifie que la liste des controles autorises pour ce chemin ne s'est pas */
/* enrichi des nouveaux controles associes au passage en mode "analog"... Afin de ne pas */
/* rajouter une nouvelle serie de 'Test(...)' imbriques les uns dans les autres et associes */
/* au refus de ces controles, on donne ici la possibilite de faire forcer la repetition de */
/* la sequence complete d'ouverture et en particulier 'VLOPENVIDEO(...)' qui fait qu'apres */
/* cet appel, les controles en cause ('VL_MUXSWITCH',...) sont miraculeusement autorises... */
# define EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL \
VRAI
# define NE_PAS_EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL \
NOTL(EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL)
/* Pour editer ou pas les messages d'erreur de 'VLSETCONTROL(...)'. */
DEFV(Local,DEFV(G_VLControlValue,parametres_courants));
/* Liste des parametres courants des noeuds, des chemins, du serveur,... */
# define PARAMETRAGE_NOEUD_1(identite_du_noeud,parametre,valeur,type_parametre,edit,iter) \
/* On notera que l'on ne peut pas creer 'PARAMETRAGE_NOEUD_QUELCONQUE(...)' a cause */ \
/* de l'edition d'un nombre variable de valeurs en cas d'erreur... */ \
Bblock \
EGAL(ASD1(parametres_courants,parametre),valeur); \
\
Test(PAS_D_ERREUR(VLSETCONTROL(identite_du_serveur_video \
,chemin_emetteur_recepteur \
,identite_du_noeud \
,type_parametre \
,ADRESSE(parametres_courants) \
) \
) \
) \
Bblock \
Eblock \
ATes \
Bblock \
Test(IL_FAUT(edit)) \
Bblock \
ERREUR_DE_PARAMETRAGE(identite_du_noeud \
,type_parametre \
,"\n Parametrage Noeud 1" \
,iter \
); \
CAL1(Prer1(" Valeur demandee....=%d\n" \
,valeur \
) \
); \
/* On notera que l'on edite systematiquement en format 'entier %d' ce qui n'est pas genant */ \
/* car, en effet, toutes les valeurs possibles sont dans ce format... */ \
Test(PAS_D_ERREUR(VLGETCONTROL(identite_du_serveur_video \
,chemin_emetteur_recepteur \
,identite_du_noeud \
,type_parametre \
,ADRESSE(parametres_courants) \
) \
) \
) \
Bblock \
CAL1(Prer1(" Valeur obtenue.....=%d\n" \
,ASD1(parametres_courants,parametre) \
) \
); \
/* On notera que l'on edite systematiquement en format 'entier %d' ce qui n'est pas genant */ \
/* car, en effet, toutes les valeurs possibles sont dans ce format... */ \
Eblock \
ATes \
Bblock \
ERREUR_DE_PARAMETRAGE(identite_du_noeud \
,type_parametre \
,"Verification Noeud 1" \
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION \
); \
/* On notera l'utilisation de 'UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION' quelle que */ \
/* soit la valeur de 'iter' afin de ne traiter qu'une seule fois 'iter' dans les procedures */ \
/* de type 'PARAMETRAGE_NOEUD_?(...)'. */ \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ETes \
Eblock \
/* Parametrage d'un noeud avec une valeur. */
# define PARAMETRAGE_NOEUD_2(identite_du_noeud,parametre1,parametre11,valeur1,parametre12,valeur2,type_parametre,edit,iter) \
/* On notera que l'on ne peut pas creer 'PARAMETRAGE_NOEUD_QUELCONQUE(...)' a cause */ \
/* de l'edition d'un nombre variable de valeurs en cas d'erreur... */ \
Bblock \
EGAL(ASD2(parametres_courants,parametre1,parametre11),valeur1); \
EGAL(ASD2(parametres_courants,parametre1,parametre12),valeur2); \
\
Test(PAS_D_ERREUR(VLSETCONTROL(identite_du_serveur_video \
,chemin_emetteur_recepteur \
,identite_du_noeud \
,type_parametre \
,ADRESSE(parametres_courants) \
) \
) \
) \
Bblock \
Eblock \
ATes \
Bblock \
Test(IL_FAUT(edit)) \
Bblock \
ERREUR_DE_PARAMETRAGE(identite_du_noeud \
,type_parametre \
,"\n Parametrage Noeud 2" \
,iter \
); \
CAL1(Prer2(" Valeur demandee....={%d,%d}\n" \
,valeur1 \
,valeur2 \
) \
); \
/* On notera que l'on edite systematiquement en format 'entier %d' ce qui n'est pas genant */ \
/* car, en effet, toutes les valeurs possibles sont dans ce format... */ \
Test(PAS_D_ERREUR(VLGETCONTROL(identite_du_serveur_video \
,chemin_emetteur_recepteur \
,identite_du_noeud \
,type_parametre \
,ADRESSE(parametres_courants) \
) \
) \
) \
Bblock \
CAL1(Prer2(" Valeur obtenue.....={%d,%d}\n" \
,ASD2(parametres_courants,parametre1,parametre11) \
,ASD2(parametres_courants,parametre1,parametre12) \
) \
); \
/* On notera que l'on edite systematiquement en format 'entier %d' ce qui n'est pas genant */ \
/* car, en effet, toutes les valeurs possibles sont dans ce format... */ \
Eblock \
ATes \
Bblock \
ERREUR_DE_PARAMETRAGE(identite_du_noeud \
,type_parametre \
,"Verification Noeud 2" \
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION \
); \
/* On notera l'utilisation de 'UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION' quelle que */ \
/* soit la valeur de 'iter' afin de ne traiter qu'une seule fois 'iter' dans les procedures */ \
/* de type 'PARAMETRAGE_NOEUD_?(...)'. */ \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ETes \
Eblock \
/* Parametrage d'un noeud avec deux valeurs. */
# define nPARAMETRAGE_NOEUD_1(identite_du_noeud,parametre,valeur,type_parametre,edit,iter) \
Bblock \
BLOC(VIDE;); \
Eblock \
/* Parametrage ineffectif d'un noeud avec une valeur. Cette procedure a ete introduite */ \
/* pour conserver des sequences de code apparemment inutiles... */
# define nPARAMETRAGE_NOEUD_2(identite_du_noeud,parametre1,parametre11,valeur1,parametre12,valeur2,type_parametre,edit,iter) \
Bblock \
BLOC(VIDE;); \
Eblock \
/* Parametrage ineffectif d'un noeud avec deux valeurs. Cette procedure a ete introduite */ \
/* pour conserver des sequences de code apparemment inutiles... */
# define SE_SYNCHRONISER_SUR_UNE_SOURCE_EXTERNE \
SGI_____se_synchroniser_sur_une_source_externe
# define SYNCHRONISER_LA_CARTE_GALILEO_SUR_UNE_SOURCE_EXTERNE \
VRAI
# define NE_PAS_SYNCHRONISER_LA_CARTE_GALILEO_SUR_UNE_SOURCE_EXTERNE \
NOTL(SYNCHRONISER_LA_CARTE_GALILEO_SUR_UNE_SOURCE_EXTERNE)
DEFV(Common,DEFV(Logical,SINT(SGI_____se_synchroniser_sur_une_source_externe,SYNCHRONISER_LA_CARTE_GALILEO_SUR_UNE_SOURCE_EXTERNE)));
/* Indique s'il faut ('VRAI') ou pas ('FAUX') se synchroniser sur une source externe, par */
/* exemple pour des enregistrements disques... */
/* */
/* ATTENTION, lorsque l'on est en 'VL_SYNC_GENLOCK' la sortie 'Pal' ("composite") de la */
/* carte 'Galileo' ne fonctionne pas correctement ; en particulier on perd la couleur... */
/* Pour sortir du 'Pal', il faut donc etre en mode 'VL_SYNC_INTERNAL', et donc ne pas se */
/* synchroniser sur une source externe... */
# if (nSYSTEM_RELEASE < 503000000) /* Common,DEFV(Fonction,) : avec 'VideoAnalogique'. */
# define LISTE_DES_EVENEMENTS_A_DETECTER \
VLNoEventsMask \
/* Liste des evenements a detecter au cours d'un transfert. */
# define DETECTION_DES_DEFAUTS_EN_COURS_DE_TRANSFERT(se_mettre_en_mode_genlock) \
Bblock \
BLOC(VIDE;); \
Eblock \
/* Detection des defauts ayant eu lieu au cours d'un transfert. */
# Aif (nSYSTEM_RELEASE < 503000000) /* Common,DEFV(Fonction,) : avec 'VideoAnalogique'. */
# Eif (nSYSTEM_RELEASE < 503000000) /* Common,DEFV(Fonction,) : avec 'VideoAnalogique'. */
# if (nSYSTEM_RELEASE >= 503000000) /* Common,DEFV(Fonction,) : avec 'VideoAnalogique'. */
# define LISTE_DES_EVENEMENTS_A_DETECTER \
OUIN(COND(IL_FAUT(SE_SYNCHRONISER_SUR_UNE_SOURCE_EXTERNE) \
,VLSyncLostMask \
,VLNoEventsMask \
) \
,OUIN(VLTransferFailedMask \
,VLNoEventsMask \
) \
) \
/* Liste des evenements a detecter au cours d'un transfert. */
# define TEMPORISATION_AVANT_DE_TESTER_LES_EVENEMENTS \
ZERO \
/* L'experience montre qu'il est necessaire d'attendre un peu avant d'executer la fonction */ \
/* 'VLPENDING(...)' car, sinon, on perd au moins un evenement... Malheureusement, une valeur */ \
/* non nulle provoque un phenomene visuel ennuyeux : en effet, lors d'une entree video, la */ \
/* fenetre 'X-Window' ouverte precedemment, le reste alors que l'on a decide d'arreter le */ \
/* transfert ; alors un desagreable effet Larsen apparait (la memoire se trouve alors en */ \
/* quelque sorte bouclee sur elle-meme). */
# define TEMPORISATION_DE_BLOCAGE_SUR_DEFAUT_EN_COURS_DE_TRANSFERT \
SECONDES_PAR_MINUTE
DEFV(Common,DEFV(Logical,SINT(SGI_____bloquer_generation_video_si_defaut_en_cours_de_transfert,VRAI)));
/* Indique s'il faut ('VRAI') ou pas ('FAUX') bloquer ad vitam eternam la generation video */
/* si un defaut de type 'VLSyncLost' se presente, et ce afin d'eviter des enregistrements */
/* d'images NOIR sur le disque 'PAL-beta'... */
# define DETECTION_DES_DEFAUTS_EN_COURS_DE_TRANSFERT(se_mettre_en_mode_genlock) \
Bblock \
DEFV(Int,INIT(nombre_d_evements_en_attente,UNDEF)); \
/* Afin de parcourir la liste des evenements en attente... */ \
\
DODO(TEMPORISATION_AVANT_DE_TESTER_LES_EVENEMENTS); \
/* Attente eventuelle afin de garantir qu'on connait tous les evenements... */ \
EGAL(nombre_d_evements_en_attente,VLPENDING(identite_du_serveur_video)); \
/* Recuperation du nombre d'evenements en attente, qui sont en fait des defauts... */ \
\
Test(IZNE(nombre_d_evements_en_attente)) \
Bblock \
PRINT_ERREUR("il y a eu au moins un defaut pendant le transfert qui s'acheve ici"); \
\
Repe(nombre_d_evements_en_attente) \
Bblock \
DEFV(G_VLEvent,evenement_courant); \
CALS(VLNEXTEVENT(identite_du_serveur_video,evenement_courant)); \
/* Recuperation de l'evenement courant. */ \
\
Choi(ASD1(evenement_courant,reason)) \
Bblock \
Ca1e(VLSyncLost) \
Bblock \
PRINT_ERREUR("il y a soit un probleme de synchronisation en sortie"); \
PRINT_ERREUR("ou bien une absence de signal video en entree"); \
Test(IL_FAUT(se_mettre_en_mode_genlock)) \
Bblock \
PRINT_ATTENTION("le mode 'genlock' etait demande"); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Test(IL_FAUT(SGI_____bloquer_generation_video_si_defaut_en_cours_de_transfert)) \
Bblock \
Loop \
Bblock \
PRINT_ATTENTION("le processus de generation video est bloque"); \
DODO(TEMPORISATION_DE_BLOCAGE_SUR_DEFAUT_EN_COURS_DE_TRANSFERT); \
/* Le 19980316122616, ce blocage ad vitam eternam a ete introduit afin de garantir que */ \
/* lorsque ceci est utilise pour enregistrer sur le disque 'PAL-beta' il n'y ait pas de */ \
/* risque d'enregistrer les images NOIR... */ \
Eblock \
ELoo \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
ECa1 \
\
Ca1e(VLTransferFailed) \
Bblock \
PRINT_ERREUR("le transfert a ete aborte"); \
Eblock \
ECa1 \
\
Defo \
Bblock \
PRINT_ERREUR("un defaut n'est pas reconnu"); \
/* Bizarre, voir la definition de 'LISTE_DES_EVENEMENTS_A_DETECTER'... */ \
Eblock \
EDef \
Eblock \
ECho \
Eblock \
ERep \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
Eblock \
/* Detection des defauts ayant eu lieu au cours d'un transfert. */
# Aif (nSYSTEM_RELEASE >= 503000000) /* Common,DEFV(Fonction,) : avec 'VideoAnalogique'. */
# Eif (nSYSTEM_RELEASE >= 503000000) /* Common,DEFV(Fonction,) : avec 'VideoAnalogique'. */
# define VISUALISER_LE_CONTENU_DE_L_ECRAN_DE_LA_STATION_DE_TRAVAIL \
VRAI
# define VISUALISER_UNE_IMAGE_RASTER \
NOTL(VISUALISER_LE_CONTENU_DE_L_ECRAN_DE_LA_STATION_DE_TRAVAIL)
DEFV(Common,DEFV(Logical,SINT(SGI_____visualiser_le_contenu_de_l_ecran_de_la_station_de_travail,VISUALISER_UNE_IMAGE_RASTER)));
/* Indique s'il faut ('VRAI') visualiser le contenu de l'ecran de la station de travail ou */
/* bien une image raster ('FAUX'), ce qui est l'etat par defaut... On notera que lorsque */
/* cette option est utilisee, avec le parametre 'SGI_____decalage_de_VL_EV1_V_OFFSET' par */
/* defaut, il y a une bande blanche en haut de l'ecran ; toucher au decalage vertical (en */
/* fixant a 2 par exemple) fait disparaitre cette bande, mais ce n'est pas pour cela que */
/* l'on recupere le bas de l'ecran qui semble toujours perdu... */
# ifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02 /* Common,DEFV(Fonction,) : en 'VERSION_02'... */
# define CHOIX_DE_LA_SOURCE_DE_SYNCHRONISATION_EXTERNE \
Bblock \
Test(IFET(IL_FAUT(SE_SYNCHRONISER_SUR_UNE_SOURCE_EXTERNE) \
,I3ET(IFNE(SGI_____Gentree_de_synchronisation_genlock \
,VL_SYNC_SOURCE_COMPOSITE_1 \
) \
,IFNE(SGI_____Gentree_de_synchronisation_genlock \
,VL_SYNC_SOURCE_COMPOSITE_2 \
) \
,IFNE(SGI_____Gentree_de_synchronisation_genlock \
,VL_SYNC_SOURCE_COMPOSITE_3 \
) \
) \
) \
) \
Bblock \
PRINT_ERREUR("entree 'genlock' non reconnue (entree implicite forcee)"); \
EGAL(SGI_____Gentree_de_synchronisation_genlock,VL_SYNC_SOURCE_COMPOSITE); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
\
PARAMETRAGE_NOEUD_1(identite_du_noeud_device \
,intVal \
,SGI_____Gentree_de_synchronisation_genlock \
,VL_SYNC_SOURCE \
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL \
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION \
); \
Eblock \
/* Choix et validation de la source de synchronisation externe... */
# define VL_SYNC_SOURCE_COMPOSITE_1 \
ZERO
# define VL_SYNC_SOURCE_COMPOSITE_2 \
UN
# define VL_SYNC_SOURCE_COMPOSITE_3 \
DEUX
/* Valeur qui semble manquer dans <vl/vl$h> et qui definissent les sources possibles pour */
/* la synchronisation "genlock" ; ces informations ont ete obtenues grace a la commande : */
/* */
/* vlinfo -l */
/* */
/* en examinant les lignes : */
/* */
/* Name: genlocksrc */
/* Type: 58 */
/* */
/* || */
/* || */
/* ===========> 'VL_SYNC_SOURCE' (dans '<vl/vl.h>') */
/* */
/* composite 1 = 0 */
/* composite 2 = 1 */
/* composite 3 = 2 */
/* */
/* On notera les correspondances physiques (au niveau des connecteurs) suivantes : */
/* */
/* VL_SYNC_SOURCE_COMPOSITE_1 <==> VL_MUXSWITCH_COMPOSITE_1 */
/* VL_SYNC_SOURCE_COMPOSITE_2 <==> VL_MUXSWITCH_COMPOSITE_2 */
/* VL_SYNC_SOURCE_COMPOSITE_3 <==> VL_MUXSWITCH_COMPOSITE_3 */
/* */
# define VL_SYNC_SOURCE_COMPOSITE \
VL_SYNC_SOURCE_COMPOSITE_2
DEFV(Common,DEFV(Int,SINT(SGI_____Gentree_de_synchronisation_genlock,VL_SYNC_SOURCE_COMPOSITE)));
/* Definition de la source de synchronisation "genlock" utilisee. Il parait d'ailleurs */
/* que l'on ne peut utiliser ici que 'VL_SYNC_SOURCE_COMPOSITE_2'... */
# Aifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02 /* Common,DEFV(Fonction,) : en 'VERSION_02'... */
# Eifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02 /* Common,DEFV(Fonction,) : en 'VERSION_02'... */
# define MISE_DU_CHEMIN_EN_MODE_LOCK_LOCK \
Bblock \
Test(PAS_D_ERREUR(VLSETUPPATHS(identite_du_serveur_video \
,Cast_G_VLPathList(ADRESSE(chemin_emetteur_recepteur)) \
,nombre_de_chemins_a_etablir \
,VL_LOCK \
,VL_LOCK \
) \
) \
) \
/* Preparation du hardware pour permettre l'usage des controles et des flots d'informations. */ \
/* L'usage ici choisit est le mode exclusif ('VL_LOCK'). On notera que 'VLSETUPPATHS(...)' */ \
/* est obligatoire a cause du mode {VL_SHARE,VL_READ_ONLY} impose precedemment et ce afin */ \
/* de permettre le controle 'VL_SYNC'... */ \
Bblock \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("l'usage du chemin n'a pu etre modifie"); \
PRINT_ERREUR("le transfert demande ne pourra pas etre realise"); \
/* On notera au passage que l'ensemble du code qui suit pourrait etre place a l'interieur */ \
/* de la premiere alternative de ce 'Test(...)' mais que ce n'est pas fait car il faudrait */ \
/* alors le retabuler, or il y a des lignes tres longues... */ \
CAL1(Prer1(" identite du noeud emetteur = %d\n" \
,identite_du_noeud_emetteur \
) \
); \
CAL1(Prer1(" identite du noeud recepteur = %d\n" \
,identite_du_noeud_recepteur \
) \
); \
Eblock \
ETes \
Eblock \
/* Mise du chemin en mode {VL_LOCK,VL_LOCK}. */
# ifdef GESTION_DE_L_OPTION_GALILEO_VERSION_01
# define FORMAT_DE_PACKING_DES_POINTS_VIDEO \
VL_PACKING_RGB \
/* Format de definition des points en video. */
# Aifdef GESTION_DE_L_OPTION_GALILEO_VERSION_01
# Eifdef GESTION_DE_L_OPTION_GALILEO_VERSION_01
# ifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# define FORMAT_DE_PACKING_DES_POINTS_VIDEO \
VL_PACKING_RGB_8 \
/* Format de definition des points en video. ATTENTION, il semblerait que le format a */ \
/* utiliser soit : */ \
/* */ \
/* VL_PACKING_RGB_8_P */ \
/* */ \
/* qui correspondrait a : */ \
/* */ \
/* VL_PACKING_RGB */ \
/* */ \
/* des versions anterieures a la release 5.2. Malheureusement, si 'N' est le nombre de */ \
/* points de l'image, 'VL_PACKING_RGB_8_P' devrait donner par 'VLGETTRANSFERSIZE(...)' */ \
/* une taille d'image egale a '3xN', or elle donne '1xN'. On notera au passage que */ \
/* 'VL_PACKING_RGB_8' donne correctement (et par definition) la taille '4xN'. */ \
/* */ \
/* ATTENTION, l'ordre des composantes n'est pas le meme suivant le 'VL_PACKING_RGB_...' */ \
/* utilise : */ \
/* */ \
/* VL_PACKING_RGB_8 = {NOIR,B,V,R} */ \
/* */ \
/* VL_PACKING_RGB_8_P = {R,B,V} */ \
/* */ \
/* pourquoi ? D'autre part, les composantes des points sont intercalees les unes dans les */ \
/* autres (voir 'v $Dcourrier_in/940421140427'), ce dernier mode est donc pratiquement */ \
/* inutilisable... */
# Aifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# Eifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# define VL_PACKING_RGB_8 \
UNDEF
/* Afin de ne pas avoir d'erreur au niveau du pre-processeur, car en effet, le symbole */
/* 'VL_PACKING_RGB_8' n'est defini qu'en passe '$PASSE_5', alors que le test correspondant */
/* ci-apres est fait en '$PASSE_1', c'est-a-dire trop tot... */
# if ( ( (defined(BUG_SYSTEME_SGIND_VL_NOMBRE_DE_BUFFERS_PAR_IMAGE_EN_SORTIE_RVB)) \
&& (FORMAT_DE_PACKING_DES_POINTS_VIDEO == VL_PACKING_RGB_8) \
) \
)
# define NOMBRE_D_IMAGES_A_MANIPULER \
COND(IFEQ(nombre_d_images_a_manipuler,UN),DEUX,nombre_d_images_a_manipuler) \
/* Nombre d'images a communiquer a 'VLCREATEBUFFER(...)'. Ainsi, si un seul buffer doit */ \
/* etre cree, il convient en fait d'en declarer deux, afin d'eviter, lors de certains */ \
/* transferts de la memoire vers la sortie video, que le driver 'ev1' de la carte 'Galileo' */ \
/* attente un mauvais changement d'etat (ceci est le bug '#260256' corrige par le "patch" */ \
/* d'identite 'Patch_SG0000294'). */
# Aif ( ( (defined(BUG_SYSTEME_SGIND_VL_NOMBRE_DE_BUFFERS_PAR_IMAGE_EN_SORTIE_RVB)) \
&& (FORMAT_DE_PACKING_DES_POINTS_VIDEO == VL_PACKING_RGB_8) \
) \
)
# define NOMBRE_D_IMAGES_A_MANIPULER \
nombre_d_images_a_manipuler \
/* Nombre d'images a communiquer a 'VLCREATEBUFFER(...)'. */
# Eif ( ( (defined(BUG_SYSTEME_SGIND_VL_NOMBRE_DE_BUFFERS_PAR_IMAGE_EN_SORTIE_RVB)) \
&& (FORMAT_DE_PACKING_DES_POINTS_VIDEO == VL_PACKING_RGB_8) \
) \
)
# undef VL_PACKING_RGB_8 \
/* Afin de ne pas avoir d'erreur au niveau du pre-processeur, car en effet, le symbole */ \
/* 'VL_PACKING_RGB_8' n'est defini qu'en passe '$PASSE_5', alors que le test correspondant */ \
/* ci-dessus est fait en '$PASSE_1', c'est-a-dire trop tot... */
# define DECALAGE_DE_VL_EV1_DELAY_SYNC \
ZERO
DEFV(Common,DEFV(Int,SINT(SGI_____decalage_de_VL_EV1_DELAY_SYNC,DECALAGE_DE_VL_EV1_DELAY_SYNC)));
/* Definition du decalage des synchronisations de sortie par rapport a celles d'entree... */
DEFV(Common,DEFV(Int,SINT(SGI_____nombre_de_lignes_blankees,ZERO)));
/* Definition du nombre de lignes "blankees" en haut de l'image... */
# define DECALAGE_DE_VL_EV1_V_OFFSET \
ZERO
DEFV(Common,DEFV(Int,SINT(SGI_____decalage_de_VL_EV1_V_OFFSET,DECALAGE_DE_VL_EV1_V_OFFSET)));
/* Definition du decalage de l'offset vertical standard. La valeur par defaut ('ZERO') */
/* donne avec l'option 'SGI_____visualiser_le_contenu_de_l_ecran_de_la_station_de_travail' */
/* une bande blanche en haut de l'ecran... */
# if (nSYSTEM_RELEASE < 503000000)
# define DECALAGE_DE_VL_EV1_H_OFFSET \
NEGA(DIX)
# Aif (nSYSTEM_RELEASE < 503000000)
# Eif (nSYSTEM_RELEASE < 503000000)
# if (nSYSTEM_RELEASE >= 503000000)
# define DECALAGE_DE_VL_EV1_H_OFFSET \
NEGA(ADD2(CINQUANTE,HUIT))
# Aif (nSYSTEM_RELEASE >= 503000000)
# Eif (nSYSTEM_RELEASE >= 503000000)
DEFV(Common,DEFV(Int,SINT(SGI_____decalage_de_VL_EV1_H_OFFSET,DECALAGE_DE_VL_EV1_H_OFFSET)));
/* Definition du decalage de l'offset horizontal standard. ATTENTION, il y a eu pendant */
/* longtemps la valeur 'ONZE', mais alors les images etaient decadrees a gauche... */
/* */
/* ATTENTION, on notera qu'en fait deux valeurs sont utilisees : */
/* */
/* -42 : pour faire des enregistrements video sur le disque, */
/* -76 : pour faire des photographies d'ecran, */
/* */
/* cette derniere valeur est fixee dans la commande '$Fdivers', alors qu'avant le 1995031400 */
/* on trouvait ici : */
/* */
/* NEGA(ADD2(SOIXANTE_QUATRE,DOUZE)) */
/* */
/* mais il parait plus logique de mettre ici une valeur qui centre bien le signal. Cette */
/* valeur a ete obtenue experimentalement grace au programme 'v $xtc/SGI_G.530.71$c' en */
/* faisant varier ce parametre de part et d'autre de cette valeur et en essayant d'obtenir */
/* la disparition de liseres rouges qui apparaissent a gauche (<-42) ou a droite (>-42) */
/* des textes blancs inseres par le disque video alors qu'il est en 'Rec Standby'... */
/* */
/* Le 20010613151819, j'ai note (un peu tardivement...) que la valeur : */
/* */
/* -58 */
/* */
/* centrait beaucoup plus correctement les images pour les enregistrements video sur le */
/* disque, mais jusqu'a nouvel ordre, je conserve la valeur "-42" pour des raisons de */
/* compatibilite entre les sequences futures et les sequences deja enregistrees. Au passage, */
/* avec la valeur "-42" les images sont decalees vers la gauche. Malgre tout, il convient */
/* de noter que l'image enregistree n'est pas tronquee comme il est possible de le verifier */
/* sur un moniteur en mode "UnderScan" avec une image du type : */
/* */
/* xivPdf 12 1 */
/* r 003073_003584 */
/* */
/* qui possede un cadre "exterieur"... */
/* */
/* Le 20010626104408, je passe (enfin) de la valeur : */
/* */
/* NEGA(ADD2(QUARANTE,DEUX)) */
/* */
/* a la valeur : */
/* */
/* NEGA(ADD2(CINQUANTE,HUIT)) */
/* */
/* les essais ayant ete fait a l'aide de l'image 'v $xiirk/REFM.11' qui possede un cadre */
/* exterieur. */
# define DECALAGE_DE_VL_EV1_H_PHASE \
ZERO
DEFV(Common,DEFV(Int,SINT(SGI_____decalage_de_VL_EV1_H_PHASE,DECALAGE_DE_VL_EV1_H_PHASE)));
/* Definition du decalage de l'offset horizontal "fin" standard... */
# Aifdef __VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : VidAnal. */
# Eifdef __VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : VidAnal. */
# ifdef __VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS
# define SE_SYNCHRONISER_SUR_UNE_SOURCE_EXTERNE \
VRAI \
/* Indique s'il faut ('VRAI') ou pas ('FAUX') se synchroniser sur une source externe, par */ \
/* exemple pour des enregistrements disques... */
# Aifdef __VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS
# Eifdef __VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# define POSITIONNEMENT_DE_LA_FENETRE_COURANTE(dimens_x,x_bas_gauche,x_haut_droite,dimens_y,y_bas_gauche,y_haut_droite) \
Bblock \
INITIALISATION_POINT_2D(position_coin_bas_gauche,x_bas_gauche,y_bas_gauche); \
INITIALISATION_POINT_2D(position_coin_haut_droite,x_haut_droite,y_haut_droite); \
/* Memorisation des coordonnees des deux coins de reference opposes de la fenetre ouverte. */ \
\
CALS(prefsize(dimens_x,dimens_y)); \
/* Dimensionnement du plan de travail, */ \
\
CALS(prefposition(ASD1(position_coin_bas_gauche,x) \
,ASD1(position_coin_haut_droite,x) \
,ASD1(position_coin_bas_gauche,y) \
,ASD1(position_coin_haut_droite,y) \
) \
); \
/* Et positionnement de la fenetre... */ \
Eblock \
/* Positionnement et memorisation de celui-ci pour la fenetre courante... */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL /* Common,DEFV(Fonction,) : avec 'OpenGL'... */
DEFV(Common,DEFV(Logical,SINT(SGI_____editer_les_PRINT_ATTENTION_initiaux,FAUX)));
/* Faut-il editer les 'PRINT_ATTENTION(...)' initiaux de 'IXopen_pour_utiliser_OpenGL(...)'. */
/* */
/* ATTENTION : jusqu'au 20061120103540 'SGI_____editer_les_PRINT_ATTENTION_initiaux' */
/* s'appelait en fait 'editer_les_PRINT_ATTENTION_initiaux'. Or, il y a dans ce meme */
/* fichier 'v $xiidG/fonction.1$FON editer_les_PRINT_ATTENTION_initiaux' de nombreuses */
/* variables de type 'Argument' qui portent aussi ce nom. C'est aussi le cas de nombreuses */
/* variables dans '$xci' et dans 'v $xci/display.03$I editer_les_PRINT_ATTENTION_initiaux'. */
/* Cela semble etre une erreur qui a donc ete corrigee le 20061120103540 a l'occasion de */
/* grande operation d'unification des variables 'v $xau/LACT16.D1.modifier$sed'... */
DEFV(Local,DEFV(deltaI_2D,dimension_non_normalisee_de_la_fenetre));
DEFV(Local,DEFV(deltaF_2D,dimension_de_la_fenetre));
/* Dimensions de la fenetre non normalisee, puis normalisee. */
# define POSITIONNEMENT_DE_LA_FENETRE_COURANTE(dimens_x,x_bas_gauche,x_haut_droite,dimens_y,y_bas_gauche,y_haut_droite) \
Bblock \
INITIALISATION_POINT_2D(position_coin_bas_gauche,x_bas_gauche,y_bas_gauche); \
INITIALISATION_POINT_2D(position_coin_haut_droite,x_haut_droite,y_haut_droite); \
/* Memorisation des coordonnees des deux coins de reference opposes de la fenetre ouverte. */ \
\
INITIALISATION_ACCROISSEMENT_2D(dimension_non_normalisee_de_la_fenetre \
,dimens_x \
,dimens_y \
); \
INITIALISATION_ACCROISSEMENT_2D(dimension_de_la_fenetre \
,_____lNORMALISE_OX11(dimens_x) \
,_____lNORMALISE_OY11(dimens_y) \
); \
/* Et definition de la taille de la fenetre 'X-Window' necessaire. On notera l'utilisation */ \
/* de '_____lNORMALISE_OX11(...)' et de '_____lNORMALISE_OY11(...)' et non pas de */ \
/* '_____lNORMALISE_OXG(...)' et de '_____lNORMALISE_OYG(...)' afin de faire que la fenetre */ \
/* ouverte ait la meme dimension que cette de '__VERSION__UTILISER_LA_BIBLIOTHEQUE_GL'... */ \
Eblock \
/* Positionnement et memorisation de celui-ci pour la fenetre courante... */
# define GL_CURRENT_RASTER_DEBUT_VIEWPORT \
INDEX0
Denumer05(INIS(GL_CURRENT_RASTER_X_VIEWPORT,GL_CURRENT_RASTER_DEBUT_VIEWPORT)
,GL_CURRENT_RASTER_Y_VIEWPORT
,GL_CURRENT_RASTER_LARGEUR_VIEWPORT
,GL_CURRENT_RASTER_HAUTEUR_VIEWPORT
,GL_CURRENT_RASTER_FIN_VIEWPORT
,format_du_view_port_raster_courant
);
/* Format des informations renvoyees par 'glGetIntegerv(GL_VIEWPORT,...)'. */
# define X_VIEWPORT \
ITb1(viewport_raster_courant \
,INDX(GL_CURRENT_RASTER_X_VIEWPORT,GL_CURRENT_RASTER_DEBUT_VIEWPORT) \
)
# define Y_VIEWPORT \
ITb1(viewport_raster_courant \
,INDX(GL_CURRENT_RASTER_Y_VIEWPORT,GL_CURRENT_RASTER_DEBUT_VIEWPORT) \
)
# define LARGEUR_VIEWPORT \
ITb1(viewport_raster_courant \
,INDX(GL_CURRENT_RASTER_LARGEUR_VIEWPORT,GL_CURRENT_RASTER_DEBUT_VIEWPORT) \
)
# define HAUTEUR_VIEWPORT \
ITb1(viewport_raster_courant \
,INDX(GL_CURRENT_RASTER_HAUTEUR_VIEWPORT,GL_CURRENT_RASTER_DEBUT_VIEWPORT) \
)
/* Definition du "viewport"... */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL /* Common,DEFV(Fonction,) : avec 'OpenGL'... */
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL /* Common,DEFV(Fonction,) : avec 'OpenGL'... */
# ifdef __VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : VidAnal. */
# define XminPal_bandeau \
XminPal
# define XmaxPal_bandeau \
XmaxPal
# define dimXPal_bandeau \
dimXPal
# define YminPal_bandeau \
YminPal
# define YmaxPal_bandeau \
XYZmax(YminPal,DIVI(SV_PAL_YMAX,SGI_____facteur_de_reduction_verticale_d_une_fenetre_bandeau))
# define dimYPal_bandeau \
DIMENSION(YminPal_bandeau,YmaxPal_bandeau)
/* Definition d'une fenetre dite "bandeau" qui est en fait une bande ayant la largeur de */
/* de toute les fenetres 'Pal' mais etant tres plate, ce qui lui permet d'etre affichee */
/* tout en bas de l'ecran sans se superposer (ou tres peu) aux autres fenetres, et donc */
/* ainsi elle ne "volera" jamais (?) le "focus" d'une fenetre active, tout en permettant */
/* (grace a sa grande largeur) l'action de 'IGattente_de_l_evenement_ButtonPress(...)'. */
DEFV(Common,DEFV(Int,SINT(SGI_____facteur_de_reduction_verticale_d_une_fenetre_bandeau,SEIZE)));
/* Facteur de reduction permettant de passer d'une fenetre 'Pal' a une fenetre "bandeau"... */
/* */
/* On notera au passage que ce rapport a une valeur implicite liee au fait que : */
/* */
/* 6 2 */
/* SV_PAL_YMAX = 576 = 2 .3 */
/* */
/* qui est donc divisible exactement par 16. */
# Aifdef __VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : VidAnal. */
# Eifdef __VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : VidAnal. */
DEFV(Common,DEFV(FonctionI,IGopen(nom_de_la_fenetreA
,centrer_la_fenetre
,ARGUMENT_POINTERs(coin_bas_gauche)
,generer_de_la_video
,laisser_le_curseur_apparaitre_pendant_l_affichage
)
)
)
DEFV(Argument,DEFV(CHAR,DTb0(nom_de_la_fenetreA)));
/* Nom de la fenetre a ouvrir. */
DEFV(Argument,DEFV(Logical,centrer_la_fenetre));
/* Faut-il centrer la fenetre ('VRAI') ou bien donner explicitement la position de son coin */
/* "bas gauche" ('FAUX') ? */
DEFV(Argument,DEFV(pointF_2D,POINTERs(coin_bas_gauche)));
/* Abscisse du point de reference, */
DEFV(Argument,DEFV(Logical,generer_de_la_video));
/* Cet indicateur precise si l'on doit generer de la video 625 lignes ('VRAI'), ou */
/* bien des signaux "haute-definition" 1024 lignes ('FAUX'). Les modes suivants sont */
/* donc disponibles : */
/* */
/* FAUX : 1280x1024 60 Hz, */
/* */
/* VRAI : 768x576 50 Hz */
/* ('__VERSION__COMPILER_L_OPTION_GALILEO_DU_GRAPHIQUE_SILICON_GRAPHICS'), */
/* 780x575 50 Hz */
/* ('__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS'), */
/* */
DEFV(Argument,DEFV(Logical,laisser_le_curseur_apparaitre_pendant_l_affichage));
/* Indicateur precisant s'il faut laisser le curseur de l'ecran pendant que cette fenetre */
/* est ouverte ('VRAI') ou le supprimer ('FAUX'). */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/* ATTENTION : 'INIT_ERROR' est mis en tete des variables locales au cas ou des couples */
/* ('BDEFV','EDEFV') suivraient... */
DEFV(pointF_2D,veritable_coin_bas_gauche);
/* Abscisse du point de reference reellement utilise... */
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
DEFV(G_Screencoord,DTb1(viewport_raster_courant,NBRE(GL_CURRENT_RASTER_DEBUT_VIEWPORT,PRED(GL_CURRENT_RASTER_FIN_VIEWPORT))));
/* Informations renvoyees par 'glGetIntegerv(GL_VIEWPORT,...)'. */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# if ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
DEFV(G_VLDevList,liste_des_devices_disponibles);
/* Liste des "device"s disponibles sur le serveur video... */
DEFV(Int,INIT(numero_du_device_a_utiliser,DEMANDE_D_UN_DEVICE_INDIFFERENT));
/* Numero du "device" (indifferent...) a utiliser... */
DEFV(Int,INIT(nombre_de_chemins_a_etablir,UN));
/* Nombre de chemins a etablir (entre les "noeud"s emetteur et recepteur). */
DEFV(Int,INIT(taille_reelle_des_images_en_octets,UNDEF));
/* Taille reelle des images a manipuler... */
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# if ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
/*..............................................................................................................................*/
Test(IFEQ(identificateur_de_la_fenetre,FENETRE_PAS_OUVERTE_OU_PROBLEMES_A_L_OUVERTURE))
Bblock
TRANSFERT_POINT_2D(veritable_coin_bas_gauche,PINDIRECT(coin_bas_gauche));
/* A priori, c'est le 'coin_bas_gauche' qui sera utilise... */
Test(IL_FAUT(generer_de_la_video))
Bblock
# if ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
|| (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
EGAL(mode_de_fonctionnement,MODE_BASSE_DEFINITION_PAL);
/* Mise en place du mode de fonctionnement... */
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
|| (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
PRINT_ATTENTION("cette machine ne dispose pas d'option video ('Galileo' ou 'GenLock')");
EGAL(mode_de_fonctionnement,MODE_HAUTE_DEFINITION);
/* Le mode de fonctionnement est alors force... */
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
|| (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
Eblock
ATes
Bblock
EGAL(mode_de_fonctionnement,MODE_HAUTE_DEFINITION);
/* Mise en place du mode de fonctionnement... */
Eblock
ETes
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
Test(IFET(IFNE(mode_de_fonctionnement,MODE_BASSE_DEFINITION_PAL)
,IL_NE_FAUT_PAS(SGI_____appeler_les_fonctions_X_Window_pour_les_sorties_OpenGL)
)
)
Bblock
PRINT_ERREUR("lorsqu'il n'y a pas enregistrement video, l'appel de 'X-Window' par 'OpenGL' est imperatif");
EGAL(SGI_____appeler_les_fonctions_X_Window_pour_les_sorties_OpenGL,VRAI);
/* Et on force l'appel... */
Eblock
ATes
Bblock
Eblock
ETes
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
Choi(mode_de_fonctionnement)
Bblock
# if ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
|| (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
Ca1e(MODE_BASSE_DEFINITION_PAL)
Bblock
Test(IFOU(IL_FAUT(centrer_la_fenetre)
,IFOU(IZNE(_cDENORMALISE_OXG(ASD1(veritable_coin_bas_gauche,x)))
,IZNE(_cDENORMALISE_OYG(ASD1(veritable_coin_bas_gauche,y)))
)
)
)
Bblock
PRINT_ATTENTION("la fenetre va etre positionnee en bas a gauche pour le 'PAL'");
Eblock
ATes
Bblock
Eblock
ETes
# if ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
POSITIONNEMENT_DE_LA_FENETRE_COURANTE(dimXPal_bandeau
,XminPal_bandeau
,XmaxPal_bandeau
,dimYPal_bandeau
,YminPal_bandeau
,YmaxPal_bandeau
);
/* Definition d'une fenetre dite "bandeau" qui est en fait une bande ayant la largeur de */
/* de toute les fenetres 'Pal' mais etant tres plate, ce qui lui permet d'etre affichee */
/* tout en bas de l'ecran sans se superposer (ou tres peu) aux autres fenetres, et donc */
/* ainsi elle ne "volera" jamais (?) le "focus" d'une fenetre active, tout en permettant */
/* (grace a sa grande largeur) l'action de 'IGattente_de_l_evenement_ButtonPress(...)'. */
/* */
/* On notera au passage que le rapport 'FRA16(...)' est lie au fait que : */
/* */
/* 6 2 */
/* SV_PAL_YMAX = 576 = 2 .3 */
/* */
/* qui est donc divisible exactement par 16. */
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# if ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
POSITIONNEMENT_DE_LA_FENETRE_COURANTE(dimXPal
,XminPal
,XmaxPal
,dimYPal
,YminPal
,YmaxPal
);
/* Dimensionnement du plan de travail et positionnement en mode format 'PAL'... */
/* */
/* ATTENTION, il y a eu pendant longtemps : */
/* */
/* POSITIONNEMENT_DE_LA_FENETRE_COURANTE(dimXPal */
/* ,SGI_____XminG_d_une_fenetre_HAUTE_DEFINITION */
/* ,XMAXPAL */
/* ,dimYPal */
/* ,SGI_____YminG_d_une_fenetre_HAUTE_DEFINITION */
/* ,YMAXPAL */
/* ); */
/* */
/* ce qui donnait des images mal centrees a l'interieur... */
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
Eblock
ECa1
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
|| (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
|| (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
Ca1e(MODE_HAUTE_DEFINITION)
Bblock
Test(IL_FAUT(centrer_la_fenetre))
Bblock
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
INITIALISATION_POINT_2D(veritable_coin_bas_gauche
,_____cNORMALISE_OXG(ADD2(XminG
,SOUS(MOIT(getgdesc(GD_XPMAX))
,MOIT(dimXG_d_une_fenetre_HAUTE_DEFINITION)
)
)
)
,_____cNORMALISE_OYG(ADD2(YminG
,SOUS(MOIT(getgdesc(GD_YPMAX))
,MOIT(dimYG_d_une_fenetre_HAUTE_DEFINITION)
)
)
)
);
/* Cas ou le centrage est demande : l'argument 'coin_bas_gauche' est ignore... */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
INITIALISATION_POINT_2D(veritable_coin_bas_gauche
,_____cNORMALISE_OXG(ADD2(XminG
,SOUS(MOIT(getgdesc(GD_XPMAX))
,MOIT(dimXG_d_une_fenetre_HAUTE_DEFINITION)
)
)
)
,_____cNORMALISE_OYG(ADD2(YminG
,SOUS(MOIT(getgdesc(GD_YPMAX))
,MOIT(dimYG_d_une_fenetre_HAUTE_DEFINITION)
)
)
)
);
/* Cas ou le centrage est demande : l'argument 'coin_bas_gauche' est ignore... */
/* */
/* ATTENTION, on notera qu'il n'y a aucune difference entre 'GL' et 'OpenGL' car, en effet, */
/* etant donne que la fenetre 'X-Window' n'est pas encore ouverte, je ne sais pas comment */
/* recuperer simplement la taille de l'ecran (d'ou l'utilisation de 'getgdesc(...)' qui */
/* est malheureusement une fonction 'GL'...). */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
Eblock
ATes
Bblock
/* Cas ou le centrage n'est pas demande : c'est l'argument 'coin_bas_gauche' qui donne la */
/* position de la fenetre... */
Eblock
ETes
POSITIONNEMENT_DE_LA_FENETRE_COURANTE(dimXG_d_une_fenetre_HAUTE_DEFINITION
,ADD2(SGI_____XminG_d_une_fenetre_HAUTE_DEFINITION
,CGXR(_cDENORMALISE_OXG(ASD1(veritable_coin_bas_gauche,x)))
)
,ADD2(SGI_____XmaxG_d_une_fenetre_HAUTE_DEFINITION
,CGXR(_cDENORMALISE_OXG(ASD1(veritable_coin_bas_gauche,x)))
)
,dimYG_d_une_fenetre_HAUTE_DEFINITION
,ADD2(SGI_____YminG_d_une_fenetre_HAUTE_DEFINITION
,CGYR(_cDENORMALISE_OYG(ASD1(veritable_coin_bas_gauche,y)))
)
,ADD2(SGI_____YmaxG_d_une_fenetre_HAUTE_DEFINITION
,CGYR(_cDENORMALISE_OYG(ASD1(veritable_coin_bas_gauche,y)))
)
);
/* Dimensionnement du plan de travail et positionnement en mode haute-definition... */
Eblock
ECa1
Defo
Bblock
PRINT_ERREUR("un mode de fonctionnement n'est pas reconnu");
Eblock
EDef
Eblock
ECho
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
EGAL(identificateur_de_la_fenetre
,winopen(Cara(nom_de_la_fenetreA))
);
/* Ouverture du plan de travail. ATTENTION : il est tres important de ne pas mettre juste */
/* avant le 'winopen(Cara(nom_de_la_fenetreA))' la sequence suivante (qui placerait en */
/* background les activites graphiques) : */
/* */
/* CALS(foreground()); */
/* */
/* En effet, il est important que les operations qui suivent l'ouverture d'une fenetre */
/* et l'affichage d'une image (par exemple l'enregistrement video...) puissent prendre la */
/* main immediatement et faire ce qu'elles ont a faire (pendant que l'image est affichee */
/* s'il s'agit de l'enregistrer...). Dans le cas contraire, la fermeture de la fenetre */
/* aurait lieu avant qu'elles fussent lancees (voir par exemple la programmation de la */
/* commande d'affichage 'v $xci/display_RVB$K')... */
/* */
/* ATTENTION, l'appel a la fonction 'winopen(...)' est fait dans tous les cas, et en */
/* particulier meme pour le mode 'MODE_BASSE_DEFINITION_PAL' alors qu'on est en presence */
/* de l'option '__VERSION__COMPILER_L_OPTION_GALILEO_DU_GRAPHIQUE_SILICON_GRAPHICS'. En */
/* effet, cela permet d'arreter interactivement la visualisation en video en utilisant la */
/* fonction 'IGattente_de_l_evenement_ButtonPress(...)' (voir les durees "nulles" de la */
/* commande 'v $xci/display_RVB$K'). On notera que j'ai cherche comment faire que la fenetre */
/* courante que l'on ouvre ne soit pas au sommet de la pile des fenetres, d'une part afin */
/* qu'elle ne gene pas visuellement, et que d'autre part, elle ne "vole" pas le "focus" de */
/* la fenetre interactive active. Je n'ai malheureusement pas trouve de solutions generales */
/* (dans 'glresources' en particulier) ; c'est pourquoi, j'ai introduit la notion de */
/* "bandeau" (voir l'appel a 'POSITIONNEMENT_DE_LA_FENETRE_COURANTE(...)'). */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
BACKGROUND;
/* La mise en "background" n'est plus assuree automatiquement par 'OpenGL' comme elle */
/* l'etait par 'GL' ; il faut donc le faire explicitement. Il parait plus sage de faire */
/* cette mise en 'BACKGROUND' avant d'ouvrir la fenetre qu'apres car sinon, lors de */
/* de l'execution de la fonction 'Exit(OK)' pour le "pere", il semblerait qu'il se passe */
/* des choses anormales sur '$LACT12' (et non pas sur '$LACT27'...) ; en effet, sur */
/* '$LACT12', la fenetre s'ouvre, puis se referme immediatement, alors que sur '$LACT27' */
/* la fenetre s'ouvre, l'image apparait et reste a l'ecran le temps qu'il faut... */
APPEL_D_UNE_FONCTION_X_WINDOW_POUR_OpenGL(BLOC(EGAL(identificateur_de_la_fenetre
,IXopen_pour_utiliser_OpenGL(DEFINITION_DU_SERVEUR_X_WINDOW
,nom_de_la_fenetreA
,ADRESSE(dimension_de_la_fenetre)
,centrer_la_fenetre
,ADRESSE(veritable_coin_bas_gauche)
,SGI_____editer_les_PRINT_ATTENTION_initiaux
)
);
)
,BLOC(EGAL(identificateur_de_la_fenetre
,NOTL(FENETRE_PAS_OUVERTE_OU_PROBLEMES_A_L_OUVERTURE)
);
)
);
/* Ouverture du plan de travail. */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
Test(IFNE(identificateur_de_la_fenetre,FENETRE_PAS_OUVERTE_OU_PROBLEMES_A_L_OUVERTURE))
Bblock
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
CALS(RGBmode());
CALS(gconfig());
/* Et configuration en mode {R,V,B} ; on notera que l'appel 'gconfig()' est obligatoire, */
/* car sinon, 'RGBmode()' est ineffectif... */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
APPEL_D_UNE_FONCTION_X_WINDOW_POUR_OpenGL(BLOC(CALS(IXconnexion_avec_OpenGL());)
,BLOC(VIDE;)
);
/* Etablissement de la connexion entre 'X-Window' et 'OpenGL'... */
CALS(IGclear());
/* Nettoyage de la fenetre... */
CALS(glFlush());
/* Cette operation semble essentielle. En effet, en son absence, s'il s'ecoule un certain */
/* temps entre le 'IGopen(...)' et le 'IGdisplay(...)' (par exemple lors de la visualisation */
/* d'une sequence d'images par 'v $xci/sequence_RVB$K', la premiere image n'existant pas */
/* encore) l'effacement ne se fait reellement que lors du passage dans 'IGdisplay(...)'. On */
/* peut donc avoir, pendant une duree indeterminee, une fenetre "sale", c'est-a-dire ou */
/* seule la composante '$ROUGE' a ete effacee, alors que les composantes '$VERTE' et */
/* '$BLEUE' sont toujours la (ce sont en fait des vestiges anterieurs...). */
CALS(glGetIntegerv(GL_VIEWPORT,viewport_raster_courant));
/* Regardons le "viewport" courant... */
CALS(glViewport(X_VIEWPORT
,Y_VIEWPORT
,LARGEUR_VIEWPORT
,HAUTEUR_VIEWPORT
)
);
/* ATTENTION, ecrire : */
/* */
/* CALS(glViewport(SGI_____XminG_d_une_fenetre_HAUTE_DEFINITION */
/* ,SGI_____YminG_d_une_fenetre_HAUTE_DEFINITION */
/* ,SGI_____XmaxG_d_une_fenetre_HAUTE_DEFINITION */
/* ,SGI_____YmaxG_d_une_fenetre_HAUTE_DEFINITION */
/* ) */
/* ); */
/* */
/* provoque un phenomene bizarre lorsque, par exemple, depuis '$LACT27' on ouvre une */
/* fenetre 'OpenGl' sur '$LACT12' ; alors l'exterieur de l'image affichee, qui devrait */
/* etre parfaitement NOIR contient un "fantome" des fenetres situees en dessous, le */
/* phenomene ne se voyant qu'avec un "gamma" eleve (superieur a 4...). */
/* */
/* Puis, j'ai essaye : */
/* */
/* CALS(glViewport(Xmin,Ymin */
/* ,Xmax,Ymax */
/* ) */
/* ); */
/* */
/* mais cela provoquait le defaut evoque dans 'v $xtc/OpenGL.16$c'... */
CALS(glMatrixMode(GL_PROJECTION));
CALS(glLoadIdentity());
CALS(glOrtho(FLOT(X_VIEWPORT)
,FLOT(XYZmax(X_VIEWPORT,LARGEUR_VIEWPORT))
,FLOT(Y_VIEWPORT)
,FLOT(XYZmax(Y_VIEWPORT,HAUTEUR_VIEWPORT))
,FLOT(Zmin)
,FLOT(Zmax)
)
);
/* Definition de la projection utilisee (et oui c'est obligatoire, meme lorsque l'on est */
/* en bidimensionnel, ce qui est le cas ici...). */
/* */
/* ATTENTION, ecrire : */
/* */
/* CALS(glOrtho(FLOT(SGI_____XminG_d_une_fenetre_HAUTE_DEFINITION) */
/* ,FLOT(SGI_____XmaxG_d_une_fenetre_HAUTE_DEFINITION) */
/* ,FLOT(SGI_____YminG_d_une_fenetre_HAUTE_DEFINITION) */
/* ,FLOT(SGI_____YmaxG_d_une_fenetre_HAUTE_DEFINITION) */
/* ,FLOT(SGI_____ZminG_d_une_fenetre_HAUTE_DEFINITION) */
/* ,FLOT(SGI_____ZmaxG_d_une_fenetre_HAUTE_DEFINITION) */
/* ) */
/* ); */
/* */
/* provoque un phenomene bizarre lorsque, par exemple, depuis '$LACT27' on ouvre une */
/* fenetre 'OpenGl' sur '$LACT12' ; alors l'exterieur de l'image affichee, qui devrait */
/* etre parfaitement NOIR contient un "fantome" des fenetres situees en dessous, le */
/* phenomene ne se voyant qu'avec un "gamma" eleve (superieur a 4...). */
/* */
/* Puis, j'ai essaye : */
/* */
/* CALS(glOrtho(FLOT(Xmin),FLOT(Xmax) */
/* ,FLOT(Ymin),FLOT(Ymax) */
/* ,FLOT(Zmin),FLOT(Zmax) */
/* ) */
/* ); */
/* */
/* mais cela provoquait le defaut evoque dans 'v $xtc/OpenGL.16$c'... */
CALS(glMatrixMode(GL_MODELVIEW));
CALS(glLoadIdentity());
/* Definition du modele de visualisation... */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
Test(IL_NE_FAUT_PAS(laisser_le_curseur_apparaitre_pendant_l_affichage))
Bblock
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# if ( (defined(BUG_SYSTEME_SG_GL_CURSOR_GLOBAL)) \
)
CALS(cursoff());
/* Pour eviter de voir un vilain curseur dans l'image, on inhibe le curseur. Mais */
/* ATTENTION, sur la Personal IRIS, un bug fait que le curseur se trouve inhibe dans toutes */
/* les autres fenetres mais c'est tellement plus sur... D'autre part, la commande 'gamma' */
/* fait un 'curson()', donc il convient d'etre prudent si celle-ci est emise alors qu'une */
/* fenetre est ouverte... */
# Aif ( (defined(BUG_SYSTEME_SG_GL_CURSOR_GLOBAL)) \
)
CALS(cursoff());
/* Pour eviter de voir un vilain curseur dans l'image, on inhibe le curseur. Mais */
/* ATTENTION, sur la Personal IRIS, un bug fait que le curseur se trouve inhibe dans toutes */
/* les autres fenetres... D'autre part, la commande 'gamma' fait un 'curson()', donc il */
/* convient d'etre prudent si celle-ci est emise alors qu'une fenetre est ouverte... Enfin, */
/* on notera que 'CALS(cursoff())' est en fait execute qu'il y ait le bug ou pas sur les */
/* systemes 'SYSTEME_SG4D..._IRIX'. */
# Eif ( (defined(BUG_SYSTEME_SG_GL_CURSOR_GLOBAL)) \
)
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
Eblock
ATes
Bblock
Eblock
ETes
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
CALS(IGclear());
/* Nettoyage de la fenetre... */
CALS(pixmode(PM_SIZE,MUL2(size_Positive,NBITOC)));
/* Definition du nombre de bits par pixels. */
CALS(pixmode(PM_STRIDE,dimX));
/* Definition de la longueur des lignes de l'image a visualiser (exprimee en nombres de */
/* pixels). */
CALS(pixmode(PM_OFFSET,ZERO));
/* Definition du nombre de bits a ignorer dans le premier mot de chaque ligne. */
CALS(pixmode(PM_SHIFT,ZERO));
/* Definition d'un decalage eventuel des pixels (sous leur forme {R,V,B}. */
CALS(pixmode(PM_TTOB,FALSE));
/* Demande de remplissage des images de bas en haut ("top-to-bottom" est "FALSE")... */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
Choi(mode_de_fonctionnement)
Bblock
# if ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
Ca1e(MODE_BASSE_DEFINITION_PAL)
Bblock
DEFV(Logical,INIT(essayer_d_etablir_la_connexion,VRAI));
/* A priori, il va falloir essayer d'etablir la connexion... */
DEFV(Int,INIT(nombre_de_tentatives_d_etablissement_de_connexion,NOMBRE_DE_TENTATIVES_DE_CONNEXION_VIDEO));
/* Mais on ne pourra pas essayer une infinite de fois... */
/* ATTENTION, il y a eu ici pendant un temps : */
/* */
/* CALS(winpush()); */
/* */
/* pour mettre la fenetre 'GL' en arriere-plan. Malheureusement, faire ceci avant la */
/* sequence suivante de connexion video a pour consequence (mysterieuse...) de faire que */
/* le contenu de cette fenetre 'GL' est vide, sauf en ce qui concerne la partie qui n'est */
/* pas cachee par les autre fenetres. C'est pourquoi, cet appel a ete deplace apres la */
/* sequence de connexion video... */
EGAL(la_connexion_video_pour_une_image_a_pu_etre_etablie,FAUX);
/* A priori, la connexion video demandee ne va pas etre etablie... */
Tant(IFET(IL_FAUT(essayer_d_etablir_la_connexion)
,IZGT(nombre_de_tentatives_d_etablissement_de_connexion)
)
)
Bblock
Test(IFEQ(nombre_de_tentatives_d_etablissement_de_connexion,NOMBRE_DE_TENTATIVES_DE_CONNEXION_VIDEO))
/* Cas de la premiere tentative : il n'y a rien a faire... */
Bblock
Eblock
ATes
/* Cas des tentatives ulterieures : il faut annuler certaines des initialisations realisees */
/* a la tentative precedente... */
Bblock
CALS(VLDESTROYPATH(identite_du_serveur_video
,chemin_emetteur_recepteur
)
);
/* Destruction du chemin entre l'emetteur et le recepteur... */
Test(PAS_D_ERREUR(VLCLOSEVIDEO(identite_du_serveur_video)))
/* Enfin, fermeture de la connexion video... */
Bblock
Eblock
ATes
Bblock
PRINT_ERREUR("la fermeture de la connexion video est impossible (1)");
Eblock
ETes
Eblock
ETes
DECR(nombre_de_tentatives_d_etablissement_de_connexion,I);
/* Et une tentative de moins... */
EGAL(identite_du_serveur_video,VLOPENVIDEO(NOM_DU_SERVEUR_VIDEO_DE_L_OPTION_GALILEO));
/* Tentative d'ouverture de la connexion video. */
Test(IFNE(identite_du_serveur_video,POINTEUR_SUR_UN_OBJET_GALILEO_INEXISTANT))
Bblock
REINITIALISATION_DE_LA_CARTE_GALILEO(identite_du_serveur_video);
/* Reinitialisation de la carte (voir 'REINITIALISATION_DE_LA_CARTE_GALILEO(...)' et ses */
/* commentaires...). */
Test(IZGE(VLGETDEVICELIST(identite_du_serveur_video,ADRESSE(liste_des_devices_disponibles))))
Bblock
Test(IFOU(IFEQ(numero_du_device_a_utiliser,DEMANDE_D_UN_DEVICE_INDIFFERENT)
,IFET(IFNE(numero_du_device_a_utiliser,DEMANDE_D_UN_DEVICE_INDIFFERENT)
,IFLT(numero_du_device_a_utiliser
,INTE(ASD1(liste_des_devices_disponibles,numDevices))
)
)
)
)
Bblock
EGAL(identite_du_noeud_emetteur
,VLGETNODE(identite_du_serveur_video,VL_SRC,VL_MEM,VL_ANY)
);
/* Definition du noeud emetteur (c'est-a-dire la "memoire"). */
EGAL(identite_du_noeud_device
,VLGETNODE(identite_du_serveur_video,VL_DEVICE,VL_DOIT_ETRE_NUL,VL_DOIT_ETRE_NUL)
);
/* Definition du noeud "device"... */
EGAL(identite_du_noeud_recepteur
,VLGETNODE(identite_du_serveur_video,VL_DRN,VL_VIDEO,VL_ANY)
);
/* Definition du noeud recepteur (c'est-a-dire la "video"). */
Test(IL_FAUT(SGI_____visualiser_le_contenu_de_l_ecran_de_la_station_de_travail))
Bblock
EGAL(identite_du_noeud_mixage
,VLGETNODE(identite_du_serveur_video,VL_INTERNAL,VL_BLENDER,VL_ANY)
);
/* Definition du noeud de "mixage". */
EGAL(identite_du_noeud_station
,VLGETNODE(identite_du_serveur_video,VL_SRC,VL_SCREEN,VL_ANY)
);
/* Definition du noeud emetteur definissant le contenu de l'ecran de la station de travail. */
Eblock
ATes
Bblock
Eblock
ETes
EGAL(chemin_emetteur_recepteur
,VLCREATEPATH(identite_du_serveur_video
,COND(IFEQ(numero_du_device_a_utiliser,DEMANDE_D_UN_DEVICE_INDIFFERENT)
,VL_ANY
,numero_du_device_a_utiliser
)
,identite_du_noeud_emetteur
,identite_du_noeud_recepteur
)
);
/* Etablissement d'un chemin entre les "noeud"s emetteur et recepteur... */
Test(PAS_D_ERRORS(chemin_emetteur_recepteur))
Bblock
CALS(VLADDNODE(identite_du_serveur_video
,chemin_emetteur_recepteur
,identite_du_noeud_emetteur
)
);
CALS(VLADDNODE(identite_du_serveur_video
,chemin_emetteur_recepteur
,identite_du_noeud_device
)
);
CALS(VLADDNODE(identite_du_serveur_video
,chemin_emetteur_recepteur
,identite_du_noeud_recepteur
)
);
/* Operations dont je ne comprends pas bien l'utilite... */
Test(IL_FAUT(SGI_____visualiser_le_contenu_de_l_ecran_de_la_station_de_travail))
Bblock
CALS(VLADDNODE(identite_du_serveur_video
,chemin_emetteur_recepteur
,identite_du_noeud_mixage
)
);
CALS(VLADDNODE(identite_du_serveur_video
,chemin_emetteur_recepteur
,identite_du_noeud_station
)
);
/* Operations dont je ne comprends pas bien l'utilite... */
Eblock
ATes
Bblock
Eblock
ETes
EGAL(numero_du_device_a_utiliser
,VLGETDEVICE(identite_du_serveur_video
,chemin_emetteur_recepteur
)
);
/* Recuperation du "device" reellement utilise (lorsque 'DEMANDE_D_UN_DEVICE_INDIFFERENT' */
/* n'est pas utilise...), */
EGAL(nom_du_device_reellement_utilise
,ASD1(ITb1(ASD1(liste_des_devices_disponibles,devices)
,numero_du_device_a_utiliser
)
,name
)
);
/* Et de son nom au cas ou... */
Test(IFNE_chaine(nom_du_device_reellement_utilise,NOM_DU_DEVICE_ATTENDU))
Bblock
PRINT_ERREUR("le nom du 'device' utilise n'est pas celui qui etait attendu");
PRINT_ERREUR("on l'utilise malgre tout");
CAL1(Prer1(" 'device' attendu = %s\n",NOM_DU_DEVICE_ATTENDU));
CAL1(Prer1(" 'device' utilise = %s\n",nom_du_device_reellement_utilise));
Eblock
ATes
Bblock
Eblock
ETes
Test(PAS_D_ERREUR(VLSETUPPATHS(identite_du_serveur_video
,Cast_G_VLPathList(ADRESSE(chemin_emetteur_recepteur))
,nombre_de_chemins_a_etablir
,VL_SHARE
,VL_READ_ONLY
)
)
)
/* Preparation du hardware pour permettre l'usage des controles et des flots d'informations. */
/* */
/* ATTENTION, on notera les deux valeurs tres particulieres suivantes : */
/* */
/* VL_SHARE : destinee a pouvoir refaire un peu plus loin un autre 'VLSETUPPATHS(...)' */
/* sans avoir le desagreable message suivant : */
/* */
/* VL connection to :0.0 broken (explicit kill or server shutdown). */
/* */
/* et : */
/* */
/* VL_READ_ONLY : qui permet (enfin...) d'utiliser le controle 'VL_SYNC' (ci-dessous) */
/* sans avoir le desagreable message suivant : */
/* */
/* Bad access to the library */
/* */
/* tout cela m'ayant fait perdre pas mal de temps... */
Bblock
DEFV(Logical,INIT(une_erreur_forcant_l_iteration_a_ete_rencontree
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
)
);
/* ATTENTION, cette definition n'est la que pour permettre une compilation correcte des */
/* procedures 'PARAMETRAGE_NOEUD_?(...)', mais ne sert a rien d'autre... */
CALS(VLSELECTEVENTS(identite_du_serveur_video
,chemin_emetteur_recepteur
,LISTE_DES_EVENEMENTS_A_DETECTER
)
);
/* Selection des evenements a detecter... */
PARAMETRAGE_NOEUD_1(identite_du_noeud_device
,intVal
,VL_TIMING_625_SQ_PIX
,VL_TIMING
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
/* Parametrage des frequences. ATENTION, la demande que le signal de synchronisation ne */
/* soit pas porte par le vert par le controle 'VL_EV1_YG_SYNC' ne peut avoir lieu qu'apres */
/* le controle 'VL_FORMAT_RGB' ; ici, il serait ineffectif... */
# ifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
CHOIX_DE_LA_SOURCE_DE_SYNCHRONISATION_EXTERNE;
/* Choix et validation de la source de synchronisation externe... */
# Aifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# Eifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
PARAMETRAGE_NOEUD_1(identite_du_noeud_device
,intVal
,COND(IL_FAUT(SE_SYNCHRONISER_SUR_UNE_SOURCE_EXTERNE)
,VL_SYNC_GENLOCK
,VL_SYNC_INTERNAL
)
,VL_SYNC
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
/* Parametrage du type de synchronisation et de la source "genlock" utilisee. On notera */
/* l'utilisation de 'identite_du_noeud_device' (et non pas de 'identite_du_noeud_recepteur') */
/* pour les controles 'VL_SYNC' et 'VL_SYNC_SOURCE'... */
/* */
/* ATTENTION, lorsque l'on est en 'VL_SYNC_GENLOCK' la sortie 'Pal' ("composite") de la */
/* carte 'Galileo' ne fonctionne pas correctement ; en particulier on perd la couleur... */
MISE_DU_CHEMIN_EN_MODE_LOCK_LOCK;
/* Preparation du hardware pour permettre l'usage des controles et des flots d'informations. */
/* L'usage ici choisit est le mode exclusif ('VL_LOCK'). On notera que 'VLSETUPPATHS(...)' */
/* est obligatoire a cause du mode {VL_SHARE,VL_READ_ONLY} impose precedemment et ce afin */
/* de permettre le controle 'VL_SYNC'... */
/* */
/* On notera au passage que l'ensemble du code qui suit devrait etre place a l'interieur */
/* de la premiere alternative du 'Test(...)' de 'MISE_DU_CHEMIN_EN_MODE_LOCK_LOCK'. Mais */
/* cela n'est pas fait car il faudrait alors le retabuler, or il y a des lignes tres */
/* longues... */
Test(IL_FAUT(SGI_____visualiser_le_contenu_de_l_ecran_de_la_station_de_travail))
Bblock
PARAMETRAGE_NOEUD_1(identite_du_noeud_mixage
,intVal
,identite_du_noeud_emetteur
,VL_BLEND_A
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
PARAMETRAGE_NOEUD_1(identite_du_noeud_mixage
,intVal
,VL_BLDFCN_ZERO
,VL_BLEND_A_FCN
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
PARAMETRAGE_NOEUD_1(identite_du_noeud_mixage
,intVal
,identite_du_noeud_station
,VL_BLEND_B
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
PARAMETRAGE_NOEUD_1(identite_du_noeud_mixage
,intVal
,VL_BLDFCN_ONE
,VL_BLEND_B_FCN
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
/* Programmation du "mixage" telle que seul apparaisse le contenu de l'ecran de la station */
/* de travail. On notera que permuter l'identite des noeuds 'identite_du_noeud_emetteur' et */
/* 'identite_du_noeud_station' revient a ne faire apparaitre que l'image raster ; malgre */
/* tout cette solution n'est pas utilisee pour faire cela, car c'est en effet un peu lourd. */
/* */
/* Rappelons ici quelques definitions : */
/* */
/* 'A' : designe le "Foreground", */
/* 'B' : designe le "Background", */
/* */
/* soit : */
/* */
/* ----------------------------- */
/* | | */
/* | Background (B) | */
/* | | */
/* | | */
/* | | */
/* |------------------- | */
/* | | | */
/* | | | */
/* | Foreground (A) | | */
/* | | | */
/* | | | */
/* | | | */
/* ----------------------------- */
/* */
/* Dans le cas qui nous interesse ici (visualiser l'ecran de la station de travail), on */
/* choisit : */
/* */
/* B = l'ecran de la station de travail, */
/* A = l'image "raster". */
/* */
/* et donc on choisit de ne visualiser que le "Background" (grace aux 'VL_BLEND_?_FCN'). */
PARAMETRAGE_NOEUD_1(identite_du_noeud_mixage
,intVal
,VL_EV1_KEYERMODE_LUMA
,VL_EV1_KEYER_MODE
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
PARAMETRAGE_NOEUD_1(identite_du_noeud_mixage
,intVal
,NIVR(NOIR)
,VL_EV1_KEYER_FG_OPACITY
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
/* Je crois qu'il y a une certaine redondance entre la valeur de 'VL_EV1_KEYER_FG_OPACITY' */
/* (c'est-a-dire 'NOIR') et les valeurs attribuees a 'VL_BLEND_?_FCN'. Mais dans la mesure */
/* ou il y a de temps en temps des points parasites qui apparaissent a l'exterieur des */
/* images "raster", toutes les precautions doivent etre prises... */
/* */
/* On notera de plus que j'ai essaye d'utiliser le mode 'VL_EV1_KEYERMODE_NONE', mais il */
/* n'est apparemment pas disponible... */
PARAMETRAGE_NOEUD_2(identite_du_noeud_station
,fractVal
,numerator
,UN
,denominator
,DEUX
,VL_ZOOM
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
/* Programmation d'un zoom de rapport 1/2 permettant de faire apparaitre l'integralite de */
/* l'ecran de la station de travail (ou presque ?) sur la sortie video... */
Eblock
ATes
Bblock
Eblock
ETes
PARAMETRAGE_NOEUD_1(VL_ANY
,intVal
,VL_FORMAT_RGB
,VL_FORMAT
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
/* Parametrage du format des images (debut). */
PARAMETRAGE_NOEUD_1(identite_du_noeud_recepteur
,boolVal
,FALSE
,VL_EV1_YG_SYNC
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
/* Parametrage des signaux en demandant avec le controle 'VL_EV1_YG_SYNC' que le */
/* signal de synchronisation ne soit pas porte par le vert ('FALSE'). En effet, dans le */
/* cas contraire, lorsque le disque video est en sonde (entre la carte 'Galileo' et le */
/* moniteur 'Pal', lors du prepararif d'un enregistrement), la charge du signal vert */
/* n'est pas bonne (en fait, il parait ne pas etre charge...). */
/* */
/* ATTENTION, il est imperatif que le controle 'VL_EV1_YG_SYNC' suive lui-meme le controle */
/* 'VL_FORMAT_RGB', car sinon, il est ineffectif... */
CALS(VLGETCONTROL(identite_du_serveur_video
,chemin_emetteur_recepteur
,identite_du_noeud_recepteur
,VL_EV1_DELAY_SYNC
,ADRESSE(parametres_courants)
)
);
PARAMETRAGE_NOEUD_2(identite_du_noeud_recepteur
,fractVal
,numerator
,ADD2(ASD2(parametres_courants,fractVal,numerator)
,SGI_____decalage_de_VL_EV1_DELAY_SYNC
)
,denominator
,ASD2(parametres_courants,fractVal,denominator)
,VL_EV1_DELAY_SYNC
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
/* Programmation du retard entre les entrees et les sorties, qui est appele suivant les */
/* documents : */
/* */
/* Fine H offset */
/* ev1.Analog-Video-Output.delaysync */
/* */
PARAMETRAGE_NOEUD_1(identite_du_noeud_recepteur
,intVal
,SGI_____nombre_de_lignes_blankees
,VL_EV1_BLANK_LINE
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
/* Parametrage du nombre de ligne "blankee" en haut de l'image. On notera que mettre le */
/* controle 'VL_EV1_BLANK_LINE' avant le controle 'VL_EV1_DELAY_SYNC' donne le message */
/* d'erreur suivant : */
/* */
/* VL: Bad value passed as parameter */
/* */
/* tout en etant correctement pris en compte ! */
CALS(VLGETCONTROL(identite_du_serveur_video
,chemin_emetteur_recepteur
,identite_du_noeud_recepteur
,VL_EV1_V_OFFSET
,ADRESSE(parametres_courants)
)
);
PARAMETRAGE_NOEUD_2(identite_du_noeud_recepteur
,fractVal
,numerator
,ADD2(ASD2(parametres_courants,fractVal,numerator)
,SGI_____decalage_de_VL_EV1_V_OFFSET
)
,denominator
,ASD2(parametres_courants,fractVal,denominator)
,VL_EV1_V_OFFSET
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
CALS(VLGETCONTROL(identite_du_serveur_video
,chemin_emetteur_recepteur
,identite_du_noeud_recepteur
,VL_EV1_H_OFFSET
,ADRESSE(parametres_courants)
)
);
PARAMETRAGE_NOEUD_2(identite_du_noeud_recepteur
,fractVal
,numerator
,ADD2(ASD2(parametres_courants,fractVal,numerator)
,SGI_____decalage_de_VL_EV1_H_OFFSET
)
,denominator
,ASD2(parametres_courants,fractVal,denominator)
,VL_EV1_H_OFFSET
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
/* Programmation de l'offset video vertical et horizontal. */
/* */
/* On notera que le changement de cadrage de l'image par rapport aux synchronisations */
/* "ligne" et "trame" n'est visible qu'a condition d'observer les images "out" : */
/* */
/* -soit sur la sortie composite 'Pal' (auquel cas, il faut etre en synchronisation */
/* "internal", car sinon, la "chroma" est perdue ; voir a ce propos l'alias 'bgenlock' */
/* defini dans 'v $Fdivers'), */
/* -soit sur la sortie 'RVB' associee non pas a la synchronisation "out" sortant de */
/* la carte 'Galileo', mais a la synchronisation "genlock"... */
/* */
CALS(VLGETCONTROL(identite_du_serveur_video
,chemin_emetteur_recepteur
,identite_du_noeud_recepteur
,VL_EV1_H_PHASE
,ADRESSE(parametres_courants)
)
);
PARAMETRAGE_NOEUD_2(identite_du_noeud_recepteur
,fractVal
,numerator
,ADD2(ASD2(parametres_courants,fractVal,numerator)
,SGI_____decalage_de_VL_EV1_H_PHASE
)
,denominator
,ASD2(parametres_courants,fractVal,denominator)
,VL_EV1_H_PHASE
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
/* Programmation de ce qui est appele suivant les documents : */
/* */
/* Genlock H-phase */
/* ev1.Analog-Video-Output.hphase */
/* */
/* On notera que le changement de cadrage de l'image par rapport aux synchronisations */
/* "ligne" et "trame" n'est visible qu'a condition d'observer les images "out" : */
/* */
/* -soit sur la sortie composite 'Pal' (auquel cas, il faut etre en synchronisation */
/* "internal", car sinon, la "chroma" est perdue ; voir a ce propos l'alias 'bgenlock' */
/* defini dans 'v $Fdivers'), */
/* -soit sur la sortie 'RVB' associee non pas a la synchronisation "out" sortant de */
/* la carte 'Galileo', mais a la synchronisation "genlock"... */
/* */
PARAMETRAGE_NOEUD_1(VL_ANY
,intVal
,FORMAT_DE_PACKING_DES_POINTS_VIDEO
,VL_PACKING
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
/* Parametrage du format des images (fin). */
PARAMETRAGE_NOEUD_2(identite_du_noeud_emetteur
,xyVal
,x
,dimXPal
,y
,dimYPal
,VL_SIZE
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
/* Parametrage de la taille des images. */
CALS(VLGETCONTROL(identite_du_serveur_video
,chemin_emetteur_recepteur
,identite_du_noeud_emetteur
,VL_SIZE
,ADRESSE(parametres_courants)
)
);
/* Et validation de la taille... */
Test(IFET(IFEQ(ASD2(parametres_courants,xyVal,x),dimXPal)
,IFEQ(ASD2(parametres_courants,xyVal,y),dimYPal)
)
)
Bblock
# if ( (defined(BUG_SYSTEME_SGIND_VL_VLSETCONTROL_VL_SIZE)) \
)
PARAMETRAGE_NOEUD_2(identite_du_noeud_recepteur
,xyVal
,x
,dimXPal
,y
,dimYPal
,VL_SIZE
,NE_PAS_EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
# Aif ( (defined(BUG_SYSTEME_SGIND_VL_VLSETCONTROL_VL_SIZE)) \
)
PARAMETRAGE_NOEUD_2(identite_du_noeud_recepteur
,xyVal
,x
,dimXPal
,y
,dimYPal
,VL_SIZE
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
# Eif ( (defined(BUG_SYSTEME_SGIND_VL_VLSETCONTROL_VL_SIZE)) \
)
/* Parametrage de la taille des images. */
CALS(VLGETCONTROL(identite_du_serveur_video
,chemin_emetteur_recepteur
,identite_du_noeud_recepteur
,VL_SIZE
,ADRESSE(parametres_courants)
)
);
/* Et validation de la taille... */
Test(IFET(IFEQ(ASD2(parametres_courants,xyVal,x),dimXPal)
,IFEQ(ASD2(parametres_courants,xyVal,y),dimYPal)
)
)
Bblock
nPARAMETRAGE_NOEUD_2(identite_du_noeud_recepteur
,xyVal
,x
,XminPal
,y
,YminPal
,VL_ORIGIN
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
/* Parametrage de l'origine de la video dans l'ecran... */
nPARAMETRAGE_NOEUD_2(identite_du_noeud_recepteur
,fractVal
,numerator
,UNITE
,denominator
,UNITE
,VL_ZOOM
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
/* Parametrage du rapport de zoom. Mais, en fait, apparemment, le controle 'VL_ZOOM' n'a de */
/* sens que pour les noeuds de type 'VL_SCREEN'... */
EGAL(taille_reelle_des_images_en_octets
,VLGETTRANSFERSIZE(identite_du_serveur_video
,chemin_emetteur_recepteur
)
);
/* Recuperation de la taille des images a manipuler en octets... */
EGAL(buffer_des_images
,VLCREATEBUFFER(identite_du_serveur_video
,chemin_emetteur_recepteur
,identite_du_noeud_emetteur
,NOMBRE_D_IMAGES_A_MANIPULER
)
);
/* Creation des buffers necessaires a la manipulation des images. */
Test(IFNE(buffer_des_images
,POINTEUR_SUR_UN_OBJET_GALILEO_INEXISTANT
)
)
Bblock
DEFV(G_VLInfoPtr,informations_sur_l_image_courante);
/* Informations permettant de garantir la validite des images... */
# if (nSYSTEM_RELEASE >= 503000000)
DEFV(Logical,INIT(attendre_un_buffer_valide,VRAI));
/* Afin de boucler tant qu'il le faut sur 'VLGETNEXTVALID(...)'. */
# Aif (nSYSTEM_RELEASE >= 503000000)
# Eif (nSYSTEM_RELEASE >= 503000000)
CALS(VLREGISTERBUFFER(identite_du_serveur_video
,chemin_emetteur_recepteur
,identite_du_noeud_emetteur
,buffer_des_images
)
);
/* Et enfin, enregistrement des buffers... */
EGAL(informations_sur_l_image_courante
,POINTEUR_SUR_UN_OBJET_GALILEO_INEXISTANT
);
/* Afin de faire au moins une fois la boucle d'attente 'Tant(...)' qui va suivre... */
# if (nSYSTEM_RELEASE < 503000000)
CALS(VLPUTVALID(identite_du_serveur_video
,buffer_des_images
)
);
/* Operation mysterieuse, mais essentielle... */
Tant(IFEQ(informations_sur_l_image_courante
,POINTEUR_SUR_UN_OBJET_GALILEO_INEXISTANT
)
)
Bblock
EGAL(informations_sur_l_image_courante
,VLGETNEXTVALID(identite_du_serveur_video
,buffer_des_images
)
);
/* Et attente de validite... */
PETIT_DODO(TEMPORISATION_DES_Tant_ATTENTE_DE_BUFFER);
/* Afin de ne pas bloquer le systeme, et ce au cas ou il y aurait des defauts du type : */
/* */
/* unix: WARNING: Frame transfer aborted: analog video input not locked */
/* */
/* qui seraient permanents... */
Eblock
ETan
# Aif (nSYSTEM_RELEASE < 503000000)
# Eif (nSYSTEM_RELEASE < 503000000)
# if (nSYSTEM_RELEASE >= 503000000)
Tant(IL_FAUT(attendre_un_buffer_valide))
Bblock
EGAL(informations_sur_l_image_courante
,VLGETNEXTFREE(identite_du_serveur_video
,buffer_des_images
,taille_reelle_des_images_en_octets
)
);
/* Et attente de validite... */
Test(IFOU(IFEQ(informations_sur_l_image_courante
,POINTEUR_SUR_UN_OBJET_GALILEO_INEXISTANT
)
,IL_Y_A_ERRORS(VLBUFFERDONE(buffer_des_images))
)
)
/* ATTENTION, d'apres '/usr/people/4Dgifts/examples/dmedia/video/vl/simplem2v$c', il */
/* faudrait mettre : */
/* */
/* IFET(IFEQ(informations_sur_l_image_courant */
/* ,POINTEUR_SUR_UN_OBJET_GALILEO_INEXISTANT */
/* ) */
/* ,IL_Y_A_ERRORS(VLBUFFERDONE(buffer_des_images)) */
/* ) */
/* */
/* mais, le 'man' dit autre chose, d'ou cette nouvelle version... */
Bblock
PETIT_DODO(TEMPORISATION_DES_Tant_ATTENTE_DE_BUFFER);
/* Afin de ne pas bloquer le systeme, et ce au cas ou il y aurait des defauts du type : */
/* */
/* unix: WARNING: Frame transfer aborted: analog video input not locked */
/* */
/* qui seraient permanents... */
Eblock
ATes
Bblock
EGAL(attendre_un_buffer_valide,FAUX);
/* On arrete de boucler... */
Eblock
ETes
Eblock
ETan
/* ATTENTION, il y a eu pendant longtemps ici : */
/* */
/* Tant(IFET(IFEQ(informations_sur_l_image_courante */
/* ,POINTEUR_SUR_UN_OBJET_GALILEO_INEXISTANT */
/* ) */
/* ,PAS_D_ERRORS(VLBUFFERDONE(buffer_des_images)) */
/* ) */
/* ) */
/* Bblock */
/* EGAL(informations_sur_l_image_courante */
/* ,VLGETNEXTFREE(identite_du_serveur_video */
/* ,buffer_des_images */
/* ,taille_reelle_des_images_en_octets */
/* ) */
/* ); */
/* Eblock */
/* ETan */
/* */
/* mais cela n'est pas conforme a l'ordre de 'v $xtc/SGI_G.530.71$c' ainsi qu'aux programmes */
/* d'exemple, d'ou cette nouvelle version... */
# Aif (nSYSTEM_RELEASE >= 503000000)
# Eif (nSYSTEM_RELEASE >= 503000000)
EGAL(image_courante
,VLGETACTIVEREGION(identite_du_serveur_video
,buffer_des_images
,informations_sur_l_image_courante
)
);
/* Lorsque tout est valide, on peut recuperer un pointeur sur la zone "image courante"... */
EGAL(il_y_a_le_transfert_d_une_image_en_cours,FAUX);
/* Afin de savoir qu'il n'y a pas de transferts en cours... */
EGAL(la_connexion_video_pour_une_image_a_pu_etre_etablie,VRAI);
/* La connexion video demandee a pu etre etablie... */
EGAL(essayer_d_etablir_la_connexion,FAUX);
/* Et donc, ce n'est plus la peine de faire des tentatives... */
Eblock
ATes
Bblock
PRINT_ERREUR("les buffers d'images n'ont pu etre alloues");
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ERREUR("la taille incorrecte pour le noeud emetteur");
CAL1(Prer2(" demandee = (%d,%d)\n"
,dimXPal
,dimYPal
)
);
CAL1(Prer2(" reconnue = (%d,%d)\n"
,ASD2(parametres_courants,xyVal,x)
,ASD2(parametres_courants,xyVal,y)
)
);
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ERREUR("la taille incorrecte pour le noeud emetteur");
CAL1(Prer2(" demandee = (%d,%d)\n"
,dimXPal
,dimYPal
)
);
CAL1(Prer2(" reconnue = (%d,%d)\n"
,ASD2(parametres_courants,xyVal,x)
,ASD2(parametres_courants,xyVal,y)
)
);
Eblock
ETes
Test(EST_VRAI(une_erreur_forcant_l_iteration_a_ete_rencontree))
Bblock
/* Ce test est rajoute car 'une_erreur_forcant_l_iteration_a_ete_rencontree' puisque cette */
/* variable est inutile... */
PRINT_ERREUR("une iteration impossible est rencontree");
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ERREUR("le chemin n'a pu etre etabli (2)");
CAL1(Prer1(" identite du noeud emetteur = %d\n",identite_du_noeud_emetteur));
CAL1(Prer1(" identite du noeud recepteur = %d\n",identite_du_noeud_recepteur));
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ERREUR("le chemin n'a pu etre etabli (1)");
CAL1(Prer1(" identite du noeud emetteur = %d\n",identite_du_noeud_emetteur));
CAL1(Prer1(" identite du noeud recepteur = %d\n",identite_du_noeud_recepteur));
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ERREUR("le numero de 'device' demande est incorrect");
CAL1(Prer1(" numero de device demande = %d\n",numero_du_device_a_utiliser));
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ERREUR("impossible d'obtenir la liste des 'device's");
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ERREUR("impossible d'ouvrir la connexion video");
Eblock
ETes
PETIT_DODO(TEMPORISATION_DES_Tant_D_ETABLISSEMENT_DE_CONNEXION);
/* Afin de ne pas bloquer le systeme, et ce au cas ou il y aurait des defauts du type : */
/* */
/* unix: WARNING: Frame transfer aborted: analog video input not locked */
/* */
/* qui seraient permanents... */
Eblock
ETan
Test(IL_FAUT(essayer_d_etablir_la_connexion))
Bblock
PRINT_ERREUR("impossible d'etablir la connexion video apres plusieurs tentatives");
Eblock
ATes
Bblock
Eblock
ETes
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
CALS(winpush());
/* On notera qu'une fenetre 'GL' a ete ouverte ci-dessus par 'winopen(...)'. On conserve */
/* cette facilite car elle permet de surveiller que tout va bien, mais cette fenetre est */
/* placee ici derriere toutes les autres afin de ne pas deranger le travail. De plus, cela */
/* permet de la fermer interactivement via 'IGattente_de_l_evenement_ButtonPress(...)' (voir */
/* les durees "nulles" de 'v $xci/display_RVB$K'). En contre-partie, cela presente un petit */
/* inconvenient : celui de risquer de perdre des caracteres lorsque la fenetre graphique */
/* qui s'ouvre contient le curseur de la souris et qu'au meme moment on est train de taper */
/* sur le clavier...). Ce delicat probleme a ete resolu (provisoirement ?) par la definition */
/* d'une taille de fenetre 'Pal' dite "bandeau" qui permet, dans ce cas, de reduire la */
/* hauteur de la fenetre de facon considerable, et ce afin qu'elle n'apparaisse qu'en bas */
/* de l'ecran et qu'elle ne recouvre pas, meme partiellement, d'autres fenetres... */
/* */
/* ATTENTION, cet appel a du etre mis apres la phase d'etablissement de la connexion video */
/* car si il se trouve avant, lorsque la fenetre 'GL' est ramenee au premier plan, elle est */
/* vide (sauf en ce qui concerne les parties non cachees par d'autres fenetres...). Ici la */
/* situation est meilleure ; le seul defaut, mais general a toutes mes fenetres 'GL', est */
/* que la composante 'ROUGE' est absente (sauf en ce qui concerne les parties non cachees */
/* par d'autres fenetres...), ce qui vient du fait qu'il faudrait peut-etre gerer une sorte */
/* de rafraichissement... */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
Eblock
ECa1
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# if ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
Ca1e(MODE_BASSE_DEFINITION_PAL)
Bblock
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
CALS(setmonitor(PAL));
/* Mise au format 'PAL' avec signal de synchronisation separe. */
CALS(setvideo(CG_MODE
,COND(IL_FAUT(SE_SYNCHRONISER_SUR_UNE_SOURCE_EXTERNE)
,CG2_M_MODE9
,CG2_M_MODEA
)
)
);
CALS(setvideo(DE_R1
,DER1_G_PAL
)
);
/* Synchronisation sur une source video externe sans sous-porteuse couleur, et inhibition */
/* de la fonction 'overlay'. */
CALS(viewport(SGI_____XminG_d_une_fenetre_HAUTE_DEFINITION
,XMAXPAL
,SGI_____YminG_d_une_fenetre_HAUTE_DEFINITION
,YMAXPAL
)
);
/* Definition de la partie de la fenetre qui contient l'image (en fait toute...). */
CALS(blanktime(MUL2(ZERO,getgdesc(GD_TIMERHZ))));
/* Et ce afin de ne pas voir un ecran tout noir (une duree nulle en secondes inhibe le */
/* processus...). */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# message "ATTENTION : l'option 'GENLOCK' n'est pas disponible avec la bibliotheque 'OpenGL' (2)."
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
Eblock
ECa1
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
Ca1e(MODE_HAUTE_DEFINITION)
Bblock
Eblock
ECa1
Defo
Bblock
PRINT_ERREUR("un mode de fonctionnement n'est pas reconnu");
Eblock
EDef
Eblock
ECho
Eblock
ATes
Bblock
PRINT_ERREUR("l'ouverture de la fenetre ne peut avoir lieu");
Test(IFNE(identificateur_de_la_fenetre,FENETRE_PAS_OUVERTE_OU_PROBLEMES_A_L_OUVERTURE))
Bblock
Eblock
ATes
Bblock
PRINT_ERREUR("le code 'FENETRE_PAS_OUVERTE_OU_PROBLEMES_A_L_OUVERTURE' est incompatible avec 'winopen(...)'");
Eblock
ETes
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ERREUR("la fenetre est deja ouverte");
Eblock
ETes
RETU_ERROR;
Eblock
# if ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# undef dimYPal_bandeau
# undef YmaxPal_bandeau
# undef YminPal_bandeau
# undef dimXPal_bandeau
# undef XmaxPal_bandeau
# undef XminPal_bandeau
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# undef POSITIONNEMENT_DE_LA_FENETRE_COURANTE
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# undef HAUTEUR_VIEWPORT
# undef LARGEUR_VIEWPORT
# undef Y_VIEWPORT
# undef X_VIEWPORT
# undef GL_CURRENT_RASTER_DEBUT_VIEWPORT
# undef POSITIONNEMENT_DE_LA_FENETRE_COURANTE
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C H A N G E M E N T D E L A C O R E C T I O N D E G A M M A D E L ' E C R A N */
/* ( A P R E S O U V E R T U R E D ' U N E F E N E T R E ) : */
/* */
/*************************************************************************************************************************************/
BFonctionI
# define COULEURS_DE_CORRECTION_DE_GAMMA \
COULEURS
# define NOIR_DE_CORRECTION_DE_GAMMA \
NOIR
# define BLANC_DE_CORRECTION_DE_GAMMA \
LSTX(NOIR_DE_CORRECTION_DE_GAMMA,COULEURS_DE_CORRECTION_DE_GAMMA)
/* Definition des niveaux necessaires a la correction de gamma. */
# define NIVR_DE_CORRECTION_DE_GAMMA(niveau) \
SOUS(niveau,NOIR_DE_CORRECTION_DE_GAMMA) \
/* Fonction 'NIVR(...)' necessaire pour la fonction de gamma. */
# define CORRECTION_DE_GAMMA(rampe_de_correction_de_gamma,correction_de_gamma) \
EGAL(ITb1(rampe_de_correction_de_gamma,INDX(index,NOIR_DE_CORRECTION_DE_GAMMA)) \
,ARRI(MUL2(PUIX(DIVI(FLOT(NIVR_DE_CORRECTION_DE_GAMMA(index)) \
,FLOT(NIVR_DE_CORRECTION_DE_GAMMA(BLANC_DE_CORRECTION_DE_GAMMA)) \
) \
,INVE(correction_de_gamma) \
) \
,FLOT(NIVR_DE_CORRECTION_DE_GAMMA(BLANC_DE_CORRECTION_DE_GAMMA)) \
) \
) \
); \
/* Correction de gamma pour un niveau d'une des trois composantes chromatiques. */
DEFV(Common,DEFV(FonctionI,IGchangement_de_la_correction_de_gamma(correction_de_gamma_ROUGE
,correction_de_gamma_VERTE
,correction_de_gamma_BLEUE
)
)
)
DEFV(Argument,DEFV(Float,correction_de_gamma_ROUGE));
DEFV(Argument,DEFV(Float,correction_de_gamma_VERTE));
DEFV(Argument,DEFV(Float,correction_de_gamma_BLEUE));
/* Correction de gamma demandee pour les trois composantes chromatiques. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/* ATTENTION : 'INIT_ERROR' est mis en tete des variables locales au cas ou des couples */
/* ('BDEFV','EDEFV') suivraient... */
/*..............................................................................................................................*/
Test(I3ET(IZGT(correction_de_gamma_ROUGE)
,IZGT(correction_de_gamma_VERTE)
,IZGT(correction_de_gamma_BLEUE)
)
)
Bblock
DEFV(vrai_Short_Int_de_base,DTb1(rampe_de_correction_de_gamma_ROUGE,COULEURS_DE_CORRECTION_DE_GAMMA));
DEFV(vrai_Short_Int_de_base,DTb1(rampe_de_correction_de_gamma_VERTE,COULEURS_DE_CORRECTION_DE_GAMMA));
DEFV(vrai_Short_Int_de_base,DTb1(rampe_de_correction_de_gamma_BLEUE,COULEURS_DE_CORRECTION_DE_GAMMA));
/* Vecteur destine a contenir la correction de Gamma relative aux trois composantes */
/* chromatiques... */
DEFV(Int,INIT(index,UNDEF));
/* Index d'initialisation de 'rampe_de_correction_de_gamma'. */
BoIn(index,NOIR_DE_CORRECTION_DE_GAMMA,BLANC_DE_CORRECTION_DE_GAMMA,PAS_COULEURS)
Bblock
CORRECTION_DE_GAMMA(rampe_de_correction_de_gamma_ROUGE,correction_de_gamma_ROUGE);
CORRECTION_DE_GAMMA(rampe_de_correction_de_gamma_VERTE,correction_de_gamma_VERTE);
CORRECTION_DE_GAMMA(rampe_de_correction_de_gamma_BLEUE,correction_de_gamma_BLEUE);
/* Generation des "rampes" de correction de Gamma relative aux trois composantes */
/* chromatiques... */
Eblock
EBoI
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
CALS(gammaramp(rampe_de_correction_de_gamma_ROUGE
,rampe_de_correction_de_gamma_VERTE
,rampe_de_correction_de_gamma_BLEUE
)
);
/* Et demande de changement de la correction de gamma courante... */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
Bblock
DEFV(Int,INIT(identificateur_fictif_de_la_fenetre,FENETRE_PAS_OUVERTE_OU_PROBLEMES_A_L_OUVERTURE));
/* Fenetre fictive necessaire au fonctionnement de 'gammaramp(...)'... */
CALS(noport());
/* Afin de ne pas faire apparaitre la fenetre fictive a l'ecran... */
EGAL(identificateur_fictif_de_la_fenetre
,winopen(C_VIDE)
);
/* Ouverture d'une fenetre fictive necessaire au fonctionnement de 'gammaramp(...)' car, */
/* sinon, en version '__VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL', on recupere le message : */
/* */
/* error, gammaramp: Permission denied */
/* */
/* et le gamma ne change pas... */
CALS(gammaramp(rampe_de_correction_de_gamma_ROUGE
,rampe_de_correction_de_gamma_VERTE
,rampe_de_correction_de_gamma_BLEUE
)
);
/* Et demande de changement de la correction de gamma courante... */
CALS(gexit());
/* Fermeture de la fenetre fictive... */
Eblock
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
Eblock
ATes
Bblock
PRINT_ERREUR("la correction de gamma ne peut etre que strictement positive");
Eblock
ETes
RETU_ERROR;
Eblock
# undef CORRECTION_DE_GAMMA
# undef NIVR_DE_CORRECTION_DE_GAMMA
# undef BLANC_DE_CORRECTION_DE_GAMMA
# undef NOIR_DE_CORRECTION_DE_GAMMA
# undef COULEURS_DE_CORRECTION_DE_GAMMA
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A T T E N T E D E L ' E V E N E M E N T ' B u t t o n P r e s s ' : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IGattente_de_l_evenement_ButtonPress()))
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/* ATTENTION : 'INIT_ERROR' est mis en tete des variables locales au cas ou des couples */
/* ('BDEFV','EDEFV') suivraient... */
/*..............................................................................................................................*/
Test(IFNE(identificateur_de_la_fenetre,FENETRE_PAS_OUVERTE_OU_PROBLEMES_A_L_OUVERTURE))
Bblock
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
Tant(IFOU(I3ET(IFEQ(getbutton(LEFTMOUSE),FALSE)
,IFEQ(getbutton(MIDDLEMOUSE),FALSE)
,IFEQ(getbutton(RIGHTMOUSE),FALSE)
)
,IFOU(IFEXff(getvaluator(MOUSEX),ASD1(position_coin_bas_gauche,x),ASD1(position_coin_haut_droite,x))
,IFEXff(getvaluator(MOUSEY),ASD1(position_coin_bas_gauche,y),ASD1(position_coin_haut_droite,y))
)
)
)
/* Attente tant qu'aucun des trois boutons de la souris n'est presse. On notera que cet */
/* evenement est baptise 'ButtonPress' par analogie avec 'X-Window'... Toujours suite a */
/* l'analogie, il faut que cette action ait lieu alors que le curseur de la souris se situe */
/* dans la fenetre ouverte... */
/* */
/* On notera qu'il y a une petite anomalie dont je ne suis pas responsable. En effet, il */
/* est impossible de savoir si le curseur de la souris {MOUSEX,MOUSEY} est reellement dans */
/* une partie visible de la fenetre (on sait qu'il est dans la fenetre, mais cette partie */
/* de la fenetre peut etre cachee par une autre...). Il n'existe pas de fonctions qui */
/* permettent de savoir l'identite de la fenetre dans lequel se trouve a chaque instant */
/* le curseur de la souris (ce que l'on pourrait comparer a 'identificateur_de_la_fenetre'). */
/* Une solution batarde pourrait etre de modifier le 'Tant(IFOU(...))' en : */
/* */
/* Tant(I3OU(I3ET(...) */
/* ,IFOU(...) */
/* ,IFET(IFNE(windepth(identificateur_de_la_fenetre),UN) */
/* ,IFNE(windepth(identificateur_de_la_fenetre),DEUX) */
/* ) */
/* ) */
/* ) */
/* Bblock */
/* (...) */
/* Eblock */
/* ETan */
/* */
/* car en effet, l'experience montre que 'windepth(...)' renvoie 'UN' apres 'winopen(...)' */
/* et 'DEUX' apres qu'une fenetre ait ete rapatriee au premier plan. Ainsi l'evenement */
/* 'ButtonPress' ne serait activable que pour une fenetre au premier plan. Malheureusement, */
/* le manuel de 'windepth(...)' laisse entendre que la valeur renvoyee ne peut pas etre */
/* toujours interpretee de facon aussi simpliste... */
Bblock
BLOC(VIDE;);
Eblock
ETan
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
APPEL_D_UNE_FONCTION_X_WINDOW_POUR_OpenGL(BLOC(CALS(IXattente_de_l_evenement_ButtonPress());)
,BLOC(VIDE;)
);
/* Et on attend de nouveau un petit peu, jusqu'a ce que l'on appuie sur l'un des trois */
/* boutons de la souris... */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
Eblock
ATes
Bblock
PRINT_ERREUR("la fenetre n'est pas ouverte");
Eblock
ETes
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F E R M E T U R E D ' U N E F E N E T R E : */
/* */
/*************************************************************************************************************************************/
BFonctionI
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# define G_RESTAURATION_DU_blanktime \
GRO10(SOIXANTE) \
/* Duree en secondes avant l'extinction de l'ecran... */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
DEFV(Common,DEFV(FonctionI,IGclose()))
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/* ATTENTION : 'INIT_ERROR' est mis en tete des variables locales au cas ou des couples */
/* ('BDEFV','EDEFV') suivraient... */
# if ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# if ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
/*..............................................................................................................................*/
Test(IFNE(identificateur_de_la_fenetre,FENETRE_PAS_OUVERTE_OU_PROBLEMES_A_L_OUVERTURE))
Bblock
Choi(mode_de_fonctionnement)
Bblock
# if ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
Ca1e(MODE_BASSE_DEFINITION_PAL)
Bblock
Test(EST_VRAI(la_connexion_video_pour_une_image_a_pu_etre_etablie))
Bblock
Test(EST_VRAI(il_y_a_le_transfert_d_une_image_en_cours))
Bblock
CALS(VLPUTFREE(identite_du_serveur_video,buffer_des_images));
/* Pour faire "pendant" au 'VLGETNEXTVALID(...)' qui a precede... */
Test(PAS_D_ERREUR(VLENDTRANSFER(identite_du_serveur_video,chemin_emetteur_recepteur)))
/* Lorsqu'il y a un transfert en cours, on le termine... */
Bblock
Eblock
ATes
Bblock
PRINT_ERREUR("un transfert en cours ne peut etre interrompu");
Eblock
ETes
DETECTION_DES_DEFAUTS_EN_COURS_DE_TRANSFERT(SE_SYNCHRONISER_SUR_UNE_SOURCE_EXTERNE);
/* S'est-il produit des defauts pendant le transfert precedent ? */
EGAL(il_y_a_le_transfert_d_une_image_en_cours,FAUX);
/* Et on memorise que c'est fini, meme si 'VLENDTRANSFER(...)' a echoue ; sinon, que faire */
/* d'autre ? */
Eblock
ATes
Bblock
Eblock
ETes
CALS(VLDEREGISTERBUFFER(identite_du_serveur_video
,chemin_emetteur_recepteur
,identite_du_noeud_emetteur
,buffer_des_images
)
);
/* Et enfin, desenregistrement des buffers... */
CALS(VLDESTROYBUFFER(identite_du_serveur_video
,buffer_des_images
)
);
/* Puis destruction de ces memes buffers... */
Test(IL_FAUT(SGI_____visualiser_le_contenu_de_l_ecran_de_la_station_de_travail))
Bblock
DEFV(Logical,INIT(une_erreur_forcant_l_iteration_a_ete_rencontree
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
)
);
/* ATTENTION, cette definition n'est la que pour permettre une compilation correcte des */
/* procedures 'PARAMETRAGE_NOEUD_?(...)', mais ne sert a rien d'autre... */
PARAMETRAGE_NOEUD_1(identite_du_noeud_mixage
,intVal
,identite_du_noeud_emetteur
,VL_BLEND_A
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
PARAMETRAGE_NOEUD_1(identite_du_noeud_mixage
,intVal
,VL_BLDFCN_ZERO
,VL_BLEND_A_FCN
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
PARAMETRAGE_NOEUD_1(identite_du_noeud_mixage
,intVal
,identite_du_noeud_emetteur
,VL_BLEND_B
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
PARAMETRAGE_NOEUD_1(identite_du_noeud_mixage
,intVal
,VL_BLDFCN_ZERO
,VL_BLEND_B_FCN
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
/* Deprogrammation du "mixage" afin d'eviter un probleme lors d'une utilisation ulterieure */
/* de l'entree video temps reel : celle-ci se retrouverait alors mixee avec le contenu de */
/* l'ecran de la station de travail... ATTENTION, ce n'est pas une erreur de trouver */
/* deux fois le noeud 'identite_du_noeud_emetteur' (sans 'identite_du_noeud_station') car */
/* autrement l'effet obtenu est desastreux (des melanges etranges apparaissent...). */
Eblock
ATes
Bblock
Eblock
ETes
CALS(VLDESTROYPATH(identite_du_serveur_video
,chemin_emetteur_recepteur
)
);
/* Puis destruction du chemin entre l'emetteur et le recepteur. On notera que c'est l'appel */
/* a 'VLDESTROYPATH(...)' qui provoque la disparition de l'image sur la sortie video (et */
/* donc son retour au noir...) contrairement a l'anomalie constatee dans la fonction */
/* 'IGfin_de_diffusion_ou_de_numerisation_d_une_sequence_video(...)' ou alors la video */
/* continue de sortir... */
/* */
/* ATTENTION, on lira avec soin les commentaires relatifs a la mise en place de la */
/* connexion de repos par 'SGI_____Gentree_video_de_repos' que l'on ne peut malheureusement */
/* implementer ici aussi... */
Test(PAS_D_ERREUR(VLCLOSEVIDEO(identite_du_serveur_video)))
/* Enfin, fermeture de la connexion video... */
Bblock
Eblock
ATes
Bblock
PRINT_ERREUR("la fermeture de la connexion video est impossible (2)");
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
EGAL(la_connexion_video_pour_une_image_a_pu_etre_etablie,FAUX);
/* A priori, on ne sait pas ce qui se passera la fois suivante... */
Eblock
ECa1
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# if ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
Ca1e(MODE_BASSE_DEFINITION_PAL)
Bblock
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
CALS(blanktime(MUL2(G_RESTAURATION_DU_blanktime,getgdesc(GD_TIMERHZ))));
/* Et ce afin de re-autoriser l'extinction de l'ecran... */
CALS(setmonitor(HZ60));
/* On repasse a priori en mode haute-definition... */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# message "ATTENTION : l'option 'GENLOCK' n'est pas disponible avec la bibliotheque 'OpenGL' (3)."
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
Eblock
ECa1
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
Ca1e(MODE_HAUTE_DEFINITION)
Bblock
Eblock
ECa1
Defo
Bblock
PRINT_ERREUR("un mode de fonctionnement n'est pas reconnu");
Eblock
EDef
Eblock
ECho
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
CALS(curson());
/* Remise en place du curseur. On notera que celle-ci a lieu que le curseur ait ete elimine */
/* dans 'IGopen(...)' ou pas, et ce afin d'eviter un parametre supplementaire pour la */
/* fonction 'IGclose(...)'. ATTENTION, voir le commentaire ci-dessous relatif au deplacement */
/* de cet appel... */
CALS(finish());
/* Attente eventuelle de vidage du pipe-line graphique... */
CALS(gexit());
/* Fermeture de la fenetre... */
/* ATTENTION, afin de ne pas voir re-apparaitre le curseur juste avant la fermeture d'une */
/* fenetre, et ce quand il est indesirable, il serait preferable de le retablir ici, et */
/* donc apres la fermeture de la fenetre. Il faudrait donc placer ici : */
/* */
/* CALS(curson()); */
/* */
/* Malheureusement, cela provoque un "core"... */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
APPEL_D_UNE_FONCTION_X_WINDOW_POUR_OpenGL(BLOC(CALS(IXclose_pour_utiliser_OpenGL());)
,BLOC(VIDE;)
);
/* Fermeture de la fenetre... */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
EGAL(identificateur_de_la_fenetre,FENETRE_PAS_OUVERTE_OU_PROBLEMES_A_L_OUVERTURE);
/* Et sa memorisation... */
Eblock
ATes
Bblock
PRINT_ERREUR("la fenetre n'est pas ouverte");
Eblock
ETes
RETU_ERROR;
Eblock
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# undef G_RESTAURATION_DU_blanktime
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D I S P L A Y G R A P H I Q U E D ' U N E I M A G E " V R A I E S C O U L E U R S " : */
/* */
/*************************************************************************************************************************************/
BFonctionI
/* Ce pragma a ete deplace de 'v $xiidX/fonct$vv$FON IGdisplay_____imageA_courante' (la ou */
/* est definie cette image) jusqu'ici le 20040521130935 car, en effet, c'est lorsque ce */
/* module est necessaire ('v $xcc/cpp$Z SiliG_EXT') que l'on a besoin de cette image... */
/* Le 20040523111133 ce '#pragma' relatif a 'xcc__cpp_Z__liste_utiles' et concernant la */
/* definition 'IGdisplay_____imageA_courante' a pu etre remis a sa place et ce grace au */
/* dispositif 'v $xcc/cpp$Z 20040522102819'. */
# if ( (defined(BUG_SYSTEME_SG_GL_RAPPORT_DE_ZOOM_NON_ENTIER_DE_rectzoom)) \
)
# define FACTEUR_DE_ZOOM \
INTE(facteur_de_zoom) \
/* Facteur de zoom qui doit etre un nombre entier... */
# Aif ( (defined(BUG_SYSTEME_SG_GL_RAPPORT_DE_ZOOM_NON_ENTIER_DE_rectzoom)) \
)
# define FACTEUR_DE_ZOOM \
NEUT(facteur_de_zoom) \
/* Facteur de zoom. */
# Eif ( (defined(BUG_SYSTEME_SG_GL_RAPPORT_DE_ZOOM_NON_ENTIER_DE_rectzoom)) \
)
# define G_TRANSLATION_HORIZONTALE_DE_L_IMAGE \
COND(IL_FAUT(centrer_l_image_dans_la_fenetre) \
,MOYS(COND(IFEQ(mode_de_fonctionnement,MODE_HAUTE_DEFINITION) \
,dimXG_d_une_fenetre_HAUTE_DEFINITION \
,COND(IFEQ(mode_de_fonctionnement,MODE_BASSE_DEFINITION_PAL) \
,dimXPal \
,dimXG_d_une_fenetre_HAUTE_DEFINITION \
) \
) \
,COND(IFEQ(mode_de_fonctionnement,MODE_HAUTE_DEFINITION) \
,INTE(MUL2(facteur_de_zoom_effectif,FLOT(dimX))) \
,COND(IFEQ(mode_de_fonctionnement,MODE_BASSE_DEFINITION_PAL) \
,dimX \
,dimX \
) \
) \
) \
,_lDENORMALISE_OXG(ASI1(translation_de_l_image_dans_la_fenetre,dx)) \
) \
/* Translation horizontale de l'image dans le plan de travail. ATTENTION : on notera que */ \
/* cette definition, bien que referencant le mode 'MODE_BASSE_DEFINITION_PAL', ne depend */ \
/* pas de '__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS' afin de */ \
/* simplifier les choses... */
# define G_TRANSLATION_VERTICALE_DE_L_IMAGE \
COND(IL_FAUT(centrer_l_image_dans_la_fenetre) \
,MOYS(COND(IFEQ(mode_de_fonctionnement,MODE_HAUTE_DEFINITION) \
,dimYG_d_une_fenetre_HAUTE_DEFINITION \
,COND(IFEQ(mode_de_fonctionnement,MODE_BASSE_DEFINITION_PAL) \
,dimYPal \
,dimYG_d_une_fenetre_HAUTE_DEFINITION \
) \
) \
,COND(IFEQ(mode_de_fonctionnement,MODE_HAUTE_DEFINITION) \
,INTE(MUL2(facteur_de_zoom_effectif,FLOT(dimY))) \
,COND(IFEQ(mode_de_fonctionnement,MODE_BASSE_DEFINITION_PAL) \
,dimY \
,dimY \
) \
) \
) \
,_lDENORMALISE_OYG(ASI1(translation_de_l_image_dans_la_fenetre,dy)) \
) \
/* Translation verticale de l'image dans le plan de travail. ATTENTION : on notera que */ \
/* cette definition, bien que referencant le mode 'MODE_BASSE_DEFINITION_PAL', ne depend */ \
/* pas de '__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS' afin de */ \
/* simplifier les choses... */
# define CORRELATION_DES_PARITES_DE_LIGNES(Ymax_fenetre,Ymax_image_dans_la_fenetre) \
COND(MEME_PARITE(Ymax_fenetre,Ymax_image_dans_la_fenetre) \
,ZERO \
,UN \
) \
/* Procedure destinee a "aligner" les parites des lignes dans une fenetre et dans l'image */ \
/* contenue dans cette fenetre (en n'oubliant pas que l'axe des 'Y' en video descend au */ \
/* lieu de monter...). Cet "alignement" est rendu necessaire par la possibilite de generer */ \
/* des images stereoscopiques multiplexant les images '$DROITE' et '$GAUCHE' sur les trames */ \
/* paires et impaires. Il faut donc alors que les parites des lignes de l'image soient les */ \
/* memes que celles de la fenetre video pour voir le bon relief... */ \
/* */ \
/* ATTENTION, cela pourrait etre utilise pour entrelacer les images d'une animation afin */ \
/* de faire que la frequence des images soit 50 Hz et non pas 25 Hz. Malheureusement, cela */ \
/* n'est pas tres utile car, en effet, ne favoriserait ni les ralentis ni les arrets sur */ \
/* image car alors les images seraient "tremblottantes"... */
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# define GL_CURRENT_RASTER_DEBUT_POSITION \
INDEX0
Denumer05(INIS(GL_CURRENT_RASTER_X_POSITION,GL_CURRENT_RASTER_DEBUT_POSITION)
,GL_CURRENT_RASTER_Y_POSITION
,GL_CURRENT_RASTER_Z_POSITION
,GL_CURRENT_RASTER_W_POSITION
,GL_CURRENT_RASTER_FIN_POSITION
,format_de_la_position_raster_courante
);
/* Format des informations renvoyees par 'glGetIntegerv(GL_CURRENT_RASTER_POSITION,...)'. */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# if ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# define ENVOI_D_UN_NIVEAU_VIDEO_A_LA_CARTE_GALILEO(niveau) \
Bblock \
EGAL(IdTb1(image_courante \
,index_dans_l_image_courante \
,TAILLE_REELLE_DES_IMAGES_EN_OCTETS \
) \
,niveau \
); \
/* Transfert d'un niveau sous forme d'un octet. On notera la regle de trois, car en effet, */ \
/* il semblerait que 'taille_reelle_des_images_en_octets' donne une taille qui considere */ \
/* qu'un point est code sur 4 octets, alors que l'experience montre qu'en realite dans le */ \
/* cas de cette option, il s'agit en fait de 3 octets consecutifs... */ \
INCR(index_dans_l_image_courante,I); \
/* Et progression de l'index courant... */ \
Eblock \
/* Envoi d'un niveau video (ROUGE, VERTE ou BLEUE). */
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# if ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
DEFV(Common,DEFV(FonctionI,IGdisplay(imageA
,facteur_de_zoom
,centrer_l_image_dans_la_fenetre
,ARGUMENT_POINTERs(translation_de_l_image_dans_la_fenetre)
)
)
)
DEFV(Argument,DEFV(imageU,imageA));
/* Image Argument que l'on veut visualiser sur le bit-map couleur. */
DEFV(Argument,DEFV(Float,facteur_de_zoom));
/* Facteur de zoom horizontal et vertical de l'image... */
DEFV(Argument,DEFV(Logical,centrer_l_image_dans_la_fenetre));
/* Indicateur precisant s'il faut un centrage automatique de l'image dans la fenetre */
/* ('VRAI') ou si la translation est definie en tant que l'argument suivant ('FAUX'). */
DEFV(Argument,DEFV(deltaF_2D,POINTERs(translation_de_l_image_dans_la_fenetre)));
/* Translation explicite de l'image dans la fenetre lorsque le centrage automatique n'est */
/* pas demande ('centrer_l_image_dans_la_fenetre'='FAUX'). Dans le cas ou le centrage */
/* automatique est demande, cet argument (qui doit etre present a cause de la validation */
/* du nombre des arguments) n'est pas utilise... */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/* ATTENTION : 'INIT_ERROR' est mis en tete des variables locales au cas ou des couples */
/* ('BDEFV','EDEFV') suivraient... */
DEFV(Float,INIT(facteur_de_zoom_effectif,RAPPORT_DE_ZOOM_STANDARD_DE_rectzoom));
/* Facteur de zoom horizontal et vertical de l'image effectivement utilise... */
DEFV(G_Screencoord,INIT(abscisse_en_bas_a_gauche,ADD2(Xmin,G_TRANSLATION_HORIZONTALE_DE_L_IMAGE)));
DEFV(G_Screencoord,INIT(ordonnee_en_bas_a_gauche,ADD2(Ymin,G_TRANSLATION_VERTICALE_DE_L_IMAGE)));
DEFV(G_Screencoord,INIT(abscisse_en_haut_a_droite,ADD2(Xmax,G_TRANSLATION_HORIZONTALE_DE_L_IMAGE)));
DEFV(G_Screencoord,INIT(ordonnee_en_haut_a_droite,ADD2(Ymax,G_TRANSLATION_VERTICALE_DE_L_IMAGE)));
/* Definition de l'emplacement de l'image. Mais ATTENTION : cette initialisation est */
/* eventuellement mauvaise, car en effet 'facteur_de_zoom_effectif' n'est pas encore */
/* connu... */
DEFV(Int,INIT(translation_d_alignement_des_parites_des_lignes,UNDEF));
/* Afin de permettre une visualisation stereoscopique par multiplexage "trame paire" et */
/* "trame impaire"... */
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
DEFV(G_Screencoord,DTb1(position_raster_courante,NBRE(GL_CURRENT_RASTER_DEBUT_POSITION,PRED(GL_CURRENT_RASTER_FIN_POSITION))));
/* Informations renvoyees par 'glGetIntegerv(GL_CURRENT_RASTER_POSITION,...)'. */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# if ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
DEFV(Int,INIT(nombre_de_descripteurs_de_transfert_d_images,UN));
/* Nombre de transferts d'images a effectuer... */
DEFV(G_VLTransferDescriptor,descripteurs_de_transfert_d_images);
/* Descripteurs des transferts d'images... */
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# if ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
/*..............................................................................................................................*/
Test(IFNE(identificateur_de_la_fenetre,FENETRE_PAS_OUVERTE_OU_PROBLEMES_A_L_OUVERTURE))
Bblock
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# if ( (defined(BUG_SYSTEME_SG_GL_RAPPORT_DE_ZOOM_NON_ENTIER_DE_rectzoom)) \
)
Test(IFNE(facteur_de_zoom,FLOT(FACTEUR_DE_ZOOM)))
Bblock
PRINT_ATTENTION("le facteur de zoom doit etre entier");
CAL1(Prer1(" rapport de zoom demande = %g\n",facteur_de_zoom));
CAL1(Prer1(" rapport de zoom utilise = %d\n",FACTEUR_DE_ZOOM));
Eblock
ATes
Bblock
Eblock
ETes
# Aif ( (defined(BUG_SYSTEME_SG_GL_RAPPORT_DE_ZOOM_NON_ENTIER_DE_rectzoom)) \
)
# Eif ( (defined(BUG_SYSTEME_SG_GL_RAPPORT_DE_ZOOM_NON_ENTIER_DE_rectzoom)) \
)
Choi(mode_de_fonctionnement)
Bblock
# if ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
|| (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
Ca1e(MODE_BASSE_DEFINITION_PAL)
Bblock
Test(IFNE(facteur_de_zoom,RAPPORT_DE_ZOOM_STANDARD_DE_rectzoom))
Bblock
PRINT_ATTENTION("le facteur de zoom est ignore en 'PAL', la valeur standard est forcee");
CAL1(Prer1(" rapport de zoom demande = %g\n",facteur_de_zoom));
CAL1(Prer1(" rapport de zoom utilise = %g\n",RAPPORT_DE_ZOOM_STANDARD_DE_rectzoom));
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ECa1
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
|| (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
|| (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
Ca1e(MODE_HAUTE_DEFINITION)
Bblock
# if ( (defined(BUG_SYSTEME_SG_GL_RAPPORT_DE_ZOOM_TROP_GRAND_DE_rectzoom)) \
)
Test(IFGT(facteur_de_zoom,VALEUR_MAXIMALE_DU_RAPPORT_DE_ZOOM_DE_rectzoom))
Bblock
PRINT_ATTENTION("le rapport de zoom est trop grand, la valeur standard est conservee");
CAL1(Prer1(" rapport de zoom demande = %g\n",facteur_de_zoom));
CAL1(Prer1(" rapport de zoom maximal = %g\n",VALEUR_MAXIMALE_DU_RAPPORT_DE_ZOOM_DE_rectzoom));
Eblock
ATes
Bblock
Test(IZLE(facteur_de_zoom))
Bblock
PRINT_ATTENTION("le rapport de zoom ne peut etre negatif ou nul, la valeur standard est conservee");
CAL1(Prer1(" rapport de zoom demande = %g\n",facteur_de_zoom));
CAL1(Prer1(" rapport de zoom utilise = %g\n",RAPPORT_DE_ZOOM_STANDARD_DE_rectzoom));
Eblock
ATes
Bblock
EGAL(facteur_de_zoom_effectif,FACTEUR_DE_ZOOM);
/* Mise en place du facteur de zoom effectif (c'est-a-dire inchange au cas ou l'argument */
/* serait errone). */
Eblock
ETes
Eblock
ETes
# Aif ( (defined(BUG_SYSTEME_SG_GL_RAPPORT_DE_ZOOM_TROP_GRAND_DE_rectzoom)) \
)
Test(IZLE(facteur_de_zoom))
Bblock
PRINT_ATTENTION("le rapport de zoom ne peut etre negatif ou nul, la valeur standard est conservee");
CAL1(Prer1(" rapport de zoom demande = %g\n",facteur_de_zoom));
CAL1(Prer1(" rapport de zoom utilise = %g\n",RAPPORT_DE_ZOOM_STANDARD_DE_rectzoom));
Eblock
ATes
Bblock
EGAL(facteur_de_zoom_effectif,FACTEUR_DE_ZOOM);
/* Mise en place du facteur de zoom effectif (c'est-a-dire inchange au cas ou l'argument */
/* serait errone). */
Eblock
ETes
# Eif ( (defined(BUG_SYSTEME_SG_GL_RAPPORT_DE_ZOOM_TROP_GRAND_DE_rectzoom)) \
)
Eblock
ECa1
Defo
Bblock
PRINT_ERREUR("un mode de fonctionnement n'est pas reconnu");
Eblock
EDef
Eblock
ECho
Test(IFOU(IFGT(INTE(MUL2(facteur_de_zoom_effectif,FLOT(dimX))),dimXG_d_une_fenetre_HAUTE_DEFINITION)
,IFGT(INTE(MUL2(facteur_de_zoom_effectif,FLOT(dimY))),dimYG_d_une_fenetre_HAUTE_DEFINITION)
)
)
Bblock
PRINT_ATTENTION("l'image est trop grande par rapport a la fenetre ouverte, on force le zoom standard");
CAL1(Prer1(" rapport de zoom demande = %g\n",facteur_de_zoom));
CAL1(Prer1(" rapport de zoom utilise = %g\n",RAPPORT_DE_ZOOM_STANDARD_DE_rectzoom));
/* On notera que le test utilise 'facteur_de_zoom_effectif' mais que c'est 'facteur_de_zoom' */
/* qui est edite, car seul ce dernier est connu a l'exterieur... */
/* */
/* On notera que ce cas peut se rencontrer, meme lorsque l'on ne l'attend pas. Ainsi, par */
/* exemple, faisons : */
/* */
/* set XmaxG=1269 */
/* set YmaxG=1013 */
/* */
/* ce qui donne une fenetre plein-ecran (avec juste la bordure de la fenetre...). Alors, */
/* pour les images de format "plus grand ou egal" a 'Std', seul le zoom de rapport egal */
/* a 1 est utilisable car en effet, on a dans ces conditions : */
/* */
/* 2*512 > (1013-0) + 1 */
/* */
/* /|\ /\ */
/* | || */
/* | || */
/* */
/* =dimY =dimYG */
/* */
/* et l'image agrandie ne tient pas verticalement dans la fenetre... */
EGAL(facteur_de_zoom_effectif,RAPPORT_DE_ZOOM_STANDARD_DE_rectzoom);
Eblock
ATes
Bblock
Eblock
ETes
CALS(rectzoom(facteur_de_zoom_effectif,facteur_de_zoom_effectif));
/* Mise en place du facteur de zoom effectif (c'est-a-dire inchange au cas ou l'argument */
/* serait errone). */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
EGAL(facteur_de_zoom_effectif,RAPPORT_DE_ZOOM_STANDARD_DE_rectzoom);
/* A priori. On pourrait supprimer completement le rapport de zoom, mais il est en fait */
/* utilise a differents endroits ; le plus simple est donc de le rendre neutre... */
Test(IFNE(facteur_de_zoom,facteur_de_zoom_effectif))
Bblock
PRINT_ATTENTION("avec 'OpenGl' il n'y a pas de zoom");
CAL1(Prer1(" rapport de zoom demande = %g\n",facteur_de_zoom));
CAL1(Prer1(" rapport de zoom utilise = %f\n",facteur_de_zoom_effectif));
Eblock
ATes
Bblock
Eblock
ETes
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
EGAL(abscisse_en_bas_a_gauche,ADD2(Xmin,G_TRANSLATION_HORIZONTALE_DE_L_IMAGE));
EGAL(ordonnee_en_bas_a_gauche,ADD2(Ymin,G_TRANSLATION_VERTICALE_DE_L_IMAGE));
EGAL(abscisse_en_haut_a_droite,ADD2(Xmax,G_TRANSLATION_HORIZONTALE_DE_L_IMAGE));
EGAL(ordonnee_en_haut_a_droite,ADD2(Ymax,G_TRANSLATION_VERTICALE_DE_L_IMAGE));
/* Definition de l'emplacement de l'image lorsque 'facteur_de_zoom_effectif' est connu... */
EGAL(translation_d_alignement_des_parites_des_lignes
,CORRELATION_DES_PARITES_DE_LIGNES(ADD2(SGI_____YminG_d_une_fenetre_HAUTE_DEFINITION
,SOUS(ASD1(position_coin_haut_droite,y),ASD1(position_coin_bas_gauche,y))
)
,ordonnee_en_haut_a_droite
)
);
INCR(ordonnee_en_bas_a_gauche,translation_d_alignement_des_parites_des_lignes);
INCR(ordonnee_en_haut_a_droite,translation_d_alignement_des_parites_des_lignes);
/* Alignement des parites des lignes de l'image sur celles de la fenetre... */
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
/* Deplacement en {X,Y} permettant de definir le coin en haut et a gauche d'une image par */
/* rapport au coin en haut et a gauche d'une fenetre. Ceci a ete introduit le 20000324094524 */
/* afin de permettre d'editer correctement les coordonnees d'un point d'une image visualisee */
/* dans une fenetre plus grande. En fait le code : */
/* */
/* EGAL(fenetre_X_Window_____deplacement_horizontal_en_haut_a_gauche_d_une_image */
/* ,CGXR(abscisse_en_bas_a_gauche) */
/* ); */
/* EGAL(fenetre_X_Window_____deplacement_vertical_en_haut_a_gauche_d_une_image */
/* ,LONGUEUR(SOUS(ASD1(dimension_non_normalisee_de_la_fenetre,dy) */
/* ,CGYR(ordonnee_en_haut_a_droite)) */
/* ) */
/* ); */
/* */
/* a ete supprime le 20000327093959 ('v $xiidX/fonct$vv$FON 20000327093959'). */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
CALS(lrectwrite(abscisse_en_bas_a_gauche,ordonnee_en_bas_a_gauche
,abscisse_en_haut_a_droite,ordonnee_en_haut_a_droite
,imageA
)
);
/* Display de l'image en "vraies couleurs" au milieu du plan de travail... */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
CALS(glRasterPos2i(abscisse_en_bas_a_gauche,ordonnee_en_bas_a_gauche));
/* Positionnement de l'image dans la fenetre... */
CALS(glGetIntegerv(GL_CURRENT_RASTER_POSITION,position_raster_courante));
/* Regardons le positionnement reellement effectue... */
Test(IFNE(mode_de_fonctionnement,MODE_BASSE_DEFINITION_PAL))
Bblock
Test(IFOU(IFNE(ITb1(position_raster_courante,INDX(GL_CURRENT_RASTER_X_POSITION,GL_CURRENT_RASTER_DEBUT_POSITION))
,abscisse_en_bas_a_gauche
)
,IFNE(ITb1(position_raster_courante,INDX(GL_CURRENT_RASTER_Y_POSITION,GL_CURRENT_RASTER_DEBUT_POSITION))
,ordonnee_en_bas_a_gauche
)
)
)
Bblock
PRINT_ERREUR("la position de l'image raster est differente de ce qui a ete demande");
CAL1(Prer2(" position demandee = (%d,%d)\n"
,abscisse_en_bas_a_gauche
,ordonnee_en_bas_a_gauche
)
);
CAL1(Prer2(" position obtenue = (%d,%d)\n"
,ITb1(position_raster_courante,INDX(GL_CURRENT_RASTER_X_POSITION,GL_CURRENT_RASTER_DEBUT_POSITION))
,ITb1(position_raster_courante,INDX(GL_CURRENT_RASTER_Y_POSITION,GL_CURRENT_RASTER_DEBUT_POSITION))
)
);
/* Notons que le trace aura quand meme lieu... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
/* En mode 'MODE_BASSE_DEFINITION_PAL', le test n'est pas fait, car, en effet, il est */
/* apparemment normal que cette erreur apparaisse (voir 'v $xiidG/$Fnota'). */
Eblock
ETes
CALS(glDrawPixels(dimX,dimY
,GL_RGBA
,GL_UNSIGNED_BYTE
,imageA
)
);
CALS(glFlush());
/* Display de l'image en "vraies couleurs" au milieu du plan de travail. On notera */
/* l'usage imperatif de 'GL_RGBA' et non pas de 'GL_RGBA' afin de rester compatible */
/* avec le type 'imageU' de 'imageA'... */
Test(IFET(EST_VRAI(IGdisplay_____on_peut_revisualiser_l_imageA_courante)
,IFNE(mode_de_fonctionnement,MODE_BASSE_DEFINITION_PAL)
)
)
/* Le test de 'MODE_BASSE_DEFINITION_PAL' a ete rajoute le 1996091100 car il est apparu */
/* que la possibilite de reaffichage des images sur l'ecran de la station de travail */
/* interferait dangereusement avec la fonction 'VLBEGINTRANSFER(...)' qui renvoie alors */
/* un code d'erreur, meme si le transfert a l'air de bien se passer. En effet, il doit */
/* alors y avoir une rerentree dans 'IGdisplay(...)'. D'ou cette interdiction... */
Bblock
Test(EST_FAUX(IGdisplay_____imageA_courante_visualisable))
/* Ce qui suit ne doit etre fait qu'apres le "premier" appel a 'IGdisplay(...)'. */
Bblock
CALS(IUmove(IGdisplay_____imageA_courante,imageA));
/* Et sauvegarde systematique de la derniere image affichee 'imageA'. On notera que l'on */
/* sauvegarde l'image elle-meme (et non pas son adresse) car, en effet, entre l'instant */
/* de cette sauvegarde et son eventuelle utilisation, l'image (en memoire) peut avoir */
/* changee, voire avoir disparue (son espace memoire ayant ete desalloue par exemple...). */
EGAL(IGdisplay_____imageA_courante_visualisable,VRAI);
/* A partir de maintenant, 'imageA' est "revisualisable", mais a condition d'aller ensuite */
/* dans une fonction du type 'IGattente_de_l_evenement_ButtonPress(...)'. */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ATes
Bblock
EGAL(IGdisplay_____imageA_courante_visualisable,FAUX);
/* On ne sait jamais... */
Eblock
ETes
# undef GL_CURRENT_RASTER_DEBUT_POSITION \
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# if ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
Choi(mode_de_fonctionnement)
Bblock
Ca1e(MODE_BASSE_DEFINITION_PAL)
Bblock
Test(EST_VRAI(la_connexion_video_pour_une_image_a_pu_etre_etablie))
Bblock
DEFV(Int,INIT(index_dans_l_image_courante,INDEX0));
/* Definition de l'index sequentiel de rangement dans l'image a sortir en video... */
Test(EST_VRAI(il_y_a_le_transfert_d_une_image_en_cours))
Bblock
CALS(VLPUTFREE(identite_du_serveur_video,buffer_des_images));
/* Pour faire "pendant" au 'VLGETNEXTVALID(...)' qui a precede... */
Test(PAS_D_ERREUR(VLENDTRANSFER(identite_du_serveur_video,chemin_emetteur_recepteur)))
/* Lorsqu'il y a un transfert en cours, on le termine avant de commencer le suivant... */
Bblock
Eblock
ATes
Bblock
PRINT_ERREUR("un transfert en cours ne peut etre interrompu");
Eblock
ETes
EGAL(il_y_a_le_transfert_d_une_image_en_cours,FAUX);
/* Et on memorise que c'est fini, meme si 'VLENDTRANSFER(...)' a echoue ; sinon, que faire */
/* d'autre ? */
Eblock
ATes
Bblock
Eblock
ETes
begin_colonneQ(DoDe,MIN2(Ymin,YminPal),MAX2(Ymax,YmaxPal),pasY)
Bblock
begin_ligneQ(DoIn,MIN2(Xmin,XminPal),MAX2(Xmax,XmaxPal),pasX)
Bblock
DEFV(deltaI_2D,translation_de_l_image_par_rapport_a_la_fenetre);
/* Definition de la translation de l'image Argument par rapport a la fenetre video. */
DEFV(pointI_2D,point_courant_de_l_image);
/* Definition du point courant de l'image Argument. */
DEFV(genere_LPositive,INIT(point_courant,UNDEF));
/* Point courant {X,Y} de l'image Argument. */
INITIALISATION_ACCROISSEMENT_2D(translation_de_l_image_par_rapport_a_la_fenetre
,MOYS(dimX,dimXPal)
,MOYS(dimY,dimYPal)
);
/* Calcul de la translation de l'image Argument par rapport a la fenetre video. */
EGAL(translation_d_alignement_des_parites_des_lignes
,CORRELATION_DES_PARITES_DE_LIGNES(YmaxPal
,ADD2(Ymax
,ASD1(translation_de_l_image_par_rapport_a_la_fenetre
,dy
)
)
)
);
/* Alignement des parites des lignes de l'image sur celles de la fenetre... */
INITIALISATION_POINT_2D(point_courant_de_l_image
,ADD2(X
,ASD1(translation_de_l_image_par_rapport_a_la_fenetre,dx)
)
,ADD3(Y
,ASD1(translation_de_l_image_par_rapport_a_la_fenetre,dy)
,translation_d_alignement_des_parites_des_lignes
)
);
/* Calcul du point courant de l'image Argument. */
Test(TEST_DANS_L_IMAGE(ASD1(point_courant_de_l_image,x),ASD1(point_courant_de_l_image,y)))
Bblock
EGAL(point_courant
,loadU_point(imageA,ASD1(point_courant_de_l_image,x),ASD1(point_courant_de_l_image,y))
);
/* Lorsque le point courant {X,Y} est dans l'image Argument, on le recupere... */
Eblock
ATes
Bblock
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
EGAL(point_courant,MULTIPLEXAGE_BVR_888(NOIR,NOIR,NOIR));
/* Lorsque le point courant {X,Y} n'est pas dans l'image Argument, on genere du NOIR... */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
EGAL(point_courant,MULTIPLEXAGE_RVBg_888(NOIR,NOIR,NOIR));
/* Lorsque le point courant {X,Y} n'est pas dans l'image Argument, on genere du NOIR... */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
Eblock
ETes
Test(IFET(IFINff(X,XminPal,XmaxPal)
,IFINff(Y,YminPal,YmaxPal)
)
)
Bblock
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
DEFV(genere_p,INIT(niveau_ROUGE,DEMULTIPLEXAGE_BVR_888_ROUGE(point_courant)));
DEFV(genere_p,INIT(niveau_VERTE,DEMULTIPLEXAGE_BVR_888_VERTE(point_courant)));
DEFV(genere_p,INIT(niveau_BLEUE,DEMULTIPLEXAGE_BVR_888_BLEUE(point_courant)));
/* Definition des trois composantes {R,V,B}... */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
DEFV(genere_p,INIT(niveau_ROUGE,DEMULTIPLEXAGE_RVBg_888_ROUGE(point_courant)));
DEFV(genere_p,INIT(niveau_VERTE,DEMULTIPLEXAGE_RVBg_888_VERTE(point_courant)));
DEFV(genere_p,INIT(niveau_BLEUE,DEMULTIPLEXAGE_RVBg_888_BLEUE(point_courant)));
/* Definition des trois composantes {R,V,B}... */
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# if ( (defined(BUG_SYSTEME_SGIND_VL_PACKING_RGB)) \
)
ENVOI_D_UN_NIVEAU_VIDEO_A_LA_CARTE_GALILEO(NOIR);
/* Lorsqu'il faut quatre octets au lieu de trois, il faut inserer un 'NOIR' devant le */
/* triplet {B,V,R}... */
# Aif ( (defined(BUG_SYSTEME_SGIND_VL_PACKING_RGB)) \
)
# Eif ( (defined(BUG_SYSTEME_SGIND_VL_PACKING_RGB)) \
)
ENVOI_D_UN_NIVEAU_VIDEO_A_LA_CARTE_GALILEO(niveau_BLEUE);
ENVOI_D_UN_NIVEAU_VIDEO_A_LA_CARTE_GALILEO(niveau_VERTE);
ENVOI_D_UN_NIVEAU_VIDEO_A_LA_CARTE_GALILEO(niveau_ROUGE);
/* Envoi des trois composantes chromatiques... */
Eblock
ATes
Bblock
Eblock
ETes
Eblock
end_ligneQ(EDoI)
Eblock
end_colonneQ(EDoD)
# if (nSYSTEM_RELEASE < 503000000)
# Aif (nSYSTEM_RELEASE < 503000000)
# Eif (nSYSTEM_RELEASE < 503000000)
# if (nSYSTEM_RELEASE >= 503000000)
CALS(VLPUTVALID(identite_du_serveur_video
,buffer_des_images
)
);
/* Declaration de la validite du contenu du buffer... */
# Aif (nSYSTEM_RELEASE >= 503000000)
# Eif (nSYSTEM_RELEASE >= 503000000)
EGAL(ASD1(descripteurs_de_transfert_d_images,mode),VL_TRANSFER_MODE_DISCRETE);
EGAL(ASD1(descripteurs_de_transfert_d_images,count),nombre_d_images_a_manipuler);
EGAL(ASD1(descripteurs_de_transfert_d_images,delay),ZERO);
# if (nSYSTEM_RELEASE < 503000000)
EGAL(ASD1(descripteurs_de_transfert_d_images,trigger),VLDeviceEvent);
# Aif (nSYSTEM_RELEASE < 503000000)
# Eif (nSYSTEM_RELEASE < 503000000)
# if (nSYSTEM_RELEASE >= 503000000)
EGAL(ASD1(descripteurs_de_transfert_d_images,trigger),VLTriggerImmediate);
# Aif (nSYSTEM_RELEASE >= 503000000)
# Eif (nSYSTEM_RELEASE >= 503000000)
Test(PAS_D_ERREUR(VLBEGINTRANSFER(identite_du_serveur_video
,chemin_emetteur_recepteur
,nombre_de_descripteurs_de_transfert_d_images
,ADRESSE(descripteurs_de_transfert_d_images)
)
)
)
/* Initialisation du transfert et transfert proprement dit... */
Bblock
EGAL(il_y_a_le_transfert_d_une_image_en_cours,VRAI);
/* Et on memorise un transfert en cours... */
Eblock
ATes
Bblock
PRINT_ERREUR("un transfert n'a pu etre initialise et lance");
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ECa1
Ca1e(MODE_HAUTE_DEFINITION)
Bblock
Eblock
ECa1
Defo
Bblock
PRINT_ERREUR("un mode de fonctionnement n'est pas reconnu");
Eblock
EDef
Eblock
ECho
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# if ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
Eblock
ATes
Bblock
PRINT_ERREUR("la fenetre n'est pas ouverte");
Eblock
ETes
RETU_ERROR;
Eblock
# if ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# undef ENVOI_D_UN_NIVEAU_VIDEO_A_LA_CARTE_GALILEO
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# if ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# undef CORRELATION_DES_PARITES_DE_LIGNES
# undef G_TRANSLATION_VERTICALE_DE_L_IMAGE
# undef G_TRANSLATION_HORIZONTALE_DE_L_IMAGE
# if ( (defined(BUG_SYSTEME_SG_GL_RAPPORT_DE_ZOOM_NON_ENTIER_DE_rectzoom)) \
)
# undef FACTEUR_DE_ZOOM
# Aif ( (defined(BUG_SYSTEME_SG_GL_RAPPORT_DE_ZOOM_NON_ENTIER_DE_rectzoom)) \
)
# undef FACTEUR_DE_ZOOM
# Eif ( (defined(BUG_SYSTEME_SG_GL_RAPPORT_DE_ZOOM_NON_ENTIER_DE_rectzoom)) \
)
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E B U T D E L A D I F F U S I O N D ' U N E S E Q U E N C E V I D E O T E M P S R E E L */
/* O U D E L A N U M E R I S A T I O N D ' U N E I M A G E D E C E L L E - C I : */
/* */
/*************************************************************************************************************************************/
BFonctionI
# ifdef __VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : VidAnal. */
# ifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02 /* Common,DEFV(Fonction,) : en 'VERSION_02'... */
# if ( (defined(BUG_SYSTEME_SGIND_VL_ENTREE_VIDEO_TEMPS_REEL_NON_GENLOCKEE)) \
)
# define SE_SYNCHRONISER_SUR_UNE_SOURCE_EXTERNE_EN_ENTREE_VIDEO \
NE_PAS_SYNCHRONISER_LA_CARTE_GALILEO_SUR_UNE_SOURCE_EXTERNE \
/* Definition des possibilites de synchronisation externes lors d'une entree video... */
# Aif ( (defined(BUG_SYSTEME_SGIND_VL_ENTREE_VIDEO_TEMPS_REEL_NON_GENLOCKEE)) \
)
# define SE_SYNCHRONISER_SUR_UNE_SOURCE_EXTERNE_EN_ENTREE_VIDEO \
SE_SYNCHRONISER_SUR_UNE_SOURCE_EXTERNE \
/* Definition des possibilites de synchronisation externes lors d'une entree video... */
# Eif ( (defined(BUG_SYSTEME_SGIND_VL_ENTREE_VIDEO_TEMPS_REEL_NON_GENLOCKEE)) \
)
# define VL_DEFAULT_SOURCE_ANALOG \
ZERO
# define VL_DEFAULT_SOURCE_DIGITAL_1 \
UN
# define VL_DEFAULT_SOURCE_DIGITAL_2 \
DEUX
/* Valeur qui semble manquer dans <vl/vl$h> et qui definissent la source par defaut de */
/* l'entree video ; ces informations ont ete obtenues grace a la commande : */
/* */
/* vlinfo -l */
/* */
/* en examinant les lignes : */
/* */
/* Name: default_input */
/* Type: 0 */
/* */
/* | */
/* | */
/* -----------> 'VL_DEFAULT_SOURCE' (dans '<vl/vl.h>') */
/* */
/* analog = 0 */
/* digital 1 = 1 */
/* digital 2 = 2 */
/* */
# define VL_MUXSWITCH_YsC_1 \
ZERO
# define VL_MUXSWITCH_YsC_2 \
UN
# define VL_MUXSWITCH_YsC_3 \
DEUX
# define VL_MUXSWITCH_COMPOSITE_1 \
TROIS
# define VL_MUXSWITCH_COMPOSITE_2 \
QUATRE
# define VL_MUXSWITCH_COMPOSITE_3 \
CINQ
# define VL_MUXSWITCH_Y_RmY_BmY_1 \
SIX
# define VL_MUXSWITCH_Y_RmY_BmY_2 \
SEPT
/* Valeur qui semble manquer dans <vl/vl$h> et qui definissent les sources possibles pour */
/* l'entree video ; ces informations ont ete obtenues grace a la commande : */
/* */
/* vlinfo -l */
/* */
/* en examinant les lignes : */
/* */
/* Name: switch */
/* Type: 20 */
/* */
/* || */
/* || */
/* ===========> 'VL_MUXSWITCH' (dans '<vl/vl.h>') */
/* */
/* Y/C (svideo) 1 = 0 */
/* Y/C (svideo) 2 = 1 */
/* Y/C (svideo) 3 = 2 */
/* composite 1 = 3 */
/* composite 2 = 4 */
/* composite 3 = 5 */
/* Y, R-Y, B-Y 1 = 6 */
/* Y, R-Y, B-Y 2 = 7 */
/* */
# define VL_MUXSWITCH_COMPOSITE \
VL_MUXSWITCH_COMPOSITE_1
DEFV(Common,DEFV(Int,SINT(SGI_____Gentree_video_utilisee,VL_MUXSWITCH_COMPOSITE)));
/* Definition de la source video utilisee... */
# if ( (defined(BUG_SYSTEME_SGIND_VL_VLDESTROYPATH_ENTREE_VIDEO_TEMPS_REEL)) \
)
# define VL_MUXSWITCH_COMPOSITE_DE_REPOS \
VL_MUXSWITCH_COMPOSITE_2 \
/* Definition de la source video implicite utilisee pour faire le "repos" (c'est-a-dire, */ \
/* etat a mettre en place a la fin de l'entree video temps reel). */
# Aif ( (defined(BUG_SYSTEME_SGIND_VL_VLDESTROYPATH_ENTREE_VIDEO_TEMPS_REEL)) \
)
# Eif ( (defined(BUG_SYSTEME_SGIND_VL_VLDESTROYPATH_ENTREE_VIDEO_TEMPS_REEL)) \
)
# ifdef BUG_SYSTEME_SGIND_VL_VLDESTROYPATH_ENTREE_VIDEO_TEMPS_REEL /* Common,DEFV(Fonction,) : BUG. */
DEFV(Common,DEFV(Int,SINT(SGI_____Gentree_video_de_repos,VL_MUXSWITCH_COMPOSITE_DE_REPOS)));
/* Definition de la source video utilisee pour faire le "repos" (c'est-a-dire, etat a */
/* mettre en place a la fin de l'entree video temps reel) ; ceci a ete introduit, car */
/* dans 'IGfin_de_diffusion_ou_de_numerisation_d_une_sequence_video(...)', malgre le */
/* 'VLDESTROYPATH(...)', on continue a voir sur les sorties composite 'Pal' (bien qu'avec */
/* du jitter) et 'RVB' la video entrante (voir les commentaires concernant l'utilisation */
/* de 'SGI_____Gentree_video_de_repos'). */
# Aifdef BUG_SYSTEME_SGIND_VL_VLDESTROYPATH_ENTREE_VIDEO_TEMPS_REEL /* Common,DEFV(Fonction,) : BUG. */
# Eifdef BUG_SYSTEME_SGIND_VL_VLDESTROYPATH_ENTREE_VIDEO_TEMPS_REEL /* Common,DEFV(Fonction,) : BUG. */
# Aifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02 /* Common,DEFV(Fonction,) : en 'VERSION_02'... */
# Eifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02 /* Common,DEFV(Fonction,) : en 'VERSION_02'... */
# ifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# define VL_TBCMODE \
VL_EV1_TBC_MODE \
/* Valeur definie dans <vl/dev_ev1$h> et qui correspond au bouton "Synchronizer Mode" */ \
/* de la commande 'videopanel' ; il permet lorsqu'il est TRUE de stabiliser l'image... */ \
/* On notera enfin que : */ \
/* */ \
/* 1163264039 = 0x45560027 */ \
/* */ \
/* afin de permettre de lire les sorties de 'vlinfo -l'. */
# define VL_QUALITY \
VL_EV1_QUALITY \
/* Valeur definie dans <vl/dev_ev1$h> et qui correspond au bouton "Lock to VTR" */ \
/* de la commande 'videopanel' ; il permet lorsqu'il est TRUE de stabiliser l'image... */ \
/* On notera enfin que : */ \
/* */ \
/* 1163264023 = 0x45560017 */ \
/* */ \
/* afin de permettre de lire les sorties de 'vlinfo -l'. */ \
/* */ \
/* ATTENTION : le controle 'VL_QUALITY' est applique a 'identite_du_noeud_emetteur' lors */ \
/* 'IGdebut_de_diffusion_ou_de_numerisation_d_une_sequence_video(...)'. Il pourrait etre */ \
/* utilise aussi lors de 'IGopen(...)' pour 'identite_du_noeud_recepteur'. Mais alors on */ \
/* peut constater parfois une degradation de la qualite lors des entrees qui suivent : des */ \
/* franges horizontales d'une vingtaine de pixels peuvent alors apparaitre a droite des */ \
/* images... */
# define VL_PREFILTER \
VL_EV1_PREFILTER
# define VL_FILTER \
VL_EV1_FILTER
/* Valeurs definies dans <vl/dev_ev1$h> et qui sont necessaires a garantir la */
/* meilleure qualite possible d'image... */
/* On notera enfin que : */
/* */
/* 1163264027 = 0x4556001b */
/* 1163264022 = 0x45560016 */
/* */
/* afin de permettre de lire les sorties de 'vlinfo -l'. */
# Aifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# Eifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# ifdef GESTION_DE_L_OPTION_GALILEO_VERSION_01
# define PASSAGE_FORMAT_VIDEO_FORMAT_X_WINDOW_X \
NEUT(TRENTE_DEUX)
# define PASSAGE_FORMAT_VIDEO_FORMAT_X_WINDOW_Y \
NEUT(ZERO)
/* Increment permettant de passer de la taille de la fenetre video a la taille de la */
/* fenetre 'X-Window' necessaire... */
# define DECALAGE_1_VIDEO_DANS_LA_FENETRE_X_WINDOW_X \
NEUT(ZERO)
# define DECALAGE_1_VIDEO_DANS_LA_FENETRE_X_WINDOW_Y \
NEUT(ZERO)
/* Decalage du signal video dans la fenetre video... */
# define DECALAGE_2_VIDEO_DANS_LA_FENETRE_X_WINDOW_X \
NEUT(ZERO)
# define DECALAGE_2_VIDEO_DANS_LA_FENETRE_X_WINDOW_Y \
NEUT(UN)
/* Decalage de la fenetre video dans la fenetre 'X-Window'... */
# Aifdef GESTION_DE_L_OPTION_GALILEO_VERSION_01
# Eifdef GESTION_DE_L_OPTION_GALILEO_VERSION_01
# ifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# define PASSAGE_FORMAT_VIDEO_FORMAT_X_WINDOW_X \
NEUT(TRENTE_DEUX)
# define PASSAGE_FORMAT_VIDEO_FORMAT_X_WINDOW_Y \
NEGA(QUATRE)
/* Increment permettant de passer de la taille de la fenetre video a la taille de la */
/* fenetre 'X-Window' necessaire. */
/* */
/* On notera le '-4' sans lequel un effet "Larsen" apparait en haut de la fenetre (sur 4 */
/* lignes) ; en l'absence de ce decalage vertical, pour le faire disparaitre, il suffit */
/* que la fenetre "sous-jacente" depuis laquelle on lance la commande 'video' (par exemple) */
/* soit nettoyee par un 'clear'. Si besoin est (et par exemple a des fins demonstratives), */
/* cet effet peut etre "active" a l'aide d'une commande du type : */
/* */
/* video d2y=100 */
/* */
/* qui donne (dans ce cas) l'effet Larsen dans la partie superieure de la fenetre... */
# define DECALAGE_1_VIDEO_DANS_LA_FENETRE_X_WINDOW_X \
NEUT(ZERO)
# define DECALAGE_1_VIDEO_DANS_LA_FENETRE_X_WINDOW_Y \
NEUT(ZERO)
/* Decalage du signal video dans la fenetre video... */
# if (nSYSTEM_RELEASE < 503000000)
# define DECALAGE_2_VIDEO_DANS_LA_FENETRE_X_WINDOW_X \
NEUT(DEUX)
# Aif (nSYSTEM_RELEASE < 503000000)
# Eif (nSYSTEM_RELEASE < 503000000)
# if (nSYSTEM_RELEASE >= 503000000)
# define DECALAGE_2_VIDEO_DANS_LA_FENETRE_X_WINDOW_X \
NEUT(ADD2(SEIZE,DEUX))
# Aif (nSYSTEM_RELEASE >= 503000000)
# Eif (nSYSTEM_RELEASE >= 503000000)
# define DECALAGE_2_VIDEO_DANS_LA_FENETRE_X_WINDOW_Y \
NEUT(UN)
/* Decalage de la fenetre video dans la fenetre 'X-Window'... */
/* */
/* On notera le '+1' associe au '-4' ci-dessus. De plus, il a ete utilise pendant */
/* longtemps : */
/* */
/* # define DECALAGE_2_VIDEO_DANS_LA_FENETRE_X_WINDOW_X \ */
/* NEUT(QUATORZE) */
/* */
/* mais l'introduction de la fonction 'Iredimensionnement(...)', qui permet de generer */
/* des images "plein-ecran", a montre que cela decalait trop les images a droite... */
# Aifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# Eifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
DEFV(Common,DEFV(Int,SINT(SGI_____fenetre_X_WINDOW_decalage_2_video_X,DECALAGE_2_VIDEO_DANS_LA_FENETRE_X_WINDOW_X)));
DEFV(Common,DEFV(Int,SINT(SGI_____fenetre_X_WINDOW_decalage_2_video_Y,DECALAGE_2_VIDEO_DANS_LA_FENETRE_X_WINDOW_Y)));
/* Decalage de la fenetre video dans la fenetre 'X-Window'... */
# define NUMERATEUR_1_DU_RAPPORT_DE_ZOOM \
UN
# define NUMERATEUR_2_DU_RAPPORT_DE_ZOOM \
DEUX
# define NUMERATEUR_4_DU_RAPPORT_DE_ZOOM \
QUATRE
/* Definition des numerateurs possibles pour le rapport de zoom. */
# define DENOMINATEUR_1_DU_RAPPORT_DE_ZOOM \
UN
# define DENOMINATEUR_n_DU_RAPPORT_DE_ZOOM \
HUIT
/* Definition de la "fourchette" des denominateurs possibles pour le rapport de zoom. */
# define NUMERATEUR_DU_RAPPORT_DE_ZOOM \
NUMERATEUR_1_DU_RAPPORT_DE_ZOOM
# define DENOMINATEUR_DU_RAPPORT_DE_ZOOM \
DENOMINATEUR_1_DU_RAPPORT_DE_ZOOM
DEFV(Common,DEFV(Int,SINT(SGI_____numerateur_du_rapport_de_zoom,NUMERATEUR_DU_RAPPORT_DE_ZOOM)));
DEFV(Common,DEFV(Int,SINT(SGI_____denominateur_du_rapport_de_zoom,DENOMINATEUR_DU_RAPPORT_DE_ZOOM)));
/* Definition du rapport de zoom en tant que rapport : */
/* */
/* numerateur */
/* zoom = -------------- */
/* denominateur */
/* */
/* ceci ne pouvant s'appliquer qu'a 'identite_du_noeud_recepteur' qui est un noeud de type */
/* 'VL_SCREEN'... */
# define MISE_A_L_ECHELLE_DES_DECALAGES_X_WINDOW(decalage) \
INTE(MUL2(decalage \
,ADD2(FU \
,RACX(SOUS(EXP2(SOUS(DENOMINATEUR_n_DU_RAPPORT_DE_ZOOM \
,DENOMINATEUR_1_DU_RAPPORT_DE_ZOOM \
) \
) \
,EXP2(SOUS(SGI_____denominateur_du_rapport_de_zoom \
,DENOMINATEUR_n_DU_RAPPORT_DE_ZOOM \
) \
) \
) \
) \
) \
) \
) \
/* Fonction de mise a l'echelle des decalages 'X-Window' en fonction du rapport courant */ \
/* de zoom. Cette formule est tout a fait heuristique et son fonctionnement n'est garanti */ \
/* que pour les reductions ; c'est la raison pour laquelle on interdit dorenavant les zooms */ \
/* de rapports superieurs a 1 (d'ailleurs, ils etaient de tres mauvaise qualite...). */
DEFV(Common,DEFV(Int,SINT(SGI_____mode_de_numerisation_des_images,VL_CAPTURE_INTERLEAVED)));
/* Definition du mode de numerisation des images ; les possibilites suivantes sont */
/* disponibles : */
/* */
/* VL_CAPTURE_NONINTERLEAVED (0) */
/* VL_CAPTURE_INTERLEAVED (1) */
/* VL_CAPTURE_EVEN_FIELDS (2) */
/* VL_CAPTURE_ODD_FIELDS (3) */
/* */
/* ce qui est donne dans '/usr/include/vl/vl.h'. */
DEFV(Common,DEFV(Int,SINT(SGI_____nombre_d_images_a_ignorer_avant_d_en_numeriser_une,GRO6(FREQUENCE_DE_BALAYAGE_DES_IMAGES))));
/* Definition du nombre d'images a ignorer avant d'en numeriser une ; ce parametre est */
/* rendu necessaire par le fait que lors d'une entree video, la stabilisation des couleurs */
/* demande plusieurs secondes (apparemment, il en faut au moins 5...). */
# ifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
DEFV(Local,DEFV(G_VLBuffer,buffer_alloue_pour_la_numerisation));
/* Buffer a allouer par le serveur pour numeriser une image. */
# Aifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# Eifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
DEFV(Local,DEFV(FonctionI,IGdebut_de_diffusion_ou_de_numerisation_d_une_sequence_video(nom_variable_shell_serveur_ecran
,nom_de_la_fenetreA
,centrer_la_fenetre_video_temps_reel
,ARGUMENT_POINTERs(coin_bas_gauche)
,editer_les_PRINT_ATTENTION_initiaux
,diffuser_sequence_sinon_numeriser_image
)
)
)
DEFV(Argument,DEFV(CHAR,DTb0(nom_variable_shell_serveur_ecran)));
/* Nom de la variable shell d'acces au nom du serveur et de l'ecran ; en general, ce sera */
/* celui qui est defini par la variable 'DEFINITION_DU_SERVEUR_X_WINDOW'. */
DEFV(Argument,DEFV(CHAR,DTb0(nom_de_la_fenetreA)));
/* Nom de la fenetre a ouvrir. */
DEFV(Argument,DEFV(Logical,centrer_la_fenetre_video_temps_reel));
/* Faut-il centrer la fenetre video temps reel ('VRAI') ou bien donner explicitement la */
/* position de son coin "bas gauche" ('FAUX') ? */
DEFV(Argument,DEFV(pointF_2D,POINTERs(coin_bas_gauche)));
/* Abscisse du point de reference, */
DEFV(Argument,DEFV(Logical,editer_les_PRINT_ATTENTION_initiaux));
/* Indique si les messages initiaux du type 'PRINT_ATTENTION(...)' doivent etre emis */
/* ('VRAI') ou pas ('FAUX'). */
DEFV(Argument,DEFV(Logical,diffuser_sequence_sinon_numeriser_image));
/* Indique si l'on diffuse une sequence, ou bien dans le cas contraire, si l'on numerise */
/* une seule image. */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/* ATTENTION : 'INIT_ERROR' est mis en tete des variables locales au cas ou des couples */
/* ('BDEFV','EDEFV') suivraient... */
DEFV(Logical,INIT(essayer_d_etablir_la_connexion,VRAI));
/* A priori, il va falloir essayer d'etablir la connexion... */
DEFV(Logical,INIT(une_erreur_forcant_l_iteration_a_ete_rencontree,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION));
/* A priori, il n'y a pas encore eu d'erreur forcant l'iteration... */
DEFV(Int,INIT(nombre_de_tentatives_d_etablissement_de_connexion,NOMBRE_DE_TENTATIVES_DE_CONNEXION_VIDEO));
/* Mais on ne pourra pas essayer une infinite de fois... */
DEFV(G_VLDevList,liste_des_devices_disponibles);
/* Liste des "device"s disponibles sur le serveur video... */
DEFV(Int,INIT(numero_du_device_a_utiliser,DEMANDE_D_UN_DEVICE_INDIFFERENT));
/* Numero du "device" (indifferent...) a utiliser... */
DEFV(Int,INIT(nombre_de_chemins_a_etablir,UN));
/* Nombre de chemins a etablir (entre les "noeud"s emetteur et recepteur). */
DEFV(deltaF_2D,dimension_de_la_fenetre);
/* Dimension horizontale de la fenetre, */
# ifdef GESTION_DE_L_OPTION_GALILEO_VERSION_01
DEFV(Int,INIT(nombre_de_descripteurs_de_transfert_d_images,ZERO));
/* Nombre de transferts d'images a effectuer... */
# Aifdef GESTION_DE_L_OPTION_GALILEO_VERSION_01
# Eifdef GESTION_DE_L_OPTION_GALILEO_VERSION_01
# ifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
DEFV(Int,INIT(nombre_de_descripteurs_de_transfert_d_images,UN));
/* Nombre de transferts d'images a effectuer... */
DEFV(Int,INIT(nombre_d_images_a_manipuler,UNDEF));
/* Nombre d'images a manipuler... */
DEFV(G_VLTransferDescriptor,descripteurs_de_transfert_d_images);
/* Descripteurs des transferts d'images... */
# Aifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# Eifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
/*..............................................................................................................................*/
EGAL(la_connexion_video_pour_une_sequence_video_temps_reel_a_pu_etre_etablie,FAUX);
/* A priori, la connexion video demandee ne va pas etre etablie... */
# ifdef GESTION_DE_L_OPTION_GALILEO_VERSION_01
PRINT_ATTENTION("il manque la programmation du choix des sources videos et de synchronisation, ainsi que leur parametrage");
# Aifdef GESTION_DE_L_OPTION_GALILEO_VERSION_01
# Eifdef GESTION_DE_L_OPTION_GALILEO_VERSION_01
# ifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# Aifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# Eifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# if ( (defined(BUG_SYSTEME_SGIND_VL_ENTREE_VIDEO_TEMPS_REEL_NON_GENLOCKEE)) \
)
Test(IL_FAUT(SGI_____se_synchroniser_sur_une_source_externe))
Bblock
PRINT_ATTENTION("il est provisoirement plus simple et plus prudent de ne pas 'genlocker' les entrees videos temps reel");
Eblock
ATes
Bblock
Eblock
ETes
# Aif ( (defined(BUG_SYSTEME_SGIND_VL_ENTREE_VIDEO_TEMPS_REEL_NON_GENLOCKEE)) \
)
# Eif ( (defined(BUG_SYSTEME_SGIND_VL_ENTREE_VIDEO_TEMPS_REEL_NON_GENLOCKEE)) \
)
Tant(IFET(IL_FAUT(essayer_d_etablir_la_connexion)
,IZGT(nombre_de_tentatives_d_etablissement_de_connexion)
)
)
Bblock
Test(IFEQ(nombre_de_tentatives_d_etablissement_de_connexion,NOMBRE_DE_TENTATIVES_DE_CONNEXION_VIDEO))
/* Cas de la premiere tentative : il n'y a rien a faire... */
Bblock
Eblock
ATes
/* Cas des tentatives ulterieures : il faut annuler certaines des initialisations realisees */
/* a la tentative precedente... */
Bblock
CALS(VLDESTROYPATH(identite_du_serveur_video
,chemin_emetteur_recepteur
)
);
/* Destruction du chemin entre l'emetteur et le recepteur... */
Test(PAS_D_ERREUR(VLCLOSEVIDEO(identite_du_serveur_video)))
/* Enfin, fermeture de la connexion video... */
Bblock
Eblock
ATes
Bblock
PRINT_ERREUR("la fermeture de la connexion video est impossible (1)");
Eblock
ETes
Eblock
ETes
DECR(nombre_de_tentatives_d_etablissement_de_connexion,I);
/* Et une tentative de moins... */
EGAL(identite_du_serveur_video,VLOPENVIDEO(NOM_DU_SERVEUR_VIDEO_DE_L_OPTION_GALILEO));
/* Tentative d'ouverture de la connexion video. */
Test(IFNE(identite_du_serveur_video,POINTEUR_SUR_UN_OBJET_GALILEO_INEXISTANT))
Bblock
REINITIALISATION_DE_LA_CARTE_GALILEO(identite_du_serveur_video);
/* Reinitialisation de la carte (voir 'REINITIALISATION_DE_LA_CARTE_GALILEO(...)' et ses */
/* commentaires...). */
/* */
/* ATTENTION, tant qu'il y a des problemes avec les deux controles 'VL_DEFAULT_SOURCE' et */
/* 'VL_SYNC', il est imperatif de passer par 'VLRESTORESYSTEMDEFAULTS(...)' qui fait des */
/* initialisations "impossibles" et necessaires ici pour les 'PARAMETRAGE_NOEUD_1(...)' */
/* qui suivent (et en particulier ceux qui sont relatifs a 'VL_MUXSWITCH', 'VL_TBCMODE', */
/* 'VL_QUALITY', 'VL_PREFILTER' et 'VL_FILTER') ne seraient pas acceptes la premiere fois */
/* apres avoir change la 'VL_DEFAULT_SOURCE' "a la main" (par exemple a l'aide de la */
/* commande 'videopanel') ; en effet, on peut observer grace a 'v $xtc/SGI_G.520.42$c' */
/* qu'alors le nombre de controles reconnus n'est que de 18 (au lieu de 41) en temps normal. */
/* Il est donc important de maintenir a jour, en cas de nouvelle release du systeme par */
/* exemple, le fichier '/usr/etc/video/videod.defaults'. */
Test(IZGE(VLGETDEVICELIST(identite_du_serveur_video,ADRESSE(liste_des_devices_disponibles))))
Bblock
Test(IFOU(IFEQ(numero_du_device_a_utiliser,DEMANDE_D_UN_DEVICE_INDIFFERENT)
,IFET(IFNE(numero_du_device_a_utiliser,DEMANDE_D_UN_DEVICE_INDIFFERENT)
,IFLT(numero_du_device_a_utiliser
,INTE(ASD1(liste_des_devices_disponibles,numDevices))
)
)
)
)
Bblock
EGAL(identite_du_noeud_emetteur
,VLGETNODE(identite_du_serveur_video,VL_SRC,VL_VIDEO,VL_ANY)
);
/* Definition du noeud emetteur (c'est-a-dire la "video"). */
EGAL(identite_du_noeud_device
,VLGETNODE(identite_du_serveur_video,VL_DEVICE,VL_DOIT_ETRE_NUL,VL_DOIT_ETRE_NUL)
);
/* Definition du noeud "device"... */
Test(IL_FAUT(diffuser_sequence_sinon_numeriser_image))
Bblock
EGAL(identite_du_noeud_recepteur
,VLGETNODE(identite_du_serveur_video,VL_DRN,VL_SCREEN,VL_ANY)
);
/* Definition du noeud recepteur (c'est-a-dire la "fenetre X11"). */
Eblock
ATes
Bblock
EGAL(identite_du_noeud_recepteur
,VLGETNODE(identite_du_serveur_video,VL_DRN,VL_MEM,VL_ANY)
);
/* Definition du noeud recepteur (c'est-a-dire le buffer de numerisation de l'image). */
Eblock
ETes
EGAL(chemin_emetteur_recepteur
,VLCREATEPATH(identite_du_serveur_video
,COND(IFEQ(numero_du_device_a_utiliser,DEMANDE_D_UN_DEVICE_INDIFFERENT)
,VL_ANY
,numero_du_device_a_utiliser
)
,identite_du_noeud_emetteur
,identite_du_noeud_recepteur
)
);
/* Etablissement d'un chemin entre les "noeud"s emetteur et recepteur... */
Test(PAS_D_ERRORS(chemin_emetteur_recepteur))
Bblock
CALS(VLADDNODE(identite_du_serveur_video
,chemin_emetteur_recepteur
,identite_du_noeud_emetteur
)
);
CALS(VLADDNODE(identite_du_serveur_video
,chemin_emetteur_recepteur
,identite_du_noeud_device
)
);
CALS(VLADDNODE(identite_du_serveur_video
,chemin_emetteur_recepteur
,identite_du_noeud_recepteur
)
);
/* Operation dont je ne comprends pas bien l'utilite, mais essentiel si l'on veut que le */
/* controle 'VL_DEFAULT_SOURCE' soit pris en compte... */
EGAL(numero_du_device_a_utiliser
,VLGETDEVICE(identite_du_serveur_video
,chemin_emetteur_recepteur
)
);
/* Recuperation du "device" reellement utilise (lorsque 'DEMANDE_D_UN_DEVICE_INDIFFERENT' */
/* n'est pas utilise...), */
EGAL(nom_du_device_reellement_utilise
,ASD1(ITb1(ASD1(liste_des_devices_disponibles,devices)
,numero_du_device_a_utiliser
)
,name
)
);
/* Et de son nom au cas ou... */
Test(PAS_D_ERREUR(VLSETUPPATHS(identite_du_serveur_video
,Cast_G_VLPathList(ADRESSE(chemin_emetteur_recepteur))
,nombre_de_chemins_a_etablir
,VL_SHARE
,VL_READ_ONLY
)
)
)
/* Preparation du hardware pour permettre l'usage des controles et des flots d'informations. */
/* */
/* ATTENTION, on notera les deux valeurs tres particulieres suivantes : */
/* */
/* VL_SHARE : destinee a pouvoir refaire un peu plus loin un autre 'VLSETUPPATHS(...)' */
/* sans avoir le desagreable message suivant : */
/* */
/* VL connection to :0.0 broken (explicit kill or server shutdown). */
/* */
/* et : */
/* */
/* VL_READ_ONLY : qui permet (enfin...) d'utiliser le controle 'VL_SYNC' (ci-dessous) */
/* sans avoir le desagreable message suivant : */
/* */
/* Bad access to the library */
/* */
/* tout cela m'ayant fait perdre pas mal de temps... */
Bblock
CALS(VLSELECTEVENTS(identite_du_serveur_video
,chemin_emetteur_recepteur
,LISTE_DES_EVENEMENTS_A_DETECTER
)
);
/* Selection des evenements a detecter... */
PARAMETRAGE_NOEUD_1(identite_du_noeud_device
,intVal
,VL_DEFAULT_SOURCE_ANALOG
,VL_DEFAULT_SOURCE
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
/* Selection de l'entree par defaut... */
PARAMETRAGE_NOEUD_1(identite_du_noeud_device
,intVal
,VL_TIMING_625_SQ_PIX
,VL_TIMING
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_DOIT_FORCER_L_ITERATION
);
# ifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
CHOIX_DE_LA_SOURCE_DE_SYNCHRONISATION_EXTERNE;
/* Choix et validation de la source de synchronisation externe... */
# Aifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# Eifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
PARAMETRAGE_NOEUD_1(identite_du_noeud_device
,intVal
,COND(IL_FAUT(SE_SYNCHRONISER_SUR_UNE_SOURCE_EXTERNE_EN_ENTREE_VIDEO)
,VL_SYNC_GENLOCK
,VL_SYNC_INTERNAL
)
,VL_SYNC
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
/* Parametrage du type de synchronisation et de la source "genlock" utilisee. On notera */
/* l'utilisation de 'identite_du_noeud_device' (et non pas de 'identite_du_noeud_recepteur') */
/* pour les controles 'VL_SYNC' et 'VL_SYNC_SOURCE'... */
/* */
/* ATTENTION, lorsque l'on est en 'VL_SYNC_GENLOCK' la sortie 'Pal' ("composite") de la */
/* carte 'Galileo' ne fonctionne pas correctement ; en particulier on perd la couleur... */
/* */
/* ATTENTION, cette mise en place de 'VL_SYNC' est lie au nouveau branchement du moniteur */
/* 'RVB'. En effet, il recoit maintenant comme signal de synchronisation la synchronisation */
/* externe dit "genlock". Lors de l'entree video temps reel, il faut que l'image qu'il */
/* diffuse soit stable ; d'ou 'CHOIX_DE_LA_SOURCE_DE_SYNCHRONISATION_EXTERNE' et la mise */
/* en place du controle 'VL_SYNC' qui ont ete ajoutes... Cela a donc aussi demande que le */
/* chemin soit d'abord etabli en mode {VL_SHARE,VL_READ_ONLY} afin de mettre en place ces */
/* controles, puis de passer ci-apres en mode {VL_LOCK,VL_LOCK}... */
MISE_DU_CHEMIN_EN_MODE_LOCK_LOCK;
/* Preparation du hardware pour permettre l'usage des controles et des flots d'informations. */
/* L'usage ici choisit est le mode exclusif ('VL_LOCK'). On notera que 'VLSETUPPATHS(...)' */
/* est obligatoire a cause du mode {VL_SHARE,VL_READ_ONLY} impose precedemment et ce afin */
/* de permettre le controle 'VL_SYNC'... */
/* */
/* On notera au passage que l'ensemble du code qui suit devrait etre place a l'interieur */
/* de la premiere alternative du 'Test(...)' de 'MISE_DU_CHEMIN_EN_MODE_LOCK_LOCK'. Mais */
/* cela n'est pas fait car il faudrait alors le retabuler, or il y a des lignes tres */
/* longues... */
# ifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
Test(I3ET(IFNE(SGI_____Gentree_video_utilisee,VL_MUXSWITCH_COMPOSITE_1)
,IFNE(SGI_____Gentree_video_utilisee,VL_MUXSWITCH_COMPOSITE_2)
,IFNE(SGI_____Gentree_video_utilisee,VL_MUXSWITCH_COMPOSITE_3)
)
)
Bblock
PRINT_ERREUR("l'entree video demandee n'est pas reconnue (entree implicite forcee)");
EGAL(SGI_____Gentree_video_utilisee,VL_MUXSWITCH_COMPOSITE);
Eblock
ATes
Bblock
Eblock
ETes
PARAMETRAGE_NOEUD_1(identite_du_noeud_emetteur
,intVal
,SGI_____Gentree_video_utilisee
,VL_MUXSWITCH
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_DOIT_FORCER_L_ITERATION
);
/* C'est principalement a cause du controle 'VL_MUXSWITCH' qu'a ete introduit l'argument */
/* 'iter' des procedures 'PARAMETRAGE_NOEUD_?(...)' afin de permettre sa prise en compte */
/* correcte lors d'un changement effectif du controle 'VL_DEFAULT_SOURCE'... */
# Aifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# Eifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
/* Parametrage des frequences et de l'entree utilisee... */
nPARAMETRAGE_NOEUD_1(identite_du_noeud_emetteur
,intVal
,VL_FORMAT_COMPOSITE
,VL_FORMAT
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_DOIT_FORCER_L_ITERATION
);
nPARAMETRAGE_NOEUD_1(identite_du_noeud_emetteur
,intVal
,FORMAT_DE_PACKING_DES_POINTS_VIDEO
,VL_PACKING
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_DOIT_FORCER_L_ITERATION
);
/* Parametrage du format des images. On notera que le controle 'VL_FORMAT' est parait-il */
/* inutile car l'entree selectionnee peu avant par 'SGI_____Gentree_video_utilisee' est */
/* de type 'VL_MUXSWITCH_COMPOSITE_?'... */
nPARAMETRAGE_NOEUD_1(identite_du_noeud_emetteur
,intVal
,SGI_____mode_de_numerisation_des_images
,VL_CAP_TYPE
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_DOIT_FORCER_L_ITERATION
);
/* Parametrage du format des images. On notera que le controle 'VL_CAP_TYPE' est apparemment */
/* interdit avec le type du noeud 'identite_du_noeud_emetteur' (et qu'il est seul autorise */
/* avec des noeuds de type 'VL_MEM' et 'VL_SCREEN'...). */
# ifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
PARAMETRAGE_NOEUD_1(identite_du_noeud_emetteur
,intVal
,TRUE
,VL_TBCMODE
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_DOIT_FORCER_L_ITERATION
);
PARAMETRAGE_NOEUD_1(identite_du_noeud_emetteur
,intVal
,TRUE
,VL_QUALITY
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_DOIT_FORCER_L_ITERATION
);
PARAMETRAGE_NOEUD_1(identite_du_noeud_emetteur
,intVal
,TRUE
,VL_PREFILTER
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_DOIT_FORCER_L_ITERATION
);
PARAMETRAGE_NOEUD_1(identite_du_noeud_emetteur
,intVal
,TRUE
,VL_FILTER
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_DOIT_FORCER_L_ITERATION
);
/* Choix de la meilleure qualite d'image possible. On notera l'utilisation de 'TRUE' (et non */
/* pas de 'VRAI') afin de garantir la portabilite... */
# Aifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# Eifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
Test(IL_FAUT(diffuser_sequence_sinon_numeriser_image))
Bblock
Test(I3OU(I3ET(IFNE(SGI_____numerateur_du_rapport_de_zoom,NUMERATEUR_1_DU_RAPPORT_DE_ZOOM)
,IFNE(SGI_____numerateur_du_rapport_de_zoom,NUMERATEUR_2_DU_RAPPORT_DE_ZOOM)
,IFNE(SGI_____numerateur_du_rapport_de_zoom,NUMERATEUR_4_DU_RAPPORT_DE_ZOOM)
)
,IFEXff(SGI_____denominateur_du_rapport_de_zoom
,DENOMINATEUR_1_DU_RAPPORT_DE_ZOOM
,DENOMINATEUR_n_DU_RAPPORT_DE_ZOOM
)
,IFOU(IFEQ(SGI_____numerateur_du_rapport_de_zoom,NUMERATEUR_2_DU_RAPPORT_DE_ZOOM)
,IFEQ(SGI_____numerateur_du_rapport_de_zoom,NUMERATEUR_4_DU_RAPPORT_DE_ZOOM)
)
)
)
/* Nota : 'NUMERATEUR_2_DU_RAPPORT_DE_ZOOM' et 'NUMERATEUR_4_DU_RAPPORT_DE_ZOOM' sont */
/* elimines a cause de la fonction de 'MISE_A_L_ECHELLE_DES_DECALAGES_X_WINDOW(...) qui */
/* a ete introduite pour cadrer correctement la video quel que soit le rapport de zoom ; */
/* d'autre part, les agrandissements (rapport>1) etaient de tres mauvaise qualite... */
Bblock
PRINT_ERREUR("le rapport de zoom demande n'est pas reconnu (zoom implicite force)");
CAL1(Prer2(" zoom = %d/%d\n"
,SGI_____numerateur_du_rapport_de_zoom,SGI_____denominateur_du_rapport_de_zoom
)
);
EGAL(SGI_____numerateur_du_rapport_de_zoom,NUMERATEUR_DU_RAPPORT_DE_ZOOM);
EGAL(SGI_____denominateur_du_rapport_de_zoom,DENOMINATEUR_DU_RAPPORT_DE_ZOOM);
Eblock
ATes
Bblock
Eblock
ETes
PARAMETRAGE_NOEUD_2(identite_du_noeud_recepteur
,fractVal
,numerator
,SGI_____numerateur_du_rapport_de_zoom
,denominator
,SGI_____denominateur_du_rapport_de_zoom
,VL_ZOOM
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_DOIT_FORCER_L_ITERATION
);
/* Parametrage du rapport de zoom (qui ne peut se faire, rappelons-le, que sur un noeud */
/* du type 'VL_SCREEN'). */
Eblock
ATes
Bblock
PARAMETRAGE_NOEUD_1(identite_du_noeud_recepteur
,intVal
,FORMAT_DE_PACKING_DES_POINTS_VIDEO
,VL_PACKING
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_DOIT_FORCER_L_ITERATION
);
/* Programmation du format des pixels apres la numerisation... */
Eblock
ETes
Test(IL_FAUT(diffuser_sequence_sinon_numeriser_image))
Bblock
/* Cas de la diffusion d'une sequence : */
CALS(VLGETCONTROL(identite_du_serveur_video
,chemin_emetteur_recepteur
,identite_du_noeud_recepteur
,VL_SIZE
,ADRESSE(parametres_courants)
)
);
/* Recuperation de la taille de la fenetre video, */
INITIALISATION_ACCROISSEMENT_2D
(dimension_de_la_fenetre
,_____lNORMALISE_OX11(ADD2(ASD2(parametres_courants,xyVal,x)
,PASSAGE_FORMAT_VIDEO_FORMAT_X_WINDOW_X
)
)
,_____lNORMALISE_OY11(ADD2(ASD2(parametres_courants,xyVal,y)
,PASSAGE_FORMAT_VIDEO_FORMAT_X_WINDOW_Y
)
)
);
/* Et definition de la taille de la fenetre 'X-Window' necessaire... */
Test(EST_FAUX(une_erreur_forcant_l_iteration_a_ete_rencontree))
Bblock
Test(EST_ACTIF(IXopen_pour_l_entree_video_temps_reel
(nom_variable_shell_serveur_ecran
,nom_de_la_fenetreA
,ADRESSE(dimension_de_la_fenetre)
,centrer_la_fenetre_video_temps_reel
,coin_bas_gauche
,editer_les_PRINT_ATTENTION_initiaux
)
)
)
/* Ouverture de la fenetre 'X-Window' necessaire pour la diffusion de la video... */
/* */
/* ATTENTION, il ne faut pas ecrire : */
/* */
/* ,ADRESSE(coin_bas_gauche) */
/* */
/* car 'coin_bas_gauche' est declare en tant que 'POINTERs(...)'... */
Bblock
DEFV(pointI_2D,origine_video_dans_la_fenetre);
/* Definition de l'origine de la video dans la fenetre... */
PARAMETRAGE_NOEUD_1(identite_du_noeud_recepteur
,intVal
,X11_____fenetre_courante
,VL_WINDOW
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
/* Etablissement de la correspondance entre la fenetre video (via 'VL_WINDOW') et la fenetre */
/* 'X-Window' (via 'X11_____fenetre_courante'). */
CALS(IXmapping_pour_l_entree_video_temps_reel
(DECALAGE_1_VIDEO_DANS_LA_FENETRE_X_WINDOW_X
,DECALAGE_1_VIDEO_DANS_LA_FENETRE_X_WINDOW_Y
,ADRESSE(ASD1(origine_video_dans_la_fenetre,x))
,ADRESSE(ASD1(origine_video_dans_la_fenetre,y))
)
);
/* Affichage de la fenetre a l'ecran... */
PARAMETRAGE_NOEUD_2(identite_du_noeud_recepteur
,xyVal
,x
,ADD2(ASD1(origine_video_dans_la_fenetre,x)
,MISE_A_L_ECHELLE_DES_DECALAGES_X_WINDOW
(SGI_____fenetre_X_WINDOW_decalage_2_video_X)
)
,y
,ADD2(ASD1(origine_video_dans_la_fenetre,y)
,SGI_____fenetre_X_WINDOW_decalage_2_video_Y
)
,VL_ORIGIN
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
/* Cadrage de la video dans la fenetre 'X-Window'... */
EGAL(la_connexion_video_pour_une_sequence_video_temps_reel_a_pu_etre_etablie,VRAI);
/* La connexion video demandee a pu etre etablie... */
EGAL(essayer_d_etablir_la_connexion,FAUX);
/* Et donc, ce n'est plus la peine de faire des tentatives... */
Eblock
ATes
Bblock
PRINT_ERREUR("la fenetre n'a pu etre ouverte");
PRINT_ATTENTION("ne pas oublier que cette fenetre ne peut etre que locale");
CAL1(Prer1(" variable '$DISPLAY' = '%s'\n",Gvar(nom_variable_shell_serveur_ecran)));
Eblock
ETes
Eblock
ATes
Bblock
/* Lorsqu'une erreur forcant l'iteration a ete rencontree, la sequence complete d'ouverture */
/* va etre repetee (si l'on n'a pas epuise le "credit"...). On notera que l'on n'execute pas */
/* alors la fonction 'IXopen_pour_l_entree_video_temps_reel(...)' car sinon, a l'iteration */
/* suivante, elle serait refusee (voir les controles qu'elle effectue...). */
EGAL(une_erreur_forcant_l_iteration_a_ete_rencontree
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
/* A priori, il n'y a plus d'erreur forcant l'iteration... */
Eblock
ETes
Eblock
ATes
Bblock
/* Cas de la numerisation d'une image : */
EGAL(la_connexion_video_pour_une_sequence_video_temps_reel_a_pu_etre_etablie,VRAI);
/* La connexion video demandee a pu etre etablie... */
EGAL(essayer_d_etablir_la_connexion,FAUX);
/* Et donc, ce n'est plus la peine de faire des tentatives... */
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ERREUR("le chemin n'a pu etre etabli (2)");
CAL1(Prer1(" identite du noeud emetteur = %d\n",identite_du_noeud_emetteur));
CAL1(Prer1(" identite du noeud recepteur = %d\n",identite_du_noeud_recepteur));
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ERREUR("le chemin n'a pu etre etabli (1)");
CAL1(Prer1(" identite du noeud emetteur = %d\n",identite_du_noeud_emetteur));
CAL1(Prer1(" identite du noeud recepteur = %d\n",identite_du_noeud_recepteur));
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ERREUR("le numero de 'device' demande est incorrect");
CAL1(Prer1(" numero de device demande = %d\n",numero_du_device_a_utiliser));
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ERREUR("impossible d'obtenir la liste des 'device's");
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ERREUR("impossible d'ouvrir la connexion video");
Eblock
ETes
PETIT_DODO(TEMPORISATION_DES_Tant_D_ETABLISSEMENT_DE_CONNEXION);
/* Afin de ne pas bloquer le systeme, et ce au cas ou il y aurait des defauts du type : */
/* */
/* unix: WARNING: Frame transfer aborted: analog video input not locked */
/* */
/* qui seraient permanents... */
Eblock
ETan
Test(IL_FAUT(essayer_d_etablir_la_connexion))
Bblock
PRINT_ERREUR("impossible d'etablir la connexion video apres plusieurs tentatives");
Eblock
ATes
Bblock
Test(EST_VRAI(la_connexion_video_pour_une_sequence_video_temps_reel_a_pu_etre_etablie))
Bblock
Test(EST_FAUX(il_y_a_le_transfert_d_une_sequence_video_temps_reel_en_cours))
Bblock
# ifdef GESTION_DE_L_OPTION_GALILEO_VERSION_01
Test(IL_FAUT(diffuser_sequence_sinon_numeriser_image))
Bblock
Test(PAS_D_ERREUR(VLBEGINTRANSFER(identite_du_serveur_video
,chemin_emetteur_recepteur
,nombre_de_descripteurs_de_transfert_d_images
,POINTEUR_SUR_UN_OBJET_GALILEO_INEXISTANT
)
)
)
/* Initialisation du transfert et transfert proprement dit... */
Bblock
EGAL(il_y_a_le_transfert_d_une_sequence_video_temps_reel_en_cours,VRAI);
/* Afin de savoir qu'il y a un transfert en cours... */
Eblock
ATes
Bblock
PRINT_ERREUR("un transfert n'a pu etre initialise et lance");
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ERREUR("la numerisation d'image n'est pas disponible dans cette version");
/* On notera que 'il_y_a_le_transfert_d_une_sequence_video_temps_reel_en_cours' est 'FAUX'. */
Eblock
ETes
# Aifdef GESTION_DE_L_OPTION_GALILEO_VERSION_01
# Eifdef GESTION_DE_L_OPTION_GALILEO_VERSION_01
# ifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
EGAL(il_y_a_le_transfert_d_une_sequence_video_temps_reel_en_cours,VRAI);
/* Afin de savoir qu'il y a un transfert en cours... */
Test(IL_FAUT(diffuser_sequence_sinon_numeriser_image))
Bblock
EGAL(ASD1(descripteurs_de_transfert_d_images,mode),VL_TRANSFER_MODE_CONTINUOUS);
EGAL(ASD1(descripteurs_de_transfert_d_images,count),nombre_d_images_a_manipuler);
EGAL(ASD1(descripteurs_de_transfert_d_images,delay),ZERO);
EGAL(ASD1(descripteurs_de_transfert_d_images,trigger),VLDeviceEvent);
/* Preparation du transfert pour une diffusion de sequence... */
Eblock
ATes
Bblock
EGAL(nombre_d_images_a_manipuler,UN);
/* Il n'y a qu'une image a manipuler... */
EGAL(ASD1(descripteurs_de_transfert_d_images,mode)
,VL_TRANSFER_MODE_DISCRETE
);
EGAL(ASD1(descripteurs_de_transfert_d_images,count)
,nombre_d_images_a_manipuler
);
EGAL(ASD1(descripteurs_de_transfert_d_images,delay)
,SGI_____nombre_d_images_a_ignorer_avant_d_en_numeriser_une
);
EGAL(ASD1(descripteurs_de_transfert_d_images,trigger)
,COND(IFEQ(SGI_____mode_de_numerisation_des_images,VL_CAPTURE_INTERLEAVED)
,VLFrameVerticalRetraceMask
,COND(IFEQ(SGI_____mode_de_numerisation_des_images,VL_CAPTURE_EVEN_FIELDS)
,VLEvenVerticalRetraceMask
,COND(IFEQ(SGI_____mode_de_numerisation_des_images,VL_CAPTURE_ODD_FIELDS)
,VLOddVerticalRetraceMask
,VLFrameVerticalRetraceMask
)
)
)
);
/* Preparation du transfert pour une numerisation d'image. Le 'VLFrameVerticalRetraceMask' */
/* est destine (du moins je l'espere) a commencer la numerisation apres une synchronisation */
/* "image" ; les "trigger"s suivants existent : */
/* */
/* VLEvenVerticalRetraceMask */
/* VLOddVerticalRetraceMask */
/* VLFrameVerticalRetraceMask */
/* */
/* apparemment pour se synchronsier sur les trames paires ('Even'), impaires ('Odd') ou */
/* bien enfin sur les images ('Frame'). La synchronisation 'Frame' etant le mode choisi */
/* par defaut... */
EGAL(buffer_alloue_pour_la_numerisation
,VLCREATEBUFFER(identite_du_serveur_video
,chemin_emetteur_recepteur
,identite_du_noeud_recepteur
,nombre_d_images_a_manipuler
)
);
CALS(VLREGISTERBUFFER(identite_du_serveur_video
,chemin_emetteur_recepteur
,identite_du_noeud_recepteur
,buffer_alloue_pour_la_numerisation
)
);
/* Allocation et enregistrement du buffer necessaire a la numerisation. */
Eblock
ETes
Test(PAS_D_ERREUR(VLBEGINTRANSFER(identite_du_serveur_video
,chemin_emetteur_recepteur
,nombre_de_descripteurs_de_transfert_d_images
,ADRESSE(descripteurs_de_transfert_d_images)
)
)
)
/* Initialisation du transfert et transfert proprement dit... */
Bblock
Eblock
ATes
Bblock
PRINT_ERREUR("un transfert video temps reel ne peut etre demarre");
Eblock
ETes
# Aifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# Eifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
Eblock
ATes
Bblock
PRINT_ERREUR("un transfert video temps reel est demande alors qu'il y en a deja un en cours");
Eblock
ETes
Eblock
ATes
Bblock
Eblock
ETes
Eblock
ETes
RETU_ERROR;
Eblock
# undef MISE_A_L_ECHELLE_DES_DECALAGES_X_WINDOW
# undef DENOMINATEUR_DU_RAPPORT_DE_ZOOM
# undef NUMERATEUR_DU_RAPPORT_DE_ZOOM
# undef DENOMINATEUR_n_DU_RAPPORT_DE_ZOOM
# undef DENOMINATEUR_1_DU_RAPPORT_DE_ZOOM
# undef NUMERATEUR_4_DU_RAPPORT_DE_ZOOM
# undef NUMERATEUR_2_DU_RAPPORT_DE_ZOOM
# undef NUMERATEUR_1_DU_RAPPORT_DE_ZOOM
EFonctionI
# undef DECALAGE_DE_VL_EV1_H_PHASE
# if (nSYSTEM_RELEASE < 503000000)
# undef DECALAGE_DE_VL_EV1_H_OFFSET
# Aif (nSYSTEM_RELEASE < 503000000)
# Eif (nSYSTEM_RELEASE < 503000000)
# if (nSYSTEM_RELEASE >= 503000000)
# undef DECALAGE_DE_VL_EV1_H_OFFSET
# Aif (nSYSTEM_RELEASE >= 503000000)
# Eif (nSYSTEM_RELEASE >= 503000000)
# undef DECALAGE_DE_VL_EV1_V_OFFSET
# undef DECALAGE_DE_VL_EV1_DELAY_SYNC
# define VL_PACKING_RGB_8 \
UNDEF
/* Afin de ne pas avoir d'erreur au niveau du pre-processeur, car en effet, le symbole */
/* 'VL_PACKING_RGB_8' n'est defini qu'en passe '$PASSE_5', alors que le test correspondant */
/* ci-apres est fait en '$PASSE_1', c'est-a-dire trop tot... */
# if ( ( (defined(BUG_SYSTEME_SGIND_VL_NOMBRE_DE_BUFFERS_PAR_IMAGE_EN_SORTIE_RVB)) \
&& (FORMAT_DE_PACKING_DES_POINTS_VIDEO==VL_PACKING_RGB_8) \
) \
)
# undef NOMBRE_D_IMAGES_A_MANIPULER
# Aif ( ( (defined(BUG_SYSTEME_SGIND_VL_NOMBRE_DE_BUFFERS_PAR_IMAGE_EN_SORTIE_RVB)) \
&& (FORMAT_DE_PACKING_DES_POINTS_VIDEO==VL_PACKING_RGB_8) \
) \
)
# undef NOMBRE_D_IMAGES_A_MANIPULER
# Eif ( ( (defined(BUG_SYSTEME_SGIND_VL_NOMBRE_DE_BUFFERS_PAR_IMAGE_EN_SORTIE_RVB)) \
&& (FORMAT_DE_PACKING_DES_POINTS_VIDEO==VL_PACKING_RGB_8) \
) \
)
# undef VL_PACKING_RGB_8 \
/* Afin de ne pas avoir d'erreur au niveau du pre-processeur, car en effet, le symbole */ \
/* 'VL_PACKING_RGB_8' n'est defini qu'en passe '$PASSE_5', alors que le test correspondant */ \
/* ci-dessus est fait en '$PASSE_1', c'est-a-dire trop tot... */
# ifdef GESTION_DE_L_OPTION_GALILEO_VERSION_01
# undef FORMAT_DE_PACKING_DES_POINTS_VIDEO
# Aifdef GESTION_DE_L_OPTION_GALILEO_VERSION_01
# Eifdef GESTION_DE_L_OPTION_GALILEO_VERSION_01
# ifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# undef FORMAT_DE_PACKING_DES_POINTS_VIDEO
# Aifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# Eifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# undef MISE_DU_CHEMIN_EN_MODE_LOCK_LOCK
# undef VL_DOIT_ETRE_NUL
# undef VL_INDIFFERENT
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E B U T D E L A D I F F U S I O N D ' U N E S E Q U E N C E V I D E O T E M P S R E E L : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IGdebut_de_diffusion_d_une_sequence_video_temps_reel(nom_variable_shell_serveur_ecran
,nom_de_la_fenetreA
,centrer_la_fenetre_video_temps_reel
,ARGUMENT_POINTERs(coin_bas_gauche)
,editer_les_PRINT_ATTENTION_initiaux
)
)
)
DEFV(Argument,DEFV(CHAR,DTb0(nom_variable_shell_serveur_ecran)));
/* Nom de la variable shell d'acces au nom du serveur et de l'ecran ; en general, ce sera */
/* celui qui est defini par la variable 'DEFINITION_DU_SERVEUR_X_WINDOW'. */
DEFV(Argument,DEFV(CHAR,DTb0(nom_de_la_fenetreA)));
/* Nom de la fenetre a ouvrir. */
DEFV(Argument,DEFV(Logical,centrer_la_fenetre_video_temps_reel));
/* Faut-il centrer la fenetre video temps reel ('VRAI') ou bien donner explicitement la */
/* position de son coin "bas gauche" ('FAUX') ? */
DEFV(Argument,DEFV(pointF_2D,POINTERs(coin_bas_gauche)));
/* Abscisse du point de reference, */
DEFV(Argument,DEFV(Logical,editer_les_PRINT_ATTENTION_initiaux));
/* Indique si les messages initiaux du type 'PRINT_ATTENTION(...)' doivent etre emis */
/* ('VRAI') ou pas ('FAUX'). */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/* ATTENTION : 'INIT_ERROR' est mis en tete des variables locales au cas ou des couples */
/* ('BDEFV','EDEFV') suivraient... */
/*..............................................................................................................................*/
CALS(IGdebut_de_diffusion_ou_de_numerisation_d_une_sequence_video(nom_variable_shell_serveur_ecran
,nom_de_la_fenetreA
,centrer_la_fenetre_video_temps_reel
,ARGUMENT_POINTERs(coin_bas_gauche)
,editer_les_PRINT_ATTENTION_initiaux
,DIFFUSER_UNE_SEQUENCE_VIDEO_TEMPS_REEL
)
);
/* Vers la demande de diffusion d'une sequence... */
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E B U T D E L A N U M E R I S A T I O N D ' U N E I M A G E : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IGdebut_de_numerisation_d_une_image_video()))
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/* ATTENTION : 'INIT_ERROR' est mis en tete des variables locales au cas ou des couples */
/* ('BDEFV','EDEFV') suivraient... */
DEFV(CHAR,INIT(POINTERc(nom_variable_shell_serveur_ecran),CHAINE_UNDEF));
/* Nom de la variable shell d'acces au nom du serveur et de l'ecran ; en general, ce sera */
/* celui qui est defini par la variable 'DEFINITION_DU_SERVEUR_X_WINDOW'. */
DEFV(CHAR,INIT(POINTERc(nom_de_la_fenetreA),CHAINE_UNDEF));
/* Nom de la fenetre a ouvrir. */
DEFV(Logical,INIT(centrer_la_fenetre_video_temps_reel,LUNDEF));
/* Faut-il centrer la fenetre video temps reel ('VRAI') ou bien donner explicitement la */
/* position de son coin "bas gauche" ('FAUX') ? */
DEFV(pointF_2D,coin_bas_gauche);
/* Abscisse du point de reference, */
DEFV(Logical,INIT(editer_les_PRINT_ATTENTION_initiaux,LUNDEF));
/* Indique si les messages initiaux du type 'PRINT_ATTENTION(...)' doivent etre emis */
/* ('VRAI') ou pas ('FAUX'). */
/*..............................................................................................................................*/
INITIALISATION_POINT_2D(coin_bas_gauche,_____cNORMALISE_OX11(Xmin11),_____cNORMALISE_OY11(Ymin11));
/* Juste pour le plaisir... */
CALS(IGdebut_de_diffusion_ou_de_numerisation_d_une_sequence_video(nom_variable_shell_serveur_ecran
,nom_de_la_fenetreA
,centrer_la_fenetre_video_temps_reel
,ARGUMENT_POINTERs(coin_bas_gauche)
,editer_les_PRINT_ATTENTION_initiaux
,NUMERISER_UNE_IMAGE_D_UNE_SEQUENCE_VIDEO_TEMPS_REEL
)
);
/* Vers la demande de numerisation d'une image... */
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F I N D E L A D I F F U S I O N D ' U N E S E Q U E N C E V I D E O T E M P S R E E L */
/* O U D E L A N U M E R I S A T I O N D ' U N E I M A G E D E C E L L E - C I : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Local,DEFV(FonctionI,IGfin_de_diffusion_ou_de_numerisation_d_une_sequence_video(diffuser_sequence_sinon_numeriser_image
,composante_numerisee_ROUGE
,composante_numerisee_VERTE
,composante_numerisee_BLEUE
,methode_de_redimensionnement
)
)
)
DEFV(Argument,DEFV(Logical,diffuser_sequence_sinon_numeriser_image));
/* Indique si l'on diffuse une sequence, ou bien dans le cas contraire, si l'on numerise */
/* une seule image. */
DEFV(Argument,DEFV(image,composante_numerisee_ROUGE));
DEFV(Argument,DEFV(image,composante_numerisee_VERTE));
DEFV(Argument,DEFV(image,composante_numerisee_BLEUE));
/* Resultat de la numerisation d'une image lorsqu'elle est demandee... */
DEFV(Argument,DEFV(Int,methode_de_redimensionnement));
/* Methode de redimensionnement demandee pour l'eventuelle image numerisee... */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/* ATTENTION : 'INIT_ERROR' est mis en tete des variables locales au cas ou des couples */
/* ('BDEFV','EDEFV') suivraient... */
DEFV(Logical,INIT(une_erreur_forcant_l_iteration_a_ete_rencontree,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION));
/* A priori, il n'y a pas encore eu d'erreur forcant l'iteration... */
/*..............................................................................................................................*/
Test(EST_VRAI(la_connexion_video_pour_une_sequence_video_temps_reel_a_pu_etre_etablie))
Bblock
Test(EST_VRAI(il_y_a_le_transfert_d_une_sequence_video_temps_reel_en_cours))
Bblock
Test(IL_FAUT(diffuser_sequence_sinon_numeriser_image))
Bblock
Test(PAS_D_ERREUR(VLENDTRANSFER(identite_du_serveur_video,chemin_emetteur_recepteur)))
/* Lorsqu'il y a un transfert en cours, on le termine afin d'arreter la sequence... */
Bblock
Eblock
ATes
Bblock
PRINT_ERREUR("un transfert en cours ne peut etre interrompu (1)");
Eblock
ETes
DETECTION_DES_DEFAUTS_EN_COURS_DE_TRANSFERT(SE_SYNCHRONISER_SUR_UNE_SOURCE_EXTERNE_EN_ENTREE_VIDEO);
/* S'est-il produit des defauts pendant le transfert precedent ? */
Eblock
ATes
Bblock
DEFV(G_VLInfoPtr,informations_sur_l_image_courante);
/* Afin de savoir quand l'information contenue dans le buffer est valide... */
DEFV(Void,INIT(POINTEUR(image_numerisee),ADRESSE_NON_ENCORE_DEFINIE));
/* Pointeur sur le resultat de la numerisation dans le buffer alloue... */
# if ( (defined(BUG_SYSTEME_SGIND_VL_AXE_DES_Y_LORS_D_UNE_NUMERISATION_D_IMAGE)) \
)
BDEFV(image,composante_numerisee_avant_symetrisation_ROUGE);
BDEFV(image,composante_numerisee_avant_symetrisation_VERTE);
BDEFV(image,composante_numerisee_avant_symetrisation_BLEUE);
/* Definition des trois composantes de l'image numerisee apres le redimensionnement, */
/* mais avant la symetrie d'axe horizontal... */
# define COMPOSANTE_NUMERISEE_ROUGE \
composante_numerisee_avant_symetrisation_ROUGE
# define COMPOSANTE_NUMERISEE_VERTE \
composante_numerisee_avant_symetrisation_VERTE
# define COMPOSANTE_NUMERISEE_BLEUE \
composante_numerisee_avant_symetrisation_BLEUE
/* Definition des trois composantes de l'image numerisee apres le redimensionnement. */
# Aif ( (defined(BUG_SYSTEME_SGIND_VL_AXE_DES_Y_LORS_D_UNE_NUMERISATION_D_IMAGE)) \
)
# define COMPOSANTE_NUMERISEE_ROUGE \
composante_numerisee_ROUGE
# define COMPOSANTE_NUMERISEE_VERTE \
composante_numerisee_VERTE
# define COMPOSANTE_NUMERISEE_BLEUE \
composante_numerisee_BLEUE
/* Definition des trois composantes de l'image numerisee apres le redimensionnement. */
# Eif ( (defined(BUG_SYSTEME_SGIND_VL_AXE_DES_Y_LORS_D_UNE_NUMERISATION_D_IMAGE)) \
)
EGAL(informations_sur_l_image_courante
,POINTEUR_SUR_UN_OBJET_GALILEO_INEXISTANT
);
Tant(IFEQ(informations_sur_l_image_courante
,POINTEUR_SUR_UN_OBJET_GALILEO_INEXISTANT
)
)
Bblock
EGAL(informations_sur_l_image_courante
,VLGETNEXTVALID(identite_du_serveur_video
,buffer_alloue_pour_la_numerisation
)
);
/* Et attente de validite... */
PETIT_DODO(TEMPORISATION_DES_Tant_ATTENTE_DE_BUFFER);
/* Afin de ne pas bloquer le systeme, et ce au cas ou il y aurait des defauts du type : */
/* */
/* unix: WARNING: Frame transfer aborted: analog video input not locked */
/* */
/* qui seraient permanents... */
Eblock
ETan
EGAL(image_numerisee
,VLGETACTIVEREGION(identite_du_serveur_video
,buffer_alloue_pour_la_numerisation
,informations_sur_l_image_courante
)
);
/* Lorsque tout est valide, on peut recuperer un pointeur sur la zone "image courante"... */
CALS(VLGETCONTROL(identite_du_serveur_video
,chemin_emetteur_recepteur
,identite_du_noeud_recepteur
,VL_SIZE
,ADRESSE(parametres_courants)
)
);
/* Recuperation de la taille de l'image numerisee... */
PUSH_DIMENSIONS_2D;
/* Sauvegarde du dimensionnement initial... */
SET_DIMENSIONS_2D_SANS_VALIDATION(XminG,XYZmax(XminG,ASD2(parametres_courants,xyVal,x))
,YminG,XYZmax(YminG,ASD2(parametres_courants,xyVal,y))
);
/* Mise en place du dimensionnement de l'image numerisee... */
Bblock
BDEFV(image,composante_numerisee_avant_redimensionnement_ROUGE);
BDEFV(image,composante_numerisee_avant_redimensionnement_VERTE);
BDEFV(image,composante_numerisee_avant_redimensionnement_BLEUE);
/* Definition des trois composantes de l'image numerisee avant sont redimensionnement... */
CALS(IBVR_888_universel_fausses_couleurs(composante_numerisee_avant_redimensionnement_ROUGE
,composante_numerisee_avant_redimensionnement_VERTE
,composante_numerisee_avant_redimensionnement_BLEUE
,image_numerisee
)
);
/* Demultiplexage des trois composantes... */
CALS(Iredimensionnement(COMPOSANTE_NUMERISEE_ROUGE
,EnTete_de_sauvegardM ## Xmin,EnTete_de_sauvegardM ## Xmax
,EnTete_de_sauvegardM ## Ymin,EnTete_de_sauvegardM ## Ymax
,composante_numerisee_avant_redimensionnement_ROUGE
,Xmin,Xmax,Ymin,Ymax
,methode_de_redimensionnement
)
);
CALS(Iredimensionnement(COMPOSANTE_NUMERISEE_VERTE
,EnTete_de_sauvegardM ## Xmin,EnTete_de_sauvegardM ## Xmax
,EnTete_de_sauvegardM ## Ymin,EnTete_de_sauvegardM ## Ymax
,composante_numerisee_avant_redimensionnement_VERTE
,Xmin,Xmax,Ymin,Ymax
,methode_de_redimensionnement
)
);
CALS(Iredimensionnement(COMPOSANTE_NUMERISEE_BLEUE
,EnTete_de_sauvegardM ## Xmin,EnTete_de_sauvegardM ## Xmax
,EnTete_de_sauvegardM ## Ymin,EnTete_de_sauvegardM ## Ymax
,composante_numerisee_avant_redimensionnement_BLEUE
,Xmin,Xmax,Ymin,Ymax
,methode_de_redimensionnement
)
);
/* Et enfin, redimensionnement des trois composantes... */
EDEFV(image,composante_numerisee_avant_redimensionnement_BLEUE);
EDEFV(image,composante_numerisee_avant_redimensionnement_VERTE);
EDEFV(image,composante_numerisee_avant_redimensionnement_ROUGE);
/* Definition des trois composantes de l'image numerisee avant sont redimensionnement... */
Eblock
PULL_DIMENSIONS_2D;
/* Restauration du dimensionnement initial... */
# if ( (defined(BUG_SYSTEME_SGIND_VL_AXE_DES_Y_LORS_D_UNE_NUMERISATION_D_IMAGE)) \
)
Bblock
CALS(Ix_symetrie(composante_numerisee_ROUGE,COMPOSANTE_NUMERISEE_ROUGE));
CALS(Ix_symetrie(composante_numerisee_VERTE,COMPOSANTE_NUMERISEE_VERTE));
CALS(Ix_symetrie(composante_numerisee_BLEUE,COMPOSANTE_NUMERISEE_BLEUE));
/* Il est donc parfois necessaire de symetriser horizontalement l'image numerisee. On */
/* notera que l'on ne peut utiliser : */
/* */
/* CALS(pixmode(PM_TTOB,TRUE)); */
/* */
/* pour ce faire... */
Eblock
# Aif ( (defined(BUG_SYSTEME_SGIND_VL_AXE_DES_Y_LORS_D_UNE_NUMERISATION_D_IMAGE)) \
)
# Eif ( (defined(BUG_SYSTEME_SGIND_VL_AXE_DES_Y_LORS_D_UNE_NUMERISATION_D_IMAGE)) \
)
CALS(VLPUTFREE(identite_du_serveur_video,buffer_alloue_pour_la_numerisation));
/* Liberation du buffer acquis par 'VLGETNEXTVALID(...)'. */
Test(PAS_D_ERREUR(VLENDTRANSFER(identite_du_serveur_video,chemin_emetteur_recepteur)))
/* Lorsqu'il y a un transfert en cours, on le termine afin d'arreter la sequence... */
Bblock
Eblock
ATes
Bblock
PRINT_ERREUR("un transfert en cours ne peut etre interrompu (2)");
Eblock
ETes
DETECTION_DES_DEFAUTS_EN_COURS_DE_TRANSFERT(SE_SYNCHRONISER_SUR_UNE_SOURCE_EXTERNE_EN_ENTREE_VIDEO);
/* S'est-il produit des defauts pendant le transfert precedent ? */
CALS(VLDEREGISTERBUFFER(identite_du_serveur_video
,chemin_emetteur_recepteur
,chemin_emetteur_recepteur
,buffer_des_images
)
);
CALS(VLDESTROYBUFFER(identite_du_serveur_video
,buffer_alloue_pour_la_numerisation
)
);
/* Liberation du buffer... */
# if ( (defined(BUG_SYSTEME_SGIND_VL_AXE_DES_Y_LORS_D_UNE_NUMERISATION_D_IMAGE)) \
)
EDEFV(image,composante_numerisee_avant_symetrisation_BLEUE);
EDEFV(image,composante_numerisee_avant_symetrisation_VERTE);
EDEFV(image,composante_numerisee_avant_symetrisation_ROUGE);
/* Definition des trois composantes de l'image numerisee apres le redimensionnement, */
/* mais avant la symetrie d'axe horizontal... */
# undef COMPOSANTE_NUMERISEE_ROUGE
# undef COMPOSANTE_NUMERISEE_VERTE
# undef COMPOSANTE_NUMERISEE_BLEUE
# Aif ( (defined(BUG_SYSTEME_SGIND_VL_AXE_DES_Y_LORS_D_UNE_NUMERISATION_D_IMAGE)) \
)
# undef COMPOSANTE_NUMERISEE_ROUGE
# undef COMPOSANTE_NUMERISEE_VERTE
# undef COMPOSANTE_NUMERISEE_BLEUE
# Eif ( (defined(BUG_SYSTEME_SGIND_VL_AXE_DES_Y_LORS_D_UNE_NUMERISATION_D_IMAGE)) \
)
Eblock
ETes
EGAL(il_y_a_le_transfert_d_une_sequence_video_temps_reel_en_cours,FAUX);
/* Et on memorise que c'est fini... */
Eblock
ATes
Bblock
PRINT_ERREUR("une fin de transfert est demandee alors qu'il n'y en a aucun en cours");
Eblock
ETes
Test(IL_FAUT(diffuser_sequence_sinon_numeriser_image))
Bblock
CALS(IXclose_pour_l_entree_video_temps_reel());
/* Fermeture de la fenetre 'X-Window'... */
Eblock
ATes
Bblock
Eblock
ETes
# ifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# if ( (defined(BUG_SYSTEME_SGIND_VL_VLDESTROYPATH_ENTREE_VIDEO_TEMPS_REEL)) \
)
Test(I3ET(IFNE(SGI_____Gentree_video_de_repos,VL_MUXSWITCH_COMPOSITE_1)
,IFNE(SGI_____Gentree_video_de_repos,VL_MUXSWITCH_COMPOSITE_2)
,IFNE(SGI_____Gentree_video_de_repos,VL_MUXSWITCH_COMPOSITE_3)
)
)
Bblock
PRINT_ERREUR("l'entree video de repos n'est pas reconnue (entree implicite forcee)");
EGAL(SGI_____Gentree_video_de_repos,VL_MUXSWITCH_COMPOSITE_DE_REPOS);
Eblock
ATes
Bblock
Eblock
ETes
PARAMETRAGE_NOEUD_1(identite_du_noeud_emetteur
,intVal
,SGI_____Gentree_video_de_repos
,VL_MUXSWITCH
,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
);
/* Mise en place d'une source video de "repos". Ceci a ete introduit, car malgre le */
/* 'VLDESTROYPATH(...)' qui suit, on continue a voir, apres le 'VLCLOSEVIDEO(...)' sur */
/* les sorties composite 'Pal' (bien qu'avec jitter) et 'RVB' la video entrante... */
/* Un 'VLRESTOREFACTORYDEFAULTS(...)' ne fait pas l'affaire non plus que le controle : */
/* */
/* PARAMETRAGE_NOEUD_1(identite_du_noeud_emetteur */
/* ,intVal */
/* ,VL_SIGNAL_BLACK */
/* ,VL_SIGNAL */
/* ,EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL */
/* ,UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION */
/* ); */
/* */
/* qui n'est pas supporte par la carte 'Galileo'. Enfin, un 'VLREMOVENODE(...)' (procedure */
/* d'ailleurs non definie...) ne fait pas non plus l'affaire... */
/* */
/* On notera que bizarrement, dans 'IGclose(...)' le fonctionnement de 'VLDESTROYPATH(...)' */
/* donne toute satisfaction et assure donc le retour au noir de la sortie... */
/* */
/* Enfin, on regardera la commande 'allume' introduite dans '$Fdivers' afin de traiter le */
/* cas particulier du login. Mais ceci s'est avere insuffisant ; en effet, si au moment du */
/* login, le disque video est par exemple actif (c'est-a-dire presente une image), celle-ci */
/* est vue sur la sortie 'RVB', meme apres la commande 'allume'. C'est pourquoi, l'appel a */
/* la commande 'video' a ete ajoute afin de garantir la mise en place de l'entree video */
/* 'SGI_____Gentree_video_de_repos' ; on notera que cette operation ne peut etre mise en */
/* place de plus et simplement dans 'IGclose(...)' a cause de l'ordre des definitions qui */
/* sont faites ici (dans '$xiidG/fonction.1$FON') ; cela demanderait de deplacer plusieurs */
/* morceaux (par exemple la definition de 'SGI_____Gentree_video_de_repos'), ce qui presente */
/* toujours un certain danger... Enfin, derniere raison d'impossibilite, dans la fonction */
/* 'Gclose(...)', le noeud 'identite_du_noeud_emetteur' (de type 'VL_VIDEO') n'existe pas. */
/* */
/* On consultera aussi les commentaires relatifs a l'alias 'Ivideo' dans les deux fichiers */
/* 'v $Fdivers' et 'v $xci/disk_video_P$Z'... */
# Aif ( (defined(BUG_SYSTEME_SGIND_VL_VLDESTROYPATH_ENTREE_VIDEO_TEMPS_REEL)) \
)
# Eif ( (defined(BUG_SYSTEME_SGIND_VL_VLDESTROYPATH_ENTREE_VIDEO_TEMPS_REEL)) \
)
# Aifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# Eifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
CALS(VLDESTROYPATH(identite_du_serveur_video
,chemin_emetteur_recepteur
)
);
/* Puis destruction du chemin entre l'emetteur et le recepteur... */
Test(PAS_D_ERREUR(VLCLOSEVIDEO(identite_du_serveur_video)))
/* Enfin, fermeture de la connexion video... */
Bblock
Eblock
ATes
Bblock
PRINT_ERREUR("la fermeture de la connexion video est impossible");
Eblock
ETes
Eblock
ATes
Bblock
PRINT_ERREUR("la fin d'une sequence est demandee alors qu'il n'y a pas eu de debut");
Eblock
ETes
EGAL(la_connexion_video_pour_une_sequence_video_temps_reel_a_pu_etre_etablie,FAUX);
/* A priori, on ne sait pas ce qui se passera la fois suivante... */
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F I N D E D I F F U S I O N D ' U N E S E Q U E N C E V I D E O T E M P S R E E L : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IGfin_de_diffusion_d_une_sequence_video_temps_reel()))
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/* ATTENTION : 'INIT_ERROR' est mis en tete des variables locales au cas ou des couples */
/* ('BDEFV','EDEFV') suivraient... */
BDEFV(image,composante_numerisee_ROUGE);
BDEFV(image,composante_numerisee_VERTE);
BDEFV(image,composante_numerisee_BLEUE);
/* Ces trois images sont en fait inutiles, mais crees malgre tout afin de pouvoir appeler */
/* correctement 'IGfin_de_diffusion_ou_de_numerisation_d_une_sequence_video(...)'. */
DEFV(Int,INIT(methode_de_redimensionnement,UNDEF));
/* Methode de redimensionnement inutilisee ici... */
/*..............................................................................................................................*/
CALS(IGfin_de_diffusion_ou_de_numerisation_d_une_sequence_video(DIFFUSER_UNE_SEQUENCE_VIDEO_TEMPS_REEL
,composante_numerisee_ROUGE
,composante_numerisee_VERTE
,composante_numerisee_BLEUE
,methode_de_redimensionnement
)
);
EDEFV(image,composante_numerisee_BLEUE);
EDEFV(image,composante_numerisee_VERTE);
EDEFV(image,composante_numerisee_ROUGE);
/* Ces trois images sont en fait inutiles, mais crees malgre tout afin de pouvoir appeler */
/* correctement 'IGfin_de_diffusion_ou_de_numerisation_d_une_sequence_video(...)'. */
RETU_ERROR;
Eblock
EFonctionI
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* F I N D E N U M E R I S A T I O N D ' U N E I M A G E : */
/* */
/*************************************************************************************************************************************/
BFonctionI
DEFV(Common,DEFV(FonctionI,IGfin_de_numerisation_d_une_image_video(composante_numerisee_ROUGE
,composante_numerisee_VERTE
,composante_numerisee_BLEUE
,methode_de_redimensionnement
)
)
)
DEFV(Argument,DEFV(image,composante_numerisee_ROUGE));
DEFV(Argument,DEFV(image,composante_numerisee_VERTE));
DEFV(Argument,DEFV(image,composante_numerisee_BLEUE));
/* Resultat de la numerisation d'une image lorsqu'elle est demandee... */
DEFV(Argument,DEFV(Int,methode_de_redimensionnement));
/* Methode de redimensionnement demandee pour l'eventuelle image numerisee... */
/*-----------------------------------------------------------------------------------------------------------------------------------*/
Bblock
INIT_ERROR;
/* ATTENTION : 'INIT_ERROR' est mis en tete des variables locales au cas ou des couples */
/* ('BDEFV','EDEFV') suivraient... */
/*..............................................................................................................................*/
CALS(IGfin_de_diffusion_ou_de_numerisation_d_une_sequence_video(NUMERISER_UNE_IMAGE_D_UNE_SEQUENCE_VIDEO_TEMPS_REEL
,composante_numerisee_ROUGE
,composante_numerisee_VERTE
,composante_numerisee_BLEUE
,methode_de_redimensionnement
)
);
RETU_ERROR;
Eblock
EFonctionI
# ifdef GESTION_DE_L_OPTION_GALILEO_VERSION_01
# undef DECALAGE_2_VIDEO_DANS_LA_FENETRE_X_WINDOW_Y
# undef DECALAGE_2_VIDEO_DANS_LA_FENETRE_X_WINDOW_X
# undef DECALAGE_1_VIDEO_DANS_LA_FENETRE_X_WINDOW_Y
# undef DECALAGE_1_VIDEO_DANS_LA_FENETRE_X_WINDOW_X
# undef PASSAGE_FORMAT_VIDEO_FORMAT_X_WINDOW_X
# undef PASSAGE_FORMAT_VIDEO_FORMAT_X_WINDOW_Y
# Aifdef GESTION_DE_L_OPTION_GALILEO_VERSION_01
# Eifdef GESTION_DE_L_OPTION_GALILEO_VERSION_01
# ifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# undef DECALAGE_2_VIDEO_DANS_LA_FENETRE_X_WINDOW_Y
# if (nSYSTEM_RELEASE < 503000000)
# undef DECALAGE_2_VIDEO_DANS_LA_FENETRE_X_WINDOW_X
# Aif (nSYSTEM_RELEASE < 503000000)
# Eif (nSYSTEM_RELEASE < 503000000)
# if (nSYSTEM_RELEASE >= 503000000)
# undef DECALAGE_2_VIDEO_DANS_LA_FENETRE_X_WINDOW_X
# Aif (nSYSTEM_RELEASE >= 503000000)
# Eif (nSYSTEM_RELEASE >= 503000000)
# undef DECALAGE_1_VIDEO_DANS_LA_FENETRE_X_WINDOW_Y
# undef DECALAGE_1_VIDEO_DANS_LA_FENETRE_X_WINDOW_X
# undef PASSAGE_FORMAT_VIDEO_FORMAT_X_WINDOW_X
# undef PASSAGE_FORMAT_VIDEO_FORMAT_X_WINDOW_Y
# Aifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# Eifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# ifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# undef VL_FILTER
# undef VL_PREFILTER
# undef VL_QUALITY
# undef VL_TBCMODE
# if ( (defined(BUG_SYSTEME_SGIND_VL_VLDESTROYPATH_ENTREE_VIDEO_TEMPS_REEL)) \
)
# undef VL_MUXSWITCH_COMPOSITE_DE_REPOS
# Aif ( (defined(BUG_SYSTEME_SGIND_VL_VLDESTROYPATH_ENTREE_VIDEO_TEMPS_REEL)) \
)
# Eif ( (defined(BUG_SYSTEME_SGIND_VL_VLDESTROYPATH_ENTREE_VIDEO_TEMPS_REEL)) \
)
# undef VL_MUXSWITCH_COMPOSITE
# undef VL_MUXSWITCH_Y_RmY_BmY_2
# undef VL_MUXSWITCH_Y_RmY_BmY_1
# undef VL_MUXSWITCH_COMPOSITE_3
# undef VL_MUXSWITCH_COMPOSITE_2
# undef VL_MUXSWITCH_COMPOSITE_1
# undef VL_MUXSWITCH_YsC_3
# undef VL_MUXSWITCH_YsC_2
# undef VL_MUXSWITCH_YsC_1
# undef VL_DEFAULT_SOURCE_DIGITAL_2
# undef VL_DEFAULT_SOURCE_DIGITAL_1
# undef VL_DEFAULT_SOURCE_ANALOG
# if ( (defined(BUG_SYSTEME_SGIND_VL_ENTREE_VIDEO_TEMPS_REEL_NON_GENLOCKEE)) \
)
# undef SE_SYNCHRONISER_SUR_UNE_SOURCE_EXTERNE_EN_ENTREE_VIDEO
# Aif ( (defined(BUG_SYSTEME_SGIND_VL_ENTREE_VIDEO_TEMPS_REEL_NON_GENLOCKEE)) \
)
# undef SE_SYNCHRONISER_SUR_UNE_SOURCE_EXTERNE_EN_ENTREE_VIDEO
# Eif ( (defined(BUG_SYSTEME_SGIND_VL_ENTREE_VIDEO_TEMPS_REEL_NON_GENLOCKEE)) \
)
# undef VL_SYNC_SOURCE_COMPOSITE
# undef VL_SYNC_SOURCE_COMPOSITE_3
# undef VL_SYNC_SOURCE_COMPOSITE_2
# undef VL_SYNC_SOURCE_COMPOSITE_1
# undef CHOIX_DE_LA_SOURCE_DE_SYNCHRONISATION_EXTERNE
# Aifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# Eifdef GESTION_DE_L_OPTION_GALILEO_VERSION_02
# undef VISUALISER_UNE_IMAGE_RASTER
# undef VISUALISER_LE_CONTENU_DE_L_ECRAN_DE_LA_STATION_DE_TRAVAIL
# undef SE_SYNCHRONISER_SUR_UNE_SOURCE_EXTERNE
# undef SYNCHRONISER_LA_CARTE_GALILEO_SUR_UNE_SOURCE_EXTERNE
# undef NE_PAS_SYNCHRONISER_LA_CARTE_GALILEO_SUR_UNE_SOURCE_EXTERNE
# if (nSYSTEM_RELEASE < 503000000)
# undef DETECTION_DES_DEFAUTS_EN_COURS_DE_TRANSFERT
# undef LISTE_DES_EVENEMENTS_A_DETECTER
# Aif (nSYSTEM_RELEASE < 503000000)
# Eif (nSYSTEM_RELEASE < 503000000)
# if (nSYSTEM_RELEASE >= 503000000)
# undef DETECTION_DES_DEFAUTS_EN_COURS_DE_TRANSFERT
# undef TEMPORISATION_DE_BLOCAGE_SUR_DEFAUT_EN_COURS_DE_TRANSFERT
# undef TEMPORISATION_AVANT_DE_TESTER_LES_EVENEMENTS
# undef LISTE_DES_EVENEMENTS_A_DETECTER
# Aif (nSYSTEM_RELEASE >= 503000000)
# Eif (nSYSTEM_RELEASE >= 503000000)
# Aifdef __VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : VidAnal. */
# Eifdef __VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : VidAnal. */
# if ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# undef nPARAMETRAGE_NOEUD_1
# undef nPARAMETRAGE_NOEUD_2
# undef PARAMETRAGE_NOEUD_2
# undef ERREUR_DE_PARAMETRAGE
# undef PARAMETRAGE_NOEUD_1
# undef NE_PAS_EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
# undef EDITER_LES_MESSAGES_D_ERREUR_DE_VLSETCONTROL
# undef UNE_ERREUR_ICI_NE_DOIT_PAS_FORCER_L_ITERATION
# undef UNE_ERREUR_ICI_DOIT_FORCER_L_ITERATION
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# if ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# undef REINITIALISATION_DE_LA_CARTE_GALILEO
# if ( (defined(GESTION_DE_L_OPTION_GALILEO_VERSION_01)) \
|| (defined(GESTION_DE_L_OPTION_GALILEO_VERSION_02)) \
)
# undef VLSETUPPATHS
# undef VLSETCONTROL
# undef VLSELECTEVENTS
# undef VLRESTORESYSTEMDEFAULTS
# undef VLRESTOREFACTORYDEFAULTS
# undef VLREGISTERBUFFER
# undef VLPUTVALID
# undef VLPUTFREE
# undef VLPERROR
# undef VLPENDING
# undef VLOPENVIDEO
# undef VLNEXTEVENT
# undef VLGETTRANSFERSIZE
# undef VLGETNODE
# undef VLGETNEXTVALID
# undef VLGETNEXTFREE
# undef VLGETDEVICELIST
# undef VLGETDEVICE
# undef VLGETCONTROL
# undef VLGETACTIVEREGION
# undef VLENDTRANSFER
# undef VLDESTROYPATH
# undef VLDESTROYBUFFER
# undef VLDEREGISTERBUFFER
# undef VLCREATEPATH
# undef VLCREATEBUFFER
# undef VLCLOSEVIDEO
# undef VLBUFFERDONE
# undef VLBEGINTRANSFER
# undef VLADDNODE
# Aif ( (defined(GESTION_DE_L_OPTION_GALILEO_VERSION_01)) \
|| (defined(GESTION_DE_L_OPTION_GALILEO_VERSION_02)) \
)
# Eif ( (defined(GESTION_DE_L_OPTION_GALILEO_VERSION_01)) \
|| (defined(GESTION_DE_L_OPTION_GALILEO_VERSION_02)) \
)
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# if ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# undef SE_SYNCHRONISER_SUR_UNE_SOURCE_EXTERNE
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_GENLOCK_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# undef FENETRE_PAS_OUVERTE_OU_PROBLEMES_A_L_OUVERTURE
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# undef APPEL_D_UNE_FONCTION_X_WINDOW_POUR_OpenGL
# undef FENETRE_PAS_OUVERTE_OU_PROBLEMES_A_L_OUVERTURE
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# if ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# undef NOM_DU_DEVICE_ATTENDU
# undef DEMANDE_D_UN_DEVICE_INDIFFERENT
# undef POINTEUR_SUR_UN_OBJET_GALILEO_INEXISTANT
# undef NOM_DU_SERVEUR_VIDEO_DE_L_OPTION_GALILEO
# if ( (defined(BUG_SYSTEME_SGIND_VL_PREMIERE_CONNEXION_VIDEO)) \
)
# undef NOMBRE_DE_TENTATIVES_DE_CONNEXION_VIDEO
# Aif ( (defined(BUG_SYSTEME_SGIND_VL_PREMIERE_CONNEXION_VIDEO)) \
)
# undef NOMBRE_DE_TENTATIVES_DE_CONNEXION_VIDEO
# Eif ( (defined(BUG_SYSTEME_SGIND_VL_PREMIERE_CONNEXION_VIDEO)) \
)
# undef TAILLE_REELLE_DES_IMAGES_EN_OCTETS
# undef TEMPORISATION_DES_Tant_ATTENTE_DE_BUFFER
# undef TEMPORISATION_DES_Tant_D_ETABLISSEMENT_DE_CONNEXION
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# undef dimYG_d_une_fenetre_HAUTE_DEFINITION
# undef dimXG_d_une_fenetre_HAUTE_DEFINITION
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_GL
# ifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# undef dimYG_d_une_fenetre_HAUTE_DEFINITION
# undef dimXG_d_une_fenetre_HAUTE_DEFINITION
# undef REDUIRE_dimXYG
# Aifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# Eifdef __VERSION__UTILISER_LA_BIBLIOTHEQUE_OpenGL
# if ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# undef Cast_G_VLPathList
# Aif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
# Eif ( (defined(__VERSION__COMPILER_L_OPTION_VIDEO_ANALOGIQUE_DU_GRAPHIQUE_SILICON_GRAPHICS)) \
)
#Aifdef __VERSION__COMPILER_LE_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : compiler sur 'SiliG'. */
#Eifdef __VERSION__COMPILER_LE_GRAPHIQUE_SILICON_GRAPHICS /* Common,DEFV(Fonction,) : compiler sur 'SiliG'. */
_______________________________________________________________________________________________________________________________________