mergin latest developments of main branch:
support for LZW compression + changing MIN => FT_MIN
This commit is contained in:
David Turner
parent
79edf077a2
commit
cad0775afe
|
|
@ -1,16 +0,0 @@
|
|||
#ifndef ATARI_H
|
||||
#define ATARI_H
|
||||
|
||||
#pragma warn -stu
|
||||
|
||||
/* PureC doesn't like 32bit enumerations */
|
||||
|
||||
#ifndef FT_IMAGE_TAG
|
||||
#define FT_IMAGE_TAG( value, _x1, _x2, _x3, _x4 ) value
|
||||
#endif /* FT_IMAGE_TAG */
|
||||
|
||||
#ifndef FT_ENC_TAG
|
||||
#define FT_ENC_TAG( value, a, b, c, d ) value
|
||||
#endif /* FT_ENC_TAG */
|
||||
|
||||
#endif /* ATARI_H */
|
||||
|
|
@ -1,37 +0,0 @@
|
|||
/* the following changes file names for PureC projects */
|
||||
|
||||
if (argc > 0)
|
||||
{
|
||||
ordner = argv[0];
|
||||
if (basename(ordner) == "") /* ist Ordner */
|
||||
{
|
||||
ChangeFilenames(ordner);
|
||||
}
|
||||
}
|
||||
|
||||
proc ChangeFilenames(folder)
|
||||
local i,entries,directory,file;
|
||||
{
|
||||
entries = filelist(directory,folder);
|
||||
for (i = 0; i < entries; ++i)
|
||||
{
|
||||
file = directory[i,0];
|
||||
if ((directory[i,3]&16) > 0) /* subdirectory */
|
||||
{
|
||||
ChangeFilenames(folder+file+"\\");
|
||||
}
|
||||
else
|
||||
{
|
||||
if ((stricmp(suffix(file),".h")==0)|(stricmp(suffix(file),".c")==0))
|
||||
ChangeFilename(folder,file);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
proc ChangeFilename(path,datei)
|
||||
local newfile,err;
|
||||
{
|
||||
newfile=datei;
|
||||
newfile[0]=(newfile[0] | 32) ^ 32;
|
||||
err=files.rename("-q",path+datei,newfile);
|
||||
}
|
||||
|
|
@ -1,33 +0,0 @@
|
|||
;FreeType project file
|
||||
|
||||
FREETYPE.LIB
|
||||
|
||||
.C [-K -P -R -A]
|
||||
.L [-J -V]
|
||||
.S
|
||||
|
||||
=
|
||||
|
||||
..\..\src\base\ftsystem.c
|
||||
..\..\src\base\ftdebug.c
|
||||
|
||||
..\..\src\base\ftinit.c
|
||||
..\..\src\base\ftglyph.c
|
||||
..\..\src\base\ftmm
|
||||
..\..\src\base\ftbbox
|
||||
|
||||
..\..\src\base\ftbase.c
|
||||
..\..\src\autohint\autohint.c
|
||||
;..\..\src\cache\ftcache.c
|
||||
..\..\src\cff\cff.c
|
||||
..\..\src\cid\type1cid.c
|
||||
..\..\src\psaux\psaux.c
|
||||
..\..\src\pshinter\pshinter.c
|
||||
..\..\src\psnames\psnames.c
|
||||
..\..\src\raster\raster.c
|
||||
..\..\src\sfnt\sfnt.c
|
||||
..\..\src\smooth\smooth.c
|
||||
..\..\src\truetype\truetype.c
|
||||
..\..\src\type1\type1.c
|
||||
..\..\src\type42\type42.c
|
||||
|
||||
|
|
@ -1,51 +0,0 @@
|
|||
Compiling FreeType 2 with PureC compiler
|
||||
========================================
|
||||
|
||||
[See below for a German version.]
|
||||
|
||||
To compile FreeType 2 as a library the following changes must be applied:
|
||||
|
||||
- All *.c files must start with an uppercase letter.
|
||||
(In case GEMSCRIPT is available:
|
||||
Simply drag the whole FreeType 2 directory to the file `FNames.SIC'.)
|
||||
|
||||
- You have to change the INCLUDE directory in PureC's compiler options
|
||||
to contain both the `INCLUDE' and `freetype2\include' directory.
|
||||
Example:
|
||||
|
||||
INCLUDE;E:\freetype2\include
|
||||
|
||||
- The file `freetype2/include/Ft2build.h' must be patched as follows to
|
||||
include ATARI.H:
|
||||
|
||||
#ifndef __FT2_BUILD_GENERIC_H__
|
||||
#define __FT2_BUILD_GENERIC_H__
|
||||
|
||||
#include "ATARI.H"
|
||||
|
||||
|
||||
|
||||
Compilieren von FreeType 2 mit PureC
|
||||
====================================
|
||||
|
||||
Um FreeType 2 als eine Bibliothek (library) zu compilieren, muss folgendes
|
||||
ge„ndert werden:
|
||||
|
||||
- Alle *.c-files m<>ssen mit einem GROSSBUCHSTABEN beginnen.
|
||||
(Falls GEMSCRIPT zur Verf<72>gung steht:
|
||||
Den kompletten Ordner freetype2 auf die Datei `FNames.SIC' draggen.)
|
||||
|
||||
- In den Compiler-Optionen von PureC muss das INCLUDE directory auf INCLUDE
|
||||
und freetype2\include verweisen. Z.B.:
|
||||
|
||||
INCLUDE;E:\freetype2\include
|
||||
|
||||
- In der Datei freetype2/include/Ft2build.h muss zu Beginn
|
||||
ein #include "ATARI.H" wie folgt eingef<65>gt werden:
|
||||
|
||||
#ifndef __FT2_BUILD_GENERIC_H__
|
||||
#define __FT2_BUILD_GENERIC_H__
|
||||
|
||||
#include "ATARI.H"
|
||||
|
||||
--- end of README.TXT ---
|
||||
462
src/lzw/ftlzw.c
462
src/lzw/ftlzw.c
|
|
@ -1,462 +0,0 @@
|
|||
/***************************************************************************/
|
||||
/* */
|
||||
/* ftlzw.c */
|
||||
/* */
|
||||
/* FreeType support for .Z compressed files. */
|
||||
/* */
|
||||
/* This optional component relies on NetBSD's zopen(). It should mainly */
|
||||
/* be used to parse compressed PCF fonts, as found with many X11 server */
|
||||
/* distributions. */
|
||||
/* */
|
||||
/* Copyright 2004 by */
|
||||
/* Albert Chin-A-Young. */
|
||||
/* */
|
||||
/* Based on code in src/gzip/ftgzip.c, Copyright 2004 by */
|
||||
/* David Turner, Robert Wilhelm, and Werner Lemberg. */
|
||||
/* */
|
||||
/* This file is part of the FreeType project, and may only be used, */
|
||||
/* modified, and distributed under the terms of the FreeType project */
|
||||
/* license, LICENSE.TXT. By continuing to use, modify, or distribute */
|
||||
/* this file you indicate that you have read the license and */
|
||||
/* understand and accept it fully. */
|
||||
/* */
|
||||
/***************************************************************************/
|
||||
|
||||
#include <ft2build.h>
|
||||
#include FT_INTERNAL_MEMORY_H
|
||||
#include FT_INTERNAL_STREAM_H
|
||||
#include FT_INTERNAL_DEBUG_H
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include "zopen.h"
|
||||
|
||||
|
||||
#include FT_MODULE_ERRORS_H
|
||||
|
||||
#undef __FTERRORS_H__
|
||||
|
||||
#define FT_ERR_PREFIX LZW_Err_
|
||||
#define FT_ERR_BASE FT_Mod_Err_LZW
|
||||
|
||||
#include FT_ERRORS_H
|
||||
|
||||
|
||||
#ifdef FT_CONFIG_OPTION_USE_LZW
|
||||
|
||||
|
||||
/***************************************************************************/
|
||||
/***************************************************************************/
|
||||
/***** *****/
|
||||
/***** M E M O R Y M A N A G E M E N T *****/
|
||||
/***** *****/
|
||||
/***************************************************************************/
|
||||
/***************************************************************************/
|
||||
|
||||
/***************************************************************************/
|
||||
/***************************************************************************/
|
||||
/***** *****/
|
||||
/***** F I L E D E S C R I P T O R *****/
|
||||
/***** *****/
|
||||
/***************************************************************************/
|
||||
/***************************************************************************/
|
||||
|
||||
#define FT_LZW_BUFFER_SIZE 4096
|
||||
|
||||
typedef struct FT_LZWFileRec_
|
||||
{
|
||||
FT_Stream source; /* parent/source stream */
|
||||
FT_Stream stream; /* embedding stream */
|
||||
FT_Memory memory; /* memory allocator */
|
||||
s_zstate_t zstream; /* lzw input stream */
|
||||
|
||||
FT_ULong start; /* starting position, after .Z header */
|
||||
FT_Byte input[FT_LZW_BUFFER_SIZE]; /* input buffer */
|
||||
|
||||
FT_Byte buffer[FT_LZW_BUFFER_SIZE]; /* output buffer */
|
||||
FT_ULong pos; /* position in output */
|
||||
FT_Byte* cursor;
|
||||
FT_Byte* limit;
|
||||
|
||||
} FT_LZWFileRec, *FT_LZWFile;
|
||||
|
||||
|
||||
/* check and skip .Z header */
|
||||
static FT_Error
|
||||
ft_lzw_check_header( FT_Stream stream )
|
||||
{
|
||||
FT_Error error;
|
||||
FT_Byte head[2];
|
||||
|
||||
|
||||
if ( FT_STREAM_SEEK( 0 ) ||
|
||||
FT_STREAM_READ( head, 2 ) )
|
||||
goto Exit;
|
||||
|
||||
/* head[0] && head[1] are the magic numbers */
|
||||
if ( head[0] != 0x1f ||
|
||||
head[1] != 0x9d )
|
||||
error = LZW_Err_Invalid_File_Format;
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
static FT_Error
|
||||
ft_lzw_file_init( FT_LZWFile zip,
|
||||
FT_Stream stream,
|
||||
FT_Stream source )
|
||||
{
|
||||
s_zstate_t* zstream = &zip->zstream;
|
||||
FT_Error error = LZW_Err_Ok;
|
||||
|
||||
|
||||
zip->stream = stream;
|
||||
zip->source = source;
|
||||
zip->memory = stream->memory;
|
||||
|
||||
zip->limit = zip->buffer + FT_LZW_BUFFER_SIZE;
|
||||
zip->cursor = zip->limit;
|
||||
zip->pos = 0;
|
||||
|
||||
/* check and skip .Z header */
|
||||
{
|
||||
stream = source;
|
||||
|
||||
error = ft_lzw_check_header( source );
|
||||
if ( error )
|
||||
goto Exit;
|
||||
|
||||
zip->start = FT_STREAM_POS();
|
||||
}
|
||||
|
||||
/* initialize internal lzw variable */
|
||||
zinit( zstream );
|
||||
|
||||
zstream->avail_in = 0;
|
||||
zstream->next_in = zip->buffer;
|
||||
zstream->zs_in_count = source->size - 2;
|
||||
|
||||
if ( zstream->next_in == NULL )
|
||||
error = LZW_Err_Invalid_File_Format;
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
static void
|
||||
ft_lzw_file_done( FT_LZWFile zip )
|
||||
{
|
||||
s_zstate_t* zstream = &zip->zstream;
|
||||
|
||||
|
||||
/* clear the rest */
|
||||
zstream->next_in = NULL;
|
||||
zstream->next_out = NULL;
|
||||
zstream->avail_in = 0;
|
||||
zstream->avail_out = 0;
|
||||
zstream->total_in = 0;
|
||||
zstream->total_out = 0;
|
||||
|
||||
zip->memory = NULL;
|
||||
zip->source = NULL;
|
||||
zip->stream = NULL;
|
||||
}
|
||||
|
||||
|
||||
static FT_Error
|
||||
ft_lzw_file_reset( FT_LZWFile zip )
|
||||
{
|
||||
FT_Stream stream = zip->source;
|
||||
FT_Error error;
|
||||
|
||||
|
||||
if ( !FT_STREAM_SEEK( zip->start ) )
|
||||
{
|
||||
s_zstate_t* zstream = &zip->zstream;
|
||||
|
||||
|
||||
zinit( zstream );
|
||||
|
||||
zstream->avail_in = 0;
|
||||
zstream->next_in = zip->input;
|
||||
zstream->total_in = 0;
|
||||
zstream->avail_out = 0;
|
||||
zstream->next_out = zip->buffer;
|
||||
zstream->total_out = 0;
|
||||
zstream->zs_in_count = zip->source->size - 2;
|
||||
|
||||
zip->limit = zip->buffer + FT_LZW_BUFFER_SIZE;
|
||||
zip->cursor = zip->limit;
|
||||
zip->pos = 0;
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
static FT_Error
|
||||
ft_lzw_file_fill_input( FT_LZWFile zip )
|
||||
{
|
||||
s_zstate_t* zstream = &zip->zstream;
|
||||
FT_Stream stream = zip->source;
|
||||
FT_ULong size;
|
||||
|
||||
|
||||
if ( stream->read )
|
||||
{
|
||||
size = stream->read( stream, stream->pos, zip->input,
|
||||
FT_LZW_BUFFER_SIZE );
|
||||
if ( size == 0 )
|
||||
return LZW_Err_Invalid_Stream_Operation;
|
||||
}
|
||||
else
|
||||
{
|
||||
size = stream->size - stream->pos;
|
||||
if ( size > FT_LZW_BUFFER_SIZE )
|
||||
size = FT_LZW_BUFFER_SIZE;
|
||||
|
||||
if ( size == 0 )
|
||||
return LZW_Err_Invalid_Stream_Operation;
|
||||
|
||||
FT_MEM_COPY( zip->input, stream->base + stream->pos, size );
|
||||
}
|
||||
stream->pos += size;
|
||||
|
||||
zstream->next_in = zip->input;
|
||||
zstream->avail_in = size;
|
||||
|
||||
return LZW_Err_Ok;
|
||||
}
|
||||
|
||||
|
||||
|
||||
static FT_Error
|
||||
ft_lzw_file_fill_output( FT_LZWFile zip )
|
||||
{
|
||||
s_zstate_t* zstream = &zip->zstream;
|
||||
FT_Error error = 0;
|
||||
|
||||
|
||||
zip->cursor = zip->buffer;
|
||||
zstream->next_out = zip->cursor;
|
||||
zstream->avail_out = FT_LZW_BUFFER_SIZE;
|
||||
|
||||
while ( zstream->avail_out > 0 )
|
||||
{
|
||||
int num_read = 0;
|
||||
|
||||
|
||||
if ( zstream->avail_in == 0 )
|
||||
{
|
||||
error = ft_lzw_file_fill_input( zip );
|
||||
if ( error )
|
||||
break;
|
||||
}
|
||||
|
||||
num_read = zread( zstream );
|
||||
|
||||
if ( num_read == -1 && zstream->zs_in_count == 0 )
|
||||
{
|
||||
zip->limit = zstream->next_out;
|
||||
if ( zip->limit == zip->cursor )
|
||||
error = LZW_Err_Invalid_Stream_Operation;
|
||||
break;
|
||||
}
|
||||
else if ( num_read == -1 )
|
||||
break;
|
||||
else
|
||||
zstream->avail_out -= num_read;
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
/* fill output buffer; `count' must be <= FT_LZW_BUFFER_SIZE */
|
||||
static FT_Error
|
||||
ft_lzw_file_skip_output( FT_LZWFile zip,
|
||||
FT_ULong count )
|
||||
{
|
||||
FT_Error error = LZW_Err_Ok;
|
||||
FT_ULong delta;
|
||||
|
||||
|
||||
for (;;)
|
||||
{
|
||||
delta = (FT_ULong)( zip->limit - zip->cursor );
|
||||
if ( delta >= count )
|
||||
delta = count;
|
||||
|
||||
zip->cursor += delta;
|
||||
zip->pos += delta;
|
||||
|
||||
count -= delta;
|
||||
if ( count == 0 )
|
||||
break;
|
||||
|
||||
error = ft_lzw_file_fill_output( zip );
|
||||
if ( error )
|
||||
break;
|
||||
}
|
||||
|
||||
return error;
|
||||
}
|
||||
|
||||
|
||||
static FT_ULong
|
||||
ft_lzw_file_io( FT_LZWFile zip,
|
||||
FT_ULong pos,
|
||||
FT_Byte* buffer,
|
||||
FT_ULong count )
|
||||
{
|
||||
FT_ULong result = 0;
|
||||
FT_Error error;
|
||||
|
||||
|
||||
/* Teset inflate stream if we're seeking backwards. */
|
||||
/* Yes, that is not too efficient, but it saves memory :-) */
|
||||
if ( pos < zip->pos )
|
||||
{
|
||||
error = ft_lzw_file_reset( zip );
|
||||
if ( error )
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
/* skip unwanted bytes */
|
||||
if ( pos > zip->pos )
|
||||
{
|
||||
error = ft_lzw_file_skip_output( zip, (FT_ULong)( pos - zip->pos ) );
|
||||
if ( error )
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
if ( count == 0 )
|
||||
goto Exit;
|
||||
|
||||
/* now read the data */
|
||||
for (;;)
|
||||
{
|
||||
FT_ULong delta;
|
||||
|
||||
|
||||
delta = (FT_ULong)( zip->limit - zip->cursor );
|
||||
if ( delta >= count )
|
||||
delta = count;
|
||||
|
||||
FT_MEM_COPY( buffer, zip->cursor, delta );
|
||||
buffer += delta;
|
||||
result += delta;
|
||||
zip->cursor += delta;
|
||||
zip->pos += delta;
|
||||
|
||||
count -= delta;
|
||||
if ( count == 0 )
|
||||
break;
|
||||
|
||||
error = ft_lzw_file_fill_output( zip );
|
||||
if ( error )
|
||||
break;
|
||||
}
|
||||
|
||||
Exit:
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/***************************************************************************/
|
||||
/***************************************************************************/
|
||||
/***** *****/
|
||||
/***** L Z W E M B E D D I N G S T R E A M *****/
|
||||
/***** *****/
|
||||
/***************************************************************************/
|
||||
/***************************************************************************/
|
||||
|
||||
static void
|
||||
ft_lzw_stream_close( FT_Stream stream )
|
||||
{
|
||||
FT_LZWFile zip = (FT_LZWFile)stream->descriptor.pointer;
|
||||
FT_Memory memory = stream->memory;
|
||||
|
||||
|
||||
if ( zip )
|
||||
{
|
||||
/* finalize lzw file descriptor */
|
||||
ft_lzw_file_done( zip );
|
||||
|
||||
FT_FREE( zip );
|
||||
|
||||
stream->descriptor.pointer = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
static FT_ULong
|
||||
ft_lzw_stream_io( FT_Stream stream,
|
||||
FT_ULong pos,
|
||||
FT_Byte* buffer,
|
||||
FT_ULong count )
|
||||
{
|
||||
FT_LZWFile zip = (FT_LZWFile)stream->descriptor.pointer;
|
||||
|
||||
|
||||
return ft_lzw_file_io( zip, pos, buffer, count );
|
||||
}
|
||||
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Stream_OpenLZW( FT_Stream stream,
|
||||
FT_Stream source )
|
||||
{
|
||||
FT_Error error;
|
||||
FT_Memory memory = source->memory;
|
||||
FT_LZWFile zip;
|
||||
|
||||
|
||||
FT_ZERO( stream );
|
||||
stream->memory = memory;
|
||||
|
||||
if ( !FT_NEW( zip ) )
|
||||
{
|
||||
error = ft_lzw_file_init( zip, stream, source );
|
||||
if ( error )
|
||||
{
|
||||
FT_FREE( zip );
|
||||
goto Exit;
|
||||
}
|
||||
|
||||
stream->descriptor.pointer = zip;
|
||||
}
|
||||
|
||||
stream->size = 0x7FFFFFFFL; /* don't know the real size! */
|
||||
stream->pos = 0;
|
||||
stream->base = 0;
|
||||
stream->read = ft_lzw_stream_io;
|
||||
stream->close = ft_lzw_stream_close;
|
||||
|
||||
Exit:
|
||||
return error;
|
||||
}
|
||||
|
||||
#include "zopen.c"
|
||||
|
||||
|
||||
#else /* !FT_CONFIG_OPTION_USE_LZW */
|
||||
|
||||
|
||||
FT_EXPORT_DEF( FT_Error )
|
||||
FT_Stream_OpenLZW( FT_Stream stream,
|
||||
FT_Stream source )
|
||||
{
|
||||
FT_UNUSED( stream );
|
||||
FT_UNUSED( source );
|
||||
|
||||
return LZW_Err_Unimplemented_Feature;
|
||||
}
|
||||
|
||||
|
||||
#endif /* !FT_CONFIG_OPTION_USE_LZW */
|
||||
|
||||
|
||||
/* END */
|
||||
|
|
@ -1,70 +0,0 @@
|
|||
#
|
||||
# FreeType 2 LZW support configuration rules
|
||||
#
|
||||
|
||||
|
||||
# Copyright 2004 by
|
||||
# Albert Chin-A-Young.
|
||||
#
|
||||
# Based on src/lzw/rules.mk, Copyright 2002 by
|
||||
# David Turner, Robert Wilhelm, and Werner Lemberg.
|
||||
#
|
||||
# This file is part of the FreeType project, and may only be used, modified,
|
||||
# and distributed under the terms of the FreeType project license,
|
||||
# LICENSE.TXT. By continuing to use, modify, or distribute this file you
|
||||
# indicate that you have read the license and understand and accept it
|
||||
# fully.
|
||||
|
||||
|
||||
# LZW driver directory
|
||||
#
|
||||
LZW_DIR := $(SRC_DIR)/lzw
|
||||
|
||||
|
||||
# compilation flags for the driver
|
||||
#
|
||||
LZW_COMPILE := $(FT_COMPILE) $I$(subst /,$(COMPILER_SEP),$(LZW_DIR))
|
||||
|
||||
|
||||
# LZW support sources (i.e., C files)
|
||||
#
|
||||
LZW_DRV_SRC := $(LZW_DIR)/ftlzw.c \
|
||||
$(LZW_DIR)/zopen.c
|
||||
|
||||
# LZW support headers
|
||||
#
|
||||
LZW_DRV_H := $(LZW_DIR)/zopen.h
|
||||
|
||||
|
||||
# LZW driver object(s)
|
||||
#
|
||||
# LZW_DRV_OBJ_M is used during `multi' builds
|
||||
# LZW_DRV_OBJ_S is used during `single' builds
|
||||
#
|
||||
LZW_DRV_OBJ_M := $(OBJ_DIR)/ftlzw.$O
|
||||
LZW_DRV_OBJ_S := $(OBJ_DIR)/ftlzw.$O
|
||||
|
||||
# LZW support source file for single build
|
||||
#
|
||||
LZW_DRV_SRC_S := $(LZW_DIR)/ftlzw.c
|
||||
|
||||
|
||||
# LZW support - single object
|
||||
#
|
||||
$(LZW_DRV_OBJ_S): $(LZW_DRV_SRC_S) $(LZW_DRV_SRC) $(FREETYPE_H) $(LZW_DRV_H)
|
||||
$(LZW_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $(LZW_DRV_SRC_S))
|
||||
|
||||
|
||||
# LZW support - multiple objects
|
||||
#
|
||||
$(OBJ_DIR)/%.$O: $(LZW_DIR)/%.c $(FREETYPE_H) $(LZW_DRV_H)
|
||||
$(LZW_COMPILE) $T$(subst /,$(COMPILER_SEP),$@ $<)
|
||||
|
||||
|
||||
# update main driver object lists
|
||||
#
|
||||
DRV_OBJS_S += $(LZW_DRV_OBJ_S)
|
||||
DRV_OBJS_M += $(LZW_DRV_OBJ_M)
|
||||
|
||||
|
||||
# EOF
|
||||
399
src/lzw/zopen.c
399
src/lzw/zopen.c
|
|
@ -1,399 +0,0 @@
|
|||
/* $NetBSD: zopen.c,v 1.8 2003/08/07 11:13:29 agc Exp $ */
|
||||
|
||||
/*-
|
||||
* Copyright (c) 1985, 1986, 1992, 1993
|
||||
* The Regents of the University of California. All rights reserved.
|
||||
*
|
||||
* This code is derived from software contributed to Berkeley by
|
||||
* Diomidis Spinellis and James A. Woods, derived from original
|
||||
* work by Spencer Thomas and Joseph Orost.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. Neither the name of the University nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/*-
|
||||
*
|
||||
* Copyright (c) 2004
|
||||
* Albert Chin-A-Young.
|
||||
*
|
||||
* Modified to work with FreeType's PCF driver.
|
||||
*
|
||||
*/
|
||||
|
||||
#if defined(LIBC_SCCS) && !defined(lint)
|
||||
#if 0
|
||||
static char sccsid[] = "@(#)zopen.c 8.1 (Berkeley) 6/27/93";
|
||||
#else
|
||||
static char rcsid[] = "$NetBSD: zopen.c,v 1.8 2003/08/07 11:13:29 agc Exp $";
|
||||
#endif
|
||||
#endif /* LIBC_SCCS and not lint */
|
||||
|
||||
/*-
|
||||
* fcompress.c - File compression ala IEEE Computer, June 1984.
|
||||
*
|
||||
* Compress authors:
|
||||
* Spencer W. Thomas (decvax!utah-cs!thomas)
|
||||
* Jim McKie (decvax!mcvax!jim)
|
||||
* Steve Davies (decvax!vax135!petsd!peora!srd)
|
||||
* Ken Turkowski (decvax!decwrl!turtlevax!ken)
|
||||
* James A. Woods (decvax!ihnp4!ames!jaw)
|
||||
* Joe Orost (decvax!vax135!petsd!joe)
|
||||
*
|
||||
* Cleaned up and converted to library returning I/O streams by
|
||||
* Diomidis Spinellis <dds@doc.ic.ac.uk>.
|
||||
*/
|
||||
|
||||
#include <sys/param.h>
|
||||
#include <sys/stat.h>
|
||||
|
||||
#include <ctype.h>
|
||||
#include <signal.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#if 0
|
||||
static char_type magic_header[] =
|
||||
{ 0x1f, 0x9d }; /* 1F 9D */
|
||||
#endif
|
||||
|
||||
#define BIT_MASK 0x1f /* Defines for third byte of header. */
|
||||
#define BLOCK_MASK 0x80
|
||||
|
||||
/*
|
||||
* Masks 0x40 and 0x20 are free. I think 0x20 should mean that there is
|
||||
* a fourth header byte (for expansion).
|
||||
*/
|
||||
#define INIT_BITS 9 /* Initial number of bits/code. */
|
||||
|
||||
#define MAXCODE(n_bits) ((1 << (n_bits)) - 1)
|
||||
|
||||
/* Definitions to retain old variable names */
|
||||
#define fp zs->zs_fp
|
||||
#define state zs->zs_state
|
||||
#define n_bits zs->zs_n_bits
|
||||
#define maxbits zs->zs_maxbits
|
||||
#define maxcode zs->zs_maxcode
|
||||
#define maxmaxcode zs->zs_maxmaxcode
|
||||
#define htab zs->zs_htab
|
||||
#define codetab zs->zs_codetab
|
||||
#define hsize zs->zs_hsize
|
||||
#define free_ent zs->zs_free_ent
|
||||
#define block_compress zs->zs_block_compress
|
||||
#define clear_flg zs->zs_clear_flg
|
||||
#define offset zs->zs_offset
|
||||
#define in_count zs->zs_in_count
|
||||
#define buf_len zs->zs_buf_len
|
||||
#define buf zs->zs_buf
|
||||
#define stackp zs->u.r.zs_stackp
|
||||
#define finchar zs->u.r.zs_finchar
|
||||
#define code zs->u.r.zs_code
|
||||
#define oldcode zs->u.r.zs_oldcode
|
||||
#define incode zs->u.r.zs_incode
|
||||
#define roffset zs->u.r.zs_roffset
|
||||
#define size zs->u.r.zs_size
|
||||
#define gbuf zs->u.r.zs_gbuf
|
||||
|
||||
/*
|
||||
* To save much memory, we overlay the table used by compress() with those
|
||||
* used by decompress(). The tab_prefix table is the same size and type as
|
||||
* the codetab. The tab_suffix table needs 2**BITS characters. We get this
|
||||
* from the beginning of htab. The output stack uses the rest of htab, and
|
||||
* contains characters. There is plenty of room for any possible stack
|
||||
* (stack used to be 8000 characters).
|
||||
*/
|
||||
|
||||
#define htabof(i) htab[i]
|
||||
#define codetabof(i) codetab[i]
|
||||
|
||||
#define tab_prefixof(i) codetabof(i)
|
||||
#define tab_suffixof(i) ((char_type *)(htab))[i]
|
||||
#define de_stack ((char_type *)&tab_suffixof(1 << BITS))
|
||||
|
||||
#define CHECK_GAP 10000 /* Ratio check interval. */
|
||||
|
||||
/*
|
||||
* the next two codes should not be changed lightly, as they must not
|
||||
* lie within the contiguous general code space.
|
||||
*/
|
||||
#define FIRST 257 /* First free entry. */
|
||||
#define CLEAR 256 /* Table clear output code. */
|
||||
|
||||
/*-
|
||||
* Algorithm from "A Technique for High Performance Data Compression",
|
||||
* Terry A. Welch, IEEE Computer Vol 17, No 6 (June 1984), pp 8-19.
|
||||
*
|
||||
* Algorithm:
|
||||
* Modified Lempel-Ziv method (LZW). Basically finds common
|
||||
* substrings and replaces them with a variable size code. This is
|
||||
* deterministic, and can be done on the fly. Thus, the decompression
|
||||
* procedure needs no input table, but tracks the way the table was built.
|
||||
*/
|
||||
|
||||
#if 0
|
||||
static int
|
||||
zclose(s_zstate_t *zs)
|
||||
{
|
||||
free(zs);
|
||||
return (0);
|
||||
}
|
||||
#endif
|
||||
|
||||
/*-
|
||||
* Output the given code.
|
||||
* Inputs:
|
||||
* code: A n_bits-bit integer. If == -1, then EOF. This assumes
|
||||
* that n_bits =< (long)wordsize - 1.
|
||||
* Outputs:
|
||||
* Outputs code to the file.
|
||||
* Assumptions:
|
||||
* Chars are 8 bits long.
|
||||
* Algorithm:
|
||||
* Maintain a BITS character long buffer (so that 8 codes will
|
||||
* fit in it exactly). Use the VAX insv instruction to insert each
|
||||
* code in turn. When the buffer fills up empty it and start over.
|
||||
*/
|
||||
|
||||
static char_type rmask[9] =
|
||||
{0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f, 0xff};
|
||||
|
||||
/*
|
||||
* Decompress read. This routine adapts to the codes in the file building
|
||||
* the "string" table on-the-fly; requiring no table to be stored in the
|
||||
* compressed file. The tables used herein are shared with those of the
|
||||
* compress() routine. See the definitions above.
|
||||
*/
|
||||
static int
|
||||
zread(s_zstate_t *zs)
|
||||
{
|
||||
unsigned int count;
|
||||
|
||||
if (in_count == 0)
|
||||
return -1;
|
||||
if (zs->avail_out == 0)
|
||||
return 0;
|
||||
|
||||
count = zs->avail_out;
|
||||
switch (state) {
|
||||
case S_START:
|
||||
state = S_MIDDLE;
|
||||
break;
|
||||
case S_MIDDLE:
|
||||
goto middle;
|
||||
case S_EOF:
|
||||
goto eof;
|
||||
}
|
||||
|
||||
maxbits = *(zs->next_in); /* Set -b from file. */
|
||||
zs->avail_in--;
|
||||
zs->next_in++;
|
||||
zs->total_in++;
|
||||
in_count--;
|
||||
block_compress = maxbits & BLOCK_MASK;
|
||||
maxbits &= BIT_MASK;
|
||||
maxmaxcode = 1L << maxbits;
|
||||
if (maxbits > BITS) {
|
||||
return -1;
|
||||
}
|
||||
/* As above, initialize the first 256 entries in the table. */
|
||||
maxcode = MAXCODE(n_bits = INIT_BITS);
|
||||
for (code = 255; code >= 0; code--) {
|
||||
tab_prefixof(code) = 0;
|
||||
tab_suffixof(code) = (char_type) code;
|
||||
}
|
||||
free_ent = block_compress ? FIRST : 256;
|
||||
|
||||
finchar = oldcode = getcode(zs);
|
||||
if (oldcode == -1) /* EOF already? */
|
||||
return 0; /* Get out of here */
|
||||
|
||||
/* First code must be 8 bits = char. */
|
||||
*(zs->next_out)++ = (unsigned char)finchar;
|
||||
zs->total_out++;
|
||||
count--;
|
||||
stackp = de_stack;
|
||||
|
||||
while ((code = getcode(zs)) > -1) {
|
||||
if ((code == CLEAR) && block_compress) {
|
||||
for (code = 255; code >= 0; code--)
|
||||
tab_prefixof(code) = 0;
|
||||
clear_flg = 1;
|
||||
free_ent = FIRST - 1;
|
||||
if ((code = getcode(zs)) == -1)
|
||||
/* O, untimely death! */
|
||||
break;
|
||||
}
|
||||
incode = code;
|
||||
|
||||
/* Special case for KwKwK string. */
|
||||
if (code >= free_ent) {
|
||||
*stackp++ = finchar;
|
||||
code = oldcode;
|
||||
}
|
||||
|
||||
/* Generate output characters in reverse order. */
|
||||
while (code >= 256) {
|
||||
*stackp++ = tab_suffixof(code);
|
||||
code = tab_prefixof(code);
|
||||
}
|
||||
*stackp++ = finchar = tab_suffixof(code);
|
||||
|
||||
/* And put them out in forward order. */
|
||||
middle:
|
||||
if (stackp == de_stack)
|
||||
continue;
|
||||
|
||||
do {
|
||||
if (count-- == 0) {
|
||||
return zs->avail_out;
|
||||
}
|
||||
*(zs->next_out)++ = *--stackp;
|
||||
zs->total_out++;
|
||||
} while (stackp > de_stack);
|
||||
|
||||
/* Generate the new entry. */
|
||||
if ((code = free_ent) < maxmaxcode) {
|
||||
tab_prefixof(code) = (unsigned short) oldcode;
|
||||
tab_suffixof(code) = finchar;
|
||||
free_ent = code + 1;
|
||||
}
|
||||
|
||||
/* Remember previous code. */
|
||||
oldcode = incode;
|
||||
}
|
||||
/* state = S_EOF; */
|
||||
eof: return (zs->avail_out - count);
|
||||
}
|
||||
|
||||
/*-
|
||||
* Read one code from the standard input. If EOF, return -1.
|
||||
* Inputs:
|
||||
* stdin
|
||||
* Outputs:
|
||||
* code or -1 is returned.
|
||||
*/
|
||||
static code_int
|
||||
getcode(s_zstate_t *zs)
|
||||
{
|
||||
code_int gcode;
|
||||
int r_off, bits;
|
||||
char_type *bp;
|
||||
|
||||
bp = gbuf;
|
||||
if (clear_flg > 0 || roffset >= size || free_ent > maxcode) {
|
||||
/*
|
||||
* If the next entry will be too big for the current gcode
|
||||
* size, then we must increase the size. This implies reading
|
||||
* a new buffer full, too.
|
||||
*/
|
||||
if (free_ent > maxcode) {
|
||||
n_bits++;
|
||||
if (n_bits == maxbits) /* Won't get any bigger now. */
|
||||
maxcode = maxmaxcode;
|
||||
else
|
||||
maxcode = MAXCODE(n_bits);
|
||||
}
|
||||
if (clear_flg > 0) {
|
||||
maxcode = MAXCODE(n_bits = INIT_BITS);
|
||||
clear_flg = 0;
|
||||
}
|
||||
if ( zs->avail_in < (unsigned int)n_bits && in_count > (long)n_bits ) {
|
||||
memcpy (buf, zs->next_in, zs->avail_in);
|
||||
buf_len = zs->avail_in;
|
||||
zs->avail_in = 0;
|
||||
return -1;
|
||||
}
|
||||
if (buf_len) {
|
||||
memcpy (gbuf, buf, buf_len);
|
||||
memcpy (gbuf + buf_len, zs->next_in,
|
||||
n_bits - buf_len);
|
||||
zs->next_in += n_bits - buf_len;
|
||||
zs->avail_in -= n_bits - buf_len;
|
||||
buf_len = 0;
|
||||
zs->total_in += n_bits;
|
||||
size = n_bits;
|
||||
in_count -= n_bits;
|
||||
} else {
|
||||
if (in_count > n_bits) {
|
||||
memcpy (gbuf, zs->next_in, n_bits);
|
||||
zs->next_in += n_bits;
|
||||
zs->avail_in -= n_bits;
|
||||
zs->total_in += n_bits;
|
||||
size = n_bits;
|
||||
in_count -= n_bits;
|
||||
} else {
|
||||
memcpy (gbuf, zs->next_in, in_count);
|
||||
zs->next_in += in_count;
|
||||
zs->avail_in -= in_count;
|
||||
zs->total_in += in_count;
|
||||
size = in_count;
|
||||
in_count = 0;
|
||||
}
|
||||
}
|
||||
roffset = 0;
|
||||
/* Round size down to integral number of codes. */
|
||||
size = (size << 3) - (n_bits - 1);
|
||||
}
|
||||
r_off = roffset;
|
||||
bits = n_bits;
|
||||
|
||||
/* Get to the first byte. */
|
||||
bp += (r_off >> 3);
|
||||
r_off &= 7;
|
||||
|
||||
/* Get first part (low order bits). */
|
||||
gcode = (*bp++ >> r_off);
|
||||
bits -= (8 - r_off);
|
||||
r_off = 8 - r_off; /* Now, roffset into gcode word. */
|
||||
|
||||
/* Get any 8 bit parts in the middle (<=1 for up to 16 bits). */
|
||||
if (bits >= 8) {
|
||||
gcode |= *bp++ << r_off;
|
||||
r_off += 8;
|
||||
bits -= 8;
|
||||
}
|
||||
|
||||
/* High order bits. */
|
||||
gcode |= (*bp & rmask[bits]) << r_off;
|
||||
roffset += n_bits;
|
||||
|
||||
return (gcode);
|
||||
}
|
||||
|
||||
static void
|
||||
zinit(s_zstate_t *zs)
|
||||
{
|
||||
memset(zs, 0, sizeof (s_zstate_t));
|
||||
|
||||
maxbits = BITS; /* User settable max # bits/code. */
|
||||
maxmaxcode = 1 << maxbits; /* Should NEVER generate this code. */
|
||||
hsize = HSIZE; /* For dynamic table sizing. */
|
||||
free_ent = 0; /* First unused entry. */
|
||||
block_compress = BLOCK_MASK;
|
||||
clear_flg = 0;
|
||||
state = S_START;
|
||||
roffset = 0;
|
||||
size = 0;
|
||||
}
|
||||
114
src/lzw/zopen.h
114
src/lzw/zopen.h
|
|
@ -1,114 +0,0 @@
|
|||
/* $NetBSD: zopen.c,v 1.8 2003/08/07 11:13:29 agc Exp $ */
|
||||
|
||||
/*-
|
||||
* Copyright (c) 1985, 1986, 1992, 1993
|
||||
* The Regents of the University of California. All rights reserved.
|
||||
*
|
||||
* This code is derived from software contributed to Berkeley by
|
||||
* Diomidis Spinellis and James A. Woods, derived from original
|
||||
* work by Spencer Thomas and Joseph Orost.
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
* 1. Redistributions of source code must retain the above copyright
|
||||
* notice, this list of conditions and the following disclaimer.
|
||||
* 2. Redistributions in binary form must reproduce the above copyright
|
||||
* notice, this list of conditions and the following disclaimer in the
|
||||
* documentation and/or other materials provided with the distribution.
|
||||
* 3. Neither the name of the University nor the names of its contributors
|
||||
* may be used to endorse or promote products derived from this software
|
||||
* without specific prior written permission.
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
|
||||
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
||||
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
||||
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
||||
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*/
|
||||
|
||||
/*-
|
||||
*
|
||||
* Copyright (c) 2004
|
||||
* Albert Chin-A-Young.
|
||||
*
|
||||
* Modified to work with FreeType's PCF driver.
|
||||
*
|
||||
*/
|
||||
|
||||
#if defined(LIBC_SCCS) && !defined(lint)
|
||||
#if 0
|
||||
static char sccsid[] = "@(#)zopen.c 8.1 (Berkeley) 6/27/93";
|
||||
#else
|
||||
static char rcsid[] = "$NetBSD: zopen.c,v 1.8 2003/08/07 11:13:29 agc Exp $";
|
||||
#endif
|
||||
#endif /* LIBC_SCCS and not lint */
|
||||
|
||||
#include <stdio.h>
|
||||
|
||||
#define BITS 16 /* Default bits. */
|
||||
#define HSIZE 69001 /* 95% occupancy */
|
||||
|
||||
/* A code_int must be able to hold 2**BITS values of type int, and also -1. */
|
||||
typedef long code_int;
|
||||
typedef long count_int;
|
||||
|
||||
typedef unsigned char char_type;
|
||||
|
||||
typedef enum {
|
||||
S_START, S_MIDDLE, S_EOF
|
||||
} zs_enum;
|
||||
|
||||
typedef struct {
|
||||
unsigned char *next_in;
|
||||
unsigned int avail_in;
|
||||
unsigned long total_in;
|
||||
|
||||
unsigned char *next_out;
|
||||
unsigned int avail_out;
|
||||
unsigned long total_out;
|
||||
|
||||
zs_enum zs_state; /* State of computation */
|
||||
int zs_n_bits; /* Number of bits/code. */
|
||||
int zs_maxbits; /* User settable max # bits/code. */
|
||||
code_int zs_maxcode; /* Maximum code, given n_bits. */
|
||||
code_int zs_maxmaxcode; /* Should NEVER generate this code. */
|
||||
count_int zs_htab [HSIZE];
|
||||
unsigned short zs_codetab [HSIZE];
|
||||
code_int zs_hsize; /* For dynamic table sizing. */
|
||||
code_int zs_free_ent; /* First unused entry. */
|
||||
/*
|
||||
* Block compression parameters -- after all codes are used up,
|
||||
* and compression rate changes, start over.
|
||||
*/
|
||||
int zs_block_compress;
|
||||
int zs_clear_flg;
|
||||
int zs_offset;
|
||||
long zs_in_count; /* Remaining uncompressed bytes. */
|
||||
char_type zs_buf_len;
|
||||
char_type zs_buf[BITS]; /* Temporary buffer if we need
|
||||
to read more to accumulate
|
||||
n_bits. */
|
||||
union {
|
||||
struct {
|
||||
char_type *zs_stackp;
|
||||
int zs_finchar;
|
||||
code_int zs_code, zs_oldcode, zs_incode;
|
||||
int zs_roffset, zs_size;
|
||||
char_type zs_gbuf[BITS];
|
||||
} r; /* Read parameters */
|
||||
} u;
|
||||
} s_zstate_t;
|
||||
|
||||
static code_int getcode(s_zstate_t *);
|
||||
#if 0
|
||||
static int zclose(s_zstate_t *);
|
||||
#endif
|
||||
static void zinit(s_zstate_t *);
|
||||
static int zread(s_zstate_t *);
|
||||
Loading…
Reference in New Issue