/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        T E S T   D E   L ' E N T R E E   V I D E O   S U R   L A   C A R T E   " G A L I L E O "                                  */
/*        D E   'SYSTEME_SGIND?GA_IRIX'   ( V E R S I O N   5.2 )  :                                                                 */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/SGI_G.520.42$c' :                                                                                          */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, AAAAMMJJhhmmss).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  <stdio.h>
#include  <string.h>
#include  <X11/X.h>
#include  <X11/Xlib.h>
#include  <X11/Xutil.h>
#include  <vl/vl.h>
#include  <gl/gl.h>

extern    char      *getenv();

#define   RACINE_DU_SYSTEME_HIERARCHIQUE                                                                                                \
                    RootWindow(display,DefaultScreen(display))
#define   EPAISSEUR_DU_BORD_DES_FENETRES                                                                                                \
                    0
#define   MASQUE_VIDE                                                                                                                   \
                    (ulong)0
#define   NOM_DE_LA_FENETRE                                                                                                             \
                    ""
#define   NOM_DE_SON_ICONE                                                                                                              \
                    ""

#define   TABULATION                                                                                                                    \
                    "                                             "
#define   parametre_1(noeud,parametre,valeur,type,Ntype,message)                                                                        \
                    {                                                                                                                   \
                    int       codeR;                                                                                                    \
                    parametres.parametre = valeur;                                                                                      \
                    fprintf(stderr,"Controle %s : Parametre=%-20s   Valeur vlSetControl=%d\n",message,Ntype,valeur);                    \
                    if        ((codeR = vlSetControl(serveur_video,chemin,noeud,type,¶metres)) == 0)                                \
                              {                                                                                                         \
                              }                                                                                                         \
                    else                                                                                                                \
                              {                                                                                                         \
                              vlPerror("                                             vERREUR ");                                        \
                              if        (vlGetControl(serveur_video,chemin,noeud,type,¶metres) == 0)                                \
                                        {                                                                                               \
                                        fprintf(stderr,"%ssERREUR : Valeur vlGetControl=%d\n"                                           \
                                               ,TABULATION                                                                              \
                                               ,parametres.parametre                                                                    \
                                                );                                                                                      \
                                        }                                                                                               \
                              else                                                                                                      \
                                        {                                                                                               \
                                        vlPerror("                                             gERREUR ");                              \
                                        }                                                                                               \
                              }                                                                                                         \
                    }                                                                                                                   \
                                        /* Envoi d'un controle a un parametre.                                                       */
#define   parametre_2(noeud,parametre1,parametre11,valeur1,parametre12,valeur2,type,Ntype,message)                                      \
                    {                                                                                                                   \
                    int       codeR;                                                                                                    \
                    parametres.parametre1.parametre11 = valeur1;                                                                        \
                    parametres.parametre1.parametre12 = valeur2;                                                                        \
                    fprintf(stderr,"Controle %s : Parametre=%-20s   Valeur vlSetControl={%d,%d}\n",message,Ntype,valeur1,valeur2);      \
                    if        ((codeR = vlSetControl(serveur_video,chemin,noeud,type,¶metres)) == 0)                                \
                              {                                                                                                         \
                              }                                                                                                         \
                    else                                                                                                                \
                              {                                                                                                         \
                              vlPerror("                                             vERREUR ");                                        \
                              if        (vlGetControl(serveur_video,chemin,noeud,type,¶metres) == 0)                                \
                                        {                                                                                               \
                                        fprintf(stderr,"%ssERREUR : Valeur vlGetControl={%d,%d}\n"                                      \
                                               ,TABULATION                                                                              \
                                               ,parametres.parametre1.parametre11                                                       \
                                               ,parametres.parametre1.parametre12                                                       \
                                                );                                                                                      \
                                        }                                                                                               \
                              else                                                                                                      \
                                        {                                                                                               \
                                        vlPerror("                                             gERREUR ");                              \
                                        }                                                                                               \
                              }                                                                                                         \
                    }                                                                                                                   \
                                        /* Envoi d'un controle a deux parametres.                                                    */

main()
          {
          VLServer  serveur_video = NULL;
          int       numero_de_device = -1;
          char      *nom_de_device;
          VLDevList liste_des_devices;
          VLNode    Nemetteur,Nrecepteur,Ndevice;
          int       nombre_de_chemins=1;
          VLPath    chemin = -1;
          VLControlValue      parametres;
          VLControlList       *controles;
          VLTransferDescriptor          transfert;

          Display   *display;
          Window    fenetre;
          XSizeHints                    indices;
          XSetWindowAttributes          attributs;
          Window                        child_return;
          XEvent    evenement;
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        C O N N E X I O N   E T   P R O G R A M M A T I O N   D U   S E R V E U R   V I D E O  :                                   */
/*                                                                                                                                   */
/*                                                                                                                                   */
          serveur_video = vlOpenVideo("");
          if        (serveur_video != NULL)
                    {
                    vlRestoreSystemDefaults(serveur_video);
                    if        (vlGetDeviceList(serveur_video,&liste_des_devices) >= 0)
                              {
                              if        ((numero_de_device < (int)liste_des_devices.numDevices) && (numero_de_device >= -1))
                                        {
                                        Ndevice = vlGetNode(serveur_video,VL_DEVICE,0,0);
                                        Nemetteur = vlGetNode(serveur_video,VL_SRC,VL_VIDEO,VL_ANY);
                                        Nrecepteur = vlGetNode(serveur_video,VL_DRN,VL_SCREEN,VL_ANY);
                                        /* Acces aux deux noeuds necessaires.                                                        */
                                        chemin = vlCreatePath(serveur_video
                                                             ,((numero_de_device == -1) ? VL_ANY : numero_de_device)
                                                             ,Nemetteur,Nrecepteur
                                                              );
                                        /* Creation du chemin...                                                                     */
                                        if        (chemin >= 0)
                                                  {
                                                  vlAddNode(serveur_video,chemin,Nemetteur);
                                                  vlAddNode(serveur_video,chemin,Nrecepteur);
                                                  vlAddNode(serveur_video,chemin,Ndevice);
                                                  numero_de_device = vlGetDevice(serveur_video,chemin);
                                                  nom_de_device = liste_des_devices.devices[numero_de_device].name;
                                                  if        (vlSetupPaths(serveur_video
                                                                         ,(VLPathList)&chemin
                                                                         ,nombre_de_chemins
                                                                         ,VL_SHARE,VL_SHARE
                                                                          )
                                                             == 0)
                                        /* Etablissement du chemin...                                                                */
                                                            {
                                                            vlSelectEvents(serveur_video,chemin,VLNoEventsMask);

                                                            controles = vlGetControlList(serveur_video,chemin);
                                        /* Afin d'editer les controles disponibles pour ce chemin...                                 */
                                                            if        (controles != 0)
                                                                      {
                                                                      int                 indice;
                                                                      VLControlInfo       *liste=controles->controls;
                                                                      fprintf(stderr,"\n Nemetteur=%d",Nemetteur);
                                                                      fprintf(stderr,"\n Ndevice=%d",Ndevice);
                                                                      fprintf(stderr,"\n Nrecepteur=%d",Nrecepteur);
                                                                      fprintf(stderr,"\n nombre de controles pour ce chemin avant=%d\n"
                                                                            ,controles->numControls
                                                                             );
                                                                      for       (indice=0 ; indice<controles->numControls ; indice++)
                                                                                {
                                                                                fprintf(stderr,"\n%s (-->%d)",liste->name,liste->node);
                                                                                liste++;
                                                                                }
                                                                      fprintf(stderr,"\n");
                                                                      }
                                                            else
                                                                      {
                                                                      }

                                                            parametre_1(Ndevice
                                                                       ,intVal,0
                                                                       ,VL_DEFAULT_SOURCE,"VL_DEFAULT_SOURCE",""
                                                                        );
                                                            controles = vlGetControlList(serveur_video,chemin);
                                                            if        (controles != 0)
                                                                      {
                                                                      fprintf(stderr,"\n nombre de controles pour ce chemin apres=%d\n"
                                                                            ,controles->numControls
                                                                             );
                                        /* Nombre de controles disponibles apres le controle 'VL_DEFAULT_SOURCE'...                  */
                                                                      }
                                                            else
                                                                      {
                                                                      }
                                                            parametre_1(Ndevice
                                                                       ,intVal,VL_TIMING_625_SQ_PIX
                                                                       ,VL_TIMING,"VL_TIMING",""
                                                                        );
                                                            parametre_1(Nemetteur
                                                                       ,intVal,5
                                                                       ,VL_MUXSWITCH,"VL_MUXSWITCH",""
                                                                        );
                                        /* La valeur 5 correspond actuellement au magnetoscope VHS (3 etant le disque video)...      */
                                                            parametre_1(Nemetteur
                                                                       ,intVal,1
                                                                       ,1163264039,"1163264039",""
                                                                        );
                                                            parametre_1(Nemetteur
                                                                       ,intVal,1
                                                                       ,1163264023,"1163264023",""
                                                                        );
                                                            parametre_1(Nemetteur
                                                                       ,intVal,1
                                                                       ,1163264022,"1163264022",""
                                                                        );
                                                            parametre_1(Nemetteur
                                                                       ,intVal,1
                                                                       ,1163264027,"1163264027",""
                                                                        );
                                                            parametre_2(Nrecepteur
                                                                       ,fractVal
                                                                       ,numerator,1
                                                                       ,denominator,1
                                                                       ,VL_ZOOM,"VL_ZOOM",""
                                                                        );
                                        /* Programmation du format video...                                                          */
                                                            vlGetControl(serveur_video,chemin,Nrecepteur,VL_SIZE,¶metres);
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        C O N N E X I O N   E T   P R O G R A M M A T I O N   D U   S E R V E U R   X 1 1  :                                       */
/*                                                                                                                                   */
/*                                                                                                                                   */
                                                            display = XOpenDisplay(getenv("DISPLAY"));
                                        /* Ouverture du display X11.                                                                 */
                                                            if        (display != NULL)
                                                                      {
                                                                      indices.width = parametres.xyVal.x + 32;
                                        /* Le "+32" est destine a centrer l'image fenetre video dans la fenetre, ce que je n'arrive  */
                                        /* pas a faire autrement. Cette valeur a ete choisie afin qu'une image de type 'Pal' soit    */
                                        /* centree dans la fenetre video (on notera au passage qu'une image de type 'Std' ne l'est   */
                                        /* pas...).                                                                                  */
                                                                      indices.height = parametres.xyVal.y - 4;
                                                                      indices.x = 0;
                                                                      indices.y = 442;
                                                                      indices.flags = USPosition | USSize;
                                                                      attributs.event_mask = PropertyChangeMask | ButtonPressMask;
                                                                      fenetre = XCreateWindow(display
                                                                                             ,RACINE_DU_SYSTEME_HIERARCHIQUE
                                                                                             ,indices.x,indices.y
                                                                                             ,indices.width,indices.height
                                                                                             ,EPAISSEUR_DU_BORD_DES_FENETRES
                                                                                             ,CopyFromParent
                                                                                             ,CopyFromParent
                                                                                             ,CopyFromParent
                                                                                             ,CWEventMask
                                                                                             ,&attributs
                                                                                              );
                                                                      XSelectInput(display,fenetre,attributs.event_mask);
                                                                      XSetStandardProperties(display
                                                                                            ,fenetre
                                                                                            ,NOM_DE_LA_FENETRE
                                                                                            ,NOM_DE_SON_ICONE
                                                                                            ,None
                                                                                            ,NULL,0
                                                                                            ,&indices
                                                                                             );
                                        /* Creation de la fenetre...                                                                 */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        C O N N E X I O N   E N T R E   L A   V I D E O   E T   X 1 1  :                                                           */
/*                                                                                                                                   */
/*                                                                                                                                   */
                                                                      parametre_1(Nrecepteur
                                                                                 ,intVal,fenetre
                                                                                 ,VL_WINDOW,"VL_WINDOW",""
                                                                                  );
                                                                      XMapWindow(display,fenetre);
                                                                      XSync(display,False);
                                                                      XTranslateCoordinates(display
                                                                                           ,fenetre
                                                                                           ,RACINE_DU_SYSTEME_HIERARCHIQUE
                                                                                           ,0,0
                                                                                           ,¶metres.xyVal.x,¶metres.xyVal.y
                                                                                           ,&child_return
                                                                                            );
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        T R A N S F E R T   V I D E O  :                                                                                           */
/*                                                                                                                                   */
/*                                                                                                                                   */
                                                                      parametre_2(Nrecepteur
                                                                                 ,xyVal
                                                                                 ,x,parametres.xyVal.x+8
                                                                                 ,y,parametres.xyVal.y+1
                                                                                 ,VL_ORIGIN,"VL_ORIGIN",""
                                                                                  );
                                                                      transfert.mode = VL_TRANSFER_MODE_CONTINUOUS;
                                                                      transfert.count = 0;
                                                                      transfert.delay = 0;
                                                                      transfert.trigger = VLTriggerImmediate;
                                                                      if        (vlBeginTransfer(serveur_video,chemin,1,&transfert)
                                                                                 == 0)
                                        /* Lancement du transfert...                                                                 */
                                                                                {
                                                                                evenement.type = LASTEvent;
                                                                                while     (evenement.type != ButtonPress)
                                                                                          {
                                                                                          XNextEvent(display,&evenement);
                                                                                          }
                                        /* Attente arbitraire...                                                                     */
                                                                                vlEndTransfer(serveur_video,chemin);
                                        /* Arret du transfert...                                                                     */
                                                                                }
                                                                      else
                                                                                {
                                                                                fprintf(stderr,"\n transfert impossible");
                                                                                }
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        F I N  :                                                                                                                   */
/*                                                                                                                                   */
/*                                                                                                                                   */
                                                                      XCloseDisplay(display);
                                                                      }
                                                            else
                                                                      {
                                                                      fprintf(stderr,"\n impossible d'ouvrir le display X11");
                                                                      }
                                                            }
                                                  else
                                                            {
                                                            fprintf(stderr,"\n impossible d'etablir le chemin video");
                                                            }
                                                  parametre_1(Nemetteur
                                                             ,intVal,4
                                                             ,VL_MUXSWITCH,"VL_MUXSWITCH",""
                                                              );
                                        /* Afin de creer un etat de repos (noir...) et malgre le 'vlDestroyPath(...)' qui suit...    */
                                                  vlDestroyPath(serveur_video,chemin);
                                                  }
                                        else
                                                  {
                                                  fprintf(stderr,"\n impossible de creer le chemin video");
                                                  }
                                        }
                              else
                                        {
                                        fprintf(stderr,"\n le numero de device (%d) est mauvais",numero_de_device);
                                        }
                              }
                    else
                              {
                              fprintf(stderr,"\n impossible d'obtenir la liste des devices");
                              }
                    }
          else
                    {
                    fprintf(stderr,"\n impossible d'ouvrir le serveur video");
                    }

          vlCloseVideo(serveur_video);
          }



Copyright © Jean-François Colonna, 2021-2021.
Copyright © CMAP (Centre de Mathématiques APpliquées) UMR CNRS 7641 / Ecole Polytechnique, 2021-2021.