/*************************************************************************************************************************************/
/*                                                                                                                                   */
/*        T E S T   D E   L A   S O R T I 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.3 )  :                                                                 */
/*                                                                                                                                   */
/*                                                                                                                                   */
/*        Author of '$xtc/SGI_G.530.71$c' :                                                                                          */
/*                                                                                                                                   */
/*                    Jean-Francois Colonna (LACTAMME, AAAAMMJJhhmmss).                                                              */
/*                                                                                                                                   */
/*************************************************************************************************************************************/

#include  <stdio.h>
#include  <stdlib.h>

#include  <gl/gl.h>
#include  <gl/addrs.h>
#include  <gl/cg2vme.h>
#include  <gl/get.h>

#include  <gl/image.h>

#include  <svideo.h>
#include  <vl/vl.h>
#include  <vl/dev_ev1.h>

#define   DIMX                                                                                                                          \
                    SV_PAL_XMAX
#define   DIMY                                                                                                                          \
                    SV_PAL_YMAX
#define   X0                                                                                                                            \
                    0
#define   Y0                                                                                                                            \
                    0
#define   XM                                                                                                                            \
                    (dimX - 1)
#define   YM                                                                                                                            \
                    (dimY - 1)

#define   ROUGE                                                                                                                         \
                    3
#define   VERTE                                                                                                                         \
                    2
#define   BLEUE                                                                                                                         \
                    1
#define   gIMAGE(x,y,n)                                                                                                                 \
                    (*(((pointeur_sur_l_image) + (4*(((y)*dimX) + (x))+n))))                                                            \
                                        /* Acces a un point de l'image.                                                              */

#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;
     int       numero_de_device=-1;
     char      *nom_de_device;
     VLDevList liste_des_devices;
     VLNode    Nemetteur,Nrecepteur,Ndevice;
     int       nombre_de_chemins=1;
     VLPath    chemin;
     VLControlValue      parametres;
     VLControlList       *controles;
     int       taille_de_l_image;
     int       nombre_d_images=1;
     VLBuffer  image;
     char      *pointeur_sur_l_image;
     VLInfoPtr informations=0;
     int                           nombre_de_descripteurs=1;
     VLTransferDescriptor          descripteur;
     int       dimX=DIMX,dimY=DIMY;
     int       X,Y;

loop:
                                        /* Ah, l'horrible chose...                                                                   */

     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))
                                   {
                                   Nemetteur = vlGetNode(serveur_video,VL_SRC,VL_MEM,VL_ANY);
                                   Nrecepteur = vlGetNode(serveur_video,VL_DRN,VL_VIDEO,VL_ANY);
                                   Ndevice = vlGetNode(serveur_video,VL_DEVICE,0,0);
                                   if        (numero_de_device == -1)
                                             {
                                             if        ((chemin = vlCreatePath(serveur_video
                                                                              ,VL_ANY
                                                                              ,Nemetteur
                                                                              ,Nrecepteur
                                                                               )
                                                         ) < 0)
                                                       {
                                                       fprintf(stderr,"\n le chemin emetteur-->recepteur n'a pu etre etabli (1)...\n");
                                                       }
                                             else
                                                       {
                                                       }
                                             }
                                   else
                                             {
                                             if        ((chemin = vlCreatePath(serveur_video
                                                                              ,numero_de_device
                                                                              ,Nemetteur
                                                                              ,Nrecepteur
                                                                               )
                                                         ) < 0)
                                                       {
                                                       fprintf(stderr,"\n le chemin emetteur-->recepteur n'a pu etre etabli (2)...\n");
                                                       }
                                             else
                                                       {
                                                       }
                                             }
                                   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_READ_ONLY
                                                           )
                                        /* ATTENTION : 'VL_SHARE' pour pouvoir refaire un 'vlSetupPaths(...)' alors que 'VL_LOCK'    */
                                        /* provoquerait apres :                                                                      */
                                        /*                                                                                           */
                                        /*                  VL connection to :0.0 broken (explicit kill or server shutdown).         */
                                        /*                                                                                           */
                                        /* et 'VL_READ_ONLY' afin d'eviter :                                                         */
                                        /*                                                                                           */
                                        /*                  Bad access to the library                                                */
                                        /*                                                                                           */
                                        /* lors du 'VL_SYNC' qui suit...                                                             */
                                        /*                                                                                           */
                                              >= 0
                                              )
                                             {
                                             vlSelectEvents(serveur_video,chemin,VLSyncLostMask|VLTransferFailedMask);
                                        /* Selection d'aucun evenement...                                                            */

                                             parametre_1(Ndevice,intVal,VL_TIMING_625_SQ_PIX,VL_TIMING,"VL_TIMING","");
                                             parametre_1(Ndevice,intVal,1,VL_SYNC_SOURCE,"VL_SYNC_SOURCE","");
                                             parametre_1(Ndevice,intVal,VL_SYNC_GENLOCK,VL_SYNC,"VL_SYNC","");

                                             }
                                   else
                                             {
                                             fprintf(stderr,"\n le chemin emetteur-->recepteur n'a pu etre etabli (3)...\n");
                                             }

                                   if        (vlSetupPaths(serveur_video
                                                          ,(VLPathList)&chemin,nombre_de_chemins
                                                          ,VL_LOCK
                                                          ,VL_LOCK
                                                           )
                                              >= 0
                                              )
                                             {
                                             parametre_1(VL_ANY,intVal,VL_FORMAT_RGB,VL_FORMAT,"VL_FORMAT","");
                                        /* Programmation du timing...                                                                */

                                             parametre_1(Nrecepteur,boolVal,FALSE,VL_EV1_YG_SYNC,"VL_EV1_YG_SYNC","");
                                             vlGetControl(serveur_video,chemin,Nrecepteur,VL_EV1_DELAY_SYNC,¶metres);
                                             parametre_2(Nrecepteur
                                                        ,fractVal
                                                        ,numerator,58
                                                        ,denominator,parametres.fractVal.denominator
                                                        ,VL_EV1_DELAY_SYNC,"VL_EV1_DELAY_SYNC",""
                                                         );
                                             parametre_1(Nrecepteur,intVal,0,VL_EV1_BLANK_LINE,"VL_EV1_BLANK_LINE","");
                                             vlGetControl(serveur_video,chemin,Nrecepteur,VL_EV1_V_OFFSET,¶metres);
                                             parametre_2(Nrecepteur
                                                        ,fractVal
                                                        ,numerator,0
                                                        ,denominator,parametres.fractVal.denominator
                                                        ,VL_EV1_V_OFFSET,"VL_EV1_V_OFFSET",""
                                                         );
                                             vlGetControl(serveur_video,chemin,Nrecepteur,VL_EV1_H_OFFSET,¶metres);
                                             parametre_2(Nrecepteur
                                                        ,fractVal
                                                        ,numerator,772-42
                                                        ,denominator,parametres.fractVal.denominator
                                                        ,VL_EV1_H_OFFSET,"VL_EV1_H_OFFSET",""
                                                         );
                                             vlGetControl(serveur_video,chemin,Nrecepteur,VL_EV1_H_PHASE,¶metres);
                                             parametre_2(Nrecepteur
                                                        ,fractVal
                                                        ,numerator,46
                                                        ,denominator,parametres.fractVal.denominator
                                                        ,VL_EV1_H_PHASE,"VL_EV1_H_PHASE",""
                                                         );
                                        /* Programmation du timing...                                                                */

                                             parametre_1(VL_ANY,intVal,VL_PACKING_RGB_8,VL_PACKING,"VL_PACKING","");
                                        /* Mise en place du mode 'RVB' des points de l'image.                                        */
                                        /*                                                                                           */
                                        /* ATTENTION :                                                                               */
                                        /*                                                                                           */
                                        /*                  1-'VL_PACKING_YVYU_422_8' marche,                                        */
                                        /*                  2-'VL_PACKING_RGB_8' ne fonctionne pas (l'image n'apparait qu'apres      */
                                        /*                  le 'vlEndTransfer(...)').                                                */
                                        /*                                                                                           */
                                        /* La solution se situe au niveau du nombre de frames dans 'vlCreateBuffer(...)' ou le       */
                                        /* nombre de buffer demande a du etre multiplie par 2. Mais en fait, Ceci a ete corrige      */
                                        /* par 'Patch_SG0000294'...                                                                  */

                                             parametre_2(Nemetteur,xyVal,x,dimX,y,dimY,VL_SIZE,"VL_SIZE","");
                                        /* Mise en place de la taille des images,                                                    */
                                             vlGetControl(serveur_video,chemin,Nemetteur,VL_SIZE,¶metres);
                                             if        ((parametres.xyVal.x != dimX) || (parametres.xyVal.y != dimY))
                                                       {
                                                       fprintf(stderr,"\n la taille demandee (%d,%d) n'est pas supportee (1) --> (%d,%d)"
                                                             ,dimX,dimY
                                                             ,parametres.xyVal.x,parametres.xyVal.y
                                                              );

                                                       vlDestroyPath(serveur_video,chemin);
                                                       vlCloseVideo(serveur_video);
                                                       goto loop;
                                        /* Ah, l'horrible chose...                                                                   */
                                                       }
                                             else
                                                       {
                                                       }
                                             vlGetControl(serveur_video,chemin,Nrecepteur,VL_SIZE,¶metres);
                                             if        ((parametres.xyVal.x != dimX) || (parametres.xyVal.y != dimY))
                                                       {
                                                       fprintf(stderr,"\n la taille demandee (%d,%d) n'est pas supportee (2) --> (%d,%d)"
                                                             ,dimX,dimY
                                                             ,parametres.xyVal.x,parametres.xyVal.y
                                                              );

                                                       vlDestroyPath(serveur_video,chemin);
                                                       vlCloseVideo(serveur_video);
                                                       goto loop;
                                        /* Ah, l'horrible chose...                                                                   */
                                                       }
                                             else
                                                       {
                                                       }
                                        /* Et verification de compatibilite...                                                       */
                                             taille_de_l_image = vlGetTransferSize(serveur_video,chemin);
                                        /* Transfert de la taille de l'image...                                                      */
                                             image = vlCreateBuffer(serveur_video,chemin,Nemetteur,nombre_d_images+0);
                                        /* Creation des buffers necessaires...                                                       */

                                             if        (image != NULL)
                                                       {
                                                       vlRegisterBuffer(serveur_video,chemin,Nemetteur,image);

                                                       do
                                                                 {
                                                                 informations = vlGetNextFree(serveur_video,image,taille_de_l_image);
                                                                 }
                                                       while     ((informations==0) || (vlBufferDone(image)<0));
                                        /* ATTENTION, d'apres '/usr/people/4Dgifts/examples/dmedia/video/vl/simplem2v$c', il         */
                                        /* faudrait mettre :                                                                         */
                                        /*                                                                                           */
                                        /*                  while     ((!informations) && (!vlBufferDone(image)));                   */
                                        /*                                                                                           */
                                        /* mais, le 'man' dit autre chose...                                                         */
                                                       pointeur_sur_l_image = vlGetActiveRegion(serveur_video,image,informations);
                                                       if        (pointeur_sur_l_image != NULL)
                                                                 {
                                                                 for       (Y=Y0 ; Y<=YM ; Y++)
                                                                           {
                                                                           for       (X=X0 ; X<=XM ; X++)
                                                                                     {
                                                                                     gIMAGE(X,Y,ROUGE)=X;
                                                                                     gIMAGE(X,Y,VERTE)=Y;
                                                                                     gIMAGE(X,Y,BLEUE)=X+Y;
                                                                                     }
                                                                           }

                                                                 vlPutValid(serveur_video,image);

                                                                 descripteur.mode = VL_TRANSFER_MODE_DISCRETE;
                                                                 descripteur.count = nombre_d_images;
                                                                 descripteur.delay = 0;
                                                                 descripteur.trigger = VLTriggerImmediate;
                                                                 if        (vlBeginTransfer(serveur_video
                                                                                           ,chemin
                                                                                           ,nombre_de_descripteurs
                                                                                           ,&descripteur
                                                                                            ) != 0)
                                                                           {
                                                                           fprintf(stderr,"\n probleme de transfert...\n");
                                                                           }
                                                                 else
                                                                           {
                                                                           }

                                                                 sleep(1);

                                                                 vlPutFree(serveur_video,image);
                                                                 vlEndTransfer(serveur_video,chemin);
                                                                           {
                                                                           int       events,Kevents;
                                                                           sleep(1);
                                                                           events=vlPending(serveur_video);
                                                                           for       (Kevents=1 ; Kevents<=events ; Kevents++)
                                                                                     {
                                                                                     VLEvent evenement;
                                                                                     vlNextEvent(serveur_video,&evenement);
                                                                                     printf("\n evenement=%d",evenement.reason);
                                                                                     }
                                                                           }
                                                                 }
                                                       else
                                                                 {
                                                                 fprintf(stderr,"\n impossible d'atteindre le buffer d'image...\n");
                                                                 }
                                                       vlDeregisterBuffer(serveur_video,chemin,Nemetteur,image);
                                                       }
                                             else
                                                       {
                                                       fprintf(stderr,"\n les buffers necessaires n'ont pu etre alloues...\n");
                                                       }

                                             vlDestroyBuffer(serveur_video,image);
                                             vlDestroyPath(serveur_video,chemin);
                                             }
                                   else
                                             {
                                             fprintf(stderr,"\n le chemin emetteur-->recepteur n'a pu etre etabli (4)...\n");
                                             }
                                   }
                         else
                                   {
                                   fprintf(stderr,"\n le numero de device est incorrect...\n");
                                   }
                         }
               else
                         {
                         fprintf(stderr,"\n impossible d'obtenir la liste des devices...\n");
                         }
               vlCloseVideo(serveur_video);
               }
     else
               {
               fprintf(stderr,"\n impossible d'ouvrir la video...\n");
               }
     }



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