Lines Matching refs:can
86 about PNG, and the latest version of libpng, can be found at the PNG home
104 Further information about zlib, and the latest version of zlib, can
107 useful for more than PNG files, and can be used without libpng.
109 You can usually find the source files for the zlib utility wherever you
143 You can have more than one png_info structure associated with an image,
194 The library can be built without support for these APIs, although a
218 floating point support. The result can be seen in the generated pnglibconf.h -
222 feature macro settings - you can either add -DPNG_USER_CONFIG to the build
223 command line and put a list of feature macro settings in pngusr.h or you can set
272 but most of them have no visible effect on the API. Some can also be overridden
287 can be set using macros in pngusr.h:
371 use by the error functions, if necessary (the pointer and functions can
432 you can compile libpng with PNG_NO_SETJMP, in which case
435 You can #define PNG_ABORT() to a function that does something
455 You can change the zlib compression buffer size to be used while
495 You can set up a callback function to handle any unknown chunks in the
521 (You can give your function another name that you like instead of
530 you can retrieve with
535 chunks which the callback does not handle will be saved when read. You can
544 At this point, you can set up a callback function that will be
545 called after each row has been read, which you can use to control
555 (You can give it another name that you like instead of "read_row_callback")
571 As with the user transform you can find the output row using the
580 behavior can be wasteful if your application will never use some known
581 chunk types. To change this, you can call:
591 You can use these definitions:
660 you wish to change these limits, you can use
682 separately to each. You can change the limit on the total number of such
687 where 0x7fffffffL means unlimited. You can retrieve this limit with
692 memory that any chunk other than IDAT can occupy, originally or when
694 chunks after decompression). You can change this limit with
698 and you can retrieve the limit with
709 libpng can convert the values in the image to match the display.
711 From libpng-1.5.4 this information can be set before reading the PNG file
721 value. You can also specify a default encoding for the PNG file in
727 or you can use the fixed point equivalent:
789 (a linear portion then a gamma 2.4 power law) than PNG can express. (PNG is
801 the final display device characteristics can be changed requires system
802 specific code to obtain the current characteristic. However this can be
818 NOTE: the values can be passed to either the fixed or floating
869 advantage is that the color channels can be resampled (the image can be
932 compositing software can simply copy opaque pixels to
941 You can also try this format if your software is broken;
955 If you don't have to deal with bugs in software or hardware, or if you can fix
961 You can do color correction on the result (libpng does not currently
972 With this mode you can't do color correction, but you can do arithmetic,
978 You can avoid the expansion to 16-bit components with this mode, but you
980 All you can do is compose the result onto a matching output. Since this
1032 and if you control the code that does this you can use the optimization
1053 is dark. Take your pick - the halos are unavoidable unless you can get
1061 match the output you can take advantage of the fact that
1076 If you don't need, or can't handle, the alpha channel you can call
1089 separate gray and RGB component values, so you can let libpng produce gray or
1092 grayscale images can't have an alpha channel they can have a transparent
1113 color data you can add PNG_TRANSFORM_GRAY_TO_RGB or png_set_gray_to_rgb(png_ptr)
1126 You can use the high-level interface if (a) you are willing to read
1171 After you have called png_read_png(), you can retrieve the image data
1180 If you know your image size and pixel size ahead of time, you can allocate
1248 4) The transparent color information from a tRNS chunk. This can be modified by
1297 for PNG 1.0, and can also be
1303 interlace_type, compression_type, or filter_method can
1345 and the number of channels can change
1532 num_comments; you can put NULL here
1536 and translated keywords that can be NULL pointers, the
1554 of the screen (can be negative)
1557 of the screen (can be negative)
1618 The data from the pHYs chunk can be retrieved in several convenient
1654 The data from the oFFs chunk can be retrieved in several convenient
1669 as well, because a value in inches can't always be
1703 After you've read the header information, you can set up the library
1711 particular input data format. However some transformations can have an effect
1735 or after each RRGGBB triplet. Similarly, 8-bit or 16-bit grayscale data can
1770 PNG can have files with 16 bits per channel. If you only can handle
1795 major ommissions are conversion of grayscale to indexed images (which can be
1797 can be done by a trivial manipulation of the palette.)
1825 "." means nothing is necessary (a tRNS chunk can just be ignored).
1852 be the level of transparency instead of opacity, you can invert the
1860 they can, resulting in, for example, 8 pixels per byte for 1 bit
1901 to do that, you can add a true alpha channel with
1923 Conversely, you can convert an RGB or RGBA image to grayscale or grayscale
1955 If you have set error_action = 1 or 2, you can
1982 can be determined.
2028 supported then you can certainly do png_set_gamma() before reading the PNG
2084 This function can also be used to invert grayscale and gray-alpha images:
2099 need to change the order the pixels are packed into bytes, you can use:
2104 Finally, you can write your own transformation function if none of
2121 If supported, libpng provides two information routines that you can use to find
2140 You can also set up a pointer to a user structure for use by your
2141 callback function, and you can inform libpng that your transform
2151 You can retrieve the pointer via the function
2163 After setting the transformations, libpng can update your png_info
2170 field so you can use it to allocate your image memory. This function
2175 After you call png_read_update_info(), you can allocate any
2183 Be sure that your platform can allocate the buffer that you'll need.
2204 After you've allocated memory, you can read the image data.
2206 allocating enough memory to hold the whole image, you can just
2222 You can point to void or char or whatever you use for pixels.
2224 If you don't want to read in the whole image at once, you can
2233 If you are doing this just one row at a time, you can do this with
2247 libpng can fill out those images or it can give them to you "as is".
2267 but may change if another interlace type is added. This function can be
2285 rows between calls. You can change the locations of the data, just
2320 this can be confusing because the specification refers to the same passes
2324 You can, of course, read each sub-image row by row. If you want to
2389 writing of interlaced images. If you can't get interlacing to work in your
2396 low-level interface, you can finish reading the file.
2399 chunks after the image data, you can call png_set_crc_action()
2419 but you can pass NULL, avoiding the need to create an end_info structure.
2431 When you are done, you can free all memory allocated by libpng like this:
2468 by libpng. This can be changed, so that libpng will not free the data,
2483 You can call this function after reading the PNG data but before calling
2507 your application instead of by libpng, you can use
2571 /* This one's new. You can provide functions
2575 you can specify NULL parameters. Even when all
2577 png_set_progressive_read_fn(). You can use
2610 of 4K. Although you can give it much less if
2611 necessary (I assume you can give it chunks of
2620 /* At this point you can call png_process_data_skip if
2649 If you need to you can stop the processing of
2655 with this you can get libpng to cache the unread
2688 passing in the row and the old row. You can
2692 code easier. Thus, you can just do this for
2708 You can also call png_process_data_pause in this
2749 As these can be both relatively large, you may not want to store these
2753 both "png_ptr"; you can call them anything you like, such as
2801 you can compile libpng with PNG_NO_SETJMP, in which case
2804 You can #define PNG_ABORT() to a function that does something
2811 error according to the PNG specification, Clause 11.3.2, but the error can
2841 At this point, you can set up a callback function that will be
2842 called after each row has been written, which you can use to control
2852 (You can give it another name that you like instead of "write_row_callback")
2869 As with the user transform you can find the output row using the
2889 specific filters. You can use either a single
2907 datastream, the second parameter can be either 0 or 64.
2998 can also be
3003 the IHDR settings. The remaining png_set_*() functions can be called
3006 If you wish, you can reset the compression_type, interlace_type, or
3061 It can be one of
3238 You can change its value after calling png_set_unknown_chunks()
3252 However, you can store text either compressed or uncompressed, unlike
3293 on keywords. You can repeat keywords in a file. You can even write
3300 (Latin-1) character set (a superset of regular ASCII) and can not
3305 you can leave off the text string on non-compressed pairs.
3336 You can use the png_set_unknown_chunks function to queue up private chunks
3382 You can use the high-level interface if your image data is present
3407 If you have valid image data in the info structure (you can use
3434 you can invert the alpha channel before you write it, so that 0 is
3445 be changed, and you can safely do this transformation after your
3449 the PLTE chunk when PLTE is present, you can write the PNG info in
3456 After you've written the file information, you can set up the library
3462 checks to see if it has data that it can do something with, you should
3478 they can, resulting in, for example, 8 pixels per byte for 1 bit files.
3485 data is of another bit depth, you can write an sBIT chunk into the
3486 file so that decoders can recover the original data if desired.
3524 need to change the order the pixels are packed into bytes, you can use:
3540 Finally, you can write your own transformation function if none of
3568 You can also set up a pointer to a user structure for use by your
3574 when writing; you can set them to zero as shown.
3576 You can retrieve the pointer via the function png_get_user_transform_ptr().
3606 That's it for the transformations. Now you can write the image data.
3608 whole image in memory, you can just call png_write_image() and libpng
3620 You can point to void or char or whatever you use for pixels.
3622 If you don't want to write the whole image at once, you can
3631 If you are just writing one row at a time, you can do this with
3638 When the file is interlaced, things can get a good deal more complicated.
3642 size. libpng will build these images for you, or you can do them
3665 doing any processing. Only code that can display an image on the fly can
3687 you can pass NULL.
3691 When you are done, you can free all memory used by libpng like this:
3726 by libpng. This can be changed, so that libpng will not free the data,
3758 You can call this function before calling after the png_set_*() functions
3780 formats do not accommodate your needs then you can, and should, use the more
3870 All channels can be converted to the original value by dividing by 65535; all
3898 valid. Formats can be built up from the flag values or you can use one of
3908 NOTE: libpng can be built with particular features disabled. If you see
3913 You can guard against this by checking for the definition of the
3957 to one of the above definitions, or you can use one of the definitions below.
3978 macros can be used in array declarations and case labels where required.
3980 they can be used in #if tests.
3996 count of components. This can be used to compile-time allocate a
4010 a fixed number determined by the format so can easily be allocated on the
4069 more compressible images the PNG file can be 10 times larger with only a
4078 to the user; the user can normally easily recognize the difference between
4086 NOTE: the flag can only be set after the png_image_begin_read_ call,
4216 to use a different method of allocating and freeing data, you can use
4219 pointer that can be retrieved via
4240 the method of I/O, the library supplies callbacks that you can set
4243 also provide a void pointer that can be retrieved via the function
4310 Then, within your user_error_fn or user_warning_fn, you can retrieve
4326 You can use this to handle certain errors (normally handled as errors)
4341 and writing chunks of unknown type; you can even declare callbacks
4349 and look at how other chunks were designed, so you can do things
4352 it as a template. More details can be found in the comments inside
4363 can be found in the comments inside the code itself.
4371 They can be changed later via png_set_error_fn(). On some compilers,
4383 (Z_BEST_SPEED = 1). With versions of zlib after v0.99, you can also
4385 files larger than just storing the raw bitmap. You can specify the
4392 The memory level defaults to 8, but it can be lowered if you are
4442 can call one of these functions. The selection and configuration
4443 of row filters can have a significant impact on the size and
4457 PNG_FILTER_UP, PNG_FILTER_AVG, PNG_FILTER_PAETH, which can be bitwise
4462 you intend to use so that libpng can initialize its internal
4481 The second parameter can also be
4490 The macro definition PNG_DEBUG can be used to request debugging
4515 can still use PNG_DEBUG to control your own debugging:
4529 Libpng can support some of these extensions. To enable them, use the
4574 can be used instead of png_destroy_read_struct() and
4590 Starting with version 1.0.7, you can find out which version of the library
4599 Note that this function does not take a png_ptr, so you can call it
4602 You can also check which version of png.h you used when compiling your
4798 can call png_calloc(png_ptr, number*size) instead, and can call
4823 error according to the PNG specification, Clause 11.3.2, but the error can
4892 each pass and information that can be used to de-interlace and (if
4930 application code can check for the corresponding _SUPPORTED macro:
4945 Applications can now choose whether to use these macros or to call the
4959 This option can no longer be turned off, and the choice of accurate
4974 can be overridden by application calls to png_set_user_limits(),
4986 The library now supports a complete fixed point implementation and can
5095 Starting with libpng-1.6.0, you can configure libpng to prefix all exported
5129 by a flag so that 'small size_t' systems can select it if necessary.
5136 libpng-1.6.11, recognizing and checking sRGB profiles can be avoided by
5210 can still override them at compile time or run time, as described above).
5221 It can be set for testing debug or beta builds to ensure that they will compile
5248 going back to version 0.70. You can access the git repository (read only)
5254 or you can browse it with a web browser at
5259 Patches can be sent to png-mng-implement at lists.sourceforge.net or
5289 The braces can be omitted from simple one-line actions:
5318 Very short comments can be placed after the end of the statement
5409 Other rules can be inferred by inspecting the libpng source.