PdfContentStreamReader.h

// SPDX-FileCopyrightText: 2022 Francesco Pretto <ceztko@gmail.com>
// SPDX-License-Identifier: LGPL-2.0-or-later OR MPL-2.0
 
#ifndef PDF_CONTENT_READER_H
#define PDF_CONTENT_READER_H
 
#include "PdfXObject.h"
#include "PdfCanvas.h"
#include "PdfData.h"
#include "PdfDictionary.h"
#include "PdfVariantStack.h"
#include "PdfPostScriptTokenizer.h"
 
namespace PoDoFo {
 
enum class PdfContentType : uint8_t
{
    Unknown = 0,
    Operator,          
    ImageDictionary,   
    ImageData,         
    DoXObject,         
    BeginFormXObject,  
    EndFormXObject,    
    UnexpectedKeyword, 
};
 
enum class PdfContentWarnings : uint16_t
{
    None = 0,
    SpuriousStackContent = 1,           
    RecursiveXObject = 2,               
    InvalidImageDictionaryContent = 4,  
    MissingEndImage = 8,                
};
 
enum class PdfContentErrors : uint16_t
{
    None = 0,
    InvalidOperator = 1,                
    InvalidXObject = 2,                 
    UnexpectedToken = 4,                
};
 
class PODOFO_API PdfContent final
{
    friend class PdfContentStreamReader;
public:
    PdfContent();
public:
    struct Data
    {
        PdfVariantStack Stack;
        PdfOperator Operator = PdfOperator::Unknown;
        std::string_view Keyword;
        PdfDictionary InlineImageDictionary;
        charbuff InlineImageData;
        const PdfName* Name = nullptr;
        std::shared_ptr<PdfXObject> XObject;
    };
 
    const PdfVariantStack& GetStack() const;
    PdfOperator GetOperator() const;
    const std::string_view& GetKeyword() const;
    const PdfDictionary& GetInlineImageDictionary() const;
    const charbuff& GetInlineImageData() const;
    const std::shared_ptr<const PdfXObject>& GetXObject() const;
 
    bool HasWarnings() const;
    bool HasErrors() const;
 
    PdfContentType GetType() const { return Type; }
    PdfContentWarnings GetWarnings() const { return Warnings; }
    PdfContentErrors GetErrors() const { return Errors; }
 
    const Data& operator*() const { return Data; }
 
    Data& operator*() { return Data; }
 
    const Data* operator->() const { return &Data; }
 
    Data* operator->() { return &Data; }
 
private:
    void checkAccess(PdfContentType type) const;
 
private:
    PdfContentType Type;
    bool ThrowOnWarnings;
    PdfContentWarnings Warnings;
    PdfContentErrors Errors;
    struct Data Data;
};
 
enum class PdfContentReaderFlags
{
    None = 0,
    ThrowOnWarnings = 1,
    SkipFollowFormXObjects = 2,     
    SkipHandleNonFormXObjects = 4,  
    SkipFetchInlineImages = 8,      
};
 
using PdfInlineImageHandler = std::function<bool(const PdfDictionary& imageDict, InputStreamDevice& device)>;
 
struct PODOFO_API PdfContentReaderArgs final
{
    PdfContentReaderFlags Flags = PdfContentReaderFlags::None;
    PdfInlineImageHandler InlineImageHandler;
};
 
class PODOFO_API PdfContentStreamReader final
{
public:
    PdfContentStreamReader(const PdfCanvas& canvas, nullable<const PdfContentReaderArgs&> args = { });
 
    PdfContentStreamReader(std::shared_ptr<InputStreamDevice> device, nullable<const PdfContentReaderArgs&> args = { });
 
private:
    PdfContentStreamReader(std::shared_ptr<InputStreamDevice>&& device, const PdfCanvas* canvas,
        nullable<const PdfContentReaderArgs&> args);
 
public:
    bool TryReadNext(PdfContent& data);
 
private:
    void beforeReadReset(PdfContent& content);
 
    void afterReadClear(PdfContent& content);
 
    bool tryReadNextContent(PdfContent& content);
 
    bool tryHandleOperator(PdfContent& content, bool& eof);
 
    bool tryReadInlineImgDict(PdfContent& content);
 
    bool tryReadInlineImgData(charbuff& data, const PdfDictionary& imageDict, bool skipSaveImage);
 
    bool tryHandleXObject(PdfContent& content);
 
    bool isCalledRecursively(const PdfObject* xobj);
 
private:
    struct Storage
    {
        PdfPostScriptTokenType PsType;
        std::string_view Keyword;
        PdfVariant Variant;
        PdfName Name;
    };
 
    struct Input
    {
        std::shared_ptr<const PdfXObject> Form;
        std::shared_ptr<InputStreamDevice> Device;
        const PdfCanvas* Canvas;
    };
 
private:
    std::vector<Input> m_inputs;
    PdfContentReaderArgs m_args;
    std::shared_ptr<charbuff> m_buffer;
    PdfPostScriptTokenizer m_tokenizer;
    bool m_readingInlineImgData;  // A state of reading inline image data
 
    // Temp storage
    Storage m_temp;
};
 
};
 
ENABLE_BITMASK_OPERATORS(PoDoFo::PdfContentReaderFlags);
ENABLE_BITMASK_OPERATORS(PoDoFo::PdfContentWarnings);
ENABLE_BITMASK_OPERATORS(PoDoFo::PdfContentErrors);
 
#endif // PDF_CONTENT_READER_H