freetype相关总结

FreeType-2.7 API ：

https://www.freetype.org/freetype2/docs/reference/ft2-basic_types.html

----------------------------------------------------------

freetype 使用小结：(转：http://blog.csdn.net/wesleyluo/article/details/7432063)

FreeType是一个完全开源的、可扩展、可定制且可移植的字体引擎，它提供TrueType字体驱动的实现统一的接口来访问多种字体格式文件，

包括点阵字、TrueType、OpenType、Type1、

CID、CFF、Windows FON/FNT、X11 PCF等。FreeType函数库具有以下特点：
(1)它使得客户应用程序可以方便地访问字体文件，无论字体文件存储在哪里，并且与字体格式无关。
(2)能方便地提取全局字体数据，这些数据普遍存在于一般的字体格式中。（例如：全局度量标准，字符编码/字符映射表，等等）
(3)能方便地提取某个字符的字形数据（度量标准，图像，名字等其他任何数据）
(4)具备访问字体格式特定的功能（例如：SFNT表，多重控制，OpenType轮廓表）

使用FreeType引擎来显示字符的流程如图.2所示（FreeType Team，2008）。
首先需要初始化FreeType库，然后依次根据字符的编码处理一个字符，把它转化为点阵的位图信息，最后根据字符的信息，在相应的地方把它显示出来。

根据以上流程图相应的函数如下：
(1)首先对FreeType库进行初始化，并且读取矢量字库文件。
FT_Init_FreeType(&library);//创建新的库对象，准备作其他操作时使用FT_New_Face(library,filename,0,&face);
FT_Init_FreeType()他会缺省地注册一些模块。这个方式中，模块列表在构建时动态计算，并依赖ftinit部件的内容。
FT_New_Face()通常用来创建外观对象，如果函数调用成功，返回0。外观对象包含一些用来描述全局字体数据的属性，可以被客户程序直接访问。它包括外
观中字形的数量、外观家族的名称、风格名称、EM大小等。这个函数包括的参数library是一个全局的变量，而filename是矢量字库的路径（c文件路径名）。
这里通过以上两个步骤首先建立了FreeType库的一个实例。然后使用一个字库文件来得到字体的face对象接口。

(2)得到face对象之后，需要设置当前字体的属性，尺寸对象的内容可以通过调用函数FT_Set_Pixel_Sizes()来改变。
当一个新的face对象建立时，对于可伸缩字体格式，size对象默认值为字符大小水平和垂直均为10象素。对于定长字体格式，这个大小是未定义的，所以必
须在装载一个字形前设置该值。
FT_Set_Pixel_Sizes(face,//当前face对象
16,//字符点阵宽度
16//字符点阵高度
);
以上函数把字符象素设置为16*16象素，因此最后的位图信息就是16*16点阵象素。

(3)设置完字体的属性之后，需要得到字符的轮廓信息。
一个face对象包含一个或多个字符表(charmap)，字符表是用来转换字符码到字形索引的。TrueType字体文件通常包含两个字符表，一个用来转换Unicode字
符码到字形索引，另一个用来转换Apple Roman编码到字形索引。这样的字体既可以用于Windows（使用Unicode），同时又可用于Macintosh（使用Apple Roman）。
另外需要注意，一个特定的字符表可能没有覆盖完字体里面的全部字形。
当新建一个face对象时，它默认选择Unicode字符表。根据字符的Unicode编码来得到它的glyph索引。代码如下：
FT_Get_Char_Index(face,charcode);这个函数会在face里被选中的字符表中查找与给出的字符码对应的字形索引。

从face中来得到字符对应的glyph后，需要读取到glyph slo（t存储字形的对象：字形槽）中才能使用。
FT_Load_Glyph(face,glyph_index,FT_LOAD_DEFAULT);
FT_Load_Glyph()的第三个参数是装载标志load_flags，其值是位标志集合，用来指示某些特殊操作的，默认值为FT_LOAD_DEFAULT即0。这个函数会设法
从face中装载对应的字形图像。
然后通过FT_Get_Glyph()简单地提取一个字形图像。FT_Get_Glyph(face->glyph,&glyph);最后把字形对象转换成一个位图：
FT_Glyph_To_Bitmap(&glyph,FT_RENDER_MODE_NORMAL,0,1);
glyph是源字形句柄的地址；第二个参数是标准的渲染模式；第三个参数是二维矢量的指针，该二维矢量是在转换前用来平移源字形图像的，该指针为0时
表明渲染前不需要平移源字形；最后一个参数是一个布尔值，用来指示该函数是否要销毁源字形对象。
bitmap=(FT_BitmapGlyph)glyph;经过转化之后，字体的点阵信息就存放在bitmap参数里面，再把点阵信息写
入OSD的buffer中，即可显示出相应的字符。
依据以上算法，将FreeType应用到高清播放机中时，能正常显示菜单界面字幕。然而在播放影片的过程中，srt字幕显示过慢，无法跟进视频播放的进度，滞
后现象非常严重。

freetype相关链接：

1.http://www.freetype.org/freetype2/docs/tutorial/step1.html

2.http://www.unixresources.net/linux/clf/kylix/archive/00/00/59/21/592188.html

3.http://blog.csdn.net/absurd/archive/2006/10/28/1354499.aspx

4.http://www.wangchao.net.cn/bbsdetail_58348.html

5.http://topic.csdn.net/u/20080408/14/4C2ED903-3A22-46EC-8736-D9773FFB189A.html

6.http://www.wonstar.com/service/detail/124.html

7.http://book.csdn.net/bookfiles/308/10030812801.shtml

转自：http://blog.csdn.net/saintevil/article/details/5747582#

libfreetype使用例子；

安装我就不说了，自己安装2.4.9版本；

例子代码如下：

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


int main()
{

FT_Library    pFTLib         =  NULL;
FT_Face        pFTFace         =  NULL;
FT_Error    error         =   0 ;
//Init FreeType Lib to manage memory
error  =  FT_Init_FreeType( & pFTLib);
if (error)
{
    pFTLib  =   0 ;
    printf( " There is some error when Init Library " );
     return   - 1 ;
}

//create font face from font file
error  =  FT_New_Face(pFTLib,  "/usr/share/fonts/truetype/thai/Waree-Bold.ttf" ,  0 ,  & pFTFace);
 if ( ! error)
 {
    FT_Set_Char_Size(pFTFace,  16 << 6 ,  16 << 6 ,  300 ,  300 );
    FT_Glyph    glyph;
     //  load glyph 'C'
    FT_Load_Glyph(pFTFace, FT_Get_Char_Index(pFTFace,  67 ), FT_LOAD_DEFAULT);
    error  =  FT_Get_Glyph(pFTFace -> glyph,  & glyph);
     if ( ! error)
     {
         //  convert glyph to bitmap with 256 gray
        FT_Glyph_To_Bitmap( & glyph, ft_render_mode_normal,  0 ,  1 );
        FT_BitmapGlyph    bitmap_glyph  =  (FT_BitmapGlyph)glyph;
        FT_Bitmap &     bitmap  =  bitmap_glyph -> bitmap;
         for ( int  i = 0 ; i < bitmap.rows;  ++ i)
         {
             for ( int  j = 0 ; j < bitmap.width;  ++ j)
             {
                 //  if it has gray>0 we set show it as 1, o otherwise
                printf( " %d " , bitmap.buffer[i * bitmap.width + j] ? 1 : 0 );
            }
            printf( " 
 " );
        }
         //  free glyph
        FT_Done_Glyph(glyph);
        glyph  =  NULL;
    }
     //  free face
    FT_Done_Face(pFTFace);
    pFTFace  =  NULL;
}

 //  free FreeType Lib
FT_Done_FreeType(pFTLib);
pFTLib  =  NULL;

}

============================

使用FreeType绘制字体(转：http://blog.csdn.net/furtherchan/article/details/8667884)

不带缓存的FreeType使用

1、 初始化库

FT_Init_FreeType( FT_Library  *alibrary );

2、 通过创建一个新的 face 对象来打开一个字体文件

FT_New_Face( FT_Library   library,

               const char*  filepathname,

               FT_Long      face_index,

               FT_Face     *aface );

3、 以点或者象素的形式选择一个字符大小

  FT_Set_Char_Size( FT_Face     face,

                    FT_F26Dot6  char_width,

                    FT_F26Dot6  char_height,

                    FT_UInt     horz_resolution,

                    FT_UInt     vert_resolution );

  FT_Set_Pixel_Sizes( FT_Face  face,

                      FT_UInt  pixel_width,

                      FT_UInt  pixel_height );

4、 装载一个字形(glyph)图像，并把它转换为位图

(1)把一个字符码转换为一个字形索引

  FT_Get_Char_Index( FT_Face   face,

                     FT_ULong  charcode );

(2)从face中装载一个字形

  FT_Load_Glyph( FT_Face   face,

                 FT_UInt   glyph_index,

                 FT_Int32  load_flags );

(3)转换成bitmap位图

  FT_Glyph_To_Bitmap( FT_Glyph*       the_glyph,

                      FT_Render_Mode  render_mode,

                      FT_Vector*      origin,

                      FT_Bool         destroy );

以上1、2步可用以下函数实现，相当于调用FT_Get_Char_Index和FT_Load_Glyph：

  FT_Load_Char( FT_Face   face,

                FT_ULong  char_code,

                FT_Int32  load_flags );

5、 渲染(可选，斜体、加粗、下划线等)并绘制

FT_Set_Transform( FT_Face     face,

                    FT_Matrix*  matrix,

                    FT_Vector*  delta );

// 示例代码

FT_Library       pFTLib               =NULL;

FT_Face           pFTFace           = NULL;

FT_Glyph          glyph;

FT_UInt   glyph_index;

FT_Error  error = 0;

error =FT_Init_FreeType(&pFTLib);

if(error)

{

    printf("error");

}

error = FT_New_Face(pFTLib,ttf, 0, &pFTFace);

if(error)

{

    printf("error");

}

if(0 !=FT_Set_Char_Size(pFTFace, 0,  16<<6, 72, 72))

{

         printf("error");

}

glyph_index =FT_Get_Char_Index(pFTFace, *char);

FT_Load_Glyph(pFTFace,glyph_index, FT_LOAD_MONOCHROME | FT_LOAD_RENDER);

error =FT_Get_Glyph(pFTFace->glyph, &glyph);

if(!error)

{

    FT_Glyph_To_Bitmap(&glyph,FT_RENDER_MODE_NORMAL, 0, 0);

         FT_BitmapGlyph    bitmap_glyph = (FT_BitmapGlyph)glyph;

         FT_Bitmap      bitmap = bitmap_glyph->bitmap;

// 把点阵数据(bitmap)绘制到具体的显示设备上去

}

带缓存的FreeType使用

 

1、初始化库

FT_Init_FreeType( FT_Library  *alibrary );

2、创建cache manager

  FTC_Manager_New( FT_Library          library,

                   FT_UInt             max_faces,

                   FT_UInt             max_sizes,

                   FT_ULong            max_bytes,

                   FTC_Face_Requester  requester,

                   FT_Pointer          req_data,

                   FTC_Manager        *amanager );

3、创建charmap cache

  FTC_CMapCache_New( FTC_Manager     manager,

                     FTC_CMapCache  *acache );

4、创建cache来存储字形位图数据

  FTC_SBitCache_New( FTC_Manager     manager,

                     FTC_SBitCache  *acache );

5、使用charmap cache把字符编码转化成字形索引

  FTC_CMapCache_Lookup( FTC_CMapCache  cache,

                        FTC_FaceID     face_id,

                        FT_Int         cmap_index,

                        FT_UInt32      char_code );

6、在给定的sbit cache中查找字形位图

  FTC_SBitCache_LookupScaler( FTC_SBitCache  cache,

                              FTC_Scaler     scaler,

                              FT_ULong       load_flags,

                              FT_UInt        gindex,

                              FTC_SBit      *sbit,

                              FTC_Node      *anode );

// 示例代码

FT_Library       pFTLib               =NULL;

FT_Face           pFTFace           = NULL;

FTC_Manager cache_manager= 0;

FTC_CMapCachecmap_cache;

FTC_SBitCachesbit_cache;

FT_UInt glyph_idx;

FTC_ScalerReccurrent_ic;

FTC_Scalerselected_ic;

FTC_SBit bitmap;

FT_Error  err = 0;

err =FT_Init_FreeType(&pFTLib);

if(err)

{

    printf("error");

}

err = FTC_Manager_New(pFTLib,get_faces_to_allocate(), 0, 0,

                   fts_face_requester,(FT_Pointer)NULL, &cache_manager);

if (err)

{

         printf("error");

}

err =FTC_CMapCache_New(cache_manager, &cmap_cache);

if (err)

{

         printf("error");

}

err =FTC_SBitCache_New(cache_manager, &sbit_cache);

if (err)

{

         printf("error");

}

glyph_idx =FTC_CMapCache_Lookup(cmap_cache, current_ic.face_id, -1, char[k]);

if (glyph_idx)

{

         selected_ic = &current_ic;

}

if(FTC_SBitCache_LookupScaler(sbit_cache, selected_ic, FT_LOAD_DEFAULT,

                                                        glyph_idx,&bitmap, (FTC_Node*)NULL))

{

                   printf("error");

}

// 把点阵数据(bitmap)绘制到具体的显示设备上去

==============================

将图片数据转化为YUV420的数据格式：

首先要先将图片数据读入内存，以bmp图片为例，读入的数据为RGB格式数据，经过rgb转化为yuv的算法计算，将数据流转换为yuv的数据流。

//转换矩阵
#define MY(a,b,c) (( a*  0.2989  + b*  0.5866  + c*  0.1145))
#define MU(a,b,c) (( a*(-0.1688) + b*(-0.3312) + c*  0.5000 + 128))
#define MV(a,b,c) (( a*  0.5000  + b*(-0.4184) + c*(-0.0816) + 128))
//大小判断
#define DY(a,b,c) (MY(a,b,c) > 255 ? 255 : (MY(a,b,c) < 0 ? 0 : MY(a,b,c)))
#define DU(a,b,c) (MU(a,b,c) > 255 ? 255 : (MU(a,b,c) < 0 ? 0 : MU(a,b,c)))
#define DV(a,b,c) (MV(a,b,c) > 255 ? 255 : (MV(a,b,c) < 0 ? 0 : MV(a,b,c)))

#define WIDTH 1920
#define HEIGHT 1080

int w = 1920;
 int h = 1080;
 int i=1;
    char file[255];
    FILE *fp;
    FILE *fp2;
    unsigned char *YUV = NULL;
    unsigned char *RGB = NULL;
    unsigned char *H264 =NULL;
    long imgSize = w*h;
    long sizeh264buf=0;
    long counth264buf=0;

    RGB = (unsigned char*)malloc(imgSize*6);
    YUV = (unsigned char*)malloc(imgSize + (imgSize>>1));
    H264 = (unsigned char*)malloc(imgSize*6);
    sprintf(file, "720bmp.bmp", i);//读取文件
    if((fp = fopen(file, "rb")) == NULL)
    return 0;

   ReadBmp(RGB, fp);//将fp文件中数据读入RGB中
   Convert(RGB, YUV);//将RGB数据转换为YUV编码数据

//读BMP
void ReadBmp(unsigned char *RGB,FILE *fp)
{
    int i,j;
    unsigned char temp;

    fseek(fp,54, SEEK_SET);

    fread(RGB+WIDTH*HEIGHT*3, 1, WIDTH*HEIGHT*3, fp);//读取
    for(i=HEIGHT-1,j=0; i>=0; i--,j++)//调整顺序
    {
        memcpy(RGB+j*WIDTH*3,RGB+WIDTH*HEIGHT*3+i*WIDTH*3,WIDTH*3);
    }
   
    //顺序调整
    for(i=0; (unsigned int)i < WIDTH*HEIGHT*3; i+=3)
    {
        temp = RGB[i];
        RGB[i] = RGB[i+2];
        RGB[i+2] = temp;
    }
}

//将RGB数据流转换为yuv数据流
void Convert(unsigned char *RGB, unsigned char *YUV)
{
    //变量声明
    unsigned int i,x,y,j;
    unsigned char *Y = NULL;
    unsigned char *U = NULL;
    unsigned char *V = NULL;
   
    Y = YUV;
    U = YUV + WIDTH*HEIGHT;
    V = U + ((WIDTH*HEIGHT)>>2);

    for(y=0; y < HEIGHT; y++)
        for(x=0; x < WIDTH; x++)
        {
            j = y*WIDTH + x;
            i = j*3;
            Y[j] = (unsigned char)(DY(RGB[i], RGB[i+1], RGB[i+2]));

            if(x%2 == 1 && y%2 == 1)
            {
                j = (WIDTH>>1) * (y>>1) + (x>>1);
                //上面i仍有效
                U[j] = (unsigned char)
                       ((DU(RGB[i  ], RGB[i+1], RGB[i+2]) +
                         DU(RGB[i-3], RGB[i-2], RGB[i-1]) +
                         DU(RGB[i  -WIDTH*3], RGB[i+1-WIDTH*3], RGB[i+2-WIDTH*3]) +
                         DU(RGB[i-3-WIDTH*3], RGB[i-2-WIDTH*3], RGB[i-1-WIDTH*3]))/4);

                V[j] = (unsigned char)
                       ((DV(RGB[i  ], RGB[i+1], RGB[i+2]) +
                         DV(RGB[i-3], RGB[i-2], RGB[i-1]) +
                         DV(RGB[i  -WIDTH*3], RGB[i+1-WIDTH*3], RGB[i+2-WIDTH*3]) +
                         DV(RGB[i-3-WIDTH*3], RGB[i-2-WIDTH*3], RGB[i-1-WIDTH*3]))/4);
            }

        }
}