// Copyright 2014 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/fpdf_page/pageint.h"
|
|
#include <limits.h>
|
|
#include "core/fpdfapi/fpdf_font/cpdf_type3char.h"
|
#include "core/fpdfapi/fpdf_page/cpdf_allstates.h"
|
#include "core/fpdfapi/fpdf_page/include/cpdf_form.h"
|
#include "core/fpdfapi/fpdf_page/include/cpdf_page.h"
|
#include "core/fpdfapi/fpdf_page/include/cpdf_pageobject.h"
|
#include "core/fpdfapi/fpdf_page/include/cpdf_path.h"
|
#include "core/fpdfapi/fpdf_parser/cpdf_boolean.h"
|
#include "core/fpdfapi/fpdf_parser/cpdf_null.h"
|
#include "core/fpdfapi/fpdf_parser/fpdf_parser_utility.h"
|
#include "core/fpdfapi/fpdf_parser/include/cpdf_array.h"
|
#include "core/fpdfapi/fpdf_parser/include/cpdf_dictionary.h"
|
#include "core/fpdfapi/fpdf_parser/include/cpdf_document.h"
|
#include "core/fpdfapi/fpdf_parser/include/cpdf_name.h"
|
#include "core/fpdfapi/fpdf_parser/include/cpdf_number.h"
|
#include "core/fpdfapi/fpdf_parser/include/cpdf_stream.h"
|
#include "core/fpdfapi/fpdf_parser/include/cpdf_stream_acc.h"
|
#include "core/fpdfapi/fpdf_parser/include/cpdf_string.h"
|
#include "core/fpdfapi/fpdf_parser/include/fpdf_parser_decode.h"
|
#include "core/fpdfapi/include/cpdf_modulemgr.h"
|
#include "core/fxcodec/include/fx_codec.h"
|
#include "core/fxcrt/include/fx_ext.h"
|
#include "core/fxcrt/include/fx_safe_types.h"
|
|
namespace {
|
|
const uint32_t kMaxNestedArrayLevel = 512;
|
const uint32_t kMaxWordBuffer = 256;
|
const FX_STRSIZE kMaxStringLength = 32767;
|
|
} // namespace
|
|
CPDF_StreamParser::CPDF_StreamParser(const uint8_t* pData, uint32_t dwSize) {
|
m_pBuf = pData;
|
m_Size = dwSize;
|
m_Pos = 0;
|
m_pLastObj = nullptr;
|
}
|
|
CPDF_StreamParser::~CPDF_StreamParser() {
|
if (m_pLastObj) {
|
m_pLastObj->Release();
|
}
|
}
|
|
uint32_t DecodeAllScanlines(CCodec_ScanlineDecoder* pDecoder,
|
uint8_t*& dest_buf,
|
uint32_t& dest_size) {
|
if (!pDecoder) {
|
return FX_INVALID_OFFSET;
|
}
|
int ncomps = pDecoder->CountComps();
|
int bpc = pDecoder->GetBPC();
|
int width = pDecoder->GetWidth();
|
int height = pDecoder->GetHeight();
|
int pitch = (width * ncomps * bpc + 7) / 8;
|
if (height == 0 || pitch > (1 << 30) / height) {
|
delete pDecoder;
|
return FX_INVALID_OFFSET;
|
}
|
dest_buf = FX_Alloc2D(uint8_t, pitch, height);
|
dest_size = pitch * height; // Safe since checked alloc returned.
|
for (int row = 0; row < height; row++) {
|
const uint8_t* pLine = pDecoder->GetScanline(row);
|
if (!pLine)
|
break;
|
|
FXSYS_memcpy(dest_buf + row * pitch, pLine, pitch);
|
}
|
uint32_t srcoff = pDecoder->GetSrcOffset();
|
delete pDecoder;
|
return srcoff;
|
}
|
|
CCodec_ScanlineDecoder* FPDFAPI_CreateFaxDecoder(
|
const uint8_t* src_buf,
|
uint32_t src_size,
|
int width,
|
int height,
|
const CPDF_Dictionary* pParams);
|
|
uint32_t PDF_DecodeInlineStream(const uint8_t* src_buf,
|
uint32_t limit,
|
int width,
|
int height,
|
CFX_ByteString& decoder,
|
CPDF_Dictionary* pParam,
|
uint8_t*& dest_buf,
|
uint32_t& dest_size) {
|
if (decoder == "CCITTFaxDecode" || decoder == "CCF") {
|
CCodec_ScanlineDecoder* pDecoder =
|
FPDFAPI_CreateFaxDecoder(src_buf, limit, width, height, pParam);
|
return DecodeAllScanlines(pDecoder, dest_buf, dest_size);
|
}
|
if (decoder == "ASCII85Decode" || decoder == "A85") {
|
return A85Decode(src_buf, limit, dest_buf, dest_size);
|
}
|
if (decoder == "ASCIIHexDecode" || decoder == "AHx") {
|
return HexDecode(src_buf, limit, dest_buf, dest_size);
|
}
|
if (decoder == "FlateDecode" || decoder == "Fl") {
|
return FPDFAPI_FlateOrLZWDecode(FALSE, src_buf, limit, pParam, dest_size,
|
dest_buf, dest_size);
|
}
|
if (decoder == "LZWDecode" || decoder == "LZW") {
|
return FPDFAPI_FlateOrLZWDecode(TRUE, src_buf, limit, pParam, 0, dest_buf,
|
dest_size);
|
}
|
if (decoder == "DCTDecode" || decoder == "DCT") {
|
CCodec_ScanlineDecoder* pDecoder =
|
CPDF_ModuleMgr::Get()->GetJpegModule()->CreateDecoder(
|
src_buf, limit, width, height, 0,
|
pParam ? pParam->GetIntegerBy("ColorTransform", 1) : 1);
|
return DecodeAllScanlines(pDecoder, dest_buf, dest_size);
|
}
|
if (decoder == "RunLengthDecode" || decoder == "RL") {
|
return RunLengthDecode(src_buf, limit, dest_buf, dest_size);
|
}
|
dest_size = 0;
|
dest_buf = 0;
|
return (uint32_t)-1;
|
}
|
|
CPDF_Stream* CPDF_StreamParser::ReadInlineStream(CPDF_Document* pDoc,
|
CPDF_Dictionary* pDict,
|
CPDF_Object* pCSObj) {
|
if (m_Pos == m_Size)
|
return nullptr;
|
|
if (PDFCharIsWhitespace(m_pBuf[m_Pos]))
|
m_Pos++;
|
|
CFX_ByteString Decoder;
|
CPDF_Dictionary* pParam = nullptr;
|
CPDF_Object* pFilter = pDict->GetDirectObjectBy("Filter");
|
if (pFilter) {
|
if (CPDF_Array* pArray = pFilter->AsArray()) {
|
Decoder = pArray->GetStringAt(0);
|
CPDF_Array* pParams = pDict->GetArrayBy("DecodeParms");
|
if (pParams)
|
pParam = pParams->GetDictAt(0);
|
} else {
|
Decoder = pFilter->GetString();
|
pParam = pDict->GetDictBy("DecodeParms");
|
}
|
}
|
uint32_t width = pDict->GetIntegerBy("Width");
|
uint32_t height = pDict->GetIntegerBy("Height");
|
uint32_t OrigSize = 0;
|
if (pCSObj) {
|
uint32_t bpc = pDict->GetIntegerBy("BitsPerComponent");
|
uint32_t nComponents = 1;
|
CPDF_ColorSpace* pCS = pDoc->LoadColorSpace(pCSObj);
|
if (!pCS) {
|
nComponents = 3;
|
} else {
|
nComponents = pCS->CountComponents();
|
pDoc->GetPageData()->ReleaseColorSpace(pCSObj);
|
}
|
uint32_t pitch = width;
|
if (bpc && pitch > INT_MAX / bpc) {
|
return nullptr;
|
}
|
pitch *= bpc;
|
if (nComponents && pitch > INT_MAX / nComponents) {
|
return nullptr;
|
}
|
pitch *= nComponents;
|
if (pitch > INT_MAX - 7) {
|
return nullptr;
|
}
|
pitch += 7;
|
pitch /= 8;
|
OrigSize = pitch;
|
} else {
|
if (width > INT_MAX - 7) {
|
return nullptr;
|
}
|
OrigSize = ((width + 7) / 8);
|
}
|
if (height && OrigSize > INT_MAX / height) {
|
return nullptr;
|
}
|
OrigSize *= height;
|
uint8_t* pData = nullptr;
|
uint32_t dwStreamSize;
|
if (Decoder.IsEmpty()) {
|
if (OrigSize > m_Size - m_Pos) {
|
OrigSize = m_Size - m_Pos;
|
}
|
pData = FX_Alloc(uint8_t, OrigSize);
|
FXSYS_memcpy(pData, m_pBuf + m_Pos, OrigSize);
|
dwStreamSize = OrigSize;
|
m_Pos += OrigSize;
|
} else {
|
uint32_t dwDestSize = OrigSize;
|
dwStreamSize =
|
PDF_DecodeInlineStream(m_pBuf + m_Pos, m_Size - m_Pos, width, height,
|
Decoder, pParam, pData, dwDestSize);
|
FX_Free(pData);
|
if ((int)dwStreamSize < 0)
|
return nullptr;
|
|
uint32_t dwSavePos = m_Pos;
|
m_Pos += dwStreamSize;
|
while (1) {
|
uint32_t dwPrevPos = m_Pos;
|
CPDF_StreamParser::SyntaxType type = ParseNextElement();
|
if (type == CPDF_StreamParser::EndOfData)
|
break;
|
|
if (type != CPDF_StreamParser::Keyword) {
|
dwStreamSize += m_Pos - dwPrevPos;
|
continue;
|
}
|
if (GetWordSize() == 2 && GetWordBuf()[0] == 'E' &&
|
GetWordBuf()[1] == 'I') {
|
m_Pos = dwPrevPos;
|
break;
|
}
|
dwStreamSize += m_Pos - dwPrevPos;
|
}
|
m_Pos = dwSavePos;
|
pData = FX_Alloc(uint8_t, dwStreamSize);
|
FXSYS_memcpy(pData, m_pBuf + m_Pos, dwStreamSize);
|
m_Pos += dwStreamSize;
|
}
|
pDict->SetAtInteger("Length", (int)dwStreamSize);
|
return new CPDF_Stream(pData, dwStreamSize, pDict);
|
}
|
|
CPDF_StreamParser::SyntaxType CPDF_StreamParser::ParseNextElement() {
|
if (m_pLastObj) {
|
m_pLastObj->Release();
|
m_pLastObj = nullptr;
|
}
|
|
m_WordSize = 0;
|
FX_BOOL bIsNumber = TRUE;
|
if (!PositionIsInBounds())
|
return EndOfData;
|
|
int ch = m_pBuf[m_Pos++];
|
while (1) {
|
while (PDFCharIsWhitespace(ch)) {
|
if (!PositionIsInBounds())
|
return EndOfData;
|
|
ch = m_pBuf[m_Pos++];
|
}
|
|
if (ch != '%')
|
break;
|
|
while (1) {
|
if (!PositionIsInBounds())
|
return EndOfData;
|
|
ch = m_pBuf[m_Pos++];
|
if (PDFCharIsLineEnding(ch))
|
break;
|
}
|
}
|
|
if (PDFCharIsDelimiter(ch) && ch != '/') {
|
m_Pos--;
|
m_pLastObj = ReadNextObject(false, 0);
|
return Others;
|
}
|
|
while (1) {
|
if (m_WordSize < kMaxWordBuffer)
|
m_WordBuffer[m_WordSize++] = ch;
|
|
if (!PDFCharIsNumeric(ch))
|
bIsNumber = FALSE;
|
|
if (!PositionIsInBounds())
|
break;
|
|
ch = m_pBuf[m_Pos++];
|
|
if (PDFCharIsDelimiter(ch) || PDFCharIsWhitespace(ch)) {
|
m_Pos--;
|
break;
|
}
|
}
|
|
m_WordBuffer[m_WordSize] = 0;
|
if (bIsNumber)
|
return Number;
|
|
if (m_WordBuffer[0] == '/')
|
return Name;
|
|
if (m_WordSize == 4) {
|
if (memcmp(m_WordBuffer, "true", 4) == 0) {
|
m_pLastObj = new CPDF_Boolean(TRUE);
|
return Others;
|
}
|
if (memcmp(m_WordBuffer, "null", 4) == 0) {
|
m_pLastObj = new CPDF_Null;
|
return Others;
|
}
|
} else if (m_WordSize == 5) {
|
if (memcmp(m_WordBuffer, "false", 5) == 0) {
|
m_pLastObj = new CPDF_Boolean(FALSE);
|
return Others;
|
}
|
}
|
return Keyword;
|
}
|
|
CPDF_Object* CPDF_StreamParser::ReadNextObject(bool bAllowNestedArray,
|
uint32_t dwInArrayLevel) {
|
FX_BOOL bIsNumber;
|
GetNextWord(bIsNumber);
|
if (!m_WordSize)
|
return nullptr;
|
|
if (bIsNumber) {
|
m_WordBuffer[m_WordSize] = 0;
|
return new CPDF_Number(CFX_ByteStringC(m_WordBuffer, m_WordSize));
|
}
|
|
int first_char = m_WordBuffer[0];
|
if (first_char == '/') {
|
return new CPDF_Name(
|
PDF_NameDecode(CFX_ByteStringC(m_WordBuffer + 1, m_WordSize - 1)));
|
}
|
|
if (first_char == '(')
|
return new CPDF_String(ReadString(), FALSE);
|
|
if (first_char == '<') {
|
if (m_WordSize == 1)
|
return new CPDF_String(ReadHexString(), TRUE);
|
|
CPDF_Dictionary* pDict = new CPDF_Dictionary;
|
while (1) {
|
GetNextWord(bIsNumber);
|
if (m_WordSize == 2 && m_WordBuffer[0] == '>')
|
break;
|
|
if (!m_WordSize || m_WordBuffer[0] != '/') {
|
pDict->Release();
|
return nullptr;
|
}
|
|
CFX_ByteString key =
|
PDF_NameDecode(CFX_ByteStringC(m_WordBuffer + 1, m_WordSize - 1));
|
CPDF_Object* pObj = ReadNextObject(true, 0);
|
if (!pObj) {
|
pDict->Release();
|
return nullptr;
|
}
|
|
if (key.IsEmpty())
|
pObj->Release();
|
else
|
pDict->SetAt(key, pObj);
|
}
|
return pDict;
|
}
|
|
if (first_char == '[') {
|
if ((!bAllowNestedArray && dwInArrayLevel) ||
|
dwInArrayLevel > kMaxNestedArrayLevel) {
|
return nullptr;
|
}
|
|
CPDF_Array* pArray = new CPDF_Array;
|
while (1) {
|
CPDF_Object* pObj = ReadNextObject(bAllowNestedArray, dwInArrayLevel + 1);
|
if (pObj) {
|
pArray->Add(pObj);
|
continue;
|
}
|
|
if (!m_WordSize || m_WordBuffer[0] == ']')
|
break;
|
}
|
return pArray;
|
}
|
|
if (m_WordSize == 5 && !memcmp(m_WordBuffer, "false", 5))
|
return new CPDF_Boolean(FALSE);
|
|
if (m_WordSize == 4) {
|
if (memcmp(m_WordBuffer, "true", 4) == 0)
|
return new CPDF_Boolean(TRUE);
|
|
if (memcmp(m_WordBuffer, "null", 4) == 0)
|
return new CPDF_Null;
|
}
|
|
return nullptr;
|
}
|
|
void CPDF_StreamParser::GetNextWord(FX_BOOL& bIsNumber) {
|
m_WordSize = 0;
|
bIsNumber = TRUE;
|
if (!PositionIsInBounds())
|
return;
|
|
int ch = m_pBuf[m_Pos++];
|
while (1) {
|
while (PDFCharIsWhitespace(ch)) {
|
if (!PositionIsInBounds()) {
|
return;
|
}
|
ch = m_pBuf[m_Pos++];
|
}
|
|
if (ch != '%')
|
break;
|
|
while (1) {
|
if (!PositionIsInBounds())
|
return;
|
ch = m_pBuf[m_Pos++];
|
if (PDFCharIsLineEnding(ch))
|
break;
|
}
|
}
|
|
if (PDFCharIsDelimiter(ch)) {
|
bIsNumber = FALSE;
|
m_WordBuffer[m_WordSize++] = ch;
|
if (ch == '/') {
|
while (1) {
|
if (!PositionIsInBounds())
|
return;
|
ch = m_pBuf[m_Pos++];
|
if (!PDFCharIsOther(ch) && !PDFCharIsNumeric(ch)) {
|
m_Pos--;
|
return;
|
}
|
|
if (m_WordSize < kMaxWordBuffer)
|
m_WordBuffer[m_WordSize++] = ch;
|
}
|
} else if (ch == '<') {
|
if (!PositionIsInBounds())
|
return;
|
ch = m_pBuf[m_Pos++];
|
if (ch == '<')
|
m_WordBuffer[m_WordSize++] = ch;
|
else
|
m_Pos--;
|
} else if (ch == '>') {
|
if (!PositionIsInBounds())
|
return;
|
ch = m_pBuf[m_Pos++];
|
if (ch == '>')
|
m_WordBuffer[m_WordSize++] = ch;
|
else
|
m_Pos--;
|
}
|
return;
|
}
|
|
while (1) {
|
if (m_WordSize < kMaxWordBuffer)
|
m_WordBuffer[m_WordSize++] = ch;
|
if (!PDFCharIsNumeric(ch))
|
bIsNumber = FALSE;
|
|
if (!PositionIsInBounds())
|
return;
|
ch = m_pBuf[m_Pos++];
|
if (PDFCharIsDelimiter(ch) || PDFCharIsWhitespace(ch)) {
|
m_Pos--;
|
break;
|
}
|
}
|
}
|
|
CFX_ByteString CPDF_StreamParser::ReadString() {
|
if (!PositionIsInBounds())
|
return CFX_ByteString();
|
|
uint8_t ch = m_pBuf[m_Pos++];
|
CFX_ByteTextBuf buf;
|
int parlevel = 0;
|
int status = 0;
|
int iEscCode = 0;
|
while (1) {
|
switch (status) {
|
case 0:
|
if (ch == ')') {
|
if (parlevel == 0) {
|
if (buf.GetLength() > kMaxStringLength) {
|
return CFX_ByteString(buf.GetBuffer(), kMaxStringLength);
|
}
|
return buf.MakeString();
|
}
|
parlevel--;
|
buf.AppendChar(')');
|
} else if (ch == '(') {
|
parlevel++;
|
buf.AppendChar('(');
|
} else if (ch == '\\') {
|
status = 1;
|
} else {
|
buf.AppendChar((char)ch);
|
}
|
break;
|
case 1:
|
if (ch >= '0' && ch <= '7') {
|
iEscCode = FXSYS_toDecimalDigit(static_cast<FX_WCHAR>(ch));
|
status = 2;
|
break;
|
}
|
if (ch == 'n') {
|
buf.AppendChar('\n');
|
} else if (ch == 'r') {
|
buf.AppendChar('\r');
|
} else if (ch == 't') {
|
buf.AppendChar('\t');
|
} else if (ch == 'b') {
|
buf.AppendChar('\b');
|
} else if (ch == 'f') {
|
buf.AppendChar('\f');
|
} else if (ch == '\r') {
|
status = 4;
|
break;
|
} else if (ch == '\n') {
|
} else {
|
buf.AppendChar(ch);
|
}
|
status = 0;
|
break;
|
case 2:
|
if (ch >= '0' && ch <= '7') {
|
iEscCode =
|
iEscCode * 8 + FXSYS_toDecimalDigit(static_cast<FX_WCHAR>(ch));
|
status = 3;
|
} else {
|
buf.AppendChar(iEscCode);
|
status = 0;
|
continue;
|
}
|
break;
|
case 3:
|
if (ch >= '0' && ch <= '7') {
|
iEscCode =
|
iEscCode * 8 + FXSYS_toDecimalDigit(static_cast<FX_WCHAR>(ch));
|
buf.AppendChar(iEscCode);
|
status = 0;
|
} else {
|
buf.AppendChar(iEscCode);
|
status = 0;
|
continue;
|
}
|
break;
|
case 4:
|
status = 0;
|
if (ch != '\n') {
|
continue;
|
}
|
break;
|
}
|
if (!PositionIsInBounds())
|
break;
|
|
ch = m_pBuf[m_Pos++];
|
}
|
if (PositionIsInBounds())
|
++m_Pos;
|
|
if (buf.GetLength() > kMaxStringLength) {
|
return CFX_ByteString(buf.GetBuffer(), kMaxStringLength);
|
}
|
return buf.MakeString();
|
}
|
|
CFX_ByteString CPDF_StreamParser::ReadHexString() {
|
if (!PositionIsInBounds())
|
return CFX_ByteString();
|
|
CFX_ByteTextBuf buf;
|
bool bFirst = true;
|
int code = 0;
|
while (PositionIsInBounds()) {
|
int ch = m_pBuf[m_Pos++];
|
|
if (ch == '>')
|
break;
|
|
if (!std::isxdigit(ch))
|
continue;
|
|
int val = FXSYS_toHexDigit(ch);
|
if (bFirst) {
|
code = val * 16;
|
} else {
|
code += val;
|
buf.AppendByte((uint8_t)code);
|
}
|
bFirst = !bFirst;
|
}
|
if (!bFirst)
|
buf.AppendChar((char)code);
|
|
if (buf.GetLength() > kMaxStringLength)
|
return CFX_ByteString(buf.GetBuffer(), kMaxStringLength);
|
|
return buf.MakeString();
|
}
|
|
bool CPDF_StreamParser::PositionIsInBounds() const {
|
return m_Pos < m_Size;
|
}
|
|
CPDF_ContentParser::CPDF_ContentParser()
|
: m_Status(Ready),
|
m_InternalStage(STAGE_GETCONTENT),
|
m_pObjectHolder(nullptr),
|
m_bForm(false),
|
m_pType3Char(nullptr),
|
m_pData(nullptr),
|
m_Size(0),
|
m_CurrentOffset(0) {}
|
|
CPDF_ContentParser::~CPDF_ContentParser() {
|
if (!m_pSingleStream)
|
FX_Free(m_pData);
|
}
|
|
void CPDF_ContentParser::Start(CPDF_Page* pPage) {
|
if (m_Status != Ready || !pPage || !pPage->m_pDocument ||
|
!pPage->m_pFormDict) {
|
m_Status = Done;
|
return;
|
}
|
m_pObjectHolder = pPage;
|
m_bForm = FALSE;
|
m_Status = ToBeContinued;
|
m_InternalStage = STAGE_GETCONTENT;
|
m_CurrentOffset = 0;
|
|
CPDF_Object* pContent = pPage->m_pFormDict->GetDirectObjectBy("Contents");
|
if (!pContent) {
|
m_Status = Done;
|
return;
|
}
|
if (CPDF_Stream* pStream = pContent->AsStream()) {
|
m_nStreams = 0;
|
m_pSingleStream.reset(new CPDF_StreamAcc);
|
m_pSingleStream->LoadAllData(pStream, FALSE);
|
} else if (CPDF_Array* pArray = pContent->AsArray()) {
|
m_nStreams = pArray->GetCount();
|
if (m_nStreams)
|
m_StreamArray.resize(m_nStreams);
|
else
|
m_Status = Done;
|
} else {
|
m_Status = Done;
|
}
|
}
|
|
void CPDF_ContentParser::Start(CPDF_Form* pForm,
|
CPDF_AllStates* pGraphicStates,
|
const CFX_Matrix* pParentMatrix,
|
CPDF_Type3Char* pType3Char,
|
int level) {
|
m_pType3Char = pType3Char;
|
m_pObjectHolder = pForm;
|
m_bForm = TRUE;
|
CFX_Matrix form_matrix = pForm->m_pFormDict->GetMatrixBy("Matrix");
|
if (pGraphicStates) {
|
form_matrix.Concat(pGraphicStates->m_CTM);
|
}
|
CPDF_Array* pBBox = pForm->m_pFormDict->GetArrayBy("BBox");
|
CFX_FloatRect form_bbox;
|
CPDF_Path ClipPath;
|
if (pBBox) {
|
form_bbox = pBBox->GetRect();
|
ClipPath.New();
|
ClipPath.AppendRect(form_bbox.left, form_bbox.bottom, form_bbox.right,
|
form_bbox.top);
|
ClipPath.Transform(&form_matrix);
|
if (pParentMatrix) {
|
ClipPath.Transform(pParentMatrix);
|
}
|
form_bbox.Transform(&form_matrix);
|
if (pParentMatrix) {
|
form_bbox.Transform(pParentMatrix);
|
}
|
}
|
CPDF_Dictionary* pResources = pForm->m_pFormDict->GetDictBy("Resources");
|
m_pParser.reset(new CPDF_StreamContentParser(
|
pForm->m_pDocument, pForm->m_pPageResources, pForm->m_pResources,
|
pParentMatrix, pForm, pResources, &form_bbox, pGraphicStates, level));
|
m_pParser->GetCurStates()->m_CTM = form_matrix;
|
m_pParser->GetCurStates()->m_ParentMatrix = form_matrix;
|
if (ClipPath.NotNull()) {
|
m_pParser->GetCurStates()->m_ClipPath.AppendPath(ClipPath, FXFILL_WINDING,
|
TRUE);
|
}
|
if (pForm->m_Transparency & PDFTRANS_GROUP) {
|
CPDF_GeneralStateData* pData =
|
m_pParser->GetCurStates()->m_GeneralState.GetModify();
|
pData->m_BlendType = FXDIB_BLEND_NORMAL;
|
pData->m_StrokeAlpha = 1.0f;
|
pData->m_FillAlpha = 1.0f;
|
pData->m_pSoftMask = nullptr;
|
}
|
m_nStreams = 0;
|
m_pSingleStream.reset(new CPDF_StreamAcc);
|
m_pSingleStream->LoadAllData(pForm->m_pFormStream, FALSE);
|
m_pData = (uint8_t*)m_pSingleStream->GetData();
|
m_Size = m_pSingleStream->GetSize();
|
m_Status = ToBeContinued;
|
m_InternalStage = STAGE_PARSE;
|
m_CurrentOffset = 0;
|
}
|
|
void CPDF_ContentParser::Continue(IFX_Pause* pPause) {
|
int steps = 0;
|
while (m_Status == ToBeContinued) {
|
if (m_InternalStage == STAGE_GETCONTENT) {
|
if (m_CurrentOffset == m_nStreams) {
|
if (!m_StreamArray.empty()) {
|
FX_SAFE_UINT32 safeSize = 0;
|
for (const auto& stream : m_StreamArray) {
|
safeSize += stream->GetSize();
|
safeSize += 1;
|
}
|
if (!safeSize.IsValid()) {
|
m_Status = Done;
|
return;
|
}
|
m_Size = safeSize.ValueOrDie();
|
m_pData = FX_Alloc(uint8_t, m_Size);
|
uint32_t pos = 0;
|
for (const auto& stream : m_StreamArray) {
|
FXSYS_memcpy(m_pData + pos, stream->GetData(), stream->GetSize());
|
pos += stream->GetSize();
|
m_pData[pos++] = ' ';
|
}
|
m_StreamArray.clear();
|
} else {
|
m_pData = (uint8_t*)m_pSingleStream->GetData();
|
m_Size = m_pSingleStream->GetSize();
|
}
|
m_InternalStage = STAGE_PARSE;
|
m_CurrentOffset = 0;
|
} else {
|
CPDF_Array* pContent =
|
m_pObjectHolder->m_pFormDict->GetArrayBy("Contents");
|
m_StreamArray[m_CurrentOffset].reset(new CPDF_StreamAcc);
|
CPDF_Stream* pStreamObj = ToStream(
|
pContent ? pContent->GetDirectObjectAt(m_CurrentOffset) : nullptr);
|
m_StreamArray[m_CurrentOffset]->LoadAllData(pStreamObj, FALSE);
|
m_CurrentOffset++;
|
}
|
}
|
if (m_InternalStage == STAGE_PARSE) {
|
if (!m_pParser) {
|
m_pParser.reset(new CPDF_StreamContentParser(
|
m_pObjectHolder->m_pDocument, m_pObjectHolder->m_pPageResources,
|
nullptr, nullptr, m_pObjectHolder, m_pObjectHolder->m_pResources,
|
&m_pObjectHolder->m_BBox, nullptr, 0));
|
m_pParser->GetCurStates()->m_ColorState.GetModify()->Default();
|
}
|
if (m_CurrentOffset >= m_Size) {
|
m_InternalStage = STAGE_CHECKCLIP;
|
} else {
|
m_CurrentOffset +=
|
m_pParser->Parse(m_pData + m_CurrentOffset,
|
m_Size - m_CurrentOffset, PARSE_STEP_LIMIT);
|
}
|
}
|
if (m_InternalStage == STAGE_CHECKCLIP) {
|
if (m_pType3Char) {
|
m_pType3Char->m_bColored = m_pParser->IsColored();
|
m_pType3Char->m_Width =
|
FXSYS_round(m_pParser->GetType3Data()[0] * 1000);
|
m_pType3Char->m_BBox.left =
|
FXSYS_round(m_pParser->GetType3Data()[2] * 1000);
|
m_pType3Char->m_BBox.bottom =
|
FXSYS_round(m_pParser->GetType3Data()[3] * 1000);
|
m_pType3Char->m_BBox.right =
|
FXSYS_round(m_pParser->GetType3Data()[4] * 1000);
|
m_pType3Char->m_BBox.top =
|
FXSYS_round(m_pParser->GetType3Data()[5] * 1000);
|
}
|
for (auto& pObj : *m_pObjectHolder->GetPageObjectList()) {
|
if (pObj->m_ClipPath.IsNull()) {
|
continue;
|
}
|
if (pObj->m_ClipPath.GetPathCount() != 1) {
|
continue;
|
}
|
if (pObj->m_ClipPath.GetTextCount()) {
|
continue;
|
}
|
CPDF_Path ClipPath = pObj->m_ClipPath.GetPath(0);
|
if (!ClipPath.IsRect() || pObj->IsShading()) {
|
continue;
|
}
|
CFX_FloatRect old_rect(ClipPath.GetPointX(0), ClipPath.GetPointY(0),
|
ClipPath.GetPointX(2), ClipPath.GetPointY(2));
|
CFX_FloatRect obj_rect(pObj->m_Left, pObj->m_Bottom, pObj->m_Right,
|
pObj->m_Top);
|
if (old_rect.Contains(obj_rect)) {
|
pObj->m_ClipPath.SetNull();
|
}
|
}
|
m_Status = Done;
|
return;
|
}
|
steps++;
|
if (pPause && pPause->NeedToPauseNow()) {
|
break;
|
}
|
}
|
}
|
