kc3-lang/freetype/src/cache/ftcsbits.c

• Show log

  Commit

• Hash : ab855232
  Author :
  Date : 2000-10-31T22:13:54
  

  Fixing include header for a `make multi' build. Finishing formatting of cache stuff. Fixed getDriverClass stuff -- added it to winfnt.c also. Note that this still has to be documented.

Download

• src/cache/ftcsbits.c

• /***************************************************************************/
  /*                                                                         */
  /*  ftcsbits.c                                                             */
  /*                                                                         */
  /*    FreeType sbits manager (body).                                       */
  /*                                                                         */
  /*  Copyright 2000 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.                                        */
  /*                                                                         */
  /***************************************************************************/
  
  
  #include <freetype/cache/ftcsbits.h>
  #include <freetype/internal/ftobjs.h>
  #include <freetype/internal/ftdebug.h>
  #include <freetype/fterrors.h>
  
  #include <string.h>         /* memcmp() */
  
  
  #define  FTC_SBITSET_ELEMENT_COUNT  16
  
  
    typedef struct  FTC_SBitSetRec_
    {
      FTC_ChunkSetRec  root;
      FTC_Image_Desc   desc;
  
    } FTC_SBitSetRec, *FTC_SBitSet;
  
  
    typedef struct  FTC_SBit_CacheRec_
    {
      FTC_Chunk_CacheRec  root;
  
    } FTC_SBit_CacheRec;
  
  
  
    /*************************************************************************/
    /*************************************************************************/
    /*****                                                               *****/
    /*****                     SBIT CACHE NODES                          *****/
    /*****                                                               *****/
    /*************************************************************************/
    /*************************************************************************/
  
  
    LOCAL_FUNC_X
    void  ftc_sbit_chunk_node_destroy( FTC_ChunkNode  node )
    {
      FTC_ChunkSet  cset   = node->cset;
      FT_Memory     memory = cset->memory;
      FT_UInt       count  = node->num_elements;
      FTC_SBit      sbit   = (FTC_SBit)node->elements;
  
  
      for ( ; count > 0; sbit++, count-- )
        FREE( sbit->buffer );
  
      FREE( node->elements );
      FREE( node );
    }
  
  
    LOCAL_FUNC_X
    FT_Error  ftc_bitmap_copy( FT_Memory   memory,
                               FT_Bitmap*  source,
                               FTC_SBit    target )
    {
      FT_Error  error;
      FT_Int    pitch = source->pitch;
      FT_ULong  size;
  
  
      if ( pitch < 0 )
        pitch = -pitch;
  
      size = (FT_ULong)( pitch * source->rows );
  
      if ( !ALLOC( target->buffer, size ) )
        MEM_Copy( target->buffer, source->buffer, size );
  
      return error;
    }
  
  
    LOCAL_FUNC_X
    FT_Error  ftc_sbit_chunk_node_new( FTC_ChunkSet    cset,
                                       FT_UInt         index,
                                       FTC_ChunkNode*  anode )
    {
      FT_Error       error;
      FT_Memory      memory  = cset->memory;
      FTC_SBitSet    sbitset = (FTC_SBitSet)cset;
      FTC_ChunkNode  node    = 0;
      FT_Face        face;
      FT_Size        size;
  
  
      /* allocate node */
      if ( ALLOC( node, sizeof ( *node ) ) )
        goto Exit;
  
      /* initialize its inner fields */
      error = FTC_ChunkNode_Init( node, cset, index, 1 );
      if ( error )
        goto Exit;
  
      /* we will now load all glyph images for this chunk */
      error = FTC_Manager_Lookup_Size( cset->manager,
                                       &sbitset->desc.font,
                                       &face, &size );
      if ( !error )
      {
        FT_UInt   glyph_index = index * cset->element_count;
        FT_UInt   load_flags  = FT_LOAD_DEFAULT;
        FT_UInt   image_type  = sbitset->desc.image_type;
        FT_UInt   count       = node->num_elements;
        FTC_SBit  sbit        = (FTC_SBit)node->elements;
  
  
        /* determine load flags, depending on the font description's */
        /* image type                                                */
  
        if ( FTC_IMAGE_FORMAT( image_type ) == ftc_image_format_bitmap )
        {
          if ( image_type & ftc_image_flag_monochrome )
            load_flags |= FT_LOAD_MONOCHROME;
  
          /* disable embedded bitmaps loading if necessary */
          if ( image_type & ftc_image_flag_no_sbits )
            load_flags |= FT_LOAD_NO_BITMAP;
        }
        else
        {
          FT_ERROR(( "FTC_SBit_Cache: cannot load scalable glyphs in an"
                     " sbit cache, please check your arguments!\n" ));
          error = FT_Err_Invalid_Argument;
          goto Exit;
        }
  
        /* always render glyphs to bitmaps */
        load_flags |= FT_LOAD_RENDER;
  
        if ( image_type & ftc_image_flag_unhinted )
          load_flags |= FT_LOAD_NO_HINTING;
  
        if ( image_type & ftc_image_flag_autohinted )
          load_flags |= FT_LOAD_FORCE_AUTOHINT;
  
        /* load a chunk of small bitmaps in a row */
        for ( ; count > 0; count--, glyph_index++, sbit++ )
        {
          /* by default, indicates a `missing' glyph */
          sbit->buffer = 0;
  
          error = FT_Load_Glyph( face, glyph_index, load_flags );
          if ( !error )
          {
            FT_Int        temp;
            FT_GlyphSlot  slot   = face->glyph;
            FT_Bitmap*    bitmap = &slot->bitmap;
            FT_Int        xadvance, yadvance;
  
  
            /* check that our values fit into 8-bit containers!       */
            /* If this is not the case, our bitmap is too large       */
            /* and we will leave it as `missing' with sbit.buffer = 0 */
  
  #define CHECK_CHAR( d )  ( temp = (FT_Char)d, temp == d )
  #define CHECK_BYTE( d )  ( temp = (FT_Byte)d, temp == d )
  
            /* XXX: FIXME: add support for vertical layouts maybe */
  
            /* horizontal advance in pixels */
            xadvance = ( slot->metrics.horiAdvance + 32 ) >> 6;
            yadvance = ( slot->metrics.vertAdvance + 32 ) >> 6;
  
            if ( CHECK_BYTE( bitmap->rows  )     &&
                 CHECK_BYTE( bitmap->width )     &&
                 CHECK_CHAR( bitmap->pitch )     &&
                 CHECK_CHAR( slot->bitmap_left ) &&
                 CHECK_CHAR( slot->bitmap_top  ) &&
                 CHECK_CHAR( xadvance )          &&
                 CHECK_CHAR( yadvance )          )
            {
              sbit->width    = (FT_Byte)bitmap->width;
              sbit->height   = (FT_Byte)bitmap->rows;
              sbit->pitch    = (FT_Char)bitmap->pitch;
              sbit->left     = (FT_Char)slot->bitmap_left;
              sbit->top      = (FT_Char)slot->bitmap_top;
              sbit->xadvance = (FT_Char)xadvance;
              sbit->yadvance = (FT_Char)yadvance;
              sbit->format   = (FT_Byte)bitmap->pixel_mode;
  
              /* grab the bitmap when possible */
              if ( slot->flags & ft_glyph_own_bitmap )
              {
                slot->flags &= ~ft_glyph_own_bitmap;
                sbit->buffer = bitmap->buffer;
              }
              else
              {
                /* copy the bitmap into a new buffer -- ignore error */
                ftc_bitmap_copy( memory, bitmap, sbit );
              }
            }
          }
        }
  
        /* ignore the errors that might have occurred --        */
        /* we recognize unloaded glyphs with `sbit.buffer == 0' */
        error = 0;
      }
  
    Exit:
      if ( error && node )
      {
        FREE( node->elements );
        FREE( node );
      }
  
      *anode = node;
  
      return error;
    }
  
  
    /* this function is important because it is both part of */
    /* an FTC_ChunkSet_Class and an FTC_CacheNode_Class      */
    /*                                                       */
    LOCAL_FUNC_X
    FT_ULong  ftc_sbit_chunk_node_size( FTC_ChunkNode  node )
    {
      FT_ULong      size;
      FTC_ChunkSet  cset  = node->cset;
      FT_UInt       count = node->num_elements;
      FT_Int        pitch;
      FTC_SBit      sbit  = (FTC_SBit)node->elements;
  
  
      /* the node itself */
      size  = sizeof ( *node );
      /* the sbit records */
      size += cset->element_count * sizeof ( FTC_SBitRec );
  
      for ( ; count > 0; count--, sbit++ )
      {
        if ( sbit->buffer )
        {
          pitch = sbit->pitch;
          if ( pitch < 0 )
            pitch = -pitch;
  
          /* add the size of a given glyph image */
          size += pitch * sbit->height;
        }
      }
  
      return size;
    }
  
  
    /*************************************************************************/
    /*************************************************************************/
    /*****                                                               *****/
    /*****                     SBIT CHUNK SETS                           *****/
    /*****                                                               *****/
    /*************************************************************************/
    /*************************************************************************/
  
  
    LOCAL_FUNC_X
    FT_Error  ftc_sbit_chunk_set_sizes( FTC_ChunkSet     cset,
                                        FTC_Image_Desc*  desc )
    {
      FT_Error  error;
      FT_Face   face;
  
  
      cset->element_count = FTC_SBITSET_ELEMENT_COUNT;
      cset->element_size  = sizeof ( FTC_SBitRec );
  
      /* lookup the FT_Face to obtain the number of glyphs */
      error = FTC_Manager_Lookup_Face( cset->manager,
                                       desc->font.face_id, &face );
      if ( !error )
        cset->element_max = face->num_glyphs;
  
      return error;
    }
  
  
    LOCAL_FUNC_X
    FT_Error  ftc_sbit_chunk_set_init( FTC_SBitSet      sset,
                                       FTC_Image_Desc*  type )
    {
      sset->desc = *type;
  
      return 0;
    }
  
  
    LOCAL_FUNC_X
    FT_Bool  ftc_sbit_chunk_set_compare( FTC_SBitSet      sset,
                                         FTC_Image_Desc*  type )
    {
      return !memcmp( &sset->desc, type, sizeof ( *type ) );
    }
  
  
    FT_CPLUSPLUS( const FTC_ChunkSet_Class )  ftc_sbit_chunk_set_class =
    {
      sizeof( FTC_SBitSetRec ),
  
      (FTC_ChunkSet_InitFunc)       ftc_sbit_chunk_set_init,
      (FTC_ChunkSet_DoneFunc)       0,
      (FTC_ChunkSet_CompareFunc)    ftc_sbit_chunk_set_compare,
      (FTC_ChunkSet_SizesFunc)      ftc_sbit_chunk_set_sizes,
  
      (FTC_ChunkSet_NewNodeFunc)    ftc_sbit_chunk_node_new,
      (FTC_ChunkSet_SizeNodeFunc)   ftc_sbit_chunk_node_size,
      (FTC_ChunkSet_DestroyNodeFunc)ftc_sbit_chunk_node_destroy
    };
  
  
    /*************************************************************************/
    /*************************************************************************/
    /*****                                                               *****/
    /*****                     SBITS CACHE                               *****/
    /*****                                                               *****/
    /*************************************************************************/
    /*************************************************************************/
  
  
    FT_CPLUSPLUS( const FTC_Chunk_Cache_Class )  ftc_sbit_cache_class =
    {
      {
        sizeof( FTC_SBit_CacheRec ),
        (FTC_Cache_InitFunc)FTC_Chunk_Cache_Init,
        (FTC_Cache_DoneFunc)FTC_Chunk_Cache_Done
      },
      (FTC_ChunkSet_Class*)&ftc_sbit_chunk_set_class
    };
  
  
    FT_EXPORT_FUNC( FT_Error )  FTC_SBit_Cache_New( FTC_Manager      manager,
                                                    FTC_SBit_Cache*  acache )
    {
      return FTC_Manager_Register_Cache(
                manager,
                (FTC_Cache_Class*)&ftc_sbit_cache_class,
                (FTC_Cache*)acache );
    }
  
  
    FT_EXPORT_DEF( FT_Error )  FTC_SBit_Cache_Lookup( FTC_SBit_Cache   cache,
                                                      FTC_Image_Desc*  desc,
                                                      FT_UInt          gindex,
                                                      FTC_SBit*        asbit )
    {
      FT_Error       error;
      FTC_ChunkSet   cset;
      FTC_ChunkNode  node;
      FT_UInt        cindex;
      FTC_Manager    manager;
  
      FTC_SBitSet    sset;
      FTC_SBit       sbit;
  
  
      /* check for valid `desc' delayed to FT_Lru_Lookup() */
  
      if ( !cache || !asbit )
        return FT_Err_Invalid_Argument;
  
      *asbit = 0;
      cset   = cache->root.last_cset;
      sset   = (FTC_SBitSet)cset;
  
      if ( !cset || memcmp( &sset->desc, desc, sizeof ( *desc ) ) )
      {
        error = FT_Lru_Lookup( cache->root.csets_lru,
                               (FT_LruKey)desc,
                               (FT_Pointer*)&cset );
        cache->root.last_cset = cset;
        if ( error )
          goto Exit;
      }
  
      error = FTC_ChunkSet_Lookup_Node( cset, gindex, &node, &cindex );
      if ( error )
        goto Exit;
  
      /* now compress the manager's cache pool if needed */
      manager = cache->root.root.manager;
      if ( manager->num_bytes > manager->max_bytes )
      {
        FTC_ChunkNode_Ref   ( node );
        FTC_Manager_Compress( manager );
        FTC_ChunkNode_Unref ( node );
      }
  
      sbit   = ((FTC_SBit)((FTC_ChunkNode)node)->elements) + cindex;
      *asbit = sbit;
  
    Exit:
      return error;
    }
  
  
  /* END */
  

Download