/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N S D E S F O N C T I O N S D U */
/* D I S Q U E V I D E O ' B E T A - P A L ' ( S O N Y 'LVS6000P-LVR6000' O U 'LVR4000P' ) */
/* E T D U M A G N E T O S C O P E ' B E T A - P A L ' ( S O N Y 'UVW1400P' ) : ) */
/* */
/* */
/* Definition : */
/* */
/* Dans ce fichier, se trouvent toutes */
/* les definitions de macros relatives */
/* aux fonctions. */
/* */
/* */
/* Author of '$xiidP/fonct$vv$DEF' : */
/* */
/* Jean-Francois Colonna (LACTAMME, 19890000000000). */
/* */
/*************************************************************************************************************************************/
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I T I O N D U F O R M A T D E S I M A G E S ' P a l ' : */
/* */
/* */
/* Nota : */
/* */
/* Le format des images 'Pal', sur : */
/* */
/* 'SYSTEME_SG4D20G_IRIX_CC', */
/* 'SYSTEME_SG4D25TG_IRIX_CC', */
/* 'SYSTEME_SG4D310VGX_IRIX_CC', */
/* 'SYSTEME_SG4D35TG_IRIX_CC', */
/* 'SYSTEME_SG4D85GT_IRIX_CC', */
/* 'SYSTEME_SGIND308_IRIX_CC', */
/* 'SYSTEME_SGIND324_IRIX_CC', */
/* 'SYSTEME_SGIND3GA_IRIX_CC', */
/* 'SYSTEME_SGIND408_IRIX_CC', */
/* 'SYSTEME_SGIND424_IRIX_CC', */
/* 'SYSTEME_SGIND4GA_IRIX_CC', */
/* 'SYSTEME_SGIND508_IRIX_CC', */
/* 'SYSTEME_SGIND524_IRIX_CC', */
/* 'SYSTEME_SGIND5GA_IRIX_CC', */
/* 'SYSTEME_SGIND808_IRIX_CC', */
/* 'SYSTEME_SGIND824_IRIX_CC', */
/* 'SYSTEME_SGIND8GA_IRIX_CC', */
/* 'SYSTEME_SGINDA08_IRIX_CC', */
/* 'SYSTEME_SGINDA24_IRIX_CC', */
/* 'SYSTEME_SGINDAGA_IRIX_CC', */
/* 'SYSTEME_SGO200A1_IRIX_CC', */
/* 'SYSTEME_SGO200A2_IRIX_CC', */
/* 'SYSTEME_SGO200A4_IRIX_CC', */
/* 'SYSTEME_SGO25224_IRIX_CC', */
/* 'SYSTEME_SGO252VA_IRIX_CC', */
/* 'SYSTEME_SGO252VN_IRIX_CC', */
/* 'SYSTEME_SGPCM801_IRIX_CC', */
/* 'SYSTEME_SGPCMA01_IRIX_CC'. */
/* */
/* est defini dans '$xiidG/fonction$DEF. Sur les */
/* autres SYSTEMEs, il faut bien le definir */
/* quand meme, et c'est ici que c'est le */
/* plus logique... On fera donc attention */
/* a l'ordre des includes 'image_drive_SiliG_FONCTION_1_DEF' */
/* et 'image_drive_diskP_FONCTION_DEF' dans le fichier */
/* '$xi/INCLUDES_min$I'. */
/* */
/*************************************************************************************************************************************/
/* La fonction 'GvalDefaut(...)' a ete introduite le 20100408130019 (bien tardivement...). */
#TestADef XminPal \
GvalDefaut("XminPal",COORDONNEE_MINIMALE) \
/* Definition de l'abscisse minimale d'une image au format 'Pal', */
#TestADef XmaxPal \
GvalDefaut("XmaxPal",779) \
/* Definition de l'abscisse maximale d'une image au format 'Pal'. */
#TestADef dimXPal \
DIMENSION(XminPal,XmaxPal) \
/* Definition de la dimension de l'axe 'OX' d'une image au format 'Pal' (ceci fut introduit */ \
/* le 20100408182925). */
#TestADef YminPal \
GvalDefaut("YminPal",COORDONNEE_MINIMALE) \
/* Definition de l'ordonnee minimale d'une image au format 'Pal', */
#TestADef YmaxPal \
GvalDefaut("YmaxPal",574) \
/* Definition de l'ordonnee maximale d'une image au format 'Pal'. */
#TestADef dimYPal \
DIMENSION(YminPal,YmaxPal) \
/* Definition de la dimension de l'axe 'OY' d'une image au format 'Pal' (ceci fut introduit */ \
/* le 20100408182925). */
#TestADef dimXYPal \
MUL2(dimXPal,dimYPal) \
/* Definition de la dimension d'une image au format 'Pal' (ceci fut introduit */ \
/* le 20100408182925). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* 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 sDKVP
/* ATTENTION, la variable '$sDKVP' est a priori systematiquement definie dans le fichier */
/* 'v $Fmachines sDKVP' , mais n'est transmise a '$xiidP/fonct$vv$DEF' que sur la MACHINE */
/* '$sDKVP' et ce grace au fichier 'v $xcc/cpp$D/cpp$Y sDKVP' appele par '$xcc/cpp$Z'... */
# define __VERSION__COMPILER_LA_GESTION_DU_DISQUE_PAL_BETA \
/* Compiler la bibliotheque de gestion du disque PAL-Beta... */
#Aifdef sDKVP
#Eifdef sDKVP
#ifdef __VERSION__COMPILER_LA_GESTION_DU_DISQUE_PAL_BETA
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D U D I S Q U E U T I L I S E : */
/* */
/* */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* * * * ** * * * * * ** * */
/* * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * */
/* * * * * * * * * * * * * * * * */
/* * * * * ** * * * * * ** */
/* * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* */
/* ATTENTION : */
/* */
/* Les trois symboles qui sont definis (par */
/* '#define') ou non definis (par '#nodefine') */
/* ci-apres sont en fait et en general definis */
/* dans les commandes 'v $xci/disk_video_P$K' et */
/* 'v $xci/magneto_P$K'... */
/* */
/* De plus, le fichier '$xiidP/fonct$vv$FON' */
/* ne depend pas du choix qui est fait ci-apres entre */
/* les differentes MACHINEs possibles... */
/* */
/*************************************************************************************************************************************/
# if ( (! defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
&& (! defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
&& (! defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# define __VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P
# nodefine __VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000
# nodefine __VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P
/* Choix de la machine implicite... */
/* */
/* Le 20030314093814, les symboles 'GESTION_D_UN_*' ont ete changes en */
/* '__VERSION__GESTION_D_UN_*' afin de permettre leur recuperation dans */
/* 'v $xcc/cpp$Z _VERSION_'. */
# Aif ( (! defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
&& (! defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
&& (! defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# Eif ( (! defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
&& (! defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
&& (! defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* B U G S D E L ' A C C E S A U D I S Q U E V I D E O P A L - B E T A : */
/* */
/*************************************************************************************************************************************/
# if ( (defined(SYSTEME_APC_LinuxDebian_GCC)) \
|| (defined(SYSTEME_APC_LinuxMandrake_GCC)) \
|| (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_ICC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_ICC)) \
)
/* Ce test ete introduit le 20041110000507 car il manquait... */
# define BUG_SYSTEME_PAL_BETA_IMPOSSIBLE_DE_PURGER_LE_BUFFER_DES_CARACTERES_EN_ATTENTE_DANS_IKPopen_disque_video \
/* Ce bug a ete introduit le 20041109161155, lors du remplacement de '$LACT12' par */ \
/* '$LACT16' en tant que '$sDKVP'. En effet, lors du 'IKPopen_disque_video(...)', il y a */ \
/* un 'Read(...)' destine a purger le buffer des caracteres en attente. Sur '$LACT16', ce */ \
/* 'Read(...)' indefiniment avec le message : */ \
/* */ \
/* read(3,...,1) = -1 EAGAIN (Resource temporarily unavailable) */ \
/* */ \
/* ce que j'ai pu voir grace a '/usr/bin/strace' ou grace a l'option "editer=VRAI" dans */ \
/* 'v $xci/disk_video_P$K editer=' ; le resultat du 'Read(...)' est toujours different de */ \
/* 'FICHIER_VIDE'. Il faut donc, modifier cette facilite en remplacant un 'IFNE(...)' par */ \
/* un 'IFGT(...)'... */
# Aif ( (defined(SYSTEME_APC_LinuxDebian_GCC)) \
|| (defined(SYSTEME_APC_LinuxMandrake_GCC)) \
|| (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_ICC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_ICC)) \
)
# Eif ( (defined(SYSTEME_APC_LinuxDebian_GCC)) \
|| (defined(SYSTEME_APC_LinuxMandrake_GCC)) \
|| (defined(SYSTEME_APC_LinuxRedHat_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_GCC)) \
|| (defined(SYSTEME_APC_LinuxUbuntu_ICC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_GCC)) \
|| (defined(SYSTEME_APC_LinuxUlmint_ICC)) \
)
# TestADef BUG_SYSTEME_PAL_BETA_Read \
/* Ce bug necessite la presence d'un buffer intermediaire d'un caractere lors de lectures */ \
/* de donnees en provenance du disque ('LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA()'). */
# if ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# TestADef BUG_SYSTEME_PAL_BETA_PAL_BETA_REPETITIONS \
/* Ce bug se produit lorsque l'on repete une sequence d'images avec repetitions. Soit la */ \
/* suite a repeter 'R' fois : */ \
/* */ \
/* I , I ,..., I , I */ \
/* 1 2 n-1 n */ \
/* */ \
/* on obtiendra pour les 'R-1' premieres fois : */ \
/* */ \
/* I , I ,..., I */ \
/* 1 2 n-1 */ \
/* */ \
/* et pour la derniere iteration ('R') : */ \
/* */ \
/* I , I ,..., I , I */ \
/* 1 2 n-1 n */ \
/* */ \
/* Le 1996022200 j'ai observe une autre anomalie liee a celle-ci en visualisant la sequence */ \
/* suivante avec repetitions : */ \
/* */ \
/* xivPdf 7 2 / 007042_007058 repetitions=4 */ \
/* */ \
/* le phenomene percu (uniquement s'il y a repetitions) est le suivant ; sur les 'R-1' */ \
/* premieres repetitions (dans ce cas '3') on voit en haut de l'image '007058' (la derniere) */ \
/* une petite bande horizontale qui visiblement appartient a l'image suivante '007059'. */
# TestADef BUG_SYSTEME_PAL_BETA_PAL_BETA_REPETITIONS_99 \
/* Ce bug fait que l'on ne peut pas demander plus de 99 repetitions d'une sequence. Cela */ \
/* est-il un hasard si cela correspond au passage de 2 a 3 chiffres decimaux ? */
# TestADef BUG_SYSTEME_PAL_BETA_PAL_BETA_F_SCAN \
/* Ce bug se produit lorsque l'on essaye d'utiliser la fonction 'PAL_BETA_F_SCAN' comme */ \
/* les autres fonctions de lecture, c'est-a-dire en precisant une adresse de debut et une */ \
/* adresse de fin ; le disque renvoie alors 'NON_ACQUITTEMENT_DU_DISQUE'... */
# Aif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# if ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
)
# TestADef BUG_SYSTEME_PAL_BETA_LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA \
/* Ce bug documente dans 'v $xtc/disk_vi_P.11$c' fait qu'une duree importante s'ecoule lors */ \
/* de 'LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA()' entre la demande de positionnement et le */ \
/* positionnement effectif sur une piste numerique. De plus, lors du retour aux pistes */ \
/* analogiques, il y a un passage par l'adresse '08523' (dont le contenu apparait */ \
/* systematiquement noir) avant d'aller a l'adresse effectivement demandee. */ \
/* */ \
/* Monsieur Cagna (49 45 41 08) de chez Sony m'a appele le 1996041800 car il avait dans */ \
/* son laboratoire un 'LVR4000P' ; nous avons donc fait l'essai suivant : */ \
/* */ \
/* PAL_BETA_SEARCH */ \
/* une adresse "numerique" (par exemple '90001') */ \
/* PAL_BETA_ENTER */ \
/* */ \
/* le disque va a l'adresse demandee en s'arretant un peu en '36251' ; puis nous avons fait */ \
/* l'essai : */ \
/* */ \
/* PAL_BETA_SEARCH */ \
/* une adresse "analogique" (par exemple '1') */ \
/* PAL_BETA_ENTER */ \
/* */ \
/* le disque va a l'adresse demandee en s'arretant un peu en cours de route. Ainsi le defaut */ \
/* semble general (malheureusement...). */
# Aif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
)
# if ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# Aif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# if ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# Aif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N S G E N E R A L E S P O U R L E D I S Q U E V I D E O P A L - B E T A : */
/* */
/*************************************************************************************************************************************/
# define PREMIERE_IMAGE_PAL_BETA \
ZERO \
/* Numero de la premiere image sur le disque video PAL-Beta, */
# define LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
ZERO \
/* Argument "dummy" utilise lorsque 'NE_PAS_LIRE_DES_DONNEES_NUMERIQUES'... */
# if ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# define PREMIERE_IMAGE_ENREGISTRABLE_PAL_BETA \
SUCC(PREMIERE_IMAGE_PAL_BETA) \
/* Numero de la premiere image enregistrable sur le disque video PAL-Beta. */
# define DERNIERE_IMAGE_PAL_BETA \
PRED(36251) \
/* Numero de la derniere image sur le disque video PAL-Beta. */ \
/* */ \
/* ATTENTION, cette valeur est recuperee par '$Fdisk_video_P' afin de ne pas definir a */ \
/* deux endroits differents le meme parametre ('DERNIERE_IMAGE_PAL_BETA' et 'imageN_DKVP'). */ \
/* */ \
/* ATTENTION, jusqu'au 1994111700, il y a eu ici : */ \
/* */ \
/* # define DERNIERE_IMAGE_PAL_BETA \ */ \
/* PARE(36251) */ \
/* */ \
/* Or malheureusement, lors de l'enregistrement de la sequence : */ \
/* */ \
/* xivPdf 1 1 / 036135_036262 */ \
/* */ \
/* pour la premiere fois, on s'est heurte a cette limite. Il y a eu alors une erreur faisant */ \
/* que l'enregistrement de l'image '036251' n'a pas ete possible ; cette sequenec est donc */ \
/* devenue la sequence : */ \
/* */ \
/* xivPdf 1 1 / 036135_036250 */ \
/* */ \
/* La raison est simple ; en effet, la procedure : */ \
/* */ \
/* ENREGISTREMENT_D_UNE_SEQUENCE_PAL_BETA(adresse_de_debut,adresse_de_fin) */ \
/* */ \
/* utilise le point de montage suivant : */ \
/* */ \
/* [NEUT(adresse_de_debut),SUCC(adresse_de_fin)] */ \
/* */ \
/* la derniere piste du disque (soit '036251') est donc inaccessible en enregistrement (a */ \
/* cause du 'SUCC(...)'). */
# define PREMIERE_ZONE_DE_DONNEES_PAL_BETA \
PARE(90001) \
/* Numero de la premiere zone de donnees ('user data') sur le disque video PAL-Beta, */ \
/* */ \
/* ATTENTION, cette valeur est recuperee par '$Fdisk_video_P' afin de ne pas definir a */ \
/* deux endroits differents le meme parametre ('PREMIERE_ZONE_DE_DONNEES_PAL_BETA' et */ \
/* 'Idisque_DKVP'). */
# define DERNIERE_ZONE_DE_DONNEES_PAL_BETA \
ADD2(PREMIERE_ZONE_DE_DONNEES_PAL_BETA,PRED(DEUXp10)) \
/* Numero de la derniere zone de donnees ('user data') sur le disque video PAL-Beta. */
= define NOMBRE_DE_CHIFFRES_PAL_BETA \
NOMBRE_DE_CHIFFRES_DECIMAUX(MAX2(DERNIERE_IMAGE_PAL_BETA,DERNIERE_ZONE_DE_DONNEES_PAL_BETA)) \
/* Nombre de chiffres necessaires a coder en decimal un numero d'image du disque PAL-Beta. */ \
/* */ \
/* La procedure 'NOMBRE_DE_CHIFFRES_DECIMAUX(...)' fut introduite le 20051210182403... */
# define LONGUEUR_DES_BLOCS_DE_DONNEES_PAL_BETA \
SOIXANTE_QUATRE \
/* Longueur fixe des blocs de donnees numeriques sur le disque video PAL-Beta. */
# define LONGUEUR_MAXIMALE_DES_REPONSES_DU_DISQUE_PAL_BETA \
ADD2(LONGUEUR_DES_BLOCS_DE_DONNEES_PAL_BETA,UN) \
/* Longueur maximale a priori des reponses envoyees par le disque, ce qui correspond */ \
/* aux donnees numeriques (64), plus leur "check-sum" (+1)... */
= define LONGUEUR_MAXIMALE_D_UNE_COMMANDE_DU_DISQUE_PAL_BETA \
ADD2(LONGUEUR_MAXIMALE_DES_REPONSES_DU_DISQUE_PAL_BETA,SIZC(C_VIDE))
/* Longueur maximale des commandes envoyees au disque video PAL-Beta ; on la rencontre */
/* lorsqu'on transmet des blocs de donnees numeriques. */
# Aif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# if ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# define PREMIERE_IMAGE_ENREGISTRABLE_PAL_BETA \
NEUT(PREMIERE_IMAGE_PAL_BETA) \
/* Numero de la premiere image enregistrable sur le disque video PAL-Beta. */
# define DERNIERE_IMAGE_PAL_BETA \
INFINI \
/* Numero de la derniere image sur le disque video PAL-Beta. */
/* On notera que 'TAILLE_DES_PAQUETS_HHMMSSII' et 'NOMBRE_DE_PAQUETS_HHMMSSII' doivent */
/* etre definis avant 'NOMBRE_DE_CHIFFRES_PAL_BETA' qui suit et qui lui est defini en */
/* '$PASSE_2'. */
# define TAILLE_DES_PAQUETS_HHMMSSII \
CENT \
/* "Taille des paquets" decimaux dans lesquels on met l'heure, les minutes, les secondes */ \
/* et le numero de l'image. */
# define NOMBRE_DE_PAQUETS_HHMMSSII \
QUATRE \
/* Et leur nombre... */
/* On notera que 'TAILLE_DES_PAQUETS_HHMMSSII' et 'NOMBRE_DE_PAQUETS_HHMMSSII' doivent */
/* etre definis avant 'NOMBRE_DE_CHIFFRES_PAL_BETA' qui suit et qui lui est defini en */
/* '$PASSE_2'. */
= define NOMBRE_DE_CHIFFRES_PAL_BETA \
MUL2(NOMBRE_DE_PAQUETS_HHMMSSII,NOMBRE_DE_CHIFFRES_DECIMAUX(TAILLE_DES_PAQUETS_HHMMSSII)) \
/* Nombre de chiffres necessaires a coder en decimal un numero d'image du disque PAL-Beta. */ \
/* */ \
/* La procedure 'NOMBRE_DE_CHIFFRES_DECIMAUX(...)' fut introduite le 20051210182403. On */ \
/* notera qu'avant cette date figurait ici : */ \
/* */ \
/* INTE(LO1X(TAILLE_DES_PAQUETS_HHMMSSII)) */ \
/* */ \
/* et il semble donc qu'il manquait une incrementation d'une unite... */
# define LONGUEUR_MAXIMALE_DES_REPONSES_DU_DISQUE_PAL_BETA \
LONGUEUR_DU_BLOC_D_ETAT_PAL_BETA \
/* Longueur maximale a priori des reponses envoyees par le magnetoscope, ce qui correspond */ \
/* a l'etat de celui-ci... */
= define LONGUEUR_MAXIMALE_D_UNE_COMMANDE_DU_DISQUE_PAL_BETA \
ONZE \
/* Longueur maximale des commandes envoyees au disque video PAL-Beta ; on la rencontre */
/* avec la commande 'PAL_BETA_SEARCH_WITH_DATA'... */
# Aif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# define LONGUEUR_DU_BLOC_D_ETAT_PAL_BETA \
CINQ \
/* Longueur fixe du bloc donnant l'etat du disque video PAL-Beta. */
# if ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# define LONGUEUR_DU_BLOC_D_ADRESSE_COURANTE_PAL_BETA \
NOMBRE_DE_CHIFFRES_PAL_BETA \
/* Longueur fixe du bloc donnant l'adresse courante du disque video PAL-Beta. */
# Aif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* A D R E S S A G E D U D I S Q U E V I D E O P A L - B E T A : */
/* */
/*************************************************************************************************************************************/
# if ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# define ADRESSAGE_PAL_BETA(adresse) \
NEUT(adresse) \
/* Fonction de passage des adresses "externes" (celles vues par les programmes utilisant */ \
/* le disque) et les adresses "internes" (celles connues du disque). */
# Aif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# if ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# define IMAGE_DANS_LA_SECONDE(adresse) \
NEUT(NEUT(REST(adresse,IMAGES_PAR_SECONDE))) \
/* Numero d'une image par rapport a une seconde. */
# define SECONDE_DANS_LA_MINUTE(adresse) \
NEUT(REST(QUOD(adresse,IMAGES_PAR_SECONDE),SECONDES_PAR_MINUTE)) \
/* Numero d'une seconde par rapport a une minute. */
# define MINUTE_DANS_L_HEURE(adresse) \
REST(QUOD(QUOD(adresse,IMAGES_PAR_SECONDE),SECONDES_PAR_MINUTE),MINUTES_PAR_HEURE) \
/* Numero d'une minute par rapport a une heure. */
# define HEURE_DANS_LE_JOUR(adresse) \
QUOD(QUOD(QUOD(adresse,IMAGES_PAR_SECONDE),SECONDES_PAR_MINUTE),MINUTES_PAR_HEURE) \
/* Numero d'une heure par rapport a un jour. */
# define ADRESSAGE_PAL_BETA(adresse) \
AXPB(AXPB(AXPB(HEURE_DANS_LE_JOUR(adresse) \
,TAILLE_DES_PAQUETS_HHMMSSII \
,MINUTE_DANS_L_HEURE(adresse) \
) \
,TAILLE_DES_PAQUETS_HHMMSSII \
,SECONDE_DANS_LA_MINUTE(adresse) \
) \
,TAILLE_DES_PAQUETS_HHMMSSII \
,IMAGE_DANS_LA_SECONDE(adresse) \
) \
/* Fonction de passage des adresses "externes" (celles vues par les programmes utilisant */ \
/* le disque) et les adresses "internes" (celles connues du disque). */
# Aif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N D E S E C H A N G E S P O U R L E D I S Q U E V I D E O P A L - B E T A : */
/* */
/*************************************************************************************************************************************/
# define UN_ACQUITTEMENT_PAR_CARACTERE \
VRAI \
/* En general, il faut attendre un caractere d'acquittement ('ACQUITTEMENT_DU_DISQUE') par */ \
/* caractere ecrit, */
# define PAS_D_ACQUITTEMENT_INDIVIDUEL_DES_CARACTERES \
NOTL(UN_ACQUITTEMENT_PAR_CARACTERE) \
/* Sauf lorsqu'on transmet des donnees numeriques... */ \
/* caractere ecrit, */
# define ATTENTE_ASYNCHRONE_PAL_BETA \
VRAI \
/* Valeur de l'indicateur logique 'attendre_une_reponse_multiple', lorsque la commande */ \
/* envoyee envoie quelque chose de plus que 'ACQUITTEMENT_DU_DISQUE'... */
# define PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
NOTL(ATTENTE_ASYNCHRONE_PAL_BETA) \
/* Valeur de l'indicateur logique 'attendre_une_reponse_multiple', lorsque la commande */ \
/* n'envoie que 'ACQUITTEMENT_DU_DISQUE'... */
# define LIRE_DES_DONNEES_NUMERIQUES \
VRAI \
/* Valeur de l'indicateur logique 'lire_des_donnees_numeriques', lorsque la commande */ \
/* doit en plus lire un bloc de donnees numeriques... */
# define NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
NOTL(LIRE_DES_DONNEES_NUMERIQUES) \
/* Valeur de l'indicateur logique 'lire_des_donnees_numeriques', lorsque la commande */ \
/* ne doit pas lire un bloc de donnees numeriques, ce qui est en general le cas... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N S D I V E R S E S P O U R L E D I S Q U E V I D E O P A L - B E T A : */
/* */
/*************************************************************************************************************************************/
# define REPETER_UNE_FOIS_UNE_SEQUENCE_PAL_BETA \
UN \
/* Afin de ne repeter qu'une seule fois une sequence... */
# define VITESSE_NOMINALE_PAL_BETA \
UN \
/* Definit la vitesse nominale utilisee pour preciser un ralenti ou un accelere qui sont */ \
/* precisemment egaux a cette meme vitesse... */
# define RALENTI_FAIBLE_PAL_BETA \
VITESSE_NOMINALE_PAL_BETA \
/* Ralenti le plus faible (correspond a 1/1 de la vitesse nominale), */
# define RALENTI_FORT_PAL_BETA \
MOCD \
/* Ralenti le plus fort (correspond a 1/255 de la vitesse nominale), */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* D E F I N I T I O N S D U " C H E C K - S U M " D U D I S Q U E V I D E O P A L - B E T A : */
/* */
/*************************************************************************************************************************************/
# define AVEC_CHECK_SUM_PAL_BETA \
VRAI \
/* Lorsqu'un "check-sum" est necessaire a la fin d'une chaine de caracteres. */
# define SANS_CHECK_SUM_PAL_BETA \
NOTL(AVEC_CHECK_SUM_PAL_BETA) \
/* Lorsqu'un "check-sum" n'est pas necessaire a la fin d'une chaine de caracteres. */
# define INITIALISATION_DU_CHECK_SUM_PAL_BETA \
DEFV(CHAR,INIT(check_sum,CARA(ZERO))); \
/* Initialisation a zero du 'check-sum'... */
# define MISE_A_JOUR_DU_CHECK_SUM_PAL_BETA(chaine,index) \
DECR(check_sum,ITb1(chaine,INDX(index,PREMIER_CARACTERE))); \
/* Calcul progressif du "check-sum" par soustraction toute bete ; on notera le modulo */ \
/* implicite qui est ainsi fait. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E N E R A T I O N D E S C O M M A N D E S A U D I S Q U E V I D E O P A L - B E T A : */
/* */
/*************************************************************************************************************************************/
# define VALIDATION_DE_LA_FONCTION_D_UNE_COMMANDE_DISQUE_PAL_BETA(Commande,fonction) \
Bblock \
Test(IFNE(fonction,CARA(fonction))) \
Bblock \
PRINT_ERREUR("la fonction demandee ne tient pas sur un octet"); \
CAL1(Prer1("fonction = %08x\n",fonction)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Validation de la fonction demandee (en fait qu'elle tienne sur un octet)... */
= define MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,caractere_argument) \
Bblock \
EGAL(ITb1(Commande,INDX(index,PREMIER_CARACTERE)),caractere_argument); \
/* Mise en place du caractere courant. */ \
\
Test(IFLT(LENG(PREMIER_CARACTERE,PRED(index)),LONGUEUR_MAXIMALE_D_UNE_COMMANDE_DU_DISQUE_PAL_BETA)) \
Bblock \
INCR(index,I); \
/* Progression de l'index pour le caractere suivant eventuel... */ \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("la commande courante est trop longue"); \
Eblock \
ETes \
Eblock
/* Mise en place d'un caractere dans une commande quelconque, mais ATTENTION, avec */
/* progression de l'index de rangement 'index'... */
= define MISE_A_JOUR_C_COMMANDE_DISQUE_PAL_BETA(Commande,chaine_argument,generer_un_check_sum) \
Bblock \
INITIALISATION_DU_CHECK_SUM_PAL_BETA; \
/* A priori, on initialise le "check-sum", meme s'il ne faut pas le calculer... */ \
\
Komp(numero_du_caractere_courant,chain_Xtaille(chaine_argument)) \
Bblock \
Test(IL_FAUT(generer_un_check_sum)) \
Bblock \
MISE_A_JOUR_DU_CHECK_SUM_PAL_BETA(chaine_argument,index); \
/* Calcul progressif du "check-sum" par soustraction toute bete, lorsqu'il a ete demande ; */ \
/* on notera le modulo implicite qui est ainsi fait ; on notera que ce calcul de "check-sum" */ \
/* est fait avant 'MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA()', car en effet, cette derniere */ \
/* incremente 'index'... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,ITb1(chaine_argument,INDX(index,PREMIER_CARACTERE))); \
/* Mise en place du caractere courant de la chaine argument, en excluant 'END_OF_CHAIN'. */ \
Eblock \
EKom \
\
Test(IL_FAUT(generer_un_check_sum)) \
Bblock \
MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,check_sum); \
/* Mise en place du "check-sum" s'il a ete demande. Ce "check-sum" est donc tel qu'ajoute a */ \
/* la somme modulo un octet des caracteres, on trouve zero... */ \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock
/* Mise en place d'ne chaine de caracteres dans une commande quelconque... */
% define GENERATION_COMMANDE_DISQUE_PAL_BETA_nn(Commande,sequence_d_initialisation,longueur_de_la_commande) \
Bblock \
DEFV(Int,INIT(index,PREMIER_CARACTERE)); \
/* Index de la chaine argument de commande. */ \
BLOC(sequence_d_initialisation); \
/* Mise en place de tous les arguments... */ \
EGAL(longueur_de_la_commande,LENG(PREMIER_CARACTERE,PRED(index))); \
/* Ainsi, on calcule la longueur de la commande avant l'insertion du 'END_OF_CHAIN' ; on */ \
/* notera la presence du 'PRED(index)' du au fait qu'on a fait un 'INCR(index,I)' de trop... */ \
MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,END_OF_CHAIN); \
/* Ainsi, on fait de la commande une chaine standard... */ \
Eblock
/* Generation d'une commande a 'n' arguments definis en fait dans le 'BLOC' de la sequence */
/* d'initialisation argument. */
% define GENERATION_COMMANDE_DISQUE_PAL_BETA__01(Commande,fonction,longueur_de_la_commande) \
Bblock \
VALIDATION_DE_LA_FONCTION_D_UNE_COMMANDE_DISQUE_PAL_BETA(Commande,fonction); \
\
GENERATION_COMMANDE_DISQUE_PAL_BETA_nn(Commande \
,BLOC(MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,fonction); \
/* Mise en place du premier argument... */ \
) \
,longueur_de_la_commande \
); \
Eblock
/* Generation d'une commande a un argument 'fonction'. */
% define GENERATION_COMMANDE_DISQUE_PAL_BETA__02(Commande,fonction,data1,longueur_de_la_commande) \
Bblock \
VALIDATION_DE_LA_FONCTION_D_UNE_COMMANDE_DISQUE_PAL_BETA(Commande,fonction); \
\
GENERATION_COMMANDE_DISQUE_PAL_BETA_nn(Commande \
,BLOC(MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,fonction); \
/* Mise en place du premier argument... */ \
MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,data1); \
/* Mise en place du second argument... */ \
) \
,longueur_de_la_commande \
); \
Eblock
/* Generation d'une commande a deux arguments 'fonction' et 'data1', ou les 'data' sont */
/* des caracteres. */
% define GENERATION_COMMANDE_DISQUE_PAL_BETA__03(Commande,fonction,data1,data2,longueur_de_la_commande) \
Bblock \
VALIDATION_DE_LA_FONCTION_D_UNE_COMMANDE_DISQUE_PAL_BETA(Commande,fonction); \
\
GENERATION_COMMANDE_DISQUE_PAL_BETA_nn(Commande \
,BLOC(MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,fonction); \
/* Mise en place du premier argument... */ \
MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,data1); \
/* Mise en place du second argument... */ \
MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,data2); \
/* Mise en place du troisieme argument... */ \
) \
,longueur_de_la_commande \
); \
Eblock
/* Generation d'une commande a trois arguments 'fonction', 'data1' et 'data2', ou les */
/* 'data' sont des caracteres. */
% define GENERATION_COMMANDE_DISQUE_PAL_BETA__04(Commande,fonction,data1,data2,data3,longueur_de_la_commande) \
Bblock \
VALIDATION_DE_LA_FONCTION_D_UNE_COMMANDE_DISQUE_PAL_BETA(Commande,fonction); \
\
GENERATION_COMMANDE_DISQUE_PAL_BETA_nn(Commande \
,BLOC(MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,fonction); \
/* Mise en place du premier argument... */ \
MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,data1); \
/* Mise en place du second argument... */ \
MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,data2); \
/* Mise en place du troisieme argument... */ \
MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,data3); \
/* Mise en place du quatrieme argument... */ \
) \
,longueur_de_la_commande \
); \
Eblock
/* Generation d'une commande a quatre arguments 'fonction', 'data1', 'data2' et 'data3', */
/* ou les 'data' sont des caracteres. */
% define GENERATION_COMMANDE_DISQUE_PAL_BETA__05(Commande,fonction,data1,data2,data3,data4,longueur_de_la_commande) \
Bblock \
VALIDATION_DE_LA_FONCTION_D_UNE_COMMANDE_DISQUE_PAL_BETA(Commande,fonction); \
\
GENERATION_COMMANDE_DISQUE_PAL_BETA_nn(Commande \
,BLOC(MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,fonction); \
/* Mise en place du premier argument... */ \
MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,data1); \
/* Mise en place du second argument... */ \
MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,data2); \
/* Mise en place du troisieme argument... */ \
MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,data3); \
/* Mise en place du quatrieme argument... */ \
MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,data4); \
/* Mise en place du cinquieme argument... */ \
) \
,longueur_de_la_commande \
); \
Eblock
/* Generation d'une commande a cinq arguments 'fonction', 'data1', 'data2', 'data3' */
/* et 'data4', ou les 'data' sont des caracteres. */
% define GENERATION_COMMANDE_DISQUE_PAL_BETA__06(Commande,fonction,data1,data2,data3,data4,data5,longueur_de_la_commande) \
Bblock \
VALIDATION_DE_LA_FONCTION_D_UNE_COMMANDE_DISQUE_PAL_BETA(Commande,fonction); \
\
GENERATION_COMMANDE_DISQUE_PAL_BETA_nn(Commande \
,BLOC(MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,fonction); \
/* Mise en place du premier argument... */ \
MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,data1); \
/* Mise en place du second argument... */ \
MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,data2); \
/* Mise en place du troisieme argument... */ \
MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,data3); \
/* Mise en place du quatrieme argument... */ \
MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,data4); \
/* Mise en place du cinquieme argument... */ \
MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,data5); \
/* Mise en place du sixieme argument... */ \
) \
,longueur_de_la_commande \
); \
Eblock
/* Generation d'une commande a six arguments 'fonction', 'data1', 'data2', 'data3', */
/* 'data4' et 'data5', ou les 'data' sont des caracteres. */
% define GENERATION_COMMANDE_DISQUE_PAL_BETA__07(Commande,fonction,data1,data2,data3,data4,data5,data6,longueur_de_la_commande) \
Bblock \
VALIDATION_DE_LA_FONCTION_D_UNE_COMMANDE_DISQUE_PAL_BETA(Commande,fonction); \
\
GENERATION_COMMANDE_DISQUE_PAL_BETA_nn(Commande \
,BLOC(MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,fonction); \
/* Mise en place du premier argument... */ \
MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,data1); \
/* Mise en place du second argument... */ \
MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,data2); \
/* Mise en place du troisieme argument... */ \
MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,data3); \
/* Mise en place du quatrieme argument... */ \
MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,data4); \
/* Mise en place du cinquieme argument... */ \
MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,data5); \
/* Mise en place du sixieme argument... */ \
MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,data6); \
/* Mise en place du septieme argument... */ \
) \
,longueur_de_la_commande \
); \
Eblock
/* Generation d'une commande a sept arguments 'fonction', 'data1', 'data2', 'data3', */
/* 'data4', 'data5' et 'data6', ou les 'data' sont des caracteres. */
% define GENERATION_COMMANDE_DISQUE_PAL_BETA__11(Commande,data_1,longueur_de_la_commande) \
Bblock \
GENERATION_COMMANDE_DISQUE_PAL_BETA_nn(Commande \
,BLOC(MISE_A_JOUR_C_COMMANDE_DISQUE_PAL_BETA(Commande \
,data_1 \
,AVEC_CHECK_SUM_PAL_BETA \
); \
/* Mise en place du premier argument avec calcul de "check-sum"... */ \
) \
,longueur_de_la_commande \
); \
Eblock
/* Generation d'une commande a un argument 'data_1' (avec "check-sum"), ou 'data' est une */
/* chaine de caracteres. */
% define GENERATION_COMMANDE_DISQUE_PAL_BETA__12(Commande,fonction,data_1,longueur_de_la_commande) \
Bblock \
VALIDATION_DE_LA_FONCTION_D_UNE_COMMANDE_DISQUE_PAL_BETA(Commande,fonction); \
\
GENERATION_COMMANDE_DISQUE_PAL_BETA_nn(Commande \
,BLOC(MISE_A_JOUR_C_COMMANDE_DISQUE_PAL_BETA(Commande \
,data_1 \
,SANS_CHECK_SUM_PAL_BETA \
); \
/* Mise en place du premier argument sans calcul de "check-sum"... */ \
MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,fonction); \
/* Mise en place du second argument... */ \
) \
,longueur_de_la_commande \
); \
Eblock
/* Generation d'une commande a deux arguments 'fonction' et 'data_1', ou 'data' est une */
/* chaine de caracteres. */
% define GENERATION_COMMANDE_DISQUE_PAL_BETA__13(Commande,fonction_1,fonction_2,data_1,longueur_de_la_commande) \
Bblock \
VALIDATION_DE_LA_FONCTION_D_UNE_COMMANDE_DISQUE_PAL_BETA(Commande,fonction_1); \
VALIDATION_DE_LA_FONCTION_D_UNE_COMMANDE_DISQUE_PAL_BETA(Commande,fonction_2); \
\
GENERATION_COMMANDE_DISQUE_PAL_BETA_nn(Commande \
,BLOC(MISE_A_JOUR_C_COMMANDE_DISQUE_PAL_BETA(Commande \
,data_1 \
,SANS_CHECK_SUM_PAL_BETA \
); \
/* Mise en place du premier argument sans calcul de "check-sum"... */ \
MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,fonction_2); \
/* Mise en place du second argument... */ \
MISE_A_JOUR_K_COMMANDE_DISQUE_PAL_BETA(Commande,fonction_1); \
/* Mise en place du troisieme argument... */ \
) \
,longueur_de_la_commande \
); \
Eblock
/* Generation d'une commande a trois arguments 'fonction_1', 'fonction_2' et 'data_1', ou */
/* 'data' est une chaine de caracteres, mais ATTENTION : a l'ordre inverse de l'appel des */
/* fonctions... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O M M A N D E S " P H Y S I Q U E S " G E N E R A L E S D U D I S Q U E V I D E O P A L - B E T A : */
/* */
/*************************************************************************************************************************************/
/* On notera que pour faire des tests via 'v $xtc/disk_vi_P.21$c' (qui permet de faire */
/* facilement des tests de suites de commandes en envoyant au disque des chaines de */
/* caracteres alphanumeriques), il est possible de convertir les codes hexa-decimaux */
/* qui suivent ('0x??') a l'aide de la commande 'xalpha'. */
# ifdef __VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000
# define PAL_BETA_CONNECT_TO_PROCESSOR \
PARE(0xB7) \
/* Connexion entre l'ordinateur Hote et le disque ('Connect Processor Command'). */
# Aifdef __VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000
# Eifdef __VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000
# define PAL_BETA_C_E \
PARE(0x41) \
/* Reinitialisation des entrees ('Clear Input'). */
# define PAL_BETA_C_L \
PARE(0x56) \
/* Reinitialisation generale ('All Clear'). */
# if ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# define PAL_BETA_B_W_MODE \
PARE(0xED) \
/* Mise en mode Noir et Blanc ('Black and White Mode'). */
# define PAL_BETA_COLOR_MODE \
PARE(0xEC) \
/* Mise en mode couleur ('Color Mode'). */
# define PAL_BETA_FRAME_NUMBER_MODE \
PARE(0x55) \
/* Mise en mode "numero d'image" ('Set to Frame Number Mode'), par opposition a 'Set to */ \
/* Time Code Mode'. ATTENTION : on notera que seul le mode 'PAL_BETA_FRAME_NUMBER_MODE' */ \
/* permet d'acceder a la zone 'user data area', alors que cela est impossible en mode */ \
/* 'time code'... */
# define PAL_BETA_TIME_CODE_MODE \
PARE(0xB8) \
/* Mise en mode "time code" ('Set to Time Code Mode'), par opposition a 'Set to Frame */ \
/* Number Mode'. ATTENTION : on notera que seul le mode 'PAL_BETA_FRAME_NUMBER_MODE' */ \
/* permet d'acceder a la zone 'user data area', alors que cela est impossible en mode */ \
/* 'time code'. Ce code a ete introduit le 20020710100924. */
# Aif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# ifdef __VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000
# define PAL_BETA_PAL_MODE \
PARE(0xEB) \
/* Mise en mode 'PAL', au cas ou il y aurait du 'NTSC' ('Set to PAL Mode'). */
# Aifdef __VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000
# Eifdef __VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000
# define PAL_BETA_VIDEO_ON \
PARE(0x27) \
/* Activation de la video en sortie ('Video Signal Output Whitin Effective Picture Area'). */
# define PAL_BETA_VIDEO_OFF \
PARE(0x26) \
/* Desactivation de la video en sortie ('Mute Video Signal Output'). */
# if ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# define PAL_BETA_INDEX_ON \
PARE(0x50) \
/* Activation de l'affichage numerique sur le moniteur ('Activate Index Display'). */
# define PAL_BETA_INDEX_OFF \
PARE(0x51) \
/* Desactivation de l'affichage numerique sur le moniteur ('Deactivate Index Display'). */
# define PAL_BETA_BLANK_AREA_SEARCH \
PARE(0xBB) \
/* Recherche d'une zone enregistrable sur le disque ("blanche"). */
# Aif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# define PAL_BETA_STATUS_INQ \
PARE(0x67) \
/* Demande de l'etat du disque ('Request for Recorder'). */
# if ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# define PAL_BETA_ADDR_INQ \
PARE(0x60) \
/* Demande de l'adresse courante du disque ('Current Adress Inquiry'). */
# Aif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# if ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# define PAL_BETA_ADDR_INQ \
UNDEF \
/* Bien que n'existant pas sur '__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P', */ \
/* 'PAL_BETA_ADDR_INQ' est definie malgre tout car 'INFORMATIONS_GENERALES_PAL_BETA(...)' */ \
/* l'utilise, or exceptionnellement, je cherche a simplifier les choses... */
# Aif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# define PAL_BETA_ENTER \
PARE(0x40) \
/* Entree d'un parametre numerique ('End of Parameter Input'). */
# if ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# define PAL_BETA_SEARCH \
PARE(0x43) \
/* Positionnement sur une image ('Locate Target Address'). */
# Aif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# if ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# define PAL_BETA_EXP_8 \
PARE(0xDF) \
/* Fonction d'expansion utilisee par exemple pour 'PAL_BETA_EXP_8'. */
# define PAL_BETA_SEARCH_WITH_DATA \
PARE(0x93) \
/* Positionnement sur une image ('Locate Target Address'). */
# Aif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# define PAL_BETA_STILL \
PARE(0x4F) \
/* Demande de mise en mode "image arretee" ('Still Picture'). */
# if ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# define PAL_BETA_STOP \
PAL_BETA_STILL \
/* Demande de mise en mode "stop". */
# Aif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# if ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# define PAL_BETA_STOP \
PARE(0x3F) \
/* Demande de mise en mode "stop". */
# Aif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# if ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# define PAL_BETA_CONTINUE \
PARE(0x61) \
/* Reprise d'un mode interrompu par 'PAL_BETA_STILL' ('Resume Mode Prior to Still Command'). */
# Aif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# define PAL_BETA_MEMORY \
PARE(0x5A) \
/* Memorisation de la position courante ('Memorize the Current Location'). */
# define PAL_BETA_M_SEARCH \
PARE(0x5B) \
/* Retour a la position courante memorisee ('Locate the Memorized Address'). */
# if ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# define PAL_BETA_EJECT_ENABLE \
PARE(0x74) \
/* Autorisation de l'ejection du support ('Activate Eject Button'). */
# Aif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# define PAL_BETA_EJECT \
PARE(0x2A) \
/* Ejection du support ('Eject Disc'). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O M M A N D E S " P H Y S I Q U E S " D ' A V A N C E D U D I S Q U E V I D E O P A L - B E T A : */
/* */
/*************************************************************************************************************************************/
# define PAL_BETA_F_SCAN \
PARE(0x3E) \
/* Lecture a 30 fois la vitesse en marche avant ('Scan in Forward Direction'). */
# define PAL_BETA_F_FAST \
PARE(0x3B) \
/* Lecture a vitesse triple en marche avant ('Fast Forward Play'). */
# define PAL_BETA_F_PLAY \
PARE(0x3A) \
/* Lecture a vitesse nominale en marche avant ('Normal Forward Play'). */
# define PAL_BETA_F_SLOW \
PARE(0x3C) \
/* Lecture a vitesse lente en marche avant ('Slow Forward Play'). */
# define PAL_BETA_F_STEP \
PARE(0x3D) \
/* Avance d'une image en marche avant ('Variable Forward Play'). */
# if ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# define PAL_BETA_FWD_STEP_AND_STILL \
PARE(0x2B) \
/* Avance d'une image en marche avant ('One Frame Advance'). */
# Aif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# define PAL_BETA_R_SCAN \
PARE(0x4E) \
/* Lecture a 30 fois la vitesse en marche arriere ('Scan in Reverse Direction'). */
# define PAL_BETA_R_FAST \
PARE(0x4B) \
/* Lecture a vitesse triple en marche arriere ('Fast Reverse Play'). */
# define PAL_BETA_R_PLAY \
PARE(0x4A) \
/* Lecture a vitesse nominale en marche arriere ('Normal Reverse Play'). */
# define PAL_BETA_R_SLOW \
PARE(0x4C) \
/* Lecture a vitesse lente en marche arriere ('Slow Reverse Play'). */
# define PAL_BETA_R_STEP \
PARE(0x4D) \
/* Recul d'une image en marche arriere ('Variable Reverse Play'). */
# if ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# define PAL_BETA_REV_STEP_AND_STILL \
PARE(0x2C) \
/* Recul d'une image en marche arriere ('One Frame Reverse'). */
# define PAL_BETA_REPEAT \
PARE(0x44) \
/* Lecture jusqu'a une certaine adresse ('Repeat Play a Designated Sequence'). */
# Aif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O M M A N D E S " P H Y S I Q U E S " D E R E C O R D D U D I S Q U E V I D E O P A L - B E T A : */
/* */
/*************************************************************************************************************************************/
# if ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# define PAL_BETA_FRAME_REC \
PARE(0xE6) \
/* Afin d'enregistrer image par image ('Recording One Frame at a Time'). */
# define PAL_BETA_REC_STANDBY \
PARE(0xE0) \
/* Definition des parametres d'enregistrement ('Recording Standby'). */
# define PAL_BETA_REC \
PARE(0xE9) \
/* Enregistrement ('Execution of Recording'). */
# Aif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# if ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# define PAL_BETA_REC_DUB_REQUEST \
PARE(0xFA) \
/* Commande a envoyer imperativement avant 'PAL_BETA_REC' (mais mysterieuse...). */
# define PAL_BETA_REC \
PARE(0xCA) \
/* Enregistrement ('Execution of Recording'). */
# define PAL_BETA_REC_PAUSE \
PARE(0xCB) \
/* Mise de l'enregistreur en "standby". */
# Aif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O M M A N D E S " P H Y S I Q U E S " D E G E S T I O N D E S D O N N E E S */
/* N U M E R I Q U E S D U D I S Q U E V I D E O P A L - B E T A : */
/* */
/*************************************************************************************************************************************/
# if ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# define PAL_BETA_SET_DATA \
PARE(0xE1) \
/* Mise en place des donnees numeriques avant ecriture ('Register User Data'). */
# define PAL_BETA_WRITE_DATA \
PARE(0xE3) \
/* Ecriture des donnees mise en place ci-dessus ('Record UserData'). */
# define PAL_BETA_READ_DATA \
PARE(0xE2) \
/* Lecture des donnees numeriques ('Read Out User Data'). */
# Aif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O M M A N D E S I M P L E " T Y P E " D U D I S Q U E V I D E O P A L - B E T A : */
/* */
/*************************************************************************************************************************************/
# define COMMANDE_SIMPLE_TYPE_PAL_BETA(fonction_simple) \
Bblock \
OUVERTURE_DE_LA_LIGNE_PAL_BETA(BLOC(DEBLOCAGE_DU_CLAVIER_PAL_BETA;)); \
\
COMMANDE_QUELCONQUE_PAL_BETA(_01 \
,LIS1(fonction_simple) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
\
FERMETURE_DE_LA_LIGNE_PAL_BETA; \
Eblock \
/* Envoi d'une fonction "simple" et "typique" au disque... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E S T I O N D E L A L I G N E D E C O M M A N D E D U D I S Q U E V I D E O P A L - B E T A : */
/* */
/*************************************************************************************************************************************/
# define OUVERTURE_DE_LA_LIGNE_PAL_BETA(sequence_initiale) \
Bblock \
DODO(MOIT(IKP_____temporisation_inter_commande)); \
/* On attend un peu avant d'emettre la commande courante, et ce afin d'etre sur que la */ \
/* precedente a bien ete lancee... */ \
CALS(IKPopen_disque_video()); \
/* Ouverture de la ligne. */ \
BLOC(sequence_initiale); \
/* On ne sait jamais, on fera en general un 'DEBLOCAGE_DU_CLAVIER_PAL_BETA', mais a cause */ \
/* de 'ARRET_PAL_BETA' et de 'REPRISE_PAL_BETA', on prevoit de faire un 'VIDE', car entre */ \
/* une commande 'PAL_BETA_STILL' et une commande 'PAL_BETA_CONTINUE', il ne faut rien, de */ \
/* meme que devant la premiere... */ \
Eblock \
/* Ouverture de la ligne ; on notera qu'elle ne peut etre faite autour de chaque appel */ \
/* 'IKPenvoi_d_une_commande_au_disque_video()', et ce a cause des envois de reponses */ \
/* asynchrones qui "survolent" plusieurs commandes successives... */
# define FERMETURE_DE_LA_LIGNE_PAL_BETA \
Bblock \
CALS(IKPclose_disque_video()); \
/* Fermeture de la ligne. */ \
DODO(MOIT(IKP_____temporisation_inter_commande)); \
/* On attend un peu avant de rendre la main, afin d'etre sur que la commande est finie. */ \
Eblock \
/* Fermeture de la ligne... */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* G E N E R A T E U R D E C O M M A N D E S A U D I S Q U E V I D E O P A L - B E T A : */
/* */
/*************************************************************************************************************************************/
# define COMMANDE_QUELCONQUE_PAL_BETA(sous_nom,commandes,un_ack_par_caractere,wait_reponse_multiple,lecture_numerique,longueur) \
Bblock \
DEFV(CHAR,DTb1(commande_courante,LONGUEUR_MAXIMALE_D_UNE_COMMANDE_DU_DISQUE_PAL_BETA)); \
/* Buffer destine a contenir la commande courante apres sa mise au format... */ \
DEFV(Positive,INIT(longueur_de_la_commande_courante,UNDEF)); \
/* Longueur de la commande courante ; en effet, on ne peut utiliser le 'END_OF_CHAIN', */ \
/* puisque des caracteres 'NULL's peuvent apparaitre dedans... */ \
GENERATION_COMMANDE_DISQUE_PAL_BETA`sous_nom(commande_courante \
,commandes \
,longueur_de_la_commande_courante \
); \
/* Generation de la commande courante... */ \
CODE_ERROR(IKPenvoi_d_une_commande_au_disque_video(commande_courante \
,longueur_de_la_commande_courante \
,un_ack_par_caractere \
,wait_reponse_multiple \
,lecture_numerique \
,longueur \
) \
); \
/* Et envoi de la commande avec renvoi de 'CODE_ERREUR' afin de le renvoyer comme '$status' */ \
/* dans 'v $xci/disk_video_P$K' et d'ainsi pouvoir le tester dans 'v $xci/disk_video_P$Z'... */ \
Eblock \
/* Generation d'une commande quelconque dont on donne les arguments explicitement, et dont */ \
/* le "type" est donne par 'sous_nom'. */
# define ENTER_PAL_BETA(valeur_numerique,attendre_une_reponse_multiple) \
Bblock \
COMMANDE_QUELCONQUE_PAL_BETA(_12 \
,LIS2(PAL_BETA_ENTER \
,chain_numero(valeur_numerique \
,NOMBRE_DE_CHIFFRES_PAL_BETA \
) \
) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,attendre_une_reponse_multiple \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
DODO(IKP_____temporisation_apres_ENTER); \
/* Et oui, a cause de l'envoi des differents parametres des commandes d'enregistrement */ \
/* (du type 'ENREGISTREMENT_D_UNE_SEQUENCE_PAL_BETA'), il faut entre chacun de ses appels */ \
/* a 'ENTER_PAL_BETA(valeur_numerique)', faire un petit dodo... */ \
Eblock \
/* 'ENTER' d'une valeur numerique (numero d'image par exemple) dans le disque PAL-Beta ; on */ \
/* notera avec attention, que l'ordre des arguments ('PAL_BETA_ENTER', puis le numero) est */ \
/* l'ordre inverse de ce qui est reellement envoye au disque... */
# define ENTER_PAL_BETA_AVEC_FONCTION(fonction_a_envoyer,valeur_numerique,attendre_une_reponse_multiple) \
Bblock \
COMMANDE_QUELCONQUE_PAL_BETA(_13 \
,LIS3(PAL_BETA_ENTER \
,fonction_a_envoyer \
,chain_numero(valeur_numerique \
,NOMBRE_DE_CHIFFRES_PAL_BETA \
) \
) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,attendre_une_reponse_multiple \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
DODO(IKP_____temporisation_apres_ENTER); \
/* Et oui, a cause de l'envoi des differents parametres des commandes d'enregistrement */ \
/* (du type 'ENREGISTREMENT_D_UNE_SEQUENCE_PAL_BETA'), il faut entre chacun de ses appels */ \
/* a 'ENTER_PAL_BETA(valeur_numerique)', faire un petit dodo... */ \
Eblock \
/* 'ENTER' d'une valeur numerique (numero d'image par exemple) dans le disque PAL-Beta avec */ \
/* envoi avant le 'PAL_BETA_ENTER' d'une fonction specifique 'fonction_a_envoyer' ; on */ \
/* notera avec attention, que l'ordre des arguments ('PAL_BETA_ENTER', la fonction */ \
/* specifique 'fonction_a_envoyer', puis le numero) est l'ordre inverse de ce qui est */ \
/* reellement envoye au disque. Cette deuxieme procedure de 'ENTER' a ete introduite a */ \
/* cause de la procedure 'LECTURE_QUELCONQUE_D_UNE_SEQUENCE_PAL_BETA(...)' qui demande */ \
/* l'envoi du mode lecture avant la fonction 'PAL_BETA_ENTER'... */
# define DEBLOCAGE_DU_CLAVIER_PAL_BETA \
Bblock \
COMMANDE_QUELCONQUE_PAL_BETA(_01 \
,LIS1(PAL_BETA_C_L) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
Eblock \
/* Reinitialisation de l'acces au commande ("deblocage du clavier"). */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* Q U E L Q U E S C O M M A N D E S U T I L E S A U D I S Q U E V I D E O P A L - B E T A : */
/* */
/*************************************************************************************************************************************/
# define INFORMATIONS_GENERALES_PAL_BETA(fonction_d_acces_aux_informations,longueur_du_bloc_a_lire) \
Bblock \
begin_nouveau_block \
Bblock \
OUVERTURE_DE_LA_LIGNE_PAL_BETA(BLOC(VIDE;)); \
/* On notera le 'VIDE' du au fait que la commande 'PAL_BETA_CONTINUE' fait repasser dans */ \
/* le mode precedent le 'PAL_BETA_STILL' ; si on mettait ici 'DEBLOCAGE_DU_CLAVIER_PAL_BETA' */ \
/* c'est ce dernier qui serait "rejoue" par 'REPRISE_PAL_BETA'... */ \
\
COMMANDE_QUELCONQUE_PAL_BETA(_01 \
,LIS1(fonction_d_acces_aux_informations) \
,PAS_D_ACQUITTEMENT_INDIVIDUEL_DES_CARACTERES \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
,LIRE_DES_DONNEES_NUMERIQUES \
,longueur_du_bloc_a_lire \
); \
\
FERMETURE_DE_LA_LIGNE_PAL_BETA; \
Eblock \
end_nouveau_block \
\
begin_nouveau_block \
Bblock \
DEFV(Int,INIT(index,PREMIER_CARACTERE)); \
/* Index du buffer de reception. */ \
CAL2(Prin0("\n")); \
\
Komp(numero_du_caractere_courant,longueur_du_bloc_a_lire) \
Bblock \
Choi(fonction_d_acces_aux_informations) \
Bblock \
Ca1e(PAL_BETA_STATUS_INQ) \
Bblock \
CAL2(Prin1("%02X ",ITb1(IKP_____buffer_de_reception,INDX(index,PREMIER_CARACTERE)))); \
/* Et on edite "betement" les donnees... */ \
Eblock \
ECa1 \
\
Ca1e(PAL_BETA_ADDR_INQ) \
/* C'est a cause de ce test que sur '__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P' */ \
/* ou elle n'existe pas, la fonction 'PAL_BETA_ADDR_INQ' est definie quand meme (mais */ \
/* 'UNDEF'...). */ \
Bblock \
CAL2(Prin1("%c",ITb1(IKP_____buffer_de_reception,INDX(index,PREMIER_CARACTERE)))); \
/* Et on convertit l'adresse courante... */ \
Eblock \
ECa1 \
\
Defo \
Bblock \
PRINT_ERREUR("fonction 'fonction_d_acces_aux_informations' sans format d'edition"); \
Eblock \
EDef \
Eblock \
ECho \
\
INCR(index,I); \
/* Progression de l'index pour le caractere suivant eventuel... */ \
Eblock \
EKom \
\
CAL2(Prin0("\n")); \
Eblock \
end_nouveau_block \
Eblock \
/* Recuperation de l'etat du disque. */
# define ETAT_PAL_BETA \
Bblock \
INFORMATIONS_GENERALES_PAL_BETA(PAL_BETA_STATUS_INQ,LONGUEUR_DU_BLOC_D_ETAT_PAL_BETA); \
Eblock \
/* Recuperation de l'etat du disque. */
# if ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# define ADRESSE_COURANTE_PAL_BETA \
Bblock \
INFORMATIONS_GENERALES_PAL_BETA(PAL_BETA_ADDR_INQ,LONGUEUR_DU_BLOC_D_ADRESSE_COURANTE_PAL_BETA); \
Eblock \
/* Recuperation de l'adresse courante du disque. */
# Aif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# if ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# define ADRESSE_COURANTE_PAL_BETA \
Bblock \
PRINT_ERREUR("l'acces a l'adresse courante est indisponible"); \
Eblock \
/* Recuperation de l'adresse courante du disque. */
# Aif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# ifdef __VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000
# define PREPARATION_SPECIFIQUE_DE_L_INITIALISATION_MINIMALE_PAL_BETA \
Bblock \
OUVERTURE_DE_LA_LIGNE_PAL_BETA(BLOC(VIDE;)); \
\
COMMANDE_QUELCONQUE_PAL_BETA(_01 \
,LIS1(PAL_BETA_CONNECT_TO_PROCESSOR) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
/* Premiere operation essentielle... */ \
\
FERMETURE_DE_LA_LIGNE_PAL_BETA; \
\
RECHERCHE_D_UNE_IMAGE_PAL_BETA(PREMIERE_IMAGE_PAL_BETA); \
/* Ce positionnement est obligatoire, si l'on veut que des commandes, telle que */ \
/* 'PAL_BETA_PAL_MODE', soient acceptees juste apres... */ \
/* */ \
/* ATTENTION, on notera la structure : */ \
/* */ \
/* FERMETURE_DE_LA_LIGNE_PAL_BETA; */ \
/* RECHERCHE_D_UNE_IMAGE_PAL_BETA(PREMIERE_IMAGE_PAL_BETA); */ \
/* OUVERTURE_DE_LA_LIGNE_PAL_BETA(BLOC(VIDE;)); */ \
/* */ \
/* le positionnement sur 'PREMIERE_IMAGE_PAL_BETA' se faisant alors que la ligne est fermee, */ \
/* cela et-il normal ? Oui, car la procedure 'RECHERCHE_D_UNE_IMAGE_PAL_BETA(...)' fait */ \
/* elle-meme un [FERMETURE_DE_LA_LIGNE_PAL_BETA,OUVERTURE_DE_LA_LIGNE_PAL_BETA]... Cette */ \
/* structure est donc obligatoire... */ \
\
OUVERTURE_DE_LA_LIGNE_PAL_BETA(BLOC(VIDE;)); \
\
COMMANDE_QUELCONQUE_PAL_BETA(_06 \
,LIS6(PAL_BETA_C_L \
,PAL_BETA_EJECT_ENABLE \
,COND(IL_FAUT(IKP_____utiliser_le_mode_PAL_BETA_FRAME_NUMBER_MODE) \
,PAL_BETA_FRAME_NUMBER_MODE \
,PAL_BETA_TIME_CODE_MODE \
) \
,PAL_BETA_COLOR_MODE \
,PAL_BETA_PAL_MODE \
,PAL_BETA_VIDEO_ON \
) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
Eblock \
/* Preparation specifique a un disque 'LVS6000P-LVR6000' de l'initialisation minimale... */
# Aifdef __VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000
# Eifdef __VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000
# ifdef __VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P
# define PREPARATION_SPECIFIQUE_DE_L_INITIALISATION_MINIMALE_PAL_BETA \
Bblock \
OUVERTURE_DE_LA_LIGNE_PAL_BETA(BLOC(VIDE;)); \
\
COMMANDE_QUELCONQUE_PAL_BETA(_05 \
,LIS5(PAL_BETA_C_L \
,PAL_BETA_EJECT_ENABLE \
,COND(IL_FAUT(IKP_____utiliser_le_mode_PAL_BETA_FRAME_NUMBER_MODE) \
,PAL_BETA_FRAME_NUMBER_MODE \
,PAL_BETA_TIME_CODE_MODE \
) \
,PAL_BETA_COLOR_MODE \
,PAL_BETA_VIDEO_ON \
) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
Eblock \
/* Preparation specifique a un disque 'LVR4000P' de l'initialisation minimale... */
# Aifdef __VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P
# Eifdef __VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P
# ifdef __VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P
# define PREPARATION_SPECIFIQUE_DE_L_INITIALISATION_MINIMALE_PAL_BETA \
Bblock \
OUVERTURE_DE_LA_LIGNE_PAL_BETA(BLOC(VIDE;)); \
\
COMMANDE_QUELCONQUE_PAL_BETA(_02 \
,LIS2(PAL_BETA_C_L \
,PAL_BETA_VIDEO_ON \
) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
Eblock \
/* Preparation specifique a un magnetoscope 'UVW1400P' de l'initialisation minimale... */
# Aifdef __VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P
# Eifdef __VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P
# if ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# define INITIALISATION_MINIMALE_PAL_BETA(affichage_sur_le_moniteur_de_controle) \
Bblock \
PREPARATION_SPECIFIQUE_DE_L_INITIALISATION_MINIMALE_PAL_BETA; \
/* Preparation specifique de l'initialisation minimale ; celle-ci depend du type de disque. */ \
\
Test(IL_FAUT(affichage_sur_le_moniteur_de_controle)) \
Bblock \
COMMANDE_QUELCONQUE_PAL_BETA(_01 \
,LIS1(PAL_BETA_INDEX_ON) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
Eblock \
ATes \
Bblock \
COMMANDE_QUELCONQUE_PAL_BETA(_01 \
,LIS1(PAL_BETA_INDEX_OFF) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
Eblock \
ETes \
\
FERMETURE_DE_LA_LIGNE_PAL_BETA; \
Eblock \
/* Initialisation minimale du disque PAL-Beta : en particulier, on autorise l'affichage, */ \
/* on choisit d'adresser par numero d'image (et non pas par 'time code'), on se met en mode */ \
/* 'PAL' (au cas ou il y aurait du 'NTSC'...), avec des images en couleurs ; on notera que */ \
/* l'on ne se met pas en arret sur image ('PAL_BETA_STILL'), car l'initialisation le fait */ \
/* (par 'PAL_BETA_C_L'). ATTENTION : on notera la presence de 'PAL_BETA_EJECT_ENABLE', */ \
/* contrairement a toute logique : en effet, cette possibilite est offerte, car elle */ \
/* permet d'agir physiquement sur le disque (par exemple pour aborter un sequence */ \
/* d'enregistrement) en cas de probleme avec l'ordinateur ; dans le contraire, dans la */ \
/* mesure ou, lorsque la telecommande est active, le pupitre de l'enregistreur est inactif */ \
/* aucun moyen d'acces ne reste, sauf, bien entendu la mise hors tension, ce qui est un */ \
/* peu trop dangereux... */
# define INITIALISATION_MAXIMALE_PAL_BETA(affichage_sur_le_moniteur_de_controle) \
Bblock \
INITIALISATION_MINIMALE_PAL_BETA(affichage_sur_le_moniteur_de_controle); \
\
OUVERTURE_DE_LA_LIGNE_PAL_BETA(BLOC(VIDE;)); \
\
COMMANDE_QUELCONQUE_PAL_BETA(_01 \
,LIS1(PAL_BETA_BLANK_AREA_SEARCH) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
/* Recherche des "zones blanches" afin d'autoriser les enregistrements ulterieurs. */ \
\
FERMETURE_DE_LA_LIGNE_PAL_BETA; \
Eblock \
/* Initialisation maximale du disque PAL-Beta : en particulier, on autorise l'affichage, */ \
/* on choisit d'adresser par numero d'image (et non pas par 'time code'), on se met en mode */ \
/* 'PAL' (au cas ou il y aurait du 'NTSC'...), avec des images en couleurs ; on notera que */ \
/* l'on ne se met pas en arret sur image ('PAL_BETA_STILL'), car l'initialisation le fait */ \
/* (par 'PAL_BETA_C_L'). Enfin, on procede a la recherche des zones "blanches"... */
# Aif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# if ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# define INITIALISATION_MINIMALE_PAL_BETA(affichage_sur_le_moniteur_de_controle) \
Bblock \
PREPARATION_SPECIFIQUE_DE_L_INITIALISATION_MINIMALE_PAL_BETA; \
/* Preparation specifique de l'initialisation minimale ; celle-ci depend du type de disque. */ \
\
FERMETURE_DE_LA_LIGNE_PAL_BETA; \
Eblock \
/* Initialisation du magnetoscope... */
# define INITIALISATION_MAXIMALE_PAL_BETA(affichage_sur_le_moniteur_de_controle) \
Bblock \
INITIALISATION_MINIMALE_PAL_BETA(affichage_sur_le_moniteur_de_controle); \
Eblock \
/* Initialisation du magnetoscope... */
# Aif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O M M A N D E S D ' A R R E T - M A R C H E D U D I S Q U E V I D E O P A L - B E T A : */
/* */
/*************************************************************************************************************************************/
# define EJECTION_PAL_BETA \
Bblock \
OUVERTURE_DE_LA_LIGNE_PAL_BETA(BLOC(VIDE;)); \
\
COMMANDE_QUELCONQUE_PAL_BETA(_01 \
,LIS1(PAL_BETA_EJECT) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
\
FERMETURE_DE_LA_LIGNE_PAL_BETA; \
Eblock \
/* Ejection du disque (par exemple apres un long enregistrement...). */
# if ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# define ARRET_PAL_BETA \
Bblock \
OUVERTURE_DE_LA_LIGNE_PAL_BETA(BLOC(VIDE;)); \
/* On notera le 'VIDE' du au fait que la commande 'PAL_BETA_CONTINUE' fait repasser dans */ \
/* le mode precedent le 'PAL_BETA_STILL' ; si on mettait ici 'DEBLOCAGE_DU_CLAVIER_PAL_BETA' */ \
/* c'est ce dernier qui serait "rejoue" par 'REPRISE_PAL_BETA'... */ \
\
COMMANDE_QUELCONQUE_PAL_BETA(_01 \
,LIS1(PAL_BETA_STILL) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
\
FERMETURE_DE_LA_LIGNE_PAL_BETA; \
Eblock \
/* Arret de la commande courante, mais ATTENTION, sans 'DODO'... */
# define REPRISE_PAL_BETA \
Bblock \
OUVERTURE_DE_LA_LIGNE_PAL_BETA(BLOC(VIDE;)); \
/* On notera le 'VIDE' du au fait qu'entre une commande 'PAL_BETA_STILL' et une */ \
/* commande 'PAL_BETA_CONTINUE', il ne faut rien d'autre... */ \
\
COMMANDE_QUELCONQUE_PAL_BETA(_01 \
,LIS1(PAL_BETA_CONTINUE) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
\
FERMETURE_DE_LA_LIGNE_PAL_BETA; \
Eblock \
/* Reprise d'une commande interrompue par 'ARRET_PAL_BETA'... */
# Aif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# if ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# define ARRET_PAL_BETA \
Bblock \
OUVERTURE_DE_LA_LIGNE_PAL_BETA(BLOC(VIDE;)); \
/* On notera le 'VIDE' du au fait que la commande 'PAL_BETA_CONTINUE' fait repasser dans */ \
/* le mode precedent le 'PAL_BETA_STILL' ; si on mettait ici 'DEBLOCAGE_DU_CLAVIER_PAL_BETA' */ \
/* c'est ce dernier qui serait "rejoue" par 'REPRISE_PAL_BETA'... */ \
\
COMMANDE_QUELCONQUE_PAL_BETA(_01 \
,LIS1(PAL_BETA_STOP) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
\
FERMETURE_DE_LA_LIGNE_PAL_BETA; \
Eblock \
/* Arret de la commande courante, mais ATTENTION, sans 'DODO'... */
# define REPRISE_PAL_BETA \
Bblock \
PRINT_ERREUR("la fonction de reprise n'existe pas"); \
Eblock \
/* Reprise d'une commande interrompue par 'ARRET_PAL_BETA'... */
# Aif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# define SAUVEGARDE_POSITION_PAL_BETA \
Bblock \
COMMANDE_SIMPLE_TYPE_PAL_BETA(PAL_BETA_MEMORY); \
Eblock \
/* Memorisation de la position courante du disque ; cette commande fonctionne en "bascule" */ \
/* avec la commande 'RESTAURE_POSITION_PAL_BETA'. */
# define RESTAURE_POSITION_PAL_BETA \
Bblock \
OUVERTURE_DE_LA_LIGNE_PAL_BETA(BLOC(DEBLOCAGE_DU_CLAVIER_PAL_BETA;)); \
\
COMMANDE_QUELCONQUE_PAL_BETA(_01 \
,LIS1(PAL_BETA_M_SEARCH) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
\
FERMETURE_DE_LA_LIGNE_PAL_BETA; \
Eblock \
/* Retour a la position courante memorisee du disque ; cette commande fonctionne en */ \
/* "bascule" avec la commande 'SAUVEGARDE_POSITION_PAL_BETA'. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O M M A N D E S D E R E C H E R C H E D U D I S Q U E V I D E O P A L - B E T A : */
/* */
/*************************************************************************************************************************************/
# if ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# define RECHERCHE_D_UNE_IMAGE_PAL_BETA(adresse_de_l_image) \
Bblock \
Test(INCLff(adresse_de_l_image,PREMIERE_IMAGE_PAL_BETA,DERNIERE_IMAGE_PAL_BETA)) \
Bblock \
OUVERTURE_DE_LA_LIGNE_PAL_BETA(BLOC(DEBLOCAGE_DU_CLAVIER_PAL_BETA;)); \
\
COMMANDE_QUELCONQUE_PAL_BETA(_01 \
,LIS1(PAL_BETA_SEARCH) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
/* Definition de l'adresse de l'image recherchee ('adresse_de_l_image'). */ \
ENTER_PAL_BETA(ADRESSAGE_PAL_BETA(adresse_de_l_image),ATTENTE_ASYNCHRONE_PAL_BETA); \
\
FERMETURE_DE_LA_LIGNE_PAL_BETA; \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("l'adresse de recherche est inexistante"); \
Eblock \
ETes \
Eblock \
/* Positionnement sur une image d'adresse donnee. */
# define RECHERCHE_D_UN_BLOC_DE_DONNEES_PAL_BETA(adresse_du_bloc_de_donnees) \
Bblock \
Test(INCLff(adresse_du_bloc_de_donnees \
,PREMIERE_ZONE_DE_DONNEES_PAL_BETA \
,DERNIERE_ZONE_DE_DONNEES_PAL_BETA \
) \
) \
Bblock \
OUVERTURE_DE_LA_LIGNE_PAL_BETA(BLOC(DEBLOCAGE_DU_CLAVIER_PAL_BETA;)); \
\
COMMANDE_QUELCONQUE_PAL_BETA(_01 \
,LIS1(PAL_BETA_SEARCH) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
/* Definition de l'adresse du bloc de donnees recherche ('adresse_du_bloc_de_donnees'). */ \
ENTER_PAL_BETA(ADRESSAGE_PAL_BETA(adresse_du_bloc_de_donnees),ATTENTE_ASYNCHRONE_PAL_BETA); \
/* On notera qu'un bloc de donnees est considere comme une image en ce qui concerne son */ \
/* adressage puisqu'il passe par 'ADRESSAGE_PAL_BETA(...)'... */ \
\
FERMETURE_DE_LA_LIGNE_PAL_BETA; \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("l'adresse du bloc demande n'existe pas"); \
Eblock \
ETes \
Eblock \
/* Positionnement sur un bloc de donnees d'adresse donnee. */
# define NOMBRE_DE_TENTATIVES_DE_LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA \
QUATRE \
/* On autorise l'iteration de 'LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA(...)' en cas de defaut */ \
/* car, en effet, il est apparu le 1994101300 qu'une erreur de parite pouvait apparaitre de */ \
/* facon transitoire... */
# ifndef BUG_SYSTEME_PAL_BETA_LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA
# define LECTURE_DES_BLOCS_DE_DONNEES \
AUTORISE \
/* A priori, la lecture des blocs de donnees est AUTORISEe... */
# Aifndef BUG_SYSTEME_PAL_BETA_LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA
# define LECTURE_DES_BLOCS_DE_DONNEES \
INTERDIT \
/* A priori, la lecture des blocs de donnees est INTERDITe... */
# Eifndef BUG_SYSTEME_PAL_BETA_LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA
# define LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA(adresse_du_bloc_de_donnees,valeur_numerique) \
Bblock \
Test(EST_AUTORISE(IKP_____lecture_des_blocs_de_donnees)) \
Bblock \
DEFV(Logical,INIT(iterer_la_LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA,VRAI)); \
/* A priori, 'LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA(...)' doit etre iteree, et ce afin */ \
/* de le faire au moins une fois... */ \
DEFV(Int,INIT(nombre_de_tentatives_DE_LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA \
,NOMBRE_DE_TENTATIVES_DE_LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA \
) \
); \
/* Nombre de tentatives autorisees... */ \
\
Tant(IL_FAUT(iterer_la_LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA)) \
Bblock \
DECR(nombre_de_tentatives_DE_LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA,I); \
/* On decompte les tentatives... */ \
begin_nouveau_block \
Bblock \
\
RECHERCHE_D_UN_BLOC_DE_DONNEES_PAL_BETA(adresse_du_bloc_de_donnees); \
/* Positionnement prealable... */ \
OUVERTURE_DE_LA_LIGNE_PAL_BETA(BLOC(DEBLOCAGE_DU_CLAVIER_PAL_BETA;)); \
\
COMMANDE_QUELCONQUE_PAL_BETA(_01 \
,LIS1(PAL_BETA_READ_DATA) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,ATTENTE_ASYNCHRONE_PAL_BETA \
,LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_MAXIMALE_DES_REPONSES_DU_DISQUE_PAL_BETA \
); \
/* Lecture des donnees numeriques. */ \
\
FERMETURE_DE_LA_LIGNE_PAL_BETA; \
Eblock \
end_nouveau_block \
\
begin_nouveau_block \
Bblock \
DEFV(Int,INIT(index,PREMIER_CARACTERE)); \
/* Index du buffer de reception. */ \
INITIALISATION_DU_CHECK_SUM_PAL_BETA; \
/* A priori, on initialise le "check-sum". */ \
\
Komp(numero_du_caractere_courant,LONGUEUR_MAXIMALE_DES_REPONSES_DU_DISQUE_PAL_BETA) \
Bblock \
Test(IFLT(numero_du_caractere_courant \
,LONGUEUR_MAXIMALE_DES_REPONSES_DU_DISQUE_PAL_BETA \
) \
) \
Bblock \
MISE_A_JOUR_DU_CHECK_SUM_PAL_BETA(IKP_____buffer_de_reception,index); \
/* Calcul progressif du "check-sum" par soustraction toute bete sur tous les caracteres */ \
/* sauf sur le dernier qui est le "check-sum"... */ \
INCR(index,I); \
/* Progression de l'index pour le caractere suivant eventuel... */ \
Eblock \
ATes \
Bblock \
Test(IFEQ(check_sum \
,ITb1(IKP_____buffer_de_reception,INDX(index,PREMIER_CARACTERE)) \
) \
) \
Bblock \
EGAL(ITb1(IKP_____buffer_de_reception,INDX(index,PREMIER_CARACTERE)) \
,END_OF_CHAIN \
); \
/* Lorsque le "check-sum" est bon, on le remplace par un 'END_OF_CHAIN' afin que les donnees */ \
/* soient considerees comme une "bonne" chaine de caracteres... */ \
CAL2(Prin1("\n%s\n",IKP_____buffer_de_reception)); \
/* Et on edite "betement" les donnees... */ \
EGAL(iterer_la_LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA,FAUX); \
/* Puis on demande l'arret de l'iteration de 'LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA(...)'. */ \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("les 'check-sum's enregistre et calcule different"); \
Test(IZLE(nombre_de_tentatives_DE_LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA)) \
Bblock \
EGAL(iterer_la_LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA,FAUX); \
/* On demande l'arret de l'iteration de 'LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA(...)' si il */ \
/* a eu trop de tentatives... */ \
Eblock \
ATes \
Bblock \
/* Lorsqu'il y a eu un defaut et qu'il est encore possible d'iterer, on le fait... */ \
Eblock \
ETes \
Eblock \
ETes \
Eblock \
ETes \
Eblock \
EKom \
Eblock \
end_nouveau_block \
Eblock \
ETan \
Eblock \
ATes \
Bblock \
PRINT_AVERTISSEMENT("fonction 'LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA' non implementee"); \
PRINT_AVERTISSEMENT("elle retourne tout simplement la valeur numerique argument d'appel"); \
/* ATTENTION, le 19990217135150, les 'PRINT_ATTENTION(...)' ont ete remplace par des */ \
/* 'PRINT_AVERTISSEMENT(...)' afin de faire disparaitre implicitement ces messages. En */ \
/* effet, il est evident que ce probleme ne sera jamais corrige et je commence a bien le */ \
/* connaitre... */ \
\
CAL2(Prin1("\n%s\n" \
,MISE_EN_FORME_D_UN_BLOC_DE_DONNEES_PAL_BETA(valeur_numerique) \
) \
); \
/* Et on re-edite "betement" les donnees dans le format attendu... */ \
Eblock \
ETes \
Eblock \
/* Positionnement sur un bloc de donnees d'adresse donnee et lecture. */
# Aif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# if ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# define RECHERCHE_D_UNE_IMAGE_PAL_BETA(adresse_de_l_image) \
Bblock \
Test(INCLff(adresse_de_l_image,PREMIERE_IMAGE_PAL_BETA,DERNIERE_IMAGE_PAL_BETA)) \
Bblock \
OUVERTURE_DE_LA_LIGNE_PAL_BETA(BLOC(DEBLOCAGE_DU_CLAVIER_PAL_BETA;)); \
\
COMMANDE_QUELCONQUE_PAL_BETA(_02 \
,LIS2(PAL_BETA_EXP_8 \
,PAL_BETA_SEARCH_WITH_DATA \
) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
/* Definition de l'adresse de l'image recherchee ('adresse_de_l_image'). */ \
ENTER_PAL_BETA(ADRESSAGE_PAL_BETA(adresse_de_l_image),ATTENTE_ASYNCHRONE_PAL_BETA); \
\
FERMETURE_DE_LA_LIGNE_PAL_BETA; \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("l'adresse de recherche est inexistante"); \
Eblock \
ETes \
Eblock \
/* Positionnement sur une image d'adresse donnee. */
# define RECHERCHE_D_UN_BLOC_DE_DONNEES_PAL_BETA(adresse_du_bloc_de_donnees) \
Bblock \
PRINT_ERREUR("il n'y a pas de blocs de donnees numeriques lors d'une recherche"); \
Eblock \
/* Positionnement sur un bloc de donnees d'adresse donnee. */
# define LECTURE_D_UN_BLOC_DE_DONNEES_PAL_BETA(adresse_du_bloc_de_donnees,valeur_numerique) \
Bblock \
PRINT_ERREUR("il n'y a pas de blocs de donnees numeriques lors d'une lecture"); \
Eblock \
/* Positionnement sur un bloc de donnees d'adresse donnee et lecture. */
# Aif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O M M A N D E S D E L E C T U R E D U D I S Q U E V I D E O P A L - B E T A : */
/* */
/*************************************************************************************************************************************/
# if ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# define AVANT_UN_PAS_PAL_BETA \
Bblock \
COMMANDE_SIMPLE_TYPE_PAL_BETA(PAL_BETA_FWD_STEP_AND_STILL); \
Eblock \
/* Avance d'une seule image. A noter, que cela fonctionnerait tout aussi bien avec */ \
/* la commande 'LIS2(PAL_BETA_F_STEP,PAL_BETA_STILL)'. */
# define ARRIERE_UN_PAS_PAL_BETA \
Bblock \
COMMANDE_SIMPLE_TYPE_PAL_BETA(PAL_BETA_REV_STEP_AND_STILL); \
Eblock \
/* Recul d'une seule image. A noter, que cela fonctionnerait tout aussi bien avec */ \
/* la commande 'LIS2(PAL_BETA_R_STEP,PAL_BETA_STILL)'. */
# Aif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# if ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# define AVANT_UN_PAS_PAL_BETA \
Bblock \
PRINT_ERREUR("la commande d'avance d'une image n'est pas disponible"); \
Eblock \
/* Avance d'une seule image. A noter, que cela fonctionnerait tout aussi bien avec */ \
/* la commande 'LIS2(PAL_BETA_F_STEP,PAL_BETA_STILL)'. */
# define ARRIERE_UN_PAS_PAL_BETA \
Bblock \
PRINT_ERREUR("la commande de recul d'une image n'est pas disponible"); \
Eblock \
/* Recul d'une seule image. A noter, que cela fonctionnerait tout aussi bien avec */ \
/* la commande 'LIS2(PAL_BETA_R_STEP,PAL_BETA_STILL)'. */
# Aif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# define RALENTI_PAL_BETA(ralenti) \
TRON(ralenti,RALENTI_FAIBLE_PAL_BETA,RALENTI_FORT_PAL_BETA) \
/* Pour "valider" le taux de ralenti demande... */
# define AVANT_LENT_PAL_BETA(ralenti) \
Bblock \
OUVERTURE_DE_LA_LIGNE_PAL_BETA(BLOC(DEBLOCAGE_DU_CLAVIER_PAL_BETA;)); \
\
COMMANDE_QUELCONQUE_PAL_BETA(_01 \
,LIS1(PAL_BETA_F_STEP) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
ENTER_PAL_BETA(RALENTI_PAL_BETA(ralenti),PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA); \
/* Definition du taux de ralenti : de '1' (vitesse nominale 1/1) a '255' (vitesse */ \
/* tres lente 1/255). */ \
\
FERMETURE_DE_LA_LIGNE_PAL_BETA; \
Eblock \
/* Avance image par image, avec ralenti programmable. */
# define ARRIERE_LENT_PAL_BETA(ralenti) \
Bblock \
OUVERTURE_DE_LA_LIGNE_PAL_BETA(BLOC(DEBLOCAGE_DU_CLAVIER_PAL_BETA;)); \
\
COMMANDE_QUELCONQUE_PAL_BETA(_01 \
,LIS1(PAL_BETA_R_STEP) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
ENTER_PAL_BETA(RALENTI_PAL_BETA(ralenti),PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA); \
/* Definition du taux de ralenti : de '1' (vitesse nominale 1/1) a '255' (vitesse */ \
/* tres lente 1/255). */ \
\
FERMETURE_DE_LA_LIGNE_PAL_BETA; \
Eblock \
/* Recul image par image, avec ralenti programmable. */
# define AVANT_NORMAL_PAL_BETA \
Bblock \
COMMANDE_SIMPLE_TYPE_PAL_BETA(PAL_BETA_F_PLAY); \
Eblock \
/* Mise en 'PLAY' en marche avant du disque PAL-Beta. */
# define ARRIERE_NORMAL_PAL_BETA \
Bblock \
COMMANDE_SIMPLE_TYPE_PAL_BETA(PAL_BETA_R_PLAY); \
Eblock \
/* Mise en 'PLAY' en marche arriere du disque PAL-Beta. */
# define AVANT_RAPIDE_PAL_BETA \
Bblock \
COMMANDE_SIMPLE_TYPE_PAL_BETA(PAL_BETA_F_FAST); \
Eblock \
/* Mise en 'PLAY' en marche avant rapide du disque PAL-Beta. */
# define ARRIERE_RAPIDE_PAL_BETA \
Bblock \
COMMANDE_SIMPLE_TYPE_PAL_BETA(PAL_BETA_R_FAST); \
Eblock \
/* Mise en 'PLAY' en marche arriere rapide du disque PAL-Beta. */
# define AVANT_EXPLORATION_PAL_BETA \
Bblock \
COMMANDE_SIMPLE_TYPE_PAL_BETA(PAL_BETA_F_SCAN); \
Eblock \
/* Mise en 'PLAY' en marche avant ultra-rapide du disque PAL-Beta. */
# define ARRIERE_EXPLORATION_PAL_BETA \
Bblock \
COMMANDE_SIMPLE_TYPE_PAL_BETA(PAL_BETA_R_SCAN); \
Eblock \
/* Mise en 'PLAY' en marche arriere ultra-rapide du disque PAL-Beta. */
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* L E C T U R E D ' U N E S E Q U E N C E D ' I M A G E S : */
/* */
/*************************************************************************************************************************************/
# if ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# ifdef BUG_SYSTEME_PAL_BETA_PAL_BETA_F_SCAN
# define ENTER_PAL_BETA_F_SCAN(fonction_a_envoyer,valeur_numerique,attendre_une_reponse_multiple) \
Bblock \
PRINT_ATTENTION("fonction 'PAL_BETA_F_SCAN' mal implementee et remplacee par 'PAL_BETA_F_FAST'"); \
\
ENTER_PAL_BETA_AVEC_FONCTION(PAL_BETA_F_FAST \
,valeur_numerique \
,attendre_une_reponse_multiple \
); \
Eblock \
/* Fonction 'ENTER_PAL_BETA_AVEC_FONCTION(...)' speciale pour la fonction 'PAL_BETA_F_SCAN'. */
# Aifdef BUG_SYSTEME_PAL_BETA_PAL_BETA_F_SCAN
# define ENTER_PAL_BETA_F_SCAN(fonction_a_envoyer,valeur_numerique,attendre_une_reponse_multiple) \
Bblock \
ENTER_PAL_BETA_AVEC_FONCTION(fonction_a_envoyer \
,valeur_numerique \
,attendre_une_reponse_multiple \
); \
Eblock \
/* Fonction 'ENTER_PAL_BETA_AVEC_FONCTION(...)' speciale pour la fonction 'PAL_BETA_F_SCAN'. */
# Eifdef BUG_SYSTEME_PAL_BETA_PAL_BETA_F_SCAN
# ifdef BUG_SYSTEME_PAL_BETA_PAL_BETA_REPETITIONS_99
# define NOMBRE_DE_REPETITIONS_MAXIMAL \
PRED(CENT) \
/* Nombre de repetitions maximal... */
# define VERIFICATION_DU_NOMBRE_DE_REPETITIONS(nombre_repet) \
Bblock \
Test(IFGT(nombre_repet,NOMBRE_DE_REPETITIONS_MAXIMAL)) \
Bblock \
PRINT_ATTENTION("le nombre de repetitions va etre reduit"); \
CAL1(Prer1("(a %d)\n",NOMBRE_DE_REPETITIONS_MAXIMAL)); \
Eblock \
ATes \
Bblock \
Eblock \
ETes \
Eblock \
/* Verification de la valeur du nombre de repetitions demandees... */
# define NOMBRE_REPET(nombre_repet) \
COND(IFLE(nombre_repet,NOMBRE_DE_REPETITIONS_MAXIMAL) \
,nombre_repet \
,NOMBRE_DE_REPETITIONS_MAXIMAL \
) \
/* Nombre de repetitions reellement effectuees. */
# Aifdef BUG_SYSTEME_PAL_BETA_PAL_BETA_REPETITIONS_99
# define VERIFICATION_DU_NOMBRE_DE_REPETITIONS(nombre_repet) \
Bblock \
BLOC(VIDE;); \
Eblock \
/* Verification de la valeur du nombre de repetitions demandees... */
# define NOMBRE_REPET(nombre_repet) \
nombre_repet \
/* Nombre de repetitions reellement effectuees. */
# Eifdef BUG_SYSTEME_PAL_BETA_PAL_BETA_REPETITIONS_99
# define gLECTURE_QUELCONQUE_D_UNE_SEQUENCE_PAL_BETA(fonction_lecture,vitesse,nombre_repet,adresse_de_debut,adresse_de_fin) \
/* ATTENTION au bug 'BUG_SYSTEME_PAL_BETA_PAL_BETA_REPETITIONS'... */ \
Bblock \
Test(IFOU(IFET(I5OU(IFEQ(fonction_lecture,PAL_BETA_F_SCAN) \
,IFEQ(fonction_lecture,PAL_BETA_F_FAST) \
,IFEQ(fonction_lecture,PAL_BETA_F_PLAY) \
,IFEQ(fonction_lecture,PAL_BETA_F_SLOW) \
,IFEQ(fonction_lecture,PAL_BETA_F_STEP) \
) \
,IFLE(adresse_de_debut,adresse_de_fin) \
) \
,IFET(I5OU(IFEQ(fonction_lecture,PAL_BETA_R_SCAN) \
,IFEQ(fonction_lecture,PAL_BETA_R_FAST) \
,IFEQ(fonction_lecture,PAL_BETA_R_PLAY) \
,IFEQ(fonction_lecture,PAL_BETA_R_SLOW) \
,IFEQ(fonction_lecture,PAL_BETA_R_STEP) \
) \
,IFGE(adresse_de_debut,adresse_de_fin) \
) \
) \
) \
/* Avant le 20030204093549, le seul test effectue ici etait : */ \
/* */ \
/* IFLE(adresse_de_debut,adresse_de_fin) */ \
/* */ \
/* mais avec la nouvelle version, on prepare l'avenir (par exemple des sequences lues en */ \
/* marche arriere...). */ \
Bblock \
Test(IFET(IFGE(adresse_de_debut,PREMIERE_IMAGE_ENREGISTRABLE_PAL_BETA) \
,IFLE(adresse_de_fin,DERNIERE_IMAGE_PAL_BETA) \
) \
) \
Bblock \
VERIFICATION_DU_NOMBRE_DE_REPETITIONS(nombre_repet); \
\
RECHERCHE_D_UNE_IMAGE_PAL_BETA(adresse_de_debut); \
/* Positionnement au debut de la sequence. */ \
OUVERTURE_DE_LA_LIGNE_PAL_BETA(BLOC(DEBLOCAGE_DU_CLAVIER_PAL_BETA;)); \
\
COMMANDE_QUELCONQUE_PAL_BETA(_01 \
,LIS1(PAL_BETA_REPEAT) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
/* Mise du disque en mode 'REPEAT'. */ \
\
Choi(fonction_lecture) \
Bblock \
Ca1e(PAL_BETA_F_SCAN) \
Bblock \
ENTER_PAL_BETA_F_SCAN(fonction_lecture \
,ADRESSAGE_PAL_BETA(adresse_de_fin) \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
); \
/* Definition de la fin de la sequence (c'est-a-dire la derniere image a lire, et non pas */ \
/* celle qui la suit comme lors d'un enregistrement), avec choix de la vitesse de lecture */ \
/* par l'intermediaire de la fonction 'fonction_lecture'... */ \
Eblock \
ECa1 \
\
Ca1e(PAL_BETA_F_FAST) \
Bblock \
ENTER_PAL_BETA_AVEC_FONCTION(fonction_lecture \
,ADRESSAGE_PAL_BETA(adresse_de_fin) \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
); \
/* Definition de la fin de la sequence (c'est-a-dire la derniere image a lire, et non pas */ \
/* celle qui la suit comme lors d'un enregistrement), avec choix de la vitesse de lecture */ \
/* par l'intermediaire de la fonction 'fonction_lecture'... */ \
Eblock \
ECa1 \
\
Ca1e(PAL_BETA_F_PLAY) \
Bblock \
ENTER_PAL_BETA(ADRESSAGE_PAL_BETA(adresse_de_fin) \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
); \
/* Definition de la fin de la sequence (c'est-a-dire la derniere image a lire, et non pas */ \
/* celle qui la suit comme lors d'un enregistrement) ; on notera que pour 'PAL_BETA_F_PLAY' */ \
/* la fonction utilisee pour la lecture n'a pas besoin d'etre indiquee ('PAL_BETA_F_PLAY' */ \
/* est implicite et ce a cause de l'odre de {adresse_de_debut,adresse_de_fin}). */ \
Eblock \
ECa1 \
\
Ca1e(PAL_BETA_F_SLOW) \
Bblock \
ENTER_PAL_BETA_AVEC_FONCTION(fonction_lecture \
,ADRESSAGE_PAL_BETA(adresse_de_fin) \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
); \
/* Definition de la fin de la sequence (c'est-a-dire la derniere image a lire, et non pas */ \
/* celle qui la suit comme lors d'un enregistrement), avec choix de la vitesse de lecture */ \
/* par l'intermediaire de la fonction 'fonction_lecture'... */ \
Eblock \
ECa1 \
\
Ca1e(PAL_BETA_F_STEP) \
Bblock \
ENTER_PAL_BETA_AVEC_FONCTION(fonction_lecture \
,ADRESSAGE_PAL_BETA(adresse_de_fin) \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
); \
/* Definition de la fin de la sequence (c'est-a-dire la derniere image a lire, et non pas */ \
/* celle qui la suit comme lors d'un enregistrement), avec choix de la vitesse de lecture */ \
/* par l'intermediaire de la fonction 'fonction_lecture'... */ \
Eblock \
ECa1 \
\
Ca1e(PAL_BETA_R_SCAN) \
/* Introduit le 20030204132922... */ \
Bblock \
PRINT_ERREUR("la fonction 'PAL_BETA_R_SCAN' ne marche pas et donc non implementee"); \
/* Ceci a ete vu le 20030206163940 grace a 'v $xtc/disk_vi_P.21$c'... */ \
Eblock \
ECa1 \
\
Ca1e(PAL_BETA_R_FAST) \
/* Introduit le 20030204132922... */ \
Bblock \
PRINT_ERREUR("la fonction 'PAL_BETA_R_FAST' ne marche pas et donc non implementee"); \
/* Ceci a ete vu le 20030206163940 grace a 'v $xtc/disk_vi_P.21$c'... */ \
Eblock \
ECa1 \
\
Ca1e(PAL_BETA_R_PLAY) \
/* Introduit le 20030204132922... */ \
Bblock \
ENTER_PAL_BETA(ADRESSAGE_PAL_BETA(adresse_de_fin) \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
); \
/* Definition de la fin de la sequence (c'est-a-dire la derniere image a lire, et non pas */ \
/* celle qui la suit comme lors d'un enregistrement) ; on notera que pour 'PAL_BETA_R_PLAY' */ \
/* la fonction utilisee pour la lecture n'a pas besoin d'etre indiquee ('PAL_BETA_R_PLAY' */ \
/* est implicite et ce a cause de l'odre de {adresse_de_debut,adresse_de_fin}). */ \
Eblock \
ECa1 \
\
Ca1e(PAL_BETA_R_SLOW) \
Bblock \
PRINT_ERREUR("la fonction 'PAL_BETA_R_SLOW' ne marche pas et donc non implementee"); \
/* Ceci a ete vu le 20030206163940 grace a 'v $xtc/disk_vi_P.21$c'... */ \
Eblock \
ECa1 \
\
Ca1e(PAL_BETA_R_STEP) \
/* Introduit le 20030204132922... */ \
Bblock \
PRINT_ERREUR("la fonction 'PAL_BETA_R_STEP' ne marche pas et donc non implementee"); \
/* Ceci a ete vu le 20030206163940 grace a 'v $xtc/disk_vi_P.21$c'... */ \
Eblock \
ECa1 \
\
Defo \
Bblock \
PRINT_ERREUR("la fonction demandee n'est pas autorisee pour 'PAL_BETA_F_REPEAT'"); \
Eblock \
EDef \
Eblock \
ECho \
\
Test(IFEQ(fonction_lecture,PAL_BETA_F_STEP)) \
Bblock \
ENTER_PAL_BETA(NOMBRE_REPET(nombre_repet),PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA); \
/* Definition du nombre de repetitions a effectuer. */ \
ENTER_PAL_BETA(RALENTI_PAL_BETA(vitesse),ATTENTE_ASYNCHRONE_PAL_BETA); \
/* Definition de la vitesse de la lecture, et attente de fin de lecture... */ \
Eblock \
ATes \
Bblock \
ENTER_PAL_BETA(NOMBRE_REPET(nombre_repet),ATTENTE_ASYNCHRONE_PAL_BETA); \
/* Definition du nombre de repetitions a effectuer, et attente de fin de lecture ; on notera */ \
/* qu'il n'y a que pour 'PAL_BETA_F_STEP' que l'on definit une vitesse... */ \
Eblock \
ETes \
\
FERMETURE_DE_LA_LIGNE_PAL_BETA; \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("la sequence a lire contient des adresses inexistantes"); \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("la definition de la sequence d'images a lire est mauvaise"); \
Eblock \
ETes \
Eblock \
/* Lecture quelconque d'une sequence commencant a l'adresse 'adresse_de_debut' et se */ \
/* terminant a l'adresse 'adresse_de_fin'. On notera que l'on peut changer le mode de */ \
/* lecture par l'intermediaire de 'fonction_lecture' et du taux de ralenti */ \
/* par 'vitesse'. */
# ifdef BUG_SYSTEME_PAL_BETA_PAL_BETA_REPETITIONS
# define LECTURE_QUELCONQUE_D_UNE_SEQUENCE_PAL_BETA(fonction_lecture,vitesse,nombre_repet,adresse_debut,adresse_fin) \
Bblock \
Test(IFGT(NOMBRE_REPET(nombre_repet),UN)) \
Bblock \
VERIFICATION_DU_NOMBRE_DE_REPETITIONS(nombre_repet); \
\
gLECTURE_QUELCONQUE_D_UNE_SEQUENCE_PAL_BETA(fonction_lecture \
,vitesse \
,NOMBRE_REPET(nombre_repet) \
,adresse_debut \
,SUCC(adresse_fin) \
); \
RECHERCHE_D_UNE_IMAGE_PAL_BETA(adresse_fin); \
Eblock \
ATes \
Bblock \
gLECTURE_QUELCONQUE_D_UNE_SEQUENCE_PAL_BETA(fonction_lecture \
,vitesse \
,NOMBRE_REPET(nombre_repet) \
,adresse_debut \
,adresse_fin \
); \
Eblock \
ETes \
Eblock \
/* Lecture quelconque d'une sequence commencant a l'adresse 'adresse_debut' et se */ \
/* terminant a l'adresse 'adresse_fin'. On notera que l'on peut changer le mode de */ \
/* lecture par l'intermediaire de 'fonction_lecture' et du taux de ralenti */ \
/* par 'vitesse'. */
# Aifdef BUG_SYSTEME_PAL_BETA_PAL_BETA_REPETITIONS
# define LECTURE_QUELCONQUE_D_UNE_SEQUENCE_PAL_BETA(fonction_lecture,vitesse,nombre_repet,adresse_debut,adresse_fin) \
Bblock \
VERIFICATION_DU_NOMBRE_DE_REPETITIONS(nombre_repet); \
\
gLECTURE_QUELCONQUE_D_UNE_SEQUENCE_PAL_BETA(fonction_lecture \
,vitesse \
,NOMBRE_REPET(nombre_repet) \
,adresse_debut \
,adresse_fin \
) \
Eblock \
/* Lecture quelconque d'une sequence commencant a l'adresse 'adresse_debut' et se */ \
/* terminant a l'adresse 'adresse_fin'. On notera que l'on peut changer le mode de */ \
/* lecture par l'intermediaire de 'fonction_lecture' et du taux de ralenti */ \
/* par 'vitesse'. */
# Eifdef BUG_SYSTEME_PAL_BETA_PAL_BETA_REPETITIONS
# define LECTURE_D_UNE_SEQUENCE_PAL_BETA(adresse_de_debut,adresse_de_fin) \
Bblock \
LECTURE_QUELCONQUE_D_UNE_SEQUENCE_PAL_BETA(PAL_BETA_F_PLAY \
,VITESSE_NOMINALE_PAL_BETA \
,REPETER_UNE_FOIS_UNE_SEQUENCE_PAL_BETA \
,adresse_de_debut \
,adresse_de_fin \
); \
Eblock \
/* Lecture nominale d'une sequence commencant a l'adresse 'adresse_de_debut' et se */ \
/* terminant a l'adresse 'adresse_de_fin'. */
# Aif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# if ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# define gLECTURE_PAL_BETA(fonction_lecture) \
Bblock \
COMMANDE_SIMPLE_TYPE_PAL_BETA(fonction_lecture); \
Eblock \
/* Mise en mode lecture du magnetoscope. */ \
# define LECTURE_PAL_BETA \
Bblock \
gLECTURE_PAL_BETA(PAL_BETA_F_PLAY); \
Eblock \
/* Mise en mode lecture du magnetoscope a vitesse nominale. */
# define LECTURE_QUELCONQUE_D_UNE_SEQUENCE_PAL_BETA(fonction_lecture,vitesse,nombre_repet,adresse_debut,adresse_fin) \
Bblock \
PRINT_ERREUR("la lecture quelconque de sequences d'images est indisponible"); \
Eblock \
/* Lecture quelconque d'une sequence commencant a l'adresse 'adresse_debut' et se */ \
/* terminant a l'adresse 'adresse_fin'. On notera que l'on peut changer le mode de */ \
/* lecture par l'intermediaire de 'fonction_lecture' et du taux de ralenti */ \
/* par 'vitesse'. */
# define LECTURE_D_UNE_SEQUENCE_PAL_BETA(adresse_de_debut,adresse_de_fin) \
Bblock \
PRINT_ERREUR("la lecture de sequences d'images est indisponible"); \
Eblock \
/* Lecture nominale d'une sequence commencant a l'adresse 'adresse_de_debut' et se */ \
/* terminant a l'adresse 'adresse_de_fin'. */
# Aif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O M M A N D E S D ' E C R I T U R E D U D I S Q U E V I D E O P A L - B E T A : */
/* */
/*************************************************************************************************************************************/
# if ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# define ENREGISTREMENT_EN_CONTINU_D_UNE_SEQUENCE_PAL_BETA \
Bblock \
PRINT_ERREUR("l'enregistrement d'images en continu est indisponible"); \
Eblock \
/* Commande d'enregistrement d'images en continu. */
# define ENREGISTREMENT_D_UNE_SEQUENCE_PAL_BETA(adresse_de_debut,adresse_de_fin) \
Bblock \
Test(IFLE(adresse_de_debut,adresse_de_fin)) \
Bblock \
Test(IFET(IFGE(adresse_de_debut,PREMIERE_IMAGE_ENREGISTRABLE_PAL_BETA) \
,IFLE(adresse_de_fin,DERNIERE_IMAGE_PAL_BETA) \
) \
) \
Bblock \
OUVERTURE_DE_LA_LIGNE_PAL_BETA(BLOC(DEBLOCAGE_DU_CLAVIER_PAL_BETA;)); \
\
COMMANDE_QUELCONQUE_PAL_BETA(_01 \
,LIS1(PAL_BETA_FRAME_REC) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
/* Mise en mode image par image a priori... */ \
COMMANDE_QUELCONQUE_PAL_BETA(_01 \
,LIS1(PAL_BETA_REC_STANDBY) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
/* Entree des parametres d'enregistrement : */ \
ENTER_PAL_BETA(ADRESSAGE_PAL_BETA(NEUT(adresse_de_debut)),PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA); \
/* Definition du point d'entree ('adresse_de_debut'), */ \
ENTER_PAL_BETA(ADRESSAGE_PAL_BETA(SUCC(adresse_de_fin)),PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA); \
/* Definition du point de sortie (qui est juste derriere 'adresse_de_fin'), */ \
ENTER_PAL_BETA(NBRE(NEUT(adresse_de_debut),NEUT(adresse_de_fin)),ATTENTE_ASYNCHRONE_PAL_BETA); \
/* Definition du nombre d'images enregistrees. */ \
COMMANDE_QUELCONQUE_PAL_BETA(_01 \
,LIS1(PAL_BETA_REC) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
\
FERMETURE_DE_LA_LIGNE_PAL_BETA; \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("la sequence a enregistrer contient des adresses inexistantes"); \
Eblock \
ETes \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("la definition de la sequence d'images a enregistrer est mauvaise"); \
Eblock \
ETes \
Eblock \
/* Enregistrement d'une sequence commencant a l'adresse 'adresse_de_debut' et se */ \
/* terminant a l'adresse 'adresse_de_fin'. */
# define ENREGISTREMENT_D_UNE_IMAGE_PAL_BETA(adresse_de_l_image) \
Bblock \
ENREGISTREMENT_D_UNE_SEQUENCE_PAL_BETA(adresse_de_l_image,adresse_de_l_image); \
Eblock \
/* Enregistrement d'une seule image a l'adresse 'adresse_de_l_image'. On notera l'absence */ \
/* du couple 'OUVERTURE_DE_LA_LIGNE_PAL_BETA'/'FERMETURE_DE_LA_LIGNE_PAL_BETA', puisqu'en */ \
/* effet, il est present dans 'ENREGISTREMENT_D_UNE_SEQUENCE_PAL_BETA()'... */
# define MISE_EN_FORME_D_UN_BLOC_DE_DONNEES_PAL_BETA(valeur_numerique) \
chain_numero(valeur_numerique \
,LONGUEUR_DES_BLOCS_DE_DONNEES_PAL_BETA \
) \
/* Mise en forme d'un bloc de donnees numeriques avant enregistrement. */
# define ENREGISTREMENT_D_UN_BLOC_DE_DONNEES_PAL_BETA(adresse_du_bloc_de_donnees,valeur_numerique) \
Bblock \
Test(INCLff(adresse_du_bloc_de_donnees \
,PREMIERE_ZONE_DE_DONNEES_PAL_BETA \
,DERNIERE_ZONE_DE_DONNEES_PAL_BETA \
) \
) \
Bblock \
RECHERCHE_D_UN_BLOC_DE_DONNEES_PAL_BETA(adresse_du_bloc_de_donnees); \
/* Positionnement preliminaire dans la zone des donnees numeriques... */ \
OUVERTURE_DE_LA_LIGNE_PAL_BETA(BLOC(DEBLOCAGE_DU_CLAVIER_PAL_BETA;)); \
\
COMMANDE_QUELCONQUE_PAL_BETA(_01 \
,LIS1(PAL_BETA_SET_DATA) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
COMMANDE_QUELCONQUE_PAL_BETA(_11 \
,LIS1(MISE_EN_FORME_D_UN_BLOC_DE_DONNEES_PAL_BETA(valeur_numerique)) \
,PAS_D_ACQUITTEMENT_INDIVIDUEL_DES_CARACTERES \
,ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
/* Preparation des donnees numeriques (avec leur "check-sum"), */ \
COMMANDE_QUELCONQUE_PAL_BETA(_01 \
,LIS1(PAL_BETA_WRITE_DATA) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
/* Et ecriture sur le disque... */ \
\
FERMETURE_DE_LA_LIGNE_PAL_BETA; \
Eblock \
ATes \
Bblock \
PRINT_ERREUR("le bloc a enregistrer n'existe pas"); \
Eblock \
ETes \
Eblock \
/* Enregistrement d'un bloc de donnees numeriques a une certaine adresse. */
# Aif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
|| (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# if ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# define ENREGISTREMENT_EN_CONTINU_D_UNE_SEQUENCE_PAL_BETA \
Bblock \
OUVERTURE_DE_LA_LIGNE_PAL_BETA(BLOC(DEBLOCAGE_DU_CLAVIER_PAL_BETA;)); \
\
/* La sequence suivante : */ \
/* */ \
/* COMMANDE_QUELCONQUE_PAL_BETA(_01 */ \
/* ,LIS1(PAL_BETA_STILL) */ \
/* ,UN_ACQUITTEMENT_PAR_CARACTERE */ \
/* ,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA */ \
/* ,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES */ \
/* ,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES */ \
/* ); */ \
/* */ \
/* semble inutile... */ \
COMMANDE_QUELCONQUE_PAL_BETA(_01 \
,LIS1(PAL_BETA_REC_PAUSE) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
/* Mise en pause, la commande 'PAL_BETA_STILL' etant surement inutile... */ \
\
/* ATTENTION, il est impossible d'ecrire : */ \
/* */ \
/* COMMANDE_SIMPLE_TYPE_PAL_BETA(PAL_BETA_STILL); */ \
/* COMMANDE_SIMPLE_TYPE_PAL_BETA(PAL_BETA_REC_PAUSE); */ \
/* COMMANDE_SIMPLE_TYPE_PAL_BETA(PAL_BETA_REC_DUB_REQUEST); */ \
/* COMMANDE_SIMPLE_TYPE_PAL_BETA(PAL_BETA_REC); */ \
/* */ \
/* car, en effet, les couples : */ \
/* */ \
/* OUVERTURE_DE_LA_LIGNE_PAL_BETA(BLOC(DEBLOCAGE_DU_CLAVIER_PAL_BETA;)); */ \
/* FERMETURE_DE_LA_LIGNE_PAL_BETA; */ \
/* */ \
/* qui sont a l'interieur de 'COMMANDE_SIMPLE_TYPE_PAL_BETA(...)' font qu'alors l'image */ \
/* courante enregistree ne l'est pas a partir de 'adresse_de_l_image', mais qu'en fait, */ \
/* elle ecrase aussi environ une seconde de bande avant... */ \
\
COMMANDE_QUELCONQUE_PAL_BETA(_02 \
,LIS2(PAL_BETA_REC_DUB_REQUEST \
,PAL_BETA_REC \
) \
,UN_ACQUITTEMENT_PAR_CARACTERE \
,PAS_D_ATTENTE_ASYNCHRONE_PAL_BETA \
,NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
,LONGUEUR_SI_NE_PAS_LIRE_DES_DONNEES_NUMERIQUES \
); \
/* Et mise en enregistrement (voir le commentaire important qui precede...). */ \
FERMETURE_DE_LA_LIGNE_PAL_BETA; \
Eblock \
/* Commande d'enregistrement d'images en continu. */
# define ENREGISTREMENT_D_UNE_SEQUENCE_PAL_BETA(adresse_de_debut,adresse_de_fin) \
Bblock \
PRINT_ERREUR("l'enregistrement de sequences d'images est indisponible"); \
Eblock \
/* Enregistrement d'une sequence commencant a l'adresse 'adresse_de_debut' et se */ \
/* terminant a l'adresse 'adresse_de_fin'. */
# define DUREE_DE_L_ENREGISTREMENT_D_UNE_IMAGE_PAL_BETA \
QUATRE \
/* Pour enregistrer une image, on enregistre en fait pendant quatre secondes. ATTENTION, on */ \
/* notera qu'une duree inferieure (et par exemple 'DEUX') provoque un comportement */ \
/* aleatoire (l'image est ou n'est pas enregistree, ce qui doit correspondre au fait */ \
/* que la commande 'PAL_BETA_STOP' doit arriver trop tot...). */
# define ENREGISTREMENT_D_UNE_IMAGE_PAL_BETA(adresse_de_l_image) \
Bblock \
Test(INCLff(adresse_de_l_image,PREMIERE_IMAGE_ENREGISTRABLE_PAL_BETA,DERNIERE_IMAGE_PAL_BETA)) \
Bblock \
RECHERCHE_D_UNE_IMAGE_PAL_BETA(adresse_de_l_image); \
/* Positionnement de la machine... */ \
\
ENREGISTREMENT_EN_CONTINU_D_UNE_SEQUENCE_PAL_BETA; \
/* Commande d'enregistrement d'images en continu. */ \
\
DODO(DUREE_DE_L_ENREGISTREMENT_D_UNE_IMAGE_PAL_BETA); \
/* Et ce pendant un certain temps... */ \
COMMANDE_SIMPLE_TYPE_PAL_BETA(PAL_BETA_STOP); \
/* Puis on arrete la machine... */ \
\
Eblock \
ATes \
Bblock \
PRINT_ERREUR("l'adresse de l'image a enregistrer est inexistante"); \
Eblock \
ETes \
Eblock \
/* Enregistrement d'une seule image a l'adresse 'adresse_de_l_image'. On notera que dans */ \
/* ce contexte ('__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P'), l'enregistrement */ \
/* d'une image se fait en ecrasant la bande a partir de 'adresse_de_l_image' et ce pendant */ \
/* 'DUREE_DE_L_ENREGISTREMENT_D_UNE_IMAGE_PAL_BETA' secondes. Ainsi, on ne peut pas realiser */ \
/* le remplacement d'une image par une autre (c'est le 'UVW1800P' qui le permettrait, car */ \
/* c'est en effet une machine de montage...). */
# define ENREGISTREMENT_D_UN_BLOC_DE_DONNEES_PAL_BETA(adresse_du_bloc_de_donnees,valeur_numerique) \
Bblock \
PRINT_ERREUR("l'enregistrement d'un bloc de donnees est indisponible"); \
Eblock \
/* Enregistrement d'un bloc de donnees numeriques a une certaine adresse. */
# Aif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
/*===================================================================================================================================*/
/*************************************************************************************************************************************/
/* */
/* C O M M A N D E S D ' E C R I T U R E D U D I S Q U E V I D E O P A L - B E T A : */
/* */
/*************************************************************************************************************************************/
# if ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
)
# define EDITION_DU_TYPE_DE_MACHINE_PAL_BETA \
Bblock \
CAL2(Prin0("la machine utilisee est un disque video 'LVR4000P'\n\n")); \
Eblock \
/* Commande d'enregistrement d'images en continu. */
# Aif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVR4000P)) \
)
# if ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# define EDITION_DU_TYPE_DE_MACHINE_PAL_BETA \
Bblock \
CAL2(Prin0("la machine utilisee est un disque video 'LVS6000P-LVR6000'\n\n")); \
Eblock \
/* Commande d'enregistrement d'images en continu. */
# Aif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_DISQUE_PAL_BETA_LVS6000P_LVR6000)) \
)
# if ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# define EDITION_DU_TYPE_DE_MACHINE_PAL_BETA \
Bblock \
CAL2(Prin0("la machine utilisee est un magnetoscope 'UVW1400P'\n\n")); \
Eblock \
/* Commande d'enregistrement d'images en continu. */
# Aif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
# Eif ( (defined(__VERSION__GESTION_D_UN_MAGNETOSCOPE_PAL_BETA_UVW1400P)) \
)
#Aifdef __VERSION__COMPILER_LA_GESTION_DU_DISQUE_PAL_BETA
#Eifdef __VERSION__COMPILER_LA_GESTION_DU_DISQUE_PAL_BETA