1 /***************************************************************************/
5 /* FreeType support for .gz compressed files. */
7 /* This optional component relies on zlib. It should mainly be used to */
8 /* parse compressed PCF fonts, as found with many X11 server */
11 /* Copyright 2002, 2003, 2004, 2005, 2006 by */
12 /* David Turner, Robert Wilhelm, and Werner Lemberg. */
14 /* This file is part of the FreeType project, and may only be used, */
15 /* modified, and distributed under the terms of the FreeType project */
16 /* license, LICENSE.TXT. By continuing to use, modify, or distribute */
17 /* this file you indicate that you have read the license and */
18 /* understand and accept it fully. */
20 /***************************************************************************/
24 #include FT_INTERNAL_MEMORY_H
25 #include FT_INTERNAL_STREAM_H
26 #include FT_INTERNAL_DEBUG_H
31 #include FT_MODULE_ERRORS_H
35 #define FT_ERR_PREFIX Gzip_Err_
36 #define FT_ERR_BASE FT_Mod_Err_Gzip
41 #ifdef FT_CONFIG_OPTION_USE_ZLIB
43 #ifdef FT_CONFIG_OPTION_SYSTEM_ZLIB
47 #else /* !FT_CONFIG_OPTION_SYSTEM_ZLIB */
49 /* In this case, we include our own modified sources of the ZLib */
50 /* within the "ftgzip" component. The modifications were necessary */
51 /* to #include all files without conflicts, as well as preventing */
52 /* the definition of "extern" functions that may cause linking */
53 /* conflicts when a program is linked with both FreeType and the */
62 #define SLOW 1 /* we can't use asm-optimized sources here! */
64 /* Urgh. `inflate_mask' must not be declared twice -- C++ doesn't like
65 this. We temporarily disable it and load all necessary header files. */
66 #define NO_INFLATE_MASK
72 #undef NO_INFLATE_MASK
74 /* infutil.c must be included before infcodes.c */
83 #endif /* !FT_CONFIG_OPTION_SYSTEM_ZLIB */
86 /***************************************************************************/
87 /***************************************************************************/
89 /***** Z L I B M E M O R Y M A N A G E M E N T *****/
91 /***************************************************************************/
92 /***************************************************************************/
94 /* it is better to use FreeType memory routines instead of raw
98 ft_gzip_alloc( FT_Memory memory
,
102 FT_ULong sz
= (FT_ULong
)size
* items
;
107 (void)FT_ALLOC( p
, sz
);
113 ft_gzip_free( FT_Memory memory
,
116 FT_MEM_FREE( address
);
120 #ifndef FT_CONFIG_OPTION_SYSTEM_ZLIB
123 zcalloc ( voidpf opaque
,
127 return ft_gzip_alloc( (FT_Memory
)opaque
, items
, size
);
131 zcfree( voidpf opaque
,
134 ft_gzip_free( (FT_Memory
)opaque
, ptr
);
137 #endif /* !SYSTEM_ZLIB */
140 /***************************************************************************/
141 /***************************************************************************/
143 /***** Z L I B F I L E D E S C R I P T O R *****/
145 /***************************************************************************/
146 /***************************************************************************/
148 #define FT_GZIP_BUFFER_SIZE 4096
150 typedef struct FT_GZipFileRec_
152 FT_Stream source
; /* parent/source stream */
153 FT_Stream stream
; /* embedding stream */
154 FT_Memory memory
; /* memory allocator */
155 z_stream zstream
; /* zlib input stream */
157 FT_ULong start
; /* starting position, after .gz header */
158 FT_Byte input
[FT_GZIP_BUFFER_SIZE
]; /* input read buffer */
160 FT_Byte buffer
[FT_GZIP_BUFFER_SIZE
]; /* output buffer */
161 FT_ULong pos
; /* position in output */
165 } FT_GZipFileRec
, *FT_GZipFile
;
169 #define FT_GZIP_ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */
170 #define FT_GZIP_HEAD_CRC 0x02 /* bit 1 set: header CRC present */
171 #define FT_GZIP_EXTRA_FIELD 0x04 /* bit 2 set: extra field present */
172 #define FT_GZIP_ORIG_NAME 0x08 /* bit 3 set: original file name present */
173 #define FT_GZIP_COMMENT 0x10 /* bit 4 set: file comment present */
174 #define FT_GZIP_RESERVED 0xE0 /* bits 5..7: reserved */
177 /* check and skip .gz header - we don't support `transparent' compression */
179 ft_gzip_check_header( FT_Stream stream
)
185 if ( FT_STREAM_SEEK( 0 ) ||
186 FT_STREAM_READ( head
, 4 ) )
189 /* head[0] && head[1] are the magic numbers; */
190 /* head[2] is the method, and head[3] the flags */
191 if ( head
[0] != 0x1f ||
193 head
[2] != Z_DEFLATED
||
194 (head
[3] & FT_GZIP_RESERVED
) )
196 error
= Gzip_Err_Invalid_File_Format
;
200 /* skip time, xflags and os code */
201 (void)FT_STREAM_SKIP( 6 );
203 /* skip the extra field */
204 if ( head
[3] & FT_GZIP_EXTRA_FIELD
)
209 if ( FT_READ_USHORT_LE( len
) ||
210 FT_STREAM_SKIP( len
) )
214 /* skip original file name */
215 if ( head
[3] & FT_GZIP_ORIG_NAME
)
221 if ( FT_READ_BYTE( c
) )
228 /* skip .gz comment */
229 if ( head
[3] & FT_GZIP_COMMENT
)
235 if ( FT_READ_BYTE( c
) )
243 if ( head
[3] & FT_GZIP_HEAD_CRC
)
244 if ( FT_STREAM_SKIP( 2 ) )
253 ft_gzip_file_init( FT_GZipFile zip
,
257 z_stream
* zstream
= &zip
->zstream
;
258 FT_Error error
= Gzip_Err_Ok
;
261 zip
->stream
= stream
;
262 zip
->source
= source
;
263 zip
->memory
= stream
->memory
;
265 zip
->limit
= zip
->buffer
+ FT_GZIP_BUFFER_SIZE
;
266 zip
->cursor
= zip
->limit
;
269 /* check and skip .gz header */
273 error
= ft_gzip_check_header( stream
);
277 zip
->start
= FT_STREAM_POS();
280 /* initialize zlib -- there is no zlib header in the compressed stream */
281 zstream
->zalloc
= (alloc_func
)ft_gzip_alloc
;
282 zstream
->zfree
= (free_func
) ft_gzip_free
;
283 zstream
->opaque
= stream
->memory
;
285 zstream
->avail_in
= 0;
286 zstream
->next_in
= zip
->buffer
;
288 if ( inflateInit2( zstream
, -MAX_WBITS
) != Z_OK
||
289 zstream
->next_in
== NULL
)
290 error
= Gzip_Err_Invalid_File_Format
;
298 ft_gzip_file_done( FT_GZipFile zip
)
300 z_stream
* zstream
= &zip
->zstream
;
303 inflateEnd( zstream
);
306 zstream
->zalloc
= NULL
;
307 zstream
->zfree
= NULL
;
308 zstream
->opaque
= NULL
;
309 zstream
->next_in
= NULL
;
310 zstream
->next_out
= NULL
;
311 zstream
->avail_in
= 0;
312 zstream
->avail_out
= 0;
321 ft_gzip_file_reset( FT_GZipFile zip
)
323 FT_Stream stream
= zip
->source
;
327 if ( !FT_STREAM_SEEK( zip
->start
) )
329 z_stream
* zstream
= &zip
->zstream
;
332 inflateReset( zstream
);
334 zstream
->avail_in
= 0;
335 zstream
->next_in
= zip
->input
;
336 zstream
->avail_out
= 0;
337 zstream
->next_out
= zip
->buffer
;
339 zip
->limit
= zip
->buffer
+ FT_GZIP_BUFFER_SIZE
;
340 zip
->cursor
= zip
->limit
;
349 ft_gzip_file_fill_input( FT_GZipFile zip
)
351 z_stream
* zstream
= &zip
->zstream
;
352 FT_Stream stream
= zip
->source
;
358 size
= stream
->read( stream
, stream
->pos
, zip
->input
,
359 FT_GZIP_BUFFER_SIZE
);
361 return Gzip_Err_Invalid_Stream_Operation
;
365 size
= stream
->size
- stream
->pos
;
366 if ( size
> FT_GZIP_BUFFER_SIZE
)
367 size
= FT_GZIP_BUFFER_SIZE
;
370 return Gzip_Err_Invalid_Stream_Operation
;
372 FT_MEM_COPY( zip
->input
, stream
->base
+ stream
->pos
, size
);
376 zstream
->next_in
= zip
->input
;
377 zstream
->avail_in
= size
;
384 ft_gzip_file_fill_output( FT_GZipFile zip
)
386 z_stream
* zstream
= &zip
->zstream
;
390 zip
->cursor
= zip
->buffer
;
391 zstream
->next_out
= zip
->cursor
;
392 zstream
->avail_out
= FT_GZIP_BUFFER_SIZE
;
394 while ( zstream
->avail_out
> 0 )
399 if ( zstream
->avail_in
== 0 )
401 error
= ft_gzip_file_fill_input( zip
);
406 err
= inflate( zstream
, Z_NO_FLUSH
);
408 if ( err
== Z_STREAM_END
)
410 zip
->limit
= zstream
->next_out
;
411 if ( zip
->limit
== zip
->cursor
)
412 error
= Gzip_Err_Invalid_Stream_Operation
;
415 else if ( err
!= Z_OK
)
417 error
= Gzip_Err_Invalid_Stream_Operation
;
426 /* fill output buffer; `count' must be <= FT_GZIP_BUFFER_SIZE */
428 ft_gzip_file_skip_output( FT_GZipFile zip
,
431 FT_Error error
= Gzip_Err_Ok
;
437 delta
= (FT_ULong
)( zip
->limit
- zip
->cursor
);
438 if ( delta
>= count
)
441 zip
->cursor
+= delta
;
448 error
= ft_gzip_file_fill_output( zip
);
458 ft_gzip_file_io( FT_GZipFile zip
,
467 /* Reset inflate stream if we're seeking backwards. */
468 /* Yes, that is not too efficient, but it saves memory :-) */
469 if ( pos
< zip
->pos
)
471 error
= ft_gzip_file_reset( zip
);
476 /* skip unwanted bytes */
477 if ( pos
> zip
->pos
)
479 error
= ft_gzip_file_skip_output( zip
, (FT_ULong
)( pos
- zip
->pos
) );
487 /* now read the data */
493 delta
= (FT_ULong
)( zip
->limit
- zip
->cursor
);
494 if ( delta
>= count
)
497 FT_MEM_COPY( buffer
, zip
->cursor
, delta
);
500 zip
->cursor
+= delta
;
507 error
= ft_gzip_file_fill_output( zip
);
517 /***************************************************************************/
518 /***************************************************************************/
520 /***** G Z E M B E D D I N G S T R E A M *****/
522 /***************************************************************************/
523 /***************************************************************************/
526 ft_gzip_stream_close( FT_Stream stream
)
528 FT_GZipFile zip
= (FT_GZipFile
)stream
->descriptor
.pointer
;
529 FT_Memory memory
= stream
->memory
;
534 /* finalize gzip file descriptor */
535 ft_gzip_file_done( zip
);
539 stream
->descriptor
.pointer
= NULL
;
545 ft_gzip_stream_io( FT_Stream stream
,
550 FT_GZipFile zip
= (FT_GZipFile
)stream
->descriptor
.pointer
;
553 return ft_gzip_file_io( zip
, pos
, buffer
, count
);
558 ft_gzip_get_uncompressed_size( FT_Stream stream
)
565 old_pos
= stream
->pos
;
566 if ( !FT_Stream_Seek( stream
, stream
->size
- 4 ) )
568 result
= (FT_ULong
)FT_Stream_ReadLong( stream
, &error
);
572 FT_Stream_Seek( stream
, old_pos
);
579 FT_EXPORT_DEF( FT_Error
)
580 FT_Stream_OpenGzip( FT_Stream stream
,
584 FT_Memory memory
= source
->memory
;
589 * check the header right now; this prevents allocating un-necessary
590 * objects when we don't need them
592 error
= ft_gzip_check_header( source
);
597 stream
->memory
= memory
;
599 if ( !FT_QNEW( zip
) )
601 error
= ft_gzip_file_init( zip
, stream
, source
);
608 stream
->descriptor
.pointer
= zip
;
612 * We use the following trick to try to dramatically improve the
613 * performance while dealing with small files. If the original stream
614 * size is less than a certain threshold, we try to load the whole font
615 * file into memory. This saves us from using the 32KB buffer needed
616 * to inflate the file, plus the two 4KB intermediate input/output
617 * buffers used in the `FT_GZipFile' structure.
620 FT_ULong zip_size
= ft_gzip_get_uncompressed_size( source
);
623 if ( zip_size
!= 0 && zip_size
< 40 * 1024 )
628 if ( !FT_ALLOC( zip_buff
, zip_size
) )
633 count
= ft_gzip_file_io( zip
, 0, zip_buff
, zip_size
);
634 if ( count
== zip_size
)
636 ft_gzip_file_done( zip
);
639 stream
->descriptor
.pointer
= NULL
;
641 stream
->size
= zip_size
;
643 stream
->base
= zip_buff
;
645 stream
->close
= ft_gzip_stream_close
;
650 ft_gzip_file_io( zip
, 0, NULL
, 0 );
657 stream
->size
= 0x7FFFFFFFL
; /* don't know the real size! */
660 stream
->read
= ft_gzip_stream_io
;
661 stream
->close
= ft_gzip_stream_close
;
667 #else /* !FT_CONFIG_OPTION_USE_ZLIB */
669 FT_EXPORT_DEF( FT_Error
)
670 FT_Stream_OpenGzip( FT_Stream stream
,
676 return Gzip_Err_Unimplemented_Feature
;
679 #endif /* !FT_CONFIG_OPTION_USE_ZLIB */