blob: 55f5ccc5c5ff8b93c25b717137ee85dc9028c162 [file] [log] [blame]
// Copyright 2017 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
#include "core/fpdfapi/font/cpdf_cmap.h"
#include <memory>
#include <utility>
#include <vector>
#include "core/fpdfapi/cmaps/cmap_int.h"
#include "core/fpdfapi/font/cpdf_cmapmanager.h"
#include "core/fpdfapi/font/cpdf_cmapparser.h"
#include "core/fpdfapi/parser/cpdf_simple_parser.h"
namespace {
struct ByteRange {
uint8_t m_First;
uint8_t m_Last; // Inclusive.
};
struct PredefinedCMap {
const char* m_pName;
CIDSet m_Charset;
CIDCoding m_Coding;
CPDF_CMap::CodingScheme m_CodingScheme;
uint8_t m_LeadingSegCount;
ByteRange m_LeadingSegs[2];
};
const PredefinedCMap g_PredefinedCMaps[] = {
{"GB-EUC",
CIDSET_GB1,
CIDCODING_GB,
CPDF_CMap::MixedTwoBytes,
1,
{{0xa1, 0xfe}}},
{"GBpc-EUC",
CIDSET_GB1,
CIDCODING_GB,
CPDF_CMap::MixedTwoBytes,
1,
{{0xa1, 0xfc}}},
{"GBK-EUC",
CIDSET_GB1,
CIDCODING_GB,
CPDF_CMap::MixedTwoBytes,
1,
{{0x81, 0xfe}}},
{"GBKp-EUC",
CIDSET_GB1,
CIDCODING_GB,
CPDF_CMap::MixedTwoBytes,
1,
{{0x81, 0xfe}}},
{"GBK2K-EUC",
CIDSET_GB1,
CIDCODING_GB,
CPDF_CMap::MixedTwoBytes,
1,
{{0x81, 0xfe}}},
{"GBK2K",
CIDSET_GB1,
CIDCODING_GB,
CPDF_CMap::MixedTwoBytes,
1,
{{0x81, 0xfe}}},
{"UniGB-UCS2", CIDSET_GB1, CIDCODING_UCS2, CPDF_CMap::TwoBytes, 0, {}},
{"UniGB-UTF16", CIDSET_GB1, CIDCODING_UTF16, CPDF_CMap::TwoBytes, 0, {}},
{"B5pc",
CIDSET_CNS1,
CIDCODING_BIG5,
CPDF_CMap::MixedTwoBytes,
1,
{{0xa1, 0xfc}}},
{"HKscs-B5",
CIDSET_CNS1,
CIDCODING_BIG5,
CPDF_CMap::MixedTwoBytes,
1,
{{0x88, 0xfe}}},
{"ETen-B5",
CIDSET_CNS1,
CIDCODING_BIG5,
CPDF_CMap::MixedTwoBytes,
1,
{{0xa1, 0xfe}}},
{"ETenms-B5",
CIDSET_CNS1,
CIDCODING_BIG5,
CPDF_CMap::MixedTwoBytes,
1,
{{0xa1, 0xfe}}},
{"UniCNS-UCS2", CIDSET_CNS1, CIDCODING_UCS2, CPDF_CMap::TwoBytes, 0, {}},
{"UniCNS-UTF16", CIDSET_CNS1, CIDCODING_UTF16, CPDF_CMap::TwoBytes, 0, {}},
{"83pv-RKSJ",
CIDSET_JAPAN1,
CIDCODING_JIS,
CPDF_CMap::MixedTwoBytes,
2,
{{0x81, 0x9f}, {0xe0, 0xfc}}},
{"90ms-RKSJ",
CIDSET_JAPAN1,
CIDCODING_JIS,
CPDF_CMap::MixedTwoBytes,
2,
{{0x81, 0x9f}, {0xe0, 0xfc}}},
{"90msp-RKSJ",
CIDSET_JAPAN1,
CIDCODING_JIS,
CPDF_CMap::MixedTwoBytes,
2,
{{0x81, 0x9f}, {0xe0, 0xfc}}},
{"90pv-RKSJ",
CIDSET_JAPAN1,
CIDCODING_JIS,
CPDF_CMap::MixedTwoBytes,
2,
{{0x81, 0x9f}, {0xe0, 0xfc}}},
{"Add-RKSJ",
CIDSET_JAPAN1,
CIDCODING_JIS,
CPDF_CMap::MixedTwoBytes,
2,
{{0x81, 0x9f}, {0xe0, 0xfc}}},
{"EUC",
CIDSET_JAPAN1,
CIDCODING_JIS,
CPDF_CMap::MixedTwoBytes,
2,
{{0x8e, 0x8e}, {0xa1, 0xfe}}},
{"H", CIDSET_JAPAN1, CIDCODING_JIS, CPDF_CMap::TwoBytes, 1, {{0x21, 0x7e}}},
{"V", CIDSET_JAPAN1, CIDCODING_JIS, CPDF_CMap::TwoBytes, 1, {{0x21, 0x7e}}},
{"Ext-RKSJ",
CIDSET_JAPAN1,
CIDCODING_JIS,
CPDF_CMap::MixedTwoBytes,
2,
{{0x81, 0x9f}, {0xe0, 0xfc}}},
{"UniJIS-UCS2", CIDSET_JAPAN1, CIDCODING_UCS2, CPDF_CMap::TwoBytes, 0, {}},
{"UniJIS-UCS2-HW",
CIDSET_JAPAN1,
CIDCODING_UCS2,
CPDF_CMap::TwoBytes,
0,
{}},
{"UniJIS-UTF16",
CIDSET_JAPAN1,
CIDCODING_UTF16,
CPDF_CMap::TwoBytes,
0,
{}},
{"KSC-EUC",
CIDSET_KOREA1,
CIDCODING_KOREA,
CPDF_CMap::MixedTwoBytes,
1,
{{0xa1, 0xfe}}},
{"KSCms-UHC",
CIDSET_KOREA1,
CIDCODING_KOREA,
CPDF_CMap::MixedTwoBytes,
1,
{{0x81, 0xfe}}},
{"KSCms-UHC-HW",
CIDSET_KOREA1,
CIDCODING_KOREA,
CPDF_CMap::MixedTwoBytes,
1,
{{0x81, 0xfe}}},
{"KSCpc-EUC",
CIDSET_KOREA1,
CIDCODING_KOREA,
CPDF_CMap::MixedTwoBytes,
1,
{{0xa1, 0xfd}}},
{"UniKS-UCS2", CIDSET_KOREA1, CIDCODING_UCS2, CPDF_CMap::TwoBytes, 0, {}},
{"UniKS-UTF16", CIDSET_KOREA1, CIDCODING_UTF16, CPDF_CMap::TwoBytes, 0, {}},
};
int CheckFourByteCodeRange(uint8_t* codes,
int size,
const std::vector<CPDF_CMap::CodeRange>& ranges) {
int iSeg = pdfium::CollectionSize<int>(ranges) - 1;
while (iSeg >= 0) {
if (ranges[iSeg].m_CharSize < size) {
--iSeg;
continue;
}
int iChar = 0;
while (iChar < size) {
if (codes[iChar] < ranges[iSeg].m_Lower[iChar] ||
codes[iChar] > ranges[iSeg].m_Upper[iChar]) {
break;
}
++iChar;
}
if (iChar == ranges[iSeg].m_CharSize)
return 2;
if (iChar)
return (size == ranges[iSeg].m_CharSize) ? 2 : 1;
iSeg--;
}
return 0;
}
int GetFourByteCharSizeImpl(uint32_t charcode,
const std::vector<CPDF_CMap::CodeRange>& ranges) {
if (ranges.empty())
return 1;
uint8_t codes[4];
codes[0] = codes[1] = 0x00;
codes[2] = (uint8_t)(charcode >> 8 & 0xFF);
codes[3] = (uint8_t)charcode;
int offset = 0;
int size = 4;
for (int i = 0; i < 4; ++i) {
int iSeg = pdfium::CollectionSize<int>(ranges) - 1;
while (iSeg >= 0) {
if (ranges[iSeg].m_CharSize < size) {
--iSeg;
continue;
}
int iChar = 0;
while (iChar < size) {
if (codes[offset + iChar] < ranges[iSeg].m_Lower[iChar] ||
codes[offset + iChar] > ranges[iSeg].m_Upper[iChar]) {
break;
}
++iChar;
}
if (iChar == ranges[iSeg].m_CharSize)
return size;
--iSeg;
}
--size;
++offset;
}
return 1;
}
} // namespace
CPDF_CMap::CPDF_CMap()
: m_bLoaded(false),
m_bVertical(false),
m_Charset(CIDSET_UNKNOWN),
m_CodingScheme(TwoBytes),
m_Coding(CIDCODING_UNKNOWN),
m_pEmbedMap(nullptr) {}
CPDF_CMap::~CPDF_CMap() {}
void CPDF_CMap::LoadPredefined(CPDF_CMapManager* pMgr,
const CFX_ByteString& bsName,
bool bPromptCJK) {
m_PredefinedCMap = bsName;
if (m_PredefinedCMap == "Identity-H" || m_PredefinedCMap == "Identity-V") {
m_Coding = CIDCODING_CID;
m_bVertical = bsName[9] == 'V';
m_bLoaded = true;
return;
}
CFX_ByteString cmapid = m_PredefinedCMap;
m_bVertical = cmapid.Right(1) == "V";
if (cmapid.GetLength() > 2) {
cmapid = cmapid.Left(cmapid.GetLength() - 2);
}
const PredefinedCMap* map = nullptr;
for (size_t i = 0; i < FX_ArraySize(g_PredefinedCMaps); ++i) {
if (cmapid == CFX_ByteStringC(g_PredefinedCMaps[i].m_pName)) {
map = &g_PredefinedCMaps[i];
break;
}
}
if (!map)
return;
m_Charset = map->m_Charset;
m_Coding = map->m_Coding;
m_CodingScheme = map->m_CodingScheme;
if (m_CodingScheme == MixedTwoBytes) {
m_MixedTwoByteLeadingBytes = std::vector<bool>(256);
for (uint32_t i = 0; i < map->m_LeadingSegCount; ++i) {
const ByteRange& seg = map->m_LeadingSegs[i];
for (int b = seg.m_First; b <= seg.m_Last; ++b)
m_MixedTwoByteLeadingBytes[b] = true;
}
}
FPDFAPI_FindEmbeddedCMap(bsName, m_Charset, m_Coding, m_pEmbedMap);
if (!m_pEmbedMap)
return;
m_bLoaded = true;
}
void CPDF_CMap::LoadEmbedded(const uint8_t* pData, uint32_t size) {
m_DirectCharcodeToCIDTable = std::vector<uint16_t>(65536);
CPDF_CMapParser parser(this);
CPDF_SimpleParser syntax(pData, size);
while (1) {
CFX_ByteStringC word = syntax.GetWord();
if (word.IsEmpty()) {
break;
}
parser.ParseWord(word);
}
if (m_CodingScheme == MixedFourBytes && parser.HasAdditionalMappings()) {
m_AdditionalCharcodeToCIDMappings = parser.TakeAdditionalMappings();
std::sort(
m_AdditionalCharcodeToCIDMappings.begin(),
m_AdditionalCharcodeToCIDMappings.end(),
[](const CPDF_CMap::CIDRange& arg1, const CPDF_CMap::CIDRange& arg2) {
return arg1.m_EndCode < arg2.m_EndCode;
});
}
}
uint16_t CPDF_CMap::CIDFromCharCode(uint32_t charcode) const {
if (m_Coding == CIDCODING_CID)
return static_cast<uint16_t>(charcode);
if (m_pEmbedMap)
return FPDFAPI_CIDFromCharCode(m_pEmbedMap, charcode);
if (m_DirectCharcodeToCIDTable.empty())
return static_cast<uint16_t>(charcode);
if (charcode < 0x10000)
return m_DirectCharcodeToCIDTable[charcode];
auto it = std::lower_bound(m_AdditionalCharcodeToCIDMappings.begin(),
m_AdditionalCharcodeToCIDMappings.end(), charcode,
[](const CPDF_CMap::CIDRange& arg, uint32_t val) {
return arg.m_EndCode < val;
});
if (it == m_AdditionalCharcodeToCIDMappings.end() ||
it->m_StartCode > charcode) {
return 0;
}
return it->m_StartCID + charcode - it->m_StartCode;
}
uint32_t CPDF_CMap::GetNextChar(const char* pString,
int nStrLen,
int& offset) const {
auto* pBytes = reinterpret_cast<const uint8_t*>(pString);
switch (m_CodingScheme) {
case OneByte: {
return pBytes[offset++];
}
case TwoBytes: {
uint8_t byte1 = pBytes[offset++];
return 256 * byte1 + pBytes[offset++];
}
case MixedTwoBytes: {
uint8_t byte1 = pBytes[offset++];
if (!m_MixedTwoByteLeadingBytes[byte1])
return byte1;
return 256 * byte1 + pBytes[offset++];
}
case MixedFourBytes: {
uint8_t codes[4];
int char_size = 1;
codes[0] = pBytes[offset++];
while (1) {
int ret = CheckFourByteCodeRange(codes, char_size,
m_MixedFourByteLeadingRanges);
if (ret == 0)
return 0;
if (ret == 2) {
uint32_t charcode = 0;
for (int i = 0; i < char_size; i++)
charcode = (charcode << 8) + codes[i];
return charcode;
}
if (char_size == 4 || offset == nStrLen)
return 0;
codes[char_size++] = pBytes[offset++];
}
break;
}
}
return 0;
}
int CPDF_CMap::GetCharSize(uint32_t charcode) const {
switch (m_CodingScheme) {
case OneByte:
return 1;
case TwoBytes:
return 2;
case MixedTwoBytes:
if (charcode < 0x100)
return 1;
return 2;
case MixedFourBytes:
if (charcode < 0x100)
return 1;
if (charcode < 0x10000)
return 2;
if (charcode < 0x1000000)
return 3;
return 4;
}
return 1;
}
int CPDF_CMap::CountChar(const char* pString, int size) const {
switch (m_CodingScheme) {
case OneByte:
return size;
case TwoBytes:
return (size + 1) / 2;
case MixedTwoBytes: {
int count = 0;
for (int i = 0; i < size; i++) {
count++;
if (m_MixedTwoByteLeadingBytes[reinterpret_cast<const uint8_t*>(
pString)[i]]) {
i++;
}
}
return count;
}
case MixedFourBytes: {
int count = 0, offset = 0;
while (offset < size) {
GetNextChar(pString, size, offset);
count++;
}
return count;
}
}
return size;
}
int CPDF_CMap::AppendChar(char* str, uint32_t charcode) const {
switch (m_CodingScheme) {
case OneByte:
str[0] = (uint8_t)charcode;
return 1;
case TwoBytes:
str[0] = (uint8_t)(charcode / 256);
str[1] = (uint8_t)(charcode % 256);
return 2;
case MixedTwoBytes:
if (charcode < 0x100 && !m_MixedTwoByteLeadingBytes[(uint8_t)charcode]) {
str[0] = (uint8_t)charcode;
return 1;
}
str[0] = (uint8_t)(charcode >> 8);
str[1] = (uint8_t)charcode;
return 2;
case MixedFourBytes:
if (charcode < 0x100) {
int iSize =
GetFourByteCharSizeImpl(charcode, m_MixedFourByteLeadingRanges);
if (iSize == 0)
iSize = 1;
str[iSize - 1] = (uint8_t)charcode;
if (iSize > 1)
memset(str, 0, iSize - 1);
return iSize;
}
if (charcode < 0x10000) {
str[0] = (uint8_t)(charcode >> 8);
str[1] = (uint8_t)charcode;
return 2;
}
if (charcode < 0x1000000) {
str[0] = (uint8_t)(charcode >> 16);
str[1] = (uint8_t)(charcode >> 8);
str[2] = (uint8_t)charcode;
return 3;
}
str[0] = (uint8_t)(charcode >> 24);
str[1] = (uint8_t)(charcode >> 16);
str[2] = (uint8_t)(charcode >> 8);
str[3] = (uint8_t)charcode;
return 4;
}
return 0;
}