ftlzw.c revision 0098d5502d384e1dd41ec42a3cbf9dee1916ed72 
1/***************************************************************************/
2/*                                                                         */
3/*  ftlzw.c                                                                */
4/*                                                                         */
5/*    FreeType support for .Z compressed files.                            */
6/*                                                                         */
7/*  This optional component relies on NetBSD's zopen().  It should mainly  */
8/*  be used to parse compressed PCF fonts, as found with many X11 server   */
9/*  distributions.                                                         */
10/*                                                                         */
11/*  Copyright 2004-2006, 2009, 2010, 2012-2014 by                          */
12/*  Albert Chin-A-Young.                                                   */
13/*                                                                         */
14/*  Based on code in src/gzip/ftgzip.c, Copyright 2004 by                  */
15/*  David Turner, Robert Wilhelm, and Werner Lemberg.                      */
16/*                                                                         */
17/*  This file is part of the FreeType project, and may only be used,       */
18/*  modified, and distributed under the terms of the FreeType project      */
19/*  license, LICENSE.TXT.  By continuing to use, modify, or distribute     */
20/*  this file you indicate that you have read the license and              */
21/*  understand and accept it fully.                                        */
22/*                                                                         */
23/***************************************************************************/
24
25#include <ft2build.h>
26#include FT_INTERNAL_MEMORY_H
27#include FT_INTERNAL_STREAM_H
28#include FT_INTERNAL_DEBUG_H
29#include FT_LZW_H
30#include FT_CONFIG_STANDARD_LIBRARY_H
31
32
33#include FT_MODULE_ERRORS_H
34
35#undef __FTERRORS_H__
36
37#undef  FT_ERR_PREFIX
38#define FT_ERR_PREFIX  LZW_Err_
39#define FT_ERR_BASE    FT_Mod_Err_LZW
40
41#include FT_ERRORS_H
42
43
44#ifdef FT_CONFIG_OPTION_USE_LZW
45
46#ifdef FT_CONFIG_OPTION_PIC
47#error "lzw code does not support PIC yet"
48#endif
49
50#include "ftzopen.h"
51
52
53/***************************************************************************/
54/***************************************************************************/
55/*****                                                                 *****/
56/*****                  M E M O R Y   M A N A G E M E N T              *****/
57/*****                                                                 *****/
58/***************************************************************************/
59/***************************************************************************/
60
61/***************************************************************************/
62/***************************************************************************/
63/*****                                                                 *****/
64/*****                   F I L E   D E S C R I P T O R                 *****/
65/*****                                                                 *****/
66/***************************************************************************/
67/***************************************************************************/
68
69#define FT_LZW_BUFFER_SIZE  4096
70
71  typedef struct  FT_LZWFileRec_
72  {
73    FT_Stream       source;         /* parent/source stream        */
74    FT_Stream       stream;         /* embedding stream            */
75    FT_Memory       memory;         /* memory allocator            */
76    FT_LzwStateRec  lzw;            /* lzw decompressor state      */
77
78    FT_Byte         buffer[FT_LZW_BUFFER_SIZE]; /* output buffer      */
79    FT_ULong        pos;                        /* position in output */
80    FT_Byte*        cursor;
81    FT_Byte*        limit;
82
83  } FT_LZWFileRec, *FT_LZWFile;
84
85
86  /* check and skip .Z header */
87  static FT_Error
88  ft_lzw_check_header( FT_Stream  stream )
89  {
90    FT_Error  error;
91    FT_Byte   head[2];
92
93
94    if ( FT_STREAM_SEEK( 0 )       ||
95         FT_STREAM_READ( head, 2 ) )
96      goto Exit;
97
98    /* head[0] && head[1] are the magic numbers */
99    if ( head[0] != 0x1F ||
100         head[1] != 0x9D )
101      error = FT_THROW( Invalid_File_Format );
102
103  Exit:
104    return error;
105  }
106
107
108  static FT_Error
109  ft_lzw_file_init( FT_LZWFile  zip,
110                    FT_Stream   stream,
111                    FT_Stream   source )
112  {
113    FT_LzwState  lzw   = &zip->lzw;
114    FT_Error     error;
115
116
117    zip->stream = stream;
118    zip->source = source;
119    zip->memory = stream->memory;
120
121    zip->limit  = zip->buffer + FT_LZW_BUFFER_SIZE;
122    zip->cursor = zip->limit;
123    zip->pos    = 0;
124
125    /* check and skip .Z header */
126    error = ft_lzw_check_header( source );
127    if ( error )
128      goto Exit;
129
130    /* initialize internal lzw variable */
131    ft_lzwstate_init( lzw, source );
132
133  Exit:
134    return error;
135  }
136
137
138  static void
139  ft_lzw_file_done( FT_LZWFile  zip )
140  {
141    /* clear the rest */
142    ft_lzwstate_done( &zip->lzw );
143
144    zip->memory = NULL;
145    zip->source = NULL;
146    zip->stream = NULL;
147  }
148
149
150  static FT_Error
151  ft_lzw_file_reset( FT_LZWFile  zip )
152  {
153    FT_Stream  stream = zip->source;
154    FT_Error   error;
155
156
157    if ( !FT_STREAM_SEEK( 0 ) )
158    {
159      ft_lzwstate_reset( &zip->lzw );
160
161      zip->limit  = zip->buffer + FT_LZW_BUFFER_SIZE;
162      zip->cursor = zip->limit;
163      zip->pos    = 0;
164    }
165
166    return error;
167  }
168
169
170  static FT_Error
171  ft_lzw_file_fill_output( FT_LZWFile  zip )
172  {
173    FT_LzwState  lzw = &zip->lzw;
174    FT_ULong     count;
175    FT_Error     error = FT_Err_Ok;
176
177
178    zip->cursor = zip->buffer;
179
180    count = ft_lzwstate_io( lzw, zip->buffer, FT_LZW_BUFFER_SIZE );
181
182    zip->limit = zip->cursor + count;
183
184    if ( count == 0 )
185      error = FT_THROW( Invalid_Stream_Operation );
186
187    return error;
188  }
189
190
191  /* fill output buffer; `count' must be <= FT_LZW_BUFFER_SIZE */
192  static FT_Error
193  ft_lzw_file_skip_output( FT_LZWFile  zip,
194                           FT_ULong    count )
195  {
196    FT_Error  error = FT_Err_Ok;
197
198
199    /* first, we skip what we can from the output buffer */
200    {
201      FT_ULong  delta = (FT_ULong)( zip->limit - zip->cursor );
202
203
204      if ( delta >= count )
205        delta = count;
206
207      zip->cursor += delta;
208      zip->pos    += delta;
209
210      count -= delta;
211    }
212
213    /* next, we skip as many bytes remaining as possible */
214    while ( count > 0 )
215    {
216      FT_ULong  delta = FT_LZW_BUFFER_SIZE;
217      FT_ULong  numread;
218
219
220      if ( delta > count )
221        delta = count;
222
223      numread = ft_lzwstate_io( &zip->lzw, NULL, delta );
224      if ( numread < delta )
225      {
226        /* not enough bytes */
227        error = FT_THROW( Invalid_Stream_Operation );
228        break;
229      }
230
231      zip->pos += delta;
232      count    -= delta;
233    }
234
235    return error;
236  }
237
238
239  static FT_ULong
240  ft_lzw_file_io( FT_LZWFile  zip,
241                  FT_ULong    pos,
242                  FT_Byte*    buffer,
243                  FT_ULong    count )
244  {
245    FT_ULong  result = 0;
246    FT_Error  error;
247
248
249    /* seeking backwards. */
250    if ( pos < zip->pos )
251    {
252      /* If the new position is within the output buffer, simply       */
253      /* decrement pointers, otherwise we reset the stream completely! */
254      if ( ( zip->pos - pos ) <= (FT_ULong)( zip->cursor - zip->buffer ) )
255      {
256        zip->cursor -= zip->pos - pos;
257        zip->pos     = pos;
258      }
259      else
260      {
261        error = ft_lzw_file_reset( zip );
262        if ( error )
263          goto Exit;
264      }
265    }
266
267    /* skip unwanted bytes */
268    if ( pos > zip->pos )
269    {
270      error = ft_lzw_file_skip_output( zip, (FT_ULong)( pos - zip->pos ) );
271      if ( error )
272        goto Exit;
273    }
274
275    if ( count == 0 )
276      goto Exit;
277
278    /* now read the data */
279    for (;;)
280    {
281      FT_ULong  delta;
282
283
284      delta = (FT_ULong)( zip->limit - zip->cursor );
285      if ( delta >= count )
286        delta = count;
287
288      FT_MEM_COPY( buffer + result, zip->cursor, delta );
289      result      += delta;
290      zip->cursor += delta;
291      zip->pos    += delta;
292
293      count -= delta;
294      if ( count == 0 )
295        break;
296
297      error = ft_lzw_file_fill_output( zip );
298      if ( error )
299        break;
300    }
301
302  Exit:
303    return result;
304  }
305
306
307/***************************************************************************/
308/***************************************************************************/
309/*****                                                                 *****/
310/*****            L Z W   E M B E D D I N G   S T R E A M              *****/
311/*****                                                                 *****/
312/***************************************************************************/
313/***************************************************************************/
314
315  static void
316  ft_lzw_stream_close( FT_Stream  stream )
317  {
318    FT_LZWFile  zip    = (FT_LZWFile)stream->descriptor.pointer;
319    FT_Memory   memory = stream->memory;
320
321
322    if ( zip )
323    {
324      /* finalize lzw file descriptor */
325      ft_lzw_file_done( zip );
326
327      FT_FREE( zip );
328
329      stream->descriptor.pointer = NULL;
330    }
331  }
332
333
334  static FT_ULong
335  ft_lzw_stream_io( FT_Stream  stream,
336                    FT_ULong   pos,
337                    FT_Byte*   buffer,
338                    FT_ULong   count )
339  {
340    FT_LZWFile  zip = (FT_LZWFile)stream->descriptor.pointer;
341
342
343    return ft_lzw_file_io( zip, pos, buffer, count );
344  }
345
346
347  FT_EXPORT_DEF( FT_Error )
348  FT_Stream_OpenLZW( FT_Stream  stream,
349                     FT_Stream  source )
350  {
351    FT_Error    error;
352    FT_Memory   memory;
353    FT_LZWFile  zip = NULL;
354
355
356    if ( !stream || !source )
357    {
358      error = FT_THROW( Invalid_Stream_Handle );
359      goto Exit;
360    }
361
362    memory = source->memory;
363
364    /*
365     *  Check the header right now; this prevents allocation of a huge
366     *  LZWFile object (400 KByte of heap memory) if not necessary.
367     *
368     *  Did I mention that you should never use .Z compressed font
369     *  files?
370     */
371    error = ft_lzw_check_header( source );
372    if ( error )
373      goto Exit;
374
375    FT_ZERO( stream );
376    stream->memory = memory;
377
378    if ( !FT_NEW( zip ) )
379    {
380      error = ft_lzw_file_init( zip, stream, source );
381      if ( error )
382      {
383        FT_FREE( zip );
384        goto Exit;
385      }
386
387      stream->descriptor.pointer = zip;
388    }
389
390    stream->size  = 0x7FFFFFFFL;  /* don't know the real size! */
391    stream->pos   = 0;
392    stream->base  = 0;
393    stream->read  = ft_lzw_stream_io;
394    stream->close = ft_lzw_stream_close;
395
396  Exit:
397    return error;
398  }
399
400
401#include "ftzopen.c"
402
403
404#else  /* !FT_CONFIG_OPTION_USE_LZW */
405
406
407  FT_EXPORT_DEF( FT_Error )
408  FT_Stream_OpenLZW( FT_Stream  stream,
409                     FT_Stream  source )
410  {
411    FT_UNUSED( stream );
412    FT_UNUSED( source );
413
414    return FT_THROW( Unimplemented_Feature );
415  }
416
417
418#endif /* !FT_CONFIG_OPTION_USE_LZW */
419
420
421/* END */
422