zoukankan      html  css  js  c++  java
  • 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'
    ", 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
    ", 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
    ",
                    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
    ",
    	  //		   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_baseA7_host_uvc_freertos_freeTypehost_uvc_freertos_caiar_V7ddr_debugobjsfnt.o] 
    Error while running Linker 

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

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

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

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

  • 相关阅读:
    result set sql server
    [转载]:C#、.Net面试题目及答案
    [转载]:合并两个已排序好的int数组,并排序返回c#实现
    [转载]实际举例C#引用类型和值类型的区别
    mysql 性能优化方案
    oracle 并行原理深入解析及案例精粹
    创建Oracle外部表 External Table
    Oracle 分区表
    MySQL索引类型一览
    MySQL配置文件mysql.ini参数详解、MySQL性能优化
  • 原文地址:https://www.cnblogs.com/10cm/p/12568900.html
Copyright © 2011-2022 走看看