/****************************************************************************
 *
 * pklib.c
 *
 *   FreeType font driver for TeX's PK FONT files.
 *
 * Copyright 1996-2018 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_FREETYPE_H
#include FT_INTERNAL_DEBUG_H
#include FT_INTERNAL_STREAM_H
#include FT_INTERNAL_OBJECTS_H
#include FT_SYSTEM_H
#include FT_CONFIG_CONFIG_H
#include FT_ERRORS_H
#include FT_TYPES_H

#include "pk.h"
#include "pkdrivr.h"
#include "pkerror.h"


  /**************************************************************************
   *
   * The macro FT_COMPONENT is used in trace mode.  It is an implicit
   * parameter of the FT_TRACE() and FT_ERROR() macros, used to print/log
   * messages during execution.
   */
#undef  FT_COMPONENT
#define FT_COMPONENT  trace_pklib

FT_Byte  bits_table[] = {
  0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };


  /**************************************************************************
   *
   * PK font utility functions.
   *
   */

  FT_Long   pk_read_intn( FT_Stream, FT_Int );
  FT_ULong  pk_read_uintn( FT_Stream, FT_Int );

#define READ_UINT1( stream )    (FT_Byte)pk_read_uintn( stream, 1)
#define READ_UINT2( stream )    (FT_Byte)pk_read_uintn( stream, 2)
#define READ_UINT3( stream )    (FT_Byte)pk_read_uintn( stream, 3)
#define READ_UINT4( stream )    (FT_Byte)pk_read_uintn( stream, 4)
#define READ_UINTN( stream,n)   (FT_ULong)pk_read_uintn( stream, n)
#define READ_INT1( stream )     (FT_String)pk_read_intn( stream, 1)
#define READ_INT2( stream )     (FT_String)pk_read_intn( stream, 2)
#define READ_INT4( stream )     (FT_Long)pk_read_intn( stream, 4)

/*
 * Reading a Number from file
 */
  FT_ULong
  pk_read_uintn(FT_Stream stream, FT_Int size)
  {
    FT_ULong  v,k;
    FT_Error  error;
    FT_Byte tp;
    v = 0L;
    while (size >= 1)
    {
      if ( FT_READ_BYTE(tp) )
        return 0;
      k =(FT_ULong)tp;
      v = v*256L + k;
      --size;
    }
    return v;
  }

  FT_Long
  pk_read_intn(FT_Stream stream, FT_Int size)
  {
    FT_Long  v;
    FT_Byte  tp;
    FT_Error error;
    FT_ULong z ;

    if ( FT_READ_BYTE(tp) )
        return 0;
    z= (FT_ULong)tp;
    v = (FT_Long)z & 0xffL;
    if (v & 0x80L)
      v = v - 256L;
    --size;
    while (size >= 1)
    {
      if ( FT_READ_BYTE(tp) )
        return 0;
      z= (FT_ULong)tp;
      v = v*256L + z;
      --size;
		}
    return v;
  }

  FT_Int  pk_read_nyble_rest_cnt;
  FT_Int  pk_read_nyble_max_bytes;

  void
  pk_read_nyble_init( FT_Int max )
  {
    pk_read_nyble_rest_cnt  = 0;
    pk_read_nyble_max_bytes = max;
  }

  FT_Int
  pk_read_nyble(FT_Stream stream)
  {
    static FT_Byte  d;
    FT_Int          v;

    switch (pk_read_nyble_rest_cnt)
    {
    case 0:
      d = READ_UINT1( stream );
      if (--pk_read_nyble_max_bytes < 0)
        return -1L;
      v = d / 0x10;
      d = d % 0x10;
      pk_read_nyble_rest_cnt = 1;
      break;
    case 1:
    default:
      v = d;
      pk_read_nyble_rest_cnt = 0;
      break;
    }
  return v;
  }

  FT_Long
  pk_read_packed_number(FT_Long* repeat, FT_Stream stream, int dyn_f)
  {
    FT_Int   d, n;
    FT_Long  di;

    entry:
      d = pk_read_nyble( stream );
      if (d == 0)
      {
        n = 0;
        do
        {
          di = pk_read_nyble( stream );
          n++;
        }
        while (di == 0);
        for ( ; n > 0; n--)
          di = di*16 + pk_read_nyble( stream );
        return di - 15 + (13 - dyn_f)*16 + dyn_f;
      }
    if (d <= dyn_f)
      return d;
    if (d <= 13)
      return (d - dyn_f - 1)*16 + pk_read_nyble( stream ) + dyn_f + 1;
    *repeat = 1;
    if (d == 14)
      *repeat = pk_read_packed_number(repeat, stream, dyn_f);
    goto entry;
  }

  FT_Int
  pk_read_14( FT_Stream stream,
              FT_ULong rs,
              PK_Bitmap bm )
  {
    FT_Long   x, y, x8, xm;
    FT_Byte   *bm_ptr;
    FT_ULong  bit16_buff;
    FT_Int    rest_bit16_buff;

    static FT_UInt mask_table[] =
      { 0xdead,   0x80,   0xc0,   0xe0,   0xf0,   0xf8,   0xfc,   0xfe, 0xdead };

    if (rs == 0)
      return 0;

    x8 = bm->bbx_width / 8;
    xm = bm->bbx_width % 8;
    bm_ptr = bm->bitmap;

    bit16_buff = READ_UINT1( stream ) << 8;
    FT_TRACE2(( "pk_read_14: bit16_buff is %ld\n",bit16_buff ));
    rest_bit16_buff = 8;
    --rs;

    for(y = 0; y < bm->bbx_height; y++)
    {
      for(x = 0; x < x8; x++)
      {
        *(bm_ptr++) = bit16_buff >> 8;
        rest_bit16_buff -= 8;
        bit16_buff = (bit16_buff << 8) & 0xffff;
        if (rs > 0)
        {
	        bit16_buff |= (READ_UINT1( stream ) << (8 - rest_bit16_buff));
	        rest_bit16_buff += 8;
	        --rs;
        }
      }
      if (xm != 0)
      {
        *(bm_ptr++) = (bit16_buff >> 8) & mask_table[xm];
        rest_bit16_buff -= xm;
        bit16_buff = (bit16_buff << xm) & 0xffff;
        if (rest_bit16_buff < 8)
        {
	        if (rs > 0)
	        {
	          bit16_buff |= (READ_UINT1( stream ) << (8 - rest_bit16_buff));
	          rest_bit16_buff += 8;
	          --rs;
	        }
        }
      }
    }
    return 0;
  }

  FT_Int
  pk_read_n14( FT_Stream stream,
               FT_Int dyn_f,
               FT_Int bw,
               FT_ULong rs,
               PK_Bitmap bm )
  {
    FT_Long   x, y, xx, yy, repeat;
    FT_Int    bits, b_p;
    FT_Byte   *p, *p0, *p1;

    pk_read_nyble_init(rs);
    p    = bm->bitmap;
    bw   = 1-bw;
    bits = 0;
    for (y = 0; y < bm->bbx_height; )
    {
      b_p    = 0;
      repeat = 0;
      p0     = p;
      for (x = 0; x < bm->bbx_width; x++)
      {
        if (bits == 0)
        {
	        bw   = 1-bw;
	        if ((bits = pk_read_packed_number(&repeat, stream, dyn_f)) < 0)
	          return -1;
        }
        if (bw == 1)
	        *p = *p | bits_table[b_p];
        --bits;
        if (++b_p >= 8)
        {
	        b_p = 0;
	        p++;
        }
      }
      if (b_p != 0)
        p++;
      y++;
      for (yy = 0; yy < repeat; yy++)
      {
        p1 = p0;
        for (xx = 0; xx < bm->raster; xx++)
	        *(p++) = *(p1++);
        y++;
      }
    }
    return 0;
  }

  /**************************************************************************
   *
   * API.
   *
   */

  FT_LOCAL_DEF( FT_Error )
  pk_load_font(FT_Stream       stream,
               FT_Memory       extmemory,
               PK_Glyph        *goptr )
  {
    PK_Glyph    go;
    FT_Byte     instr, pre, id;
    FT_Long     ds, check_sum, hppp, vppp, k;
    FT_Long     cc, tfm, dx, dy, dm, w, h, rs;
    FT_Int      flag, dny_f, bw, ess, size;
    FT_Long     hoff, voff, mv_x, mv_y, gptr;
    FT_Int      bc, ec, nchars, index, i;
    FT_Error    error  = FT_Err_Ok;
    FT_Memory   memory = extmemory; /* needed for FT_NEW */
    PK_Encoding encoding = NULL;

    go = NULL;
    nchars = -1;

    if( FT_STREAM_SEEK( 0 ) )
      goto Exit;

    pre = READ_UINT1( stream );
    if (pre != PK_PRE)
    {
      error = FT_THROW( Unknown_File_Format );
      goto Exit;
    }

    id = READ_UINT1( stream );
    if (id != PK_ID)
    {
      error = FT_THROW( Unknown_File_Format );
      goto Exit;
    }

    FT_TRACE2(( "pk_load_font: PK_ID(89) found\n" ));

    k = READ_UINT1( stream );
    if ( FT_STREAM_SKIP( k ) )
      goto Exit;

    ds        = READ_INT4( stream );
    check_sum = READ_INT4( stream );
    hppp      = READ_INT4( stream );
    vppp      = READ_INT4( stream );

    FT_TRACE2(( "pk_load_font: checksum is %ld\n",check_sum ));

    gptr = stream->pos;

    #if 0
      /* read min & max char code */
      bc = 256;
      ec = -1;
      for (;;)
      {
        instr = READ_UINT1( stream );
        if (instr == PK_POST)
        break;
        switch ((int) instr)
        {
          case PK_XXX1:  k = (FT_ULong)READ_UINT1( stream ); if ( FT_STREAM_SKIP( k ) ) goto Exit; break;
          case PK_XXX2:  k = (FT_ULong)READ_UINT2( stream ); if ( FT_STREAM_SKIP( k ) ) goto Exit; break;
          case PK_XXX3:  k = (FT_ULong)READ_UINT3( stream ); if ( FT_STREAM_SKIP( k ) ) goto Exit; break;
          case PK_XXX4:  k = (FT_ULong)READ_UINT4( stream ); if ( FT_STREAM_SKIP( k ) ) goto Exit; break;
          case PK_YYY:   if ( FT_STREAM_SKIP( 4 ) ) goto Exit; break;
          case PK_NO_OP: break;
          default:
            size  = instr & 0x3; instr >>= 2;
            ess   = instr & 0x1;
          if (ess == 0)
          {                          /* short */
	          rs = (FT_ULong)(size*256) + (FT_ULong)READ_UINT1( stream );
	          cc   = (FT_ULong)READ_UINT1( stream );
          }
          else if ((ess == 1) && (size != 3))
          {                          /* extended short */
	          rs = (FT_ULong)(size*65536) + (FT_ULong)READ_UINT2( stream );
	          cc   = (FT_ULong)READ_UINT1( stream );
          }
          else
          {                          /* standard */
	          rs   = READ_UINT4( stream );
	          cc   = (FT_ULong)READ_UINT4( stream );
          }
          if ( FT_STREAM_SKIP( rs ) )
            goto Exit;
          if (cc < bc)
	          bc = cc;
          if (cc > ec)
	          ec = cc;
          break;
        }
      }
    #else
      bc = 0;
      ec = 255;
    #endif

    nchars    = ec - bc + 1;
    if( FT_ALLOC(go, sizeof(PK_GlyphRec)) )
      goto Exit;

    FT_TRACE2(( "pk_load_font: Allocated sufficient memory in go\n" ));

    if( FT_ALLOC_MULT(go->bm_table, sizeof(PK_BitmapRec), nchars) )
      goto Exit;

    FT_TRACE2(( "pk_load_font: Allocated sufficient memory in go->bm_table\n" ));

    if ( FT_NEW_ARRAY( encoding, nchars ) )
      return error;

    FT_TRACE2(( "pk_load_font: Allocated sufficient memory in encoding\n" ));

    go->ds   = (FT_UInt)ds/(1<<20);
    go->hppp = (FT_UInt)hppp/(1<<16);
    go->vppp = (FT_UInt)vppp/(1<<16);
    go->font_bbx_w = 0;
    go->font_bbx_h = 0;
    go->font_bbx_xoff = 0;
    go->font_bbx_yoff = 0;
    go->code_min = bc;
    go->code_max = ec;

    /* read glyphs */
    if( FT_STREAM_SEEK( gptr ) )
        goto Exit;

    index = 0;
    go->nglyphs = 0;
    for (;;)
    {
      if ((instr = READ_UINT1( stream )) == PK_POST)
        break;
      switch ((FT_Int)instr)
      {
        case PK_XXX1:
          k = (FT_ULong)READ_UINT1( stream );
          if ( FT_STREAM_SKIP( k ) )
            goto Exit;
          break;
        case PK_XXX2:
          k = (FT_ULong)READ_UINT2( stream );
          if ( FT_STREAM_SKIP( k ) )
            goto Exit;
          break;
        case PK_XXX3:
          k = (FT_ULong)READ_UINT3( stream );
          if ( FT_STREAM_SKIP( k ) )
            goto Exit;
          break;
        case PK_XXX4:
          k = (FT_ULong)READ_UINT4( stream );
          if ( FT_STREAM_SKIP( k ) )
            goto Exit;
          break;
        case PK_YYY:
          if ( FT_STREAM_SKIP( 4 ) )
            goto Exit;
          break;
        case PK_NO_OP:
          break;
        default:
          flag  = instr;
          size  = flag % 0x04;  flag = flag >> 2;
          ess   = flag % 0x02;  flag = flag >> 1;
          bw    = flag % 0x02;  flag = flag >> 1;
          dny_f = flag % 0x10;
        if (ess == 0)
        {                          /* short */
          rs   = (FT_ULong)(size*256) + (FT_ULong)READ_UINT1( stream ) - (FT_ULong)8;
          cc   = (FT_ULong)READ_UINT1( stream );
          tfm  = (FT_ULong)READ_UINT3( stream );
          dm   = (FT_ULong)READ_UINT1( stream );
          w    = (FT_ULong)READ_UINT1( stream );
          h    = (FT_ULong)READ_UINT1( stream );
          hoff = (FT_Long)READ_INT1( stream );
          voff = (FT_Long)READ_INT1( stream );
          mv_x = dm;
          mv_y = 0;
        }
        else if ((ess == 1) && (size != 3))
        {                          /* extended short */
          rs   = (FT_ULong)(size*65536) + (FT_ULong)READ_UINT2( stream ) - (FT_ULong)13;
          cc   = (FT_ULong)READ_UINT1( stream );
          tfm  = (FT_ULong)READ_UINT3( stream );
          dm   = (FT_ULong)READ_UINT2( stream );
          w    = (FT_ULong)READ_UINT2( stream );
          h    = (FT_ULong)READ_UINT2( stream );
          hoff = (FT_Long)READ_INT2( stream );
          voff = (FT_Long)READ_INT2( stream );
          mv_x = dm;
          mv_y = 0;
        }
        else
        {                           /* standard */
          rs   = READ_UINT4( stream ) - (FT_ULong)28;
          cc   = READ_UINT4( stream );
          tfm  = READ_UINT4( stream );
          dx   = READ_UINT4( stream );
          dy   = READ_UINT4( stream );
	        w    = READ_UINT4( stream );
          h    = READ_UINT4( stream );
          hoff = READ_INT4( stream );
          voff = READ_INT4( stream );
          mv_x = (FT_UInt)dx/(FT_UInt)(1<<16);
          mv_y = (FT_UInt)dy/(FT_UInt)(1<<16);
        }

        if ((cc < go->code_min) || (go->code_max < cc))
        {
          error = FT_THROW( Invalid_File_Format );
          goto Exit;
        }

        go->bm_table[index].bbx_width  = w;
        go->bm_table[index].bbx_height = h;
        go->bm_table[index].raster = (w+7)/8;
        go->bm_table[index].off_x  = -hoff;
        go->bm_table[index].off_y  = voff;
        go->bm_table[index].mv_x   = mv_x;
        go->bm_table[index].mv_y   = mv_y;
        go->bm_table[index].bitmap = (unsigned char*)malloc(h*( (w+7)>>3 ));
        go->bm_table[index].code   = cc ; /* For backward compatibility */
        go->nglyphs               += 1;

        encoding[index].enc   = cc ;
        encoding[index].glyph = index;

        FT_TRACE6(( "pk_load_font: go->bm_table values are :\n"
                    "                       go->bm_table[%d].bbx_width  : %ld\n"
                    "                       go->bm_table[%d].bbx_height : %ld\n"
                    "                       go->bm_table[%d].raster     : %d\n"
                    "                       go->bm_table[%d].off_x      : %d\n"
                    "                       go->bm_table[%d].off_y      : %d\n"
                    "                       go->bm_table[%d].mv_x       : %d\n"
                    "                       go->bm_table[%d].mv_y       : %d\n", index, go->bm_table[index].bbx_width, index,
                                                                                 go->bm_table[index].bbx_height, index,
                                                                                 go->bm_table[index].raster, index,
                                                                                 go->bm_table[index].off_x, index,
                                                                                 go->bm_table[index].off_y, index,
                                                                                 go->bm_table[index].mv_x, index,
                                                                                 go->bm_table[index].mv_y, index ));


        if (go->bm_table[index].bitmap == NULL)
        {
          error = FT_THROW( Invalid_File_Format );
          goto Exit;
        }

        memset(go->bm_table[index].bitmap, 0, h*((w+7)/8));

        if (dny_f == 14)
        {
          if (pk_read_14(stream, rs, &(go->bm_table[index])) < 0)
          {
            FT_ERROR(( "pk_load_font: error in `pk_read_14'\n" ));
            error = FT_THROW( Unknown_File_Format );
            goto Exit;
          }
        }
        else
        {
          if (pk_read_n14(stream, dny_f, bw, rs, &(go->bm_table[index])) < 0)
          {
            FT_ERROR(( "pk_load_font: error in `pk_read_n14'\n" ));
            error = FT_THROW( Unknown_File_Format );
            goto Exit;
          }
        }
        if (go->font_bbx_w < w)
          go->font_bbx_w = w;
        if (go->font_bbx_h < h)
          go->font_bbx_h = h;
        if (go->font_bbx_xoff > -hoff)
          go->font_bbx_xoff = -hoff;
        if (go->font_bbx_yoff > (voff - h))
          go->font_bbx_yoff = (voff - h);

        index++;
      }
    }

    go->nencodings = go->nglyphs;
    go->encodings  = encoding;

    *goptr          = go;
    return error;

    Exit:
      if (go != NULL)
      {
        for (i = 0; i < nchars; i++)
        {
          if (go->bm_table[i].bitmap != NULL)
           FT_FREE(go->bm_table[i].bitmap);
        }
        FT_FREE(go->bm_table);
        FT_FREE(go);
      }
      return error;
  }

  FT_LOCAL_DEF( void )
  pk_free_font( PK_Face face )
  {
    FT_Memory  memory = FT_FACE( face )->memory;
    PK_Glyph   go     = face->pk_glyph;
    FT_UInt    nchars = FT_FACE( face )->num_glyphs,i;

    if ( !go )
      return;

    if( go->bm_table )
    {
      for (i = 0; i < nchars; i++)
      {
        if (go->bm_table[i].bitmap != NULL)
          FT_FREE(go->bm_table[i].bitmap);
       }
    }
    FT_FREE(go->bm_table);
    FT_FREE(go);
  }

/* END */