src/lzw/ftlzw.c

   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 */