xref: /xsrc/external/mit/bdftopcf/dist/pcfwrite.c

/*

Copyright 1990, 1994, 1998  The Open Group

Permission to use, copy, modify, distribute, and sell this software and its
documentation for any purpose is hereby granted without fee, provided that
the above copyright notice appear in all copies and that both that
copyright notice and this permission notice appear in supporting
documentation.

The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
IN NO EVENT SHALL THE OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR
OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.

Except as contained in this notice, the name of The Open Group shall
not be used in advertising or otherwise to promote the sale, use or
other dealings in this Software without prior written authorization
from The Open Group.

*/

/*
 * Author:  Keith Packard, MIT X Consortium
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "fntfilst.h"
#include "bitmap.h"
#include "pcf.h"

#include <stdarg.h>
#include <stdio.h>

/* Write PCF font files */

static CARD32 current_position;

static void _X_ATTRIBUTE_PRINTF(1, 2)
pcfError(const char *message, ...)
{
    va_list args;

    va_start(args, message);

    fprintf(stderr, "PCF Error: ");
    vfprintf(stderr, message, args);
    va_end(args);
}

static int
pcfWrite(FontFilePtr file, char *b, int c)
{
    current_position += c;
    return FontFileWrite(file, b, c);
}

static int
pcfPutLSB32(FontFilePtr file, int c)
{
    current_position += 4;
    (void) FontFilePutc(c, file);
    (void) FontFilePutc(c >> 8, file);
    (void) FontFilePutc(c >> 16, file);
    return FontFilePutc(c >> 24, file);
}

static int
pcfPutINT32(FontFilePtr file, CARD32 format, int c)
{
    current_position += 4;
    if (PCF_BYTE_ORDER(format) == MSBFirst) {
        (void) FontFilePutc(c >> 24, file);
        (void) FontFilePutc(c >> 16, file);
        (void) FontFilePutc(c >> 8, file);
        return FontFilePutc(c, file);
    }
    else {
        (void) FontFilePutc(c, file);
        (void) FontFilePutc(c >> 8, file);
        (void) FontFilePutc(c >> 16, file);
        return FontFilePutc(c >> 24, file);
    }
}

static int
pcfPutINT16(FontFilePtr file, CARD32 format, int c)
{
    current_position += 2;
    if (PCF_BYTE_ORDER(format) == MSBFirst) {
        (void) FontFilePutc(c >> 8, file);
        return FontFilePutc(c, file);
    }
    else {
        (void) FontFilePutc(c, file);
        return FontFilePutc(c >> 8, file);
    }
}

/*ARGSUSED*/
static int
pcfPutINT8(FontFilePtr file, CARD32 format, int c)
{
    current_position += 1;
    return FontFilePutc(c, file);
}

static void
pcfWriteTOC(FontFilePtr file, PCFTablePtr table, int count)
{
    CARD32 version = PCF_FILE_VERSION;

    pcfPutLSB32(file, version);
    pcfPutLSB32(file, count);
    for (int i = 0; i < count; i++) {
        pcfPutLSB32(file, table->type);
        pcfPutLSB32(file, table->format);
        pcfPutLSB32(file, table->size);
        pcfPutLSB32(file, table->offset);
        table++;
    }
}

static void
pcfPutCompressedMetric(FontFilePtr file, CARD32 format, xCharInfo * metric)
{
    pcfPutINT8(file, format, metric->leftSideBearing + 0x80);
    pcfPutINT8(file, format, metric->rightSideBearing + 0x80);
    pcfPutINT8(file, format, metric->characterWidth + 0x80);
    pcfPutINT8(file, format, metric->ascent + 0x80);
    pcfPutINT8(file, format, metric->descent + 0x80);
}

static void
pcfPutMetric(FontFilePtr file, CARD32 format, xCharInfo * metric)
{
    pcfPutINT16(file, format, metric->leftSideBearing);
    pcfPutINT16(file, format, metric->rightSideBearing);
    pcfPutINT16(file, format, metric->characterWidth);
    pcfPutINT16(file, format, metric->ascent);
    pcfPutINT16(file, format, metric->descent);
    pcfPutINT16(file, format, metric->attributes);
}

static void
pcfPutBitmap(FontFilePtr file, CARD32 format, CharInfoPtr pCI)
{
    int count;
    unsigned char *bits;

    count = BYTES_FOR_GLYPH(pCI, PCF_GLYPH_PAD(format));
    bits = (unsigned char *) pCI->bits;
    current_position += count;
    while (count--)
        FontFilePutc(*bits++, file);
}

static void
pcfPutAccel(FontFilePtr file, CARD32 format, FontInfoPtr pFontInfo)
{
    pcfPutINT8(file, format, pFontInfo->noOverlap);
    pcfPutINT8(file, format, pFontInfo->constantMetrics);
    pcfPutINT8(file, format, pFontInfo->terminalFont);
    pcfPutINT8(file, format, pFontInfo->constantWidth);
    pcfPutINT8(file, format, pFontInfo->inkInside);
    pcfPutINT8(file, format, pFontInfo->inkMetrics);
    pcfPutINT8(file, format, pFontInfo->drawDirection);
    pcfPutINT8(file, format, 0);
    pcfPutINT32(file, format, pFontInfo->fontAscent);
    pcfPutINT32(file, format, pFontInfo->fontDescent);
    pcfPutINT32(file, format, pFontInfo->maxOverlap);
    pcfPutMetric(file, format, &pFontInfo->minbounds);
    pcfPutMetric(file, format, &pFontInfo->maxbounds);
    if (PCF_FORMAT_MATCH(format, PCF_ACCEL_W_INKBOUNDS)) {
        pcfPutMetric(file, format, &pFontInfo->ink_minbounds);
        pcfPutMetric(file, format, &pFontInfo->ink_maxbounds);
    }
}

#define S32 4
#define S16 2
#define S8 1

#define Pad(s)	    (RoundUp(s) - (s))
#define RoundUp(s)  (((s) + 3) & ~3)

#define Compressable(i)	(-128 <= (i) && (i) <= 127)

#define CanCompressMetric(m)	(Compressable((m)->leftSideBearing) && \
				 Compressable((m)->rightSideBearing) && \
				 Compressable((m)->characterWidth) && \
				 Compressable((m)->ascent) && \
				 Compressable((m)->descent) && \
				 (m)->attributes == 0)

#define CanCompressMetrics(min,max) (CanCompressMetric(min) && CanCompressMetric(max))

static char *
pcfNameForAtom(Atom a)
{
    return NameForAtom(a);
}

int
pcfWriteFont(FontPtr pFont, FontFilePtr file)
{
    PCFTableRec tables[32] = { { 0 } }, *table;
    CARD32      mask;
    int         ntables;
    int         size;
    CARD32      format;
    int         i;
    int         cur_table;
    int         prop_string_size;
    int         glyph_string_size;
    xCharInfo  *minbounds, *maxbounds;
    xCharInfo  *ink_minbounds, *ink_maxbounds;
    BitmapFontPtr bitmapFont;
    int         nencodings = 0;
    int         header_size;
    FontPropPtr offsetProps;
    int         prop_pad = 0;
    char       *atom_name;
    int         glyph;
    CARD32      offset;

    bitmapFont = (BitmapFontPtr) pFont->fontPrivate;
    if (bitmapFont->bitmapExtra) {
        minbounds = &bitmapFont->bitmapExtra->info.minbounds;
        maxbounds = &bitmapFont->bitmapExtra->info.maxbounds;
        ink_minbounds = &bitmapFont->bitmapExtra->info.ink_minbounds;
        ink_maxbounds = &bitmapFont->bitmapExtra->info.ink_maxbounds;
    }
    else {
        minbounds = &pFont->info.minbounds;
        maxbounds = &pFont->info.maxbounds;
        ink_minbounds = &pFont->info.ink_minbounds;
        ink_maxbounds = &pFont->info.ink_maxbounds;
    }
    offsetProps = malloc(pFont->info.nprops * sizeof(FontPropRec));
    if (!offsetProps) {
        pcfError("pcfWriteFont(): Couldn't allocate offsetProps (%d*%d)",
                 pFont->info.nprops, (int) sizeof(FontPropRec));
        return AllocError;
    }
    prop_string_size = 0;
    for (i = 0; i < pFont->info.nprops; i++) {
        offsetProps[i].name = prop_string_size;
        prop_string_size +=
            strlen(pcfNameForAtom(pFont->info.props[i].name)) + 1;
        if (pFont->info.isStringProp[i]) {
            offsetProps[i].value = prop_string_size;
            prop_string_size +=
                strlen(pcfNameForAtom(pFont->info.props[i].value)) + 1;
        }
        else
            offsetProps[i].value = pFont->info.props[i].value;
    }
    format = PCF_FORMAT(pFont->bit, pFont->byte, pFont->glyph, pFont->scan);
    mask = 0xFFFFFFF;
    ntables = 0;
    table = tables;
    while (mask) {
        CARD32 bit = lowbit(mask);
        mask &= ~bit;
        table->type = bit;
        switch (bit) {
        case PCF_PROPERTIES:
            table->format = PCF_DEFAULT_FORMAT | format;
            size = S32 + S32 + (S32 + S8 + S32) * pFont->info.nprops;
            prop_pad = Pad(size);
            table->size = RoundUp(size) + S32 + RoundUp(prop_string_size);
            table++;
            break;
        case PCF_ACCELERATORS:
            if (bitmapFont->bitmapExtra->info.inkMetrics)
                table->format = PCF_ACCEL_W_INKBOUNDS | format;
            else
                table->format = PCF_DEFAULT_FORMAT | format;
            table->size = 100;
            table++;
            break;
        case PCF_METRICS:
            if (CanCompressMetrics(minbounds, maxbounds)) {
                table->format = PCF_COMPRESSED_METRICS | format;
                size = S32 + S16 + bitmapFont->num_chars * (5 * S8);
                table->size = RoundUp(size);
            }
            else {
                table->format = PCF_DEFAULT_FORMAT | format;
                table->size = S32 + S32 + bitmapFont->num_chars * (6 * S16);
            }
            table++;
            break;
        case PCF_BITMAPS:
            table->format = PCF_DEFAULT_FORMAT | format;
            size = S32 + S32 + bitmapFont->num_chars * S32 +
                GLYPHPADOPTIONS * S32 +
                bitmapFont->bitmapExtra->
                bitmapsSizes[PCF_GLYPH_PAD_INDEX(format)];
            table->size = RoundUp(size);
            table++;
            break;
        case PCF_INK_METRICS:
            if (bitmapFont->ink_metrics) {
                if (CanCompressMetrics(ink_minbounds, ink_maxbounds)) {
                    table->format = PCF_COMPRESSED_METRICS | format;
                    size = S32 + S16 + bitmapFont->num_chars * (5 * S8);
                    table->size = RoundUp(size);
                }
                else {
                    table->format = PCF_DEFAULT_FORMAT | format;
                    table->size = S32 + S32 + bitmapFont->num_chars * (6 * S16);
                }
                table++;
            }
            break;
        case PCF_BDF_ENCODINGS:
            table->format = PCF_DEFAULT_FORMAT | format;
            nencodings = (pFont->info.lastRow - pFont->info.firstRow + 1) *
                (pFont->info.lastCol - pFont->info.firstCol + 1);
            size = S32 + 5 * S16 + nencodings * S16;
            table->size = RoundUp(size);
            table++;
            break;
        case PCF_SWIDTHS:
            table->format = PCF_DEFAULT_FORMAT | format;
            table->size = S32 + S32 + bitmapFont->num_chars * S32;
            table++;
            break;
        case PCF_GLYPH_NAMES:
            table->format = PCF_DEFAULT_FORMAT | format;
            glyph_string_size = 0;
            for (i = 0; i < bitmapFont->num_chars; i++)
                glyph_string_size +=
                    strlen(pcfNameForAtom
                           (bitmapFont->bitmapExtra->glyphNames[i])) + 1;
            table->size =
                S32 + S32 + bitmapFont->num_chars * S32 + S32 +
                RoundUp(glyph_string_size);
            table++;
            break;
        case PCF_BDF_ACCELERATORS:
            if (pFont->info.inkMetrics)
                table->format = PCF_ACCEL_W_INKBOUNDS | format;
            else
                table->format = PCF_DEFAULT_FORMAT | format;
            table->size = 100;
            table++;
            break;
        }
    }
    ntables = table - tables;
    offset = 0;
    header_size = S32 + S32 + ntables * (4 * S32);
    offset = header_size;
    for (cur_table = 0, table = tables;
         cur_table < ntables; cur_table++, table++) {
        table->offset = offset;
        offset += table->size;
    }
    current_position = 0;
    pcfWriteTOC(file, tables, ntables);
    for (cur_table = 0, table = tables;
         cur_table < ntables; cur_table++, table++) {
        if (current_position > table->offset) {
            printf("can't go backwards... %d > %d\n",
                   (int) current_position, (int) table->offset);
            free(offsetProps);
            return BadFontName;
        }
        while (current_position < table->offset)
            pcfPutINT8(file, format, '\0');
        pcfPutLSB32(file, table->format);
        switch (table->type) {
        case PCF_PROPERTIES:
            pcfPutINT32(file, format, pFont->info.nprops);
            for (i = 0; i < pFont->info.nprops; i++) {
                pcfPutINT32(file, format, offsetProps[i].name);
                pcfPutINT8(file, format, pFont->info.isStringProp[i]);
                pcfPutINT32(file, format, offsetProps[i].value);
            }
            for (i = 0; i < prop_pad; i++)
                pcfPutINT8(file, format, 0);
            pcfPutINT32(file, format, prop_string_size);
            for (i = 0; i < pFont->info.nprops; i++) {
                atom_name = pcfNameForAtom(pFont->info.props[i].name);
                pcfWrite(file, atom_name, strlen(atom_name) + 1);
                if (pFont->info.isStringProp[i]) {
                    atom_name = pcfNameForAtom(pFont->info.props[i].value);
                    pcfWrite(file, atom_name, strlen(atom_name) + 1);
                }
            }
            break;
        case PCF_ACCELERATORS:
            pcfPutAccel(file, table->format, &bitmapFont->bitmapExtra->info);
            break;
        case PCF_METRICS:
            if (PCF_FORMAT_MATCH(table->format, PCF_COMPRESSED_METRICS)) {
                pcfPutINT16(file, format, bitmapFont->num_chars);
                for (i = 0; i < bitmapFont->num_chars; i++)
                    pcfPutCompressedMetric(file, format,
                                           &bitmapFont->metrics[i].metrics);
            }
            else {
                pcfPutINT32(file, format, bitmapFont->num_chars);
                for (i = 0; i < bitmapFont->num_chars; i++)
                    pcfPutMetric(file, format, &bitmapFont->metrics[i].metrics);
            }
            break;
        case PCF_BITMAPS:
            pcfPutINT32(file, format, bitmapFont->num_chars);
            glyph = PCF_GLYPH_PAD(format);
            offset = 0;
            for (i = 0; i < bitmapFont->num_chars; i++) {
                pcfPutINT32(file, format, offset);
                offset += BYTES_FOR_GLYPH(&bitmapFont->metrics[i], glyph);
            }
            for (i = 0; i < GLYPHPADOPTIONS; i++) {
                pcfPutINT32(file, format,
                            bitmapFont->bitmapExtra->bitmapsSizes[i]);
            }
            for (i = 0; i < bitmapFont->num_chars; i++)
                pcfPutBitmap(file, format, &bitmapFont->metrics[i]);
            break;
        case PCF_INK_METRICS:
            if (PCF_FORMAT_MATCH(table->format, PCF_COMPRESSED_METRICS)) {
                pcfPutINT16(file, format, bitmapFont->num_chars);
                for (i = 0; i < bitmapFont->num_chars; i++)
                    pcfPutCompressedMetric(file, format,
                                           &bitmapFont->ink_metrics[i]);
            }
            else {
                pcfPutINT32(file, format, bitmapFont->num_chars);
                for (i = 0; i < bitmapFont->num_chars; i++)
                    pcfPutMetric(file, format, &bitmapFont->ink_metrics[i]);
            }
            break;
        case PCF_BDF_ENCODINGS:
            pcfPutINT16(file, format, pFont->info.firstCol);
            pcfPutINT16(file, format, pFont->info.lastCol);
            pcfPutINT16(file, format, pFont->info.firstRow);
            pcfPutINT16(file, format, pFont->info.lastRow);
            pcfPutINT16(file, format, pFont->info.defaultCh);
            for (i = 0; i < nencodings; i++) {
                if (ACCESSENCODING(bitmapFont->encoding, i))
                    pcfPutINT16(file, format,
                                ACCESSENCODING(bitmapFont->encoding, i) -
                                bitmapFont->metrics);
                else
                    pcfPutINT16(file, format, 0xFFFF);
            }
            break;
        case PCF_SWIDTHS:
            pcfPutINT32(file, format, bitmapFont->num_chars);
            for (i = 0; i < bitmapFont->num_chars; i++)
                pcfPutINT32(file, format, bitmapFont->bitmapExtra->sWidths[i]);
            break;
        case PCF_GLYPH_NAMES:
            pcfPutINT32(file, format, bitmapFont->num_chars);
            offset = 0;
            for (i = 0; i < bitmapFont->num_chars; i++) {
                pcfPutINT32(file, format, offset);
                offset +=
                    strlen(pcfNameForAtom
                           (bitmapFont->bitmapExtra->glyphNames[i])) + 1;
            }
            pcfPutINT32(file, format, offset);
            for (i = 0; i < bitmapFont->num_chars; i++) {
                atom_name =
                    pcfNameForAtom(bitmapFont->bitmapExtra->glyphNames[i]);
                pcfWrite(file, atom_name, strlen(atom_name) + 1);
            }
            break;
        case PCF_BDF_ACCELERATORS:
            pcfPutAccel(file, table->format, &pFont->info);
            break;
        }
    }

    free(offsetProps);
    return Successful;
}