/* documentation des appels  la librairie dynamique screen.ldg */

Screen.ldg 0.65

6 fonctions sont  disposition:

                         --------------------------

long __CDECL screen_init( long vdihandle, videoinf *display, char *type_ecran, sortievideo 
*more_infos, long flag) 
	Permet d'initialiser l'cran cette fonction doit tre appele avant la  
	fonction  d'affichage  l'cran screen_display(). Un seul appel  
	cette fonction suffit.

paramtres
screen_init() retourne 0 si l'cran n'est pas support 1 si il l'est 
et que le mode est rapide, 2 si il est support mais que le mode est 
lent et -1 si le type d'cran propos est stupide.

vdihandle: numro de la station virtuelle VDI de votre application
display: pointeur sur une structure "videoinf" la fonction remplira 
pour vous largeur_ECRAN, hauteur_ECRAN, octets, add_ECRAN. Le reste est a remplir 
 votre charge en fonction de vos besoins.
type_ecran: chaine de caractre dcrivant l'cran cela peut tre donn 
par le testeur d'cran.
more_infos: structure remplie par la fonction vous permettant de 
connaitre les palettes ncessaires.
flag: Si premire fois que vous utilisez cette procedure mettre 0, si 
il y a eu changement de rsolution mettre -1L

Cette procdure est absolument ncessaire une fois avant 
screen_display() mais interdit avant virtual_display()

                         --------------------------
    
void __CDECL screen_display(long vdihandle, videoinf *display) 
	Affiche l'image sur l'cran

 Fonction permettant d'afficher directement  l'cran une image RGB
 ou une partie d'image de taille indiffrente. Cette fonction permet
 de rduire les couleurs et d'afficher du mode RVB 32bits au mode
 palette 8bits avec tramage.

vdihandle: numro de la station virtuelle VDI de votre application
display : strcture pralablement remplie dcrivant ce que l'on veut 
faire.


                         --------------------------

long __CDECL virtual_display(long vdihandle, videoinf *display, char *type_memoire, sortievideo 
*more_infos) 
	Permet de travailler en mmoire et permet par exemple de faire du
	tramage rapide. Le type de format d'image  grer en mmoire 
	doit tre dcrit par *display et *type_mmoire que vous aurez 
	rempli prallablement.

paramtres

virtual_display() retourne 0 si l'cran n'est pas support 1 si il l'est 
et que le mode est rapide, 2 si il est support mais que le mode est 
lent et -1 si le type d'cran propos est stupide.

vdihandle: numro de la station virtuelle VDI de votre application
display: pointeur sur une structure "videoinf" il faut remplir 
les champs largeur_ECRAN, hauteur_ECRAN, octets, add_ECRAN, contrairement  la 
fonction screen_init().  add_ECRAN doit correspondre  l'adresse 
mmoire o vous voulez faire la copie.
type_memoire: description du format de sorti dsir comme pour 
screen_init()
more_infos: structure remplie par la fonction vous permettant de 
connaitre les palettes ncessaires.

Remarque: Il est interdit d'utiliser screen_init() si vous dcidez 
d'utiliser l'affichage virtuel
                         --------------------------


void __CDECL fix_palette(sortievideo *more_infos, long mode, long vdihandle)
  Pour fixer la palette (valable jusqu' 256 couleurs)  utiliser 
  aprs screen_init()

more_infos: dja pass  screen_init()
mode: 1L pour le moment
vdihandle: numro vdi de la virtual worstation.


                         --------------------------

long __CDECL screen_detect(long vdihandle, char *answer)
	Permet de dtecter le format hard de la mmoire vido
	Supporte normalement toutes les machines GEM mme les 
	mulateurs.
	
paramtres

screen_detect() retourne un long <0L si il y a erreur

vdihandle: handle VDI de votre application
*answer: pointeur sur une chaine de caractre (mini 50), dans cette 
chaine sera retourn le format en ASCII de la vido, dsigne comme 
suit:
_En premier un chiffre prcd ventuellement par -, ce chiffre 
reprsente le nombre de plans de la vido, le - indique qu'il s'agit 
d'un codage au format Little Endiant (format Intel) au lieu d'un 
Big Endiant (format Motorola).

_Ensuite vient le format par lui mme, deux cas distincts, les formats 
 palette (jusqu' 8 plans) et les formats RVB au del.
Dans le premier cas le chiffre est suivi ventuellement de E si 
l'cran est au format entrelac puis de C puis ventuellement de 
SP qui signifie que la palette n'est pas hard mais de type soft (si 
vous changez la dfinition d'une couleur, les pixels dja dessins  
l'cran ne seront pas modifis, seuls les pixels dessins aprs 
auront la couleur voulue)  ex: 8C, 8EC, 8CSP ...
Dans le second cas sont exprims le codage RVB, dans l'ordre de codage 
du poids fort vers le poids faible chaque couleur dsigne par la 
lettre R(rouge), V(vert), B(bleu) ou encore X(bit non utilis) suivi 
du nombre de bits utiliss. ex: 32X8R8V8B8

_Ce codage peut tre suivi de la mention "VDI", qui signifie que 
l'cran n'est pas accessible directement (Physbase, Logbase ne 
fonctionne pas), c'est possible avec certains mulateurs. Il faut donc 
adresser l'cran avec le VDI pas le choix. ex: 8CSPVDI
screen_display() ne sait pas directement raliser cette opration, il 
est ncessaire d'allouer un bloc mmoire suffisament grand puis par 
virtual_display() de demander le dessin dans ce bloc. Il ne vous reste 
plus qu' faire une copie avec vro_cpyfm(). Le format bien sur doit 
correspondre au format d'cran si vous copiez avec le paramtre 
fd_stand = 0 des structures MFDB passes. Si fd_stand = 1 alors il 
faut prendre le format VDI standard correspondant au nombre de plans 
de votre cran (note pour le moment il n'existe pas ce mode en 8 
plans, cette fonctionalit est  l'tude)

_Le codage est ensuite suivi de la lettre ':' puis du nombre 
supplmentaire d'octets en fin de ligne (la plupart du temps 0 mais 
ce genre de carte existe sur Mac)

Actuellement le systme supporte les mmoires video suivantes:
32 plans:
	32X8R8V8B8
	32R8V8B8X8
	32B8V8R8X8
	32X8B8V8R8   (rem: TGA32)
24 plans:                
	24R8V8B8 (format de base des fonctions)
	24B8V8R8     (rem: TGA24)
16(15) plans:
	-16R5V6B5
	-16X1R5V5B5
	16R5V6B5
	16X1R5V5B5
	16R5V5X1B5 (TC color Falcon)
8 plans avec palette:
	8C
	8G
	8EC
	8EG


                         --------------------------

void __CDECL trnfm_8C_to_R8V8B8(unsigned char *src8C, void *destR8V8B8, unsigned char *palette,long width, long height,long mode)
   transforme une image entire de type 8C vers mode TC 24R8V8B8 
   (le mode normalis pour screen), cette foncton ne travaille que sur 
   des image entres et simples, elle ne peut donc tre utilise que 
   pour du travaille buffuris et non en acces directe vido

paramtres:

*src8C: pointeur sur l'image  transformer
*destR8V8B8: pointeur sur le buffer destination
*palette: palette RGB de l'image source 8bits par couleur fondamentale, donc 3octets par couleur
	les valeurs sont  la suites les unes des autres couleurs de 0  255
width: largeur de l'image en pixels (1pixel = 1octet)
height: hauteur de l'image en pixels
mode: pour le moment mettre 0L


Et c'est fini!!!

La procdure supporte:

-Ecrans  nombres de plans: 1, 2, 4, 8, 16(15), 24, 32
-Les formats doivent tre du type palette couleur pour le nombre de 
plans de 1  8 et au format type RVB de 16  32
-Permet de dtecter si un cran est du type entrelac ou non pour les 
crans de type palette couleur
-Pour ce mme type d'cran il permet de dterminer si la palette hard 
existe ou non (ex TOS2WIN, STemulator n'ont pas de palette hard)
-Pour les crans type RVB il permet de dtecter si l'cran est au 
format Little Endiant ou Big Endiant (cela n'a d'intrt qu'en 16 
plans).
-Permet de dtecter si en fin de ligne il y a des octets 
supplmentaires inutiles (cas possible sous MagicMac selon carte 
vido)
-La procdure dtecte si on peut ou non adresser directement l'cran.
-Ca marche sur tout ce que j'ai pu tester (ST, Hades Nova, MagicMac,
STemulator, Tos2Win, TosBox, Magic ...) Si vous constatez une 
incompatibilit contactez nous!!!


screen_ldg supporte le partage entre plusieurs applications il n'y a
rien de particulier  faire

Les structures:

typedef struct
{
	unsigned LONG add_RGB;       /* adresse du buffer image au format natif RGB 8bits 
															par couleur si -1L forcer  reconnaitre l'cran
															pas d'affichage retour des paramtres dans la structure
															et typepixel rempli (prvoir 15 octets) */
	unsigned WORD largeur_RGB;   /* largeur de l'image RGB */
	unsigned WORD hauteur_RGB;   /* hauteur de l'image RGB */
	unsigned LONG add_ECRAN;     /* adresse cran ou mmoire si NULL automatique cran */
	unsigned WORD largeur_ECRAN; /* largeur de l'cran en pixels si 0 automatique*/
	unsigned WORD hauteur_ECRAN; /* hauteur de l'cran en pixels si 0 automatique*/
	LONG octets;  /* nombres d'octets de dcalage en fin de ligne sur la plupart des 
								cartes = 0*/
	unsigned WORD  position_X;   /* position sur l'cran en pixels selon X de dpart de recopie */
	unsigned WORD position_Y;	   /* position sur l'cran en pixels selon Y de dpart de recopie */
	unsigned WORD X_voulu;       /* position dans l'image en pixels selon X de dpart de recopie */
	unsigned WORD Y_voulu;       /* position dans l'image en pixels selon Y de dpart de recopie */
	unsigned WORD largeur_voulue;/* largeur en pixel de recopie */
	unsigned WORD hauteur_voulue;/* hauteur en pixels de recopie */
	unsigned LONG add_palette_SP;/* adresse d'un tableau de 255 valeurs des correspondances
	  				de couleur pour le cas sans palette hard */
} videoinf;

typedef struct
{
	unsigned LONG chainepix;  /* adresse de la chaine de caractre dcrivant un pixel */
	unsigned char retour1;    /* 0 oK, 0xFF cran non support */ 
	unsigned char retour2;    /* 0xFF routine gnrale lente */
	unsigned WORD version;    /* numro de version */
	unsigned LONG palettecouleur; /* adresse palette couleur */
	unsigned LONG palettegris;    /* adresse palette grise */
} sortievideo;

Exemple d'utilisation

Affichage directe  l'cran exemple pour GCC:

#include <stdio.h>
#include <osbind.h>
#include <ldg.h>
#include <compiler.h>
#include "scrnldg.h" 
long __CDECL (*screen_detect)(long vdihandle, char *answer);
long __CDECL (*screen_init)(long vdihandle, videoinf *display, char *type_ecran, sortievideo *more_infos, long flag);
static void __CDECL (*fix_palette)(sortievideo *more_infos, long mode, long vdihandle)=NULL;
void __CDECL (*screen_display)(long vdihandle, videoinf *display);

main()
{ videoinf mydisplay;
  sortievideo myinfos;
  int app_id,vdihandle, work_in[]= {1,1,1,1,1,1,1,1,1,1,2}, work_out[57];  
  LDG *screenldg;
  
  app_id = appl_init (); 
  
  if( (screenldg = ldg_exec ( app_id, "screen.ldg")) == NULL)  /* Chargement de la lib screen.ldg */
  { /* chec */
    form_alert ( 1, "[1][Erreur chargement librairie |SCREEN.LDG!][OK]");
    appl_exit();
    exit(0);
  }
  				/* recharche des fonctions de screen.ldg pour les utiliser */
  screen_detect=ldg_find("screen_detect", screenldg);
  screen_init=ldg_find("screen_init", screenldg);
  fix_palette=ldg_find("fix_palette", screenldg);
  screen_display=ldg_find("screen_display", screenldg);
  
  if((screen_detect!=NULL)&&(screen_init!=NULL)&&(fix_palette!=NULL)&&(screen_display!=NULL)) /* les fonctions ont t trouves */
  { char retourneecc[50];
    retourneecc[0]=0;
    
    v_opnvwk(work_in,&vdihandle,work_out); /* les fonctions ont besoin du handle VDI pour fonctionner on ouvre une station virtuelle VDI */
    
    if(screen_detect((long)vdihandle,retourneecc)>=0) 
    {  /* cran reconnu mais peut tre pas support! on n'en sait 
       rien jusque l */
       if(screen_init((long)vdihandle, &mydisplay,retourneecc,&myinfos,0L)>0) 
       { /* cran support ca rempli tout par dfaut  notre place */
       	 char *pt_image; /* pointeur sur notre image */
       	 
       	 fix_palette(&myinfos, 1L, (long) vdihandle); /* l je fixe la pallette n'est en fait ncessaire que pour les rsolution <= 8 plans */
       	 
       	 /* on doit charger une image au format RVB CAD par pixel 
       	 3 octets dans l'ordre RVB admettons qu'elle face 50*60*/
       	 pt_image=Malloc(50*60*3);
       	 /* ...  chargement de votre image a vou de jouer */
       	/* on renseigne sur l'image source  */
       	 mydisplay.largeur_RGB=50;
       	 mydisplay.hauteur_RGB=60;
       	 	/* on veut l'image tout a gauche et  20 
       	 	pixels du haut sur l'cran */
       	 mydisplay.position_X=0; 
       	 mydisplay.position_Y=20;
       	 	/*  partir du coin haut gauche de l'image */
       	 mydisplay.X_voulu=0;
       	 mydisplay.Y_voulu=0;
       	 	/* sur toute la largeur et hauteur de l'image (ne 
       	 	peut depasser cette taille)*/
       	 mydisplay.largeur_voulue=50;
       	 mydisplay.hauteur_voulue=60;
       	 screen_display(vdihandle, &mydisplay); /* affichage */
       	 
       	 /* maintenant sur une portion d'image !!!*/
       	 	/* on veut l'image  60 pixels de la gauche et  20 
       	 	pixels du haut sur l'cran */
       	 mydisplay.position_X=60; 
       	 mydisplay.position_Y=20;
       	 	/*  partir de 10 pixels %  la gauche et 20 % au 
       	 	haut */
       	 mydisplay.X_voulu=10;
       	 mydisplay.Y_voulu=20;
       	 	/* sur 20 pixels par 20 pixels */
       	 mydisplay.largeur_voulue=20;
       	 mydisplay.hauteur_voulue=20;
       	 screen_display(vdihandle, &mydisplay); /* affichage */
       }
    }
    
    v_clsvwk(vdihandle);  /* refermeture de la station VDI */
  
  }
  
  ldg_term(app_id, screenldg); /* libration du LDG */

  appl_exit();
}


Olivier LANDEMARRE le 21/04/1999