libtthimage/Lib/basic_io.c

164 lines
3.8 KiB
C
Raw Normal View History

2022-06-26 11:06:35 +02:00
/*
BASIC_IO Sept 2001
-------- ---------
Ce module a <EFBFBD>t<EFBFBD> <EFBFBD>crit pour tenter de r<EFBFBD>gler les
probl<EFBFBD>mes de "boutisme" pour que <EFBFBD>a puisse aussi
tourner sur les vrais processeurs, parce que, bon,
les 386, <EFBFBD>a suffit, hein...
Ceci dit, je ne sais pas vraiment comment traiter
le probl<EFBFBD>me. Pour le moment (Septembre 2001) c'est
un peu beaucoup du "try and test".
D'autre part, comment <EFBFBD>a va se passer sur des CPUs
<EFBFBD> 64 (ou 128) bits ?
-------------------------------------------------
9 oct 2001: pourquoi pas de fonction pour ecrire des BYTEs ?
*/
#include <stdio.h>
#include <stdlib.h>
2022-06-26 22:55:56 +02:00
#include "../tthimage.h"
2022-06-26 11:06:35 +02:00
/*::------------------------------------------------------------------::*/
int Image_basicIO_teste_boutisme(char *txt)
{
char *unix = "Unix";
long lfoo;
fprintf(stderr, "Image:\ttests de 'boutisme'\n\tmerci linux-31@culte.org\n");
fprintf(stderr, "\t- %s -\n", txt);
lfoo = * (long *) unix;
fprintf(stderr, "\t%08lx\n", lfoo);
/* ah ah ah, mais il y a autre chose dans le source 'imprime.c'
* a propos du boutisme... */
return FUNC_NOT_FINISH;
}
/*::------------------------------------------------------------------::*/
int Image_basicIO_read_I_short(FILE *fp, uint16_t *pvalue)
{
unsigned char byteH, byteL;
int foo = 0;
foo += fread(&byteL, 1, 1, fp);
foo += fread(&byteH, 1, 1, fp);
*pvalue = ( (byteH<<8) + byteL );
return foo==2 ? OLL_KORRECT : BASIC_IO_RD_ERR;
}
/*::------------------------------------------------------------------::*/
int Image_basicIO_read_M_short(FILE *fp, uint16_t *pvalue)
{
unsigned char byteH, byteL;
int foo = 0;
foo += fread(&byteH, 1, 1, fp);
foo += fread(&byteL, 1, 1, fp);
*pvalue = ( (byteH<<8) + byteL );
return foo==2 ? OLL_KORRECT : BASIC_IO_RD_ERR;
}
/*::------------------------------------------------------------------::*/
int Image_basicIO_write_I_short(FILE *fp, short value)
{
unsigned char byte;
int foo = 0;
#if DEBUG_LEVEL > 2
fprintf(stderr, "Basic IO: write I short: %d\n", value);
#endif
byte = (unsigned short)value & 0xff;
#if DEBUG_LEVEL > 2
fprintf(stderr, "Basic IO: low byte = %02x\n", byte);
#endif
foo += fwrite(&byte, 1, 1, fp);
byte = ((unsigned short)value >> 8) & 0xff;
#if DEBUG_LEVEL > 2
fprintf(stderr, "Basic IO: hight byte = %02x\n", byte);
#endif
foo += fwrite(&byte, 1, 1, fp);
return foo==2 ? OLL_KORRECT : BASIC_IO_WR_ERR;
}
/*::------------------------------------------------------------------::*/
int Image_basicIO_write_M_short(FILE *fp, short value)
{
unsigned char byte;
int foo = 0;
#if DEBUG_LEVEL > 2
fprintf(stderr, "Basic IO: write M short: %d\n", value);
#endif
byte = ((unsigned short)value >> 8) & 0xff;
foo += fwrite(&byte, 1, 1, fp);
byte = (unsigned short)value & 0xff;
foo += fwrite(&byte, 1, 1, fp);
return foo==2 ? OLL_KORRECT : BASIC_IO_WR_ERR;
}
/*::------------------------------------------------------------------::*/
int Image_basicIO_read_I_long(FILE *fp, uint32_t *pvalue)
{
unsigned char byte;
int foo;
uint32_t value;
#if DEBUG_LEVEL > 2
fprintf(stderr, "Basic IO: read I long (a tester) !\n");
#endif
value = 0L;
for (foo=0; foo<4; foo++)
{
if (1 != fread(&byte, 1, 1, fp))
{
fprintf(stderr, "bad fread in %s\n", __func__);
abort();
}
value <<= 8;
value += byte;
#if DEBUG_LEVEL > 2
fprintf(stderr, " %d %02x %08lx %ld\n", foo, byte, value, value);
#endif
}
*pvalue = value;
return FUNC_IS_BETA;
}
/*::------------------------------------------------------------------::*/
int Image_basicIO_write_I_long(FILE *fp, long value)
{
unsigned char byte;
int foo, bar;
#if DEBUG_LEVEL > 2
fprintf(stderr, "Basic IO: write I long: %ld\n", value);
#endif
for (foo=0; foo<4; foo++)
{
bar = foo * 8;
byte = (value >> bar) & 0xff;
#if DEBUG_LEVEL > 2
fprintf(stderr, " %3d %3d %02x\n", foo, bar, byte);
#endif
fwrite(&byte, 1, 1, fp);
}
return OLL_KORRECT;
}
/*::------------------------------------------------------------------::*/