PdfImage.h

// SPDX-FileCopyrightText: 2005 Dominik Seichter <domseichter@web.de>
// SPDX-FileCopyrightText: 2020 Francesco Pretto <ceztko@gmail.com>
// SPDX-License-Identifier: LGPL-2.0-or-later OR MPL-2.0
 
#ifndef PDF_IMAGE_H
#define PDF_IMAGE_H
 
#include "PdfXObject.h"
 
#include "PdfColorSpace.h"
 
#ifdef PODOFO_HAVE_JPEG_LIB
struct jpeg_decompress_struct;
#endif // PODOFO_HAVE_JPEG_LIB
 
struct png_struct_def;
struct png_info_def;
 
namespace PoDoFo {
 
class PdfDocument;
class InputStream;
 
enum class PdfImageOrientation : uint8_t
{
    Unknown = 0,
    TopLeft,
    TopRight,
    BottomRight,
    BottomLeft,
    LeftTop,
    RightTop,
    RightBottom,
    LeftBottom
};
 
struct PODOFO_API PdfImageInfo final
{
    unsigned Width = 0;
    unsigned Height = 0;
    nullable<PdfFilterList> Filters;
    unsigned char BitsPerComponent = 0;
    PdfColorSpaceInitializer ColorSpace;
    std::vector<double> DecodeArray;
    PdfImageOrientation Orientation = PdfImageOrientation::TopLeft;
};
 
enum class PdfImageLoadFlags
{
    None = 0,
    SkipTransform = 1,  
};
 
struct PODOFO_API PdfImageLoadParams final
{
    unsigned ImageIndex = 0;
    PdfImageLoadFlags Flags = PdfImageLoadFlags::None;
};
 
class PODOFO_API PdfImage final : public PdfXObject
{
    friend class PdfXObject;
    friend class PdfDocument;
 
private:
    PdfImage(PdfDocument& doc);
 
public:
    void DecodeTo(charbuff& buff, PdfPixelFormat format, int scanLineSize = -1) const;
    void DecodeTo(const bufferspan& buff, PdfPixelFormat format, int scanLineSize = -1) const;
    void DecodeTo(OutputStream& stream, PdfPixelFormat format, int scanLineSize = -1) const;
 
    charbuff GetDecodedCopy(PdfPixelFormat format);
 
    bool TryFetchRawImageInfo(PdfImageInfo& info);
 
    void SetSoftMask(const PdfImage& softmask);
 
    void SetData(const bufferview& buffer, unsigned width, unsigned height,
        PdfPixelFormat format, int rowSize = -1);
 
    void SetData(InputStream& stream, unsigned width, unsigned height,
        PdfPixelFormat format, int rowSize = -1);
 
    void SetDataRaw(const bufferview& buffer, const PdfImageInfo& info);
 
    void SetDataRaw(InputStream& stream, const PdfImageInfo& info);
 
    PdfImageInfo Load(const std::string_view& filepath, const PdfImageLoadParams& params = { });
 
    PdfImageInfo LoadFromBuffer(const bufferview& buffer, const PdfImageLoadParams& params = { });
 
    void ExportTo(charbuff& buff, PdfExportFormat format, PdfArray args = {}) const;
 
    void SetChromaKeyMask(int64_t r, int64_t g, int64_t b, int64_t threshold = 0);
 
    void SetInterpolate(bool value);
 
    Rect GetRect() const override;
 
    const PdfColorSpaceFilter& GetColorSpace() const { return *m_ColorSpace; }
 
    unsigned GetWidth() const { return m_Width; }
 
    unsigned GetHeight() const { return m_Height; }
 
protected:
    const PdfXObjectForm* GetForm() const override;
 
private:
    PdfImage(PdfObject& obj);
 
    void setDataRaw(InputStream& stream, const PdfImageInfo& info, PdfImageLoadFlags flags);
 
#ifdef PODOFO_HAVE_JPEG_LIB
    void loadFromJpegInfo(jpeg_decompress_struct& ctx, PdfImageInfo& info);
    void exportToJpeg(charbuff& buff, const PdfArray& args) const;
    void loadFromJpeg(const std::string_view& filename, PdfImageInfo& info);
 
    void loadFromJpegData(const unsigned char* data, size_t len, PdfImageInfo& info);
#endif // PODOFO_HAVE_JPEG_LIB
 
#ifdef PODOFO_HAVE_TIFF_LIB
    void loadFromTiffHandle(void* handle, const PdfImageLoadParams& params, charbuff& buffer, PdfImageInfo& info);
    void loadFromTiff(const std::string_view& filename, const PdfImageLoadParams& params, charbuff& buffer, PdfImageInfo& info);
 
    void loadFromTiffData(const unsigned char* data, size_t len, const PdfImageLoadParams& params, charbuff& buffer, PdfImageInfo& info);
#endif // PODOFO_HAVE_TIFF_LIB
 
#ifdef PODOFO_HAVE_PNG_LIB
    void loadFromPngHandle(FILE* stream, charbuff& buffer, PdfImageInfo& info);
    void loadFromPng(const std::string_view& filename, charbuff& buffer, PdfImageInfo& info);
 
    void loadFromPngData(const unsigned char* data, size_t len, charbuff& buffer, PdfImageInfo& info);
 
    void loadFromPngContent(png_struct_def* png, png_info_def* pngInfo, charbuff& buffer, PdfImageInfo& info);
#endif // PODOFO_HAVE_PNG_LIB
 
    unsigned getBufferSize(PdfPixelFormat format) const;
 
    std::unique_ptr<PdfXObjectForm> getTransformation(PdfImageOrientation orientation);
 
private:
    PdfColorSpaceFilterPtr m_ColorSpace;
    unsigned m_Width;
    unsigned m_Height;
    unsigned char m_BitsPerComponent;
    std::unique_ptr<PdfXObjectForm> m_Transformation;
};
 
};
 
ENABLE_BITMASK_OPERATORS(PoDoFo::PdfImageLoadFlags);
 
#endif // PDF_IMAGE_H