pdf2json 0.1.0

data/pdf2json-0.52-source/splash/SplashT1Font.h

@@ -0,0 +1,57 @@
+//========================================================================
+//
+// SplashT1Font.h
+//
+//========================================================================
+
+#ifndef SPLASHT1FONT_H
+#define SPLASHT1FONT_H
+
+#include <aconf.h>
+
+#if HAVE_T1LIB_H
+
+#ifdef USE_GCC_PRAGMAS
+#pragma interface
+#endif
+
+#include "SplashFont.h"
+
+class SplashT1FontFile;
+
+//------------------------------------------------------------------------
+// SplashT1Font
+//------------------------------------------------------------------------
+
+class SplashT1Font: public SplashFont {
+public:
+
+  SplashT1Font(SplashT1FontFile *fontFileA, SplashCoord *matA,
+	       SplashCoord *textMatA);
+
+  virtual ~SplashT1Font();
+
+  // Munge xFrac and yFrac before calling SplashFont::getGlyph.
+  virtual GBool getGlyph(int c, int xFrac, int yFrac,
+			 SplashGlyphBitmap *bitmap);
+
+  // Rasterize a glyph.  The <xFrac> and <yFrac> values are the same
+  // as described for getGlyph.
+  virtual GBool makeGlyph(int c, int xFrac, int yFrac,
+			  SplashGlyphBitmap *bitmap);
+
+  // Return the path for a glyph.
+  virtual SplashPath *getGlyphPath(int c);
+
+private:
+
+  int t1libID;			// t1lib font ID
+  int outlineID;		// t1lib font ID for glyph outlines
+  float size;
+  float outlineSize;		// size for glyph outlines
+  float outlineMul;
+};
+
+#endif // HAVE_T1LIB_H
+
+#endif

data/pdf2json-0.52-source/splash/SplashT1FontEngine.cc

@@ -0,0 +1,124 @@
+//========================================================================
+//
+// SplashT1FontEngine.cc
+//
+//========================================================================
+
+#include <aconf.h>
+
+#if HAVE_T1LIB_H
+
+#ifdef USE_GCC_PRAGMAS
+#pragma implementation
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#ifndef WIN32
+#  include <unistd.h>
+#endif
+#include <t1lib.h>
+#include "GString.h"
+#include "gfile.h"
+#include "FoFiType1C.h"
+#include "SplashT1FontFile.h"
+#include "SplashT1FontEngine.h"
+
+#ifdef VMS
+#if (__VMS_VER < 70000000)
+extern "C" int unlink(char *filename);
+#endif
+#endif
+
+//------------------------------------------------------------------------
+
+int SplashT1FontEngine::t1libInitCount = 0;
+
+//------------------------------------------------------------------------
+
+static void fileWrite(void *stream, char *data, int len) {
+  fwrite(data, 1, len, (FILE *)stream);
+}
+
+//------------------------------------------------------------------------
+// SplashT1FontEngine
+//------------------------------------------------------------------------
+
+SplashT1FontEngine::SplashT1FontEngine(GBool aaA) {
+  aa = aaA;
+}
+
+SplashT1FontEngine *SplashT1FontEngine::init(GBool aaA) {
+  // grayVals[i] = round(i * 255 / 16)
+  static unsigned long grayVals[17] = {
+    0, 16, 32, 48, 64, 80, 96, 112, 128, 143, 159, 175, 191, 207, 223, 239, 255
+  };
+
+  //~ for multithreading: need a mutex here
+  if (t1libInitCount == 0) {
+    T1_SetBitmapPad(8);
+    if (!T1_InitLib(NO_LOGFILE | IGNORE_CONFIGFILE | IGNORE_FONTDATABASE |
+		    T1_NO_AFM)) {
+      return NULL;
+    }
+    if (aaA) {
+      T1_AASetBitsPerPixel(8);
+      T1_AASetLevel(T1_AA_HIGH);
+      T1_AAHSetGrayValues(grayVals);
+    } else {
+      T1_AANSetGrayValues(0, 1);
+    }
+  }
+  ++t1libInitCount;
+
+  return new SplashT1FontEngine(aaA);
+}
+
+SplashT1FontEngine::~SplashT1FontEngine() {
+  //~ for multithreading: need a mutex here
+  if (--t1libInitCount == 0) {
+    T1_CloseLib();
+  }
+}
+
+SplashFontFile *SplashT1FontEngine::loadType1Font(SplashFontFileID *idA,
+						  char *fileName,
+						  GBool deleteFile,
+						  char **enc) {
+  return SplashT1FontFile::loadType1Font(this, idA, fileName, deleteFile, enc);
+}
+
+SplashFontFile *SplashT1FontEngine::loadType1CFont(SplashFontFileID *idA,
+						   char *fileName,
+						   GBool deleteFile,
+						   char **enc) {
+  FoFiType1C *ff;
+  GString *tmpFileName;
+  FILE *tmpFile;
+  SplashFontFile *ret;
+
+  if (!(ff = FoFiType1C::load(fileName))) {
+    return NULL;
+  }
+  tmpFileName = NULL;
+  if (!openTempFile(&tmpFileName, &tmpFile, "wb", NULL)) {
+    delete ff;
+    return NULL;
+  }
+  ff->convertToType1(NULL, NULL, gTrue, &fileWrite, tmpFile);
+  delete ff;
+  fclose(tmpFile);
+  ret = SplashT1FontFile::loadType1Font(this, idA, tmpFileName->getCString(),
+					gTrue, enc);
+  if (ret) {
+    if (deleteFile) {
+      unlink(fileName);
+    }
+  } else {
+    unlink(tmpFileName->getCString());
+  }
+  delete tmpFileName;
+  return ret;
+}
+
+#endif // HAVE_T1LIB_H

data/pdf2json-0.52-source/splash/SplashT1FontEngine.h

@@ -0,0 +1,53 @@
+//========================================================================
+//
+// SplashT1FontEngine.h
+//
+//========================================================================
+
+#ifndef SPLASHT1FONTENGINE_H
+#define SPLASHT1FONTENGINE_H
+
+#include <aconf.h>
+
+#if HAVE_T1LIB_H
+
+#ifdef USE_GCC_PRAGMAS
+#pragma interface
+#endif
+
+#include "gtypes.h"
+
+class SplashFontFile;
+class SplashFontFileID;
+
+//------------------------------------------------------------------------
+// SplashT1FontEngine
+//------------------------------------------------------------------------
+
+class SplashT1FontEngine {
+public:
+
+  static SplashT1FontEngine *init(GBool aaA);
+
+  ~SplashT1FontEngine();
+
+  // Load fonts.
+  SplashFontFile *loadType1Font(SplashFontFileID *idA, char *fileName,
+				GBool deleteFile, char **enc);
+  SplashFontFile *loadType1CFont(SplashFontFileID *idA, char *fileName,
+				 GBool deleteFile, char **enc);
+
+private:
+
+  SplashT1FontEngine(GBool aaA);
+
+  static int t1libInitCount;
+  GBool aa;
+
+  friend class SplashT1FontFile;
+  friend class SplashT1Font;
+};
+
+#endif // HAVE_T1LIB_H
+
+#endif

data/pdf2json-0.52-source/splash/SplashT1FontFile.cc

@@ -0,0 +1,97 @@
+//========================================================================
+//
+// SplashT1FontFile.cc
+//
+//========================================================================
+
+#include <aconf.h>
+
+#if HAVE_T1LIB_H
+
+#ifdef USE_GCC_PRAGMAS
+#pragma implementation
+#endif
+
+#include <string.h>
+#include <t1lib.h>
+#include "gmem.h"
+#include "SplashT1FontEngine.h"
+#include "SplashT1Font.h"
+#include "SplashT1FontFile.h"
+
+//------------------------------------------------------------------------
+// SplashT1FontFile
+//------------------------------------------------------------------------
+
+SplashFontFile *SplashT1FontFile::loadType1Font(SplashT1FontEngine *engineA,
+						SplashFontFileID *idA,
+						char *fileNameA,
+						GBool deleteFileA,
+						char **encA) {
+  int t1libIDA;
+  char **encTmp;
+  char *encStrTmp;
+  int encStrSize;
+  char *encPtr;
+  int i;
+
+  // load the font file
+  if ((t1libIDA = T1_AddFont(fileNameA)) < 0) {
+    return NULL;
+  }
+  T1_LoadFont(t1libIDA);
+
+  // reencode it
+  encStrSize = 0;
+  for (i = 0; i < 256; ++i) {
+    if (encA[i]) {
+      encStrSize += strlen(encA[i]) + 1;
+    }
+  }
+  encTmp = (char **)gmallocn(257, sizeof(char *));
+  encStrTmp = (char *)gmallocn(encStrSize, sizeof(char));
+  encPtr = encStrTmp;
+  for (i = 0; i < 256; ++i) {
+    if (encA[i]) {
+      strcpy(encPtr, encA[i]);
+      encTmp[i] = encPtr;
+      encPtr += strlen(encPtr) + 1;
+    } else {
+      encTmp[i] = ".notdef";
+    }
+  }
+  encTmp[256] = "custom";
+  T1_ReencodeFont(t1libIDA, encTmp);
+
+  return new SplashT1FontFile(engineA, idA, fileNameA, deleteFileA,
+			      t1libIDA, encTmp, encStrTmp);
+}
+
+SplashT1FontFile::SplashT1FontFile(SplashT1FontEngine *engineA,
+				   SplashFontFileID *idA,
+				   char *fileNameA, GBool deleteFileA,
+				   int t1libIDA, char **encA, char *encStrA):
+  SplashFontFile(idA, fileNameA, deleteFileA)
+{
+  engine = engineA;
+  t1libID = t1libIDA;
+  enc = encA;
+  encStr = encStrA;
+}
+
+SplashT1FontFile::~SplashT1FontFile() {
+  gfree(encStr);
+  gfree(enc);
+  T1_DeleteFont(t1libID);
+}
+
+SplashFont *SplashT1FontFile::makeFont(SplashCoord *mat,
+				       SplashCoord *textMat) {
+  SplashFont *font;
+
+  font = new SplashT1Font(this, mat, textMat);
+  font->initCache();
+  return font;
+}
+
+#endif // HAVE_T1LIB_H

data/pdf2json-0.52-source/splash/SplashT1FontFile.h

@@ -0,0 +1,58 @@
+//========================================================================
+//
+// SplashT1FontFile.h
+//
+//========================================================================
+
+#ifndef SPLASHT1FONTFILE_H
+#define SPLASHT1FONTFILE_H
+
+#include <aconf.h>
+
+#if HAVE_T1LIB_H
+
+#ifdef USE_GCC_PRAGMAS
+#pragma interface
+#endif
+
+#include "SplashFontFile.h"
+
+class SplashT1FontEngine;
+
+//------------------------------------------------------------------------
+// SplashT1FontFile
+//------------------------------------------------------------------------
+
+class SplashT1FontFile: public SplashFontFile {
+public:
+
+  static SplashFontFile *loadType1Font(SplashT1FontEngine *engineA,
+				       SplashFontFileID *idA,
+				       char *fileNameA, GBool deleteFileA,
+				       char **encA);
+
+  virtual ~SplashT1FontFile();
+
+  // Create a new SplashT1Font, i.e., a scaled instance of this font
+  // file.
+  virtual SplashFont *makeFont(SplashCoord *mat,
+			       SplashCoord *textMat);
+
+private:
+
+  SplashT1FontFile(SplashT1FontEngine *engineA,
+		   SplashFontFileID *idA,
+		   char *fileNameA, GBool deleteFileA,
+		   int t1libIDA, char **encA, char *encStrA);
+
+  SplashT1FontEngine *engine;
+  int t1libID;			// t1lib font ID
+  char **enc;
+  char *encStr;
+
+  friend class SplashT1Font;
+};
+
+#endif // HAVE_T1LIB_H
+
+#endif

data/pdf2json-0.52-source/splash/SplashTypes.h

@@ -0,0 +1,132 @@
+//========================================================================
+//
+// SplashTypes.h
+//
+//========================================================================
+
+#ifndef SPLASHTYPES_H
+#define SPLASHTYPES_H
+
+#include <aconf.h>
+#include "gtypes.h"
+
+//------------------------------------------------------------------------
+// coordinates
+//------------------------------------------------------------------------
+
+#if USE_FIXEDPOINT
+#include "FixedPoint.h"
+typedef FixedPoint SplashCoord;
+#else
+typedef double SplashCoord;
+#endif
+
+//------------------------------------------------------------------------
+// antialiasing
+//------------------------------------------------------------------------
+
+#define splashAASize 4
+
+//------------------------------------------------------------------------
+// colors
+//------------------------------------------------------------------------
+
+enum SplashColorMode {
+  splashModeMono1,		// 1 bit per component, 8 pixels per byte,
+				//   MSbit is on the left
+  splashModeMono8,		// 1 byte per component, 1 byte per pixel
+  splashModeRGB8,		// 1 byte per component, 3 bytes per pixel:
+				//   RGBRGB...
+  splashModeBGR8		// 1 byte per component, 3 bytes per pixel:
+				//   BGRBGR...
+
+#if SPLASH_CMYK
+  ,
+  splashModeCMYK8		// 1 byte per component, 4 bytes per pixel:
+				//   CMYKCMYK...
+#endif
+};
+
+// number of components in each color mode
+// (defined in SplashState.cc)
+extern int splashColorModeNComps[];
+
+// max number of components in any SplashColor
+#if SPLASH_CMYK
+#  define splashMaxColorComps 4
+#else
+#  define splashMaxColorComps 3
+#endif
+
+typedef Guchar SplashColor[splashMaxColorComps];
+typedef Guchar *SplashColorPtr;
+
+// RGB8
+static inline Guchar splashRGB8R(SplashColorPtr rgb8) { return rgb8[0]; }
+static inline Guchar splashRGB8G(SplashColorPtr rgb8) { return rgb8[1]; }
+static inline Guchar splashRGB8B(SplashColorPtr rgb8) { return rgb8[2]; }
+
+// BGR8
+static inline Guchar splashBGR8R(SplashColorPtr bgr8) { return bgr8[2]; }
+static inline Guchar splashBGR8G(SplashColorPtr bgr8) { return bgr8[1]; }
+static inline Guchar splashBGR8B(SplashColorPtr bgr8) { return bgr8[0]; }
+
+#if SPLASH_CMYK
+// CMYK8
+static inline Guchar splashCMYK8C(SplashColorPtr cmyk8) { return cmyk8[0]; }
+static inline Guchar splashCMYK8M(SplashColorPtr cmyk8) { return cmyk8[1]; }
+static inline Guchar splashCMYK8Y(SplashColorPtr cmyk8) { return cmyk8[2]; }
+static inline Guchar splashCMYK8K(SplashColorPtr cmyk8) { return cmyk8[3]; }
+#endif
+
+static inline void splashColorCopy(SplashColorPtr dest, SplashColorPtr src) {
+  dest[0] = src[0];
+  dest[1] = src[1];
+  dest[2] = src[2];
+#if SPLASH_CMYK
+  dest[3] = src[3];
+#endif
+}
+
+static inline void splashColorXor(SplashColorPtr dest, SplashColorPtr src) {
+  dest[0] ^= src[0];
+  dest[1] ^= src[1];
+  dest[2] ^= src[2];
+#if SPLASH_CMYK
+  dest[3] ^= src[3];
+#endif
+}
+
+//------------------------------------------------------------------------
+// blend functions
+//------------------------------------------------------------------------
+
+typedef void (*SplashBlendFunc)(SplashColorPtr src, SplashColorPtr dest,
+				SplashColorPtr blend, SplashColorMode cm);
+
+//------------------------------------------------------------------------
+// screen parameters
+//------------------------------------------------------------------------
+
+enum SplashScreenType {
+  splashScreenDispersed,
+  splashScreenClustered,
+  splashScreenStochasticClustered
+};
+
+struct SplashScreenParams {
+  SplashScreenType type;
+  int size;
+  int dotRadius;
+  SplashCoord gamma;
+  SplashCoord blackThreshold;
+  SplashCoord whiteThreshold;
+};
+
+//------------------------------------------------------------------------
+// error results
+//------------------------------------------------------------------------
+
+typedef int SplashError;
+
+#endif