Edit

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

Branch :

  • Show log

    Commit

  • Author : David Turner
    Date : 2000-10-28 13:17:11
    Hash : 4e4a4363
    Message : - completed the abstract chunk cache class - started implementin a "small-bitmaps" cache derived from it - (soon a "metrics" cache will be written too)

  • src/cache/ftcsbits.c
  • #include <cache/ftcsbits.h>
    
      /*************************************************************************/
      /*************************************************************************/
      /*****                                                               *****/
      /*****                    GLYPH IMAGE 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 );
      }
    
    
      static
      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_SBitChunk *anode )
      {
        FT_Error         error;
        FT_Memory        memory  = cset->memory;
        FTC_SBitSet      sbitset = (FTC_SBitSet)cset;
        FTC_SBitChunk    node    = 0;
        FT_Face          face;
        FT_Size          size;
    
    
        /* allocate node */
        if ( ALLOC( node, sizeof ( *node ) ) )
          goto Exit;
    
        /* init its inner fields */
        error = FTC_ChunkNode_Init( FTC_CHUNKNODE(node), cset, index, 1 );
        if (error)
          goto Exit;
    
        /* we will now load all glyph images */
        error = FTC_Manager_Lookup_Size( cset->manager,
                                         &sbitset->description.font,
                                         &face, &size );
        if ( !error )
        {
          FT_UInt  glyph_index = index * cset->chunk_size;
          FT_UInt  load_flags  = FT_LOAD_DEFAULT;
          FT_UInt  image_type  = sbitset->description.image_type;
          FT_UInt  count       = node->num_elements;
          FTC_SBit sbit        = (FTC_SBit)node->elements;
    
    
          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 if ( FTC_IMAGE_FORMAT( image_type ) == ftc_image_format_outline )
          {
            /* disable embedded bitmaps loading */
            load_flags |= FT_LOAD_NO_BITMAP;
    
            if ( image_type & ftc_image_flag_unscaled )
            {
              FT_ERROR(( "FTC_SBit_Cache: cannot load vector outlines in a"
                         " sbit cache, please check your arguments !!\n" ));
              error = FT_Err_Bad_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++ )
          {
            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        advance;
    
              /* check that our values fit in 8-bit containers !! */
    #define  CHECK_SCHAR(d)  ( temp = (FT_SChar)d, temp == d )
    #define  CHECK_BYTE(d)   ( temp = (FT_Byte) d, temp == d )
    
              advance = (slot->metrics.horiAdvance+32) >> 6;
              
              if ( CHECK_BYTE ( bitmap->rows  )     &&
                   CHECK_BYTE ( bitmap->width )     &&
                   CHECK_SCHAR( bitmap->pitch )     &&
                   CHECK_SCHAR( slot->bitmap_left ) &&
                   CHECK_SCHAR( slot->bitmap_top  ) &&
                   CHECK_SCHAR( advance )           )
              {
                sbit->width   = (FT_Byte) bitmap->width;
                sbit->height  = (FT_Byte) bitmap->height;
                sbit->pitch   = (FT_SChar)bitmap->pitch;
                sbit->left    = (FT_SChar)slot->bitmap_left;
                sbit->top     = (FT_SChar)slot->bitmap_top;
                sbit->advance = (FT_SChar)advance;
    
                /* 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 );
                }
              }
            }
            else
              sbit->buffer = 0;
          }
    
          /* ignore the errors that might have occured there      */
          /* 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 */
      /* a FTC_ChunkSet_Class and a FTC_CacheNode_Class     */
      /*                                                       */
      LOCAL_FUNC_X
      FT_ULong  ftc_sbit_chunk_node_size( FTC_SBitChunk  node )
      {
        FT_ULong  size  = 0;
        FT_Glyph  glyph = node->ft_glyph;
    
    
        switch ( glyph->format )
        {
        case ft_glyph_format_bitmap:
          {
            FT_BitmapGlyph  bitg;
    
    
            bitg = (FT_BitmapGlyph)glyph;
            size = bitg->bitmap.rows * labs( bitg->bitmap.pitch ) +
                   sizeof ( *bitg );
          }
          break;
    
        case ft_glyph_format_outline:
          {
            FT_OutlineGlyph  outg;
    
    
            outg = (FT_OutlineGlyph)glyph;
            size = outg->outline.n_points *
                     ( sizeof( FT_Vector ) + sizeof ( FT_Byte ) ) +
                   outg->outline.n_contours * sizeof ( FT_Short ) +
                   sizeof ( *outg );
          }
          break;
    
        default:
          ;
        }
    
        size += sizeof ( *node );
        return size;
      }
    
    
      /*************************************************************************/
      /*************************************************************************/
      /*****                                                               *****/
      /*****                    GLYPH IMAGE QUEUES                         *****/
      /*****                                                               *****/
      /*************************************************************************/
      /*************************************************************************/
    
    
      LOCAL_FUNC_X
      FT_Error  ftc_image_set_init( FTC_ImageSet     iset,
                                    FTC_Image_Desc*  type )
      {
        iset->description = *type;
        return 0;
      }
    
    
      LOCAL_FUNC_X
      FT_Bool  ftc_image_set_compare( FTC_ImageSet     iset,
                                      FTC_Image_Desc*  type )
      {
        return !memcmp( &iset->description, type, sizeof ( *type ) );
      }
    
    
      FT_CPLUSPLUS( const FTC_ChunkSet_Class )  ftc_sbit_chunk_set_class =
      {
        sizeof( FTC_ImageSetRec ),
    
        (FTC_ChunkSet_InitFunc)       ftc_image_set_init,
        (FTC_ChunkSet_DoneFunc)       0,
        (FTC_ChunkSet_CompareFunc)    ftc_image_set_compare,
    
        (FTC_ChunkSet_NewNodeFunc)    ftc_sbit_chunk_node_new,
        (FTC_ChunkSet_SizeNodeFunc)   ftc_sbit_chunk_node_size,
        (FTC_ChunkSet_DestroyNodeFunc)ftc_sbit_chunk_node_destroy
      };
    
    
      /*************************************************************************/
      /*************************************************************************/
      /*****                                                               *****/
      /*****                    GLYPH IMAGE CACHE                          *****/
      /*****                                                               *****/
      /*************************************************************************/
      /*************************************************************************/
    
    
      FT_CPLUSPLUS( const FTC_Glyph_Cache_Class )  ftc_sbit_chunk_cache_class =
      {
        {
          sizeof( FTC_Image_CacheRec ),
          (FTC_Cache_InitFunc) FTC_Glyph_Cache_Init,
          (FTC_Cache_DoneFunc) FTC_Glyph_Cache_Done
        },
        (FTC_ChunkSet_Class*) &ftc_sbit_chunk_set_class
      };
    
    
      FT_EXPORT_FUNC( FT_Error )  FTC_Image_Cache_New( FTC_Manager       manager,
                                                       FTC_Image_Cache*  acache )
      {
        return FTC_Manager_Register_Cache(
                  manager,
                  (FTC_Cache_Class*)&ftc_sbit_chunk_cache_class,
                  (FTC_Cache*)acache );
      }
    
    
      FT_EXPORT_DEF( FT_Error )
      FTC_Image_Cache_Lookup( FTC_Image_Cache  cache,
                              FTC_Image_Desc*  desc,
                              FT_UInt          gindex,
                              FT_Glyph*        aglyph )
      {
        FT_Error       error;
        FTC_ChunkSet   gset;
        FTC_GlyphNode  node;
        FTC_Manager    manager;
    
        FTC_ImageSet   img_set;
    
    
        /* check for valid `desc' delayed to FT_Lru_Lookup() */
    
        if ( !cache || !aglyph )
          return FT_Err_Invalid_Argument;
    
        *aglyph  = 0;
        gset     = cache->root.last_gset;
        img_set  = (FTC_ImageSet)gset;
        if ( !gset || memcmp( &img_set->description, desc, sizeof ( *desc ) ) )
        {
          error = FT_Lru_Lookup( cache->root.gsets_lru,
                                 (FT_LruKey)desc,
                                 (FT_Pointer*)&gset );
          cache->root.last_gset = gset;
          if ( error )
            goto Exit;
        }
    
        error = FTC_ChunkSet_Lookup_Node( gset, gindex, &node );
        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_GlyphNode_Ref   ( node );
          FTC_Manager_Compress( manager );
          FTC_GlyphNode_Unref ( node );
        }
    
        *aglyph = ((FTC_SBitChunk)node)->ft_glyph;
    
      Exit:
        return error;
      }