XFA: merge patch from CL 817753002
[pdfium.git] / core / src / fxge / fx_freetype / fxft2.5.01 / src / sfnt / ttsbit.c
1 /***************************************************************************/
2 /*                                                                         */
3 /*  ttsbit.c                                                               */
4 /*                                                                         */
5 /*    TrueType and OpenType embedded bitmap support (body).                */
6 /*                                                                         */
7 /*  Copyright 2005-2009, 2013 by                                           */
8 /*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
9 /*                                                                         */
10 /*  Copyright 2013 by Google, Inc.                                         */
11 /*  Google Author(s): Behdad Esfahbod.                                     */
12 /*                                                                         */
13 /*  This file is part of the FreeType project, and may only be used,       */
14 /*  modified, and distributed under the terms of the FreeType project      */
15 /*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
16 /*  this file you indicate that you have read the license and              */
17 /*  understand and accept it fully.                                        */
18 /*                                                                         */
19 /***************************************************************************/
20
21
22 #include "../../include/ft2build.h"
23 #include "../../include/freetype/internal/ftdebug.h"
24 #include "../../include/freetype/internal/ftstream.h"
25 #include "../../include/freetype/tttags.h"
26 #include "../../include/freetype/ftbitmap.h"
27 #include "ttsbit.h"
28
29 #include "sferrors.h"
30
31 #include "pngshim.h"
32
33
34   /*************************************************************************/
35   /*                                                                       */
36   /* The macro FT_COMPONENT is used in trace mode.  It is an implicit      */
37   /* parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log  */
38   /* messages during execution.                                            */
39   /*                                                                       */
40 #undef  FT_COMPONENT
41 #define FT_COMPONENT  trace_ttsbit
42
43
44   FT_LOCAL_DEF( FT_Error )
45   tt_face_load_eblc( TT_Face    face,
46                      FT_Stream  stream )
47   {
48     FT_Error  error = FT_Err_Ok;
49     FT_Fixed  version;
50     FT_ULong  num_strikes, table_size;
51     FT_Byte*  p;
52     FT_Byte*  p_limit;
53     FT_UInt   count;
54
55
56     face->sbit_num_strikes = 0;
57
58     /* this table is optional */
59     error = face->goto_table( face, TTAG_CBLC, stream, &table_size );
60     if ( error )
61       error = face->goto_table( face, TTAG_EBLC, stream, &table_size );
62     if ( error )
63       error = face->goto_table( face, TTAG_bloc, stream, &table_size );
64     if ( error )
65       goto Exit;
66
67     if ( table_size < 8 )
68     {
69       FT_ERROR(( "tt_face_load_sbit_strikes: table too short\n" ));
70       error = FT_THROW( Invalid_File_Format );
71       goto Exit;
72     }
73
74     if ( FT_FRAME_EXTRACT( table_size, face->sbit_table ) )
75       goto Exit;
76
77     face->sbit_table_size = table_size;
78
79     p       = face->sbit_table;
80     p_limit = p + table_size;
81
82     version     = FT_NEXT_ULONG( p );
83     num_strikes = FT_NEXT_ULONG( p );
84
85     if ( version != 0x00020000UL || num_strikes >= 0x10000UL )
86     {
87       FT_ERROR(( "tt_face_load_sbit_strikes: invalid table version\n" ));
88       error = FT_THROW( Invalid_File_Format );
89       goto Fail;
90     }
91
92     /*
93      *  Count the number of strikes available in the table.  We are a bit
94      *  paranoid there and don't trust the data.
95      */
96     count = (FT_UInt)num_strikes;
97     if ( 8 + 48UL * count > table_size )
98       count = (FT_UInt)( ( p_limit - p ) / 48 );
99
100     face->sbit_num_strikes = count;
101
102     FT_TRACE3(( "sbit_num_strikes: %u\n", count ));
103   Exit:
104     return error;
105
106   Fail:
107     FT_FRAME_RELEASE( face->sbit_table );
108     face->sbit_table_size = 0;
109     goto Exit;
110   }
111
112
113   FT_LOCAL_DEF( void )
114   tt_face_free_eblc( TT_Face  face )
115   {
116     FT_Stream  stream = face->root.stream;
117
118
119     FT_FRAME_RELEASE( face->sbit_table );
120     face->sbit_table_size  = 0;
121     face->sbit_num_strikes = 0;
122   }
123
124
125   FT_LOCAL_DEF( FT_Error )
126   tt_face_set_sbit_strike( TT_Face          face,
127                            FT_Size_Request  req,
128                            FT_ULong*        astrike_index )
129   {
130     return FT_Match_Size( (FT_Face)face, req, 0, astrike_index );
131   }
132
133
134   FT_LOCAL_DEF( FT_Error )
135   tt_face_load_strike_metrics( TT_Face           face,
136                                FT_ULong          strike_index,
137                                FT_Size_Metrics*  metrics )
138   {
139     FT_Byte*  strike;
140
141
142     if ( strike_index >= (FT_ULong)face->sbit_num_strikes )
143       return FT_THROW( Invalid_Argument );
144
145     strike = face->sbit_table + 8 + strike_index * 48;
146
147     metrics->x_ppem = (FT_UShort)strike[44];
148     metrics->y_ppem = (FT_UShort)strike[45];
149
150     metrics->ascender  = (FT_Char)strike[16] << 6;  /* hori.ascender  */
151     metrics->descender = (FT_Char)strike[17] << 6;  /* hori.descender */
152     metrics->height    = metrics->ascender - metrics->descender;
153
154     /* XXX: Is this correct? */
155     metrics->max_advance = ( (FT_Char)strike[22] + /* min_origin_SB  */
156                                       strike[18] + /* max_width      */
157                              (FT_Char)strike[23]   /* min_advance_SB */
158                                                  ) << 6;
159
160     return FT_Err_Ok;
161   }
162
163
164   typedef struct  TT_SBitDecoderRec_
165   {
166     TT_Face          face;
167     FT_Stream        stream;
168     FT_Bitmap*       bitmap;
169     TT_SBit_Metrics  metrics;
170     FT_Bool          metrics_loaded;
171     FT_Bool          bitmap_allocated;
172     FT_Byte          bit_depth;
173
174     FT_ULong         ebdt_start;
175     FT_ULong         ebdt_size;
176
177     FT_ULong         strike_index_array;
178     FT_ULong         strike_index_count;
179     FT_Byte*         eblc_base;
180     FT_Byte*         eblc_limit;
181
182   } TT_SBitDecoderRec, *TT_SBitDecoder;
183
184
185   static FT_Error
186   tt_sbit_decoder_init( TT_SBitDecoder       decoder,
187                         TT_Face              face,
188                         FT_ULong             strike_index,
189                         TT_SBit_MetricsRec*  metrics )
190   {
191     FT_Error   error;
192     FT_Stream  stream = face->root.stream;
193     FT_ULong   ebdt_size;
194
195
196     error = face->goto_table( face, TTAG_CBDT, stream, &ebdt_size );
197     if ( error )
198       error = face->goto_table( face, TTAG_EBDT, stream, &ebdt_size );
199     if ( error )
200       error = face->goto_table( face, TTAG_bdat, stream, &ebdt_size );
201     if ( error )
202       goto Exit;
203
204     decoder->face    = face;
205     decoder->stream  = stream;
206     decoder->bitmap  = &face->root.glyph->bitmap;
207     decoder->metrics = metrics;
208
209     decoder->metrics_loaded   = 0;
210     decoder->bitmap_allocated = 0;
211
212     decoder->ebdt_start = FT_STREAM_POS();
213     decoder->ebdt_size  = ebdt_size;
214
215     decoder->eblc_base  = face->sbit_table;
216     decoder->eblc_limit = face->sbit_table + face->sbit_table_size;
217
218     /* now find the strike corresponding to the index */
219     {
220       FT_Byte*  p;
221
222
223       if ( 8 + 48 * strike_index + 3 * 4 + 34 + 1 > face->sbit_table_size )
224       {
225         error = FT_THROW( Invalid_File_Format );
226         goto Exit;
227       }
228
229       p = decoder->eblc_base + 8 + 48 * strike_index;
230
231       decoder->strike_index_array = FT_NEXT_ULONG( p );
232       p                          += 4;
233       decoder->strike_index_count = FT_NEXT_ULONG( p );
234       p                          += 34;
235       decoder->bit_depth          = *p;
236
237       if ( decoder->strike_index_array > face->sbit_table_size             ||
238            decoder->strike_index_array + 8 * decoder->strike_index_count >
239              face->sbit_table_size                                         )
240         error = FT_THROW( Invalid_File_Format );
241     }
242
243   Exit:
244     return error;
245   }
246
247
248   static void
249   tt_sbit_decoder_done( TT_SBitDecoder  decoder )
250   {
251     FT_UNUSED( decoder );
252   }
253
254
255   static FT_Error
256   tt_sbit_decoder_alloc_bitmap( TT_SBitDecoder  decoder,
257                                 FT_UInt         load_flags )
258   {
259     FT_Error    error = FT_Err_Ok;
260     FT_UInt     width, height;
261     FT_Bitmap*  map = decoder->bitmap;
262     FT_Long     size;
263
264
265     if ( !decoder->metrics_loaded )
266     {
267       error = FT_THROW( Invalid_Argument );
268       goto Exit;
269     }
270
271     width  = decoder->metrics->width;
272     height = decoder->metrics->height;
273
274     map->width = (int)width;
275     map->rows  = (int)height;
276
277     switch ( decoder->bit_depth )
278     {
279     case 1:
280       map->pixel_mode = FT_PIXEL_MODE_MONO;
281       map->pitch      = ( map->width + 7 ) >> 3;
282       map->num_grays  = 2;
283       break;
284
285     case 2:
286       map->pixel_mode = FT_PIXEL_MODE_GRAY2;
287       map->pitch      = ( map->width + 3 ) >> 2;
288       map->num_grays  = 4;
289       break;
290
291     case 4:
292       map->pixel_mode = FT_PIXEL_MODE_GRAY4;
293       map->pitch      = ( map->width + 1 ) >> 1;
294       map->num_grays  = 16;
295       break;
296
297     case 8:
298       map->pixel_mode = FT_PIXEL_MODE_GRAY;
299       map->pitch      = map->width;
300       map->num_grays  = 256;
301       break;
302
303     case 32:
304       if ( load_flags & FT_LOAD_COLOR )
305       {
306         map->pixel_mode = FT_PIXEL_MODE_BGRA;
307         map->pitch      = map->width * 4;
308         map->num_grays  = 256;
309       }
310       else
311       {
312         map->pixel_mode = FT_PIXEL_MODE_GRAY;
313         map->pitch      = map->width;
314         map->num_grays  = 256;
315       }
316       break;
317
318     default:
319       error = FT_THROW( Invalid_File_Format );
320       goto Exit;
321     }
322
323     size = map->rows * map->pitch;
324
325     /* check that there is no empty image */
326     if ( size == 0 )
327       goto Exit;     /* exit successfully! */
328
329     error = ft_glyphslot_alloc_bitmap( decoder->face->root.glyph, size );
330     if ( error )
331       goto Exit;
332
333     decoder->bitmap_allocated = 1;
334
335   Exit:
336     return error;
337   }
338
339
340   static FT_Error
341   tt_sbit_decoder_load_metrics( TT_SBitDecoder  decoder,
342                                 FT_Byte*       *pp,
343                                 FT_Byte*        limit,
344                                 FT_Bool         big )
345   {
346     FT_Byte*         p       = *pp;
347     TT_SBit_Metrics  metrics = decoder->metrics;
348
349
350     if ( p + 5 > limit )
351       goto Fail;
352
353     metrics->height       = p[0];
354     metrics->width        = p[1];
355     metrics->horiBearingX = (FT_Char)p[2];
356     metrics->horiBearingY = (FT_Char)p[3];
357     metrics->horiAdvance  = p[4];
358
359     p += 5;
360     if ( big )
361     {
362       if ( p + 3 > limit )
363         goto Fail;
364
365       metrics->vertBearingX = (FT_Char)p[0];
366       metrics->vertBearingY = (FT_Char)p[1];
367       metrics->vertAdvance  = p[2];
368
369       p += 3;
370     }
371
372     decoder->metrics_loaded = 1;
373     *pp = p;
374     return FT_Err_Ok;
375
376   Fail:
377     FT_TRACE1(( "tt_sbit_decoder_load_metrics: broken table" ));
378     return FT_THROW( Invalid_Argument );
379   }
380
381
382   /* forward declaration */
383   static FT_Error
384   tt_sbit_decoder_load_image( TT_SBitDecoder  decoder,
385                               FT_UInt         load_flags,
386                               FT_UInt         glyph_index,
387                               FT_Int          x_pos,
388                               FT_Int          y_pos );
389
390   typedef FT_Error  (*TT_SBitDecoder_LoadFunc)( TT_SBitDecoder  decoder,
391                                                 FT_UInt         load_flags,
392                                                 FT_Byte*        p,
393                                                 FT_Byte*        plimit,
394                                                 FT_Int          x_pos,
395                                                 FT_Int          y_pos );
396
397
398   static FT_Error
399   tt_sbit_decoder_load_byte_aligned( TT_SBitDecoder  decoder,
400                                      FT_UInt         load_flags,
401                                      FT_Byte*        p,
402                                      FT_Byte*        limit,
403                                      FT_Int          x_pos,
404                                      FT_Int          y_pos )
405   {
406     FT_Error    error = FT_Err_Ok;
407     FT_Byte*    line;
408     FT_Int      bit_height, bit_width, pitch, width, height, line_bits, h;
409     FT_Bitmap*  bitmap;
410
411     FT_UNUSED( load_flags );
412
413
414     /* check that we can write the glyph into the bitmap */
415     bitmap     = decoder->bitmap;
416     bit_width  = bitmap->width;
417     bit_height = bitmap->rows;
418     pitch      = bitmap->pitch;
419     line       = bitmap->buffer;
420
421     width  = decoder->metrics->width;
422     height = decoder->metrics->height;
423
424     line_bits = width * decoder->bit_depth;
425
426     if ( x_pos < 0 || x_pos + width > bit_width   ||
427          y_pos < 0 || y_pos + height > bit_height )
428     {
429       FT_TRACE1(( "tt_sbit_decoder_load_byte_aligned:"
430                   " invalid bitmap dimensions\n" ));
431       error = FT_THROW( Invalid_File_Format );
432       goto Exit;
433     }
434
435     if ( p + ( ( line_bits + 7 ) >> 3 ) * height > limit )
436     {
437       FT_TRACE1(( "tt_sbit_decoder_load_byte_aligned: broken bitmap\n" ));
438       error = FT_THROW( Invalid_File_Format );
439       goto Exit;
440     }
441
442     /* now do the blit */
443     line  += y_pos * pitch + ( x_pos >> 3 );
444     x_pos &= 7;
445
446     if ( x_pos == 0 )  /* the easy one */
447     {
448       for ( h = height; h > 0; h--, line += pitch )
449       {
450         FT_Byte*  pwrite = line;
451         FT_Int    w;
452
453
454         for ( w = line_bits; w >= 8; w -= 8 )
455         {
456           pwrite[0] = (FT_Byte)( pwrite[0] | *p++ );
457           pwrite   += 1;
458         }
459
460         if ( w > 0 )
461           pwrite[0] = (FT_Byte)( pwrite[0] | ( *p++ & ( 0xFF00U >> w ) ) );
462       }
463     }
464     else  /* x_pos > 0 */
465     {
466       for ( h = height; h > 0; h--, line += pitch )
467       {
468         FT_Byte*  pwrite = line;
469         FT_Int    w;
470         FT_UInt   wval = 0;
471
472
473         for ( w = line_bits; w >= 8; w -= 8 )
474         {
475           wval       = (FT_UInt)( wval | *p++ );
476           pwrite[0]  = (FT_Byte)( pwrite[0] | ( wval >> x_pos ) );
477           pwrite    += 1;
478           wval     <<= 8;
479         }
480
481         if ( w > 0 )
482           wval = (FT_UInt)( wval | ( *p++ & ( 0xFF00U >> w ) ) );
483
484         /* all bits read and there are `x_pos + w' bits to be written */
485
486         pwrite[0] = (FT_Byte)( pwrite[0] | ( wval >> x_pos ) );
487
488         if ( x_pos + w > 8 )
489         {
490           pwrite++;
491           wval     <<= 8;
492           pwrite[0]  = (FT_Byte)( pwrite[0] | ( wval >> x_pos ) );
493         }
494       }
495     }
496
497   Exit:
498     if ( !error )
499       FT_TRACE3(( "tt_sbit_decoder_load_byte_aligned: loaded\n" ));
500     return error;
501   }
502
503
504   /*
505    * Load a bit-aligned bitmap (with pointer `p') into a line-aligned bitmap
506    * (with pointer `pwrite').  In the example below, the width is 3 pixel,
507    * and `x_pos' is 1 pixel.
508    *
509    *       p                               p+1
510    *     |                               |                               |
511    *     | 7   6   5   4   3   2   1   0 | 7   6   5   4   3   2   1   0 |...
512    *     |                               |                               |
513    *       +-------+   +-------+   +-------+ ...
514    *           .           .           .
515    *           .           .           .
516    *           v           .           .
517    *       +-------+       .           .
518    * |                               | .
519    * | 7   6   5   4   3   2   1   0 | .
520    * |                               | .
521    *   pwrite              .           .
522    *                       .           .
523    *                       v           .
524    *                   +-------+       .
525    *             |                               |
526    *             | 7   6   5   4   3   2   1   0 |
527    *             |                               |
528    *               pwrite+1            .
529    *                                   .
530    *                                   v
531    *                               +-------+
532    *                         |                               |
533    *                         | 7   6   5   4   3   2   1   0 |
534    *                         |                               |
535    *                           pwrite+2
536    *
537    */
538
539   static FT_Error
540   tt_sbit_decoder_load_bit_aligned( TT_SBitDecoder  decoder,
541                                     FT_UInt         load_flags,
542                                     FT_Byte*        p,
543                                     FT_Byte*        limit,
544                                     FT_Int          x_pos,
545                                     FT_Int          y_pos )
546   {
547     FT_Error    error = FT_Err_Ok;
548     FT_Byte*    line;
549     FT_Int      bit_height, bit_width, pitch, width, height, line_bits, h, nbits;
550     FT_Bitmap*  bitmap;
551     FT_UShort   rval;
552
553     FT_UNUSED( load_flags );
554
555
556     /* check that we can write the glyph into the bitmap */
557     bitmap     = decoder->bitmap;
558     bit_width  = bitmap->width;
559     bit_height = bitmap->rows;
560     pitch      = bitmap->pitch;
561     line       = bitmap->buffer;
562
563     width  = decoder->metrics->width;
564     height = decoder->metrics->height;
565
566     line_bits = width * decoder->bit_depth;
567
568     if ( x_pos < 0 || x_pos + width  > bit_width  ||
569          y_pos < 0 || y_pos + height > bit_height )
570     {
571       FT_TRACE1(( "tt_sbit_decoder_load_bit_aligned:"
572                   " invalid bitmap dimensions\n" ));
573       error = FT_THROW( Invalid_File_Format );
574       goto Exit;
575     }
576
577     if ( p + ( ( line_bits * height + 7 ) >> 3 ) > limit )
578     {
579       FT_TRACE1(( "tt_sbit_decoder_load_bit_aligned: broken bitmap\n" ));
580       error = FT_THROW( Invalid_File_Format );
581       goto Exit;
582     }
583
584     /* now do the blit */
585
586     /* adjust `line' to point to the first byte of the bitmap */
587     line  += y_pos * pitch + ( x_pos >> 3 );
588     x_pos &= 7;
589
590     /* the higher byte of `rval' is used as a buffer */
591     rval  = 0;
592     nbits = 0;
593
594     for ( h = height; h > 0; h--, line += pitch )
595     {
596       FT_Byte*  pwrite = line;
597       FT_Int    w      = line_bits;
598
599
600       /* handle initial byte (in target bitmap) specially if necessary */
601       if ( x_pos )
602       {
603         w = ( line_bits < 8 - x_pos ) ? line_bits : 8 - x_pos;
604
605         if ( h == height )
606         {
607           rval  = *p++;
608           nbits = x_pos;
609         }
610         else if ( nbits < w )
611         {
612           if ( p < limit )
613             rval |= *p++;
614           nbits += 8 - w;
615         }
616         else
617         {
618           rval  >>= 8;
619           nbits  -= w;
620         }
621
622         *pwrite++ |= ( ( rval >> nbits ) & 0xFF ) &
623                      ( ~( 0xFF << w ) << ( 8 - w - x_pos ) );
624         rval     <<= 8;
625
626         w = line_bits - w;
627       }
628
629       /* handle medial bytes */
630       for ( ; w >= 8; w -= 8 )
631       {
632         rval      |= *p++;
633         *pwrite++ |= ( rval >> nbits ) & 0xFF;
634
635         rval <<= 8;
636       }
637
638       /* handle final byte if necessary */
639       if ( w > 0 )
640       {
641         if ( nbits < w )
642         {
643           if ( p < limit )
644             rval |= *p++;
645           *pwrite |= ( ( rval >> nbits ) & 0xFF ) & ( 0xFF00U >> w );
646           nbits   += 8 - w;
647
648           rval <<= 8;
649         }
650         else
651         {
652           *pwrite |= ( ( rval >> nbits ) & 0xFF ) & ( 0xFF00U >> w );
653           nbits   -= w;
654         }
655       }
656     }
657
658   Exit:
659     if ( !error )
660       FT_TRACE3(( "tt_sbit_decoder_load_bit_aligned: loaded\n" ));
661     return error;
662   }
663
664
665   static FT_Error
666   tt_sbit_decoder_load_compound( TT_SBitDecoder  decoder,
667                                  FT_UInt         load_flags,
668                                  FT_Byte*        p,
669                                  FT_Byte*        limit,
670                                  FT_Int          x_pos,
671                                  FT_Int          y_pos )
672   {
673     FT_Error  error = FT_Err_Ok;
674     FT_UInt   num_components, nn;
675
676     FT_Char  horiBearingX = decoder->metrics->horiBearingX;
677     FT_Char  horiBearingY = decoder->metrics->horiBearingY;
678     FT_Byte  horiAdvance  = decoder->metrics->horiAdvance;
679     FT_Char  vertBearingX = decoder->metrics->vertBearingX;
680     FT_Char  vertBearingY = decoder->metrics->vertBearingY;
681     FT_Byte  vertAdvance  = decoder->metrics->vertAdvance;
682
683
684     if ( p + 2 > limit )
685       goto Fail;
686
687     num_components = FT_NEXT_USHORT( p );
688     if ( p + 4 * num_components > limit )
689     {
690       FT_TRACE1(( "tt_sbit_decoder_load_compound: broken table\n" ));
691       goto Fail;
692     }
693
694     FT_TRACE3(( "tt_sbit_decoder_load_compound: loading %d components\n",
695                 num_components ));
696
697     for ( nn = 0; nn < num_components; nn++ )
698     {
699       FT_UInt  gindex = FT_NEXT_USHORT( p );
700       FT_Byte  dx     = FT_NEXT_BYTE( p );
701       FT_Byte  dy     = FT_NEXT_BYTE( p );
702
703
704       /* NB: a recursive call */
705       error = tt_sbit_decoder_load_image( decoder, load_flags, gindex,
706                                           x_pos + dx, y_pos + dy );
707       if ( error )
708         break;
709     }
710
711     FT_TRACE3(( "tt_sbit_decoder_load_compound: done\n" ));
712
713     decoder->metrics->horiBearingX = horiBearingX;
714     decoder->metrics->horiBearingY = horiBearingY;
715     decoder->metrics->horiAdvance  = horiAdvance;
716     decoder->metrics->vertBearingX = vertBearingX;
717     decoder->metrics->vertBearingY = vertBearingY;
718     decoder->metrics->vertAdvance  = vertAdvance;
719     decoder->metrics->width        = (FT_Byte)decoder->bitmap->width;
720     decoder->metrics->height       = (FT_Byte)decoder->bitmap->rows;
721
722   Exit:
723     return error;
724
725   Fail:
726     error = FT_THROW( Invalid_File_Format );
727     goto Exit;
728   }
729
730
731 #ifdef FT_CONFIG_OPTION_USE_PNG
732
733   static FT_Error
734   tt_sbit_decoder_load_png( TT_SBitDecoder  decoder,
735                             FT_UInt         load_flags,
736                             FT_Byte*        p,
737                             FT_Byte*        limit,
738                             FT_Int          x_pos,
739                             FT_Int          y_pos )
740   {
741     FT_Error  error = FT_Err_Ok;
742     FT_ULong  png_len;
743
744     FT_UNUSED( load_flags );
745
746
747     if ( limit - p < 4 )
748     {
749       FT_TRACE1(( "tt_sbit_decoder_load_png: broken bitmap\n" ));
750       error = FT_THROW( Invalid_File_Format );
751       goto Exit;
752     }
753
754     png_len = FT_NEXT_ULONG( p );
755     if ( (FT_ULong)( limit - p ) < png_len )
756     {
757       FT_TRACE1(( "tt_sbit_decoder_load_png: broken bitmap\n" ));
758       error = FT_THROW( Invalid_File_Format );
759       goto Exit;
760     }
761
762     error = Load_SBit_Png( decoder->bitmap,
763                            x_pos,
764                            y_pos,
765                            decoder->bit_depth,
766                            decoder->metrics,
767                            decoder->stream->memory,
768                            p,
769                            png_len );
770
771   Exit:
772     if ( !error )
773       FT_TRACE3(( "tt_sbit_decoder_load_png: loaded\n" ));
774     return error;
775   }
776
777 #endif /* FT_CONFIG_OPTION_USE_PNG */
778
779
780   static FT_Error
781   tt_sbit_decoder_load_bitmap( TT_SBitDecoder  decoder,
782                                FT_UInt         load_flags,
783                                FT_UInt         glyph_format,
784                                FT_ULong        glyph_start,
785                                FT_ULong        glyph_size,
786                                FT_Int          x_pos,
787                                FT_Int          y_pos )
788   {
789     FT_Error   error;
790     FT_Stream  stream = decoder->stream;
791     FT_Byte*   p;
792     FT_Byte*   p_limit;
793     FT_Byte*   data;
794
795
796     /* seek into the EBDT table now */
797     if ( glyph_start + glyph_size > decoder->ebdt_size )
798     {
799       error = FT_THROW( Invalid_Argument );
800       goto Exit;
801     }
802
803     if ( FT_STREAM_SEEK( decoder->ebdt_start + glyph_start ) ||
804          FT_FRAME_EXTRACT( glyph_size, data )                )
805       goto Exit;
806
807     p       = data;
808     p_limit = p + glyph_size;
809
810     /* read the data, depending on the glyph format */
811     switch ( glyph_format )
812     {
813     case 1:
814     case 2:
815     case 8:
816     case 17:
817       error = tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 0 );
818       break;
819
820     case 6:
821     case 7:
822     case 9:
823     case 18:
824       error = tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 );
825       break;
826
827     default:
828       error = FT_Err_Ok;
829     }
830
831     if ( error )
832       goto Fail;
833
834     {
835       TT_SBitDecoder_LoadFunc  loader;
836
837
838       switch ( glyph_format )
839       {
840       case 1:
841       case 6:
842         loader = tt_sbit_decoder_load_byte_aligned;
843         break;
844
845       case 2:
846       case 5:
847       case 7:
848         loader = tt_sbit_decoder_load_bit_aligned;
849         break;
850
851       case 8:
852         if ( p + 1 > p_limit )
853           goto Fail;
854
855         p += 1;  /* skip padding */
856         /* fall-through */
857
858       case 9:
859         loader = tt_sbit_decoder_load_compound;
860         break;
861
862 #ifdef FT_CONFIG_OPTION_USE_PNG
863       case 17: /* small metrics, PNG image data   */
864       case 18: /* big metrics, PNG image data     */
865       case 19: /* metrics in EBLC, PNG image data */
866         loader = tt_sbit_decoder_load_png;
867         break;
868 #endif /* FT_CONFIG_OPTION_USE_PNG */
869
870       default:
871         error = FT_THROW( Invalid_Table );
872         goto Fail;
873       }
874
875       if ( !decoder->bitmap_allocated )
876       {
877         error = tt_sbit_decoder_alloc_bitmap( decoder, load_flags );
878         if ( error )
879           goto Fail;
880       }
881
882       if ( decoder->bit_depth == 32                          &&
883            decoder->bitmap->pixel_mode != FT_PIXEL_MODE_BGRA )
884       {
885         /* Flatten color bitmaps if color was not requested. */
886
887         FT_Library library = decoder->face->root.glyph->library;
888         FT_Memory  memory  = decoder->stream->memory;
889
890         FT_Bitmap color, *orig;
891
892
893         if ( decoder->bitmap->pixel_mode != FT_PIXEL_MODE_GRAY ||
894              x_pos != 0 || y_pos != 0                          )
895         {
896           /* Shouldn't happen. */
897           error = FT_THROW( Invalid_Table );
898           goto Fail;
899         }
900
901         FT_Bitmap_New( &color );
902
903         color.rows       = decoder->bitmap->rows;
904         color.width      = decoder->bitmap->width;
905         color.pitch      = color.width * 4;
906         color.pixel_mode = FT_PIXEL_MODE_BGRA;
907
908         if ( FT_ALLOC( color.buffer, color.rows * color.pitch ) )
909           goto Fail;
910
911         orig            = decoder->bitmap;
912         decoder->bitmap = &color;
913
914         error = loader( decoder, load_flags, p, p_limit, x_pos, y_pos );
915
916         decoder->bitmap = orig;
917
918         /* explicitly test against FT_Err_Ok to avoid compiler warnings */
919         /* (we do an assignment within a conditional)                   */
920         if ( error                                           ||
921              ( error = FT_Bitmap_Convert( library,
922                                           &color,
923                                           decoder->bitmap,
924                                           1 ) ) != FT_Err_Ok )
925         {
926           FT_Bitmap_Done( library, &color );
927           goto Fail;
928         }
929
930         FT_Bitmap_Done( library, &color );
931       }
932
933       else
934         error = loader( decoder, load_flags, p, p_limit, x_pos, y_pos );
935     }
936
937   Fail:
938     FT_FRAME_RELEASE( data );
939
940   Exit:
941     return error;
942   }
943
944
945   static FT_Error
946   tt_sbit_decoder_load_image( TT_SBitDecoder  decoder,
947                               FT_UInt         load_flags,
948                               FT_UInt         glyph_index,
949                               FT_Int          x_pos,
950                               FT_Int          y_pos )
951   {
952     /*
953      *  First, we find the correct strike range that applies to this
954      *  glyph index.
955      */
956
957     FT_Byte*  p          = decoder->eblc_base + decoder->strike_index_array;
958     FT_Byte*  p_limit    = decoder->eblc_limit;
959     FT_ULong  num_ranges = decoder->strike_index_count;
960     FT_UInt   start, end, index_format, image_format;
961     FT_ULong  image_start = 0, image_end = 0, image_offset;
962
963
964     for ( ; num_ranges > 0; num_ranges-- )
965     {
966       start = FT_NEXT_USHORT( p );
967       end   = FT_NEXT_USHORT( p );
968
969       if ( glyph_index >= start && glyph_index <= end )
970         goto FoundRange;
971
972       p += 4;  /* ignore index offset */
973     }
974     goto NoBitmap;
975
976   FoundRange:
977     image_offset = FT_NEXT_ULONG( p );
978
979     /* overflow check */
980     p = decoder->eblc_base + decoder->strike_index_array;
981     if ( image_offset > (FT_ULong)( p_limit - p ) )
982       goto Failure;
983
984     p += image_offset;
985     if ( p + 8 > p_limit )
986       goto NoBitmap;
987
988     /* now find the glyph's location and extend within the ebdt table */
989     index_format = FT_NEXT_USHORT( p );
990     image_format = FT_NEXT_USHORT( p );
991     image_offset = FT_NEXT_ULONG ( p );
992
993     switch ( index_format )
994     {
995     case 1: /* 4-byte offsets relative to `image_offset' */
996       {
997         p += 4 * ( glyph_index - start );
998         if ( p + 8 > p_limit )
999           goto NoBitmap;
1000
1001         image_start = FT_NEXT_ULONG( p );
1002         image_end   = FT_NEXT_ULONG( p );
1003
1004         if ( image_start == image_end )  /* missing glyph */
1005           goto NoBitmap;
1006       }
1007       break;
1008
1009     case 2: /* big metrics, constant image size */
1010       {
1011         FT_ULong  image_size;
1012
1013
1014         if ( p + 12 > p_limit )
1015           goto NoBitmap;
1016
1017         image_size = FT_NEXT_ULONG( p );
1018
1019         if ( tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ) )
1020           goto NoBitmap;
1021
1022         image_start = image_size * ( glyph_index - start );
1023         image_end   = image_start + image_size;
1024       }
1025       break;
1026
1027     case 3: /* 2-byte offsets relative to 'image_offset' */
1028       {
1029         p += 2 * ( glyph_index - start );
1030         if ( p + 4 > p_limit )
1031           goto NoBitmap;
1032
1033         image_start = FT_NEXT_USHORT( p );
1034         image_end   = FT_NEXT_USHORT( p );
1035
1036         if ( image_start == image_end )  /* missing glyph */
1037           goto NoBitmap;
1038       }
1039       break;
1040
1041     case 4: /* sparse glyph array with (glyph,offset) pairs */
1042       {
1043         FT_ULong  mm, num_glyphs;
1044
1045
1046         if ( p + 4 > p_limit )
1047           goto NoBitmap;
1048
1049         num_glyphs = FT_NEXT_ULONG( p );
1050
1051         /* overflow check for p + ( num_glyphs + 1 ) * 4 */
1052         if ( num_glyphs > (FT_ULong)( ( ( p_limit - p ) >> 2 ) - 1 ) )
1053           goto NoBitmap;
1054
1055         for ( mm = 0; mm < num_glyphs; mm++ )
1056         {
1057           FT_UInt  gindex = FT_NEXT_USHORT( p );
1058
1059
1060           if ( gindex == glyph_index )
1061           {
1062             image_start = FT_NEXT_USHORT( p );
1063             p          += 2;
1064             image_end   = FT_PEEK_USHORT( p );
1065             break;
1066           }
1067           p += 2;
1068         }
1069
1070         if ( mm >= num_glyphs )
1071           goto NoBitmap;
1072       }
1073       break;
1074
1075     case 5: /* constant metrics with sparse glyph codes */
1076     case 19:
1077       {
1078         FT_ULong  image_size, mm, num_glyphs;
1079
1080
1081         if ( p + 16 > p_limit )
1082           goto NoBitmap;
1083
1084         image_size = FT_NEXT_ULONG( p );
1085
1086         if ( tt_sbit_decoder_load_metrics( decoder, &p, p_limit, 1 ) )
1087           goto NoBitmap;
1088
1089         num_glyphs = FT_NEXT_ULONG( p );
1090
1091         /* overflow check for p + 2 * num_glyphs */
1092         if ( num_glyphs > (FT_ULong)( ( p_limit - p ) >> 1 ) )
1093           goto NoBitmap;
1094
1095         for ( mm = 0; mm < num_glyphs; mm++ )
1096         {
1097           FT_UInt  gindex = FT_NEXT_USHORT( p );
1098
1099
1100           if ( gindex == glyph_index )
1101             break;
1102         }
1103
1104         if ( mm >= num_glyphs )
1105           goto NoBitmap;
1106
1107         image_start = image_size * mm;
1108         image_end   = image_start + image_size;
1109       }
1110       break;
1111
1112     default:
1113       goto NoBitmap;
1114     }
1115
1116     if ( image_start > image_end )
1117       goto NoBitmap;
1118
1119     image_end  -= image_start;
1120     image_start = image_offset + image_start;
1121
1122     FT_TRACE3(( "tt_sbit_decoder_load_image:"
1123                 " found sbit (format %d) for glyph index %d\n",
1124                 image_format, glyph_index ));
1125
1126     return tt_sbit_decoder_load_bitmap( decoder,
1127                                         load_flags,
1128                                         image_format,
1129                                         image_start,
1130                                         image_end,
1131                                         x_pos,
1132                                         y_pos );
1133
1134   Failure:
1135     return FT_THROW( Invalid_Table );
1136
1137   NoBitmap:
1138     FT_TRACE4(( "tt_sbit_decoder_load_image:"
1139                 " no sbit found for glyph index %d\n", glyph_index ));
1140
1141     return FT_THROW( Invalid_Argument );
1142   }
1143
1144
1145   FT_LOCAL( FT_Error )
1146   tt_face_load_sbit_image( TT_Face              face,
1147                            FT_ULong             strike_index,
1148                            FT_UInt              glyph_index,
1149                            FT_UInt              load_flags,
1150                            FT_Stream            stream,
1151                            FT_Bitmap           *map,
1152                            TT_SBit_MetricsRec  *metrics )
1153   {
1154     TT_SBitDecoderRec  decoder[1];
1155     FT_Error           error;
1156
1157     FT_UNUSED( load_flags );
1158     FT_UNUSED( stream );
1159     FT_UNUSED( map );
1160
1161
1162     error = tt_sbit_decoder_init( decoder, face, strike_index, metrics );
1163     if ( !error )
1164     {
1165       error = tt_sbit_decoder_load_image( decoder,
1166                                           load_flags,
1167                                           glyph_index,
1168                                           0,
1169                                           0 );
1170       tt_sbit_decoder_done( decoder );
1171     }
1172
1173     return error;
1174   }
1175
1176
1177 /* EOF */