Alien-FreeImage
view release on metacpan or search on metacpan
WriteMakefile(
NAME => 'Any::FreeImage::Module',
VERSION_FROM => 'lib/Any/FreeImage/Module.pm',
LIBS => Alien::FreeImage->config('LIBS'),
INC => Alien::FreeImage->config('INC'),
# + additional params
);
METHODS
config()
This function is the main public interface to this module.
Alien::FreeImage->config('LIBS');
Returns a string like: '-L/path/to/freeimage/dir -lfreeimage'
Alien::FreeImage->config('INC');
Returns a string like: '-I/path/to/freeimage/dir'
Alien::FreeImage->config('PREFIX');
lib/Alien/FreeImage.pm view on Meta::CPAN
VERSION_FROM => 'lib/Any/FreeImage/Module.pm',
LIBS => Alien::FreeImage->config('LIBS'),
INC => Alien::FreeImage->config('INC'),
# + additional params
);
=head1 METHODS
=head2 config()
This function is the main public interface to this module.
Alien::FreeImage->config('LIBS');
Returns a string like: '-L/path/to/freeimage/dir -lfreeimage'
Alien::FreeImage->config('INC');
Returns a string like: '-I/path/to/freeimage/dir'
Alien::FreeImage->config('PREFIX');
src/Source/CacheFile.h view on Meta::CPAN
#endif // _WIN32
// ----------------------------------------------------------
class CacheFile {
typedef std::list<Block *> PageCache;
typedef std::list<Block *>::iterator PageCacheIt;
typedef std::map<int, PageCacheIt> PageMap;
typedef std::map<int, PageCacheIt>::iterator PageMapIt;
public :
CacheFile(const std::string filename, BOOL keep_in_memory);
~CacheFile();
BOOL open();
void close();
BOOL readFile(BYTE *data, int nr, int size);
int writeFile(BYTE *data, int size);
void deleteFile(int nr);
private :
src/Source/DeprecationManager/DeprecationMgr.h view on Meta::CPAN
{ \
void *fptr = NULL; \
DeprecationMgr::GetInstance()->AddDeprecatedFunction(a, b, fptr); \
}
#endif
// ==========================================================
class DeprecationMgr {
#if (_MSC_VER == 1100) // VC 5.0 need to look into the docs for the compiler for the value of each version
public:
#else
private:
#endif
struct DeprecatedFunction {
const char *old_function_name;
const char *new_function_name;
std::set<int> called_from;
};
std::map<const char *, DeprecatedFunction> m_functions;
public:
DeprecationMgr();
~DeprecationMgr();
static DeprecationMgr * GetInstance ( void );
void AddDeprecatedFunction(const char *old_function_name, const char *new_function_name, const void *frame_ptr);
};
#endif //DEPRECATIONMGR_H
src/Source/FreeImage/ConversionType.cpp view on Meta::CPAN
#include "Utilities.h"
// ----------------------------------------------------------
/** Convert a greyscale image of type Tsrc to type Tdst.
Conversion is done using standard C language casting convention.
*/
template<class Tdst, class Tsrc>
class CONVERT_TYPE
{
public:
FIBITMAP* convert(FIBITMAP *src, FREE_IMAGE_TYPE dst_type);
};
template<class Tdst, class Tsrc> FIBITMAP*
CONVERT_TYPE<Tdst, Tsrc>::convert(FIBITMAP *src, FREE_IMAGE_TYPE dst_type) {
FIBITMAP *dst = NULL;
unsigned width = FreeImage_GetWidth(src);
unsigned height = FreeImage_GetHeight(src);
src/Source/FreeImage/ConversionType.cpp view on Meta::CPAN
}
/** Convert a greyscale image of type Tsrc to a 8-bit grayscale dib.
Conversion is done using either a linear scaling from [min, max] to [0, 255]
or a rounding from src_pixel to (BYTE) MIN(255, MAX(0, q)) where int q = int(src_pixel + 0.5);
*/
template<class Tsrc>
class CONVERT_TO_BYTE
{
public:
FIBITMAP* convert(FIBITMAP *src, BOOL scale_linear);
};
template<class Tsrc> FIBITMAP*
CONVERT_TO_BYTE<Tsrc>::convert(FIBITMAP *src, BOOL scale_linear) {
FIBITMAP *dst = NULL;
unsigned x, y;
unsigned width = FreeImage_GetWidth(src);
unsigned height = FreeImage_GetHeight(src);
src/Source/FreeImage/ConversionType.cpp view on Meta::CPAN
}
return dst;
}
/** Convert a greyscale image of type Tsrc to a FICOMPLEX dib.
*/
template<class Tsrc>
class CONVERT_TO_COMPLEX
{
public:
FIBITMAP* convert(FIBITMAP *src);
};
template<class Tsrc> FIBITMAP*
CONVERT_TO_COMPLEX<Tsrc>::convert(FIBITMAP *src) {
FIBITMAP *dst = NULL;
unsigned width = FreeImage_GetWidth(src);
unsigned height = FreeImage_GetHeight(src);
src/Source/FreeImage/MultiPage.cpp view on Meta::CPAN
// ----------------------------------------------------------
struct BlockTypeS {
BlockType m_type;
BlockTypeS(BlockType type) : m_type(type) {
}
virtual ~BlockTypeS() {}
};
struct BlockContinueus : public BlockTypeS {
int m_start;
int m_end;
BlockContinueus(int s, int e) : BlockTypeS(BLOCK_CONTINUEUS),
m_start(s),
m_end(e) {
}
};
struct BlockReference : public BlockTypeS {
int m_reference;
int m_size;
BlockReference(int r, int size) : BlockTypeS(BLOCK_REFERENCE),
m_reference(r),
m_size(size) {
}
};
// ----------------------------------------------------------
src/Source/FreeImage/PSDParser.cpp view on Meta::CPAN
nBytes += n * sizeof(BYTE);
}
return nBytes;
}
//---------------------------------------------------------------------------
/**
Invert only color components, skipping Alpha/Black
(Can be useful as public/utility function)
*/
static
BOOL invertColor(FIBITMAP* dib) {
FREE_IMAGE_TYPE type = FreeImage_GetImageType(dib);
const unsigned Bpp = FreeImage_GetBPP(dib)/8;
if((type == FIT_BITMAP && Bpp == 4) || type == FIT_RGBA16) {
const unsigned width = FreeImage_GetWidth(dib);
const unsigned height = FreeImage_GetHeight(dib);
BYTE *line_start = FreeImage_GetScanLine(dib, 0);
src/Source/FreeImage/PSDParser.h view on Meta::CPAN
BYTE Columns[4]; //! The width of the image in pixels. Supported range is 1 to 30,000.
BYTE Depth[2]; //! The number of bits per channel. Supported values are 1, 8, and 16.
BYTE Mode[2]; //! Colour mode of the file, Bitmap=0, Grayscale=1, Indexed=2, RGB=3, CMYK=4, Multichannel=7, Duotone=8, Lab=9.
} psdHeader;
/**
Table 2-12: HeaderInfo Color spaces
@see psdHeader
*/
class psdHeaderInfo {
public:
short _Channels; //! Numer of channels including any alpha channels, supported range is 1 to 24.
int _Height; //! The height of the image in pixels. Supported range is 1 to 30,000.
int _Width; //! The width of the image in pixels. Supported range is 1 to 30,000.
short _BitsPerChannel;//! The number of bits per channel. Supported values are 1, 8, and 16.
short _ColourMode; //! Colour mode of the file, Bitmap=0, Grayscale=1, Indexed=2, RGB=3, CMYK=4, Multichannel=7, Duotone=8, Lab=9.
public:
psdHeaderInfo();
~psdHeaderInfo();
/**
@return Returns the number of bytes read
*/
bool Read(FreeImageIO *io, fi_handle handle);
};
/**
Table 2-13 Color mode data section
src/Source/FreeImage/PSDParser.h view on Meta::CPAN
this section is just 4 bytes: the length field, which is set to zero.
For indexed color images, the length will be equal to 768, and the color data
will contain the color table for the image, in non-interleaved order.
For duotone images, the color data will contain the duotone specification,
the format of which is not documented. Other applications that read
Photoshop files can treat a duotone image as a grayscale image, and just
preserve the contents of the duotone information when reading and writing
the file.
*/
class psdColourModeData {
public:
int _Length; //! The length of the following color data
BYTE * _plColourData; //! The color data
public:
psdColourModeData();
~psdColourModeData();
/**
@return Returns the number of bytes read
*/
bool Read(FreeImageIO *io, fi_handle handle);
bool FillPalette(FIBITMAP *dib);
};
/**
Table 2-1: Image resource block
NB: Resource data is padded to make size even
*/
class psdImageResource {
public:
int _Length;
char _OSType[4]; //! Photoshop always uses its signature, 8BIM
short _ID; //! Unique identifier. Image resource IDs on page 8
BYTE * _plName; //! A pascal string, padded to make size even (a null name consists of two bytes of 0)
int _Size; //! Actual size of resource data. This does not include the Type, ID, Name or Size fields.
public:
psdImageResource();
~psdImageResource();
void Reset();
};
/**
Table A-6: ResolutionInfo structure
This structure contains information about the resolution of an image. It is
written as an image resource. See the Document file formats chapter for more
details.
*/
class psdResolutionInfo {
public:
short _widthUnit; //! Display width as 1=inches; 2=cm; 3=points; 4=picas; 5=columns.
short _heightUnit; //! Display height as 1=inches; 2=cm; 3=points; 4=picas; 5=columns.
short _hRes; //! Horizontal resolution in pixels per inch.
short _vRes; //! Vertical resolution in pixels per inch.
int _hResUnit; //! 1=display horizontal resolution in pixels per inch; 2=display horizontal resolution in pixels per cm.
int _vResUnit; //! 1=display vertical resolution in pixels per inch; 2=display vertical resolution in pixels per cm.
public:
psdResolutionInfo();
~psdResolutionInfo();
/**
@return Returns the number of bytes read
*/
int Read(FreeImageIO *io, fi_handle handle);
/**
@param res_x [out] X resolution in pixels/meter
@param res_y [out] Y resolution in pixels/meter
*/
void GetResolutionInfo(unsigned &res_x, unsigned &res_y);
};
// Obsolete - Photoshop 2.0
class psdResolutionInfo_v2 {
public:
short _Channels;
short _Rows;
short _Columns;
short _Depth;
short _Mode;
public:
psdResolutionInfo_v2();
~psdResolutionInfo_v2();
/**
@return Returns the number of bytes read
*/
int Read(FreeImageIO *io, fi_handle handle);
};
/**
Table A-7: DisplayInfo Color spaces
This structure contains display information about each channel. It is written as an image resource.
*/
class psdDisplayInfo {
public:
short _ColourSpace;
short _Colour[4];
short _Opacity; //! 0..100
BYTE _Kind; //! selected = 0, protected = 1
BYTE _padding; //! should be zero
public:
psdDisplayInfo();
~psdDisplayInfo();
/**
@return Returns the number of bytes read
*/
int Read(FreeImageIO *io, fi_handle handle);
};
/**
Table 2-5: Thumbnail resource header
Adobe Photoshop 5.0 and later stores thumbnail information for preview
display in an image resource block. These resource blocks consist of an initial
28 byte header, followed by a JFIF thumbnail in RGB (red, green, blue) order
for both Macintosh and Windows. Adobe Photoshop 4.0 stored the
thumbnail information in the same format except the data section is BGR
(blue, green, red). The Adobe Photoshop 4.0 format is at resource ID 1033
and the Adobe Photoshop 5.0 format is at resource ID 1036.
*/
class psdThumbnail {
public:
int _Format; //! = 1 (kJpegRGB). Also supports kRawRGB (0).
int _Width; //! Width of thumbnail in pixels.
int _Height; //! Height of thumbnail in pixels.
int _WidthBytes; //! Padded row bytes as (width * bitspixel + 31) / 32 * 4.
int _Size; //! Total size as widthbytes * height * planes
int _CompressedSize; //! Size after compression. Used for consistentcy check.
short _BitPerPixel; //! = 24. Bits per pixel.
short _Planes; //! = 1. Number of planes.
FIBITMAP * _dib; //! JFIF data as uncompressed dib. Note: For resource ID 1033 the data is in BGR format.
public:
psdThumbnail();
~psdThumbnail();
FIBITMAP* getDib() { return _dib; }
/**
@return Returns the number of bytes read
*/
int Read(FreeImageIO *io, fi_handle handle, int iResourceSize, bool isBGR);
private:
psdThumbnail(const psdThumbnail&);
psdThumbnail& operator=(const psdThumbnail&);
};
class psdICCProfile {
public:
int _ProfileSize;
BYTE * _ProfileData;
public:
psdICCProfile();
~psdICCProfile();
void clear();
/**
@return Returns the number of bytes read
*/
int Read(FreeImageIO *io, fi_handle handle, int size);
};
/**
src/Source/FreeImage/PSDParser.h view on Meta::CPAN
bool _bCopyright;
int _fi_flags;
int _fi_format_id;
private:
/** Actually ignore it */
bool ReadLayerAndMaskInfoSection(FreeImageIO *io, fi_handle handle);
FIBITMAP* ReadImageData(FreeImageIO *io, fi_handle handle);
public:
psdParser();
~psdParser();
FIBITMAP* Load(FreeImageIO *io, fi_handle handle, int s_format_id, int flags=0);
/** Also used by the TIFF plugin */
bool ReadImageResources(FreeImageIO *io, fi_handle handle, LONG length=0);
/** Used by the TIFF plugin */
FIBITMAP* GetThumbnail() {
return _thumbnail.getDib();
}
};
src/Source/FreeImage/PluginDDS.cpp view on Meta::CPAN
bytesPerBlock = 16
};
};
template <class INFO> class DXT_BLOCKDECODER_BASE {
protected:
Color8888 m_colors[4];
const typename INFO::Block *m_pBlock;
unsigned m_colorRow;
public:
void Setup (const BYTE *pBlock) {
m_pBlock = (const typename INFO::Block *)pBlock;
GetBlockColors (m_pBlock->color, m_colors, INFO::isDXT1);
}
void SetY (int y) {
m_colorRow = m_pBlock->color.row[y];
}
void GetColor (int x, int y, Color8888 &color) {
unsigned bits = (m_colorRow >> (x * 2)) & 3;
color = m_colors[bits];
}
};
class DXT_BLOCKDECODER_1 : public DXT_BLOCKDECODER_BASE <DXT_INFO_1> {
public:
typedef DXT_INFO_1 INFO;
};
class DXT_BLOCKDECODER_3 : public DXT_BLOCKDECODER_BASE <DXT_INFO_3> {
public:
typedef DXT_BLOCKDECODER_BASE <DXT_INFO_3> base;
typedef DXT_INFO_3 INFO;
protected:
unsigned m_alphaRow;
public:
void SetY (int y) {
base::SetY (y);
m_alphaRow = m_pBlock->alpha.row[y];
}
void GetColor (int x, int y, Color8888 &color) {
base::GetColor (x, y, color);
const unsigned bits = (m_alphaRow >> (x * 4)) & 0xF;
color.a = (BYTE)((bits * 0xFF) / 0xF);
}
};
class DXT_BLOCKDECODER_5 : public DXT_BLOCKDECODER_BASE <DXT_INFO_5> {
public:
typedef DXT_BLOCKDECODER_BASE <DXT_INFO_5> base;
typedef DXT_INFO_5 INFO;
protected:
unsigned m_alphas[8];
unsigned m_alphaBits;
int m_offset;
public:
void Setup (const BYTE *pBlock) {
base::Setup (pBlock);
const DXTAlphaBlock3BitLinear &block = m_pBlock->alpha;
m_alphas[0] = block.alpha[0];
m_alphas[1] = block.alpha[1];
if (m_alphas[0] > m_alphas[1]) {
// 8 alpha block
for (int i = 0; i < 6; i++) {
m_alphas[i + 2] = ((6 - i) * m_alphas[0] + (1 + i) * m_alphas[1] + 3) / 7;
src/Source/FreeImage/PluginEXR.cpp view on Meta::CPAN
// ==========================================================
static int s_format_id;
// ----------------------------------------------------------
/**
FreeImage input stream wrapper
@see Imf_2_2::IStream
*/
class C_IStream : public Imf::IStream {
private:
FreeImageIO *_io;
fi_handle _handle;
public:
C_IStream (FreeImageIO *io, fi_handle handle) :
Imf::IStream(""), _io (io), _handle(handle) {
}
virtual bool read (char c[/*n*/], int n) {
return ((unsigned)n != _io->read_proc(c, 1, n, _handle));
}
virtual Imath::Int64 tellg() {
return _io->tell_proc(_handle);
src/Source/FreeImage/PluginEXR.cpp view on Meta::CPAN
virtual void clear() {
}
};
// ----------------------------------------------------------
/**
FreeImage output stream wrapper
@see Imf_2_2::OStream
*/
class C_OStream : public Imf::OStream {
private:
FreeImageIO *_io;
fi_handle _handle;
public:
C_OStream (FreeImageIO *io, fi_handle handle) :
Imf::OStream(""), _io (io), _handle(handle) {
}
virtual void write(const char c[/*n*/], int n) {
if((unsigned)n != _io->write_proc((void*)&c[0], 1, n, _handle)) {
Iex::throwErrnoExc();
}
}
src/Source/FreeImage/PluginGIF.cpp view on Meta::CPAN
}
int disposal_method;
WORD left, top, width, height;
};
//GIF defines a max of 12 bits per code
#define MAX_LZW_CODE 4096
class StringTable
{
public:
StringTable();
~StringTable();
void Initialize(int minCodeSize);
BYTE *FillInputBuffer(int len);
void CompressStart(int bpp, int width);
int CompressEnd(BYTE *buf); //0-4 bytes
bool Compress(BYTE *buf, int *len);
bool Decompress(BYTE *buf, int *len);
void Done(void);
src/Source/FreeImage/PluginJPEG.cpp view on Meta::CPAN
#define JFXX_TYPE_JPEG 0x10 // JFIF extension marker: JPEG-compressed thumbnail image
#define JFXX_TYPE_8bit 0x11 // JFIF extension marker: palette thumbnail image
#define JFXX_TYPE_24bit 0x13 // JFIF extension marker: RGB thumbnail image
// ----------------------------------------------------------
// Typedef declarations
// ----------------------------------------------------------
typedef struct tagErrorManager {
/// "public" fields
struct jpeg_error_mgr pub;
/// for return to caller
jmp_buf setjmp_buffer;
} ErrorManager;
typedef struct tagSourceManager {
/// public fields
struct jpeg_source_mgr pub;
/// source stream
fi_handle infile;
FreeImageIO *m_io;
/// start of buffer
JOCTET * buffer;
/// have we gotten any data yet ?
boolean start_of_file;
} SourceManager;
typedef struct tagDestinationManager {
/// public fields
struct jpeg_destination_mgr pub;
/// destination stream
fi_handle outfile;
FreeImageIO *m_io;
/// start of buffer
JOCTET * buffer;
} DestinationManager;
typedef SourceManager* freeimage_src_ptr;
typedef DestinationManager* freeimage_dst_ptr;
src/Source/FreeImage/PluginRAW.cpp view on Meta::CPAN
static int s_format_id;
// ==========================================================
// Internal functions
// ==========================================================
// ----------------------------------------------------------
// FreeImage datastream wrapper
// ----------------------------------------------------------
class LibRaw_freeimage_datastream : public LibRaw_abstract_datastream {
private:
FreeImageIO *_io;
fi_handle _handle;
long _eof;
INT64 _fsize;
public:
LibRaw_freeimage_datastream(FreeImageIO *io, fi_handle handle) : _io(io), _handle(handle) {
long start_pos = io->tell_proc(handle);
io->seek_proc(handle, 0, SEEK_END);
_eof = io->tell_proc(handle);
_fsize = _eof - start_pos;
io->seek_proc(handle, start_pos, SEEK_SET);
}
~LibRaw_freeimage_datastream() {
}
src/Source/FreeImage/PluginRAW.cpp view on Meta::CPAN
"bmq," // NuCore Raw Image File.
"cap," // Phase One Digital Camera Raw Image Format.
"cine," // Phantom Software Raw Image File.
"cr2," // Canon Digital Camera RAW Image Format version 2.0. These images are based on the TIFF image standard.
"crw," // Canon Digital Camera RAW Image Format version 1.0.
"cs1," // Sinar Capture Shop Raw Image File.
"dc2," // Kodak DC25 Digital Camera File.
"dcr," // Kodak Digital Camera Raw Image Format for these models: Kodak DSC Pro SLR/c, Kodak DSC Pro SLR/n, Kodak DSC Pro 14N, Kodak DSC PRO 14nx.
"drf," // Kodak Digital Camera Raw Image Format.
"dsc," // Kodak Digital Camera Raw Image Format.
"dng," // Adobe Digital Negative: DNG is publicly available archival format for the raw files generated by digital cameras. By addressing the lack of an open standard for the raw files created by individual camera models, DNG helps ensure that ph...
"erf," // Epson Digital Camera Raw Image Format.
"fff," // Imacon Digital Camera Raw Image Format.
"ia," // Sinar Raw Image File.
"iiq," // Phase One Digital Camera Raw Image Format.
"k25," // Kodak DC25 Digital Camera Raw Image Format.
"kc2," // Kodak DCS200 Digital Camera Raw Image Format.
"kdc," // Kodak Digital Camera Raw Image Format.
"mdc," // Minolta RD175 Digital Camera Raw Image Format.
"mef," // Mamiya Digital Camera Raw Image Format.
"mos," // Leaf Raw Image File.
src/Source/FreeImage/PluginTARGA.cpp view on Meta::CPAN
#define TGA_RLEMONO 11 // run-length encoded, black-and-white image
#define TGA_CMPCMAP 32 // compressed (Huffman/Delta/RLE) color-mapped image (e.g., VDA/D) - Obsolete
#define TGA_CMPCMAP4 33 // compressed (Huffman/Delta/RLE) color-mapped four pass image (e.g., VDA/D) - Obsolete
// ==========================================================
// Thumbnail functions
// ==========================================================
class TargaThumbnail
{
public:
TargaThumbnail() : _w(0), _h(0), _depth(0), _data(NULL) {
}
~TargaThumbnail() {
if(_data) {
free(_data);
}
}
BOOL isNull() const {
return (_data == NULL);
src/Source/FreeImage/PluginTARGA.cpp view on Meta::CPAN
// Internal functions
// ==========================================================
/** This class is used when loading RLE compressed images, it implements io cache of fixed size.
In general RLE compressed images *should* be compressed line by line with line sizes stored in Scan Line Table section.
In reality, however there are images not obeying the specification, compressing image data continuously across lines,
making it impossible to load the file cached at every line.
*/
class IOCache
{
public:
IOCache(FreeImageIO *io, fi_handle handle, size_t size) :
_ptr(NULL), _begin(NULL), _end(NULL), _size(size), _io(io), _handle(handle) {
_begin = (BYTE*)malloc(size);
if (_begin) {
_end = _begin + _size;
_ptr = _end; // will force refill on first access
}
}
~IOCache() {
src/Source/FreeImageToolkit/Filters.h view on Meta::CPAN
{
protected:
#define FILTER_PI double (3.1415926535897932384626433832795)
#define FILTER_2PI double (2.0 * 3.1415926535897932384626433832795)
#define FILTER_4PI double (4.0 * 3.1415926535897932384626433832795)
/// Filter support
double m_dWidth;
public:
/// Constructor
CGenericFilter (double dWidth) : m_dWidth (dWidth) {}
/// Destructor
virtual ~CGenericFilter() {}
/// Returns the filter support
double GetWidth() { return m_dWidth; }
/// Change the filter suport
void SetWidth (double dWidth) { m_dWidth = dWidth; }
src/Source/FreeImageToolkit/Filters.h view on Meta::CPAN
// All filters are centered on 0
// -----------------------------------------------------------------------------------
/**
Box filter<br>
Box, pulse, Fourier window, 1st order (constant) b-spline.<br><br>
<b>Reference</b> : <br>
Glassner A.S., Principles of digital image synthesis. Morgan Kaufmann Publishers, Inc, San Francisco, Vol. 2, 1995
*/
class CBoxFilter : public CGenericFilter
{
public:
/**
Constructor<br>
Default fixed width = 0.5
*/
CBoxFilter() : CGenericFilter(0.5) {}
virtual ~CBoxFilter() {}
double Filter (double dVal) { return (fabs(dVal) <= m_dWidth ? 1.0 : 0.0); }
};
/** Bilinear filter
*/
class CBilinearFilter : public CGenericFilter
{
public:
CBilinearFilter () : CGenericFilter(1) {}
virtual ~CBilinearFilter() {}
double Filter (double dVal) {
dVal = fabs(dVal);
return (dVal < m_dWidth ? m_dWidth - dVal : 0.0);
}
};
src/Source/FreeImageToolkit/Filters.h view on Meta::CPAN
The parameters b and c can be used to adjust the properties of the cubic.
They are sometimes referred to as "blurring" and "ringing" respectively.
The default is b = 1/3 and c = 1/3, which were the values recommended by
Mitchell and Netravali as yielding the most visually pleasing results in subjective tests of human beings.
Larger values of b and c can produce interesting op-art effects--for example, try b = 0 and c = -5. <br><br>
<b>Reference</b> : <br>
Don P. Mitchell and Arun N. Netravali, Reconstruction filters in computer graphics.
In John Dill, editor, Computer Graphics (SIGGRAPH '88 Proceedings), Vol. 22, No. 4, August 1988, pp. 221-228.
*/
class CBicubicFilter : public CGenericFilter
{
protected:
// data for parameterized Mitchell filter
double p0, p2, p3;
double q0, q1, q2, q3;
public:
/**
Constructor<br>
Default fixed width = 2
@param b Filter parameter (default value is 1/3)
@param c Filter parameter (default value is 1/3)
*/
CBicubicFilter (double b = (1/(double)3), double c = (1/(double)3)) : CGenericFilter(2) {
p0 = (6 - 2*b) / 6;
p2 = (-18 + 12*b + 6*c) / 6;
p3 = (12 - 9*b - 6*c) / 6;
src/Source/FreeImageToolkit/Filters.h view on Meta::CPAN
<b>References</b> : <br>
<ul>
<li>Mitchell Don P., Netravali Arun N., Reconstruction filters in computer graphics.
In John Dill, editor, Computer Graphics (SIGGRAPH '88 Proceedings), Vol. 22, No. 4, August 1988, pp. 221-228.
<li>Keys R.G., Cubic Convolution Interpolation for Digital Image Processing.
IEEE Trans. Acoustics, Speech, and Signal Processing, vol. 29, no. 6, pp. 1153-1160, Dec. 1981.
</ul>
*/
class CCatmullRomFilter : public CGenericFilter
{
public:
/**
Constructor<br>
Default fixed width = 2
*/
CCatmullRomFilter() : CGenericFilter(2) {}
virtual ~CCatmullRomFilter() {}
double Filter(double dVal) {
if(dVal < -2) return 0;
src/Source/FreeImageToolkit/Filters.h view on Meta::CPAN
}
};
/**
Lanczos-windowed sinc filter<br>
Lanczos3 filter is an alternative to CBicubicFilter with high values of c about 0.6 ... 0.75
which produces quite strong sharpening. It usually offers better quality (fewer artifacts) and a sharp image.<br><br>
*/
class CLanczos3Filter : public CGenericFilter
{
public:
/**
Constructor<br>
Default fixed width = 3
*/
CLanczos3Filter() : CGenericFilter(3) {}
virtual ~CLanczos3Filter() {}
double Filter(double dVal) {
dVal = fabs(dVal);
if(dVal < m_dWidth) {
src/Source/FreeImageToolkit/Filters.h view on Meta::CPAN
return (sin(value) / value);
}
return 1;
}
};
/**
4th order (cubic) b-spline<br>
*/
class CBSplineFilter : public CGenericFilter
{
public:
/**
Constructor<br>
Default fixed width = 2
*/
CBSplineFilter() : CGenericFilter(2) {}
virtual ~CBSplineFilter() {}
double Filter(double dVal) {
src/Source/FreeImageToolkit/Filters.h view on Meta::CPAN
}
};
// -----------------------------------------------------------------------------------
// Window function library
// -----------------------------------------------------------------------------------
/**
Blackman window
*/
class CBlackmanFilter : public CGenericFilter
{
public:
/**
Constructor<br>
Default width = 0.5
*/
CBlackmanFilter (double dWidth = double(0.5)) : CGenericFilter(dWidth) {}
virtual ~CBlackmanFilter() {}
double Filter (double dVal) {
if(fabs (dVal) > m_dWidth) {
return 0;
src/Source/FreeImageToolkit/Resize.h view on Meta::CPAN
} Contribution;
private:
/// Row (or column) of contribution weights
Contribution *m_WeightTable;
/// Filter window size (of affecting source pixels)
unsigned m_WindowSize;
/// Length of line (no. of rows / cols)
unsigned m_LineLength;
public:
/**
Constructor<br>
Allocate and compute the weights table
@param pFilter Filter used for upsampling or downsampling
@param uDstSize Length (in pixels) of the destination line buffer
@param uSrcSize Length (in pixels) of the source line buffer
*/
CWeightsTable(CGenericFilter *pFilter, unsigned uDstSize, unsigned uSrcSize);
/**
src/Source/FreeImageToolkit/Resize.h view on Meta::CPAN
[2] Eran Yariv, Two Pass Scaling using Filters. The Code Project, December 1999.
[online] http://www.codeproject.com/bitmap/2_pass_scaling.asp
*/
class CResizeEngine
{
private:
/// Pointer to the FIR / IIR filter
CGenericFilter* m_pFilter;
public:
/**
Constructor
@param filter FIR /IIR filter to be used
*/
CResizeEngine(CGenericFilter* filter):m_pFilter(filter) {}
/// Destructor
virtual ~CResizeEngine() {}
src/Source/LibJPEG/README view on Meta::CPAN
The Independent JPEG Group's JPEG software
==========================================
README for release 9a of 19-Jan-2014
====================================
This distribution contains the ninth public release of the Independent JPEG
Group's free JPEG software. You are welcome to redistribute this software and
to use it for any purpose, subject to the conditions under LEGAL ISSUES, below.
This software is the work of Tom Lane, Guido Vollbeding, Philip Gladstone,
Bill Allombert, Jim Boucher, Lee Crocker, Bob Friesenhahn, Ben Jackson,
Julian Minguillon, Luis Ortiz, George Phillips, Davide Rossi, Ge' Weijers,
and other members of the Independent JPEG Group.
IJG is not affiliated with the ISO/IEC JTC1/SC29/WG1 standards committee
(previously known as JPEG, together with ITU-T SG16).
src/Source/LibJPEG/README view on Meta::CPAN
the Independent JPEG Group".
(3) Permission for use of this software is granted only if the user accepts
full responsibility for any undesirable consequences; the authors accept
NO LIABILITY for damages of any kind.
These conditions apply to any software derived from or based on the IJG code,
not just to the unmodified library. If you use our work, you ought to
acknowledge us.
Permission is NOT granted for the use of any IJG author's name or company name
in advertising or publicity relating to this software or products derived from
it. This software may be referred to only as "the Independent JPEG Group's
software".
We specifically permit and encourage the use of this software as the basis of
commercial products, provided that all warranty or liability claims are
assumed by the product vendor.
The Unix configuration script "configure" was produced with GNU Autoconf.
It is copyright by the Free Software Foundation but is freely distributable.
src/Source/LibJPEG/README view on Meta::CPAN
code but don't know much about data compression in general. The book's JPEG
sample code is far from industrial-strength, but when you are ready to look
at a full implementation, you've got one here...
The best currently available description of JPEG is the textbook "JPEG Still
Image Data Compression Standard" by William B. Pennebaker and Joan L.
Mitchell, published by Van Nostrand Reinhold, 1993, ISBN 0-442-01272-1.
Price US$59.95, 638 pp. The book includes the complete text of the ISO JPEG
standards (DIS 10918-1 and draft DIS 10918-2).
Although this is by far the most detailed and comprehensive exposition of
JPEG publicly available, we point out that it is still missing an explanation
of the most essential properties and algorithms of the underlying DCT
technology.
If you think that you know about DCT-based JPEG after reading this book,
then you are in delusion. The real fundamentals and corresponding potential
of DCT-based JPEG are not publicly known so far, and that is the reason for
all the mistaken developments taking place in the image coding domain.
The original JPEG standard is divided into two parts, Part 1 being the actual
specification, while Part 2 covers compliance testing methods. Part 1 is
titled "Digital Compression and Coding of Continuous-tone Still Images,
Part 1: Requirements and guidelines" and has document numbers ISO/IEC IS
10918-1, ITU-T T.81. Part 2 is titled "Digital Compression and Coding of
Continuous-tone Still Images, Part 2: Compliance testing" and has document
numbers ISO/IEC IS 10918-2, ITU-T T.83.
IJG JPEG 8 introduced an implementation of the JPEG SmartScale extension
src/Source/LibJPEG/README view on Meta::CPAN
document is Revision 3. And a contributed document ISO/IEC JTC1/SC29/WG1 N
5799 with title "Evolution of JPEG", June/July 2011, Berlin, Germany.
IJG JPEG 9 introduces a reversible color transform for improved lossless
compression which is described in a contributed document ISO/IEC JTC1/SC29/
WG1 N 6080 with title "JPEG 9 Lossless Coding", June/July 2012, Paris,
France.
The JPEG standard does not specify all details of an interchangeable file
format. For the omitted details we follow the "JFIF" conventions, revision
1.02. JFIF 1.02 has been adopted as an Ecma International Technical Report
and thus received a formal publication status. It is available as a free
download in PDF format from
http://www.ecma-international.org/publications/techreports/E-TR-098.htm.
A PostScript version of the JFIF document is available at
http://www.ijg.org/files/jfif.ps.gz. There is also a plain text version at
http://www.ijg.org/files/jfif.txt.gz, but it is missing the figures.
The TIFF 6.0 file format specification can be obtained by FTP from
ftp://ftp.sgi.com/graphics/tiff/TIFF6.ps.gz. The JPEG incorporation scheme
found in the TIFF 6.0 spec of 3-June-92 has a number of serious problems.
IJG does not recommend use of the TIFF 6.0 design (TIFF Compression tag 6).
Instead, we recommend the JPEG design proposed by TIFF Technical Note #2
(Compression tag 7). Copies of this Note can be obtained from
src/Source/LibJPEG/README view on Meta::CPAN
kind of formats which is misleading because they don't support original
JPEG images.
We have no sympathy for the promotion of inferior formats. Indeed, one of
the original reasons for developing this free software was to help force
convergence on common, interoperable format standards for JPEG files.
Don't use an incompatible file format!
(In any case, our decoder will remain capable of reading existing JPEG
image files indefinitely.)
The ISO committee pretends to be "responsible for the popular JPEG" in their
public reports which is not true because they don't respond to actual
requirements for the maintenance of the original JPEG specification.
Furthermore, the ISO committee pretends to "ensure interoperability" with
their standards which is not true because their "standards" support only
application-specific and proprietary use cases and contain mathematically
incorrect code.
There are currently different distributions in circulation containing the
name "libjpeg" which is misleading because they don't have the features and
are incompatible with formats supported by actual IJG libjpeg distributions.
One of those fakes is released by members of the ISO committee and just uses
src/Source/LibJPEG/README view on Meta::CPAN
are now duly secured and held in trust for the free people of this planet.
People of the planet, on every country, may have a financial interest in
the assets of these former principals, agents, and beneficiaries of the
foreclosed institutions and corporations.
IJG asserts what is: that each man, woman, and child has unalienable value
and rights granted and deposited in them by the Creator and not any one of
the people is subordinate to any artificial principality, corporate fiction
or the special interest of another without their appropriate knowing,
willing and intentional consent made by contract or accommodation agreement.
IJG expresses that which already was.
The people have already determined and demanded that public administration
entities, national governments, and their supporting judicial systems must
be fully transparent, accountable, and liable.
IJG has secured the value for all concerned free people of the planet.
A partial list of foreclosed institutions and corporations ("Hall of Shame")
is currently prepared and will be published later.
TO DO
=====
src/Source/LibJPEG/example.c view on Meta::CPAN
* establish the return point. We want the replacement error_exit to do a
* longjmp(). But we need to make the setjmp buffer accessible to the
* error_exit routine. To do this, we make a private extension of the
* standard JPEG error handler object. (If we were using C++, we'd say we
* were making a subclass of the regular error handler.)
*
* Here's the extended error handler struct:
*/
struct my_error_mgr {
struct jpeg_error_mgr pub; /* "public" fields */
jmp_buf setjmp_buffer; /* for return to caller */
};
typedef struct my_error_mgr * my_error_ptr;
/*
* Here's the routine that will replace the standard error_exit method:
*/
src/Source/LibJPEG/jcarith.c view on Meta::CPAN
*/
#define JPEG_INTERNALS
#include "jinclude.h"
#include "jpeglib.h"
/* Expanded entropy encoder object for arithmetic encoding. */
typedef struct {
struct jpeg_entropy_encoder pub; /* public fields */
INT32 c; /* C register, base of coding interval, layout as in sec. D.1.3 */
INT32 a; /* A register, normalized size of coding interval */
INT32 sc; /* counter for stacked 0xFF values which might overflow */
INT32 zc; /* counter for pending 0x00 output values which might *
* be discarded at the end ("Pacman" termination) */
int ct; /* bit shift counter, determines when next byte will be written */
int buffer; /* buffer for most recent output byte != 0xFF */
int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
src/Source/LibJPEG/jccoefct.c view on Meta::CPAN
#else
#ifdef C_MULTISCAN_FILES_SUPPORTED
#define FULL_COEF_BUFFER_SUPPORTED
#endif
#endif
/* Private buffer controller object */
typedef struct {
struct jpeg_c_coef_controller pub; /* public fields */
JDIMENSION iMCU_row_num; /* iMCU row # within image */
JDIMENSION mcu_ctr; /* counts MCUs processed in current row */
int MCU_vert_offset; /* counts MCU rows within iMCU row */
int MCU_rows_per_iMCU_row; /* number of such rows needed */
/* For single-pass compression, it's sufficient to buffer just one MCU
* (although this may prove a bit slow in practice). We allocate a
* workspace of C_MAX_BLOCKS_IN_MCU coefficient blocks, and reuse it for each
* MCU constructed and sent. (On 80x86, the workspace is FAR even though
src/Source/LibJPEG/jccolor.c view on Meta::CPAN
*/
#define JPEG_INTERNALS
#include "jinclude.h"
#include "jpeglib.h"
/* Private subobject */
typedef struct {
struct jpeg_color_converter pub; /* public fields */
/* Private state for RGB->YCC conversion */
INT32 * rgb_ycc_tab; /* => table for RGB to YCbCr conversion */
} my_color_converter;
typedef my_color_converter * my_cconvert_ptr;
/**************** RGB -> YCbCr conversion: most common case **************/
src/Source/LibJPEG/jcdctmgr.c view on Meta::CPAN
#define JPEG_INTERNALS
#include "jinclude.h"
#include "jpeglib.h"
#include "jdct.h" /* Private declarations for DCT subsystem */
/* Private subobject for this module */
typedef struct {
struct jpeg_forward_dct pub; /* public fields */
/* Pointer to the DCT routine actually in use */
forward_DCT_method_ptr do_dct[MAX_COMPONENTS];
#ifdef DCT_FLOAT_SUPPORTED
/* Same as above for the floating-point case. */
float_DCT_method_ptr do_float_dct[MAX_COMPONENTS];
#endif
} my_fdct_controller;
src/Source/LibJPEG/jchuff.c view on Meta::CPAN
(dest).put_bits = (src).put_bits, \
(dest).last_dc_val[0] = (src).last_dc_val[0], \
(dest).last_dc_val[1] = (src).last_dc_val[1], \
(dest).last_dc_val[2] = (src).last_dc_val[2], \
(dest).last_dc_val[3] = (src).last_dc_val[3])
#endif
#endif
typedef struct {
struct jpeg_entropy_encoder pub; /* public fields */
savable_state saved; /* Bit buffer & DC state at start of MCU */
/* These fields are NOT loaded into local working state. */
unsigned int restarts_to_go; /* MCUs left in this restart interval */
int next_restart_num; /* next restart number to write (0-7) */
/* Pointers to derived tables (these workspaces have image lifespan) */
c_derived_tbl * dc_derived_tbls[NUM_HUFF_TBLS];
c_derived_tbl * ac_derived_tbls[NUM_HUFF_TBLS];
src/Source/LibJPEG/jcmainct.c view on Meta::CPAN
* is needed at this step. If there were, that mode could not be used with
* "raw data" input, since this module is bypassed in that case. However,
* we've left the code here for possible use in special applications.
*/
#undef FULL_MAIN_BUFFER_SUPPORTED
/* Private buffer controller object */
typedef struct {
struct jpeg_c_main_controller pub; /* public fields */
JDIMENSION cur_iMCU_row; /* number of current iMCU row */
JDIMENSION rowgroup_ctr; /* counts row groups received in iMCU row */
boolean suspended; /* remember if we suspended output */
J_BUF_MODE pass_mode; /* current operating mode */
/* If using just a strip buffer, this points to the entire set of buffers
* (we allocate one for each component). In the full-image case, this
* points to the currently accessible strips of the virtual arrays.
*/
src/Source/LibJPEG/jcmarker.c view on Meta::CPAN
M_TEM = 0x01,
M_ERROR = 0x100
} JPEG_MARKER;
/* Private state */
typedef struct {
struct jpeg_marker_writer pub; /* public fields */
unsigned int last_restart_interval; /* last DRI value emitted; 0 after SOI */
} my_marker_writer;
typedef my_marker_writer * my_marker_ptr;
/*
* Basic output routines.
*
src/Source/LibJPEG/jcmaster.c view on Meta::CPAN
/* Private state */
typedef enum {
main_pass, /* input data, also do first output step */
huff_opt_pass, /* Huffman code optimization pass */
output_pass /* data output pass */
} c_pass_type;
typedef struct {
struct jpeg_comp_master pub; /* public fields */
c_pass_type pass_type; /* the type of the current pass */
int pass_number; /* # of passes completed */
int total_passes; /* total # of passes needed */
int scan_number; /* current index in scan_info[] */
} my_comp_master;
typedef my_comp_master * my_master_ptr;
src/Source/LibJPEG/jcprepct.c view on Meta::CPAN
* At the top and bottom of the image, we create dummy context rows by
* copying the first or last real pixel row. This copying could be avoided
* by pointer hacking as is done in jdmainct.c, but it doesn't seem worth the
* trouble on the compression side.
*/
/* Private buffer controller object */
typedef struct {
struct jpeg_c_prep_controller pub; /* public fields */
/* Downsampling input buffer. This buffer holds color-converted data
* until we have enough to do a downsample step.
*/
JSAMPARRAY color_buf[MAX_COMPONENTS];
JDIMENSION rows_to_go; /* counts rows remaining in source image */
int next_buf_row; /* index of next row to store in color_buf */
#ifdef CONTEXT_ROWS_SUPPORTED /* only needed for context case */
src/Source/LibJPEG/jcsample.c view on Meta::CPAN
/* Pointer to routine to downsample a single component */
typedef JMETHOD(void, downsample1_ptr,
(j_compress_ptr cinfo, jpeg_component_info * compptr,
JSAMPARRAY input_data, JSAMPARRAY output_data));
/* Private subobject */
typedef struct {
struct jpeg_downsampler pub; /* public fields */
/* Downsampling method pointers, one per component */
downsample1_ptr methods[MAX_COMPONENTS];
/* Height of an output row group for each component. */
int rowgroup_height[MAX_COMPONENTS];
/* These arrays save pixel expansion factors so that int_downsample need not
* recompute them each time. They are unused for other downsampling methods.
*/
src/Source/LibJPEG/jctrans.c view on Meta::CPAN
* The rest of this file is a special implementation of the coefficient
* buffer controller. This is similar to jccoefct.c, but it handles only
* output from presupplied virtual arrays. Furthermore, we generate any
* dummy padding blocks on-the-fly rather than expecting them to be present
* in the arrays.
*/
/* Private buffer controller object */
typedef struct {
struct jpeg_c_coef_controller pub; /* public fields */
JDIMENSION iMCU_row_num; /* iMCU row # within image */
JDIMENSION mcu_ctr; /* counts MCUs processed in current row */
int MCU_vert_offset; /* counts MCU rows within iMCU row */
int MCU_rows_per_iMCU_row; /* number of such rows needed */
/* Virtual block array for each component. */
jvirt_barray_ptr * whole_image;
/* Workspace for constructing dummy blocks at right/bottom edges. */
src/Source/LibJPEG/jdarith.c view on Meta::CPAN
*/
#define JPEG_INTERNALS
#include "jinclude.h"
#include "jpeglib.h"
/* Expanded entropy decoder object for arithmetic decoding. */
typedef struct {
struct jpeg_entropy_decoder pub; /* public fields */
INT32 c; /* C register, base of coding interval + input bit buffer */
INT32 a; /* A register, normalized size of coding interval */
int ct; /* bit shift counter, # of bits left in bit buffer part of C */
/* init: ct = -16 */
/* run: ct = 0..7 */
/* error: ct = -1 */
int last_dc_val[MAX_COMPS_IN_SCAN]; /* last DC coef for each component */
int dc_context[MAX_COMPS_IN_SCAN]; /* context index for DC conditioning */
( run in 0.785 second using v1.01-cache-2.11-cpan-64827b87656 )