341 lines
16 KiB
C
341 lines
16 KiB
C
#include "\projet\lib386\lib_sys\adeline.h"
|
|
#include "\projet\lib386\lib_sys\lib_sys.h"
|
|
#include "\projet\lib386\lib_svga\lib_svga.h"
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
/*ΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉ*
|
|
Γûê ΓûêΓûÇΓûÇΓûê ΓûêΓûä ΓûäΓûê
|
|
ΓûêΓûê ΓûêΓûêΓûÇΓûÇΓûê ΓûêΓûêΓûÇ Γûê
|
|
ΓûÇΓûÇΓûÇΓûÇΓûÇ ΓûÇΓûÇΓûÇΓûÇΓûÇ ΓûÇΓûÇ ΓûÇ
|
|
*ΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉ*/
|
|
/*ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ*/
|
|
|
|
#define MAXBUFLIGNE 1500
|
|
#define RowByte(w) ((((w)+15)>>4) << 1)
|
|
|
|
UWORD Larg ;
|
|
|
|
WORD Lbm_Width = 640 ;
|
|
|
|
#define BUFLIGNEMAX 720
|
|
|
|
static WORD Handle ;
|
|
static ULONG rejet ;
|
|
static ULONG len ;
|
|
static BYTE head[] = "BMHD" ;
|
|
static WORD larg,haut ;
|
|
static BYTE nbr_plan ;
|
|
static BYTE flgcomp ; /* flg de compression */
|
|
static BYTE Masking ;
|
|
//static BYTE bufflig[BUFLIGNEMAX] ;
|
|
|
|
static UBYTE tabmsk[8] = { 0x01,0x02,0x04,0x08,
|
|
0x10,0x20,0x40,0x80 } ;
|
|
|
|
static LONG CptIff ;
|
|
static UBYTE *PtrIff ;
|
|
static UBYTE *BufferIff ;
|
|
|
|
/*ΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉ*/
|
|
/*ΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉ*/
|
|
|
|
UBYTE ReadIff()
|
|
{
|
|
if( CptIff == 0 )
|
|
{
|
|
Read( Handle, BufferIff, 64000L ) ;
|
|
CptIff = 64000L ;
|
|
PtrIff =(void *)BufferIff ;
|
|
}
|
|
CptIff-- ;
|
|
return *PtrIff++ ;
|
|
}
|
|
|
|
/*ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ*/
|
|
|
|
void WriteIff( void *ptrin, ULONG len )
|
|
{
|
|
Write( Handle, ptrin, len );
|
|
}
|
|
|
|
/*ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ*/
|
|
|
|
void WriteIffLong( ULONG data )
|
|
{
|
|
WriteIff( (void*)&((UBYTE*)&data)[3], 1L );
|
|
WriteIff( (void*)&((UBYTE*)&data)[2], 1L );
|
|
WriteIff( (void*)&((UBYTE*)&data)[1], 1L );
|
|
WriteIff( (void*)&((UBYTE*)&data)[0], 1L );
|
|
}
|
|
|
|
/*ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ*/
|
|
|
|
void itoml( void *l )
|
|
{
|
|
UBYTE c ;
|
|
UBYTE *ptc ;
|
|
|
|
ptc = (char*)l ;
|
|
c = ptc[0] ;
|
|
ptc[0] = ptc[3] ;
|
|
ptc[3] = c ;
|
|
c = ptc[1] ;
|
|
ptc[1] = ptc[2] ;
|
|
ptc[2] = c ;
|
|
}
|
|
|
|
/*ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ*/
|
|
|
|
void lit_bmhd()
|
|
{
|
|
UBYTE a,b ;
|
|
|
|
Read( Handle, &a, 1L ) ;
|
|
Read( Handle, &b, 1L ) ;
|
|
larg = ((unsigned int)a)*256 + b ;
|
|
|
|
Read( Handle, &a, 1L ) ;
|
|
Read( Handle, &b, 1L ) ;
|
|
haut = ((unsigned int)a)*256 + b ;
|
|
|
|
Read( Handle, &len, 4L ) ; /* lit 4 octets */
|
|
Read( Handle, &nbr_plan, 1L );
|
|
Read( Handle, &Masking, 1L ) ;
|
|
Read( Handle, &flgcomp, 1L );
|
|
Read( Handle, &a, 1L ) ; /* pad */
|
|
Read( Handle, &rejet, 4L ) ;
|
|
Read( Handle, &rejet, 4L ) ;
|
|
Larg = larg;
|
|
if( larg>320 ) larg = 320;
|
|
if( haut>200 ) haut = 200;
|
|
Masking &= 1;
|
|
}
|
|
|
|
/*ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ*/
|
|
|
|
void lit_bloc() /* on a un bloc inconnu */
|
|
{
|
|
WORD l ;
|
|
|
|
for(l = 0 ; l < (int)len ; l++)
|
|
Read(Handle, &rejet, 1L ) ; /* a jeter */
|
|
}
|
|
|
|
/*ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ*/
|
|
|
|
void lit_ligne( UBYTE *ptdst, WORD nboctet )
|
|
{
|
|
UBYTE *dst;
|
|
BYTE o;
|
|
WORD nb;
|
|
UWORD i;
|
|
|
|
dst = ptdst;
|
|
if(flgcomp)
|
|
{
|
|
while(nboctet > 0)
|
|
{
|
|
o = ReadIff();
|
|
if(o >= 0)
|
|
{
|
|
nb = o + 1;
|
|
nboctet -= nb;
|
|
for ( i=0 ; i<nb ; i++) *dst++ = ReadIff();
|
|
}
|
|
else
|
|
{
|
|
if(o != -128)
|
|
{
|
|
nb = -o + 1;
|
|
nboctet -= nb;
|
|
o = ReadIff();
|
|
while(nb--) *dst++ = o;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
while( nboctet-- ) *dst++ = ReadIff();
|
|
}
|
|
|
|
/*ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ*/
|
|
|
|
void ConvertMCGA(UBYTE *bufligne, UBYTE *dst, UWORD nboctet, WORD nbplan )
|
|
{
|
|
WORD a,b,p,msk ;
|
|
UBYTE col ;
|
|
|
|
for(a = 0 ; a < nboctet ; a++)
|
|
{
|
|
for(b = 0 ; b < 8; b++)
|
|
{
|
|
col = 0;
|
|
msk = tabmsk[7-b] ;
|
|
for(p = nbplan-1 ; p >= 0 ; p--)
|
|
{
|
|
col <<= 1 ;
|
|
if(*(bufligne + p*nboctet + a) & msk) col++ ;
|
|
}
|
|
*dst++ = col;
|
|
}
|
|
}
|
|
}
|
|
|
|
/*ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ*/
|
|
|
|
void lit_bodyILBM( UBYTE *ptr )
|
|
{
|
|
WORD lig,nboctet ;
|
|
UBYTE *bufligne ;
|
|
|
|
if ((bufligne = Malloc(MAXBUFLIGNE)) == 0 ) return ;
|
|
nboctet = RowByte(Larg) ;
|
|
|
|
for(lig = 0 ; lig < 200 ; lig++)
|
|
{
|
|
memset( bufligne, 0, MAXBUFLIGNE ) ;
|
|
if (lig < haut )
|
|
{
|
|
lit_ligne( bufligne,nboctet*nbr_plan ) ;
|
|
ConvertMCGA(bufligne,ptr,nboctet,nbr_plan ) ;
|
|
memset( ptr+nboctet*8,0, 320-nboctet*8 ) ;
|
|
}
|
|
else
|
|
{
|
|
memset( ptr, 0, Lbm_Width ) ;
|
|
}
|
|
ptr += Lbm_Width ;
|
|
}
|
|
Free( bufligne ) ;
|
|
}
|
|
|
|
/*ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ*/
|
|
|
|
void lit_bodyPBM( UBYTE *ptr )
|
|
{
|
|
WORD lig ;
|
|
|
|
for(lig = 0 ; lig < 200 ; lig++)
|
|
{
|
|
lit_ligne( ptr,larg ) ;
|
|
ptr += Lbm_Width ;
|
|
}
|
|
}
|
|
|
|
/*ΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉ*
|
|
Γûê ΓûêΓûÇΓûÇΓûÇΓûê ΓûêΓûÇΓûÇΓûÇΓûê ΓûêΓûÇΓûÇΓûÇΓûä Γûê ΓûêΓûÇΓûÇΓûê ΓûêΓûä ΓûäΓûê
|
|
ΓûêΓûê ΓûêΓûê Γûê ΓûêΓûêΓûÇΓûÇΓûê ΓûêΓûê Γûê ΓûêΓûê ΓûêΓûêΓûÇΓûÇΓûê ΓûêΓûêΓûÇ Γûê
|
|
ΓûÇΓûÇΓûÇΓûÇΓûÇ ΓûÇΓûÇΓûÇΓûÇΓûÇ ΓûÇΓûÇ ΓûÇ ΓûÇΓûÇΓûÇΓûÇ ΓûÇΓûÇΓûÇΓûÇΓûÇ ΓûÇΓûÇΓûÇΓûÇΓûÇ ΓûÇΓûÇΓûÇΓûÇΓûÇ ΓûÇΓûÇ ΓûÇ
|
|
*ΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉ*/
|
|
/*ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ*/
|
|
|
|
LONG Load_Lbm( char *name, UBYTE *ptrscreen, UBYTE *ptrpal )
|
|
{
|
|
ULONG len2 ;
|
|
WORD type = 0 ; /* 0 = ILBM; 1 = PBM */
|
|
UBYTE *ptr ;
|
|
|
|
CptIff = 0;
|
|
Handle = OpenRead( name ) ;
|
|
if( !Handle ) return FALSE ;
|
|
|
|
BufferIff = Malloc( 64000 ) ;
|
|
|
|
/* printf( "%s: ", name ) ; */
|
|
|
|
Read( Handle, head, 4L ) ;
|
|
Read( Handle, &len, 4L ) ; /* lit taille */
|
|
Read( Handle, head, 4L ) ; /* lit ILBM */
|
|
if( strcmp( head, "ILBM" )!= 0 ) type = 1; /* PBM */
|
|
|
|
while( TRUE )
|
|
{
|
|
len2 = Read( Handle, head, 4L ) ;
|
|
if( len2 != 4 ) break ; /* fin de fichier */
|
|
Read( Handle, &len, 4L ) ; /* lit taille du chunk */
|
|
itoml( &len ) ;
|
|
if( len&1 ) len++ ;
|
|
if(strcmp(head,"BMHD") == 0) lit_bmhd() ;
|
|
else
|
|
if(strcmp(head,"CMAP") == 0) /* pal */
|
|
Read( Handle, ptrpal, 768 ) ;
|
|
else
|
|
if(strcmp(head,"BODY") == 0)
|
|
{
|
|
if( type==0 )
|
|
lit_bodyILBM( ptrscreen ) ;
|
|
else
|
|
lit_bodyPBM( ptrscreen ) ;
|
|
break;
|
|
}
|
|
else lit_bloc() ;/* bloc inconnu on le saute */
|
|
}
|
|
|
|
Free( BufferIff ) ;
|
|
Close( Handle ) ;
|
|
|
|
/* printf( "converted to VGA " ) ; */
|
|
return TRUE ;
|
|
}
|
|
|
|
|
|
/*ΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉ*
|
|
ΓûêΓûêΓûÇΓûÇΓûÇ ΓûêΓûÇΓûÇΓûÇΓûê Γûê Γûê ΓûêΓûÇΓûÇΓûÇΓûÇ Γûê ΓûêΓûÇΓûÇΓûê ΓûêΓûä ΓûäΓûê
|
|
ΓûÇΓûÇΓûÇΓûÇΓûê ΓûêΓûêΓûÇΓûÇΓûê ΓûêΓûê ΓûäΓûÇ ΓûêΓûêΓûÇΓûÇ ΓûêΓûê ΓûêΓûêΓûÇΓûÇΓûê ΓûêΓûêΓûÇ Γûê
|
|
ΓûÇΓûÇΓûÇΓûÇΓûÇ ΓûÇΓûÇ ΓûÇ ΓûÇΓûÇΓûÇ ΓûÇΓûÇΓûÇΓûÇΓûÇ ΓûÇΓûÇΓûÇΓûÇΓûÇ ΓûÇΓûÇΓûÇΓûÇΓûÇ ΓûÇΓûÇΓûÇΓûÇΓûÇ ΓûÇΓûÇ ΓûÇ
|
|
*ΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉΓòÉ*/
|
|
/*ΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇΓöÇ*/
|
|
|
|
LONG Save_Lbm( char *name, UBYTE *ptrscr, UBYTE *ptrpal )
|
|
{
|
|
UWORD nbplan=8,a=0;
|
|
UWORD resolx = 320;
|
|
UWORD resoly = 200;
|
|
UWORD y ;
|
|
UWORD ligne,colonne;
|
|
|
|
Handle = OpenWrite( name );
|
|
if ( Handle == 0) return 0 ;
|
|
WriteIff("FORM",4L);
|
|
WriteIffLong(64816L);
|
|
WriteIff("PBM ",4L);
|
|
WriteIff("BMHD",4L);
|
|
WriteIffLong(20L);
|
|
WriteIff((void *)&((UBYTE*)&resolx)[1],1L);
|
|
WriteIff((void *)&((UBYTE*)&resolx)[0],1L);
|
|
WriteIff((void *)&((UBYTE*)&resoly)[1],1L) ;
|
|
WriteIff((void *)&((UBYTE*)&resoly)[0],1L) ;
|
|
WriteIffLong(0L); /* lit 4 octets avant le, */
|
|
WriteIff(&nbplan,1L);
|
|
WriteIff(&a,1L);
|
|
a = 0; /* flg non compilee */
|
|
WriteIff(&a,1L);
|
|
WriteIff(&a,1L); /* pad */
|
|
WriteIffLong(0L);
|
|
WriteIffLong(0L);
|
|
|
|
WriteIff("CMAP",4L); /* pal */
|
|
WriteIffLong(3*256L);
|
|
WriteIff(ptrpal,3*256L);
|
|
|
|
colonne = 40;
|
|
ligne = 200;
|
|
|
|
WriteIff ("BODY",4L);
|
|
WriteIffLong ((LONG)(colonne*nbplan*ligne));
|
|
|
|
for( y=0; y<200; y++ )
|
|
{
|
|
Write( Handle, ptrscr, 320 ) ;
|
|
ptrscr += Lbm_Width ;
|
|
}
|
|
|
|
/* Write (Handle, ptrscr, 64000L ); */
|
|
|
|
Close( Handle );
|
|
return TRUE ;
|
|
}
|