blob: 08056ba77ff46e25cfb4331b5010e82733297ca3 [file] [log] [blame]
// Copyright (c) 2009 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <fcntl.h>
#include <freetype/ftoutln.h>
#include <ft2build.h>
#include FT_FREETYPE_H
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include "opentype-sanitiser.h"
#include "ots-memory-stream.h"
namespace {
void DumpBitmap(const FT_Bitmap *bitmap) {
for (int i = 0; i < bitmap->rows * bitmap->width; ++i) {
if (bitmap->buffer[i] > 192) {
std::fprintf(stderr, "#");
} else if (bitmap->buffer[i] > 128) {
std::fprintf(stderr, "*");
} else if (bitmap->buffer[i] > 64) {
std::fprintf(stderr, "+");
} else if (bitmap->buffer[i] > 32) {
std::fprintf(stderr, ".");
} else {
std::fprintf(stderr, " ");
}
if ((i + 1) % bitmap->width == 0) {
std::fprintf(stderr, "\n");
}
}
}
int CompareBitmaps(const FT_Bitmap *orig, const FT_Bitmap *trans) {
int ret = 0;
if (orig->width == trans->width &&
orig->rows == trans->rows) {
for (int i = 0; i < orig->rows * orig->width; ++i) {
if (orig->buffer[i] != trans->buffer[i]) {
std::fprintf(stderr, "bitmap data doesn't match!\n");
ret = 1;
break;
}
}
} else {
std::fprintf(stderr, "bitmap metrics doesn't match! (%d, %d), (%d, %d)\n",
orig->width, orig->rows, trans->width, trans->rows);
ret = 1;
}
if (ret) {
std::fprintf(stderr, "EXPECTED:\n");
DumpBitmap(orig);
std::fprintf(stderr, "\nACTUAL:\n");
DumpBitmap(trans);
std::fprintf(stderr, "\n\n");
}
delete[] orig->buffer;
delete[] trans->buffer;
return ret;
}
int GetBitmap(FT_Library library, FT_Outline *outline, FT_Bitmap *bitmap) {
FT_BBox bbox;
FT_Outline_Get_CBox(outline, &bbox);
bbox.xMin &= ~63;
bbox.yMin &= ~63;
bbox.xMax = (bbox.xMax + 63) & ~63;
bbox.yMax = (bbox.yMax + 63) & ~63;
FT_Outline_Translate(outline, -bbox.xMin, -bbox.yMin);
const int w = (bbox.xMax - bbox.xMin) >> 6;
const int h = (bbox.yMax - bbox.yMin) >> 6;
if (w == 0 || h == 0) {
return -1; // white space
}
if (w < 0 || h < 0) {
std::fprintf(stderr, "bad width/height\n");
return 1; // error
}
uint8_t *buf = new uint8_t[w * h];
std::memset(buf, 0x0, w * h);
bitmap->width = w;
bitmap->rows = h;
bitmap->pitch = w;
bitmap->buffer = buf;
bitmap->pixel_mode = FT_PIXEL_MODE_GRAY;
bitmap->num_grays = 256;
if (FT_Outline_Get_Bitmap(library, outline, bitmap)) {
std::fprintf(stderr, "can't get outline\n");
delete[] buf;
return 1; // error.
}
return 0;
}
int LoadChar(FT_Face face, bool use_bitmap, int pt, FT_ULong c) {
static const int kDpi = 72;
FT_Matrix matrix;
matrix.xx = matrix.yy = 1 << 16;
matrix.xy = matrix.yx = 0 << 16;
FT_Int32 flags = FT_LOAD_DEFAULT | FT_LOAD_TARGET_NORMAL;
if (!use_bitmap) {
// Since the transcoder drops embedded bitmaps from the transcoded one,
// we have to use FT_LOAD_NO_BITMAP flag for the original face.
flags |= FT_LOAD_NO_BITMAP;
}
FT_Error error = FT_Set_Char_Size(face, pt * (1 << 6), 0, kDpi, 0);
if (error) {
std::fprintf(stderr, "Failed to set the char size!\n");
return 1;
}
FT_Set_Transform(face, &matrix, 0);
error = FT_Load_Char(face, c, flags);
if (error) return -1; // no such glyf in the font.
if (face->glyph->format != FT_GLYPH_FORMAT_OUTLINE) {
std::fprintf(stderr, "bad format\n");
return 1;
}
return 0;
}
int LoadCharThenCompare(FT_Library library,
FT_Face orig_face, FT_Face trans_face,
int pt, FT_ULong c) {
FT_Bitmap orig_bitmap, trans_bitmap;
// Load original bitmap.
int ret = LoadChar(orig_face, false, pt, c);
if (ret) return ret; // 1: error, -1: no such glyph
FT_Outline *outline = &orig_face->glyph->outline;
ret = GetBitmap(library, outline, &orig_bitmap);
if (ret) return ret; // white space?
// Load transformed bitmap.
ret = LoadChar(trans_face, true, pt, c);
if (ret == -1) {
std::fprintf(stderr, "the glyph is not found on the transcoded font\n");
}
if (ret) return 1; // -1 should be treated as error.
outline = &trans_face->glyph->outline;
ret = GetBitmap(library, outline, &trans_bitmap);
if (ret) return ret; // white space?
return CompareBitmaps(&orig_bitmap, &trans_bitmap);
}
int SideBySide(FT_Library library, const char *file_name,
uint8_t *orig_font, size_t orig_len,
uint8_t *trans_font, size_t trans_len) {
FT_Face orig_face;
FT_Error error
= FT_New_Memory_Face(library, orig_font, orig_len, 0, &orig_face);
if (error) {
std::fprintf(stderr, "Failed to open the original font: %s!\n", file_name);
return 1;
}
FT_Face trans_face;
error = FT_New_Memory_Face(library, trans_font, trans_len, 0, &trans_face);
if (error) {
std::fprintf(stderr, "Failed to open the transcoded font: %s!\n",
file_name);
return 1;
}
static const int kPts[] = {100, 20, 18, 16, 12, 10, 8}; // pt
static const size_t kPtsLen = sizeof(kPts) / sizeof(kPts[0]);
static const int kUnicodeRanges[] = {
0x0020, 0x007E, // Basic Latin (ASCII)
0x00A1, 0x017F, // Latin-1
0x1100, 0x11FF, // Hangul
0x3040, 0x309F, // Japanese HIRAGANA letters
0x3130, 0x318F, // Hangul
0x4E00, 0x4F00, // CJK Kanji/Hanja
0xAC00, 0xAD00, // Hangul
};
static const size_t kUnicodeRangesLen
= sizeof(kUnicodeRanges) / sizeof(kUnicodeRanges[0]);
for (size_t i = 0; i < kPtsLen; ++i) {
for (size_t j = 0; j < kUnicodeRangesLen; j += 2) {
for (int k = 0; k <= kUnicodeRanges[j + 1] - kUnicodeRanges[j]; ++k) {
int ret = LoadCharThenCompare(library, orig_face, trans_face,
kPts[i],
kUnicodeRanges[j] + k);
if (ret > 0) {
std::fprintf(stderr, "Glyph mismatch! (file: %s, U+%04x, %dpt)!\n",
file_name, kUnicodeRanges[j] + k, kPts[i]);
return 1;
}
}
}
}
return 0;
}
} // namespace
int main(int argc, char **argv) {
ots::DisableDebugOutput(); // turn off ERROR and WARNING outputs.
if (argc != 2) {
std::fprintf(stderr, "Usage: %s ttf_or_otf_filename\n", argv[0]);
return 1;
}
// load the font to memory.
const int fd = ::open(argv[1], O_RDONLY);
if (fd < 0) {
::perror("open");
return 1;
}
struct stat st;
::fstat(fd, &st);
const off_t orig_len = st.st_size;
uint8_t *orig_font = new uint8_t[orig_len];
if (::read(fd, orig_font, orig_len) != orig_len) {
std::fprintf(stderr, "Failed to read file!\n");
return 1;
}
::close(fd);
// check if FreeType2 can open the original font.
FT_Library library;
FT_Error error = FT_Init_FreeType(&library);
if (error) {
std::fprintf(stderr, "Failed to initialize FreeType2!\n");
return 1;
}
FT_Face dummy;
error = FT_New_Memory_Face(library, orig_font, orig_len, 0, &dummy);
if (error) {
std::fprintf(stderr, "Failed to open the original font with FT2! %s\n",
argv[1]);
return 1;
}
// transcode the original font.
static const size_t kPadLen = 20 * 1024;
uint8_t *trans_font = new uint8_t[orig_len + kPadLen];
ots::MemoryStream output(trans_font, orig_len + kPadLen);
bool result = ots::Process(&output, orig_font, orig_len);
if (!result) {
std::fprintf(stderr, "Failed to sanitise file! %s\n", argv[1]);
return 1;
}
const size_t trans_len = output.Tell();
// perform side-by-side tests.
return SideBySide(library, argv[1],
orig_font, orig_len,
trans_font, trans_len);
}