path: root/powermanga/powermanga-0.79/linuxroutines.cpp

//*****************************************************************************
// copyright (c) 1998-2003 TLK Games all rights reserved
//-----------------------------------------------------------------------------
// file         : "linuxroutines.cpp"
// created      : 1999-08-19
// updates      : 2004-08-01 
//------------------------------------------------------------------------------
// functions    :  int              mem_initialise(unsigned int _iNombreZones)
//                 char*            reserveMemoire(unsigned int _iTailleMemoire)
//                 void             libereMemoire(char* _pMemoire)
//                 void             mem_libereTous()
//                 int              load_pcx(char*, char*) ;
//                 sDescriptionGfx* load_pcx(char*) ;
//                 unsigned int     littleWord(char* _pMem) ;
//                 short            litMot16bits(short* _pMem) ;
//                 int              litMot32bits(int* _pMem) ;
//                 int              chaine_cmp(char* _pChaine1, char* _pChaine2, unsigned int _iTaille) ;
//                 char*            chargeFichier(char* _pNomFichier)
//                 char*            chargeFichier(char* _pNomFichier, unsigned int* pTaille)
//                 int              chargeFichier(char* _pNomFichier, char* _pMemoire)
//                 void             fps_init()
//                 void             fps_affiche() 
//                 void             afficheErreur(char* _pErreur1, char* _pErreur2)
//                 int              synchro_processusPause(int _iTemps)
//                 int              synchro_CalculDifference()
//                 int              synchro_CalculDifference2()
//-----------------------------------------------------------------------------
// This program is free software; you can redistribute it and/or modify it under
// the terms of the GNU General Public License as published by the Free Software
// Foundation; either version 2 of the License, or (at your option) any later
// version.
// 
// This program is distributed in the hope that it will be useful, but WITHOUT
// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
// details.
//
// You should have received a copy of the GNU General Public License along with
// this program; if not, write to the Free Software Foundation, Inc., 59 Temple
// Place - Suite 330, Boston, MA  02111-1307, USA.
//
//*****************************************************************************

#include "powermanga.hpp"
#include <errno.h>

#ifndef SDL_TLK
#include <sys/types.h>
#include <sys/stat.h>
#endif

//..............................................................................
extern unsigned int     iVerbeux;                              //1=affiche les arguments / 1=verbose mode

//gestion de la memoire .........................................................
typedef struct
{ char *pMemoire;                                              //pointeur sur la zone memoire / pointer to memory zone
  int   iTailleMemoire;                                         //taille de la zone en octets / size of memory zone in bytes
}
sListeMemoire;
char                   *pZoneListeMemoire;
sListeMemoire          *pZoneListeBase;
sListeMemoire          *pZoneListeLibre;
unsigned int            iTailleListe;                          //taille de la liste memoire / size of memory table             
unsigned int            iNombreZonesMaximum;                   //nombre de zones memoires maxi / number maximum of memory zone
unsigned int            iNombreZones;                          //nombre de zone actuelle       / number of memroy zone
unsigned int            iOctetsTotal;                          //taille prise en octets        / total memory size allocated           
unsigned int            iNombreZonesMax;                       //nombre maximum de zones reserves

//..............................................................................
unsigned int            iCompteurBoucle;
#ifdef SDL_TLK 
Uint32                  time_begin;
Uint32                  temps_actuel;
Uint32                  temps_sauve;
Uint32                  temps_actuel2;
Uint32                  temps_sauve2;
#else
static struct timeval   time_begin;
static struct timeval   temps_actuel;
static struct timeval   temps_sauve;
static struct timeval   temps_actuel2;
static struct timeval   temps_sauve2;
#endif

//..............................................................................
short                   litMot16bitsBig(short *_pMem);
unsigned short          litMot16bits(unsigned short *_pMem);
extern const char       nomprefix[];
extern unsigned int     iFrame3; 
//------------------------------------------------------------------------------
// initialise la liste memoire / initialise memory table
// input =>  _iNombreZones : nombre de zones memoire possibles au maximum / number maximum of memory zone
// ouput <= 0=erreur / 0=error
//------------------------------------------------------------------------------
int mem_initialise(unsigned int _iNombreZones)
{
  unsigned int _iIndex;
  iNombreZones = 0;                                            // nombre de zones reservees a zero
  pZoneListeMemoire = 0;
  iNombreZonesMaximum = _iNombreZones;                         // nombre maximum de zones pouvant etre reservees 
  iNombreZonesMax = 0;
  iTailleListe = iNombreZonesMaximum * sizeof(sListeMemoire);
  iOctetsTotal = iTailleListe;
  pZoneListeMemoire = (char *)malloc(iTailleListe);
  if(!pZoneListeMemoire)
  { afficheErreur("malloc() failed", "linuxroutines/mem_initialise()");
    return 0;
  }
  pZoneListeBase = (sListeMemoire *) pZoneListeMemoire;
  pZoneListeLibre = pZoneListeBase;
  sListeMemoire          *_pMem = pZoneListeBase;

  for(_iIndex = 0; _iIndex < iNombreZonesMaximum; _iIndex++, _pMem++)   //clean memory table
  { _pMem->pMemoire = 0x0;
    _pMem->iTailleMemoire = 0x0;
  }
  return 1;
}

//------------------------------------------------------------------------------
// reserve une zone memoire / allocate memory
// input  => _iTailleMemoire : taille memoire en octets souhaitee / size of bytes
// output <= _pMem           : adresse memoire (0=erreur) / pointer to memory
//------------------------------------------------------------------------------
char *reserveMemoire(unsigned int _iTailleMemoire)
{
  char                   *_pMem = 0x0;
  char                   *_pMemoire = 0x0;
  char                    _cZero = 0;
  unsigned int            _iIndex;
  if(iNombreZones >= iNombreZonesMaximum)
  { printf ("linuxroutines.cpp/reserveMemoire(unsigned int) : table overflow ; size request %i bytes ; total allocate : % i in %i zones\n", _iTailleMemoire, iOctetsTotal, iNombreZones);
    return 0;
  }
  _pMem = (char *)malloc(_iTailleMemoire);
  if(!_pMem)
  { printf ("linuxroutines.cpp/reserveMemoire(unsigned int) : malloc(int) return 0 ; size request %i bytes ; total allocate : % i in %i zones\n", _iTailleMemoire, iOctetsTotal, iNombreZones);
    return 0;
  }
  iOctetsTotal += _iTailleMemoire;
  pZoneListeLibre->pMemoire = _pMem;                           //pointeur memoire      
  pZoneListeLibre->iTailleMemoire = _iTailleMemoire;           //taille en octets      
  pZoneListeLibre += 1;
  iNombreZones++;
  if(iNombreZones > iNombreZonesMax)
      iNombreZonesMax = iNombreZones; 
  _pMemoire = _pMem;
  for(_iIndex = 0; _iIndex < _iTailleMemoire; _iIndex++)
    *(_pMemoire++) = _cZero;                                   //efface memoire        
  return (_pMem);
}

//------------------------------------------------------------------------------
// liberation d'une zone memoire / free memory
// input => _pMemoire : adresse de la zone a liberer / pointer to memory
//------------------------------------------------------------------------------
void libereMemoire(char *_pMemoire)
{
  sListeMemoire          *_pListeMem;
  sListeMemoire          *_pListeMemSource;
  unsigned int            _iCompteur;
  if(_pMemoire)
  { _pListeMem = pZoneListeBase;
    for(_iCompteur = 0; _iCompteur < iNombreZones; _iCompteur++, _pListeMem++)
    { if(_pListeMem->pMemoire == _pMemoire)                    //on a trouve l'adresse dans la table ?
      { free(_pMemoire);                                       //oui, libere la memoire                                
        _pListeMemSource = _pListeMem + 1;
        iOctetsTotal -= _pListeMem->iTailleMemoire;
        iNombreZones--;
        pZoneListeLibre--;
        while (_iCompteur < iNombreZones)
        { _pListeMem->pMemoire = _pListeMemSource->pMemoire;
          _pListeMem->iTailleMemoire = _pListeMemSource->iTailleMemoire;
          _iCompteur++;
          _pListeMem++;
          _pListeMemSource++;
        }
        _pListeMem->pMemoire = 0x0;
        _pListeMem->iTailleMemoire = 0x0;
        _pMemoire = 0;
        break;
      }
    }
    if(_pMemoire > 0)
    { fprintf(stderr, "libereMemoire() : can't release the address %x\n", (int)_pMemoire);
    }
  }
  else
  { fprintf(stderr, "libereMemoire() : try to release a null address!\n");  
  }
}

//------------------------------------------------------------------------------
// retourne la taille d'une adresse memoire reservee / get memory zone's size
// input => _pMem : pointeur sur une zone memoire / pointer to memory
//------------------------------------------------------------------------------
int mem_retourneTaille(char *_pMem)
{
  unsigned int            _iCompteur;
  sListeMemoire          *_pListeMem = pZoneListeBase;
  if(_pMem)
  { for(_iCompteur = 0; _iCompteur < iNombreZones; _iCompteur++, _pListeMem++)
    { if(_pListeMem->pMemoire == _pMem)
        return _pListeMem->iTailleMemoire;
    }
  }
  return 0;
}

//------------------------------------------------------------------------------
// libere toutes les zones memoires / free all memory
//------------------------------------------------------------------------------
void mem_libereTous()
{
  unsigned int _iCompteur;
  char *_pMemoire;
  sListeMemoire *_pListeMem = pZoneListeBase;
#ifdef _VERBEUX_
  if(iVerbeux > 0)
    fprintf(stdout, "> linuxroutines.cpp/mem_libereTous(): maximum of memory which were allocated during the game : %i\n", iNombreZonesMax);
#endif
  if(iNombreZones >0)
  { 
#ifdef _VERBEUX_
    if(iVerbeux > 0)
      fprintf(stdout, "> linuxroutines.cpp/mem_libereTous() : %i zones were not released.\n", iNombreZones);
#endif
    for(_iCompteur = 0; _iCompteur < iNombreZones; _iCompteur++, _pListeMem++)
    { _pMemoire = _pListeMem->pMemoire;
      if(_pMemoire)
      { /* fprintf(stderr, "mem_libereTous: adresseMem =%x ; taille_mem=%ld\n", 
          (int)_pListeMem->pMemoire, _pListeMem->iTailleMemoire); */
        free(_pMemoire); //libere la memoire                             
        _pListeMem->pMemoire = 0;
        _pListeMem->iTailleMemoire = 0;
      }
    }
    if(pZoneListeMemoire)
    { free(pZoneListeMemoire);
      pZoneListeMemoire = 0x0;
    }
    iNombreZones = 0;
  }
}

//------------------------------------------------------------------------------
// decompress pcx file 
// input  =>  _pFichier     : filename
// output <= _pStructureGfx : pointer to the "sDescriptionGfx" structure / 0=error 
//------------------------------------------------------------------------------
sDescriptionGfx *load_pcx(char *_pNomFichier)
{
  unsigned int            iLongeur;
  unsigned int            ptr = 128;
  unsigned char           nbr_bytes;
  unsigned char           val;
  unsigned int            i1, i, total;
  unsigned char          *_pFichier, *_pAdresseMem;
  sDescriptionGfx        *_pDescripGfx = 0x0;
  _pFichier = (unsigned char *)chargeFichier(_pNomFichier, &iLongeur);  //load file in memory
  if(!_pFichier) return 0;
  unsigned short         *_p16 = (unsigned short *)_pFichier;
  unsigned int            _iLarge = (litMot16bits(_p16 + 4) - litMot16bits(_p16 + 2)) + 1;      //image width
  unsigned int            _iHaut = (litMot16bits(_p16 + 5) - litMot16bits(_p16 + 3)) + 1;       //image height
  unsigned int            _iProfondeur = _pFichier[3];         //bits per pixel

  _pDescripGfx = (sDescriptionGfx *) reserveMemoire(sizeof(sDescriptionGfx));   //allocate structure memory
  if(!_pDescripGfx)
  { afficheErreur("_pDescripGfx out of memory", "linuxroutines.cpp/load_pcx()");
    return 0;
  }
  _pDescripGfx->iLargeur = _iLarge;
  _pDescripGfx->iHauteur = _iHaut;
  _pDescripGfx->iProfond = _iProfondeur;
  _pDescripGfx->iTaille = _iLarge * _iHaut * (_iProfondeur >> 3);
  _pDescripGfx->pAdresse = reserveMemoire(_pDescripGfx->iTaille);       //allocate image memory
  if(!_pDescripGfx->pAdresse)
  { libereMemoire((char *)_pDescripGfx);
    printf("linuxroutines.cpp/load_pcx() : height=%i / width=%i \n", _iLarge, _iHaut);
    afficheErreur("_pDescripGfx->iTaille : out of memory\n", "linuxroutines.cpp/reserveMemoire()");
    return 0;
  }
  //decompress rle
  _pAdresseMem = (unsigned char *)_pDescripGfx->pAdresse;
  total = 0;
  i = iLongeur - 768;
  while (ptr < i)
  { if((_pFichier[ptr] & 0xC0) == 0xC0)
    { nbr_bytes = _pFichier[ptr] & 0x3F;
      ptr++;
    }
    else
      nbr_bytes = 1;
    val = _pFichier[ptr];
    total += nbr_bytes;                  // Samuel Hocevar
    if(total >= _pDescripGfx->iTaille)
    break;
    for(i1 = 0; i1 < nbr_bytes; i1++)
    { *_pAdresseMem = val;
      _pAdresseMem++;
    }
    ptr++;
  }
  libereMemoire((char *)_pFichier);
#ifdef _VERBEUX_
  if(iVerbeux > 0)
    fprintf (
      stdout,
      "> linuxroutines.cpp/load_pcx(): \"%s\"; height=%i; width=%i; size=%i\n",
      _pNomFichier,
      _iLarge,
      _iHaut,
      _pDescripGfx->iTaille);
#endif
  return _pDescripGfx;
}

//------------------------------------------------------------------------------
// lecture d'un mot de 16 bits code en memoire en little-endian
// input  => _pMem    : pointeur sur le mot en memoire
// output <= _iValeur : valeur utilisale
//------------------------------------------------------------------------------
unsigned int littleWord(char *_pMem)
{
  unsigned short *t = (unsigned short *)_pMem;
  return *t;
}

//------------------------------------------------------------------------------
// lecture d'un long mot signe de 16 bits little-endian (compatible little-endian/big-endian)
// input  => _pMem    : pointeur sur le mot en memoire
// output <= _iValeur : valeur utilisale
//------------------------------------------------------------------------------
short litMot16bits(short *_pMem)
{
  short  _iValeur = 0;
  unsigned char  *_pMemoire = (unsigned char *)_pMem;
  _iValeur = _pMemoire[1];                                     //lit du little endian pour un powerpc
  _iValeur <<= 8;
  _iValeur += _pMemoire[0];
  return (_iValeur);
}

//------------------------------------------------------------------------------
// lecture d'un long mot signe de 16 bits little-endian (compatible little-endian/big-endian)
// input  => _pMem    : pointeur sur le mot en memoire
// output <= _iValeur : valeur utilisale
//------------------------------------------------------------------------------
unsigned short litMot16bits(unsigned short *_pMem)
{
  unsigned short          _iValeur = 0;
  unsigned char          *_pMemoire = (unsigned char *)_pMem;
  _iValeur = _pMemoire[1];                                     //lit du little endian pour un powerpc
  _iValeur <<= 8;
  _iValeur += _pMemoire[0];
  return (_iValeur);
}

//------------------------------------------------------------------------------
// lecture d'un long mot signe de 16 bits big-endian (compatible little-endian/big-endian)
// input => _pMem    : pointeur sur le mot en memoire
// output <= _iValeur : valeur utilisale
//------------------------------------------------------------------------------
short litMot16bitsBig(short *_pMem)
{
  short                   _iValeur = 0;
  unsigned char          *_pMemoire = (unsigned char *)_pMem;
  _iValeur = _pMemoire[0];                                     //lit du big endian pour un 80x86
  _iValeur <<= 8;
  _iValeur += _pMemoire[1];
  return (_iValeur);
}

//------------------------------------------------------------------------------
//lecture d'un long mot signe de 32 bits little-endian(compatible little-endian/big-endian)
// input  => _pMem    : pointeur sur le mot 32 bits en memoire
// output <= _iValeur : valeur utilisale
//------------------------------------------------------------------------------
int litMot32bits(int *_pMem)
{
  int                     _iValeur = 0;
  unsigned char          *_pMemoire = (unsigned char *)_pMem;
  _iValeur = _pMemoire[3];
  _iValeur <<= 8;
  _iValeur += _pMemoire[2];
  _iValeur <<= 8;
  _iValeur = _pMemoire[1];
  _iValeur <<= 8;
  _iValeur += _pMemoire[0];
  return (_iValeur);
}

//------------------------------------------------------------------------------
// convertit un long mot de 32 bits en memoire little-endian => big-endian
//------------------------------------------------------------------------------
void convert32bits_2bigendian (unsigned char* memory)
{ unsigned char b0, b1, b2, b3;
  b0 = memory[1];
  b1 = memory[0];
  b2 = memory[3];
  b3 = memory[2];
  memory[0] = b2;
  memory[1] = b3;
  memory[2] = b0;
  memory[3] = b1;
}

//------------------------------------------------------------------------------
//comparaison de deux chaines de caracteres
// input  => _pChaine1 : pointeur sur la premiere chaine
//        => _pChaine1 : pointeur sur la deuxieme chaine
//        => _iTaille  : longeurs en octets de chaines
// output <= 0les chaines ont au moins une difference / 1=les chaines sont identiques
//------------------------------------------------------------------------------
int chaine_cmp(char *_pChaine1, char *_pChaine2, unsigned int _iTaille)
{
  unsigned int            _iLongeur = _iTaille;
  char                   *_pMem1 = _pChaine1;
  char                   *_pMem2 = _pChaine2;
  unsigned int            _iIndex;
  char                    _cOctet1, _cOctet2;
  for(_iIndex = 0; _iIndex < _iLongeur; _iIndex++)
  { _cOctet1 = _pMem1[_iIndex];
    _cOctet2 = _pMem2[_iIndex];
    if(_cOctet2 != _cOctet1)
      return (0);
  }
  return (1);
}

//------------------------------------------------------------------------------
// locate a file under one of the data directories (thanx to Andre Majorel :-)
// input  =>  name : name of file relative to data directory
// output <=  0    : could not locate file (not found, or not enough
//                   memory, or the name given was absolute)
// other           : pointer to a malloc'd buffer containing the name
//                   under which the file was found. free()-ing the
//                   buffer is the responsibility of the caller.
//------------------------------------------------------------------------------
static const char      *data_directories[]=
{ ".",                                                         // Normally unused, except when running from the source directory...
  "/opt/QtPalmtop/share/games/powermanga/",
  0                                                            // Special value meaning "$(PREFIX)/share/games/powermanga/"
                                                               // Also marks end of list
};
static char pathstring[256];

char *locate_data_file(const char *const name)
{
  
  for(int i = 0; i < 256; i++)
	pathstring[i] = 0;
	
  if(name == 0) return 0;
  if(*name == '/') return strdup(name);                        // Guillaume Cottenceau (2001-03-15) replace "return 0;" by "strdup(name);"
                                                               // En effet, nous sommes dans le cas ou le programme recherche dans /usr/share/games/powermanga
  for(const char **p = data_directories;; p++)
  { char *pathname;
    if(*p == 0)
    { const char *subdir = "/share/games/powermanga/";
      pathname = &pathstring[0];
      /*pathname=(char *)malloc(strlen(nomprefix) + strlen(subdir) + strlen(name) + 1);
      if(pathname == 0)
      { fflush(stdout);
        fprintf(stderr, "powermanga: not enough memory\n");
        return 0;
      }*/
      strcpy(pathname, nomprefix);
      strcat(pathname, subdir);
      strcat(pathname, name);
    }
    else if(**p == '~')                                        // Not used anymore
    { static const char       bogus = '\0';
      static const char      *home_dir = &bogus;
      if(home_dir == &bogus) home_dir = getenv("HOME");
      if(home_dir == 0) continue;                             // $HOME not set. Skip this directory.
      pathname = &pathstring[0];
      
      /*pathname = (char *)malloc(strlen(home_dir) + 1 + strlen(*p + 1) + 1 + strlen(name) + 1);
      if(pathname == 0)
      { fflush(stdout);
        fprintf(stderr, "powermanga: not enough memory\n");
        return 0;
      }*/
      strcpy(pathname, home_dir);
      strcat(pathname, *p + 1);
      strcat(pathname, "/");
      strcat(pathname, name);
    }
    else
    {
      pathname = &pathstring[0];
      /*pathname = (char *)malloc(strlen(*p) + 1 + strlen(name) + 1);
      if(pathname == 0)
      { fflush(stdout);
        fprintf(stderr, "powermanga: not enough memory\n");
        return 0;
      }*/
      strcpy(pathname, *p);
      strcat(pathname, "/");
      strcat(pathname, name);
    }
    //puts(pathname);  // DEBUG
#ifdef WIN32
    struct _stat s;
    if(_stat(pathname, &s) == 0 && !_S_ISDIR(s.st_mode))
      return pathname;
#else
    struct stat s;
    if(stat(pathname, &s) == 0 && !S_ISDIR(s.st_mode))
      return pathname;
#endif
    //free(pathname);
    if(*p == 0) break;
  }
  return 0;                                                    // Not found.
}

//------------------------------------------------------------------------------
// load a file in memory / charge un fichier en memoire
// input =>  _pNomFichier  : nom du fichier
//           _pAdresse     : adresse de chargemebt
//           _iTaille      : taille a lire
// output <= 1             : tout c'est bien passe
//           0             : erreur
//------------------------------------------------------------------------------
char *chargeFichier(char *_pNomFichier)
{
  unsigned int            _pTaille;
  return chargeFichier(_pNomFichier, &_pTaille);
}

//------------------------------------------------------------------------------
// load a file in memory 
// input => _pNomFichier : filename
// sortie <= _pMemoire   : ptr/integer 
//------------------------------------------------------------------------------
char *chargeFichier(char *_pNomFichier, unsigned int *pTaille)
{
  int _iHandle;
  char *_pMemoire;
  struct stat sDescriptionFichier;
  char *pathname = locate_data_file(_pNomFichier);
  if(pathname == 0)
  { printf("linuxroutines/chargeFichier() : can't locate file : %s\n\n", _pNomFichier);
    return 0;
  }
#ifdef WIN32
  _iHandle = open(pathname, O_RDONLY | O_BINARY, 0); 
#else
  _iHandle = open(pathname, O_RDONLY, 0); 
#endif
  if(_iHandle == -1)
  { printf("linuxroutines/chargeFichier() : can't open file : %s (%s)\n\n", pathname, strerror(errno));
    //free(pathname);
    return 0;
  }
  if(fstat(_iHandle, &sDescriptionFichier))
  { printf("linuxroutines/chargeFichier() : can't stat file : %s (%s)\n\n", pathname, strerror(errno));
    close(_iHandle);
    //free(pathname);
    return 0;
  }
  (*pTaille) = sDescriptionFichier.st_size;                    //sauve taille
  _pMemoire = reserveMemoire(sDescriptionFichier.st_size);     //reserve la place en memoire pour lire le fichier
  if(!_pMemoire)
  { printf("linuxroutines/chargeFichier() %s : out of memory\n\n", pathname);
    close(_iHandle);
    //free(pathname);
    return 0;
  }
  if(read(_iHandle, _pMemoire, sDescriptionFichier.st_size) != sDescriptionFichier.st_size)
  { libereMemoire(_pMemoire);
    printf("linuxroutines/chargeFichier() can't read file %s (%s)\n\n", pathname, strerror(errno));
    close(_iHandle);
    //free(pathname);
    return 0;
  }
  close(_iHandle);
#ifdef _VERBEUX_
  if(iVerbeux > 1)
    printf("linuxroutines/chargeFichier : file %s was loaded in memory\n", pathname);
#endif
  //free(pathname);
  return _pMemoire;
}

//------------------------------------------------------------------------------
// load a file in memory / charge un fichier en memoire
// input   => _pNomFichier : filename / nom du fichier
//         => _pMemoire    : pointer to memory / pointeur sur la memoire   
// output <= 1             : 0 error/erreur
//------------------------------------------------------------------------------
int chargeFichier(char *_pNomFichier, char *_pMemoire)
{
  int                     _iHandle;
  struct stat             sDescriptionFichier;
  char                   *pathname = locate_data_file(_pNomFichier);
  if(pathname == 0)
  { printf("linuxroutines/chargeFichier() : can't locate file : %s\n\n", _pNomFichier);
    return 0;
  }
#ifdef WIN32
  _iHandle = open(pathname, O_RDONLY | O_BINARY, 0); 
#else
  _iHandle = open(pathname, O_RDONLY, 0); 
#endif
  if(_iHandle == -1)
  { printf ("linuxroutines.cpp/chargeFichier() : can't open file : %s (%s)\n\n", pathname, strerror(errno));
    //free(pathname);
    return 0;
  }
  if(fstat(_iHandle, &sDescriptionFichier))
  { printf ("linuxroutines.cpp/chargeFichier() : can't stat file : %s (%s)\n\n", pathname, strerror(errno));
    close(_iHandle);
    //free(pathname);
    return 0;
  }
  if(read(_iHandle, _pMemoire, sDescriptionFichier.st_size) != sDescriptionFichier.st_size)
  { printf("linuxroutines.cpp/chargeFichier() can't read file %s (%s)\n\n", pathname, strerror(errno));
    close(_iHandle);
    //free(pathname);
    return 0;
  }
  close(_iHandle);
#ifdef _VERBEUX_
  if(iVerbeux > 1) printf("linuxroutines/chargeFichier : file %s was loaded in memory\n", pathname);
#endif
  //free(pathname);
  return 1;
}

//------------------------------------------------------------------------------
// initialise le compteur de boucle et l'heure de depart du programme
//------------------------------------------------------------------------------
void fps_init()
{
#ifdef SDL_TLK 
  time_begin = SDL_GetTicks();
  temps_sauve = SDL_GetTicks();
  temps_sauve2 = SDL_GetTicks();
#else
  gettimeofday(&time_begin, NULL);
  gettimeofday(&temps_sauve, NULL);
  gettimeofday(&temps_sauve2, NULL);
#endif
  iCompteurBoucle = 0;
}

//------------------------------------------------------------------------------
// affiche information sur le systeme
//------------------------------------------------------------------------------
void fps_affiche()
{
  
#ifdef SDL_TLK
  double fps;
  unsigned long duration;
  Sint32 time_end; 
  time_end = SDL_GetTicks();
  duration = time_end - time_begin;
  fps = (1000.0 * iCompteurBoucle) / duration;
  if(iVerbeux > 0)
  { printf("> linuxroutines.cpp/number of loops : %i\n", iCompteurBoucle);
    printf("> linuxroutines.cpp/running time    : %li\n", duration);
    printf("> linuxroutines.cpp/fps_affiche()   : frames per seconde : %g \n", fps);
  }
#else  
  struct utsname          kernel;
  struct stat             statmem;
  unsigned long           duration;
  double                  fps;
  double                  mem;
  char                    os_name[32];
  char                    os_vers[32];
  char                    cpu[64];
  char                    freq[32];
  FILE                   *cpuinfo;
  char                    txt[256];
  static struct timeval   time_end;

  //calcul le temps total d'execution ............................................
  gettimeofday(&time_end, NULL);
  duration = (time_end.tv_sec - time_begin.tv_sec) * 1000 + (time_end.tv_usec - time_begin.tv_usec) / 1000;
  fps = (1000.0 * iCompteurBoucle) / duration;

  //version du systeme d'exploitation ............................................
  if(uname(&kernel) < 0)
  { strcpy(os_name, "?");
    strcpy(os_vers, "");
  }
  else
  { strncpy(os_name, kernel.sysname, 32);
    strncpy(os_vers, kernel.release, 32);
  }
  //processeur & memoire physique du systeme .....................................
  stat("/proc/kcore", &statmem);
  mem = ((float)statmem.st_size) / 1024 / 1024;
  strcpy(cpu, "Unknown");
  strcpy(freq, "Unknown");
  cpuinfo = fopen("/proc/cpuinfo", "r");
  if(cpuinfo != NULL)
  { while (fgets(txt, 255, cpuinfo))
    { if(!strncmp(txt, "model", 5))
      { int                     i = 0;
        while (txt[i] != ':') i++;
        i += 2;
        for(int j = 0; j < 64;)
        { if(txt[i++] != '\n') cpu[j++] = txt[i - 1];
        }
      }
      if(!strncmp(txt, "cpu MHz", 7))
      { int                     i = 0;
        while (txt[i] != ':') i++;
        i += 2;
        sprintf(freq, "%d", atoi(txt + i));
      }
    }
  }
  //processeur & memoire physique du systeme .....................................
  if(iVerbeux > 0)
  { printf("operating system   : %s %s\n", os_name, os_vers);
    printf("processor          : %s at %s Mhz with %.0f RAM\n", cpu, freq, mem);
    printf("number of loops    : %i\n", iCompteurBoucle);
    printf("running time       : %li\n", duration);
    printf("frames per seconde : %g \n", fps);
    //printf ( "Compilateur      : %s\n" , COMPILO );
  }
#endif
}

//------------------------------------------------------------------------------
// display error message
// input => _Message :  message 
//------------------------------------------------------------------------------
void afficheMessage(char *_Message)
{ 
  printf("%s\n", _Message);
}

//------------------------------------------------------------------------------
// display error message
// input => _Message1 :  message 1 
//       => _Message2 :  message 2 
//------------------------------------------------------------------------------
void afficheMessage(char *_Message1, char *_Message2)
{
  printf("%s %s\n", _Message1, _Message2);
}

//------------------------------------------------------------------------------
// display error message
// input => _pErreur1 : error message 
//       => _pErreur2 : title error
//------------------------------------------------------------------------------
void afficheErreur(char *_pErreur1, char *_pErreur2)
{
  printf("%s %s\n", _pErreur2, _pErreur1);
}

//------------------------------------------------------------------------------
// display error message
// input        => _pErreur1 : error message 
//              => _pErreur2 : title error
//              => _pErreur3 : error message
//------------------------------------------------------------------------------
void afficheErreur(char *_pErreur1, char *_pErreur2, char *_pErreur3)
{
  printf("%s %s %s\n", _pErreur2, _pErreur1, _pErreur3);
}

//------------------------------------------------------------------------------
// display error message
// input        => _pErreur1 : error message 
//              => _pErreur2 : title error
//              => _iErreur : error number
//------------------------------------------------------------------------------
void afficheErreur(char *_pErreur1, char *_pErreur2, int _iErreur)
{
  printf("%s %s error=%i\n", _pErreur2, _pErreur1, _iErreur);
}

//------------------------------------------------------------------------------
// sleep process
// input => i : time
//------------------------------------------------------------------------------
int synchro_processusPause(int _iTemps)
{
#ifdef SDL_TLK 
  if(_iTemps > (int)iFrame3)
    _iTemps = iFrame3;
  if(_iTemps > 0)
    SDL_Delay(_iTemps);
  return (_iTemps > 0 ? _iTemps : 0);
#else
  struct timeval temps;
  if(_iTemps > (int)iFrame3)
    _iTemps = iFrame3;
  if(_iTemps > 0)
  { temps.tv_usec = _iTemps % (unsigned long)1000000;
    temps.tv_sec = _iTemps / (unsigned long)1000000;
    //sleep for a time interval
    select(0, NULL, NULL, NULL, &temps);
  }
  return (_iTemps > 0 ? _iTemps : 0);
#endif
}

#ifdef SDL_TLK
int synchro_CalculDifference()
{
  int _iDifference;
  temps_actuel = SDL_GetTicks();
  _iDifference = temps_actuel - temps_sauve;
  temps_sauve = temps_actuel;
  return _iDifference;
}
#else
//------------------------------------------------------------------------------
// calcul la difference entre deux heure differentes
// sortie <= : _iDifference
//------------------------------------------------------------------------------
int synchro_CalculDifference()
{
  int _iDifference;
  gettimeofday(&temps_actuel, NULL);
  _iDifference = (1000000 * (temps_actuel.tv_sec - temps_sauve.tv_sec)) + (temps_actuel.tv_usec - temps_sauve.tv_usec);
  temps_sauve = temps_actuel;
  return _iDifference;
}

//------------------------------------------------------------------------------
// calcul la difference entre deux heure differentes
// sortie <= : _iDifference
//------------------------------------------------------------------------------
int synchro_CalculDifference2()
{
  int _iDifference;
  gettimeofday(&temps_actuel2, NULL);
  _iDifference = (1000000 * (temps_actuel2.tv_sec - temps_sauve2.tv_sec)) + (temps_actuel2.tv_usec - temps_sauve2.tv_usec);
  temps_sauve2 = temps_actuel2;
  return _iDifference;
}
#endif