// TetiSoft: Modified to avoid fopen() fclose() fread() fseek() ftell() // malloc() realloc() and free() which can't be used in an amiga // shared run-time library linked with libinit.o #include #ifdef __GNUC__ // Avoid warnings "struct X declared inside parameter list" #include #include #include #include #endif // Necessary with OS3.9 includes #define __USE_SYSBASE #include #include /***************************************************************************/ /* */ /* ftsystem.c */ /* */ /* ANSI-specific FreeType low-level system interface (body). */ /* */ /* Copyright 1996-2001 by */ /* David Turner, Robert Wilhelm, and Werner Lemberg. */ /* */ /* This file is part of the FreeType project, and may only be used, */ /* modified, and distributed under the terms of the FreeType project */ /* license, LICENSE.TXT. By continuing to use, modify, or distribute */ /* this file you indicate that you have read the license and */ /* understand and accept it fully. */ /* */ /***************************************************************************/ /*************************************************************************/ /* */ /* This file contains the default interface used by FreeType to access */ /* low-level, i.e. memory management, i/o access as well as thread */ /* synchronisation. It can be replaced by user-specific routines if */ /* necessary. */ /* */ /*************************************************************************/ #include #include FT_CONFIG_CONFIG_H #include FT_INTERNAL_DEBUG_H #include FT_SYSTEM_H #include FT_ERRORS_H #include FT_TYPES_H #include FT_FREETYPE_H #include #include #include #include "lib.h" extern struct TTRenderBase *Ttb; // TetiSoft: C implementation of AllocVecPooled (see autodoc exec/AllocPooled) APTR AllocVecPooled(APTR poolHeader, ULONG memSize) { struct Library *SysBase = Ttb->ttb_SysBase; ULONG newSize = memSize + sizeof(ULONG); ULONG *mem = AllocPooled(poolHeader, newSize); if (!mem) return NULL; *mem = newSize; return mem + 1; } // TetiSoft: C implementation of FreeVecPooled (see autodoc exec/AllocPooled) void FreeVecPooled(APTR poolHeader, APTR memory) { struct Library *SysBase = Ttb->ttb_SysBase; ULONG *realmem = (ULONG *)memory - 1; FreePooled(poolHeader, realmem, *realmem); } /*************************************************************************/ /* */ /* MEMORY MANAGEMENT INTERFACE */ /* */ /*************************************************************************/ /*************************************************************************/ /* */ /* It is not necessary to do any error checking for the */ /* allocation-related functions. This will be done by the higher level */ /* routines like FT_Alloc() or FT_Realloc(). */ /* */ /*************************************************************************/ /*************************************************************************/ /* */ /* */ /* ft_alloc */ /* */ /* */ /* The memory allocation function. */ /* */ /* */ /* memory :: A pointer to the memory object. */ /* */ /* size :: The requested size in bytes. */ /* */ /* */ /* The address of newly allocated block. */ /* */ FT_CALLBACK_DEF( void* ) ft_alloc( FT_Memory memory, long size ) { // FT_UNUSED( memory ); // return malloc( size ); return AllocVecPooled( memory->user, size ); } /*************************************************************************/ /* */ /* */ /* ft_realloc */ /* */ /* */ /* The memory reallocation function. */ /* */ /* */ /* memory :: A pointer to the memory object. */ /* */ /* cur_size :: The current size of the allocated memory block. */ /* */ /* new_size :: The newly requested size in bytes. */ /* */ /* block :: The current address of the block in memory. */ /* */ /* */ /* The address of the reallocated memory block. */ /* */ FT_CALLBACK_DEF( void* ) ft_realloc( FT_Memory memory, long cur_size, long new_size, void* block ) { // FT_UNUSED( memory ); // FT_UNUSED( cur_size ); // return realloc( block, new_size ); struct Library *SysBase = Ttb->ttb_SysBase; void* new_block; new_block = AllocVecPooled ( memory->user, new_size ); if ( new_block != NULL ) { CopyMem ( block, new_block, ( new_size > cur_size ) ? cur_size : new_size ); FreeVecPooled ( memory->user, block ); } return new_block; } /*************************************************************************/ /* */ /* */ /* ft_free */ /* */ /* */ /* The memory release function. */ /* */ /* */ /* memory :: A pointer to the memory object. */ /* */ /* block :: The address of block in memory to be freed. */ /* */ FT_CALLBACK_DEF( void ) ft_free( FT_Memory memory, void* block ) { // FT_UNUSED( memory ); // free( block ); FreeVecPooled( memory->user, block ); } /*************************************************************************/ /* */ /* RESOURCE MANAGEMENT INTERFACE */ /* */ /*************************************************************************/ /*************************************************************************/ /* */ /* The macro FT_COMPONENT is used in trace mode. It is an implicit */ /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log */ /* messages during execution. */ /* */ #undef FT_COMPONENT #define FT_COMPONENT trace_io /* We use the macro STREAM_FILE for convenience to extract the */ /* system-specific stream handle from a given FreeType stream object */ //#define STREAM_FILE( stream ) ( (FILE*)stream->descriptor.pointer ) #define STREAM_FILE( stream ) ( (BPTR)stream->descriptor.pointer ) // TetiSoft /*************************************************************************/ /* */ /* */ /* ft_close_stream */ /* */ /* */ /* The function to close a stream. */ /* */ /* */ /* stream :: A pointer to the stream object. */ /* */ FT_CALLBACK_DEF( void ) ft_close_stream( FT_Stream stream ) { struct Library *DOSBase = Ttb->ttb_DOSBase; // fclose( STREAM_FILE( stream ) ); Close( STREAM_FILE( stream ) ); // TetiSoft stream->descriptor.pointer = NULL; stream->size = 0; stream->base = 0; } /*************************************************************************/ /* */ /* */ /* ft_io_stream */ /* */ /* */ /* The function to open a stream. */ /* */ /* */ /* stream :: A pointer to the stream object. */ /* */ /* offset :: The position in the data stream to start reading. */ /* */ /* buffer :: The address of buffer to store the read data. */ /* */ /* count :: The number of bytes to read from the stream. */ /* */ /* */ /* The number of bytes actually read. */ /* */ FT_CALLBACK_DEF( unsigned long ) ft_io_stream( FT_Stream stream, unsigned long offset, unsigned char* buffer, unsigned long count ) { struct Library *DOSBase = Ttb->ttb_DOSBase; // FILE* file; BPTR file; // TetiSoft file = STREAM_FILE( stream ); // fseek( file, offset, SEEK_SET ); Seek( file, offset, OFFSET_BEGINNING ); // TetiSoft // return (unsigned long)fread( buffer, 1, count, file ); return (unsigned long)FRead( file, buffer, 1, count); } /* documentation is in ftobjs.h */ FT_EXPORT_DEF( FT_Error ) FT_New_Stream( const char* filepathname, FT_Stream astream ) { struct Library *DOSBase = Ttb->ttb_DOSBase; // FILE* file; BPTR file; // TetiSoft struct FileInfoBlock *fib; // TetiSoft if ( !astream ) return FT_Err_Invalid_Stream_Handle; // file = fopen( filepathname, "rb" ); file = Open((STRPTR)filepathname, MODE_OLDFILE ); // TetiSoft if ( !file ) { FT_ERROR(( "FT_New_Stream:" )); FT_ERROR(( " could not open `%s'\n", filepathname )); return FT_Err_Cannot_Open_Resource; } // fseek( file, 0, SEEK_END ); // astream->size = ftell( file ); // fseek( file, 0, SEEK_SET ); fib = AllocDosObject( DOS_FIB, NULL ); if ( !fib ) { Close ( file ); FT_ERROR(( "FT_New_Stream:" )); FT_ERROR(( " could not open `%s'\n", filepathname )); return FT_Err_Cannot_Open_Resource; } if (!( ExamineFH ( file, fib ))) { FreeDosObject(DOS_FIB, fib); Close ( file ); FT_ERROR(( "FT_New_Stream:" )); FT_ERROR(( " could not open `%s'\n", filepathname )); return FT_Err_Cannot_Open_Resource; } astream->size = fib->fib_Size; FreeDosObject(DOS_FIB, fib); // astream->descriptor.pointer = file; astream->descriptor.pointer = (void *)file; astream->pathname.pointer = (char*)filepathname; astream->pos = 0; astream->read = ft_io_stream; astream->close = ft_close_stream; FT_TRACE1(( "FT_New_Stream:" )); FT_TRACE1(( " opened `%s' (%d bytes) successfully\n", filepathname, astream->size )); return FT_Err_Ok; } #ifdef FT_DEBUG_MEMORY extern FT_Int ft_mem_debug_init( FT_Memory memory ); extern void ft_mem_debug_done( FT_Memory memory ); #endif /* documentation is in ftobjs.h */ FT_EXPORT_DEF( FT_Memory ) FT_New_Memory( void ) { struct Library *SysBase = Ttb->ttb_SysBase; FT_Memory memory; // memory = (FT_Memory)malloc( sizeof ( *memory ) ); memory = (FT_Memory)AllocVec( sizeof ( *memory ), MEMF_PUBLIC ); if ( memory ) { // memory->user = 0; #ifdef __GNUC__ memory->user = CreatePool ( MEMF_PUBLIC, 2048, 2048 ); #else memory->user = AsmCreatePool ( MEMF_PUBLIC, 2048, 2048, SysBase ); #endif if ( memory->user == NULL ) { FreeVec ( memory ); memory = NULL; } else { memory->alloc = ft_alloc; memory->realloc = ft_realloc; memory->free = ft_free; #ifdef FT_DEBUG_MEMORY ft_mem_debug_init( memory ); #endif } } return memory; } /* documentation is in ftobjs.h */ FT_EXPORT_DEF( void ) FT_Done_Memory( FT_Memory memory ) { struct Library *SysBase = Ttb->ttb_SysBase; #ifdef FT_DEBUG_MEMORY ft_mem_debug_done( memory ); #endif #ifdef __GNUC__ DeletePool( memory->user ); #else AsmDeletePool( memory->user, SysBase ); #endif FreeVec( memory ); } /* END */