Lines Matching full:will
39 will need. We assume that libpng is already installed; see the
70 Most users will not have to modify the library significantly; advanced
103 will not, for the most part, be used by a user except as the first
122 structures are going to be hidden, and the contents of the structures will
135 progressive reading is covered in the next section, you will still
141 You will want to do the I/O initialization(*) before you get into libpng,
143 will also want to insure that you are, in fact, dealing with a PNG
146 png_sig_cmp(), and it will return 0 (false) if the bytes match the
154 with the number of bytes you read from the beginning. Libpng will
157 (*): If you are not using the standard I/O functions, you will need
223 to your routine. Therefore, you will need to call setjmp and pass
225 routines, you will need to update the jmpbuf field every time you enter
226 a new routine that will call a png_*() function.
232 back to your setjmp, you will want to call png_destroy_read_struct() to
245 errors will result in a call to PNG_ABORT() which defaults to abort().
248 use the C function fread(). If you use this, you will need to pass a
305 chunks will be saved when read, in case your callback function will need
309 At this point, you can set up a callback function that will be
329 input PNG stream. Both known and unknown chunks will be read. Normal
330 behavior is that known chunks will be parsed into information in
331 various info_ptr members while unknown chunks will be discarded. This
332 behavior can be wasteful if your application will never use some known
353 Unknown chunks declared in this way will be saved as raw data onto a
355 known to libpng is named in the list, it will be handled as unknown,
357 instances of png_set_keep_unknown_chunks(), the final instance will
359 chunk_list; if they are, libpng will process them normally anyway.
362 where the private "vpAg" chunk will later be processed by a user chunk
397 Larger images will be rejected immediately with a png_error() call. If
415 of sPLT, tEXt, iTXt, zTXt, and unknown chunks that will be stored, with
505 If you don't allocate row_pointers ahead of time, png_read_png() will
516 This will process all chunks up to but not including the image data.
705 Note while png_set_text() will accept text, language,
707 structure returned by png_get_text will always contain
709 empty strings but they will never be NULL pointers.
821 until after you read the stuff after the image. This will be
828 ways to transform the data will be described in the order that they
833 make sure to only enable a transformation if it will be valid for the
843 Data will be decoded into the supplied row buffers packed into bytes
845 For example, 4 bit/pixel paletted or grayscale data will be returned
847 byte, unless png_set_packing() is called. 8-bit RGB data will be stored
850 16-bit RGB data will be returned RRGGBB RRGGBB, with the most significant
919 8 bits per channel, this will strip the pixels down to 8 bit.
947 If you do this, any input with a tRNS chunk will be expanded to
988 will generate RGBA pixels.
1007 RGB. This code will do that conversion:
1038 It will return a png_byte that is zero if the image was gray or
1040 will be silently converted to grayscale, using the green channel
1099 to know what the display gamma is. Ideally, the user will know this, and
1100 the application will allow them to set it. One method of allowing the user
1102 SCREEN_GAMMA or DISPLAY_GAMMA environment variable, which will hopefully be
1151 file has more entries then will fit on your screen, png_set_dither()
1152 will do that. Note that this is a simple match dither that merely
1155 pass a palette that is larger then maximum_colors, the file will
1156 reduce the number of colors in the palette so it will fit into
1157 maximum_colors. If there is a histogram, it will use it to make
1185 The following code will reverse this (make black be one and white be
1223 See pngtest.c for a working example. Your function will be called
1228 function will change the number of channels or bit depth with the
1253 will also update your palette with the correct screen_gamma and
1261 varies among applications, no example will be given. If you
1262 are allocating one large chunk, you will need to build an
1263 array of pointers to each row, as it will be needed for some
1271 call png_read_image() and libpng will read in all the image data
1272 and put it in the memory area supplied. You will need to pass in
1326 The first pass will return an image 1/8 as wide as the entire image
1328 (every 8th row starting in row 0), the second will be 1/8 as wide
1330 third pass will be 1/4 as wide (every 4th pixel starting in column 0) and
1331 1/8 as high (every 8th row starting in row 4), and the fourth pass will
1333 and every 4th row starting in row 0). The fifth pass will return an
1335 while the sixth pass will be 1/2 as wide and 1/2 as high as the original
1336 (starting in column 1 and row 0). The seventh and final pass will be as
1347 This will return the number of passes needed. Currently, this
1350 where it will return one pass.
1410 by the user and not by libpng, and will in those cases do nothing.
1417 by libpng. This can be changed, so that libpng will not free the data,
1418 or so that it will free data that was allocated by the user with png_malloc()
1448 the key member, and png_free_data() will free only text_ptr.key. Similarly,
1452 The png_free_data() function will turn off the "valid" flag for anything
1479 giving the library the data directly in png_process_data(). I will
1481 so I will only highlight the differences (although I will show
1526 which will return a void pointer, which you have
1591 on the interlace handler, this function will
1593 of these rows will not be changed from the
1595 the new_row variable will be NULL. The rows
1604 call this function for NULL rows (it will just
1606 does the memcpy for you) if it will make the
1616 pass (pass == 0, really) will completely cover
1619 for interlaced images), you will have to pass
1620 the current row, and the function will combine
1631 will usually have the same info chunk as you
1650 You will want to do the I/O initialization before you get into libpng,
1652 using the standard I/O functions, you will need to replace them with
1664 will want to check if they return NULL. If you are also reading,
1692 After you have these structures, you will need to set up the
1694 longjmp() back to your routine. Therefore, you will need to call
1696 write the file from different routines, you will need to update
1697 the png_jmpbuf(png_ptr) every time you enter a new routine that will
1714 errors will result in a call to PNG_ABORT() which defaults to abort().
1717 use the C function fwrite(). If you use this, you will need to pass a
1735 At this point, you can set up a callback function that will be
1752 You now have the option of modifying how the compression library will
1783 row of pixels will be stored in case it's needed later), and then add
2051 any language code or translated keyword will not be written out.
2122 all there is to it. The chunks will be written by the next following
2125 list will also be written out in a sequence that satisfies the PNG
2208 ways to transform the data will be described in the order that they
2213 make sure to only enable a transformation if it will be valid for the
2229 If the data is supplied at 1 pixel per byte, use this code, which will
2258 this will scale the values to appear to be the correct bit depth as
2300 See pngtest.c for a working example. Your function will be called
2330 So if you write 50 lines, and then png_set_flush 25, it will flush the
2335 may be acceptable for real-time applications). Infrequent flushing will
2344 will write the image. You will need to pass in an array of pointers to
2377 size. libpng will build these images for you, or you can do them
2391 This will return the number of passes needed. Currently, this is seven,
2434 by the user and not by libpng, and will in those cases do nothing.
2445 by libpng. This can be changed, so that libpng will not free the data,
2446 or so that it will free data that was allocated by the user with png_malloc()
2485 the key member, and png_free_data() will free only text_ptr.key. Similarly,
2511 at a time, you will want to set MAXSEG_64K in zlib.h. Since it is
2513 will change between applications, these functions must be modified in
2529 function will normally call png_error() if it receives a NULL from the
2532 Your free_fn() will never be called with a NULL ptr, since libpng's
2585 functions, you will need to set up your own message callbacks. These
2597 default function will be used, calling fprintf() and/or longjmp() if a
2642 You will want to look into zconf.h to tell zlib (and thus libpng) that
2648 For DOS users who only have access to the lower 640K, you will
2665 You will need to write new error and warning functions that use the GUI
2701 other things, lower levels will result in sections of incompressible
2828 as this will cause applications linked with different versions of the
2831 those sections that are actually used will be loaded into memory.
2867 having level = 0 will be printed. There aren't any such statements in
2868 this version of libpng, but if you insert some they will be printed.
2907 functions will be removed from libpng version 2.0.0.
3192 will hold years up to 65535. The other two hold the date in text
3193 format, and will hold years up to 9999.
