source: trunk/poppler/freetype-2.1.10/src/sfnt/ttsbit0.c @ 2

Last change on this file since 2 was 2, checked in by Eugene Romanenko, 15 years ago

First import

File size: 24.4 KB
Line 
1/***************************************************************************/
2/*                                                                         */
3/*  ttsbit0.c                                                              */
4/*                                                                         */
5/*    TrueType and OpenType embedded bitmap support (body).                */
6/*    This is a heap-optimized version.                                    */
7/*                                                                         */
8/*  Copyright 2005 by                                                      */
9/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
10/*                                                                         */
11/*  This file is part of the FreeType project, and may only be used,       */
12/*  modified, and distributed under the terms of the FreeType project      */
13/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
14/*  this file you indicate that you have read the license and              */
15/*  understand and accept it fully.                                        */
16/*                                                                         */
17/***************************************************************************/
18
19
20#include <ft2build.h>
21#include FT_INTERNAL_DEBUG_H
22#include FT_INTERNAL_STREAM_H
23#include FT_TRUETYPE_TAGS_H
24#include "ttsbit.h"
25
26#include "sferrors.h"
27
28
29  /*************************************************************************/
30  /*                                                                       */
31  /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
32  /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
33  /* messages during execution.                                            */
34  /*                                                                       */
35#undef  FT_COMPONENT
36#define FT_COMPONENT  trace_ttsbit
37
38
39    static const FT_Frame_Field  tt_sbit_line_metrics_fields[] =
40    {
41#undef  FT_STRUCTURE
42#define FT_STRUCTURE  TT_SBit_LineMetricsRec
43
44      /* no FT_FRAME_START */
45        FT_FRAME_CHAR( ascender ),
46        FT_FRAME_CHAR( descender ),
47        FT_FRAME_BYTE( max_width ),
48
49        FT_FRAME_CHAR( caret_slope_numerator ),
50        FT_FRAME_CHAR( caret_slope_denominator ),
51        FT_FRAME_CHAR( caret_offset ),
52
53        FT_FRAME_CHAR( min_origin_SB ),
54        FT_FRAME_CHAR( min_advance_SB ),
55        FT_FRAME_CHAR( max_before_BL ),
56        FT_FRAME_CHAR( min_after_BL ),
57        FT_FRAME_CHAR( pads[0] ),
58        FT_FRAME_CHAR( pads[1] ),
59      FT_FRAME_END
60    };
61
62    static const FT_Frame_Field  tt_strike_start_fields[] =
63    {
64#undef  FT_STRUCTURE
65#define FT_STRUCTURE  TT_SBit_StrikeRec
66
67      /* no FT_FRAME_START */
68        FT_FRAME_ULONG( ranges_offset ),
69        FT_FRAME_SKIP_LONG,
70        FT_FRAME_ULONG( num_ranges ),
71        FT_FRAME_ULONG( color_ref ),
72      FT_FRAME_END
73    };
74
75    static const FT_Frame_Field  tt_strike_end_fields[] =
76    {
77      /* no FT_FRAME_START */
78        FT_FRAME_USHORT( start_glyph ),
79        FT_FRAME_USHORT( end_glyph ),
80        FT_FRAME_BYTE  ( x_ppem ),
81        FT_FRAME_BYTE  ( y_ppem ),
82        FT_FRAME_BYTE  ( bit_depth ),
83        FT_FRAME_CHAR  ( flags ),
84      FT_FRAME_END
85    };
86
87
88  FT_LOCAL_DEF( FT_Error )
89  tt_face_load_sbit_strikes( TT_Face    face,
90                             FT_Stream  stream )
91  {
92    FT_Error   error  = SFNT_Err_Ok;
93    FT_Fixed   version;
94    FT_ULong   num_strikes, table_size;
95    FT_Byte*   p;
96    FT_Byte*   p_limit;
97    FT_UInt    nn, count;
98
99
100    face->sbit_num_strikes = 0;
101
102    /* this table is optional */
103    error = face->goto_table( face, TTAG_EBLC, stream, &table_size );
104    if ( error )
105      error = face->goto_table( face, TTAG_bloc, stream, &table_size );
106    if ( error )
107      goto Exit;
108
109    if ( table_size < 8 )
110    {
111      FT_ERROR(( "%s: table too short!\n", "tt_face_load_sbit_strikes" ));
112      error = SFNT_Err_Invalid_File_Format;
113      goto Exit;
114    }
115
116    if ( FT_FRAME_EXTRACT( table_size, face->sbit_table ) )
117      goto Exit;
118
119    face->sbit_table_size = table_size;
120
121    p       = face->sbit_table;
122    p_limit = p + table_size;
123
124    version     = FT_NEXT_ULONG( p );
125    num_strikes = FT_NEXT_ULONG( p );
126
127    if ( version != 0x00020000UL || num_strikes >= 0x10000UL )
128    {
129      FT_ERROR(( "%s: invalid table version!\n",
130                 "tt_face_load_sbit_strikes" ));
131      error = SFNT_Err_Invalid_File_Format;
132      goto Fail;
133    }
134
135    /*
136     *  Count the number of strikes available in the table.  We are a bit
137     *  paranoid there and don't trust the data.
138     */
139    count = (FT_UInt)num_strikes;
140    if ( 8 +48UL * count > table_size )
141      count = (FT_UInt)( ( p_limit - p ) / 48 );
142
143    face->sbit_num_strikes = count;
144
145    /*
146     *  Now allocate the root array of FT_Bitmap_Size records and
147     *  populate them.  Unfortunately, it isn't possible to indicate bit
148     *  depths in the FT_Bitmap_Size record.  This is a design error.
149     */
150    {
151      FT_Memory  memory  = face->root.stream->memory;
152      FT_UInt    em_size = (FT_UInt) face->header.Units_Per_EM;
153      FT_Short   height  = (FT_Short)( face->horizontal.Ascender -
154                                       face->horizontal.Descender +
155                                       face->horizontal.Line_Gap );
156
157      FT_Short   avgwidth = face->os2.xAvgCharWidth;
158
159
160      if ( FT_NEW_ARRAY( face->root.available_sizes, count ) )
161        goto Fail;
162
163      for ( nn = 0; nn < count; nn++ )
164      {
165        FT_Bitmap_Size*  bsize = face->root.available_sizes + nn;
166        FT_UInt          x_ppem, y_ppem;
167
168
169        x_ppem = p[44];
170        y_ppem = p[45];
171
172        bsize->x_ppem = (FT_Pos)(x_ppem << 6);
173        bsize->y_ppem = (FT_Pos)(y_ppem << 6);
174
175        bsize->height = (FT_Short)( height*y_ppem   + em_size / 2 ) / em_size;
176        bsize->width  = (FT_Short)( avgwidth*y_ppem + em_size / 2 ) / em_size;
177        bsize->size   = bsize->y_ppem;
178
179        p += 48;
180      }
181
182      face->root.face_flags     |= FT_FACE_FLAG_FIXED_SIZES;
183      face->root.num_fixed_sizes = count;
184    }
185
186  Exit:
187    return error;
188
189  Fail:
190    FT_FRAME_RELEASE( face->sbit_table );
191    face->sbit_table_size = 0;
192    goto Exit;
193  }
194
195
196  FT_LOCAL_DEF( void )
197  tt_face_free_sbit_strikes( TT_Face  face )
198  {
199    FT_Stream  stream = face->root.stream;
200
201
202    FT_FRAME_RELEASE( face->sbit_table );
203    face->sbit_table_size  = 0;
204    face->sbit_num_strikes = 0;
205  }
206
207
208  FT_LOCAL_DEF( FT_Error )
209  tt_face_set_sbit_strike( TT_Face    face,
210                           FT_UInt    x_ppem,
211                           FT_UInt    y_ppem,
212                           FT_ULong  *astrike_index )
213  {
214    FT_UInt   nn, count;
215    FT_Byte*  p;
216    FT_Byte*  p_limit;
217
218
219    if ( x_ppem > 255               ||
220         y_ppem < 1 || y_ppem > 255 )
221      return SFNT_Err_Invalid_PPem;
222
223    p       = face->sbit_table + 8;
224    p_limit = p + face->sbit_table_size;
225    count   = face->sbit_num_strikes;
226
227    for ( nn = 0; nn < count; nn++ )
228    {
229      if ( x_ppem == (FT_UInt)p[44] && y_ppem == (FT_UInt)p[45] )
230      {
231        *astrike_index = (FT_ULong)nn;
232        return SFNT_Err_Ok;
233      }
234      p += 48;
235    }
236
237    return SFNT_Err_Invalid_PPem;
238  }
239
240
241  typedef struct
242  {
243    TT_Face          face;
244    FT_Stream        stream;
245    FT_Bitmap*       bitmap;
246    TT_SBit_Metrics  metrics;
247    FT_Bool          metrics_loaded;
248    FT_Bool          bitmap_allocated;
249    FT_Byte          bit_depth;
250
251    FT_ULong         ebdt_start;
252    FT_ULong         ebdt_size;
253
254    FT_ULong         strike_index_array;
255    FT_ULong         strike_index_count;
256    FT_Byte*         eblc_base;
257    FT_Byte*         eblc_limit;
258
259  } TT_SBitDecoderRec, *TT_SBitDecoder;
260
261
262  static FT_Error
263  tt_sbit_decoder_init( TT_SBitDecoder       decoder,
264                        TT_Face              face,
265                        FT_ULong             strike_index,
266                        TT_SBit_MetricsRec*  metrics )
267  {
268    FT_Error   error;
269    FT_Stream  stream     = face->root.stream;
270    FT_ULong   ebdt_size;
271
272
273    error = face->goto_table( face, TTAG_EBDT, stream, &ebdt_size );
274    if ( error )
275      error = face->goto_table( face, TTAG_bdat, stream, &ebdt_size );
276    if ( error )
277      goto Exit;
278
279    decoder->face    = face;
280    decoder->stream  = stream;
281    decoder->bitmap  = &face->root.glyph->bitmap;
282    decoder->metrics = metrics;
283
284    decoder->metrics_loaded   = 0;
285    decoder->bitmap_allocated = 0;
286
287    decoder->ebdt_start = FT_STREAM_POS();
288    decoder->ebdt_size  = ebdt_size;
289
290    decoder->eblc_base  = face->sbit_table;
291    decoder->eblc_limit = face->sbit_table + face->sbit_table_size;
292
293    /* now find the strike corresponding to the index */
294    {
295      FT_Byte*  p = decoder->eblc_base + 8 + 48 * strike_index;
296
297
298      decoder->strike_index_array = FT_NEXT_ULONG( p );
299      p                          += 4;
300      decoder->strike_index_count = FT_NEXT_ULONG( p );
301      p                          += 34;
302      decoder->bit_depth          = *p;
303    }
304
305  Exit:
306    return error;
307  }
308
309
310  static void
311  tt_sbit_decoder_done( TT_SBitDecoder  decoder )
312  {
313    FT_UNUSED( decoder );
314  }
315
316
317  static FT_Error
318  tt_sbit_decoder_alloc_bitmap( TT_SBitDecoder  decoder )
319  {
320    FT_Error    error = SFNT_Err_Ok;
321    FT_UInt     width, height;
322    FT_Bitmap*  map = decoder->bitmap;
323    FT_Long     size;
324
325
326    if ( !decoder->metrics_loaded )
327    {
328      error = SFNT_Err_Invalid_Argument;
329      goto Exit;
330    }
331
332    width  = decoder->metrics->width;
333    height = decoder->metrics->height;
334
335    map->width = (int)width;
336    map->rows  = (int)height;
337
338    switch ( decoder->bit_depth )
339    {
340    case 1:
341      map->pixel_mode = FT_PIXEL_MODE_MONO;
342      map->pitch      = ( map->width + 7 ) >> 3;
343      break;
344
345    case 2:
346      map->pixel_mode = FT_PIXEL_MODE_GRAY2;
347      map->pitch      = ( map->width + 3 ) >> 2;
348      break;
349
350    case 4:
351      map->pixel_mode = FT_PIXEL_MODE_GRAY4;
352      map->pitch      = ( map->width + 1 ) >> 1;
353      break;
354
355    case 8:
356      map->pixel_mode = FT_PIXEL_MODE_GRAY;
357      map->pitch      = map->width;
358      break;
359
360    default:
361      error = SFNT_Err_Invalid_File_Format;
362      goto Exit;
363    }
364
365    size = map->rows * map->pitch;
366
367    /* check that there is no empty image */
368    if ( size == 0 )
369      goto Exit;     /* exit successfully! */
370
371    error = ft_glyphslot_alloc_bitmap( decoder->face->root.glyph, size );
372    if ( error )
373      goto Exit;
374
375    decoder->bitmap_allocated = 1;
376
377  Exit:
378    return error;
379  }
380
381
382  static FT_Error
383  tt_sbit_decoder_load_metrics( TT_SBitDecoder  decoder,
384                                FT_Byte*       *pp,
385                                FT_Byte*        limit,
386                                FT_Bool         big )
387  {
388    FT_Byte*         p       = *pp;
389    TT_SBit_Metrics  metrics = decoder->metrics;
390
391
392    if ( p + 5 > limit )
393      goto Fail;
394
395    if ( !decoder->metrics_loaded )
396    {
397      metrics->height       = p[0];
398      metrics->width        = p[1];
399      metrics->horiBearingX = (FT_Char)p[2];
400      metrics->horiBearingY = (FT_Char)p[3];
401      metrics->horiAdvance  = p[4];
402    }
403
404    p += 5;
405    if ( big )
406    {
407      if ( p + 3 > limit )
408        goto Fail;
409
410      if ( !decoder->metrics_loaded )
411      {
412        metrics->vertBearingX = (FT_Char)p[0];
413        metrics->vertBearingY = (FT_Char)p[1];
414        metrics->vertAdvance  = p[2];
415      }
416
417      p += 3;
418    }
419
420    decoder->metrics_loaded = 1;
421    *pp = p;
422    return 0;
423
424  Fail:
425    return SFNT_Err_Invalid_Argument;
426  }
427
428
429  /* forward declaration */
430  static FT_Error
431  tt_sbit_decoder_load_image( TT_SBitDecoder  decoder,
432                              FT_UInt         glyph_index,
433                              FT_Int          x_pos,
434                              FT_Int          y_pos );
435
436  typedef FT_Error  (*TT_SBitDecoder_LoadFunc)( TT_SBitDecoder  decoder,
437                                                FT_Byte*        p,
438                                                FT_Byte*        plimit,
439                                                FT_Int          x_pos,
440                                                FT_Int          y_pos );
441
442
443  static FT_Error
444  tt_sbit_decoder_load_byte_aligned( TT_SBitDecoder  decoder,
445                                     FT_Byte*        p,
446                                     FT_Byte*        limit,
447                                     FT_Int          x_pos,
448                                     FT_Int          y_pos )
449  {
450    FT_Error    error = SFNT_Err_Ok;
451    FT_Byte*    line;
452    FT_Int      bit_height, bit_width, pitch, width, height, h;
453    FT_Bitmap*  bitmap;
454
455
456    if ( !decoder->bitmap_allocated )
457    {
458      error = tt_sbit_decoder_alloc_bitmap( decoder );
459      if ( error )
460        goto Exit;
461    }
462
463    /* check that we can write the glyph into the bitmap */
464    bitmap     = decoder->bitmap;
465    bit_width  = bitmap->width;
466    bit_height = bitmap->rows;
467    pitch      = bitmap->pitch;
468    line       = bitmap->buffer;
469
470    width  = decoder->metrics->width;
471    height = decoder->metrics->height;
472
473    if ( x_pos < 0 || x_pos + width > bit_width   ||
474         y_pos < 0 || y_pos + height > bit_height )
475    {
476      error = SFNT_Err_Invalid_File_Format;
477      goto Exit;
478    }
479
480    if ( p + ( ( width + 7 ) >> 3 ) * height > limit )
481    {
482      error = SFNT_Err_Invalid_File_Format;
483      goto Exit;
484    }
485
486    /* now do the blit */
487    line  += y_pos * pitch + ( x_pos >> 3 );
488    x_pos &= 7;
489
490    if ( x_pos == 0 )  /* the easy one */
491    {
492      for ( h = height; h > 0; h--, line += pitch )
493      {
494        FT_Byte*  write = line;
495        FT_Int    w;
496
497
498        for ( w = width; w >= 8; w -= 8 )
499        {
500          write[0] = (FT_Byte)( write[0] | *p++ );
501          write   += 1;
502        }
503
504        if ( w > 0 )
505          write[0] = (FT_Byte)( write[0] | ( *p++ & ( 0xFF00U >> w ) ) );
506      }
507    }
508    else  /* x_pos > 0 */
509    {
510      for ( h = height; h > 0; h--, line += pitch )
511      {
512        FT_Byte*  write = line;
513        FT_Int    w;
514        FT_UInt   wval = 0;
515
516
517        for ( w = width; w >= 8; w -= 8 )
518        {
519          wval      = (FT_UInt)( wval | *p++ );
520          write[0]  = (FT_Byte)( write[0] | ( wval >> x_pos ) );
521          write    += 1;
522          wval    <<= 8;
523        }
524
525        if ( w > 0 )
526          wval = (FT_UInt)(wval | ( *p++ & ( 0xFF00U >> w ) ) );
527
528        write[0] = (FT_Byte)( write[0] | ( wval >> x_pos ) );
529      }
530    }
531
532  Exit:
533    return error;
534  }
535
536
537  static FT_Error
538  tt_sbit_decoder_load_bit_aligned( TT_SBitDecoder  decoder,
539                                    FT_Byte*        p,
540                                    FT_Byte*        limit,
541                                    FT_Int          x_pos,
542                                    FT_Int          y_pos )
543  {
544    FT_Error    error = SFNT_Err_Ok;
545    FT_Byte*    line;
546    FT_Int      bit_height, bit_width, pitch, width, height, h;
547    FT_Bitmap*  bitmap;
548    FT_UInt32   rval;
549
550
551    if ( !decoder->bitmap_allocated )
552    {
553      error = tt_sbit_decoder_alloc_bitmap( decoder );
554      if ( error )
555        goto Exit;
556    }
557
558    /* check that we can write the glyph into the bitmap */
559    bitmap     = decoder->bitmap;
560    bit_width  = bitmap->width;
561    bit_height = bitmap->rows;
562    pitch      = bitmap->pitch;
563    line       = bitmap->buffer;
564
565    width  = decoder->metrics->width;
566    height = decoder->metrics->height;
567
568    if ( x_pos < 0 || x_pos + width  > bit_width  ||
569         y_pos < 0 || y_pos + height > bit_height )
570    {
571      error = SFNT_Err_Invalid_File_Format;
572      goto Exit;
573    }
574
575    if ( p + ( ( width + 7 ) >> 3 ) * height > limit )
576    {
577      error = SFNT_Err_Invalid_File_Format;
578      goto Exit;
579    }
580
581    /* now do the blit */
582    line  += y_pos * pitch + ( x_pos >> 3 );
583    x_pos &= 7;
584    rval   = 0x10000UL;
585
586    for ( h = height; h > 0; h--, line += pitch )
587    {
588      FT_Byte*   write = line;
589      FT_UInt32  wval  = 0x100 << x_pos;
590      FT_Int     w;
591
592
593      for ( w = width; w >= 8; w -= 8 )
594      {
595        if ( rval & 0x10000UL )
596          rval = 0x100 | *p++;
597
598        wval |= rval & 0x80;
599
600        wval <<= 1;
601        rval <<= 1;
602
603        if ( wval & 0x10000UL )
604        {
605          write[0] = (FT_Byte)( write[0] | ( wval >> 8 ) );
606          write   += 1;
607          wval     = 0x100;
608        }
609      }
610
611      if ( wval != 0x100 )
612      {
613        while ( wval > 0x1FF )
614          wval >>= 1;
615
616        write[0] = (FT_Byte)( write[0] | wval );
617      }
618    }
619
620  Exit:
621    return error;
622  }
623
624
625  static FT_Error
626  tt_sbit_decoder_load_compound( TT_SBitDecoder  decoder,
627                                 FT_Byte*        p,
628                                 FT_Byte*        limit,
629                                 FT_Int          x_pos,
630                                 FT_Int          y_pos )
631  {
632    FT_Error  error = SFNT_Err_Ok;
633    FT_UInt   num_components, nn;
634
635
636    if ( p + 2 > limit )
637      goto Fail;
638
639    num_components = FT_NEXT_USHORT( p );
640    if ( p + 4 * num_components > limit )
641      goto Fail;
642
643    for ( nn = 0; nn < num_components; nn++ )
644    {
645      FT_UInt   gindex = FT_NEXT_USHORT( p );
646      FT_Byte   dx     = FT_NEXT_BYTE( p );
647      FT_Byte   dy     = FT_NEXT_BYTE( p );
648
649
650      /* NB: a recursive call */
651      error = tt_sbit_decoder_load_image( decoder, gindex,
652                                          x_pos + dx, y_pos + dy );
653      if ( error )
654        break;
655    }
656
657  Exit:
658    return error;
659
660  Fail:
661    error = SFNT_Err_Invalid_File_Format;
662    goto Exit;
663  }
664
665
666  static FT_Error
667  tt_sbit_decoder_load_bitmap( TT_SBitDecoder  decoder,
668                               FT_UInt         glyph_format,
669                               FT_ULong        glyph_start,
670                               FT_ULong        glyph_size,
671                               FT_Int          x_pos,
672                               FT_Int          y_pos )
673  {
674    FT_Error   error;
675    FT_Stream  stream = decoder->stream;
676    FT_Byte*   p;
677    FT_Byte*   p_limit;
678    FT_Byte*   data;
679
680
681    /* seek into the EBDT table now */
682    if ( glyph_start + glyph_size > decoder->ebdt_size )
683    {
684      error = SFNT_Err_Invalid_Argument;
685      goto Exit;
686    }
687
688    if ( FT_STREAM_SEEK( decoder->ebdt_start + glyph_start ) ||
689         FT_FRAME_EXTRACT( glyph_size, data )                )
690      goto Exit;
691
692    p       = data;
693    p_limit = p + glyph_size;
694
695    /* read the data, depending on the glyph format */
696    switch ( glyph_format )
697    {
698    case 1:
699    case 2:
700    case 8:
701      error = tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 0 );
702      break;
703
704    case 6:
705    case 7:
706    case 9:
707      error = tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 );
708      break;
709
710    default:
711      error = SFNT_Err_Ok;
712    }
713
714    if ( error )
715      goto Fail;
716
717    {
718      TT_SBitDecoder_LoadFunc  loader;
719
720
721      switch ( glyph_format )
722      {
723      case 1:
724      case 6:
725        loader = tt_sbit_decoder_load_byte_aligned;
726        break;
727
728      case 2:
729      case 5:
730      case 7:
731        loader = tt_sbit_decoder_load_bit_aligned;
732        break;
733
734      case 8:
735        if ( p + 1 > p_limit )
736          goto Fail;
737
738        p += 1;  /* skip padding */
739        /* fall-through */
740
741      case 9:
742        loader = tt_sbit_decoder_load_compound;
743        break;
744
745      default:
746        goto Fail;
747      }
748
749      error = loader( decoder, p, p_limit, x_pos, y_pos );
750    }
751
752  Fail:
753    FT_FRAME_RELEASE( data );
754
755  Exit:
756    return error;
757  }
758
759
760  static FT_Error
761  tt_sbit_decoder_load_image( TT_SBitDecoder  decoder,
762                              FT_UInt         glyph_index,
763                              FT_Int          x_pos,
764                              FT_Int          y_pos )
765  {
766    /*
767     *  First, we find the correct strike range that applies to this
768     *  glyph index.
769     */
770
771    FT_Byte*  p          = decoder->eblc_base + decoder->strike_index_array;
772    FT_Byte*  p_limit    = decoder->eblc_limit;
773    FT_ULong  num_ranges = decoder->strike_index_count;
774    FT_UInt   start, end, index_format, image_format;
775    FT_ULong  image_start = 0, image_end = 0, image_offset;
776
777
778    if ( p + 8 * num_ranges > p_limit )
779      goto NoBitmap;
780
781    for ( ; num_ranges > 0; num_ranges-- )
782    {
783      start = FT_NEXT_USHORT( p );
784      end   = FT_NEXT_USHORT( p );
785
786      if ( glyph_index >= start && glyph_index <= end )
787        goto FoundRange;
788
789      p += 4;  /* ignore index offset */
790    }
791    goto NoBitmap;
792
793  FoundRange:
794    image_offset = FT_NEXT_ULONG( p );
795    p = decoder->eblc_base + decoder->strike_index_array + image_offset;
796    if ( p + 8 > p_limit )
797      goto NoBitmap;
798
799    /* now find the glyph's location and extend within the ebdt table */
800    index_format = FT_NEXT_USHORT( p );
801    image_format = FT_NEXT_USHORT( p );
802    image_offset = FT_NEXT_ULONG ( p );
803
804    switch ( index_format )
805    {
806    case 1: /* 4-byte offsets relative to `image_offset' */
807      {
808        p += 4 * ( glyph_index - start );
809        if ( p + 8 > p_limit )
810          goto NoBitmap;
811
812        image_start = FT_NEXT_ULONG( p );
813        image_end   = FT_NEXT_ULONG( p );
814
815        if ( image_start == image_end )  /* missing glyph */
816          goto NoBitmap;
817      }
818      break;
819
820    case 2: /* big metrics, constant image size */
821      {
822        FT_ULong  image_size;
823
824
825        if ( p + 12 > p_limit )
826          goto NoBitmap;
827
828        image_size = FT_NEXT_ULONG( p );
829
830        if ( tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ) )
831          goto NoBitmap;
832
833        image_start = image_offset + image_size * ( glyph_index - start );
834        image_end   = image_start  + image_size;
835      }
836      break;
837
838    case 3: /* 2-byte offsets relative to 'image_offset' */
839      {
840        p += 2 * ( glyph_index - start );
841        if ( p + 4 > p_limit )
842          goto NoBitmap;
843
844        image_start = FT_NEXT_USHORT( p );
845        image_end   = FT_NEXT_USHORT( p );
846
847        if ( image_start == image_end )  /* missing glyph */
848          goto NoBitmap;
849      }
850      break;
851
852    case 4: /* sparse glyph array with (glyph,offset) pairs */
853      {
854        FT_ULong  mm, num_glyphs;
855
856
857        if ( p + 4 > p_limit )
858          goto NoBitmap;
859
860        num_glyphs = FT_NEXT_ULONG( p );
861        if ( p + ( num_glyphs + 1 ) * 4 > p_limit )
862          goto NoBitmap;
863
864        for ( mm = 0; mm < num_glyphs; mm++ )
865        {
866          FT_UInt  gindex = FT_NEXT_USHORT( p );
867
868
869          if ( gindex == glyph_index )
870          {
871            image_start = FT_NEXT_USHORT( p );
872            p          += 2;
873            image_end   = FT_PEEK_USHORT( p );
874            break;
875          }
876          p += 2;
877        }
878
879        if ( mm >= num_glyphs )
880          goto NoBitmap;
881      }
882      break;
883
884    case 5: /* constant metrics with sparse glyph codes */
885      {
886        FT_ULong  image_size, mm, num_glyphs;
887
888
889        if ( p + 16 > p_limit )
890          goto NoBitmap;
891
892        image_size = FT_NEXT_ULONG( p );
893
894        if ( tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ) )
895          goto NoBitmap;
896
897        num_glyphs = FT_NEXT_ULONG( p );
898        if ( p + 2 * num_glyphs > p_limit )
899          goto NoBitmap;
900
901        for ( mm = 0; mm < num_glyphs; mm++ )
902        {
903          FT_UInt  gindex = FT_NEXT_USHORT( p );
904
905
906          if ( gindex == glyph_index )
907            break;
908        }
909
910        if ( mm >= num_glyphs )
911          goto NoBitmap;
912
913        image_start = image_offset + image_size*mm;
914        image_end   = image_start + image_size;
915      }
916      break;
917
918    default:
919      goto NoBitmap;
920    }
921
922    if ( image_start > image_end )
923      goto NoBitmap;
924
925    image_end  -= image_start;
926    image_start = image_offset + image_start;
927
928    return tt_sbit_decoder_load_bitmap( decoder,
929                                        image_format,
930                                        image_start,
931                                        image_end,
932                                        x_pos,
933                                        y_pos );
934
935  NoBitmap:
936    return SFNT_Err_Invalid_Argument;
937  }
938
939
940  FT_LOCAL( FT_Error )
941  tt_face_load_sbit_image( TT_Face              face,
942                           FT_ULong             strike_index,
943                           FT_UInt              glyph_index,
944                           FT_UInt              load_flags,
945                           FT_Stream            stream,
946                           FT_Bitmap           *map,
947                           TT_SBit_MetricsRec  *metrics )
948  {
949    TT_SBitDecoderRec  decoder[1];
950    FT_Error           error;
951
952    FT_UNUSED( load_flags );
953    FT_UNUSED( stream );
954    FT_UNUSED( map );
955
956
957    error = tt_sbit_decoder_init( decoder, face, strike_index, metrics );
958    if ( !error )
959    {
960      error = tt_sbit_decoder_load_image( decoder, glyph_index, 0, 0 );
961      tt_sbit_decoder_done( decoder );
962    }
963
964    return error;
965  }
966
967/* EOF */
Note: See TracBrowser for help on using the repository browser.