From 735ee530243b5e9be51f945517b5f7c7630c4f34 Mon Sep 17 00:00:00 2001 From: Piers Daniell Date: Mon, 23 Feb 2015 16:23:13 -0700 Subject: Update tri and cube with stage These changes were cherry-picked from nvidia-dev-20150218 and KhronosGroup/GDC-stable. --- include/XCB/randr.h | 7 + include/XCB/xcb.h | 578 +++++ include/XCB/xcb_windefs.h | 45 + include/XCB/xproto.h | 5783 +++++++++++++++++++++++++++++++++++++++++++++ include/png.h | 3687 +++++++++++++++++++++++++++++ include/pngconf.h | 1496 ++++++++++++ include/zconf.h | 511 ++++ include/zlib.h | 1768 ++++++++++++++ 8 files changed, 13875 insertions(+) create mode 100644 include/XCB/randr.h create mode 100644 include/XCB/xcb.h create mode 100644 include/XCB/xcb_windefs.h create mode 100644 include/XCB/xproto.h create mode 100644 include/png.h create mode 100644 include/pngconf.h create mode 100644 include/zconf.h create mode 100644 include/zlib.h (limited to 'include') diff --git a/include/XCB/randr.h b/include/XCB/randr.h new file mode 100644 index 00000000..b4c101d9 --- /dev/null +++ b/include/XCB/randr.h @@ -0,0 +1,7 @@ +#ifndef __RANDR_H +#define __RANDR_H + +typedef void * xcb_randr_provider_t; +typedef void * xcb_randr_crtc_t; + +#endif // __RANDR_H diff --git a/include/XCB/xcb.h b/include/XCB/xcb.h new file mode 100644 index 00000000..88ed22df --- /dev/null +++ b/include/XCB/xcb.h @@ -0,0 +1,578 @@ +/* + * Copyright (C) 2001-2006 Bart Massey, Jamey Sharp, and Josh Triplett. + * All Rights Reserved. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the names of the authors or their + * institutions shall not be used in advertising or otherwise to promote the + * sale, use or other dealings in this Software without prior written + * authorization from the authors. + */ + +#ifndef __XCB_H__ +#define __XCB_H__ +#include + +#if defined(__solaris__) +#include +#else +#include +#endif + +#ifndef _WIN32 +#include +#else +#include "xcb_windefs.h" +#endif + + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @file xcb.h + */ + +#define XCB_PACKED __attribute__((__packed__)) + +/** + * @defgroup XCB_Core_API XCB Core API + * @brief Core API of the XCB library. + * + * @{ + */ + +/* Pre-defined constants */ + +/** Current protocol version */ +#define X_PROTOCOL 11 + +/** Current minor version */ +#define X_PROTOCOL_REVISION 0 + +/** X_TCP_PORT + display number = server port for TCP transport */ +#define X_TCP_PORT 6000 + +/** xcb connection errors because of socket, pipe and other stream errors. */ +#define XCB_CONN_ERROR 1 + +/** xcb connection shutdown because of extension not supported */ +#define XCB_CONN_CLOSED_EXT_NOTSUPPORTED 2 + +/** malloc(), calloc() and realloc() error upon failure, for eg ENOMEM */ +#define XCB_CONN_CLOSED_MEM_INSUFFICIENT 3 + +/** Connection closed, exceeding request length that server accepts. */ +#define XCB_CONN_CLOSED_REQ_LEN_EXCEED 4 + +/** Connection closed, error during parsing display string. */ +#define XCB_CONN_CLOSED_PARSE_ERR 5 + +/** Connection closed because the server does not have a screen matching the display. */ +#define XCB_CONN_CLOSED_INVALID_SCREEN 6 + +/** Connection closed because some FD passing operation failed */ +#define XCB_CONN_CLOSED_FDPASSING_FAILED 7 + +#define XCB_TYPE_PAD(T,I) (-(I) & (sizeof(T) > 4 ? 3 : sizeof(T) - 1)) + +/* Opaque structures */ + +/** + * @brief XCB Connection structure. + * + * A structure that contain all data that XCB needs to communicate with an X server. + */ +typedef struct xcb_connection_t xcb_connection_t; /**< Opaque structure containing all data that XCB needs to communicate with an X server. */ + + +/* Other types */ + +/** + * @brief Generic iterator. + * + * A generic iterator structure. + */ +typedef struct { + void *data; /**< Data of the current iterator */ + int rem; /**< remaining elements */ + int index; /**< index of the current iterator */ +} xcb_generic_iterator_t; + +/** + * @brief Generic reply. + * + * A generic reply structure. + */ +typedef struct { + uint8_t response_type; /**< Type of the response */ + uint8_t pad0; /**< Padding */ + uint16_t sequence; /**< Sequence number */ + uint32_t length; /**< Length of the response */ +} xcb_generic_reply_t; + +/** + * @brief Generic event. + * + * A generic event structure. + */ +typedef struct { + uint8_t response_type; /**< Type of the response */ + uint8_t pad0; /**< Padding */ + uint16_t sequence; /**< Sequence number */ + uint32_t pad[7]; /**< Padding */ + uint32_t full_sequence; /**< full sequence */ +} xcb_generic_event_t; + +/** + * @brief GE event + * + * An event as sent by the XGE extension. The length field specifies the + * number of 4-byte blocks trailing the struct. + * + * @deprecated Since some fields in this struct have unfortunate names, it is + * recommended to use xcb_ge_generic_event_t instead. + */ +typedef struct { + uint8_t response_type; /**< Type of the response */ + uint8_t pad0; /**< Padding */ + uint16_t sequence; /**< Sequence number */ + uint32_t length; + uint16_t event_type; + uint16_t pad1; + uint32_t pad[5]; /**< Padding */ + uint32_t full_sequence; /**< full sequence */ +} xcb_ge_event_t; + +/** + * @brief Generic error. + * + * A generic error structure. + */ +typedef struct { + uint8_t response_type; /**< Type of the response */ + uint8_t error_code; /**< Error code */ + uint16_t sequence; /**< Sequence number */ + uint32_t resource_id; /** < Resource ID for requests with side effects only */ + uint16_t minor_code; /** < Minor opcode of the failed request */ + uint8_t major_code; /** < Major opcode of the failed request */ + uint8_t pad0; + uint32_t pad[5]; /**< Padding */ + uint32_t full_sequence; /**< full sequence */ +} xcb_generic_error_t; + +/** + * @brief Generic cookie. + * + * A generic cookie structure. + */ +typedef struct { + unsigned int sequence; /**< Sequence number */ +} xcb_void_cookie_t; + + +/* Include the generated xproto header. */ +#include "xproto.h" + + +/** XCB_NONE is the universal null resource or null atom parameter value for many core X requests */ +#define XCB_NONE 0L + +/** XCB_COPY_FROM_PARENT can be used for many xcb_create_window parameters */ +#define XCB_COPY_FROM_PARENT 0L + +/** XCB_CURRENT_TIME can be used in most requests that take an xcb_timestamp_t */ +#define XCB_CURRENT_TIME 0L + +/** XCB_NO_SYMBOL fills in unused entries in xcb_keysym_t tables */ +#define XCB_NO_SYMBOL 0L + + +/* xcb_auth.c */ + +/** + * @brief Container for authorization information. + * + * A container for authorization information to be sent to the X server. + */ +typedef struct xcb_auth_info_t { + int namelen; /**< Length of the string name (as returned by strlen). */ + char *name; /**< String containing the authentication protocol name, such as "MIT-MAGIC-COOKIE-1" or "XDM-AUTHORIZATION-1". */ + int datalen; /**< Length of the data member. */ + char *data; /**< Data interpreted in a protocol-specific manner. */ +} xcb_auth_info_t; + + +/* xcb_out.c */ + +/** + * @brief Forces any buffered output to be written to the server. + * @param c: The connection to the X server. + * @return > @c 0 on success, <= @c 0 otherwise. + * + * Forces any buffered output to be written to the server. Blocks + * until the write is complete. + */ +int xcb_flush(xcb_connection_t *c); + +/** + * @brief Returns the maximum request length that this server accepts. + * @param c: The connection to the X server. + * @return The maximum request length field. + * + * In the absence of the BIG-REQUESTS extension, returns the + * maximum request length field from the connection setup data, which + * may be as much as 65535. If the server supports BIG-REQUESTS, then + * the maximum request length field from the reply to the + * BigRequestsEnable request will be returned instead. + * + * Note that this length is measured in four-byte units, making the + * theoretical maximum lengths roughly 256kB without BIG-REQUESTS and + * 16GB with. + */ +uint32_t xcb_get_maximum_request_length(xcb_connection_t *c); + +/** + * @brief Prefetch the maximum request length without blocking. + * @param c: The connection to the X server. + * + * Without blocking, does as much work as possible toward computing + * the maximum request length accepted by the X server. + * + * Invoking this function may cause a call to xcb_big_requests_enable, + * but will not block waiting for the reply. + * xcb_get_maximum_request_length will return the prefetched data + * after possibly blocking while the reply is retrieved. + * + * Note that in order for this function to be fully non-blocking, the + * application must previously have called + * xcb_prefetch_extension_data(c, &xcb_big_requests_id) and the reply + * must have already arrived. + */ +void xcb_prefetch_maximum_request_length(xcb_connection_t *c); + + +/* xcb_in.c */ + +/** + * @brief Returns the next event or error from the server. + * @param c: The connection to the X server. + * @return The next event from the server. + * + * Returns the next event or error from the server, or returns null in + * the event of an I/O error. Blocks until either an event or error + * arrive, or an I/O error occurs. + */ +xcb_generic_event_t *xcb_wait_for_event(xcb_connection_t *c); + +/** + * @brief Returns the next event or error from the server. + * @param c: The connection to the X server. + * @return The next event from the server. + * + * Returns the next event or error from the server, if one is + * available, or returns @c NULL otherwise. If no event is available, that + * might be because an I/O error like connection close occurred while + * attempting to read the next event, in which case the connection is + * shut down when this function returns. + */ +xcb_generic_event_t *xcb_poll_for_event(xcb_connection_t *c); + +/** + * @brief Returns the next event without reading from the connection. + * @param c: The connection to the X server. + * @return The next already queued event from the server. + * + * This is a version of xcb_poll_for_event that only examines the + * event queue for new events. The function doesn't try to read new + * events from the connection if no queued events are found. + * + * This function is useful for callers that know in advance that all + * interesting events have already been read from the connection. For + * example, callers might use xcb_wait_for_reply and be interested + * only of events that preceded a specific reply. + */ +xcb_generic_event_t *xcb_poll_for_queued_event(xcb_connection_t *c); + +typedef struct xcb_special_event xcb_special_event_t; + +/** + * @brief Returns the next event from a special queue + */ +xcb_generic_event_t *xcb_poll_for_special_event(xcb_connection_t *c, + xcb_special_event_t *se); + +/** + * @brief Returns the next event from a special queue, blocking until one arrives + */ +xcb_generic_event_t *xcb_wait_for_special_event(xcb_connection_t *c, + xcb_special_event_t *se); +/** + * @typedef typedef struct xcb_extension_t xcb_extension_t + */ +typedef struct xcb_extension_t xcb_extension_t; /**< Opaque structure used as key for xcb_get_extension_data_t. */ + +/** + * @brief Listen for a special event + */ +xcb_special_event_t *xcb_register_for_special_xge(xcb_connection_t *c, + xcb_extension_t *ext, + uint32_t eid, + uint32_t *stamp); + +/** + * @brief Stop listening for a special event + */ +void xcb_unregister_for_special_event(xcb_connection_t *c, + xcb_special_event_t *se); + +/** + * @brief Return the error for a request, or NULL if none can ever arrive. + * @param c: The connection to the X server. + * @param cookie: The request cookie. + * @return The error for the request, or NULL if none can ever arrive. + * + * The xcb_void_cookie_t cookie supplied to this function must have resulted + * from a call to xcb_[request_name]_checked(). This function will block + * until one of two conditions happens. If an error is received, it will be + * returned. If a reply to a subsequent request has already arrived, no error + * can arrive for this request, so this function will return NULL. + * + * Note that this function will perform a sync if needed to ensure that the + * sequence number will advance beyond that provided in cookie; this is a + * convenience to avoid races in determining whether the sync is needed. + */ +xcb_generic_error_t *xcb_request_check(xcb_connection_t *c, xcb_void_cookie_t cookie); + +/** + * @brief Discards the reply for a request. + * @param c: The connection to the X server. + * @param sequence: The request sequence number from a cookie. + * + * Discards the reply for a request. Additionally, any error generated + * by the request is also discarded (unless it was an _unchecked request + * and the error has already arrived). + * + * This function will not block even if the reply is not yet available. + * + * Note that the sequence really does have to come from an xcb cookie; + * this function is not designed to operate on socket-handoff replies. + */ +void xcb_discard_reply(xcb_connection_t *c, unsigned int sequence); + + +/* xcb_ext.c */ + +/** + * @brief Caches reply information from QueryExtension requests. + * @param c: The connection. + * @param ext: The extension data. + * @return A pointer to the xcb_query_extension_reply_t for the extension. + * + * This function is the primary interface to the "extension cache", + * which caches reply information from QueryExtension + * requests. Invoking this function may cause a call to + * xcb_query_extension to retrieve extension information from the + * server, and may block until extension data is received from the + * server. + * + * The result must not be freed. This storage is managed by the cache + * itself. + */ +const struct xcb_query_extension_reply_t *xcb_get_extension_data(xcb_connection_t *c, xcb_extension_t *ext); + +/** + * @brief Prefetch of extension data into the extension cache + * @param c: The connection. + * @param ext: The extension data. + * + * This function allows a "prefetch" of extension data into the + * extension cache. Invoking the function may cause a call to + * xcb_query_extension, but will not block waiting for the + * reply. xcb_get_extension_data will return the prefetched data after + * possibly blocking while it is retrieved. + */ +void xcb_prefetch_extension_data(xcb_connection_t *c, xcb_extension_t *ext); + + +/* xcb_conn.c */ + +/** + * @brief Access the data returned by the server. + * @param c: The connection. + * @return A pointer to an xcb_setup_t structure. + * + * Accessor for the data returned by the server when the xcb_connection_t + * was initialized. This data includes + * - the server's required format for images, + * - a list of available visuals, + * - a list of available screens, + * - the server's maximum request length (in the absence of the + * BIG-REQUESTS extension), + * - and other assorted information. + * + * See the X protocol specification for more details. + * + * The result must not be freed. + */ +const struct xcb_setup_t *xcb_get_setup(xcb_connection_t *c); + +/** + * @brief Access the file descriptor of the connection. + * @param c: The connection. + * @return The file descriptor. + * + * Accessor for the file descriptor that was passed to the + * xcb_connect_to_fd call that returned @p c. + */ +int xcb_get_file_descriptor(xcb_connection_t *c); + +/** + * @brief Test whether the connection has shut down due to a fatal error. + * @param c: The connection. + * @return > 0 if the connection is in an error state; 0 otherwise. + * + * Some errors that occur in the context of an xcb_connection_t + * are unrecoverable. When such an error occurs, the + * connection is shut down and further operations on the + * xcb_connection_t have no effect, but memory will not be freed until + * xcb_disconnect() is called on the xcb_connection_t. + * + * @return XCB_CONN_ERROR, because of socket errors, pipe errors or other stream errors. + * @return XCB_CONN_CLOSED_EXT_NOTSUPPORTED, when extension not supported. + * @return XCB_CONN_CLOSED_MEM_INSUFFICIENT, when memory not available. + * @return XCB_CONN_CLOSED_REQ_LEN_EXCEED, exceeding request length that server accepts. + * @return XCB_CONN_CLOSED_PARSE_ERR, error during parsing display string. + * @return XCB_CONN_CLOSED_INVALID_SCREEN, because the server does not have a screen matching the display. + */ +int xcb_connection_has_error(xcb_connection_t *c); + +/** + * @brief Connects to the X server. + * @param fd: The file descriptor. + * @param auth_info: Authentication data. + * @return A newly allocated xcb_connection_t structure. + * + * Connects to an X server, given the open socket @p fd and the + * xcb_auth_info_t @p auth_info. The file descriptor @p fd is + * bidirectionally connected to an X server. If the connection + * should be unauthenticated, @p auth_info must be @c + * NULL. + * + * Always returns a non-NULL pointer to a xcb_connection_t, even on failure. + * Callers need to use xcb_connection_has_error() to check for failure. + * When finished, use xcb_disconnect() to close the connection and free + * the structure. + */ +xcb_connection_t *xcb_connect_to_fd(int fd, xcb_auth_info_t *auth_info); + +/** + * @brief Closes the connection. + * @param c: The connection. + * + * Closes the file descriptor and frees all memory associated with the + * connection @c c. If @p c is @c NULL, nothing is done. + */ +void xcb_disconnect(xcb_connection_t *c); + + +/* xcb_util.c */ + +/** + * @brief Parses a display string name in the form documented by X(7x). + * @param name: The name of the display. + * @param host: A pointer to a malloc'd copy of the hostname. + * @param display: A pointer to the display number. + * @param screen: A pointer to the screen number. + * @return 0 on failure, non 0 otherwise. + * + * Parses the display string name @p display_name in the form + * documented by X(7x). Has no side effects on failure. If + * @p displayname is @c NULL or empty, it uses the environment + * variable DISPLAY. @p hostp is a pointer to a newly allocated string + * that contain the host name. @p displayp is set to the display + * number and @p screenp to the preferred screen number. @p screenp + * can be @c NULL. If @p displayname does not contain a screen number, + * it is set to @c 0. + */ +int xcb_parse_display(const char *name, char **host, int *display, int *screen); + +/** + * @brief Connects to the X server. + * @param displayname: The name of the display. + * @param screenp: A pointer to a preferred screen number. + * @return A newly allocated xcb_connection_t structure. + * + * Connects to the X server specified by @p displayname. If @p + * displayname is @c NULL, uses the value of the DISPLAY environment + * variable. If a particular screen on that server is preferred, the + * int pointed to by @p screenp (if not @c NULL) will be set to that + * screen; otherwise the screen will be set to 0. + * + * Always returns a non-NULL pointer to a xcb_connection_t, even on failure. + * Callers need to use xcb_connection_has_error() to check for failure. + * When finished, use xcb_disconnect() to close the connection and free + * the structure. + */ +xcb_connection_t *xcb_connect(const char *displayname, int *screenp); + +/** + * @brief Connects to the X server, using an authorization information. + * @param display: The name of the display. + * @param auth: The authorization information. + * @param screen: A pointer to a preferred screen number. + * @return A newly allocated xcb_connection_t structure. + * + * Connects to the X server specified by @p displayname, using the + * authorization @p auth. If a particular screen on that server is + * preferred, the int pointed to by @p screenp (if not @c NULL) will + * be set to that screen; otherwise @p screenp will be set to 0. + * + * Always returns a non-NULL pointer to a xcb_connection_t, even on failure. + * Callers need to use xcb_connection_has_error() to check for failure. + * When finished, use xcb_disconnect() to close the connection and free + * the structure. + */ +xcb_connection_t *xcb_connect_to_display_with_auth_info(const char *display, xcb_auth_info_t *auth, int *screen); + + +/* xcb_xid.c */ + +/** + * @brief Allocates an XID for a new object. + * @param c: The connection. + * @return A newly allocated XID. + * + * Allocates an XID for a new object. Typically used just prior to + * various object creation functions, such as xcb_create_window. + */ +uint32_t xcb_generate_id(xcb_connection_t *c); + + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + + +#endif /* __XCB_H__ */ diff --git a/include/XCB/xcb_windefs.h b/include/XCB/xcb_windefs.h new file mode 100644 index 00000000..df6026da --- /dev/null +++ b/include/XCB/xcb_windefs.h @@ -0,0 +1,45 @@ +/* Copyright (C) 2009 Jatin Golani. + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the "Software"), + * to deal in the Software without restriction, including without limitation + * the rights to use, copy, modify, merge, publish, distribute, sublicense, + * and/or sell copies of the Software, and to permit persons to whom the + * Software is furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN + * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN + * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * + * Except as contained in this notice, the names of the authors or their + * institutions shall not be used in advertising or otherwise to promote the + * sale, use or other dealings in this Software without prior written + * authorization from the authors. + */ + + +#ifndef _XCB_WINDEFS_H +#define _XCB_WINDEFS_H + +#ifndef WINVER +#define WINVER 0x0501 /* required for getaddrinfo/freeaddrinfo defined only for WinXP and above */ +#endif + +#include +#include +#include + +struct iovec { + void *iov_base; /* Pointer to data. */ + int iov_len; /* Length of data. */ +}; + +typedef unsigned int in_addr_t; + +#endif /* xcb_windefs.h */ diff --git a/include/XCB/xproto.h b/include/XCB/xproto.h new file mode 100644 index 00000000..aafb9584 --- /dev/null +++ b/include/XCB/xproto.h @@ -0,0 +1,5783 @@ +/* + * This file generated automatically from xproto.xml by c_client.py. + * Edit at your peril. + */ + +#ifndef __XPROTO_H +#define __XPROTO_H + +#include "xcb.h" + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct xcb_char2b_t { + uint8_t byte1; + uint8_t byte2; +} xcb_char2b_t; + +typedef struct xcb_char2b_iterator_t { + xcb_char2b_t *data; + int rem; + int index; +} xcb_char2b_iterator_t; + +typedef uint32_t xcb_window_t; + +typedef struct xcb_window_iterator_t { + xcb_window_t *data; + int rem; + int index; +} xcb_window_iterator_t; + +typedef uint32_t xcb_pixmap_t; + +typedef struct xcb_pixmap_iterator_t { + xcb_pixmap_t *data; + int rem; + int index; +} xcb_pixmap_iterator_t; + +typedef uint32_t xcb_cursor_t; + +typedef struct xcb_cursor_iterator_t { + xcb_cursor_t *data; + int rem; + int index; +} xcb_cursor_iterator_t; + +typedef uint32_t xcb_font_t; + +typedef struct xcb_font_iterator_t { + xcb_font_t *data; + int rem; + int index; +} xcb_font_iterator_t; + +typedef uint32_t xcb_gcontext_t; + +typedef struct xcb_gcontext_iterator_t { + xcb_gcontext_t *data; + int rem; + int index; +} xcb_gcontext_iterator_t; + +typedef uint32_t xcb_colormap_t; + +typedef struct xcb_colormap_iterator_t { + xcb_colormap_t *data; + int rem; + int index; +} xcb_colormap_iterator_t; + +typedef uint32_t xcb_atom_t; + +typedef struct xcb_atom_iterator_t { + xcb_atom_t *data; + int rem; + int index; +} xcb_atom_iterator_t; + +typedef uint32_t xcb_drawable_t; + +typedef struct xcb_drawable_iterator_t { + xcb_drawable_t *data; + int rem; + int index; +} xcb_drawable_iterator_t; + +typedef uint32_t xcb_fontable_t; + +typedef struct xcb_fontable_iterator_t { + xcb_fontable_t *data; + int rem; + int index; +} xcb_fontable_iterator_t; + +typedef uint32_t xcb_visualid_t; + +typedef struct xcb_visualid_iterator_t { + xcb_visualid_t *data; + int rem; + int index; +} xcb_visualid_iterator_t; + +typedef uint32_t xcb_timestamp_t; + +typedef struct xcb_timestamp_iterator_t { + xcb_timestamp_t *data; + int rem; + int index; +} xcb_timestamp_iterator_t; + +typedef uint32_t xcb_keysym_t; + +typedef struct xcb_keysym_iterator_t { + xcb_keysym_t *data; + int rem; + int index; +} xcb_keysym_iterator_t; + +typedef uint8_t xcb_keycode_t; + +typedef struct xcb_keycode_iterator_t { + xcb_keycode_t *data; + int rem; + int index; +} xcb_keycode_iterator_t; + +typedef uint8_t xcb_button_t; + +typedef struct xcb_button_iterator_t { + xcb_button_t *data; + int rem; + int index; +} xcb_button_iterator_t; + +typedef struct xcb_point_t { + int16_t x; + int16_t y; +} xcb_point_t; + +typedef struct xcb_point_iterator_t { + xcb_point_t *data; + int rem; + int index; +} xcb_point_iterator_t; + +typedef struct xcb_rectangle_t { + int16_t x; + int16_t y; + uint16_t width; + uint16_t height; +} xcb_rectangle_t; + +typedef struct xcb_rectangle_iterator_t { + xcb_rectangle_t *data; + int rem; + int index; +} xcb_rectangle_iterator_t; + +typedef struct xcb_arc_t { + int16_t x; + int16_t y; + uint16_t width; + uint16_t height; + int16_t angle1; + int16_t angle2; +} xcb_arc_t; + +typedef struct xcb_arc_iterator_t { + xcb_arc_t *data; + int rem; + int index; +} xcb_arc_iterator_t; + +typedef struct xcb_format_t { + uint8_t depth; + uint8_t bits_per_pixel; + uint8_t scanline_pad; + uint8_t pad0[5]; +} xcb_format_t; + +typedef struct xcb_format_iterator_t { + xcb_format_t *data; + int rem; + int index; +} xcb_format_iterator_t; + +typedef enum xcb_visual_class_t { + XCB_VISUAL_CLASS_STATIC_GRAY = 0, + XCB_VISUAL_CLASS_GRAY_SCALE = 1, + XCB_VISUAL_CLASS_STATIC_COLOR = 2, + XCB_VISUAL_CLASS_PSEUDO_COLOR = 3, + XCB_VISUAL_CLASS_TRUE_COLOR = 4, + XCB_VISUAL_CLASS_DIRECT_COLOR = 5 +} xcb_visual_class_t; + +typedef struct xcb_visualtype_t { + xcb_visualid_t visual_id; + uint8_t _class; + uint8_t bits_per_rgb_value; + uint16_t colormap_entries; + uint32_t red_mask; + uint32_t green_mask; + uint32_t blue_mask; + uint8_t pad0[4]; +} xcb_visualtype_t; + +typedef struct xcb_visualtype_iterator_t { + xcb_visualtype_t *data; + int rem; + int index; +} xcb_visualtype_iterator_t; + +typedef struct xcb_depth_t { + uint8_t depth; + uint8_t pad0; + uint16_t visuals_len; + uint8_t pad1[4]; +} xcb_depth_t; + +typedef struct xcb_depth_iterator_t { + xcb_depth_t *data; + int rem; + int index; +} xcb_depth_iterator_t; + +typedef enum xcb_event_mask_t { + XCB_EVENT_MASK_NO_EVENT = 0, + XCB_EVENT_MASK_KEY_PRESS = 1, + XCB_EVENT_MASK_KEY_RELEASE = 2, + XCB_EVENT_MASK_BUTTON_PRESS = 4, + XCB_EVENT_MASK_BUTTON_RELEASE = 8, + XCB_EVENT_MASK_ENTER_WINDOW = 16, + XCB_EVENT_MASK_LEAVE_WINDOW = 32, + XCB_EVENT_MASK_POINTER_MOTION = 64, + XCB_EVENT_MASK_POINTER_MOTION_HINT = 128, + XCB_EVENT_MASK_BUTTON_1_MOTION = 256, + XCB_EVENT_MASK_BUTTON_2_MOTION = 512, + XCB_EVENT_MASK_BUTTON_3_MOTION = 1024, + XCB_EVENT_MASK_BUTTON_4_MOTION = 2048, + XCB_EVENT_MASK_BUTTON_5_MOTION = 4096, + XCB_EVENT_MASK_BUTTON_MOTION = 8192, + XCB_EVENT_MASK_KEYMAP_STATE = 16384, + XCB_EVENT_MASK_EXPOSURE = 32768, + XCB_EVENT_MASK_VISIBILITY_CHANGE = 65536, + XCB_EVENT_MASK_STRUCTURE_NOTIFY = 131072, + XCB_EVENT_MASK_RESIZE_REDIRECT = 262144, + XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY = 524288, + XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT = 1048576, + XCB_EVENT_MASK_FOCUS_CHANGE = 2097152, + XCB_EVENT_MASK_PROPERTY_CHANGE = 4194304, + XCB_EVENT_MASK_COLOR_MAP_CHANGE = 8388608, + XCB_EVENT_MASK_OWNER_GRAB_BUTTON = 16777216 +} xcb_event_mask_t; + +typedef enum xcb_backing_store_t { + XCB_BACKING_STORE_NOT_USEFUL = 0, + XCB_BACKING_STORE_WHEN_MAPPED = 1, + XCB_BACKING_STORE_ALWAYS = 2 +} xcb_backing_store_t; + +typedef struct xcb_screen_t { + xcb_window_t root; + xcb_colormap_t default_colormap; + uint32_t white_pixel; + uint32_t black_pixel; + uint32_t current_input_masks; + uint16_t width_in_pixels; + uint16_t height_in_pixels; + uint16_t width_in_millimeters; + uint16_t height_in_millimeters; + uint16_t min_installed_maps; + uint16_t max_installed_maps; + xcb_visualid_t root_visual; + uint8_t backing_stores; + uint8_t save_unders; + uint8_t root_depth; + uint8_t allowed_depths_len; +} xcb_screen_t; + +typedef struct xcb_screen_iterator_t { + xcb_screen_t *data; + int rem; + int index; +} xcb_screen_iterator_t; + +typedef struct xcb_setup_request_t { + uint8_t byte_order; + uint8_t pad0; + uint16_t protocol_major_version; + uint16_t protocol_minor_version; + uint16_t authorization_protocol_name_len; + uint16_t authorization_protocol_data_len; + uint8_t pad1[2]; +} xcb_setup_request_t; + +typedef struct xcb_setup_request_iterator_t { + xcb_setup_request_t *data; + int rem; + int index; +} xcb_setup_request_iterator_t; + +typedef struct xcb_setup_failed_t { + uint8_t status; + uint8_t reason_len; + uint16_t protocol_major_version; + uint16_t protocol_minor_version; + uint16_t length; +} xcb_setup_failed_t; + +typedef struct xcb_setup_failed_iterator_t { + xcb_setup_failed_t *data; + int rem; + int index; +} xcb_setup_failed_iterator_t; + +typedef struct xcb_setup_authenticate_t { + uint8_t status; + uint8_t pad0[5]; + uint16_t length; +} xcb_setup_authenticate_t; + +typedef struct xcb_setup_authenticate_iterator_t { + xcb_setup_authenticate_t *data; + int rem; + int index; +} xcb_setup_authenticate_iterator_t; + +typedef enum xcb_image_order_t { + XCB_IMAGE_ORDER_LSB_FIRST = 0, + XCB_IMAGE_ORDER_MSB_FIRST = 1 +} xcb_image_order_t; + +typedef struct xcb_setup_t { + uint8_t status; + uint8_t pad0; + uint16_t protocol_major_version; + uint16_t protocol_minor_version; + uint16_t length; + uint32_t release_number; + uint32_t resource_id_base; + uint32_t resource_id_mask; + uint32_t motion_buffer_size; + uint16_t vendor_len; + uint16_t maximum_request_length; + uint8_t roots_len; + uint8_t pixmap_formats_len; + uint8_t image_byte_order; + uint8_t bitmap_format_bit_order; + uint8_t bitmap_format_scanline_unit; + uint8_t bitmap_format_scanline_pad; + xcb_keycode_t min_keycode; + xcb_keycode_t max_keycode; + uint8_t pad1[4]; +} xcb_setup_t; + +typedef struct xcb_setup_iterator_t { + xcb_setup_t *data; + int rem; + int index; +} xcb_setup_iterator_t; + +typedef enum xcb_mod_mask_t { + XCB_MOD_MASK_SHIFT = 1, + XCB_MOD_MASK_LOCK = 2, + XCB_MOD_MASK_CONTROL = 4, + XCB_MOD_MASK_1 = 8, + XCB_MOD_MASK_2 = 16, + XCB_MOD_MASK_3 = 32, + XCB_MOD_MASK_4 = 64, + XCB_MOD_MASK_5 = 128, + XCB_MOD_MASK_ANY = 32768 +} xcb_mod_mask_t; + +typedef enum xcb_key_but_mask_t { + XCB_KEY_BUT_MASK_SHIFT = 1, + XCB_KEY_BUT_MASK_LOCK = 2, + XCB_KEY_BUT_MASK_CONTROL = 4, + XCB_KEY_BUT_MASK_MOD_1 = 8, + XCB_KEY_BUT_MASK_MOD_2 = 16, + XCB_KEY_BUT_MASK_MOD_3 = 32, + XCB_KEY_BUT_MASK_MOD_4 = 64, + XCB_KEY_BUT_MASK_MOD_5 = 128, + XCB_KEY_BUT_MASK_BUTTON_1 = 256, + XCB_KEY_BUT_MASK_BUTTON_2 = 512, + XCB_KEY_BUT_MASK_BUTTON_3 = 1024, + XCB_KEY_BUT_MASK_BUTTON_4 = 2048, + XCB_KEY_BUT_MASK_BUTTON_5 = 4096 +} xcb_key_but_mask_t; + +typedef enum xcb_window_enum_t { + XCB_WINDOW_NONE = 0 +} xcb_window_enum_t; + +#define XCB_KEY_PRESS 2 + +typedef struct xcb_key_press_event_t { + uint8_t response_type; + xcb_keycode_t detail; + uint16_t sequence; + xcb_timestamp_t time; + xcb_window_t root; + xcb_window_t event; + xcb_window_t child; + int16_t root_x; + int16_t root_y; + int16_t event_x; + int16_t event_y; + uint16_t state; + uint8_t same_screen; + uint8_t pad0; +} xcb_key_press_event_t; + +#define XCB_KEY_RELEASE 3 + +typedef xcb_key_press_event_t xcb_key_release_event_t; + +typedef enum xcb_button_mask_t { + XCB_BUTTON_MASK_1 = 256, + XCB_BUTTON_MASK_2 = 512, + XCB_BUTTON_MASK_3 = 1024, + XCB_BUTTON_MASK_4 = 2048, + XCB_BUTTON_MASK_5 = 4096, + XCB_BUTTON_MASK_ANY = 32768 +} xcb_button_mask_t; + +#define XCB_BUTTON_PRESS 4 + +typedef struct xcb_button_press_event_t { + uint8_t response_type; + xcb_button_t detail; + uint16_t sequence; + xcb_timestamp_t time; + xcb_window_t root; + xcb_window_t event; + xcb_window_t child; + int16_t root_x; + int16_t root_y; + int16_t event_x; + int16_t event_y; + uint16_t state; + uint8_t same_screen; + uint8_t pad0; +} xcb_button_press_event_t; + +#define XCB_BUTTON_RELEASE 5 + +typedef xcb_button_press_event_t xcb_button_release_event_t; + +typedef enum xcb_motion_t { + XCB_MOTION_NORMAL = 0, + XCB_MOTION_HINT = 1 +} xcb_motion_t; + +#define XCB_MOTION_NOTIFY 6 + +typedef struct xcb_motion_notify_event_t { + uint8_t response_type; + uint8_t detail; + uint16_t sequence; + xcb_timestamp_t time; + xcb_window_t root; + xcb_window_t event; + xcb_window_t child; + int16_t root_x; + int16_t root_y; + int16_t event_x; + int16_t event_y; + uint16_t state; + uint8_t same_screen; + uint8_t pad0; +} xcb_motion_notify_event_t; + +typedef enum xcb_notify_detail_t { + XCB_NOTIFY_DETAIL_ANCESTOR = 0, + XCB_NOTIFY_DETAIL_VIRTUAL = 1, + XCB_NOTIFY_DETAIL_INFERIOR = 2, + XCB_NOTIFY_DETAIL_NONLINEAR = 3, + XCB_NOTIFY_DETAIL_NONLINEAR_VIRTUAL = 4, + XCB_NOTIFY_DETAIL_POINTER = 5, + XCB_NOTIFY_DETAIL_POINTER_ROOT = 6, + XCB_NOTIFY_DETAIL_NONE = 7 +} xcb_notify_detail_t; + +typedef enum xcb_notify_mode_t { + XCB_NOTIFY_MODE_NORMAL = 0, + XCB_NOTIFY_MODE_GRAB = 1, + XCB_NOTIFY_MODE_UNGRAB = 2, + XCB_NOTIFY_MODE_WHILE_GRABBED = 3 +} xcb_notify_mode_t; + +#define XCB_ENTER_NOTIFY 7 + +typedef struct xcb_enter_notify_event_t { + uint8_t response_type; + uint8_t detail; + uint16_t sequence; + xcb_timestamp_t time; + xcb_window_t root; + xcb_window_t event; + xcb_window_t child; + int16_t root_x; + int16_t root_y; + int16_t event_x; + int16_t event_y; + uint16_t state; + uint8_t mode; + uint8_t same_screen_focus; +} xcb_enter_notify_event_t; + +#define XCB_LEAVE_NOTIFY 8 + +typedef xcb_enter_notify_event_t xcb_leave_notify_event_t; + +#define XCB_FOCUS_IN 9 + +typedef struct xcb_focus_in_event_t { + uint8_t response_type; + uint8_t detail; + uint16_t sequence; + xcb_window_t event; + uint8_t mode; + uint8_t pad0[3]; +} xcb_focus_in_event_t; + +#define XCB_FOCUS_OUT 10 + +typedef xcb_focus_in_event_t xcb_focus_out_event_t; + +#define XCB_KEYMAP_NOTIFY 11 + +typedef struct xcb_keymap_notify_event_t { + uint8_t response_type; + uint8_t keys[31]; +} xcb_keymap_notify_event_t; + +#define XCB_EXPOSE 12 + +typedef struct xcb_expose_event_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t window; + uint16_t x; + uint16_t y; + uint16_t width; + uint16_t height; + uint16_t count; + uint8_t pad1[2]; +} xcb_expose_event_t; + +#define XCB_GRAPHICS_EXPOSURE 13 + +typedef struct xcb_graphics_exposure_event_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_drawable_t drawable; + uint16_t x; + uint16_t y; + uint16_t width; + uint16_t height; + uint16_t minor_opcode; + uint16_t count; + uint8_t major_opcode; + uint8_t pad1[3]; +} xcb_graphics_exposure_event_t; + +#define XCB_NO_EXPOSURE 14 + +typedef struct xcb_no_exposure_event_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_drawable_t drawable; + uint16_t minor_opcode; + uint8_t major_opcode; + uint8_t pad1; +} xcb_no_exposure_event_t; + +typedef enum xcb_visibility_t { + XCB_VISIBILITY_UNOBSCURED = 0, + XCB_VISIBILITY_PARTIALLY_OBSCURED = 1, + XCB_VISIBILITY_FULLY_OBSCURED = 2 +} xcb_visibility_t; + +#define XCB_VISIBILITY_NOTIFY 15 + +typedef struct xcb_visibility_notify_event_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t window; + uint8_t state; + uint8_t pad1[3]; +} xcb_visibility_notify_event_t; + +#define XCB_CREATE_NOTIFY 16 + +typedef struct xcb_create_notify_event_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t parent; + xcb_window_t window; + int16_t x; + int16_t y; + uint16_t width; + uint16_t height; + uint16_t border_width; + uint8_t override_redirect; + uint8_t pad1; +} xcb_create_notify_event_t; + +#define XCB_DESTROY_NOTIFY 17 + +typedef struct xcb_destroy_notify_event_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t event; + xcb_window_t window; +} xcb_destroy_notify_event_t; + +#define XCB_UNMAP_NOTIFY 18 + +typedef struct xcb_unmap_notify_event_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t event; + xcb_window_t window; + uint8_t from_configure; + uint8_t pad1[3]; +} xcb_unmap_notify_event_t; + +#define XCB_MAP_NOTIFY 19 + +typedef struct xcb_map_notify_event_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t event; + xcb_window_t window; + uint8_t override_redirect; + uint8_t pad1[3]; +} xcb_map_notify_event_t; + +#define XCB_MAP_REQUEST 20 + +typedef struct xcb_map_request_event_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t parent; + xcb_window_t window; +} xcb_map_request_event_t; + +#define XCB_REPARENT_NOTIFY 21 + +typedef struct xcb_reparent_notify_event_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t event; + xcb_window_t window; + xcb_window_t parent; + int16_t x; + int16_t y; + uint8_t override_redirect; + uint8_t pad1[3]; +} xcb_reparent_notify_event_t; + +#define XCB_CONFIGURE_NOTIFY 22 + +typedef struct xcb_configure_notify_event_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t event; + xcb_window_t window; + xcb_window_t above_sibling; + int16_t x; + int16_t y; + uint16_t width; + uint16_t height; + uint16_t border_width; + uint8_t override_redirect; + uint8_t pad1; +} xcb_configure_notify_event_t; + +#define XCB_CONFIGURE_REQUEST 23 + +typedef struct xcb_configure_request_event_t { + uint8_t response_type; + uint8_t stack_mode; + uint16_t sequence; + xcb_window_t parent; + xcb_window_t window; + xcb_window_t sibling; + int16_t x; + int16_t y; + uint16_t width; + uint16_t height; + uint16_t border_width; + uint16_t value_mask; +} xcb_configure_request_event_t; + +#define XCB_GRAVITY_NOTIFY 24 + +typedef struct xcb_gravity_notify_event_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t event; + xcb_window_t window; + int16_t x; + int16_t y; +} xcb_gravity_notify_event_t; + +#define XCB_RESIZE_REQUEST 25 + +typedef struct xcb_resize_request_event_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t window; + uint16_t width; + uint16_t height; +} xcb_resize_request_event_t; + +typedef enum xcb_place_t { + XCB_PLACE_ON_TOP = 0, + XCB_PLACE_ON_BOTTOM = 1 +} xcb_place_t; + +#define XCB_CIRCULATE_NOTIFY 26 + +typedef struct xcb_circulate_notify_event_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t event; + xcb_window_t window; + uint8_t pad1[4]; + uint8_t place; + uint8_t pad2[3]; +} xcb_circulate_notify_event_t; + +#define XCB_CIRCULATE_REQUEST 27 + +typedef xcb_circulate_notify_event_t xcb_circulate_request_event_t; + +typedef enum xcb_property_t { + XCB_PROPERTY_NEW_VALUE = 0, + XCB_PROPERTY_DELETE = 1 +} xcb_property_t; + +#define XCB_PROPERTY_NOTIFY 28 + +typedef struct xcb_property_notify_event_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t window; + xcb_atom_t atom; + xcb_timestamp_t time; + uint8_t state; + uint8_t pad1[3]; +} xcb_property_notify_event_t; + +#define XCB_SELECTION_CLEAR 29 + +typedef struct xcb_selection_clear_event_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_timestamp_t time; + xcb_window_t owner; + xcb_atom_t selection; +} xcb_selection_clear_event_t; + +typedef enum xcb_time_t { + XCB_TIME_CURRENT_TIME = 0 +} xcb_time_t; + +typedef enum xcb_atom_enum_t { + XCB_ATOM_NONE = 0, + XCB_ATOM_ANY = 0, + XCB_ATOM_PRIMARY = 1, + XCB_ATOM_SECONDARY = 2, + XCB_ATOM_ARC = 3, + XCB_ATOM_ATOM = 4, + XCB_ATOM_BITMAP = 5, + XCB_ATOM_CARDINAL = 6, + XCB_ATOM_COLORMAP = 7, + XCB_ATOM_CURSOR = 8, + XCB_ATOM_CUT_BUFFER0 = 9, + XCB_ATOM_CUT_BUFFER1 = 10, + XCB_ATOM_CUT_BUFFER2 = 11, + XCB_ATOM_CUT_BUFFER3 = 12, + XCB_ATOM_CUT_BUFFER4 = 13, + XCB_ATOM_CUT_BUFFER5 = 14, + XCB_ATOM_CUT_BUFFER6 = 15, + XCB_ATOM_CUT_BUFFER7 = 16, + XCB_ATOM_DRAWABLE = 17, + XCB_ATOM_FONT = 18, + XCB_ATOM_INTEGER = 19, + XCB_ATOM_PIXMAP = 20, + XCB_ATOM_POINT = 21, + XCB_ATOM_RECTANGLE = 22, + XCB_ATOM_RESOURCE_MANAGER = 23, + XCB_ATOM_RGB_COLOR_MAP = 24, + XCB_ATOM_RGB_BEST_MAP = 25, + XCB_ATOM_RGB_BLUE_MAP = 26, + XCB_ATOM_RGB_DEFAULT_MAP = 27, + XCB_ATOM_RGB_GRAY_MAP = 28, + XCB_ATOM_RGB_GREEN_MAP = 29, + XCB_ATOM_RGB_RED_MAP = 30, + XCB_ATOM_STRING = 31, + XCB_ATOM_VISUALID = 32, + XCB_ATOM_WINDOW = 33, + XCB_ATOM_WM_COMMAND = 34, + XCB_ATOM_WM_HINTS = 35, + XCB_ATOM_WM_CLIENT_MACHINE = 36, + XCB_ATOM_WM_ICON_NAME = 37, + XCB_ATOM_WM_ICON_SIZE = 38, + XCB_ATOM_WM_NAME = 39, + XCB_ATOM_WM_NORMAL_HINTS = 40, + XCB_ATOM_WM_SIZE_HINTS = 41, + XCB_ATOM_WM_ZOOM_HINTS = 42, + XCB_ATOM_MIN_SPACE = 43, + XCB_ATOM_NORM_SPACE = 44, + XCB_ATOM_MAX_SPACE = 45, + XCB_ATOM_END_SPACE = 46, + XCB_ATOM_SUPERSCRIPT_X = 47, + XCB_ATOM_SUPERSCRIPT_Y = 48, + XCB_ATOM_SUBSCRIPT_X = 49, + XCB_ATOM_SUBSCRIPT_Y = 50, + XCB_ATOM_UNDERLINE_POSITION = 51, + XCB_ATOM_UNDERLINE_THICKNESS = 52, + XCB_ATOM_STRIKEOUT_ASCENT = 53, + XCB_ATOM_STRIKEOUT_DESCENT = 54, + XCB_ATOM_ITALIC_ANGLE = 55, + XCB_ATOM_X_HEIGHT = 56, + XCB_ATOM_QUAD_WIDTH = 57, + XCB_ATOM_WEIGHT = 58, + XCB_ATOM_POINT_SIZE = 59, + XCB_ATOM_RESOLUTION = 60, + XCB_ATOM_COPYRIGHT = 61, + XCB_ATOM_NOTICE = 62, + XCB_ATOM_FONT_NAME = 63, + XCB_ATOM_FAMILY_NAME = 64, + XCB_ATOM_FULL_NAME = 65, + XCB_ATOM_CAP_HEIGHT = 66, + XCB_ATOM_WM_CLASS = 67, + XCB_ATOM_WM_TRANSIENT_FOR = 68 +} xcb_atom_enum_t; + +#define XCB_SELECTION_REQUEST 30 + +typedef struct xcb_selection_request_event_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_timestamp_t time; + xcb_window_t owner; + xcb_window_t requestor; + xcb_atom_t selection; + xcb_atom_t target; + xcb_atom_t property; +} xcb_selection_request_event_t; + +#define XCB_SELECTION_NOTIFY 31 + +typedef struct xcb_selection_notify_event_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_timestamp_t time; + xcb_window_t requestor; + xcb_atom_t selection; + xcb_atom_t target; + xcb_atom_t property; +} xcb_selection_notify_event_t; + +typedef enum xcb_colormap_state_t { + XCB_COLORMAP_STATE_UNINSTALLED = 0, + XCB_COLORMAP_STATE_INSTALLED = 1 +} xcb_colormap_state_t; + +typedef enum xcb_colormap_enum_t { + XCB_COLORMAP_NONE = 0 +} xcb_colormap_enum_t; + +#define XCB_COLORMAP_NOTIFY 32 + +typedef struct xcb_colormap_notify_event_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + xcb_window_t window; + xcb_colormap_t colormap; + uint8_t _new; + uint8_t state; + uint8_t pad1[2]; +} xcb_colormap_notify_event_t; + +typedef union xcb_client_message_data_t { + uint8_t data8[20]; + uint16_t data16[10]; + uint32_t data32[5]; +} xcb_client_message_data_t; + +typedef struct xcb_client_message_data_iterator_t { + xcb_client_message_data_t *data; + int rem; + int index; +} xcb_client_message_data_iterator_t; + +#define XCB_CLIENT_MESSAGE 33 + +typedef struct xcb_client_message_event_t { + uint8_t response_type; + uint8_t format; + uint16_t sequence; + xcb_window_t window; + xcb_atom_t type; + xcb_client_message_data_t data; +} xcb_client_message_event_t; + +typedef enum xcb_mapping_t { + XCB_MAPPING_MODIFIER = 0, + XCB_MAPPING_KEYBOARD = 1, + XCB_MAPPING_POINTER = 2 +} xcb_mapping_t; + +#define XCB_MAPPING_NOTIFY 34 + +typedef struct xcb_mapping_notify_event_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint8_t request; + xcb_keycode_t first_keycode; + uint8_t count; + uint8_t pad1; +} xcb_mapping_notify_event_t; + +#define XCB_GE_GENERIC 35 + +typedef struct xcb_ge_generic_event_t { + uint8_t response_type; + uint8_t extension; + uint16_t sequence; + uint32_t length; + uint16_t event_type; + uint8_t pad0[22]; + uint32_t full_sequence; +} xcb_ge_generic_event_t; + +#define XCB_REQUEST 1 + +typedef struct xcb_request_error_t { + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; + uint32_t bad_value; + uint16_t minor_opcode; + uint8_t major_opcode; + uint8_t pad0; +} xcb_request_error_t; + +#define XCB_VALUE 2 + +typedef struct xcb_value_error_t { + uint8_t response_type; + uint8_t error_code; + uint16_t sequence; + uint32_t bad_value; + uint16_t minor_opcode; + uint8_t major_opcode; + uint8_t pad0; +} xcb_value_error_t; + +#define XCB_WINDOW 3 + +typedef xcb_value_error_t xcb_window_error_t; + +#define XCB_PIXMAP 4 + +typedef xcb_value_error_t xcb_pixmap_error_t; + +#define XCB_ATOM 5 + +typedef xcb_value_error_t xcb_atom_error_t; + +#define XCB_CURSOR 6 + +typedef xcb_value_error_t xcb_cursor_error_t; + +#define XCB_FONT 7 + +typedef xcb_value_error_t xcb_font_error_t; + +#define XCB_MATCH 8 + +typedef xcb_request_error_t xcb_match_error_t; + +#define XCB_DRAWABLE 9 + +typedef xcb_value_error_t xcb_drawable_error_t; + +#define XCB_ACCESS 10 + +typedef xcb_request_error_t xcb_access_error_t; + +#define XCB_ALLOC 11 + +typedef xcb_request_error_t xcb_alloc_error_t; + +#define XCB_COLORMAP 12 + +typedef xcb_value_error_t xcb_colormap_error_t; + +#define XCB_G_CONTEXT 13 + +typedef xcb_value_error_t xcb_g_context_error_t; + +#define XCB_ID_CHOICE 14 + +typedef xcb_value_error_t xcb_id_choice_error_t; + +#define XCB_NAME 15 + +typedef xcb_request_error_t xcb_name_error_t; + +#define XCB_LENGTH 16 + +typedef xcb_request_error_t xcb_length_error_t; + +#define XCB_IMPLEMENTATION 17 + +typedef xcb_request_error_t xcb_implementation_error_t; + +typedef enum xcb_window_class_t { + XCB_WINDOW_CLASS_COPY_FROM_PARENT = 0, + XCB_WINDOW_CLASS_INPUT_OUTPUT = 1, + XCB_WINDOW_CLASS_INPUT_ONLY = 2 +} xcb_window_class_t; + +typedef enum xcb_cw_t { + XCB_CW_BACK_PIXMAP = 1, + XCB_CW_BACK_PIXEL = 2, + XCB_CW_BORDER_PIXMAP = 4, + XCB_CW_BORDER_PIXEL = 8, + XCB_CW_BIT_GRAVITY = 16, + XCB_CW_WIN_GRAVITY = 32, + XCB_CW_BACKING_STORE = 64, + XCB_CW_BACKING_PLANES = 128, + XCB_CW_BACKING_PIXEL = 256, + XCB_CW_OVERRIDE_REDIRECT = 512, + XCB_CW_SAVE_UNDER = 1024, + XCB_CW_EVENT_MASK = 2048, + XCB_CW_DONT_PROPAGATE = 4096, + XCB_CW_COLORMAP = 8192, + XCB_CW_CURSOR = 16384 +} xcb_cw_t; + +typedef enum xcb_back_pixmap_t { + XCB_BACK_PIXMAP_NONE = 0, + XCB_BACK_PIXMAP_PARENT_RELATIVE = 1 +} xcb_back_pixmap_t; + +typedef enum xcb_gravity_t { + XCB_GRAVITY_BIT_FORGET = 0, + XCB_GRAVITY_WIN_UNMAP = 0, + XCB_GRAVITY_NORTH_WEST = 1, + XCB_GRAVITY_NORTH = 2, + XCB_GRAVITY_NORTH_EAST = 3, + XCB_GRAVITY_WEST = 4, + XCB_GRAVITY_CENTER = 5, + XCB_GRAVITY_EAST = 6, + XCB_GRAVITY_SOUTH_WEST = 7, + XCB_GRAVITY_SOUTH = 8, + XCB_GRAVITY_SOUTH_EAST = 9, + XCB_GRAVITY_STATIC = 10 +} xcb_gravity_t; + +#define XCB_CREATE_WINDOW 1 + +typedef struct xcb_create_window_request_t { + uint8_t major_opcode; + uint8_t depth; + uint16_t length; + xcb_window_t wid; + xcb_window_t parent; + int16_t x; + int16_t y; + uint16_t width; + uint16_t height; + uint16_t border_width; + uint16_t _class; + xcb_visualid_t visual; + uint32_t value_mask; +} xcb_create_window_request_t; + +#define XCB_CHANGE_WINDOW_ATTRIBUTES 2 + +typedef struct xcb_change_window_attributes_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; + uint32_t value_mask; +} xcb_change_window_attributes_request_t; + +typedef enum xcb_map_state_t { + XCB_MAP_STATE_UNMAPPED = 0, + XCB_MAP_STATE_UNVIEWABLE = 1, + XCB_MAP_STATE_VIEWABLE = 2 +} xcb_map_state_t; + +typedef struct xcb_get_window_attributes_cookie_t { + unsigned int sequence; +} xcb_get_window_attributes_cookie_t; + +#define XCB_GET_WINDOW_ATTRIBUTES 3 + +typedef struct xcb_get_window_attributes_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; +} xcb_get_window_attributes_request_t; + +typedef struct xcb_get_window_attributes_reply_t { + uint8_t response_type; + uint8_t backing_store; + uint16_t sequence; + uint32_t length; + xcb_visualid_t visual; + uint16_t _class; + uint8_t bit_gravity; + uint8_t win_gravity; + uint32_t backing_planes; + uint32_t backing_pixel; + uint8_t save_under; + uint8_t map_is_installed; + uint8_t map_state; + uint8_t override_redirect; + xcb_colormap_t colormap; + uint32_t all_event_masks; + uint32_t your_event_mask; + uint16_t do_not_propagate_mask; + uint8_t pad0[2]; +} xcb_get_window_attributes_reply_t; + +#define XCB_DESTROY_WINDOW 4 + +typedef struct xcb_destroy_window_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; +} xcb_destroy_window_request_t; + +#define XCB_DESTROY_SUBWINDOWS 5 + +typedef struct xcb_destroy_subwindows_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; +} xcb_destroy_subwindows_request_t; + +typedef enum xcb_set_mode_t { + XCB_SET_MODE_INSERT = 0, + XCB_SET_MODE_DELETE = 1 +} xcb_set_mode_t; + +#define XCB_CHANGE_SAVE_SET 6 + +typedef struct xcb_change_save_set_request_t { + uint8_t major_opcode; + uint8_t mode; + uint16_t length; + xcb_window_t window; +} xcb_change_save_set_request_t; + +#define XCB_REPARENT_WINDOW 7 + +typedef struct xcb_reparent_window_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; + xcb_window_t parent; + int16_t x; + int16_t y; +} xcb_reparent_window_request_t; + +#define XCB_MAP_WINDOW 8 + +typedef struct xcb_map_window_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; +} xcb_map_window_request_t; + +#define XCB_MAP_SUBWINDOWS 9 + +typedef struct xcb_map_subwindows_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; +} xcb_map_subwindows_request_t; + +#define XCB_UNMAP_WINDOW 10 + +typedef struct xcb_unmap_window_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; +} xcb_unmap_window_request_t; + +#define XCB_UNMAP_SUBWINDOWS 11 + +typedef struct xcb_unmap_subwindows_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; +} xcb_unmap_subwindows_request_t; + +typedef enum xcb_config_window_t { + XCB_CONFIG_WINDOW_X = 1, + XCB_CONFIG_WINDOW_Y = 2, + XCB_CONFIG_WINDOW_WIDTH = 4, + XCB_CONFIG_WINDOW_HEIGHT = 8, + XCB_CONFIG_WINDOW_BORDER_WIDTH = 16, + XCB_CONFIG_WINDOW_SIBLING = 32, + XCB_CONFIG_WINDOW_STACK_MODE = 64 +} xcb_config_window_t; + +typedef enum xcb_stack_mode_t { + XCB_STACK_MODE_ABOVE = 0, + XCB_STACK_MODE_BELOW = 1, + XCB_STACK_MODE_TOP_IF = 2, + XCB_STACK_MODE_BOTTOM_IF = 3, + XCB_STACK_MODE_OPPOSITE = 4 +} xcb_stack_mode_t; + +#define XCB_CONFIGURE_WINDOW 12 + +typedef struct xcb_configure_window_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; + uint16_t value_mask; + uint8_t pad1[2]; +} xcb_configure_window_request_t; + +typedef enum xcb_circulate_t { + XCB_CIRCULATE_RAISE_LOWEST = 0, + XCB_CIRCULATE_LOWER_HIGHEST = 1 +} xcb_circulate_t; + +#define XCB_CIRCULATE_WINDOW 13 + +typedef struct xcb_circulate_window_request_t { + uint8_t major_opcode; + uint8_t direction; + uint16_t length; + xcb_window_t window; +} xcb_circulate_window_request_t; + +typedef struct xcb_get_geometry_cookie_t { + unsigned int sequence; +} xcb_get_geometry_cookie_t; + +#define XCB_GET_GEOMETRY 14 + +typedef struct xcb_get_geometry_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_drawable_t drawable; +} xcb_get_geometry_request_t; + +typedef struct xcb_get_geometry_reply_t { + uint8_t response_type; + uint8_t depth; + uint16_t sequence; + uint32_t length; + xcb_window_t root; + int16_t x; + int16_t y; + uint16_t width; + uint16_t height; + uint16_t border_width; + uint8_t pad0[2]; +} xcb_get_geometry_reply_t; + +typedef struct xcb_query_tree_cookie_t { + unsigned int sequence; +} xcb_query_tree_cookie_t; + +#define XCB_QUERY_TREE 15 + +typedef struct xcb_query_tree_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; +} xcb_query_tree_request_t; + +typedef struct xcb_query_tree_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_window_t root; + xcb_window_t parent; + uint16_t children_len; + uint8_t pad1[14]; +} xcb_query_tree_reply_t; + +typedef struct xcb_intern_atom_cookie_t { + unsigned int sequence; +} xcb_intern_atom_cookie_t; + +#define XCB_INTERN_ATOM 16 + +typedef struct xcb_intern_atom_request_t { + uint8_t major_opcode; + uint8_t only_if_exists; + uint16_t length; + uint16_t name_len; + uint8_t pad0[2]; +} xcb_intern_atom_request_t; + +typedef struct xcb_intern_atom_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_atom_t atom; +} xcb_intern_atom_reply_t; + +typedef struct xcb_get_atom_name_cookie_t { + unsigned int sequence; +} xcb_get_atom_name_cookie_t; + +#define XCB_GET_ATOM_NAME 17 + +typedef struct xcb_get_atom_name_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_atom_t atom; +} xcb_get_atom_name_request_t; + +typedef struct xcb_get_atom_name_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t name_len; + uint8_t pad1[22]; +} xcb_get_atom_name_reply_t; + +typedef enum xcb_prop_mode_t { + XCB_PROP_MODE_REPLACE = 0, + XCB_PROP_MODE_PREPEND = 1, + XCB_PROP_MODE_APPEND = 2 +} xcb_prop_mode_t; + +#define XCB_CHANGE_PROPERTY 18 + +typedef struct xcb_change_property_request_t { + uint8_t major_opcode; + uint8_t mode; + uint16_t length; + xcb_window_t window; + xcb_atom_t property; + xcb_atom_t type; + uint8_t format; + uint8_t pad0[3]; + uint32_t data_len; +} xcb_change_property_request_t; + +#define XCB_DELETE_PROPERTY 19 + +typedef struct xcb_delete_property_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; + xcb_atom_t property; +} xcb_delete_property_request_t; + +typedef enum xcb_get_property_type_t { + XCB_GET_PROPERTY_TYPE_ANY = 0 +} xcb_get_property_type_t; + +typedef struct xcb_get_property_cookie_t { + unsigned int sequence; +} xcb_get_property_cookie_t; + +#define XCB_GET_PROPERTY 20 + +typedef struct xcb_get_property_request_t { + uint8_t major_opcode; + uint8_t _delete; + uint16_t length; + xcb_window_t window; + xcb_atom_t property; + xcb_atom_t type; + uint32_t long_offset; + uint32_t long_length; +} xcb_get_property_request_t; + +typedef struct xcb_get_property_reply_t { + uint8_t response_type; + uint8_t format; + uint16_t sequence; + uint32_t length; + xcb_atom_t type; + uint32_t bytes_after; + uint32_t value_len; + uint8_t pad0[12]; +} xcb_get_property_reply_t; + +typedef struct xcb_list_properties_cookie_t { + unsigned int sequence; +} xcb_list_properties_cookie_t; + +#define XCB_LIST_PROPERTIES 21 + +typedef struct xcb_list_properties_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; +} xcb_list_properties_request_t; + +typedef struct xcb_list_properties_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t atoms_len; + uint8_t pad1[22]; +} xcb_list_properties_reply_t; + +#define XCB_SET_SELECTION_OWNER 22 + +typedef struct xcb_set_selection_owner_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t owner; + xcb_atom_t selection; + xcb_timestamp_t time; +} xcb_set_selection_owner_request_t; + +typedef struct xcb_get_selection_owner_cookie_t { + unsigned int sequence; +} xcb_get_selection_owner_cookie_t; + +#define XCB_GET_SELECTION_OWNER 23 + +typedef struct xcb_get_selection_owner_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_atom_t selection; +} xcb_get_selection_owner_request_t; + +typedef struct xcb_get_selection_owner_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_window_t owner; +} xcb_get_selection_owner_reply_t; + +#define XCB_CONVERT_SELECTION 24 + +typedef struct xcb_convert_selection_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t requestor; + xcb_atom_t selection; + xcb_atom_t target; + xcb_atom_t property; + xcb_timestamp_t time; +} xcb_convert_selection_request_t; + +typedef enum xcb_send_event_dest_t { + XCB_SEND_EVENT_DEST_POINTER_WINDOW = 0, + XCB_SEND_EVENT_DEST_ITEM_FOCUS = 1 +} xcb_send_event_dest_t; + +#define XCB_SEND_EVENT 25 + +typedef struct xcb_send_event_request_t { + uint8_t major_opcode; + uint8_t propagate; + uint16_t length; + xcb_window_t destination; + uint32_t event_mask; + char event[32]; +} xcb_send_event_request_t; + +typedef enum xcb_grab_mode_t { + XCB_GRAB_MODE_SYNC = 0, + XCB_GRAB_MODE_ASYNC = 1 +} xcb_grab_mode_t; + +typedef enum xcb_grab_status_t { + XCB_GRAB_STATUS_SUCCESS = 0, + XCB_GRAB_STATUS_ALREADY_GRABBED = 1, + XCB_GRAB_STATUS_INVALID_TIME = 2, + XCB_GRAB_STATUS_NOT_VIEWABLE = 3, + XCB_GRAB_STATUS_FROZEN = 4 +} xcb_grab_status_t; + +typedef enum xcb_cursor_enum_t { + XCB_CURSOR_NONE = 0 +} xcb_cursor_enum_t; + +typedef struct xcb_grab_pointer_cookie_t { + unsigned int sequence; +} xcb_grab_pointer_cookie_t; + +#define XCB_GRAB_POINTER 26 + +typedef struct xcb_grab_pointer_request_t { + uint8_t major_opcode; + uint8_t owner_events; + uint16_t length; + xcb_window_t grab_window; + uint16_t event_mask; + uint8_t pointer_mode; + uint8_t keyboard_mode; + xcb_window_t confine_to; + xcb_cursor_t cursor; + xcb_timestamp_t time; +} xcb_grab_pointer_request_t; + +typedef struct xcb_grab_pointer_reply_t { + uint8_t response_type; + uint8_t status; + uint16_t sequence; + uint32_t length; +} xcb_grab_pointer_reply_t; + +#define XCB_UNGRAB_POINTER 27 + +typedef struct xcb_ungrab_pointer_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_timestamp_t time; +} xcb_ungrab_pointer_request_t; + +typedef enum xcb_button_index_t { + XCB_BUTTON_INDEX_ANY = 0, + XCB_BUTTON_INDEX_1 = 1, + XCB_BUTTON_INDEX_2 = 2, + XCB_BUTTON_INDEX_3 = 3, + XCB_BUTTON_INDEX_4 = 4, + XCB_BUTTON_INDEX_5 = 5 +} xcb_button_index_t; + +#define XCB_GRAB_BUTTON 28 + +typedef struct xcb_grab_button_request_t { + uint8_t major_opcode; + uint8_t owner_events; + uint16_t length; + xcb_window_t grab_window; + uint16_t event_mask; + uint8_t pointer_mode; + uint8_t keyboard_mode; + xcb_window_t confine_to; + xcb_cursor_t cursor; + uint8_t button; + uint8_t pad0; + uint16_t modifiers; +} xcb_grab_button_request_t; + +#define XCB_UNGRAB_BUTTON 29 + +typedef struct xcb_ungrab_button_request_t { + uint8_t major_opcode; + uint8_t button; + uint16_t length; + xcb_window_t grab_window; + uint16_t modifiers; + uint8_t pad0[2]; +} xcb_ungrab_button_request_t; + +#define XCB_CHANGE_ACTIVE_POINTER_GRAB 30 + +typedef struct xcb_change_active_pointer_grab_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_cursor_t cursor; + xcb_timestamp_t time; + uint16_t event_mask; + uint8_t pad1[2]; +} xcb_change_active_pointer_grab_request_t; + +typedef struct xcb_grab_keyboard_cookie_t { + unsigned int sequence; +} xcb_grab_keyboard_cookie_t; + +#define XCB_GRAB_KEYBOARD 31 + +typedef struct xcb_grab_keyboard_request_t { + uint8_t major_opcode; + uint8_t owner_events; + uint16_t length; + xcb_window_t grab_window; + xcb_timestamp_t time; + uint8_t pointer_mode; + uint8_t keyboard_mode; + uint8_t pad0[2]; +} xcb_grab_keyboard_request_t; + +typedef struct xcb_grab_keyboard_reply_t { + uint8_t response_type; + uint8_t status; + uint16_t sequence; + uint32_t length; +} xcb_grab_keyboard_reply_t; + +#define XCB_UNGRAB_KEYBOARD 32 + +typedef struct xcb_ungrab_keyboard_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_timestamp_t time; +} xcb_ungrab_keyboard_request_t; + +typedef enum xcb_grab_t { + XCB_GRAB_ANY = 0 +} xcb_grab_t; + +#define XCB_GRAB_KEY 33 + +typedef struct xcb_grab_key_request_t { + uint8_t major_opcode; + uint8_t owner_events; + uint16_t length; + xcb_window_t grab_window; + uint16_t modifiers; + xcb_keycode_t key; + uint8_t pointer_mode; + uint8_t keyboard_mode; + uint8_t pad0[3]; +} xcb_grab_key_request_t; + +#define XCB_UNGRAB_KEY 34 + +typedef struct xcb_ungrab_key_request_t { + uint8_t major_opcode; + xcb_keycode_t key; + uint16_t length; + xcb_window_t grab_window; + uint16_t modifiers; + uint8_t pad0[2]; +} xcb_ungrab_key_request_t; + +typedef enum xcb_allow_t { + XCB_ALLOW_ASYNC_POINTER = 0, + XCB_ALLOW_SYNC_POINTER = 1, + XCB_ALLOW_REPLAY_POINTER = 2, + XCB_ALLOW_ASYNC_KEYBOARD = 3, + XCB_ALLOW_SYNC_KEYBOARD = 4, + XCB_ALLOW_REPLAY_KEYBOARD = 5, + XCB_ALLOW_ASYNC_BOTH = 6, + XCB_ALLOW_SYNC_BOTH = 7 +} xcb_allow_t; + +#define XCB_ALLOW_EVENTS 35 + +typedef struct xcb_allow_events_request_t { + uint8_t major_opcode; + uint8_t mode; + uint16_t length; + xcb_timestamp_t time; +} xcb_allow_events_request_t; + +#define XCB_GRAB_SERVER 36 + +typedef struct xcb_grab_server_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; +} xcb_grab_server_request_t; + +#define XCB_UNGRAB_SERVER 37 + +typedef struct xcb_ungrab_server_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; +} xcb_ungrab_server_request_t; + +typedef struct xcb_query_pointer_cookie_t { + unsigned int sequence; +} xcb_query_pointer_cookie_t; + +#define XCB_QUERY_POINTER 38 + +typedef struct xcb_query_pointer_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; +} xcb_query_pointer_request_t; + +typedef struct xcb_query_pointer_reply_t { + uint8_t response_type; + uint8_t same_screen; + uint16_t sequence; + uint32_t length; + xcb_window_t root; + xcb_window_t child; + int16_t root_x; + int16_t root_y; + int16_t win_x; + int16_t win_y; + uint16_t mask; + uint8_t pad0[2]; +} xcb_query_pointer_reply_t; + +typedef struct xcb_timecoord_t { + xcb_timestamp_t time; + int16_t x; + int16_t y; +} xcb_timecoord_t; + +typedef struct xcb_timecoord_iterator_t { + xcb_timecoord_t *data; + int rem; + int index; +} xcb_timecoord_iterator_t; + +typedef struct xcb_get_motion_events_cookie_t { + unsigned int sequence; +} xcb_get_motion_events_cookie_t; + +#define XCB_GET_MOTION_EVENTS 39 + +typedef struct xcb_get_motion_events_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; + xcb_timestamp_t start; + xcb_timestamp_t stop; +} xcb_get_motion_events_request_t; + +typedef struct xcb_get_motion_events_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t events_len; + uint8_t pad1[20]; +} xcb_get_motion_events_reply_t; + +typedef struct xcb_translate_coordinates_cookie_t { + unsigned int sequence; +} xcb_translate_coordinates_cookie_t; + +#define XCB_TRANSLATE_COORDINATES 40 + +typedef struct xcb_translate_coordinates_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t src_window; + xcb_window_t dst_window; + int16_t src_x; + int16_t src_y; +} xcb_translate_coordinates_request_t; + +typedef struct xcb_translate_coordinates_reply_t { + uint8_t response_type; + uint8_t same_screen; + uint16_t sequence; + uint32_t length; + xcb_window_t child; + int16_t dst_x; + int16_t dst_y; +} xcb_translate_coordinates_reply_t; + +#define XCB_WARP_POINTER 41 + +typedef struct xcb_warp_pointer_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t src_window; + xcb_window_t dst_window; + int16_t src_x; + int16_t src_y; + uint16_t src_width; + uint16_t src_height; + int16_t dst_x; + int16_t dst_y; +} xcb_warp_pointer_request_t; + +typedef enum xcb_input_focus_t { + XCB_INPUT_FOCUS_NONE = 0, + XCB_INPUT_FOCUS_POINTER_ROOT = 1, + XCB_INPUT_FOCUS_PARENT = 2, + XCB_INPUT_FOCUS_FOLLOW_KEYBOARD = 3 +} xcb_input_focus_t; + +#define XCB_SET_INPUT_FOCUS 42 + +typedef struct xcb_set_input_focus_request_t { + uint8_t major_opcode; + uint8_t revert_to; + uint16_t length; + xcb_window_t focus; + xcb_timestamp_t time; +} xcb_set_input_focus_request_t; + +typedef struct xcb_get_input_focus_cookie_t { + unsigned int sequence; +} xcb_get_input_focus_cookie_t; + +#define XCB_GET_INPUT_FOCUS 43 + +typedef struct xcb_get_input_focus_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; +} xcb_get_input_focus_request_t; + +typedef struct xcb_get_input_focus_reply_t { + uint8_t response_type; + uint8_t revert_to; + uint16_t sequence; + uint32_t length; + xcb_window_t focus; +} xcb_get_input_focus_reply_t; + +typedef struct xcb_query_keymap_cookie_t { + unsigned int sequence; +} xcb_query_keymap_cookie_t; + +#define XCB_QUERY_KEYMAP 44 + +typedef struct xcb_query_keymap_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; +} xcb_query_keymap_request_t; + +typedef struct xcb_query_keymap_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t keys[32]; +} xcb_query_keymap_reply_t; + +#define XCB_OPEN_FONT 45 + +typedef struct xcb_open_font_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_font_t fid; + uint16_t name_len; + uint8_t pad1[2]; +} xcb_open_font_request_t; + +#define XCB_CLOSE_FONT 46 + +typedef struct xcb_close_font_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_font_t font; +} xcb_close_font_request_t; + +typedef enum xcb_font_draw_t { + XCB_FONT_DRAW_LEFT_TO_RIGHT = 0, + XCB_FONT_DRAW_RIGHT_TO_LEFT = 1 +} xcb_font_draw_t; + +typedef struct xcb_fontprop_t { + xcb_atom_t name; + uint32_t value; +} xcb_fontprop_t; + +typedef struct xcb_fontprop_iterator_t { + xcb_fontprop_t *data; + int rem; + int index; +} xcb_fontprop_iterator_t; + +typedef struct xcb_charinfo_t { + int16_t left_side_bearing; + int16_t right_side_bearing; + int16_t character_width; + int16_t ascent; + int16_t descent; + uint16_t attributes; +} xcb_charinfo_t; + +typedef struct xcb_charinfo_iterator_t { + xcb_charinfo_t *data; + int rem; + int index; +} xcb_charinfo_iterator_t; + +typedef struct xcb_query_font_cookie_t { + unsigned int sequence; +} xcb_query_font_cookie_t; + +#define XCB_QUERY_FONT 47 + +typedef struct xcb_query_font_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_fontable_t font; +} xcb_query_font_request_t; + +typedef struct xcb_query_font_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + xcb_charinfo_t min_bounds; + uint8_t pad1[4]; + xcb_charinfo_t max_bounds; + uint8_t pad2[4]; + uint16_t min_char_or_byte2; + uint16_t max_char_or_byte2; + uint16_t default_char; + uint16_t properties_len; + uint8_t draw_direction; + uint8_t min_byte1; + uint8_t max_byte1; + uint8_t all_chars_exist; + int16_t font_ascent; + int16_t font_descent; + uint32_t char_infos_len; +} xcb_query_font_reply_t; + +typedef struct xcb_query_text_extents_cookie_t { + unsigned int sequence; +} xcb_query_text_extents_cookie_t; + +#define XCB_QUERY_TEXT_EXTENTS 48 + +typedef struct xcb_query_text_extents_request_t { + uint8_t major_opcode; + uint8_t odd_length; + uint16_t length; + xcb_fontable_t font; +} xcb_query_text_extents_request_t; + +typedef struct xcb_query_text_extents_reply_t { + uint8_t response_type; + uint8_t draw_direction; + uint16_t sequence; + uint32_t length; + int16_t font_ascent; + int16_t font_descent; + int16_t overall_ascent; + int16_t overall_descent; + int32_t overall_width; + int32_t overall_left; + int32_t overall_right; +} xcb_query_text_extents_reply_t; + +typedef struct xcb_str_t { + uint8_t name_len; +} xcb_str_t; + +typedef struct xcb_str_iterator_t { + xcb_str_t *data; + int rem; + int index; +} xcb_str_iterator_t; + +typedef struct xcb_list_fonts_cookie_t { + unsigned int sequence; +} xcb_list_fonts_cookie_t; + +#define XCB_LIST_FONTS 49 + +typedef struct xcb_list_fonts_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + uint16_t max_names; + uint16_t pattern_len; +} xcb_list_fonts_request_t; + +typedef struct xcb_list_fonts_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t names_len; + uint8_t pad1[22]; +} xcb_list_fonts_reply_t; + +typedef struct xcb_list_fonts_with_info_cookie_t { + unsigned int sequence; +} xcb_list_fonts_with_info_cookie_t; + +#define XCB_LIST_FONTS_WITH_INFO 50 + +typedef struct xcb_list_fonts_with_info_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + uint16_t max_names; + uint16_t pattern_len; +} xcb_list_fonts_with_info_request_t; + +typedef struct xcb_list_fonts_with_info_reply_t { + uint8_t response_type; + uint8_t name_len; + uint16_t sequence; + uint32_t length; + xcb_charinfo_t min_bounds; + uint8_t pad0[4]; + xcb_charinfo_t max_bounds; + uint8_t pad1[4]; + uint16_t min_char_or_byte2; + uint16_t max_char_or_byte2; + uint16_t default_char; + uint16_t properties_len; + uint8_t draw_direction; + uint8_t min_byte1; + uint8_t max_byte1; + uint8_t all_chars_exist; + int16_t font_ascent; + int16_t font_descent; + uint32_t replies_hint; +} xcb_list_fonts_with_info_reply_t; + +#define XCB_SET_FONT_PATH 51 + +typedef struct xcb_set_font_path_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + uint16_t font_qty; + uint8_t pad1[2]; +} xcb_set_font_path_request_t; + +typedef struct xcb_get_font_path_cookie_t { + unsigned int sequence; +} xcb_get_font_path_cookie_t; + +#define XCB_GET_FONT_PATH 52 + +typedef struct xcb_get_font_path_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; +} xcb_get_font_path_request_t; + +typedef struct xcb_get_font_path_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t path_len; + uint8_t pad1[22]; +} xcb_get_font_path_reply_t; + +#define XCB_CREATE_PIXMAP 53 + +typedef struct xcb_create_pixmap_request_t { + uint8_t major_opcode; + uint8_t depth; + uint16_t length; + xcb_pixmap_t pid; + xcb_drawable_t drawable; + uint16_t width; + uint16_t height; +} xcb_create_pixmap_request_t; + +#define XCB_FREE_PIXMAP 54 + +typedef struct xcb_free_pixmap_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_pixmap_t pixmap; +} xcb_free_pixmap_request_t; + +typedef enum xcb_gc_t { + XCB_GC_FUNCTION = 1, + XCB_GC_PLANE_MASK = 2, + XCB_GC_FOREGROUND = 4, + XCB_GC_BACKGROUND = 8, + XCB_GC_LINE_WIDTH = 16, + XCB_GC_LINE_STYLE = 32, + XCB_GC_CAP_STYLE = 64, + XCB_GC_JOIN_STYLE = 128, + XCB_GC_FILL_STYLE = 256, + XCB_GC_FILL_RULE = 512, + XCB_GC_TILE = 1024, + XCB_GC_STIPPLE = 2048, + XCB_GC_TILE_STIPPLE_ORIGIN_X = 4096, + XCB_GC_TILE_STIPPLE_ORIGIN_Y = 8192, + XCB_GC_FONT = 16384, + XCB_GC_SUBWINDOW_MODE = 32768, + XCB_GC_GRAPHICS_EXPOSURES = 65536, + XCB_GC_CLIP_ORIGIN_X = 131072, + XCB_GC_CLIP_ORIGIN_Y = 262144, + XCB_GC_CLIP_MASK = 524288, + XCB_GC_DASH_OFFSET = 1048576, + XCB_GC_DASH_LIST = 2097152, + XCB_GC_ARC_MODE = 4194304 +} xcb_gc_t; + +typedef enum xcb_gx_t { + XCB_GX_CLEAR = 0, + XCB_GX_AND = 1, + XCB_GX_AND_REVERSE = 2, + XCB_GX_COPY = 3, + XCB_GX_AND_INVERTED = 4, + XCB_GX_NOOP = 5, + XCB_GX_XOR = 6, + XCB_GX_OR = 7, + XCB_GX_NOR = 8, + XCB_GX_EQUIV = 9, + XCB_GX_INVERT = 10, + XCB_GX_OR_REVERSE = 11, + XCB_GX_COPY_INVERTED = 12, + XCB_GX_OR_INVERTED = 13, + XCB_GX_NAND = 14, + XCB_GX_SET = 15 +} xcb_gx_t; + +typedef enum xcb_line_style_t { + XCB_LINE_STYLE_SOLID = 0, + XCB_LINE_STYLE_ON_OFF_DASH = 1, + XCB_LINE_STYLE_DOUBLE_DASH = 2 +} xcb_line_style_t; + +typedef enum xcb_cap_style_t { + XCB_CAP_STYLE_NOT_LAST = 0, + XCB_CAP_STYLE_BUTT = 1, + XCB_CAP_STYLE_ROUND = 2, + XCB_CAP_STYLE_PROJECTING = 3 +} xcb_cap_style_t; + +typedef enum xcb_join_style_t { + XCB_JOIN_STYLE_MITER = 0, + XCB_JOIN_STYLE_ROUND = 1, + XCB_JOIN_STYLE_BEVEL = 2 +} xcb_join_style_t; + +typedef enum xcb_fill_style_t { + XCB_FILL_STYLE_SOLID = 0, + XCB_FILL_STYLE_TILED = 1, + XCB_FILL_STYLE_STIPPLED = 2, + XCB_FILL_STYLE_OPAQUE_STIPPLED = 3 +} xcb_fill_style_t; + +typedef enum xcb_fill_rule_t { + XCB_FILL_RULE_EVEN_ODD = 0, + XCB_FILL_RULE_WINDING = 1 +} xcb_fill_rule_t; + +typedef enum xcb_subwindow_mode_t { + XCB_SUBWINDOW_MODE_CLIP_BY_CHILDREN = 0, + XCB_SUBWINDOW_MODE_INCLUDE_INFERIORS = 1 +} xcb_subwindow_mode_t; + +typedef enum xcb_arc_mode_t { + XCB_ARC_MODE_CHORD = 0, + XCB_ARC_MODE_PIE_SLICE = 1 +} xcb_arc_mode_t; + +#define XCB_CREATE_GC 55 + +typedef struct xcb_create_gc_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_gcontext_t cid; + xcb_drawable_t drawable; + uint32_t value_mask; +} xcb_create_gc_request_t; + +#define XCB_CHANGE_GC 56 + +typedef struct xcb_change_gc_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_gcontext_t gc; + uint32_t value_mask; +} xcb_change_gc_request_t; + +#define XCB_COPY_GC 57 + +typedef struct xcb_copy_gc_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_gcontext_t src_gc; + xcb_gcontext_t dst_gc; + uint32_t value_mask; +} xcb_copy_gc_request_t; + +#define XCB_SET_DASHES 58 + +typedef struct xcb_set_dashes_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_gcontext_t gc; + uint16_t dash_offset; + uint16_t dashes_len; +} xcb_set_dashes_request_t; + +typedef enum xcb_clip_ordering_t { + XCB_CLIP_ORDERING_UNSORTED = 0, + XCB_CLIP_ORDERING_Y_SORTED = 1, + XCB_CLIP_ORDERING_YX_SORTED = 2, + XCB_CLIP_ORDERING_YX_BANDED = 3 +} xcb_clip_ordering_t; + +#define XCB_SET_CLIP_RECTANGLES 59 + +typedef struct xcb_set_clip_rectangles_request_t { + uint8_t major_opcode; + uint8_t ordering; + uint16_t length; + xcb_gcontext_t gc; + int16_t clip_x_origin; + int16_t clip_y_origin; +} xcb_set_clip_rectangles_request_t; + +#define XCB_FREE_GC 60 + +typedef struct xcb_free_gc_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_gcontext_t gc; +} xcb_free_gc_request_t; + +#define XCB_CLEAR_AREA 61 + +typedef struct xcb_clear_area_request_t { + uint8_t major_opcode; + uint8_t exposures; + uint16_t length; + xcb_window_t window; + int16_t x; + int16_t y; + uint16_t width; + uint16_t height; +} xcb_clear_area_request_t; + +#define XCB_COPY_AREA 62 + +typedef struct xcb_copy_area_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_drawable_t src_drawable; + xcb_drawable_t dst_drawable; + xcb_gcontext_t gc; + int16_t src_x; + int16_t src_y; + int16_t dst_x; + int16_t dst_y; + uint16_t width; + uint16_t height; +} xcb_copy_area_request_t; + +#define XCB_COPY_PLANE 63 + +typedef struct xcb_copy_plane_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_drawable_t src_drawable; + xcb_drawable_t dst_drawable; + xcb_gcontext_t gc; + int16_t src_x; + int16_t src_y; + int16_t dst_x; + int16_t dst_y; + uint16_t width; + uint16_t height; + uint32_t bit_plane; +} xcb_copy_plane_request_t; + +typedef enum xcb_coord_mode_t { + XCB_COORD_MODE_ORIGIN = 0, + XCB_COORD_MODE_PREVIOUS = 1 +} xcb_coord_mode_t; + +#define XCB_POLY_POINT 64 + +typedef struct xcb_poly_point_request_t { + uint8_t major_opcode; + uint8_t coordinate_mode; + uint16_t length; + xcb_drawable_t drawable; + xcb_gcontext_t gc; +} xcb_poly_point_request_t; + +#define XCB_POLY_LINE 65 + +typedef struct xcb_poly_line_request_t { + uint8_t major_opcode; + uint8_t coordinate_mode; + uint16_t length; + xcb_drawable_t drawable; + xcb_gcontext_t gc; +} xcb_poly_line_request_t; + +typedef struct xcb_segment_t { + int16_t x1; + int16_t y1; + int16_t x2; + int16_t y2; +} xcb_segment_t; + +typedef struct xcb_segment_iterator_t { + xcb_segment_t *data; + int rem; + int index; +} xcb_segment_iterator_t; + +#define XCB_POLY_SEGMENT 66 + +typedef struct xcb_poly_segment_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_drawable_t drawable; + xcb_gcontext_t gc; +} xcb_poly_segment_request_t; + +#define XCB_POLY_RECTANGLE 67 + +typedef struct xcb_poly_rectangle_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_drawable_t drawable; + xcb_gcontext_t gc; +} xcb_poly_rectangle_request_t; + +#define XCB_POLY_ARC 68 + +typedef struct xcb_poly_arc_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_drawable_t drawable; + xcb_gcontext_t gc; +} xcb_poly_arc_request_t; + +typedef enum xcb_poly_shape_t { + XCB_POLY_SHAPE_COMPLEX = 0, + XCB_POLY_SHAPE_NONCONVEX = 1, + XCB_POLY_SHAPE_CONVEX = 2 +} xcb_poly_shape_t; + +#define XCB_FILL_POLY 69 + +typedef struct xcb_fill_poly_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_drawable_t drawable; + xcb_gcontext_t gc; + uint8_t shape; + uint8_t coordinate_mode; + uint8_t pad1[2]; +} xcb_fill_poly_request_t; + +#define XCB_POLY_FILL_RECTANGLE 70 + +typedef struct xcb_poly_fill_rectangle_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_drawable_t drawable; + xcb_gcontext_t gc; +} xcb_poly_fill_rectangle_request_t; + +#define XCB_POLY_FILL_ARC 71 + +typedef struct xcb_poly_fill_arc_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_drawable_t drawable; + xcb_gcontext_t gc; +} xcb_poly_fill_arc_request_t; + +typedef enum xcb_image_format_t { + XCB_IMAGE_FORMAT_XY_BITMAP = 0, + XCB_IMAGE_FORMAT_XY_PIXMAP = 1, + XCB_IMAGE_FORMAT_Z_PIXMAP = 2 +} xcb_image_format_t; + +#define XCB_PUT_IMAGE 72 + +typedef struct xcb_put_image_request_t { + uint8_t major_opcode; + uint8_t format; + uint16_t length; + xcb_drawable_t drawable; + xcb_gcontext_t gc; + uint16_t width; + uint16_t height; + int16_t dst_x; + int16_t dst_y; + uint8_t left_pad; + uint8_t depth; + uint8_t pad0[2]; +} xcb_put_image_request_t; + +typedef struct xcb_get_image_cookie_t { + unsigned int sequence; +} xcb_get_image_cookie_t; + +#define XCB_GET_IMAGE 73 + +typedef struct xcb_get_image_request_t { + uint8_t major_opcode; + uint8_t format; + uint16_t length; + xcb_drawable_t drawable; + int16_t x; + int16_t y; + uint16_t width; + uint16_t height; + uint32_t plane_mask; +} xcb_get_image_request_t; + +typedef struct xcb_get_image_reply_t { + uint8_t response_type; + uint8_t depth; + uint16_t sequence; + uint32_t length; + xcb_visualid_t visual; + uint8_t pad0[20]; +} xcb_get_image_reply_t; + +#define XCB_POLY_TEXT_8 74 + +typedef struct xcb_poly_text_8_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_drawable_t drawable; + xcb_gcontext_t gc; + int16_t x; + int16_t y; +} xcb_poly_text_8_request_t; + +#define XCB_POLY_TEXT_16 75 + +typedef struct xcb_poly_text_16_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_drawable_t drawable; + xcb_gcontext_t gc; + int16_t x; + int16_t y; +} xcb_poly_text_16_request_t; + +#define XCB_IMAGE_TEXT_8 76 + +typedef struct xcb_image_text_8_request_t { + uint8_t major_opcode; + uint8_t string_len; + uint16_t length; + xcb_drawable_t drawable; + xcb_gcontext_t gc; + int16_t x; + int16_t y; +} xcb_image_text_8_request_t; + +#define XCB_IMAGE_TEXT_16 77 + +typedef struct xcb_image_text_16_request_t { + uint8_t major_opcode; + uint8_t string_len; + uint16_t length; + xcb_drawable_t drawable; + xcb_gcontext_t gc; + int16_t x; + int16_t y; +} xcb_image_text_16_request_t; + +typedef enum xcb_colormap_alloc_t { + XCB_COLORMAP_ALLOC_NONE = 0, + XCB_COLORMAP_ALLOC_ALL = 1 +} xcb_colormap_alloc_t; + +#define XCB_CREATE_COLORMAP 78 + +typedef struct xcb_create_colormap_request_t { + uint8_t major_opcode; + uint8_t alloc; + uint16_t length; + xcb_colormap_t mid; + xcb_window_t window; + xcb_visualid_t visual; +} xcb_create_colormap_request_t; + +#define XCB_FREE_COLORMAP 79 + +typedef struct xcb_free_colormap_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_colormap_t cmap; +} xcb_free_colormap_request_t; + +#define XCB_COPY_COLORMAP_AND_FREE 80 + +typedef struct xcb_copy_colormap_and_free_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_colormap_t mid; + xcb_colormap_t src_cmap; +} xcb_copy_colormap_and_free_request_t; + +#define XCB_INSTALL_COLORMAP 81 + +typedef struct xcb_install_colormap_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_colormap_t cmap; +} xcb_install_colormap_request_t; + +#define XCB_UNINSTALL_COLORMAP 82 + +typedef struct xcb_uninstall_colormap_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_colormap_t cmap; +} xcb_uninstall_colormap_request_t; + +typedef struct xcb_list_installed_colormaps_cookie_t { + unsigned int sequence; +} xcb_list_installed_colormaps_cookie_t; + +#define XCB_LIST_INSTALLED_COLORMAPS 83 + +typedef struct xcb_list_installed_colormaps_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; +} xcb_list_installed_colormaps_request_t; + +typedef struct xcb_list_installed_colormaps_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t cmaps_len; + uint8_t pad1[22]; +} xcb_list_installed_colormaps_reply_t; + +typedef struct xcb_alloc_color_cookie_t { + unsigned int sequence; +} xcb_alloc_color_cookie_t; + +#define XCB_ALLOC_COLOR 84 + +typedef struct xcb_alloc_color_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_colormap_t cmap; + uint16_t red; + uint16_t green; + uint16_t blue; + uint8_t pad1[2]; +} xcb_alloc_color_request_t; + +typedef struct xcb_alloc_color_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t red; + uint16_t green; + uint16_t blue; + uint8_t pad1[2]; + uint32_t pixel; +} xcb_alloc_color_reply_t; + +typedef struct xcb_alloc_named_color_cookie_t { + unsigned int sequence; +} xcb_alloc_named_color_cookie_t; + +#define XCB_ALLOC_NAMED_COLOR 85 + +typedef struct xcb_alloc_named_color_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_colormap_t cmap; + uint16_t name_len; + uint8_t pad1[2]; +} xcb_alloc_named_color_request_t; + +typedef struct xcb_alloc_named_color_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint32_t pixel; + uint16_t exact_red; + uint16_t exact_green; + uint16_t exact_blue; + uint16_t visual_red; + uint16_t visual_green; + uint16_t visual_blue; +} xcb_alloc_named_color_reply_t; + +typedef struct xcb_alloc_color_cells_cookie_t { + unsigned int sequence; +} xcb_alloc_color_cells_cookie_t; + +#define XCB_ALLOC_COLOR_CELLS 86 + +typedef struct xcb_alloc_color_cells_request_t { + uint8_t major_opcode; + uint8_t contiguous; + uint16_t length; + xcb_colormap_t cmap; + uint16_t colors; + uint16_t planes; +} xcb_alloc_color_cells_request_t; + +typedef struct xcb_alloc_color_cells_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t pixels_len; + uint16_t masks_len; + uint8_t pad1[20]; +} xcb_alloc_color_cells_reply_t; + +typedef struct xcb_alloc_color_planes_cookie_t { + unsigned int sequence; +} xcb_alloc_color_planes_cookie_t; + +#define XCB_ALLOC_COLOR_PLANES 87 + +typedef struct xcb_alloc_color_planes_request_t { + uint8_t major_opcode; + uint8_t contiguous; + uint16_t length; + xcb_colormap_t cmap; + uint16_t colors; + uint16_t reds; + uint16_t greens; + uint16_t blues; +} xcb_alloc_color_planes_request_t; + +typedef struct xcb_alloc_color_planes_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t pixels_len; + uint8_t pad1[2]; + uint32_t red_mask; + uint32_t green_mask; + uint32_t blue_mask; + uint8_t pad2[8]; +} xcb_alloc_color_planes_reply_t; + +#define XCB_FREE_COLORS 88 + +typedef struct xcb_free_colors_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_colormap_t cmap; + uint32_t plane_mask; +} xcb_free_colors_request_t; + +typedef enum xcb_color_flag_t { + XCB_COLOR_FLAG_RED = 1, + XCB_COLOR_FLAG_GREEN = 2, + XCB_COLOR_FLAG_BLUE = 4 +} xcb_color_flag_t; + +typedef struct xcb_coloritem_t { + uint32_t pixel; + uint16_t red; + uint16_t green; + uint16_t blue; + uint8_t flags; + uint8_t pad0; +} xcb_coloritem_t; + +typedef struct xcb_coloritem_iterator_t { + xcb_coloritem_t *data; + int rem; + int index; +} xcb_coloritem_iterator_t; + +#define XCB_STORE_COLORS 89 + +typedef struct xcb_store_colors_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_colormap_t cmap; +} xcb_store_colors_request_t; + +#define XCB_STORE_NAMED_COLOR 90 + +typedef struct xcb_store_named_color_request_t { + uint8_t major_opcode; + uint8_t flags; + uint16_t length; + xcb_colormap_t cmap; + uint32_t pixel; + uint16_t name_len; + uint8_t pad0[2]; +} xcb_store_named_color_request_t; + +typedef struct xcb_rgb_t { + uint16_t red; + uint16_t green; + uint16_t blue; + uint8_t pad0[2]; +} xcb_rgb_t; + +typedef struct xcb_rgb_iterator_t { + xcb_rgb_t *data; + int rem; + int index; +} xcb_rgb_iterator_t; + +typedef struct xcb_query_colors_cookie_t { + unsigned int sequence; +} xcb_query_colors_cookie_t; + +#define XCB_QUERY_COLORS 91 + +typedef struct xcb_query_colors_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_colormap_t cmap; +} xcb_query_colors_request_t; + +typedef struct xcb_query_colors_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t colors_len; + uint8_t pad1[22]; +} xcb_query_colors_reply_t; + +typedef struct xcb_lookup_color_cookie_t { + unsigned int sequence; +} xcb_lookup_color_cookie_t; + +#define XCB_LOOKUP_COLOR 92 + +typedef struct xcb_lookup_color_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_colormap_t cmap; + uint16_t name_len; + uint8_t pad1[2]; +} xcb_lookup_color_request_t; + +typedef struct xcb_lookup_color_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t exact_red; + uint16_t exact_green; + uint16_t exact_blue; + uint16_t visual_red; + uint16_t visual_green; + uint16_t visual_blue; +} xcb_lookup_color_reply_t; + +typedef enum xcb_pixmap_enum_t { + XCB_PIXMAP_NONE = 0 +} xcb_pixmap_enum_t; + +#define XCB_CREATE_CURSOR 93 + +typedef struct xcb_create_cursor_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_cursor_t cid; + xcb_pixmap_t source; + xcb_pixmap_t mask; + uint16_t fore_red; + uint16_t fore_green; + uint16_t fore_blue; + uint16_t back_red; + uint16_t back_green; + uint16_t back_blue; + uint16_t x; + uint16_t y; +} xcb_create_cursor_request_t; + +typedef enum xcb_font_enum_t { + XCB_FONT_NONE = 0 +} xcb_font_enum_t; + +#define XCB_CREATE_GLYPH_CURSOR 94 + +typedef struct xcb_create_glyph_cursor_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_cursor_t cid; + xcb_font_t source_font; + xcb_font_t mask_font; + uint16_t source_char; + uint16_t mask_char; + uint16_t fore_red; + uint16_t fore_green; + uint16_t fore_blue; + uint16_t back_red; + uint16_t back_green; + uint16_t back_blue; +} xcb_create_glyph_cursor_request_t; + +#define XCB_FREE_CURSOR 95 + +typedef struct xcb_free_cursor_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_cursor_t cursor; +} xcb_free_cursor_request_t; + +#define XCB_RECOLOR_CURSOR 96 + +typedef struct xcb_recolor_cursor_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_cursor_t cursor; + uint16_t fore_red; + uint16_t fore_green; + uint16_t fore_blue; + uint16_t back_red; + uint16_t back_green; + uint16_t back_blue; +} xcb_recolor_cursor_request_t; + +typedef enum xcb_query_shape_of_t { + XCB_QUERY_SHAPE_OF_LARGEST_CURSOR = 0, + XCB_QUERY_SHAPE_OF_FASTEST_TILE = 1, + XCB_QUERY_SHAPE_OF_FASTEST_STIPPLE = 2 +} xcb_query_shape_of_t; + +typedef struct xcb_query_best_size_cookie_t { + unsigned int sequence; +} xcb_query_best_size_cookie_t; + +#define XCB_QUERY_BEST_SIZE 97 + +typedef struct xcb_query_best_size_request_t { + uint8_t major_opcode; + uint8_t _class; + uint16_t length; + xcb_drawable_t drawable; + uint16_t width; + uint16_t height; +} xcb_query_best_size_request_t; + +typedef struct xcb_query_best_size_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t width; + uint16_t height; +} xcb_query_best_size_reply_t; + +typedef struct xcb_query_extension_cookie_t { + unsigned int sequence; +} xcb_query_extension_cookie_t; + +#define XCB_QUERY_EXTENSION 98 + +typedef struct xcb_query_extension_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + uint16_t name_len; + uint8_t pad1[2]; +} xcb_query_extension_request_t; + +typedef struct xcb_query_extension_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint8_t present; + uint8_t major_opcode; + uint8_t first_event; + uint8_t first_error; +} xcb_query_extension_reply_t; + +typedef struct xcb_list_extensions_cookie_t { + unsigned int sequence; +} xcb_list_extensions_cookie_t; + +#define XCB_LIST_EXTENSIONS 99 + +typedef struct xcb_list_extensions_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; +} xcb_list_extensions_request_t; + +typedef struct xcb_list_extensions_reply_t { + uint8_t response_type; + uint8_t names_len; + uint16_t sequence; + uint32_t length; + uint8_t pad0[24]; +} xcb_list_extensions_reply_t; + +#define XCB_CHANGE_KEYBOARD_MAPPING 100 + +typedef struct xcb_change_keyboard_mapping_request_t { + uint8_t major_opcode; + uint8_t keycode_count; + uint16_t length; + xcb_keycode_t first_keycode; + uint8_t keysyms_per_keycode; + uint8_t pad0[2]; +} xcb_change_keyboard_mapping_request_t; + +typedef struct xcb_get_keyboard_mapping_cookie_t { + unsigned int sequence; +} xcb_get_keyboard_mapping_cookie_t; + +#define XCB_GET_KEYBOARD_MAPPING 101 + +typedef struct xcb_get_keyboard_mapping_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_keycode_t first_keycode; + uint8_t count; +} xcb_get_keyboard_mapping_request_t; + +typedef struct xcb_get_keyboard_mapping_reply_t { + uint8_t response_type; + uint8_t keysyms_per_keycode; + uint16_t sequence; + uint32_t length; + uint8_t pad0[24]; +} xcb_get_keyboard_mapping_reply_t; + +typedef enum xcb_kb_t { + XCB_KB_KEY_CLICK_PERCENT = 1, + XCB_KB_BELL_PERCENT = 2, + XCB_KB_BELL_PITCH = 4, + XCB_KB_BELL_DURATION = 8, + XCB_KB_LED = 16, + XCB_KB_LED_MODE = 32, + XCB_KB_KEY = 64, + XCB_KB_AUTO_REPEAT_MODE = 128 +} xcb_kb_t; + +typedef enum xcb_led_mode_t { + XCB_LED_MODE_OFF = 0, + XCB_LED_MODE_ON = 1 +} xcb_led_mode_t; + +typedef enum xcb_auto_repeat_mode_t { + XCB_AUTO_REPEAT_MODE_OFF = 0, + XCB_AUTO_REPEAT_MODE_ON = 1, + XCB_AUTO_REPEAT_MODE_DEFAULT = 2 +} xcb_auto_repeat_mode_t; + +#define XCB_CHANGE_KEYBOARD_CONTROL 102 + +typedef struct xcb_change_keyboard_control_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + uint32_t value_mask; +} xcb_change_keyboard_control_request_t; + +typedef struct xcb_get_keyboard_control_cookie_t { + unsigned int sequence; +} xcb_get_keyboard_control_cookie_t; + +#define XCB_GET_KEYBOARD_CONTROL 103 + +typedef struct xcb_get_keyboard_control_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; +} xcb_get_keyboard_control_request_t; + +typedef struct xcb_get_keyboard_control_reply_t { + uint8_t response_type; + uint8_t global_auto_repeat; + uint16_t sequence; + uint32_t length; + uint32_t led_mask; + uint8_t key_click_percent; + uint8_t bell_percent; + uint16_t bell_pitch; + uint16_t bell_duration; + uint8_t pad0[2]; + uint8_t auto_repeats[32]; +} xcb_get_keyboard_control_reply_t; + +#define XCB_BELL 104 + +typedef struct xcb_bell_request_t { + uint8_t major_opcode; + int8_t percent; + uint16_t length; +} xcb_bell_request_t; + +#define XCB_CHANGE_POINTER_CONTROL 105 + +typedef struct xcb_change_pointer_control_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + int16_t acceleration_numerator; + int16_t acceleration_denominator; + int16_t threshold; + uint8_t do_acceleration; + uint8_t do_threshold; +} xcb_change_pointer_control_request_t; + +typedef struct xcb_get_pointer_control_cookie_t { + unsigned int sequence; +} xcb_get_pointer_control_cookie_t; + +#define XCB_GET_POINTER_CONTROL 106 + +typedef struct xcb_get_pointer_control_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; +} xcb_get_pointer_control_request_t; + +typedef struct xcb_get_pointer_control_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t acceleration_numerator; + uint16_t acceleration_denominator; + uint16_t threshold; + uint8_t pad1[18]; +} xcb_get_pointer_control_reply_t; + +typedef enum xcb_blanking_t { + XCB_BLANKING_NOT_PREFERRED = 0, + XCB_BLANKING_PREFERRED = 1, + XCB_BLANKING_DEFAULT = 2 +} xcb_blanking_t; + +typedef enum xcb_exposures_t { + XCB_EXPOSURES_NOT_ALLOWED = 0, + XCB_EXPOSURES_ALLOWED = 1, + XCB_EXPOSURES_DEFAULT = 2 +} xcb_exposures_t; + +#define XCB_SET_SCREEN_SAVER 107 + +typedef struct xcb_set_screen_saver_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + int16_t timeout; + int16_t interval; + uint8_t prefer_blanking; + uint8_t allow_exposures; +} xcb_set_screen_saver_request_t; + +typedef struct xcb_get_screen_saver_cookie_t { + unsigned int sequence; +} xcb_get_screen_saver_cookie_t; + +#define XCB_GET_SCREEN_SAVER 108 + +typedef struct xcb_get_screen_saver_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; +} xcb_get_screen_saver_request_t; + +typedef struct xcb_get_screen_saver_reply_t { + uint8_t response_type; + uint8_t pad0; + uint16_t sequence; + uint32_t length; + uint16_t timeout; + uint16_t interval; + uint8_t prefer_blanking; + uint8_t allow_exposures; + uint8_t pad1[18]; +} xcb_get_screen_saver_reply_t; + +typedef enum xcb_host_mode_t { + XCB_HOST_MODE_INSERT = 0, + XCB_HOST_MODE_DELETE = 1 +} xcb_host_mode_t; + +typedef enum xcb_family_t { + XCB_FAMILY_INTERNET = 0, + XCB_FAMILY_DECNET = 1, + XCB_FAMILY_CHAOS = 2, + XCB_FAMILY_SERVER_INTERPRETED = 5, + XCB_FAMILY_INTERNET_6 = 6 +} xcb_family_t; + +#define XCB_CHANGE_HOSTS 109 + +typedef struct xcb_change_hosts_request_t { + uint8_t major_opcode; + uint8_t mode; + uint16_t length; + uint8_t family; + uint8_t pad0; + uint16_t address_len; +} xcb_change_hosts_request_t; + +typedef struct xcb_host_t { + uint8_t family; + uint8_t pad0; + uint16_t address_len; +} xcb_host_t; + +typedef struct xcb_host_iterator_t { + xcb_host_t *data; + int rem; + int index; +} xcb_host_iterator_t; + +typedef struct xcb_list_hosts_cookie_t { + unsigned int sequence; +} xcb_list_hosts_cookie_t; + +#define XCB_LIST_HOSTS 110 + +typedef struct xcb_list_hosts_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; +} xcb_list_hosts_request_t; + +typedef struct xcb_list_hosts_reply_t { + uint8_t response_type; + uint8_t mode; + uint16_t sequence; + uint32_t length; + uint16_t hosts_len; + uint8_t pad0[22]; +} xcb_list_hosts_reply_t; + +typedef enum xcb_access_control_t { + XCB_ACCESS_CONTROL_DISABLE = 0, + XCB_ACCESS_CONTROL_ENABLE = 1 +} xcb_access_control_t; + +#define XCB_SET_ACCESS_CONTROL 111 + +typedef struct xcb_set_access_control_request_t { + uint8_t major_opcode; + uint8_t mode; + uint16_t length; +} xcb_set_access_control_request_t; + +typedef enum xcb_close_down_t { + XCB_CLOSE_DOWN_DESTROY_ALL = 0, + XCB_CLOSE_DOWN_RETAIN_PERMANENT = 1, + XCB_CLOSE_DOWN_RETAIN_TEMPORARY = 2 +} xcb_close_down_t; + +#define XCB_SET_CLOSE_DOWN_MODE 112 + +typedef struct xcb_set_close_down_mode_request_t { + uint8_t major_opcode; + uint8_t mode; + uint16_t length; +} xcb_set_close_down_mode_request_t; + +typedef enum xcb_kill_t { + XCB_KILL_ALL_TEMPORARY = 0 +} xcb_kill_t; + +#define XCB_KILL_CLIENT 113 + +typedef struct xcb_kill_client_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + uint32_t resource; +} xcb_kill_client_request_t; + +#define XCB_ROTATE_PROPERTIES 114 + +typedef struct xcb_rotate_properties_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; + xcb_window_t window; + uint16_t atoms_len; + int16_t delta; +} xcb_rotate_properties_request_t; + +typedef enum xcb_screen_saver_t { + XCB_SCREEN_SAVER_RESET = 0, + XCB_SCREEN_SAVER_ACTIVE = 1 +} xcb_screen_saver_t; + +#define XCB_FORCE_SCREEN_SAVER 115 + +typedef struct xcb_force_screen_saver_request_t { + uint8_t major_opcode; + uint8_t mode; + uint16_t length; +} xcb_force_screen_saver_request_t; + +typedef enum xcb_mapping_status_t { + XCB_MAPPING_STATUS_SUCCESS = 0, + XCB_MAPPING_STATUS_BUSY = 1, + XCB_MAPPING_STATUS_FAILURE = 2 +} xcb_mapping_status_t; + +typedef struct xcb_set_pointer_mapping_cookie_t { + unsigned int sequence; +} xcb_set_pointer_mapping_cookie_t; + +#define XCB_SET_POINTER_MAPPING 116 + +typedef struct xcb_set_pointer_mapping_request_t { + uint8_t major_opcode; + uint8_t map_len; + uint16_t length; +} xcb_set_pointer_mapping_request_t; + +typedef struct xcb_set_pointer_mapping_reply_t { + uint8_t response_type; + uint8_t status; + uint16_t sequence; + uint32_t length; +} xcb_set_pointer_mapping_reply_t; + +typedef struct xcb_get_pointer_mapping_cookie_t { + unsigned int sequence; +} xcb_get_pointer_mapping_cookie_t; + +#define XCB_GET_POINTER_MAPPING 117 + +typedef struct xcb_get_pointer_mapping_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; +} xcb_get_pointer_mapping_request_t; + +typedef struct xcb_get_pointer_mapping_reply_t { + uint8_t response_type; + uint8_t map_len; + uint16_t sequence; + uint32_t length; + uint8_t pad0[24]; +} xcb_get_pointer_mapping_reply_t; + +typedef enum xcb_map_index_t { + XCB_MAP_INDEX_SHIFT = 0, + XCB_MAP_INDEX_LOCK = 1, + XCB_MAP_INDEX_CONTROL = 2, + XCB_MAP_INDEX_1 = 3, + XCB_MAP_INDEX_2 = 4, + XCB_MAP_INDEX_3 = 5, + XCB_MAP_INDEX_4 = 6, + XCB_MAP_INDEX_5 = 7 +} xcb_map_index_t; + +typedef struct xcb_set_modifier_mapping_cookie_t { + unsigned int sequence; +} xcb_set_modifier_mapping_cookie_t; + +#define XCB_SET_MODIFIER_MAPPING 118 + +typedef struct xcb_set_modifier_mapping_request_t { + uint8_t major_opcode; + uint8_t keycodes_per_modifier; + uint16_t length; +} xcb_set_modifier_mapping_request_t; + +typedef struct xcb_set_modifier_mapping_reply_t { + uint8_t response_type; + uint8_t status; + uint16_t sequence; + uint32_t length; +} xcb_set_modifier_mapping_reply_t; + +typedef struct xcb_get_modifier_mapping_cookie_t { + unsigned int sequence; +} xcb_get_modifier_mapping_cookie_t; + +#define XCB_GET_MODIFIER_MAPPING 119 + +typedef struct xcb_get_modifier_mapping_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; +} xcb_get_modifier_mapping_request_t; + +typedef struct xcb_get_modifier_mapping_reply_t { + uint8_t response_type; + uint8_t keycodes_per_modifier; + uint16_t sequence; + uint32_t length; + uint8_t pad0[24]; +} xcb_get_modifier_mapping_reply_t; + +#define XCB_NO_OPERATION 127 + +typedef struct xcb_no_operation_request_t { + uint8_t major_opcode; + uint8_t pad0; + uint16_t length; +} xcb_no_operation_request_t; + +void +xcb_char2b_next (xcb_char2b_iterator_t *i ); + +xcb_generic_iterator_t +xcb_char2b_end (xcb_char2b_iterator_t i ); + +void +xcb_window_next (xcb_window_iterator_t *i ); + +xcb_generic_iterator_t +xcb_window_end (xcb_window_iterator_t i ); + +void +xcb_pixmap_next (xcb_pixmap_iterator_t *i ); + +xcb_generic_iterator_t +xcb_pixmap_end (xcb_pixmap_iterator_t i ); + +void +xcb_cursor_next (xcb_cursor_iterator_t *i ); + +xcb_generic_iterator_t +xcb_cursor_end (xcb_cursor_iterator_t i ); + +void +xcb_font_next (xcb_font_iterator_t *i ); + +xcb_generic_iterator_t +xcb_font_end (xcb_font_iterator_t i ); + +void +xcb_gcontext_next (xcb_gcontext_iterator_t *i ); + +xcb_generic_iterator_t +xcb_gcontext_end (xcb_gcontext_iterator_t i ); + +void +xcb_colormap_next (xcb_colormap_iterator_t *i ); + +xcb_generic_iterator_t +xcb_colormap_end (xcb_colormap_iterator_t i ); + +void +xcb_atom_next (xcb_atom_iterator_t *i ); + +xcb_generic_iterator_t +xcb_atom_end (xcb_atom_iterator_t i ); + +void +xcb_drawable_next (xcb_drawable_iterator_t *i ); + +xcb_generic_iterator_t +xcb_drawable_end (xcb_drawable_iterator_t i ); + +void +xcb_fontable_next (xcb_fontable_iterator_t *i ); + +xcb_generic_iterator_t +xcb_fontable_end (xcb_fontable_iterator_t i ); + +void +xcb_visualid_next (xcb_visualid_iterator_t *i ); + +xcb_generic_iterator_t +xcb_visualid_end (xcb_visualid_iterator_t i ); + +void +xcb_timestamp_next (xcb_timestamp_iterator_t *i ); + +xcb_generic_iterator_t +xcb_timestamp_end (xcb_timestamp_iterator_t i ); + +void +xcb_keysym_next (xcb_keysym_iterator_t *i ); + +xcb_generic_iterator_t +xcb_keysym_end (xcb_keysym_iterator_t i ); + +void +xcb_keycode_next (xcb_keycode_iterator_t *i ); + +xcb_generic_iterator_t +xcb_keycode_end (xcb_keycode_iterator_t i ); + +void +xcb_button_next (xcb_button_iterator_t *i ); + +xcb_generic_iterator_t +xcb_button_end (xcb_button_iterator_t i ); + +void +xcb_point_next (xcb_point_iterator_t *i ); + +xcb_generic_iterator_t +xcb_point_end (xcb_point_iterator_t i ); + +void +xcb_rectangle_next (xcb_rectangle_iterator_t *i ); + +xcb_generic_iterator_t +xcb_rectangle_end (xcb_rectangle_iterator_t i ); + +void +xcb_arc_next (xcb_arc_iterator_t *i ); + +xcb_generic_iterator_t +xcb_arc_end (xcb_arc_iterator_t i ); + +void +xcb_format_next (xcb_format_iterator_t *i ); + +xcb_generic_iterator_t +xcb_format_end (xcb_format_iterator_t i ); + +void +xcb_visualtype_next (xcb_visualtype_iterator_t *i ); + +xcb_generic_iterator_t +xcb_visualtype_end (xcb_visualtype_iterator_t i ); + +int +xcb_depth_sizeof (const void *_buffer ); + +xcb_visualtype_t * +xcb_depth_visuals (const xcb_depth_t *R ); + +int +xcb_depth_visuals_length (const xcb_depth_t *R ); + +xcb_visualtype_iterator_t +xcb_depth_visuals_iterator (const xcb_depth_t *R ); + +void +xcb_depth_next (xcb_depth_iterator_t *i ); + +xcb_generic_iterator_t +xcb_depth_end (xcb_depth_iterator_t i ); + +int +xcb_screen_sizeof (const void *_buffer ); + +int +xcb_screen_allowed_depths_length (const xcb_screen_t *R ); + +xcb_depth_iterator_t +xcb_screen_allowed_depths_iterator (const xcb_screen_t *R ); + +void +xcb_screen_next (xcb_screen_iterator_t *i ); + +xcb_generic_iterator_t +xcb_screen_end (xcb_screen_iterator_t i ); + +int +xcb_setup_request_sizeof (const void *_buffer ); + +char * +xcb_setup_request_authorization_protocol_name (const xcb_setup_request_t *R ); + +int +xcb_setup_request_authorization_protocol_name_length (const xcb_setup_request_t *R ); + +xcb_generic_iterator_t +xcb_setup_request_authorization_protocol_name_end (const xcb_setup_request_t *R ); + +char * +xcb_setup_request_authorization_protocol_data (const xcb_setup_request_t *R ); + +int +xcb_setup_request_authorization_protocol_data_length (const xcb_setup_request_t *R ); + +xcb_generic_iterator_t +xcb_setup_request_authorization_protocol_data_end (const xcb_setup_request_t *R ); + +void +xcb_setup_request_next (xcb_setup_request_iterator_t *i ); + +xcb_generic_iterator_t +xcb_setup_request_end (xcb_setup_request_iterator_t i ); + +int +xcb_setup_failed_sizeof (const void *_buffer ); + +char * +xcb_setup_failed_reason (const xcb_setup_failed_t *R ); + +int +xcb_setup_failed_reason_length (const xcb_setup_failed_t *R ); + +xcb_generic_iterator_t +xcb_setup_failed_reason_end (const xcb_setup_failed_t *R ); + +void +xcb_setup_failed_next (xcb_setup_failed_iterator_t *i ); + +xcb_generic_iterator_t +xcb_setup_failed_end (xcb_setup_failed_iterator_t i ); + +int +xcb_setup_authenticate_sizeof (const void *_buffer ); + +char * +xcb_setup_authenticate_reason (const xcb_setup_authenticate_t *R ); + +int +xcb_setup_authenticate_reason_length (const xcb_setup_authenticate_t *R ); + +xcb_generic_iterator_t +xcb_setup_authenticate_reason_end (const xcb_setup_authenticate_t *R ); + +void +xcb_setup_authenticate_next (xcb_setup_authenticate_iterator_t *i ); + +xcb_generic_iterator_t +xcb_setup_authenticate_end (xcb_setup_authenticate_iterator_t i ); + +int +xcb_setup_sizeof (const void *_buffer ); + +char * +xcb_setup_vendor (const xcb_setup_t *R ); + +int +xcb_setup_vendor_length (const xcb_setup_t *R ); + +xcb_generic_iterator_t +xcb_setup_vendor_end (const xcb_setup_t *R ); + +xcb_format_t * +xcb_setup_pixmap_formats (const xcb_setup_t *R ); + +int +xcb_setup_pixmap_formats_length (const xcb_setup_t *R ); + +xcb_format_iterator_t +xcb_setup_pixmap_formats_iterator (const xcb_setup_t *R ); + +int +xcb_setup_roots_length (const xcb_setup_t *R ); + +xcb_screen_iterator_t +xcb_setup_roots_iterator (const xcb_setup_t *R ); + +void +xcb_setup_next (xcb_setup_iterator_t *i ); + +xcb_generic_iterator_t +xcb_setup_end (xcb_setup_iterator_t i ); + +void +xcb_client_message_data_next (xcb_client_message_data_iterator_t *i ); + +xcb_generic_iterator_t +xcb_client_message_data_end (xcb_client_message_data_iterator_t i ); + +int +xcb_create_window_sizeof (const void *_buffer ); + +xcb_void_cookie_t +xcb_create_window_checked (xcb_connection_t *c , + uint8_t depth , + xcb_window_t wid , + xcb_window_t parent , + int16_t x , + int16_t y , + uint16_t width , + uint16_t height , + uint16_t border_width , + uint16_t _class , + xcb_visualid_t visual , + uint32_t value_mask , + const uint32_t *value_list ); + +xcb_void_cookie_t +xcb_create_window (xcb_connection_t *c , + uint8_t depth , + xcb_window_t wid , + xcb_window_t parent , + int16_t x , + int16_t y , + uint16_t width , + uint16_t height , + uint16_t border_width , + uint16_t _class , + xcb_visualid_t visual , + uint32_t value_mask , + const uint32_t *value_list ); + +int +xcb_change_window_attributes_sizeof (const void *_buffer ); + +xcb_void_cookie_t +xcb_change_window_attributes_checked (xcb_connection_t *c , + xcb_window_t window , + uint32_t value_mask , + const uint32_t *value_list ); + +xcb_void_cookie_t +xcb_change_window_attributes (xcb_connection_t *c , + xcb_window_t window , + uint32_t value_mask , + const uint32_t *value_list ); + +xcb_get_window_attributes_cookie_t +xcb_get_window_attributes (xcb_connection_t *c , + xcb_window_t window ); + +xcb_get_window_attributes_cookie_t +xcb_get_window_attributes_unchecked (xcb_connection_t *c , + xcb_window_t window ); + +xcb_get_window_attributes_reply_t * +xcb_get_window_attributes_reply (xcb_connection_t *c , + xcb_get_window_attributes_cookie_t cookie , + xcb_generic_error_t **e ); + +xcb_void_cookie_t +xcb_destroy_window_checked (xcb_connection_t *c , + xcb_window_t window ); + +xcb_void_cookie_t +xcb_destroy_window (xcb_connection_t *c , + xcb_window_t window ); + +xcb_void_cookie_t +xcb_destroy_subwindows_checked (xcb_connection_t *c , + xcb_window_t window ); + +xcb_void_cookie_t +xcb_destroy_subwindows (xcb_connection_t *c , + xcb_window_t window ); + +xcb_void_cookie_t +xcb_change_save_set_checked (xcb_connection_t *c , + uint8_t mode , + xcb_window_t window ); + +xcb_void_cookie_t +xcb_change_save_set (xcb_connection_t *c , + uint8_t mode , + xcb_window_t window ); + +xcb_void_cookie_t +xcb_reparent_window_checked (xcb_connection_t *c , + xcb_window_t window , + xcb_window_t parent , + int16_t x , + int16_t y ); + +xcb_void_cookie_t +xcb_reparent_window (xcb_connection_t *c , + xcb_window_t window , + xcb_window_t parent , + int16_t x , + int16_t y ); + +xcb_void_cookie_t +xcb_map_window_checked (xcb_connection_t *c , + xcb_window_t window ); + +xcb_void_cookie_t +xcb_map_window (xcb_connection_t *c , + xcb_window_t window ); + +xcb_void_cookie_t +xcb_map_subwindows_checked (xcb_connection_t *c , + xcb_window_t window ); + +xcb_void_cookie_t +xcb_map_subwindows (xcb_connection_t *c , + xcb_window_t window ); + +xcb_void_cookie_t +xcb_unmap_window_checked (xcb_connection_t *c , + xcb_window_t window ); + +xcb_void_cookie_t +xcb_unmap_window (xcb_connection_t *c , + xcb_window_t window ); + +xcb_void_cookie_t +xcb_unmap_subwindows_checked (xcb_connection_t *c , + xcb_window_t window ); + +xcb_void_cookie_t +xcb_unmap_subwindows (xcb_connection_t *c , + xcb_window_t window ); + +int +xcb_configure_window_sizeof (const void *_buffer ); + +xcb_void_cookie_t +xcb_configure_window_checked (xcb_connection_t *c , + xcb_window_t window , + uint16_t value_mask , + const uint32_t *value_list ); + +xcb_void_cookie_t +xcb_configure_window (xcb_connection_t *c , + xcb_window_t window , + uint16_t value_mask , + const uint32_t *value_list ); + +xcb_void_cookie_t +xcb_circulate_window_checked (xcb_connection_t *c , + uint8_t direction , + xcb_window_t window ); + +xcb_void_cookie_t +xcb_circulate_window (xcb_connection_t *c , + uint8_t direction , + xcb_window_t window ); + +xcb_get_geometry_cookie_t +xcb_get_geometry (xcb_connection_t *c , + xcb_drawable_t drawable ); + +xcb_get_geometry_cookie_t +xcb_get_geometry_unchecked (xcb_connection_t *c , + xcb_drawable_t drawable ); + +xcb_get_geometry_reply_t * +xcb_get_geometry_reply (xcb_connection_t *c , + xcb_get_geometry_cookie_t cookie , + xcb_generic_error_t **e ); + +int +xcb_query_tree_sizeof (const void *_buffer ); + +xcb_query_tree_cookie_t +xcb_query_tree (xcb_connection_t *c , + xcb_window_t window ); + +xcb_query_tree_cookie_t +xcb_query_tree_unchecked (xcb_connection_t *c , + xcb_window_t window ); + +xcb_window_t * +xcb_query_tree_children (const xcb_query_tree_reply_t *R ); + +int +xcb_query_tree_children_length (const xcb_query_tree_reply_t *R ); + +xcb_generic_iterator_t +xcb_query_tree_children_end (const xcb_query_tree_reply_t *R ); + +xcb_query_tree_reply_t * +xcb_query_tree_reply (xcb_connection_t *c , + xcb_query_tree_cookie_t cookie , + xcb_generic_error_t **e ); + +int +xcb_intern_atom_sizeof (const void *_buffer ); + +xcb_intern_atom_cookie_t +xcb_intern_atom (xcb_connection_t *c , + uint8_t only_if_exists , + uint16_t name_len , + const char *name ); + +xcb_intern_atom_cookie_t +xcb_intern_atom_unchecked (xcb_connection_t *c , + uint8_t only_if_exists , + uint16_t name_len , + const char *name ); + +xcb_intern_atom_reply_t * +xcb_intern_atom_reply (xcb_connection_t *c , + xcb_intern_atom_cookie_t cookie , + xcb_generic_error_t **e ); + +int +xcb_get_atom_name_sizeof (const void *_buffer ); + +xcb_get_atom_name_cookie_t +xcb_get_atom_name (xcb_connection_t *c , + xcb_atom_t atom ); + +xcb_get_atom_name_cookie_t +xcb_get_atom_name_unchecked (xcb_connection_t *c , + xcb_atom_t atom ); + +char * +xcb_get_atom_name_name (const xcb_get_atom_name_reply_t *R ); + +int +xcb_get_atom_name_name_length (const xcb_get_atom_name_reply_t *R ); + +xcb_generic_iterator_t +xcb_get_atom_name_name_end (const xcb_get_atom_name_reply_t *R ); + +xcb_get_atom_name_reply_t * +xcb_get_atom_name_reply (xcb_connection_t *c , + xcb_get_atom_name_cookie_t cookie , + xcb_generic_error_t **e ); + +int +xcb_change_property_sizeof (const void *_buffer ); + +xcb_void_cookie_t +xcb_change_property_checked (xcb_connection_t *c , + uint8_t mode , + xcb_window_t window , + xcb_atom_t property , + xcb_atom_t type , + uint8_t format , + uint32_t data_len , + const void *data ); + +xcb_void_cookie_t +xcb_change_property (xcb_connection_t *c , + uint8_t mode , + xcb_window_t window , + xcb_atom_t property , + xcb_atom_t type , + uint8_t format , + uint32_t data_len , + const void *data ); + +xcb_void_cookie_t +xcb_delete_property_checked (xcb_connection_t *c , + xcb_window_t window , + xcb_atom_t property ); + +xcb_void_cookie_t +xcb_delete_property (xcb_connection_t *c , + xcb_window_t window , + xcb_atom_t property ); + +int +xcb_get_property_sizeof (const void *_buffer ); + +xcb_get_property_cookie_t +xcb_get_property (xcb_connection_t *c , + uint8_t _delete , + xcb_window_t window , + xcb_atom_t property , + xcb_atom_t type , + uint32_t long_offset , + uint32_t long_length ); + +xcb_get_property_cookie_t +xcb_get_property_unchecked (xcb_connection_t *c , + uint8_t _delete , + xcb_window_t window , + xcb_atom_t property , + xcb_atom_t type , + uint32_t long_offset , + uint32_t long_length ); + +void * +xcb_get_property_value (const xcb_get_property_reply_t *R ); + +int +xcb_get_property_value_length (const xcb_get_property_reply_t *R ); + +xcb_generic_iterator_t +xcb_get_property_value_end (const xcb_get_property_reply_t *R ); + +xcb_get_property_reply_t * +xcb_get_property_reply (xcb_connection_t *c , + xcb_get_property_cookie_t cookie , + xcb_generic_error_t **e ); + +int +xcb_list_properties_sizeof (const void *_buffer ); + +xcb_list_properties_cookie_t +xcb_list_properties (xcb_connection_t *c , + xcb_window_t window ); + +xcb_list_properties_cookie_t +xcb_list_properties_unchecked (xcb_connection_t *c , + xcb_window_t window ); + +xcb_atom_t * +xcb_list_properties_atoms (const xcb_list_properties_reply_t *R ); + +int +xcb_list_properties_atoms_length (const xcb_list_properties_reply_t *R ); + +xcb_generic_iterator_t +xcb_list_properties_atoms_end (const xcb_list_properties_reply_t *R ); + +xcb_list_properties_reply_t * +xcb_list_properties_reply (xcb_connection_t *c , + xcb_list_properties_cookie_t cookie , + xcb_generic_error_t **e ); + +xcb_void_cookie_t +xcb_set_selection_owner_checked (xcb_connection_t *c , + xcb_window_t owner , + xcb_atom_t selection , + xcb_timestamp_t time ); + +xcb_void_cookie_t +xcb_set_selection_owner (xcb_connection_t *c , + xcb_window_t owner , + xcb_atom_t selection , + xcb_timestamp_t time ); + +xcb_get_selection_owner_cookie_t +xcb_get_selection_owner (xcb_connection_t *c , + xcb_atom_t selection ); + +xcb_get_selection_owner_cookie_t +xcb_get_selection_owner_unchecked (xcb_connection_t *c , + xcb_atom_t selection ); + +xcb_get_selection_owner_reply_t * +xcb_get_selection_owner_reply (xcb_connection_t *c , + xcb_get_selection_owner_cookie_t cookie , + xcb_generic_error_t **e ); + +xcb_void_cookie_t +xcb_convert_selection_checked (xcb_connection_t *c , + xcb_window_t requestor , + xcb_atom_t selection , + xcb_atom_t target , + xcb_atom_t property , + xcb_timestamp_t time ); + +xcb_void_cookie_t +xcb_convert_selection (xcb_connection_t *c , + xcb_window_t requestor , + xcb_atom_t selection , + xcb_atom_t target , + xcb_atom_t property , + xcb_timestamp_t time ); + +xcb_void_cookie_t +xcb_send_event_checked (xcb_connection_t *c , + uint8_t propagate , + xcb_window_t destination , + uint32_t event_mask , + const char *event ); + +xcb_void_cookie_t +xcb_send_event (xcb_connection_t *c , + uint8_t propagate , + xcb_window_t destination , + uint32_t event_mask , + const char *event ); + +xcb_grab_pointer_cookie_t +xcb_grab_pointer (xcb_connection_t *c , + uint8_t owner_events , + xcb_window_t grab_window , + uint16_t event_mask , + uint8_t pointer_mode , + uint8_t keyboard_mode , + xcb_window_t confine_to , + xcb_cursor_t cursor , + xcb_timestamp_t time ); + +xcb_grab_pointer_cookie_t +xcb_grab_pointer_unchecked (xcb_connection_t *c , + uint8_t owner_events , + xcb_window_t grab_window , + uint16_t event_mask , + uint8_t pointer_mode , + uint8_t keyboard_mode , + xcb_window_t confine_to , + xcb_cursor_t cursor , + xcb_timestamp_t time ); + +xcb_grab_pointer_reply_t * +xcb_grab_pointer_reply (xcb_connection_t *c , + xcb_grab_pointer_cookie_t cookie , + xcb_generic_error_t **e ); + +xcb_void_cookie_t +xcb_ungrab_pointer_checked (xcb_connection_t *c , + xcb_timestamp_t time ); + +xcb_void_cookie_t +xcb_ungrab_pointer (xcb_connection_t *c , + xcb_timestamp_t time ); + +xcb_void_cookie_t +xcb_grab_button_checked (xcb_connection_t *c , + uint8_t owner_events , + xcb_window_t grab_window , + uint16_t event_mask , + uint8_t pointer_mode , + uint8_t keyboard_mode , + xcb_window_t confine_to , + xcb_cursor_t cursor , + uint8_t button , + uint16_t modifiers ); + +xcb_void_cookie_t +xcb_grab_button (xcb_connection_t *c , + uint8_t owner_events , + xcb_window_t grab_window , + uint16_t event_mask , + uint8_t pointer_mode , + uint8_t keyboard_mode , + xcb_window_t confine_to , + xcb_cursor_t cursor , + uint8_t button , + uint16_t modifiers ); + +xcb_void_cookie_t +xcb_ungrab_button_checked (xcb_connection_t *c , + uint8_t button , + xcb_window_t grab_window , + uint16_t modifiers ); + +xcb_void_cookie_t +xcb_ungrab_button (xcb_connection_t *c , + uint8_t button , + xcb_window_t grab_window , + uint16_t modifiers ); + +xcb_void_cookie_t +xcb_change_active_pointer_grab_checked (xcb_connection_t *c , + xcb_cursor_t cursor , + xcb_timestamp_t time , + uint16_t event_mask ); + +xcb_void_cookie_t +xcb_change_active_pointer_grab (xcb_connection_t *c , + xcb_cursor_t cursor , + xcb_timestamp_t time , + uint16_t event_mask ); + +xcb_grab_keyboard_cookie_t +xcb_grab_keyboard (xcb_connection_t *c , + uint8_t owner_events , + xcb_window_t grab_window , + xcb_timestamp_t time , + uint8_t pointer_mode , + uint8_t keyboard_mode ); + +xcb_grab_keyboard_cookie_t +xcb_grab_keyboard_unchecked (xcb_connection_t *c , + uint8_t owner_events , + xcb_window_t grab_window , + xcb_timestamp_t time , + uint8_t pointer_mode , + uint8_t keyboard_mode ); + +xcb_grab_keyboard_reply_t * +xcb_grab_keyboard_reply (xcb_connection_t *c , + xcb_grab_keyboard_cookie_t cookie , + xcb_generic_error_t **e ); + +xcb_void_cookie_t +xcb_ungrab_keyboard_checked (xcb_connection_t *c , + xcb_timestamp_t time ); + +xcb_void_cookie_t +xcb_ungrab_keyboard (xcb_connection_t *c , + xcb_timestamp_t time ); + +xcb_void_cookie_t +xcb_grab_key_checked (xcb_connection_t *c , + uint8_t owner_events , + xcb_window_t grab_window , + uint16_t modifiers , + xcb_keycode_t key , + uint8_t pointer_mode , + uint8_t keyboard_mode ); + +xcb_void_cookie_t +xcb_grab_key (xcb_connection_t *c , + uint8_t owner_events , + xcb_window_t grab_window , + uint16_t modifiers , + xcb_keycode_t key , + uint8_t pointer_mode , + uint8_t keyboard_mode ); + +xcb_void_cookie_t +xcb_ungrab_key_checked (xcb_connection_t *c , + xcb_keycode_t key , + xcb_window_t grab_window , + uint16_t modifiers ); + +xcb_void_cookie_t +xcb_ungrab_key (xcb_connection_t *c , + xcb_keycode_t key , + xcb_window_t grab_window , + uint16_t modifiers ); + +xcb_void_cookie_t +xcb_allow_events_checked (xcb_connection_t *c , + uint8_t mode , + xcb_timestamp_t time ); + +xcb_void_cookie_t +xcb_allow_events (xcb_connection_t *c , + uint8_t mode , + xcb_timestamp_t time ); + +xcb_void_cookie_t +xcb_grab_server_checked (xcb_connection_t *c ); + +xcb_void_cookie_t +xcb_grab_server (xcb_connection_t *c ); + +xcb_void_cookie_t +xcb_ungrab_server_checked (xcb_connection_t *c ); + +xcb_void_cookie_t +xcb_ungrab_server (xcb_connection_t *c ); + +xcb_query_pointer_cookie_t +xcb_query_pointer (xcb_connection_t *c , + xcb_window_t window ); + +xcb_query_pointer_cookie_t +xcb_query_pointer_unchecked (xcb_connection_t *c , + xcb_window_t window ); + +xcb_query_pointer_reply_t * +xcb_query_pointer_reply (xcb_connection_t *c , + xcb_query_pointer_cookie_t cookie , + xcb_generic_error_t **e ); + +void +xcb_timecoord_next (xcb_timecoord_iterator_t *i ); + +xcb_generic_iterator_t +xcb_timecoord_end (xcb_timecoord_iterator_t i ); + +int +xcb_get_motion_events_sizeof (const void *_buffer ); + +xcb_get_motion_events_cookie_t +xcb_get_motion_events (xcb_connection_t *c , + xcb_window_t window , + xcb_timestamp_t start , + xcb_timestamp_t stop ); + +xcb_get_motion_events_cookie_t +xcb_get_motion_events_unchecked (xcb_connection_t *c , + xcb_window_t window , + xcb_timestamp_t start , + xcb_timestamp_t stop ); + +xcb_timecoord_t * +xcb_get_motion_events_events (const xcb_get_motion_events_reply_t *R ); + +int +xcb_get_motion_events_events_length (const xcb_get_motion_events_reply_t *R ); + +xcb_timecoord_iterator_t +xcb_get_motion_events_events_iterator (const xcb_get_motion_events_reply_t *R ); + +xcb_get_motion_events_reply_t * +xcb_get_motion_events_reply (xcb_connection_t *c , + xcb_get_motion_events_cookie_t cookie , + xcb_generic_error_t **e ); + +xcb_translate_coordinates_cookie_t +xcb_translate_coordinates (xcb_connection_t *c , + xcb_window_t src_window , + xcb_window_t dst_window , + int16_t src_x , + int16_t src_y ); + +xcb_translate_coordinates_cookie_t +xcb_translate_coordinates_unchecked (xcb_connection_t *c , + xcb_window_t src_window , + xcb_window_t dst_window , + int16_t src_x , + int16_t src_y ); + +xcb_translate_coordinates_reply_t * +xcb_translate_coordinates_reply (xcb_connection_t *c , + xcb_translate_coordinates_cookie_t cookie , + xcb_generic_error_t **e ); + +xcb_void_cookie_t +xcb_warp_pointer_checked (xcb_connection_t *c , + xcb_window_t src_window , + xcb_window_t dst_window , + int16_t src_x , + int16_t src_y , + uint16_t src_width , + uint16_t src_height , + int16_t dst_x , + int16_t dst_y ); + +xcb_void_cookie_t +xcb_warp_pointer (xcb_connection_t *c , + xcb_window_t src_window , + xcb_window_t dst_window , + int16_t src_x , + int16_t src_y , + uint16_t src_width , + uint16_t src_height , + int16_t dst_x , + int16_t dst_y ); + +xcb_void_cookie_t +xcb_set_input_focus_checked (xcb_connection_t *c , + uint8_t revert_to , + xcb_window_t focus , + xcb_timestamp_t time ); + +xcb_void_cookie_t +xcb_set_input_focus (xcb_connection_t *c , + uint8_t revert_to , + xcb_window_t focus , + xcb_timestamp_t time ); + +xcb_get_input_focus_cookie_t +xcb_get_input_focus (xcb_connection_t *c ); + +xcb_get_input_focus_cookie_t +xcb_get_input_focus_unchecked (xcb_connection_t *c ); + +xcb_get_input_focus_reply_t * +xcb_get_input_focus_reply (xcb_connection_t *c , + xcb_get_input_focus_cookie_t cookie , + xcb_generic_error_t **e ); + +xcb_query_keymap_cookie_t +xcb_query_keymap (xcb_connection_t *c ); + +xcb_query_keymap_cookie_t +xcb_query_keymap_unchecked (xcb_connection_t *c ); + +xcb_query_keymap_reply_t * +xcb_query_keymap_reply (xcb_connection_t *c , + xcb_query_keymap_cookie_t cookie , + xcb_generic_error_t **e ); + +int +xcb_open_font_sizeof (const void *_buffer ); + +xcb_void_cookie_t +xcb_open_font_checked (xcb_connection_t *c , + xcb_font_t fid , + uint16_t name_len , + const char *name ); + +xcb_void_cookie_t +xcb_open_font (xcb_connection_t *c , + xcb_font_t fid , + uint16_t name_len , + const char *name ); + +xcb_void_cookie_t +xcb_close_font_checked (xcb_connection_t *c , + xcb_font_t font ); + +xcb_void_cookie_t +xcb_close_font (xcb_connection_t *c , + xcb_font_t font ); + +void +xcb_fontprop_next (xcb_fontprop_iterator_t *i ); + +xcb_generic_iterator_t +xcb_fontprop_end (xcb_fontprop_iterator_t i ); + +void +xcb_charinfo_next (xcb_charinfo_iterator_t *i ); + +xcb_generic_iterator_t +xcb_charinfo_end (xcb_charinfo_iterator_t i ); + +int +xcb_query_font_sizeof (const void *_buffer ); + +xcb_query_font_cookie_t +xcb_query_font (xcb_connection_t *c , + xcb_fontable_t font ); + +xcb_query_font_cookie_t +xcb_query_font_unchecked (xcb_connection_t *c , + xcb_fontable_t font ); + +xcb_fontprop_t * +xcb_query_font_properties (const xcb_query_font_reply_t *R ); + +int +xcb_query_font_properties_length (const xcb_query_font_reply_t *R ); + +xcb_fontprop_iterator_t +xcb_query_font_properties_iterator (const xcb_query_font_reply_t *R ); + +xcb_charinfo_t * +xcb_query_font_char_infos (const xcb_query_font_reply_t *R ); + +int +xcb_query_font_char_infos_length (const xcb_query_font_reply_t *R ); + +xcb_charinfo_iterator_t +xcb_query_font_char_infos_iterator (const xcb_query_font_reply_t *R ); + +xcb_query_font_reply_t * +xcb_query_font_reply (xcb_connection_t *c , + xcb_query_font_cookie_t cookie , + xcb_generic_error_t **e ); + +int +xcb_query_text_extents_sizeof (const void *_buffer , + uint32_t string_len ); + +xcb_query_text_extents_cookie_t +xcb_query_text_extents (xcb_connection_t *c , + xcb_fontable_t font , + uint32_t string_len , + const xcb_char2b_t *string ); + +xcb_query_text_extents_cookie_t +xcb_query_text_extents_unchecked (xcb_connection_t *c , + xcb_fontable_t font , + uint32_t string_len , + const xcb_char2b_t *string ); + +xcb_query_text_extents_reply_t * +xcb_query_text_extents_reply (xcb_connection_t *c , + xcb_query_text_extents_cookie_t cookie , + xcb_generic_error_t **e ); + +int +xcb_str_sizeof (const void *_buffer ); + +char * +xcb_str_name (const xcb_str_t *R ); + +int +xcb_str_name_length (const xcb_str_t *R ); + +xcb_generic_iterator_t +xcb_str_name_end (const xcb_str_t *R ); + +void +xcb_str_next (xcb_str_iterator_t *i ); + +xcb_generic_iterator_t +xcb_str_end (xcb_str_iterator_t i ); + +int +xcb_list_fonts_sizeof (const void *_buffer ); + +xcb_list_fonts_cookie_t +xcb_list_fonts (xcb_connection_t *c , + uint16_t max_names , + uint16_t pattern_len , + const char *pattern ); + +xcb_list_fonts_cookie_t +xcb_list_fonts_unchecked (xcb_connection_t *c , + uint16_t max_names , + uint16_t pattern_len , + const char *pattern ); + +int +xcb_list_fonts_names_length (const xcb_list_fonts_reply_t *R ); + +xcb_str_iterator_t +xcb_list_fonts_names_iterator (const xcb_list_fonts_reply_t *R ); + +xcb_list_fonts_reply_t * +xcb_list_fonts_reply (xcb_connection_t *c , + xcb_list_fonts_cookie_t cookie , + xcb_generic_error_t **e ); + +int +xcb_list_fonts_with_info_sizeof (const void *_buffer ); + +xcb_list_fonts_with_info_cookie_t +xcb_list_fonts_with_info (xcb_connection_t *c , + uint16_t max_names , + uint16_t pattern_len , + const char *pattern ); + +xcb_list_fonts_with_info_cookie_t +xcb_list_fonts_with_info_unchecked (xcb_connection_t *c , + uint16_t max_names , + uint16_t pattern_len , + const char *pattern ); + +xcb_fontprop_t * +xcb_list_fonts_with_info_properties (const xcb_list_fonts_with_info_reply_t *R ); + +int +xcb_list_fonts_with_info_properties_length (const xcb_list_fonts_with_info_reply_t *R ); + +xcb_fontprop_iterator_t +xcb_list_fonts_with_info_properties_iterator (const xcb_list_fonts_with_info_reply_t *R ); + +char * +xcb_list_fonts_with_info_name (const xcb_list_fonts_with_info_reply_t *R ); + +int +xcb_list_fonts_with_info_name_length (const xcb_list_fonts_with_info_reply_t *R ); + +xcb_generic_iterator_t +xcb_list_fonts_with_info_name_end (const xcb_list_fonts_with_info_reply_t *R ); + +xcb_list_fonts_with_info_reply_t * +xcb_list_fonts_with_info_reply (xcb_connection_t *c , + xcb_list_fonts_with_info_cookie_t cookie , + xcb_generic_error_t **e ); + +int +xcb_set_font_path_sizeof (const void *_buffer ); + +xcb_void_cookie_t +xcb_set_font_path_checked (xcb_connection_t *c , + uint16_t font_qty , + const xcb_str_t *font ); + +xcb_void_cookie_t +xcb_set_font_path (xcb_connection_t *c , + uint16_t font_qty , + const xcb_str_t *font ); + +int +xcb_get_font_path_sizeof (const void *_buffer ); + +xcb_get_font_path_cookie_t +xcb_get_font_path (xcb_connection_t *c ); + +xcb_get_font_path_cookie_t +xcb_get_font_path_unchecked (xcb_connection_t *c ); + +int +xcb_get_font_path_path_length (const xcb_get_font_path_reply_t *R ); + +xcb_str_iterator_t +xcb_get_font_path_path_iterator (const xcb_get_font_path_reply_t *R ); + +xcb_get_font_path_reply_t * +xcb_get_font_path_reply (xcb_connection_t *c , + xcb_get_font_path_cookie_t cookie , + xcb_generic_error_t **e ); + +xcb_void_cookie_t +xcb_create_pixmap_checked (xcb_connection_t *c , + uint8_t depth , + xcb_pixmap_t pid , + xcb_drawable_t drawable , + uint16_t width , + uint16_t height ); + +xcb_void_cookie_t +xcb_create_pixmap (xcb_connection_t *c , + uint8_t depth , + xcb_pixmap_t pid , + xcb_drawable_t drawable , + uint16_t width , + uint16_t height ); + +xcb_void_cookie_t +xcb_free_pixmap_checked (xcb_connection_t *c , + xcb_pixmap_t pixmap ); + +xcb_void_cookie_t +xcb_free_pixmap (xcb_connection_t *c , + xcb_pixmap_t pixmap ); + +int +xcb_create_gc_sizeof (const void *_buffer ); + +xcb_void_cookie_t +xcb_create_gc_checked (xcb_connection_t *c , + xcb_gcontext_t cid , + xcb_drawable_t drawable , + uint32_t value_mask , + const uint32_t *value_list ); + +xcb_void_cookie_t +xcb_create_gc (xcb_connection_t *c , + xcb_gcontext_t cid , + xcb_drawable_t drawable , + uint32_t value_mask , + const uint32_t *value_list ); + +int +xcb_change_gc_sizeof (const void *_buffer ); + +xcb_void_cookie_t +xcb_change_gc_checked (xcb_connection_t *c , + xcb_gcontext_t gc , + uint32_t value_mask , + const uint32_t *value_list ); + +xcb_void_cookie_t +xcb_change_gc (xcb_connection_t *c , + xcb_gcontext_t gc , + uint32_t value_mask , + const uint32_t *value_list ); + +xcb_void_cookie_t +xcb_copy_gc_checked (xcb_connection_t *c , + xcb_gcontext_t src_gc , + xcb_gcontext_t dst_gc , + uint32_t value_mask ); + +xcb_void_cookie_t +xcb_copy_gc (xcb_connection_t *c , + xcb_gcontext_t src_gc , + xcb_gcontext_t dst_gc , + uint32_t value_mask ); + +int +xcb_set_dashes_sizeof (const void *_buffer ); + +xcb_void_cookie_t +xcb_set_dashes_checked (xcb_connection_t *c , + xcb_gcontext_t gc , + uint16_t dash_offset , + uint16_t dashes_len , + const uint8_t *dashes ); + +xcb_void_cookie_t +xcb_set_dashes (xcb_connection_t *c , + xcb_gcontext_t gc , + uint16_t dash_offset , + uint16_t dashes_len , + const uint8_t *dashes ); + +int +xcb_set_clip_rectangles_sizeof (const void *_buffer , + uint32_t rectangles_len ); + +xcb_void_cookie_t +xcb_set_clip_rectangles_checked (xcb_connection_t *c , + uint8_t ordering , + xcb_gcontext_t gc , + int16_t clip_x_origin , + int16_t clip_y_origin , + uint32_t rectangles_len , + const xcb_rectangle_t *rectangles ); + +xcb_void_cookie_t +xcb_set_clip_rectangles (xcb_connection_t *c , + uint8_t ordering , + xcb_gcontext_t gc , + int16_t clip_x_origin , + int16_t clip_y_origin , + uint32_t rectangles_len , + const xcb_rectangle_t *rectangles ); + +xcb_void_cookie_t +xcb_free_gc_checked (xcb_connection_t *c , + xcb_gcontext_t gc ); + +xcb_void_cookie_t +xcb_free_gc (xcb_connection_t *c , + xcb_gcontext_t gc ); + +xcb_void_cookie_t +xcb_clear_area_checked (xcb_connection_t *c , + uint8_t exposures , + xcb_window_t window , + int16_t x , + int16_t y , + uint16_t width , + uint16_t height ); + +xcb_void_cookie_t +xcb_clear_area (xcb_connection_t *c , + uint8_t exposures , + xcb_window_t window , + int16_t x , + int16_t y , + uint16_t width , + uint16_t height ); + +xcb_void_cookie_t +xcb_copy_area_checked (xcb_connection_t *c , + xcb_drawable_t src_drawable , + xcb_drawable_t dst_drawable , + xcb_gcontext_t gc , + int16_t src_x , + int16_t src_y , + int16_t dst_x , + int16_t dst_y , + uint16_t width , + uint16_t height ); + +xcb_void_cookie_t +xcb_copy_area (xcb_connection_t *c , + xcb_drawable_t src_drawable , + xcb_drawable_t dst_drawable , + xcb_gcontext_t gc , + int16_t src_x , + int16_t src_y , + int16_t dst_x , + int16_t dst_y , + uint16_t width , + uint16_t height ); + +xcb_void_cookie_t +xcb_copy_plane_checked (xcb_connection_t *c , + xcb_drawable_t src_drawable , + xcb_drawable_t dst_drawable , + xcb_gcontext_t gc , + int16_t src_x , + int16_t src_y , + int16_t dst_x , + int16_t dst_y , + uint16_t width , + uint16_t height , + uint32_t bit_plane ); + +xcb_void_cookie_t +xcb_copy_plane (xcb_connection_t *c , + xcb_drawable_t src_drawable , + xcb_drawable_t dst_drawable , + xcb_gcontext_t gc , + int16_t src_x , + int16_t src_y , + int16_t dst_x , + int16_t dst_y , + uint16_t width , + uint16_t height , + uint32_t bit_plane ); + +int +xcb_poly_point_sizeof (const void *_buffer , + uint32_t points_len ); + +xcb_void_cookie_t +xcb_poly_point_checked (xcb_connection_t *c , + uint8_t coordinate_mode , + xcb_drawable_t drawable , + xcb_gcontext_t gc , + uint32_t points_len , + const xcb_point_t *points ); + +xcb_void_cookie_t +xcb_poly_point (xcb_connection_t *c , + uint8_t coordinate_mode , + xcb_drawable_t drawable , + xcb_gcontext_t gc , + uint32_t points_len , + const xcb_point_t *points ); + +int +xcb_poly_line_sizeof (const void *_buffer , + uint32_t points_len ); + +xcb_void_cookie_t +xcb_poly_line_checked (xcb_connection_t *c , + uint8_t coordinate_mode , + xcb_drawable_t drawable , + xcb_gcontext_t gc , + uint32_t points_len , + const xcb_point_t *points ); + +xcb_void_cookie_t +xcb_poly_line (xcb_connection_t *c , + uint8_t coordinate_mode , + xcb_drawable_t drawable , + xcb_gcontext_t gc , + uint32_t points_len , + const xcb_point_t *points ); + +void +xcb_segment_next (xcb_segment_iterator_t *i ); + +xcb_generic_iterator_t +xcb_segment_end (xcb_segment_iterator_t i ); + +int +xcb_poly_segment_sizeof (const void *_buffer , + uint32_t segments_len ); + +xcb_void_cookie_t +xcb_poly_segment_checked (xcb_connection_t *c , + xcb_drawable_t drawable , + xcb_gcontext_t gc , + uint32_t segments_len , + const xcb_segment_t *segments ); + +xcb_void_cookie_t +xcb_poly_segment (xcb_connection_t *c , + xcb_drawable_t drawable , + xcb_gcontext_t gc , + uint32_t segments_len , + const xcb_segment_t *segments ); + +int +xcb_poly_rectangle_sizeof (const void *_buffer , + uint32_t rectangles_len ); + +xcb_void_cookie_t +xcb_poly_rectangle_checked (xcb_connection_t *c , + xcb_drawable_t drawable , + xcb_gcontext_t gc , + uint32_t rectangles_len , + const xcb_rectangle_t *rectangles ); + +xcb_void_cookie_t +xcb_poly_rectangle (xcb_connection_t *c , + xcb_drawable_t drawable , + xcb_gcontext_t gc , + uint32_t rectangles_len , + const xcb_rectangle_t *rectangles ); + +int +xcb_poly_arc_sizeof (const void *_buffer , + uint32_t arcs_len ); + +xcb_void_cookie_t +xcb_poly_arc_checked (xcb_connection_t *c , + xcb_drawable_t drawable , + xcb_gcontext_t gc , + uint32_t arcs_len , + const xcb_arc_t *arcs ); + +xcb_void_cookie_t +xcb_poly_arc (xcb_connection_t *c , + xcb_drawable_t drawable , + xcb_gcontext_t gc , + uint32_t arcs_len , + const xcb_arc_t *arcs ); + +int +xcb_fill_poly_sizeof (const void *_buffer , + uint32_t points_len ); + +xcb_void_cookie_t +xcb_fill_poly_checked (xcb_connection_t *c , + xcb_drawable_t drawable , + xcb_gcontext_t gc , + uint8_t shape , + uint8_t coordinate_mode , + uint32_t points_len , + const xcb_point_t *points ); + +xcb_void_cookie_t +xcb_fill_poly (xcb_connection_t *c , + xcb_drawable_t drawable , + xcb_gcontext_t gc , + uint8_t shape , + uint8_t coordinate_mode , + uint32_t points_len , + const xcb_point_t *points ); + +int +xcb_poly_fill_rectangle_sizeof (const void *_buffer , + uint32_t rectangles_len ); + +xcb_void_cookie_t +xcb_poly_fill_rectangle_checked (xcb_connection_t *c , + xcb_drawable_t drawable , + xcb_gcontext_t gc , + uint32_t rectangles_len , + const xcb_rectangle_t *rectangles ); + +xcb_void_cookie_t +xcb_poly_fill_rectangle (xcb_connection_t *c , + xcb_drawable_t drawable , + xcb_gcontext_t gc , + uint32_t rectangles_len , + const xcb_rectangle_t *rectangles ); + +int +xcb_poly_fill_arc_sizeof (const void *_buffer , + uint32_t arcs_len ); + +xcb_void_cookie_t +xcb_poly_fill_arc_checked (xcb_connection_t *c , + xcb_drawable_t drawable , + xcb_gcontext_t gc , + uint32_t arcs_len , + const xcb_arc_t *arcs ); + +xcb_void_cookie_t +xcb_poly_fill_arc (xcb_connection_t *c , + xcb_drawable_t drawable , + xcb_gcontext_t gc , + uint32_t arcs_len , + const xcb_arc_t *arcs ); + +int +xcb_put_image_sizeof (const void *_buffer , + uint32_t data_len ); + +xcb_void_cookie_t +xcb_put_image_checked (xcb_connection_t *c , + uint8_t format , + xcb_drawable_t drawable , + xcb_gcontext_t gc , + uint16_t width , + uint16_t height , + int16_t dst_x , + int16_t dst_y , + uint8_t left_pad , + uint8_t depth , + uint32_t data_len , + const uint8_t *data ); + +xcb_void_cookie_t +xcb_put_image (xcb_connection_t *c , + uint8_t format , + xcb_drawable_t drawable , + xcb_gcontext_t gc , + uint16_t width , + uint16_t height , + int16_t dst_x , + int16_t dst_y , + uint8_t left_pad , + uint8_t depth , + uint32_t data_len , + const uint8_t *data ); + +int +xcb_get_image_sizeof (const void *_buffer ); + +xcb_get_image_cookie_t +xcb_get_image (xcb_connection_t *c , + uint8_t format , + xcb_drawable_t drawable , + int16_t x , + int16_t y , + uint16_t width , + uint16_t height , + uint32_t plane_mask ); + +xcb_get_image_cookie_t +xcb_get_image_unchecked (xcb_connection_t *c , + uint8_t format , + xcb_drawable_t drawable , + int16_t x , + int16_t y , + uint16_t width , + uint16_t height , + uint32_t plane_mask ); + +uint8_t * +xcb_get_image_data (const xcb_get_image_reply_t *R ); + +int +xcb_get_image_data_length (const xcb_get_image_reply_t *R ); + +xcb_generic_iterator_t +xcb_get_image_data_end (const xcb_get_image_reply_t *R ); + +xcb_get_image_reply_t * +xcb_get_image_reply (xcb_connection_t *c , + xcb_get_image_cookie_t cookie , + xcb_generic_error_t **e ); + +int +xcb_poly_text_8_sizeof (const void *_buffer , + uint32_t items_len ); + +xcb_void_cookie_t +xcb_poly_text_8_checked (xcb_connection_t *c , + xcb_drawable_t drawable , + xcb_gcontext_t gc , + int16_t x , + int16_t y , + uint32_t items_len , + const uint8_t *items ); + +xcb_void_cookie_t +xcb_poly_text_8 (xcb_connection_t *c , + xcb_drawable_t drawable , + xcb_gcontext_t gc , + int16_t x , + int16_t y , + uint32_t items_len , + const uint8_t *items ); + +int +xcb_poly_text_16_sizeof (const void *_buffer , + uint32_t items_len ); + +xcb_void_cookie_t +xcb_poly_text_16_checked (xcb_connection_t *c , + xcb_drawable_t drawable , + xcb_gcontext_t gc , + int16_t x , + int16_t y , + uint32_t items_len , + const uint8_t *items ); + +xcb_void_cookie_t +xcb_poly_text_16 (xcb_connection_t *c , + xcb_drawable_t drawable , + xcb_gcontext_t gc , + int16_t x , + int16_t y , + uint32_t items_len , + const uint8_t *items ); + +int +xcb_image_text_8_sizeof (const void *_buffer ); + +xcb_void_cookie_t +xcb_image_text_8_checked (xcb_connection_t *c , + uint8_t string_len , + xcb_drawable_t drawable , + xcb_gcontext_t gc , + int16_t x , + int16_t y , + const char *string ); + +xcb_void_cookie_t +xcb_image_text_8 (xcb_connection_t *c , + uint8_t string_len , + xcb_drawable_t drawable , + xcb_gcontext_t gc , + int16_t x , + int16_t y , + const char *string ); + +int +xcb_image_text_16_sizeof (const void *_buffer ); + +xcb_void_cookie_t +xcb_image_text_16_checked (xcb_connection_t *c , + uint8_t string_len , + xcb_drawable_t drawable , + xcb_gcontext_t gc , + int16_t x , + int16_t y , + const xcb_char2b_t *string ); + +xcb_void_cookie_t +xcb_image_text_16 (xcb_connection_t *c , + uint8_t string_len , + xcb_drawable_t drawable , + xcb_gcontext_t gc , + int16_t x , + int16_t y , + const xcb_char2b_t *string ); + +xcb_void_cookie_t +xcb_create_colormap_checked (xcb_connection_t *c , + uint8_t alloc , + xcb_colormap_t mid , + xcb_window_t window , + xcb_visualid_t visual ); + +xcb_void_cookie_t +xcb_create_colormap (xcb_connection_t *c , + uint8_t alloc , + xcb_colormap_t mid , + xcb_window_t window , + xcb_visualid_t visual ); + +xcb_void_cookie_t +xcb_free_colormap_checked (xcb_connection_t *c , + xcb_colormap_t cmap ); + +xcb_void_cookie_t +xcb_free_colormap (xcb_connection_t *c , + xcb_colormap_t cmap ); + +xcb_void_cookie_t +xcb_copy_colormap_and_free_checked (xcb_connection_t *c , + xcb_colormap_t mid , + xcb_colormap_t src_cmap ); + +xcb_void_cookie_t +xcb_copy_colormap_and_free (xcb_connection_t *c , + xcb_colormap_t mid , + xcb_colormap_t src_cmap ); + +xcb_void_cookie_t +xcb_install_colormap_checked (xcb_connection_t *c , + xcb_colormap_t cmap ); + +xcb_void_cookie_t +xcb_install_colormap (xcb_connection_t *c , + xcb_colormap_t cmap ); + +xcb_void_cookie_t +xcb_uninstall_colormap_checked (xcb_connection_t *c , + xcb_colormap_t cmap ); + +xcb_void_cookie_t +xcb_uninstall_colormap (xcb_connection_t *c , + xcb_colormap_t cmap ); + +int +xcb_list_installed_colormaps_sizeof (const void *_buffer ); + +xcb_list_installed_colormaps_cookie_t +xcb_list_installed_colormaps (xcb_connection_t *c , + xcb_window_t window ); + +xcb_list_installed_colormaps_cookie_t +xcb_list_installed_colormaps_unchecked (xcb_connection_t *c , + xcb_window_t window ); + +xcb_colormap_t * +xcb_list_installed_colormaps_cmaps (const xcb_list_installed_colormaps_reply_t *R ); + +int +xcb_list_installed_colormaps_cmaps_length (const xcb_list_installed_colormaps_reply_t *R ); + +xcb_generic_iterator_t +xcb_list_installed_colormaps_cmaps_end (const xcb_list_installed_colormaps_reply_t *R ); + +xcb_list_installed_colormaps_reply_t * +xcb_list_installed_colormaps_reply (xcb_connection_t *c , + xcb_list_installed_colormaps_cookie_t cookie , + xcb_generic_error_t **e ); + +xcb_alloc_color_cookie_t +xcb_alloc_color (xcb_connection_t *c , + xcb_colormap_t cmap , + uint16_t red , + uint16_t green , + uint16_t blue ); + +xcb_alloc_color_cookie_t +xcb_alloc_color_unchecked (xcb_connection_t *c , + xcb_colormap_t cmap , + uint16_t red , + uint16_t green , + uint16_t blue ); + +xcb_alloc_color_reply_t * +xcb_alloc_color_reply (xcb_connection_t *c , + xcb_alloc_color_cookie_t cookie , + xcb_generic_error_t **e ); + +int +xcb_alloc_named_color_sizeof (const void *_buffer ); + +xcb_alloc_named_color_cookie_t +xcb_alloc_named_color (xcb_connection_t *c , + xcb_colormap_t cmap , + uint16_t name_len , + const char *name ); + +xcb_alloc_named_color_cookie_t +xcb_alloc_named_color_unchecked (xcb_connection_t *c , + xcb_colormap_t cmap , + uint16_t name_len , + const char *name ); + +xcb_alloc_named_color_reply_t * +xcb_alloc_named_color_reply (xcb_connection_t *c , + xcb_alloc_named_color_cookie_t cookie , + xcb_generic_error_t **e ); + +int +xcb_alloc_color_cells_sizeof (const void *_buffer ); + +xcb_alloc_color_cells_cookie_t +xcb_alloc_color_cells (xcb_connection_t *c , + uint8_t contiguous , + xcb_colormap_t cmap , + uint16_t colors , + uint16_t planes ); + +xcb_alloc_color_cells_cookie_t +xcb_alloc_color_cells_unchecked (xcb_connection_t *c , + uint8_t contiguous , + xcb_colormap_t cmap , + uint16_t colors , + uint16_t planes ); + +uint32_t * +xcb_alloc_color_cells_pixels (const xcb_alloc_color_cells_reply_t *R ); + +int +xcb_alloc_color_cells_pixels_length (const xcb_alloc_color_cells_reply_t *R ); + +xcb_generic_iterator_t +xcb_alloc_color_cells_pixels_end (const xcb_alloc_color_cells_reply_t *R ); + +uint32_t * +xcb_alloc_color_cells_masks (const xcb_alloc_color_cells_reply_t *R ); + +int +xcb_alloc_color_cells_masks_length (const xcb_alloc_color_cells_reply_t *R ); + +xcb_generic_iterator_t +xcb_alloc_color_cells_masks_end (const xcb_alloc_color_cells_reply_t *R ); + +xcb_alloc_color_cells_reply_t * +xcb_alloc_color_cells_reply (xcb_connection_t *c , + xcb_alloc_color_cells_cookie_t cookie , + xcb_generic_error_t **e ); + +int +xcb_alloc_color_planes_sizeof (const void *_buffer ); + +xcb_alloc_color_planes_cookie_t +xcb_alloc_color_planes (xcb_connection_t *c , + uint8_t contiguous , + xcb_colormap_t cmap , + uint16_t colors , + uint16_t reds , + uint16_t greens , + uint16_t blues ); + +xcb_alloc_color_planes_cookie_t +xcb_alloc_color_planes_unchecked (xcb_connection_t *c , + uint8_t contiguous , + xcb_colormap_t cmap , + uint16_t colors , + uint16_t reds , + uint16_t greens , + uint16_t blues ); + +uint32_t * +xcb_alloc_color_planes_pixels (const xcb_alloc_color_planes_reply_t *R ); + +int +xcb_alloc_color_planes_pixels_length (const xcb_alloc_color_planes_reply_t *R ); + +xcb_generic_iterator_t +xcb_alloc_color_planes_pixels_end (const xcb_alloc_color_planes_reply_t *R ); + +xcb_alloc_color_planes_reply_t * +xcb_alloc_color_planes_reply (xcb_connection_t *c , + xcb_alloc_color_planes_cookie_t cookie , + xcb_generic_error_t **e ); + +int +xcb_free_colors_sizeof (const void *_buffer , + uint32_t pixels_len ); + +xcb_void_cookie_t +xcb_free_colors_checked (xcb_connection_t *c , + xcb_colormap_t cmap , + uint32_t plane_mask , + uint32_t pixels_len , + const uint32_t *pixels ); + +xcb_void_cookie_t +xcb_free_colors (xcb_connection_t *c , + xcb_colormap_t cmap , + uint32_t plane_mask , + uint32_t pixels_len , + const uint32_t *pixels ); + +void +xcb_coloritem_next (xcb_coloritem_iterator_t *i ); + +xcb_generic_iterator_t +xcb_coloritem_end (xcb_coloritem_iterator_t i ); + +int +xcb_store_colors_sizeof (const void *_buffer , + uint32_t items_len ); + +xcb_void_cookie_t +xcb_store_colors_checked (xcb_connection_t *c , + xcb_colormap_t cmap , + uint32_t items_len , + const xcb_coloritem_t *items ); + +xcb_void_cookie_t +xcb_store_colors (xcb_connection_t *c , + xcb_colormap_t cmap , + uint32_t items_len , + const xcb_coloritem_t *items ); + +int +xcb_store_named_color_sizeof (const void *_buffer ); + +xcb_void_cookie_t +xcb_store_named_color_checked (xcb_connection_t *c , + uint8_t flags , + xcb_colormap_t cmap , + uint32_t pixel , + uint16_t name_len , + const char *name ); + +xcb_void_cookie_t +xcb_store_named_color (xcb_connection_t *c , + uint8_t flags , + xcb_colormap_t cmap , + uint32_t pixel , + uint16_t name_len , + const char *name ); + +void +xcb_rgb_next (xcb_rgb_iterator_t *i ); + +xcb_generic_iterator_t +xcb_rgb_end (xcb_rgb_iterator_t i ); + +int +xcb_query_colors_sizeof (const void *_buffer , + uint32_t pixels_len ); + +xcb_query_colors_cookie_t +xcb_query_colors (xcb_connection_t *c , + xcb_colormap_t cmap , + uint32_t pixels_len , + const uint32_t *pixels ); + +xcb_query_colors_cookie_t +xcb_query_colors_unchecked (xcb_connection_t *c , + xcb_colormap_t cmap , + uint32_t pixels_len , + const uint32_t *pixels ); + +xcb_rgb_t * +xcb_query_colors_colors (const xcb_query_colors_reply_t *R ); + +int +xcb_query_colors_colors_length (const xcb_query_colors_reply_t *R ); + +xcb_rgb_iterator_t +xcb_query_colors_colors_iterator (const xcb_query_colors_reply_t *R ); + +xcb_query_colors_reply_t * +xcb_query_colors_reply (xcb_connection_t *c , + xcb_query_colors_cookie_t cookie , + xcb_generic_error_t **e ); + +int +xcb_lookup_color_sizeof (const void *_buffer ); + +xcb_lookup_color_cookie_t +xcb_lookup_color (xcb_connection_t *c , + xcb_colormap_t cmap , + uint16_t name_len , + const char *name ); + +xcb_lookup_color_cookie_t +xcb_lookup_color_unchecked (xcb_connection_t *c , + xcb_colormap_t cmap , + uint16_t name_len , + const char *name ); + +xcb_lookup_color_reply_t * +xcb_lookup_color_reply (xcb_connection_t *c , + xcb_lookup_color_cookie_t cookie , + xcb_generic_error_t **e ); + +xcb_void_cookie_t +xcb_create_cursor_checked (xcb_connection_t *c , + xcb_cursor_t cid , + xcb_pixmap_t source , + xcb_pixmap_t mask , + uint16_t fore_red , + uint16_t fore_green , + uint16_t fore_blue , + uint16_t back_red , + uint16_t back_green , + uint16_t back_blue , + uint16_t x , + uint16_t y ); + +xcb_void_cookie_t +xcb_create_cursor (xcb_connection_t *c , + xcb_cursor_t cid , + xcb_pixmap_t source , + xcb_pixmap_t mask , + uint16_t fore_red , + uint16_t fore_green , + uint16_t fore_blue , + uint16_t back_red , + uint16_t back_green , + uint16_t back_blue , + uint16_t x , + uint16_t y ); + +xcb_void_cookie_t +xcb_create_glyph_cursor_checked (xcb_connection_t *c , + xcb_cursor_t cid , + xcb_font_t source_font , + xcb_font_t mask_font , + uint16_t source_char , + uint16_t mask_char , + uint16_t fore_red , + uint16_t fore_green , + uint16_t fore_blue , + uint16_t back_red , + uint16_t back_green , + uint16_t back_blue ); + +xcb_void_cookie_t +xcb_create_glyph_cursor (xcb_connection_t *c , + xcb_cursor_t cid , + xcb_font_t source_font , + xcb_font_t mask_font , + uint16_t source_char , + uint16_t mask_char , + uint16_t fore_red , + uint16_t fore_green , + uint16_t fore_blue , + uint16_t back_red , + uint16_t back_green , + uint16_t back_blue ); + +xcb_void_cookie_t +xcb_free_cursor_checked (xcb_connection_t *c , + xcb_cursor_t cursor ); + +xcb_void_cookie_t +xcb_free_cursor (xcb_connection_t *c , + xcb_cursor_t cursor ); + +xcb_void_cookie_t +xcb_recolor_cursor_checked (xcb_connection_t *c , + xcb_cursor_t cursor , + uint16_t fore_red , + uint16_t fore_green , + uint16_t fore_blue , + uint16_t back_red , + uint16_t back_green , + uint16_t back_blue ); + +xcb_void_cookie_t +xcb_recolor_cursor (xcb_connection_t *c , + xcb_cursor_t cursor , + uint16_t fore_red , + uint16_t fore_green , + uint16_t fore_blue , + uint16_t back_red , + uint16_t back_green , + uint16_t back_blue ); + +xcb_query_best_size_cookie_t +xcb_query_best_size (xcb_connection_t *c , + uint8_t _class , + xcb_drawable_t drawable , + uint16_t width , + uint16_t height ); + +xcb_query_best_size_cookie_t +xcb_query_best_size_unchecked (xcb_connection_t *c , + uint8_t _class , + xcb_drawable_t drawable , + uint16_t width , + uint16_t height ); + +xcb_query_best_size_reply_t * +xcb_query_best_size_reply (xcb_connection_t *c , + xcb_query_best_size_cookie_t cookie , + xcb_generic_error_t **e ); + +int +xcb_query_extension_sizeof (const void *_buffer ); + +xcb_query_extension_cookie_t +xcb_query_extension (xcb_connection_t *c , + uint16_t name_len , + const char *name ); + +xcb_query_extension_cookie_t +xcb_query_extension_unchecked (xcb_connection_t *c , + uint16_t name_len , + const char *name ); + +xcb_query_extension_reply_t * +xcb_query_extension_reply (xcb_connection_t *c , + xcb_query_extension_cookie_t cookie , + xcb_generic_error_t **e ); + +int +xcb_list_extensions_sizeof (const void *_buffer ); + +xcb_list_extensions_cookie_t +xcb_list_extensions (xcb_connection_t *c ); + +xcb_list_extensions_cookie_t +xcb_list_extensions_unchecked (xcb_connection_t *c ); + +int +xcb_list_extensions_names_length (const xcb_list_extensions_reply_t *R ); + +xcb_str_iterator_t +xcb_list_extensions_names_iterator (const xcb_list_extensions_reply_t *R ); + +xcb_list_extensions_reply_t * +xcb_list_extensions_reply (xcb_connection_t *c , + xcb_list_extensions_cookie_t cookie , + xcb_generic_error_t **e ); + +int +xcb_change_keyboard_mapping_sizeof (const void *_buffer ); + +xcb_void_cookie_t +xcb_change_keyboard_mapping_checked (xcb_connection_t *c , + uint8_t keycode_count , + xcb_keycode_t first_keycode , + uint8_t keysyms_per_keycode , + const xcb_keysym_t *keysyms ); + +xcb_void_cookie_t +xcb_change_keyboard_mapping (xcb_connection_t *c , + uint8_t keycode_count , + xcb_keycode_t first_keycode , + uint8_t keysyms_per_keycode , + const xcb_keysym_t *keysyms ); + +int +xcb_get_keyboard_mapping_sizeof (const void *_buffer ); + +xcb_get_keyboard_mapping_cookie_t +xcb_get_keyboard_mapping (xcb_connection_t *c , + xcb_keycode_t first_keycode , + uint8_t count ); + +xcb_get_keyboard_mapping_cookie_t +xcb_get_keyboard_mapping_unchecked (xcb_connection_t *c , + xcb_keycode_t first_keycode , + uint8_t count ); + +xcb_keysym_t * +xcb_get_keyboard_mapping_keysyms (const xcb_get_keyboard_mapping_reply_t *R ); + +int +xcb_get_keyboard_mapping_keysyms_length (const xcb_get_keyboard_mapping_reply_t *R ); + +xcb_generic_iterator_t +xcb_get_keyboard_mapping_keysyms_end (const xcb_get_keyboard_mapping_reply_t *R ); + +xcb_get_keyboard_mapping_reply_t * +xcb_get_keyboard_mapping_reply (xcb_connection_t *c , + xcb_get_keyboard_mapping_cookie_t cookie , + xcb_generic_error_t **e ); + +int +xcb_change_keyboard_control_sizeof (const void *_buffer ); + +xcb_void_cookie_t +xcb_change_keyboard_control_checked (xcb_connection_t *c , + uint32_t value_mask , + const uint32_t *value_list ); + +xcb_void_cookie_t +xcb_change_keyboard_control (xcb_connection_t *c , + uint32_t value_mask , + const uint32_t *value_list ); + +xcb_get_keyboard_control_cookie_t +xcb_get_keyboard_control (xcb_connection_t *c ); + +xcb_get_keyboard_control_cookie_t +xcb_get_keyboard_control_unchecked (xcb_connection_t *c ); + +xcb_get_keyboard_control_reply_t * +xcb_get_keyboard_control_reply (xcb_connection_t *c , + xcb_get_keyboard_control_cookie_t cookie , + xcb_generic_error_t **e ); + +xcb_void_cookie_t +xcb_bell_checked (xcb_connection_t *c , + int8_t percent ); + +xcb_void_cookie_t +xcb_bell (xcb_connection_t *c , + int8_t percent ); + +xcb_void_cookie_t +xcb_change_pointer_control_checked (xcb_connection_t *c , + int16_t acceleration_numerator , + int16_t acceleration_denominator , + int16_t threshold , + uint8_t do_acceleration , + uint8_t do_threshold ); + +xcb_void_cookie_t +xcb_change_pointer_control (xcb_connection_t *c , + int16_t acceleration_numerator , + int16_t acceleration_denominator , + int16_t threshold , + uint8_t do_acceleration , + uint8_t do_threshold ); + +xcb_get_pointer_control_cookie_t +xcb_get_pointer_control (xcb_connection_t *c ); + +xcb_get_pointer_control_cookie_t +xcb_get_pointer_control_unchecked (xcb_connection_t *c ); + +xcb_get_pointer_control_reply_t * +xcb_get_pointer_control_reply (xcb_connection_t *c , + xcb_get_pointer_control_cookie_t cookie , + xcb_generic_error_t **e ); + +xcb_void_cookie_t +xcb_set_screen_saver_checked (xcb_connection_t *c , + int16_t timeout , + int16_t interval , + uint8_t prefer_blanking , + uint8_t allow_exposures ); + +xcb_void_cookie_t +xcb_set_screen_saver (xcb_connection_t *c , + int16_t timeout , + int16_t interval , + uint8_t prefer_blanking , + uint8_t allow_exposures ); + +xcb_get_screen_saver_cookie_t +xcb_get_screen_saver (xcb_connection_t *c ); + +xcb_get_screen_saver_cookie_t +xcb_get_screen_saver_unchecked (xcb_connection_t *c ); + +xcb_get_screen_saver_reply_t * +xcb_get_screen_saver_reply (xcb_connection_t *c , + xcb_get_screen_saver_cookie_t cookie , + xcb_generic_error_t **e ); + +int +xcb_change_hosts_sizeof (const void *_buffer ); + +xcb_void_cookie_t +xcb_change_hosts_checked (xcb_connection_t *c , + uint8_t mode , + uint8_t family , + uint16_t address_len , + const uint8_t *address ); + +xcb_void_cookie_t +xcb_change_hosts (xcb_connection_t *c , + uint8_t mode , + uint8_t family , + uint16_t address_len , + const uint8_t *address ); + +int +xcb_host_sizeof (const void *_buffer ); + +uint8_t * +xcb_host_address (const xcb_host_t *R ); + +int +xcb_host_address_length (const xcb_host_t *R ); + +xcb_generic_iterator_t +xcb_host_address_end (const xcb_host_t *R ); + +void +xcb_host_next (xcb_host_iterator_t *i ); + +xcb_generic_iterator_t +xcb_host_end (xcb_host_iterator_t i ); + +int +xcb_list_hosts_sizeof (const void *_buffer ); + +xcb_list_hosts_cookie_t +xcb_list_hosts (xcb_connection_t *c ); + +xcb_list_hosts_cookie_t +xcb_list_hosts_unchecked (xcb_connection_t *c ); + +int +xcb_list_hosts_hosts_length (const xcb_list_hosts_reply_t *R ); + +xcb_host_iterator_t +xcb_list_hosts_hosts_iterator (const xcb_list_hosts_reply_t *R ); + +xcb_list_hosts_reply_t * +xcb_list_hosts_reply (xcb_connection_t *c , + xcb_list_hosts_cookie_t cookie , + xcb_generic_error_t **e ); + +xcb_void_cookie_t +xcb_set_access_control_checked (xcb_connection_t *c , + uint8_t mode ); + +xcb_void_cookie_t +xcb_set_access_control (xcb_connection_t *c , + uint8_t mode ); + +xcb_void_cookie_t +xcb_set_close_down_mode_checked (xcb_connection_t *c , + uint8_t mode ); + +xcb_void_cookie_t +xcb_set_close_down_mode (xcb_connection_t *c , + uint8_t mode ); + +xcb_void_cookie_t +xcb_kill_client_checked (xcb_connection_t *c , + uint32_t resource ); + +xcb_void_cookie_t +xcb_kill_client (xcb_connection_t *c , + uint32_t resource ); + +int +xcb_rotate_properties_sizeof (const void *_buffer ); + +xcb_void_cookie_t +xcb_rotate_properties_checked (xcb_connection_t *c , + xcb_window_t window , + uint16_t atoms_len , + int16_t delta , + const xcb_atom_t *atoms ); + +xcb_void_cookie_t +xcb_rotate_properties (xcb_connection_t *c , + xcb_window_t window , + uint16_t atoms_len , + int16_t delta , + const xcb_atom_t *atoms ); + +xcb_void_cookie_t +xcb_force_screen_saver_checked (xcb_connection_t *c , + uint8_t mode ); + +xcb_void_cookie_t +xcb_force_screen_saver (xcb_connection_t *c , + uint8_t mode ); + +int +xcb_set_pointer_mapping_sizeof (const void *_buffer ); + +xcb_set_pointer_mapping_cookie_t +xcb_set_pointer_mapping (xcb_connection_t *c , + uint8_t map_len , + const uint8_t *map ); + +xcb_set_pointer_mapping_cookie_t +xcb_set_pointer_mapping_unchecked (xcb_connection_t *c , + uint8_t map_len , + const uint8_t *map ); + +xcb_set_pointer_mapping_reply_t * +xcb_set_pointer_mapping_reply (xcb_connection_t *c , + xcb_set_pointer_mapping_cookie_t cookie , + xcb_generic_error_t **e ); + +int +xcb_get_pointer_mapping_sizeof (const void *_buffer ); + +xcb_get_pointer_mapping_cookie_t +xcb_get_pointer_mapping (xcb_connection_t *c ); + +xcb_get_pointer_mapping_cookie_t +xcb_get_pointer_mapping_unchecked (xcb_connection_t *c ); + +uint8_t * +xcb_get_pointer_mapping_map (const xcb_get_pointer_mapping_reply_t *R ); + +int +xcb_get_pointer_mapping_map_length (const xcb_get_pointer_mapping_reply_t *R ); + +xcb_generic_iterator_t +xcb_get_pointer_mapping_map_end (const xcb_get_pointer_mapping_reply_t *R ); + +xcb_get_pointer_mapping_reply_t * +xcb_get_pointer_mapping_reply (xcb_connection_t *c , + xcb_get_pointer_mapping_cookie_t cookie , + xcb_generic_error_t **e ); + +int +xcb_set_modifier_mapping_sizeof (const void *_buffer ); + +xcb_set_modifier_mapping_cookie_t +xcb_set_modifier_mapping (xcb_connection_t *c , + uint8_t keycodes_per_modifier , + const xcb_keycode_t *keycodes ); + +xcb_set_modifier_mapping_cookie_t +xcb_set_modifier_mapping_unchecked (xcb_connection_t *c , + uint8_t keycodes_per_modifier , + const xcb_keycode_t *keycodes ); + +xcb_set_modifier_mapping_reply_t * +xcb_set_modifier_mapping_reply (xcb_connection_t *c , + xcb_set_modifier_mapping_cookie_t cookie , + xcb_generic_error_t **e ); + +int +xcb_get_modifier_mapping_sizeof (const void *_buffer ); + +xcb_get_modifier_mapping_cookie_t +xcb_get_modifier_mapping (xcb_connection_t *c ); + +xcb_get_modifier_mapping_cookie_t +xcb_get_modifier_mapping_unchecked (xcb_connection_t *c ); + +xcb_keycode_t * +xcb_get_modifier_mapping_keycodes (const xcb_get_modifier_mapping_reply_t *R ); + +int +xcb_get_modifier_mapping_keycodes_length (const xcb_get_modifier_mapping_reply_t *R ); + +xcb_generic_iterator_t +xcb_get_modifier_mapping_keycodes_end (const xcb_get_modifier_mapping_reply_t *R ); + +xcb_get_modifier_mapping_reply_t * +xcb_get_modifier_mapping_reply (xcb_connection_t *c , + xcb_get_modifier_mapping_cookie_t cookie , + xcb_generic_error_t **e ); + +xcb_void_cookie_t +xcb_no_operation_checked (xcb_connection_t *c ); + +xcb_void_cookie_t +xcb_no_operation (xcb_connection_t *c ); + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/png.h b/include/png.h new file mode 100644 index 00000000..9fc8cefd --- /dev/null +++ b/include/png.h @@ -0,0 +1,3687 @@ +/* png.h - header file for PNG reference library + * + * libpng version 1.2.37 - June 4, 2009 + * Copyright (c) 1998-2009 Glenn Randers-Pehrson + * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) + * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) + * + * Authors and maintainers: + * libpng versions 0.71, May 1995, through 0.88, January 1996: Guy Schalnat + * libpng versions 0.89c, June 1996, through 0.96, May 1997: Andreas Dilger + * libpng versions 0.97, January 1998, through 1.2.37 - June 4, 2009: Glenn + * See also "Contributing Authors", below. + * + * Note about libpng version numbers: + * + * Due to various miscommunications, unforeseen code incompatibilities + * and occasional factors outside the authors' control, version numbering + * on the library has not always been consistent and straightforward. + * The following table summarizes matters since version 0.89c, which was + * the first widely used release: + * + * source png.h png.h shared-lib + * version string int version + * ------- ------ ----- ---------- + * 0.89c "1.0 beta 3" 0.89 89 1.0.89 + * 0.90 "1.0 beta 4" 0.90 90 0.90 [should have been 2.0.90] + * 0.95 "1.0 beta 5" 0.95 95 0.95 [should have been 2.0.95] + * 0.96 "1.0 beta 6" 0.96 96 0.96 [should have been 2.0.96] + * 0.97b "1.00.97 beta 7" 1.00.97 97 1.0.1 [should have been 2.0.97] + * 0.97c 0.97 97 2.0.97 + * 0.98 0.98 98 2.0.98 + * 0.99 0.99 98 2.0.99 + * 0.99a-m 0.99 99 2.0.99 + * 1.00 1.00 100 2.1.0 [100 should be 10000] + * 1.0.0 (from here on, the 100 2.1.0 [100 should be 10000] + * 1.0.1 png.h string is 10001 2.1.0 + * 1.0.1a-e identical to the 10002 from here on, the shared library + * 1.0.2 source version) 10002 is 2.V where V is the source code + * 1.0.2a-b 10003 version, except as noted. + * 1.0.3 10003 + * 1.0.3a-d 10004 + * 1.0.4 10004 + * 1.0.4a-f 10005 + * 1.0.5 (+ 2 patches) 10005 + * 1.0.5a-d 10006 + * 1.0.5e-r 10100 (not source compatible) + * 1.0.5s-v 10006 (not binary compatible) + * 1.0.6 (+ 3 patches) 10006 (still binary incompatible) + * 1.0.6d-f 10007 (still binary incompatible) + * 1.0.6g 10007 + * 1.0.6h 10007 10.6h (testing xy.z so-numbering) + * 1.0.6i 10007 10.6i + * 1.0.6j 10007 2.1.0.6j (incompatible with 1.0.0) + * 1.0.7beta11-14 DLLNUM 10007 2.1.0.7beta11-14 (binary compatible) + * 1.0.7beta15-18 1 10007 2.1.0.7beta15-18 (binary compatible) + * 1.0.7rc1-2 1 10007 2.1.0.7rc1-2 (binary compatible) + * 1.0.7 1 10007 (still compatible) + * 1.0.8beta1-4 1 10008 2.1.0.8beta1-4 + * 1.0.8rc1 1 10008 2.1.0.8rc1 + * 1.0.8 1 10008 2.1.0.8 + * 1.0.9beta1-6 1 10009 2.1.0.9beta1-6 + * 1.0.9rc1 1 10009 2.1.0.9rc1 + * 1.0.9beta7-10 1 10009 2.1.0.9beta7-10 + * 1.0.9rc2 1 10009 2.1.0.9rc2 + * 1.0.9 1 10009 2.1.0.9 + * 1.0.10beta1 1 10010 2.1.0.10beta1 + * 1.0.10rc1 1 10010 2.1.0.10rc1 + * 1.0.10 1 10010 2.1.0.10 + * 1.0.11beta1-3 1 10011 2.1.0.11beta1-3 + * 1.0.11rc1 1 10011 2.1.0.11rc1 + * 1.0.11 1 10011 2.1.0.11 + * 1.0.12beta1-2 2 10012 2.1.0.12beta1-2 + * 1.0.12rc1 2 10012 2.1.0.12rc1 + * 1.0.12 2 10012 2.1.0.12 + * 1.1.0a-f - 10100 2.1.1.0a-f (branch abandoned) + * 1.2.0beta1-2 2 10200 2.1.2.0beta1-2 + * 1.2.0beta3-5 3 10200 3.1.2.0beta3-5 + * 1.2.0rc1 3 10200 3.1.2.0rc1 + * 1.2.0 3 10200 3.1.2.0 + * 1.2.1beta1-4 3 10201 3.1.2.1beta1-4 + * 1.2.1rc1-2 3 10201 3.1.2.1rc1-2 + * 1.2.1 3 10201 3.1.2.1 + * 1.2.2beta1-6 12 10202 12.so.0.1.2.2beta1-6 + * 1.0.13beta1 10 10013 10.so.0.1.0.13beta1 + * 1.0.13rc1 10 10013 10.so.0.1.0.13rc1 + * 1.2.2rc1 12 10202 12.so.0.1.2.2rc1 + * 1.0.13 10 10013 10.so.0.1.0.13 + * 1.2.2 12 10202 12.so.0.1.2.2 + * 1.2.3rc1-6 12 10203 12.so.0.1.2.3rc1-6 + * 1.2.3 12 10203 12.so.0.1.2.3 + * 1.2.4beta1-3 13 10204 12.so.0.1.2.4beta1-3 + * 1.0.14rc1 13 10014 10.so.0.1.0.14rc1 + * 1.2.4rc1 13 10204 12.so.0.1.2.4rc1 + * 1.0.14 10 10014 10.so.0.1.0.14 + * 1.2.4 13 10204 12.so.0.1.2.4 + * 1.2.5beta1-2 13 10205 12.so.0.1.2.5beta1-2 + * 1.0.15rc1-3 10 10015 10.so.0.1.0.15rc1-3 + * 1.2.5rc1-3 13 10205 12.so.0.1.2.5rc1-3 + * 1.0.15 10 10015 10.so.0.1.0.15 + * 1.2.5 13 10205 12.so.0.1.2.5 + * 1.2.6beta1-4 13 10206 12.so.0.1.2.6beta1-4 + * 1.0.16 10 10016 10.so.0.1.0.16 + * 1.2.6 13 10206 12.so.0.1.2.6 + * 1.2.7beta1-2 13 10207 12.so.0.1.2.7beta1-2 + * 1.0.17rc1 10 10017 10.so.0.1.0.17rc1 + * 1.2.7rc1 13 10207 12.so.0.1.2.7rc1 + * 1.0.17 10 10017 10.so.0.1.0.17 + * 1.2.7 13 10207 12.so.0.1.2.7 + * 1.2.8beta1-5 13 10208 12.so.0.1.2.8beta1-5 + * 1.0.18rc1-5 10 10018 10.so.0.1.0.18rc1-5 + * 1.2.8rc1-5 13 10208 12.so.0.1.2.8rc1-5 + * 1.0.18 10 10018 10.so.0.1.0.18 + * 1.2.8 13 10208 12.so.0.1.2.8 + * 1.2.9beta1-3 13 10209 12.so.0.1.2.9beta1-3 + * 1.2.9beta4-11 13 10209 12.so.0.9[.0] + * 1.2.9rc1 13 10209 12.so.0.9[.0] + * 1.2.9 13 10209 12.so.0.9[.0] + * 1.2.10beta1-8 13 10210 12.so.0.10[.0] + * 1.2.10rc1-3 13 10210 12.so.0.10[.0] + * 1.2.10 13 10210 12.so.0.10[.0] + * 1.2.11beta1-4 13 10211 12.so.0.11[.0] + * 1.0.19rc1-5 10 10019 10.so.0.19[.0] + * 1.2.11rc1-5 13 10211 12.so.0.11[.0] + * 1.0.19 10 10019 10.so.0.19[.0] + * 1.2.11 13 10211 12.so.0.11[.0] + * 1.0.20 10 10020 10.so.0.20[.0] + * 1.2.12 13 10212 12.so.0.12[.0] + * 1.2.13beta1 13 10213 12.so.0.13[.0] + * 1.0.21 10 10021 10.so.0.21[.0] + * 1.2.13 13 10213 12.so.0.13[.0] + * 1.2.14beta1-2 13 10214 12.so.0.14[.0] + * 1.0.22rc1 10 10022 10.so.0.22[.0] + * 1.2.14rc1 13 10214 12.so.0.14[.0] + * 1.0.22 10 10022 10.so.0.22[.0] + * 1.2.14 13 10214 12.so.0.14[.0] + * 1.2.15beta1-6 13 10215 12.so.0.15[.0] + * 1.0.23rc1-5 10 10023 10.so.0.23[.0] + * 1.2.15rc1-5 13 10215 12.so.0.15[.0] + * 1.0.23 10 10023 10.so.0.23[.0] + * 1.2.15 13 10215 12.so.0.15[.0] + * 1.2.16beta1-2 13 10216 12.so.0.16[.0] + * 1.2.16rc1 13 10216 12.so.0.16[.0] + * 1.0.24 10 10024 10.so.0.24[.0] + * 1.2.16 13 10216 12.so.0.16[.0] + * 1.2.17beta1-2 13 10217 12.so.0.17[.0] + * 1.0.25rc1 10 10025 10.so.0.25[.0] + * 1.2.17rc1-3 13 10217 12.so.0.17[.0] + * 1.0.25 10 10025 10.so.0.25[.0] + * 1.2.17 13 10217 12.so.0.17[.0] + * 1.0.26 10 10026 10.so.0.26[.0] + * 1.2.18 13 10218 12.so.0.18[.0] + * 1.2.19beta1-31 13 10219 12.so.0.19[.0] + * 1.0.27rc1-6 10 10027 10.so.0.27[.0] + * 1.2.19rc1-6 13 10219 12.so.0.19[.0] + * 1.0.27 10 10027 10.so.0.27[.0] + * 1.2.19 13 10219 12.so.0.19[.0] + * 1.2.20beta01-04 13 10220 12.so.0.20[.0] + * 1.0.28rc1-6 10 10028 10.so.0.28[.0] + * 1.2.20rc1-6 13 10220 12.so.0.20[.0] + * 1.0.28 10 10028 10.so.0.28[.0] + * 1.2.20 13 10220 12.so.0.20[.0] + * 1.2.21beta1-2 13 10221 12.so.0.21[.0] + * 1.2.21rc1-3 13 10221 12.so.0.21[.0] + * 1.0.29 10 10029 10.so.0.29[.0] + * 1.2.21 13 10221 12.so.0.21[.0] + * 1.2.22beta1-4 13 10222 12.so.0.22[.0] + * 1.0.30rc1 10 10030 10.so.0.30[.0] + * 1.2.22rc1 13 10222 12.so.0.22[.0] + * 1.0.30 10 10030 10.so.0.30[.0] + * 1.2.22 13 10222 12.so.0.22[.0] + * 1.2.23beta01-05 13 10223 12.so.0.23[.0] + * 1.2.23rc01 13 10223 12.so.0.23[.0] + * 1.2.23 13 10223 12.so.0.23[.0] + * 1.2.24beta01-02 13 10224 12.so.0.24[.0] + * 1.2.24rc01 13 10224 12.so.0.24[.0] + * 1.2.24 13 10224 12.so.0.24[.0] + * 1.2.25beta01-06 13 10225 12.so.0.25[.0] + * 1.2.25rc01-02 13 10225 12.so.0.25[.0] + * 1.0.31 10 10031 10.so.0.31[.0] + * 1.2.25 13 10225 12.so.0.25[.0] + * 1.2.26beta01-06 13 10226 12.so.0.26[.0] + * 1.2.26rc01 13 10226 12.so.0.26[.0] + * 1.2.26 13 10226 12.so.0.26[.0] + * 1.0.32 10 10032 10.so.0.32[.0] + * 1.2.27beta01-06 13 10227 12.so.0.27[.0] + * 1.2.27rc01 13 10227 12.so.0.27[.0] + * 1.0.33 10 10033 10.so.0.33[.0] + * 1.2.27 13 10227 12.so.0.27[.0] + * 1.0.34 10 10034 10.so.0.34[.0] + * 1.2.28 13 10228 12.so.0.28[.0] + * 1.2.29beta01-03 13 10229 12.so.0.29[.0] + * 1.2.29rc01 13 10229 12.so.0.29[.0] + * 1.0.35 10 10035 10.so.0.35[.0] + * 1.2.29 13 10229 12.so.0.29[.0] + * 1.0.37 10 10037 10.so.0.37[.0] + * 1.2.30beta01-04 13 10230 12.so.0.30[.0] + * 1.0.38rc01-08 10 10038 10.so.0.38[.0] + * 1.2.30rc01-08 13 10230 12.so.0.30[.0] + * 1.0.38 10 10038 10.so.0.38[.0] + * 1.2.30 13 10230 12.so.0.30[.0] + * 1.0.39rc01-03 10 10039 10.so.0.39[.0] + * 1.2.31rc01-03 13 10231 12.so.0.31[.0] + * 1.0.39 10 10039 10.so.0.39[.0] + * 1.2.31 13 10231 12.so.0.31[.0] + * 1.2.32beta01-02 13 10232 12.so.0.32[.0] + * 1.0.40rc01 10 10040 10.so.0.40[.0] + * 1.2.32rc01 13 10232 12.so.0.32[.0] + * 1.0.40 10 10040 10.so.0.40[.0] + * 1.2.32 13 10232 12.so.0.32[.0] + * 1.2.33beta01-02 13 10233 12.so.0.33[.0] + * 1.2.33rc01-02 13 10233 12.so.0.33[.0] + * 1.0.41rc01 10 10041 10.so.0.41[.0] + * 1.2.33 13 10233 12.so.0.33[.0] + * 1.0.41 10 10041 10.so.0.41[.0] + * 1.2.34beta01-07 13 10234 12.so.0.34[.0] + * 1.0.42rc01 10 10042 10.so.0.42[.0] + * 1.2.34rc01 13 10234 12.so.0.34[.0] + * 1.0.42 10 10042 10.so.0.42[.0] + * 1.2.34 13 10234 12.so.0.34[.0] + * 1.2.35beta01-03 13 10235 12.so.0.35[.0] + * 1.0.43rc01-02 10 10043 10.so.0.43[.0] + * 1.2.35rc01-02 13 10235 12.so.0.35[.0] + * 1.0.43 10 10043 10.so.0.43[.0] + * 1.2.35 13 10235 12.so.0.35[.0] + * 1.2.36beta01-05 13 10236 12.so.0.36[.0] + * 1.2.36rc01 13 10236 12.so.0.36[.0] + * 1.0.44 10 10044 10.so.0.44[.0] + * 1.2.36 13 10236 12.so.0.36[.0] + * 1.2.37beta01-03 13 10237 12.so.0.37[.0] + * 1.2.37rc01 13 10237 12.so.0.37[.0] + * 1.2.37 13 10237 12.so.0.37[.0] + * + * Henceforth the source version will match the shared-library major + * and minor numbers; the shared-library major version number will be + * used for changes in backward compatibility, as it is intended. The + * PNG_LIBPNG_VER macro, which is not used within libpng but is available + * for applications, is an unsigned integer of the form xyyzz corresponding + * to the source version x.y.z (leading zeros in y and z). Beta versions + * were given the previous public release number plus a letter, until + * version 1.0.6j; from then on they were given the upcoming public + * release number plus "betaNN" or "rcNN". + * + * Binary incompatibility exists only when applications make direct access + * to the info_ptr or png_ptr members through png.h, and the compiled + * application is loaded with a different version of the library. + * + * DLLNUM will change each time there are forward or backward changes + * in binary compatibility (e.g., when a new feature is added). + * + * See libpng.txt or libpng.3 for more information. The PNG specification + * is available as a W3C Recommendation and as an ISO Specification, + * defines should NOT be changed. + */ +#define PNG_INFO_gAMA 0x0001 +#define PNG_INFO_sBIT 0x0002 +#define PNG_INFO_cHRM 0x0004 +#define PNG_INFO_PLTE 0x0008 +#define PNG_INFO_tRNS 0x0010 +#define PNG_INFO_bKGD 0x0020 +#define PNG_INFO_hIST 0x0040 +#define PNG_INFO_pHYs 0x0080 +#define PNG_INFO_oFFs 0x0100 +#define PNG_INFO_tIME 0x0200 +#define PNG_INFO_pCAL 0x0400 +#define PNG_INFO_sRGB 0x0800 /* GR-P, 0.96a */ +#define PNG_INFO_iCCP 0x1000 /* ESR, 1.0.6 */ +#define PNG_INFO_sPLT 0x2000 /* ESR, 1.0.6 */ +#define PNG_INFO_sCAL 0x4000 /* ESR, 1.0.6 */ +#define PNG_INFO_IDAT 0x8000L /* ESR, 1.0.6 */ + +/* This is used for the transformation routines, as some of them + * change these values for the row. It also should enable using + * the routines for other purposes. + */ +typedef struct png_row_info_struct +{ + png_uint_32 width; /* width of row */ + png_uint_32 rowbytes; /* number of bytes in row */ + png_byte color_type; /* color type of row */ + png_byte bit_depth; /* bit depth of row */ + png_byte channels; /* number of channels (1, 2, 3, or 4) */ + png_byte pixel_depth; /* bits per pixel (depth * channels) */ +} png_row_info; + +typedef png_row_info FAR * png_row_infop; +typedef png_row_info FAR * FAR * png_row_infopp; + +/* These are the function types for the I/O functions and for the functions + * that allow the user to override the default I/O functions with his or her + * own. The png_error_ptr type should match that of user-supplied warning + * and error functions, while the png_rw_ptr type should match that of the + * user read/write data functions. + */ +typedef struct png_struct_def png_struct; +typedef png_struct FAR * png_structp; + +typedef void (PNGAPI *png_error_ptr) PNGARG((png_structp, png_const_charp)); +typedef void (PNGAPI *png_rw_ptr) PNGARG((png_structp, png_bytep, png_size_t)); +typedef void (PNGAPI *png_flush_ptr) PNGARG((png_structp)); +typedef void (PNGAPI *png_read_status_ptr) PNGARG((png_structp, png_uint_32, + int)); +typedef void (PNGAPI *png_write_status_ptr) PNGARG((png_structp, png_uint_32, + int)); + +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +typedef void (PNGAPI *png_progressive_info_ptr) PNGARG((png_structp, png_infop)); +typedef void (PNGAPI *png_progressive_end_ptr) PNGARG((png_structp, png_infop)); +typedef void (PNGAPI *png_progressive_row_ptr) PNGARG((png_structp, png_bytep, + png_uint_32, int)); +#endif + +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_LEGACY_SUPPORTED) +typedef void (PNGAPI *png_user_transform_ptr) PNGARG((png_structp, + png_row_infop, png_bytep)); +#endif + +#if defined(PNG_USER_CHUNKS_SUPPORTED) +typedef int (PNGAPI *png_user_chunk_ptr) PNGARG((png_structp, png_unknown_chunkp)); +#endif +#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) +typedef void (PNGAPI *png_unknown_chunk_ptr) PNGARG((png_structp)); +#endif + +/* Transform masks for the high-level interface */ +#define PNG_TRANSFORM_IDENTITY 0x0000 /* read and write */ +#define PNG_TRANSFORM_STRIP_16 0x0001 /* read only */ +#define PNG_TRANSFORM_STRIP_ALPHA 0x0002 /* read only */ +#define PNG_TRANSFORM_PACKING 0x0004 /* read and write */ +#define PNG_TRANSFORM_PACKSWAP 0x0008 /* read and write */ +#define PNG_TRANSFORM_EXPAND 0x0010 /* read only */ +#define PNG_TRANSFORM_INVERT_MONO 0x0020 /* read and write */ +#define PNG_TRANSFORM_SHIFT 0x0040 /* read and write */ +#define PNG_TRANSFORM_BGR 0x0080 /* read and write */ +#define PNG_TRANSFORM_SWAP_ALPHA 0x0100 /* read and write */ +#define PNG_TRANSFORM_SWAP_ENDIAN 0x0200 /* read and write */ +#define PNG_TRANSFORM_INVERT_ALPHA 0x0400 /* read and write */ +#define PNG_TRANSFORM_STRIP_FILLER 0x0800 /* WRITE only, deprecated */ +/* Added to libpng-1.2.34 */ +#define PNG_TRANSFORM_STRIP_FILLER_BEFORE 0x0800 /* WRITE only */ +#define PNG_TRANSFORM_STRIP_FILLER_AFTER 0x1000 /* WRITE only */ + +/* Flags for MNG supported features */ +#define PNG_FLAG_MNG_EMPTY_PLTE 0x01 +#define PNG_FLAG_MNG_FILTER_64 0x04 +#define PNG_ALL_MNG_FEATURES 0x05 + +typedef png_voidp (*png_malloc_ptr) PNGARG((png_structp, png_size_t)); +typedef void (*png_free_ptr) PNGARG((png_structp, png_voidp)); + +/* The structure that holds the information to read and write PNG files. + * The only people who need to care about what is inside of this are the + * people who will be modifying the library for their own special needs. + * It should NOT be accessed directly by an application, except to store + * the jmp_buf. + */ + +struct png_struct_def +{ +#ifdef PNG_SETJMP_SUPPORTED + jmp_buf jmpbuf; /* used in png_error */ +#endif + png_error_ptr error_fn; /* function for printing errors and aborting */ + png_error_ptr warning_fn; /* function for printing warnings */ + png_voidp error_ptr; /* user supplied struct for error functions */ + png_rw_ptr write_data_fn; /* function for writing output data */ + png_rw_ptr read_data_fn; /* function for reading input data */ + png_voidp io_ptr; /* ptr to application struct for I/O functions */ + +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) + png_user_transform_ptr read_user_transform_fn; /* user read transform */ +#endif + +#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) + png_user_transform_ptr write_user_transform_fn; /* user write transform */ +#endif + +/* These were added in libpng-1.0.2 */ +#if defined(PNG_USER_TRANSFORM_PTR_SUPPORTED) +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) + png_voidp user_transform_ptr; /* user supplied struct for user transform */ + png_byte user_transform_depth; /* bit depth of user transformed pixels */ + png_byte user_transform_channels; /* channels in user transformed pixels */ +#endif +#endif + + png_uint_32 mode; /* tells us where we are in the PNG file */ + png_uint_32 flags; /* flags indicating various things to libpng */ + png_uint_32 transformations; /* which transformations to perform */ + + z_stream zstream; /* pointer to decompression structure (below) */ + png_bytep zbuf; /* buffer for zlib */ + png_size_t zbuf_size; /* size of zbuf */ + int zlib_level; /* holds zlib compression level */ + int zlib_method; /* holds zlib compression method */ + int zlib_window_bits; /* holds zlib compression window bits */ + int zlib_mem_level; /* holds zlib compression memory level */ + int zlib_strategy; /* holds zlib compression strategy */ + + png_uint_32 width; /* width of image in pixels */ + png_uint_32 height; /* height of image in pixels */ + png_uint_32 num_rows; /* number of rows in current pass */ + png_uint_32 usr_width; /* width of row at start of write */ + png_uint_32 rowbytes; /* size of row in bytes */ + png_uint_32 irowbytes; /* size of current interlaced row in bytes */ + png_uint_32 iwidth; /* width of current interlaced row in pixels */ + png_uint_32 row_number; /* current row in interlace pass */ + png_bytep prev_row; /* buffer to save previous (unfiltered) row */ + png_bytep row_buf; /* buffer to save current (unfiltered) row */ +#ifndef PNG_NO_WRITE_FILTER + png_bytep sub_row; /* buffer to save "sub" row when filtering */ + png_bytep up_row; /* buffer to save "up" row when filtering */ + png_bytep avg_row; /* buffer to save "avg" row when filtering */ + png_bytep paeth_row; /* buffer to save "Paeth" row when filtering */ +#endif + png_row_info row_info; /* used for transformation routines */ + + png_uint_32 idat_size; /* current IDAT size for read */ + png_uint_32 crc; /* current chunk CRC value */ + png_colorp palette; /* palette from the input file */ + png_uint_16 num_palette; /* number of color entries in palette */ + png_uint_16 num_trans; /* number of transparency values */ + png_byte chunk_name[5]; /* null-terminated name of current chunk */ + png_byte compression; /* file compression type (always 0) */ + png_byte filter; /* file filter type (always 0) */ + png_byte interlaced; /* PNG_INTERLACE_NONE, PNG_INTERLACE_ADAM7 */ + png_byte pass; /* current interlace pass (0 - 6) */ + png_byte do_filter; /* row filter flags (see PNG_FILTER_ below ) */ + png_byte color_type; /* color type of file */ + png_byte bit_depth; /* bit depth of file */ + png_byte usr_bit_depth; /* bit depth of users row */ + png_byte pixel_depth; /* number of bits per pixel */ + png_byte channels; /* number of channels in file */ + png_byte usr_channels; /* channels at start of write */ + png_byte sig_bytes; /* magic bytes read/written from start of file */ + +#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) +#ifdef PNG_LEGACY_SUPPORTED + png_byte filler; /* filler byte for pixel expansion */ +#else + png_uint_16 filler; /* filler bytes for pixel expansion */ +#endif +#endif + +#if defined(PNG_bKGD_SUPPORTED) + png_byte background_gamma_type; +# ifdef PNG_FLOATING_POINT_SUPPORTED + float background_gamma; +# endif + png_color_16 background; /* background color in screen gamma space */ +#if defined(PNG_READ_GAMMA_SUPPORTED) + png_color_16 background_1; /* background normalized to gamma 1.0 */ +#endif +#endif /* PNG_bKGD_SUPPORTED */ + +#if defined(PNG_WRITE_FLUSH_SUPPORTED) + png_flush_ptr output_flush_fn;/* Function for flushing output */ + png_uint_32 flush_dist; /* how many rows apart to flush, 0 - no flush */ + png_uint_32 flush_rows; /* number of rows written since last flush */ +#endif + +#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) + int gamma_shift; /* number of "insignificant" bits 16-bit gamma */ +#ifdef PNG_FLOATING_POINT_SUPPORTED + float gamma; /* file gamma value */ + float screen_gamma; /* screen gamma value (display_exponent) */ +#endif +#endif + +#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) + png_bytep gamma_table; /* gamma table for 8-bit depth files */ + png_bytep gamma_from_1; /* converts from 1.0 to screen */ + png_bytep gamma_to_1; /* converts from file to 1.0 */ + png_uint_16pp gamma_16_table; /* gamma table for 16-bit depth files */ + png_uint_16pp gamma_16_from_1; /* converts from 1.0 to screen */ + png_uint_16pp gamma_16_to_1; /* converts from file to 1.0 */ +#endif + +#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_sBIT_SUPPORTED) + png_color_8 sig_bit; /* significant bits in each available channel */ +#endif + +#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) + png_color_8 shift; /* shift for significant bit tranformation */ +#endif + +#if defined(PNG_tRNS_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) \ + || defined(PNG_READ_EXPAND_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) + png_bytep trans; /* transparency values for paletted files */ + png_color_16 trans_values; /* transparency values for non-paletted files */ +#endif + + png_read_status_ptr read_row_fn; /* called after each row is decoded */ + png_write_status_ptr write_row_fn; /* called after each row is encoded */ +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED + png_progressive_info_ptr info_fn; /* called after header data fully read */ + png_progressive_row_ptr row_fn; /* called after each prog. row is decoded */ + png_progressive_end_ptr end_fn; /* called after image is complete */ + png_bytep save_buffer_ptr; /* current location in save_buffer */ + png_bytep save_buffer; /* buffer for previously read data */ + png_bytep current_buffer_ptr; /* current location in current_buffer */ + png_bytep current_buffer; /* buffer for recently used data */ + png_uint_32 push_length; /* size of current input chunk */ + png_uint_32 skip_length; /* bytes to skip in input data */ + png_size_t save_buffer_size; /* amount of data now in save_buffer */ + png_size_t save_buffer_max; /* total size of save_buffer */ + png_size_t buffer_size; /* total amount of available input data */ + png_size_t current_buffer_size; /* amount of data now in current_buffer */ + int process_mode; /* what push library is currently doing */ + int cur_palette; /* current push library palette index */ + +# if defined(PNG_TEXT_SUPPORTED) + png_size_t current_text_size; /* current size of text input data */ + png_size_t current_text_left; /* how much text left to read in input */ + png_charp current_text; /* current text chunk buffer */ + png_charp current_text_ptr; /* current location in current_text */ +# endif /* PNG_TEXT_SUPPORTED */ +#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ + +#if defined(__TURBOC__) && !defined(_Windows) && !defined(__FLAT__) +/* for the Borland special 64K segment handler */ + png_bytepp offset_table_ptr; + png_bytep offset_table; + png_uint_16 offset_table_number; + png_uint_16 offset_table_count; + png_uint_16 offset_table_count_free; +#endif + +#if defined(PNG_READ_DITHER_SUPPORTED) + png_bytep palette_lookup; /* lookup table for dithering */ + png_bytep dither_index; /* index translation for palette files */ +#endif + +#if defined(PNG_READ_DITHER_SUPPORTED) || defined(PNG_hIST_SUPPORTED) + png_uint_16p hist; /* histogram */ +#endif + +#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) + png_byte heuristic_method; /* heuristic for row filter selection */ + png_byte num_prev_filters; /* number of weights for previous rows */ + png_bytep prev_filters; /* filter type(s) of previous row(s) */ + png_uint_16p filter_weights; /* weight(s) for previous line(s) */ + png_uint_16p inv_filter_weights; /* 1/weight(s) for previous line(s) */ + png_uint_16p filter_costs; /* relative filter calculation cost */ + png_uint_16p inv_filter_costs; /* 1/relative filter calculation cost */ +#endif + +#if defined(PNG_TIME_RFC1123_SUPPORTED) + png_charp time_buffer; /* String to hold RFC 1123 time text */ +#endif + +/* New members added in libpng-1.0.6 */ + +#ifdef PNG_FREE_ME_SUPPORTED + png_uint_32 free_me; /* flags items libpng is responsible for freeing */ +#endif + +#if defined(PNG_USER_CHUNKS_SUPPORTED) + png_voidp user_chunk_ptr; + png_user_chunk_ptr read_user_chunk_fn; /* user read chunk handler */ +#endif + +#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) + int num_chunk_list; + png_bytep chunk_list; +#endif + +/* New members added in libpng-1.0.3 */ +#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) + png_byte rgb_to_gray_status; + /* These were changed from png_byte in libpng-1.0.6 */ + png_uint_16 rgb_to_gray_red_coeff; + png_uint_16 rgb_to_gray_green_coeff; + png_uint_16 rgb_to_gray_blue_coeff; +#endif + +/* New member added in libpng-1.0.4 (renamed in 1.0.9) */ +#if defined(PNG_MNG_FEATURES_SUPPORTED) || \ + defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ + defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) +/* changed from png_byte to png_uint_32 at version 1.2.0 */ +#ifdef PNG_1_0_X + png_byte mng_features_permitted; +#else + png_uint_32 mng_features_permitted; +#endif /* PNG_1_0_X */ +#endif + +/* New member added in libpng-1.0.7 */ +#if defined(PNG_READ_GAMMA_SUPPORTED) || defined(PNG_READ_BACKGROUND_SUPPORTED) + png_fixed_point int_gamma; +#endif + +/* New member added in libpng-1.0.9, ifdef'ed out in 1.0.12, enabled in 1.2.0 */ +#if defined(PNG_MNG_FEATURES_SUPPORTED) + png_byte filter_type; +#endif + +#if defined(PNG_1_0_X) +/* New member added in libpng-1.0.10, ifdef'ed out in 1.2.0 */ + png_uint_32 row_buf_size; +#endif + +/* New members added in libpng-1.2.0 */ +#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) +# if !defined(PNG_1_0_X) +# if defined(PNG_MMX_CODE_SUPPORTED) + png_byte mmx_bitdepth_threshold; + png_uint_32 mmx_rowbytes_threshold; +# endif + png_uint_32 asm_flags; +# endif +#endif + +/* New members added in libpng-1.0.2 but first enabled by default in 1.2.0 */ +#ifdef PNG_USER_MEM_SUPPORTED + png_voidp mem_ptr; /* user supplied struct for mem functions */ + png_malloc_ptr malloc_fn; /* function for allocating memory */ + png_free_ptr free_fn; /* function for freeing memory */ +#endif + +/* New member added in libpng-1.0.13 and 1.2.0 */ + png_bytep big_row_buf; /* buffer to save current (unfiltered) row */ + +#if defined(PNG_READ_DITHER_SUPPORTED) +/* The following three members were added at version 1.0.14 and 1.2.4 */ + png_bytep dither_sort; /* working sort array */ + png_bytep index_to_palette; /* where the original index currently is */ + /* in the palette */ + png_bytep palette_to_index; /* which original index points to this */ + /* palette color */ +#endif + +/* New members added in libpng-1.0.16 and 1.2.6 */ + png_byte compression_type; + +#ifdef PNG_SET_USER_LIMITS_SUPPORTED + png_uint_32 user_width_max; + png_uint_32 user_height_max; +#endif + +/* New member added in libpng-1.0.25 and 1.2.17 */ +#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) + /* storage for unknown chunk that the library doesn't recognize. */ + png_unknown_chunk unknown_chunk; +#endif + +/* New members added in libpng-1.2.26 */ + png_uint_32 old_big_row_buf_size, old_prev_row_size; + +/* New member added in libpng-1.2.30 */ + png_charp chunkdata; /* buffer for reading chunk data */ + +}; + + +/* This triggers a compiler error in png.c, if png.c and png.h + * do not agree upon the version number. + */ +typedef png_structp version_1_2_37; + +typedef png_struct FAR * FAR * png_structpp; + +/* Here are the function definitions most commonly used. This is not + * the place to find out how to use libpng. See libpng.txt for the + * full explanation, see example.c for the summary. This just provides + * a simple one line description of the use of each function. + */ + +/* Returns the version number of the library */ +extern PNG_EXPORT(png_uint_32,png_access_version_number) PNGARG((void)); + +/* Tell lib we have already handled the first magic bytes. + * Handling more than 8 bytes from the beginning of the file is an error. + */ +extern PNG_EXPORT(void,png_set_sig_bytes) PNGARG((png_structp png_ptr, + int num_bytes)); + +/* Check sig[start] through sig[start + num_to_check - 1] to see if it's a + * PNG file. Returns zero if the supplied bytes match the 8-byte PNG + * signature, and non-zero otherwise. Having num_to_check == 0 or + * start > 7 will always fail (ie return non-zero). + */ +extern PNG_EXPORT(int,png_sig_cmp) PNGARG((png_bytep sig, png_size_t start, + png_size_t num_to_check)); + +/* Simple signature checking function. This is the same as calling + * png_check_sig(sig, n) := !png_sig_cmp(sig, 0, n). + */ +extern PNG_EXPORT(int,png_check_sig) PNGARG((png_bytep sig, int num)); + +/* Allocate and initialize png_ptr struct for reading, and any other memory. */ +extern PNG_EXPORT(png_structp,png_create_read_struct) + PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, + png_error_ptr error_fn, png_error_ptr warn_fn)); + +/* Allocate and initialize png_ptr struct for writing, and any other memory */ +extern PNG_EXPORT(png_structp,png_create_write_struct) + PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, + png_error_ptr error_fn, png_error_ptr warn_fn)); + +#ifdef PNG_WRITE_SUPPORTED +extern PNG_EXPORT(png_uint_32,png_get_compression_buffer_size) + PNGARG((png_structp png_ptr)); +#endif + +#ifdef PNG_WRITE_SUPPORTED +extern PNG_EXPORT(void,png_set_compression_buffer_size) + PNGARG((png_structp png_ptr, png_uint_32 size)); +#endif + +/* Reset the compression stream */ +extern PNG_EXPORT(int,png_reset_zstream) PNGARG((png_structp png_ptr)); + +/* New functions added in libpng-1.0.2 (not enabled by default until 1.2.0) */ +#ifdef PNG_USER_MEM_SUPPORTED +extern PNG_EXPORT(png_structp,png_create_read_struct_2) + PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, + png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, + png_malloc_ptr malloc_fn, png_free_ptr free_fn)); +extern PNG_EXPORT(png_structp,png_create_write_struct_2) + PNGARG((png_const_charp user_png_ver, png_voidp error_ptr, + png_error_ptr error_fn, png_error_ptr warn_fn, png_voidp mem_ptr, + png_malloc_ptr malloc_fn, png_free_ptr free_fn)); +#endif + +/* Write a PNG chunk - size, type, (optional) data, CRC. */ +extern PNG_EXPORT(void,png_write_chunk) PNGARG((png_structp png_ptr, + png_bytep chunk_name, png_bytep data, png_size_t length)); + +/* Write the start of a PNG chunk - length and chunk name. */ +extern PNG_EXPORT(void,png_write_chunk_start) PNGARG((png_structp png_ptr, + png_bytep chunk_name, png_uint_32 length)); + +/* Write the data of a PNG chunk started with png_write_chunk_start(). */ +extern PNG_EXPORT(void,png_write_chunk_data) PNGARG((png_structp png_ptr, + png_bytep data, png_size_t length)); + +/* Finish a chunk started with png_write_chunk_start() (includes CRC). */ +extern PNG_EXPORT(void,png_write_chunk_end) PNGARG((png_structp png_ptr)); + +/* Allocate and initialize the info structure */ +extern PNG_EXPORT(png_infop,png_create_info_struct) + PNGARG((png_structp png_ptr)); + +#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +/* Initialize the info structure (old interface - DEPRECATED) */ +extern PNG_EXPORT(void,png_info_init) PNGARG((png_infop info_ptr)); +#undef png_info_init +#define png_info_init(info_ptr) png_info_init_3(&info_ptr,\ + png_sizeof(png_info)); +#endif + +extern PNG_EXPORT(void,png_info_init_3) PNGARG((png_infopp info_ptr, + png_size_t png_info_struct_size)); + +/* Writes all the PNG information before the image. */ +extern PNG_EXPORT(void,png_write_info_before_PLTE) PNGARG((png_structp png_ptr, + png_infop info_ptr)); +extern PNG_EXPORT(void,png_write_info) PNGARG((png_structp png_ptr, + png_infop info_ptr)); + +#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED +/* read the information before the actual image data. */ +extern PNG_EXPORT(void,png_read_info) PNGARG((png_structp png_ptr, + png_infop info_ptr)); +#endif + +#if defined(PNG_TIME_RFC1123_SUPPORTED) +extern PNG_EXPORT(png_charp,png_convert_to_rfc1123) + PNGARG((png_structp png_ptr, png_timep ptime)); +#endif + +#if !defined(_WIN32_WCE) +/* "time.h" functions are not supported on WindowsCE */ +#if defined(PNG_WRITE_tIME_SUPPORTED) +/* convert from a struct tm to png_time */ +extern PNG_EXPORT(void,png_convert_from_struct_tm) PNGARG((png_timep ptime, + struct tm FAR * ttime)); + +/* convert from time_t to png_time. Uses gmtime() */ +extern PNG_EXPORT(void,png_convert_from_time_t) PNGARG((png_timep ptime, + time_t ttime)); +#endif /* PNG_WRITE_tIME_SUPPORTED */ +#endif /* _WIN32_WCE */ + +#if defined(PNG_READ_EXPAND_SUPPORTED) +/* Expand data to 24-bit RGB, or 8-bit grayscale, with alpha if available. */ +extern PNG_EXPORT(void,png_set_expand) PNGARG((png_structp png_ptr)); +#if !defined(PNG_1_0_X) +extern PNG_EXPORT(void,png_set_expand_gray_1_2_4_to_8) PNGARG((png_structp + png_ptr)); +#endif +extern PNG_EXPORT(void,png_set_palette_to_rgb) PNGARG((png_structp png_ptr)); +extern PNG_EXPORT(void,png_set_tRNS_to_alpha) PNGARG((png_structp png_ptr)); +#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +/* Deprecated */ +extern PNG_EXPORT(void,png_set_gray_1_2_4_to_8) PNGARG((png_structp png_ptr)); +#endif +#endif + +#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) +/* Use blue, green, red order for pixels. */ +extern PNG_EXPORT(void,png_set_bgr) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) +/* Expand the grayscale to 24-bit RGB if necessary. */ +extern PNG_EXPORT(void,png_set_gray_to_rgb) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) +/* Reduce RGB to grayscale. */ +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_rgb_to_gray) PNGARG((png_structp png_ptr, + int error_action, double red, double green )); +#endif +extern PNG_EXPORT(void,png_set_rgb_to_gray_fixed) PNGARG((png_structp png_ptr, + int error_action, png_fixed_point red, png_fixed_point green )); +extern PNG_EXPORT(png_byte,png_get_rgb_to_gray_status) PNGARG((png_structp + png_ptr)); +#endif + +extern PNG_EXPORT(void,png_build_grayscale_palette) PNGARG((int bit_depth, + png_colorp palette)); + +#if defined(PNG_READ_STRIP_ALPHA_SUPPORTED) +extern PNG_EXPORT(void,png_set_strip_alpha) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) || \ + defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) +extern PNG_EXPORT(void,png_set_swap_alpha) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) || \ + defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) +extern PNG_EXPORT(void,png_set_invert_alpha) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_FILLER_SUPPORTED) || defined(PNG_WRITE_FILLER_SUPPORTED) +/* Add a filler byte to 8-bit Gray or 24-bit RGB images. */ +extern PNG_EXPORT(void,png_set_filler) PNGARG((png_structp png_ptr, + png_uint_32 filler, int flags)); +/* The values of the PNG_FILLER_ defines should NOT be changed */ +#define PNG_FILLER_BEFORE 0 +#define PNG_FILLER_AFTER 1 +/* Add an alpha byte to 8-bit Gray or 24-bit RGB images. */ +#if !defined(PNG_1_0_X) +extern PNG_EXPORT(void,png_set_add_alpha) PNGARG((png_structp png_ptr, + png_uint_32 filler, int flags)); +#endif +#endif /* PNG_READ_FILLER_SUPPORTED || PNG_WRITE_FILLER_SUPPORTED */ + +#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) +/* Swap bytes in 16-bit depth files. */ +extern PNG_EXPORT(void,png_set_swap) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_PACK_SUPPORTED) || defined(PNG_WRITE_PACK_SUPPORTED) +/* Use 1 byte per pixel in 1, 2, or 4-bit depth files. */ +extern PNG_EXPORT(void,png_set_packing) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED) +/* Swap packing order of pixels in bytes. */ +extern PNG_EXPORT(void,png_set_packswap) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_SHIFT_SUPPORTED) || defined(PNG_WRITE_SHIFT_SUPPORTED) +/* Converts files to legal bit depths. */ +extern PNG_EXPORT(void,png_set_shift) PNGARG((png_structp png_ptr, + png_color_8p true_bits)); +#endif + +#if defined(PNG_READ_INTERLACING_SUPPORTED) || \ + defined(PNG_WRITE_INTERLACING_SUPPORTED) +/* Have the code handle the interlacing. Returns the number of passes. */ +extern PNG_EXPORT(int,png_set_interlace_handling) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) +/* Invert monochrome files */ +extern PNG_EXPORT(void,png_set_invert_mono) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_BACKGROUND_SUPPORTED) +/* Handle alpha and tRNS by replacing with a background color. */ +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_background) PNGARG((png_structp png_ptr, + png_color_16p background_color, int background_gamma_code, + int need_expand, double background_gamma)); +#endif +#define PNG_BACKGROUND_GAMMA_UNKNOWN 0 +#define PNG_BACKGROUND_GAMMA_SCREEN 1 +#define PNG_BACKGROUND_GAMMA_FILE 2 +#define PNG_BACKGROUND_GAMMA_UNIQUE 3 +#endif + +#if defined(PNG_READ_16_TO_8_SUPPORTED) +/* strip the second byte of information from a 16-bit depth file. */ +extern PNG_EXPORT(void,png_set_strip_16) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_DITHER_SUPPORTED) +/* Turn on dithering, and reduce the palette to the number of colors available. */ +extern PNG_EXPORT(void,png_set_dither) PNGARG((png_structp png_ptr, + png_colorp palette, int num_palette, int maximum_colors, + png_uint_16p histogram, int full_dither)); +#endif + +#if defined(PNG_READ_GAMMA_SUPPORTED) +/* Handle gamma correction. Screen_gamma=(display_exponent) */ +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_gamma) PNGARG((png_structp png_ptr, + double screen_gamma, double default_file_gamma)); +#endif +#endif + +#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +#if defined(PNG_READ_EMPTY_PLTE_SUPPORTED) || \ + defined(PNG_WRITE_EMPTY_PLTE_SUPPORTED) +/* Permit or disallow empty PLTE (0: not permitted, 1: permitted) */ +/* Deprecated and will be removed. Use png_permit_mng_features() instead. */ +extern PNG_EXPORT(void,png_permit_empty_plte) PNGARG((png_structp png_ptr, + int empty_plte_permitted)); +#endif +#endif + +#if defined(PNG_WRITE_FLUSH_SUPPORTED) +/* Set how many lines between output flushes - 0 for no flushing */ +extern PNG_EXPORT(void,png_set_flush) PNGARG((png_structp png_ptr, int nrows)); +/* Flush the current PNG output buffer */ +extern PNG_EXPORT(void,png_write_flush) PNGARG((png_structp png_ptr)); +#endif + +/* optional update palette with requested transformations */ +extern PNG_EXPORT(void,png_start_read_image) PNGARG((png_structp png_ptr)); + +/* optional call to update the users info structure */ +extern PNG_EXPORT(void,png_read_update_info) PNGARG((png_structp png_ptr, + png_infop info_ptr)); + +#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED +/* read one or more rows of image data. */ +extern PNG_EXPORT(void,png_read_rows) PNGARG((png_structp png_ptr, + png_bytepp row, png_bytepp display_row, png_uint_32 num_rows)); +#endif + +#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED +/* read a row of data. */ +extern PNG_EXPORT(void,png_read_row) PNGARG((png_structp png_ptr, + png_bytep row, + png_bytep display_row)); +#endif + +#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED +/* read the whole image into memory at once. */ +extern PNG_EXPORT(void,png_read_image) PNGARG((png_structp png_ptr, + png_bytepp image)); +#endif + +/* write a row of image data */ +extern PNG_EXPORT(void,png_write_row) PNGARG((png_structp png_ptr, + png_bytep row)); + +/* write a few rows of image data */ +extern PNG_EXPORT(void,png_write_rows) PNGARG((png_structp png_ptr, + png_bytepp row, png_uint_32 num_rows)); + +/* write the image data */ +extern PNG_EXPORT(void,png_write_image) PNGARG((png_structp png_ptr, + png_bytepp image)); + +/* writes the end of the PNG file. */ +extern PNG_EXPORT(void,png_write_end) PNGARG((png_structp png_ptr, + png_infop info_ptr)); + +#ifndef PNG_NO_SEQUENTIAL_READ_SUPPORTED +/* read the end of the PNG file. */ +extern PNG_EXPORT(void,png_read_end) PNGARG((png_structp png_ptr, + png_infop info_ptr)); +#endif + +/* free any memory associated with the png_info_struct */ +extern PNG_EXPORT(void,png_destroy_info_struct) PNGARG((png_structp png_ptr, + png_infopp info_ptr_ptr)); + +/* free any memory associated with the png_struct and the png_info_structs */ +extern PNG_EXPORT(void,png_destroy_read_struct) PNGARG((png_structpp + png_ptr_ptr, png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr)); + +/* free all memory used by the read (old method - NOT DLL EXPORTED) */ +/* Debian note: exporting as it is required by legacy applications */ +extern PNG_EXPORT(void,png_read_destroy) PNGARG((png_structp png_ptr, png_infop info_ptr, + png_infop end_info_ptr)); + +/* free any memory associated with the png_struct and the png_info_structs */ +extern PNG_EXPORT(void,png_destroy_write_struct) + PNGARG((png_structpp png_ptr_ptr, png_infopp info_ptr_ptr)); + +/* free any memory used in png_ptr struct (old method - NOT DLL EXPORTED) */ +/* Debian note: exporting as it is required by legacy applications */ +extern PNG_EXPORT(void,png_write_destroy) PNGARG((png_structp png_ptr)); + +/* set the libpng method of handling chunk CRC errors */ +extern PNG_EXPORT(void,png_set_crc_action) PNGARG((png_structp png_ptr, + int crit_action, int ancil_action)); + +/* Values for png_set_crc_action() to say how to handle CRC errors in + * ancillary and critical chunks, and whether to use the data contained + * therein. Note that it is impossible to "discard" data in a critical + * chunk. For versions prior to 0.90, the action was always error/quit, + * whereas in version 0.90 and later, the action for CRC errors in ancillary + * chunks is warn/discard. These values should NOT be changed. + * + * value action:critical action:ancillary + */ +#define PNG_CRC_DEFAULT 0 /* error/quit warn/discard data */ +#define PNG_CRC_ERROR_QUIT 1 /* error/quit error/quit */ +#define PNG_CRC_WARN_DISCARD 2 /* (INVALID) warn/discard data */ +#define PNG_CRC_WARN_USE 3 /* warn/use data warn/use data */ +#define PNG_CRC_QUIET_USE 4 /* quiet/use data quiet/use data */ +#define PNG_CRC_NO_CHANGE 5 /* use current value use current value */ + +/* These functions give the user control over the scan-line filtering in + * libpng and the compression methods used by zlib. These functions are + * mainly useful for testing, as the defaults should work with most users. + * Those users who are tight on memory or want faster performance at the + * expense of compression can modify them. See the compression library + * header file (zlib.h) for an explination of the compression functions. + */ + +/* set the filtering method(s) used by libpng. Currently, the only valid + * value for "method" is 0. + */ +extern PNG_EXPORT(void,png_set_filter) PNGARG((png_structp png_ptr, int method, + int filters)); + +/* Flags for png_set_filter() to say which filters to use. The flags + * are chosen so that they don't conflict with real filter types + * below, in case they are supplied instead of the #defined constants. + * These values should NOT be changed. + */ +#define PNG_NO_FILTERS 0x00 +#define PNG_FILTER_NONE 0x08 +#define PNG_FILTER_SUB 0x10 +#define PNG_FILTER_UP 0x20 +#define PNG_FILTER_AVG 0x40 +#define PNG_FILTER_PAETH 0x80 +#define PNG_ALL_FILTERS (PNG_FILTER_NONE | PNG_FILTER_SUB | PNG_FILTER_UP | \ + PNG_FILTER_AVG | PNG_FILTER_PAETH) + +/* Filter values (not flags) - used in pngwrite.c, pngwutil.c for now. + * These defines should NOT be changed. + */ +#define PNG_FILTER_VALUE_NONE 0 +#define PNG_FILTER_VALUE_SUB 1 +#define PNG_FILTER_VALUE_UP 2 +#define PNG_FILTER_VALUE_AVG 3 +#define PNG_FILTER_VALUE_PAETH 4 +#define PNG_FILTER_VALUE_LAST 5 + +#if defined(PNG_WRITE_WEIGHTED_FILTER_SUPPORTED) /* EXPERIMENTAL */ +/* The "heuristic_method" is given by one of the PNG_FILTER_HEURISTIC_ + * defines, either the default (minimum-sum-of-absolute-differences), or + * the experimental method (weighted-minimum-sum-of-absolute-differences). + * + * Weights are factors >= 1.0, indicating how important it is to keep the + * filter type consistent between rows. Larger numbers mean the current + * filter is that many times as likely to be the same as the "num_weights" + * previous filters. This is cumulative for each previous row with a weight. + * There needs to be "num_weights" values in "filter_weights", or it can be + * NULL if the weights aren't being specified. Weights have no influence on + * the selection of the first row filter. Well chosen weights can (in theory) + * improve the compression for a given image. + * + * Costs are factors >= 1.0 indicating the relative decoding costs of a + * filter type. Higher costs indicate more decoding expense, and are + * therefore less likely to be selected over a filter with lower computational + * costs. There needs to be a value in "filter_costs" for each valid filter + * type (given by PNG_FILTER_VALUE_LAST), or it can be NULL if you aren't + * setting the costs. Costs try to improve the speed of decompression without + * unduly increasing the compressed image size. + * + * A negative weight or cost indicates the default value is to be used, and + * values in the range [0.0, 1.0) indicate the value is to remain unchanged. + * The default values for both weights and costs are currently 1.0, but may + * change if good general weighting/cost heuristics can be found. If both + * the weights and costs are set to 1.0, this degenerates the WEIGHTED method + * to the UNWEIGHTED method, but with added encoding time/computation. + */ +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_filter_heuristics) PNGARG((png_structp png_ptr, + int heuristic_method, int num_weights, png_doublep filter_weights, + png_doublep filter_costs)); +#endif +#endif /* PNG_WRITE_WEIGHTED_FILTER_SUPPORTED */ + +/* Heuristic used for row filter selection. These defines should NOT be + * changed. + */ +#define PNG_FILTER_HEURISTIC_DEFAULT 0 /* Currently "UNWEIGHTED" */ +#define PNG_FILTER_HEURISTIC_UNWEIGHTED 1 /* Used by libpng < 0.95 */ +#define PNG_FILTER_HEURISTIC_WEIGHTED 2 /* Experimental feature */ +#define PNG_FILTER_HEURISTIC_LAST 3 /* Not a valid value */ + +/* Set the library compression level. Currently, valid values range from + * 0 - 9, corresponding directly to the zlib compression levels 0 - 9 + * (0 - no compression, 9 - "maximal" compression). Note that tests have + * shown that zlib compression levels 3-6 usually perform as well as level 9 + * for PNG images, and do considerably fewer caclulations. In the future, + * these values may not correspond directly to the zlib compression levels. + */ +extern PNG_EXPORT(void,png_set_compression_level) PNGARG((png_structp png_ptr, + int level)); + +extern PNG_EXPORT(void,png_set_compression_mem_level) + PNGARG((png_structp png_ptr, int mem_level)); + +extern PNG_EXPORT(void,png_set_compression_strategy) + PNGARG((png_structp png_ptr, int strategy)); + +extern PNG_EXPORT(void,png_set_compression_window_bits) + PNGARG((png_structp png_ptr, int window_bits)); + +extern PNG_EXPORT(void,png_set_compression_method) PNGARG((png_structp png_ptr, + int method)); + +/* These next functions are called for input/output, memory, and error + * handling. They are in the file pngrio.c, pngwio.c, and pngerror.c, + * and call standard C I/O routines such as fread(), fwrite(), and + * fprintf(). These functions can be made to use other I/O routines + * at run time for those applications that need to handle I/O in a + * different manner by calling png_set_???_fn(). See libpng.txt for + * more information. + */ + +#if !defined(PNG_NO_STDIO) +/* Initialize the input/output for the PNG file to the default functions. */ +extern PNG_EXPORT(void,png_init_io) PNGARG((png_structp png_ptr, png_FILE_p fp)); +#endif + +/* Replace the (error and abort), and warning functions with user + * supplied functions. If no messages are to be printed you must still + * write and use replacement functions. The replacement error_fn should + * still do a longjmp to the last setjmp location if you are using this + * method of error handling. If error_fn or warning_fn is NULL, the + * default function will be used. + */ + +extern PNG_EXPORT(void,png_set_error_fn) PNGARG((png_structp png_ptr, + png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warning_fn)); + +/* Return the user pointer associated with the error functions */ +extern PNG_EXPORT(png_voidp,png_get_error_ptr) PNGARG((png_structp png_ptr)); + +/* Replace the default data output functions with a user supplied one(s). + * If buffered output is not used, then output_flush_fn can be set to NULL. + * If PNG_WRITE_FLUSH_SUPPORTED is not defined at libpng compile time + * output_flush_fn will be ignored (and thus can be NULL). + * It is probably a mistake to use NULL for output_flush_fn if + * write_data_fn is not also NULL unless you have built libpng with + * PNG_WRITE_FLUSH_SUPPORTED undefined, because in this case libpng's + * default flush function, which uses the standard *FILE structure, will + * be used. + */ +extern PNG_EXPORT(void,png_set_write_fn) PNGARG((png_structp png_ptr, + png_voidp io_ptr, png_rw_ptr write_data_fn, png_flush_ptr output_flush_fn)); + +/* Replace the default data input function with a user supplied one. */ +extern PNG_EXPORT(void,png_set_read_fn) PNGARG((png_structp png_ptr, + png_voidp io_ptr, png_rw_ptr read_data_fn)); + +/* Return the user pointer associated with the I/O functions */ +extern PNG_EXPORT(png_voidp,png_get_io_ptr) PNGARG((png_structp png_ptr)); + +extern PNG_EXPORT(void,png_set_read_status_fn) PNGARG((png_structp png_ptr, + png_read_status_ptr read_row_fn)); + +extern PNG_EXPORT(void,png_set_write_status_fn) PNGARG((png_structp png_ptr, + png_write_status_ptr write_row_fn)); + +#ifdef PNG_USER_MEM_SUPPORTED +/* Replace the default memory allocation functions with user supplied one(s). */ +extern PNG_EXPORT(void,png_set_mem_fn) PNGARG((png_structp png_ptr, + png_voidp mem_ptr, png_malloc_ptr malloc_fn, png_free_ptr free_fn)); +/* Return the user pointer associated with the memory functions */ +extern PNG_EXPORT(png_voidp,png_get_mem_ptr) PNGARG((png_structp png_ptr)); +#endif + +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_LEGACY_SUPPORTED) +extern PNG_EXPORT(void,png_set_read_user_transform_fn) PNGARG((png_structp + png_ptr, png_user_transform_ptr read_user_transform_fn)); +#endif + +#if defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_LEGACY_SUPPORTED) +extern PNG_EXPORT(void,png_set_write_user_transform_fn) PNGARG((png_structp + png_ptr, png_user_transform_ptr write_user_transform_fn)); +#endif + +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_LEGACY_SUPPORTED) +extern PNG_EXPORT(void,png_set_user_transform_info) PNGARG((png_structp + png_ptr, png_voidp user_transform_ptr, int user_transform_depth, + int user_transform_channels)); +/* Return the user pointer associated with the user transform functions */ +extern PNG_EXPORT(png_voidp,png_get_user_transform_ptr) + PNGARG((png_structp png_ptr)); +#endif + +#ifdef PNG_USER_CHUNKS_SUPPORTED +extern PNG_EXPORT(void,png_set_read_user_chunk_fn) PNGARG((png_structp png_ptr, + png_voidp user_chunk_ptr, png_user_chunk_ptr read_user_chunk_fn)); +extern PNG_EXPORT(png_voidp,png_get_user_chunk_ptr) PNGARG((png_structp + 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. + */ +extern PNG_EXPORT(void,png_set_progressive_read_fn) PNGARG((png_structp 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 */ +extern PNG_EXPORT(png_voidp,png_get_progressive_ptr) + PNGARG((png_structp png_ptr)); + +/* function to be called when data becomes available */ +extern PNG_EXPORT(void,png_process_data) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_bytep buffer, png_size_t buffer_size)); + +/* function that combines rows. Not very much different than the + * png_combine_row() call. Is this even used????? + */ +extern PNG_EXPORT(void,png_progressive_combine_row) PNGARG((png_structp png_ptr, + png_bytep old_row, png_bytep new_row)); +#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ + +extern PNG_EXPORT(png_voidp,png_malloc) PNGARG((png_structp png_ptr, + png_uint_32 size)); + +#if defined(PNG_1_0_X) +# define png_malloc_warn png_malloc +#else +/* Added at libpng version 1.2.4 */ +extern PNG_EXPORT(png_voidp,png_malloc_warn) PNGARG((png_structp png_ptr, + png_uint_32 size)); +#endif + +/* frees a pointer allocated by png_malloc() */ +extern PNG_EXPORT(void,png_free) PNGARG((png_structp png_ptr, png_voidp ptr)); + +#if defined(PNG_1_0_X) +/* Function to allocate memory for zlib. */ +extern PNG_EXPORT(voidpf,png_zalloc) PNGARG((voidpf png_ptr, uInt items, + uInt size)); + +/* Function to free memory for zlib */ +extern PNG_EXPORT(void,png_zfree) PNGARG((voidpf png_ptr, voidpf ptr)); +#endif + +/* Free data that was allocated internally */ +extern PNG_EXPORT(void,png_free_data) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 free_me, int num)); +#ifdef PNG_FREE_ME_SUPPORTED +/* Reassign responsibility for freeing existing data, whether allocated + * by libpng or by the application */ +extern PNG_EXPORT(void,png_data_freer) PNGARG((png_structp png_ptr, + png_infop info_ptr, int freer, png_uint_32 mask)); +#endif +/* assignments for png_data_freer */ +#define PNG_DESTROY_WILL_FREE_DATA 1 +#define PNG_SET_WILL_FREE_DATA 1 +#define PNG_USER_WILL_FREE_DATA 2 +/* Flags for png_ptr->free_me and info_ptr->free_me */ +#define PNG_FREE_HIST 0x0008 +#define PNG_FREE_ICCP 0x0010 +#define PNG_FREE_SPLT 0x0020 +#define PNG_FREE_ROWS 0x0040 +#define PNG_FREE_PCAL 0x0080 +#define PNG_FREE_SCAL 0x0100 +#define PNG_FREE_UNKN 0x0200 +#define PNG_FREE_LIST 0x0400 +#define PNG_FREE_PLTE 0x1000 +#define PNG_FREE_TRNS 0x2000 +#define PNG_FREE_TEXT 0x4000 +#define PNG_FREE_ALL 0x7fff +#define PNG_FREE_MUL 0x4220 /* PNG_FREE_SPLT|PNG_FREE_TEXT|PNG_FREE_UNKN */ + +#ifdef PNG_USER_MEM_SUPPORTED +extern PNG_EXPORT(png_voidp,png_malloc_default) PNGARG((png_structp png_ptr, + png_uint_32 size)); +extern PNG_EXPORT(void,png_free_default) PNGARG((png_structp png_ptr, + png_voidp ptr)); +#endif + +extern PNG_EXPORT(png_voidp,png_memcpy_check) PNGARG((png_structp png_ptr, + png_voidp s1, png_voidp s2, png_uint_32 size)); + +extern PNG_EXPORT(png_voidp,png_memset_check) PNGARG((png_structp png_ptr, + png_voidp s1, int value, png_uint_32 size)); + +#if defined(USE_FAR_KEYWORD) /* memory model conversion function */ +extern void *png_far_to_near PNGARG((png_structp png_ptr,png_voidp ptr, + int check)); +#endif /* USE_FAR_KEYWORD */ + +#ifndef PNG_NO_ERROR_TEXT +/* Fatal error in PNG image of libpng - can't continue */ +extern PNG_EXPORT(void,png_error) PNGARG((png_structp png_ptr, + png_const_charp error_message)); + +/* The same, but the chunk name is prepended to the error string. */ +extern PNG_EXPORT(void,png_chunk_error) PNGARG((png_structp png_ptr, + png_const_charp error_message)); +#else +/* Fatal error in PNG image of libpng - can't continue */ +extern PNG_EXPORT(void,png_err) PNGARG((png_structp png_ptr)); +#endif + +#ifndef PNG_NO_WARNINGS +/* Non-fatal error in libpng. Can continue, but may have a problem. */ +extern PNG_EXPORT(void,png_warning) PNGARG((png_structp png_ptr, + png_const_charp warning_message)); + +#ifdef PNG_READ_SUPPORTED +/* Non-fatal error in libpng, chunk name is prepended to message. */ +extern PNG_EXPORT(void,png_chunk_warning) PNGARG((png_structp png_ptr, + png_const_charp warning_message)); +#endif /* PNG_READ_SUPPORTED */ +#endif /* PNG_NO_WARNINGS */ + +/* The png_set_ functions are for storing values in the png_info_struct. + * Similarly, the png_get_ calls are used to read values from the + * png_info_struct, either storing the parameters in the passed variables, or + * setting pointers into the png_info_struct where the data is stored. The + * png_get_ functions return a non-zero value if the data was available + * in info_ptr, or return zero and do not change any of the parameters if the + * data was not available. + * + * These functions should be used instead of directly accessing png_info + * to avoid problems with future changes in the size and internal layout of + * png_info_struct. + */ +/* Returns "flag" if chunk data is valid in info_ptr. */ +extern PNG_EXPORT(png_uint_32,png_get_valid) PNGARG((png_structp png_ptr, +png_infop info_ptr, png_uint_32 flag)); + +/* Returns number of bytes needed to hold a transformed row. */ +extern PNG_EXPORT(png_uint_32,png_get_rowbytes) PNGARG((png_structp png_ptr, +png_infop info_ptr)); + +#if defined(PNG_INFO_IMAGE_SUPPORTED) +/* Returns row_pointers, which is an array of pointers to scanlines that was +returned from png_read_png(). */ +extern PNG_EXPORT(png_bytepp,png_get_rows) PNGARG((png_structp png_ptr, +png_infop info_ptr)); +/* Set row_pointers, which is an array of pointers to scanlines for use +by png_write_png(). */ +extern PNG_EXPORT(void,png_set_rows) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_bytepp row_pointers)); +#endif + +/* Returns number of color channels in image. */ +extern PNG_EXPORT(png_byte,png_get_channels) PNGARG((png_structp png_ptr, +png_infop info_ptr)); + +#ifdef PNG_EASY_ACCESS_SUPPORTED +/* Returns image width in pixels. */ +extern PNG_EXPORT(png_uint_32, png_get_image_width) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image height in pixels. */ +extern PNG_EXPORT(png_uint_32, png_get_image_height) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image bit_depth. */ +extern PNG_EXPORT(png_byte, png_get_bit_depth) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image color_type. */ +extern PNG_EXPORT(png_byte, png_get_color_type) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image filter_type. */ +extern PNG_EXPORT(png_byte, png_get_filter_type) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image interlace_type. */ +extern PNG_EXPORT(png_byte, png_get_interlace_type) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image compression_type. */ +extern PNG_EXPORT(png_byte, png_get_compression_type) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns image resolution in pixels per meter, from pHYs chunk data. */ +extern PNG_EXPORT(png_uint_32, png_get_pixels_per_meter) PNGARG((png_structp +png_ptr, png_infop info_ptr)); +extern PNG_EXPORT(png_uint_32, png_get_x_pixels_per_meter) PNGARG((png_structp +png_ptr, png_infop info_ptr)); +extern PNG_EXPORT(png_uint_32, png_get_y_pixels_per_meter) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +/* Returns pixel aspect ratio, computed from pHYs chunk data. */ +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(float, png_get_pixel_aspect_ratio) PNGARG((png_structp +png_ptr, png_infop info_ptr)); +#endif + +/* Returns image x, y offset in pixels or microns, from oFFs chunk data. */ +extern PNG_EXPORT(png_int_32, png_get_x_offset_pixels) PNGARG((png_structp +png_ptr, png_infop info_ptr)); +extern PNG_EXPORT(png_int_32, png_get_y_offset_pixels) PNGARG((png_structp +png_ptr, png_infop info_ptr)); +extern PNG_EXPORT(png_int_32, png_get_x_offset_microns) PNGARG((png_structp +png_ptr, png_infop info_ptr)); +extern PNG_EXPORT(png_int_32, png_get_y_offset_microns) PNGARG((png_structp +png_ptr, png_infop info_ptr)); + +#endif /* PNG_EASY_ACCESS_SUPPORTED */ + +/* Returns pointer to signature string read from PNG header */ +extern PNG_EXPORT(png_bytep,png_get_signature) PNGARG((png_structp png_ptr, +png_infop info_ptr)); + +#if defined(PNG_bKGD_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_bKGD) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_color_16p *background)); +#endif + +#if defined(PNG_bKGD_SUPPORTED) +extern PNG_EXPORT(void,png_set_bKGD) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_color_16p background)); +#endif + +#if defined(PNG_cHRM_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(png_uint_32,png_get_cHRM) PNGARG((png_structp png_ptr, + png_infop info_ptr, double *white_x, double *white_y, double *red_x, + double *red_y, double *green_x, double *green_y, double *blue_x, + double *blue_y)); +#endif +#ifdef PNG_FIXED_POINT_SUPPORTED +extern PNG_EXPORT(png_uint_32,png_get_cHRM_fixed) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_fixed_point *int_white_x, png_fixed_point + *int_white_y, png_fixed_point *int_red_x, png_fixed_point *int_red_y, + png_fixed_point *int_green_x, png_fixed_point *int_green_y, png_fixed_point + *int_blue_x, png_fixed_point *int_blue_y)); +#endif +#endif + +#if defined(PNG_cHRM_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_cHRM) PNGARG((png_structp png_ptr, + png_infop info_ptr, double white_x, double white_y, double red_x, + double red_y, double green_x, double green_y, double blue_x, double blue_y)); +#endif +#ifdef PNG_FIXED_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_cHRM_fixed) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_fixed_point int_white_x, png_fixed_point int_white_y, + png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point + int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, + png_fixed_point int_blue_y)); +#endif +#endif + +#if defined(PNG_gAMA_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(png_uint_32,png_get_gAMA) PNGARG((png_structp png_ptr, + png_infop info_ptr, double *file_gamma)); +#endif +extern PNG_EXPORT(png_uint_32,png_get_gAMA_fixed) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_fixed_point *int_file_gamma)); +#endif + +#if defined(PNG_gAMA_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_gAMA) PNGARG((png_structp png_ptr, + png_infop info_ptr, double file_gamma)); +#endif +extern PNG_EXPORT(void,png_set_gAMA_fixed) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_fixed_point int_file_gamma)); +#endif + +#if defined(PNG_hIST_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_hIST) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_16p *hist)); +#endif + +#if defined(PNG_hIST_SUPPORTED) +extern PNG_EXPORT(void,png_set_hIST) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_16p hist)); +#endif + +extern PNG_EXPORT(png_uint_32,png_get_IHDR) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 *width, png_uint_32 *height, + int *bit_depth, int *color_type, int *interlace_method, + int *compression_method, int *filter_method)); + +extern PNG_EXPORT(void,png_set_IHDR) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 width, png_uint_32 height, int bit_depth, + int color_type, int interlace_method, int compression_method, + int filter_method)); + +#if defined(PNG_oFFs_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_oFFs) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_int_32 *offset_x, png_int_32 *offset_y, + int *unit_type)); +#endif + +#if defined(PNG_oFFs_SUPPORTED) +extern PNG_EXPORT(void,png_set_oFFs) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_int_32 offset_x, png_int_32 offset_y, + int unit_type)); +#endif + +#if defined(PNG_pCAL_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_pCAL) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_charp *purpose, png_int_32 *X0, png_int_32 *X1, + int *type, int *nparams, png_charp *units, png_charpp *params)); +#endif + +#if defined(PNG_pCAL_SUPPORTED) +extern PNG_EXPORT(void,png_set_pCAL) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_charp purpose, png_int_32 X0, png_int_32 X1, + int type, int nparams, png_charp units, png_charpp params)); +#endif + +#if defined(PNG_pHYs_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_pHYs) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)); +#endif + +#if defined(PNG_pHYs_SUPPORTED) +extern PNG_EXPORT(void,png_set_pHYs) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 res_x, png_uint_32 res_y, int unit_type)); +#endif + +extern PNG_EXPORT(png_uint_32,png_get_PLTE) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_colorp *palette, int *num_palette)); + +extern PNG_EXPORT(void,png_set_PLTE) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_colorp palette, int num_palette)); + +#if defined(PNG_sBIT_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_sBIT) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_color_8p *sig_bit)); +#endif + +#if defined(PNG_sBIT_SUPPORTED) +extern PNG_EXPORT(void,png_set_sBIT) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_color_8p sig_bit)); +#endif + +#if defined(PNG_sRGB_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_sRGB) PNGARG((png_structp png_ptr, + png_infop info_ptr, int *intent)); +#endif + +#if defined(PNG_sRGB_SUPPORTED) +extern PNG_EXPORT(void,png_set_sRGB) PNGARG((png_structp png_ptr, + png_infop info_ptr, int intent)); +extern PNG_EXPORT(void,png_set_sRGB_gAMA_and_cHRM) PNGARG((png_structp png_ptr, + png_infop info_ptr, int intent)); +#endif + +#if defined(PNG_iCCP_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_iCCP) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_charpp name, int *compression_type, + png_charpp profile, png_uint_32 *proflen)); + /* Note to maintainer: profile should be png_bytepp */ +#endif + +#if defined(PNG_iCCP_SUPPORTED) +extern PNG_EXPORT(void,png_set_iCCP) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_charp name, int compression_type, + png_charp profile, png_uint_32 proflen)); + /* Note to maintainer: profile should be png_bytep */ +#endif + +#if defined(PNG_sPLT_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_sPLT) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_sPLT_tpp entries)); +#endif + +#if defined(PNG_sPLT_SUPPORTED) +extern PNG_EXPORT(void,png_set_sPLT) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_sPLT_tp entries, int nentries)); +#endif + +#if defined(PNG_TEXT_SUPPORTED) +/* png_get_text also returns the number of text chunks in *num_text */ +extern PNG_EXPORT(png_uint_32,png_get_text) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_textp *text_ptr, int *num_text)); +#endif + +/* + * Note while png_set_text() will accept a structure whose text, + * language, and translated keywords are NULL pointers, the structure + * returned by png_get_text will always contain regular + * zero-terminated C strings. They might be empty strings but + * they will never be NULL pointers. + */ + +#if defined(PNG_TEXT_SUPPORTED) +extern PNG_EXPORT(void,png_set_text) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_textp text_ptr, int num_text)); +#endif + +#if defined(PNG_tIME_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_tIME) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_timep *mod_time)); +#endif + +#if defined(PNG_tIME_SUPPORTED) +extern PNG_EXPORT(void,png_set_tIME) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_timep mod_time)); +#endif + +#if defined(PNG_tRNS_SUPPORTED) +extern PNG_EXPORT(png_uint_32,png_get_tRNS) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_bytep *trans, int *num_trans, + png_color_16p *trans_values)); +#endif + +#if defined(PNG_tRNS_SUPPORTED) +extern PNG_EXPORT(void,png_set_tRNS) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_bytep trans, int num_trans, + png_color_16p trans_values)); +#endif + +#if defined(PNG_tRNS_SUPPORTED) +#endif + +#if defined(PNG_sCAL_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(png_uint_32,png_get_sCAL) PNGARG((png_structp png_ptr, + png_infop info_ptr, int *unit, double *width, double *height)); +#else +#ifdef PNG_FIXED_POINT_SUPPORTED +extern PNG_EXPORT(png_uint_32,png_get_sCAL_s) PNGARG((png_structp png_ptr, + png_infop info_ptr, int *unit, png_charpp swidth, png_charpp sheight)); +#endif +#endif +#endif /* PNG_sCAL_SUPPORTED */ + +#if defined(PNG_sCAL_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_sCAL) PNGARG((png_structp png_ptr, + png_infop info_ptr, int unit, double width, double height)); +#else +#ifdef PNG_FIXED_POINT_SUPPORTED +extern PNG_EXPORT(void,png_set_sCAL_s) PNGARG((png_structp png_ptr, + png_infop info_ptr, int unit, png_charp swidth, png_charp sheight)); +#endif +#endif +#endif /* PNG_sCAL_SUPPORTED || PNG_WRITE_sCAL_SUPPORTED */ + +#if defined(PNG_UNKNOWN_CHUNKS_SUPPORTED) +/* provide a list of chunks and how they are to be handled, if the built-in + handling or default unknown chunk handling is not desired. Any chunks not + listed will be handled in the default manner. The IHDR and IEND chunks + must not be listed. + keep = 0: follow default behaviour + = 1: do not keep + = 2: keep only if safe-to-copy + = 3: keep even if unsafe-to-copy +*/ +extern PNG_EXPORT(void, png_set_keep_unknown_chunks) PNGARG((png_structp + png_ptr, int keep, png_bytep chunk_list, int num_chunks)); +extern PNG_EXPORT(void, png_set_unknown_chunks) PNGARG((png_structp png_ptr, + png_infop info_ptr, png_unknown_chunkp unknowns, int num_unknowns)); +extern PNG_EXPORT(void, png_set_unknown_chunk_location) + PNGARG((png_structp png_ptr, png_infop info_ptr, int chunk, int location)); +extern PNG_EXPORT(png_uint_32,png_get_unknown_chunks) PNGARG((png_structp + png_ptr, png_infop info_ptr, png_unknown_chunkpp entries)); +#endif +#ifdef PNG_HANDLE_AS_UNKNOWN_SUPPORTED +PNG_EXPORT(int,png_handle_as_unknown) PNGARG((png_structp png_ptr, png_bytep + chunk_name)); +#endif + +/* Png_free_data() will turn off the "valid" flag for anything it frees. + If you need to turn it off for a chunk that your application has freed, + you can use png_set_invalid(png_ptr, info_ptr, PNG_INFO_CHNK); */ +extern PNG_EXPORT(void, png_set_invalid) PNGARG((png_structp png_ptr, + png_infop info_ptr, int mask)); + +#if defined(PNG_INFO_IMAGE_SUPPORTED) +/* The "params" pointer is currently not used and is for future expansion. */ +extern PNG_EXPORT(void, png_read_png) PNGARG((png_structp png_ptr, + png_infop info_ptr, + int transforms, + png_voidp params)); +extern PNG_EXPORT(void, png_write_png) PNGARG((png_structp png_ptr, + png_infop info_ptr, + int transforms, + png_voidp params)); +#endif + +/* Define PNG_DEBUG at compile time for debugging information. Higher + * numbers for PNG_DEBUG mean more debugging information. This has + * only been added since version 0.95 so it is not implemented throughout + * libpng yet, but more support will be added as needed. + */ +#ifdef PNG_DEBUG +#if (PNG_DEBUG > 0) +#if !defined(PNG_DEBUG_FILE) && defined(_MSC_VER) +#include +#if (PNG_DEBUG > 1) +#ifndef _DEBUG +# define _DEBUG +#endif +#ifndef png_debug +#define png_debug(l,m) _RPT0(_CRT_WARN,m PNG_STRING_NEWLINE) +#endif +#ifndef png_debug1 +#define png_debug1(l,m,p1) _RPT1(_CRT_WARN,m PNG_STRING_NEWLINE,p1) +#endif +#ifndef png_debug2 +#define png_debug2(l,m,p1,p2) _RPT2(_CRT_WARN,m PNG_STRING_NEWLINE,p1,p2) +#endif +#endif +#else /* PNG_DEBUG_FILE || !_MSC_VER */ +#ifndef PNG_DEBUG_FILE +#define PNG_DEBUG_FILE stderr +#endif /* PNG_DEBUG_FILE */ + +#if (PNG_DEBUG > 1) +/* Note: ["%s"m PNG_STRING_NEWLINE] probably does not work on + * non-ISO compilers */ +# ifdef __STDC__ +# ifndef png_debug +# define png_debug(l,m) \ + { \ + int num_tabs=l; \ + fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \ + (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":"")))); \ + } +# endif +# ifndef png_debug1 +# define png_debug1(l,m,p1) \ + { \ + int num_tabs=l; \ + fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \ + (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1); \ + } +# endif +# ifndef png_debug2 +# define png_debug2(l,m,p1,p2) \ + { \ + int num_tabs=l; \ + fprintf(PNG_DEBUG_FILE,"%s"m PNG_STRING_NEWLINE,(num_tabs==1 ? "\t" : \ + (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))),p1,p2); \ + } +# endif +# else /* __STDC __ */ +# ifndef png_debug +# define png_debug(l,m) \ + { \ + int num_tabs=l; \ + char format[256]; \ + snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \ + (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \ + m,PNG_STRING_NEWLINE); \ + fprintf(PNG_DEBUG_FILE,format); \ + } +# endif +# ifndef png_debug1 +# define png_debug1(l,m,p1) \ + { \ + int num_tabs=l; \ + char format[256]; \ + snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \ + (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \ + m,PNG_STRING_NEWLINE); \ + fprintf(PNG_DEBUG_FILE,format,p1); \ + } +# endif +# ifndef png_debug2 +# define png_debug2(l,m,p1,p2) \ + { \ + int num_tabs=l; \ + char format[256]; \ + snprintf(format,256,"%s%s%s",(num_tabs==1 ? "\t" : \ + (num_tabs==2 ? "\t\t":(num_tabs>2 ? "\t\t\t":""))), \ + m,PNG_STRING_NEWLINE); \ + fprintf(PNG_DEBUG_FILE,format,p1,p2); \ + } +# endif +# endif /* __STDC __ */ +#endif /* (PNG_DEBUG > 1) */ + +#endif /* _MSC_VER */ +#endif /* (PNG_DEBUG > 0) */ +#endif /* PNG_DEBUG */ +#ifndef png_debug +#define png_debug(l, m) +#endif +#ifndef png_debug1 +#define png_debug1(l, m, p1) +#endif +#ifndef png_debug2 +#define png_debug2(l, m, p1, p2) +#endif + +extern PNG_EXPORT(png_charp,png_get_copyright) PNGARG((png_structp png_ptr)); +extern PNG_EXPORT(png_charp,png_get_header_ver) PNGARG((png_structp png_ptr)); +extern PNG_EXPORT(png_charp,png_get_header_version) PNGARG((png_structp png_ptr)); +extern PNG_EXPORT(png_charp,png_get_libpng_ver) PNGARG((png_structp png_ptr)); + +#ifdef PNG_MNG_FEATURES_SUPPORTED +extern PNG_EXPORT(png_uint_32,png_permit_mng_features) PNGARG((png_structp + png_ptr, png_uint_32 mng_features_permitted)); +#endif + +/* For use in png_set_keep_unknown, added to version 1.2.6 */ +#define PNG_HANDLE_CHUNK_AS_DEFAULT 0 +#define PNG_HANDLE_CHUNK_NEVER 1 +#define PNG_HANDLE_CHUNK_IF_SAFE 2 +#define PNG_HANDLE_CHUNK_ALWAYS 3 + +/* Added to version 1.2.0 */ +#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) +#if defined(PNG_MMX_CODE_SUPPORTED) +#define PNG_ASM_FLAG_MMX_SUPPORT_COMPILED 0x01 /* not user-settable */ +#define PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU 0x02 /* not user-settable */ +#define PNG_ASM_FLAG_MMX_READ_COMBINE_ROW 0x04 +#define PNG_ASM_FLAG_MMX_READ_INTERLACE 0x08 +#define PNG_ASM_FLAG_MMX_READ_FILTER_SUB 0x10 +#define PNG_ASM_FLAG_MMX_READ_FILTER_UP 0x20 +#define PNG_ASM_FLAG_MMX_READ_FILTER_AVG 0x40 +#define PNG_ASM_FLAG_MMX_READ_FILTER_PAETH 0x80 +#define PNG_ASM_FLAGS_INITIALIZED 0x80000000 /* not user-settable */ + +#define PNG_MMX_READ_FLAGS ( PNG_ASM_FLAG_MMX_READ_COMBINE_ROW \ + | PNG_ASM_FLAG_MMX_READ_INTERLACE \ + | PNG_ASM_FLAG_MMX_READ_FILTER_SUB \ + | PNG_ASM_FLAG_MMX_READ_FILTER_UP \ + | PNG_ASM_FLAG_MMX_READ_FILTER_AVG \ + | PNG_ASM_FLAG_MMX_READ_FILTER_PAETH ) +#define PNG_MMX_WRITE_FLAGS ( 0 ) + +#define PNG_MMX_FLAGS ( PNG_ASM_FLAG_MMX_SUPPORT_COMPILED \ + | PNG_ASM_FLAG_MMX_SUPPORT_IN_CPU \ + | PNG_MMX_READ_FLAGS \ + | PNG_MMX_WRITE_FLAGS ) + +#define PNG_SELECT_READ 1 +#define PNG_SELECT_WRITE 2 +#endif /* PNG_MMX_CODE_SUPPORTED */ + +#if !defined(PNG_1_0_X) +/* pngget.c */ +extern PNG_EXPORT(png_uint_32,png_get_mmx_flagmask) + PNGARG((int flag_select, int *compilerID)); + +/* pngget.c */ +extern PNG_EXPORT(png_uint_32,png_get_asm_flagmask) + PNGARG((int flag_select)); + +/* pngget.c */ +extern PNG_EXPORT(png_uint_32,png_get_asm_flags) + PNGARG((png_structp png_ptr)); + +/* pngget.c */ +extern PNG_EXPORT(png_byte,png_get_mmx_bitdepth_threshold) + PNGARG((png_structp png_ptr)); + +/* pngget.c */ +extern PNG_EXPORT(png_uint_32,png_get_mmx_rowbytes_threshold) + PNGARG((png_structp png_ptr)); + +/* pngset.c */ +extern PNG_EXPORT(void,png_set_asm_flags) + PNGARG((png_structp png_ptr, png_uint_32 asm_flags)); + +/* pngset.c */ +extern PNG_EXPORT(void,png_set_mmx_thresholds) + PNGARG((png_structp png_ptr, png_byte mmx_bitdepth_threshold, + png_uint_32 mmx_rowbytes_threshold)); + +#endif /* PNG_1_0_X */ + +#if !defined(PNG_1_0_X) +/* png.c, pnggccrd.c, or pngvcrd.c */ +extern PNG_EXPORT(int,png_mmx_support) PNGARG((void)); +#endif /* PNG_1_0_X */ +#endif /* PNG_ASSEMBLER_CODE_SUPPORTED */ + +/* Strip the prepended error numbers ("#nnn ") from error and warning + * messages before passing them to the error or warning handler. */ +#ifdef PNG_ERROR_NUMBERS_SUPPORTED +extern PNG_EXPORT(void,png_set_strip_error_numbers) PNGARG((png_structp + png_ptr, png_uint_32 strip_mode)); +#endif + +/* Added at libpng-1.2.6 */ +#ifdef PNG_SET_USER_LIMITS_SUPPORTED +extern PNG_EXPORT(void,png_set_user_limits) PNGARG((png_structp + png_ptr, png_uint_32 user_width_max, png_uint_32 user_height_max)); +extern PNG_EXPORT(png_uint_32,png_get_user_width_max) PNGARG((png_structp + png_ptr)); +extern PNG_EXPORT(png_uint_32,png_get_user_height_max) PNGARG((png_structp + png_ptr)); +#endif + + +/* Maintainer: Put new public prototypes here ^, in libpng.3, and project defs */ + +#ifdef PNG_READ_COMPOSITE_NODIV_SUPPORTED +/* With these routines we avoid an integer divide, which will be slower on + * most machines. However, it does take more operations than the corresponding + * divide method, so it may be slower on a few RISC systems. There are two + * shifts (by 8 or 16 bits) and an addition, versus a single integer divide. + * + * Note that the rounding factors are NOT supposed to be the same! 128 and + * 32768 are correct for the NODIV code; 127 and 32767 are correct for the + * standard method. + * + * [Optimized code by Greg Roelofs and Mark Adler...blame us for bugs. :-) ] + */ + + /* fg and bg should be in `gamma 1.0' space; alpha is the opacity */ + +# define png_composite(composite, fg, alpha, bg) \ + { png_uint_16 temp = (png_uint_16)((png_uint_16)(fg) * (png_uint_16)(alpha) \ + + (png_uint_16)(bg)*(png_uint_16)(255 - \ + (png_uint_16)(alpha)) + (png_uint_16)128); \ + (composite) = (png_byte)((temp + (temp >> 8)) >> 8); } + +# define png_composite_16(composite, fg, alpha, bg) \ + { png_uint_32 temp = (png_uint_32)((png_uint_32)(fg) * (png_uint_32)(alpha) \ + + (png_uint_32)(bg)*(png_uint_32)(65535L - \ + (png_uint_32)(alpha)) + (png_uint_32)32768L); \ + (composite) = (png_uint_16)((temp + (temp >> 16)) >> 16); } + +#else /* standard method using integer division */ + +# define png_composite(composite, fg, alpha, bg) \ + (composite) = (png_byte)(((png_uint_16)(fg) * (png_uint_16)(alpha) + \ + (png_uint_16)(bg) * (png_uint_16)(255 - (png_uint_16)(alpha)) + \ + (png_uint_16)127) / 255) + +# define png_composite_16(composite, fg, alpha, bg) \ + (composite) = (png_uint_16)(((png_uint_32)(fg) * (png_uint_32)(alpha) + \ + (png_uint_32)(bg)*(png_uint_32)(65535L - (png_uint_32)(alpha)) + \ + (png_uint_32)32767) / (png_uint_32)65535L) + +#endif /* PNG_READ_COMPOSITE_NODIV_SUPPORTED */ + +/* Inline macros to do direct reads of bytes from the input buffer. These + * require that you are using an architecture that uses PNG byte ordering + * (MSB first) and supports unaligned data storage. I think that PowerPC + * in big-endian mode and 680x0 are the only ones that will support this. + * The x86 line of processors definitely do not. The png_get_int_32() + * routine also assumes we are using two's complement format for negative + * values, which is almost certainly true. + */ +#if defined(PNG_READ_BIG_ENDIAN_SUPPORTED) +# define png_get_uint_32(buf) ( *((png_uint_32p) (buf))) +# define png_get_uint_16(buf) ( *((png_uint_16p) (buf))) +# define png_get_int_32(buf) ( *((png_int_32p) (buf))) +#else +extern PNG_EXPORT(png_uint_32,png_get_uint_32) PNGARG((png_bytep buf)); +extern PNG_EXPORT(png_uint_16,png_get_uint_16) PNGARG((png_bytep buf)); +extern PNG_EXPORT(png_int_32,png_get_int_32) PNGARG((png_bytep buf)); +#endif /* !PNG_READ_BIG_ENDIAN_SUPPORTED */ +extern PNG_EXPORT(png_uint_32,png_get_uint_31) + PNGARG((png_structp png_ptr, png_bytep buf)); +/* No png_get_int_16 -- may be added if there's a real need for it. */ + +/* Place a 32-bit number into a buffer in PNG byte order (big-endian). + */ +extern PNG_EXPORT(void,png_save_uint_32) + PNGARG((png_bytep buf, png_uint_32 i)); +extern PNG_EXPORT(void,png_save_int_32) + PNGARG((png_bytep buf, png_int_32 i)); + +/* Place a 16-bit number into a buffer in PNG byte order. + * The parameter is declared unsigned int, not png_uint_16, + * just to avoid potential problems on pre-ANSI C compilers. + */ +extern PNG_EXPORT(void,png_save_uint_16) + PNGARG((png_bytep buf, unsigned int i)); +/* No png_save_int_16 -- may be added if there's a real need for it. */ + +/* ************************************************************************* */ + +/* These next functions are used internally in the code. They generally + * shouldn't be used unless you are writing code to add or replace some + * functionality in libpng. More information about most functions can + * be found in the files where the functions are located. + */ + + +/* Various modes of operation, that are visible to applications because + * they are used for unknown chunk location. + */ +#define PNG_HAVE_IHDR 0x01 +#define PNG_HAVE_PLTE 0x02 +#define PNG_HAVE_IDAT 0x04 +#define PNG_AFTER_IDAT 0x08 /* Have complete zlib datastream */ +#define PNG_HAVE_IEND 0x10 + +#if defined(PNG_INTERNAL) + +/* More modes of operation. Note that after an init, mode is set to + * zero automatically when the structure is created. + */ +#define PNG_HAVE_gAMA 0x20 +#define PNG_HAVE_cHRM 0x40 +#define PNG_HAVE_sRGB 0x80 +#define PNG_HAVE_CHUNK_HEADER 0x100 +#define PNG_WROTE_tIME 0x200 +#define PNG_WROTE_INFO_BEFORE_PLTE 0x400 +#define PNG_BACKGROUND_IS_GRAY 0x800 +#define PNG_HAVE_PNG_SIGNATURE 0x1000 +#define PNG_HAVE_CHUNK_AFTER_IDAT 0x2000 /* Have another chunk after IDAT */ + +/* flags for the transformations the PNG library does on the image data */ +#define PNG_BGR 0x0001 +#define PNG_INTERLACE 0x0002 +#define PNG_PACK 0x0004 +#define PNG_SHIFT 0x0008 +#define PNG_SWAP_BYTES 0x0010 +#define PNG_INVERT_MONO 0x0020 +#define PNG_DITHER 0x0040 +#define PNG_BACKGROUND 0x0080 +#define PNG_BACKGROUND_EXPAND 0x0100 + /* 0x0200 unused */ +#define PNG_16_TO_8 0x0400 +#define PNG_RGBA 0x0800 +#define PNG_EXPAND 0x1000 +#define PNG_GAMMA 0x2000 +#define PNG_GRAY_TO_RGB 0x4000 +#define PNG_FILLER 0x8000L +#define PNG_PACKSWAP 0x10000L +#define PNG_SWAP_ALPHA 0x20000L +#define PNG_STRIP_ALPHA 0x40000L +#define PNG_INVERT_ALPHA 0x80000L +#define PNG_USER_TRANSFORM 0x100000L +#define PNG_RGB_TO_GRAY_ERR 0x200000L +#define PNG_RGB_TO_GRAY_WARN 0x400000L +#define PNG_RGB_TO_GRAY 0x600000L /* two bits, RGB_TO_GRAY_ERR|WARN */ + /* 0x800000L Unused */ +#define PNG_ADD_ALPHA 0x1000000L /* Added to libpng-1.2.7 */ +#define PNG_EXPAND_tRNS 0x2000000L /* Added to libpng-1.2.9 */ + /* 0x4000000L unused */ + /* 0x8000000L unused */ + /* 0x10000000L unused */ + /* 0x20000000L unused */ + /* 0x40000000L unused */ + +/* flags for png_create_struct */ +#define PNG_STRUCT_PNG 0x0001 +#define PNG_STRUCT_INFO 0x0002 + +/* Scaling factor for filter heuristic weighting calculations */ +#define PNG_WEIGHT_SHIFT 8 +#define PNG_WEIGHT_FACTOR (1<<(PNG_WEIGHT_SHIFT)) +#define PNG_COST_SHIFT 3 +#define PNG_COST_FACTOR (1<<(PNG_COST_SHIFT)) + +/* flags for the png_ptr->flags rather than declaring a byte for each one */ +#define PNG_FLAG_ZLIB_CUSTOM_STRATEGY 0x0001 +#define PNG_FLAG_ZLIB_CUSTOM_LEVEL 0x0002 +#define PNG_FLAG_ZLIB_CUSTOM_MEM_LEVEL 0x0004 +#define PNG_FLAG_ZLIB_CUSTOM_WINDOW_BITS 0x0008 +#define PNG_FLAG_ZLIB_CUSTOM_METHOD 0x0010 +#define PNG_FLAG_ZLIB_FINISHED 0x0020 +#define PNG_FLAG_ROW_INIT 0x0040 +#define PNG_FLAG_FILLER_AFTER 0x0080 +#define PNG_FLAG_CRC_ANCILLARY_USE 0x0100 +#define PNG_FLAG_CRC_ANCILLARY_NOWARN 0x0200 +#define PNG_FLAG_CRC_CRITICAL_USE 0x0400 +#define PNG_FLAG_CRC_CRITICAL_IGNORE 0x0800 +#define PNG_FLAG_FREE_PLTE 0x1000 +#define PNG_FLAG_FREE_TRNS 0x2000 +#define PNG_FLAG_FREE_HIST 0x4000 +#define PNG_FLAG_KEEP_UNKNOWN_CHUNKS 0x8000L +#define PNG_FLAG_KEEP_UNSAFE_CHUNKS 0x10000L +#define PNG_FLAG_LIBRARY_MISMATCH 0x20000L +#define PNG_FLAG_STRIP_ERROR_NUMBERS 0x40000L +#define PNG_FLAG_STRIP_ERROR_TEXT 0x80000L +#define PNG_FLAG_MALLOC_NULL_MEM_OK 0x100000L +#define PNG_FLAG_ADD_ALPHA 0x200000L /* Added to libpng-1.2.8 */ +#define PNG_FLAG_STRIP_ALPHA 0x400000L /* Added to libpng-1.2.8 */ + /* 0x800000L unused */ + /* 0x1000000L unused */ + /* 0x2000000L unused */ + /* 0x4000000L unused */ + /* 0x8000000L unused */ + /* 0x10000000L unused */ + /* 0x20000000L unused */ + /* 0x40000000L unused */ + +#define PNG_FLAG_CRC_ANCILLARY_MASK (PNG_FLAG_CRC_ANCILLARY_USE | \ + PNG_FLAG_CRC_ANCILLARY_NOWARN) + +#define PNG_FLAG_CRC_CRITICAL_MASK (PNG_FLAG_CRC_CRITICAL_USE | \ + PNG_FLAG_CRC_CRITICAL_IGNORE) + +#define PNG_FLAG_CRC_MASK (PNG_FLAG_CRC_ANCILLARY_MASK | \ + PNG_FLAG_CRC_CRITICAL_MASK) + +/* save typing and make code easier to understand */ + +#define PNG_COLOR_DIST(c1, c2) (abs((int)((c1).red) - (int)((c2).red)) + \ + abs((int)((c1).green) - (int)((c2).green)) + \ + abs((int)((c1).blue) - (int)((c2).blue))) + +/* Added to libpng-1.2.6 JB */ +#define PNG_ROWBYTES(pixel_bits, width) \ + ((pixel_bits) >= 8 ? \ + ((width) * (((png_uint_32)(pixel_bits)) >> 3)) : \ + (( ((width) * ((png_uint_32)(pixel_bits))) + 7) >> 3) ) + +/* PNG_OUT_OF_RANGE returns true if value is outside the range + ideal-delta..ideal+delta. Each argument is evaluated twice. + "ideal" and "delta" should be constants, normally simple + integers, "value" a variable. Added to libpng-1.2.6 JB */ +#define PNG_OUT_OF_RANGE(value, ideal, delta) \ + ( (value) < (ideal)-(delta) || (value) > (ideal)+(delta) ) + +/* variables declared in png.c - only it needs to define PNG_NO_EXTERN */ +#if !defined(PNG_NO_EXTERN) || defined(PNG_ALWAYS_EXTERN) +/* place to hold the signature string for a PNG file. */ +#ifdef PNG_USE_GLOBAL_ARRAYS + PNG_EXPORT_VAR (PNG_CONST png_byte FARDATA) png_sig[8]; +#else +#endif +#endif /* PNG_NO_EXTERN */ + +/* Constant strings for known chunk types. If you need to add a chunk, + * define the name here, and add an invocation of the macro in png.c and + * wherever it's needed. + */ +#define PNG_IHDR png_byte png_IHDR[5] = { 73, 72, 68, 82, '\0'} +#define PNG_IDAT png_byte png_IDAT[5] = { 73, 68, 65, 84, '\0'} +#define PNG_IEND png_byte png_IEND[5] = { 73, 69, 78, 68, '\0'} +#define PNG_PLTE png_byte png_PLTE[5] = { 80, 76, 84, 69, '\0'} +#define PNG_bKGD png_byte png_bKGD[5] = { 98, 75, 71, 68, '\0'} +#define PNG_cHRM png_byte png_cHRM[5] = { 99, 72, 82, 77, '\0'} +#define PNG_gAMA png_byte png_gAMA[5] = {103, 65, 77, 65, '\0'} +#define PNG_hIST png_byte png_hIST[5] = {104, 73, 83, 84, '\0'} +#define PNG_iCCP png_byte png_iCCP[5] = {105, 67, 67, 80, '\0'} +#define PNG_iTXt png_byte png_iTXt[5] = {105, 84, 88, 116, '\0'} +#define PNG_oFFs png_byte png_oFFs[5] = {111, 70, 70, 115, '\0'} +#define PNG_pCAL png_byte png_pCAL[5] = {112, 67, 65, 76, '\0'} +#define PNG_sCAL png_byte png_sCAL[5] = {115, 67, 65, 76, '\0'} +#define PNG_pHYs png_byte png_pHYs[5] = {112, 72, 89, 115, '\0'} +#define PNG_sBIT png_byte png_sBIT[5] = {115, 66, 73, 84, '\0'} +#define PNG_sPLT png_byte png_sPLT[5] = {115, 80, 76, 84, '\0'} +#define PNG_sRGB png_byte png_sRGB[5] = {115, 82, 71, 66, '\0'} +#define PNG_tEXt png_byte png_tEXt[5] = {116, 69, 88, 116, '\0'} +#define PNG_tIME png_byte png_tIME[5] = {116, 73, 77, 69, '\0'} +#define PNG_tRNS png_byte png_tRNS[5] = {116, 82, 78, 83, '\0'} +#define PNG_zTXt png_byte png_zTXt[5] = {122, 84, 88, 116, '\0'} + +#ifdef PNG_USE_GLOBAL_ARRAYS +PNG_EXPORT_VAR (png_byte FARDATA) png_IHDR[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_IDAT[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_IEND[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_PLTE[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_bKGD[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_cHRM[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_gAMA[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_hIST[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_iCCP[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_iTXt[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_oFFs[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_pCAL[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_sCAL[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_pHYs[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_sBIT[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_sPLT[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_sRGB[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_tEXt[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_tIME[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_tRNS[5]; +PNG_EXPORT_VAR (png_byte FARDATA) png_zTXt[5]; +#endif /* PNG_USE_GLOBAL_ARRAYS */ + +#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +/* Initialize png_ptr struct for reading, and allocate any other memory. + * (old interface - DEPRECATED - use png_create_read_struct instead). + */ +extern PNG_EXPORT(void,png_read_init) PNGARG((png_structp png_ptr)); +#undef png_read_init +#define png_read_init(png_ptr) png_read_init_3(&png_ptr, \ + PNG_LIBPNG_VER_STRING, png_sizeof(png_struct)); +#endif + +extern PNG_EXPORT(void,png_read_init_3) PNGARG((png_structpp ptr_ptr, + png_const_charp user_png_ver, png_size_t png_struct_size)); +#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +extern PNG_EXPORT(void,png_read_init_2) PNGARG((png_structp png_ptr, + png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t + png_info_size)); +#endif + +#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +/* Initialize png_ptr struct for writing, and allocate any other memory. + * (old interface - DEPRECATED - use png_create_write_struct instead). + */ +extern PNG_EXPORT(void,png_write_init) PNGARG((png_structp png_ptr)); +#undef png_write_init +#define png_write_init(png_ptr) png_write_init_3(&png_ptr, \ + PNG_LIBPNG_VER_STRING, png_sizeof(png_struct)); +#endif + +extern PNG_EXPORT(void,png_write_init_3) PNGARG((png_structpp ptr_ptr, + png_const_charp user_png_ver, png_size_t png_struct_size)); +extern PNG_EXPORT(void,png_write_init_2) PNGARG((png_structp png_ptr, + png_const_charp user_png_ver, png_size_t png_struct_size, png_size_t + png_info_size)); + +/* Allocate memory for an internal libpng struct */ +PNG_EXTERN png_voidp png_create_struct PNGARG((int type)); + +/* Free memory from internal libpng struct */ +PNG_EXTERN void png_destroy_struct PNGARG((png_voidp struct_ptr)); + +PNG_EXTERN png_voidp png_create_struct_2 PNGARG((int type, png_malloc_ptr + malloc_fn, png_voidp mem_ptr)); +PNG_EXTERN void png_destroy_struct_2 PNGARG((png_voidp struct_ptr, + png_free_ptr free_fn, png_voidp mem_ptr)); + +/* Free any memory that info_ptr points to and reset struct. */ +PNG_EXTERN void png_info_destroy PNGARG((png_structp png_ptr, + png_infop info_ptr)); + +#ifndef PNG_1_0_X +/* Function to allocate memory for zlib. */ +PNG_EXTERN voidpf png_zalloc PNGARG((voidpf png_ptr, uInt items, uInt size)); + +/* Function to free memory for zlib */ +PNG_EXTERN void png_zfree PNGARG((voidpf png_ptr, voidpf ptr)); + +#ifdef PNG_SIZE_T +/* Function to convert a sizeof an item to png_sizeof item */ + PNG_EXTERN png_size_t PNGAPI png_convert_size PNGARG((size_t size)); +#endif + +/* Next four functions are used internally as callbacks. PNGAPI is required + * but not PNG_EXPORT. PNGAPI added at libpng version 1.2.3. */ + +PNG_EXTERN void PNGAPI png_default_read_data PNGARG((png_structp png_ptr, + png_bytep data, png_size_t length)); + +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +PNG_EXTERN void PNGAPI png_push_fill_buffer PNGARG((png_structp png_ptr, + png_bytep buffer, png_size_t length)); +#endif + +PNG_EXTERN void PNGAPI png_default_write_data PNGARG((png_structp png_ptr, + png_bytep data, png_size_t length)); + +#if defined(PNG_WRITE_FLUSH_SUPPORTED) +#if !defined(PNG_NO_STDIO) +PNG_EXTERN void PNGAPI png_default_flush PNGARG((png_structp png_ptr)); +#endif +#endif +#else /* PNG_1_0_X */ +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +PNG_EXTERN void png_push_fill_buffer PNGARG((png_structp png_ptr, + png_bytep buffer, png_size_t length)); +#endif +#endif /* PNG_1_0_X */ + +/* Reset the CRC variable */ +PNG_EXTERN void png_reset_crc PNGARG((png_structp png_ptr)); + +/* Write the "data" buffer to whatever output you are using. */ +PNG_EXTERN void png_write_data PNGARG((png_structp png_ptr, png_bytep data, + png_size_t length)); + +/* Read data from whatever input you are using into the "data" buffer */ +PNG_EXTERN void png_read_data PNGARG((png_structp png_ptr, png_bytep data, + png_size_t length)); + +/* Read bytes into buf, and update png_ptr->crc */ +PNG_EXTERN void png_crc_read PNGARG((png_structp png_ptr, png_bytep buf, + png_size_t length)); + +/* Decompress data in a chunk that uses compression */ +#if defined(PNG_zTXt_SUPPORTED) || defined(PNG_iTXt_SUPPORTED) || \ + defined(PNG_iCCP_SUPPORTED) || defined(PNG_sPLT_SUPPORTED) +PNG_EXTERN void png_decompress_chunk PNGARG((png_structp png_ptr, + int comp_type, png_size_t chunklength, + png_size_t prefix_length, png_size_t *data_length)); +#endif + +/* Read "skip" bytes, read the file crc, and (optionally) verify png_ptr->crc */ +PNG_EXTERN int png_crc_finish PNGARG((png_structp png_ptr, png_uint_32 skip)); + +/* Read the CRC from the file and compare it to the libpng calculated CRC */ +PNG_EXTERN int png_crc_error PNGARG((png_structp png_ptr)); + +/* Calculate the CRC over a section of data. Note that we are only + * passing a maximum of 64K on systems that have this as a memory limit, + * since this is the maximum buffer size we can specify. + */ +PNG_EXTERN void png_calculate_crc PNGARG((png_structp png_ptr, png_bytep ptr, + png_size_t length)); + +#if defined(PNG_WRITE_FLUSH_SUPPORTED) +PNG_EXTERN void png_flush PNGARG((png_structp png_ptr)); +#endif + +/* simple function to write the signature */ +PNG_EXTERN void png_write_sig PNGARG((png_structp png_ptr)); + +/* write various chunks */ + +/* Write the IHDR chunk, and update the png_struct with the necessary + * information. + */ +PNG_EXTERN void png_write_IHDR PNGARG((png_structp png_ptr, png_uint_32 width, + png_uint_32 height, + int bit_depth, int color_type, int compression_method, int filter_method, + int interlace_method)); + +PNG_EXTERN void png_write_PLTE PNGARG((png_structp png_ptr, png_colorp palette, + png_uint_32 num_pal)); + +PNG_EXTERN void png_write_IDAT PNGARG((png_structp png_ptr, png_bytep data, + png_size_t length)); + +PNG_EXTERN void png_write_IEND PNGARG((png_structp png_ptr)); + +#if defined(PNG_WRITE_gAMA_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +PNG_EXTERN void png_write_gAMA PNGARG((png_structp png_ptr, double file_gamma)); +#endif +#ifdef PNG_FIXED_POINT_SUPPORTED +PNG_EXTERN void png_write_gAMA_fixed PNGARG((png_structp png_ptr, png_fixed_point + file_gamma)); +#endif +#endif + +#if defined(PNG_WRITE_sBIT_SUPPORTED) +PNG_EXTERN void png_write_sBIT PNGARG((png_structp png_ptr, png_color_8p sbit, + int color_type)); +#endif + +#if defined(PNG_WRITE_cHRM_SUPPORTED) +#ifdef PNG_FLOATING_POINT_SUPPORTED +PNG_EXTERN void png_write_cHRM PNGARG((png_structp png_ptr, + double white_x, double white_y, + double red_x, double red_y, double green_x, double green_y, + double blue_x, double blue_y)); +#endif +#ifdef PNG_FIXED_POINT_SUPPORTED +PNG_EXTERN void png_write_cHRM_fixed PNGARG((png_structp png_ptr, + png_fixed_point int_white_x, png_fixed_point int_white_y, + png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point + int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, + png_fixed_point int_blue_y)); +#endif +#endif + +#if defined(PNG_WRITE_sRGB_SUPPORTED) +PNG_EXTERN void png_write_sRGB PNGARG((png_structp png_ptr, + int intent)); +#endif + +#if defined(PNG_WRITE_iCCP_SUPPORTED) +PNG_EXTERN void png_write_iCCP PNGARG((png_structp png_ptr, + png_charp name, int compression_type, + png_charp profile, int proflen)); + /* Note to maintainer: profile should be png_bytep */ +#endif + +#if defined(PNG_WRITE_sPLT_SUPPORTED) +PNG_EXTERN void png_write_sPLT PNGARG((png_structp png_ptr, + png_sPLT_tp palette)); +#endif + +#if defined(PNG_WRITE_tRNS_SUPPORTED) +PNG_EXTERN void png_write_tRNS PNGARG((png_structp png_ptr, png_bytep trans, + png_color_16p values, int number, int color_type)); +#endif + +#if defined(PNG_WRITE_bKGD_SUPPORTED) +PNG_EXTERN void png_write_bKGD PNGARG((png_structp png_ptr, + png_color_16p values, int color_type)); +#endif + +#if defined(PNG_WRITE_hIST_SUPPORTED) +PNG_EXTERN void png_write_hIST PNGARG((png_structp png_ptr, png_uint_16p hist, + int num_hist)); +#endif + +#if defined(PNG_WRITE_TEXT_SUPPORTED) || defined(PNG_WRITE_pCAL_SUPPORTED) || \ + defined(PNG_WRITE_iCCP_SUPPORTED) || defined(PNG_WRITE_sPLT_SUPPORTED) +PNG_EXTERN png_size_t png_check_keyword PNGARG((png_structp png_ptr, + png_charp key, png_charpp new_key)); +#endif + +#if defined(PNG_WRITE_tEXt_SUPPORTED) +PNG_EXTERN void png_write_tEXt PNGARG((png_structp png_ptr, png_charp key, + png_charp text, png_size_t text_len)); +#endif + +#if defined(PNG_WRITE_zTXt_SUPPORTED) +PNG_EXTERN void png_write_zTXt PNGARG((png_structp png_ptr, png_charp key, + png_charp text, png_size_t text_len, int compression)); +#endif + +#if defined(PNG_WRITE_iTXt_SUPPORTED) +PNG_EXTERN void png_write_iTXt PNGARG((png_structp png_ptr, + int compression, png_charp key, png_charp lang, png_charp lang_key, + png_charp text)); +#endif + +#if defined(PNG_TEXT_SUPPORTED) /* Added at version 1.0.14 and 1.2.4 */ +PNG_EXTERN int png_set_text_2 PNGARG((png_structp png_ptr, + png_infop info_ptr, png_textp text_ptr, int num_text)); +#endif + +#if defined(PNG_WRITE_oFFs_SUPPORTED) +PNG_EXTERN void png_write_oFFs PNGARG((png_structp png_ptr, + png_int_32 x_offset, png_int_32 y_offset, int unit_type)); +#endif + +#if defined(PNG_WRITE_pCAL_SUPPORTED) +PNG_EXTERN void png_write_pCAL PNGARG((png_structp png_ptr, png_charp purpose, + png_int_32 X0, png_int_32 X1, int type, int nparams, + png_charp units, png_charpp params)); +#endif + +#if defined(PNG_WRITE_pHYs_SUPPORTED) +PNG_EXTERN void png_write_pHYs PNGARG((png_structp png_ptr, + png_uint_32 x_pixels_per_unit, png_uint_32 y_pixels_per_unit, + int unit_type)); +#endif + +#if defined(PNG_WRITE_tIME_SUPPORTED) +PNG_EXTERN void png_write_tIME PNGARG((png_structp png_ptr, + png_timep mod_time)); +#endif + +#if defined(PNG_WRITE_sCAL_SUPPORTED) +#if defined(PNG_FLOATING_POINT_SUPPORTED) && !defined(PNG_NO_STDIO) +PNG_EXTERN void png_write_sCAL PNGARG((png_structp png_ptr, + int unit, double width, double height)); +#else +#ifdef PNG_FIXED_POINT_SUPPORTED +PNG_EXTERN void png_write_sCAL_s PNGARG((png_structp png_ptr, + int unit, png_charp width, png_charp height)); +#endif +#endif +#endif + +/* Called when finished processing a row of data */ +PNG_EXTERN void png_write_finish_row PNGARG((png_structp png_ptr)); + +/* Internal use only. Called before first row of data */ +PNG_EXTERN void png_write_start_row PNGARG((png_structp png_ptr)); + +#if defined(PNG_READ_GAMMA_SUPPORTED) +PNG_EXTERN void png_build_gamma_table PNGARG((png_structp png_ptr)); +#endif + +/* combine a row of data, dealing with alpha, etc. if requested */ +PNG_EXTERN void png_combine_row PNGARG((png_structp png_ptr, png_bytep row, + int mask)); + +#if defined(PNG_READ_INTERLACING_SUPPORTED) +/* expand an interlaced row */ +/* OLD pre-1.0.9 interface: +PNG_EXTERN void png_do_read_interlace PNGARG((png_row_infop row_info, + png_bytep row, int pass, png_uint_32 transformations)); + */ +PNG_EXTERN void png_do_read_interlace PNGARG((png_structp png_ptr)); +#endif + +/* GRR TO DO (2.0 or whenever): simplify other internal calling interfaces */ + +#if defined(PNG_WRITE_INTERLACING_SUPPORTED) +/* grab pixels out of a row for an interlaced pass */ +PNG_EXTERN void png_do_write_interlace PNGARG((png_row_infop row_info, + png_bytep row, int pass)); +#endif + +/* unfilter a row */ +PNG_EXTERN void png_read_filter_row PNGARG((png_structp png_ptr, + png_row_infop row_info, png_bytep row, png_bytep prev_row, int filter)); + +/* Choose the best filter to use and filter the row data */ +PNG_EXTERN void png_write_find_filter PNGARG((png_structp png_ptr, + png_row_infop row_info)); + +/* Write out the filtered row. */ +PNG_EXTERN void png_write_filtered_row PNGARG((png_structp png_ptr, + png_bytep filtered_row)); +/* finish a row while reading, dealing with interlacing passes, etc. */ +PNG_EXTERN void png_read_finish_row PNGARG((png_structp png_ptr)); + +/* initialize the row buffers, etc. */ +PNG_EXTERN void png_read_start_row PNGARG((png_structp png_ptr)); +/* optional call to update the users info structure */ +PNG_EXTERN void png_read_transform_info PNGARG((png_structp png_ptr, + png_infop info_ptr)); + +/* these are the functions that do the transformations */ +#if defined(PNG_READ_FILLER_SUPPORTED) +PNG_EXTERN void png_do_read_filler PNGARG((png_row_infop row_info, + png_bytep row, png_uint_32 filler, png_uint_32 flags)); +#endif + +#if defined(PNG_READ_SWAP_ALPHA_SUPPORTED) +PNG_EXTERN void png_do_read_swap_alpha PNGARG((png_row_infop row_info, + png_bytep row)); +#endif + +#if defined(PNG_WRITE_SWAP_ALPHA_SUPPORTED) +PNG_EXTERN void png_do_write_swap_alpha PNGARG((png_row_infop row_info, + png_bytep row)); +#endif + +#if defined(PNG_READ_INVERT_ALPHA_SUPPORTED) +PNG_EXTERN void png_do_read_invert_alpha PNGARG((png_row_infop row_info, + png_bytep row)); +#endif + +#if defined(PNG_WRITE_INVERT_ALPHA_SUPPORTED) +PNG_EXTERN void png_do_write_invert_alpha PNGARG((png_row_infop row_info, + png_bytep row)); +#endif + +#if defined(PNG_WRITE_FILLER_SUPPORTED) || \ + defined(PNG_READ_STRIP_ALPHA_SUPPORTED) +PNG_EXTERN void png_do_strip_filler PNGARG((png_row_infop row_info, + png_bytep row, png_uint_32 flags)); +#endif + +#if defined(PNG_READ_SWAP_SUPPORTED) || defined(PNG_WRITE_SWAP_SUPPORTED) +PNG_EXTERN void png_do_swap PNGARG((png_row_infop row_info, png_bytep row)); +#endif + +#if defined(PNG_READ_PACKSWAP_SUPPORTED) || defined(PNG_WRITE_PACKSWAP_SUPPORTED) +PNG_EXTERN void png_do_packswap PNGARG((png_row_infop row_info, png_bytep row)); +#endif + +#if defined(PNG_READ_RGB_TO_GRAY_SUPPORTED) +PNG_EXTERN int png_do_rgb_to_gray PNGARG((png_structp png_ptr, png_row_infop + row_info, png_bytep row)); +#endif + +#if defined(PNG_READ_GRAY_TO_RGB_SUPPORTED) +PNG_EXTERN void png_do_gray_to_rgb PNGARG((png_row_infop row_info, + png_bytep row)); +#endif + +#if defined(PNG_READ_PACK_SUPPORTED) +PNG_EXTERN void png_do_unpack PNGARG((png_row_infop row_info, png_bytep row)); +#endif + +#if defined(PNG_READ_SHIFT_SUPPORTED) +PNG_EXTERN void png_do_unshift PNGARG((png_row_infop row_info, png_bytep row, + png_color_8p sig_bits)); +#endif + +#if defined(PNG_READ_INVERT_SUPPORTED) || defined(PNG_WRITE_INVERT_SUPPORTED) +PNG_EXTERN void png_do_invert PNGARG((png_row_infop row_info, png_bytep row)); +#endif + +#if defined(PNG_READ_16_TO_8_SUPPORTED) +PNG_EXTERN void png_do_chop PNGARG((png_row_infop row_info, png_bytep row)); +#endif + +#if defined(PNG_READ_DITHER_SUPPORTED) +PNG_EXTERN void png_do_dither PNGARG((png_row_infop row_info, + png_bytep row, png_bytep palette_lookup, png_bytep dither_lookup)); + +# if defined(PNG_CORRECT_PALETTE_SUPPORTED) +PNG_EXTERN void png_correct_palette PNGARG((png_structp png_ptr, + png_colorp palette, int num_palette)); +# endif +#endif + +#if defined(PNG_READ_BGR_SUPPORTED) || defined(PNG_WRITE_BGR_SUPPORTED) +PNG_EXTERN void png_do_bgr PNGARG((png_row_infop row_info, png_bytep row)); +#endif + +#if defined(PNG_WRITE_PACK_SUPPORTED) +PNG_EXTERN void png_do_pack PNGARG((png_row_infop row_info, + png_bytep row, png_uint_32 bit_depth)); +#endif + +#if defined(PNG_WRITE_SHIFT_SUPPORTED) +PNG_EXTERN void png_do_shift PNGARG((png_row_infop row_info, png_bytep row, + png_color_8p bit_depth)); +#endif + +#if defined(PNG_READ_BACKGROUND_SUPPORTED) +#if defined(PNG_READ_GAMMA_SUPPORTED) +PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row, + png_color_16p trans_values, png_color_16p background, + png_color_16p background_1, + png_bytep gamma_table, png_bytep gamma_from_1, png_bytep gamma_to_1, + png_uint_16pp gamma_16, png_uint_16pp gamma_16_from_1, + png_uint_16pp gamma_16_to_1, int gamma_shift)); +#else +PNG_EXTERN void png_do_background PNGARG((png_row_infop row_info, png_bytep row, + png_color_16p trans_values, png_color_16p background)); +#endif +#endif + +#if defined(PNG_READ_GAMMA_SUPPORTED) +PNG_EXTERN void png_do_gamma PNGARG((png_row_infop row_info, png_bytep row, + png_bytep gamma_table, png_uint_16pp gamma_16_table, + int gamma_shift)); +#endif + +#if defined(PNG_READ_EXPAND_SUPPORTED) +PNG_EXTERN void png_do_expand_palette PNGARG((png_row_infop row_info, + png_bytep row, png_colorp palette, png_bytep trans, int num_trans)); +PNG_EXTERN void png_do_expand PNGARG((png_row_infop row_info, + png_bytep row, png_color_16p trans_value)); +#endif + +/* The following decodes the appropriate chunks, and does error correction, + * then calls the appropriate callback for the chunk if it is valid. + */ + +/* decode the IHDR chunk */ +PNG_EXTERN void png_handle_IHDR PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +PNG_EXTERN void png_handle_PLTE PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +PNG_EXTERN void png_handle_IEND PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); + +#if defined(PNG_READ_bKGD_SUPPORTED) +PNG_EXTERN void png_handle_bKGD PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_cHRM_SUPPORTED) +PNG_EXTERN void png_handle_cHRM PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_gAMA_SUPPORTED) +PNG_EXTERN void png_handle_gAMA PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_hIST_SUPPORTED) +PNG_EXTERN void png_handle_hIST PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_iCCP_SUPPORTED) +extern void png_handle_iCCP PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif /* PNG_READ_iCCP_SUPPORTED */ + +#if defined(PNG_READ_iTXt_SUPPORTED) +PNG_EXTERN void png_handle_iTXt PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_oFFs_SUPPORTED) +PNG_EXTERN void png_handle_oFFs PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_pCAL_SUPPORTED) +PNG_EXTERN void png_handle_pCAL PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_pHYs_SUPPORTED) +PNG_EXTERN void png_handle_pHYs PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_sBIT_SUPPORTED) +PNG_EXTERN void png_handle_sBIT PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_sCAL_SUPPORTED) +PNG_EXTERN void png_handle_sCAL PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_sPLT_SUPPORTED) +extern void png_handle_sPLT PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif /* PNG_READ_sPLT_SUPPORTED */ + +#if defined(PNG_READ_sRGB_SUPPORTED) +PNG_EXTERN void png_handle_sRGB PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_tEXt_SUPPORTED) +PNG_EXTERN void png_handle_tEXt PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_tIME_SUPPORTED) +PNG_EXTERN void png_handle_tIME PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_tRNS_SUPPORTED) +PNG_EXTERN void png_handle_tRNS PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +#if defined(PNG_READ_zTXt_SUPPORTED) +PNG_EXTERN void png_handle_zTXt PNGARG((png_structp png_ptr, png_infop info_ptr, + png_uint_32 length)); +#endif + +PNG_EXTERN void png_handle_unknown PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 length)); + +PNG_EXTERN void png_check_chunk_name PNGARG((png_structp png_ptr, + png_bytep chunk_name)); + +/* handle the transformations for reading and writing */ +PNG_EXTERN void png_do_read_transformations PNGARG((png_structp png_ptr)); +PNG_EXTERN void png_do_write_transformations PNGARG((png_structp png_ptr)); + +PNG_EXTERN void png_init_read_transformations PNGARG((png_structp png_ptr)); + +#ifdef PNG_PROGRESSIVE_READ_SUPPORTED +PNG_EXTERN void png_push_read_chunk PNGARG((png_structp png_ptr, + png_infop info_ptr)); +PNG_EXTERN void png_push_read_sig PNGARG((png_structp png_ptr, + png_infop info_ptr)); +PNG_EXTERN void png_push_check_crc PNGARG((png_structp png_ptr)); +PNG_EXTERN void png_push_crc_skip PNGARG((png_structp png_ptr, + png_uint_32 length)); +PNG_EXTERN void png_push_crc_finish PNGARG((png_structp png_ptr)); +PNG_EXTERN void png_push_save_buffer PNGARG((png_structp png_ptr)); +PNG_EXTERN void png_push_restore_buffer PNGARG((png_structp png_ptr, + png_bytep buffer, png_size_t buffer_length)); +PNG_EXTERN void png_push_read_IDAT PNGARG((png_structp png_ptr)); +PNG_EXTERN void png_process_IDAT_data PNGARG((png_structp png_ptr, + png_bytep buffer, png_size_t buffer_length)); +PNG_EXTERN void png_push_process_row PNGARG((png_structp png_ptr)); +PNG_EXTERN void png_push_handle_unknown PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 length)); +PNG_EXTERN void png_push_have_info PNGARG((png_structp png_ptr, + png_infop info_ptr)); +PNG_EXTERN void png_push_have_end PNGARG((png_structp png_ptr, + png_infop info_ptr)); +PNG_EXTERN void png_push_have_row PNGARG((png_structp png_ptr, png_bytep row)); +PNG_EXTERN void png_push_read_end PNGARG((png_structp png_ptr, + png_infop info_ptr)); +PNG_EXTERN void png_process_some_data PNGARG((png_structp png_ptr, + png_infop info_ptr)); +PNG_EXTERN void png_read_push_finish_row PNGARG((png_structp png_ptr)); +#if defined(PNG_READ_tEXt_SUPPORTED) +PNG_EXTERN void png_push_handle_tEXt PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 length)); +PNG_EXTERN void png_push_read_tEXt PNGARG((png_structp png_ptr, + png_infop info_ptr)); +#endif +#if defined(PNG_READ_zTXt_SUPPORTED) +PNG_EXTERN void png_push_handle_zTXt PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 length)); +PNG_EXTERN void png_push_read_zTXt PNGARG((png_structp png_ptr, + png_infop info_ptr)); +#endif +#if defined(PNG_READ_iTXt_SUPPORTED) +PNG_EXTERN void png_push_handle_iTXt PNGARG((png_structp png_ptr, + png_infop info_ptr, png_uint_32 length)); +PNG_EXTERN void png_push_read_iTXt PNGARG((png_structp png_ptr, + png_infop info_ptr)); +#endif + +#endif /* PNG_PROGRESSIVE_READ_SUPPORTED */ + +#ifdef PNG_MNG_FEATURES_SUPPORTED +PNG_EXTERN void png_do_read_intrapixel PNGARG((png_row_infop row_info, + png_bytep row)); +PNG_EXTERN void png_do_write_intrapixel PNGARG((png_row_infop row_info, + png_bytep row)); +#endif + +#if defined(PNG_ASSEMBLER_CODE_SUPPORTED) +#if defined(PNG_MMX_CODE_SUPPORTED) +/* png.c */ /* PRIVATE */ +PNG_EXTERN void png_init_mmx_flags PNGARG((png_structp png_ptr)); +#endif +#endif + +#if defined(PNG_INCH_CONVERSIONS) && defined(PNG_FLOATING_POINT_SUPPORTED) +PNG_EXTERN png_uint_32 png_get_pixels_per_inch PNGARG((png_structp png_ptr, +png_infop info_ptr)); + +PNG_EXTERN png_uint_32 png_get_x_pixels_per_inch PNGARG((png_structp png_ptr, +png_infop info_ptr)); + +PNG_EXTERN png_uint_32 png_get_y_pixels_per_inch PNGARG((png_structp png_ptr, +png_infop info_ptr)); + +PNG_EXTERN float png_get_x_offset_inches PNGARG((png_structp png_ptr, +png_infop info_ptr)); + +PNG_EXTERN float png_get_y_offset_inches PNGARG((png_structp png_ptr, +png_infop info_ptr)); + +#if defined(PNG_pHYs_SUPPORTED) +PNG_EXTERN png_uint_32 png_get_pHYs_dpi PNGARG((png_structp png_ptr, +png_infop info_ptr, png_uint_32 *res_x, png_uint_32 *res_y, int *unit_type)); +#endif /* PNG_pHYs_SUPPORTED */ +#endif /* PNG_INCH_CONVERSIONS && PNG_FLOATING_POINT_SUPPORTED */ + +/* Read the chunk header (length + type name) */ +PNG_EXTERN png_uint_32 png_read_chunk_header PNGARG((png_structp png_ptr)); + +/* Added at libpng version 1.2.34 */ +#if defined(PNG_cHRM_SUPPORTED) +PNG_EXTERN int png_check_cHRM_fixed PNGARG((png_structp png_ptr, + png_fixed_point int_white_x, png_fixed_point int_white_y, + png_fixed_point int_red_x, png_fixed_point int_red_y, png_fixed_point + int_green_x, png_fixed_point int_green_y, png_fixed_point int_blue_x, + png_fixed_point int_blue_y)); +#endif + +/* Maintainer: Put new private prototypes here ^ and in libpngpf.3 */ + +#endif /* PNG_INTERNAL */ + +#ifdef __cplusplus +} +#endif + +#endif /* PNG_VERSION_INFO_ONLY */ +/* do not put anything past this line */ +#endif /* PNG_H */ diff --git a/include/pngconf.h b/include/pngconf.h new file mode 100644 index 00000000..025368db --- /dev/null +++ b/include/pngconf.h @@ -0,0 +1,1496 @@ + +/* pngconf.h - machine configurable file for libpng + * + * libpng version 1.2.37 - June 4, 2009 + * For conditions of distribution and use, see copyright notice in png.h + * Copyright (c) 1998-2009 Glenn Randers-Pehrson + * (Version 0.96 Copyright (c) 1996, 1997 Andreas Dilger) + * (Version 0.88 Copyright (c) 1995, 1996 Guy Eric Schalnat, Group 42, Inc.) + */ + +/* Any machine specific code is near the front of this file, so if you + * are configuring libpng for a machine, you may want to read the section + * starting here down to where it starts to typedef png_color, png_text, + * and png_info. + */ + +#ifndef PNGCONF_H +#define PNGCONF_H + +#define PNG_1_2_X + +/* + * PNG_USER_CONFIG has to be defined on the compiler command line. This + * includes the resource compiler for Windows DLL configurations. + */ +#ifdef PNG_USER_CONFIG +# ifndef PNG_USER_PRIVATEBUILD +# define PNG_USER_PRIVATEBUILD +# endif +#include "pngusr.h" +#endif + +/* PNG_CONFIGURE_LIBPNG is set by the "configure" script. */ +#ifdef PNG_CONFIGURE_LIBPNG +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif +#endif + +/* + * Added at libpng-1.2.8 + * + * If you create a private DLL you need to define in "pngusr.h" the followings: + * #define PNG_USER_PRIVATEBUILD + * e.g. #define PNG_USER_PRIVATEBUILD "Build by MyCompany for xyz reasons." + * #define PNG_USER_DLLFNAME_POSTFIX + * e.g. // private DLL "libpng13gx.dll" + * #define PNG_USER_DLLFNAME_POSTFIX "gx" + * + * The following macros are also at your disposal if you want to complete the + * DLL VERSIONINFO structure. + * - PNG_USER_VERSIONINFO_COMMENTS + * - PNG_USER_VERSIONINFO_COMPANYNAME + * - PNG_USER_VERSIONINFO_LEGALTRADEMARKS + */ + +#ifdef __STDC__ +#ifdef SPECIALBUILD +# pragma message("PNG_LIBPNG_SPECIALBUILD (and deprecated SPECIALBUILD)\ + are now LIBPNG reserved macros. Use PNG_USER_PRIVATEBUILD instead.") +#endif + +#ifdef PRIVATEBUILD +# pragma message("PRIVATEBUILD is deprecated.\ + Use PNG_USER_PRIVATEBUILD instead.") +# define PNG_USER_PRIVATEBUILD PRIVATEBUILD +#endif +#endif /* __STDC__ */ + +#ifndef PNG_VERSION_INFO_ONLY + +/* End of material added to libpng-1.2.8 */ + +/* Added at libpng-1.2.19, removed at libpng-1.2.20 because it caused trouble + Restored at libpng-1.2.21 */ +#if !defined(PNG_NO_WARN_UNINITIALIZED_ROW) && \ + !defined(PNG_WARN_UNINITIALIZED_ROW) +# define PNG_WARN_UNINITIALIZED_ROW 1 +#endif +/* End of material added at libpng-1.2.19/1.2.21 */ + +/* This is the size of the compression buffer, and thus the size of + * an IDAT chunk. Make this whatever size you feel is best for your + * machine. One of these will be allocated per png_struct. When this + * is full, it writes the data to the disk, and does some other + * calculations. Making this an extremely small size will slow + * the library down, but you may want to experiment to determine + * where it becomes significant, if you are concerned with memory + * usage. Note that zlib allocates at least 32Kb also. For readers, + * this describes the size of the buffer available to read the data in. + * Unless this gets smaller than the size of a row (compressed), + * it should not make much difference how big this is. + */ + +#ifndef PNG_ZBUF_SIZE +# define PNG_ZBUF_SIZE 8192 +#endif + +/* Enable if you want a write-only libpng */ + +#ifndef PNG_NO_READ_SUPPORTED +# define PNG_READ_SUPPORTED +#endif + +/* Enable if you want a read-only libpng */ + +#ifndef PNG_NO_WRITE_SUPPORTED +# define PNG_WRITE_SUPPORTED +#endif + +/* Enabled by default in 1.2.0. You can disable this if you don't need to + support PNGs that are embedded in MNG datastreams */ +#if !defined(PNG_1_0_X) && !defined(PNG_NO_MNG_FEATURES) +# ifndef PNG_MNG_FEATURES_SUPPORTED +# define PNG_MNG_FEATURES_SUPPORTED +# endif +#endif + +#ifndef PNG_NO_FLOATING_POINT_SUPPORTED +# ifndef PNG_FLOATING_POINT_SUPPORTED +# define PNG_FLOATING_POINT_SUPPORTED +# endif +#endif + +/* If you are running on a machine where you cannot allocate more + * than 64K of memory at once, uncomment this. While libpng will not + * normally need that much memory in a chunk (unless you load up a very + * large file), zlib needs to know how big of a chunk it can use, and + * libpng thus makes sure to check any memory allocation to verify it + * will fit into memory. +#define PNG_MAX_MALLOC_64K + */ +#if defined(MAXSEG_64K) && !defined(PNG_MAX_MALLOC_64K) +# define PNG_MAX_MALLOC_64K +#endif + +/* Special munging to support doing things the 'cygwin' way: + * 'Normal' png-on-win32 defines/defaults: + * PNG_BUILD_DLL -- building dll + * PNG_USE_DLL -- building an application, linking to dll + * (no define) -- building static library, or building an + * application and linking to the static lib + * 'Cygwin' defines/defaults: + * PNG_BUILD_DLL -- (ignored) building the dll + * (no define) -- (ignored) building an application, linking to the dll + * PNG_STATIC -- (ignored) building the static lib, or building an + * application that links to the static lib. + * ALL_STATIC -- (ignored) building various static libs, or building an + * application that links to the static libs. + * Thus, + * a cygwin user should define either PNG_BUILD_DLL or PNG_STATIC, and + * this bit of #ifdefs will define the 'correct' config variables based on + * that. If a cygwin user *wants* to define 'PNG_USE_DLL' that's okay, but + * unnecessary. + * + * Also, the precedence order is: + * ALL_STATIC (since we can't #undef something outside our namespace) + * PNG_BUILD_DLL + * PNG_STATIC + * (nothing) == PNG_USE_DLL + * + * CYGWIN (2002-01-20): The preceding is now obsolete. With the advent + * of auto-import in binutils, we no longer need to worry about + * __declspec(dllexport) / __declspec(dllimport) and friends. Therefore, + * we don't need to worry about PNG_STATIC or ALL_STATIC when it comes + * to __declspec() stuff. However, we DO need to worry about + * PNG_BUILD_DLL and PNG_STATIC because those change some defaults + * such as CONSOLE_IO and whether GLOBAL_ARRAYS are allowed. + */ +#if defined(__CYGWIN__) +# if defined(ALL_STATIC) +# if defined(PNG_BUILD_DLL) +# undef PNG_BUILD_DLL +# endif +# if defined(PNG_USE_DLL) +# undef PNG_USE_DLL +# endif +# if defined(PNG_DLL) +# undef PNG_DLL +# endif +# if !defined(PNG_STATIC) +# define PNG_STATIC +# endif +# else +# if defined (PNG_BUILD_DLL) +# if defined(PNG_STATIC) +# undef PNG_STATIC +# endif +# if defined(PNG_USE_DLL) +# undef PNG_USE_DLL +# endif +# if !defined(PNG_DLL) +# define PNG_DLL +# endif +# else +# if defined(PNG_STATIC) +# if defined(PNG_USE_DLL) +# undef PNG_USE_DLL +# endif +# if defined(PNG_DLL) +# undef PNG_DLL +# endif +# else +# if !defined(PNG_USE_DLL) +# define PNG_USE_DLL +# endif +# if !defined(PNG_DLL) +# define PNG_DLL +# endif +# endif +# endif +# endif +#endif + +/* This protects us against compilers that run on a windowing system + * and thus don't have or would rather us not use the stdio types: + * stdin, stdout, and stderr. The only one currently used is stderr + * in png_error() and png_warning(). #defining PNG_NO_CONSOLE_IO will + * prevent these from being compiled and used. #defining PNG_NO_STDIO + * will also prevent these, plus will prevent the entire set of stdio + * macros and functions (FILE *, printf, etc.) from being compiled and used, + * unless (PNG_DEBUG > 0) has been #defined. + * + * #define PNG_NO_CONSOLE_IO + * #define PNG_NO_STDIO + */ + +#if defined(_WIN32_WCE) +# include + /* Console I/O functions are not supported on WindowsCE */ +# define PNG_NO_CONSOLE_IO + /* abort() may not be supported on some/all Windows CE platforms */ +# define PNG_ABORT() exit(-1) +# ifdef PNG_DEBUG +# undef PNG_DEBUG +# endif +#endif + +#ifdef PNG_BUILD_DLL +# ifndef PNG_CONSOLE_IO_SUPPORTED +# ifndef PNG_NO_CONSOLE_IO +# define PNG_NO_CONSOLE_IO +# endif +# endif +#endif + +# ifdef PNG_NO_STDIO +# ifndef PNG_NO_CONSOLE_IO +# define PNG_NO_CONSOLE_IO +# endif +# ifdef PNG_DEBUG +# if (PNG_DEBUG > 0) +# include +# endif +# endif +# else +# if !defined(_WIN32_WCE) +/* "stdio.h" functions are not supported on WindowsCE */ +# include +# endif +# endif + +/* This macro protects us against machines that don't have function + * prototypes (ie K&R style headers). If your compiler does not handle + * function prototypes, define this macro and use the included ansi2knr. + * I've always been able to use _NO_PROTO as the indicator, but you may + * need to drag the empty declaration out in front of here, or change the + * ifdef to suit your own needs. + */ +#ifndef PNGARG + +#ifdef OF /* zlib prototype munger */ +# define PNGARG(arglist) OF(arglist) +#else + +#ifdef _NO_PROTO +# define PNGARG(arglist) () +# ifndef PNG_TYPECAST_NULL +# define PNG_TYPECAST_NULL +# endif +#else +# define PNGARG(arglist) arglist +#endif /* _NO_PROTO */ + + +#endif /* OF */ + +#endif /* PNGARG */ + +/* Try to determine if we are compiling on a Mac. Note that testing for + * just __MWERKS__ is not good enough, because the Codewarrior is now used + * on non-Mac platforms. + */ +#ifndef MACOS +# if (defined(__MWERKS__) && defined(macintosh)) || defined(applec) || \ + defined(THINK_C) || defined(__SC__) || defined(TARGET_OS_MAC) +# define MACOS +# endif +#endif + +/* enough people need this for various reasons to include it here */ +#if !defined(MACOS) && !defined(RISCOS) && !defined(_WIN32_WCE) +# include +#endif + +#if !defined(PNG_SETJMP_NOT_SUPPORTED) && !defined(PNG_NO_SETJMP_SUPPORTED) +# define PNG_SETJMP_SUPPORTED +#endif + +#ifdef PNG_SETJMP_SUPPORTED +/* This is an attempt to force a single setjmp behaviour on Linux. If + * the X config stuff didn't define _BSD_SOURCE we wouldn't need this. + * + * You can bypass this test if you know that your application uses exactly + * the same setjmp.h that was included when libpng was built. Only define + * PNG_SKIP_SETJMP_CHECK while building your application, prior to the + * application's '#include "png.h"'. Don't define PNG_SKIP_SETJMP_CHECK + * while building a separate libpng library for general use. + */ + +# ifndef PNG_SKIP_SETJMP_CHECK +# ifdef __linux__ +# ifdef _BSD_SOURCE +# define PNG_SAVE_BSD_SOURCE +# undef _BSD_SOURCE +# endif +# ifdef _SETJMP_H + /* If you encounter a compiler error here, see the explanation + * near the end of INSTALL. + */ + __pngconf.h__ in libpng already includes setjmp.h; + __dont__ include it again.; +# endif +# endif /* __linux__ */ +# endif /* PNG_SKIP_SETJMP_CHECK */ + + /* include setjmp.h for error handling */ +# include + +# ifdef __linux__ +# ifdef PNG_SAVE_BSD_SOURCE +# ifndef _BSD_SOURCE +# define _BSD_SOURCE +# endif +# undef PNG_SAVE_BSD_SOURCE +# endif +# endif /* __linux__ */ +#endif /* PNG_SETJMP_SUPPORTED */ + +#ifdef BSD +# include +#else +# include +#endif + +/* Other defines for things like memory and the like can go here. */ +#ifdef PNG_INTERNAL + +#include + +/* The functions exported by PNG_EXTERN are PNG_INTERNAL functions, which + * aren't usually used outside the library (as far as I know), so it is + * debatable if they should be exported at all. In the future, when it is + * possible to have run-time registry of chunk-handling functions, some of + * these will be made available again. +#define PNG_EXTERN extern + */ +#define PNG_EXTERN + +/* Other defines specific to compilers can go here. Try to keep + * them inside an appropriate ifdef/endif pair for portability. + */ + +#if defined(PNG_FLOATING_POINT_SUPPORTED) +# if defined(MACOS) + /* We need to check that hasn't already been included earlier + * as it seems it doesn't agree with , yet we should really use + * if possible. + */ +# if !defined(__MATH_H__) && !defined(__MATH_H) && !defined(__cmath__) +# include +# endif +# else +# include +# endif +# if defined(_AMIGA) && defined(__SASC) && defined(_M68881) + /* Amiga SAS/C: We must include builtin FPU functions when compiling using + * MATH=68881 + */ +# include +# endif +#endif + +/* Codewarrior on NT has linking problems without this. */ +#if (defined(__MWERKS__) && defined(WIN32)) || defined(__STDC__) +# define PNG_ALWAYS_EXTERN +#endif + +/* This provides the non-ANSI (far) memory allocation routines. */ +#if defined(__TURBOC__) && defined(__MSDOS__) +# include +# include +#endif + +/* I have no idea why is this necessary... */ +#if defined(_MSC_VER) && (defined(WIN32) || defined(_Windows) || \ + defined(_WINDOWS) || defined(_WIN32) || defined(__WIN32__)) +# include +#endif + +/* This controls how fine the dithering gets. As this allocates + * a largish chunk of memory (32K), those who are not as concerned + * with dithering quality can decrease some or all of these. + */ +#ifndef PNG_DITHER_RED_BITS +# define PNG_DITHER_RED_BITS 5 +#endif +#ifndef PNG_DITHER_GREEN_BITS +# define PNG_DITHER_GREEN_BITS 5 +#endif +#ifndef PNG_DITHER_BLUE_BITS +# define PNG_DITHER_BLUE_BITS 5 +#endif + +/* This controls how fine the gamma correction becomes when you + * are only interested in 8 bits anyway. Increasing this value + * results in more memory being used, and more pow() functions + * being called to fill in the gamma tables. Don't set this value + * less then 8, and even that may not work (I haven't tested it). + */ + +#ifndef PNG_MAX_GAMMA_8 +# define PNG_MAX_GAMMA_8 11 +#endif + +/* This controls how much a difference in gamma we can tolerate before + * we actually start doing gamma conversion. + */ +#ifndef PNG_GAMMA_THRESHOLD +# define PNG_GAMMA_THRESHOLD 0.05 +#endif + +#endif /* PNG_INTERNAL */ + +/* The following uses const char * instead of char * for error + * and warning message functions, so some compilers won't complain. + * If you do not want to use const, define PNG_NO_CONST here. + */ + +#ifndef PNG_NO_CONST +# define PNG_CONST const +#else +# define PNG_CONST +#endif + +/* The following defines give you the ability to remove code from the + * library that you will not be using. I wish I could figure out how to + * automate this, but I can't do that without making it seriously hard + * on the users. So if you are not using an ability, change the #define + * to and #undef, and that part of the library will not be compiled. If + * your linker can't find a function, you may want to make sure the + * ability is defined here. Some of these depend upon some others being + * defined. I haven't figured out all the interactions here, so you may + * have to experiment awhile to get everything to compile. If you are + * creating or using a shared library, you probably shouldn't touch this, + * as it will affect the size of the structures, and this will cause bad + * things to happen if the library and/or application ever change. + */ + +/* Any features you will not be using can be undef'ed here */ + +/* GR-P, 0.96a: Set "*TRANSFORMS_SUPPORTED as default but allow user + * to turn it off with "*TRANSFORMS_NOT_SUPPORTED" or *PNG_NO_*_TRANSFORMS + * on the compile line, then pick and choose which ones to define without + * having to edit this file. It is safe to use the *TRANSFORMS_NOT_SUPPORTED + * if you only want to have a png-compliant reader/writer but don't need + * any of the extra transformations. This saves about 80 kbytes in a + * typical installation of the library. (PNG_NO_* form added in version + * 1.0.1c, for consistency) + */ + +/* The size of the png_text structure changed in libpng-1.0.6 when + * iTXt support was added. iTXt support was turned off by default through + * libpng-1.2.x, to support old apps that malloc the png_text structure + * instead of calling png_set_text() and letting libpng malloc it. It + * was turned on by default in libpng-1.3.0. + */ + +#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +# ifndef PNG_NO_iTXt_SUPPORTED +# define PNG_NO_iTXt_SUPPORTED +# endif +# ifndef PNG_NO_READ_iTXt +# define PNG_NO_READ_iTXt +# endif +# ifndef PNG_NO_WRITE_iTXt +# define PNG_NO_WRITE_iTXt +# endif +#endif + +#if !defined(PNG_NO_iTXt_SUPPORTED) +# if !defined(PNG_READ_iTXt_SUPPORTED) && !defined(PNG_NO_READ_iTXt) +# define PNG_READ_iTXt +# endif +# if !defined(PNG_WRITE_iTXt_SUPPORTED) && !defined(PNG_NO_WRITE_iTXt) +# define PNG_WRITE_iTXt +# endif +#endif + +/* The following support, added after version 1.0.0, can be turned off here en + * masse by defining PNG_LEGACY_SUPPORTED in case you need binary compatibility + * with old applications that require the length of png_struct and png_info + * to remain unchanged. + */ + +#ifdef PNG_LEGACY_SUPPORTED +# define PNG_NO_FREE_ME +# define PNG_NO_READ_UNKNOWN_CHUNKS +# define PNG_NO_WRITE_UNKNOWN_CHUNKS +# define PNG_NO_READ_USER_CHUNKS +# define PNG_NO_READ_iCCP +# define PNG_NO_WRITE_iCCP +# define PNG_NO_READ_iTXt +# define PNG_NO_WRITE_iTXt +# define PNG_NO_READ_sCAL +# define PNG_NO_WRITE_sCAL +# define PNG_NO_READ_sPLT +# define PNG_NO_WRITE_sPLT +# define PNG_NO_INFO_IMAGE +# define PNG_NO_READ_RGB_TO_GRAY +# define PNG_NO_READ_USER_TRANSFORM +# define PNG_NO_WRITE_USER_TRANSFORM +# define PNG_NO_USER_MEM +# define PNG_NO_READ_EMPTY_PLTE +# define PNG_NO_MNG_FEATURES +# define PNG_NO_FIXED_POINT_SUPPORTED +#endif + +/* Ignore attempt to turn off both floating and fixed point support */ +#if !defined(PNG_FLOATING_POINT_SUPPORTED) || \ + !defined(PNG_NO_FIXED_POINT_SUPPORTED) +# define PNG_FIXED_POINT_SUPPORTED +#endif + +#ifndef PNG_NO_FREE_ME +# define PNG_FREE_ME_SUPPORTED +#endif + +#if defined(PNG_READ_SUPPORTED) + +#if !defined(PNG_READ_TRANSFORMS_NOT_SUPPORTED) && \ + !defined(PNG_NO_READ_TRANSFORMS) +# define PNG_READ_TRANSFORMS_SUPPORTED +#endif + +#ifdef PNG_READ_TRANSFORMS_SUPPORTED +# ifndef PNG_NO_READ_EXPAND +# define PNG_READ_EXPAND_SUPPORTED +# endif +# ifndef PNG_NO_READ_SHIFT +# define PNG_READ_SHIFT_SUPPORTED +# endif +# ifndef PNG_NO_READ_PACK +# define PNG_READ_PACK_SUPPORTED +# endif +# ifndef PNG_NO_READ_BGR +# define PNG_READ_BGR_SUPPORTED +# endif +# ifndef PNG_NO_READ_SWAP +# define PNG_READ_SWAP_SUPPORTED +# endif +# ifndef PNG_NO_READ_PACKSWAP +# define PNG_READ_PACKSWAP_SUPPORTED +# endif +# ifndef PNG_NO_READ_INVERT +# define PNG_READ_INVERT_SUPPORTED +# endif +# ifndef PNG_NO_READ_DITHER +# define PNG_READ_DITHER_SUPPORTED +# endif +# ifndef PNG_NO_READ_BACKGROUND +# define PNG_READ_BACKGROUND_SUPPORTED +# endif +# ifndef PNG_NO_READ_16_TO_8 +# define PNG_READ_16_TO_8_SUPPORTED +# endif +# ifndef PNG_NO_READ_FILLER +# define PNG_READ_FILLER_SUPPORTED +# endif +# ifndef PNG_NO_READ_GAMMA +# define PNG_READ_GAMMA_SUPPORTED +# endif +# ifndef PNG_NO_READ_GRAY_TO_RGB +# define PNG_READ_GRAY_TO_RGB_SUPPORTED +# endif +# ifndef PNG_NO_READ_SWAP_ALPHA +# define PNG_READ_SWAP_ALPHA_SUPPORTED +# endif +# ifndef PNG_NO_READ_INVERT_ALPHA +# define PNG_READ_INVERT_ALPHA_SUPPORTED +# endif +# ifndef PNG_NO_READ_STRIP_ALPHA +# define PNG_READ_STRIP_ALPHA_SUPPORTED +# endif +# ifndef PNG_NO_READ_USER_TRANSFORM +# define PNG_READ_USER_TRANSFORM_SUPPORTED +# endif +# ifndef PNG_NO_READ_RGB_TO_GRAY +# define PNG_READ_RGB_TO_GRAY_SUPPORTED +# endif +#endif /* PNG_READ_TRANSFORMS_SUPPORTED */ + +#if !defined(PNG_NO_PROGRESSIVE_READ) && \ + !defined(PNG_PROGRESSIVE_READ_SUPPORTED) /* if you don't do progressive */ +# define PNG_PROGRESSIVE_READ_SUPPORTED /* reading. This is not talking */ +#endif /* about interlacing capability! You'll */ + /* still have interlacing unless you change the following line: */ + +#define PNG_READ_INTERLACING_SUPPORTED /* required in PNG-compliant decoders */ + +#ifndef PNG_NO_READ_COMPOSITE_NODIV +# ifndef PNG_NO_READ_COMPOSITED_NODIV /* libpng-1.0.x misspelling */ +# define PNG_READ_COMPOSITE_NODIV_SUPPORTED /* well tested on Intel, SGI */ +# endif +#endif + +#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +/* Deprecated, will be removed from version 2.0.0. + Use PNG_MNG_FEATURES_SUPPORTED instead. */ +#ifndef PNG_NO_READ_EMPTY_PLTE +# define PNG_READ_EMPTY_PLTE_SUPPORTED +#endif +#endif + +#endif /* PNG_READ_SUPPORTED */ + +#if defined(PNG_WRITE_SUPPORTED) + +# if !defined(PNG_WRITE_TRANSFORMS_NOT_SUPPORTED) && \ + !defined(PNG_NO_WRITE_TRANSFORMS) +# define PNG_WRITE_TRANSFORMS_SUPPORTED +#endif + +#ifdef PNG_WRITE_TRANSFORMS_SUPPORTED +# ifndef PNG_NO_WRITE_SHIFT +# define PNG_WRITE_SHIFT_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_PACK +# define PNG_WRITE_PACK_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_BGR +# define PNG_WRITE_BGR_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_SWAP +# define PNG_WRITE_SWAP_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_PACKSWAP +# define PNG_WRITE_PACKSWAP_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_INVERT +# define PNG_WRITE_INVERT_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_FILLER +# define PNG_WRITE_FILLER_SUPPORTED /* same as WRITE_STRIP_ALPHA */ +# endif +# ifndef PNG_NO_WRITE_SWAP_ALPHA +# define PNG_WRITE_SWAP_ALPHA_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_INVERT_ALPHA +# define PNG_WRITE_INVERT_ALPHA_SUPPORTED +# endif +# ifndef PNG_NO_WRITE_USER_TRANSFORM +# define PNG_WRITE_USER_TRANSFORM_SUPPORTED +# endif +#endif /* PNG_WRITE_TRANSFORMS_SUPPORTED */ + +#if !defined(PNG_NO_WRITE_INTERLACING_SUPPORTED) && \ + !defined(PNG_WRITE_INTERLACING_SUPPORTED) +#define PNG_WRITE_INTERLACING_SUPPORTED /* not required for PNG-compliant + encoders, but can cause trouble + if left undefined */ +#endif + +#if !defined(PNG_NO_WRITE_WEIGHTED_FILTER) && \ + !defined(PNG_WRITE_WEIGHTED_FILTER) && \ + defined(PNG_FLOATING_POINT_SUPPORTED) +# define PNG_WRITE_WEIGHTED_FILTER_SUPPORTED +#endif + +#ifndef PNG_NO_WRITE_FLUSH +# define PNG_WRITE_FLUSH_SUPPORTED +#endif + +#if defined(PNG_1_0_X) || defined (PNG_1_2_X) +/* Deprecated, see PNG_MNG_FEATURES_SUPPORTED, above */ +#ifndef PNG_NO_WRITE_EMPTY_PLTE +# define PNG_WRITE_EMPTY_PLTE_SUPPORTED +#endif +#endif + +#endif /* PNG_WRITE_SUPPORTED */ + +#ifndef PNG_1_0_X +# ifndef PNG_NO_ERROR_NUMBERS +# define PNG_ERROR_NUMBERS_SUPPORTED +# endif +#endif /* PNG_1_0_X */ + +#if defined(PNG_READ_USER_TRANSFORM_SUPPORTED) || \ + defined(PNG_WRITE_USER_TRANSFORM_SUPPORTED) +# ifndef PNG_NO_USER_TRANSFORM_PTR +# define PNG_USER_TRANSFORM_PTR_SUPPORTED +# endif +#endif + +#ifndef PNG_NO_STDIO +# define PNG_TIME_RFC1123_SUPPORTED +#endif + +/* This adds extra functions in pngget.c for accessing data from the + * info pointer (added in version 0.99) + * png_get_image_width() + * png_get_image_height() + * png_get_bit_depth() + * png_get_color_type() + * png_get_compression_type() + * png_get_filter_type() + * png_get_interlace_type() + * png_get_pixel_aspect_ratio() + * png_get_pixels_per_meter() + * png_get_x_offset_pixels() + * png_get_y_offset_pixels() + * png_get_x_offset_microns() + * png_get_y_offset_microns() + */ +#if !defined(PNG_NO_EASY_ACCESS) && !defined(PNG_EASY_ACCESS_SUPPORTED) +# define PNG_EASY_ACCESS_SUPPORTED +#endif + +/* PNG_ASSEMBLER_CODE was enabled by default in version 1.2.0 + * and removed from version 1.2.20. The following will be removed + * from libpng-1.4.0 +*/ + +#if defined(PNG_READ_SUPPORTED) && !defined(PNG_NO_OPTIMIZED_CODE) +# ifndef PNG_OPTIMIZED_CODE_SUPPORTED +# define PNG_OPTIMIZED_CODE_SUPPORTED +# endif +#endif + +#if defined(PNG_READ_SUPPORTED) && !defined(PNG_NO_ASSEMBLER_CODE) && defined(__i386__) +# ifndef PNG_ASSEMBLER_CODE_SUPPORTED +# define PNG_ASSEMBLER_CODE_SUPPORTED +# endif + +# if defined(__GNUC__) && defined(__x86_64__) && (__GNUC__ < 4) + /* work around 64-bit gcc compiler bugs in gcc-3.x */ +# if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE) +# define PNG_NO_MMX_CODE +# endif +# endif + +# if defined(__APPLE__) +# if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE) +# define PNG_NO_MMX_CODE +# endif +# endif + +# if (defined(__MWERKS__) && ((__MWERKS__ < 0x0900) || macintosh)) +# if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE) +# define PNG_NO_MMX_CODE +# endif +# endif + +# if !defined(PNG_MMX_CODE_SUPPORTED) && !defined(PNG_NO_MMX_CODE) +# define PNG_MMX_CODE_SUPPORTED +# endif + +#endif +/* end of obsolete code to be removed from libpng-1.4.0 */ + +#if !defined(PNG_1_0_X) +#if !defined(PNG_NO_USER_MEM) && !defined(PNG_USER_MEM_SUPPORTED) +# define PNG_USER_MEM_SUPPORTED +#endif +#endif /* PNG_1_0_X */ + +/* Added at libpng-1.2.6 */ +#if !defined(PNG_1_0_X) +#ifndef PNG_SET_USER_LIMITS_SUPPORTED +#if !defined(PNG_NO_SET_USER_LIMITS) && !defined(PNG_SET_USER_LIMITS_SUPPORTED) +# define PNG_SET_USER_LIMITS_SUPPORTED +#endif +#endif +#endif /* PNG_1_0_X */ + +/* Added at libpng-1.0.16 and 1.2.6. To accept all valid PNGS no matter + * how large, set these limits to 0x7fffffffL + */ +#ifndef PNG_USER_WIDTH_MAX +# define PNG_USER_WIDTH_MAX 1000000L +#endif +#ifndef PNG_USER_HEIGHT_MAX +# define PNG_USER_HEIGHT_MAX 1000000L +#endif + +/* Added at libpng-1.2.34 and 1.4.0 */ +#ifndef PNG_STRING_NEWLINE +#define PNG_STRING_NEWLINE "\n" +#endif + +/* These are currently experimental features, define them if you want */ + +/* very little testing */ +/* +#ifdef PNG_READ_SUPPORTED +# ifndef PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED +# define PNG_READ_16_TO_8_ACCURATE_SCALE_SUPPORTED +# endif +#endif +*/ + +/* This is only for PowerPC big-endian and 680x0 systems */ +/* some testing */ +/* +#ifndef PNG_READ_BIG_ENDIAN_SUPPORTED +# define PNG_READ_BIG_ENDIAN_SUPPORTED +#endif +*/ + +/* Buggy compilers (e.g., gcc 2.7.2.2) need this */ +/* +#define PNG_NO_POINTER_INDEXING +*/ + +/* These functions are turned off by default, as they will be phased out. */ +/* +#define PNG_USELESS_TESTS_SUPPORTED +#define PNG_CORRECT_PALETTE_SUPPORTED +*/ + +/* Any chunks you are not interested in, you can undef here. The + * ones that allocate memory may be expecially important (hIST, + * tEXt, zTXt, tRNS, pCAL). Others will just save time and make png_info + * a bit smaller. + */ + +#if defined(PNG_READ_SUPPORTED) && \ + !defined(PNG_READ_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \ + !defined(PNG_NO_READ_ANCILLARY_CHUNKS) +# define PNG_READ_ANCILLARY_CHUNKS_SUPPORTED +#endif + +#if defined(PNG_WRITE_SUPPORTED) && \ + !defined(PNG_WRITE_ANCILLARY_CHUNKS_NOT_SUPPORTED) && \ + !defined(PNG_NO_WRITE_ANCILLARY_CHUNKS) +# define PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED +#endif + +#ifdef PNG_READ_ANCILLARY_CHUNKS_SUPPORTED + +#ifdef PNG_NO_READ_TEXT +# define PNG_NO_READ_iTXt +# define PNG_NO_READ_tEXt +# define PNG_NO_READ_zTXt +#endif +#ifndef PNG_NO_READ_bKGD +# define PNG_READ_bKGD_SUPPORTED +# define PNG_bKGD_SUPPORTED +#endif +#ifndef PNG_NO_READ_cHRM +# define PNG_READ_cHRM_SUPPORTED +# define PNG_cHRM_SUPPORTED +#endif +#ifndef PNG_NO_READ_gAMA +# define PNG_READ_gAMA_SUPPORTED +# define PNG_gAMA_SUPPORTED +#endif +#ifndef PNG_NO_READ_hIST +# define PNG_READ_hIST_SUPPORTED +# define PNG_hIST_SUPPORTED +#endif +#ifndef PNG_NO_READ_iCCP +# define PNG_READ_iCCP_SUPPORTED +# define PNG_iCCP_SUPPORTED +#endif +#ifndef PNG_NO_READ_iTXt +# ifndef PNG_READ_iTXt_SUPPORTED +# define PNG_READ_iTXt_SUPPORTED +# endif +# ifndef PNG_iTXt_SUPPORTED +# define PNG_iTXt_SUPPORTED +# endif +#endif +#ifndef PNG_NO_READ_oFFs +# define PNG_READ_oFFs_SUPPORTED +# define PNG_oFFs_SUPPORTED +#endif +#ifndef PNG_NO_READ_pCAL +# define PNG_READ_pCAL_SUPPORTED +# define PNG_pCAL_SUPPORTED +#endif +#ifndef PNG_NO_READ_sCAL +# define PNG_READ_sCAL_SUPPORTED +# define PNG_sCAL_SUPPORTED +#endif +#ifndef PNG_NO_READ_pHYs +# define PNG_READ_pHYs_SUPPORTED +# define PNG_pHYs_SUPPORTED +#endif +#ifndef PNG_NO_READ_sBIT +# define PNG_READ_sBIT_SUPPORTED +# define PNG_sBIT_SUPPORTED +#endif +#ifndef PNG_NO_READ_sPLT +# define PNG_READ_sPLT_SUPPORTED +# define PNG_sPLT_SUPPORTED +#endif +#ifndef PNG_NO_READ_sRGB +# define PNG_READ_sRGB_SUPPORTED +# define PNG_sRGB_SUPPORTED +#endif +#ifndef PNG_NO_READ_tEXt +# define PNG_READ_tEXt_SUPPORTED +# define PNG_tEXt_SUPPORTED +#endif +#ifndef PNG_NO_READ_tIME +# define PNG_READ_tIME_SUPPORTED +# define PNG_tIME_SUPPORTED +#endif +#ifndef PNG_NO_READ_tRNS +# define PNG_READ_tRNS_SUPPORTED +# define PNG_tRNS_SUPPORTED +#endif +#ifndef PNG_NO_READ_zTXt +# define PNG_READ_zTXt_SUPPORTED +# define PNG_zTXt_SUPPORTED +#endif +#ifndef PNG_NO_READ_UNKNOWN_CHUNKS +# define PNG_READ_UNKNOWN_CHUNKS_SUPPORTED +# ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED +# define PNG_UNKNOWN_CHUNKS_SUPPORTED +# endif +# ifndef PNG_NO_HANDLE_AS_UNKNOWN +# define PNG_HANDLE_AS_UNKNOWN_SUPPORTED +# endif +#endif +#if !defined(PNG_NO_READ_USER_CHUNKS) && \ + defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED) +# define PNG_READ_USER_CHUNKS_SUPPORTED +# define PNG_USER_CHUNKS_SUPPORTED +# ifdef PNG_NO_READ_UNKNOWN_CHUNKS +# undef PNG_NO_READ_UNKNOWN_CHUNKS +# endif +# ifdef PNG_NO_HANDLE_AS_UNKNOWN +# undef PNG_NO_HANDLE_AS_UNKNOWN +# endif +#endif +#ifndef PNG_NO_READ_OPT_PLTE +# define PNG_READ_OPT_PLTE_SUPPORTED /* only affects support of the */ +#endif /* optional PLTE chunk in RGB and RGBA images */ +#if defined(PNG_READ_iTXt_SUPPORTED) || defined(PNG_READ_tEXt_SUPPORTED) || \ + defined(PNG_READ_zTXt_SUPPORTED) +# define PNG_READ_TEXT_SUPPORTED +# define PNG_TEXT_SUPPORTED +#endif + +#endif /* PNG_READ_ANCILLARY_CHUNKS_SUPPORTED */ + +#ifdef PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED + +#ifdef PNG_NO_WRITE_TEXT +# define PNG_NO_WRITE_iTXt +# define PNG_NO_WRITE_tEXt +# define PNG_NO_WRITE_zTXt +#endif +#ifndef PNG_NO_WRITE_bKGD +# define PNG_WRITE_bKGD_SUPPORTED +# ifndef PNG_bKGD_SUPPORTED +# define PNG_bKGD_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_cHRM +# define PNG_WRITE_cHRM_SUPPORTED +# ifndef PNG_cHRM_SUPPORTED +# define PNG_cHRM_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_gAMA +# define PNG_WRITE_gAMA_SUPPORTED +# ifndef PNG_gAMA_SUPPORTED +# define PNG_gAMA_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_hIST +# define PNG_WRITE_hIST_SUPPORTED +# ifndef PNG_hIST_SUPPORTED +# define PNG_hIST_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_iCCP +# define PNG_WRITE_iCCP_SUPPORTED +# ifndef PNG_iCCP_SUPPORTED +# define PNG_iCCP_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_iTXt +# ifndef PNG_WRITE_iTXt_SUPPORTED +# define PNG_WRITE_iTXt_SUPPORTED +# endif +# ifndef PNG_iTXt_SUPPORTED +# define PNG_iTXt_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_oFFs +# define PNG_WRITE_oFFs_SUPPORTED +# ifndef PNG_oFFs_SUPPORTED +# define PNG_oFFs_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_pCAL +# define PNG_WRITE_pCAL_SUPPORTED +# ifndef PNG_pCAL_SUPPORTED +# define PNG_pCAL_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_sCAL +# define PNG_WRITE_sCAL_SUPPORTED +# ifndef PNG_sCAL_SUPPORTED +# define PNG_sCAL_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_pHYs +# define PNG_WRITE_pHYs_SUPPORTED +# ifndef PNG_pHYs_SUPPORTED +# define PNG_pHYs_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_sBIT +# define PNG_WRITE_sBIT_SUPPORTED +# ifndef PNG_sBIT_SUPPORTED +# define PNG_sBIT_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_sPLT +# define PNG_WRITE_sPLT_SUPPORTED +# ifndef PNG_sPLT_SUPPORTED +# define PNG_sPLT_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_sRGB +# define PNG_WRITE_sRGB_SUPPORTED +# ifndef PNG_sRGB_SUPPORTED +# define PNG_sRGB_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_tEXt +# define PNG_WRITE_tEXt_SUPPORTED +# ifndef PNG_tEXt_SUPPORTED +# define PNG_tEXt_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_tIME +# define PNG_WRITE_tIME_SUPPORTED +# ifndef PNG_tIME_SUPPORTED +# define PNG_tIME_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_tRNS +# define PNG_WRITE_tRNS_SUPPORTED +# ifndef PNG_tRNS_SUPPORTED +# define PNG_tRNS_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_zTXt +# define PNG_WRITE_zTXt_SUPPORTED +# ifndef PNG_zTXt_SUPPORTED +# define PNG_zTXt_SUPPORTED +# endif +#endif +#ifndef PNG_NO_WRITE_UNKNOWN_CHUNKS +# define PNG_WRITE_UNKNOWN_CHUNKS_SUPPORTED +# ifndef PNG_UNKNOWN_CHUNKS_SUPPORTED +# define PNG_UNKNOWN_CHUNKS_SUPPORTED +# endif +# ifndef PNG_NO_HANDLE_AS_UNKNOWN +# ifndef PNG_HANDLE_AS_UNKNOWN_SUPPORTED +# define PNG_HANDLE_AS_UNKNOWN_SUPPORTED +# endif +# endif +#endif +#if defined(PNG_WRITE_iTXt_SUPPORTED) || defined(PNG_WRITE_tEXt_SUPPORTED) || \ + defined(PNG_WRITE_zTXt_SUPPORTED) +# define PNG_WRITE_TEXT_SUPPORTED +# ifndef PNG_TEXT_SUPPORTED +# define PNG_TEXT_SUPPORTED +# endif +#endif + +#endif /* PNG_WRITE_ANCILLARY_CHUNKS_SUPPORTED */ + +/* Turn this off to disable png_read_png() and + * png_write_png() and leave the row_pointers member + * out of the info structure. + */ +#ifndef PNG_NO_INFO_IMAGE +# define PNG_INFO_IMAGE_SUPPORTED +#endif + +/* need the time information for reading tIME chunks */ +#if defined(PNG_tIME_SUPPORTED) +# if !defined(_WIN32_WCE) + /* "time.h" functions are not supported on WindowsCE */ +# include +# endif +#endif + +/* Some typedefs to get us started. These should be safe on most of the + * common platforms. The typedefs should be at least as large as the + * numbers suggest (a png_uint_32 must be at least 32 bits long), but they + * don't have to be exactly that size. Some compilers dislike passing + * unsigned shorts as function parameters, so you may be better off using + * unsigned int for png_uint_16. Likewise, for 64-bit systems, you may + * want to have unsigned int for png_uint_32 instead of unsigned long. + */ + +typedef unsigned long png_uint_32; +typedef long png_int_32; +typedef unsigned short png_uint_16; +typedef short png_int_16; +typedef unsigned char png_byte; + +/* This is usually size_t. It is typedef'ed just in case you need it to + change (I'm not sure if you will or not, so I thought I'd be safe) */ +#ifdef PNG_SIZE_T + typedef PNG_SIZE_T png_size_t; +# define png_sizeof(x) png_convert_size(sizeof(x)) +#else + typedef size_t png_size_t; +# define png_sizeof(x) sizeof(x) +#endif + +/* The following is needed for medium model support. It cannot be in the + * PNG_INTERNAL section. Needs modification for other compilers besides + * MSC. Model independent support declares all arrays and pointers to be + * large using the far keyword. The zlib version used must also support + * model independent data. As of version zlib 1.0.4, the necessary changes + * have been made in zlib. The USE_FAR_KEYWORD define triggers other + * changes that are needed. (Tim Wegner) + */ + +/* Separate compiler dependencies (problem here is that zlib.h always + defines FAR. (SJT) */ +#ifdef __BORLANDC__ +# if defined(__LARGE__) || defined(__HUGE__) || defined(__COMPACT__) +# define LDATA 1 +# else +# define LDATA 0 +# endif + /* GRR: why is Cygwin in here? Cygwin is not Borland C... */ +# if !defined(__WIN32__) && !defined(__FLAT__) && !defined(__CYGWIN__) +# define PNG_MAX_MALLOC_64K +# if (LDATA != 1) +# ifndef FAR +# define FAR __far +# endif +# define USE_FAR_KEYWORD +# endif /* LDATA != 1 */ + /* Possibly useful for moving data out of default segment. + * Uncomment it if you want. Could also define FARDATA as + * const if your compiler supports it. (SJT) +# define FARDATA FAR + */ +# endif /* __WIN32__, __FLAT__, __CYGWIN__ */ +#endif /* __BORLANDC__ */ + + +/* Suggest testing for specific compiler first before testing for + * FAR. The Watcom compiler defines both __MEDIUM__ and M_I86MM, + * making reliance oncertain keywords suspect. (SJT) + */ + +/* MSC Medium model */ +#if defined(FAR) +# if defined(M_I86MM) +# define USE_FAR_KEYWORD +# define FARDATA FAR +# include +# endif +#endif + +/* SJT: default case */ +#ifndef FAR +# define FAR +#endif + +/* At this point FAR is always defined */ +#ifndef FARDATA +# define FARDATA +#endif + +/* Typedef for floating-point numbers that are converted + to fixed-point with a multiple of 100,000, e.g., int_gamma */ +typedef png_int_32 png_fixed_point; + +/* Add typedefs for pointers */ +typedef void FAR * png_voidp; +typedef png_byte FAR * png_bytep; +typedef png_uint_32 FAR * png_uint_32p; +typedef png_int_32 FAR * png_int_32p; +typedef png_uint_16 FAR * png_uint_16p; +typedef png_int_16 FAR * png_int_16p; +typedef PNG_CONST char FAR * png_const_charp; +typedef char FAR * png_charp; +typedef png_fixed_point FAR * png_fixed_point_p; + +#ifndef PNG_NO_STDIO +#if defined(_WIN32_WCE) +typedef HANDLE png_FILE_p; +#else +typedef FILE * png_FILE_p; +#endif +#endif + +#ifdef PNG_FLOATING_POINT_SUPPORTED +typedef double FAR * png_doublep; +#endif + +/* Pointers to pointers; i.e. arrays */ +typedef png_byte FAR * FAR * png_bytepp; +typedef png_uint_32 FAR * FAR * png_uint_32pp; +typedef png_int_32 FAR * FAR * png_int_32pp; +typedef png_uint_16 FAR * FAR * png_uint_16pp; +typedef png_int_16 FAR * FAR * png_int_16pp; +typedef PNG_CONST char FAR * FAR * png_const_charpp; +typedef char FAR * FAR * png_charpp; +typedef png_fixed_point FAR * FAR * png_fixed_point_pp; +#ifdef PNG_FLOATING_POINT_SUPPORTED +typedef double FAR * FAR * png_doublepp; +#endif + +/* Pointers to pointers to pointers; i.e., pointer to array */ +typedef char FAR * FAR * FAR * png_charppp; + +#if defined(PNG_1_0_X) || defined(PNG_1_2_X) +/* SPC - Is this stuff deprecated? */ +/* It'll be removed as of libpng-1.3.0 - GR-P */ +/* libpng typedefs for types in zlib. If zlib changes + * or another compression library is used, then change these. + * Eliminates need to change all the source files. + */ +typedef charf * png_zcharp; +typedef charf * FAR * png_zcharpp; +typedef z_stream FAR * png_zstreamp; +#endif /* (PNG_1_0_X) || defined(PNG_1_2_X) */ + +/* + * Define PNG_BUILD_DLL if the module being built is a Windows + * LIBPNG DLL. + * + * Define PNG_USE_DLL if you want to *link* to the Windows LIBPNG DLL. + * It is equivalent to Microsoft predefined macro _DLL that is + * automatically defined when you compile using the share + * version of the CRT (C Run-Time library) + * + * The cygwin mods make this behavior a little different: + * Define PNG_BUILD_DLL if you are building a dll for use with cygwin + * Define PNG_STATIC if you are building a static library for use with cygwin, + * -or- if you are building an application that you want to link to the + * static library. + * PNG_USE_DLL is defined by default (no user action needed) unless one of + * the other flags is defined. + */ + +#if !defined(PNG_DLL) && (defined(PNG_BUILD_DLL) || defined(PNG_USE_DLL)) +# define PNG_DLL +#endif +/* If CYGWIN, then disallow GLOBAL ARRAYS unless building a static lib. + * When building a static lib, default to no GLOBAL ARRAYS, but allow + * command-line override + */ +#if defined(__CYGWIN__) +# if !defined(PNG_STATIC) +# if defined(PNG_USE_GLOBAL_ARRAYS) +# undef PNG_USE_GLOBAL_ARRAYS +# endif +# if !defined(PNG_USE_LOCAL_ARRAYS) +# define PNG_USE_LOCAL_ARRAYS +# endif +# else +# if defined(PNG_USE_LOCAL_ARRAYS) || defined(PNG_NO_GLOBAL_ARRAYS) +# if defined(PNG_USE_GLOBAL_ARRAYS) +# undef PNG_USE_GLOBAL_ARRAYS +# endif +# endif +# endif +# if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS) +# define PNG_USE_LOCAL_ARRAYS +# endif +#endif + +/* Do not use global arrays (helps with building DLL's) + * They are no longer used in libpng itself, since version 1.0.5c, + * but might be required for some pre-1.0.5c applications. + */ +#if !defined(PNG_USE_LOCAL_ARRAYS) && !defined(PNG_USE_GLOBAL_ARRAYS) +# if defined(PNG_NO_GLOBAL_ARRAYS) || \ + (defined(__GNUC__) && defined(PNG_DLL)) || defined(_MSC_VER) +# define PNG_USE_LOCAL_ARRAYS +# else +# define PNG_USE_GLOBAL_ARRAYS +# endif +#endif + +#if defined(__CYGWIN__) +# undef PNGAPI +# define PNGAPI __cdecl +# undef PNG_IMPEXP +# define PNG_IMPEXP +#endif + +/* If you define PNGAPI, e.g., with compiler option "-DPNGAPI=__stdcall", + * you may get warnings regarding the linkage of png_zalloc and png_zfree. + * Don't ignore those warnings; you must also reset the default calling + * convention in your compiler to match your PNGAPI, and you must build + * zlib and your applications the same way you build libpng. + */ + +#if defined(__MINGW32__) && !defined(PNG_MODULEDEF) +# ifndef PNG_NO_MODULEDEF +# define PNG_NO_MODULEDEF +# endif +#endif + +#if !defined(PNG_IMPEXP) && defined(PNG_BUILD_DLL) && !defined(PNG_NO_MODULEDEF) +# define PNG_IMPEXP +#endif + +#if defined(PNG_DLL) || defined(_DLL) || defined(__DLL__ ) || \ + (( defined(_Windows) || defined(_WINDOWS) || \ + defined(WIN32) || defined(_WIN32) || defined(__WIN32__) )) + +# ifndef PNGAPI +# if defined(__GNUC__) || (defined (_MSC_VER) && (_MSC_VER >= 800)) +# define PNGAPI __cdecl +# else +# define PNGAPI _cdecl +# endif +# endif + +# if !defined(PNG_IMPEXP) && (!defined(PNG_DLL) || \ + 0 /* WINCOMPILER_WITH_NO_SUPPORT_FOR_DECLIMPEXP */) +# define PNG_IMPEXP +# endif + +# if !defined(PNG_IMPEXP) + +# define PNG_EXPORT_TYPE1(type,symbol) PNG_IMPEXP type PNGAPI symbol +# define PNG_EXPORT_TYPE2(type,symbol) type PNG_IMPEXP PNGAPI symbol + + /* Borland/Microsoft */ +# if defined(_MSC_VER) || defined(__BORLANDC__) +# if (_MSC_VER >= 800) || (__BORLANDC__ >= 0x500) +# define PNG_EXPORT PNG_EXPORT_TYPE1 +# else +# define PNG_EXPORT PNG_EXPORT_TYPE2 +# if defined(PNG_BUILD_DLL) +# define PNG_IMPEXP __export +# else +# define PNG_IMPEXP /*__import */ /* doesn't exist AFAIK in + VC++ */ +# endif /* Exists in Borland C++ for + C++ classes (== huge) */ +# endif +# endif + +# if !defined(PNG_IMPEXP) +# if defined(PNG_BUILD_DLL) +# define PNG_IMPEXP __declspec(dllexport) +# else +# define PNG_IMPEXP __declspec(dllimport) +# endif +# endif +# endif /* PNG_IMPEXP */ +#else /* !(DLL || non-cygwin WINDOWS) */ +# if (defined(__IBMC__) || defined(__IBMCPP__)) && defined(__OS2__) +# ifndef PNGAPI +# define PNGAPI _System +# endif +# else +# if 0 /* ... other platforms, with other meanings */ +# endif +# endif +#endif + +#ifndef PNGAPI +# define PNGAPI +#endif +#ifndef PNG_IMPEXP +# define PNG_IMPEXP +#endif + +#ifdef PNG_BUILDSYMS +# ifndef PNG_EXPORT +# define PNG_EXPORT(type,symbol) PNG_FUNCTION_EXPORT symbol END +# endif +# ifdef PNG_USE_GLOBAL_ARRAYS +# ifndef PNG_EXPORT_VAR +# define PNG_EXPORT_VAR(type) PNG_DATA_EXPORT +# endif +# endif +#endif + +#ifndef PNG_EXPORT +# define PNG_EXPORT(type,symbol) PNG_IMPEXP type PNGAPI symbol +#endif + +#ifdef PNG_USE_GLOBAL_ARRAYS +# ifndef PNG_EXPORT_VAR +# define PNG_EXPORT_VAR(type) extern PNG_IMPEXP type +# endif +#endif + +/* User may want to use these so they are not in PNG_INTERNAL. Any library + * functions that are passed far data must be model independent. + */ + +#ifndef PNG_ABORT +# define PNG_ABORT() abort() +#endif + +#ifdef PNG_SETJMP_SUPPORTED +# define png_jmpbuf(png_ptr) ((png_ptr)->jmpbuf) +#else +# define png_jmpbuf(png_ptr) \ + (LIBPNG_WAS_COMPILED_WITH__PNG_SETJMP_NOT_SUPPORTED) +#endif + +#if defined(USE_FAR_KEYWORD) /* memory model independent fns */ +/* use this to make far-to-near assignments */ +# define CHECK 1 +# define NOCHECK 0 +# define CVT_PTR(ptr) (png_far_to_near(png_ptr,ptr,CHECK)) +# define CVT_PTR_NOCHECK(ptr) (png_far_to_near(png_ptr,ptr,NOCHECK)) +# define png_snprintf _fsnprintf /* Added to v 1.2.19 */ +# define png_strlen _fstrlen +# define png_memcmp _fmemcmp /* SJT: added */ +# define png_memcpy _fmemcpy +# define png_memset _fmemset +#else /* use the usual functions */ +# define CVT_PTR(ptr) (ptr) +# define CVT_PTR_NOCHECK(ptr) (ptr) +# ifndef PNG_NO_SNPRINTF +# ifdef _MSC_VER +# define png_snprintf _snprintf /* Added to v 1.2.19 */ +# define png_snprintf2 _snprintf +# define png_snprintf6 _snprintf +# else +# define png_snprintf snprintf /* Added to v 1.2.19 */ +# define png_snprintf2 snprintf +# define png_snprintf6 snprintf +# endif +# else + /* You don't have or don't want to use snprintf(). Caution: Using + * sprintf instead of snprintf exposes your application to accidental + * or malevolent buffer overflows. If you don't have snprintf() + * as a general rule you should provide one (you can get one from + * Portable OpenSSH). */ +# define png_snprintf(s1,n,fmt,x1) sprintf(s1,fmt,x1) +# define png_snprintf2(s1,n,fmt,x1,x2) sprintf(s1,fmt,x1,x2) +# define png_snprintf6(s1,n,fmt,x1,x2,x3,x4,x5,x6) \ + sprintf(s1,fmt,x1,x2,x3,x4,x5,x6) +# endif +# define png_strlen strlen +# define png_memcmp memcmp /* SJT: added */ +# define png_memcpy memcpy +# define png_memset memset +#endif +/* End of memory model independent support */ + +/* Just a little check that someone hasn't tried to define something + * contradictory. + */ +#if (PNG_ZBUF_SIZE > 65536L) && defined(PNG_MAX_MALLOC_64K) +# undef PNG_ZBUF_SIZE +# define PNG_ZBUF_SIZE 65536L +#endif + +/* Added at libpng-1.2.8 */ +#endif /* PNG_VERSION_INFO_ONLY */ + +#endif /* PNGCONF_H */ diff --git a/include/zconf.h b/include/zconf.h new file mode 100644 index 00000000..9987a775 --- /dev/null +++ b/include/zconf.h @@ -0,0 +1,511 @@ +/* zconf.h -- configuration of the zlib compression library + * Copyright (C) 1995-2013 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* @(#) $Id$ */ + +#ifndef ZCONF_H +#define ZCONF_H + +/* + * If you *really* need a unique prefix for all types and library functions, + * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. + * Even better than compiling with -DZ_PREFIX would be to use configure to set + * this permanently in zconf.h using "./configure --zprefix". + */ +#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */ +# define Z_PREFIX_SET + +/* all linked symbols */ +# define _dist_code z__dist_code +# define _length_code z__length_code +# define _tr_align z__tr_align +# define _tr_flush_bits z__tr_flush_bits +# define _tr_flush_block z__tr_flush_block +# define _tr_init z__tr_init +# define _tr_stored_block z__tr_stored_block +# define _tr_tally z__tr_tally +# define adler32 z_adler32 +# define adler32_combine z_adler32_combine +# define adler32_combine64 z_adler32_combine64 +# ifndef Z_SOLO +# define compress z_compress +# define compress2 z_compress2 +# define compressBound z_compressBound +# endif +# define crc32 z_crc32 +# define crc32_combine z_crc32_combine +# define crc32_combine64 z_crc32_combine64 +# define deflate z_deflate +# define deflateBound z_deflateBound +# define deflateCopy z_deflateCopy +# define deflateEnd z_deflateEnd +# define deflateInit2_ z_deflateInit2_ +# define deflateInit_ z_deflateInit_ +# define deflateParams z_deflateParams +# define deflatePending z_deflatePending +# define deflatePrime z_deflatePrime +# define deflateReset z_deflateReset +# define deflateResetKeep z_deflateResetKeep +# define deflateSetDictionary z_deflateSetDictionary +# define deflateSetHeader z_deflateSetHeader +# define deflateTune z_deflateTune +# define deflate_copyright z_deflate_copyright +# define get_crc_table z_get_crc_table +# ifndef Z_SOLO +# define gz_error z_gz_error +# define gz_intmax z_gz_intmax +# define gz_strwinerror z_gz_strwinerror +# define gzbuffer z_gzbuffer +# define gzclearerr z_gzclearerr +# define gzclose z_gzclose +# define gzclose_r z_gzclose_r +# define gzclose_w z_gzclose_w +# define gzdirect z_gzdirect +# define gzdopen z_gzdopen +# define gzeof z_gzeof +# define gzerror z_gzerror +# define gzflush z_gzflush +# define gzgetc z_gzgetc +# define gzgetc_ z_gzgetc_ +# define gzgets z_gzgets +# define gzoffset z_gzoffset +# define gzoffset64 z_gzoffset64 +# define gzopen z_gzopen +# define gzopen64 z_gzopen64 +# ifdef _WIN32 +# define gzopen_w z_gzopen_w +# endif +# define gzprintf z_gzprintf +# define gzvprintf z_gzvprintf +# define gzputc z_gzputc +# define gzputs z_gzputs +# define gzread z_gzread +# define gzrewind z_gzrewind +# define gzseek z_gzseek +# define gzseek64 z_gzseek64 +# define gzsetparams z_gzsetparams +# define gztell z_gztell +# define gztell64 z_gztell64 +# define gzungetc z_gzungetc +# define gzwrite z_gzwrite +# endif +# define inflate z_inflate +# define inflateBack z_inflateBack +# define inflateBackEnd z_inflateBackEnd +# define inflateBackInit_ z_inflateBackInit_ +# define inflateCopy z_inflateCopy +# define inflateEnd z_inflateEnd +# define inflateGetHeader z_inflateGetHeader +# define inflateInit2_ z_inflateInit2_ +# define inflateInit_ z_inflateInit_ +# define inflateMark z_inflateMark +# define inflatePrime z_inflatePrime +# define inflateReset z_inflateReset +# define inflateReset2 z_inflateReset2 +# define inflateSetDictionary z_inflateSetDictionary +# define inflateGetDictionary z_inflateGetDictionary +# define inflateSync z_inflateSync +# define inflateSyncPoint z_inflateSyncPoint +# define inflateUndermine z_inflateUndermine +# define inflateResetKeep z_inflateResetKeep +# define inflate_copyright z_inflate_copyright +# define inflate_fast z_inflate_fast +# define inflate_table z_inflate_table +# ifndef Z_SOLO +# define uncompress z_uncompress +# endif +# define zError z_zError +# ifndef Z_SOLO +# define zcalloc z_zcalloc +# define zcfree z_zcfree +# endif +# define zlibCompileFlags z_zlibCompileFlags +# define zlibVersion z_zlibVersion + +/* all zlib typedefs in zlib.h and zconf.h */ +# define Byte z_Byte +# define Bytef z_Bytef +# define alloc_func z_alloc_func +# define charf z_charf +# define free_func z_free_func +# ifndef Z_SOLO +# define gzFile z_gzFile +# endif +# define gz_header z_gz_header +# define gz_headerp z_gz_headerp +# define in_func z_in_func +# define intf z_intf +# define out_func z_out_func +# define uInt z_uInt +# define uIntf z_uIntf +# define uLong z_uLong +# define uLongf z_uLongf +# define voidp z_voidp +# define voidpc z_voidpc +# define voidpf z_voidpf + +/* all zlib structs in zlib.h and zconf.h */ +# define gz_header_s z_gz_header_s +# define internal_state z_internal_state + +#endif + +#if defined(__MSDOS__) && !defined(MSDOS) +# define MSDOS +#endif +#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2) +# define OS2 +#endif +#if defined(_WINDOWS) && !defined(WINDOWS) +# define WINDOWS +#endif +#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__) +# ifndef WIN32 +# define WIN32 +# endif +#endif +#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32) +# if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) +# ifndef SYS16BIT +# define SYS16BIT +# endif +# endif +#endif + +/* + * Compile with -DMAXSEG_64K if the alloc function cannot allocate more + * than 64k bytes at a time (needed on systems with 16-bit int). + */ +#ifdef SYS16BIT +# define MAXSEG_64K +#endif +#ifdef MSDOS +# define UNALIGNED_OK +#endif + +#ifdef __STDC_VERSION__ +# ifndef STDC +# define STDC +# endif +# if __STDC_VERSION__ >= 199901L +# ifndef STDC99 +# define STDC99 +# endif +# endif +#endif +#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) +# define STDC +#endif +#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) +# define STDC +#endif +#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) +# define STDC +#endif +#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) +# define STDC +#endif + +#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ +# define STDC +#endif + +#ifndef STDC +# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ +# define const /* note: need a more gentle solution here */ +# endif +#endif + +#if defined(ZLIB_CONST) && !defined(z_const) +# define z_const const +#else +# define z_const +#endif + +/* Some Mac compilers merge all .h files incorrectly: */ +#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__) +# define NO_DUMMY_DECL +#endif + +/* Maximum value for memLevel in deflateInit2 */ +#ifndef MAX_MEM_LEVEL +# ifdef MAXSEG_64K +# define MAX_MEM_LEVEL 8 +# else +# define MAX_MEM_LEVEL 9 +# endif +#endif + +/* Maximum value for windowBits in deflateInit2 and inflateInit2. + * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files + * created by gzip. (Files created by minigzip can still be extracted by + * gzip.) + */ +#ifndef MAX_WBITS +# define MAX_WBITS 15 /* 32K LZ77 window */ +#endif + +/* The memory requirements for deflate are (in bytes): + (1 << (windowBits+2)) + (1 << (memLevel+9)) + that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) + plus a few kilobytes for small objects. For example, if you want to reduce + the default memory requirements from 256K to 128K, compile with + make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" + Of course this will generally degrade compression (there's no free lunch). + + The memory requirements for inflate are (in bytes) 1 << windowBits + that is, 32K for windowBits=15 (default value) plus a few kilobytes + for small objects. +*/ + + /* Type declarations */ + +#ifndef OF /* function prototypes */ +# ifdef STDC +# define OF(args) args +# else +# define OF(args) () +# endif +#endif + +#ifndef Z_ARG /* function prototypes for stdarg */ +# if defined(STDC) || defined(Z_HAVE_STDARG_H) +# define Z_ARG(args) args +# else +# define Z_ARG(args) () +# endif +#endif + +/* The following definitions for FAR are needed only for MSDOS mixed + * model programming (small or medium model with some far allocations). + * This was tested only with MSC; for other MSDOS compilers you may have + * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, + * just define FAR to be empty. + */ +#ifdef SYS16BIT +# if defined(M_I86SM) || defined(M_I86MM) + /* MSC small or medium model */ +# define SMALL_MEDIUM +# ifdef _MSC_VER +# define FAR _far +# else +# define FAR far +# endif +# endif +# if (defined(__SMALL__) || defined(__MEDIUM__)) + /* Turbo C small or medium model */ +# define SMALL_MEDIUM +# ifdef __BORLANDC__ +# define FAR _far +# else +# define FAR far +# endif +# endif +#endif + +#if defined(WINDOWS) || defined(WIN32) + /* If building or using zlib as a DLL, define ZLIB_DLL. + * This is not mandatory, but it offers a little performance increase. + */ +# ifdef ZLIB_DLL +# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) +# ifdef ZLIB_INTERNAL +# define ZEXTERN extern __declspec(dllexport) +# else +# define ZEXTERN extern __declspec(dllimport) +# endif +# endif +# endif /* ZLIB_DLL */ + /* If building or using zlib with the WINAPI/WINAPIV calling convention, + * define ZLIB_WINAPI. + * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. + */ +# ifdef ZLIB_WINAPI +# ifdef FAR +# undef FAR +# endif +# include + /* No need for _export, use ZLIB.DEF instead. */ + /* For complete Windows compatibility, use WINAPI, not __stdcall. */ +# define ZEXPORT WINAPI +# ifdef WIN32 +# define ZEXPORTVA WINAPIV +# else +# define ZEXPORTVA FAR CDECL +# endif +# endif +#endif + +#if defined (__BEOS__) +# ifdef ZLIB_DLL +# ifdef ZLIB_INTERNAL +# define ZEXPORT __declspec(dllexport) +# define ZEXPORTVA __declspec(dllexport) +# else +# define ZEXPORT __declspec(dllimport) +# define ZEXPORTVA __declspec(dllimport) +# endif +# endif +#endif + +#ifndef ZEXTERN +# define ZEXTERN extern +#endif +#ifndef ZEXPORT +# define ZEXPORT +#endif +#ifndef ZEXPORTVA +# define ZEXPORTVA +#endif + +#ifndef FAR +# define FAR +#endif + +#if !defined(__MACTYPES__) +typedef unsigned char Byte; /* 8 bits */ +#endif +typedef unsigned int uInt; /* 16 bits or more */ +typedef unsigned long uLong; /* 32 bits or more */ + +#ifdef SMALL_MEDIUM + /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ +# define Bytef Byte FAR +#else + typedef Byte FAR Bytef; +#endif +typedef char FAR charf; +typedef int FAR intf; +typedef uInt FAR uIntf; +typedef uLong FAR uLongf; + +#ifdef STDC + typedef void const *voidpc; + typedef void FAR *voidpf; + typedef void *voidp; +#else + typedef Byte const *voidpc; + typedef Byte FAR *voidpf; + typedef Byte *voidp; +#endif + +#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC) +# include +# if (UINT_MAX == 0xffffffffUL) +# define Z_U4 unsigned +# elif (ULONG_MAX == 0xffffffffUL) +# define Z_U4 unsigned long +# elif (USHRT_MAX == 0xffffffffUL) +# define Z_U4 unsigned short +# endif +#endif + +#ifdef Z_U4 + typedef Z_U4 z_crc_t; +#else + typedef unsigned long z_crc_t; +#endif + +#ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */ +# define Z_HAVE_UNISTD_H +#endif + +#ifdef HAVE_STDARG_H /* may be set to #if 1 by ./configure */ +# define Z_HAVE_STDARG_H +#endif + +#ifdef STDC +# ifndef Z_SOLO +# include /* for off_t */ +# endif +#endif + +#if defined(STDC) || defined(Z_HAVE_STDARG_H) +# ifndef Z_SOLO +# include /* for va_list */ +# endif +#endif + +#ifdef _WIN32 +# ifndef Z_SOLO +# include /* for wchar_t */ +# endif +#endif + +/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and + * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even + * though the former does not conform to the LFS document), but considering + * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as + * equivalently requesting no 64-bit operations + */ +#if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1 +# undef _LARGEFILE64_SOURCE +#endif + +#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H) +# define Z_HAVE_UNISTD_H +#endif +#ifndef Z_SOLO +# if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE) +# include /* for SEEK_*, off_t, and _LFS64_LARGEFILE */ +# ifdef VMS +# include /* for off_t */ +# endif +# ifndef z_off_t +# define z_off_t off_t +# endif +# endif +#endif + +#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0 +# define Z_LFS64 +#endif + +#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64) +# define Z_LARGE64 +#endif + +#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64) +# define Z_WANT64 +#endif + +#if !defined(SEEK_SET) && !defined(Z_SOLO) +# define SEEK_SET 0 /* Seek from beginning of file. */ +# define SEEK_CUR 1 /* Seek from current position. */ +# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ +#endif + +#ifndef z_off_t +# define z_off_t long +#endif + +#if !defined(_WIN32) && defined(Z_LARGE64) +# define z_off64_t off64_t +#else +# if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO) +# define z_off64_t __int64 +# else +# define z_off64_t z_off_t +# endif +#endif + +/* MVS linker does not support external names larger than 8 bytes */ +#if defined(__MVS__) + #pragma map(deflateInit_,"DEIN") + #pragma map(deflateInit2_,"DEIN2") + #pragma map(deflateEnd,"DEEND") + #pragma map(deflateBound,"DEBND") + #pragma map(inflateInit_,"ININ") + #pragma map(inflateInit2_,"ININ2") + #pragma map(inflateEnd,"INEND") + #pragma map(inflateSync,"INSY") + #pragma map(inflateSetDictionary,"INSEDI") + #pragma map(compressBound,"CMBND") + #pragma map(inflate_table,"INTABL") + #pragma map(inflate_fast,"INFA") + #pragma map(inflate_copyright,"INCOPY") +#endif + +#endif /* ZCONF_H */ diff --git a/include/zlib.h b/include/zlib.h new file mode 100644 index 00000000..3e0c7672 --- /dev/null +++ b/include/zlib.h @@ -0,0 +1,1768 @@ +/* zlib.h -- interface of the 'zlib' general purpose compression library + version 1.2.8, April 28th, 2013 + + Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Jean-loup Gailly Mark Adler + jloup@gzip.org madler@alumni.caltech.edu + + + The data format used by the zlib library is described by RFCs (Request for + Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950 + (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format). +*/ + +#ifndef ZLIB_H +#define ZLIB_H + +#include "zconf.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define ZLIB_VERSION "1.2.8" +#define ZLIB_VERNUM 0x1280 +#define ZLIB_VER_MAJOR 1 +#define ZLIB_VER_MINOR 2 +#define ZLIB_VER_REVISION 8 +#define ZLIB_VER_SUBREVISION 0 + +/* + The 'zlib' compression library provides in-memory compression and + decompression functions, including integrity checks of the uncompressed data. + This version of the library supports only one compression method (deflation) + but other algorithms will be added later and will have the same stream + interface. + + Compression can be done in a single step if the buffers are large enough, + or can be done by repeated calls of the compression function. In the latter + case, the application must provide more input and/or consume the output + (providing more output space) before each call. + + The compressed data format used by default by the in-memory functions is + the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped + around a deflate stream, which is itself documented in RFC 1951. + + The library also supports reading and writing files in gzip (.gz) format + with an interface similar to that of stdio using the functions that start + with "gz". The gzip format is different from the zlib format. gzip is a + gzip wrapper, documented in RFC 1952, wrapped around a deflate stream. + + This library can optionally read and write gzip streams in memory as well. + + The zlib format was designed to be compact and fast for use in memory + and on communications channels. The gzip format was designed for single- + file compression on file systems, has a larger header than zlib to maintain + directory information, and uses a different, slower check method than zlib. + + The library does not install any signal handler. The decoder checks + the consistency of the compressed data, so the library should never crash + even in case of corrupted input. +*/ + +typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); +typedef void (*free_func) OF((voidpf opaque, voidpf address)); + +struct internal_state; + +typedef struct z_stream_s { + z_const Bytef *next_in; /* next input byte */ + uInt avail_in; /* number of bytes available at next_in */ + uLong total_in; /* total number of input bytes read so far */ + + Bytef *next_out; /* next output byte should be put there */ + uInt avail_out; /* remaining free space at next_out */ + uLong total_out; /* total number of bytes output so far */ + + z_const char *msg; /* last error message, NULL if no error */ + struct internal_state FAR *state; /* not visible by applications */ + + alloc_func zalloc; /* used to allocate the internal state */ + free_func zfree; /* used to free the internal state */ + voidpf opaque; /* private data object passed to zalloc and zfree */ + + int data_type; /* best guess about the data type: binary or text */ + uLong adler; /* adler32 value of the uncompressed data */ + uLong reserved; /* reserved for future use */ +} z_stream; + +typedef z_stream FAR *z_streamp; + +/* + gzip header information passed to and from zlib routines. See RFC 1952 + for more details on the meanings of these fields. +*/ +typedef struct gz_header_s { + int text; /* true if compressed data believed to be text */ + uLong time; /* modification time */ + int xflags; /* extra flags (not used when writing a gzip file) */ + int os; /* operating system */ + Bytef *extra; /* pointer to extra field or Z_NULL if none */ + uInt extra_len; /* extra field length (valid if extra != Z_NULL) */ + uInt extra_max; /* space at extra (only when reading header) */ + Bytef *name; /* pointer to zero-terminated file name or Z_NULL */ + uInt name_max; /* space at name (only when reading header) */ + Bytef *comment; /* pointer to zero-terminated comment or Z_NULL */ + uInt comm_max; /* space at comment (only when reading header) */ + int hcrc; /* true if there was or will be a header crc */ + int done; /* true when done reading gzip header (not used + when writing a gzip file) */ +} gz_header; + +typedef gz_header FAR *gz_headerp; + +/* + The application must update next_in and avail_in when avail_in has dropped + to zero. It must update next_out and avail_out when avail_out has dropped + to zero. The application must initialize zalloc, zfree and opaque before + calling the init function. All other fields are set by the compression + library and must not be updated by the application. + + The opaque value provided by the application will be passed as the first + parameter for calls of zalloc and zfree. This can be useful for custom + memory management. The compression library attaches no meaning to the + opaque value. + + zalloc must return Z_NULL if there is not enough memory for the object. + If zlib is used in a multi-threaded application, zalloc and zfree must be + thread safe. + + On 16-bit systems, the functions zalloc and zfree must be able to allocate + exactly 65536 bytes, but will not be required to allocate more than this if + the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, pointers + returned by zalloc for objects of exactly 65536 bytes *must* have their + offset normalized to zero. The default allocation function provided by this + library ensures this (see zutil.c). To reduce memory requirements and avoid + any allocation of 64K objects, at the expense of compression ratio, compile + the library with -DMAX_WBITS=14 (see zconf.h). + + The fields total_in and total_out can be used for statistics or progress + reports. After compression, total_in holds the total size of the + uncompressed data and may be saved for use in the decompressor (particularly + if the decompressor wants to decompress everything in a single step). +*/ + + /* constants */ + +#define Z_NO_FLUSH 0 +#define Z_PARTIAL_FLUSH 1 +#define Z_SYNC_FLUSH 2 +#define Z_FULL_FLUSH 3 +#define Z_FINISH 4 +#define Z_BLOCK 5 +#define Z_TREES 6 +/* Allowed flush values; see deflate() and inflate() below for details */ + +#define Z_OK 0 +#define Z_STREAM_END 1 +#define Z_NEED_DICT 2 +#define Z_ERRNO (-1) +#define Z_STREAM_ERROR (-2) +#define Z_DATA_ERROR (-3) +#define Z_MEM_ERROR (-4) +#define Z_BUF_ERROR (-5) +#define Z_VERSION_ERROR (-6) +/* Return codes for the compression/decompression functions. Negative values + * are errors, positive values are used for special but normal events. + */ + +#define Z_NO_COMPRESSION 0 +#define Z_BEST_SPEED 1 +#define Z_BEST_COMPRESSION 9 +#define Z_DEFAULT_COMPRESSION (-1) +/* compression levels */ + +#define Z_FILTERED 1 +#define Z_HUFFMAN_ONLY 2 +#define Z_RLE 3 +#define Z_FIXED 4 +#define Z_DEFAULT_STRATEGY 0 +/* compression strategy; see deflateInit2() below for details */ + +#define Z_BINARY 0 +#define Z_TEXT 1 +#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */ +#define Z_UNKNOWN 2 +/* Possible values of the data_type field (though see inflate()) */ + +#define Z_DEFLATED 8 +/* The deflate compression method (the only one supported in this version) */ + +#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ + +#define zlib_version zlibVersion() +/* for compatibility with versions < 1.0.2 */ + + + /* basic functions */ + +ZEXTERN const char * ZEXPORT zlibVersion OF((void)); +/* The application can compare zlibVersion and ZLIB_VERSION for consistency. + If the first character differs, the library code actually used is not + compatible with the zlib.h header file used by the application. This check + is automatically made by deflateInit and inflateInit. + */ + +/* +ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); + + Initializes the internal stream state for compression. The fields + zalloc, zfree and opaque must be initialized before by the caller. If + zalloc and zfree are set to Z_NULL, deflateInit updates them to use default + allocation functions. + + The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9: + 1 gives best speed, 9 gives best compression, 0 gives no compression at all + (the input data is simply copied a block at a time). Z_DEFAULT_COMPRESSION + requests a default compromise between speed and compression (currently + equivalent to level 6). + + deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_STREAM_ERROR if level is not a valid compression level, or + Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible + with the version assumed by the caller (ZLIB_VERSION). msg is set to null + if there is no error message. deflateInit does not perform any compression: + this will be done by deflate(). +*/ + + +ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); +/* + deflate compresses as much data as possible, and stops when the input + buffer becomes empty or the output buffer becomes full. It may introduce + some output latency (reading input without producing any output) except when + forced to flush. + + The detailed semantics are as follows. deflate performs one or both of the + following actions: + + - Compress more input starting at next_in and update next_in and avail_in + accordingly. If not all input can be processed (because there is not + enough room in the output buffer), next_in and avail_in are updated and + processing will resume at this point for the next call of deflate(). + + - Provide more output starting at next_out and update next_out and avail_out + accordingly. This action is forced if the parameter flush is non zero. + Forcing flush frequently degrades the compression ratio, so this parameter + should be set only when necessary (in interactive applications). Some + output may be provided even if flush is not set. + + Before the call of deflate(), the application should ensure that at least + one of the actions is possible, by providing more input and/or consuming more + output, and updating avail_in or avail_out accordingly; avail_out should + never be zero before the call. The application can consume the compressed + output when it wants, for example when the output buffer is full (avail_out + == 0), or after each call of deflate(). If deflate returns Z_OK and with + zero avail_out, it must be called again after making room in the output + buffer because there might be more output pending. + + Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to + decide how much data to accumulate before producing output, in order to + maximize compression. + + If the parameter flush is set to Z_SYNC_FLUSH, all pending output is + flushed to the output buffer and the output is aligned on a byte boundary, so + that the decompressor can get all input data available so far. (In + particular avail_in is zero after the call if enough output space has been + provided before the call.) Flushing may degrade compression for some + compression algorithms and so it should be used only when necessary. This + completes the current deflate block and follows it with an empty stored block + that is three bits plus filler bits to the next byte, followed by four bytes + (00 00 ff ff). + + If flush is set to Z_PARTIAL_FLUSH, all pending output is flushed to the + output buffer, but the output is not aligned to a byte boundary. All of the + input data so far will be available to the decompressor, as for Z_SYNC_FLUSH. + This completes the current deflate block and follows it with an empty fixed + codes block that is 10 bits long. This assures that enough bytes are output + in order for the decompressor to finish the block before the empty fixed code + block. + + If flush is set to Z_BLOCK, a deflate block is completed and emitted, as + for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to + seven bits of the current block are held to be written as the next byte after + the next deflate block is completed. In this case, the decompressor may not + be provided enough bits at this point in order to complete decompression of + the data provided so far to the compressor. It may need to wait for the next + block to be emitted. This is for advanced applications that need to control + the emission of deflate blocks. + + If flush is set to Z_FULL_FLUSH, all output is flushed as with + Z_SYNC_FLUSH, and the compression state is reset so that decompression can + restart from this point if previous compressed data has been damaged or if + random access is desired. Using Z_FULL_FLUSH too often can seriously degrade + compression. + + If deflate returns with avail_out == 0, this function must be called again + with the same value of the flush parameter and more output space (updated + avail_out), until the flush is complete (deflate returns with non-zero + avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that + avail_out is greater than six to avoid repeated flush markers due to + avail_out == 0 on return. + + If the parameter flush is set to Z_FINISH, pending input is processed, + pending output is flushed and deflate returns with Z_STREAM_END if there was + enough output space; if deflate returns with Z_OK, this function must be + called again with Z_FINISH and more output space (updated avail_out) but no + more input data, until it returns with Z_STREAM_END or an error. After + deflate has returned Z_STREAM_END, the only possible operations on the stream + are deflateReset or deflateEnd. + + Z_FINISH can be used immediately after deflateInit if all the compression + is to be done in a single step. In this case, avail_out must be at least the + value returned by deflateBound (see below). Then deflate is guaranteed to + return Z_STREAM_END. If not enough output space is provided, deflate will + not return Z_STREAM_END, and it must be called again as described above. + + deflate() sets strm->adler to the adler32 checksum of all input read + so far (that is, total_in bytes). + + deflate() may update strm->data_type if it can make a good guess about + the input data type (Z_BINARY or Z_TEXT). In doubt, the data is considered + binary. This field is only for information purposes and does not affect the + compression algorithm in any manner. + + deflate() returns Z_OK if some progress has been made (more input + processed or more output produced), Z_STREAM_END if all input has been + consumed and all output has been produced (only when flush is set to + Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example + if next_in or next_out was Z_NULL), Z_BUF_ERROR if no progress is possible + (for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not + fatal, and deflate() can be called again with more input and more output + space to continue compressing. +*/ + + +ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); +/* + All dynamically allocated data structures for this stream are freed. + This function discards any unprocessed input and does not flush any pending + output. + + deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the + stream state was inconsistent, Z_DATA_ERROR if the stream was freed + prematurely (some input or output was discarded). In the error case, msg + may be set but then points to a static string (which must not be + deallocated). +*/ + + +/* +ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); + + Initializes the internal stream state for decompression. The fields + next_in, avail_in, zalloc, zfree and opaque must be initialized before by + the caller. If next_in is not Z_NULL and avail_in is large enough (the + exact value depends on the compression method), inflateInit determines the + compression method from the zlib header and allocates all data structures + accordingly; otherwise the allocation will be deferred to the first call of + inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to + use default allocation functions. + + inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_VERSION_ERROR if the zlib library version is incompatible with the + version assumed by the caller, or Z_STREAM_ERROR if the parameters are + invalid, such as a null pointer to the structure. msg is set to null if + there is no error message. inflateInit does not perform any decompression + apart from possibly reading the zlib header if present: actual decompression + will be done by inflate(). (So next_in and avail_in may be modified, but + next_out and avail_out are unused and unchanged.) The current implementation + of inflateInit() does not process any header information -- that is deferred + until inflate() is called. +*/ + + +ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); +/* + inflate decompresses as much data as possible, and stops when the input + buffer becomes empty or the output buffer becomes full. It may introduce + some output latency (reading input without producing any output) except when + forced to flush. + + The detailed semantics are as follows. inflate performs one or both of the + following actions: + + - Decompress more input starting at next_in and update next_in and avail_in + accordingly. If not all input can be processed (because there is not + enough room in the output buffer), next_in is updated and processing will + resume at this point for the next call of inflate(). + + - Provide more output starting at next_out and update next_out and avail_out + accordingly. inflate() provides as much output as possible, until there is + no more input data or no more space in the output buffer (see below about + the flush parameter). + + Before the call of inflate(), the application should ensure that at least + one of the actions is possible, by providing more input and/or consuming more + output, and updating the next_* and avail_* values accordingly. The + application can consume the uncompressed output when it wants, for example + when the output buffer is full (avail_out == 0), or after each call of + inflate(). If inflate returns Z_OK and with zero avail_out, it must be + called again after making room in the output buffer because there might be + more output pending. + + The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH, + Z_BLOCK, or Z_TREES. Z_SYNC_FLUSH requests that inflate() flush as much + output as possible to the output buffer. Z_BLOCK requests that inflate() + stop if and when it gets to the next deflate block boundary. When decoding + the zlib or gzip format, this will cause inflate() to return immediately + after the header and before the first block. When doing a raw inflate, + inflate() will go ahead and process the first block, and will return when it + gets to the end of that block, or when it runs out of data. + + The Z_BLOCK option assists in appending to or combining deflate streams. + Also to assist in this, on return inflate() will set strm->data_type to the + number of unused bits in the last byte taken from strm->next_in, plus 64 if + inflate() is currently decoding the last block in the deflate stream, plus + 128 if inflate() returned immediately after decoding an end-of-block code or + decoding the complete header up to just before the first byte of the deflate + stream. The end-of-block will not be indicated until all of the uncompressed + data from that block has been written to strm->next_out. The number of + unused bits may in general be greater than seven, except when bit 7 of + data_type is set, in which case the number of unused bits will be less than + eight. data_type is set as noted here every time inflate() returns for all + flush options, and so can be used to determine the amount of currently + consumed input in bits. + + The Z_TREES option behaves as Z_BLOCK does, but it also returns when the + end of each deflate block header is reached, before any actual data in that + block is decoded. This allows the caller to determine the length of the + deflate block header for later use in random access within a deflate block. + 256 is added to the value of strm->data_type when inflate() returns + immediately after reaching the end of the deflate block header. + + inflate() should normally be called until it returns Z_STREAM_END or an + error. However if all decompression is to be performed in a single step (a + single call of inflate), the parameter flush should be set to Z_FINISH. In + this case all pending input is processed and all pending output is flushed; + avail_out must be large enough to hold all of the uncompressed data for the + operation to complete. (The size of the uncompressed data may have been + saved by the compressor for this purpose.) The use of Z_FINISH is not + required to perform an inflation in one step. However it may be used to + inform inflate that a faster approach can be used for the single inflate() + call. Z_FINISH also informs inflate to not maintain a sliding window if the + stream completes, which reduces inflate's memory footprint. If the stream + does not complete, either because not all of the stream is provided or not + enough output space is provided, then a sliding window will be allocated and + inflate() can be called again to continue the operation as if Z_NO_FLUSH had + been used. + + In this implementation, inflate() always flushes as much output as + possible to the output buffer, and always uses the faster approach on the + first call. So the effects of the flush parameter in this implementation are + on the return value of inflate() as noted below, when inflate() returns early + when Z_BLOCK or Z_TREES is used, and when inflate() avoids the allocation of + memory for a sliding window when Z_FINISH is used. + + If a preset dictionary is needed after this call (see inflateSetDictionary + below), inflate sets strm->adler to the Adler-32 checksum of the dictionary + chosen by the compressor and returns Z_NEED_DICT; otherwise it sets + strm->adler to the Adler-32 checksum of all output produced so far (that is, + total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described + below. At the end of the stream, inflate() checks that its computed adler32 + checksum is equal to that saved by the compressor and returns Z_STREAM_END + only if the checksum is correct. + + inflate() can decompress and check either zlib-wrapped or gzip-wrapped + deflate data. The header type is detected automatically, if requested when + initializing with inflateInit2(). Any information contained in the gzip + header is not retained, so applications that need that information should + instead use raw inflate, see inflateInit2() below, or inflateBack() and + perform their own processing of the gzip header and trailer. When processing + gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output + producted so far. The CRC-32 is checked against the gzip trailer. + + inflate() returns Z_OK if some progress has been made (more input processed + or more output produced), Z_STREAM_END if the end of the compressed data has + been reached and all uncompressed output has been produced, Z_NEED_DICT if a + preset dictionary is needed at this point, Z_DATA_ERROR if the input data was + corrupted (input stream not conforming to the zlib format or incorrect check + value), Z_STREAM_ERROR if the stream structure was inconsistent (for example + next_in or next_out was Z_NULL), Z_MEM_ERROR if there was not enough memory, + Z_BUF_ERROR if no progress is possible or if there was not enough room in the + output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and + inflate() can be called again with more input and more output space to + continue decompressing. If Z_DATA_ERROR is returned, the application may + then call inflateSync() to look for a good compression block if a partial + recovery of the data is desired. +*/ + + +ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); +/* + All dynamically allocated data structures for this stream are freed. + This function discards any unprocessed input and does not flush any pending + output. + + inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state + was inconsistent. In the error case, msg may be set but then points to a + static string (which must not be deallocated). +*/ + + + /* Advanced functions */ + +/* + The following functions are needed only in some special applications. +*/ + +/* +ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, + int level, + int method, + int windowBits, + int memLevel, + int strategy)); + + This is another version of deflateInit with more compression options. The + fields next_in, zalloc, zfree and opaque must be initialized before by the + caller. + + The method parameter is the compression method. It must be Z_DEFLATED in + this version of the library. + + The windowBits parameter is the base two logarithm of the window size + (the size of the history buffer). It should be in the range 8..15 for this + version of the library. Larger values of this parameter result in better + compression at the expense of memory usage. The default value is 15 if + deflateInit is used instead. + + windowBits can also be -8..-15 for raw deflate. In this case, -windowBits + determines the window size. deflate() will then generate raw deflate data + with no zlib header or trailer, and will not compute an adler32 check value. + + windowBits can also be greater than 15 for optional gzip encoding. Add + 16 to windowBits to write a simple gzip header and trailer around the + compressed data instead of a zlib wrapper. The gzip header will have no + file name, no extra data, no comment, no modification time (set to zero), no + header crc, and the operating system will be set to 255 (unknown). If a + gzip stream is being written, strm->adler is a crc32 instead of an adler32. + + The memLevel parameter specifies how much memory should be allocated + for the internal compression state. memLevel=1 uses minimum memory but is + slow and reduces compression ratio; memLevel=9 uses maximum memory for + optimal speed. The default value is 8. See zconf.h for total memory usage + as a function of windowBits and memLevel. + + The strategy parameter is used to tune the compression algorithm. Use the + value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a + filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no + string match), or Z_RLE to limit match distances to one (run-length + encoding). Filtered data consists mostly of small values with a somewhat + random distribution. In this case, the compression algorithm is tuned to + compress them better. The effect of Z_FILTERED is to force more Huffman + coding and less string matching; it is somewhat intermediate between + Z_DEFAULT_STRATEGY and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as + fast as Z_HUFFMAN_ONLY, but give better compression for PNG image data. The + strategy parameter only affects the compression ratio but not the + correctness of the compressed output even if it is not set appropriately. + Z_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler + decoder for special applications. + + deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_STREAM_ERROR if any parameter is invalid (such as an invalid + method), or Z_VERSION_ERROR if the zlib library version (zlib_version) is + incompatible with the version assumed by the caller (ZLIB_VERSION). msg is + set to null if there is no error message. deflateInit2 does not perform any + compression: this will be done by deflate(). +*/ + +ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, + const Bytef *dictionary, + uInt dictLength)); +/* + Initializes the compression dictionary from the given byte sequence + without producing any compressed output. When using the zlib format, this + function must be called immediately after deflateInit, deflateInit2 or + deflateReset, and before any call of deflate. When doing raw deflate, this + function must be called either before any call of deflate, or immediately + after the completion of a deflate block, i.e. after all input has been + consumed and all output has been delivered when using any of the flush + options Z_BLOCK, Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, or Z_FULL_FLUSH. The + compressor and decompressor must use exactly the same dictionary (see + inflateSetDictionary). + + The dictionary should consist of strings (byte sequences) that are likely + to be encountered later in the data to be compressed, with the most commonly + used strings preferably put towards the end of the dictionary. Using a + dictionary is most useful when the data to be compressed is short and can be + predicted with good accuracy; the data can then be compressed better than + with the default empty dictionary. + + Depending on the size of the compression data structures selected by + deflateInit or deflateInit2, a part of the dictionary may in effect be + discarded, for example if the dictionary is larger than the window size + provided in deflateInit or deflateInit2. Thus the strings most likely to be + useful should be put at the end of the dictionary, not at the front. In + addition, the current implementation of deflate will use at most the window + size minus 262 bytes of the provided dictionary. + + Upon return of this function, strm->adler is set to the adler32 value + of the dictionary; the decompressor may later use this value to determine + which dictionary has been used by the compressor. (The adler32 value + applies to the whole dictionary even if only a subset of the dictionary is + actually used by the compressor.) If a raw deflate was requested, then the + adler32 value is not computed and strm->adler is not set. + + deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a + parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is + inconsistent (for example if deflate has already been called for this stream + or if not at a block boundary for raw deflate). deflateSetDictionary does + not perform any compression: this will be done by deflate(). +*/ + +ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, + z_streamp source)); +/* + Sets the destination stream as a complete copy of the source stream. + + This function can be useful when several compression strategies will be + tried, for example when there are several ways of pre-processing the input + data with a filter. The streams that will be discarded should then be freed + by calling deflateEnd. Note that deflateCopy duplicates the internal + compression state which can be quite large, so this strategy is slow and can + consume lots of memory. + + deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_STREAM_ERROR if the source stream state was inconsistent + (such as zalloc being Z_NULL). msg is left unchanged in both source and + destination. +*/ + +ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); +/* + This function is equivalent to deflateEnd followed by deflateInit, + but does not free and reallocate all the internal compression state. The + stream will keep the same compression level and any other attributes that + may have been set by deflateInit2. + + deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being Z_NULL). +*/ + +ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, + int level, + int strategy)); +/* + Dynamically update the compression level and compression strategy. The + interpretation of level and strategy is as in deflateInit2. This can be + used to switch between compression and straight copy of the input data, or + to switch to a different kind of input data requiring a different strategy. + If the compression level is changed, the input available so far is + compressed with the old level (and may be flushed); the new level will take + effect only at the next call of deflate(). + + Before the call of deflateParams, the stream state must be set as for + a call of deflate(), since the currently available input may have to be + compressed and flushed. In particular, strm->avail_out must be non-zero. + + deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source + stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR if + strm->avail_out was zero. +*/ + +ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm, + int good_length, + int max_lazy, + int nice_length, + int max_chain)); +/* + Fine tune deflate's internal compression parameters. This should only be + used by someone who understands the algorithm used by zlib's deflate for + searching for the best matching string, and even then only by the most + fanatic optimizer trying to squeeze out the last compressed bit for their + specific input data. Read the deflate.c source code for the meaning of the + max_lazy, good_length, nice_length, and max_chain parameters. + + deflateTune() can be called after deflateInit() or deflateInit2(), and + returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream. + */ + +ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, + uLong sourceLen)); +/* + deflateBound() returns an upper bound on the compressed size after + deflation of sourceLen bytes. It must be called after deflateInit() or + deflateInit2(), and after deflateSetHeader(), if used. This would be used + to allocate an output buffer for deflation in a single pass, and so would be + called before deflate(). If that first deflate() call is provided the + sourceLen input bytes, an output buffer allocated to the size returned by + deflateBound(), and the flush value Z_FINISH, then deflate() is guaranteed + to return Z_STREAM_END. Note that it is possible for the compressed size to + be larger than the value returned by deflateBound() if flush options other + than Z_FINISH or Z_NO_FLUSH are used. +*/ + +ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm, + unsigned *pending, + int *bits)); +/* + deflatePending() returns the number of bytes and bits of output that have + been generated, but not yet provided in the available output. The bytes not + provided would be due to the available output space having being consumed. + The number of bits of output not provided are between 0 and 7, where they + await more bits to join them in order to fill out a full byte. If pending + or bits are Z_NULL, then those values are not set. + + deflatePending returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. + */ + +ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, + int bits, + int value)); +/* + deflatePrime() inserts bits in the deflate output stream. The intent + is that this function is used to start off the deflate output with the bits + leftover from a previous deflate stream when appending to it. As such, this + function can only be used for raw deflate, and must be used before the first + deflate() call after a deflateInit2() or deflateReset(). bits must be less + than or equal to 16, and that many of the least significant bits of value + will be inserted in the output. + + deflatePrime returns Z_OK if success, Z_BUF_ERROR if there was not enough + room in the internal buffer to insert the bits, or Z_STREAM_ERROR if the + source stream state was inconsistent. +*/ + +ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, + gz_headerp head)); +/* + deflateSetHeader() provides gzip header information for when a gzip + stream is requested by deflateInit2(). deflateSetHeader() may be called + after deflateInit2() or deflateReset() and before the first call of + deflate(). The text, time, os, extra field, name, and comment information + in the provided gz_header structure are written to the gzip header (xflag is + ignored -- the extra flags are set according to the compression level). The + caller must assure that, if not Z_NULL, name and comment are terminated with + a zero byte, and that if extra is not Z_NULL, that extra_len bytes are + available there. If hcrc is true, a gzip header crc is included. Note that + the current versions of the command-line version of gzip (up through version + 1.3.x) do not support header crc's, and will report that it is a "multi-part + gzip file" and give up. + + If deflateSetHeader is not used, the default gzip header has text false, + the time set to zero, and os set to 255, with no extra, name, or comment + fields. The gzip header is returned to the default state by deflateReset(). + + deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +/* +ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, + int windowBits)); + + This is another version of inflateInit with an extra parameter. The + fields next_in, avail_in, zalloc, zfree and opaque must be initialized + before by the caller. + + The windowBits parameter is the base two logarithm of the maximum window + size (the size of the history buffer). It should be in the range 8..15 for + this version of the library. The default value is 15 if inflateInit is used + instead. windowBits must be greater than or equal to the windowBits value + provided to deflateInit2() while compressing, or it must be equal to 15 if + deflateInit2() was not used. If a compressed stream with a larger window + size is given as input, inflate() will return with the error code + Z_DATA_ERROR instead of trying to allocate a larger window. + + windowBits can also be zero to request that inflate use the window size in + the zlib header of the compressed stream. + + windowBits can also be -8..-15 for raw inflate. In this case, -windowBits + determines the window size. inflate() will then process raw deflate data, + not looking for a zlib or gzip header, not generating a check value, and not + looking for any check values for comparison at the end of the stream. This + is for use with other formats that use the deflate compressed data format + such as zip. Those formats provide their own check values. If a custom + format is developed using the raw deflate format for compressed data, it is + recommended that a check value such as an adler32 or a crc32 be applied to + the uncompressed data as is done in the zlib, gzip, and zip formats. For + most applications, the zlib format should be used as is. Note that comments + above on the use in deflateInit2() applies to the magnitude of windowBits. + + windowBits can also be greater than 15 for optional gzip decoding. Add + 32 to windowBits to enable zlib and gzip decoding with automatic header + detection, or add 16 to decode only the gzip format (the zlib format will + return a Z_DATA_ERROR). If a gzip stream is being decoded, strm->adler is a + crc32 instead of an adler32. + + inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_VERSION_ERROR if the zlib library version is incompatible with the + version assumed by the caller, or Z_STREAM_ERROR if the parameters are + invalid, such as a null pointer to the structure. msg is set to null if + there is no error message. inflateInit2 does not perform any decompression + apart from possibly reading the zlib header if present: actual decompression + will be done by inflate(). (So next_in and avail_in may be modified, but + next_out and avail_out are unused and unchanged.) The current implementation + of inflateInit2() does not process any header information -- that is + deferred until inflate() is called. +*/ + +ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, + const Bytef *dictionary, + uInt dictLength)); +/* + Initializes the decompression dictionary from the given uncompressed byte + sequence. This function must be called immediately after a call of inflate, + if that call returned Z_NEED_DICT. The dictionary chosen by the compressor + can be determined from the adler32 value returned by that call of inflate. + The compressor and decompressor must use exactly the same dictionary (see + deflateSetDictionary). For raw inflate, this function can be called at any + time to set the dictionary. If the provided dictionary is smaller than the + window and there is already data in the window, then the provided dictionary + will amend what's there. The application must insure that the dictionary + that was used for compression is provided. + + inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a + parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is + inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the + expected one (incorrect adler32 value). inflateSetDictionary does not + perform any decompression: this will be done by subsequent calls of + inflate(). +*/ + +ZEXTERN int ZEXPORT inflateGetDictionary OF((z_streamp strm, + Bytef *dictionary, + uInt *dictLength)); +/* + Returns the sliding dictionary being maintained by inflate. dictLength is + set to the number of bytes in the dictionary, and that many bytes are copied + to dictionary. dictionary must have enough space, where 32768 bytes is + always enough. If inflateGetDictionary() is called with dictionary equal to + Z_NULL, then only the dictionary length is returned, and nothing is copied. + Similary, if dictLength is Z_NULL, then it is not set. + + inflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the + stream state is inconsistent. +*/ + +ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); +/* + Skips invalid compressed data until a possible full flush point (see above + for the description of deflate with Z_FULL_FLUSH) can be found, or until all + available input is skipped. No output is provided. + + inflateSync searches for a 00 00 FF FF pattern in the compressed data. + All full flush points have this pattern, but not all occurrences of this + pattern are full flush points. + + inflateSync returns Z_OK if a possible full flush point has been found, + Z_BUF_ERROR if no more input was provided, Z_DATA_ERROR if no flush point + has been found, or Z_STREAM_ERROR if the stream structure was inconsistent. + In the success case, the application may save the current current value of + total_in which indicates where valid compressed data was found. In the + error case, the application may repeatedly call inflateSync, providing more + input each time, until success or end of the input data. +*/ + +ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, + z_streamp source)); +/* + Sets the destination stream as a complete copy of the source stream. + + This function can be useful when randomly accessing a large stream. The + first pass through the stream can periodically record the inflate state, + allowing restarting inflate at those points when randomly accessing the + stream. + + inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_STREAM_ERROR if the source stream state was inconsistent + (such as zalloc being Z_NULL). msg is left unchanged in both source and + destination. +*/ + +ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); +/* + This function is equivalent to inflateEnd followed by inflateInit, + but does not free and reallocate all the internal decompression state. The + stream will keep attributes that may have been set by inflateInit2. + + inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being Z_NULL). +*/ + +ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm, + int windowBits)); +/* + This function is the same as inflateReset, but it also permits changing + the wrap and window size requests. The windowBits parameter is interpreted + the same as it is for inflateInit2. + + inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being Z_NULL), or if + the windowBits parameter is invalid. +*/ + +ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm, + int bits, + int value)); +/* + This function inserts bits in the inflate input stream. The intent is + that this function is used to start inflating at a bit position in the + middle of a byte. The provided bits will be used before any bytes are used + from next_in. This function should only be used with raw inflate, and + should be used before the first inflate() call after inflateInit2() or + inflateReset(). bits must be less than or equal to 16, and that many of the + least significant bits of value will be inserted in the input. + + If bits is negative, then the input stream bit buffer is emptied. Then + inflatePrime() can be called again to put bits in the buffer. This is used + to clear out bits leftover after feeding inflate a block description prior + to feeding inflate codes. + + inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm)); +/* + This function returns two values, one in the lower 16 bits of the return + value, and the other in the remaining upper bits, obtained by shifting the + return value down 16 bits. If the upper value is -1 and the lower value is + zero, then inflate() is currently decoding information outside of a block. + If the upper value is -1 and the lower value is non-zero, then inflate is in + the middle of a stored block, with the lower value equaling the number of + bytes from the input remaining to copy. If the upper value is not -1, then + it is the number of bits back from the current bit position in the input of + the code (literal or length/distance pair) currently being processed. In + that case the lower value is the number of bytes already emitted for that + code. + + A code is being processed if inflate is waiting for more input to complete + decoding of the code, or if it has completed decoding but is waiting for + more output space to write the literal or match data. + + inflateMark() is used to mark locations in the input data for random + access, which may be at bit positions, and to note those cases where the + output of a code may span boundaries of random access blocks. The current + location in the input stream can be determined from avail_in and data_type + as noted in the description for the Z_BLOCK flush parameter for inflate. + + inflateMark returns the value noted above or -1 << 16 if the provided + source stream state was inconsistent. +*/ + +ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm, + gz_headerp head)); +/* + inflateGetHeader() requests that gzip header information be stored in the + provided gz_header structure. inflateGetHeader() may be called after + inflateInit2() or inflateReset(), and before the first call of inflate(). + As inflate() processes the gzip stream, head->done is zero until the header + is completed, at which time head->done is set to one. If a zlib stream is + being decoded, then head->done is set to -1 to indicate that there will be + no gzip header information forthcoming. Note that Z_BLOCK or Z_TREES can be + used to force inflate() to return immediately after header processing is + complete and before any actual data is decompressed. + + The text, time, xflags, and os fields are filled in with the gzip header + contents. hcrc is set to true if there is a header CRC. (The header CRC + was valid if done is set to one.) If extra is not Z_NULL, then extra_max + contains the maximum number of bytes to write to extra. Once done is true, + extra_len contains the actual extra field length, and extra contains the + extra field, or that field truncated if extra_max is less than extra_len. + If name is not Z_NULL, then up to name_max characters are written there, + terminated with a zero unless the length is greater than name_max. If + comment is not Z_NULL, then up to comm_max characters are written there, + terminated with a zero unless the length is greater than comm_max. When any + of extra, name, or comment are not Z_NULL and the respective field is not + present in the header, then that field is set to Z_NULL to signal its + absence. This allows the use of deflateSetHeader() with the returned + structure to duplicate the header. However if those fields are set to + allocated memory, then the application will need to save those pointers + elsewhere so that they can be eventually freed. + + If inflateGetHeader is not used, then the header information is simply + discarded. The header is always checked for validity, including the header + CRC if present. inflateReset() will reset the process to discard the header + information. The application would need to call inflateGetHeader() again to + retrieve the header from the next gzip stream. + + inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +/* +ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits, + unsigned char FAR *window)); + + Initialize the internal stream state for decompression using inflateBack() + calls. The fields zalloc, zfree and opaque in strm must be initialized + before the call. If zalloc and zfree are Z_NULL, then the default library- + derived memory allocation routines are used. windowBits is the base two + logarithm of the window size, in the range 8..15. window is a caller + supplied buffer of that size. Except for special applications where it is + assured that deflate was used with small window sizes, windowBits must be 15 + and a 32K byte window must be supplied to be able to decompress general + deflate streams. + + See inflateBack() for the usage of these routines. + + inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of + the parameters are invalid, Z_MEM_ERROR if the internal state could not be + allocated, or Z_VERSION_ERROR if the version of the library does not match + the version of the header file. +*/ + +typedef unsigned (*in_func) OF((void FAR *, + z_const unsigned char FAR * FAR *)); +typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned)); + +ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, + in_func in, void FAR *in_desc, + out_func out, void FAR *out_desc)); +/* + inflateBack() does a raw inflate with a single call using a call-back + interface for input and output. This is potentially more efficient than + inflate() for file i/o applications, in that it avoids copying between the + output and the sliding window by simply making the window itself the output + buffer. inflate() can be faster on modern CPUs when used with large + buffers. inflateBack() trusts the application to not change the output + buffer passed by the output function, at least until inflateBack() returns. + + inflateBackInit() must be called first to allocate the internal state + and to initialize the state with the user-provided window buffer. + inflateBack() may then be used multiple times to inflate a complete, raw + deflate stream with each call. inflateBackEnd() is then called to free the + allocated state. + + A raw deflate stream is one with no zlib or gzip header or trailer. + This routine would normally be used in a utility that reads zip or gzip + files and writes out uncompressed files. The utility would decode the + header and process the trailer on its own, hence this routine expects only + the raw deflate stream to decompress. This is different from the normal + behavior of inflate(), which expects either a zlib or gzip header and + trailer around the deflate stream. + + inflateBack() uses two subroutines supplied by the caller that are then + called by inflateBack() for input and output. inflateBack() calls those + routines until it reads a complete deflate stream and writes out all of the + uncompressed data, or until it encounters an error. The function's + parameters and return types are defined above in the in_func and out_func + typedefs. inflateBack() will call in(in_desc, &buf) which should return the + number of bytes of provided input, and a pointer to that input in buf. If + there is no input available, in() must return zero--buf is ignored in that + case--and inflateBack() will return a buffer error. inflateBack() will call + out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. out() + should return zero on success, or non-zero on failure. If out() returns + non-zero, inflateBack() will return with an error. Neither in() nor out() + are permitted to change the contents of the window provided to + inflateBackInit(), which is also the buffer that out() uses to write from. + The length written by out() will be at most the window size. Any non-zero + amount of input may be provided by in(). + + For convenience, inflateBack() can be provided input on the first call by + setting strm->next_in and strm->avail_in. If that input is exhausted, then + in() will be called. Therefore strm->next_in must be initialized before + calling inflateBack(). If strm->next_in is Z_NULL, then in() will be called + immediately for input. If strm->next_in is not Z_NULL, then strm->avail_in + must also be initialized, and then if strm->avail_in is not zero, input will + initially be taken from strm->next_in[0 .. strm->avail_in - 1]. + + The in_desc and out_desc parameters of inflateBack() is passed as the + first parameter of in() and out() respectively when they are called. These + descriptors can be optionally used to pass any information that the caller- + supplied in() and out() functions need to do their job. + + On return, inflateBack() will set strm->next_in and strm->avail_in to + pass back any unused input that was provided by the last in() call. The + return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR + if in() or out() returned an error, Z_DATA_ERROR if there was a format error + in the deflate stream (in which case strm->msg is set to indicate the nature + of the error), or Z_STREAM_ERROR if the stream was not properly initialized. + In the case of Z_BUF_ERROR, an input or output error can be distinguished + using strm->next_in which will be Z_NULL only if in() returned an error. If + strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning + non-zero. (in() will always be called before out(), so strm->next_in is + assured to be defined if out() returns non-zero.) Note that inflateBack() + cannot return Z_OK. +*/ + +ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm)); +/* + All memory allocated by inflateBackInit() is freed. + + inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream + state was inconsistent. +*/ + +ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); +/* Return flags indicating compile-time options. + + Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other: + 1.0: size of uInt + 3.2: size of uLong + 5.4: size of voidpf (pointer) + 7.6: size of z_off_t + + Compiler, assembler, and debug options: + 8: DEBUG + 9: ASMV or ASMINF -- use ASM code + 10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention + 11: 0 (reserved) + + One-time table building (smaller code, but not thread-safe if true): + 12: BUILDFIXED -- build static block decoding tables when needed + 13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed + 14,15: 0 (reserved) + + Library content (indicates missing functionality): + 16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking + deflate code when not needed) + 17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect + and decode gzip streams (to avoid linking crc code) + 18-19: 0 (reserved) + + Operation variations (changes in library functionality): + 20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate + 21: FASTEST -- deflate algorithm with only one, lowest compression level + 22,23: 0 (reserved) + + The sprintf variant used by gzprintf (zero is best): + 24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format + 25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure! + 26: 0 = returns value, 1 = void -- 1 means inferred string length returned + + Remainder: + 27-31: 0 (reserved) + */ + +#ifndef Z_SOLO + + /* utility functions */ + +/* + The following utility functions are implemented on top of the basic + stream-oriented functions. To simplify the interface, some default options + are assumed (compression level and memory usage, standard memory allocation + functions). The source code of these utility functions can be modified if + you need special options. +*/ + +ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen)); +/* + Compresses the source buffer into the destination buffer. sourceLen is + the byte length of the source buffer. Upon entry, destLen is the total size + of the destination buffer, which must be at least the value returned by + compressBound(sourceLen). Upon exit, destLen is the actual size of the + compressed buffer. + + compress returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if there was not enough room in the output + buffer. +*/ + +ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen, + int level)); +/* + Compresses the source buffer into the destination buffer. The level + parameter has the same meaning as in deflateInit. sourceLen is the byte + length of the source buffer. Upon entry, destLen is the total size of the + destination buffer, which must be at least the value returned by + compressBound(sourceLen). Upon exit, destLen is the actual size of the + compressed buffer. + + compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_BUF_ERROR if there was not enough room in the output buffer, + Z_STREAM_ERROR if the level parameter is invalid. +*/ + +ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen)); +/* + compressBound() returns an upper bound on the compressed size after + compress() or compress2() on sourceLen bytes. It would be used before a + compress() or compress2() call to allocate the destination buffer. +*/ + +ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen)); +/* + Decompresses the source buffer into the destination buffer. sourceLen is + the byte length of the source buffer. Upon entry, destLen is the total size + of the destination buffer, which must be large enough to hold the entire + uncompressed data. (The size of the uncompressed data must have been saved + previously by the compressor and transmitted to the decompressor by some + mechanism outside the scope of this compression library.) Upon exit, destLen + is the actual size of the uncompressed buffer. + + uncompress returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if there was not enough room in the output + buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete. In + the case where there is not enough room, uncompress() will fill the output + buffer with the uncompressed data up to that point. +*/ + + /* gzip file access functions */ + +/* + This library supports reading and writing files in gzip (.gz) format with + an interface similar to that of stdio, using the functions that start with + "gz". The gzip format is different from the zlib format. gzip is a gzip + wrapper, documented in RFC 1952, wrapped around a deflate stream. +*/ + +typedef struct gzFile_s *gzFile; /* semi-opaque gzip file descriptor */ + +/* +ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); + + Opens a gzip (.gz) file for reading or writing. The mode parameter is as + in fopen ("rb" or "wb") but can also include a compression level ("wb9") or + a strategy: 'f' for filtered data as in "wb6f", 'h' for Huffman-only + compression as in "wb1h", 'R' for run-length encoding as in "wb1R", or 'F' + for fixed code compression as in "wb9F". (See the description of + deflateInit2 for more information about the strategy parameter.) 'T' will + request transparent writing or appending with no compression and not using + the gzip format. + + "a" can be used instead of "w" to request that the gzip stream that will + be written be appended to the file. "+" will result in an error, since + reading and writing to the same gzip file is not supported. The addition of + "x" when writing will create the file exclusively, which fails if the file + already exists. On systems that support it, the addition of "e" when + reading or writing will set the flag to close the file on an execve() call. + + These functions, as well as gzip, will read and decode a sequence of gzip + streams in a file. The append function of gzopen() can be used to create + such a file. (Also see gzflush() for another way to do this.) When + appending, gzopen does not test whether the file begins with a gzip stream, + nor does it look for the end of the gzip streams to begin appending. gzopen + will simply append a gzip stream to the existing file. + + gzopen can be used to read a file which is not in gzip format; in this + case gzread will directly read from the file without decompression. When + reading, this will be detected automatically by looking for the magic two- + byte gzip header. + + gzopen returns NULL if the file could not be opened, if there was + insufficient memory to allocate the gzFile state, or if an invalid mode was + specified (an 'r', 'w', or 'a' was not provided, or '+' was provided). + errno can be checked to determine if the reason gzopen failed was that the + file could not be opened. +*/ + +ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); +/* + gzdopen associates a gzFile with the file descriptor fd. File descriptors + are obtained from calls like open, dup, creat, pipe or fileno (if the file + has been previously opened with fopen). The mode parameter is as in gzopen. + + The next call of gzclose on the returned gzFile will also close the file + descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor + fd. If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd, + mode);. The duplicated descriptor should be saved to avoid a leak, since + gzdopen does not close fd if it fails. If you are using fileno() to get the + file descriptor from a FILE *, then you will have to use dup() to avoid + double-close()ing the file descriptor. Both gzclose() and fclose() will + close the associated file descriptor, so they need to have different file + descriptors. + + gzdopen returns NULL if there was insufficient memory to allocate the + gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not + provided, or '+' was provided), or if fd is -1. The file descriptor is not + used until the next gz* read, write, seek, or close operation, so gzdopen + will not detect if fd is invalid (unless fd is -1). +*/ + +ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size)); +/* + Set the internal buffer size used by this library's functions. The + default buffer size is 8192 bytes. This function must be called after + gzopen() or gzdopen(), and before any other calls that read or write the + file. The buffer memory allocation is always deferred to the first read or + write. Two buffers are allocated, either both of the specified size when + writing, or one of the specified size and the other twice that size when + reading. A larger buffer size of, for example, 64K or 128K bytes will + noticeably increase the speed of decompression (reading). + + The new buffer size also affects the maximum length for gzprintf(). + + gzbuffer() returns 0 on success, or -1 on failure, such as being called + too late. +*/ + +ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); +/* + Dynamically update the compression level or strategy. See the description + of deflateInit2 for the meaning of these parameters. + + gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not + opened for writing. +*/ + +ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); +/* + Reads the given number of uncompressed bytes from the compressed file. If + the input file is not in gzip format, gzread copies the given number of + bytes into the buffer directly from the file. + + After reaching the end of a gzip stream in the input, gzread will continue + to read, looking for another gzip stream. Any number of gzip streams may be + concatenated in the input file, and will all be decompressed by gzread(). + If something other than a gzip stream is encountered after a gzip stream, + that remaining trailing garbage is ignored (and no error is returned). + + gzread can be used to read a gzip file that is being concurrently written. + Upon reaching the end of the input, gzread will return with the available + data. If the error code returned by gzerror is Z_OK or Z_BUF_ERROR, then + gzclearerr can be used to clear the end of file indicator in order to permit + gzread to be tried again. Z_OK indicates that a gzip stream was completed + on the last gzread. Z_BUF_ERROR indicates that the input file ended in the + middle of a gzip stream. Note that gzread does not return -1 in the event + of an incomplete gzip stream. This error is deferred until gzclose(), which + will return Z_BUF_ERROR if the last gzread ended in the middle of a gzip + stream. Alternatively, gzerror can be used before gzclose to detect this + case. + + gzread returns the number of uncompressed bytes actually read, less than + len for end of file, or -1 for error. +*/ + +ZEXTERN int ZEXPORT gzwrite OF((gzFile file, + voidpc buf, unsigned len)); +/* + Writes the given number of uncompressed bytes into the compressed file. + gzwrite returns the number of uncompressed bytes written or 0 in case of + error. +*/ + +ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...)); +/* + Converts, formats, and writes the arguments to the compressed file under + control of the format string, as in fprintf. gzprintf returns the number of + uncompressed bytes actually written, or 0 in case of error. The number of + uncompressed bytes written is limited to 8191, or one less than the buffer + size given to gzbuffer(). The caller should assure that this limit is not + exceeded. If it is exceeded, then gzprintf() will return an error (0) with + nothing written. In this case, there may also be a buffer overflow with + unpredictable consequences, which is possible only if zlib was compiled with + the insecure functions sprintf() or vsprintf() because the secure snprintf() + or vsnprintf() functions were not available. This can be determined using + zlibCompileFlags(). +*/ + +ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); +/* + Writes the given null-terminated string to the compressed file, excluding + the terminating null character. + + gzputs returns the number of characters written, or -1 in case of error. +*/ + +ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); +/* + Reads bytes from the compressed file until len-1 characters are read, or a + newline character is read and transferred to buf, or an end-of-file + condition is encountered. If any characters are read or if len == 1, the + string is terminated with a null character. If no characters are read due + to an end-of-file or len < 1, then the buffer is left untouched. + + gzgets returns buf which is a null-terminated string, or it returns NULL + for end-of-file or in case of error. If there was an error, the contents at + buf are indeterminate. +*/ + +ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); +/* + Writes c, converted to an unsigned char, into the compressed file. gzputc + returns the value that was written, or -1 in case of error. +*/ + +ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); +/* + Reads one byte from the compressed file. gzgetc returns this byte or -1 + in case of end of file or error. This is implemented as a macro for speed. + As such, it does not do all of the checking the other functions do. I.e. + it does not check to see if file is NULL, nor whether the structure file + points to has been clobbered or not. +*/ + +ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); +/* + Push one character back onto the stream to be read as the first character + on the next read. At least one character of push-back is allowed. + gzungetc() returns the character pushed, or -1 on failure. gzungetc() will + fail if c is -1, and may fail if a character has been pushed but not read + yet. If gzungetc is used immediately after gzopen or gzdopen, at least the + output buffer size of pushed characters is allowed. (See gzbuffer above.) + The pushed character will be discarded if the stream is repositioned with + gzseek() or gzrewind(). +*/ + +ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); +/* + Flushes all pending output into the compressed file. The parameter flush + is as in the deflate() function. The return value is the zlib error number + (see function gzerror below). gzflush is only permitted when writing. + + If the flush parameter is Z_FINISH, the remaining data is written and the + gzip stream is completed in the output. If gzwrite() is called again, a new + gzip stream will be started in the output. gzread() is able to read such + concatented gzip streams. + + gzflush should be called only when strictly necessary because it will + degrade compression if called too often. +*/ + +/* +ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, + z_off_t offset, int whence)); + + Sets the starting position for the next gzread or gzwrite on the given + compressed file. The offset represents a number of bytes in the + uncompressed data stream. The whence parameter is defined as in lseek(2); + the value SEEK_END is not supported. + + If the file is opened for reading, this function is emulated but can be + extremely slow. If the file is opened for writing, only forward seeks are + supported; gzseek then compresses a sequence of zeroes up to the new + starting position. + + gzseek returns the resulting offset location as measured in bytes from + the beginning of the uncompressed stream, or -1 in case of error, in + particular if the file is opened for writing and the new starting position + would be before the current position. +*/ + +ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); +/* + Rewinds the given file. This function is supported only for reading. + + gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) +*/ + +/* +ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); + + Returns the starting position for the next gzread or gzwrite on the given + compressed file. This position represents a number of bytes in the + uncompressed data stream, and is zero when starting, even if appending or + reading a gzip stream from the middle of a file using gzdopen(). + + gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) +*/ + +/* +ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file)); + + Returns the current offset in the file being read or written. This offset + includes the count of bytes that precede the gzip stream, for example when + appending or when using gzdopen() for reading. When reading, the offset + does not include as yet unused buffered input. This information can be used + for a progress indicator. On error, gzoffset() returns -1. +*/ + +ZEXTERN int ZEXPORT gzeof OF((gzFile file)); +/* + Returns true (1) if the end-of-file indicator has been set while reading, + false (0) otherwise. Note that the end-of-file indicator is set only if the + read tried to go past the end of the input, but came up short. Therefore, + just like feof(), gzeof() may return false even if there is no more data to + read, in the event that the last read request was for the exact number of + bytes remaining in the input file. This will happen if the input file size + is an exact multiple of the buffer size. + + If gzeof() returns true, then the read functions will return no more data, + unless the end-of-file indicator is reset by gzclearerr() and the input file + has grown since the previous end of file was detected. +*/ + +ZEXTERN int ZEXPORT gzdirect OF((gzFile file)); +/* + Returns true (1) if file is being copied directly while reading, or false + (0) if file is a gzip stream being decompressed. + + If the input file is empty, gzdirect() will return true, since the input + does not contain a gzip stream. + + If gzdirect() is used immediately after gzopen() or gzdopen() it will + cause buffers to be allocated to allow reading the file to determine if it + is a gzip file. Therefore if gzbuffer() is used, it should be called before + gzdirect(). + + When writing, gzdirect() returns true (1) if transparent writing was + requested ("wT" for the gzopen() mode), or false (0) otherwise. (Note: + gzdirect() is not needed when writing. Transparent writing must be + explicitly requested, so the application already knows the answer. When + linking statically, using gzdirect() will include all of the zlib code for + gzip file reading and decompression, which may not be desired.) +*/ + +ZEXTERN int ZEXPORT gzclose OF((gzFile file)); +/* + Flushes all pending output if necessary, closes the compressed file and + deallocates the (de)compression state. Note that once file is closed, you + cannot call gzerror with file, since its structures have been deallocated. + gzclose must not be called more than once on the same file, just as free + must not be called more than once on the same allocation. + + gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a + file operation error, Z_MEM_ERROR if out of memory, Z_BUF_ERROR if the + last read ended in the middle of a gzip stream, or Z_OK on success. +*/ + +ZEXTERN int ZEXPORT gzclose_r OF((gzFile file)); +ZEXTERN int ZEXPORT gzclose_w OF((gzFile file)); +/* + Same as gzclose(), but gzclose_r() is only for use when reading, and + gzclose_w() is only for use when writing or appending. The advantage to + using these instead of gzclose() is that they avoid linking in zlib + compression or decompression code that is not used when only reading or only + writing respectively. If gzclose() is used, then both compression and + decompression code will be included the application when linking to a static + zlib library. +*/ + +ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); +/* + Returns the error message for the last error which occurred on the given + compressed file. errnum is set to zlib error number. If an error occurred + in the file system and not in the compression library, errnum is set to + Z_ERRNO and the application may consult errno to get the exact error code. + + The application must not modify the returned string. Future calls to + this function may invalidate the previously returned string. If file is + closed, then the string previously returned by gzerror will no longer be + available. + + gzerror() should be used to distinguish errors from end-of-file for those + functions above that do not distinguish those cases in their return values. +*/ + +ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); +/* + Clears the error and end-of-file flags for file. This is analogous to the + clearerr() function in stdio. This is useful for continuing to read a gzip + file that is being written concurrently. +*/ + +#endif /* !Z_SOLO */ + + /* checksum functions */ + +/* + These functions are not related to compression but are exported + anyway because they might be useful in applications using the compression + library. +*/ + +ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); +/* + Update a running Adler-32 checksum with the bytes buf[0..len-1] and + return the updated checksum. If buf is Z_NULL, this function returns the + required initial value for the checksum. + + An Adler-32 checksum is almost as reliable as a CRC32 but can be computed + much faster. + + Usage example: + + uLong adler = adler32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + adler = adler32(adler, buffer, length); + } + if (adler != original_adler) error(); +*/ + +/* +ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2, + z_off_t len2)); + + Combine two Adler-32 checksums into one. For two sequences of bytes, seq1 + and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for + each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of + seq1 and seq2 concatenated, requiring only adler1, adler2, and len2. Note + that the z_off_t type (like off_t) is a signed integer. If len2 is + negative, the result has no meaning or utility. +*/ + +ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); +/* + Update a running CRC-32 with the bytes buf[0..len-1] and return the + updated CRC-32. If buf is Z_NULL, this function returns the required + initial value for the crc. Pre- and post-conditioning (one's complement) is + performed within this function so it shouldn't be done by the application. + + Usage example: + + uLong crc = crc32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + crc = crc32(crc, buffer, length); + } + if (crc != original_crc) error(); +*/ + +/* +ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2)); + + Combine two CRC-32 check values into one. For two sequences of bytes, + seq1 and seq2 with lengths len1 and len2, CRC-32 check values were + calculated for each, crc1 and crc2. crc32_combine() returns the CRC-32 + check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and + len2. +*/ + + + /* various hacks, don't look :) */ + +/* deflateInit and inflateInit are macros to allow checking the zlib version + * and the compiler's view of z_stream: + */ +ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, + int windowBits, int memLevel, + int strategy, const char *version, + int stream_size)); +ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, + unsigned char FAR *window, + const char *version, + int stream_size)); +#define deflateInit(strm, level) \ + deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream)) +#define inflateInit(strm) \ + inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream)) +#define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ + deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ + (strategy), ZLIB_VERSION, (int)sizeof(z_stream)) +#define inflateInit2(strm, windowBits) \ + inflateInit2_((strm), (windowBits), ZLIB_VERSION, \ + (int)sizeof(z_stream)) +#define inflateBackInit(strm, windowBits, window) \ + inflateBackInit_((strm), (windowBits), (window), \ + ZLIB_VERSION, (int)sizeof(z_stream)) + +#ifndef Z_SOLO + +/* gzgetc() macro and its supporting function and exposed data structure. Note + * that the real internal state is much larger than the exposed structure. + * This abbreviated structure exposes just enough for the gzgetc() macro. The + * user should not mess with these exposed elements, since their names or + * behavior could change in the future, perhaps even capriciously. They can + * only be used by the gzgetc() macro. You have been warned. + */ +struct gzFile_s { + unsigned have; + unsigned char *next; + z_off64_t pos; +}; +ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */ +#ifdef Z_PREFIX_SET +# undef z_gzgetc +# define z_gzgetc(g) \ + ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g)) +#else +# define gzgetc(g) \ + ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : gzgetc(g)) +#endif + +/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or + * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if + * both are true, the application gets the *64 functions, and the regular + * functions are changed to 64 bits) -- in case these are set on systems + * without large file support, _LFS64_LARGEFILE must also be true + */ +#ifdef Z_LARGE64 + ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); + ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); + ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); + ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); + ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t)); + ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t)); +#endif + +#if !defined(ZLIB_INTERNAL) && defined(Z_WANT64) +# ifdef Z_PREFIX_SET +# define z_gzopen z_gzopen64 +# define z_gzseek z_gzseek64 +# define z_gztell z_gztell64 +# define z_gzoffset z_gzoffset64 +# define z_adler32_combine z_adler32_combine64 +# define z_crc32_combine z_crc32_combine64 +# else +# define gzopen gzopen64 +# define gzseek gzseek64 +# define gztell gztell64 +# define gzoffset gzoffset64 +# define adler32_combine adler32_combine64 +# define crc32_combine crc32_combine64 +# endif +# ifndef Z_LARGE64 + ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); + ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int)); + ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile)); + ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile)); + ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t)); + ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t)); +# endif +#else + ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *)); + ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int)); + ZEXTERN z_off_t ZEXPORT gztell OF((gzFile)); + ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile)); + ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); + ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); +#endif + +#else /* Z_SOLO */ + + ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); + ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); + +#endif /* !Z_SOLO */ + +/* hack for buggy compilers */ +#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL) + struct internal_state {int dummy;}; +#endif + +/* undocumented functions */ +ZEXTERN const char * ZEXPORT zError OF((int)); +ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp)); +ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table OF((void)); +ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int)); +ZEXTERN int ZEXPORT inflateResetKeep OF((z_streamp)); +ZEXTERN int ZEXPORT deflateResetKeep OF((z_streamp)); +#if defined(_WIN32) && !defined(Z_SOLO) +ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t *path, + const char *mode)); +#endif +#if defined(STDC) || defined(Z_HAVE_STDARG_H) +# ifndef Z_SOLO +ZEXTERN int ZEXPORTVA gzvprintf Z_ARG((gzFile file, + const char *format, + va_list va)); +# endif +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* ZLIB_H */ -- cgit v1.2.3