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

Screen.ldg 0.97    			Belfort le 13/01/2000

16 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, -2 probleme de 
paramtres.

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

4 plans:     (pour le moment la	 couleur n'est pas gre -> tramage 
en noir et blan a terme j'espere fournir un tramage couleur pour 4EC 
et 4C)
	4C   (existe sur vieux Mac???)
	4EC  (format ST basse)
	4G
	4EG  (format ST basse)
	4P   (existe sur vieux mac, ET4000: mode plan par plan comme 
	VDI pas sur que cela marche!)

2 plans:     (pour le moment la	 couleur n'est pas gre -> tramage 
en noir et blan a terme j'espere fournir un tramage couleur pour 2EC 
et 2C)
	2C   (existe sur vieux Mac???)
	2EC  (format ST moyenne)
	2G
	2EG  (format ST moyenne)

1 plan:
	1C ou 1G (ST haute)

	
WARNING: Utilisation: L'cran doit tre retenu avant l'appel  
screen_detect() sous peine de mauvaise dtection, une fois la 
dtection l'cran doit tre libr.
exemple:
while(!wind_update(BEG_UPDATE)); 
flag=screen_detect((long)vdihandle,retourneecc);
wind_update(END_UPDATE); 

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

long __CDECL trnfm_to_R8V8B8(unsigned char *src, long destR8V8B8, unsigned char *palette,long width, long height,long nb_plans,long mode)
 transforme une image entire  diffrents formats vers mode TC 24R8V8B8 (le mode normalis pour screen) 
 	  	
 	  	*src: pointeur sur l'image  transformer  	
		destR8V8B8: pointeur sur le buffer destination ou numro GEMDOS donn par Fopen() 		
		*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 dans l'ordre RVB
				Si -1L pour 1 plan et 4plans palette par dfaut, ne pas utiliser pour les autres plans
		width: largeur de l'image en pixels 
		height: hauteur de l'image en pixels
		nb_plans: nombres de plans dans l'image source (1, 2, 3,4,5,6,7,8, 16, 32 pas de 24 bien sur!!!)
		mode: 0L : Source type VDI (description plan par plan)
		      1L : Source entrelace (typiquement video entrelace ST et Falcon jusqu' 8 plans (256 couleurs))
		      	ce mode n'est support que pour 2, 4 et 8 
		      	plans ou standard VDI 16, 24 et 32 plans (RVB 
		      	la largeur source peut etre quelconque mais 
		      	pour compatibilit VDI la largeur relle de 
		      	la source est le multiple de 16 suprieur si 
		      	largeur%16!=0) Ne pas appeler cette fonction 
		      	en 24plans si largeur%16==0 c'est alors le 
		      	format natif de screen_display()
		      2L : Source mode non entrelace pixel par pixel (format le + simple!)
		      	ce mode n'est support que pour 4, 8, 16 et 32 
		      	plans
		      
		      au dela de 8 plans "mode" n'est plus pris en compte le format est du type RVB
		      ainsi que pour le mode 1 plan
		      
		      Si bit 8 de mode = 1 (256) alors la destination n'est plus un pointeur mmoire
		      mais le numro GEMDOS d'un fichier ouvert en criture de la fonction cliente
		      o la transformation sera crite.
		      Si bit 9 de mode = 1 alors sauvegarde du fichier texture.24b dans le rpertoire
		      courant.
		      
		retourne 1L si ok, 
						 0L si non support, 
						 <0L si erreur  
								-1 largeur image non supporte ex en mono multiple de 8, mode 1 doit tre multiple de 16
								-2 palette manquante (ncessaire mme pour le mode noir et blanc car on peut substituer au noir et au blanc 2 couleurs au choix)
								-3 mode non support
								-4 erreur source
								-5 erreur destination
								-6 conversion impossible (en mode 1 uniquement nb plans demands incohrent)								
                                                                -7 la conversion demande pour le moment ne supporte pas l'criture sur disque
                						-8 Erreur handle GEMDOS!
                						-9 Conversion stupide! vous tes dja en 24bits comme il faut

Attention l'image doit tre complte en largeur on ne peut donc pas s'en servir pour faire
de l'affichage directe ca doit se passer en mmoire, le client est supposer savoir calculer
la taille du buffer destination (3*width*height) et le rserver avant appel. L'image source
n'est pas modifie. Source et destination ne peuvent pas tre confondues!!!

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

long  __CDECL trnfm_plane_to_VDI(unsigned char *src, unsigned char *dest, long nb_plans,char *srcdef, long width, long height, long options)
/*Transformations  nombre de plans constants sans modification des couleurs juste une 
rorganisation de l'image sans changement de repre vers le format VDI pour le nombre
de plans donns CAD:
	Nb de plans			Format initial						Format VDI               nom srcdef autoris
	    1						1 plan										aucune transformation!
	    2						Entrelac									2 plans spars          EC
	    4						Entrelac/non entrelac		4 plans spars          EC et C
	    8						Entrelac/non entrelac 	8 plans spars          EC et C
	    16					Formats RVB divers      	R5V6B5                   ex B5V6B5 ...
	    24					Formats RVB divers				R8V8B8                   ex B8V8R8 ...
	    32					Formats RVB divers				X8R8V8B8                 ex X8B8V8R8 ...
Ces formats peuvent ensuites tre utiliss avec vr_trnfm() pour le mettre au format de la carte
soit pour mettre en forme vers trnfm_to_R8V8B8() principalements pour les plans >8 car cette
fonction sait directement dja transformer directement vers 24 plans les nombres de plans infrieurs.
   *src : source
   *dest : destination  WARNING le buffer destination doit assumer avoir la bonne taille
   	si options==0 ou 1 CAD ((width+15)&(0xFFFFFFFFL-15L))*height*nb_plans sinon width*height*nb_plans
   nb_plans : nombre de plans
   *srcdef : format du source
   width : largeur image
   height : hauteur image
   option : 0 transformation vers VDI, 2 transformation vers mode simple
   
   retourne 1 si Ok sinon:
   			 0  non support
   			-1 largeur image non supporte

	la destination doit tre rserve par le client  la taille du source

ATTENTION: cette procdure est actuellement trs incomplte elle supporte les transformations suivantes:
 8C ainsi que toutes les transformations 24 et 32 plans 


                         --------------------------
                         
void __CDECL trnfm_ind_pal( unsigned char *palette, long nbplans)
   converti une palette GEMDOS vers une palette standard VDI 
   (positionnement des couleurs)
   fonctionne pour 4 et 8 plans.
   
   unsigned char *palette : palette de dpart et de retour
   long nbplans : nombre de plans


*/

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

void __CDECL restore_palette(long vdihandle)
   restore la palette quand il n'y a plus de client intress


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

void __CDECL screen_display_texture(long vdihandle, videoinf *display, long startx, long starty)
   affiche une texture
   startx, starty, x,y ou commence la rfrence  l'cran de la 
   texture

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

short __CDECL screen_display_from_disk(long vdihandle, videoinf *display,long gemdos_handle)
   fait l'affichage  partir d'un bloc RVB sur disque retourne 0 si ok
   vdihandle : station VDI ouverte
   display :strcture pralablement remplie dcrivant ce que l'on veut faire.
   gemdos_handle : numro de fichier Gemdos ouvert par le client sur 
   le buffer RVB enregistr.

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

void __CDECL Save_TGA(char *file, void *buffer, long WIDTH, long HEIGHT, long mode)

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

void __CDECL direct_display(long vdihandle,videoinf *display,long nbplans,long mode) /* affiche une image au format dja de l'cran vers l'cran par VDI */
/* si mode == 1 alors  partir du disque add_RGB devient le numro GEMDOS de fichier
Ce mode n'est pour le moment pas support mettre 0 
sinon add_RGB == adresse en mmoire de l'image Bitmap (sans octets supplmentaires!)
et au format dja transform cran 
add_ECRAN n'est pas pris en compte affichage uniquement sur cran par VDI */

Attention: screen_detect() doit tre obligatoirement appele pour 
utiliser cette fonction

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

void __CDECL direct_display_texture(long vdihandle, videoinf *display, long startx, long starty)  
/* affiche l'image en considerant que c'est une texture CAD rpte l'image pour remplir
la destination idem screen_display_texture() Cette procdure utilise 
le VDI */

Attention: screen_detect() doit tre obligatoirement appele pour 
utiliser cette fonction


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


void __CDECL resize_R8V8B8(char *dest,long dest_width,long dest_height,char *src,long src_width,long src_height)
Modifie la largeur et hauteur d'une image pour le moment c'est une 
routine minimale, l'aspect!!!!!!!
Cette routine est plus ideale pour les petites images et les 
rtrcissements comme sur les pages WEB, pour les travaux
plus volumineux voir plutot resize_generalR8V8B8() si elle ne vous 
conviendrait pas mieux.
dest=pointeur sur un buffer prallou par le client  la taille 
	dest_width*dest_height*3 image destination sera au format 
	R8V8B8
dest_width=largeur destination
dest_height=hauteur destination
src=pointeur source image au format R8V8B8
src_width=largeur source
src_height=hauteur source

WARNING: largeurs et hauteurs ne peuvent pas dpasser 65535 malgre les 
long, cela  cause de l'acclration de l'algorithme

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" 
#include "protoscr.c" 
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);
void __CDECL (*restore_palette)(long vdihandle);

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], palette=0;  
  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 */
  init_screen(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 */
    while(!wind_update(BEG_UPDATE)); 
    if(screen_detect((long)vdihandle,retourneecc)>=0) 
    {  /* cran reconnu mais peut tre pas support! on n'en sait 
       rien jusque l */
       wind_update(END_UPDATE); 
       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 */
       	 palette=1;
       	 
       	 /* 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 */
       	 
       }
    } else wind_update(END_UPDATE); 
    
    v_clsvwk(vdihandle);  /* refermeture de la station VDI */
    if((palette)&&(restore_palette!=NULL)) restore_palette(vdihandle);
  }
  
  ldg_term(app_id, screenldg); /* libration du LDG */

  appl_exit();
}


Olivier LANDEMARRE le 23/08/1999