react-native-real-time-nitro 1.7.0 → 1.8.0

package/3rdparty/output/android/libwebsockets/arm64-v8a/include/libwebsockets/lws-uc8176-spi.h

@@ -0,0 +1,55 @@
+/*
+ * lws abstract display implementation for epd-acep on spi
+ *
+ * Copyright (C) 2019 - 2022 Andy Green <andy@warmcat.com>
+ *
+ * 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 OR COPYRIGHT HOLDERS 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.
+ */
+
+#if !defined(__LWS_DISPLAY_UC8176_SPI_H__)
+#define __LWS_DISPLAY_UC8176_SPI_H__
+
+typedef struct lws_display_uc8176_spi {
+
+	lws_display_t		disp; /* use lws_display_uc8176_ops to set */
+	const lws_spi_ops_t	*spi;	      /* spi ops */
+
+	lws_display_completion_t	cb;
+
+	const lws_gpio_ops_t	*gpio;	      /* NULL or gpio ops */
+	_lws_plat_gpio_t	reset_gpio;   /* if gpio ops, nReset gpio # */
+	_lws_plat_gpio_t	busy_gpio;   /* if gpio ops, busy gpio # */
+
+	uint8_t			spi_index; /* cs index starting from 0 */
+
+} lws_display_uc8176_spi_t;
+
+int
+lws_display_uc8176_spi_init(lws_display_state_t *lds);
+int
+lws_display_uc8176_spi_blit(lws_display_state_t *lds, const uint8_t *src,
+			     lws_box_t *box, lws_dll2_owner_t *ids);
+int
+lws_display_uc8176_spi_power(lws_display_state_t *lds, int state);
+
+#define lws_display_uc8176_ops \
+	.init = lws_display_uc8176_spi_init, \
+	.blit = lws_display_uc8176_spi_blit, \
+	.power = lws_display_uc8176_spi_power
+#endif

package/3rdparty/output/android/libwebsockets/arm64-v8a/include/libwebsockets/lws-upng.h

@@ -0,0 +1,160 @@
+/*
+ * uPNG -- derived from LodePNG version 20100808
+ *
+ * Copyright (c) 2005-2010 Lode Vandevenne
+ * Copyright (c) 2010 Sean Middleditch
+ * Copyright (c) 2021-2022 Andy Green <andy@warmcat.com>
+ *
+ * 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.
+ *
+ *  The above notice is the ZLIB license, libpng also uses it.
+ *
+ * This version is based on upng project's fork of lodepng and rewritten for
+ * lws, changing the whole approach to decode on demand to issue a line of
+ * output at a time, statefully.
+ */
+
+typedef enum lws_upng_format_t {
+	LWS_UPNG_BADFORMAT,
+	LWS_UPNG_RGB8,
+	LWS_UPNG_RGB16,
+	LWS_UPNG_RGBA8,
+	LWS_UPNG_RGBA16,
+	LWS_UPNG_LUMINANCE1,
+	LWS_UPNG_LUMINANCE2,
+	LWS_UPNG_LUMINANCE4,
+	LWS_UPNG_LUMINANCE8,
+	LWS_UPNG_LUMINANCE_ALPHA1,
+	LWS_UPNG_LUMINANCE_ALPHA2,
+	LWS_UPNG_LUMINANCE_ALPHA4,
+	LWS_UPNG_LUMINANCE_ALPHA8
+} lws_upng_format_t;
+
+struct inflator_ctx;
+typedef struct lws_upng_t lws_upng_t;
+
+/**
+ * lws_upng_new() - Create new UPNG decode object
+ *
+ * Returns a new PNG decoding object, which should be destroyed with
+ * lws_upng_free() when done with, or NULL if OOM.
+ */
+LWS_VISIBLE LWS_EXTERN lws_upng_t *
+lws_upng_new(void);
+
+/**
+ * lws_upng_free() - Destroy a PNG decode object
+ *
+ * \param upng: Pointer to the decode object to destroy and set to NULL
+ *
+ * This also frees any sub-allocations in the object.
+ */
+LWS_VISIBLE LWS_EXTERN void
+lws_upng_free(lws_upng_t **upng);
+
+/**
+ * lws_upng_emit_next_line() - deocde the next line
+ *
+ * \param upng: the decode object
+ * \param ppix: pointer to a pointer set to the line's decoded pixel data
+ * \param buf: pointer to a const uint8_t array of PNG input
+ * \param size: pointer to the count of bytes available at *buf
+ * \param hold_at_metadata: true if we should not advance to decode
+ *
+ * Make PNG input available to the decoder so it can issue the next line's
+ * worth of pixels.  If the call consumed any input, *buf and *size are
+ * adjusted accordingly.
+ *
+ * The decoder is stateful so it is not sensitive to the chunk size for the
+ * input.
+ *
+ * If \p hold_at_metadata is set, then the decoder will only go as far as
+ * picking out the metadata like image dimensions, but not start the decode,
+ * which requires the >30KB heap allocation.  This lets you put off for as long
+ * as possible committing to the decode allocation... this only helps overall
+ * if you have flow controlled the incoming PNG data.
+ *
+ * Return will be one of LWS_SRET_WANT_INPUT is the decoder is stalled waiting
+ * for more input to be provided, LWS_SRET_WANT_OUTPUT is the decoder stopped
+ * because it had produced a whole line of output pixels (which can be found
+ * starting at *ppix), LWS_SRET_OK is it completed and LWS_SRET_FATAL or larger
+ * if the decode failed.
+ */
+LWS_VISIBLE LWS_EXTERN lws_stateful_ret_t
+lws_upng_emit_next_line(lws_upng_t *upng, const uint8_t **ppix,
+			const uint8_t **buf, size_t *size,
+			char hold_at_metadata);
+
+LWS_VISIBLE LWS_EXTERN unsigned int
+lws_upng_get_width(const lws_upng_t *upng);
+LWS_VISIBLE LWS_EXTERN unsigned int
+lws_upng_get_height(const lws_upng_t *upng);
+LWS_VISIBLE LWS_EXTERN unsigned int
+lws_upng_get_bpp(const lws_upng_t *upng);
+LWS_VISIBLE LWS_EXTERN unsigned int
+lws_upng_get_bitdepth(const lws_upng_t *upng);
+LWS_VISIBLE LWS_EXTERN unsigned int
+lws_upng_get_components(const lws_upng_t *upng);
+LWS_VISIBLE LWS_EXTERN unsigned int
+lws_upng_get_pixelsize(const lws_upng_t *upng);
+LWS_VISIBLE LWS_EXTERN lws_upng_format_t
+lws_upng_get_format(const lws_upng_t *upng);
+
+/**
+ * lws_upng_inflator_create() - create a gzip inflator context
+ *
+ * \param outring: pointer set to the output ringbuffer on exit
+ * \param outringlen: size of the output ringbuffer set on exit
+ * \param opl: pointer to set to point to ctx outpos_linear
+ * \param cl: pointer to set to point to ctx consumed_linear
+ *
+ * Creates an opaque gzip inflator object.
+ */
+LWS_VISIBLE LWS_EXTERN struct inflator_ctx *
+lws_upng_inflator_create(const uint8_t **outring, size_t *outringlen,
+			 size_t **opl, size_t **cl);
+
+/**
+ * lws_upng_inflate_data() - inflate compressed data statefully
+ *
+ * \param inf: inflator context created with lws_upng_inflator_create()
+ * \param buf: NULL to continue consumption of existing input, or new input
+ * \param len: ignored if \p buf is NULL, else amount of new input at \p buf
+ *
+ * Tries to progress the inflation.  If output is available, \p *opl will be
+ * further along than before it was called.  \p *cl should be set to \p opl
+ * to consume the available output data.
+ *
+ * Output is into a ringfuffer, typically sized at 32KB.  \p opl and \p cl
+ * are "linear", that is extend beyond the ringbuffer.  They should be modulo
+ * outringlen (given when the inflator was created) when accessing outring.
+ */
+LWS_VISIBLE LWS_EXTERN lws_stateful_ret_t
+lws_upng_inflate_data(struct inflator_ctx *inf, const void *buf, size_t len);
+
+/**
+ * lws_upng_inflator_destroy() - destroys the inflation context and ringbuffer
+ *
+ * \p inf: pointer to pointer to inflation context
+ *
+ * Frees the inflation context and its allocations, and sets \p *inf to NULL.
+ */
+LWS_VISIBLE LWS_EXTERN void
+lws_upng_inflator_destroy(struct inflator_ctx **inf);

package/3rdparty/output/android/libwebsockets/arm64-v8a/include/libwebsockets/lws-vfs.h

@@ -93,10 +93,15 @@ struct lws_fops_index {
 };
 
 struct lws_plat_file_ops {
-	lws_fop_fd_t (*LWS_FOP_OPEN)(const struct lws_plat_file_ops *fops,
+	lws_fop_fd_t (*LWS_FOP_OPEN)(const struct lws_plat_file_ops *fops_own,
+				     const struct lws_plat_file_ops *fops,
 				     const char *filename, const char *vpath,
 				     lws_fop_flags_t *flags);
 	/**< Open file (always binary access if plat supports it)
+	 * fops_own is the fops this was called through.  fops is the base
+	 * fops the open can use to find files to process as present as its own,
+	 * like the zip fops does.
+	 *
 	 * vpath may be NULL, or if the fops understands it, the point at which
 	 * the filename's virtual part starts.
 	 * *flags & LWS_FOP_FLAGS_MASK should be set to O_RDONLY or O_RDWR.
@@ -121,7 +126,12 @@ struct lws_plat_file_ops {
 	/**< vfs path signatures implying use of this fops */
 
 	const struct lws_plat_file_ops *next;
-	/**< NULL or next fops in list */
+	/**< NULL or next fops in list... eg copy static fops def to heap
+	 * and modify copy at runtime */
+
+	struct lws_context		*cx;
+	/**< the lws_context...  eg copy static fops def to heap
+	 * and modify copy at runtime */
 
 	/* Add new things just above here ---^
 	 * This is part of the ABI, don't needlessly break compatibility */
@@ -254,7 +264,8 @@ lws_vfs_file_write(lws_fop_fd_t fop_fd, lws_filepos_t *amount,
  */
 
 LWS_VISIBLE LWS_EXTERN lws_fop_fd_t
-_lws_plat_file_open(const struct lws_plat_file_ops *fops, const char *filename,
+_lws_plat_file_open(const struct lws_plat_file_ops *fops_own,
+		    const struct lws_plat_file_ops *fops, const char *filename,
 		    const char *vpath, lws_fop_flags_t *flags);
 LWS_VISIBLE LWS_EXTERN int
 _lws_plat_file_close(lws_fop_fd_t *fop_fd);

package/3rdparty/output/android/libwebsockets/arm64-v8a/include/libwebsockets/lws-write.h

@@ -27,23 +27,6 @@
     APIs related to writing data on a connection
 */
 //@{
-#if !defined(LWS_SIZEOFPTR)
-#define LWS_SIZEOFPTR ((int)sizeof (void *))
-#endif
-
-#if defined(__x86_64__)
-#define _LWS_PAD_SIZE 16	/* Intel recommended for best performance */
-#else
-#define _LWS_PAD_SIZE LWS_SIZEOFPTR   /* Size of a pointer on the target arch */
-#endif
-#define _LWS_PAD(n) (((n) % _LWS_PAD_SIZE) ? \
-		((n) + (_LWS_PAD_SIZE - ((n) % _LWS_PAD_SIZE))) : (n))
-/* last 2 is for lws-meta */
-#define LWS_PRE _LWS_PAD(4 + 10 + 2)
-/* used prior to 1.7 and retained for backward compatibility */
-#define LWS_SEND_BUFFER_PRE_PADDING LWS_PRE
-#define LWS_SEND_BUFFER_POST_PADDING 0
-
 #define LWS_WRITE_RAW LWS_WRITE_HTTP
 
 /*
@@ -241,18 +224,18 @@ lws_write(struct lws *wsi, unsigned char *buf, size_t len,
  * Returns the correct LWS_WRITE_ flag to use for each fragment of a message
  * in turn.
  */
-static LWS_INLINE int
+static LWS_INLINE enum lws_write_protocol
 lws_write_ws_flags(int initial, int is_start, int is_end)
 {
-	int r;
+	enum lws_write_protocol r;
 
 	if (is_start)
-		r = initial;
+		r = (enum lws_write_protocol)initial;
 	else
 		r = LWS_WRITE_CONTINUATION;
 
 	if (!is_end)
-		r |= LWS_WRITE_NO_FIN;
+		r = (enum lws_write_protocol)((int)r | (int)LWS_WRITE_NO_FIN);
 
 	return r;
 }

package/3rdparty/output/android/libwebsockets/arm64-v8a/include/libwebsockets/lws-ws-ext.h

@@ -184,7 +184,7 @@ lws_ext_parse_options(const struct lws_extension *ext, struct lws *wsi,
  *
  * Built-in callback implementing RFC7692 permessage-deflate
  */
-LWS_EXTERN int
+LWS_VISIBLE LWS_EXTERN int
 lws_extension_callback_pm_deflate(struct lws_context *context,
 				  const struct lws_extension *ext,
 				  struct lws *wsi,

package/3rdparty/output/android/libwebsockets/arm64-v8a/include/libwebsockets/lws-ws-state.h

@@ -38,7 +38,7 @@ LWS_VISIBLE LWS_EXTERN int LWS_WARN_UNUSED_RESULT
 lws_send_pipe_choked(struct lws *wsi);
 
 /**
- * lws_is_final_fragment() - tests if last part of ws message
+ * lws_is_final_fragment() - tests if received fragment is last part of ws message
  *
  * \param wsi: lws connection
  */
@@ -46,13 +46,22 @@ LWS_VISIBLE LWS_EXTERN int
 lws_is_final_fragment(struct lws *wsi);
 
 /**
- * lws_is_first_fragment() - tests if first part of ws message
+ * lws_is_first_fragment() - tests if received fragment is first part of ws message
  *
  * \param wsi: lws connection
  */
 LWS_VISIBLE LWS_EXTERN int
 lws_is_first_fragment(struct lws *wsi);
 
+/**
+ * lws_ws_sending_multifragment() - return 1 if we are in the middle of sending a multi-fragment message
+ *
+ * \param wsi: lws connection
+ */
+
+LWS_VISIBLE LWS_EXTERN int
+lws_ws_sending_multifragment(struct lws *wsi);
+
 /**
  * lws_get_reserved_bits() - access reserved bits of ws frame
  * \param wsi: lws connection
@@ -60,6 +69,13 @@ lws_is_first_fragment(struct lws *wsi);
 LWS_VISIBLE LWS_EXTERN unsigned char
 lws_get_reserved_bits(struct lws *wsi);
 
+/**
+ * lws_get_opcode() - access opcode of ws frame
+ * \param wsi: lws connection
+ */
+LWS_VISIBLE LWS_EXTERN uint8_t
+lws_get_opcode(struct lws *wsi);
+
 /**
  * lws_partial_buffered() - find out if lws buffered the last write
  * \param wsi:	websocket connection to check

package/3rdparty/output/android/libwebsockets/arm64-v8a/include/libwebsockets.h

@@ -36,15 +36,37 @@ extern "C" {
 #include <stdarg.h>
 #endif
 
+#include "lws_config.h"
+
+#if defined(LWS_HAVE_SYS_TYPES_H) && !defined(LWS_PLAT_BAREMETAL)
+#include <sys/types.h>
+#endif
+#if defined(LWS_HAVE_NET_ETHERNET_H)
+#include <net/ethernet.h>
+#endif
+/* NetBSD */
+#if defined(LWS_HAVE_NET_IF_ETHER_H)
+#include <net/if_ether.h>
+#endif
+#if defined(_WIN32) && !defined(ETHER_ADDR_LEN)
+#define ETHER_ADDR_LEN 6
+#endif
+#if defined (__sun)
+	#include <sys/ethernet.h>
+	#if !defined(ETHER_ADDR_LEN) && defined(ETHERADDRL)
+		#define ETHER_ADDR_LEN ETHERADDRL
+	#endif
+#endif
+#define LWS_ETHER_ADDR_LEN ETHER_ADDR_LEN
+
+#include <stddef.h>
 #include <string.h>
 #include <stdlib.h>
 
-#include "lws_config.h"
 
 /* place for one-shot opaque forward references */
 
 typedef struct lws_context * lws_ctx_t;
-struct lws_sequencer;
 struct lws_dsh;
 
 /*
@@ -64,6 +86,8 @@ struct lws_dsh;
 
 #define LWS_US_TO_MS(x) ((x + (LWS_US_PER_MS / 2)) / LWS_US_PER_MS)
 
+#define LWS_FOURCC(a, b, c, d) ((a << 24) | (b << 16) | (c << 8) | d)
+
 #if defined(LWS_HAS_INTPTR_T)
 #include <stdint.h>
 #define lws_intptr_t intptr_t
@@ -88,8 +112,8 @@ typedef unsigned long long lws_intptr_t;
 #define O_RDONLY	_O_RDONLY
 #endif
 
-typedef int uid_t;
-typedef int gid_t;
+typedef unsigned int uid_t;
+typedef unsigned int gid_t;
 typedef unsigned short sa_family_t;
 #if !defined(LWS_HAVE_SUSECONDS_T)
 typedef unsigned int useconds_t;
@@ -121,39 +145,46 @@ typedef int suseconds_t;
 #define LWS_EXTERN
 #endif
 
-#if defined(__MINGW32__)
-#define LWS_INVALID_FILE -1
-#else
 #define LWS_INVALID_FILE INVALID_HANDLE_VALUE
-#endif
 #define LWS_SOCK_INVALID (INVALID_SOCKET)
 #define LWS_O_RDONLY _O_RDONLY
 #define LWS_O_WRONLY _O_WRONLY
 #define LWS_O_CREAT _O_CREAT
 #define LWS_O_TRUNC _O_TRUNC
 
-#ifndef __func__
+#if (__STDC_VERSION__ < 199901L) && !defined(__func__)
 #define __func__ __FUNCTION__
 #endif
 
+#define LWS_POSIX_LENGTH_CAST(x) (unsigned int)(x)
+
 #else /* NOT WIN32 */
 #include <unistd.h>
+
+#define LWS_POSIX_LENGTH_CAST(x) (x)
+
 #if defined(LWS_HAVE_SYS_CAPABILITY_H) && defined(LWS_HAVE_LIBCAP)
 #include <sys/capability.h>
 #endif
 
-#if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__QNX__) || defined(__OpenBSD__)
+#if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__QNX__) || defined(__OpenBSD__) || defined(__NuttX__)
 #include <sys/socket.h>
 #include <netinet/in.h>
 #endif
 
+/* Find ETHER_ADDR_LEN on OpenBSD */
+#if defined(__OpenBSD__)
+#include <net/if_arp.h>
+#include <netinet/if_ether.h>
+#endif
+
 #define LWS_INLINE inline
 #define LWS_O_RDONLY O_RDONLY
 #define LWS_O_WRONLY O_WRONLY
 #define LWS_O_CREAT O_CREAT
 #define LWS_O_TRUNC O_TRUNC
 
-#if !defined(LWS_PLAT_OPTEE) && !defined(OPTEE_TA) && !defined(LWS_PLAT_FREERTOS)
+#if !defined(LWS_PLAT_OPTEE) && !defined(OPTEE_TA) && !defined(LWS_PLAT_FREERTOS) && !defined(LWS_PLAT_BAREMETAL)
 #include <poll.h>
 #include <netdb.h>
 #define LWS_INVALID_FILE -1
@@ -202,6 +233,7 @@ typedef int suseconds_t;
 #endif /* not shared */
 
 #define LWS_WARN_DEPRECATED __attribute__ ((deprecated))
+#undef printf
 #define LWS_FORMAT(string_index) __attribute__ ((format(printf, string_index, string_index+1)))
 #else /* not GNUC */
 
@@ -283,6 +315,7 @@ typedef int suseconds_t;
 #define MBEDTLS_CONFIG_FILE <mbedtls/esp_config.h>
 #endif
 #endif
+
 #if defined(LWS_WITH_TLS)
 #include <mbedtls/ssl.h>
 #include <mbedtls/entropy.h>
@@ -386,6 +419,9 @@ struct lws;
 /* File operations stuff exists */
 #define LWS_FEATURE_FOPS
 
+/* Mounts have extra no_cache member */
+#define LWS_FEATURE_MOUNT_NO_CACHE
+
 
 #if defined(_WIN32)
 #if !defined(LWS_WIN32_HANDLE_TYPES)
@@ -573,6 +609,25 @@ struct lws_pollargs {
 	int prev_events;	/**< the previous event mask */
 };
 
+#if !defined(LWS_SIZEOFPTR)
+#define LWS_SIZEOFPTR ((int)sizeof (void *))
+#endif
+
+#if defined(__x86_64__)
+#define _LWS_PAD_SIZE 16	/* Intel recommended for best performance */
+#else
+#define _LWS_PAD_SIZE LWS_SIZEOFPTR   /* Size of a pointer on the target arch */
+#endif
+#define _LWS_PAD(n) (((n) % _LWS_PAD_SIZE) ? \
+		((n) + (_LWS_PAD_SIZE - ((n) % _LWS_PAD_SIZE))) : (n))
+/* last 2 is for lws-meta */
+#define LWS_PRE _LWS_PAD(4 + 10 + 2)
+/* used prior to 1.7 and retained for backward compatibility */
+#define LWS_SEND_BUFFER_PRE_PADDING LWS_PRE
+#define LWS_SEND_BUFFER_POST_PADDING 0
+
+
+
 struct lws_extension; /* needed even with ws exts disabled for create context */
 struct lws_token_limits;
 struct lws_protocols;
@@ -581,10 +636,68 @@ struct lws_tokens;
 struct lws_vhost;
 struct lws;
 
+/* Generic stateful operation return codes */
+
+typedef enum {
+	LWS_SRET_OK		= 0,
+	LWS_SRET_WANT_INPUT     = (1 << 16),
+	LWS_SRET_WANT_OUTPUT    = (1 << 17),
+	LWS_SRET_FATAL          = (1 << 18),
+	LWS_SRET_NO_FURTHER_IN  = (1 << 19),
+	LWS_SRET_NO_FURTHER_OUT = (1 << 20),
+	LWS_SRET_AWAIT_RETRY    = (1 << 21),
+	LWS_SRET_YIELD          = (1 << 22), /* return to the event loop and continue */
+} lws_stateful_ret_t;
+
+typedef struct lws_fixed3232 {
+	int32_t		whole;	/* signed 32-bit int */
+	int32_t		frac;	/* signed frac proportion from 0 to (100M - 1) */
+} lws_fx_t;
+
+#define LWS_FX_FRACTION_MSD 100000000
+#define lws_neg(a) (a->whole < 0 || a->frac < 0)
+#define lws_fx_set(a, x, y) { a.whole = x; a.frac = x < 0 ? -y : y; }
+#define lws_fix64(a) (((int64_t)a->whole << 32) + \
+		(((1ll << 32) * (a->frac < 0 ? -a->frac : a->frac)) / LWS_FX_FRACTION_MSD))
+#define lws_fix64_abs(a) \
+	((((int64_t)(a->whole < 0 ? (-a->whole) : a->whole) << 32) + \
+			(((1ll << 32) * (a->frac < 0 ? -a->frac : a->frac)) / LWS_FX_FRACTION_MSD)))
+
+#define lws_fix3232(a, a64) { a->whole = (int32_t)(a64 >> 32); \
+			      a->frac = (int32_t)((100000000 * (a64 & 0xffffffff)) >> 32); }
+
+LWS_VISIBLE LWS_EXTERN const lws_fx_t *
+lws_fx_add(lws_fx_t *r, const lws_fx_t *a, const lws_fx_t *b);
+
+LWS_VISIBLE LWS_EXTERN const lws_fx_t *
+lws_fx_sub(lws_fx_t *r, const lws_fx_t *a, const lws_fx_t *b);
+
+LWS_VISIBLE LWS_EXTERN const lws_fx_t *
+lws_fx_mul(lws_fx_t *r, const lws_fx_t *a, const lws_fx_t *b);
+
+LWS_VISIBLE LWS_EXTERN const lws_fx_t *
+lws_fx_div(lws_fx_t *r, const lws_fx_t *a, const lws_fx_t *b);
+
+LWS_VISIBLE LWS_EXTERN const lws_fx_t *
+lws_fx_sqrt(lws_fx_t *r, const lws_fx_t *a);
+
+LWS_VISIBLE LWS_EXTERN int
+lws_fx_comp(const lws_fx_t *a, const lws_fx_t *b);
+
+LWS_VISIBLE LWS_EXTERN int
+lws_fx_roundup(const lws_fx_t *a);
+
+LWS_VISIBLE LWS_EXTERN int
+lws_fx_rounddown(const lws_fx_t *a);
+
+LWS_VISIBLE LWS_EXTERN const char *
+lws_fx_string(const lws_fx_t *a, char *buf, size_t size);
+
 #include <libwebsockets/lws-dll2.h>
 #include <libwebsockets/lws-map.h>
 
 #include <libwebsockets/lws-fault-injection.h>
+#include <libwebsockets/lws-backtrace.h>
 #include <libwebsockets/lws-timeout-timer.h>
 #include <libwebsockets/lws-cache-ttl.h>
 #if defined(LWS_WITH_SYS_SMD)
@@ -592,18 +705,27 @@ struct lws;
 #endif
 #include <libwebsockets/lws-state.h>
 #include <libwebsockets/lws-retry.h>
+#if defined(LWS_WITH_NETWORK)
 #include <libwebsockets/lws-adopt.h>
 #include <libwebsockets/lws-network-helper.h>
 #include <libwebsockets/lws-metrics.h>
+#endif
+
+#include <libwebsockets/lws-ota.h>
 #include <libwebsockets/lws-system.h>
-#include <libwebsockets/lws-ws-close.h>
 #include <libwebsockets/lws-callbacks.h>
+
+#if defined(LWS_WITH_NETWORK)
+#include <libwebsockets/lws-ws-close.h>
 #include <libwebsockets/lws-ws-state.h>
 #include <libwebsockets/lws-ws-ext.h>
+#endif
+
 #include <libwebsockets/lws-protocols-plugins.h>
 
 #include <libwebsockets/lws-context-vhost.h>
 
+#if defined(LWS_WITH_NETWORK)
 #if defined(LWS_WITH_CONMON)
 #include <libwebsockets/lws-conmon.h>
 #endif
@@ -614,16 +736,21 @@ struct lws;
 #include <libwebsockets/lws-client.h>
 #include <libwebsockets/lws-http.h>
 #include <libwebsockets/lws-spa.h>
+#endif
 #include <libwebsockets/lws-purify.h>
 #include <libwebsockets/lws-misc.h>
 #include <libwebsockets/lws-dsh.h>
+#if defined(LWS_WITH_NETWORK)
 #include <libwebsockets/lws-service.h>
 #include <libwebsockets/lws-write.h>
 #include <libwebsockets/lws-writeable.h>
+#endif
 #include <libwebsockets/lws-ring.h>
 #include <libwebsockets/lws-sha1-base64.h>
 #include <libwebsockets/lws-x509.h>
+#if defined(LWS_WITH_NETWORK)
 #include <libwebsockets/lws-cgi.h>
+#endif
 #if defined(LWS_WITH_FILE_OPS)
 #include <libwebsockets/lws-vfs.h>
 #endif
@@ -638,16 +765,13 @@ struct lws;
 #include <libwebsockets/lws-lwsac.h>
 #include <libwebsockets/lws-fts.h>
 #include <libwebsockets/lws-diskcache.h>
-#include <libwebsockets/lws-sequencer.h>
 #include <libwebsockets/lws-secure-streams.h>
+#include <libwebsockets/lws-secure-streams-serialization.h>
 #include <libwebsockets/lws-secure-streams-policy.h>
 #include <libwebsockets/lws-secure-streams-client.h>
+#include <libwebsockets/lws-secure-streams-transport-proxy.h>
+#include <libwebsockets/lws-jrpc.h>
 
-#if !defined(LWS_PLAT_FREERTOS)
-#include <libwebsockets/abstract/abstract.h>
-
-#include <libwebsockets/lws-test-sequencer.h>
-#endif
 #include <libwebsockets/lws-async-dns.h>
 
 #if defined(LWS_WITH_TLS)
@@ -673,20 +797,35 @@ struct lws;
 
 #endif
 
+#if defined(LWS_WITH_NETWORK)
 #include <libwebsockets/lws-eventlib-exports.h>
+#endif
 #include <libwebsockets/lws-i2c.h>
 #include <libwebsockets/lws-spi.h>
+#if defined(LWS_ESP_PLATFORM)
+#include <libwebsockets/lws-esp32-spi.h>
+#endif
 #include <libwebsockets/lws-gpio.h>
 #include <libwebsockets/lws-bb-i2c.h>
 #include <libwebsockets/lws-bb-spi.h>
 #include <libwebsockets/lws-button.h>
 #include <libwebsockets/lws-led.h>
 #include <libwebsockets/lws-pwm.h>
+#include <libwebsockets/lws-upng.h>
+#include <libwebsockets/lws-jpeg.h>
 #include <libwebsockets/lws-display.h>
+#include <libwebsockets/lws-dlo.h>
 #include <libwebsockets/lws-ssd1306-i2c.h>
 #include <libwebsockets/lws-ili9341-spi.h>
+#include <libwebsockets/lws-spd1656-spi.h>
+#include <libwebsockets/lws-uc8176-spi.h>
+#include <libwebsockets/lws-ssd1675b-spi.h>
 #include <libwebsockets/lws-settings.h>
+#if defined(LWS_WITH_NETWORK)
 #include <libwebsockets/lws-netdev.h>
+#endif
+
+#include <libwebsockets/lws-html.h>
 
 #ifdef __cplusplus
 }