freeType2.9.1移植到A7(1)

      因为项目需要,将在A7平台上跑freeRTOS,然后发现不论是恩智浦或者是意法半导体都没有提供emwin的库,没法使用了,只要自己写了一个gui图形库,主要ugui的接口,尽量减少控件对回调的调用,作为一个基本的gui库,自然要支持汉字的显示,今天就介绍一下feeType的移植。

      移植过程参考一个freetype2.3.10的stm32工程添加一下代码

添加.h头文件

ft2build.h

ftconfig.h

ftheader.h

ftmodule.h

ftoption.h

ftstdlib.h

添加C文件

ftbase.c

ftbitmap.c

ftglyph.c

ftinit.c

ftsystem.c

sfnt.c

smooth.c

truetype.c

在app.c中添加

#include <ft2build.h>
#include <freetype/freetype.h>
#include <freetype/ftglyph.h>

然后编译工程,提示没有包含相关头文件,最后找到其中的原因是,这些宏是在internal.h中定义的,而internal.h 只有在FT2_BUILD_LIBRARY被定义的时候才会在ftheader.h中被定义。

  /*
   * Include internal headers definitions from <internal/...>
   * only when building the library.
   */
#ifdef FT2_BUILD_LIBRARY
#define  FT_INTERNAL_INTERNAL_H  <freetype/internal/internal.h>
#include FT_INTERNAL_INTERNAL_H
#endif /* FT2_BUILD_LIBRARY */

虽然提示,在编译lib库时才定义FT2_BUILD_LIBRARY,我的理解是,咱们是直接用freeType的源码跟自己的gui代码编译直接生成可执行文件,所以,这个宏还是需要编译的,如果生成了库之后,再包含ft2build.h文件时,则可以不用定义这个宏。所以在ft2build中添加这个宏。

#ifndef FT2BUILD_H_
#define FT2BUILD_H_
#define FT2_BUILD_LIBRARY  //咱们添加的
#include <freetype/config/ftheader.h>

#endif /* FT2BUILD_H_ */

到了这里,我们再次编译,还是发现有不少错误,主要是某些文件操作的函数没有被定义,这里咱们参考前面提到的stm32的例程修改ftsytem.c文件,修改之后代码如下:

/***************************************************************************/
/*                                                                         */
/*  ftsystem.c                                                             */
/*                                                                         */
/*    ANSI-specific FreeType low-level system interface (body).            */
/*                                                                         */
/*  Copyright 1996-2018 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 <ft2build.h>
#include FT_CONFIG_CONFIG_H
#include FT_INTERNAL_DEBUG_H
#include FT_INTERNAL_STREAM_H
#include FT_SYSTEM_H
#include FT_ERRORS_H
#include FT_TYPES_H


  /*************************************************************************/
  /*                                                                       */
  /*                       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_mem_alloc() or ft_mem_realloc().                     */
  /*                                                                       */
  /*************************************************************************/


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    ft_alloc                                                           */
  /*                                                                       */
  /* <Description>                                                         */
  /*    The memory allocation function.                                    */
  /*                                                                       */
  /* <Input>                                                               */
  /*    memory :: A pointer to the memory object.                          */
  /*                                                                       */
  /*    size   :: The requested size in bytes.                             */
  /*                                                                       */
  /* <Return>                                                              */
  /*    The address of newly allocated block.                              */
  /*                                                                       */
  FT_CALLBACK_DEF( void* )
  ft_alloc( FT_Memory  memory,
            long       size )
  {
    FT_UNUSED( memory );

    return ft_smalloc( (size_t)size );
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    ft_realloc                                                         */
  /*                                                                       */
  /* <Description>                                                         */
  /*    The memory reallocation function.                                  */
  /*                                                                       */
  /* <Input>                                                               */
  /*    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.            */
  /*                                                                       */
  /* <Return>                                                              */
  /*    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 ft_srealloc( block, (size_t)new_size );
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    ft_free                                                            */
  /*                                                                       */
  /* <Description>                                                         */
  /*    The memory release function.                                       */
  /*                                                                       */
  /* <Input>                                                               */
  /*    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 );

    ft_sfree( block );
  }


  /*************************************************************************/
  /*                                                                       */
  /*                     RESOURCE MANAGEMENT INTERFACE                     */
  /*                                                                       */
  /*************************************************************************/

#ifndef FT_CONFIG_OPTION_DISABLE_STREAM_SUPPORT

  /*************************************************************************/
  /*                                                                       */
  /* 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 )  ( (FT_FILE*)stream->descriptor.pointer )


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    ft_ansi_stream_close                                               */
  /*                                                                       */
  /* <Description>                                                         */
  /*    The function to close a stream.                                    */
  /*                                                                       */
  /* <Input>                                                               */
  /*    stream :: A pointer to the stream object.                          */
  /*                                                                       */
  FT_CALLBACK_DEF( void )
  ft_ansi_stream_close( FT_Stream  stream )
  {
    ft_fclose( STREAM_FILE( stream ) );

    stream->descriptor.pointer = NULL;
    stream->size               = 0;
    stream->base               = NULL;
  }


  /*************************************************************************/
  /*                                                                       */
  /* <Function>                                                            */
  /*    ft_ansi_stream_io                                                  */
  /*                                                                       */
  /* <Description>                                                         */
  /*    The function to open a stream.                                     */
  /*                                                                       */
  /* <Input>                                                               */
  /*    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.             */
  /*                                                                       */
  /* <Return>                                                              */
  /*    The number of bytes actually read.  If `count' is zero (this is,   */
  /*    the function is used for seeking), a non-zero return value         */
  /*    indicates an error.                                                */
  /*                                                                       */
#if 0
  FT_CALLBACK_DEF( unsigned long )
  ft_ansi_stream_io( FT_Stream       stream,
                     unsigned long   offset,
                     unsigned char*  buffer,
                     unsigned long   count )
  {
    FT_FILE*  file;


    if ( !count && offset > stream->size )
      return 1;

    file = STREAM_FILE( stream );

    if ( stream->pos != offset )
      ft_fseek( file, (long)offset, SEEK_SET );

    return (unsigned long)ft_fread( buffer, 1, count, file );
  }
#endif
 FIL fstt;
 unsigned long size;
  FT_CALLBACK_DEF( unsigned long )
  ft_ansi_stream_io( FT_Stream       stream,
                     unsigned long   offset,
                     unsigned char*  buffer,
                     unsigned long   count )
  {
    FIL*  file;
	FRESULT res;
	file = STREAM_FILE(stream);
	if(stream->pos != offset)
	f_lseek(file,offset);
	res = f_read(&fstt,&buffer[0],count,&size);
	return count;

  }


  /* documentation is in ftstream.h */

#if 0
  FT_BASE_DEF( FT_Error )
  FT_Stream_Open( FT_Stream    stream,
                  const char*  filepathname )
  {
    FT_FILE*  file;


    if ( !stream )
      return FT_THROW( Invalid_Stream_Handle );

    stream->descriptor.pointer = NULL;
    stream->pathname.pointer   = (char*)filepathname;
    stream->base               = NULL;
    stream->pos                = 0;
    stream->read               = NULL;
    stream->close              = NULL;

    file = ft_fopen( filepathname, "rb" );
    if ( !file )
    {
      FT_ERROR(( "FT_Stream_Open:"
                 " could not open `%s'\n", filepathname ));

      return FT_THROW( Cannot_Open_Resource );
    }

    ft_fseek( file, 0, SEEK_END );
    stream->size = (unsigned long)ft_ftell( file );
    if ( !stream->size )
    {
      FT_ERROR(( "FT_Stream_Open:" ));
      FT_ERROR(( " opened `%s' but zero-sized\n", filepathname ));
      ft_fclose( file );
      return FT_THROW( Cannot_Open_Stream );
    }
    ft_fseek( file, 0, SEEK_SET );

    stream->descriptor.pointer = file;
    stream->read  = ft_ansi_stream_io;
    stream->close = ft_ansi_stream_close;

    FT_TRACE1(( "FT_Stream_Open:" ));
    FT_TRACE1(( " opened `%s' (%d bytes) successfully\n",
                filepathname, stream->size ));

    return FT_Err_Ok;
  }
#endif

  FT_BASE_DEF( FT_Error )
   FT_Stream_Open( FT_Stream	stream, //ks
				   const char*	filepathname )
   {
	 FT_FILE*  file;
	 FRESULT res;
	 FIL fsrc;
	 DIR dirs;
	 char readb[4]={0};
	 if ( !stream )
	   return FT_Err_Invalid_Stream_Handle;

	 //file = ft_fopen( filepathname, "rb" );

	 res=f_open(&fstt, filepathname, FA_OPEN_EXISTING | FA_READ);
	 //fstt=fsrc;	 
	 if ( !res )
	 {

		  //printf("?y3£′ò?a???t");

	  // return FT_Err_Cannot_Open_Resource;
	 }

	// ft_fseek( file, 0, SEEK_END );

	 //stream->size = ft_ftell( file );
	 stream->size=fstt.obj.objsize;
   //  ft_fseek( file, 0, SEEK_SET );

	 stream->descriptor.pointer = &fstt;
	 stream->pathname.pointer	= (char*)filepathname;
	 stream->pos				= 0;

	 stream->read  = ft_ansi_stream_io;
	 stream->close = ft_ansi_stream_close;

	// FT_TRACE1(( "FT_Stream_Open:" ));
	 //FT_TRACE1(( " opened `%s' (%d bytes) successfully\n",
	  //		   filepathname, stream->size ));

	 return FT_Err_Ok;
   }



#endif /* !FT_CONFIG_OPTION_DISABLE_STREAM_SUPPORT */

#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 */

#if 0
  FT_BASE_DEF( FT_Memory )
  FT_New_Memory( void )
  {
    FT_Memory  memory;


    memory = (FT_Memory)ft_smalloc( sizeof ( *memory ) );
    if ( memory )
    {
      memory->user    = NULL;
      memory->alloc   = ft_alloc;
      memory->realloc = ft_realloc;
      memory->free    = ft_free;
#ifdef FT_DEBUG_MEMORY
      ft_mem_debug_init( memory );
#endif
    }

    return memory;
  }
#endif
	FT_BASE_DEF( FT_Memory )
	FT_New_Memory( void )
	{
	  FT_Memory  memory;


//	  memory = (FT_Memory)ft_smalloc( sizeof ( *memory ) );
	  memory = (FT_Memory)malloc( sizeof ( *memory ) );

	  if ( memory )
	  {
		memory->user	= NULL;
		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_BASE_DEF( void )
  FT_Done_Memory( FT_Memory  memory )
  {
#ifdef FT_DEBUG_MEMORY
    ft_mem_debug_done( memory );
#endif
    ft_sfree( memory );
  }


/* END */

在移植文件的读写的时候发现一个问题,0.08版本的与 0.13版本有点差异,前者open文件后,在FIL的结构中就有fsize(文件的大小),而后者则是在FIL结构中的obj中的objsize

如此这般之后,错误已经只有一条了:

Error[Li005]: no definition for "FT_Gzip_Uncompress" [referenced from D:\ARM_base\A7_host_uvc_freertos_freeType\host_uvc_freertos_ca\iar_V7\ddr_debug\obj\sfnt.o] 
Error while running Linker 

解决办法就是将ftgzip.c文件加入工程,到这里源码在IAR平台编译成功。

之前在使用freeType渲染ttf矢量字库的时候,因为仓促的原因,没有对freeType进行移植,而是在PC上调用freeType库将ttf文件生成对应字号bmp数据,将其按照gb2312转uincode码的数组顺序存储为文件,然后单片机读取字体文件进行显示,同事在使用过程中比较麻烦,如果需要不同大小的字体,则需要生成不同的文件,而且这些文件在使用之前还需要存入内存,以方便提升显示速度,如果应用需要不同字号的字体,又或者不同的字体,这就对内存的需求非常大,所以最后还是选择freeType的在线渲染,后期希望能做到支持多种字体不同大小的渲染。

在通过freetype加载字库的时候有两种方式,第一种是,将字库文件读取到内存中,还有一种是流操作的方式,考虑到嵌入式设备的资源有限,而且普通的字库都在6M以上,一般采用文件流的方式,而这个的缺点就是效率有所降低,具体采用哪种方式,需要根据实际的情况来评估。

后面将更新如何调用freeType接口实现自己的在线渲染,同时独立与自己的gui库。

posted @ 2020-03-25 19:39  字由人  阅读(842)  评论(0编辑  收藏  举报