src/ftglue.c

/* ftglue.c: Glue code for compiling the OpenType code from
 *           FreeType 1 using only the public API of FreeType 2
 *
 * By David Turner, The FreeType Project (www.freetype.org)
 *
 * This code is explicitely put in the public domain
 *
 * See ftglue.h for more information.
 */

#include "ftglue.h"

#if 0
#  include <stdio.h>
#  define LOG(x) ftglue_log x

static void
ftglue_log( const char*   format, ... )
{
  va_list  ap;

  va_start( ap, format );
  vfprintf( stderr, format, ap );
  va_end( ap );
}

#else
#  define LOG(x) \
      do {       \
      } while (0)
#endif

/* only used internally */
static FT_Pointer
ftglue_qalloc (FT_Memory memory,
               FT_ULong  size,
               FT_Error *perror)
{
    FT_Error   error = 0;
    FT_Pointer block = NULL;

    if (size > 0) {
	block = memory->alloc (memory, size);
	if (!block)
	    error = FT_Err_Out_Of_Memory;
    }

    *perror = error;
    return block;
}

#undef QALLOC /* just in case */
#define QALLOC(ptr, size) ((ptr) = ftglue_qalloc (memory, (size), &error), error != 0)
#define FREE(_ptr)                      \
    do {                                \
	if ((_ptr)) {                   \
	    ftglue_free (memory, _ptr); \
	    _ptr = NULL;                \
	}                               \
    } while (0)

static void
ftglue_free (FT_Memory  memory,
             FT_Pointer block)
{
    if (block)
	memory->free (memory, block);
}

FTGLUE_APIDEF (FT_Long)
ftglue_stream_pos (FT_Stream stream)
{
    LOG (("ftglue:stream:pos() -> %ld\n", stream->pos));
    return stream->pos;
}

FTGLUE_APIDEF (FT_Error)
ftglue_stream_seek (FT_Stream stream,
                    FT_Long   pos)
{
    FT_Error error = 0;

    if (stream->read) {
	if (stream->read (stream, pos, 0, 0))
	    error = FT_Err_Invalid_Stream_Operation;
    } else if (pos < 0 || (FT_ULong)pos > stream->size)
	error = FT_Err_Invalid_Stream_Operation;

    if (!error)
	stream->pos = pos;
    LOG (("ftglue:stream:seek(%ld) -> %d\n", pos, error));
    return error;
}

FTGLUE_APIDEF (FT_Error)
ftglue_stream_frame_enter (FT_Stream stream,
                           FT_ULong  count)
{
    FT_Error error = FT_Err_Ok;
    FT_ULong read_bytes;

    if (stream->read) {
	/* allocate the frame in memory */
	FT_Memory memory = stream->memory;

	if (QALLOC (stream->base, count))
	    goto Exit;

	/* read it */
	read_bytes = stream->read (stream, stream->pos,
	                           stream->base, count);
	if (read_bytes < count) {
	    FREE (stream->base);
	    error = FT_Err_Invalid_Stream_Operation;
	}
	stream->cursor = stream->base;
	stream->limit = stream->cursor + count;
	stream->pos += read_bytes;
    } else {
	/* check current and new position */
	if (stream->pos >= stream->size ||
	    stream->pos + count > stream->size) {
	    error = FT_Err_Invalid_Stream_Operation;
	    goto Exit;
	}

	/* set cursor */
	stream->cursor = stream->base + stream->pos;
	stream->limit = stream->cursor + count;
	stream->pos += count;
    }

Exit:
    LOG (("ftglue:stream:frame_enter(%ld) -> %d\n", count, error));
    return error;
}

FTGLUE_APIDEF (void)
ftglue_stream_frame_exit (FT_Stream stream)
{
    if (stream->read) {
	FT_Memory memory = stream->memory;

	FREE (stream->base);
    }
    stream->cursor = 0;
    stream->limit = 0;

    LOG (("ftglue:stream:frame_exit()\n"));
}

FTGLUE_APIDEF (FT_Error)
ftglue_face_goto_table (FT_Face   face,
                        FT_ULong  the_tag,
                        FT_Stream stream,
                        FT_ULong *table_size)
{
    FT_Error error;

    LOG (("ftglue_face_goto_table( %p, %c%c%c%c, %p )\n",
          face,
          (int)((the_tag >> 24) & 0xFF),
          (int)((the_tag >> 16) & 0xFF),
          (int)((the_tag >> 8) & 0xFF),
          (int)(the_tag & 0xFF),
          stream));

    if (!FT_IS_SFNT (face)) {
	LOG (("not a SFNT face !!\n"));
	error = FT_Err_Invalid_Face_Handle;
    } else {
	/* parse the directory table directly, without using
	 * FreeType's built-in data structures
	 */
	FT_ULong offset = 0, sig;
	FT_UInt  count, nn;

	if (FILE_Seek (0) || ACCESS_Frame (4))
	    goto Exit;

	sig = GET_Tag4();

	FORGET_Frame();

	if (sig == FT_MAKE_TAG ('t', 't', 'c', 'f')) {
	    /* deal with TrueType collections */

	    LOG ((">> This is a TrueType Collection\n"));

	    if (FILE_Seek (12 + face->face_index * 4) ||
	        ACCESS_Frame (4))
		goto Exit;

	    offset = GET_ULong();

	    FORGET_Frame();
	}

	LOG (("TrueType offset = %ld\n", offset));

	if (FILE_Seek (offset + 4) ||
	    ACCESS_Frame (2))
	    goto Exit;

	count = GET_UShort();

	FORGET_Frame();

	if (FILE_Seek (offset + 12) ||
	    ACCESS_Frame (count * 16))
	    goto Exit;

	for (nn = 0; nn < count; nn++) {
	    FT_ULong tag = GET_ULong();
	    FT_ULong checksum FC_UNUSED = GET_ULong();
	    FT_ULong start = GET_ULong();
	    FT_ULong size FC_UNUSED = GET_ULong();

	    if (tag == the_tag) {
		LOG (("TrueType table (start: %ld) (size: %ld)\n", start, size));
		error = ftglue_stream_seek (stream, start);
		if (table_size)
		    *table_size = size;
		goto FoundIt;
	    }
	}
	error = FT_Err_Table_Missing;

    FoundIt:
	FORGET_Frame();
    }

Exit:
    LOG (("TrueType error=%d\n", error));

    return error;
}

#undef QALLOC
#include "fcaliastail.h"
#undef __ftglue__