Alien-FreeImage
view release on metacpan or search on metacpan
src/Source/FreeImage/PluginJ2K.cpp view on Meta::CPAN
// set decoding parameters to default values
opj_set_default_decoder_parameters(¶meters);
try {
// decode the JPEG-2000 codestream
// get a decoder handle
d_codec = opj_create_decompress(OPJ_CODEC_J2K);
// configure the event callbacks
// catch events using our callbacks (no local context needed here)
opj_set_info_handler(d_codec, NULL, NULL);
opj_set_warning_handler(d_codec, j2k_warning_callback, NULL);
opj_set_error_handler(d_codec, j2k_error_callback, NULL);
// setup the decoder decoding parameters using user parameters
if( !opj_setup_decoder(d_codec, ¶meters) ) {
throw "Failed to setup the decoder\n";
}
// read the main header of the codestream and if necessary the JP2 boxes
src/Source/FreeImage/PluginJ2K.cpp view on Meta::CPAN
}
// decide if MCT should be used
parameters.tcp_mct = (image->numcomps == 3) ? 1 : 0;
// encode the destination image
// get a J2K compressor handle
c_codec = opj_create_compress(OPJ_CODEC_J2K);
// configure the event callbacks
// catch events using our callbacks (no local context needed here)
opj_set_info_handler(c_codec, NULL, NULL);
opj_set_warning_handler(c_codec, j2k_warning_callback, NULL);
opj_set_error_handler(c_codec, j2k_error_callback, NULL);
// setup the encoder parameters using the current image and using user parameters
opj_setup_encoder(c_codec, ¶meters, image);
// encode the image
bSuccess = opj_start_compress(c_codec, image, c_stream);
if(bSuccess) {
src/Source/FreeImage/PluginJP2.cpp view on Meta::CPAN
// set decoding parameters to default values
opj_set_default_decoder_parameters(¶meters);
try {
// decode the JPEG-2000 file
// get a decoder handle
d_codec = opj_create_decompress(OPJ_CODEC_JP2);
// configure the event callbacks
// catch events using our callbacks (no local context needed here)
opj_set_info_handler(d_codec, NULL, NULL);
opj_set_warning_handler(d_codec, jp2_warning_callback, NULL);
opj_set_error_handler(d_codec, jp2_error_callback, NULL);
// setup the decoder decoding parameters using user parameters
if( !opj_setup_decoder(d_codec, ¶meters) ) {
throw "Failed to setup the decoder\n";
}
// read the main header of the codestream and if necessary the JP2 boxes
src/Source/FreeImage/PluginJP2.cpp view on Meta::CPAN
}
// decide if MCT should be used
parameters.tcp_mct = (image->numcomps == 3) ? 1 : 0;
// encode the destination image
// get a JP2 compressor handle
c_codec = opj_create_compress(OPJ_CODEC_JP2);
// configure the event callbacks
// catch events using our callbacks (no local context needed here)
opj_set_info_handler(c_codec, NULL, NULL);
opj_set_warning_handler(c_codec, jp2_warning_callback, NULL);
opj_set_error_handler(c_codec, jp2_error_callback, NULL);
// setup the encoder parameters using the current image and using user parameters
opj_setup_encoder(c_codec, ¶meters, image);
// encode the image
bSuccess = opj_start_compress(c_codec, image, c_stream);
if(bSuccess) {
src/Source/LibPNG/CHANGES view on Meta::CPAN
Version 0.87 [January, 1996]
fixed medium model bugs
fixed other bugs introduced in 0.85 and 0.86
added some minor documentation
Version 0.88 [January, 1996]
fixed progressive bugs
replaced tabs with spaces
cleaned up documentation
added callbacks for read/write and warning/error functions
Version 0.89 [July, 1996]
Added new initialization API to make libpng work better with shared libs
we now have png_create_read_struct(), png_create_write_struct(),
png_create_info_struct(), png_destroy_read_struct(), and
png_destroy_write_struct() instead of the separate calls to
malloc and png_read_init(), png_info_init(), and png_write_init()
Changed warning/error callback functions to fix bug - this means you
should use the new initialization API if you were using the old
png_set_message_fn() calls, and that the old API no longer exists
src/Source/LibPNG/CHANGES view on Meta::CPAN
Changed pngtest to report PASS even when file size is different (Jean-loup G.)
Corrected some logic errors in png_do_invert_alpha() (Chris Patterson)
Version 0.99f [March 5, 1998]
Corrected a bug in pngpread() introduced in version 99c (Kevin Bracey)
Moved makefiles into a "scripts" directory, and added INSTALL instruction file
Added makefile.os2 and pngos2.def (A. Zabolotny) and makefile.s2x (W. Sebok)
Added pointers to "note on libpng versions" in makefile.lnx and README
Added row callback feature when reading and writing nonprogressive rows
and added a test of this feature in pngtest.c
Added user transform callbacks, with test of the feature in pngtest.c
Version 0.99g [March 6, 1998, morning]
Minor changes to pngtest.c to suppress compiler warnings.
Removed "beta" language from documentation.
Version 0.99h [March 6, 1998, evening]
Minor changes to previous minor changes to pngtest.c
Changed PNG_READ_NOT_FULLY_SUPPORTED to PNG_READ_TRANSFORMS_NOT_SUPPORTED
and added PNG_PROGRESSIVE_READ_NOT_SUPPORTED macro
Added user transform capability
src/Source/LibPNG/CHANGES view on Meta::CPAN
Version 1.5.0beta14 [March 14, 2010]
Removed direct access to png_ptr->io_ptr from the Windows code in pngtest.c
Revised Makefile.am to account for recent additions and replacements.
Corrected CE and OS/2 DEF files (scripts/png*def) for symbols removed and
added ordinal numbers to the Windows DEF file and corrected the duplicated
ordinal numbers on CE symbols that are commented out.
Added back in export symbols that can be present in the Windows build but
are disabled by default.
PNG_EXPORT changed to include an 'ordinal' field for DEF file generation.
PNG_CALLBACK added to make callback definitions uniform. PNGAPI split
into PNGCAPI (base C form), PNGAPI (exports) and PNGCBAPI (callbacks),
and appropriate changes made to all files. Cygwin builds re-hinged to
allow procedure call standard changes and to remove the need for the DEF
file (fixes build on Cygwin).
Enabled 'attribute' warnings that are relevant to library APIs and callbacks.
Changed rules for generation of the various symbol files and added a new
rule for a DEF file (which is also added to the distribution).
Updated the symbol file generation to stop it adding spurious spaces
to EOL (coming from preprocessor macro expansion). Added a facility
to join tokens in the output and rewrite *.dfn to use this.
Eliminated scripts/*.def in favor of libpng.def; updated projects/visualc71
and removed scripts/makefile.cygwin.
Made PNG_BUILD_DLL safe: it can be set whenever a DLL is being built.
Removed the include of sys/types.h - apparently unnecessary now on the
platforms on which it happened (all but Mac OS and RISC OS).
src/Source/LibPNG/CHANGES view on Meta::CPAN
Version 1.5.0beta19 [April 24, 2010]
Added PNG_{READ,WRITE}_INT_FUNCTIONS_SUPPORTED. This allows the functions
to read and write ints to be disabled independently of PNG_USE_READ_MACROS,
which allows libpng to be built with the functions even though the default
is to use the macros - this allows applications to choose at app build
time whether or not to use macros (previously impossible because the
functions weren't in the default build.)
Changed Windows calling convention back to __cdecl for API functions.
For Windows/x86 platforms only:
__stdcall is no longer needed for Visual Basic, so libpng-1.5.0 uses
__cdecl throughout (both API functions and callbacks) on Windows/x86
platforms.
Replaced visualc6 and visualc71 projects with new vstudio project
Relaxed the overly-restrictive permissions of some files.
Version 1.5.0beta20 [April 24, 2010]
Relaxed more overly-restrictive permissions of some files.
Version 1.5.0beta21 [April 27, 2010]
Removed some unwanted binary bytes and changed CRLF to NEWLINE in the new
vstudio project files, and some trivial editing of some files in the
src/Source/LibPNG/example.c view on Meta::CPAN
/* One of the following I/O initialization methods is REQUIRED */
#ifdef streams /* PNG file I/O method 1 */
/* Set up the input control if you are using standard C streams */
png_init_io(png_ptr, fp);
#else no_streams /* PNG file I/O method 2 */
/* If you are using replacement read functions, instead of calling
* png_init_io() here you would call:
*/
png_set_read_fn(png_ptr, (void *)user_io_ptr, user_read_fn);
/* where user_io_ptr is a structure you want available to the callbacks */
#endif no_streams /* Use only one I/O method! */
/* If we have already read some of the signature */
png_set_sig_bytes(png_ptr, sig_read);
#ifdef hilevel
/*
* If you have enough memory to read in the entire image at once,
* and you need to specify only transforms that can be controlled
* with one of the PNG_TRANSFORM_* bits (this presently excludes
src/Source/LibPNG/example.c view on Meta::CPAN
return (ERROR);
}
if (setjmp(png_jmpbuf((*png_ptr))))
{
png_destroy_read_struct(png_ptr, info_ptr, NULL);
return (ERROR);
}
/* This one's new. You will need to provide all three
* function callbacks, even if you aren't using them all.
* If you aren't using all functions, you can specify NULL
* parameters. Even when all three functions are NULL,
* you need to call png_set_progressive_read_fn().
* These functions shouldn't be dependent on global or
* static variables if you are decoding several images
* simultaneously. You should store stream specific data
* in a separate struct, given as the second parameter,
* and retrieve the pointer from inside the callbacks using
* the function png_get_progressive_ptr(png_ptr).
*/
png_set_progressive_read_fn(*png_ptr, (void *)stream_data,
info_callback, row_callback, end_callback);
return (OK);
}
int
process_data(png_structp *png_ptr, png_infop *info_ptr,
src/Source/LibPNG/example.c view on Meta::CPAN
#ifdef streams /* I/O initialization method 1 */
/* Set up the output control if you are using standard C streams */
png_init_io(png_ptr, fp);
#else no_streams /* I/O initialization method 2 */
/* If you are using replacement write functions, instead of calling
* png_init_io() here you would call
*/
png_set_write_fn(png_ptr, (void *)user_io_ptr, user_write_fn,
user_IO_flush_function);
/* where user_io_ptr is a structure you want available to the callbacks */
#endif no_streams /* Only use one initialization method */
#ifdef hilevel
/* This is the easy way. Use it if you already have all the
* image info living in the structure. You could "|" many
* PNG_TRANSFORM flags into the png_transforms integer here.
*/
png_write_png(png_ptr, info_ptr, png_transforms, NULL);
#else
src/Source/LibPNG/libpng-manual.txt view on Meta::CPAN
PNG_INFO_iCCP, PNG_INFO_sPLT,
PNG_INFO_sCAL, PNG_INFO_IDAT
For a more compact example of reading a PNG image, see the file example.c.
Reading PNG files progressively
The progressive reader is slightly different from the non-progressive
reader. Instead of calling png_read_info(), png_read_rows(), and
png_read_end(), you make one call to png_process_data(), which calls
callbacks when it has the info, a row, or the end of the image. You
set up these callbacks with png_set_progressive_read_fn(). You don't
have to worry about the input/output functions of libpng, as you are
giving the library the data directly in png_process_data(). I will
assume that you have read the section on reading PNG files above,
so I will only highlight the differences (although I will show
all of the code).
png_structp png_ptr;
png_infop info_ptr;
/* An example code fragment of how you would
src/Source/LibPNG/libpng-manual.txt view on Meta::CPAN
/* This one's new. You can provide functions
to be called when the header info is valid,
when each row is completed, and when the image
is finished. If you aren't using all functions,
you can specify NULL parameters. Even when all
three functions are NULL, you need to call
png_set_progressive_read_fn(). You can use
any struct as the user_ptr (cast to a void pointer
for the function call), and retrieve the pointer
from inside the callbacks using the function
png_get_progressive_ptr(png_ptr);
which will return a void pointer, which you have
to cast appropriately.
*/
png_set_progressive_read_fn(png_ptr, (void *)user_ptr,
info_callback, row_callback, end_callback);
return 0;
src/Source/LibPNG/libpng-manual.txt view on Meta::CPAN
png_init_io(png_ptr, fp);
If you are embedding your PNG into a datastream such as MNG, and don't
want libpng to write the 8-byte signature, or if you have already
written the signature in your application, use
png_set_sig_bytes(png_ptr, 8);
to inform libpng that it should not write a signature.
Write callbacks
At this point, you can set up a callback function that will be
called after each row has been written, which you can use to control
a progress meter or the like. It's demonstrated in pngtest.c.
You must supply a function
void write_row_callback(png_structp png_ptr, png_uint_32 row,
int pass);
{
/* put your code here */
src/Source/LibPNG/libpng-manual.txt view on Meta::CPAN
standard things like memory allocation, input/output, and error handling.
The second deals with more complicated things like adding new chunks,
adding new transformations, and generally changing how libpng works.
Both of those are compile-time issues; that is, they are generally
determined at the time the code is written, and there is rarely a need
to provide the user with a means of changing them.
Memory allocation, input/output, and error handling
All of the memory allocation, input/output, and error handling in libpng
goes through callbacks that are user-settable. The default routines are
in pngmem.c, pngrio.c, pngwio.c, and pngerror.c, respectively. To change
these functions, call the appropriate png_set_*_fn() function.
Memory allocation is done through the functions png_malloc(), png_calloc(),
and png_free(). The png_malloc() and png_free() functions currently just
call the standard C functions and png_calloc() calls png_malloc() and then
clears the newly allocated memory to zero; note that png_calloc(png_ptr, size)
is not the same as the calloc(number, size) function provided by stdlib.h.
There is limited support for certain systems with segmented memory
architectures and the types of pointers declared by png.h match this; you
src/Source/LibPNG/libpng-manual.txt view on Meta::CPAN
Your malloc_fn() must return NULL in case of failure. The png_malloc()
function will normally call png_error() if it receives a NULL from the
system memory allocator or from your replacement malloc_fn().
Your free_fn() will never be called with a NULL ptr, since libpng's
png_free() checks for NULL before calling free_fn().
Input/Output in libpng is done through png_read() and png_write(),
which currently just call fread() and fwrite(). The FILE * is stored in
png_struct and is initialized via png_init_io(). If you wish to change
the method of I/O, the library supplies callbacks that you can set
through the function png_set_read_fn() and png_set_write_fn() at run
time, instead of calling the png_init_io() function. These functions
also provide a void pointer that can be retrieved via the function
png_get_io_ptr(). For example:
png_set_read_fn(png_structp read_ptr,
voidp read_io_ptr, png_rw_ptr read_data_fn)
png_set_write_fn(png_structp write_ptr,
voidp write_io_ptr, png_rw_ptr write_data_fn,
src/Source/LibPNG/libpng-manual.txt view on Meta::CPAN
PNG_NO_SETJMP, in which case it is handled via PNG_ABORT()),
but you could change this to do things like exit() if you should wish,
as long as your function does not return.
On non-fatal errors, png_warning() is called
to print a warning message, and then control returns to the calling code.
By default png_error() and png_warning() print a message on stderr via
fprintf() unless the library is compiled with PNG_NO_CONSOLE_IO defined
(because you don't want the messages) or PNG_NO_STDIO defined (because
fprintf() isn't available). If you wish to change the behavior of the error
functions, you will need to set up your own message callbacks. These
functions are normally supplied at the time that the png_struct is created.
It is also possible to redirect errors and warnings to your own replacement
functions after png_create_*_struct() has been called by calling:
png_set_error_fn(png_structp png_ptr,
png_voidp error_ptr, png_error_ptr error_fn,
png_error_ptr warning_fn);
png_voidp error_ptr = png_get_error_ptr(png_ptr);
src/Source/LibPNG/libpng-manual.txt view on Meta::CPAN
allowed: 0: treat png_benign_error() as an error.
1: treat png_benign_error() as a warning.
As of libpng-1.6.0, the default condition is to treat benign errors as
warnings while reading and as errors while writing.
Custom chunks
If you need to read or write custom chunks, you may need to get deeper
into the libpng code. The library now has mechanisms for storing
and writing chunks of unknown type; you can even declare callbacks
for custom chunks. However, this may not be good enough if the
library code itself needs to know about interactions between your
chunk and existing `intrinsic' chunks.
If you need to write a new intrinsic chunk, first read the PNG
specification. Acquire a first level of understanding of how it works.
Pay particular attention to the sections that describe chunk names,
and look at how other chunks were designed, so you can do things
similarly. Second, check out the sections of libpng that read and
write chunks. Try to find a chunk that is similar to yours and use
src/Source/LibPNG/libpng-manual.txt view on Meta::CPAN
png_create_info_struct() because they isolate the size of the structures
from the application, allow version error checking, and also allow the
use of custom error handling routines during the initialization, which
the old functions do not. The functions png_read_destroy() and
png_write_destroy() do not actually free the memory that libpng
allocated for these structs, but just reset the data structures, so they
can be used instead of png_destroy_read_struct() and
png_destroy_write_struct() if you feel there is too much system overhead
allocating and freeing the png_struct for each image read.
Setting the error callbacks via png_set_message_fn() before
png_read_init() as was suggested in libpng-0.88 is no longer supported
because this caused applications that do not use custom error functions
to fail if the png_ptr was not initialized to zero. It is still possible
to set the error callbacks AFTER png_read_init(), or to change them with
png_set_error_fn(), which is essentially the same function, but with a new
name to force compilation errors with applications that try to use the old
method.
Support for the sCAL, iCCP, iTXt, and sPLT chunks was added at libpng-1.0.6;
however, iTXt support was not enabled by default.
Starting with version 1.0.7, you can find out which version of the library
you are using at run-time:
src/Source/LibPNG/libpng.3 view on Meta::CPAN
PNG_INFO_iCCP, PNG_INFO_sPLT,
PNG_INFO_sCAL, PNG_INFO_IDAT
For a more compact example of reading a PNG image, see the file example.c.
.SS Reading PNG files progressively
The progressive reader is slightly different from the non-progressive
reader. Instead of calling png_read_info(), png_read_rows(), and
png_read_end(), you make one call to png_process_data(), which calls
callbacks when it has the info, a row, or the end of the image. You
set up these callbacks with png_set_progressive_read_fn(). You don't
have to worry about the input/output functions of libpng, as you are
giving the library the data directly in png_process_data(). I will
assume that you have read the section on reading PNG files above,
so I will only highlight the differences (although I will show
all of the code).
png_structp png_ptr;
png_infop info_ptr;
/* An example code fragment of how you would
src/Source/LibPNG/libpng.3 view on Meta::CPAN
/* This one's new. You can provide functions
to be called when the header info is valid,
when each row is completed, and when the image
is finished. If you aren't using all functions,
you can specify NULL parameters. Even when all
three functions are NULL, you need to call
png_set_progressive_read_fn(). You can use
any struct as the user_ptr (cast to a void pointer
for the function call), and retrieve the pointer
from inside the callbacks using the function
png_get_progressive_ptr(png_ptr);
which will return a void pointer, which you have
to cast appropriately.
*/
png_set_progressive_read_fn(png_ptr, (void *)user_ptr,
info_callback, row_callback, end_callback);
return 0;
src/Source/LibPNG/libpng.3 view on Meta::CPAN
png_init_io(png_ptr, fp);
If you are embedding your PNG into a datastream such as MNG, and don't
want libpng to write the 8-byte signature, or if you have already
written the signature in your application, use
png_set_sig_bytes(png_ptr, 8);
to inform libpng that it should not write a signature.
.SS Write callbacks
At this point, you can set up a callback function that will be
called after each row has been written, which you can use to control
a progress meter or the like. It's demonstrated in pngtest.c.
You must supply a function
void write_row_callback(png_structp png_ptr, png_uint_32 row,
int pass);
{
/* put your code here */
src/Source/LibPNG/libpng.3 view on Meta::CPAN
standard things like memory allocation, input/output, and error handling.
The second deals with more complicated things like adding new chunks,
adding new transformations, and generally changing how libpng works.
Both of those are compile-time issues; that is, they are generally
determined at the time the code is written, and there is rarely a need
to provide the user with a means of changing them.
Memory allocation, input/output, and error handling
All of the memory allocation, input/output, and error handling in libpng
goes through callbacks that are user-settable. The default routines are
in pngmem.c, pngrio.c, pngwio.c, and pngerror.c, respectively. To change
these functions, call the appropriate png_set_*_fn() function.
Memory allocation is done through the functions png_malloc(), png_calloc(),
and png_free(). The png_malloc() and png_free() functions currently just
call the standard C functions and png_calloc() calls png_malloc() and then
clears the newly allocated memory to zero; note that png_calloc(png_ptr, size)
is not the same as the calloc(number, size) function provided by stdlib.h.
There is limited support for certain systems with segmented memory
architectures and the types of pointers declared by png.h match this; you
src/Source/LibPNG/libpng.3 view on Meta::CPAN
Your malloc_fn() must return NULL in case of failure. The png_malloc()
function will normally call png_error() if it receives a NULL from the
system memory allocator or from your replacement malloc_fn().
Your free_fn() will never be called with a NULL ptr, since libpng's
png_free() checks for NULL before calling free_fn().
Input/Output in libpng is done through png_read() and png_write(),
which currently just call fread() and fwrite(). The FILE * is stored in
png_struct and is initialized via png_init_io(). If you wish to change
the method of I/O, the library supplies callbacks that you can set
through the function png_set_read_fn() and png_set_write_fn() at run
time, instead of calling the png_init_io() function. These functions
also provide a void pointer that can be retrieved via the function
png_get_io_ptr(). For example:
png_set_read_fn(png_structp read_ptr,
voidp read_io_ptr, png_rw_ptr read_data_fn)
png_set_write_fn(png_structp write_ptr,
voidp write_io_ptr, png_rw_ptr write_data_fn,
src/Source/LibPNG/libpng.3 view on Meta::CPAN
PNG_NO_SETJMP, in which case it is handled via PNG_ABORT()),
but you could change this to do things like exit() if you should wish,
as long as your function does not return.
On non-fatal errors, png_warning() is called
to print a warning message, and then control returns to the calling code.
By default png_error() and png_warning() print a message on stderr via
fprintf() unless the library is compiled with PNG_NO_CONSOLE_IO defined
(because you don't want the messages) or PNG_NO_STDIO defined (because
fprintf() isn't available). If you wish to change the behavior of the error
functions, you will need to set up your own message callbacks. These
functions are normally supplied at the time that the png_struct is created.
It is also possible to redirect errors and warnings to your own replacement
functions after png_create_*_struct() has been called by calling:
png_set_error_fn(png_structp png_ptr,
png_voidp error_ptr, png_error_ptr error_fn,
png_error_ptr warning_fn);
png_voidp error_ptr = png_get_error_ptr(png_ptr);
src/Source/LibPNG/libpng.3 view on Meta::CPAN
allowed: 0: treat png_benign_error() as an error.
1: treat png_benign_error() as a warning.
As of libpng-1.6.0, the default condition is to treat benign errors as
warnings while reading and as errors while writing.
.SS Custom chunks
If you need to read or write custom chunks, you may need to get deeper
into the libpng code. The library now has mechanisms for storing
and writing chunks of unknown type; you can even declare callbacks
for custom chunks. However, this may not be good enough if the
library code itself needs to know about interactions between your
chunk and existing `intrinsic' chunks.
If you need to write a new intrinsic chunk, first read the PNG
specification. Acquire a first level of understanding of how it works.
Pay particular attention to the sections that describe chunk names,
and look at how other chunks were designed, so you can do things
similarly. Second, check out the sections of libpng that read and
write chunks. Try to find a chunk that is similar to yours and use
src/Source/LibPNG/libpng.3 view on Meta::CPAN
png_create_info_struct() because they isolate the size of the structures
from the application, allow version error checking, and also allow the
use of custom error handling routines during the initialization, which
the old functions do not. The functions png_read_destroy() and
png_write_destroy() do not actually free the memory that libpng
allocated for these structs, but just reset the data structures, so they
can be used instead of png_destroy_read_struct() and
png_destroy_write_struct() if you feel there is too much system overhead
allocating and freeing the png_struct for each image read.
Setting the error callbacks via png_set_message_fn() before
png_read_init() as was suggested in libpng-0.88 is no longer supported
because this caused applications that do not use custom error functions
to fail if the png_ptr was not initialized to zero. It is still possible
to set the error callbacks AFTER png_read_init(), or to change them with
png_set_error_fn(), which is essentially the same function, but with a new
name to force compilation errors with applications that try to use the old
method.
Support for the sCAL, iCCP, iTXt, and sPLT chunks was added at libpng-1.0.6;
however, iTXt support was not enabled by default.
Starting with version 1.0.7, you can find out which version of the library
you are using at run-time:
src/Source/LibPNG/png.h view on Meta::CPAN
typedef const png_info * png_const_infop;
typedef png_info * * png_infopp;
/* Types with names ending 'p' are pointer types. The corresponding types with
* names ending 'rp' are identical pointer types except that the pointer is
* marked 'restrict', which means that it is the only pointer to the object
* passed to the function. Applications should not use the 'restrict' types;
* it is always valid to pass 'p' to a pointer with a function argument of the
* corresponding 'rp' type. Different compilers have different rules with
* regard to type matching in the presence of 'restrict'. For backward
* compatibility libpng callbacks never have 'restrict' in their parameters and,
* consequentially, writing portable application code is extremely difficult if
* an attempt is made to use 'restrict'.
*/
typedef png_struct * PNG_RESTRICT png_structrp;
typedef const png_struct * PNG_RESTRICT png_const_structrp;
typedef png_info * PNG_RESTRICT png_inforp;
typedef const png_info * PNG_RESTRICT png_const_inforp;
/* Three color definitions. The order of the red, green, and blue, (and the
* exact size) is not important, although the size of the fields need to
src/Source/LibPNG/png.h view on Meta::CPAN
*/
PNG_EXPORT(88, void, png_set_read_user_chunk_fn, (png_structrp png_ptr,
png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn));
#endif
#ifdef PNG_USER_CHUNKS_SUPPORTED
PNG_EXPORT(89, png_voidp, png_get_user_chunk_ptr, (png_const_structrp png_ptr));
#endif
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
/* Sets the function callbacks for the push reader, and a pointer to a
* user-defined structure available to the callback functions.
*/
PNG_EXPORT(90, void, png_set_progressive_read_fn, (png_structrp png_ptr,
png_voidp progressive_ptr, png_progressive_info_ptr info_fn,
png_progressive_row_ptr row_fn, png_progressive_end_ptr end_fn));
/* Returns the user pointer associated with the push read functions */
PNG_EXPORT(91, png_voidp, png_get_progressive_ptr,
(png_const_structrp png_ptr));
src/Source/LibPNG/png.h view on Meta::CPAN
/* Hence two macros to determine the number of rows or columns in a given
* pass of an image given its height or width. In fact these macros may
* return non-zero even though the sub-image is empty, because the other
* dimension may be empty for a small image.
*/
#define PNG_PASS_ROWS(height, pass) (((height)+(((1<<PNG_PASS_ROW_SHIFT(pass))\
-1)-PNG_PASS_START_ROW(pass)))>>PNG_PASS_ROW_SHIFT(pass))
#define PNG_PASS_COLS(width, pass) (((width)+(((1<<PNG_PASS_COL_SHIFT(pass))\
-1)-PNG_PASS_START_COL(pass)))>>PNG_PASS_COL_SHIFT(pass))
/* For the reader row callbacks (both progressive and sequential) it is
* necessary to find the row in the output image given a row in an interlaced
* image, so two more macros:
*/
#define PNG_ROW_FROM_PASS_ROW(y_in, pass) \
(((y_in)<<PNG_PASS_ROW_SHIFT(pass))+PNG_PASS_START_ROW(pass))
#define PNG_COL_FROM_PASS_COL(x_in, pass) \
(((x_in)<<PNG_PASS_COL_SHIFT(pass))+PNG_PASS_START_COL(pass))
/* Two macros which return a boolean (0 or 1) saying whether the given row
* or column is in a particular pass. These use a common utility macro that
src/Source/LibPNG/pngconf.h view on Meta::CPAN
* Microsoft and Borland C compilers ('IBM PC', 'DOS', 'Windows' systems
* and some others) there are multiple ways to call a function and the
* default can be changed on the compiler command line. For this reason
* libpng specifies the calling convention of every exported function and
* every function called via a user supplied function pointer. This is
* done in this file by defining the following macros:
*
* PNGAPI Calling convention for exported functions.
* PNGCBAPI Calling convention for user provided (callback) functions.
* PNGCAPI Calling convention used by the ANSI-C library (required
* for longjmp callbacks and sometimes used internally to
* specify the calling convention for zlib).
*
* These macros should never be overridden. If it is necessary to
* change calling convention in a private build this can be done
* by setting PNG_API_RULE (which defaults to 0) to one of the values
* below to select the correct 'API' variants.
*
* PNG_API_RULE=0 Use PNGCAPI - the 'C' calling convention - throughout.
* This is correct in every known environment.
* PNG_API_RULE=1 Use the operating system convention for PNGAPI and
* the 'C' calling convention (from PNGCAPI) for
* callbacks (PNGCBAPI). This is no longer required
* in any known environment - if it has to be used
* please post an explanation of the problem to the
* libpng mailing list.
*
* These cases only differ if the operating system does not use the C
* calling convention, at present this just means the above cases
* (x86 DOS/Windows sytems) and, even then, this does not apply to
* Cygwin running on those systems.
*
* Note that the value must be defined in pnglibconf.h so that what
src/Source/LibPNG/pngpriv.h view on Meta::CPAN
# if (defined(__ARM_NEON__) || defined(__ARM_NEON)) && \
defined(PNG_ALIGNED_MEMORY_SUPPORTED)
# define PNG_ARM_NEON_OPT 2
# else
# define PNG_ARM_NEON_OPT 0
# endif
#endif
#if PNG_ARM_NEON_OPT > 0
/* NEON optimizations are to be at least considered by libpng, so enable the
* callbacks to do this.
*/
# define PNG_FILTER_OPTIMIZATIONS png_init_filter_functions_neon
/* By default the 'intrinsics' code in arm/filter_neon_intrinsics.c is used
* if possible - if __ARM_NEON__ is set and the compiler version is not known
* to be broken. This is controlled by PNG_ARM_NEON_IMPLEMENTATION which can
* be:
*
* 1 The intrinsics code (the default with __ARM_NEON__)
* 2 The hand coded assembler (the default without __ARM_NEON__)
src/Source/LibPNG/pngpriv.h view on Meta::CPAN
/* Free an allocated jmp_buf (always succeeds) */
PNG_INTERNAL_FUNCTION(void,png_free_jmpbuf,(png_structrp png_ptr),PNG_EMPTY);
/* Function to allocate memory for zlib. PNGAPI is disallowed. */
PNG_INTERNAL_FUNCTION(voidpf,png_zalloc,(voidpf png_ptr, uInt items, uInt size),
PNG_ALLOCATED);
/* Function to free memory for zlib. PNGAPI is disallowed. */
PNG_INTERNAL_FUNCTION(void,png_zfree,(voidpf png_ptr, voidpf ptr),PNG_EMPTY);
/* Next four functions are used internally as callbacks. PNGCBAPI is required
* but not PNG_EXPORT. PNGAPI added at libpng version 1.2.3, changed to
* PNGCBAPI at 1.5.0
*/
PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_default_read_data,(png_structp png_ptr,
png_bytep data, png_size_t length),PNG_EMPTY);
#ifdef PNG_PROGRESSIVE_READ_SUPPORTED
PNG_INTERNAL_FUNCTION(void PNGCBAPI,png_push_fill_buffer,(png_structp png_ptr,
png_bytep buffer, png_size_t length),PNG_EMPTY);
src/Source/LibPNG/pngread.c view on Meta::CPAN
png_free(png_ptr, png_ptr->unknown_chunk.data);
png_ptr->unknown_chunk.data = NULL;
#endif
#ifdef PNG_SET_UNKNOWN_CHUNKS_SUPPORTED
png_free(png_ptr, png_ptr->chunk_list);
png_ptr->chunk_list = NULL;
#endif
/* NOTE: the 'setjmp' buffer may still be allocated and the memory and error
* callbacks are still set at this point. They are required to complete the
* destruction of the png_struct itself.
*/
}
/* Free all memory used by the read */
void PNGAPI
png_destroy_read_struct(png_structpp png_ptr_ptr, png_infopp info_ptr_ptr,
png_infopp end_info_ptr_ptr)
{
png_structrp png_ptr = NULL;
src/Source/LibPNG/pngtest.c view on Meta::CPAN
#ifndef PNG_HANDLE_CHUNK_ALWAYS
# define PNG_HANDLE_CHUNK_ALWAYS 3
#endif
#ifndef PNG_HANDLE_CHUNK_IF_SAFE
# define PNG_HANDLE_CHUNK_IF_SAFE 2
#endif
/* Utility to save typing/errors, the argument must be a name */
#define MEMZERO(var) ((void)memset(&var, 0, sizeof var))
/* Example of using row callbacks to make a simple progress meter */
static int status_pass = 1;
static int status_dots_requested = 0;
static int status_dots = 1;
static void PNGCBAPI
read_row_callback(png_structp png_ptr, png_uint_32 row_number, int pass)
{
if (png_ptr == NULL || row_number > PNG_UINT_31_MAX)
return;
src/Source/LibRawLite/Changelog.txt view on Meta::CPAN
* LibRaw can read RAW data from memory buffer via
new LibRaw::open_buffer() API call (implemented on top of
new input framework).
This call used in sample application dcraw_emu and simple_dcraw
(with -B command-line switch) to test new API.
* Error handling callback functions now can be called with
NULL filename passed (if underlying data stream object
does not know file name).
So, client error handling callbacks should work with NULL
filename.
* All client code should be recompiled
* Imported dcraw 8.90/1.417:
+ Support for loading White Balance data from
Sony ARW files edited with Sony IDC software.
* LibRaw 0.7.0-Alpha5
src/Source/LibRawLite/Changelog.txt view on Meta::CPAN
* LibRaw 0.6.0-alpha5
* All client code should be recompiled
2008-09-10 Alex Tutubalin <lexa@lexa.ru>
* New processing stages in enum LibRaw_progress:
LIBRAW_PROGRESS_BAD_PIXELS LIBRAW_PROGRESS_DARK_FRAME
(reserved stages LIBRAW_PROGRESS_RESERVED_PRE1-PRE2 has removed)
* libraw_strprogress() - convert progress code into string
* Added progress/cancellation user callbacks
+ new fatal error code: CANCELLED_BY_CALLBACK
+ sample usage in samples/dcraw_emu.cpp (try run it with -v -v -v opts)
* LibRaw 0.6.0-alpha4
* All client code should be recompiled
2008-09-08 Alex Tutubalin <lexa@lexa.ru>
* ICC-profiles support (same as in dcraw)
+ input/output profiles (specified as path to 'icc' file or 'embed' for
src/Source/LibRawLite/dcraw/dcraw.c view on Meta::CPAN
#ifdef LIBRAW_LIBRARY_BUILD
#ifdef LIBRAW_USE_OPENMP
#pragma omp for schedule(dynamic)
#endif
#endif
for (top=2; top < height-5; top += TS-6){
#ifdef LIBRAW_LIBRARY_BUILD
#ifdef LIBRAW_USE_OPENMP
if(0== omp_get_thread_num())
#endif
if(callbacks.progress_cb) {
int rr = (*callbacks.progress_cb)(callbacks.progresscb_data,LIBRAW_PROGRESS_INTERPOLATE,top-2,height-7);
if(rr)
terminate_flag = 1;
}
#endif
for (left=2; !terminate_flag && (left < width-5); left += TS-6) {
ahd_interpolate_green_h_and_v(top, left, rgb);
ahd_interpolate_r_and_b_and_convert_to_cielab(top, left, rgb, lab);
ahd_interpolate_build_homogeneity_map(top, left, lab, homo);
ahd_interpolate_combine_homogeneous_pixels(top, left, rgb, homo);
}
src/Source/LibRawLite/dcraw/dcraw.c view on Meta::CPAN
if(!strcmp(make,"Hasselblad") && (tiff_nifds > 3) && (entries > 512)) return;
// printf("\n*** in parse_exif, make: =%s= model: =%s=", make, model);
while (entries--) {
tiff_get (base, &tag, &type, &len, &save);
// printf("\n\ttag: %x", tag);
#ifdef LIBRAW_LIBRARY_BUILD
if(callbacks.exif_cb)
{
int savepos = ftell(ifp);
callbacks.exif_cb(callbacks.exifparser_data,tag,type,len,order,ifp);
fseek(ifp,savepos,SEEK_SET);
}
#endif
switch (tag) {
#ifdef LIBRAW_LIBRARY_BUILD
case 0xa405: // FocalLengthIn35mmFormat
imgdata.lens.FocalLengthIn35mmFormat = get2();
break;
case 0xa432: // LensInfo, 42034dec, Lens Specification per EXIF standard
imgdata.lens.MinFocal = getreal(type);
src/Source/LibRawLite/dcraw/dcraw.c view on Meta::CPAN
unsigned entries, tag, type, len, save;
int i, c, wbi=-2;
float mul[3]={1,1,1}, num;
static const int wbtag[] = { 64037,64040,64039,64041,-1,-1,64042 };
entries = get2();
if (entries > 1024) return;
while (entries--) {
tiff_get (base, &tag, &type, &len, &save);
#ifdef LIBRAW_LIBRARY_BUILD
if(callbacks.exif_cb)
{
int savepos = ftell(ifp);
callbacks.exif_cb(callbacks.exifparser_data,tag | 0x20000,type,len,order,ifp);
fseek(ifp,savepos,SEEK_SET);
}
#endif
if (tag == 1020) wbi = getint(type);
if (tag == 1021 && len == 72) { /* WB set in software */
fseek (ifp, 40, SEEK_CUR);
FORC3 cam_mul[c] = 2048.0 / get2();
wbi = -2;
}
if (tag == 2120 + wbi ||
src/Source/LibRawLite/dcraw/dcraw.c view on Meta::CPAN
for (i=0; i < 4; i++)
cc[j][i] = i == j;
entries = get2();
if (entries > 512) return 1;
while (entries--) {
tiff_get (base, &tag, &type, &len, &save);
// printf ("\n*** parse_tiff_ifd tag: 0x%04x", tag);
#ifdef LIBRAW_LIBRARY_BUILD
if(callbacks.exif_cb)
{
int savepos = ftell(ifp);
callbacks.exif_cb(callbacks.exifparser_data,tag|(pana_raw?0x30000:0),type,len,order,ifp);
fseek(ifp,savepos,SEEK_SET);
}
#endif
switch (tag) {
case 1: if(len==4) pana_raw = get4(); break;
case 5: width = get2(); break;
case 6: height = get2(); break;
case 7: width += get2(); break;
case 9: if ((i = get2())) filters = i;
#ifdef LIBRAW_LIBRARY_BUILD
src/Source/LibRawLite/internal/dcraw_common.cpp view on Meta::CPAN
#ifdef LIBRAW_LIBRARY_BUILD
#ifdef LIBRAW_USE_OPENMP
#pragma omp for schedule(dynamic)
#endif
#endif
for (top=2; top < height-5; top += TS-6){
#ifdef LIBRAW_LIBRARY_BUILD
#ifdef LIBRAW_USE_OPENMP
if(0== omp_get_thread_num())
#endif
if(callbacks.progress_cb) {
int rr = (*callbacks.progress_cb)(callbacks.progresscb_data,LIBRAW_PROGRESS_INTERPOLATE,top-2,height-7);
if(rr)
terminate_flag = 1;
}
#endif
for (left=2; !terminate_flag && (left < width-5); left += TS-6) {
ahd_interpolate_green_h_and_v(top, left, rgb);
ahd_interpolate_r_and_b_and_convert_to_cielab(top, left, rgb, lab);
ahd_interpolate_build_homogeneity_map(top, left, lab, homo);
ahd_interpolate_combine_homogeneous_pixels(top, left, rgb, homo);
}
src/Source/LibRawLite/internal/dcraw_common.cpp view on Meta::CPAN
if(!strcmp(make,"Hasselblad") && (tiff_nifds > 3) && (entries > 512)) return;
// printf("\n*** in parse_exif, make: =%s= model: =%s=", make, model);
while (entries--) {
tiff_get (base, &tag, &type, &len, &save);
// printf("\n\ttag: %x", tag);
#ifdef LIBRAW_LIBRARY_BUILD
if(callbacks.exif_cb)
{
int savepos = ftell(ifp);
callbacks.exif_cb(callbacks.exifparser_data,tag,type,len,order,ifp);
fseek(ifp,savepos,SEEK_SET);
}
#endif
switch (tag) {
#ifdef LIBRAW_LIBRARY_BUILD
case 0xa405: // FocalLengthIn35mmFormat
imgdata.lens.FocalLengthIn35mmFormat = get2();
break;
case 0xa432: // LensInfo, 42034dec, Lens Specification per EXIF standard
imgdata.lens.MinFocal = getreal(type);
src/Source/LibRawLite/internal/dcraw_common.cpp view on Meta::CPAN
unsigned entries, tag, type, len, save;
int i, c, wbi=-2;
float mul[3]={1,1,1}, num;
static const int wbtag[] = { 64037,64040,64039,64041,-1,-1,64042 };
entries = get2();
if (entries > 1024) return;
while (entries--) {
tiff_get (base, &tag, &type, &len, &save);
#ifdef LIBRAW_LIBRARY_BUILD
if(callbacks.exif_cb)
{
int savepos = ftell(ifp);
callbacks.exif_cb(callbacks.exifparser_data,tag | 0x20000,type,len,order,ifp);
fseek(ifp,savepos,SEEK_SET);
}
#endif
if (tag == 1020) wbi = getint(type);
if (tag == 1021 && len == 72) { /* WB set in software */
fseek (ifp, 40, SEEK_CUR);
FORC3 cam_mul[c] = 2048.0 / get2();
wbi = -2;
}
if (tag == 2120 + wbi ||
src/Source/LibRawLite/internal/dcraw_common.cpp view on Meta::CPAN
for (i=0; i < 4; i++)
cc[j][i] = i == j;
entries = get2();
if (entries > 512) return 1;
while (entries--) {
tiff_get (base, &tag, &type, &len, &save);
// printf ("\n*** parse_tiff_ifd tag: 0x%04x", tag);
#ifdef LIBRAW_LIBRARY_BUILD
if(callbacks.exif_cb)
{
int savepos = ftell(ifp);
callbacks.exif_cb(callbacks.exifparser_data,tag|(pana_raw?0x30000:0),type,len,order,ifp);
fseek(ifp,savepos,SEEK_SET);
}
#endif
switch (tag) {
case 1: if(len==4) pana_raw = get4(); break;
case 5: width = get2(); break;
case 6: height = get2(); break;
case 7: width += get2(); break;
case 9: if ((i = get2())) filters = i;
#ifdef LIBRAW_LIBRARY_BUILD
src/Source/LibRawLite/libraw/libraw.h view on Meta::CPAN
int adjust_sizes_info_only(void);
LibRaw_colormatrix_type camera_color_type();
int subtract_black();
int subtract_black_internal();
int raw2image();
int raw2image_ex(int do_subtract_black);
void raw2image_start();
void free_image();
int adjust_maximum();
void set_exifparser_handler( exif_parser_callback cb,void *data) {callbacks.exifparser_data = data; callbacks.exif_cb = cb; }
void set_memerror_handler( memory_callback cb,void *data) {callbacks.memcb_data = data; callbacks.mem_cb = cb; }
void set_dataerror_handler(data_callback func, void *data) { callbacks.datacb_data = data; callbacks.data_cb = func;}
void set_progress_handler(progress_callback pcb, void *data) { callbacks.progresscb_data = data; callbacks.progress_cb = pcb;}
/* helpers */
static const char* version();
static int versionNumber();
static const char** cameraList();
static int cameraCount();
static const char* strprogress(enum LibRaw_progress);
static const char* strerror(int p);
/* dcraw emulation */
int dcraw_ppm_tiff_writer(const char *filename);
src/Source/LibRawLite/libraw/libraw.h view on Meta::CPAN
void* realloc(void *p, size_t s);
void free(void *p);
void merror (void *ptr, const char *where);
void derror();
LibRaw_TLS *tls;
libraw_internal_data_t libraw_internal_data;
decode first_decode[2048], *second_decode, *free_decode;
tiff_ifd_t tiff_ifd[10];
libraw_memmgr memmgr;
libraw_callbacks_t callbacks;
LibRaw_constants rgb_constants;
void (LibRaw:: *write_thumb)();
void (LibRaw:: *write_fun)();
void (LibRaw:: *load_raw)();
void (LibRaw:: *thumb_load_raw)();
void kodak_thumb_loader();
void write_thumb_ppm_tiff(FILE *);
src/Source/LibRawLite/libraw/libraw.h view on Meta::CPAN
/* X3F data */
void *_x3f_data;
#ifdef LIBRAW_LIBRARY_BUILD
#include "internal/libraw_internal_funcs.h"
#endif
};
#ifdef LIBRAW_LIBRARY_BUILD
#define RUN_CALLBACK(stage,iter,expect) if(callbacks.progress_cb) { \
int rr = (*callbacks.progress_cb)(callbacks.progresscb_data,stage,iter,expect); \
if(rr!=0) throw LIBRAW_EXCEPTION_CANCELLED_BY_CALLBACK; \
}
#endif
#endif /* __cplusplus */
#endif /* _LIBRAW_CLASS_H */
src/Source/LibRawLite/libraw/libraw_types.h view on Meta::CPAN
void* memcb_data;
data_callback data_cb;
void* datacb_data;
progress_callback progress_cb;
void *progresscb_data;
exif_parser_callback exif_cb;
void *exifparser_data;
} libraw_callbacks_t;
typedef struct
{
enum LibRaw_image_formats type;
ushort height,
width,
colors,
bits;
unsigned int data_size;
src/Source/LibRawLite/src/libraw_cxx.cpp view on Meta::CPAN
return LIBRAW_CMATRIX_OTHER;
}
void LibRaw::derror()
{
if (!libraw_internal_data.unpacker_data.data_error && libraw_internal_data.internal_data.input)
{
if (libraw_internal_data.internal_data.input->eof())
{
if(callbacks.data_cb)(*callbacks.data_cb)(callbacks.datacb_data,
libraw_internal_data.internal_data.input->fname(),-1);
throw LIBRAW_EXCEPTION_IO_EOF;
}
else
{
if(callbacks.data_cb)(*callbacks.data_cb)(callbacks.datacb_data,
libraw_internal_data.internal_data.input->fname(),
libraw_internal_data.internal_data.input->tell());
//throw LIBRAW_EXCEPTION_IO_CORRUPT;
}
}
libraw_internal_data.unpacker_data.data_error++;
}
void LibRaw::dcraw_clear_mem(libraw_processed_image_t* p)
{
src/Source/LibRawLite/src/libraw_cxx.cpp view on Meta::CPAN
verbose = 1;
#else
verbose = 0;
#endif
ZERO(imgdata);
imgdata.lens.makernotes.CanonFocalUnits = 1;
imgdata.lens.makernotes.LensID = 0xffffffffffffffffULL;
cleargps(&imgdata.other.parsed_gps);
ZERO(libraw_internal_data);
ZERO(callbacks);
_rawspeed_camerameta = _rawspeed_decoder = NULL;
_x3f_data = NULL;
#ifdef USE_RAWSPEED
CameraMetaDataLR *camerameta = make_camera_metadata(); // May be NULL in case of exception in make_camera_metadata()
_rawspeed_camerameta = static_cast<void*>(camerameta);
#endif
callbacks.mem_cb = (flags & LIBRAW_OPIONS_NO_MEMERR_CALLBACK) ? NULL: &default_memory_callback;
callbacks.data_cb = (flags & LIBRAW_OPIONS_NO_DATAERR_CALLBACK)? NULL : &default_data_callback;
callbacks.exif_cb = NULL; // no default callback
memmove(&imgdata.params.aber,&aber,sizeof(aber));
memmove(&imgdata.params.gamm,&gamm,sizeof(gamm));
memmove(&imgdata.params.greybox,&greybox,sizeof(greybox));
memmove(&imgdata.params.cropbox,&cropbox,sizeof(cropbox));
imgdata.params.bright=1;
imgdata.params.use_camera_matrix=1;
imgdata.params.user_flip=-1;
imgdata.params.user_black=-1;
imgdata.params.user_cblack[0]=imgdata.params.user_cblack[1]=imgdata.params.user_cblack[2]=imgdata.params.user_cblack[3]=-1000001;
src/Source/LibRawLite/src/libraw_cxx.cpp view on Meta::CPAN
{
C.maximum = real_max;
}
return LIBRAW_SUCCESS;
}
void LibRaw:: merror (void *ptr, const char *where)
{
if (ptr) return;
if(callbacks.mem_cb)(*callbacks.mem_cb)(callbacks.memcb_data,
libraw_internal_data.internal_data.input
?libraw_internal_data.internal_data.input->fname()
:NULL,
where);
throw LIBRAW_EXCEPTION_ALLOC;
}
int LibRaw::open_file(const char *fname, INT64 max_buf_size)
src/Source/LibWebP/src/webp/encode.h view on Meta::CPAN
// Pointer to side statistics (updated only if not NULL)
WebPAuxStats* stats;
// Error code for the latest error encountered during encoding
WebPEncodingError error_code;
// If not NULL, report progress during encoding.
WebPProgressHook progress_hook;
void* user_data; // this field is free to be set to any value and
// used during callbacks (like progress-report e.g.).
uint32_t pad3[3]; // padding for later use
// Unused for now
uint8_t *pad4, *pad5;
uint32_t pad6[8]; // padding for later use
// PRIVATE FIELDS
////////////////////
void* memory_; // row chunk of memory for yuva planes
( run in 0.401 second using v1.01-cache-2.11-cpan-9b1e4054eb1 )