EIC code displayed by LXR master/​include/​poppler/​splash/​SplashTypes.h	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2025-12-11 10:26:10

 //========================================================================
 //
 // SplashTypes.h
 //
 //========================================================================
 
 //========================================================================
 //
 // Modified under the Poppler project - http://poppler.freedesktop.org
 //
 // All changes made under the Poppler project to this file are licensed
 // under GPL version 2 or later
 //
 // Copyright (C) 2006, 2010, 2019, 2020 Albert Astals Cid <aacid@kde.org>
 // Copyright (C) 2008 Tomas Are Haavet <tomasare@gmail.com>
 // Copyright (C) 2009, 2011-2013 Thomas Freitag <Thomas.Freitag@alfa.de>
 // Copyright (C) 2009 Stefan Thomas <thomas@eload24.com>
 // Copyright (C) 2010 William Bader <williambader@hotmail.com>
 // Copyright (C) 2017 Adrian Johnson <ajohnson@redneon.com>
 // Copyright (C) 2018 Stefan Brüns <stefan.bruens@rwth-aachen.de>
 //
 // To see a description of the changes please see the Changelog file that
 // came with your tarball or type make ChangeLog if you are building from git
 //
 //========================================================================
 
 #ifndef SPLASHTYPES_H
 #define SPLASHTYPES_H
 
 #include <cstddef>
 
 //------------------------------------------------------------------------
 // coordinates
 //------------------------------------------------------------------------
 
 #if defined(USE_FLOAT)
 typedef float SplashCoord;
 #else
 typedef double SplashCoord;
 #endif
 
 //------------------------------------------------------------------------
 // antialiasing
 //------------------------------------------------------------------------
 
 #define splashAASize 4
 
 #ifndef SPOT_NCOMPS
 #    define SPOT_NCOMPS 4
 #endif
 
 //------------------------------------------------------------------------
 // colors
 //------------------------------------------------------------------------
 
 enum SplashColorMode
 {
     splashModeMono1, // 1 bit per component, 8 pixels per byte,
                      //   MSbit is on the left
     splashModeMono8, // 1 byte per component, 1 byte per pixel
     splashModeRGB8, // 1 byte per component, 3 bytes per pixel:
                     //   RGBRGB...
     splashModeBGR8, // 1 byte per component, 3 bytes per pixel:
                     //   BGRBGR...
     splashModeXBGR8, // 1 byte per component, 4 bytes per pixel:
                      //   XBGRXBGR...
     splashModeCMYK8, // 1 byte per component, 4 bytes per pixel:
                      //   CMYKCMYK...
     splashModeDeviceN8 // 1 byte per component,
                        // 4 bytes + n bytes spot colors per pixel:
                        // CMYKSSSSCMYKSSSS...
 };
 
 enum SplashThinLineMode
 {
     splashThinLineDefault, // if SA on: draw solid if requested line width, transformed into
                            // device space, is less than half a pixel and a shaped line else
     splashThinLineSolid, // draw line solid at least with 1 pixel
     splashThinLineShape // draw line shaped at least with 1 pixel
 };
 // number of components in each color mode
 // (defined in SplashState.cc)
 extern int splashColorModeNComps[];
 
 // max number of components in any SplashColor
 constexpr std::size_t splashMaxColorComps = SPOT_NCOMPS + 4;
 
 typedef unsigned char SplashColor[splashMaxColorComps];
 typedef unsigned char *SplashColorPtr;
 typedef const unsigned char *SplashColorConstPtr;
 
 // RGB8
 static inline unsigned char splashRGB8R(SplashColorPtr rgb8)
 {
     return rgb8[0];
 }
 static inline unsigned char splashRGB8G(SplashColorPtr rgb8)
 {
     return rgb8[1];
 }
 static inline unsigned char splashRGB8B(SplashColorPtr rgb8)
 {
     return rgb8[2];
 }
 
 // BGR8
 static inline unsigned char splashBGR8R(SplashColorPtr bgr8)
 {
     return bgr8[2];
 }
 static inline unsigned char splashBGR8G(SplashColorPtr bgr8)
 {
     return bgr8[1];
 }
 static inline unsigned char splashBGR8B(SplashColorPtr bgr8)
 {
     return bgr8[0];
 }
 
 // CMYK8
 static inline unsigned char splashCMYK8C(SplashColorPtr cmyk8)
 {
     return cmyk8[0];
 }
 static inline unsigned char splashCMYK8M(SplashColorPtr cmyk8)
 {
     return cmyk8[1];
 }
 static inline unsigned char splashCMYK8Y(SplashColorPtr cmyk8)
 {
     return cmyk8[2];
 }
 static inline unsigned char splashCMYK8K(SplashColorPtr cmyk8)
 {
     return cmyk8[3];
 }
 
 // DEVICEN8
 static inline unsigned char splashDeviceN8C(SplashColorPtr deviceN8)
 {
     return deviceN8[0];
 }
 static inline unsigned char splashDeviceN8M(SplashColorPtr deviceN8)
 {
     return deviceN8[1];
 }
 static inline unsigned char splashDeviceN8Y(SplashColorPtr deviceN8)
 {
     return deviceN8[2];
 }
 static inline unsigned char splashDeviceN8K(SplashColorPtr deviceN8)
 {
     return deviceN8[3];
 }
 static inline unsigned char splashDeviceN8S(SplashColorPtr deviceN8, int nSpot)
 {
     return deviceN8[4 + nSpot];
 }
 
 static inline void splashClearColor(SplashColorPtr dest)
 {
     dest[0] = 0;
     dest[1] = 0;
     dest[2] = 0;
     dest[3] = 0;
     for (int i = 4; i < SPOT_NCOMPS + 4; i++) {
         dest[i] = 0;
     }
 }
 
 static inline void splashColorCopy(SplashColorPtr dest, SplashColorConstPtr src)
 {
     dest[0] = src[0];
     dest[1] = src[1];
     dest[2] = src[2];
     dest[3] = src[3];
     for (int i = 4; i < SPOT_NCOMPS + 4; i++) {
         dest[i] = src[i];
     }
 }
 
 static inline bool splashColorEqual(SplashColorConstPtr dest, SplashColorConstPtr src)
 {
     for (int i = 0; i < SPOT_NCOMPS + 4; i++) {
         if (dest[i] != src[i]) {
             return false;
         }
     }
     return true;
 }
 
 static inline void splashColorXor(SplashColorPtr dest, SplashColorConstPtr src)
 {
     dest[0] ^= src[0];
     dest[1] ^= src[1];
     dest[2] ^= src[2];
     dest[3] ^= src[3];
     for (int i = 4; i < SPOT_NCOMPS + 4; i++) {
         dest[i] ^= src[i];
     }
 }
 
 //------------------------------------------------------------------------
 // blend functions
 //------------------------------------------------------------------------
 
 typedef void (*SplashBlendFunc)(SplashColorPtr src, SplashColorPtr dest, SplashColorPtr blend, SplashColorMode cm);
 
 //------------------------------------------------------------------------
 // screen parameters
 //------------------------------------------------------------------------
 
 enum SplashScreenType
 {
     splashScreenDispersed,
     splashScreenClustered,
     splashScreenStochasticClustered
 };
 
 struct SplashScreenParams
 {
     SplashScreenType type;
     int size;
     int dotRadius;
     SplashCoord gamma;
     SplashCoord blackThreshold;
     SplashCoord whiteThreshold;
 };
 
 //------------------------------------------------------------------------
 // error results
 //------------------------------------------------------------------------
 
 typedef int SplashError;
 
 //------------------------------------------------------------------------
 // image file formats
 //------------------------------------------------------------------------
 
 enum SplashImageFileFormat
 {
     splashFormatJpeg,
     splashFormatPng,
     splashFormatTiff,
     splashFormatJpegCMYK
 };
 
 #endif

This page was automatically generated by the 2.3.7 LXR engine. The LXR team