![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ttfext.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Isaki's NoNo m68k/m88k emulator] / nono / util / ttfext|
Return to ttfext.cpp CVS log | Up to [Isaki's NoNo m68k/m88k emulator] / nono / util / ttfext |
1.1 root 1: //
2: // nono
3: // Copyright (C) 2022 nono project
4: // Licensed under nono-license.txt
5: //
6:
7: //
8: // TTF から埋め込みビットマップを抜き出して BDF にする。
9: //
10:
11: // TTF の構造についてはこの辺参照。
12: // - https://learn.microsoft.com/en-us/typography/opentype/spec/ > Tables
13: //
14: // - OpenType ファイル構造
15: // https://aznote.jakou.com/prog/opentype/02_struct.html
16:
17: #include "header.h"
18: #include "autofd.h"
19: #include "mystring.h"
20: #include <errno.h>
21: #include <fcntl.h>
22: #include <iconv.h>
23: #include <unistd.h>
24: #include <vector>
25:
26: #define HOWMANY(x, y) (((x) + (y - 1)) / (y))
27:
28: static constexpr uint32
29: FOURCC(const char *str)
30: {
31: return (str[0] << 24) | (str[1] << 16) | (str[2] << 8) | str[3];
32: }
33:
34: static int debug = 1;
35: static const char *new_family_name;
36:
37: //
38: // ファイルアクセス
39: //
40: class File
41: {
42: public:
43: File() {
44: fd = -1;
45: }
46: File(const File& rhs) {
47: fd = rhs.fd;
48: }
49: ~File() {
50: Close();
51: }
52:
53: bool Create(const std::string& filename_) {
54: filename = filename_;
55: fd = open(filename.c_str(), O_RDWR | O_CREAT | O_TRUNC, 0644);
56: if (fd < 0) {
57: err(1, "open: %s", filename.c_str());
58: }
59: return true;
60: }
61: bool Open(const std::string& filename_) {
62: filename = filename_;
63: fd = open(filename.c_str(), O_RDONLY);
64: if (fd < 0) {
65: err(1, "open: %s", filename.c_str());
66: }
67: return true;
68: }
69:
70: void Close() {
71: if (fd >= 0) {
72: close(fd);
73: }
74: }
75:
76: ssize_t Read(void *buf, size_t len) {
77: auto r = read(fd, buf, len);
78: if (r < 0) {
79: err(1, "File.Read(%d)", fd);
80: }
81: return r;
82: }
83:
84: ssize_t Write(const void *buf, size_t len) {
85: auto r = write(fd, buf, len);
86: if (r < 0) {
87: err(1, "File.Write(%d)", fd);
88: }
89: return r;
90: }
91:
92: // TTF はビッグエンディアンなので、専用読み込みルーチンを用意
93: uint8 Read8() {
94: uint8 buf[1];
95: Read(&buf, sizeof(buf));
96: return buf[0];
97: }
98:
99: uint16 Read16() {
100: uint8 buf[2];
101: Read(&buf, sizeof(buf));
102: return (buf[0] << 8) | buf[1];
103: }
104:
105: uint32 Read32() {
106: uint8 buf[4];
107: Read(&buf, sizeof(buf));
108: return (buf[0] << 24) | (buf[1] << 16) | (buf[2] << 8) | buf[3];
109: }
110:
111: // 便利用
112: ssize_t Write(const std::string& str) {
113: return Write(str.data(), str.length());
114: }
115:
116: ssize_t Print(const char *fmt, ...) {
117: char buf[1024];
118: va_list ap;
119: va_start(ap, fmt);
120: vsnprintf(buf, sizeof(buf), fmt, ap);
121: va_end(ap);
122: return Write(buf, strlen(buf));
123: }
124:
125: off_t Seek(off_t off) {
126: auto r = lseek(fd, off, SEEK_SET);
127: if (r < 0) {
128: err(1, "File.Seek(%d, %jd)", fd, (intmax_t)off);
129: }
130: return r;
131: }
132:
133: off_t Tell() const {
134: auto r = lseek(fd, 0, SEEK_CUR);
135: if (r < 0) {
136: err(1, "File.Tell(%d)", fd);
137: }
138: return r;
139: }
140:
141: const std::string& GetName() const { return filename; }
142:
143: private:
144: int fd {};
145: std::string filename {};
146: };
147:
148: // UTF-16 文字列 srcbuf を UTF-8 文字列に変換して返す。
149: // from はエンコーディング名で "utf-16be" とか。
150: // UTF-16 は '\0' を含むので std::string が使えず他のエンコーディングの
151: // 場合と共通化しづらい。
152: static std::string
153: FromUTF16(const char *from, const std::vector<uint8>& srcbuf)
154: {
155: const char *to = "utf-8";
156: auto cd = iconv_open(to, from);
157: if (cd == (iconv_t)-1) {
158: err(1, "iconv_open(%s, %s)", to, from);
159: }
160:
161: const char *src = (const char *)&srcbuf[0];
162: size_t srcleft = srcbuf.size();
163: std::vector<char> dstbuf(srcbuf.size() * 3); // 適当
164: char *dst = &dstbuf[0];
165: size_t dstleft = dstbuf.size();
166:
167: auto r = ICONV(cd, &src, &srcleft, &dst, &dstleft);
168: iconv_close(cd);
169: if (r == (size_t)-1 && errno != EILSEQ) {
170: err(1, "iconv failed");
171: }
172:
173: dst[dstbuf.size() - dstleft] = '\0';
174: return std::string(dstbuf.data());
175: }
176:
177:
178: //
179: // ここから TTF
180: //
181:
182: struct NameRecord
183: {
184: uint16 platformID;
185: uint16 encodingID;
186: uint16 languageID;
187: uint16 nameID;
188: uint16 length;
189: uint16 stringOffset;
190:
191: std::string name;
192:
193: // nameID の表示用文字列を返す
194: std::string GetNameIDStr() const {
195: return GetNameIDStr(nameID);
196: }
197: static std::string GetNameIDStr(uint id);
198: };
199:
200: // 各パラメータの意味はここのサイトの中ほどにある g の図参照。
201: // https://learn.microsoft.com/en-us/typography/opentype/spec/eblc
202: //
203: // horiAdvance, vertAdvance が要するにフォントサイズ。
204: struct BigGlyphMetrics
205: {
206: uint8 height; // Number of rows of data.
207: uint8 width; // Number of columns of data.
208: int8 horiBearingX; // Distance in pixels from the horizontal origin to
209: // the left edge of the bitmap.
210: int8 horiBearingY; // Distance in pixels from the horizontal origin to
211: // the top edge of the bitmap.
212: uint8 horiAdvance; // Horizontal advance width in pixels.
213: int8 vertBearingX; // Distance in pixels from the vertical origin to
214: // the left edge of the bitmap.
215: int8 vertBearingY; // Distance in pixels from the vertical origin to
216: // the top edge of the bitmap.
217: uint8 vertAdvance; // Vertical advance width in pixels.
218:
219: // file からこの構造体をロードする
220: void Load(File& file);
221: };
222:
223: // IndexSubTable にいろいろ混ぜてしまう。
224: class IndexSubTable
225: {
226: public:
227: // indexSubTable
228: uint16 firstGlyphIndex;
229: uint16 lastGlyphIndex;
230: uint32 additionalOffsetToIndexSubTable; // サブテーブルまでのオフセット
231:
232: // indexSubHeader
233: uint16 indexFormat; // Format of this IndexSubTable.
234: uint16 imageFormat; // Format of EBDT image data.
235: uint32 imageDataOffset; // Offset to image data in EBDT table.
236:
237: // indexSubTable1
238: // first..last までの何かの EBDT 内でのオフセット
239: std::vector<uint32> sbitOffset;
240:
241: // indexSubTable2
242: uint32 imageSize; // All the glyphs are of the same size.
243: BigGlyphMetrics bigMetrics; // All glyphs have the same metrics;
244: // glyph data may be compressed,
245: // byte-aligned, or bit-aligned.
246: };
247:
248: class SbitLineMetrics
249: {
250: public:
251: int8 ascender;
252: int8 descender; // 上を正として、ベースラインからの距離。なので負。
253: uint8 widthMax;
254: int8 caretSlopeNumerator;
255: int8 caretSlopeDenominator;
256: int8 caretOffset;
257: int8 minOriginSB;
258: int8 minAdvanceSB;
259: int8 maxBeforeBL;
260: int8 minAfterBL;
261: int8 pad1;
262: int8 pad2;
263:
264: // file からこの構造体をロードする
265: void Load(File& file);
266: };
267:
268: class BitmapSize
269: {
270: public:
271: // flags。BigGlyphMetrics とかで使う。
272: enum {
273: HORIZONTAL_METRICS = 0x01,
274: VERTICAL_METRICS = 0x02,
275: };
276:
277: public:
278: uint32 indexSubTableArrayOffset;
279: uint32 indexTablesSize;
280: uint32 numberOfIndexSubTables;
281: uint32 colorRef;
282: SbitLineMetrics hori;
283: SbitLineMetrics vert;
284: uint16 startGlyphIndex;
285: uint16 endGlyphIndex;
286: uint8 ppemX;
287: uint8 ppemY;
288: uint8 bitDepth;
289: uint8 flags;
290:
291: std::vector<IndexSubTable> indexSubTable {};
292: };
293:
294: class EncodingRecord
295: {
296: public:
297: uint16 platformID;
298: uint16 encodingID;
299: uint32 subtableOffset;
300:
301: std::string ToString() const;
302: };
303:
304: class CMAPSubTableFormat4
305: {
306: public:
307: uint16 format; // Format number is set to 4.
308:
309: uint16 length; // This is the length in bytes of the
310: // subtable.
311: uint16 language;
312: uint16 segCountX2; // 2 × segCount.
313:
314: uint16 searchRange; // Maximum power of 2 less than or
315: // equal to segCount,
316: // times 2 ((2**floor(log2(segCount))) * 2
317:
318: uint16 entrySelector; // Log_2 of the maximum power of 2 less
319: // than or equal to numTables
320: // (log2(searchRange/2),
321: // which is equal to floor(log2(segCount)))
322:
323: uint16 rangeShift; // segCount times 2, minus searchRange
324: // ((segCount * 2) - searchRange)
325:
326: std::vector<uint16> endCode; // End characterCode for each segment,
327: // last=0xFFFF.
328:
329: std::vector<uint16> startCode; // Start character code for each segment.
330: std::vector<int16> idDelta; // Delta for all character codes in segment.
331: std::vector<uint16> idRangeOffsets;
332: // Offsets into glyphIdArray or 0
333: std::vector<uint16> glyphIdArray;
334: // Glyph index array (arbitrary length)
335: };
336:
337: enum NameID
338: {
339: Copyright = 0,
340: FontFamilyName,
341: FontSubfamilyName,
342: UniqueFontIdentifier,
343: FullFontName,
344: VersionString,
345: PostScriptName,
346: Trademark,
347: ManufacturerName,
348: Designer,
349: Description,
350: URLVendor,
351: URLDesigner,
352: LicenseDescription,
353: LicenseInfoURL,
354: reserved,
355: TypoGraphicFamilyName,
356: TypographicSubfamilyName,
357: CompatibleFull,
358: SampleText,
359: PostScriptCIDFindfontName,
360: WWSFamilyName,
361: WWSSubfamilyName,
362: LightBackgroundPalette,
363: DarkBackgroundPalette,
364: VariationsPostScriptNamePrefix,
365: };
366:
367: class TTF_name
368: {
369: enum {
370: Platform_Unicode = 0,
371: Platform_Macintosh = 1,
372: Platform_Windows = 3,
373: };
374:
375: public:
376: TTF_name(File& file, off_t offset);
377:
378: // 指定の NameID の値を取得する
379: std::string GetName(NameID id) const;
380:
381: private:
382: static std::string GetPlatformIDStr(uint id);
383:
384: std::vector<NameRecord> nameRecord {};
385: };
386:
387: class TTF_EBLC
388: {
389: public:
390: TTF_EBLC(const File& file_, off_t offset);
391:
392: std::vector<BitmapSize> bitmapSizes {};
393:
394: // グリフ数を返す
395: int GetGlyphCount() const { return endGlyphIndex - startGlyphIndex + 1; }
396: // フォントパラメータを返す
397: int GetFontsize() const { return fontsize; }
398: int GetAscent() const { return ascent; }
399: int GetDescent() const { return descent; }
400:
401: private:
402: File file {};
403:
404: uint startGlyphIndex {};
405: uint endGlyphIndex {};
406: uint fontsize {};
407: int ascent {};
408: int descent {}; // 正数とする
409: };
410:
411:
412: class TTF_EBDT
413: {
414: public:
415: TTF_EBDT(const File& file_, off_t offset);
416: };
417:
418: class TTF_cmap
419: {
420: public:
421: TTF_cmap(const File& file_, off_t offset);
422:
423: void MakeASCIIMap(std::vector<uint>& asciimap);
424: void MakeJISMap(std::vector<uint>& jismap);
425:
426: private:
427: int Code2GID(int code) const;
428:
429: File file {};
430: std::vector<EncodingRecord> encodingRecords {};
431: CMAPSubTableFormat4 sub;
432: };
433:
434:
435: //
436: // TTF を扱うクラス。
437: // フィールド名などは概ね公式ドキュメントに従う。
438: //
439: class TTFFile
440: {
441: static const uint32 NAME_name = FOURCC("name");
442: static const uint32 NAME_EBDT = FOURCC("EBDT");
443: static const uint32 NAME_EBLC = FOURCC("EBLC");
444: static const uint32 NAME_cmap = FOURCC("cmap");
445:
446: public:
447: TTFFile();
448: ~TTFFile();
449:
450: bool Open(const File& file_);
451: void SaveBDFAscii(File& outfile);
452: void SaveBDFKanji(File& outfile);
453:
454: // ASCII から GID への変換テーブル
455: std::vector<uint> asciimap {};
456: // JIS から GID への変換テーブル
457: std::vector<uint> jismap {};
458:
459: // グリフデータ。GID => data[]
460: std::vector<std::vector<uint8>> glyph {};
461:
462: private:
463: void LoadGlyph();
464: void LoadGlyphFormat1_7(const IndexSubTable& sub);
465: void LoadGlyphFormat2_5(const IndexSubTable& sub);
466: std::string DebugBitmapData(int, const std::vector<uint8>& data);
467: void WriteBDFHeader(File& outfile, int width);
468: std::string MakeChar(uint code, int, int, const std::vector<uint8>& data);
469:
470: File file {};
471: std::unique_ptr<TTF_name> name {};
472: std::unique_ptr<TTF_EBLC> eblc {};
473: std::unique_ptr<TTF_cmap> cmap {};
474: int fontsize {};
475: int ascent {};
476: int descent {}; // 正数とする
477:
478: uint32 offset_name {};
479: uint32 offset_EBDT {};
480: uint32 offset_EBLC {};
481: uint32 offset_cmap {};
482: };
483:
484: // コンストラクタ
485: TTFFile::TTFFile()
486: {
487: asciimap.resize(256);
488: // JIS は上位下位とも (0x21 .. 0x7e) の範囲
489: jismap.resize(0x5e * 0x5e);
490: }
491:
492: // デストラクタ
493: TTFFile::~TTFFile()
494: {
495: }
496:
497: // ファイルから情報を取得
498: bool
499: TTFFile::Open(const File& file_)
500: {
501: file = file_;
502:
503: // 先頭のファイルヘッダ(オフセットテーブルというらしい)は 12バイト
504: uint32 version = file.Read32();
505: uint32 numTables = file.Read16();
506: uint32 searchRange __unused = file.Read16();
507: uint32 entrySelector __unused = file.Read16();
508: uint32 rangeShift __unused = file.Read16();
509: if (debug) {
510: printf("version = %08x\n", version);
511: printf("numTables = %d\n", numTables);
512: }
513:
514: // テーブルを調べて、必要なセクションの開始位置を取得
515: for (int i = 0; i < numTables; i++) {
516: uint32_t namecc = file.Read32();
517: uint32_t csum = file.Read32();
518: uint32_t offset = file.Read32();
519: uint32_t len = file.Read32();
520:
521: (void)csum;
522:
523: if (debug) {
524: printf("[%d] %c%c%c%c off=%08x len=%08x\n",
525: i,
526: (namecc >> 24),
527: (namecc >> 16) & 0xff,
528: (namecc >> 8) & 0xff,
529: (namecc) & 0xff,
530: offset,
531: len);
532: }
533:
534: if (namecc == NAME_name) {
535: offset_name = offset;
536: }
537: if (namecc == NAME_EBDT) {
538: offset_EBDT = offset;
539: }
540: if (namecc == NAME_EBLC) {
541: offset_EBLC = offset;
542: }
543: if (namecc == NAME_cmap) {
544: offset_cmap = offset;
545: }
546: }
547:
548: // 必要なセクションが全部揃ってなければエラー終了
549: if (offset_name == 0) {
550: errx(1, "%s: no name section", file.GetName().c_str());
551: }
552: if (offset_EBDT == 0) {
553: errx(1, "%s: no EBDT section", file.GetName().c_str());
554: }
555: if (offset_EBLC == 0) {
556: errx(1, "%s: no EBLC section", file.GetName().c_str());
557: }
558: if (offset_cmap == 0) {
559: errx(1, "%s: no cmap section", file.GetName().c_str());
560: }
561:
562: // name セクションの読み込み。
563: // name セクションは Copyright などのプロパティなど。
564: name.reset(new TTF_name(file, offset_name));
565:
566: // EBLC セクションの読み込み。
567: // EBLC セクションはビットマップグリフに関する情報(サイズや格納方法)。
568: eblc.reset(new TTF_EBLC(file, offset_EBLC));
569: fontsize = eblc->GetFontsize();
570: ascent = eblc->GetAscent();
571: descent = eblc->GetDescent();
572: // それによってグリフ領域を確保。
573: glyph.resize(eblc->GetGlyphCount());
574:
575: // cmap セクションの読み込み。
576: // cmap セクションは文字コードと GID(内部のGlyph ID) とのマッピングなど。
577: cmap.reset(new TTF_cmap(file, offset_cmap));
578:
579: // グリフインデックスを求める。
580: cmap->MakeASCIIMap(asciimap);
581: cmap->MakeJISMap(jismap);
582:
583: // EBDT セクションからフォントデータを読み込み。
584: // EBDT セクションはほぼビットマップデータ置き場。
585: LoadGlyph();
586:
587: return true;
588: }
589:
590: // eblc で列挙されているすべてのグリフを読み込む。
591: void
592: TTFFile::LoadGlyph()
593: {
594: // bitmapSizez[]->indexSubTable[] の2段階のテーブル。
595: for (const auto& bs : eblc->bitmapSizes) {
596: for (const auto& sub : bs.indexSubTable) {
597: // indexFormat はグリフのパラメータを持っているこのインデックス
598: // 自体が (共用体のようになっていて) どの形式かを示している。
599: // imageFormat は EBDT 内のグリフデータがどの形式かを示している。
600: // indexFormat と imageFormat は対象のグリフの性質によって
601: // ある程度組み合わせが決まっている。
602: if (sub.indexFormat == 1 && sub.imageFormat == 7) {
603: LoadGlyphFormat1_7(sub);
604: } else if (sub.indexFormat == 2 && sub.imageFormat == 5) {
605: LoadGlyphFormat2_5(sub);
606: } else {
607: // 他の組み合わせは出てこないので無視
608: errx(1, "Unsupported index=%d image=%d format",
609: sub.indexFormat, sub.imageFormat);
610: }
611: }
612: }
613: }
614:
615: // indexFormat=1, imageFormat=7
616: void
617: TTFFile::LoadGlyphFormat1_7(const IndexSubTable& sub)
618: {
619: if (sub.lastGlyphIndex - sub.firstGlyphIndex + 1 != sub.sbitOffset.size()) {
620: errx(1, "sbitOffset mismatch?");
621: }
622:
623: // indexFormat==1 は
624: // GlyphIndex の数分 sbitOffset[] で EBDT 内オフセットが指定してある。
625: //
626: // 例えば
627: // firstGlyphIndex = 0
628: // lastGlyphIndex = 2
629: // imageDataOffset = 00000004
630: // sbitOffset[] = { 00000000, 0000000c, 00000015 }
631: // の場合、グリフデータは EBDT 先頭から数えて
632: // GID=0 は $00000004+$00000000 = $00000004 から
633: // GID=1 は $00000004+$0000000c = $00000010 から
634: // GID=2 は $00000004+$00000015 = $00000019 から
635: // 始まる。
636: //
637: // imageFormat==7 は "big metrics, bit-aligned data" 形式で、EBDT 内の
638: // 指定オフセットの位置には
639: // BigGlyphMetrics bigMetrics;
640: // uint8 imageData[];
641: // が記録されている。
642: //
643: // 例えば三点リーダのような疎なグリフに有効で、
644: // BigGlyphMetrics でオフセットが指定されており、
645: // imageData[] は実際の描画点のある下図中枠の部分だけでよい、という構造。
646: //
647: // BigGlyphMetrics.horiBearingX
648: // |->|
649: // +-------------+
650: // | |
651: // | +-------+ |---
652: // | |X X X| | ^
653: // | +-------+ | | BigGlyphMetrics.horiBearingY
654: // | | |
655: // +-------------+--- Baseline
656: // | |
657: // +-------------+
658:
659: for (int i = 0, end = sub.sbitOffset.size(); i < end; i++) {
660: uint32 offset = sub.sbitOffset[i];
661: uint gid = sub.firstGlyphIndex + i;
662:
663: file.Seek(offset_EBDT + sub.imageDataOffset + offset);
664: BigGlyphMetrics big;
665: big.Load(file);
666: if (debug) {
667: printf(" %08x %dx%d horiXY=(%d,%d) vertXY=(%d,%d) Adv=%dx%d\n",
668: offset,
669: big.width, big.height,
670: big.horiBearingX,
671: big.horiBearingY,
672: big.vertBearingX,
673: big.vertBearingY,
674: big.horiAdvance,
675: big.vertAdvance);
676: }
677:
678: // 64x64 ドットの領域を用意して一旦左上詰めで imageData[] を読み込む。
679: std::vector<uint64> map;
680: int bytelen = HOWMANY(big.width * big.height, 8);
681: int width = big.width;
682: uint64 input = 0;
683: int nbit = 0;
684: for (int j = 0; j < bytelen; j++) {
685: // 入力キューに下から詰めていく
686: input = (input << 8) | file.Read8();
687: nbit += 8;
688: // 1ライン分を超えてる間切り出す
689: while (nbit >= width) {
690: uint64 bytedata;
691: // 1ライン分を右詰めして..
692: bytedata = input >> (nbit - width);
693: // MSB 詰めし直して..
694: bytedata <<= (64 - width);
695: // そのまま map の MSB 詰め
696: map.push_back(bytedata);
697: // 取り出した分を除外
698: input <<= 64 - (nbit - width);
699: input >>= 64 - (nbit - width);
700: nbit -= width;
701: }
702: }
703:
704: // X方向へオフセット。
705: // HORIZONTAL_METRICS では horiBearingX は左に入れるパディング。
706: for (auto& m : map) {
707: m >>= big.horiBearingX;
708: }
709: // Y方向へオフセット。
710: // HORIZONTAL_METRICS では horiBearingY は基準線からグリフ片の
711: // 上端までの上方向へのオフセット。基準線は ascent, descent のやつ。
712: int paddingY = big.vertAdvance - 2 - big.horiBearingY;
713: for (int j = 0; j < paddingY; j++) {
714: map.insert(map.begin(), 0);
715: }
716: // 縦が足りない分はここで補充
717: map.resize(big.vertAdvance);
718:
719: // horiAdvance * vertAdvance ビット分を書き出す。
720: std::vector<uint8> data;
721: for (int y = 0; y < big.vertAdvance; y++) {
722: for (int x = 0; x < big.horiAdvance; x += 8) {
723: uint8 c = map[y] >> (56 - x);
724: data.push_back(c);
725: }
726: }
727:
728: if (0 && debug) {
729: printf("gid=%d\n", gid);
730: printf("%s\n", DebugBitmapData(big.horiAdvance, data).c_str());
731: }
732:
733: glyph[gid] = data;
734: }
735: }
736:
737: // indexFormat=2, imageFormat=5
738: void
739: TTFFile::LoadGlyphFormat2_5(const IndexSubTable& sub)
740: {
741: // indexFormat==2 "All glyphs have identical metrics" は
742: // uint32 imageSize;
743: // BigGlyphMetrics bigMetrics;
744: // を持っており、ここでメトリックが指定されている。
745: // EBDT 内のオフセットは imageDataOffset。
746: //
747: // imageFormat==5 "metrics in EBLC, bit-aligned image data only" は、
748: // データをビット境界で詰め込んであるのでここでバイト境界にする
749: // (横 12bit を横 2バイトにする)。
750:
751: int nglyph = sub.lastGlyphIndex - sub.firstGlyphIndex + 1;
752: uint32 bytes = sub.imageSize;
753: file.Seek(offset_EBDT + sub.imageDataOffset);
754: for (int i = 0; i < nglyph; i++) {
755: uint32 gid = sub.firstGlyphIndex + i;
756:
757: std::vector<uint8> data;
758: int width = sub.bigMetrics.width; // ショートカット
759: uint64 input = 0; // とりあえず横64まで
760: int nbit = 0; // input 内の有効ビット
761: for (int j = 0; j < bytes; j++) {
762: // 入力キューに下から詰めていく
763: input = (input << 8) | file.Read8();
764: nbit += 8;
765: // 1ライン分を超えたら切り出す
766: if (nbit >= width) {
767: uint32 bytedata;
768: // 1ライン分を右詰めして..
769: bytedata = input >> (nbit - width);
770: // MSB 詰めし直して..
771: bytedata <<= (32 - width);
772: // 上から1バイトずつ取り出す
773: for (int k = 0; k < width; k += 8) {
774: data.push_back(bytedata >> 24);
775: bytedata <<= 8;
776: }
777: // 取り出した部分を除外
778: input <<= 64 - (nbit - width);
779: input >>= 64 - (nbit - width);
780: nbit -= width;
781: }
782: }
783: glyph[gid] = data;
784:
785: if (0 && debug) {
786: printf("gid=%d\n", gid);
787: printf("%s\n", DebugBitmapData(width, data).c_str());
788: }
789: }
790: }
791:
792: // デバッグ用のビットマップデータの表示文字列を返す。
793: // widthbit はフォントの横幅(ビット)。
794: // data は byte-aligned のデータ。
795: std::string
796: TTFFile::DebugBitmapData(int widthbit, const std::vector<uint8>& data)
797: {
798: std::string str;
799:
800: int wbyte = HOWMANY(widthbit, 8);
801: std::vector<char> buf(widthbit + 2);
802:
803: for (int i = 0, end = data.size(); i < end; i += wbyte) {
804: uint32 v = 0;
805: for (int j = 0; j < wbyte; j++) {
806: v = (v << 8) | data[i + j];
807: }
808: v <<= (32 - wbyte * 8);
809: int b;
810: for (b = 0; b < wbyte * 8; b++, v <<= 1) {
811: buf[b] = ((int32)v < 0) ? '@' : '.';
812: }
813: buf[b++] = '\n';
814: buf[b] = '\0';
815:
816: str += std::string(buf.data());
817: }
818: return str;
819: }
820:
821: // ASCII 部分 (というか半角部分) を BDF で保存する。
822: void
823: TTFFile::SaveBDFAscii(File& outfile)
824: {
825: // ヘッダ出力
826: WriteBDFHeader(outfile, 1);
827:
828: // ここからグリフ出力。
829: // 先に要素数を出力する必要があるので一旦集める。
830: std::vector<std::string> glypharray;
831: for (int code = 0, end = asciimap.size(); code < end; code++) {
832: int gid = asciimap[code];
833: if (gid != 0) {
834: auto line = MakeChar(code, fontsize / 2, fontsize, glyph[gid]);
835: glypharray.push_back(line);
836: }
837: }
838:
839: // 出力
840: outfile.Print("CHARS %d\n", (int)glypharray.size());
841: outfile.Write("\n");
842: for (const auto& line : glypharray) {
843: outfile.Write(line.c_str());
844: }
845: outfile.Write("ENDFONT\n");
846: }
847:
848: // 全角部分を BDF で保存する。
849: void
850: TTFFile::SaveBDFKanji(File& outfile)
851: {
852: // ヘッダ出力
853: WriteBDFHeader(outfile, 2);
854:
855: // ここからグリフ出力。
856: // 先に要素数を出力する必要があるので一旦集める。
857: std::vector<std::string> glypharray;
858: for (int h = 0; h < 0x5e; h++) {
859: for (int l = 0; l < 0x5e; l++) {
860: int idx = h * 0x5e + l;
861: int gid = jismap[idx];
862: int jh = 0x21 + h;
863: int jl = 0x21 + l;
864: int jiscode = (jh << 8) + jl;
865: if (gid != 0) {
866: auto line = MakeChar(jiscode, fontsize, fontsize, glyph[gid]);
867: glypharray.push_back(line);
868: }
869: }
870: }
871:
872: // 出力
873: outfile.Print("CHARS %d\n", (int)glypharray.size());
874: outfile.Write("\n");
875: for (const auto& line : glypharray) {
876: outfile.Write(line.c_str());
877: }
878: outfile.Write("ENDFONT\n");
879: }
880:
881: // width は 1 なら半角、2 なら全角。
882: void
883: TTFFile::WriteBDFHeader(File& outfile, int width)
884: {
885: // よく分からん
886: std::string foundry = name->GetName(NameID::ManufacturerName);
887: std::string family_name = name->GetName(NameID::PostScriptName);
888: std::string weight = name->GetName(NameID::FontSubfamilyName);
889: const char *slant = "R";
890: const char *setwidth = "Normal";
891: const char *addstyle = "";
892: int pixelsize = fontsize;
893: int pointsize = 150;
894: int resolutionX = 75;
895: int resolutionY = 75;
896: char spacing = 'C';
897: int average_width = fontsize * 10; // ?
898: const char *charset_registry;
899: if (width == 1) {
900: charset_registry = "ASCII";
901: } else {
902: charset_registry = "JISX0208.1983";
903: }
904: const char *charset_encoding = "0";
905:
906: if (foundry.empty()) {
907: foundry = "misc";
908: }
909:
910: // SIL OFL は改変フォントに元フォントと同じ名前を使ってはいけない。
911: // TTF -> BDF の形式変更も改変になるようにも読めるので、別の名前を使う。
912: if (new_family_name) {
913: family_name = new_family_name;
914: }
915:
916: outfile.Write("STARTFONT 2.1\n");
917: outfile.Print("FONT -%s-%s-%s-%s-%s-%s-%d-%d-%d-%d-%c-%d-%s-%s\n",
918: foundry.c_str(),
919: family_name.c_str(),
920: weight.c_str(),
921: slant,
922: setwidth,
923: addstyle,
924: pixelsize,
925: pointsize,
926: resolutionX,
927: resolutionY,
928: spacing,
929: average_width,
930: charset_registry,
931: charset_encoding);
932: outfile.Print("SIZE %d %d %d\n", fontsize, resolutionX, resolutionY);
933: outfile.Print("FONTBOUNDINGBOX %d %d 0 %d\n",
934: fontsize / 2 * width, fontsize, -descent);
935: outfile.Write("\n");
936:
937: // プロパティ。先頭行に要素数を出力する必要があるので一旦集める
938: std::vector<std::string> prop;
939: #define PROP(str...) prop.push_back(string_format(str));
940:
941: PROP("FONTNAME_REGISTRY \"\"");
942: PROP("FOUNDRY \"%s\"", foundry.c_str());
943: PROP("FAMILY_NAME \"%s\"", family_name.c_str());
944: PROP("WEIGHT_NAME \"%s\"", weight.c_str());
945: PROP("SLANT \"%s\"", slant);
946: PROP("SETWIDTH_NAME \"%s\"", setwidth);
947: PROP("ADD_STYLE_NAME \"%s\"", addstyle);
948: PROP("PIXEL_SIZE %d", fontsize);
949: PROP("POINT_SIZE %d", pointsize);
950: PROP("RESOLUTION_X %d", resolutionX);
951: PROP("RESOLUTION_Y %d", resolutionY);
952: PROP("SPACING \"%c\"", spacing);
953: PROP("AVERAGE_WIDTH %d", average_width);
954: PROP("CHARSET_REGISTRY \"%s\"", charset_registry);
955: PROP("CHARSET_ENCODING \"%s\"", charset_encoding);
956: PROP("COPYRIGHT \"%s License: %s %s\"",
957: name->GetName(NameID::Copyright).c_str(),
958: name->GetName(NameID::LicenseDescription).c_str(),
959: name->GetName(NameID::LicenseInfoURL).c_str());
960: PROP("WEIGHT 10");
961: PROP("DEFAULT_CHAR 0"); // ?
962: PROP("FONT_ASCENT %d", ascent);
963: PROP("FONT_DESCENT %d", descent);
964:
965: // 勝手に追加。
966: std::string v;
967: v = name->GetName(NameID::FullFontName);
968: if (v.empty() == false) {
969: PROP("_COMMENT_TTF_FULL_FONT_NAME \"%s\"", v.c_str());
970: }
971: v = name->GetName(NameID::VersionString);
972: if (v.empty() == false) {
973: PROP("_COMMENT_TTF_VERSION \"%s\"", v.c_str());
974: }
975: v = name->GetName(NameID::Designer);
976: if (v.empty() == false) {
977: PROP("_COMMENT_TTF_DESIGNER \"%s\"", v.c_str());
978: }
979: v = name->GetName(NameID::URLVendor);
980: if (v.empty() == false) {
981: PROP("_COMMENT_TTF_URL_VENDOR \"%s\"", v.c_str());
982: }
983: v = name->GetName(NameID::URLDesigner);
984: if (v.empty() == false) {
985: PROP("_COMMENT_TTF_URL_DESIGNER \"%s\"", v.c_str());
986: }
987:
988: outfile.Print("STARTPROPERTIES %d\n", (int)prop.size());
989: for (const auto& s : prop) {
990: outfile.Write(s + "\n");
991: }
992: outfile.Write("ENDPROPERTIES\n");
993: outfile.Write("\n");
994: }
995:
996: // 1文字分の STARTCHAR .. ENDCHAR までを文字列にしたものを返す。
997: std::string
998: TTFFile::MakeChar(uint code, int w, int h, const std::vector<uint8>& data)
999: {
1000: std::string lines;
1001:
1002: // STARTCHAR のほうはほぼコメント。ENCODING のほうが文字のコード。
1003: if (code < 0x100) {
1004: lines += string_format("STARTCHAR %02x\n", code);
1005: } else {
1006: lines += string_format("STARTCHAR %04x\n", code);
1007: }
1008: lines += string_format("ENCODING %d\n", code);
1009: lines += "SWIDTH 960 0\n";
1010: lines += string_format("DWIDTH %d 0\n", w);
1011: lines += string_format("BBX %d %d 0 %d\n", w, h, -descent);
1012: lines += "BITMAP\n";
1013: // 読み込んだグリフデータは左端を必ずバイト境界から始めてある。
1014: int widthbytes = data.size() / h;
1015: for (int y = 0, yend = data.size(); y < yend; y += widthbytes) {
1016: for (int x = 0; x < widthbytes; x++) {
1017: lines += string_format("%02x", data[y + x]);
1018: }
1019: lines += "\n";
1020: }
1021: lines += "ENDCHAR\n";
1022: lines += "\n";
1023:
1024: return lines;
1025: }
1026:
1027:
1028: //
1029: // name セクション
1030: //
1031:
1032: // コンストラクタ
1033: TTF_name::TTF_name(File& file, off_t offset_name)
1034: {
1035: file.Seek(offset_name);
1036: uint32 version = file.Read16();
1037: uint32 count = file.Read16();
1038: uint32 storageOffset = file.Read16();
1039:
1040: nameRecord.resize(count);
1041: for (int i = 0; i < count; i++) {
1042: auto& rec = nameRecord[i];
1043: rec.platformID = file.Read16();
1044: rec.encodingID = file.Read16();
1045: rec.languageID = file.Read16();
1046: rec.nameID = file.Read16();
1047: rec.length = file.Read16();
1048: rec.stringOffset = file.Read16();
1049: }
1050: for (auto& rec : nameRecord) {
1051: file.Seek(offset_name + storageOffset + rec.stringOffset);
1052: if (rec.platformID == Platform_Windows) {
1053: // UTF-16BE エンコーディングと規定されている
1054: std::vector<uint8> src(rec.length);
1055: for (int j = 0; j < rec.length; j++) {
1056: src[j] = file.Read8();
1057: }
1058: rec.name = FromUTF16("utf-16be", src);
1059: } else {
1060: // とりあえず ASCII だと思ってそのまま使う
1061: for (int j = 0; j < rec.length; j++) {
1062: rec.name += (char)file.Read8();
1063: }
1064: }
1065: }
1066:
1067: if (debug) {
1068: for (int i = 0, end = nameRecord.size(); i < end; i++) {
1069: const auto& rec = nameRecord[i];
1070: printf("nameRecord[%d].platformID = %d(%s)\n",
1071: i, rec.platformID, GetPlatformIDStr(rec.platformID).c_str());
1072: printf("nameRecord[%d].encodingID = %d\n", i, rec.encodingID);
1073: printf("nameRecord[%d].languageID = %d\n", i, rec.languageID);
1074: printf("nameRecord[%d].nameID = %d(%s)\n", i, rec.nameID,
1075: rec.GetNameIDStr().c_str());
1076: printf("nameRecord[%d].name = \"%s\"\n", i, rec.name.c_str());
1077: }
1078: }
1079: (void)version;
1080: (void)storageOffset;
1081: }
1082:
1083: // 指定の文字列を返す。
1084: // とりあえず ASCII だけっぽい Macintosh のほうから返す。どうしたもんか。
1085: std::string
1086: TTF_name::GetName(NameID id) const
1087: {
1088: for (const auto& rec : nameRecord) {
1089: if (rec.platformID == Platform_Macintosh && rec.nameID == id) {
1090: return rec.name;
1091: }
1092: }
1093: return "";
1094: }
1095:
1096: // デバッグ用に platformID を文字列にして返す
1097: /*static*/ std::string
1098: TTF_name::GetPlatformIDStr(uint id)
1099: {
1100: static const char * const platform_names[] = {
1101: "Unicode",
1102: "Macintosh",
1103: "",
1104: "Windows",
1105: };
1106:
1107: if (id < countof(platform_names)) {
1108: return platform_names[id];
1109: } else {
1110: return "";
1111: }
1112: }
1113:
1114:
1115: //
1116: // EBLC セクション
1117: //
1118:
1119: // コンストラクタ
1120: TTF_EBLC::TTF_EBLC(const File& file_, off_t offset_EBLC)
1121: : file(file_)
1122: {
1123: startGlyphIndex = 0;
1124: endGlyphIndex = 65536;
1125:
1126: // EBLC ヘッダ
1127: // uint16 majorVersion;
1128: // uint16 minorVersion;
1129: // uint32 numSizes;
1130: // BitmapSize bitmapSizes[];
1131: // numSizes フィールドの次から、BitmapSize が numSizes 個並んでるっぽい。
1132:
1133: file.Seek(offset_EBLC);
1134: auto majorVersion = file.Read16();
1135: auto minorVersion = file.Read16();
1136: if (majorVersion != 2 || minorVersion != 0) {
1137: errx(1, "Unknown EBLC version %d.%d", majorVersion, minorVersion);
1138: }
1139: uint32 numSizes = file.Read32();
1140: if (debug) {
1141: printf("EBLC.numSizes=%d\n", numSizes);
1142: }
1143:
1144: // bitmapSizes[] を全部読み込む
1145: bitmapSizes.resize(numSizes);
1146: for (int i = 0; i < numSizes; i++) {
1147: auto& bs = bitmapSizes[i];
1148: bs.indexSubTableArrayOffset = file.Read32();
1149: bs.indexTablesSize = file.Read32();
1150: bs.numberOfIndexSubTables = file.Read32();
1151: bs.colorRef = file.Read32();
1152: bs.hori.Load(file);
1153: bs.vert.Load(file);
1154: bs.startGlyphIndex = file.Read16();
1155: bs.endGlyphIndex = file.Read16();
1156: bs.ppemX = file.Read8();
1157: bs.ppemY = file.Read8();
1158: bs.bitDepth = file.Read8();
1159: bs.flags = file.Read8();
1160: if (debug) {
1161: printf("bitmapSizes[%d]\n", i);
1162: #define A(fmt, name) printf(" %-24s = " #fmt "\n", #name, bs.name)
1163: A($%08x, indexSubTableArrayOffset);
1164: A($%08x, indexTablesSize);
1165: A(%d, numberOfIndexSubTables);
1166: A(%d, colorRef);
1167: A(%d, startGlyphIndex);
1168: A(%d, endGlyphIndex);
1169: A(%d, ppemX);
1170: A(%d, ppemY);
1171: A(%d, bitDepth);
1172: A($%x, flags);
1173:
1174: if (bs.flags == BitmapSize::HORIZONTAL_METRICS) {
1175: A(%d, hori.ascender);
1176: A(%d, hori.descender);
1177: }
1178: }
1179: if (bs.flags != BitmapSize::HORIZONTAL_METRICS) {
1180: errx(1, "Unsupported bitmap flags $%x", bs.flags);
1181: }
1182:
1183: // bitmapSizes[] 全体に渡る start..end
1184: startGlyphIndex = std::max(startGlyphIndex, (uint)bs.startGlyphIndex);
1185: endGlyphIndex = std::min(endGlyphIndex, (uint)bs.endGlyphIndex);
1186:
1187: // 代表値みたいなのは本当はないかもだが、必要なのでとりあえず。
1188: if (fontsize == 0) {
1189: fontsize = bs.ppemY;
1190: } else if (fontsize != bs.ppemY) {
1191: errx(1, "bs.ppemY=%d but already has %d", bs.ppemY, fontsize);
1192: }
1193: if (ascent == 0) {
1194: ascent = bs.hori.ascender;
1195: } else if (ascent != bs.hori.ascender) {
1196: errx(1, "bs.hori.ascender=%d but already has %d",
1197: bs.hori.ascender, ascent);
1198: }
1199: // (TTF の) descender は負数、(BDF の) descent は正数ということにする。
1200: if (descent == 0) {
1201: descent = -bs.hori.descender;
1202: } else if (descent != bs.hori.descender) {
1203: errx(1, "bs.hori.descender=%d but already has (-)%d",
1204: bs.hori.descender, descent);
1205: }
1206: }
1207:
1208: // 各 bitmapSizes には indexSubTables[] 配列がある。
1209: for (auto& bs : bitmapSizes) {
1210: bs.indexSubTable.resize(bs.numberOfIndexSubTables);
1211:
1212: // indexSubTableArrayOffset は EBLC 先頭からのオフセット。
1213: // indexSubTable[] 自体にはグリフ範囲と additional へのオフセットのみ
1214: // 記録されている。additional のほうはフォーマットによってサイズが
1215: // 異なるためだと思う。
1216: // additional が指す先は indexSubHeader で、ここの indexFormat で
1217: // この後に続く indexSubTable の種別が決まっている。
1218: //
1219: // indexSubTable {
1220: // { firstGlyphIndex, lastGlyphIndex }
1221: // additionalOffsetToIndexSubTable ----+
1222: // } |
1223: // |
1224: // +-------------------------------------+
1225: // |
1226: // +-> indexSubHeader {
1227: // indexFormat = 1;
1228: // imageFormat;
1229: // imageDataOffset --> EBDT 内のオフセット
1230: // }
1231: // indexSubTable1 {
1232: // IndexSubType;
1233: // sbitOffset[];
1234: // }
1235: //
1236: file.Seek(offset_EBLC + bs.indexSubTableArrayOffset);
1237: for (int j = 0; j < bs.numberOfIndexSubTables; j++) {
1238: auto& sub = bs.indexSubTable[j];
1239: sub.firstGlyphIndex = file.Read16();
1240: sub.lastGlyphIndex = file.Read16();
1241: sub.additionalOffsetToIndexSubTable = file.Read32();
1242: if (debug) {
1243: printf("indexSubTable[%d] GlyphIndex=%4d-%4d "
1244: "additionalOffsetToIndexSubTable=$%08x\n", j,
1245: sub.firstGlyphIndex,
1246: sub.lastGlyphIndex,
1247: sub.additionalOffsetToIndexSubTable);
1248: }
1249: }
1250:
1251: for (int j = 0; j < bs.numberOfIndexSubTables; j++) {
1252: auto& sub = bs.indexSubTable[j];
1253: file.Seek(offset_EBLC
1254: + bs.indexSubTableArrayOffset
1255: + sub.additionalOffsetToIndexSubTable);
1256: // ここが indexSubType header
1257: sub.indexFormat = file.Read16();
1258: sub.imageFormat = file.Read16();
1259: sub.imageDataOffset = file.Read32();
1260: if (debug) {
1261: printf("[%d] indexFormat=%d imageFormat=%d "
1262: "imageDataOffset=$%08x\n",
1263: j, sub.indexFormat, sub.imageFormat, sub.imageDataOffset);
1264: }
1265:
1266: switch (sub.indexFormat) {
1267: case 1: // indexSubTable1
1268: {
1269: // IndexSubType header;
1270: // Offset32 sbitOffset[];
1271: //
1272: // 公式ドキュメントの改行位置が微妙に分からんけど。
1273: // sbitOffsets[glyphIndex] + imageDataOffset = glyphData;
1274: // sizeOfArray = (lastGlyph - firstGlyph + 1) + 1
1275: // + 1 pad if needed;
1276: int nglyph = sub.lastGlyphIndex - sub.firstGlyphIndex + 1;
1277: sub.sbitOffset.resize(nglyph);
1278: for (int i = 0; i < nglyph; i++) {
1279: uint32 offset = file.Read32();
1280: sub.sbitOffset[i] = offset;
1281: if (debug) {
1282: printf(" %08x", offset);
1283: if (i % 8 == 7) {
1284: printf("\n");
1285: }
1286: }
1287: }
1288: if (debug) {
1289: printf("\n");
1290: }
1291: break;
1292: }
1293:
1294: case 2: // indexSubTable2
1295: {
1296: // IndexSubType header;
1297: // uint32 imageSize;
1298: // BigGlyphMetrics bigMetrics;
1299: sub.imageSize = file.Read32();
1300: auto& big = sub.bigMetrics;
1301: big.Load(file);
1302: if (debug) {
1303: printf(" imageSize=%d bigMetrics=%dx%d\n",
1304: sub.imageSize, big.width, big.height);
1305: }
1306: break;
1307: }
1308:
1309: default:
1310: errx(1, "unsupported indexSubTable%d", sub.indexFormat);
1311: }
1312: }
1313: }
1314: }
1315:
1316:
1317: //
1318: // cmap セクション
1319: //
1320:
1321: // コンストラクタ
1322: TTF_cmap::TTF_cmap(const File& file_, off_t offset)
1323: : file(file_)
1324: {
1325: // cmap ヘッダ
1326: //
1327: // uint16 version; // Table version number (0).
1328: // uint16 numTables; // Number of encoding tables that follow.
1329: // EncodingRecord encodingRecords[numTables];
1330:
1331: file.Seek(offset);
1332: uint16 version = file.Read16();
1333: uint16 numTables = file.Read16();
1334:
1335: if (version != 0) {
1336: errx(1, "Unsupported cmap version %d\n", version);
1337: }
1338:
1339: printf("cmap:\n");
1340: encodingRecords.resize(numTables);
1341: for (int i = 0; i < encodingRecords.size(); i++) {
1342: auto& enc = encodingRecords[i];
1343: enc.platformID = file.Read16();
1344: enc.encodingID = file.Read16();
1345: enc.subtableOffset = file.Read32();
1346:
1347: if (debug) {
1348: printf("[%d] %s subtableOffset=%08x\n", i,
1349: enc.ToString().c_str(),
1350: enc.subtableOffset);
1351: }
1352: }
1353:
1354: // とりあえず Unicode2.0 BMP のみターゲットにする。
1355: EncodingRecord *uenc = NULL;
1356: for (auto& enc : encodingRecords) {
1357: if (enc.platformID == 0 && enc.encodingID == 3) {
1358: uenc = &enc;
1359: }
1360: }
1361: if (uenc == NULL) {
1362: errx(1, "cmap: Unicode2.0 BMP mapping not found");
1363: }
1364:
1365: // Unicode2.0 BMP の場合 offset の先は Format4 らしい。
1366: // subtableOffset は cmap 先頭からのオフセット。
1367: off_t tablestart = file.Seek(offset + uenc->subtableOffset);
1368: sub.format = file.Read16();
1369: sub.length = file.Read16();
1370: sub.language = file.Read16();
1371: sub.segCountX2 = file.Read16();
1372: sub.searchRange = file.Read16();
1373: sub.entrySelector = file.Read16();
1374: sub.rangeShift = file.Read16();
1375:
1376: int segCount = sub.segCountX2 / 2;
1377: sub.endCode.resize(segCount);
1378: sub.startCode.resize(segCount);
1379: sub.idDelta.resize(segCount);
1380: sub.idRangeOffsets.resize(segCount);
1381:
1382: for (int i = 0; i < segCount; i++) {
1383: sub.endCode[i] = file.Read16();
1384: }
1385: file.Read16(); // reservedPad
1386: for (int i = 0; i < segCount; i++) {
1387: sub.startCode[i] = file.Read16();
1388: }
1389: for (int i = 0; i < segCount; i++) {
1390: sub.idDelta[i] = file.Read16();
1391: }
1392: for (int i = 0; i < segCount; i++) {
1393: sub.idRangeOffsets[i] = file.Read16();
1394: }
1395: // glyphIdArray[] の長さは直接は書いてないが、sub.length が
1396: // (たぶん subtable 先頭からの) subtable のバイト長らしいので、そこまで。
1397: int remain = sub.length - (file.Tell() - tablestart);
1398: sub.glyphIdArray.resize(remain / 2);
1399: for (int i = 0; i < remain / 2; i++) {
1400: sub.glyphIdArray[i] = file.Read16();
1401: }
1402:
1403: if (debug) {
1404: printf("cmap SubTable Format4\n");
1405: printf(" format=%d\n", sub.format);
1406: printf(" length=%d\n", sub.length);
1407: printf(" language=%d\n", sub.language);
1408: printf(" segCountX2=%d\n", sub.segCountX2);
1409: printf(" searchRange=%d\n", sub.searchRange);
1410: printf(" entrySelector=%d\n", sub.entrySelector);
1411: printf(" rangeShift=%d\n", sub.rangeShift);
1412: printf(" glyphIdArray[%d]\n", (int)sub.glyphIdArray.size());
1413: }
1414: }
1415:
1416: // ASCII というか1バイトコードのマップを作成する。
1417: // asciimap は 0-255 確保されていること。
1418: void
1419: TTF_cmap::MakeASCIIMap(std::vector<uint>& asciimap)
1420: {
1421: // ASCII + 1バイトコード
1422: for (int code = 1, end = asciimap.size(); code < end; code++) {
1423: asciimap[code] = Code2GID(code);
1424: }
1425: if (debug) {
1426: printf("asciimap:\n");
1427: for (int i = 0, end = asciimap.size(); i < end; i++) {
1428: printf(" %3d", asciimap[i]);
1429: if (i % 16 == 15) {
1430: printf("\n");
1431: }
1432: }
1433: }
1434: }
1435:
1436: // JIS コードのマップを作成する。
1437: // jismap はあらかじめ確保されていること。
1438: void
1439: TTF_cmap::MakeJISMap(std::vector<uint>& jismap)
1440: {
1441: auto cd = iconv_open("unicodebig", "iso-2022-jp");
1442: if (cd == (iconv_t)-1) {
1443: err(1, "iconv_open");
1444: }
1445:
1446: for (int h = 0; h < 0x5e; h++) {
1447: for (int l = 0; l < 0x5e; l++) {
1448: int idx = h * 0x5e + l;
1449:
1450: // JIS コードを Unicode コードポイントに変換
1451: int jh = 0x21 + h;
1452: int jl = 0x21 + l;
1453: std::string srcbuf = string_format("\x1b$B%c%c\x1b(B", jh, jl);
1454: const char *src = &srcbuf[0];
1455: size_t srcleft = srcbuf.length();
1456: std::array<uint8, 4> dstbuf;
1457: char *dst = (char *)dstbuf.data();
1458: size_t dstleft = dstbuf.size();
1459: auto r = ICONV(cd, &src, &srcleft, &dst, &dstleft);
1460: if (r == (size_t)-1) {
1461: // JIS コードの割り当てがないところでは EILSEQ になる
1462: if (errno == EILSEQ) {
1463: continue;
1464: }
1465: err(1, "iconv %02x%02x failed", jh, jl);
1466: }
1467: if (r != 0) {
1468: errx(1, "iconv: invalid conversions is %zd", r);
1469: }
1470: if (dstleft != 2) {
1471: errx(1, "iconv %02x%02x: dstleft=%zd", jh, jl, dstleft);
1472: }
1473: // UnicodeBig は2バイト。
1474: // ビッグエンディアンで取り出しているので上位、下位の順
1475: uint32 ucode = (dstbuf[0] << 8) | dstbuf[1];
1476:
1477: // JIS コードの {jh,jl} を Unicode に変換して GID を引く。
1478: auto gid = Code2GID(ucode);
1479: jismap[idx] = gid;
1480: }
1481: }
1482: iconv_close(cd);
1483:
1484: if (0 && debug) {
1485: printf("jismap:\n");
1486: for (int h = 0; h < 0x5e; h++) {
1487: for (int l = 0; l < 0x5e; l++) {
1488: int idx = h * 0x5e + l;
1489: int gid = jismap[idx];
1490: if (gid != 0) {
1491: printf(" JIS%02x%02x GID=%4d\n", h + 0x21, l + 0x21, gid);
1492: }
1493: }
1494: }
1495: }
1496: }
1497:
1498: // 文字コード code からグリフインデックス(GID)を求める
1499: int
1500: TTF_cmap::Code2GID(int code) const
1501: {
1502: // endCode[] から code を含むセグメント i を求める
1503: int i = -1;
1504: for (int j = 0; j < sub.endCode.size(); j++) {
1505: if (code <= sub.endCode[j]) {
1506: i = j;
1507: break;
1508: }
1509: }
1510: if (i < 0) {
1511: return 0;
1512: }
1513:
1514: // このセグメントの開始コードより若ければ、対応インデックスなし
1515: int start = sub.startCode[i];
1516: if (code < start) {
1517: return 0;
1518: }
1519:
1520: if (sub.idRangeOffsets[i] == 0) {
1521: return (code + sub.idDelta[i]) & 0xffff;
1522: } else {
1523: errx(1, "idRangeOffset != 0");
1524: }
1525: }
1526:
1527:
1528: // BigGlyphMetrics を読み込む。file は更新される。
1529: void
1530: BigGlyphMetrics::Load(File& file)
1531: {
1532: height = file.Read8();
1533: width = file.Read8();
1534: horiBearingX = file.Read8();
1535: horiBearingY = file.Read8();
1536: horiAdvance = file.Read8();
1537: vertBearingX = file.Read8();
1538: vertBearingY = file.Read8();
1539: vertAdvance = file.Read8();
1540: }
1541:
1542: // SbitLineMetrics を読み込む。file は更新される。
1543: void
1544: SbitLineMetrics::Load(File& file)
1545: {
1546: ascender = file.Read8();
1547: descender = file.Read8();
1548: widthMax = file.Read8();
1549: caretSlopeNumerator = file.Read8();
1550: caretSlopeDenominator = file.Read8();
1551: caretOffset = file.Read8();
1552: minOriginSB = file.Read8();
1553: minAdvanceSB = file.Read8();
1554: maxBeforeBL = file.Read8();
1555: minAfterBL = file.Read8();
1556: pad1 = file.Read8();
1557: pad2 = file.Read8();
1558: }
1559:
1560: // NameRecord.NameID の名前を文字列で返す
1561: /*static*/ std::string
1562: NameRecord::GetNameIDStr(uint id)
1563: {
1564: static const char * const names[] = {
1565: "Copyright notice", // 0
1566: "Font Family name", // 1
1567: "Font Subfamily name", // 2
1568: "Unique font identifier", // 3
1569: "Full font name", // 4
1570: "Version string", // 5
1571: "PostScript name", // 6
1572: "Trademark", // 7
1573: "Manufacturer Name", // 8
1574: "Designer", // 9
1575: "Description", // 10
1576: "URL Vendor", // 11
1577: "URL Designer", // 12
1578: "License Description", // 13
1579: "License Info", // 14
1580: "Reserved", // 15
1581: "Typographic Family name", // 16
1582: "Typographic Subfamily name", // 17
1583: "Compatible Full", // 18
1584: "Sample Text", // 19
1585: "PostScript CID findfont name", // 20
1586: "WWS Family Name", // 21
1587: "WWS Subfamily Name", // 22
1588: "Light Background Palette", // 23
1589: "Dark Background Palette", // 24
1590: "Variations PostScript Name Prefix", // 25
1591: };
1592: if (id < countof(names)) {
1593: return names[id];
1594: } else {
1595: return "";
1596: }
1597: }
1598:
1599: // EncodingRecord のデバッグ表示用文字列を返す
1600: std::string
1601: EncodingRecord::ToString() const
1602: {
1603: std::string str;
1604:
1605: str = string_format("platformID=%d", platformID);
1606: static const char * const platform_names[] = {
1607: "Unicode",
1608: "Macintosh",
1609: "ISO(deprecated)",
1610: "Windows",
1611: "Custom",
1612: };
1613: if (platformID < countof(platform_names)) {
1614: str += string_format("(%s)", platform_names[platformID]);
1615: }
1616:
1617: str += string_format(" encodingID=%d", encodingID);
1618: if (platformID == 0) {
1619: static const char * encoding_names_0[] = {
1620: "1.0",
1621: "1.1",
1622: "ISO/IEC 10646",
1623: "2.0 BMP",
1624: "2.0 full",
1625: "Variation Sequences",
1626: "full reportoire",
1627: };
1628: if (encodingID < countof(encoding_names_0)) {
1629: str += string_format("(%s)", encoding_names_0[encodingID]);
1630: }
1631: } else if (platformID == 3) {
1632: static const char * encoding_names_3[] = {
1633: "Symbol",
1634: "Unicode BMP",
1635: "ShiftJIS",
1636: "PRC",
1637: "Big5",
1638: "Wansung",
1639: "Johab",
1640: "Reserved",
1641: "Reserved",
1642: "Reserved",
1643: "Unicode full reportoire",
1644: };
1645: if (encodingID < countof(encoding_names_3)) {
1646: str += string_format("(%s)", encoding_names_3[encodingID]);
1647: }
1648: }
1649:
1650: return str;
1651: }
1652:
1653:
1654: [[noreturn]] static void
1655: usage()
1656: {
1657: errx(1, "usage: [-f family_name] infile.TTF outascii.BDF outkanji.BDF");
1658: }
1659:
1660: int
1661: main(int ac, char *av[])
1662: {
1663: int c;
1664:
1665: while ((c = getopt(ac, av, "f:")) != -1) {
1666: switch (c) {
1667: case 'f':
1668: new_family_name = optarg;
1669: break;
1670: default:
1671: usage();
1672: break;
1673: }
1674: }
1675: ac -= optind;
1676: av += optind;
1677:
1678: if (ac < 3) {
1679: usage();
1680: }
1681:
1682: File infile;
1683: infile.Open(av[0]);
1684:
1685: TTFFile ttf;
1686: ttf.Open(infile);
1687:
1688: File outfile1;
1689: outfile1.Create(av[1]);
1690: ttf.SaveBDFAscii(outfile1);
1691:
1692: File outfile2;
1693: outfile2.Create(av[2]);
1694: ttf.SaveBDFKanji(outfile2);
1695:
1696: return 0;
1697: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.