From a2c9aade9c3c5a00d4a3d4e88daaec3cca981198 Mon Sep 17 00:00:00 2001 From: bri3d Date: Sun, 11 Dec 2022 15:09:06 -0700 Subject: [PATCH 1/7] add libspng 0.7.3 --- jni/libspng/spng.c | 6979 ++++++++++++++++++++++++++++++++++++++++++++ jni/libspng/spng.h | 537 ++++ 2 files changed, 7516 insertions(+) create mode 100644 jni/libspng/spng.c create mode 100644 jni/libspng/spng.h diff --git a/jni/libspng/spng.c b/jni/libspng/spng.c new file mode 100644 index 0000000..f88492b --- /dev/null +++ b/jni/libspng/spng.c @@ -0,0 +1,6979 @@ +/* SPDX-License-Identifier: (BSD-2-Clause AND libpng-2.0) */ + +#define SPNG__BUILD + +#include "spng.h" + +#include +#include +#include +#include + +#define ZLIB_CONST + +#ifdef __FRAMAC__ + #define SPNG_DISABLE_OPT + #include "tests/framac_stubs.h" +#else + #ifdef SPNG_USE_MINIZ + #include + #else + #include + #endif +#endif + +#ifdef SPNG_MULTITHREADING + #include +#endif + +/* Not build options, edit at your own risk! */ +#define SPNG_READ_SIZE (8192) +#define SPNG_WRITE_SIZE SPNG_READ_SIZE +#define SPNG_MAX_CHUNK_COUNT (1000) + +#define SPNG_TARGET_CLONES(x) + +#ifndef SPNG_DISABLE_OPT + + #if defined(__i386__) || defined(__x86_64__) || defined(_M_IX86) || defined(_M_X64) + #define SPNG_X86 + + #if defined(__x86_64__) || defined(_M_X64) + #define SPNG_X86_64 + #endif + + #elif defined(__aarch64__) || defined(_M_ARM64) /* || defined(__ARM_NEON) */ + #define SPNG_ARM /* NOTE: only arm64 builds are tested! */ + #else + #pragma message "disabling SIMD optimizations for unknown target" + #define SPNG_DISABLE_OPT + #endif + + #if defined(SPNG_X86_64) && defined(SPNG_ENABLE_TARGET_CLONES) + #undef SPNG_TARGET_CLONES + #define SPNG_TARGET_CLONES(x) __attribute__((target_clones(x))) + #else + #define SPNG_TARGET_CLONES(x) + #endif + + #ifndef SPNG_DISABLE_OPT + static void defilter_sub3(size_t rowbytes, unsigned char *row); + static void defilter_sub4(size_t rowbytes, unsigned char *row); + static void defilter_avg3(size_t rowbytes, unsigned char *row, const unsigned char *prev); + static void defilter_avg4(size_t rowbytes, unsigned char *row, const unsigned char *prev); + static void defilter_paeth3(size_t rowbytes, unsigned char *row, const unsigned char *prev); + static void defilter_paeth4(size_t rowbytes, unsigned char *row, const unsigned char *prev); + + #if defined(SPNG_ARM) + static uint32_t expand_palette_rgba8_neon(unsigned char *row, const unsigned char *scanline, const unsigned char *plte, uint32_t width); + static uint32_t expand_palette_rgb8_neon(unsigned char *row, const unsigned char *scanline, const unsigned char *plte, uint32_t width); + #endif + #endif +#endif + +#if defined(_MSC_VER) + #pragma warning(push) + #pragma warning(disable: 4244) +#endif + +#if (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) || defined(__BIG_ENDIAN__) + #define SPNG_BIG_ENDIAN +#else + #define SPNG_LITTLE_ENDIAN +#endif + +enum spng_state +{ + SPNG_STATE_INVALID = 0, + SPNG_STATE_INIT = 1, /* No PNG buffer/stream is set */ + SPNG_STATE_INPUT, /* Decoder input PNG was set */ + SPNG_STATE_OUTPUT = SPNG_STATE_INPUT, /* Encoder output was set */ + SPNG_STATE_IHDR, /* IHDR was read/written */ + SPNG_STATE_FIRST_IDAT, /* Encoded up to / reached first IDAT */ + SPNG_STATE_DECODE_INIT, /* Decoder is ready for progressive reads */ + SPNG_STATE_ENCODE_INIT = SPNG_STATE_DECODE_INIT, + SPNG_STATE_EOI, /* Reached the last scanline/row */ + SPNG_STATE_LAST_IDAT, /* Reached last IDAT, set at end of decode_image() */ + SPNG_STATE_AFTER_IDAT, /* */ + SPNG_STATE_IEND, /* Reached IEND */ +}; + +enum spng__internal +{ + SPNG__IO_SIGNAL = 1 << 9, + SPNG__CTX_FLAGS_ALL = (SPNG_CTX_IGNORE_ADLER32 | SPNG_CTX_ENCODER) +}; + +#define SPNG_STR(x) _SPNG_STR(x) +#define _SPNG_STR(x) #x + +#define SPNG_VERSION_STRING SPNG_STR(SPNG_VERSION_MAJOR) "." \ + SPNG_STR(SPNG_VERSION_MINOR) "." \ + SPNG_STR(SPNG_VERSION_PATCH) + +#define SPNG_GET_CHUNK_BOILERPLATE(chunk) \ + if(ctx == NULL) return 1; \ + int ret = read_chunks(ctx, 0); \ + if(ret) return ret; \ + if(!ctx->stored.chunk) return SPNG_ECHUNKAVAIL; \ + if(chunk == NULL) return 1 + +#define SPNG_SET_CHUNK_BOILERPLATE(chunk) \ + if(ctx == NULL || chunk == NULL) return 1; \ + if(ctx->data == NULL && !ctx->encode_only) return SPNG_ENOSRC; \ + int ret = read_chunks(ctx, 0); \ + if(ret) return ret + +/* Determine if the spng_option can be overriden/optimized */ +#define spng__optimize(option) (ctx->optimize_option & (1 << option)) + +struct spng_subimage +{ + uint32_t width; + uint32_t height; + size_t out_width; /* byte width based on output format */ + size_t scanline_width; +}; + +struct spng_text2 +{ + int type; + char *keyword; + char *text; + + size_t text_length; + + uint8_t compression_flag; /* iTXt only */ + char *language_tag; /* iTXt only */ + char *translated_keyword; /* iTXt only */ + + size_t cache_usage; + char user_keyword_storage[80]; +}; + +struct decode_flags +{ + unsigned apply_trns: 1; + unsigned apply_gamma: 1; + unsigned use_sbit: 1; + unsigned indexed: 1; + unsigned do_scaling: 1; + unsigned interlaced: 1; + unsigned same_layout: 1; + unsigned zerocopy: 1; + unsigned unpack: 1; +}; + +struct encode_flags +{ + unsigned interlace: 1; + unsigned same_layout: 1; + unsigned to_bigendian: 1; + unsigned progressive: 1; + unsigned finalize: 1; + + enum spng_filter_choice filter_choice; +}; + +struct spng_chunk_bitfield +{ + unsigned ihdr: 1; + unsigned plte: 1; + unsigned chrm: 1; + unsigned iccp: 1; + unsigned gama: 1; + unsigned sbit: 1; + unsigned srgb: 1; + unsigned text: 1; + unsigned bkgd: 1; + unsigned hist: 1; + unsigned trns: 1; + unsigned phys: 1; + unsigned splt: 1; + unsigned time: 1; + unsigned offs: 1; + unsigned exif: 1; + unsigned unknown: 1; +}; + +/* Packed sample iterator */ +struct spng__iter +{ + const uint8_t mask; + unsigned shift_amount; + const unsigned initial_shift, bit_depth; + const unsigned char *samples; +}; + +union spng__decode_plte +{ + struct spng_plte_entry rgba[256]; + unsigned char rgb[256 * 3]; + unsigned char raw[256 * 4]; + uint32_t align_this; +}; + +struct spng__zlib_options +{ + int compression_level; + int window_bits; + int mem_level; + int strategy; + int data_type; +}; + +typedef void spng__undo(spng_ctx *ctx); + +struct spng_ctx +{ + size_t data_size; + size_t bytes_read; + size_t stream_buf_size; + unsigned char *stream_buf; + const unsigned char *data; + + /* User-defined pointers for streaming */ + spng_read_fn *read_fn; + spng_write_fn *write_fn; + void *stream_user_ptr; + + /* Used for buffer reads */ + const unsigned char *png_base; + size_t bytes_left; + size_t last_read_size; + + /* Used for encoding */ + int user_owns_out_png; + unsigned char *out_png; + unsigned char *write_ptr; + size_t out_png_size; + size_t bytes_encoded; + + /* These are updated by read/write_header()/read_chunk_bytes() */ + struct spng_chunk current_chunk; + uint32_t cur_chunk_bytes_left; + uint32_t cur_actual_crc; + + struct spng_alloc alloc; + + enum spng_ctx_flags flags; + enum spng_format fmt; + + enum spng_state state; + + unsigned streaming: 1; + unsigned internal_buffer: 1; /* encoding to internal buffer */ + + unsigned inflate: 1; + unsigned deflate: 1; + unsigned encode_only: 1; + unsigned strict: 1; + unsigned discard: 1; + unsigned skip_crc: 1; + unsigned keep_unknown: 1; + unsigned prev_was_idat: 1; + + struct spng__zlib_options image_options; + struct spng__zlib_options text_options; + + spng__undo *undo; + + /* input file contains this chunk */ + struct spng_chunk_bitfield file; + + /* chunk was stored with spng_set_*() */ + struct spng_chunk_bitfield user; + + /* chunk was stored by reading or with spng_set_*() */ + struct spng_chunk_bitfield stored; + + /* used to reset the above in case of an error */ + struct spng_chunk_bitfield prev_stored; + + struct spng_chunk first_idat, last_idat; + + uint32_t max_width, max_height; + + size_t max_chunk_size; + size_t chunk_cache_limit; + size_t chunk_cache_usage; + uint32_t chunk_count_limit; + uint32_t chunk_count_total; + + int crc_action_critical; + int crc_action_ancillary; + + uint32_t optimize_option; + + struct spng_ihdr ihdr; + + struct spng_plte plte; + + struct spng_chrm_int chrm_int; + struct spng_iccp iccp; + + uint32_t gama; + + struct spng_sbit sbit; + + uint8_t srgb_rendering_intent; + + uint32_t n_text; + struct spng_text2 *text_list; + + struct spng_bkgd bkgd; + struct spng_hist hist; + struct spng_trns trns; + struct spng_phys phys; + + uint32_t n_splt; + struct spng_splt *splt_list; + + struct spng_time time; + struct spng_offs offs; + struct spng_exif exif; + + uint32_t n_chunks; + struct spng_unknown_chunk *chunk_list; + + struct spng_subimage subimage[7]; + + z_stream zstream; + unsigned char *scanline_buf, *prev_scanline_buf, *row_buf, *filtered_scanline_buf; + unsigned char *scanline, *prev_scanline, *row, *filtered_scanline; + + /* based on fmt */ + size_t image_size; /* may be zero */ + size_t image_width; + + unsigned bytes_per_pixel; /* derived from ihdr */ + unsigned pixel_size; /* derived from spng_format+ihdr */ + int widest_pass; + int last_pass; /* last non-empty pass */ + + uint16_t *gamma_lut; /* points to either _lut8 or _lut16 */ + uint16_t *gamma_lut16; + uint16_t gamma_lut8[256]; + unsigned char trns_px[8]; + union spng__decode_plte decode_plte; + struct spng_sbit decode_sb; + struct decode_flags decode_flags; + struct spng_row_info row_info; + + struct encode_flags encode_flags; +}; + +static const uint32_t spng_u32max = INT32_MAX; + +static const uint32_t adam7_x_start[7] = { 0, 4, 0, 2, 0, 1, 0 }; +static const uint32_t adam7_y_start[7] = { 0, 0, 4, 0, 2, 0, 1 }; +static const uint32_t adam7_x_delta[7] = { 8, 8, 4, 4, 2, 2, 1 }; +static const uint32_t adam7_y_delta[7] = { 8, 8, 8, 4, 4, 2, 2 }; + +static const uint8_t spng_signature[8] = { 137, 80, 78, 71, 13, 10, 26, 10 }; + +static const uint8_t type_ihdr[4] = { 73, 72, 68, 82 }; +static const uint8_t type_plte[4] = { 80, 76, 84, 69 }; +static const uint8_t type_idat[4] = { 73, 68, 65, 84 }; +static const uint8_t type_iend[4] = { 73, 69, 78, 68 }; + +static const uint8_t type_trns[4] = { 116, 82, 78, 83 }; +static const uint8_t type_chrm[4] = { 99, 72, 82, 77 }; +static const uint8_t type_gama[4] = { 103, 65, 77, 65 }; +static const uint8_t type_iccp[4] = { 105, 67, 67, 80 }; +static const uint8_t type_sbit[4] = { 115, 66, 73, 84 }; +static const uint8_t type_srgb[4] = { 115, 82, 71, 66 }; +static const uint8_t type_text[4] = { 116, 69, 88, 116 }; +static const uint8_t type_ztxt[4] = { 122, 84, 88, 116 }; +static const uint8_t type_itxt[4] = { 105, 84, 88, 116 }; +static const uint8_t type_bkgd[4] = { 98, 75, 71, 68 }; +static const uint8_t type_hist[4] = { 104, 73, 83, 84 }; +static const uint8_t type_phys[4] = { 112, 72, 89, 115 }; +static const uint8_t type_splt[4] = { 115, 80, 76, 84 }; +static const uint8_t type_time[4] = { 116, 73, 77, 69 }; + +static const uint8_t type_offs[4] = { 111, 70, 70, 115 }; +static const uint8_t type_exif[4] = { 101, 88, 73, 102 }; + +static inline void *spng__malloc(spng_ctx *ctx, size_t size) +{ + return ctx->alloc.malloc_fn(size); +} + +static inline void *spng__calloc(spng_ctx *ctx, size_t nmemb, size_t size) +{ + return ctx->alloc.calloc_fn(nmemb, size); +} + +static inline void *spng__realloc(spng_ctx *ctx, void *ptr, size_t size) +{ + return ctx->alloc.realloc_fn(ptr, size); +} + +static inline void spng__free(spng_ctx *ctx, void *ptr) +{ + ctx->alloc.free_fn(ptr); +} + +#if defined(SPNG_USE_MINIZ) +static void *spng__zalloc(void *opaque, size_t items, size_t size) +#else +static void *spng__zalloc(void *opaque, uInt items, uInt size) +#endif +{ + spng_ctx *ctx = opaque; + + if(size > SIZE_MAX / items) return NULL; + + size_t len = (size_t)items * size; + + return spng__malloc(ctx, len); +} + +static void spng__zfree(void *opqaue, void *ptr) +{ + spng_ctx *ctx = opqaue; + spng__free(ctx, ptr); +} + +static inline uint16_t read_u16(const void *src) +{ + const unsigned char *data = src; + + return (data[0] & 0xFFU) << 8 | (data[1] & 0xFFU); +} + +static inline uint32_t read_u32(const void *src) +{ + const unsigned char *data = src; + + return (data[0] & 0xFFUL) << 24 | (data[1] & 0xFFUL) << 16 | + (data[2] & 0xFFUL) << 8 | (data[3] & 0xFFUL); +} + +static inline int32_t read_s32(const void *src) +{ + int32_t ret = (int32_t)read_u32(src); + + return ret; +} + +static inline void write_u16(void *dest, uint16_t x) +{ + unsigned char *data = dest; + + data[0] = x >> 8; + data[1] = x & 0xFF; +} + +static inline void write_u32(void *dest, uint32_t x) +{ + unsigned char *data = dest; + + data[0] = (x >> 24); + data[1] = (x >> 16) & 0xFF; + data[2] = (x >> 8) & 0xFF; + data[3] = x & 0xFF; +} + +static inline void write_s32(void *dest, int32_t x) +{ + uint32_t n = x; + write_u32(dest, n); +} + +/* Returns an iterator for 1,2,4,8-bit samples */ +static struct spng__iter spng__iter_init(unsigned bit_depth, const unsigned char *samples) +{ + struct spng__iter iter = + { + .mask = (uint32_t)(1 << bit_depth) - 1, + .shift_amount = 8 - bit_depth, + .initial_shift = 8 - bit_depth, + .bit_depth = bit_depth, + .samples = samples + }; + + return iter; +} + +/* Returns the current sample unpacked, iterates to the next one */ +static inline uint8_t get_sample(struct spng__iter *iter) +{ + uint8_t x = (iter->samples[0] >> iter->shift_amount) & iter->mask; + + iter->shift_amount -= iter->bit_depth; + + if(iter->shift_amount > 7) + { + iter->shift_amount = iter->initial_shift; + iter->samples++; + } + + return x; +} + +static void u16_row_to_host(void *row, size_t size) +{ + uint16_t *px = row; + size_t i, n = size / 2; + + for(i=0; i < n; i++) + { + px[i] = read_u16(&px[i]); + } +} + +static void u16_row_to_bigendian(void *row, size_t size) +{ + uint16_t *px = (uint16_t*)row; + size_t i, n = size / 2; + + for(i=0; i < n; i++) + { + write_u16(&px[i], px[i]); + } +} + +static void rgb8_row_to_rgba8(const unsigned char *row, unsigned char *out, uint32_t n) +{ + uint32_t i; + for(i=0; i < n; i++) + { + memcpy(out + i * 4, row + i * 3, 3); + out[i*4+3] = 255; + } +} + +static unsigned num_channels(const struct spng_ihdr *ihdr) +{ + switch(ihdr->color_type) + { + case SPNG_COLOR_TYPE_TRUECOLOR: return 3; + case SPNG_COLOR_TYPE_GRAYSCALE_ALPHA: return 2; + case SPNG_COLOR_TYPE_TRUECOLOR_ALPHA: return 4; + case SPNG_COLOR_TYPE_GRAYSCALE: + case SPNG_COLOR_TYPE_INDEXED: + return 1; + default: return 0; + } +} + +/* Calculate scanline width in bits, round up to the nearest byte */ +static int calculate_scanline_width(const struct spng_ihdr *ihdr, uint32_t width, size_t *scanline_width) +{ + if(ihdr == NULL || !width) return SPNG_EINTERNAL; + + size_t res = num_channels(ihdr) * ihdr->bit_depth; + + if(res > SIZE_MAX / width) return SPNG_EOVERFLOW; + res = res * width; + + res += 15; /* Filter byte + 7 for rounding */ + + if(res < 15) return SPNG_EOVERFLOW; + + res /= 8; + + if(res > UINT32_MAX) return SPNG_EOVERFLOW; + + *scanline_width = res; + + return 0; +} + +static int calculate_subimages(struct spng_ctx *ctx) +{ + if(ctx == NULL) return SPNG_EINTERNAL; + + struct spng_ihdr *ihdr = &ctx->ihdr; + struct spng_subimage *sub = ctx->subimage; + + if(ihdr->interlace_method == 1) + { + sub[0].width = (ihdr->width + 7) >> 3; + sub[0].height = (ihdr->height + 7) >> 3; + sub[1].width = (ihdr->width + 3) >> 3; + sub[1].height = (ihdr->height + 7) >> 3; + sub[2].width = (ihdr->width + 3) >> 2; + sub[2].height = (ihdr->height + 3) >> 3; + sub[3].width = (ihdr->width + 1) >> 2; + sub[3].height = (ihdr->height + 3) >> 2; + sub[4].width = (ihdr->width + 1) >> 1; + sub[4].height = (ihdr->height + 1) >> 2; + sub[5].width = ihdr->width >> 1; + sub[5].height = (ihdr->height + 1) >> 1; + sub[6].width = ihdr->width; + sub[6].height = ihdr->height >> 1; + } + else + { + sub[0].width = ihdr->width; + sub[0].height = ihdr->height; + } + + int i; + for(i=0; i < 7; i++) + { + if(sub[i].width == 0 || sub[i].height == 0) continue; + + int ret = calculate_scanline_width(ihdr, sub[i].width, &sub[i].scanline_width); + if(ret) return ret; + + if(sub[ctx->widest_pass].scanline_width < sub[i].scanline_width) ctx->widest_pass = i; + + ctx->last_pass = i; + } + + return 0; +} + +static int check_decode_fmt(const struct spng_ihdr *ihdr, const int fmt) +{ + switch(fmt) + { + case SPNG_FMT_RGBA8: + case SPNG_FMT_RGBA16: + case SPNG_FMT_RGB8: + case SPNG_FMT_PNG: + case SPNG_FMT_RAW: + return 0; + case SPNG_FMT_G8: + case SPNG_FMT_GA8: + if(ihdr->color_type == SPNG_COLOR_TYPE_GRAYSCALE && ihdr->bit_depth <= 8) return 0; + else return SPNG_EFMT; + case SPNG_FMT_GA16: + if(ihdr->color_type == SPNG_COLOR_TYPE_GRAYSCALE && ihdr->bit_depth == 16) return 0; + else return SPNG_EFMT; + default: return SPNG_EFMT; + } +} + +static int calculate_image_width(const struct spng_ihdr *ihdr, int fmt, size_t *len) +{ + if(ihdr == NULL || len == NULL) return SPNG_EINTERNAL; + + size_t res = ihdr->width; + unsigned bytes_per_pixel; + + switch(fmt) + { + case SPNG_FMT_RGBA8: + case SPNG_FMT_GA16: + bytes_per_pixel = 4; + break; + case SPNG_FMT_RGBA16: + bytes_per_pixel = 8; + break; + case SPNG_FMT_RGB8: + bytes_per_pixel = 3; + break; + case SPNG_FMT_PNG: + case SPNG_FMT_RAW: + { + int ret = calculate_scanline_width(ihdr, ihdr->width, &res); + if(ret) return ret; + + res -= 1; /* exclude filter byte */ + bytes_per_pixel = 1; + break; + } + case SPNG_FMT_G8: + bytes_per_pixel = 1; + break; + case SPNG_FMT_GA8: + bytes_per_pixel = 2; + break; + default: return SPNG_EINTERNAL; + } + + if(res > SIZE_MAX / bytes_per_pixel) return SPNG_EOVERFLOW; + res = res * bytes_per_pixel; + + *len = res; + + return 0; +} + +static int calculate_image_size(const struct spng_ihdr *ihdr, int fmt, size_t *len) +{ + if(ihdr == NULL || len == NULL) return SPNG_EINTERNAL; + + size_t res = 0; + + int ret = calculate_image_width(ihdr, fmt, &res); + if(ret) return ret; + + if(res > SIZE_MAX / ihdr->height) return SPNG_EOVERFLOW; + res = res * ihdr->height; + + *len = res; + + return 0; +} + +static int increase_cache_usage(spng_ctx *ctx, size_t bytes, int new_chunk) +{ + if(ctx == NULL || !bytes) return SPNG_EINTERNAL; + + if(new_chunk) + { + ctx->chunk_count_total++; + if(ctx->chunk_count_total < 1) return SPNG_EOVERFLOW; + + if(ctx->chunk_count_total > ctx->chunk_count_limit) return SPNG_ECHUNK_LIMITS; + } + + size_t new_usage = ctx->chunk_cache_usage + bytes; + + if(new_usage < ctx->chunk_cache_usage) return SPNG_EOVERFLOW; + + if(new_usage > ctx->chunk_cache_limit) return SPNG_ECHUNK_LIMITS; + + ctx->chunk_cache_usage = new_usage; + + return 0; +} + +static int decrease_cache_usage(spng_ctx *ctx, size_t usage) +{ + if(ctx == NULL || !usage) return SPNG_EINTERNAL; + if(usage > ctx->chunk_cache_usage) return SPNG_EINTERNAL; + + ctx->chunk_cache_usage -= usage; + + return 0; +} + +static int is_critical_chunk(struct spng_chunk *chunk) +{ + if(chunk == NULL) return 0; + if((chunk->type[0] & (1 << 5)) == 0) return 1; + + return 0; +} + +static int decode_err(spng_ctx *ctx, int err) +{ + ctx->state = SPNG_STATE_INVALID; + + return err; +} + +static int encode_err(spng_ctx *ctx, int err) +{ + ctx->state = SPNG_STATE_INVALID; + + return err; +} + +static inline int read_data(spng_ctx *ctx, size_t bytes) +{ + if(ctx == NULL) return SPNG_EINTERNAL; + if(!bytes) return 0; + + if(ctx->streaming && (bytes > SPNG_READ_SIZE)) return SPNG_EINTERNAL; + + int ret = ctx->read_fn(ctx, ctx->stream_user_ptr, ctx->stream_buf, bytes); + + if(ret) + { + if(ret > 0 || ret < SPNG_IO_ERROR) ret = SPNG_IO_ERROR; + + return ret; + } + + ctx->bytes_read += bytes; + if(ctx->bytes_read < bytes) return SPNG_EOVERFLOW; + + return 0; +} + +/* Ensure there is enough space for encoding starting at ctx->write_ptr */ +static int require_bytes(spng_ctx *ctx, size_t bytes) +{ + if(ctx == NULL) return SPNG_EINTERNAL; + + if(ctx->streaming) + { + if(bytes > ctx->stream_buf_size) + { + size_t new_size = ctx->stream_buf_size; + + /* Start at default IDAT size + header + crc */ + if(new_size < (SPNG_WRITE_SIZE + 12)) new_size = SPNG_WRITE_SIZE + 12; + + if(new_size < bytes) new_size = bytes; + + void *temp = spng__realloc(ctx, ctx->stream_buf, new_size); + + if(temp == NULL) return encode_err(ctx, SPNG_EMEM); + + ctx->stream_buf = temp; + ctx->stream_buf_size = bytes; + ctx->write_ptr = ctx->stream_buf; + } + + return 0; + } + + if(!ctx->internal_buffer) return SPNG_ENODST; + + size_t required = ctx->bytes_encoded + bytes; + if(required < bytes) return SPNG_EOVERFLOW; + + if(required > ctx->out_png_size) + { + size_t new_size = ctx->out_png_size; + + /* Start with a size that doesn't require a realloc() 100% of the time */ + if(new_size < (SPNG_WRITE_SIZE * 2)) new_size = SPNG_WRITE_SIZE * 2; + + /* Prefer the next power of two over the requested size */ + while(new_size < required) + { + if(new_size / SIZE_MAX > 2) return encode_err(ctx, SPNG_EOVERFLOW); + + new_size *= 2; + } + + void *temp = spng__realloc(ctx, ctx->out_png, new_size); + + if(temp == NULL) return encode_err(ctx, SPNG_EMEM); + + ctx->out_png = temp; + ctx->out_png_size = new_size; + ctx->write_ptr = ctx->out_png + ctx->bytes_encoded; + } + + return 0; +} + +static int write_data(spng_ctx *ctx, const void *data, size_t bytes) +{ + if(ctx == NULL) return SPNG_EINTERNAL; + if(!bytes) return 0; + + if(ctx->streaming) + { + if(bytes > SPNG_WRITE_SIZE) return SPNG_EINTERNAL; + + int ret = ctx->write_fn(ctx, ctx->stream_user_ptr, (void*)data, bytes); + + if(ret) + { + if(ret > 0 || ret < SPNG_IO_ERROR) ret = SPNG_IO_ERROR; + + return encode_err(ctx, ret); + } + } + else + { + int ret = require_bytes(ctx, bytes); + if(ret) return encode_err(ctx, ret); + + memcpy(ctx->write_ptr, data, bytes); + + ctx->write_ptr += bytes; + } + + ctx->bytes_encoded += bytes; + if(ctx->bytes_encoded < bytes) return SPNG_EOVERFLOW; + + return 0; +} + +static int write_header(spng_ctx *ctx, const uint8_t chunk_type[4], size_t chunk_length, unsigned char **data) +{ + if(ctx == NULL || chunk_type == NULL) return SPNG_EINTERNAL; + if(chunk_length > spng_u32max) return SPNG_EINTERNAL; + + size_t total = chunk_length + 12; + + int ret = require_bytes(ctx, total); + if(ret) return ret; + + uint32_t crc = crc32(0, NULL, 0); + ctx->current_chunk.crc = crc32(crc, chunk_type, 4); + + memcpy(&ctx->current_chunk.type, chunk_type, 4); + ctx->current_chunk.length = (uint32_t)chunk_length; + + if(!data) return SPNG_EINTERNAL; + + if(ctx->streaming) *data = ctx->stream_buf + 8; + else *data = ctx->write_ptr + 8; + + return 0; +} + +static int trim_chunk(spng_ctx *ctx, uint32_t length) +{ + if(length > spng_u32max) return SPNG_EINTERNAL; + if(length > ctx->current_chunk.length) return SPNG_EINTERNAL; + + ctx->current_chunk.length = length; + + return 0; +} + +static int finish_chunk(spng_ctx *ctx) +{ + if(ctx == NULL) return SPNG_EINTERNAL; + + struct spng_chunk *chunk = &ctx->current_chunk; + + unsigned char *header; + unsigned char *chunk_data; + + if(ctx->streaming) + { + chunk_data = ctx->stream_buf + 8; + header = ctx->stream_buf; + } + else + { + chunk_data = ctx->write_ptr + 8; + header = ctx->write_ptr; + } + + write_u32(header, chunk->length); + memcpy(header + 4, chunk->type, 4); + + chunk->crc = crc32(chunk->crc, chunk_data, chunk->length); + + write_u32(chunk_data + chunk->length, chunk->crc); + + if(ctx->streaming) + { + const unsigned char *ptr = ctx->stream_buf; + uint32_t bytes_left = chunk->length + 12; + uint32_t len = 0; + + while(bytes_left) + { + ptr += len; + len = SPNG_WRITE_SIZE; + + if(len > bytes_left) len = bytes_left; + + int ret = write_data(ctx, ptr, len); + if(ret) return ret; + + bytes_left -= len; + } + } + else + { + ctx->bytes_encoded += chunk->length; + if(ctx->bytes_encoded < chunk->length) return SPNG_EOVERFLOW; + + ctx->bytes_encoded += 12; + if(ctx->bytes_encoded < 12) return SPNG_EOVERFLOW; + + ctx->write_ptr += chunk->length + 12; + } + + return 0; +} + +static int write_chunk(spng_ctx *ctx, const uint8_t type[4], const void *data, size_t length) +{ + if(ctx == NULL || type == NULL) return SPNG_EINTERNAL; + if(length && data == NULL) return SPNG_EINTERNAL; + + unsigned char *write_ptr; + + int ret = write_header(ctx, type, length, &write_ptr); + if(ret) return ret; + + if(length) memcpy(write_ptr, data, length); + + return finish_chunk(ctx); +} + +static int write_iend(spng_ctx *ctx) +{ + unsigned char iend_chunk[12] = { 0, 0, 0, 0, 73, 69, 78, 68, 174, 66, 96, 130 }; + return write_data(ctx, iend_chunk, 12); +} + +static int write_unknown_chunks(spng_ctx *ctx, enum spng_location location) +{ + if(!ctx->stored.unknown) return 0; + + const struct spng_unknown_chunk *chunk = ctx->chunk_list; + + uint32_t i; + for(i=0; i < ctx->n_chunks; i++, chunk++) + { + if(chunk->location != location) continue; + + int ret = write_chunk(ctx, chunk->type, chunk->data, chunk->length); + if(ret) return ret; + } + + return 0; +} + +/* Read and check the current chunk's crc, + returns -SPNG_CRC_DISCARD if the chunk should be discarded */ +static inline int read_and_check_crc(spng_ctx *ctx) +{ + if(ctx == NULL) return SPNG_EINTERNAL; + + int ret; + ret = read_data(ctx, 4); + if(ret) return ret; + + ctx->current_chunk.crc = read_u32(ctx->data); + + if(ctx->skip_crc) return 0; + + if(ctx->cur_actual_crc != ctx->current_chunk.crc) + { + if(is_critical_chunk(&ctx->current_chunk)) + { + if(ctx->crc_action_critical == SPNG_CRC_USE) return 0; + } + else + { + if(ctx->crc_action_ancillary == SPNG_CRC_USE) return 0; + if(ctx->crc_action_ancillary == SPNG_CRC_DISCARD) return -SPNG_CRC_DISCARD; + } + + return SPNG_ECHUNK_CRC; + } + + return 0; +} + +/* Read and validate the current chunk's crc and the next chunk header */ +static inline int read_header(spng_ctx *ctx) +{ + if(ctx == NULL) return SPNG_EINTERNAL; + + int ret; + struct spng_chunk chunk = { 0 }; + + ret = read_and_check_crc(ctx); + if(ret) + { + if(ret == -SPNG_CRC_DISCARD) + { + ctx->discard = 1; + } + else return ret; + } + + ret = read_data(ctx, 8); + if(ret) return ret; + + chunk.offset = ctx->bytes_read - 8; + + chunk.length = read_u32(ctx->data); + + memcpy(&chunk.type, ctx->data + 4, 4); + + if(chunk.length > spng_u32max) return SPNG_ECHUNK_STDLEN; + + ctx->cur_chunk_bytes_left = chunk.length; + + if(is_critical_chunk(&chunk) && ctx->crc_action_critical == SPNG_CRC_USE) ctx->skip_crc = 1; + else if(ctx->crc_action_ancillary == SPNG_CRC_USE) ctx->skip_crc = 1; + else ctx->skip_crc = 0; + + if(!ctx->skip_crc) + { + ctx->cur_actual_crc = crc32(0, NULL, 0); + ctx->cur_actual_crc = crc32(ctx->cur_actual_crc, chunk.type, 4); + } + + ctx->current_chunk = chunk; + + return 0; +} + +/* Read chunk bytes and update crc */ +static int read_chunk_bytes(spng_ctx *ctx, uint32_t bytes) +{ + if(ctx == NULL) return SPNG_EINTERNAL; + if(!ctx->cur_chunk_bytes_left || !bytes) return SPNG_EINTERNAL; + if(bytes > ctx->cur_chunk_bytes_left) return SPNG_EINTERNAL; /* XXX: more specific error? */ + + int ret; + + ret = read_data(ctx, bytes); + if(ret) return ret; + + if(!ctx->skip_crc) ctx->cur_actual_crc = crc32(ctx->cur_actual_crc, ctx->data, bytes); + + ctx->cur_chunk_bytes_left -= bytes; + + return ret; +} + +/* read_chunk_bytes() + read_data() with custom output buffer */ +static int read_chunk_bytes2(spng_ctx *ctx, void *out, uint32_t bytes) +{ + if(ctx == NULL) return SPNG_EINTERNAL; + if(!ctx->cur_chunk_bytes_left || !bytes) return SPNG_EINTERNAL; + if(bytes > ctx->cur_chunk_bytes_left) return SPNG_EINTERNAL; /* XXX: more specific error? */ + + int ret; + uint32_t len = bytes; + + if(ctx->streaming && len > SPNG_READ_SIZE) len = SPNG_READ_SIZE; + + while(bytes) + { + if(len > bytes) len = bytes; + + ret = ctx->read_fn(ctx, ctx->stream_user_ptr, out, len); + if(ret) return ret; + + if(!ctx->streaming) memcpy(out, ctx->data, len); + + ctx->bytes_read += len; + if(ctx->bytes_read < len) return SPNG_EOVERFLOW; + + if(!ctx->skip_crc) ctx->cur_actual_crc = crc32(ctx->cur_actual_crc, out, len); + + ctx->cur_chunk_bytes_left -= len; + + out = (char*)out + len; + bytes -= len; + len = SPNG_READ_SIZE; + } + + return 0; +} + +static int discard_chunk_bytes(spng_ctx *ctx, uint32_t bytes) +{ + if(ctx == NULL) return SPNG_EINTERNAL; + if(!bytes) return 0; + + int ret; + + if(ctx->streaming) /* Do small, consecutive reads */ + { + while(bytes) + { + uint32_t len = SPNG_READ_SIZE; + + if(len > bytes) len = bytes; + + ret = read_chunk_bytes(ctx, len); + if(ret) return ret; + + bytes -= len; + } + } + else + { + ret = read_chunk_bytes(ctx, bytes); + if(ret) return ret; + } + + return 0; +} + +static int spng__inflate_init(spng_ctx *ctx, int window_bits) +{ + if(ctx->zstream.state) inflateEnd(&ctx->zstream); + + ctx->inflate = 1; + + ctx->zstream.zalloc = spng__zalloc; + ctx->zstream.zfree = spng__zfree; + ctx->zstream.opaque = ctx; + + if(inflateInit2(&ctx->zstream, window_bits) != Z_OK) return SPNG_EZLIB_INIT; + +#if ZLIB_VERNUM >= 0x1290 && !defined(SPNG_USE_MINIZ) + + int validate = 1; + + if(ctx->flags & SPNG_CTX_IGNORE_ADLER32) validate = 0; + + if(is_critical_chunk(&ctx->current_chunk)) + { + if(ctx->crc_action_critical == SPNG_CRC_USE) validate = 0; + } + else /* ancillary */ + { + if(ctx->crc_action_ancillary == SPNG_CRC_USE) validate = 0; + } + + if(inflateValidate(&ctx->zstream, validate)) return SPNG_EZLIB_INIT; + +#else /* This requires zlib >= 1.2.11 */ + #pragma message ("inflateValidate() not available, SPNG_CTX_IGNORE_ADLER32 will be ignored") +#endif + + return 0; +} + +static int spng__deflate_init(spng_ctx *ctx, struct spng__zlib_options *options) +{ + if(ctx->zstream.state) deflateEnd(&ctx->zstream); + + ctx->deflate = 1; + + z_stream *zstream = &ctx->zstream; + zstream->zalloc = spng__zalloc; + zstream->zfree = spng__zfree; + zstream->opaque = ctx; + zstream->data_type = options->data_type; + + int ret = deflateInit2(zstream, options->compression_level, Z_DEFLATED, options->window_bits, options->mem_level, options->strategy); + + if(ret != Z_OK) return SPNG_EZLIB_INIT; + + return 0; +} + +/* Inflate a zlib stream starting with start_buf if non-NULL, + continuing from the datastream till an end marker, + allocating and writing the inflated stream to *out, + leaving "extra" bytes at the end, final buffer length is *len. + + Takes into account the chunk size and cache limits. +*/ +static int spng__inflate_stream(spng_ctx *ctx, char **out, size_t *len, size_t extra, const void *start_buf, size_t start_len) +{ + int ret = spng__inflate_init(ctx, 15); + if(ret) return ret; + + size_t max = ctx->chunk_cache_limit - ctx->chunk_cache_usage; + + if(ctx->max_chunk_size < max) max = ctx->max_chunk_size; + + if(extra > max) return SPNG_ECHUNK_LIMITS; + max -= extra; + + uint32_t read_size; + size_t size = 8 * 1024; + void *t, *buf = spng__malloc(ctx, size); + + if(buf == NULL) return SPNG_EMEM; + + z_stream *stream = &ctx->zstream; + + if(start_buf != NULL && start_len) + { + stream->avail_in = (uInt)start_len; + stream->next_in = start_buf; + } + else + { + stream->avail_in = 0; + stream->next_in = NULL; + } + + stream->avail_out = (uInt)size; + stream->next_out = buf; + + while(ret != Z_STREAM_END) + { + ret = inflate(stream, Z_NO_FLUSH); + + if(ret == Z_STREAM_END) break; + + if(ret != Z_OK && ret != Z_BUF_ERROR) + { + ret = SPNG_EZLIB; + goto err; + } + + if(!stream->avail_out) /* Resize buffer */ + { + /* overflow or reached chunk/cache limit */ + if( (2 > SIZE_MAX / size) || (size > max / 2) ) + { + ret = SPNG_ECHUNK_LIMITS; + goto err; + } + + size *= 2; + + t = spng__realloc(ctx, buf, size); + if(t == NULL) goto mem; + + buf = t; + + stream->avail_out = (uInt)size / 2; + stream->next_out = (unsigned char*)buf + size / 2; + } + else if(!stream->avail_in) /* Read more chunk bytes */ + { + read_size = ctx->cur_chunk_bytes_left; + if(ctx->streaming && read_size > SPNG_READ_SIZE) read_size = SPNG_READ_SIZE; + + ret = read_chunk_bytes(ctx, read_size); + + if(ret) + { + if(!read_size) ret = SPNG_EZLIB; + + goto err; + } + + stream->avail_in = read_size; + stream->next_in = ctx->data; + } + } + + size = stream->total_out; + + if(!size) + { + ret = SPNG_EZLIB; + goto err; + } + + size += extra; + if(size < extra) goto mem; + + t = spng__realloc(ctx, buf, size); + if(t == NULL) goto mem; + + buf = t; + + (void)increase_cache_usage(ctx, size, 0); + + *out = buf; + *len = size; + + return 0; + +mem: + ret = SPNG_EMEM; +err: + spng__free(ctx, buf); + return ret; +} + +/* Read at least one byte from the IDAT stream */ +static int read_idat_bytes(spng_ctx *ctx, uint32_t *bytes_read) +{ + if(ctx == NULL || bytes_read == NULL) return SPNG_EINTERNAL; + if(memcmp(ctx->current_chunk.type, type_idat, 4)) return SPNG_EIDAT_TOO_SHORT; + + int ret; + uint32_t len; + + while(!ctx->cur_chunk_bytes_left) + { + ret = read_header(ctx); + if(ret) return ret; + + if(memcmp(ctx->current_chunk.type, type_idat, 4)) return SPNG_EIDAT_TOO_SHORT; + } + + if(ctx->streaming) + {/* TODO: estimate bytes to read for progressive reads */ + len = SPNG_READ_SIZE; + if(len > ctx->cur_chunk_bytes_left) len = ctx->cur_chunk_bytes_left; + } + else len = ctx->current_chunk.length; + + ret = read_chunk_bytes(ctx, len); + + *bytes_read = len; + + return ret; +} + +static int read_scanline_bytes(spng_ctx *ctx, unsigned char *dest, size_t len) +{ + if(ctx == NULL || dest == NULL) return SPNG_EINTERNAL; + + int ret = Z_OK; + uint32_t bytes_read; + + z_stream *zstream = &ctx->zstream; + + zstream->avail_out = (uInt)len; + zstream->next_out = dest; + + while(zstream->avail_out != 0) + { + ret = inflate(zstream, Z_NO_FLUSH); + + if(ret == Z_OK) continue; + + if(ret == Z_STREAM_END) /* Reached an end-marker */ + { + if(zstream->avail_out != 0) return SPNG_EIDAT_TOO_SHORT; + } + else if(ret == Z_BUF_ERROR) /* Read more IDAT bytes */ + { + ret = read_idat_bytes(ctx, &bytes_read); + if(ret) return ret; + + zstream->avail_in = bytes_read; + zstream->next_in = ctx->data; + } + else return SPNG_EIDAT_STREAM; + } + + return 0; +} + +static uint8_t paeth(uint8_t a, uint8_t b, uint8_t c) +{ + int16_t p = a + b - c; + int16_t pa = abs(p - a); + int16_t pb = abs(p - b); + int16_t pc = abs(p - c); + + if(pa <= pb && pa <= pc) return a; + else if(pb <= pc) return b; + + return c; +} + +SPNG_TARGET_CLONES("default,avx2") +static void defilter_up(size_t bytes, unsigned char *row, const unsigned char *prev) +{ + size_t i; + for(i=0; i < bytes; i++) + { + row[i] += prev[i]; + } +} + +/* Defilter *scanline in-place. + *prev_scanline and *scanline should point to the first pixel, + scanline_width is the width of the scanline including the filter byte. +*/ +static int defilter_scanline(const unsigned char *prev_scanline, unsigned char *scanline, + size_t scanline_width, unsigned bytes_per_pixel, unsigned filter) +{ + if(prev_scanline == NULL || scanline == NULL || !scanline_width) return SPNG_EINTERNAL; + + size_t i; + scanline_width--; + + if(filter == 0) return 0; + +#ifndef SPNG_DISABLE_OPT + if(filter == SPNG_FILTER_UP) goto no_opt; + + if(bytes_per_pixel == 4) + { + if(filter == SPNG_FILTER_SUB) + defilter_sub4(scanline_width, scanline); + else if(filter == SPNG_FILTER_AVERAGE) + defilter_avg4(scanline_width, scanline, prev_scanline); + else if(filter == SPNG_FILTER_PAETH) + defilter_paeth4(scanline_width, scanline, prev_scanline); + else return SPNG_EFILTER; + + return 0; + } + else if(bytes_per_pixel == 3) + { + if(filter == SPNG_FILTER_SUB) + defilter_sub3(scanline_width, scanline); + else if(filter == SPNG_FILTER_AVERAGE) + defilter_avg3(scanline_width, scanline, prev_scanline); + else if(filter == SPNG_FILTER_PAETH) + defilter_paeth3(scanline_width, scanline, prev_scanline); + else return SPNG_EFILTER; + + return 0; + } +no_opt: +#endif + + if(filter == SPNG_FILTER_UP) + { + defilter_up(scanline_width, scanline, prev_scanline); + return 0; + } + + for(i=0; i < scanline_width; i++) + { + uint8_t x, a, b, c; + + if(i >= bytes_per_pixel) + { + a = scanline[i - bytes_per_pixel]; + b = prev_scanline[i]; + c = prev_scanline[i - bytes_per_pixel]; + } + else /* First pixel in row */ + { + a = 0; + b = prev_scanline[i]; + c = 0; + } + + x = scanline[i]; + + switch(filter) + { + case SPNG_FILTER_SUB: + { + x = x + a; + break; + } + case SPNG_FILTER_AVERAGE: + { + uint16_t avg = (a + b) / 2; + x = x + avg; + break; + } + case SPNG_FILTER_PAETH: + { + x = x + paeth(a,b,c); + break; + } + } + + scanline[i] = x; + } + + return 0; +} + +static int filter_scanline(unsigned char *filtered, const unsigned char *prev_scanline, const unsigned char *scanline, + size_t scanline_width, unsigned bytes_per_pixel, const unsigned filter) +{ + if(prev_scanline == NULL || scanline == NULL || scanline_width <= 1) return SPNG_EINTERNAL; + + if(filter > 4) return SPNG_EFILTER; + if(filter == 0) return 0; + + scanline_width--; + + uint32_t i; + for(i=0; i < scanline_width; i++) + { + uint8_t x, a, b, c; + + if(i >= bytes_per_pixel) + { + a = scanline[i - bytes_per_pixel]; + b = prev_scanline[i]; + c = prev_scanline[i - bytes_per_pixel]; + } + else /* first pixel in row */ + { + a = 0; + b = prev_scanline[i]; + c = 0; + } + + x = scanline[i]; + + switch(filter) + { + case SPNG_FILTER_SUB: + { + x = x - a; + break; + } + case SPNG_FILTER_UP: + { + x = x - b; + break; + } + case SPNG_FILTER_AVERAGE: + { + uint16_t avg = (a + b) / 2; + x = x - avg; + break; + } + case SPNG_FILTER_PAETH: + { + x = x - paeth(a,b,c); + break; + } + } + + filtered[i] = x; + } + + return 0; +} + +static int32_t filter_sum(const unsigned char *prev_scanline, const unsigned char *scanline, + size_t size, unsigned bytes_per_pixel, const unsigned filter) +{ + /* prevent potential over/underflow, bails out at a width of ~8M pixels for RGBA8 */ + if(size > (INT32_MAX / 128)) return INT32_MAX; + + uint32_t i; + int32_t sum = 0; + uint8_t x, a, b, c; + + for(i=0; i < size; i++) + { + if(i >= bytes_per_pixel) + { + a = scanline[i - bytes_per_pixel]; + b = prev_scanline[i]; + c = prev_scanline[i - bytes_per_pixel]; + } + else /* first pixel in row */ + { + a = 0; + b = prev_scanline[i]; + c = 0; + } + + x = scanline[i]; + + switch(filter) + { + case SPNG_FILTER_NONE: + { + break; + } + case SPNG_FILTER_SUB: + { + x = x - a; + break; + } + case SPNG_FILTER_UP: + { + x = x - b; + break; + } + case SPNG_FILTER_AVERAGE: + { + uint16_t avg = (a + b) / 2; + x = x - avg; + break; + } + case SPNG_FILTER_PAETH: + { + x = x - paeth(a,b,c); + break; + } + } + + sum += 128 - abs((int)x - 128); + } + + return sum; +} + +static unsigned get_best_filter(const unsigned char *prev_scanline, const unsigned char *scanline, + size_t scanline_width, unsigned bytes_per_pixel, const int choices) +{ + if(!choices) return SPNG_FILTER_NONE; + + scanline_width--; + + int i; + unsigned int best_filter = 0; + enum spng_filter_choice flag; + int32_t sum, best_score = INT32_MAX; + int32_t filter_scores[5] = { INT32_MAX, INT32_MAX, INT32_MAX, INT32_MAX, INT32_MAX }; + + if( !(choices & (choices - 1)) ) + {/* only one choice/bit is set */ + for(i=0; i < 5; i++) + { + if(choices == 1 << (i + 3)) return i; + } + } + + for(i=0; i < 5; i++) + { + flag = 1 << (i + 3); + + if(choices & flag) sum = filter_sum(prev_scanline, scanline, scanline_width, bytes_per_pixel, i); + else continue; + + filter_scores[i] = abs(sum); + + if(filter_scores[i] < best_score) + { + best_score = filter_scores[i]; + best_filter = i; + } + } + + return best_filter; +} + +/* Scale "sbits" significant bits in "sample" from "bit_depth" to "target" + + "bit_depth" must be a valid PNG depth + "sbits" must be less than or equal to "bit_depth" + "target" must be between 1 and 16 +*/ +static uint16_t sample_to_target(uint16_t sample, unsigned bit_depth, unsigned sbits, unsigned target) +{ + if(bit_depth == sbits) + { + if(target == sbits) return sample; /* No scaling */ + }/* bit_depth > sbits */ + else sample = sample >> (bit_depth - sbits); /* Shift significant bits to bottom */ + + /* Downscale */ + if(target < sbits) return sample >> (sbits - target); + + /* Upscale using left bit replication */ + int8_t shift_amount = target - sbits; + uint16_t sample_bits = sample; + sample = 0; + + while(shift_amount >= 0) + { + sample = sample | (sample_bits << shift_amount); + shift_amount -= sbits; + } + + int8_t partial = shift_amount + (int8_t)sbits; + + if(partial != 0) sample = sample | (sample_bits >> abs(shift_amount)); + + return sample; +} + +static inline void gamma_correct_row(unsigned char *row, uint32_t pixels, int fmt, const uint16_t *gamma_lut) +{ + uint32_t i; + + if(fmt == SPNG_FMT_RGBA8) + { + unsigned char *px; + for(i=0; i < pixels; i++) + { + px = row + i * 4; + + px[0] = gamma_lut[px[0]]; + px[1] = gamma_lut[px[1]]; + px[2] = gamma_lut[px[2]]; + } + } + else if(fmt == SPNG_FMT_RGBA16) + { + for(i=0; i < pixels; i++) + { + uint16_t px[4]; + memcpy(px, row + i * 8, 8); + + px[0] = gamma_lut[px[0]]; + px[1] = gamma_lut[px[1]]; + px[2] = gamma_lut[px[2]]; + + memcpy(row + i * 8, px, 8); + } + } + else if(fmt == SPNG_FMT_RGB8) + { + unsigned char *px; + for(i=0; i < pixels; i++) + { + px = row + i * 3; + + px[0] = gamma_lut[px[0]]; + px[1] = gamma_lut[px[1]]; + px[2] = gamma_lut[px[2]]; + } + } +} + +/* Apply transparency to output row */ +static inline void trns_row(unsigned char *row, + const unsigned char *scanline, + const unsigned char *trns, + unsigned scanline_stride, + struct spng_ihdr *ihdr, + uint32_t pixels, + int fmt) +{ + uint32_t i; + unsigned row_stride; + unsigned depth = ihdr->bit_depth; + + if(fmt == SPNG_FMT_RGBA8) + { + if(ihdr->color_type == SPNG_COLOR_TYPE_GRAYSCALE) return; /* already applied in the decoding loop */ + + row_stride = 4; + for(i=0; i < pixels; i++, scanline+=scanline_stride, row+=row_stride) + { + if(!memcmp(scanline, trns, scanline_stride)) row[3] = 0; + } + } + else if(fmt == SPNG_FMT_RGBA16) + { + if(ihdr->color_type == SPNG_COLOR_TYPE_GRAYSCALE) return; /* already applied in the decoding loop */ + + row_stride = 8; + for(i=0; i < pixels; i++, scanline+=scanline_stride, row+=row_stride) + { + if(!memcmp(scanline, trns, scanline_stride)) memset(row + 6, 0, 2); + } + } + else if(fmt == SPNG_FMT_GA8) + { + row_stride = 2; + + if(depth == 16) + { + for(i=0; i < pixels; i++, scanline+=scanline_stride, row+=row_stride) + { + if(!memcmp(scanline, trns, scanline_stride)) memset(row + 1, 0, 1); + } + } + else /* depth <= 8 */ + { + struct spng__iter iter = spng__iter_init(depth, scanline); + + for(i=0; i < pixels; i++, row+=row_stride) + { + if(trns[0] == get_sample(&iter)) row[1] = 0; + } + } + } + else if(fmt == SPNG_FMT_GA16) + { + row_stride = 4; + + if(depth == 16) + { + for(i=0; i< pixels; i++, scanline+=scanline_stride, row+=row_stride) + { + if(!memcmp(scanline, trns, 2)) memset(row + 2, 0, 2); + } + } + else + { + struct spng__iter iter = spng__iter_init(depth, scanline); + + for(i=0; i< pixels; i++, row+=row_stride) + { + if(trns[0] == get_sample(&iter)) memset(row + 2, 0, 2); + } + } + } + else return; +} + +static inline void scale_row(unsigned char *row, uint32_t pixels, int fmt, unsigned depth, const struct spng_sbit *sbit) +{ + uint32_t i; + + if(fmt == SPNG_FMT_RGBA8) + { + unsigned char px[4]; + for(i=0; i < pixels; i++) + { + memcpy(px, row + i * 4, 4); + + px[0] = sample_to_target(px[0], depth, sbit->red_bits, 8); + px[1] = sample_to_target(px[1], depth, sbit->green_bits, 8); + px[2] = sample_to_target(px[2], depth, sbit->blue_bits, 8); + px[3] = sample_to_target(px[3], depth, sbit->alpha_bits, 8); + + memcpy(row + i * 4, px, 4); + } + } + else if(fmt == SPNG_FMT_RGBA16) + { + uint16_t px[4]; + for(i=0; i < pixels; i++) + { + memcpy(px, row + i * 8, 8); + + px[0] = sample_to_target(px[0], depth, sbit->red_bits, 16); + px[1] = sample_to_target(px[1], depth, sbit->green_bits, 16); + px[2] = sample_to_target(px[2], depth, sbit->blue_bits, 16); + px[3] = sample_to_target(px[3], depth, sbit->alpha_bits, 16); + + memcpy(row + i * 8, px, 8); + } + } + else if(fmt == SPNG_FMT_RGB8) + { + unsigned char px[4]; + for(i=0; i < pixels; i++) + { + memcpy(px, row + i * 3, 3); + + px[0] = sample_to_target(px[0], depth, sbit->red_bits, 8); + px[1] = sample_to_target(px[1], depth, sbit->green_bits, 8); + px[2] = sample_to_target(px[2], depth, sbit->blue_bits, 8); + + memcpy(row + i * 3, px, 3); + } + } + else if(fmt == SPNG_FMT_G8) + { + for(i=0; i < pixels; i++) + { + row[i] = sample_to_target(row[i], depth, sbit->grayscale_bits, 8); + } + } + else if(fmt == SPNG_FMT_GA8) + { + for(i=0; i < pixels; i++) + { + row[i*2] = sample_to_target(row[i*2], depth, sbit->grayscale_bits, 8); + } + } +} + +/* Expand to *row using 8-bit palette indices from *scanline */ +static void expand_row(unsigned char *row, + const unsigned char *scanline, + const union spng__decode_plte *decode_plte, + uint32_t width, + int fmt) +{ + uint32_t i = 0; + unsigned char *px; + unsigned char entry; + const struct spng_plte_entry *plte = decode_plte->rgba; + +#if defined(SPNG_ARM) + if(fmt == SPNG_FMT_RGBA8) i = expand_palette_rgba8_neon(row, scanline, decode_plte->raw, width); + else if(fmt == SPNG_FMT_RGB8) + { + i = expand_palette_rgb8_neon(row, scanline, decode_plte->raw, width); + + for(; i < width; i++) + {/* In this case the LUT is 3 bytes packed */ + px = row + i * 3; + entry = scanline[i]; + px[0] = decode_plte->raw[entry * 3 + 0]; + px[1] = decode_plte->raw[entry * 3 + 1]; + px[2] = decode_plte->raw[entry * 3 + 2]; + } + return; + } +#endif + + if(fmt == SPNG_FMT_RGBA8) + { + for(; i < width; i++) + { + px = row + i * 4; + entry = scanline[i]; + px[0] = plte[entry].red; + px[1] = plte[entry].green; + px[2] = plte[entry].blue; + px[3] = plte[entry].alpha; + } + } + else if(fmt == SPNG_FMT_RGB8) + { + for(; i < width; i++) + { + px = row + i * 3; + entry = scanline[i]; + px[0] = plte[entry].red; + px[1] = plte[entry].green; + px[2] = plte[entry].blue; + } + } +} + +/* Unpack 1/2/4/8-bit samples to G8/GA8/GA16 or G16 -> GA16 */ +static void unpack_scanline(unsigned char *out, const unsigned char *scanline, uint32_t width, unsigned bit_depth, int fmt) +{ + struct spng__iter iter = spng__iter_init(bit_depth, scanline); + uint32_t i; + uint16_t sample, alpha = 65535; + + + if(fmt == SPNG_FMT_GA8) goto ga8; + else if(fmt == SPNG_FMT_GA16) goto ga16; + + /* 1/2/4-bit -> 8-bit */ + for(i=0; i < width; i++) out[i] = get_sample(&iter); + + return; + +ga8: + /* 1/2/4/8-bit -> GA8 */ + for(i=0; i < width; i++) + { + out[i*2] = get_sample(&iter); + out[i*2 + 1] = 255; + } + + return; + +ga16: + + /* 16 -> GA16 */ + if(bit_depth == 16) + { + for(i=0; i < width; i++) + { + memcpy(out + i * 4, scanline + i * 2, 2); + memcpy(out + i * 4 + 2, &alpha, 2); + } + return; + } + + /* 1/2/4/8-bit -> GA16 */ + for(i=0; i < width; i++) + { + sample = get_sample(&iter); + memcpy(out + i * 4, &sample, 2); + memcpy(out + i * 4 + 2, &alpha, 2); + } +} + +static int check_ihdr(const struct spng_ihdr *ihdr, uint32_t max_width, uint32_t max_height) +{ + if(ihdr->width > spng_u32max || !ihdr->width) return SPNG_EWIDTH; + if(ihdr->height > spng_u32max || !ihdr->height) return SPNG_EHEIGHT; + + if(ihdr->width > max_width) return SPNG_EUSER_WIDTH; + if(ihdr->height > max_height) return SPNG_EUSER_HEIGHT; + + switch(ihdr->color_type) + { + case SPNG_COLOR_TYPE_GRAYSCALE: + { + if( !(ihdr->bit_depth == 1 || ihdr->bit_depth == 2 || + ihdr->bit_depth == 4 || ihdr->bit_depth == 8 || + ihdr->bit_depth == 16) ) + return SPNG_EBIT_DEPTH; + + break; + } + case SPNG_COLOR_TYPE_TRUECOLOR: + case SPNG_COLOR_TYPE_GRAYSCALE_ALPHA: + case SPNG_COLOR_TYPE_TRUECOLOR_ALPHA: + { + if( !(ihdr->bit_depth == 8 || ihdr->bit_depth == 16) ) + return SPNG_EBIT_DEPTH; + + break; + } + case SPNG_COLOR_TYPE_INDEXED: + { + if( !(ihdr->bit_depth == 1 || ihdr->bit_depth == 2 || + ihdr->bit_depth == 4 || ihdr->bit_depth == 8) ) + return SPNG_EBIT_DEPTH; + + break; + } + default: return SPNG_ECOLOR_TYPE; + } + + if(ihdr->compression_method) return SPNG_ECOMPRESSION_METHOD; + if(ihdr->filter_method) return SPNG_EFILTER_METHOD; + + if(ihdr->interlace_method > 1) return SPNG_EINTERLACE_METHOD; + + return 0; +} + +static int check_plte(const struct spng_plte *plte, const struct spng_ihdr *ihdr) +{ + if(plte == NULL || ihdr == NULL) return 1; + + if(plte->n_entries == 0) return 1; + if(plte->n_entries > 256) return 1; + + if(ihdr->color_type == SPNG_COLOR_TYPE_INDEXED) + { + if(plte->n_entries > (1U << ihdr->bit_depth)) return 1; + } + + return 0; +} + +static int check_sbit(const struct spng_sbit *sbit, const struct spng_ihdr *ihdr) +{ + if(sbit == NULL || ihdr == NULL) return 1; + + if(ihdr->color_type == 0) + { + if(sbit->grayscale_bits == 0) return SPNG_ESBIT; + if(sbit->grayscale_bits > ihdr->bit_depth) return SPNG_ESBIT; + } + else if(ihdr->color_type == 2 || ihdr->color_type == 3) + { + if(sbit->red_bits == 0) return SPNG_ESBIT; + if(sbit->green_bits == 0) return SPNG_ESBIT; + if(sbit->blue_bits == 0) return SPNG_ESBIT; + + uint8_t bit_depth; + if(ihdr->color_type == 3) bit_depth = 8; + else bit_depth = ihdr->bit_depth; + + if(sbit->red_bits > bit_depth) return SPNG_ESBIT; + if(sbit->green_bits > bit_depth) return SPNG_ESBIT; + if(sbit->blue_bits > bit_depth) return SPNG_ESBIT; + } + else if(ihdr->color_type == 4) + { + if(sbit->grayscale_bits == 0) return SPNG_ESBIT; + if(sbit->alpha_bits == 0) return SPNG_ESBIT; + + if(sbit->grayscale_bits > ihdr->bit_depth) return SPNG_ESBIT; + if(sbit->alpha_bits > ihdr->bit_depth) return SPNG_ESBIT; + } + else if(ihdr->color_type == 6) + { + if(sbit->red_bits == 0) return SPNG_ESBIT; + if(sbit->green_bits == 0) return SPNG_ESBIT; + if(sbit->blue_bits == 0) return SPNG_ESBIT; + if(sbit->alpha_bits == 0) return SPNG_ESBIT; + + if(sbit->red_bits > ihdr->bit_depth) return SPNG_ESBIT; + if(sbit->green_bits > ihdr->bit_depth) return SPNG_ESBIT; + if(sbit->blue_bits > ihdr->bit_depth) return SPNG_ESBIT; + if(sbit->alpha_bits > ihdr->bit_depth) return SPNG_ESBIT; + } + + return 0; +} + +static int check_chrm_int(const struct spng_chrm_int *chrm_int) +{ + if(chrm_int == NULL) return 1; + + if(chrm_int->white_point_x > spng_u32max || + chrm_int->white_point_y > spng_u32max || + chrm_int->red_x > spng_u32max || + chrm_int->red_y > spng_u32max || + chrm_int->green_x > spng_u32max || + chrm_int->green_y > spng_u32max || + chrm_int->blue_x > spng_u32max || + chrm_int->blue_y > spng_u32max) return SPNG_ECHRM; + + return 0; +} + +static int check_phys(const struct spng_phys *phys) +{ + if(phys == NULL) return 1; + + if(phys->unit_specifier > 1) return SPNG_EPHYS; + + if(phys->ppu_x > spng_u32max) return SPNG_EPHYS; + if(phys->ppu_y > spng_u32max) return SPNG_EPHYS; + + return 0; +} + +static int check_time(const struct spng_time *time) +{ + if(time == NULL) return 1; + + if(time->month == 0 || time->month > 12) return 1; + if(time->day == 0 || time->day > 31) return 1; + if(time->hour > 23) return 1; + if(time->minute > 59) return 1; + if(time->second > 60) return 1; + + return 0; +} + +static int check_offs(const struct spng_offs *offs) +{ + if(offs == NULL) return 1; + + if(offs->unit_specifier > 1) return 1; + + return 0; +} + +static int check_exif(const struct spng_exif *exif) +{ + if(exif == NULL) return 1; + if(exif->data == NULL) return 1; + + if(exif->length < 4) return SPNG_ECHUNK_SIZE; + if(exif->length > spng_u32max) return SPNG_ECHUNK_STDLEN; + + const uint8_t exif_le[4] = { 73, 73, 42, 0 }; + const uint8_t exif_be[4] = { 77, 77, 0, 42 }; + + if(memcmp(exif->data, exif_le, 4) && memcmp(exif->data, exif_be, 4)) return 1; + + return 0; +} + +/* Validate PNG keyword */ +static int check_png_keyword(const char *str) +{ + if(str == NULL) return 1; + size_t len = strlen(str); + const char *end = str + len; + + if(!len) return 1; + if(len > 79) return 1; + if(str[0] == ' ') return 1; /* Leading space */ + if(end[-1] == ' ') return 1; /* Trailing space */ + if(strstr(str, " ") != NULL) return 1; /* Consecutive spaces */ + + uint8_t c; + while(str != end) + { + memcpy(&c, str, 1); + + if( (c >= 32 && c <= 126) || (c >= 161) ) str++; + else return 1; /* Invalid character */ + } + + return 0; +} + +/* Validate PNG text *str up to 'len' bytes */ +static int check_png_text(const char *str, size_t len) +{/* XXX: are consecutive newlines permitted? */ + if(str == NULL || len == 0) return 1; + + uint8_t c; + size_t i = 0; + while(i < len) + { + memcpy(&c, str + i, 1); + + if( (c >= 32 && c <= 126) || (c >= 161) || c == 10) i++; + else return 1; /* Invalid character */ + } + + return 0; +} + +/* Returns non-zero for standard chunks which are stored without allocating memory */ +static int is_small_chunk(uint8_t type[4]) +{ + if(!memcmp(type, type_plte, 4)) return 1; + else if(!memcmp(type, type_chrm, 4)) return 1; + else if(!memcmp(type, type_gama, 4)) return 1; + else if(!memcmp(type, type_sbit, 4)) return 1; + else if(!memcmp(type, type_srgb, 4)) return 1; + else if(!memcmp(type, type_bkgd, 4)) return 1; + else if(!memcmp(type, type_trns, 4)) return 1; + else if(!memcmp(type, type_hist, 4)) return 1; + else if(!memcmp(type, type_phys, 4)) return 1; + else if(!memcmp(type, type_time, 4)) return 1; + else if(!memcmp(type, type_offs, 4)) return 1; + else return 0; +} + +static int read_ihdr(spng_ctx *ctx) +{ + int ret; + struct spng_chunk *chunk = &ctx->current_chunk; + const unsigned char *data; + + chunk->offset = 8; + chunk->length = 13; + size_t sizeof_sig_ihdr = 29; + + ret = read_data(ctx, sizeof_sig_ihdr); + if(ret) return ret; + + data = ctx->data; + + if(memcmp(data, spng_signature, sizeof(spng_signature))) return SPNG_ESIGNATURE; + + chunk->length = read_u32(data + 8); + memcpy(&chunk->type, data + 12, 4); + + if(chunk->length != 13) return SPNG_EIHDR_SIZE; + if(memcmp(chunk->type, type_ihdr, 4)) return SPNG_ENOIHDR; + + ctx->cur_actual_crc = crc32(0, NULL, 0); + ctx->cur_actual_crc = crc32(ctx->cur_actual_crc, data + 12, 17); + + ctx->ihdr.width = read_u32(data + 16); + ctx->ihdr.height = read_u32(data + 20); + ctx->ihdr.bit_depth = data[24]; + ctx->ihdr.color_type = data[25]; + ctx->ihdr.compression_method = data[26]; + ctx->ihdr.filter_method = data[27]; + ctx->ihdr.interlace_method = data[28]; + + ret = check_ihdr(&ctx->ihdr, ctx->max_width, ctx->max_height); + if(ret) return ret; + + ctx->file.ihdr = 1; + ctx->stored.ihdr = 1; + + if(ctx->ihdr.bit_depth < 8) ctx->bytes_per_pixel = 1; + else ctx->bytes_per_pixel = num_channels(&ctx->ihdr) * (ctx->ihdr.bit_depth / 8); + + ret = calculate_subimages(ctx); + if(ret) return ret; + + return 0; +} + +static void splt_undo(spng_ctx *ctx) +{ + struct spng_splt *splt = &ctx->splt_list[ctx->n_splt - 1]; + + spng__free(ctx, splt->entries); + + decrease_cache_usage(ctx, sizeof(struct spng_splt)); + decrease_cache_usage(ctx, splt->n_entries * sizeof(struct spng_splt_entry)); + + splt->entries = NULL; + + ctx->n_splt--; +} + +static void text_undo(spng_ctx *ctx) +{ + struct spng_text2 *text = &ctx->text_list[ctx->n_text - 1]; + + spng__free(ctx, text->keyword); + if(text->compression_flag) spng__free(ctx, text->text); + + decrease_cache_usage(ctx, text->cache_usage); + decrease_cache_usage(ctx, sizeof(struct spng_text2)); + + text->keyword = NULL; + text->text = NULL; + + ctx->n_text--; +} + +static void chunk_undo(spng_ctx *ctx) +{ + struct spng_unknown_chunk *chunk = &ctx->chunk_list[ctx->n_chunks - 1]; + + spng__free(ctx, chunk->data); + + decrease_cache_usage(ctx, chunk->length); + decrease_cache_usage(ctx, sizeof(struct spng_unknown_chunk)); + + chunk->data = NULL; + + ctx->n_chunks--; +} + +static int read_non_idat_chunks(spng_ctx *ctx) +{ + int ret; + struct spng_chunk chunk; + const unsigned char *data; + + ctx->discard = 0; + ctx->undo = NULL; + ctx->prev_stored = ctx->stored; + + while( !(ret = read_header(ctx))) + { + if(ctx->discard) + { + if(ctx->undo) ctx->undo(ctx); + + ctx->stored = ctx->prev_stored; + } + + ctx->discard = 0; + ctx->undo = NULL; + + ctx->prev_stored = ctx->stored; + chunk = ctx->current_chunk; + + if(!memcmp(chunk.type, type_idat, 4)) + { + if(ctx->state < SPNG_STATE_FIRST_IDAT) + { + if(ctx->ihdr.color_type == 3 && !ctx->stored.plte) return SPNG_ENOPLTE; + + ctx->first_idat = chunk; + return 0; + } + + if(ctx->prev_was_idat) + { + /* Ignore extra IDAT's */ + ret = discard_chunk_bytes(ctx, chunk.length); + if(ret) return ret; + + continue; + } + else return SPNG_ECHUNK_POS; /* IDAT chunk not at the end of the IDAT sequence */ + } + + ctx->prev_was_idat = 0; + + if(is_small_chunk(chunk.type)) + { + /* None of the known chunks can be zero length */ + if(!chunk.length) return SPNG_ECHUNK_SIZE; + + /* The largest of these chunks is PLTE with 256 entries */ + ret = read_chunk_bytes(ctx, chunk.length > 768 ? 768 : chunk.length); + if(ret) return ret; + } + + data = ctx->data; + + if(is_critical_chunk(&chunk)) + { + if(!memcmp(chunk.type, type_plte, 4)) + { + if(ctx->file.trns || ctx->file.hist || ctx->file.bkgd) return SPNG_ECHUNK_POS; + if(chunk.length % 3 != 0) return SPNG_ECHUNK_SIZE; + + ctx->plte.n_entries = chunk.length / 3; + + if(check_plte(&ctx->plte, &ctx->ihdr)) return SPNG_ECHUNK_SIZE; /* XXX: EPLTE? */ + + size_t i; + for(i=0; i < ctx->plte.n_entries; i++) + { + ctx->plte.entries[i].red = data[i * 3]; + ctx->plte.entries[i].green = data[i * 3 + 1]; + ctx->plte.entries[i].blue = data[i * 3 + 2]; + } + + ctx->file.plte = 1; + ctx->stored.plte = 1; + } + else if(!memcmp(chunk.type, type_iend, 4)) + { + if(ctx->state == SPNG_STATE_AFTER_IDAT) + { + if(chunk.length) return SPNG_ECHUNK_SIZE; + + ret = read_and_check_crc(ctx); + if(ret == -SPNG_CRC_DISCARD) ret = 0; + + return ret; + } + else return SPNG_ECHUNK_POS; + } + else if(!memcmp(chunk.type, type_ihdr, 4)) return SPNG_ECHUNK_POS; + else return SPNG_ECHUNK_UNKNOWN_CRITICAL; + } + else if(!memcmp(chunk.type, type_chrm, 4)) /* Ancillary chunks */ + { + if(ctx->file.plte) return SPNG_ECHUNK_POS; + if(ctx->state == SPNG_STATE_AFTER_IDAT) return SPNG_ECHUNK_POS; + if(ctx->file.chrm) return SPNG_EDUP_CHRM; + + if(chunk.length != 32) return SPNG_ECHUNK_SIZE; + + ctx->chrm_int.white_point_x = read_u32(data); + ctx->chrm_int.white_point_y = read_u32(data + 4); + ctx->chrm_int.red_x = read_u32(data + 8); + ctx->chrm_int.red_y = read_u32(data + 12); + ctx->chrm_int.green_x = read_u32(data + 16); + ctx->chrm_int.green_y = read_u32(data + 20); + ctx->chrm_int.blue_x = read_u32(data + 24); + ctx->chrm_int.blue_y = read_u32(data + 28); + + if(check_chrm_int(&ctx->chrm_int)) return SPNG_ECHRM; + + ctx->file.chrm = 1; + ctx->stored.chrm = 1; + } + else if(!memcmp(chunk.type, type_gama, 4)) + { + if(ctx->file.plte) return SPNG_ECHUNK_POS; + if(ctx->state == SPNG_STATE_AFTER_IDAT) return SPNG_ECHUNK_POS; + if(ctx->file.gama) return SPNG_EDUP_GAMA; + + if(chunk.length != 4) return SPNG_ECHUNK_SIZE; + + ctx->gama = read_u32(data); + + if(!ctx->gama) return SPNG_EGAMA; + if(ctx->gama > spng_u32max) return SPNG_EGAMA; + + ctx->file.gama = 1; + ctx->stored.gama = 1; + } + else if(!memcmp(chunk.type, type_sbit, 4)) + { + if(ctx->file.plte) return SPNG_ECHUNK_POS; + if(ctx->state == SPNG_STATE_AFTER_IDAT) return SPNG_ECHUNK_POS; + if(ctx->file.sbit) return SPNG_EDUP_SBIT; + + if(ctx->ihdr.color_type == 0) + { + if(chunk.length != 1) return SPNG_ECHUNK_SIZE; + + ctx->sbit.grayscale_bits = data[0]; + } + else if(ctx->ihdr.color_type == 2 || ctx->ihdr.color_type == 3) + { + if(chunk.length != 3) return SPNG_ECHUNK_SIZE; + + ctx->sbit.red_bits = data[0]; + ctx->sbit.green_bits = data[1]; + ctx->sbit.blue_bits = data[2]; + } + else if(ctx->ihdr.color_type == 4) + { + if(chunk.length != 2) return SPNG_ECHUNK_SIZE; + + ctx->sbit.grayscale_bits = data[0]; + ctx->sbit.alpha_bits = data[1]; + } + else if(ctx->ihdr.color_type == 6) + { + if(chunk.length != 4) return SPNG_ECHUNK_SIZE; + + ctx->sbit.red_bits = data[0]; + ctx->sbit.green_bits = data[1]; + ctx->sbit.blue_bits = data[2]; + ctx->sbit.alpha_bits = data[3]; + } + + if(check_sbit(&ctx->sbit, &ctx->ihdr)) return SPNG_ESBIT; + + ctx->file.sbit = 1; + ctx->stored.sbit = 1; + } + else if(!memcmp(chunk.type, type_srgb, 4)) + { + if(ctx->file.plte) return SPNG_ECHUNK_POS; + if(ctx->state == SPNG_STATE_AFTER_IDAT) return SPNG_ECHUNK_POS; + if(ctx->file.srgb) return SPNG_EDUP_SRGB; + + if(chunk.length != 1) return SPNG_ECHUNK_SIZE; + + ctx->srgb_rendering_intent = data[0]; + + if(ctx->srgb_rendering_intent > 3) return SPNG_ESRGB; + + ctx->file.srgb = 1; + ctx->stored.srgb = 1; + } + else if(!memcmp(chunk.type, type_bkgd, 4)) + { + if(ctx->state == SPNG_STATE_AFTER_IDAT) return SPNG_ECHUNK_POS; + if(ctx->file.bkgd) return SPNG_EDUP_BKGD; + + if(ctx->ihdr.color_type == 0 || ctx->ihdr.color_type == 4) + { + if(chunk.length != 2) return SPNG_ECHUNK_SIZE; + + ctx->bkgd.gray = read_u16(data); + } + else if(ctx->ihdr.color_type == 2 || ctx->ihdr.color_type == 6) + { + if(chunk.length != 6) return SPNG_ECHUNK_SIZE; + + ctx->bkgd.red = read_u16(data); + ctx->bkgd.green = read_u16(data + 2); + ctx->bkgd.blue = read_u16(data + 4); + } + else if(ctx->ihdr.color_type == 3) + { + if(chunk.length != 1) return SPNG_ECHUNK_SIZE; + if(!ctx->file.plte) return SPNG_EBKGD_NO_PLTE; + + ctx->bkgd.plte_index = data[0]; + if(ctx->bkgd.plte_index >= ctx->plte.n_entries) return SPNG_EBKGD_PLTE_IDX; + } + + ctx->file.bkgd = 1; + ctx->stored.bkgd = 1; + } + else if(!memcmp(chunk.type, type_trns, 4)) + { + if(ctx->state == SPNG_STATE_AFTER_IDAT) return SPNG_ECHUNK_POS; + if(ctx->file.trns) return SPNG_EDUP_TRNS; + if(!chunk.length) return SPNG_ECHUNK_SIZE; + + if(ctx->ihdr.color_type == 0) + { + if(chunk.length != 2) return SPNG_ECHUNK_SIZE; + + ctx->trns.gray = read_u16(data); + } + else if(ctx->ihdr.color_type == 2) + { + if(chunk.length != 6) return SPNG_ECHUNK_SIZE; + + ctx->trns.red = read_u16(data); + ctx->trns.green = read_u16(data + 2); + ctx->trns.blue = read_u16(data + 4); + } + else if(ctx->ihdr.color_type == 3) + { + if(chunk.length > ctx->plte.n_entries) return SPNG_ECHUNK_SIZE; + if(!ctx->file.plte) return SPNG_ETRNS_NO_PLTE; + + memcpy(ctx->trns.type3_alpha, data, chunk.length); + ctx->trns.n_type3_entries = chunk.length; + } + + if(ctx->ihdr.color_type == 4 || ctx->ihdr.color_type == 6) return SPNG_ETRNS_COLOR_TYPE; + + ctx->file.trns = 1; + ctx->stored.trns = 1; + } + else if(!memcmp(chunk.type, type_hist, 4)) + { + if(!ctx->file.plte) return SPNG_EHIST_NO_PLTE; + if(ctx->state == SPNG_STATE_AFTER_IDAT) return SPNG_ECHUNK_POS; + if(ctx->file.hist) return SPNG_EDUP_HIST; + + if( (chunk.length / 2) != (ctx->plte.n_entries) ) return SPNG_ECHUNK_SIZE; + + size_t k; + for(k=0; k < (chunk.length / 2); k++) + { + ctx->hist.frequency[k] = read_u16(data + k*2); + } + + ctx->file.hist = 1; + ctx->stored.hist = 1; + } + else if(!memcmp(chunk.type, type_phys, 4)) + { + if(ctx->state == SPNG_STATE_AFTER_IDAT) return SPNG_ECHUNK_POS; + if(ctx->file.phys) return SPNG_EDUP_PHYS; + + if(chunk.length != 9) return SPNG_ECHUNK_SIZE; + + ctx->phys.ppu_x = read_u32(data); + ctx->phys.ppu_y = read_u32(data + 4); + ctx->phys.unit_specifier = data[8]; + + if(check_phys(&ctx->phys)) return SPNG_EPHYS; + + ctx->file.phys = 1; + ctx->stored.phys = 1; + } + else if(!memcmp(chunk.type, type_time, 4)) + { + if(ctx->file.time) return SPNG_EDUP_TIME; + + if(chunk.length != 7) return SPNG_ECHUNK_SIZE; + + struct spng_time time; + + time.year = read_u16(data); + time.month = data[2]; + time.day = data[3]; + time.hour = data[4]; + time.minute = data[5]; + time.second = data[6]; + + if(check_time(&time)) return SPNG_ETIME; + + ctx->file.time = 1; + + if(!ctx->user.time) ctx->time = time; + + ctx->stored.time = 1; + } + else if(!memcmp(chunk.type, type_offs, 4)) + { + if(ctx->state == SPNG_STATE_AFTER_IDAT) return SPNG_ECHUNK_POS; + if(ctx->file.offs) return SPNG_EDUP_OFFS; + + if(chunk.length != 9) return SPNG_ECHUNK_SIZE; + + ctx->offs.x = read_s32(data); + ctx->offs.y = read_s32(data + 4); + ctx->offs.unit_specifier = data[8]; + + if(check_offs(&ctx->offs)) return SPNG_EOFFS; + + ctx->file.offs = 1; + ctx->stored.offs = 1; + } + else /* Arbitrary-length chunk */ + { + + if(!memcmp(chunk.type, type_exif, 4)) + { + if(ctx->file.exif) return SPNG_EDUP_EXIF; + + ctx->file.exif = 1; + + if(ctx->user.exif) goto discard; + + if(increase_cache_usage(ctx, chunk.length, 1)) return SPNG_ECHUNK_LIMITS; + + struct spng_exif exif; + + exif.length = chunk.length; + + exif.data = spng__malloc(ctx, chunk.length); + if(exif.data == NULL) return SPNG_EMEM; + + ret = read_chunk_bytes2(ctx, exif.data, chunk.length); + if(ret) + { + spng__free(ctx, exif.data); + return ret; + } + + if(check_exif(&exif)) + { + spng__free(ctx, exif.data); + return SPNG_EEXIF; + } + + ctx->exif = exif; + + ctx->stored.exif = 1; + } + else if(!memcmp(chunk.type, type_iccp, 4)) + {/* TODO: add test file with color profile */ + if(ctx->file.plte) return SPNG_ECHUNK_POS; + if(ctx->state == SPNG_STATE_AFTER_IDAT) return SPNG_ECHUNK_POS; + if(ctx->file.iccp) return SPNG_EDUP_ICCP; + if(!chunk.length) return SPNG_ECHUNK_SIZE; + + ctx->file.iccp = 1; + + uint32_t peek_bytes = 81 > chunk.length ? chunk.length : 81; + + ret = read_chunk_bytes(ctx, peek_bytes); + if(ret) return ret; + + unsigned char *keyword_nul = memchr(ctx->data, '\0', peek_bytes); + if(keyword_nul == NULL) return SPNG_EICCP_NAME; + + uint32_t keyword_len = keyword_nul - ctx->data; + + if(keyword_len > 79) return SPNG_EICCP_NAME; + + memcpy(ctx->iccp.profile_name, ctx->data, keyword_len); + + if(check_png_keyword(ctx->iccp.profile_name)) return SPNG_EICCP_NAME; + + if(chunk.length < (keyword_len + 2)) return SPNG_ECHUNK_SIZE; + + if(ctx->data[keyword_len + 1] != 0) return SPNG_EICCP_COMPRESSION_METHOD; + + ret = spng__inflate_stream(ctx, &ctx->iccp.profile, &ctx->iccp.profile_len, 0, ctx->data + keyword_len + 2, peek_bytes - (keyword_len + 2)); + + if(ret) return ret; + + ctx->stored.iccp = 1; + } + else if(!memcmp(chunk.type, type_text, 4) || + !memcmp(chunk.type, type_ztxt, 4) || + !memcmp(chunk.type, type_itxt, 4)) + { + if(!chunk.length) return SPNG_ECHUNK_SIZE; + + ctx->file.text = 1; + + if(ctx->user.text) goto discard; + + if(increase_cache_usage(ctx, sizeof(struct spng_text2), 1)) return SPNG_ECHUNK_LIMITS; + + ctx->n_text++; + if(ctx->n_text < 1) return SPNG_EOVERFLOW; + if(sizeof(struct spng_text2) > SIZE_MAX / ctx->n_text) return SPNG_EOVERFLOW; + + void *buf = spng__realloc(ctx, ctx->text_list, ctx->n_text * sizeof(struct spng_text2)); + if(buf == NULL) return SPNG_EMEM; + ctx->text_list = buf; + + struct spng_text2 *text = &ctx->text_list[ctx->n_text - 1]; + memset(text, 0, sizeof(struct spng_text2)); + + ctx->undo = text_undo; + + uint32_t text_offset = 0, language_tag_offset = 0, translated_keyword_offset = 0; + uint32_t peek_bytes = 256; /* enough for 3 80-byte keywords and some text bytes */ + uint32_t keyword_len; + + if(peek_bytes > chunk.length) peek_bytes = chunk.length; + + ret = read_chunk_bytes(ctx, peek_bytes); + if(ret) return ret; + + data = ctx->data; + + const unsigned char *zlib_stream = NULL; + const unsigned char *peek_end = data + peek_bytes; + const unsigned char *keyword_nul = memchr(data, 0, chunk.length > 80 ? 80 : chunk.length); + + if(keyword_nul == NULL) return SPNG_ETEXT_KEYWORD; + + keyword_len = keyword_nul - data; + + if(!memcmp(chunk.type, type_text, 4)) + { + text->type = SPNG_TEXT; + + text->text_length = chunk.length - keyword_len - 1; + + text_offset = keyword_len; + + /* increment past nul if there is a text field */ + if(text->text_length) text_offset++; + } + else if(!memcmp(chunk.type, type_ztxt, 4)) + { + text->type = SPNG_ZTXT; + + if((peek_bytes - keyword_len) <= 2) return SPNG_EZTXT; + + if(keyword_nul[1]) return SPNG_EZTXT_COMPRESSION_METHOD; + + text->compression_flag = 1; + + text_offset = keyword_len + 2; + } + else if(!memcmp(chunk.type, type_itxt, 4)) + { + text->type = SPNG_ITXT; + + /* at least two 1-byte fields, two >=0 length strings, and one byte of (compressed) text */ + if((peek_bytes - keyword_len) < 5) return SPNG_EITXT; + + text->compression_flag = keyword_nul[1]; + + if(text->compression_flag > 1) return SPNG_EITXT_COMPRESSION_FLAG; + + if(keyword_nul[2]) return SPNG_EITXT_COMPRESSION_METHOD; + + language_tag_offset = keyword_len + 3; + + const unsigned char *term; + term = memchr(data + language_tag_offset, 0, peek_bytes - language_tag_offset); + if(term == NULL) return SPNG_EITXT_LANG_TAG; + + if((peek_end - term) < 2) return SPNG_EITXT; + + translated_keyword_offset = term - data + 1; + + zlib_stream = memchr(data + translated_keyword_offset, 0, peek_bytes - translated_keyword_offset); + if(zlib_stream == NULL) return SPNG_EITXT; + if(zlib_stream == peek_end) return SPNG_EITXT; + + text_offset = zlib_stream - data + 1; + text->text_length = chunk.length - text_offset; + } + else return SPNG_EINTERNAL; + + + if(text->compression_flag) + { + /* cache usage = peek_bytes + decompressed text size + nul */ + if(increase_cache_usage(ctx, peek_bytes, 0)) return SPNG_ECHUNK_LIMITS; + + text->keyword = spng__calloc(ctx, 1, peek_bytes); + if(text->keyword == NULL) return SPNG_EMEM; + + memcpy(text->keyword, data, peek_bytes); + + zlib_stream = ctx->data + text_offset; + + ret = spng__inflate_stream(ctx, &text->text, &text->text_length, 1, zlib_stream, peek_bytes - text_offset); + + if(ret) return ret; + + text->text[text->text_length - 1] = '\0'; + text->cache_usage = text->text_length + peek_bytes; + } + else + { + if(increase_cache_usage(ctx, chunk.length + 1, 0)) return SPNG_ECHUNK_LIMITS; + + text->keyword = spng__malloc(ctx, chunk.length + 1); + if(text->keyword == NULL) return SPNG_EMEM; + + memcpy(text->keyword, data, peek_bytes); + + if(chunk.length > peek_bytes) + { + ret = read_chunk_bytes2(ctx, text->keyword + peek_bytes, chunk.length - peek_bytes); + if(ret) return ret; + } + + text->text = text->keyword + text_offset; + + text->text_length = chunk.length - text_offset; + + text->text[text->text_length] = '\0'; + text->cache_usage = chunk.length + 1; + } + + if(check_png_keyword(text->keyword)) return SPNG_ETEXT_KEYWORD; + + text->text_length = strlen(text->text); + + if(text->type != SPNG_ITXT) + { + language_tag_offset = keyword_len; + translated_keyword_offset = keyword_len; + + if(ctx->strict && check_png_text(text->text, text->text_length)) + { + if(text->type == SPNG_ZTXT) return SPNG_EZTXT; + else return SPNG_ETEXT; + } + } + + text->language_tag = text->keyword + language_tag_offset; + text->translated_keyword = text->keyword + translated_keyword_offset; + + ctx->stored.text = 1; + } + else if(!memcmp(chunk.type, type_splt, 4)) + { + if(ctx->state == SPNG_STATE_AFTER_IDAT) return SPNG_ECHUNK_POS; + if(ctx->user.splt) goto discard; /* XXX: could check profile names for uniqueness */ + if(!chunk.length) return SPNG_ECHUNK_SIZE; + + ctx->file.splt = 1; + + /* chunk.length + sizeof(struct spng_splt) + splt->n_entries * sizeof(struct spng_splt_entry) */ + if(increase_cache_usage(ctx, chunk.length + sizeof(struct spng_splt), 1)) return SPNG_ECHUNK_LIMITS; + + ctx->n_splt++; + if(ctx->n_splt < 1) return SPNG_EOVERFLOW; + if(sizeof(struct spng_splt) > SIZE_MAX / ctx->n_splt) return SPNG_EOVERFLOW; + + void *buf = spng__realloc(ctx, ctx->splt_list, ctx->n_splt * sizeof(struct spng_splt)); + if(buf == NULL) return SPNG_EMEM; + ctx->splt_list = buf; + + struct spng_splt *splt = &ctx->splt_list[ctx->n_splt - 1]; + + memset(splt, 0, sizeof(struct spng_splt)); + + ctx->undo = splt_undo; + + void *t = spng__malloc(ctx, chunk.length); + if(t == NULL) return SPNG_EMEM; + + splt->entries = t; /* simplifies error handling */ + data = t; + + ret = read_chunk_bytes2(ctx, t, chunk.length); + if(ret) return ret; + + uint32_t keyword_len = chunk.length < 80 ? chunk.length : 80; + + const unsigned char *keyword_nul = memchr(data, 0, keyword_len); + if(keyword_nul == NULL) return SPNG_ESPLT_NAME; + + keyword_len = keyword_nul - data; + + memcpy(splt->name, data, keyword_len); + + if(check_png_keyword(splt->name)) return SPNG_ESPLT_NAME; + + uint32_t j; + for(j=0; j < (ctx->n_splt - 1); j++) + { + if(!strcmp(ctx->splt_list[j].name, splt->name)) return SPNG_ESPLT_DUP_NAME; + } + + if( (chunk.length - keyword_len) <= 2) return SPNG_ECHUNK_SIZE; + + splt->sample_depth = data[keyword_len + 1]; + + uint32_t entries_len = chunk.length - keyword_len - 2; + if(!entries_len) return SPNG_ECHUNK_SIZE; + + if(splt->sample_depth == 16) + { + if(entries_len % 10 != 0) return SPNG_ECHUNK_SIZE; + splt->n_entries = entries_len / 10; + } + else if(splt->sample_depth == 8) + { + if(entries_len % 6 != 0) return SPNG_ECHUNK_SIZE; + splt->n_entries = entries_len / 6; + } + else return SPNG_ESPLT_DEPTH; + + if(!splt->n_entries) return SPNG_ECHUNK_SIZE; + + size_t list_size = splt->n_entries; + + if(list_size > SIZE_MAX / sizeof(struct spng_splt_entry)) return SPNG_EOVERFLOW; + + list_size *= sizeof(struct spng_splt_entry); + + if(increase_cache_usage(ctx, list_size, 0)) return SPNG_ECHUNK_LIMITS; + + splt->entries = spng__malloc(ctx, list_size); + if(splt->entries == NULL) + { + spng__free(ctx, t); + return SPNG_EMEM; + } + + data = (unsigned char*)t + keyword_len + 2; + + uint32_t k; + if(splt->sample_depth == 16) + { + for(k=0; k < splt->n_entries; k++) + { + splt->entries[k].red = read_u16(data + k * 10); + splt->entries[k].green = read_u16(data + k * 10 + 2); + splt->entries[k].blue = read_u16(data + k * 10 + 4); + splt->entries[k].alpha = read_u16(data + k * 10 + 6); + splt->entries[k].frequency = read_u16(data + k * 10 + 8); + } + } + else if(splt->sample_depth == 8) + { + for(k=0; k < splt->n_entries; k++) + { + splt->entries[k].red = data[k * 6]; + splt->entries[k].green = data[k * 6 + 1]; + splt->entries[k].blue = data[k * 6 + 2]; + splt->entries[k].alpha = data[k * 6 + 3]; + splt->entries[k].frequency = read_u16(data + k * 6 + 4); + } + } + + spng__free(ctx, t); + decrease_cache_usage(ctx, chunk.length); + + ctx->stored.splt = 1; + } + else /* Unknown chunk */ + { + ctx->file.unknown = 1; + + if(!ctx->keep_unknown) goto discard; + if(ctx->user.unknown) goto discard; + + if(increase_cache_usage(ctx, chunk.length + sizeof(struct spng_unknown_chunk), 1)) return SPNG_ECHUNK_LIMITS; + + ctx->n_chunks++; + if(ctx->n_chunks < 1) return SPNG_EOVERFLOW; + if(sizeof(struct spng_unknown_chunk) > SIZE_MAX / ctx->n_chunks) return SPNG_EOVERFLOW; + + void *buf = spng__realloc(ctx, ctx->chunk_list, ctx->n_chunks * sizeof(struct spng_unknown_chunk)); + if(buf == NULL) return SPNG_EMEM; + ctx->chunk_list = buf; + + struct spng_unknown_chunk *chunkp = &ctx->chunk_list[ctx->n_chunks - 1]; + + memset(chunkp, 0, sizeof(struct spng_unknown_chunk)); + + ctx->undo = chunk_undo; + + memcpy(chunkp->type, chunk.type, 4); + + if(ctx->state < SPNG_STATE_FIRST_IDAT) + { + if(ctx->file.plte) chunkp->location = SPNG_AFTER_PLTE; + else chunkp->location = SPNG_AFTER_IHDR; + } + else if(ctx->state >= SPNG_STATE_AFTER_IDAT) chunkp->location = SPNG_AFTER_IDAT; + + if(chunk.length > 0) + { + void *t = spng__malloc(ctx, chunk.length); + if(t == NULL) return SPNG_EMEM; + + ret = read_chunk_bytes2(ctx, t, chunk.length); + if(ret) + { + spng__free(ctx, t); + return ret; + } + + chunkp->length = chunk.length; + chunkp->data = t; + } + + ctx->stored.unknown = 1; + } + +discard: + ret = discard_chunk_bytes(ctx, ctx->cur_chunk_bytes_left); + if(ret) return ret; + } + + } + + return ret; +} + +/* Read chunks before or after the IDAT chunks depending on state */ +static int read_chunks(spng_ctx *ctx, int only_ihdr) +{ + if(ctx == NULL) return SPNG_EINTERNAL; + if(!ctx->state) return SPNG_EBADSTATE; + if(ctx->data == NULL) + { + if(ctx->encode_only) return 0; + else return SPNG_EINTERNAL; + } + + int ret = 0; + + if(ctx->state == SPNG_STATE_INPUT) + { + ret = read_ihdr(ctx); + + if(ret) return decode_err(ctx, ret); + + ctx->state = SPNG_STATE_IHDR; + } + + if(only_ihdr) return 0; + + if(ctx->state == SPNG_STATE_EOI) + { + ctx->state = SPNG_STATE_AFTER_IDAT; + ctx->prev_was_idat = 1; + } + + while(ctx->state < SPNG_STATE_FIRST_IDAT || ctx->state == SPNG_STATE_AFTER_IDAT) + { + ret = read_non_idat_chunks(ctx); + + if(!ret) + { + if(ctx->state < SPNG_STATE_FIRST_IDAT) ctx->state = SPNG_STATE_FIRST_IDAT; + else if(ctx->state == SPNG_STATE_AFTER_IDAT) ctx->state = SPNG_STATE_IEND; + } + else + { + switch(ret) + { + case SPNG_ECHUNK_POS: + case SPNG_ECHUNK_SIZE: /* size != expected size, SPNG_ECHUNK_STDLEN = invalid size */ + case SPNG_EDUP_PLTE: + case SPNG_EDUP_CHRM: + case SPNG_EDUP_GAMA: + case SPNG_EDUP_ICCP: + case SPNG_EDUP_SBIT: + case SPNG_EDUP_SRGB: + case SPNG_EDUP_BKGD: + case SPNG_EDUP_HIST: + case SPNG_EDUP_TRNS: + case SPNG_EDUP_PHYS: + case SPNG_EDUP_TIME: + case SPNG_EDUP_OFFS: + case SPNG_EDUP_EXIF: + case SPNG_ECHRM: + case SPNG_ETRNS_COLOR_TYPE: + case SPNG_ETRNS_NO_PLTE: + case SPNG_EGAMA: + case SPNG_EICCP_NAME: + case SPNG_EICCP_COMPRESSION_METHOD: + case SPNG_ESBIT: + case SPNG_ESRGB: + case SPNG_ETEXT: + case SPNG_ETEXT_KEYWORD: + case SPNG_EZTXT: + case SPNG_EZTXT_COMPRESSION_METHOD: + case SPNG_EITXT: + case SPNG_EITXT_COMPRESSION_FLAG: + case SPNG_EITXT_COMPRESSION_METHOD: + case SPNG_EITXT_LANG_TAG: + case SPNG_EITXT_TRANSLATED_KEY: + case SPNG_EBKGD_NO_PLTE: + case SPNG_EBKGD_PLTE_IDX: + case SPNG_EHIST_NO_PLTE: + case SPNG_EPHYS: + case SPNG_ESPLT_NAME: + case SPNG_ESPLT_DUP_NAME: + case SPNG_ESPLT_DEPTH: + case SPNG_ETIME: + case SPNG_EOFFS: + case SPNG_EEXIF: + case SPNG_EZLIB: + { + if(!ctx->strict && !is_critical_chunk(&ctx->current_chunk)) + { + ret = discard_chunk_bytes(ctx, ctx->cur_chunk_bytes_left); + if(ret) return decode_err(ctx, ret); + + if(ctx->undo) ctx->undo(ctx); + + ctx->stored = ctx->prev_stored; + + ctx->discard = 0; + ctx->undo = NULL; + + continue; + } + else return decode_err(ctx, ret); + + break; + } + default: return decode_err(ctx, ret); + } + } + } + + return ret; +} + +static int read_scanline(spng_ctx *ctx) +{ + int ret, pass = ctx->row_info.pass; + struct spng_row_info *ri = &ctx->row_info; + const struct spng_subimage *sub = ctx->subimage; + size_t scanline_width = sub[pass].scanline_width; + uint32_t scanline_idx = ri->scanline_idx; + + uint8_t next_filter = 0; + + if(scanline_idx == (sub[pass].height - 1) && ri->pass == ctx->last_pass) + { + ret = read_scanline_bytes(ctx, ctx->scanline, scanline_width - 1); + } + else + { + ret = read_scanline_bytes(ctx, ctx->scanline, scanline_width); + if(ret) return ret; + + next_filter = ctx->scanline[scanline_width - 1]; + if(next_filter > 4) ret = SPNG_EFILTER; + } + + if(ret) return ret; + + if(!scanline_idx && ri->filter > 1) + { + /* prev_scanline is all zeros for the first scanline */ + memset(ctx->prev_scanline, 0, scanline_width); + } + + if(ctx->ihdr.bit_depth == 16 && ctx->fmt != SPNG_FMT_RAW) u16_row_to_host(ctx->scanline, scanline_width - 1); + + ret = defilter_scanline(ctx->prev_scanline, ctx->scanline, scanline_width, ctx->bytes_per_pixel, ri->filter); + if(ret) return ret; + + ri->filter = next_filter; + + return 0; +} + +static int update_row_info(spng_ctx *ctx) +{ + int interlacing = ctx->ihdr.interlace_method; + struct spng_row_info *ri = &ctx->row_info; + const struct spng_subimage *sub = ctx->subimage; + + if(ri->scanline_idx == (sub[ri->pass].height - 1)) /* Last scanline */ + { + if(ri->pass == ctx->last_pass) + { + ctx->state = SPNG_STATE_EOI; + + return SPNG_EOI; + } + + ri->scanline_idx = 0; + ri->pass++; + + /* Skip empty passes */ + while( (!sub[ri->pass].width || !sub[ri->pass].height) && (ri->pass < ctx->last_pass)) ri->pass++; + } + else + { + ri->row_num++; + ri->scanline_idx++; + } + + if(interlacing) ri->row_num = adam7_y_start[ri->pass] + ri->scanline_idx * adam7_y_delta[ri->pass]; + + return 0; +} + +int spng_decode_scanline(spng_ctx *ctx, void *out, size_t len) +{ + if(ctx == NULL || out == NULL) return 1; + + if(ctx->state >= SPNG_STATE_EOI) return SPNG_EOI; + + struct decode_flags f = ctx->decode_flags; + + struct spng_row_info *ri = &ctx->row_info; + const struct spng_subimage *sub = ctx->subimage; + + const struct spng_ihdr *ihdr = &ctx->ihdr; + const uint16_t *gamma_lut = ctx->gamma_lut; + unsigned char *trns_px = ctx->trns_px; + const struct spng_sbit *sb = &ctx->decode_sb; + const struct spng_plte_entry *plte = ctx->decode_plte.rgba; + struct spng__iter iter = spng__iter_init(ihdr->bit_depth, ctx->scanline); + + const unsigned char *scanline; + + const int pass = ri->pass; + const int fmt = ctx->fmt; + const size_t scanline_width = sub[pass].scanline_width; + const uint32_t width = sub[pass].width; + uint32_t k; + uint8_t r_8, g_8, b_8, a_8, gray_8; + uint16_t r_16, g_16, b_16, a_16, gray_16; + r_8=0; g_8=0; b_8=0; a_8=0; gray_8=0; + r_16=0; g_16=0; b_16=0; a_16=0; gray_16=0; + size_t pixel_size = 4; /* SPNG_FMT_RGBA8 */ + size_t pixel_offset = 0; + unsigned char *pixel; + unsigned processing_depth = ihdr->bit_depth; + + if(f.indexed) processing_depth = 8; + + if(fmt == SPNG_FMT_RGBA16) pixel_size = 8; + else if(fmt == SPNG_FMT_RGB8) pixel_size = 3; + + if(len < sub[pass].out_width) return SPNG_EBUFSIZ; + + int ret = read_scanline(ctx); + + if(ret) return decode_err(ctx, ret); + + scanline = ctx->scanline; + + for(k=0; k < width; k++) + { + pixel = (unsigned char*)out + pixel_offset; + pixel_offset += pixel_size; + + if(f.same_layout) + { + if(f.zerocopy) break; + + memcpy(out, scanline, scanline_width - 1); + break; + } + + if(f.unpack) + { + unpack_scanline(out, scanline, width, ihdr->bit_depth, fmt); + break; + } + + if(ihdr->color_type == SPNG_COLOR_TYPE_TRUECOLOR) + { + if(ihdr->bit_depth == 16) + { + memcpy(&r_16, scanline + (k * 6), 2); + memcpy(&g_16, scanline + (k * 6) + 2, 2); + memcpy(&b_16, scanline + (k * 6) + 4, 2); + + a_16 = 65535; + } + else /* == 8 */ + { + if(fmt == SPNG_FMT_RGBA8) + { + rgb8_row_to_rgba8(scanline, out, width); + break; + } + + r_8 = scanline[k * 3]; + g_8 = scanline[k * 3 + 1]; + b_8 = scanline[k * 3 + 2]; + + a_8 = 255; + } + } + else if(ihdr->color_type == SPNG_COLOR_TYPE_INDEXED) + { + uint8_t entry = 0; + + if(ihdr->bit_depth == 8) + { + if(fmt & (SPNG_FMT_RGBA8 | SPNG_FMT_RGB8)) + { + expand_row(out, scanline, &ctx->decode_plte, width, fmt); + break; + } + + entry = scanline[k]; + } + else /* < 8 */ + { + entry = get_sample(&iter); + } + + if(fmt & (SPNG_FMT_RGBA8 | SPNG_FMT_RGB8)) + { + pixel[0] = plte[entry].red; + pixel[1] = plte[entry].green; + pixel[2] = plte[entry].blue; + if(fmt == SPNG_FMT_RGBA8) pixel[3] = plte[entry].alpha; + + continue; + } + else /* RGBA16 */ + { + r_16 = plte[entry].red; + g_16 = plte[entry].green; + b_16 = plte[entry].blue; + a_16 = plte[entry].alpha; + + r_16 = (r_16 << 8) | r_16; + g_16 = (g_16 << 8) | g_16; + b_16 = (b_16 << 8) | b_16; + a_16 = (a_16 << 8) | a_16; + + memcpy(pixel, &r_16, 2); + memcpy(pixel + 2, &g_16, 2); + memcpy(pixel + 4, &b_16, 2); + memcpy(pixel + 6, &a_16, 2); + + continue; + } + } + else if(ihdr->color_type == SPNG_COLOR_TYPE_TRUECOLOR_ALPHA) + { + if(ihdr->bit_depth == 16) + { + memcpy(&r_16, scanline + (k * 8), 2); + memcpy(&g_16, scanline + (k * 8) + 2, 2); + memcpy(&b_16, scanline + (k * 8) + 4, 2); + memcpy(&a_16, scanline + (k * 8) + 6, 2); + } + else /* == 8 */ + { + r_8 = scanline[k * 4]; + g_8 = scanline[k * 4 + 1]; + b_8 = scanline[k * 4 + 2]; + a_8 = scanline[k * 4 + 3]; + } + } + else if(ihdr->color_type == SPNG_COLOR_TYPE_GRAYSCALE) + { + if(ihdr->bit_depth == 16) + { + memcpy(&gray_16, scanline + k * 2, 2); + + if(f.apply_trns && ctx->trns.gray == gray_16) a_16 = 0; + else a_16 = 65535; + + r_16 = gray_16; + g_16 = gray_16; + b_16 = gray_16; + } + else /* <= 8 */ + { + gray_8 = get_sample(&iter); + + if(f.apply_trns && ctx->trns.gray == gray_8) a_8 = 0; + else a_8 = 255; + + r_8 = gray_8; g_8 = gray_8; b_8 = gray_8; + } + } + else if(ihdr->color_type == SPNG_COLOR_TYPE_GRAYSCALE_ALPHA) + { + if(ihdr->bit_depth == 16) + { + memcpy(&gray_16, scanline + (k * 4), 2); + memcpy(&a_16, scanline + (k * 4) + 2, 2); + + r_16 = gray_16; + g_16 = gray_16; + b_16 = gray_16; + } + else /* == 8 */ + { + gray_8 = scanline[k * 2]; + a_8 = scanline[k * 2 + 1]; + + r_8 = gray_8; + g_8 = gray_8; + b_8 = gray_8; + } + } + + + if(fmt & (SPNG_FMT_RGBA8 | SPNG_FMT_RGB8)) + { + if(ihdr->bit_depth == 16) + { + r_8 = r_16 >> 8; + g_8 = g_16 >> 8; + b_8 = b_16 >> 8; + a_8 = a_16 >> 8; + } + + pixel[0] = r_8; + pixel[1] = g_8; + pixel[2] = b_8; + + if(fmt == SPNG_FMT_RGBA8) pixel[3] = a_8; + } + else if(fmt == SPNG_FMT_RGBA16) + { + if(ihdr->bit_depth != 16) + { + r_16 = r_8; + g_16 = g_8; + b_16 = b_8; + a_16 = a_8; + } + + memcpy(pixel, &r_16, 2); + memcpy(pixel + 2, &g_16, 2); + memcpy(pixel + 4, &b_16, 2); + memcpy(pixel + 6, &a_16, 2); + } + }/* for(k=0; k < width; k++) */ + + if(f.apply_trns) trns_row(out, scanline, trns_px, ctx->bytes_per_pixel, &ctx->ihdr, width, fmt); + + if(f.do_scaling) scale_row(out, width, fmt, processing_depth, sb); + + if(f.apply_gamma) gamma_correct_row(out, width, fmt, gamma_lut); + + /* The previous scanline is always defiltered */ + void *t = ctx->prev_scanline; + ctx->prev_scanline = ctx->scanline; + ctx->scanline = t; + + ret = update_row_info(ctx); + + if(ret == SPNG_EOI) + { + if(ctx->cur_chunk_bytes_left) /* zlib stream ended before an IDAT chunk boundary */ + {/* Discard the rest of the chunk */ + int error = discard_chunk_bytes(ctx, ctx->cur_chunk_bytes_left); + if(error) return decode_err(ctx, error); + } + + ctx->last_idat = ctx->current_chunk; + } + + return ret; +} + +int spng_decode_row(spng_ctx *ctx, void *out, size_t len) +{ + if(ctx == NULL || out == NULL) return 1; + if(ctx->state >= SPNG_STATE_EOI) return SPNG_EOI; + if(len < ctx->image_width) return SPNG_EBUFSIZ; + + const struct spng_ihdr *ihdr = &ctx->ihdr; + int ret, pass = ctx->row_info.pass; + unsigned char *outptr = out; + + if(!ihdr->interlace_method || pass == 6) return spng_decode_scanline(ctx, out, len); + + ret = spng_decode_scanline(ctx, ctx->row, ctx->image_width); + if(ret && ret != SPNG_EOI) return ret; + + uint32_t k; + unsigned pixel_size = 4; /* RGBA8 */ + if(ctx->fmt == SPNG_FMT_RGBA16) pixel_size = 8; + else if(ctx->fmt == SPNG_FMT_RGB8) pixel_size = 3; + else if(ctx->fmt == SPNG_FMT_G8) pixel_size = 1; + else if(ctx->fmt == SPNG_FMT_GA8) pixel_size = 2; + else if(ctx->fmt & (SPNG_FMT_PNG | SPNG_FMT_RAW)) + { + if(ihdr->bit_depth < 8) + { + struct spng__iter iter = spng__iter_init(ihdr->bit_depth, ctx->row); + const uint8_t samples_per_byte = 8 / ihdr->bit_depth; + uint8_t sample; + + for(k=0; k < ctx->subimage[pass].width; k++) + { + sample = get_sample(&iter); + + size_t ioffset = adam7_x_start[pass] + k * adam7_x_delta[pass]; + + sample = sample << (iter.initial_shift - ioffset * ihdr->bit_depth % 8); + + ioffset /= samples_per_byte; + + outptr[ioffset] |= sample; + } + + return 0; + } + else pixel_size = ctx->bytes_per_pixel; + } + + for(k=0; k < ctx->subimage[pass].width; k++) + { + size_t ioffset = (adam7_x_start[pass] + (size_t) k * adam7_x_delta[pass]) * pixel_size; + + memcpy(outptr + ioffset, ctx->row + k * pixel_size, pixel_size); + } + + return 0; +} + +int spng_decode_chunks(spng_ctx *ctx) +{ + if(ctx == NULL) return 1; + if(ctx->encode_only) return SPNG_ECTXTYPE; + if(ctx->state < SPNG_STATE_INPUT) return SPNG_ENOSRC; + if(ctx->state == SPNG_STATE_IEND) return 0; + + return read_chunks(ctx, 0); +} + +int spng_decode_image(spng_ctx *ctx, void *out, size_t len, int fmt, int flags) +{ + if(ctx == NULL) return 1; + if(ctx->encode_only) return SPNG_ECTXTYPE; + if(ctx->state >= SPNG_STATE_EOI) return SPNG_EOI; + + const struct spng_ihdr *ihdr = &ctx->ihdr; + + int ret = read_chunks(ctx, 0); + if(ret) return decode_err(ctx, ret); + + ret = check_decode_fmt(ihdr, fmt); + if(ret) return ret; + + ret = calculate_image_width(ihdr, fmt, &ctx->image_width); + if(ret) return decode_err(ctx, ret); + + if(ctx->image_width > SIZE_MAX / ihdr->height) ctx->image_size = 0; /* overflow */ + else ctx->image_size = ctx->image_width * ihdr->height; + + if( !(flags & SPNG_DECODE_PROGRESSIVE) ) + { + if(out == NULL) return 1; + if(!ctx->image_size) return SPNG_EOVERFLOW; + if(len < ctx->image_size) return SPNG_EBUFSIZ; + } + + uint32_t bytes_read = 0; + + ret = read_idat_bytes(ctx, &bytes_read); + if(ret) return decode_err(ctx, ret); + + if(bytes_read > 1) + { + int valid = read_u16(ctx->data) % 31 ? 0 : 1; + + unsigned flg = ctx->data[1]; + unsigned flevel = flg >> 6; + int compression_level = Z_DEFAULT_COMPRESSION; + + if(flevel == 0) compression_level = 0; /* fastest */ + else if(flevel == 1) compression_level = 1; /* fast */ + else if(flevel == 2) compression_level = 6; /* default */ + else if(flevel == 3) compression_level = 9; /* slowest, max compression */ + + if(valid) ctx->image_options.compression_level = compression_level; + } + + ret = spng__inflate_init(ctx, ctx->image_options.window_bits); + if(ret) return decode_err(ctx, ret); + + ctx->zstream.avail_in = bytes_read; + ctx->zstream.next_in = ctx->data; + + size_t scanline_buf_size = ctx->subimage[ctx->widest_pass].scanline_width; + + scanline_buf_size += 32; + + if(scanline_buf_size < 32) return SPNG_EOVERFLOW; + + ctx->scanline_buf = spng__malloc(ctx, scanline_buf_size); + ctx->prev_scanline_buf = spng__malloc(ctx, scanline_buf_size); + + ctx->scanline = ctx->scanline_buf; + ctx->prev_scanline = ctx->prev_scanline_buf; + + struct decode_flags f = {0}; + + ctx->fmt = fmt; + + if(ihdr->color_type == SPNG_COLOR_TYPE_INDEXED) f.indexed = 1; + + unsigned processing_depth = ihdr->bit_depth; + + if(f.indexed) processing_depth = 8; + + if(ihdr->interlace_method) + { + f.interlaced = 1; + ctx->row_buf = spng__malloc(ctx, ctx->image_width); + ctx->row = ctx->row_buf; + + if(ctx->row == NULL) return decode_err(ctx, SPNG_EMEM); + } + + if(ctx->scanline == NULL || ctx->prev_scanline == NULL) + { + return decode_err(ctx, SPNG_EMEM); + } + + f.do_scaling = 1; + if(f.indexed) f.do_scaling = 0; + + unsigned depth_target = 8; /* FMT_RGBA8, G8 */ + if(fmt == SPNG_FMT_RGBA16) depth_target = 16; + + if(flags & SPNG_DECODE_TRNS && ctx->stored.trns) f.apply_trns = 1; + else flags &= ~SPNG_DECODE_TRNS; + + if(ihdr->color_type == SPNG_COLOR_TYPE_GRAYSCALE_ALPHA || + ihdr->color_type == SPNG_COLOR_TYPE_TRUECOLOR_ALPHA) flags &= ~SPNG_DECODE_TRNS; + + if(flags & SPNG_DECODE_GAMMA && ctx->stored.gama) f.apply_gamma = 1; + else flags &= ~SPNG_DECODE_GAMMA; + + if(flags & SPNG_DECODE_USE_SBIT && ctx->stored.sbit) f.use_sbit = 1; + else flags &= ~SPNG_DECODE_USE_SBIT; + + if(fmt & (SPNG_FMT_RGBA8 | SPNG_FMT_RGBA16)) + { + if(ihdr->color_type == SPNG_COLOR_TYPE_TRUECOLOR_ALPHA && + ihdr->bit_depth == depth_target) f.same_layout = 1; + } + else if(fmt == SPNG_FMT_RGB8) + { + if(ihdr->color_type == SPNG_COLOR_TYPE_TRUECOLOR && + ihdr->bit_depth == depth_target) f.same_layout = 1; + + f.apply_trns = 0; /* not applicable */ + } + else if(fmt & (SPNG_FMT_PNG | SPNG_FMT_RAW)) + { + f.same_layout = 1; + f.do_scaling = 0; + f.apply_gamma = 0; /* for now */ + f.apply_trns = 0; + } + else if(fmt == SPNG_FMT_G8 && ihdr->color_type == SPNG_COLOR_TYPE_GRAYSCALE && ihdr->bit_depth <= 8) + { + if(ihdr->bit_depth == depth_target) f.same_layout = 1; + else if(ihdr->bit_depth < 8) f.unpack = 1; + + f.apply_trns = 0; + } + else if(fmt == SPNG_FMT_GA8 && ihdr->color_type == SPNG_COLOR_TYPE_GRAYSCALE && ihdr->bit_depth <= 8) + { + if(ihdr->color_type == SPNG_COLOR_TYPE_GRAYSCALE_ALPHA && + ihdr->bit_depth == depth_target) f.same_layout = 1; + else if(ihdr->bit_depth <= 8) f.unpack = 1; + } + else if(fmt == SPNG_FMT_GA16 && ihdr->color_type == SPNG_COLOR_TYPE_GRAYSCALE && ihdr->bit_depth == 16) + { + if(ihdr->color_type == SPNG_COLOR_TYPE_GRAYSCALE_ALPHA && + ihdr->bit_depth == depth_target) f.same_layout = 1; + else if(ihdr->bit_depth == 16) f.unpack = 1; + } + + /*if(f.same_layout && !flags && !f.interlaced) f.zerocopy = 1;*/ + + uint16_t *gamma_lut = NULL; + + if(f.apply_gamma) + { + float file_gamma = (float)ctx->gama / 100000.0f; + float max; + + unsigned lut_entries; + + if(fmt & (SPNG_FMT_RGBA8 | SPNG_FMT_RGB8)) + { + lut_entries = 256; + max = 255.0f; + + gamma_lut = ctx->gamma_lut8; + ctx->gamma_lut = ctx->gamma_lut8; + } + else /* SPNG_FMT_RGBA16 */ + { + lut_entries = 65536; + max = 65535.0f; + + ctx->gamma_lut16 = spng__malloc(ctx, lut_entries * sizeof(uint16_t)); + if(ctx->gamma_lut16 == NULL) return decode_err(ctx, SPNG_EMEM); + + gamma_lut = ctx->gamma_lut16; + ctx->gamma_lut = ctx->gamma_lut16; + } + + float screen_gamma = 2.2f; + float exponent = file_gamma * screen_gamma; + + if(FP_ZERO == fpclassify(exponent)) return decode_err(ctx, SPNG_EGAMA); + + exponent = 1.0f / exponent; + + unsigned i; + for(i=0; i < lut_entries; i++) + { + float c = pow((float)i / max, exponent) * max; + if(c > max) c = max; + + gamma_lut[i] = (uint16_t)c; + } + } + + struct spng_sbit *sb = &ctx->decode_sb; + + sb->red_bits = processing_depth; + sb->green_bits = processing_depth; + sb->blue_bits = processing_depth; + sb->alpha_bits = processing_depth; + sb->grayscale_bits = processing_depth; + + if(f.use_sbit) + { + if(ihdr->color_type == 0) + { + sb->grayscale_bits = ctx->sbit.grayscale_bits; + sb->alpha_bits = ihdr->bit_depth; + } + else if(ihdr->color_type == 2 || ihdr->color_type == 3) + { + sb->red_bits = ctx->sbit.red_bits; + sb->green_bits = ctx->sbit.green_bits; + sb->blue_bits = ctx->sbit.blue_bits; + sb->alpha_bits = ihdr->bit_depth; + } + else if(ihdr->color_type == 4) + { + sb->grayscale_bits = ctx->sbit.grayscale_bits; + sb->alpha_bits = ctx->sbit.alpha_bits; + } + else /* == 6 */ + { + sb->red_bits = ctx->sbit.red_bits; + sb->green_bits = ctx->sbit.green_bits; + sb->blue_bits = ctx->sbit.blue_bits; + sb->alpha_bits = ctx->sbit.alpha_bits; + } + } + + if(ihdr->bit_depth == 16 && fmt & (SPNG_FMT_RGBA8 | SPNG_FMT_RGB8)) + {/* samples are scaled down by 8 bits in the decode loop */ + sb->red_bits -= 8; + sb->green_bits -= 8; + sb->blue_bits -= 8; + sb->alpha_bits -= 8; + sb->grayscale_bits -= 8; + + processing_depth = 8; + } + + /* Prevent infinite loops in sample_to_target() */ + if(!depth_target || depth_target > 16 || + !processing_depth || processing_depth > 16 || + !sb->grayscale_bits || sb->grayscale_bits > processing_depth || + !sb->alpha_bits || sb->alpha_bits > processing_depth || + !sb->red_bits || sb->red_bits > processing_depth || + !sb->green_bits || sb->green_bits > processing_depth || + !sb->blue_bits || sb->blue_bits > processing_depth) + { + return decode_err(ctx, SPNG_ESBIT); + } + + if(sb->red_bits == sb->green_bits && + sb->green_bits == sb->blue_bits && + sb->blue_bits == sb->alpha_bits && + sb->alpha_bits == processing_depth && + processing_depth == depth_target) f.do_scaling = 0; + + struct spng_plte_entry *plte = ctx->decode_plte.rgba; + + /* Pre-process palette entries */ + if(f.indexed) + { + uint8_t red, green, blue, alpha; + + uint32_t i; + for(i=0; i < 256; i++) + { + if(f.apply_trns && i < ctx->trns.n_type3_entries) + ctx->plte.entries[i].alpha = ctx->trns.type3_alpha[i]; + else + ctx->plte.entries[i].alpha = 255; + + red = sample_to_target(ctx->plte.entries[i].red, 8, sb->red_bits, 8); + green = sample_to_target(ctx->plte.entries[i].green, 8, sb->green_bits, 8); + blue = sample_to_target(ctx->plte.entries[i].blue, 8, sb->blue_bits, 8); + alpha = sample_to_target(ctx->plte.entries[i].alpha, 8, sb->alpha_bits, 8); + +#if defined(SPNG_ARM) + if(fmt == SPNG_FMT_RGB8 && ihdr->bit_depth == 8) + {/* Working with 3 bytes at a time is more of an ARM thing */ + ctx->decode_plte.rgb[i * 3 + 0] = red; + ctx->decode_plte.rgb[i * 3 + 1] = green; + ctx->decode_plte.rgb[i * 3 + 2] = blue; + continue; + } +#endif + plte[i].red = red; + plte[i].green = green; + plte[i].blue = blue; + plte[i].alpha = alpha; + } + + f.apply_trns = 0; + } + + unsigned char *trns_px = ctx->trns_px; + + if(f.apply_trns) + { + uint16_t mask = ~0; + if(ctx->ihdr.bit_depth < 16) mask = (1 << ctx->ihdr.bit_depth) - 1; + + if(fmt & (SPNG_FMT_RGBA8 | SPNG_FMT_RGBA16)) + { + if(ihdr->color_type == SPNG_COLOR_TYPE_TRUECOLOR) + { + if(ihdr->bit_depth == 16) + { + memcpy(trns_px, &ctx->trns.red, 2); + memcpy(trns_px + 2, &ctx->trns.green, 2); + memcpy(trns_px + 4, &ctx->trns.blue, 2); + } + else + { + trns_px[0] = ctx->trns.red & mask; + trns_px[1] = ctx->trns.green & mask; + trns_px[2] = ctx->trns.blue & mask; + } + } + } + else if(ihdr->color_type == SPNG_COLOR_TYPE_GRAYSCALE) // fmt == SPNG_FMT_GA8 && + { + if(ihdr->bit_depth == 16) + { + memcpy(trns_px, &ctx->trns.gray, 2); + } + else + { + trns_px[0] = ctx->trns.gray & mask; + } + } + } + + ctx->decode_flags = f; + + ctx->state = SPNG_STATE_DECODE_INIT; + + struct spng_row_info *ri = &ctx->row_info; + struct spng_subimage *sub = ctx->subimage; + + while(!sub[ri->pass].width || !sub[ri->pass].height) ri->pass++; + + if(f.interlaced) ri->row_num = adam7_y_start[ri->pass]; + + unsigned pixel_size = 4; /* SPNG_FMT_RGBA8 */ + + if(fmt == SPNG_FMT_RGBA16) pixel_size = 8; + else if(fmt == SPNG_FMT_RGB8) pixel_size = 3; + else if(fmt == SPNG_FMT_G8) pixel_size = 1; + else if(fmt == SPNG_FMT_GA8) pixel_size = 2; + + int i; + for(i=ri->pass; i <= ctx->last_pass; i++) + { + if(!sub[i].scanline_width) continue; + + if(fmt & (SPNG_FMT_PNG | SPNG_FMT_RAW)) sub[i].out_width = sub[i].scanline_width - 1; + else sub[i].out_width = (size_t)sub[i].width * pixel_size; + + if(sub[i].out_width > UINT32_MAX) return decode_err(ctx, SPNG_EOVERFLOW); + } + + /* Read the first filter byte, offsetting all reads by 1 byte. + The scanlines will be aligned with the start of the array with + the next scanline's filter byte at the end, + the last scanline will end up being 1 byte "shorter". */ + ret = read_scanline_bytes(ctx, &ri->filter, 1); + if(ret) return decode_err(ctx, ret); + + if(ri->filter > 4) return decode_err(ctx, SPNG_EFILTER); + + if(flags & SPNG_DECODE_PROGRESSIVE) + { + return 0; + } + + do + { + size_t ioffset = ri->row_num * ctx->image_width; + + ret = spng_decode_row(ctx, (unsigned char*)out + ioffset, ctx->image_width); + }while(!ret); + + if(ret != SPNG_EOI) return decode_err(ctx, ret); + + return 0; +} + +int spng_get_row_info(spng_ctx *ctx, struct spng_row_info *row_info) +{ + if(ctx == NULL || row_info == NULL || ctx->state < SPNG_STATE_DECODE_INIT) return 1; + + if(ctx->state >= SPNG_STATE_EOI) return SPNG_EOI; + + *row_info = ctx->row_info; + + return 0; +} + +static int write_chunks_before_idat(spng_ctx *ctx) +{ + if(ctx == NULL) return SPNG_EINTERNAL; + if(!ctx->encode_only) return SPNG_EINTERNAL; + if(!ctx->stored.ihdr) return SPNG_EINTERNAL; + + int ret; + uint32_t i; + size_t length; + const struct spng_ihdr *ihdr = &ctx->ihdr; + unsigned char *data = ctx->decode_plte.raw; + + ret = write_data(ctx, spng_signature, 8); + if(ret) return ret; + + write_u32(data, ihdr->width); + write_u32(data + 4, ihdr->height); + data[8] = ihdr->bit_depth; + data[9] = ihdr->color_type; + data[10] = ihdr->compression_method; + data[11] = ihdr->filter_method; + data[12] = ihdr->interlace_method; + + ret = write_chunk(ctx, type_ihdr, data, 13); + if(ret) return ret; + + if(ctx->stored.chrm) + { + write_u32(data, ctx->chrm_int.white_point_x); + write_u32(data + 4, ctx->chrm_int.white_point_y); + write_u32(data + 8, ctx->chrm_int.red_x); + write_u32(data + 12, ctx->chrm_int.red_y); + write_u32(data + 16, ctx->chrm_int.green_x); + write_u32(data + 20, ctx->chrm_int.green_y); + write_u32(data + 24, ctx->chrm_int.blue_x); + write_u32(data + 28, ctx->chrm_int.blue_y); + + ret = write_chunk(ctx, type_chrm, data, 32); + if(ret) return ret; + } + + if(ctx->stored.gama) + { + write_u32(data, ctx->gama); + + ret = write_chunk(ctx, type_gama, data, 4); + if(ret) return ret; + } + + if(ctx->stored.iccp) + { + uLongf dest_len = compressBound((uLong)ctx->iccp.profile_len); + + Bytef *buf = spng__malloc(ctx, dest_len); + if(buf == NULL) return SPNG_EMEM; + + ret = compress2(buf, &dest_len, (void*)ctx->iccp.profile, (uLong)ctx->iccp.profile_len, Z_DEFAULT_COMPRESSION); + + if(ret != Z_OK) + { + spng__free(ctx, buf); + return SPNG_EZLIB; + } + + size_t name_len = strlen(ctx->iccp.profile_name); + + length = name_len + 2; + length += dest_len; + + if(dest_len > length) return SPNG_EOVERFLOW; + + unsigned char *cdata = NULL; + + ret = write_header(ctx, type_iccp, length, &cdata); + + if(ret) + { + spng__free(ctx, buf); + return ret; + } + + memcpy(cdata, ctx->iccp.profile_name, name_len + 1); + cdata[name_len + 1] = 0; /* compression method */ + memcpy(cdata + name_len + 2, buf, dest_len); + + spng__free(ctx, buf); + + ret = finish_chunk(ctx); + if(ret) return ret; + } + + if(ctx->stored.sbit) + { + switch(ctx->ihdr.color_type) + { + case SPNG_COLOR_TYPE_GRAYSCALE: + { + length = 1; + + data[0] = ctx->sbit.grayscale_bits; + + break; + } + case SPNG_COLOR_TYPE_TRUECOLOR: + case SPNG_COLOR_TYPE_INDEXED: + { + length = 3; + + data[0] = ctx->sbit.red_bits; + data[1] = ctx->sbit.green_bits; + data[2] = ctx->sbit.blue_bits; + + break; + } + case SPNG_COLOR_TYPE_GRAYSCALE_ALPHA: + { + length = 2; + + data[0] = ctx->sbit.grayscale_bits; + data[1] = ctx->sbit.alpha_bits; + + break; + } + case SPNG_COLOR_TYPE_TRUECOLOR_ALPHA: + { + length = 4; + + data[0] = ctx->sbit.red_bits; + data[1] = ctx->sbit.green_bits; + data[2] = ctx->sbit.blue_bits; + data[3] = ctx->sbit.alpha_bits; + + break; + } + default: return SPNG_EINTERNAL; + } + + ret = write_chunk(ctx, type_sbit, data, length); + if(ret) return ret; + } + + if(ctx->stored.srgb) + { + ret = write_chunk(ctx, type_srgb, &ctx->srgb_rendering_intent, 1); + if(ret) return ret; + } + + ret = write_unknown_chunks(ctx, SPNG_AFTER_IHDR); + if(ret) return ret; + + if(ctx->stored.plte) + { + for(i=0; i < ctx->plte.n_entries; i++) + { + data[i * 3 + 0] = ctx->plte.entries[i].red; + data[i * 3 + 1] = ctx->plte.entries[i].green; + data[i * 3 + 2] = ctx->plte.entries[i].blue; + } + + ret = write_chunk(ctx, type_plte, data, ctx->plte.n_entries * 3); + if(ret) return ret; + } + + if(ctx->stored.bkgd) + { + switch(ctx->ihdr.color_type) + { + case SPNG_COLOR_TYPE_GRAYSCALE: + case SPNG_COLOR_TYPE_GRAYSCALE_ALPHA: + { + length = 2; + + write_u16(data, ctx->bkgd.gray); + + break; + } + case SPNG_COLOR_TYPE_TRUECOLOR: + case SPNG_COLOR_TYPE_TRUECOLOR_ALPHA: + { + length = 6; + + write_u16(data, ctx->bkgd.red); + write_u16(data + 2, ctx->bkgd.green); + write_u16(data + 4, ctx->bkgd.blue); + + break; + } + case SPNG_COLOR_TYPE_INDEXED: + { + length = 1; + + data[0] = ctx->bkgd.plte_index; + + break; + } + default: return SPNG_EINTERNAL; + } + + ret = write_chunk(ctx, type_bkgd, data, length); + if(ret) return ret; + } + + if(ctx->stored.hist) + { + length = ctx->plte.n_entries * 2; + + for(i=0; i < ctx->plte.n_entries; i++) + { + write_u16(data + i * 2, ctx->hist.frequency[i]); + } + + ret = write_chunk(ctx, type_hist, data, length); + if(ret) return ret; + } + + if(ctx->stored.trns) + { + if(ctx->ihdr.color_type == SPNG_COLOR_TYPE_GRAYSCALE) + { + write_u16(data, ctx->trns.gray); + + ret = write_chunk(ctx, type_trns, data, 2); + } + else if(ctx->ihdr.color_type == SPNG_COLOR_TYPE_TRUECOLOR) + { + write_u16(data, ctx->trns.red); + write_u16(data + 2, ctx->trns.green); + write_u16(data + 4, ctx->trns.blue); + + ret = write_chunk(ctx, type_trns, data, 6); + } + else if(ctx->ihdr.color_type == SPNG_COLOR_TYPE_INDEXED) + { + ret = write_chunk(ctx, type_trns, ctx->trns.type3_alpha, ctx->trns.n_type3_entries); + } + + if(ret) return ret; + } + + if(ctx->stored.phys) + { + write_u32(data, ctx->phys.ppu_x); + write_u32(data + 4, ctx->phys.ppu_y); + data[8] = ctx->phys.unit_specifier; + + ret = write_chunk(ctx, type_phys, data, 9); + if(ret) return ret; + } + + if(ctx->stored.splt) + { + const struct spng_splt *splt; + unsigned char *cdata = NULL; + + uint32_t k; + for(i=0; i < ctx->n_splt; i++) + { + splt = &ctx->splt_list[i]; + + size_t name_len = strlen(splt->name); + length = name_len + 1; + + if(splt->sample_depth == 8) length += splt->n_entries * 6 + 1; + else if(splt->sample_depth == 16) length += splt->n_entries * 10 + 1; + + ret = write_header(ctx, type_splt, length, &cdata); + if(ret) return ret; + + memcpy(cdata, splt->name, name_len + 1); + cdata += name_len + 2; + cdata[-1] = splt->sample_depth; + + if(splt->sample_depth == 8) + { + for(k=0; k < splt->n_entries; k++) + { + cdata[k * 6 + 0] = splt->entries[k].red; + cdata[k * 6 + 1] = splt->entries[k].green; + cdata[k * 6 + 2] = splt->entries[k].blue; + cdata[k * 6 + 3] = splt->entries[k].alpha; + write_u16(cdata + k * 6 + 4, splt->entries[k].frequency); + } + } + else if(splt->sample_depth == 16) + { + for(k=0; k < splt->n_entries; k++) + { + write_u16(cdata + k * 10 + 0, splt->entries[k].red); + write_u16(cdata + k * 10 + 2, splt->entries[k].green); + write_u16(cdata + k * 10 + 4, splt->entries[k].blue); + write_u16(cdata + k * 10 + 6, splt->entries[k].alpha); + write_u16(cdata + k * 10 + 8, splt->entries[k].frequency); + } + } + + ret = finish_chunk(ctx); + if(ret) return ret; + } + } + + if(ctx->stored.time) + { + write_u16(data, ctx->time.year); + data[2] = ctx->time.month; + data[3] = ctx->time.day; + data[4] = ctx->time.hour; + data[5] = ctx->time.minute; + data[6] = ctx->time.second; + + ret = write_chunk(ctx, type_time, data, 7); + if(ret) return ret; + } + + if(ctx->stored.text) + { + unsigned char *cdata = NULL; + const struct spng_text2 *text; + const uint8_t *text_type_array[4] = { 0, type_text, type_ztxt, type_itxt }; + + for(i=0; i < ctx->n_text; i++) + { + text = &ctx->text_list[i]; + + const uint8_t *text_chunk_type = text_type_array[text->type]; + Bytef *compressed_text = NULL; + size_t keyword_len = 0; + size_t language_tag_len = 0; + size_t translated_keyword_len = 0; + size_t compressed_length = 0; + size_t text_length = 0; + + keyword_len = strlen(text->keyword); + text_length = strlen(text->text); + + length = keyword_len + 1; + + if(text->type == SPNG_ZTXT) + { + length += 1; /* compression method */ + } + else if(text->type == SPNG_ITXT) + { + if(!text->language_tag || !text->translated_keyword) return SPNG_EINTERNAL; + + language_tag_len = strlen(text->language_tag); + translated_keyword_len = strlen(text->translated_keyword); + + length += language_tag_len; + if(length < language_tag_len) return SPNG_EOVERFLOW; + + length += translated_keyword_len; + if(length < translated_keyword_len) return SPNG_EOVERFLOW; + + length += 4; /* compression flag + method + nul for the two strings */ + if(length < 4) return SPNG_EOVERFLOW; + } + + if(text->compression_flag) + { + ret = spng__deflate_init(ctx, &ctx->text_options); + if(ret) return ret; + + z_stream *zstream = &ctx->zstream; + uLongf dest_len = deflateBound(zstream, (uLong)text_length); + + compressed_text = spng__malloc(ctx, dest_len); + + if(compressed_text == NULL) return SPNG_EMEM; + + zstream->next_in = (void*)text->text; + zstream->avail_in = (uInt)text_length; + + zstream->next_out = compressed_text; + zstream->avail_out = dest_len; + + ret = deflate(zstream, Z_FINISH); + + if(ret != Z_STREAM_END) + { + spng__free(ctx, compressed_text); + return SPNG_EZLIB; + } + + compressed_length = zstream->total_out; + + length += compressed_length; + if(length < compressed_length) return SPNG_EOVERFLOW; + } + else + { + text_length = strlen(text->text); + + length += text_length; + if(length < text_length) return SPNG_EOVERFLOW; + } + + ret = write_header(ctx, text_chunk_type, length, &cdata); + if(ret) + { + spng__free(ctx, compressed_text); + return ret; + } + + memcpy(cdata, text->keyword, keyword_len + 1); + cdata += keyword_len + 1; + + if(text->type == SPNG_ITXT) + { + cdata[0] = text->compression_flag; + cdata[1] = 0; /* compression method */ + cdata += 2; + + memcpy(cdata, text->language_tag, language_tag_len + 1); + cdata += language_tag_len + 1; + + memcpy(cdata, text->translated_keyword, translated_keyword_len + 1); + cdata += translated_keyword_len + 1; + } + else if(text->type == SPNG_ZTXT) + { + cdata[0] = 0; /* compression method */ + cdata++; + } + + if(text->compression_flag) memcpy(cdata, compressed_text, compressed_length); + else memcpy(cdata, text->text, text_length); + + spng__free(ctx, compressed_text); + + ret = finish_chunk(ctx); + if(ret) return ret; + } + } + + if(ctx->stored.offs) + { + write_s32(data, ctx->offs.x); + write_s32(data + 4, ctx->offs.y); + data[8] = ctx->offs.unit_specifier; + + ret = write_chunk(ctx, type_offs, data, 9); + if(ret) return ret; + } + + if(ctx->stored.exif) + { + ret = write_chunk(ctx, type_exif, ctx->exif.data, ctx->exif.length); + if(ret) return ret; + } + + ret = write_unknown_chunks(ctx, SPNG_AFTER_PLTE); + if(ret) return ret; + + return 0; +} + +static int write_chunks_after_idat(spng_ctx *ctx) +{ + if(ctx == NULL) return SPNG_EINTERNAL; + + int ret = write_unknown_chunks(ctx, SPNG_AFTER_IDAT); + if(ret) return ret; + + return write_iend(ctx); +} + +/* Compress and write scanline to IDAT stream */ +static int write_idat_bytes(spng_ctx *ctx, const void *scanline, size_t len, int flush) +{ + if(ctx == NULL || scanline == NULL) return SPNG_EINTERNAL; + if(len > UINT_MAX) return SPNG_EINTERNAL; + + int ret = 0; + unsigned char *data = NULL; + z_stream *zstream = &ctx->zstream; + uint32_t idat_length = SPNG_WRITE_SIZE; + + zstream->next_in = scanline; + zstream->avail_in = (uInt)len; + + do + { + ret = deflate(zstream, flush); + + if(zstream->avail_out == 0) + { + ret = finish_chunk(ctx); + if(ret) return encode_err(ctx, ret); + + ret = write_header(ctx, type_idat, idat_length, &data); + if(ret) return encode_err(ctx, ret); + + zstream->next_out = data; + zstream->avail_out = idat_length; + } + + }while(zstream->avail_in); + + if(ret != Z_OK) return SPNG_EZLIB; + + return 0; +} + +static int finish_idat(spng_ctx *ctx) +{ + int ret = 0; + unsigned char *data = NULL; + z_stream *zstream = &ctx->zstream; + uint32_t idat_length = SPNG_WRITE_SIZE; + + while(ret != Z_STREAM_END) + { + ret = deflate(zstream, Z_FINISH); + + if(ret) + { + if(ret == Z_STREAM_END) break; + + if(ret != Z_BUF_ERROR) return SPNG_EZLIB; + } + + if(zstream->avail_out == 0) + { + ret = finish_chunk(ctx); + if(ret) return encode_err(ctx, ret); + + ret = write_header(ctx, type_idat, idat_length, &data); + if(ret) return encode_err(ctx, ret); + + zstream->next_out = data; + zstream->avail_out = idat_length; + } + } + + uint32_t trimmed_length = idat_length - zstream->avail_out; + + ret = trim_chunk(ctx, trimmed_length); + if(ret) return ret; + + return finish_chunk(ctx); +} + +static int encode_scanline(spng_ctx *ctx, const void *scanline, size_t len) +{ + if(ctx == NULL || scanline == NULL) return SPNG_EINTERNAL; + + int ret, pass = ctx->row_info.pass; + uint8_t filter = 0; + struct spng_row_info *ri = &ctx->row_info; + const struct spng_subimage *sub = ctx->subimage; + struct encode_flags f = ctx->encode_flags; + unsigned char *filtered_scanline = ctx->filtered_scanline; + size_t scanline_width = sub[pass].scanline_width; + + if(len < scanline_width - 1) return SPNG_EINTERNAL; + + /* encode_row() interlaces directly to ctx->scanline */ + if(scanline != ctx->scanline) memcpy(ctx->scanline, scanline, scanline_width - 1); + + if(f.to_bigendian) u16_row_to_bigendian(ctx->scanline, scanline_width - 1); + const int requires_previous = f.filter_choice & (SPNG_FILTER_CHOICE_UP | SPNG_FILTER_CHOICE_AVG | SPNG_FILTER_CHOICE_PAETH); + + /* XXX: exclude 'requires_previous' filters by default for first scanline? */ + if(!ri->scanline_idx && requires_previous) + { + /* prev_scanline is all zeros for the first scanline */ + memset(ctx->prev_scanline, 0, scanline_width); + } + + filter = get_best_filter(ctx->prev_scanline, ctx->scanline, scanline_width, ctx->bytes_per_pixel, f.filter_choice); + + if(!filter) filtered_scanline = ctx->scanline; + + filtered_scanline[-1] = filter; + + if(filter) + { + ret = filter_scanline(filtered_scanline, ctx->prev_scanline, ctx->scanline, scanline_width, ctx->bytes_per_pixel, filter); + if(ret) return encode_err(ctx, ret); + } + + ret = write_idat_bytes(ctx, filtered_scanline - 1, scanline_width, Z_NO_FLUSH); + if(ret) return encode_err(ctx, ret); + + /* The previous scanline is always unfiltered */ + void *t = ctx->prev_scanline; + ctx->prev_scanline = ctx->scanline; + ctx->scanline = t; + + ret = update_row_info(ctx); + + if(ret == SPNG_EOI) + { + int error = finish_idat(ctx); + if(error) encode_err(ctx, error); + + if(f.finalize) + { + error = spng_encode_chunks(ctx); + if(error) return encode_err(ctx, error); + } + } + + return ret; +} + +static int encode_row(spng_ctx *ctx, const void *row, size_t len) +{ + if(ctx == NULL || row == NULL) return SPNG_EINTERNAL; + + const int pass = ctx->row_info.pass; + + if(!ctx->ihdr.interlace_method || pass == 6) return encode_scanline(ctx, row, len); + + uint32_t k; + const unsigned pixel_size = ctx->pixel_size; + const unsigned bit_depth = ctx->ihdr.bit_depth; + + if(bit_depth < 8) + { + const unsigned samples_per_byte = 8 / bit_depth; + const uint8_t mask = (1 << bit_depth) - 1; + const unsigned initial_shift = 8 - bit_depth; + unsigned shift_amount = initial_shift; + + unsigned char *scanline = ctx->scanline; + const unsigned char *row_uc = row; + uint8_t sample; + + memset(scanline, 0, ctx->subimage[pass].scanline_width); + + for(k=0; k < ctx->subimage[pass].width; k++) + { + size_t ioffset = adam7_x_start[pass] + k * adam7_x_delta[pass]; + + sample = row_uc[ioffset / samples_per_byte]; + + sample = sample >> (initial_shift - ioffset * bit_depth % 8); + sample = sample & mask; + sample = sample << shift_amount; + + scanline[0] |= sample; + + shift_amount -= bit_depth; + + if(shift_amount > 7) + { + shift_amount = initial_shift; + scanline++; + } + } + + return encode_scanline(ctx, ctx->scanline, len); + } + + for(k=0; k < ctx->subimage[pass].width; k++) + { + size_t ioffset = (adam7_x_start[pass] + (size_t) k * adam7_x_delta[pass]) * pixel_size; + + memcpy(ctx->scanline + k * pixel_size, (unsigned char*)row + ioffset, pixel_size); + } + + return encode_scanline(ctx, ctx->scanline, len); +} + +int spng_encode_scanline(spng_ctx *ctx, const void *scanline, size_t len) +{ + if(ctx == NULL || scanline == NULL) return SPNG_EINVAL; + if(ctx->state >= SPNG_STATE_EOI) return SPNG_EOI; + if(len < (ctx->subimage[ctx->row_info.pass].scanline_width -1) ) return SPNG_EBUFSIZ; + + return encode_scanline(ctx, scanline, len); +} + +int spng_encode_row(spng_ctx *ctx, const void *row, size_t len) +{ + if(ctx == NULL || row == NULL) return SPNG_EINVAL; + if(ctx->state >= SPNG_STATE_EOI) return SPNG_EOI; + if(len < ctx->image_width) return SPNG_EBUFSIZ; + + return encode_row(ctx, row, len); +} + +int spng_encode_chunks(spng_ctx *ctx) +{ + if(ctx == NULL) return 1; + if(!ctx->state) return SPNG_EBADSTATE; + if(ctx->state < SPNG_STATE_OUTPUT) return SPNG_ENODST; + if(!ctx->encode_only) return SPNG_ECTXTYPE; + + int ret = 0; + + if(ctx->state < SPNG_STATE_FIRST_IDAT) + { + if(!ctx->stored.ihdr) return SPNG_ENOIHDR; + + ret = write_chunks_before_idat(ctx); + if(ret) return encode_err(ctx, ret); + + ctx->state = SPNG_STATE_FIRST_IDAT; + } + else if(ctx->state == SPNG_STATE_FIRST_IDAT) + { + return 0; + } + else if(ctx->state == SPNG_STATE_EOI) + { + ret = write_chunks_after_idat(ctx); + if(ret) return encode_err(ctx, ret); + + ctx->state = SPNG_STATE_IEND; + } + else return SPNG_EOPSTATE; + + return 0; +} + +int spng_encode_image(spng_ctx *ctx, const void *img, size_t len, int fmt, int flags) +{ + if(ctx == NULL) return 1; + if(!ctx->state) return SPNG_EBADSTATE; + if(!ctx->encode_only) return SPNG_ECTXTYPE; + if(!ctx->stored.ihdr) return SPNG_ENOIHDR; + if( !(fmt == SPNG_FMT_PNG || fmt == SPNG_FMT_RAW) ) return SPNG_EFMT; + + int ret = 0; + const struct spng_ihdr *ihdr = &ctx->ihdr; + struct encode_flags *encode_flags = &ctx->encode_flags; + + if(ihdr->color_type == SPNG_COLOR_TYPE_INDEXED && !ctx->stored.plte) return SPNG_ENOPLTE; + + ret = calculate_image_width(ihdr, fmt, &ctx->image_width); + if(ret) return encode_err(ctx, ret); + + if(ctx->image_width > SIZE_MAX / ihdr->height) ctx->image_size = 0; /* overflow */ + else ctx->image_size = ctx->image_width * ihdr->height; + + if( !(flags & SPNG_ENCODE_PROGRESSIVE) ) + { + if(img == NULL) return 1; + if(!ctx->image_size) return SPNG_EOVERFLOW; + if(len != ctx->image_size) return SPNG_EBUFSIZ; + } + + ret = spng_encode_chunks(ctx); + if(ret) return encode_err(ctx, ret); + + ret = calculate_subimages(ctx); + if(ret) return encode_err(ctx, ret); + + if(ihdr->bit_depth < 8) ctx->bytes_per_pixel = 1; + else ctx->bytes_per_pixel = num_channels(ihdr) * (ihdr->bit_depth / 8); + + if(spng__optimize(SPNG_FILTER_CHOICE)) + { + /* Filtering would make no difference */ + if(!ctx->image_options.compression_level) + { + encode_flags->filter_choice = SPNG_DISABLE_FILTERING; + } + + /* Palette indices and low bit-depth images do not benefit from filtering */ + if(ihdr->color_type == SPNG_COLOR_TYPE_INDEXED || ihdr->bit_depth < 8) + { + encode_flags->filter_choice = SPNG_DISABLE_FILTERING; + } + } + + /* This is technically the same as disabling filtering */ + if(encode_flags->filter_choice == SPNG_FILTER_CHOICE_NONE) + { + encode_flags->filter_choice = SPNG_DISABLE_FILTERING; + } + + if(!encode_flags->filter_choice && spng__optimize(SPNG_IMG_COMPRESSION_STRATEGY)) + { + ctx->image_options.strategy = Z_DEFAULT_STRATEGY; + } + + ret = spng__deflate_init(ctx, &ctx->image_options); + if(ret) return encode_err(ctx, ret); + + size_t scanline_buf_size = ctx->subimage[ctx->widest_pass].scanline_width; + + scanline_buf_size += 32; + + if(scanline_buf_size < 32) return SPNG_EOVERFLOW; + + ctx->scanline_buf = spng__malloc(ctx, scanline_buf_size); + ctx->prev_scanline_buf = spng__malloc(ctx, scanline_buf_size); + + if(ctx->scanline_buf == NULL || ctx->prev_scanline_buf == NULL) return encode_err(ctx, SPNG_EMEM); + + /* Maintain alignment for pixels, filter at [-1] */ + ctx->scanline = ctx->scanline_buf + 16; + ctx->prev_scanline = ctx->prev_scanline_buf + 16; + + if(encode_flags->filter_choice) + { + ctx->filtered_scanline_buf = spng__malloc(ctx, scanline_buf_size); + if(ctx->filtered_scanline_buf == NULL) return encode_err(ctx, SPNG_EMEM); + + ctx->filtered_scanline = ctx->filtered_scanline_buf + 16; + } + + struct spng_subimage *sub = ctx->subimage; + struct spng_row_info *ri = &ctx->row_info; + + ctx->fmt = fmt; + + z_stream *zstream = &ctx->zstream; + zstream->avail_out = SPNG_WRITE_SIZE; + + ret = write_header(ctx, type_idat, zstream->avail_out, &zstream->next_out); + if(ret) return encode_err(ctx, ret); + + if(ihdr->interlace_method) encode_flags->interlace = 1; + + if(fmt & (SPNG_FMT_PNG | SPNG_FMT_RAW) ) encode_flags->same_layout = 1; + + if(ihdr->bit_depth == 16 && fmt != SPNG_FMT_RAW) encode_flags->to_bigendian = 1; + + if(flags & SPNG_ENCODE_FINALIZE) encode_flags->finalize = 1; + + while(!sub[ri->pass].width || !sub[ri->pass].height) ri->pass++; + + if(encode_flags->interlace) ri->row_num = adam7_y_start[ri->pass]; + + ctx->pixel_size = 4; /* SPNG_FMT_RGBA8 */ + + if(fmt == SPNG_FMT_RGBA16) ctx->pixel_size = 8; + else if(fmt == SPNG_FMT_RGB8) ctx->pixel_size = 3; + else if(fmt == SPNG_FMT_G8) ctx->pixel_size = 1; + else if(fmt == SPNG_FMT_GA8) ctx->pixel_size = 2; + else if(fmt & (SPNG_FMT_PNG | SPNG_FMT_RAW)) ctx->pixel_size = ctx->bytes_per_pixel; + + ctx->state = SPNG_STATE_ENCODE_INIT; + + if(flags & SPNG_ENCODE_PROGRESSIVE) + { + encode_flags->progressive = 1; + + return 0; + } + + do + { + size_t ioffset = ri->row_num * ctx->image_width; + + ret = encode_row(ctx, (unsigned char*)img + ioffset, ctx->image_width); + + }while(!ret); + + if(ret != SPNG_EOI) return encode_err(ctx, ret); + + return 0; +} + +spng_ctx *spng_ctx_new(int flags) +{ + struct spng_alloc alloc = + { + .malloc_fn = malloc, + .realloc_fn = realloc, + .calloc_fn = calloc, + .free_fn = free + }; + + return spng_ctx_new2(&alloc, flags); +} + +spng_ctx *spng_ctx_new2(struct spng_alloc *alloc, int flags) +{ + if(alloc == NULL) return NULL; + if(flags != (flags & SPNG__CTX_FLAGS_ALL)) return NULL; + + if(alloc->malloc_fn == NULL) return NULL; + if(alloc->realloc_fn == NULL) return NULL; + if(alloc->calloc_fn == NULL) return NULL; + if(alloc->free_fn == NULL) return NULL; + + spng_ctx *ctx = alloc->calloc_fn(1, sizeof(spng_ctx)); + if(ctx == NULL) return NULL; + + ctx->alloc = *alloc; + + ctx->max_width = spng_u32max; + ctx->max_height = spng_u32max; + + ctx->max_chunk_size = spng_u32max; + ctx->chunk_cache_limit = SIZE_MAX; + ctx->chunk_count_limit = SPNG_MAX_CHUNK_COUNT; + + ctx->state = SPNG_STATE_INIT; + + ctx->crc_action_critical = SPNG_CRC_ERROR; + ctx->crc_action_ancillary = SPNG_CRC_DISCARD; + + const struct spng__zlib_options image_defaults = + { + .compression_level = Z_DEFAULT_COMPRESSION, + .window_bits = 15, + .mem_level = 8, + .strategy = Z_FILTERED, + .data_type = 0 /* Z_BINARY */ + }; + + const struct spng__zlib_options text_defaults = + { + .compression_level = Z_DEFAULT_COMPRESSION, + .window_bits = 15, + .mem_level = 8, + .strategy = Z_DEFAULT_STRATEGY, + .data_type = 1 /* Z_TEXT */ + }; + + ctx->image_options = image_defaults; + ctx->text_options = text_defaults; + + ctx->optimize_option = ~0; + ctx->encode_flags.filter_choice = SPNG_FILTER_CHOICE_ALL; + + ctx->flags = flags; + + if(flags & SPNG_CTX_ENCODER) ctx->encode_only = 1; + + return ctx; +} + +void spng_ctx_free(spng_ctx *ctx) +{ + if(ctx == NULL) return; + + if(ctx->streaming && ctx->stream_buf != NULL) spng__free(ctx, ctx->stream_buf); + + if(!ctx->user.exif) spng__free(ctx, ctx->exif.data); + + if(!ctx->user.iccp) spng__free(ctx, ctx->iccp.profile); + + uint32_t i; + + if(ctx->splt_list != NULL && !ctx->user.splt) + { + for(i=0; i < ctx->n_splt; i++) + { + spng__free(ctx, ctx->splt_list[i].entries); + } + spng__free(ctx, ctx->splt_list); + } + + if(ctx->text_list != NULL) + { + for(i=0; i< ctx->n_text; i++) + { + if(ctx->user.text) break; + + spng__free(ctx, ctx->text_list[i].keyword); + if(ctx->text_list[i].compression_flag) spng__free(ctx, ctx->text_list[i].text); + } + spng__free(ctx, ctx->text_list); + } + + if(ctx->chunk_list != NULL && !ctx->user.unknown) + { + for(i=0; i< ctx->n_chunks; i++) + { + spng__free(ctx, ctx->chunk_list[i].data); + } + spng__free(ctx, ctx->chunk_list); + } + + if(ctx->deflate) deflateEnd(&ctx->zstream); + else inflateEnd(&ctx->zstream); + + if(!ctx->user_owns_out_png) spng__free(ctx, ctx->out_png); + + spng__free(ctx, ctx->gamma_lut16); + + spng__free(ctx, ctx->row_buf); + spng__free(ctx, ctx->scanline_buf); + spng__free(ctx, ctx->prev_scanline_buf); + spng__free(ctx, ctx->filtered_scanline_buf); + + spng_free_fn *free_fn = ctx->alloc.free_fn; + + memset(ctx, 0, sizeof(spng_ctx)); + + free_fn(ctx); +} + +static int buffer_read_fn(spng_ctx *ctx, void *user, void *data, size_t n) +{ + if(n > ctx->bytes_left) return SPNG_IO_EOF; + + (void)user; + (void)data; + ctx->data = ctx->data + ctx->last_read_size; + + ctx->last_read_size = n; + ctx->bytes_left -= n; + + return 0; +} + +static int file_read_fn(spng_ctx *ctx, void *user, void *data, size_t n) +{ + FILE *file = user; + (void)ctx; + + if(fread(data, n, 1, file) != 1) + { + if(feof(file)) return SPNG_IO_EOF; + else return SPNG_IO_ERROR; + } + + return 0; +} + +static int file_write_fn(spng_ctx *ctx, void *user, void *data, size_t n) +{ + FILE *file = user; + (void)ctx; + + if(fwrite(data, n, 1, file) != 1) return SPNG_IO_ERROR; + + return 0; +} + +int spng_set_png_buffer(spng_ctx *ctx, const void *buf, size_t size) +{ + if(ctx == NULL || buf == NULL) return 1; + if(!ctx->state) return SPNG_EBADSTATE; + if(ctx->encode_only) return SPNG_ECTXTYPE; /* not supported */ + + if(ctx->data != NULL) return SPNG_EBUF_SET; + + ctx->data = buf; + ctx->png_base = buf; + ctx->data_size = size; + ctx->bytes_left = size; + + ctx->read_fn = buffer_read_fn; + + ctx->state = SPNG_STATE_INPUT; + + return 0; +} + +int spng_set_png_stream(spng_ctx *ctx, spng_rw_fn *rw_func, void *user) +{ + if(ctx == NULL || rw_func == NULL) return 1; + if(!ctx->state) return SPNG_EBADSTATE; + + /* SPNG_STATE_OUTPUT shares the same value */ + if(ctx->state >= SPNG_STATE_INPUT) return SPNG_EBUF_SET; + + if(ctx->encode_only) + { + if(ctx->out_png != NULL) return SPNG_EBUF_SET; + + ctx->write_fn = rw_func; + ctx->write_ptr = ctx->stream_buf; + + ctx->state = SPNG_STATE_OUTPUT; + } + else + { + ctx->stream_buf = spng__malloc(ctx, SPNG_READ_SIZE); + if(ctx->stream_buf == NULL) return SPNG_EMEM; + + ctx->read_fn = rw_func; + ctx->data = ctx->stream_buf; + ctx->data_size = SPNG_READ_SIZE; + + ctx->state = SPNG_STATE_INPUT; + } + + ctx->stream_user_ptr = user; + + ctx->streaming = 1; + + return 0; +} + +int spng_set_png_file(spng_ctx *ctx, FILE *file) +{ + if(file == NULL) return 1; + + if(ctx->encode_only) return spng_set_png_stream(ctx, file_write_fn, file); + + return spng_set_png_stream(ctx, file_read_fn, file); +} + +void *spng_get_png_buffer(spng_ctx *ctx, size_t *len, int *error) +{ + int tmp = 0; + error = error ? error : &tmp; + *error = 0; + + if(ctx == NULL || !len) *error = SPNG_EINVAL; + + if(*error) return NULL; + + if(!ctx->encode_only) *error = SPNG_ECTXTYPE; + else if(!ctx->state) *error = SPNG_EBADSTATE; + else if(!ctx->internal_buffer) *error = SPNG_EOPSTATE; + else if(ctx->state < SPNG_STATE_EOI) *error = SPNG_EOPSTATE; + else if(ctx->state != SPNG_STATE_IEND) *error = SPNG_ENOTFINAL; + + if(*error) return NULL; + + ctx->user_owns_out_png = 1; + + *len = ctx->bytes_encoded; + + return ctx->out_png; +} + +int spng_set_image_limits(spng_ctx *ctx, uint32_t width, uint32_t height) +{ + if(ctx == NULL) return 1; + + if(width > spng_u32max || height > spng_u32max) return 1; + + ctx->max_width = width; + ctx->max_height = height; + + return 0; +} + +int spng_get_image_limits(spng_ctx *ctx, uint32_t *width, uint32_t *height) +{ + if(ctx == NULL || width == NULL || height == NULL) return 1; + + *width = ctx->max_width; + *height = ctx->max_height; + + return 0; +} + +int spng_set_chunk_limits(spng_ctx *ctx, size_t chunk_size, size_t cache_limit) +{ + if(ctx == NULL || chunk_size > spng_u32max || chunk_size > cache_limit) return 1; + + ctx->max_chunk_size = chunk_size; + + ctx->chunk_cache_limit = cache_limit; + + return 0; +} + +int spng_get_chunk_limits(spng_ctx *ctx, size_t *chunk_size, size_t *cache_limit) +{ + if(ctx == NULL || chunk_size == NULL || cache_limit == NULL) return 1; + + *chunk_size = ctx->max_chunk_size; + + *cache_limit = ctx->chunk_cache_limit; + + return 0; +} + +int spng_set_crc_action(spng_ctx *ctx, int critical, int ancillary) +{ + if(ctx == NULL) return 1; + if(ctx->encode_only) return SPNG_ECTXTYPE; + + if(critical > 2 || critical < 0) return 1; + if(ancillary > 2 || ancillary < 0) return 1; + + if(critical == SPNG_CRC_DISCARD) return 1; + + ctx->crc_action_critical = critical; + ctx->crc_action_ancillary = ancillary; + + return 0; +} + +int spng_set_option(spng_ctx *ctx, enum spng_option option, int value) +{ + if(ctx == NULL) return 1; + if(!ctx->state) return SPNG_EBADSTATE; + + switch(option) + { + case SPNG_KEEP_UNKNOWN_CHUNKS: + { + ctx->keep_unknown = value ? 1 : 0; + break; + } + case SPNG_IMG_COMPRESSION_LEVEL: + { + ctx->image_options.compression_level = value; + break; + } + case SPNG_IMG_WINDOW_BITS: + { + ctx->image_options.window_bits = value; + break; + } + case SPNG_IMG_MEM_LEVEL: + { + ctx->image_options.mem_level = value; + break; + } + case SPNG_IMG_COMPRESSION_STRATEGY: + { + ctx->image_options.strategy = value; + break; + } + case SPNG_TEXT_COMPRESSION_LEVEL: + { + ctx->text_options.compression_level = value; + break; + } + case SPNG_TEXT_WINDOW_BITS: + { + ctx->text_options.window_bits = value; + break; + } + case SPNG_TEXT_MEM_LEVEL: + { + ctx->text_options.mem_level = value; + break; + } + case SPNG_TEXT_COMPRESSION_STRATEGY: + { + ctx->text_options.strategy = value; + break; + } + case SPNG_FILTER_CHOICE: + { + if(value & ~SPNG_FILTER_CHOICE_ALL) return 1; + ctx->encode_flags.filter_choice = value; + break; + } + case SPNG_CHUNK_COUNT_LIMIT: + { + if(value < 0) return 1; + if(value > (int)ctx->chunk_count_total) return 1; + ctx->chunk_count_limit = value; + break; + } + case SPNG_ENCODE_TO_BUFFER: + { + if(value < 0) return 1; + if(!ctx->encode_only) return SPNG_ECTXTYPE; + if(ctx->state >= SPNG_STATE_OUTPUT) return SPNG_EOPSTATE; + + if(!value) break; + + ctx->internal_buffer = 1; + ctx->state = SPNG_STATE_OUTPUT; + + break; + } + default: return 1; + } + + /* Option can no longer be overriden by the library */ + if(option < 32) ctx->optimize_option &= ~(1 << option); + + return 0; +} + +int spng_get_option(spng_ctx *ctx, enum spng_option option, int *value) +{ + if(ctx == NULL || value == NULL) return 1; + if(!ctx->state) return SPNG_EBADSTATE; + + switch(option) + { + case SPNG_KEEP_UNKNOWN_CHUNKS: + { + *value = ctx->keep_unknown; + break; + } + case SPNG_IMG_COMPRESSION_LEVEL: + { + *value = ctx->image_options.compression_level; + break; + } + case SPNG_IMG_WINDOW_BITS: + { + *value = ctx->image_options.window_bits; + break; + } + case SPNG_IMG_MEM_LEVEL: + { + *value = ctx->image_options.mem_level; + break; + } + case SPNG_IMG_COMPRESSION_STRATEGY: + { + *value = ctx->image_options.strategy; + break; + } + case SPNG_TEXT_COMPRESSION_LEVEL: + { + *value = ctx->text_options.compression_level; + break; + } + case SPNG_TEXT_WINDOW_BITS: + { + *value = ctx->text_options.window_bits; + break; + } + case SPNG_TEXT_MEM_LEVEL: + { + *value = ctx->text_options.mem_level; + break; + } + case SPNG_TEXT_COMPRESSION_STRATEGY: + { + *value = ctx->text_options.strategy; + break; + } + case SPNG_FILTER_CHOICE: + { + *value = ctx->encode_flags.filter_choice; + break; + } + case SPNG_CHUNK_COUNT_LIMIT: + { + *value = ctx->chunk_count_limit; + break; + } + case SPNG_ENCODE_TO_BUFFER: + { + if(ctx->internal_buffer) *value = 1; + else *value = 0; + + break; + } + default: return 1; + } + + return 0; +} + +int spng_decoded_image_size(spng_ctx *ctx, int fmt, size_t *len) +{ + if(ctx == NULL || len == NULL) return 1; + + int ret = read_chunks(ctx, 1); + if(ret) return ret; + + ret = check_decode_fmt(&ctx->ihdr, fmt); + if(ret) return ret; + + return calculate_image_size(&ctx->ihdr, fmt, len); +} + +int spng_get_ihdr(spng_ctx *ctx, struct spng_ihdr *ihdr) +{ + if(ctx == NULL) return 1; + int ret = read_chunks(ctx, 1); + if(ret) return ret; + if(ihdr == NULL) return 1; + + *ihdr = ctx->ihdr; + + return 0; +} + +int spng_get_plte(spng_ctx *ctx, struct spng_plte *plte) +{ + SPNG_GET_CHUNK_BOILERPLATE(plte); + + *plte = ctx->plte; + + return 0; +} + +int spng_get_trns(spng_ctx *ctx, struct spng_trns *trns) +{ + SPNG_GET_CHUNK_BOILERPLATE(trns); + + *trns = ctx->trns; + + return 0; +} + +int spng_get_chrm(spng_ctx *ctx, struct spng_chrm *chrm) +{ + SPNG_GET_CHUNK_BOILERPLATE(chrm); + + chrm->white_point_x = (double)ctx->chrm_int.white_point_x / 100000.0; + chrm->white_point_y = (double)ctx->chrm_int.white_point_y / 100000.0; + chrm->red_x = (double)ctx->chrm_int.red_x / 100000.0; + chrm->red_y = (double)ctx->chrm_int.red_y / 100000.0; + chrm->blue_y = (double)ctx->chrm_int.blue_y / 100000.0; + chrm->blue_x = (double)ctx->chrm_int.blue_x / 100000.0; + chrm->green_x = (double)ctx->chrm_int.green_x / 100000.0; + chrm->green_y = (double)ctx->chrm_int.green_y / 100000.0; + + return 0; +} + +int spng_get_chrm_int(spng_ctx *ctx, struct spng_chrm_int *chrm) +{ + SPNG_GET_CHUNK_BOILERPLATE(chrm); + + *chrm = ctx->chrm_int; + + return 0; +} + +int spng_get_gama(spng_ctx *ctx, double *gamma) +{ + double *gama = gamma; + SPNG_GET_CHUNK_BOILERPLATE(gama); + + *gama = (double)ctx->gama / 100000.0; + + return 0; +} + +int spng_get_gama_int(spng_ctx *ctx, uint32_t *gama_int) +{ + uint32_t *gama = gama_int; + SPNG_GET_CHUNK_BOILERPLATE(gama); + + *gama_int = ctx->gama; + + return 0; +} + +int spng_get_iccp(spng_ctx *ctx, struct spng_iccp *iccp) +{ + SPNG_GET_CHUNK_BOILERPLATE(iccp); + + *iccp = ctx->iccp; + + return 0; +} + +int spng_get_sbit(spng_ctx *ctx, struct spng_sbit *sbit) +{ + SPNG_GET_CHUNK_BOILERPLATE(sbit); + + *sbit = ctx->sbit; + + return 0; +} + +int spng_get_srgb(spng_ctx *ctx, uint8_t *rendering_intent) +{ + uint8_t *srgb = rendering_intent; + SPNG_GET_CHUNK_BOILERPLATE(srgb); + + *srgb = ctx->srgb_rendering_intent; + + return 0; +} + +int spng_get_text(spng_ctx *ctx, struct spng_text *text, uint32_t *n_text) +{ + if(ctx == NULL) return 1; + int ret = read_chunks(ctx, 0); + if(ret) return ret; + if(!ctx->stored.text) return SPNG_ECHUNKAVAIL; + if(n_text == NULL) return 1; + + if(text == NULL) + { + *n_text = ctx->n_text; + return 0; + } + + if(*n_text < ctx->n_text) return 1; + + uint32_t i; + for(i=0; i< ctx->n_text; i++) + { + text[i].type = ctx->text_list[i].type; + memcpy(&text[i].keyword, ctx->text_list[i].keyword, strlen(ctx->text_list[i].keyword) + 1); + text[i].compression_method = 0; + text[i].compression_flag = ctx->text_list[i].compression_flag; + text[i].language_tag = ctx->text_list[i].language_tag; + text[i].translated_keyword = ctx->text_list[i].translated_keyword; + text[i].length = ctx->text_list[i].text_length; + text[i].text = ctx->text_list[i].text; + } + + return ret; +} + +int spng_get_bkgd(spng_ctx *ctx, struct spng_bkgd *bkgd) +{ + SPNG_GET_CHUNK_BOILERPLATE(bkgd); + + *bkgd = ctx->bkgd; + + return 0; +} + +int spng_get_hist(spng_ctx *ctx, struct spng_hist *hist) +{ + SPNG_GET_CHUNK_BOILERPLATE(hist); + + *hist = ctx->hist; + + return 0; +} + +int spng_get_phys(spng_ctx *ctx, struct spng_phys *phys) +{ + SPNG_GET_CHUNK_BOILERPLATE(phys); + + *phys = ctx->phys; + + return 0; +} + +int spng_get_splt(spng_ctx *ctx, struct spng_splt *splt, uint32_t *n_splt) +{ + if(ctx == NULL) return 1; + int ret = read_chunks(ctx, 0); + if(ret) return ret; + if(!ctx->stored.splt) return SPNG_ECHUNKAVAIL; + if(n_splt == NULL) return 1; + + if(splt == NULL) + { + *n_splt = ctx->n_splt; + return 0; + } + + if(*n_splt < ctx->n_splt) return 1; + + memcpy(splt, ctx->splt_list, ctx->n_splt * sizeof(struct spng_splt)); + + return 0; +} + +int spng_get_time(spng_ctx *ctx, struct spng_time *time) +{ + SPNG_GET_CHUNK_BOILERPLATE(time); + + *time = ctx->time; + + return 0; +} + +int spng_get_unknown_chunks(spng_ctx *ctx, struct spng_unknown_chunk *chunks, uint32_t *n_chunks) +{ + if(ctx == NULL) return 1; + int ret = read_chunks(ctx, 0); + if(ret) return ret; + if(!ctx->stored.unknown) return SPNG_ECHUNKAVAIL; + if(n_chunks == NULL) return 1; + + if(chunks == NULL) + { + *n_chunks = ctx->n_chunks; + return 0; + } + + if(*n_chunks < ctx->n_chunks) return 1; + + memcpy(chunks, ctx->chunk_list, sizeof(struct spng_unknown_chunk)); + + return 0; +} + +int spng_get_offs(spng_ctx *ctx, struct spng_offs *offs) +{ + SPNG_GET_CHUNK_BOILERPLATE(offs); + + *offs = ctx->offs; + + return 0; +} + +int spng_get_exif(spng_ctx *ctx, struct spng_exif *exif) +{ + SPNG_GET_CHUNK_BOILERPLATE(exif); + + *exif = ctx->exif; + + return 0; +} + +int spng_set_ihdr(spng_ctx *ctx, struct spng_ihdr *ihdr) +{ + SPNG_SET_CHUNK_BOILERPLATE(ihdr); + + if(ctx->stored.ihdr) return 1; + + ret = check_ihdr(ihdr, ctx->max_width, ctx->max_height); + if(ret) return ret; + + ctx->ihdr = *ihdr; + + ctx->stored.ihdr = 1; + ctx->user.ihdr = 1; + + return 0; +} + +int spng_set_plte(spng_ctx *ctx, struct spng_plte *plte) +{ + SPNG_SET_CHUNK_BOILERPLATE(plte); + + if(!ctx->stored.ihdr) return 1; + + if(check_plte(plte, &ctx->ihdr)) return 1; + + ctx->plte.n_entries = plte->n_entries; + + memcpy(ctx->plte.entries, plte->entries, plte->n_entries * sizeof(struct spng_plte_entry)); + + ctx->stored.plte = 1; + ctx->user.plte = 1; + + return 0; +} + +int spng_set_trns(spng_ctx *ctx, struct spng_trns *trns) +{ + SPNG_SET_CHUNK_BOILERPLATE(trns); + + if(!ctx->stored.ihdr) return SPNG_ENOIHDR; + + if(ctx->ihdr.color_type == SPNG_COLOR_TYPE_GRAYSCALE) + { + ctx->trns.gray = trns->gray; + } + else if(ctx->ihdr.color_type == SPNG_COLOR_TYPE_TRUECOLOR) + { + ctx->trns.red = trns->red; + ctx->trns.green = trns->green; + ctx->trns.blue = trns->blue; + } + else if(ctx->ihdr.color_type == SPNG_COLOR_TYPE_INDEXED) + { + if(!ctx->stored.plte) return SPNG_ETRNS_NO_PLTE; + if(trns->n_type3_entries > ctx->plte.n_entries) return 1; + + ctx->trns.n_type3_entries = trns->n_type3_entries; + memcpy(ctx->trns.type3_alpha, trns->type3_alpha, trns->n_type3_entries); + } + else return SPNG_ETRNS_COLOR_TYPE; + + ctx->stored.trns = 1; + ctx->user.trns = 1; + + return 0; +} + +int spng_set_chrm(spng_ctx *ctx, struct spng_chrm *chrm) +{ + SPNG_SET_CHUNK_BOILERPLATE(chrm); + + struct spng_chrm_int chrm_int; + + chrm_int.white_point_x = (uint32_t)(chrm->white_point_x * 100000.0); + chrm_int.white_point_y = (uint32_t)(chrm->white_point_y * 100000.0); + chrm_int.red_x = (uint32_t)(chrm->red_x * 100000.0); + chrm_int.red_y = (uint32_t)(chrm->red_y * 100000.0); + chrm_int.green_x = (uint32_t)(chrm->green_x * 100000.0); + chrm_int.green_y = (uint32_t)(chrm->green_y * 100000.0); + chrm_int.blue_x = (uint32_t)(chrm->blue_x * 100000.0); + chrm_int.blue_y = (uint32_t)(chrm->blue_y * 100000.0); + + if(check_chrm_int(&chrm_int)) return SPNG_ECHRM; + + ctx->chrm_int = chrm_int; + + ctx->stored.chrm = 1; + ctx->user.chrm = 1; + + return 0; +} + +int spng_set_chrm_int(spng_ctx *ctx, struct spng_chrm_int *chrm_int) +{ + SPNG_SET_CHUNK_BOILERPLATE(chrm_int); + + if(check_chrm_int(chrm_int)) return SPNG_ECHRM; + + ctx->chrm_int = *chrm_int; + + ctx->stored.chrm = 1; + ctx->user.chrm = 1; + + return 0; +} + +int spng_set_gama(spng_ctx *ctx, double gamma) +{ + SPNG_SET_CHUNK_BOILERPLATE(ctx); + + uint32_t gama = gamma * 100000.0; + + if(!gama) return 1; + if(gama > spng_u32max) return 1; + + ctx->gama = gama; + + ctx->stored.gama = 1; + ctx->user.gama = 1; + + return 0; +} + +int spng_set_gama_int(spng_ctx *ctx, uint32_t gamma) +{ + SPNG_SET_CHUNK_BOILERPLATE(ctx); + + if(!gamma) return 1; + if(gamma > spng_u32max) return 1; + + ctx->gama = gamma; + + ctx->stored.gama = 1; + ctx->user.gama = 1; + + return 0; +} + +int spng_set_iccp(spng_ctx *ctx, struct spng_iccp *iccp) +{ + SPNG_SET_CHUNK_BOILERPLATE(iccp); + + if(check_png_keyword(iccp->profile_name)) return SPNG_EICCP_NAME; + if(!iccp->profile_len) return SPNG_ECHUNK_SIZE; + if(iccp->profile_len > spng_u32max) return SPNG_ECHUNK_STDLEN; + + if(ctx->iccp.profile && !ctx->user.iccp) spng__free(ctx, ctx->iccp.profile); + + ctx->iccp = *iccp; + + ctx->stored.iccp = 1; + ctx->user.iccp = 1; + + return 0; +} + +int spng_set_sbit(spng_ctx *ctx, struct spng_sbit *sbit) +{ + SPNG_SET_CHUNK_BOILERPLATE(sbit); + + if(check_sbit(sbit, &ctx->ihdr)) return 1; + + if(!ctx->stored.ihdr) return 1; + + ctx->sbit = *sbit; + + ctx->stored.sbit = 1; + ctx->user.sbit = 1; + + return 0; +} + +int spng_set_srgb(spng_ctx *ctx, uint8_t rendering_intent) +{ + SPNG_SET_CHUNK_BOILERPLATE(ctx); + + if(rendering_intent > 3) return 1; + + ctx->srgb_rendering_intent = rendering_intent; + + ctx->stored.srgb = 1; + ctx->user.srgb = 1; + + return 0; +} + +int spng_set_text(spng_ctx *ctx, struct spng_text *text, uint32_t n_text) +{ + if(!n_text) return 1; + SPNG_SET_CHUNK_BOILERPLATE(text); + + uint32_t i; + for(i=0; i < n_text; i++) + { + if(check_png_keyword(text[i].keyword)) return SPNG_ETEXT_KEYWORD; + if(!text[i].length) return 1; + if(text[i].length > UINT_MAX) return 1; + if(text[i].text == NULL) return 1; + + if(text[i].type == SPNG_TEXT) + { + if(ctx->strict && check_png_text(text[i].text, text[i].length)) return 1; + } + else if(text[i].type == SPNG_ZTXT) + { + if(ctx->strict && check_png_text(text[i].text, text[i].length)) return 1; + + if(text[i].compression_method != 0) return SPNG_EZTXT_COMPRESSION_METHOD; + } + else if(text[i].type == SPNG_ITXT) + { + if(text[i].compression_flag > 1) return SPNG_EITXT_COMPRESSION_FLAG; + if(text[i].compression_method != 0) return SPNG_EITXT_COMPRESSION_METHOD; + if(text[i].language_tag == NULL) return SPNG_EITXT_LANG_TAG; + if(text[i].translated_keyword == NULL) return SPNG_EITXT_TRANSLATED_KEY; + } + else return 1; + + } + + struct spng_text2 *text_list = spng__calloc(ctx, sizeof(struct spng_text2), n_text); + + if(!text_list) return SPNG_EMEM; + + if(ctx->text_list != NULL) + { + for(i=0; i < ctx->n_text; i++) + { + if(ctx->user.text) break; + + spng__free(ctx, ctx->text_list[i].keyword); + if(ctx->text_list[i].compression_flag) spng__free(ctx, ctx->text_list[i].text); + } + spng__free(ctx, ctx->text_list); + } + + for(i=0; i < n_text; i++) + { + text_list[i].type = text[i].type; + /* Prevent issues with spng_text.keyword[80] going out of scope */ + text_list[i].keyword = text_list[i].user_keyword_storage; + memcpy(text_list[i].user_keyword_storage, text[i].keyword, strlen(text[i].keyword)); + text_list[i].text = text[i].text; + text_list[i].text_length = text[i].length; + + if(text[i].type == SPNG_ZTXT) + { + text_list[i].compression_flag = 1; + } + else if(text[i].type == SPNG_ITXT) + { + text_list[i].compression_flag = text[i].compression_flag; + text_list[i].language_tag = text[i].language_tag; + text_list[i].translated_keyword = text[i].translated_keyword; + } + } + + ctx->text_list = text_list; + ctx->n_text = n_text; + + ctx->stored.text = 1; + ctx->user.text = 1; + + return 0; +} + +int spng_set_bkgd(spng_ctx *ctx, struct spng_bkgd *bkgd) +{ + SPNG_SET_CHUNK_BOILERPLATE(bkgd); + + if(!ctx->stored.ihdr) return 1; + + if(ctx->ihdr.color_type == 0 || ctx->ihdr.color_type == 4) + { + ctx->bkgd.gray = bkgd->gray; + } + else if(ctx->ihdr.color_type == 2 || ctx->ihdr.color_type == 6) + { + ctx->bkgd.red = bkgd->red; + ctx->bkgd.green = bkgd->green; + ctx->bkgd.blue = bkgd->blue; + } + else if(ctx->ihdr.color_type == 3) + { + if(!ctx->stored.plte) return SPNG_EBKGD_NO_PLTE; + if(bkgd->plte_index >= ctx->plte.n_entries) return SPNG_EBKGD_PLTE_IDX; + + ctx->bkgd.plte_index = bkgd->plte_index; + } + + ctx->stored.bkgd = 1; + ctx->user.bkgd = 1; + + return 0; +} + +int spng_set_hist(spng_ctx *ctx, struct spng_hist *hist) +{ + SPNG_SET_CHUNK_BOILERPLATE(hist); + + if(!ctx->stored.plte) return SPNG_EHIST_NO_PLTE; + + ctx->hist = *hist; + + ctx->stored.hist = 1; + ctx->user.hist = 1; + + return 0; +} + +int spng_set_phys(spng_ctx *ctx, struct spng_phys *phys) +{ + SPNG_SET_CHUNK_BOILERPLATE(phys); + + if(check_phys(phys)) return SPNG_EPHYS; + + ctx->phys = *phys; + + ctx->stored.phys = 1; + ctx->user.phys = 1; + + return 0; +} + +int spng_set_splt(spng_ctx *ctx, struct spng_splt *splt, uint32_t n_splt) +{ + if(!n_splt) return 1; + SPNG_SET_CHUNK_BOILERPLATE(splt); + + uint32_t i; + for(i=0; i < n_splt; i++) + { + if(check_png_keyword(splt[i].name)) return SPNG_ESPLT_NAME; + if( !(splt[i].sample_depth == 8 || splt[i].sample_depth == 16) ) return SPNG_ESPLT_DEPTH; + } + + if(ctx->stored.splt && !ctx->user.splt) + { + for(i=0; i < ctx->n_splt; i++) + { + if(ctx->splt_list[i].entries != NULL) spng__free(ctx, ctx->splt_list[i].entries); + } + spng__free(ctx, ctx->splt_list); + } + + ctx->splt_list = splt; + ctx->n_splt = n_splt; + + ctx->stored.splt = 1; + ctx->user.splt = 1; + + return 0; +} + +int spng_set_time(spng_ctx *ctx, struct spng_time *time) +{ + SPNG_SET_CHUNK_BOILERPLATE(time); + + if(check_time(time)) return SPNG_ETIME; + + ctx->time = *time; + + ctx->stored.time = 1; + ctx->user.time = 1; + + return 0; +} + +int spng_set_unknown_chunks(spng_ctx *ctx, struct spng_unknown_chunk *chunks, uint32_t n_chunks) +{ + if(!n_chunks) return 1; + SPNG_SET_CHUNK_BOILERPLATE(chunks); + + uint32_t i; + for(i=0; i < n_chunks; i++) + { + if(chunks[i].length > spng_u32max) return SPNG_ECHUNK_STDLEN; + if(chunks[i].length && chunks[i].data == NULL) return 1; + + switch(chunks[i].location) + { + case SPNG_AFTER_IHDR: + case SPNG_AFTER_PLTE: + case SPNG_AFTER_IDAT: + break; + default: return SPNG_ECHUNK_POS; + } + } + + if(ctx->stored.unknown && !ctx->user.unknown) + { + for(i=0; i < ctx->n_chunks; i++) + { + spng__free(ctx, ctx->chunk_list[i].data); + } + spng__free(ctx, ctx->chunk_list); + } + + ctx->chunk_list = chunks; + ctx->n_chunks = n_chunks; + + ctx->stored.unknown = 1; + ctx->user.unknown = 1; + + return 0; +} + +int spng_set_offs(spng_ctx *ctx, struct spng_offs *offs) +{ + SPNG_SET_CHUNK_BOILERPLATE(offs); + + if(check_offs(offs)) return SPNG_EOFFS; + + ctx->offs = *offs; + + ctx->stored.offs = 1; + ctx->user.offs = 1; + + return 0; +} + +int spng_set_exif(spng_ctx *ctx, struct spng_exif *exif) +{ + SPNG_SET_CHUNK_BOILERPLATE(exif); + + if(check_exif(exif)) return SPNG_EEXIF; + + if(ctx->exif.data != NULL && !ctx->user.exif) spng__free(ctx, ctx->exif.data); + + ctx->exif = *exif; + + ctx->stored.exif = 1; + ctx->user.exif = 1; + + return 0; +} + +const char *spng_strerror(int err) +{ + switch(err) + { + case SPNG_IO_EOF: return "end of stream"; + case SPNG_IO_ERROR: return "stream error"; + case SPNG_OK: return "success"; + case SPNG_EINVAL: return "invalid argument"; + case SPNG_EMEM: return "out of memory"; + case SPNG_EOVERFLOW: return "arithmetic overflow"; + case SPNG_ESIGNATURE: return "invalid signature"; + case SPNG_EWIDTH: return "invalid image width"; + case SPNG_EHEIGHT: return "invalid image height"; + case SPNG_EUSER_WIDTH: return "image width exceeds user limit"; + case SPNG_EUSER_HEIGHT: return "image height exceeds user limit"; + case SPNG_EBIT_DEPTH: return "invalid bit depth"; + case SPNG_ECOLOR_TYPE: return "invalid color type"; + case SPNG_ECOMPRESSION_METHOD: return "invalid compression method"; + case SPNG_EFILTER_METHOD: return "invalid filter method"; + case SPNG_EINTERLACE_METHOD: return "invalid interlace method"; + case SPNG_EIHDR_SIZE: return "invalid IHDR chunk size"; + case SPNG_ENOIHDR: return "missing IHDR chunk"; + case SPNG_ECHUNK_POS: return "invalid chunk position"; + case SPNG_ECHUNK_SIZE: return "invalid chunk length"; + case SPNG_ECHUNK_CRC: return "invalid chunk checksum"; + case SPNG_ECHUNK_TYPE: return "invalid chunk type"; + case SPNG_ECHUNK_UNKNOWN_CRITICAL: return "unknown critical chunk"; + case SPNG_EDUP_PLTE: return "duplicate PLTE chunk"; + case SPNG_EDUP_CHRM: return "duplicate cHRM chunk"; + case SPNG_EDUP_GAMA: return "duplicate gAMA chunk"; + case SPNG_EDUP_ICCP: return "duplicate iCCP chunk"; + case SPNG_EDUP_SBIT: return "duplicate sBIT chunk"; + case SPNG_EDUP_SRGB: return "duplicate sRGB chunk"; + case SPNG_EDUP_BKGD: return "duplicate bKGD chunk"; + case SPNG_EDUP_HIST: return "duplicate hIST chunk"; + case SPNG_EDUP_TRNS: return "duplicate tRNS chunk"; + case SPNG_EDUP_PHYS: return "duplicate pHYs chunk"; + case SPNG_EDUP_TIME: return "duplicate tIME chunk"; + case SPNG_EDUP_OFFS: return "duplicate oFFs chunk"; + case SPNG_EDUP_EXIF: return "duplicate eXIf chunk"; + case SPNG_ECHRM: return "invalid cHRM chunk"; + case SPNG_EPLTE_IDX: return "invalid palette (PLTE) index"; + case SPNG_ETRNS_COLOR_TYPE: return "tRNS chunk with incompatible color type"; + case SPNG_ETRNS_NO_PLTE: return "missing palette (PLTE) for tRNS chunk"; + case SPNG_EGAMA: return "invalid gAMA chunk"; + case SPNG_EICCP_NAME: return "invalid iCCP profile name"; + case SPNG_EICCP_COMPRESSION_METHOD: return "invalid iCCP compression method"; + case SPNG_ESBIT: return "invalid sBIT chunk"; + case SPNG_ESRGB: return "invalid sRGB chunk"; + case SPNG_ETEXT: return "invalid tEXt chunk"; + case SPNG_ETEXT_KEYWORD: return "invalid tEXt keyword"; + case SPNG_EZTXT: return "invalid zTXt chunk"; + case SPNG_EZTXT_COMPRESSION_METHOD: return "invalid zTXt compression method"; + case SPNG_EITXT: return "invalid iTXt chunk"; + case SPNG_EITXT_COMPRESSION_FLAG: return "invalid iTXt compression flag"; + case SPNG_EITXT_COMPRESSION_METHOD: return "invalid iTXt compression method"; + case SPNG_EITXT_LANG_TAG: return "invalid iTXt language tag"; + case SPNG_EITXT_TRANSLATED_KEY: return "invalid iTXt translated key"; + case SPNG_EBKGD_NO_PLTE: return "missing palette for bKGD chunk"; + case SPNG_EBKGD_PLTE_IDX: return "invalid palette index for bKGD chunk"; + case SPNG_EHIST_NO_PLTE: return "missing palette for hIST chunk"; + case SPNG_EPHYS: return "invalid pHYs chunk"; + case SPNG_ESPLT_NAME: return "invalid suggested palette name"; + case SPNG_ESPLT_DUP_NAME: return "duplicate suggested palette (sPLT) name"; + case SPNG_ESPLT_DEPTH: return "invalid suggested palette (sPLT) sample depth"; + case SPNG_ETIME: return "invalid tIME chunk"; + case SPNG_EOFFS: return "invalid oFFs chunk"; + case SPNG_EEXIF: return "invalid eXIf chunk"; + case SPNG_EIDAT_TOO_SHORT: return "IDAT stream too short"; + case SPNG_EIDAT_STREAM: return "IDAT stream error"; + case SPNG_EZLIB: return "zlib error"; + case SPNG_EFILTER: return "invalid scanline filter"; + case SPNG_EBUFSIZ: return "invalid buffer size"; + case SPNG_EIO: return "i/o error"; + case SPNG_EOF: return "end of file"; + case SPNG_EBUF_SET: return "buffer already set"; + case SPNG_EBADSTATE: return "non-recoverable state"; + case SPNG_EFMT: return "invalid format"; + case SPNG_EFLAGS: return "invalid flags"; + case SPNG_ECHUNKAVAIL: return "chunk not available"; + case SPNG_ENCODE_ONLY: return "encode only context"; + case SPNG_EOI: return "reached end-of-image state"; + case SPNG_ENOPLTE: return "missing PLTE for indexed image"; + case SPNG_ECHUNK_LIMITS: return "reached chunk/cache limits"; + case SPNG_EZLIB_INIT: return "zlib init error"; + case SPNG_ECHUNK_STDLEN: return "chunk exceeds maximum standard length"; + case SPNG_EINTERNAL: return "internal error"; + case SPNG_ECTXTYPE: return "invalid operation for context type"; + case SPNG_ENOSRC: return "source PNG not set"; + case SPNG_ENODST: return "PNG output not set"; + case SPNG_EOPSTATE: return "invalid operation for state"; + case SPNG_ENOTFINAL: return "PNG not finalized"; + default: return "unknown error"; + } +} + +const char *spng_version_string(void) +{ + return SPNG_VERSION_STRING; +} + +#if defined(_MSC_VER) + #pragma warning(pop) +#endif + +/* The following SIMD optimizations are derived from libpng source code. */ + +/* +* PNG Reference Library License version 2 +* +* Copyright (c) 1995-2019 The PNG Reference Library Authors. +* Copyright (c) 2018-2019 Cosmin Truta. +* Copyright (c) 2000-2002, 2004, 2006-2018 Glenn Randers-Pehrson. +* Copyright (c) 1996-1997 Andreas Dilger. +* Copyright (c) 1995-1996 Guy Eric Schalnat, Group 42, Inc. +* +* The software is supplied "as is", without warranty of any kind, +* express or implied, including, without limitation, the warranties +* of merchantability, fitness for a particular purpose, title, and +* non-infringement. In no event shall the Copyright owners, or +* anyone distributing the software, be liable for any damages or +* other liability, whether in contract, tort or otherwise, arising +* from, out of, or in connection with the software, or the use or +* other dealings in the software, even if advised of the possibility +* of such damage. +* +* Permission is hereby granted to use, copy, modify, and distribute +* this software, or portions hereof, for any purpose, without fee, +* 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 Copyright notice may not be removed or altered from any +* source or altered source distribution. +*/ + +#if defined(SPNG_X86) + +#ifndef SPNG_SSE + #define SPNG_SSE 1 +#endif + +#if defined(__GNUC__) && !defined(__clang__) + #if SPNG_SSE == 3 + #pragma GCC target("ssse3") + #elif SPNG_SSE == 4 + #pragma GCC target("sse4.1") + #else + #pragma GCC target("sse2") + #endif +#endif + +/* SSE2 optimised filter functions + * Derived from filter_neon_intrinsics.c + * + * Copyright (c) 2018 Cosmin Truta + * Copyright (c) 2016-2017 Glenn Randers-Pehrson + * Written by Mike Klein and Matt Sarett + * Derived from arm/filter_neon_intrinsics.c + * + * This code is derived from libpng source code. + * For conditions of distribution and use, see the disclaimer + * and license above. + */ + +#include +#include +#include + +/* Functions in this file look at most 3 pixels (a,b,c) to predict the 4th (d). + * They're positioned like this: + * prev: c b + * row: a d + * The Sub filter predicts d=a, Avg d=(a+b)/2, and Paeth predicts d to be + * whichever of a, b, or c is closest to p=a+b-c. + */ + +static __m128i load4(const void* p) +{ + int tmp; + memcpy(&tmp, p, sizeof(tmp)); + return _mm_cvtsi32_si128(tmp); +} + +static void store4(void* p, __m128i v) +{ + int tmp = _mm_cvtsi128_si32(v); + memcpy(p, &tmp, sizeof(int)); +} + +static __m128i load3(const void* p) +{ + uint32_t tmp = 0; + memcpy(&tmp, p, 3); + return _mm_cvtsi32_si128(tmp); +} + +static void store3(void* p, __m128i v) +{ + int tmp = _mm_cvtsi128_si32(v); + memcpy(p, &tmp, 3); +} + +static void defilter_sub3(size_t rowbytes, unsigned char *row) +{ + /* The Sub filter predicts each pixel as the previous pixel, a. + * There is no pixel to the left of the first pixel. It's encoded directly. + * That works with our main loop if we just say that left pixel was zero. + */ + size_t rb = rowbytes; + + __m128i a, d = _mm_setzero_si128(); + + while(rb >= 4) + { + a = d; d = load4(row); + d = _mm_add_epi8(d, a); + store3(row, d); + + row += 3; + rb -= 3; + } + + if(rb > 0) + { + a = d; d = load3(row); + d = _mm_add_epi8(d, a); + store3(row, d); + } +} + +static void defilter_sub4(size_t rowbytes, unsigned char *row) +{ + /* The Sub filter predicts each pixel as the previous pixel, a. + * There is no pixel to the left of the first pixel. It's encoded directly. + * That works with our main loop if we just say that left pixel was zero. + */ + size_t rb = rowbytes+4; + + __m128i a, d = _mm_setzero_si128(); + + while(rb > 4) + { + a = d; d = load4(row); + d = _mm_add_epi8(d, a); + store4(row, d); + + row += 4; + rb -= 4; + } +} + +static void defilter_avg3(size_t rowbytes, unsigned char *row, const unsigned char *prev) +{ + /* The Avg filter predicts each pixel as the (truncated) average of a and b. + * There's no pixel to the left of the first pixel. Luckily, it's + * predicted to be half of the pixel above it. So again, this works + * perfectly with our loop if we make sure a starts at zero. + */ + + size_t rb = rowbytes; + + const __m128i zero = _mm_setzero_si128(); + + __m128i b; + __m128i a, d = zero; + + while(rb >= 4) + { + __m128i avg; + b = load4(prev); + a = d; d = load4(row ); + + /* PNG requires a truncating average, so we can't just use _mm_avg_epu8 */ + avg = _mm_avg_epu8(a,b); + /* ...but we can fix it up by subtracting off 1 if it rounded up. */ + avg = _mm_sub_epi8(avg, _mm_and_si128(_mm_xor_si128(a, b), + _mm_set1_epi8(1))); + d = _mm_add_epi8(d, avg); + store3(row, d); + + prev += 3; + row += 3; + rb -= 3; + } + + if(rb > 0) + { + __m128i avg; + b = load3(prev); + a = d; d = load3(row ); + + /* PNG requires a truncating average, so we can't just use _mm_avg_epu8 */ + avg = _mm_avg_epu8(a, b); + /* ...but we can fix it up by subtracting off 1 if it rounded up. */ + avg = _mm_sub_epi8(avg, _mm_and_si128(_mm_xor_si128(a, b), + _mm_set1_epi8(1))); + + d = _mm_add_epi8(d, avg); + store3(row, d); + } +} + +static void defilter_avg4(size_t rowbytes, unsigned char *row, const unsigned char *prev) +{ + /* The Avg filter predicts each pixel as the (truncated) average of a and b. + * There's no pixel to the left of the first pixel. Luckily, it's + * predicted to be half of the pixel above it. So again, this works + * perfectly with our loop if we make sure a starts at zero. + */ + size_t rb = rowbytes+4; + + const __m128i zero = _mm_setzero_si128(); + __m128i b; + __m128i a, d = zero; + + while(rb > 4) + { + __m128i avg; + b = load4(prev); + a = d; d = load4(row ); + + /* PNG requires a truncating average, so we can't just use _mm_avg_epu8 */ + avg = _mm_avg_epu8(a,b); + /* ...but we can fix it up by subtracting off 1 if it rounded up. */ + avg = _mm_sub_epi8(avg, _mm_and_si128(_mm_xor_si128(a, b), + _mm_set1_epi8(1))); + + d = _mm_add_epi8(d, avg); + store4(row, d); + + prev += 4; + row += 4; + rb -= 4; + } +} + +/* Returns |x| for 16-bit lanes. */ +#if (SPNG_SSE >= 3) && !defined(_MSC_VER) +__attribute__((target("ssse3"))) +#endif +static __m128i abs_i16(__m128i x) +{ +#if SPNG_SSE >= 3 + return _mm_abs_epi16(x); +#else + /* Read this all as, return x<0 ? -x : x. + * To negate two's complement, you flip all the bits then add 1. + */ + __m128i is_negative = _mm_cmplt_epi16(x, _mm_setzero_si128()); + + /* Flip negative lanes. */ + x = _mm_xor_si128(x, is_negative); + + /* +1 to negative lanes, else +0. */ + x = _mm_sub_epi16(x, is_negative); + return x; +#endif +} + +/* Bytewise c ? t : e. */ +static __m128i if_then_else(__m128i c, __m128i t, __m128i e) +{ +#if SPNG_SSE >= 4 + return _mm_blendv_epi8(e, t, c); +#else + return _mm_or_si128(_mm_and_si128(c, t), _mm_andnot_si128(c, e)); +#endif +} + +static void defilter_paeth3(size_t rowbytes, unsigned char *row, const unsigned char *prev) +{ + /* Paeth tries to predict pixel d using the pixel to the left of it, a, + * and two pixels from the previous row, b and c: + * prev: c b + * row: a d + * The Paeth function predicts d to be whichever of a, b, or c is nearest to + * p=a+b-c. + * + * The first pixel has no left context, and so uses an Up filter, p = b. + * This works naturally with our main loop's p = a+b-c if we force a and c + * to zero. + * Here we zero b and d, which become c and a respectively at the start of + * the loop. + */ + size_t rb = rowbytes; + const __m128i zero = _mm_setzero_si128(); + __m128i c, b = zero, + a, d = zero; + + while(rb >= 4) + { + /* It's easiest to do this math (particularly, deal with pc) with 16-bit + * intermediates. + */ + __m128i pa,pb,pc,smallest,nearest; + c = b; b = _mm_unpacklo_epi8(load4(prev), zero); + a = d; d = _mm_unpacklo_epi8(load4(row ), zero); + + /* (p-a) == (a+b-c - a) == (b-c) */ + + pa = _mm_sub_epi16(b, c); + + /* (p-b) == (a+b-c - b) == (a-c) */ + pb = _mm_sub_epi16(a, c); + + /* (p-c) == (a+b-c - c) == (a+b-c-c) == (b-c)+(a-c) */ + pc = _mm_add_epi16(pa, pb); + + pa = abs_i16(pa); /* |p-a| */ + pb = abs_i16(pb); /* |p-b| */ + pc = abs_i16(pc); /* |p-c| */ + + smallest = _mm_min_epi16(pc, _mm_min_epi16(pa, pb)); + + /* Paeth breaks ties favoring a over b over c. */ + nearest = if_then_else(_mm_cmpeq_epi16(smallest, pa), a, + if_then_else(_mm_cmpeq_epi16(smallest, pb), b, c)); + + /* Note `_epi8`: we need addition to wrap modulo 255. */ + d = _mm_add_epi8(d, nearest); + store3(row, _mm_packus_epi16(d, d)); + + prev += 3; + row += 3; + rb -= 3; + } + + if(rb > 0) + { + /* It's easiest to do this math (particularly, deal with pc) with 16-bit + * intermediates. + */ + __m128i pa, pb, pc, smallest, nearest; + c = b; b = _mm_unpacklo_epi8(load3(prev), zero); + a = d; d = _mm_unpacklo_epi8(load3(row ), zero); + + /* (p-a) == (a+b-c - a) == (b-c) */ + pa = _mm_sub_epi16(b, c); + + /* (p-b) == (a+b-c - b) == (a-c) */ + pb = _mm_sub_epi16(a, c); + + /* (p-c) == (a+b-c - c) == (a+b-c-c) == (b-c)+(a-c) */ + pc = _mm_add_epi16(pa, pb); + + pa = abs_i16(pa); /* |p-a| */ + pb = abs_i16(pb); /* |p-b| */ + pc = abs_i16(pc); /* |p-c| */ + + smallest = _mm_min_epi16(pc, _mm_min_epi16(pa, pb)); + + /* Paeth breaks ties favoring a over b over c. */ + nearest = if_then_else(_mm_cmpeq_epi16(smallest, pa), a, + if_then_else(_mm_cmpeq_epi16(smallest, pb), b, c)); + + /* Note `_epi8`: we need addition to wrap modulo 255. */ + d = _mm_add_epi8(d, nearest); + store3(row, _mm_packus_epi16(d, d)); + } +} + +static void defilter_paeth4(size_t rowbytes, unsigned char *row, const unsigned char *prev) +{ + /* Paeth tries to predict pixel d using the pixel to the left of it, a, + * and two pixels from the previous row, b and c: + * prev: c b + * row: a d + * The Paeth function predicts d to be whichever of a, b, or c is nearest to + * p=a+b-c. + * + * The first pixel has no left context, and so uses an Up filter, p = b. + * This works naturally with our main loop's p = a+b-c if we force a and c + * to zero. + * Here we zero b and d, which become c and a respectively at the start of + * the loop. + */ + size_t rb = rowbytes+4; + + const __m128i zero = _mm_setzero_si128(); + __m128i pa, pb, pc, smallest, nearest; + __m128i c, b = zero, + a, d = zero; + + while(rb > 4) + { + /* It's easiest to do this math (particularly, deal with pc) with 16-bit + * intermediates. + */ + c = b; b = _mm_unpacklo_epi8(load4(prev), zero); + a = d; d = _mm_unpacklo_epi8(load4(row ), zero); + + /* (p-a) == (a+b-c - a) == (b-c) */ + pa = _mm_sub_epi16(b, c); + + /* (p-b) == (a+b-c - b) == (a-c) */ + pb = _mm_sub_epi16(a, c); + + /* (p-c) == (a+b-c - c) == (a+b-c-c) == (b-c)+(a-c) */ + pc = _mm_add_epi16(pa, pb); + + pa = abs_i16(pa); /* |p-a| */ + pb = abs_i16(pb); /* |p-b| */ + pc = abs_i16(pc); /* |p-c| */ + + smallest = _mm_min_epi16(pc, _mm_min_epi16(pa, pb)); + + /* Paeth breaks ties favoring a over b over c. */ + nearest = if_then_else(_mm_cmpeq_epi16(smallest, pa), a, + if_then_else(_mm_cmpeq_epi16(smallest, pb), b, c)); + + /* Note `_epi8`: we need addition to wrap modulo 255. */ + d = _mm_add_epi8(d, nearest); + store4(row, _mm_packus_epi16(d, d)); + + prev += 4; + row += 4; + rb -= 4; + } +} + +#endif /* SPNG_X86 */ + + +#if defined(SPNG_ARM) + +/* NEON optimised filter functions + * Derived from filter_neon_intrinsics.c + * + * Copyright (c) 2018 Cosmin Truta + * Copyright (c) 2014,2016 Glenn Randers-Pehrson + * Written by James Yu , October 2013. + * Based on filter_neon.S, written by Mans Rullgard, 2011. + * + * This code is derived from libpng source code. + * For conditions of distribution and use, see the disclaimer + * and license in this file. + */ + +#define png_aligncast(type, value) ((void*)(value)) +#define png_aligncastconst(type, value) ((const void*)(value)) + +/* libpng row pointers are not necessarily aligned to any particular boundary, + * however this code will only work with appropriate alignment. mips/mips_init.c + * checks for this (and will not compile unless it is done). This code uses + * variants of png_aligncast to avoid compiler warnings. + */ +#define png_ptr(type,pointer) png_aligncast(type *,pointer) +#define png_ptrc(type,pointer) png_aligncastconst(const type *,pointer) + +/* The following relies on a variable 'temp_pointer' being declared with type + * 'type'. This is written this way just to hide the GCC strict aliasing + * warning; note that the code is safe because there never is an alias between + * the input and output pointers. + */ +#define png_ldr(type,pointer)\ + (temp_pointer = png_ptr(type,pointer), *temp_pointer) + + +#if defined(_MSC_VER) && !defined(__clang__) && defined(_M_ARM64) + #include +#else + #include +#endif + +static void defilter_sub3(size_t rowbytes, unsigned char *row) +{ + unsigned char *rp = row; + unsigned char *rp_stop = row + rowbytes; + + uint8x16_t vtmp = vld1q_u8(rp); + uint8x8x2_t *vrpt = png_ptr(uint8x8x2_t, &vtmp); + uint8x8x2_t vrp = *vrpt; + + uint8x8x4_t vdest; + vdest.val[3] = vdup_n_u8(0); + + for (; rp < rp_stop;) + { + uint8x8_t vtmp1, vtmp2; + uint32x2_t *temp_pointer; + + vtmp1 = vext_u8(vrp.val[0], vrp.val[1], 3); + vdest.val[0] = vadd_u8(vdest.val[3], vrp.val[0]); + vtmp2 = vext_u8(vrp.val[0], vrp.val[1], 6); + vdest.val[1] = vadd_u8(vdest.val[0], vtmp1); + + vtmp1 = vext_u8(vrp.val[1], vrp.val[1], 1); + vdest.val[2] = vadd_u8(vdest.val[1], vtmp2); + vdest.val[3] = vadd_u8(vdest.val[2], vtmp1); + + vtmp = vld1q_u8(rp + 12); + vrpt = png_ptr(uint8x8x2_t, &vtmp); + vrp = *vrpt; + + vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[0]), 0); + rp += 3; + vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[1]), 0); + rp += 3; + vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[2]), 0); + rp += 3; + vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[3]), 0); + rp += 3; + } +} + +static void defilter_sub4(size_t rowbytes, unsigned char *row) +{ + unsigned char *rp = row; + unsigned char *rp_stop = row + rowbytes; + + uint8x8x4_t vdest; + vdest.val[3] = vdup_n_u8(0); + + for (; rp < rp_stop; rp += 16) + { + uint32x2x4_t vtmp = vld4_u32(png_ptr(uint32_t,rp)); + uint8x8x4_t *vrpt = png_ptr(uint8x8x4_t,&vtmp); + uint8x8x4_t vrp = *vrpt; + uint32x2x4_t *temp_pointer; + uint32x2x4_t vdest_val; + + vdest.val[0] = vadd_u8(vdest.val[3], vrp.val[0]); + vdest.val[1] = vadd_u8(vdest.val[0], vrp.val[1]); + vdest.val[2] = vadd_u8(vdest.val[1], vrp.val[2]); + vdest.val[3] = vadd_u8(vdest.val[2], vrp.val[3]); + + vdest_val = png_ldr(uint32x2x4_t, &vdest); + vst4_lane_u32(png_ptr(uint32_t,rp), vdest_val, 0); + } +} + +static void defilter_avg3(size_t rowbytes, unsigned char *row, const unsigned char *prev_row) +{ + unsigned char *rp = row; + const unsigned char *pp = prev_row; + unsigned char *rp_stop = row + rowbytes; + + uint8x16_t vtmp; + uint8x8x2_t *vrpt; + uint8x8x2_t vrp; + uint8x8x4_t vdest; + vdest.val[3] = vdup_n_u8(0); + + vtmp = vld1q_u8(rp); + vrpt = png_ptr(uint8x8x2_t,&vtmp); + vrp = *vrpt; + + for (; rp < rp_stop; pp += 12) + { + uint8x8_t vtmp1, vtmp2, vtmp3; + + uint8x8x2_t *vppt; + uint8x8x2_t vpp; + + uint32x2_t *temp_pointer; + + vtmp = vld1q_u8(pp); + vppt = png_ptr(uint8x8x2_t,&vtmp); + vpp = *vppt; + + vtmp1 = vext_u8(vrp.val[0], vrp.val[1], 3); + vdest.val[0] = vhadd_u8(vdest.val[3], vpp.val[0]); + vdest.val[0] = vadd_u8(vdest.val[0], vrp.val[0]); + + vtmp2 = vext_u8(vpp.val[0], vpp.val[1], 3); + vtmp3 = vext_u8(vrp.val[0], vrp.val[1], 6); + vdest.val[1] = vhadd_u8(vdest.val[0], vtmp2); + vdest.val[1] = vadd_u8(vdest.val[1], vtmp1); + + vtmp2 = vext_u8(vpp.val[0], vpp.val[1], 6); + vtmp1 = vext_u8(vrp.val[1], vrp.val[1], 1); + + vtmp = vld1q_u8(rp + 12); + vrpt = png_ptr(uint8x8x2_t,&vtmp); + vrp = *vrpt; + + vdest.val[2] = vhadd_u8(vdest.val[1], vtmp2); + vdest.val[2] = vadd_u8(vdest.val[2], vtmp3); + + vtmp2 = vext_u8(vpp.val[1], vpp.val[1], 1); + + vdest.val[3] = vhadd_u8(vdest.val[2], vtmp2); + vdest.val[3] = vadd_u8(vdest.val[3], vtmp1); + + vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[0]), 0); + rp += 3; + vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[1]), 0); + rp += 3; + vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[2]), 0); + rp += 3; + vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[3]), 0); + rp += 3; + } +} + +static void defilter_avg4(size_t rowbytes, unsigned char *row, const unsigned char *prev_row) +{ + unsigned char *rp = row; + unsigned char *rp_stop = row + rowbytes; + const unsigned char *pp = prev_row; + + uint8x8x4_t vdest; + vdest.val[3] = vdup_n_u8(0); + + for (; rp < rp_stop; rp += 16, pp += 16) + { + uint32x2x4_t vtmp; + uint8x8x4_t *vrpt, *vppt; + uint8x8x4_t vrp, vpp; + uint32x2x4_t *temp_pointer; + uint32x2x4_t vdest_val; + + vtmp = vld4_u32(png_ptr(uint32_t,rp)); + vrpt = png_ptr(uint8x8x4_t,&vtmp); + vrp = *vrpt; + vtmp = vld4_u32(png_ptrc(uint32_t,pp)); + vppt = png_ptr(uint8x8x4_t,&vtmp); + vpp = *vppt; + + vdest.val[0] = vhadd_u8(vdest.val[3], vpp.val[0]); + vdest.val[0] = vadd_u8(vdest.val[0], vrp.val[0]); + vdest.val[1] = vhadd_u8(vdest.val[0], vpp.val[1]); + vdest.val[1] = vadd_u8(vdest.val[1], vrp.val[1]); + vdest.val[2] = vhadd_u8(vdest.val[1], vpp.val[2]); + vdest.val[2] = vadd_u8(vdest.val[2], vrp.val[2]); + vdest.val[3] = vhadd_u8(vdest.val[2], vpp.val[3]); + vdest.val[3] = vadd_u8(vdest.val[3], vrp.val[3]); + + vdest_val = png_ldr(uint32x2x4_t, &vdest); + vst4_lane_u32(png_ptr(uint32_t,rp), vdest_val, 0); + } +} + +static uint8x8_t paeth_arm(uint8x8_t a, uint8x8_t b, uint8x8_t c) +{ + uint8x8_t d, e; + uint16x8_t p1, pa, pb, pc; + + p1 = vaddl_u8(a, b); /* a + b */ + pc = vaddl_u8(c, c); /* c * 2 */ + pa = vabdl_u8(b, c); /* pa */ + pb = vabdl_u8(a, c); /* pb */ + pc = vabdq_u16(p1, pc); /* pc */ + + p1 = vcleq_u16(pa, pb); /* pa <= pb */ + pa = vcleq_u16(pa, pc); /* pa <= pc */ + pb = vcleq_u16(pb, pc); /* pb <= pc */ + + p1 = vandq_u16(p1, pa); /* pa <= pb && pa <= pc */ + + d = vmovn_u16(pb); + e = vmovn_u16(p1); + + d = vbsl_u8(d, b, c); + e = vbsl_u8(e, a, d); + + return e; +} + +static void defilter_paeth3(size_t rowbytes, unsigned char *row, const unsigned char *prev_row) +{ + unsigned char *rp = row; + const unsigned char *pp = prev_row; + unsigned char *rp_stop = row + rowbytes; + + uint8x16_t vtmp; + uint8x8x2_t *vrpt; + uint8x8x2_t vrp; + uint8x8_t vlast = vdup_n_u8(0); + uint8x8x4_t vdest; + vdest.val[3] = vdup_n_u8(0); + + vtmp = vld1q_u8(rp); + vrpt = png_ptr(uint8x8x2_t,&vtmp); + vrp = *vrpt; + + for (; rp < rp_stop; pp += 12) + { + uint8x8x2_t *vppt; + uint8x8x2_t vpp; + uint8x8_t vtmp1, vtmp2, vtmp3; + uint32x2_t *temp_pointer; + + vtmp = vld1q_u8(pp); + vppt = png_ptr(uint8x8x2_t,&vtmp); + vpp = *vppt; + + vdest.val[0] = paeth_arm(vdest.val[3], vpp.val[0], vlast); + vdest.val[0] = vadd_u8(vdest.val[0], vrp.val[0]); + + vtmp1 = vext_u8(vrp.val[0], vrp.val[1], 3); + vtmp2 = vext_u8(vpp.val[0], vpp.val[1], 3); + vdest.val[1] = paeth_arm(vdest.val[0], vtmp2, vpp.val[0]); + vdest.val[1] = vadd_u8(vdest.val[1], vtmp1); + + vtmp1 = vext_u8(vrp.val[0], vrp.val[1], 6); + vtmp3 = vext_u8(vpp.val[0], vpp.val[1], 6); + vdest.val[2] = paeth_arm(vdest.val[1], vtmp3, vtmp2); + vdest.val[2] = vadd_u8(vdest.val[2], vtmp1); + + vtmp1 = vext_u8(vrp.val[1], vrp.val[1], 1); + vtmp2 = vext_u8(vpp.val[1], vpp.val[1], 1); + + vtmp = vld1q_u8(rp + 12); + vrpt = png_ptr(uint8x8x2_t,&vtmp); + vrp = *vrpt; + + vdest.val[3] = paeth_arm(vdest.val[2], vtmp2, vtmp3); + vdest.val[3] = vadd_u8(vdest.val[3], vtmp1); + + vlast = vtmp2; + + vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[0]), 0); + rp += 3; + vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[1]), 0); + rp += 3; + vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[2]), 0); + rp += 3; + vst1_lane_u32(png_ptr(uint32_t,rp), png_ldr(uint32x2_t,&vdest.val[3]), 0); + rp += 3; + } +} + +static void defilter_paeth4(size_t rowbytes, unsigned char *row, const unsigned char *prev_row) +{ + unsigned char *rp = row; + unsigned char *rp_stop = row + rowbytes; + const unsigned char *pp = prev_row; + + uint8x8_t vlast = vdup_n_u8(0); + uint8x8x4_t vdest; + vdest.val[3] = vdup_n_u8(0); + + for (; rp < rp_stop; rp += 16, pp += 16) + { + uint32x2x4_t vtmp; + uint8x8x4_t *vrpt, *vppt; + uint8x8x4_t vrp, vpp; + uint32x2x4_t *temp_pointer; + uint32x2x4_t vdest_val; + + vtmp = vld4_u32(png_ptr(uint32_t,rp)); + vrpt = png_ptr(uint8x8x4_t,&vtmp); + vrp = *vrpt; + vtmp = vld4_u32(png_ptrc(uint32_t,pp)); + vppt = png_ptr(uint8x8x4_t,&vtmp); + vpp = *vppt; + + vdest.val[0] = paeth_arm(vdest.val[3], vpp.val[0], vlast); + vdest.val[0] = vadd_u8(vdest.val[0], vrp.val[0]); + vdest.val[1] = paeth_arm(vdest.val[0], vpp.val[1], vpp.val[0]); + vdest.val[1] = vadd_u8(vdest.val[1], vrp.val[1]); + vdest.val[2] = paeth_arm(vdest.val[1], vpp.val[2], vpp.val[1]); + vdest.val[2] = vadd_u8(vdest.val[2], vrp.val[2]); + vdest.val[3] = paeth_arm(vdest.val[2], vpp.val[3], vpp.val[2]); + vdest.val[3] = vadd_u8(vdest.val[3], vrp.val[3]); + + vlast = vpp.val[3]; + + vdest_val = png_ldr(uint32x2x4_t, &vdest); + vst4_lane_u32(png_ptr(uint32_t,rp), vdest_val, 0); + } +} + +/* NEON optimised palette expansion functions + * Derived from palette_neon_intrinsics.c + * + * Copyright (c) 2018-2019 Cosmin Truta + * Copyright (c) 2017-2018 Arm Holdings. All rights reserved. + * Written by Richard Townsend , February 2017. + * + * This code is derived from libpng source code. + * For conditions of distribution and use, see the disclaimer + * and license in this file. + * + * Related: https://developer.arm.com/documentation/101964/latest/Color-palette-expansion + * + * The functions were refactored to iterate forward. + * + */ + +/* Expands a palettized row into RGBA8. */ +static uint32_t expand_palette_rgba8_neon(unsigned char *row, const unsigned char *scanline, const unsigned char *plte, uint32_t width) +{ + const uint32_t scanline_stride = 4; + const uint32_t row_stride = scanline_stride * 4; + const uint32_t count = width / scanline_stride; + const uint32_t *palette = (const uint32_t*)plte; + + if(!count) return 0; + + uint32_t i; + uint32x4_t cur; + for(i=0; i < count; i++, scanline += scanline_stride) + { + cur = vld1q_dup_u32 (palette + scanline[0]); + cur = vld1q_lane_u32(palette + scanline[1], cur, 1); + cur = vld1q_lane_u32(palette + scanline[2], cur, 2); + cur = vld1q_lane_u32(palette + scanline[3], cur, 3); + vst1q_u32((uint32_t*)(row + i * row_stride), cur); + } + + return count * scanline_stride; +} + +/* Expands a palettized row into RGB8. */ +static uint32_t expand_palette_rgb8_neon(unsigned char *row, const unsigned char *scanline, const unsigned char *plte, uint32_t width) +{ + const uint32_t scanline_stride = 8; + const uint32_t row_stride = scanline_stride * 3; + const uint32_t count = width / scanline_stride; + + if(!count) return 0; + + uint32_t i; + uint8x8x3_t cur; + for(i=0; i < count; i++, scanline += scanline_stride) + { + cur = vld3_dup_u8 (plte + 3 * scanline[0]); + cur = vld3_lane_u8(plte + 3 * scanline[1], cur, 1); + cur = vld3_lane_u8(plte + 3 * scanline[2], cur, 2); + cur = vld3_lane_u8(plte + 3 * scanline[3], cur, 3); + cur = vld3_lane_u8(plte + 3 * scanline[4], cur, 4); + cur = vld3_lane_u8(plte + 3 * scanline[5], cur, 5); + cur = vld3_lane_u8(plte + 3 * scanline[6], cur, 6); + cur = vld3_lane_u8(plte + 3 * scanline[7], cur, 7); + vst3_u8(row + i * row_stride, cur); + } + + return count * scanline_stride; +} + +#endif /* SPNG_ARM */ diff --git a/jni/libspng/spng.h b/jni/libspng/spng.h new file mode 100644 index 0000000..908ffc9 --- /dev/null +++ b/jni/libspng/spng.h @@ -0,0 +1,537 @@ +/* SPDX-License-Identifier: BSD-2-Clause */ +#ifndef SPNG_H +#define SPNG_H + +#ifdef __cplusplus +extern "C" { +#endif + +#if (defined(_WIN32) || defined(__CYGWIN__)) && !defined(SPNG_STATIC) + #if defined(SPNG__BUILD) + #define SPNG_API __declspec(dllexport) + #else + #define SPNG_API __declspec(dllimport) + #endif +#else + #define SPNG_API +#endif + +#if defined(_MSC_VER) + #define SPNG_CDECL __cdecl +#else + #define SPNG_CDECL +#endif + +#include +#include +#include + +#define SPNG_VERSION_MAJOR 0 +#define SPNG_VERSION_MINOR 7 +#define SPNG_VERSION_PATCH 3 + +enum spng_errno +{ + SPNG_IO_ERROR = -2, + SPNG_IO_EOF = -1, + SPNG_OK = 0, + SPNG_EINVAL, + SPNG_EMEM, + SPNG_EOVERFLOW, + SPNG_ESIGNATURE, + SPNG_EWIDTH, + SPNG_EHEIGHT, + SPNG_EUSER_WIDTH, + SPNG_EUSER_HEIGHT, + SPNG_EBIT_DEPTH, + SPNG_ECOLOR_TYPE, + SPNG_ECOMPRESSION_METHOD, + SPNG_EFILTER_METHOD, + SPNG_EINTERLACE_METHOD, + SPNG_EIHDR_SIZE, + SPNG_ENOIHDR, + SPNG_ECHUNK_POS, + SPNG_ECHUNK_SIZE, + SPNG_ECHUNK_CRC, + SPNG_ECHUNK_TYPE, + SPNG_ECHUNK_UNKNOWN_CRITICAL, + SPNG_EDUP_PLTE, + SPNG_EDUP_CHRM, + SPNG_EDUP_GAMA, + SPNG_EDUP_ICCP, + SPNG_EDUP_SBIT, + SPNG_EDUP_SRGB, + SPNG_EDUP_BKGD, + SPNG_EDUP_HIST, + SPNG_EDUP_TRNS, + SPNG_EDUP_PHYS, + SPNG_EDUP_TIME, + SPNG_EDUP_OFFS, + SPNG_EDUP_EXIF, + SPNG_ECHRM, + SPNG_EPLTE_IDX, + SPNG_ETRNS_COLOR_TYPE, + SPNG_ETRNS_NO_PLTE, + SPNG_EGAMA, + SPNG_EICCP_NAME, + SPNG_EICCP_COMPRESSION_METHOD, + SPNG_ESBIT, + SPNG_ESRGB, + SPNG_ETEXT, + SPNG_ETEXT_KEYWORD, + SPNG_EZTXT, + SPNG_EZTXT_COMPRESSION_METHOD, + SPNG_EITXT, + SPNG_EITXT_COMPRESSION_FLAG, + SPNG_EITXT_COMPRESSION_METHOD, + SPNG_EITXT_LANG_TAG, + SPNG_EITXT_TRANSLATED_KEY, + SPNG_EBKGD_NO_PLTE, + SPNG_EBKGD_PLTE_IDX, + SPNG_EHIST_NO_PLTE, + SPNG_EPHYS, + SPNG_ESPLT_NAME, + SPNG_ESPLT_DUP_NAME, + SPNG_ESPLT_DEPTH, + SPNG_ETIME, + SPNG_EOFFS, + SPNG_EEXIF, + SPNG_EIDAT_TOO_SHORT, + SPNG_EIDAT_STREAM, + SPNG_EZLIB, + SPNG_EFILTER, + SPNG_EBUFSIZ, + SPNG_EIO, + SPNG_EOF, + SPNG_EBUF_SET, + SPNG_EBADSTATE, + SPNG_EFMT, + SPNG_EFLAGS, + SPNG_ECHUNKAVAIL, + SPNG_ENCODE_ONLY, + SPNG_EOI, + SPNG_ENOPLTE, + SPNG_ECHUNK_LIMITS, + SPNG_EZLIB_INIT, + SPNG_ECHUNK_STDLEN, + SPNG_EINTERNAL, + SPNG_ECTXTYPE, + SPNG_ENOSRC, + SPNG_ENODST, + SPNG_EOPSTATE, + SPNG_ENOTFINAL, +}; + +enum spng_text_type +{ + SPNG_TEXT = 1, + SPNG_ZTXT = 2, + SPNG_ITXT = 3 +}; + +enum spng_color_type +{ + SPNG_COLOR_TYPE_GRAYSCALE = 0, + SPNG_COLOR_TYPE_TRUECOLOR = 2, + SPNG_COLOR_TYPE_INDEXED = 3, + SPNG_COLOR_TYPE_GRAYSCALE_ALPHA = 4, + SPNG_COLOR_TYPE_TRUECOLOR_ALPHA = 6 +}; + +enum spng_filter +{ + SPNG_FILTER_NONE = 0, + SPNG_FILTER_SUB = 1, + SPNG_FILTER_UP = 2, + SPNG_FILTER_AVERAGE = 3, + SPNG_FILTER_PAETH = 4 +}; + +enum spng_filter_choice +{ + SPNG_DISABLE_FILTERING = 0, + SPNG_FILTER_CHOICE_NONE = 8, + SPNG_FILTER_CHOICE_SUB = 16, + SPNG_FILTER_CHOICE_UP = 32, + SPNG_FILTER_CHOICE_AVG = 64, + SPNG_FILTER_CHOICE_PAETH = 128, + SPNG_FILTER_CHOICE_ALL = (8|16|32|64|128) +}; + +enum spng_interlace_method +{ + SPNG_INTERLACE_NONE = 0, + SPNG_INTERLACE_ADAM7 = 1 +}; + +/* Channels are always in byte-order */ +enum spng_format +{ + SPNG_FMT_RGBA8 = 1, + SPNG_FMT_RGBA16 = 2, + SPNG_FMT_RGB8 = 4, + + /* Partially implemented, see documentation */ + SPNG_FMT_GA8 = 16, + SPNG_FMT_GA16 = 32, + SPNG_FMT_G8 = 64, + + /* No conversion or scaling */ + SPNG_FMT_PNG = 256, + SPNG_FMT_RAW = 512 /* big-endian (everything else is host-endian) */ +}; + +enum spng_ctx_flags +{ + SPNG_CTX_IGNORE_ADLER32 = 1, /* Ignore checksum in DEFLATE streams */ + SPNG_CTX_ENCODER = 2 /* Create an encoder context */ +}; + +enum spng_decode_flags +{ + SPNG_DECODE_USE_TRNS = 1, /* Deprecated */ + SPNG_DECODE_USE_GAMA = 2, /* Deprecated */ + SPNG_DECODE_USE_SBIT = 8, /* Undocumented */ + + SPNG_DECODE_TRNS = 1, /* Apply transparency */ + SPNG_DECODE_GAMMA = 2, /* Apply gamma correction */ + SPNG_DECODE_PROGRESSIVE = 256 /* Initialize for progressive reads */ +}; + +enum spng_crc_action +{ + /* Default for critical chunks */ + SPNG_CRC_ERROR = 0, + + /* Discard chunk, invalid for critical chunks. + Since v0.6.2: default for ancillary chunks */ + SPNG_CRC_DISCARD = 1, + + /* Ignore and don't calculate checksum. + Since v0.6.2: also ignores checksums in DEFLATE streams */ + SPNG_CRC_USE = 2 +}; + +enum spng_encode_flags +{ + SPNG_ENCODE_PROGRESSIVE = 1, /* Initialize for progressive writes */ + SPNG_ENCODE_FINALIZE = 2, /* Finalize PNG after encoding image */ +}; + +struct spng_ihdr +{ + uint32_t width; + uint32_t height; + uint8_t bit_depth; + uint8_t color_type; + uint8_t compression_method; + uint8_t filter_method; + uint8_t interlace_method; +}; + +struct spng_plte_entry +{ + uint8_t red; + uint8_t green; + uint8_t blue; + + uint8_t alpha; /* Reserved for internal use */ +}; + +struct spng_plte +{ + uint32_t n_entries; + struct spng_plte_entry entries[256]; +}; + +struct spng_trns +{ + uint16_t gray; + + uint16_t red; + uint16_t green; + uint16_t blue; + + uint32_t n_type3_entries; + uint8_t type3_alpha[256]; +}; + +struct spng_chrm_int +{ + uint32_t white_point_x; + uint32_t white_point_y; + uint32_t red_x; + uint32_t red_y; + uint32_t green_x; + uint32_t green_y; + uint32_t blue_x; + uint32_t blue_y; +}; + +struct spng_chrm +{ + double white_point_x; + double white_point_y; + double red_x; + double red_y; + double green_x; + double green_y; + double blue_x; + double blue_y; +}; + +struct spng_iccp +{ + char profile_name[80]; + size_t profile_len; + char *profile; +}; + +struct spng_sbit +{ + uint8_t grayscale_bits; + uint8_t red_bits; + uint8_t green_bits; + uint8_t blue_bits; + uint8_t alpha_bits; +}; + +struct spng_text +{ + char keyword[80]; + int type; + + size_t length; + char *text; + + uint8_t compression_flag; /* iTXt only */ + uint8_t compression_method; /* iTXt, ztXt only */ + char *language_tag; /* iTXt only */ + char *translated_keyword; /* iTXt only */ +}; + +struct spng_bkgd +{ + uint16_t gray; /* Only for gray/gray alpha */ + uint16_t red; + uint16_t green; + uint16_t blue; + uint16_t plte_index; /* Only for indexed color */ +}; + +struct spng_hist +{ + uint16_t frequency[256]; +}; + +struct spng_phys +{ + uint32_t ppu_x, ppu_y; + uint8_t unit_specifier; +}; + +struct spng_splt_entry +{ + uint16_t red; + uint16_t green; + uint16_t blue; + uint16_t alpha; + uint16_t frequency; +}; + +struct spng_splt +{ + char name[80]; + uint8_t sample_depth; + uint32_t n_entries; + struct spng_splt_entry *entries; +}; + +struct spng_time +{ + uint16_t year; + uint8_t month; + uint8_t day; + uint8_t hour; + uint8_t minute; + uint8_t second; +}; + +struct spng_offs +{ + int32_t x, y; + uint8_t unit_specifier; +}; + +struct spng_exif +{ + size_t length; + char *data; +}; + +struct spng_chunk +{ + size_t offset; + uint32_t length; + uint8_t type[4]; + uint32_t crc; +}; + +enum spng_location +{ + SPNG_AFTER_IHDR = 1, + SPNG_AFTER_PLTE = 2, + SPNG_AFTER_IDAT = 8, +}; + +struct spng_unknown_chunk +{ + uint8_t type[4]; + size_t length; + void *data; + enum spng_location location; +}; + +enum spng_option +{ + SPNG_KEEP_UNKNOWN_CHUNKS = 1, + + SPNG_IMG_COMPRESSION_LEVEL, + SPNG_IMG_WINDOW_BITS, + SPNG_IMG_MEM_LEVEL, + SPNG_IMG_COMPRESSION_STRATEGY, + + SPNG_TEXT_COMPRESSION_LEVEL, + SPNG_TEXT_WINDOW_BITS, + SPNG_TEXT_MEM_LEVEL, + SPNG_TEXT_COMPRESSION_STRATEGY, + + SPNG_FILTER_CHOICE, + SPNG_CHUNK_COUNT_LIMIT, + SPNG_ENCODE_TO_BUFFER, +}; + +typedef void* SPNG_CDECL spng_malloc_fn(size_t size); +typedef void* SPNG_CDECL spng_realloc_fn(void* ptr, size_t size); +typedef void* SPNG_CDECL spng_calloc_fn(size_t count, size_t size); +typedef void SPNG_CDECL spng_free_fn(void* ptr); + +struct spng_alloc +{ + spng_malloc_fn *malloc_fn; + spng_realloc_fn *realloc_fn; + spng_calloc_fn *calloc_fn; + spng_free_fn *free_fn; +}; + +struct spng_row_info +{ + uint32_t scanline_idx; + uint32_t row_num; /* deinterlaced row index */ + int pass; + uint8_t filter; +}; + +typedef struct spng_ctx spng_ctx; + +typedef int spng_read_fn(spng_ctx *ctx, void *user, void *dest, size_t length); +typedef int spng_write_fn(spng_ctx *ctx, void *user, void *src, size_t length); + +typedef int spng_rw_fn(spng_ctx *ctx, void *user, void *dst_src, size_t length); + +SPNG_API spng_ctx *spng_ctx_new(int flags); +SPNG_API spng_ctx *spng_ctx_new2(struct spng_alloc *alloc, int flags); +SPNG_API void spng_ctx_free(spng_ctx *ctx); + +SPNG_API int spng_set_png_buffer(spng_ctx *ctx, const void *buf, size_t size); +SPNG_API int spng_set_png_stream(spng_ctx *ctx, spng_rw_fn *rw_func, void *user); +SPNG_API int spng_set_png_file(spng_ctx *ctx, FILE *file); + +SPNG_API void *spng_get_png_buffer(spng_ctx *ctx, size_t *len, int *error); + +SPNG_API int spng_set_image_limits(spng_ctx *ctx, uint32_t width, uint32_t height); +SPNG_API int spng_get_image_limits(spng_ctx *ctx, uint32_t *width, uint32_t *height); + +SPNG_API int spng_set_chunk_limits(spng_ctx *ctx, size_t chunk_size, size_t cache_size); +SPNG_API int spng_get_chunk_limits(spng_ctx *ctx, size_t *chunk_size, size_t *cache_size); + +SPNG_API int spng_set_crc_action(spng_ctx *ctx, int critical, int ancillary); + +SPNG_API int spng_set_option(spng_ctx *ctx, enum spng_option option, int value); +SPNG_API int spng_get_option(spng_ctx *ctx, enum spng_option option, int *value); + +SPNG_API int spng_decoded_image_size(spng_ctx *ctx, int fmt, size_t *len); + +/* Decode */ +SPNG_API int spng_decode_image(spng_ctx *ctx, void *out, size_t len, int fmt, int flags); + +/* Progressive decode */ +SPNG_API int spng_decode_scanline(spng_ctx *ctx, void *out, size_t len); +SPNG_API int spng_decode_row(spng_ctx *ctx, void *out, size_t len); +SPNG_API int spng_decode_chunks(spng_ctx *ctx); + +/* Encode/decode */ +SPNG_API int spng_get_row_info(spng_ctx *ctx, struct spng_row_info *row_info); + +/* Encode */ +SPNG_API int spng_encode_image(spng_ctx *ctx, const void *img, size_t len, int fmt, int flags); + +/* Progressive encode */ +SPNG_API int spng_encode_scanline(spng_ctx *ctx, const void *scanline, size_t len); +SPNG_API int spng_encode_row(spng_ctx *ctx, const void *row, size_t len); +SPNG_API int spng_encode_chunks(spng_ctx *ctx); + +SPNG_API int spng_get_ihdr(spng_ctx *ctx, struct spng_ihdr *ihdr); +SPNG_API int spng_get_plte(spng_ctx *ctx, struct spng_plte *plte); +SPNG_API int spng_get_trns(spng_ctx *ctx, struct spng_trns *trns); +SPNG_API int spng_get_chrm(spng_ctx *ctx, struct spng_chrm *chrm); +SPNG_API int spng_get_chrm_int(spng_ctx *ctx, struct spng_chrm_int *chrm_int); +SPNG_API int spng_get_gama(spng_ctx *ctx, double *gamma); +SPNG_API int spng_get_gama_int(spng_ctx *ctx, uint32_t *gama_int); +SPNG_API int spng_get_iccp(spng_ctx *ctx, struct spng_iccp *iccp); +SPNG_API int spng_get_sbit(spng_ctx *ctx, struct spng_sbit *sbit); +SPNG_API int spng_get_srgb(spng_ctx *ctx, uint8_t *rendering_intent); +SPNG_API int spng_get_text(spng_ctx *ctx, struct spng_text *text, uint32_t *n_text); +SPNG_API int spng_get_bkgd(spng_ctx *ctx, struct spng_bkgd *bkgd); +SPNG_API int spng_get_hist(spng_ctx *ctx, struct spng_hist *hist); +SPNG_API int spng_get_phys(spng_ctx *ctx, struct spng_phys *phys); +SPNG_API int spng_get_splt(spng_ctx *ctx, struct spng_splt *splt, uint32_t *n_splt); +SPNG_API int spng_get_time(spng_ctx *ctx, struct spng_time *time); +SPNG_API int spng_get_unknown_chunks(spng_ctx *ctx, struct spng_unknown_chunk *chunks, uint32_t *n_chunks); + +/* Official extensions */ +SPNG_API int spng_get_offs(spng_ctx *ctx, struct spng_offs *offs); +SPNG_API int spng_get_exif(spng_ctx *ctx, struct spng_exif *exif); + + +SPNG_API int spng_set_ihdr(spng_ctx *ctx, struct spng_ihdr *ihdr); +SPNG_API int spng_set_plte(spng_ctx *ctx, struct spng_plte *plte); +SPNG_API int spng_set_trns(spng_ctx *ctx, struct spng_trns *trns); +SPNG_API int spng_set_chrm(spng_ctx *ctx, struct spng_chrm *chrm); +SPNG_API int spng_set_chrm_int(spng_ctx *ctx, struct spng_chrm_int *chrm_int); +SPNG_API int spng_set_gama(spng_ctx *ctx, double gamma); +SPNG_API int spng_set_gama_int(spng_ctx *ctx, uint32_t gamma); +SPNG_API int spng_set_iccp(spng_ctx *ctx, struct spng_iccp *iccp); +SPNG_API int spng_set_sbit(spng_ctx *ctx, struct spng_sbit *sbit); +SPNG_API int spng_set_srgb(spng_ctx *ctx, uint8_t rendering_intent); +SPNG_API int spng_set_text(spng_ctx *ctx, struct spng_text *text, uint32_t n_text); +SPNG_API int spng_set_bkgd(spng_ctx *ctx, struct spng_bkgd *bkgd); +SPNG_API int spng_set_hist(spng_ctx *ctx, struct spng_hist *hist); +SPNG_API int spng_set_phys(spng_ctx *ctx, struct spng_phys *phys); +SPNG_API int spng_set_splt(spng_ctx *ctx, struct spng_splt *splt, uint32_t n_splt); +SPNG_API int spng_set_time(spng_ctx *ctx, struct spng_time *time); +SPNG_API int spng_set_unknown_chunks(spng_ctx *ctx, struct spng_unknown_chunk *chunks, uint32_t n_chunks); + +/* Official extensions */ +SPNG_API int spng_set_offs(spng_ctx *ctx, struct spng_offs *offs); +SPNG_API int spng_set_exif(spng_ctx *ctx, struct spng_exif *exif); + + +SPNG_API const char *spng_strerror(int err); +SPNG_API const char *spng_version_string(void); + +#ifdef __cplusplus +} +#endif + +#endif /* SPNG_H */ From fede642a680b77a57f84ce8f58c8252e0834182a Mon Sep 17 00:00:00 2001 From: bri3d Date: Sun, 11 Dec 2022 17:40:59 -0700 Subject: [PATCH 2/7] working PNG support --- jni/Android.mk | 5 +- jni/osd_dji_overlay_udp.c | 177 +++++++++++++++++++++++--------------- 2 files changed, 113 insertions(+), 69 deletions(-) diff --git a/jni/Android.mk b/jni/Android.mk index 9c80a81..44f4ac6 100644 --- a/jni/Android.mk +++ b/jni/Android.mk @@ -9,7 +9,7 @@ include $(CLEAR_VARS) LOCAL_CFLAGS += -fPIC -std=c99 -O3 LOCAL_LDFLAGS += -fPIC -LOCAL_LDLIBS := -llog +LOCAL_LDLIBS := -llog -lz LOCAL_ARM_NEON := true LOCAL_MODULE := displayport_osd_shim LOCAL_SHARED_LIBRARIES := duml_hal @@ -29,7 +29,8 @@ LOCAL_SRC_FILES := \ rec/rec.c \ util/fs_util.c \ toast/toast.c \ - lz4/lz4.c + lz4/lz4.c \ + libspng/spng.c include $(BUILD_SHARED_LIBRARY) include $(CLEAR_VARS) diff --git a/jni/osd_dji_overlay_udp.c b/jni/osd_dji_overlay_udp.c index 3c3339d..1208716 100644 --- a/jni/osd_dji_overlay_udp.c +++ b/jni/osd_dji_overlay_udp.c @@ -21,6 +21,7 @@ #include "hw/dji_services.h" #include "json/osd_config.h" #include "fakehd/fakehd.h" +#include "libspng/spng.h" #include "lz4/lz4.h" #include "toast/toast.h" #include "net/network.h" @@ -45,6 +46,7 @@ #define GOGGLES_V2_VOFFSET 215 #define NUM_CHARS 256 +#define NUM_FONT_PAGES 4 #define INPUT_FILENAME "/dev/input/event0" #define SPLASH_STRING "OSD WAITING..." @@ -75,7 +77,7 @@ typedef enum { #ifdef DEBUG #define DEBUG_PRINT(fmt, args...) fprintf(stderr, fmt, ## args) #else -#define DEBUG_PRINT(fmt, args...) +#define DEBUG_PRINT(fmt, args...) fprintf(stderr, fmt, ## args) #endif #define SWAP32(data) \ @@ -92,8 +94,7 @@ typedef struct display_info_s { uint8_t font_height; uint16_t x_offset; uint16_t y_offset; - void *font_page_1; - void *font_page_2; + void *fonts[NUM_FONT_PAGES]; } display_info_t; static void rec_msp_draw_complete_hook(); @@ -117,8 +118,7 @@ static display_info_t sd_display_info = { .font_height = 54, .x_offset = 180, .y_offset = 0, - .font_page_1 = NULL, - .font_page_2 = NULL, + .fonts = {NULL, NULL, NULL, NULL}, }; static display_info_t full_display_info = { @@ -128,8 +128,7 @@ static display_info_t full_display_info = { .font_height = 36, .x_offset = 0, .y_offset = 0, - .font_page_1 = NULL, - .font_page_2 = NULL, + .fonts = {NULL, NULL, NULL, NULL}, }; static display_info_t hd_display_info = { @@ -139,8 +138,7 @@ static display_info_t hd_display_info = { .font_height = 36, .x_offset = 120, .y_offset = 80, - .font_page_1 = NULL, - .font_page_2 = NULL, + .fonts = {NULL, NULL, NULL, NULL}, }; static display_info_t overlay_display_info = { @@ -150,8 +148,7 @@ static display_info_t overlay_display_info = { .font_height = 36, .x_offset = 960, .y_offset = 450, - .font_page_1 = NULL, - .font_page_2 = NULL, + .fonts = {NULL, NULL, NULL, NULL}, }; static enum display_mode_s { @@ -179,20 +176,20 @@ static void msp_draw_character(uint32_t x, uint32_t y, uint16_t c) { /* Main rendering function: take a character_map and a display_info and draw it into a framebuffer */ static void draw_character_map(display_info_t *display_info, void* restrict fb_addr, uint16_t character_map[MAX_DISPLAY_X][MAX_DISPLAY_Y]) { - if (display_info->font_page_1 == NULL) { + if (display_info->fonts[0] == NULL) { DEBUG_PRINT("No font available, failed to draw.\n"); return; } - void *font_page_2 = display_info->font_page_2 == NULL ? display_info->font_page_1 : display_info->font_page_2; void* restrict font; for(int y = 0; y < display_info->char_height; y++) { for(int x = 0; x < display_info->char_width; x++) { uint16_t c = character_map[x][y]; if (c != 0) { - font = display_info->font_page_1; - if (c > 255) { - c = c & 0xFF; - font = font_page_2; + int page = (c & 0x300) >> 8; + c = c & 0xFF; + font = display_info->fonts[page]; + if(font == NULL) { + font = display_info->fonts[0]; } uint32_t pixel_x = (x * display_info->font_width) + display_info->x_offset; uint32_t pixel_y = (y * display_info->font_height) + display_info->y_offset; @@ -292,7 +289,7 @@ static font_variant_e font_variant_from_string(char *variant_string) { return font_variant; } -static void get_font_path_with_prefix(char *font_path_dest, const char *font_path, uint8_t len, uint8_t is_hd, font_variant_e font_variant, uint8_t page) +static void get_font_path_with_prefix(char *font_path_dest, const char *font_path, uint8_t len, uint8_t is_hd, font_variant_e font_variant) { char name_buf[len]; char res_buf[len]; @@ -323,59 +320,113 @@ static void get_font_path_with_prefix(char *font_path_dest, const char *font_pat snprintf(res_buf, len, "%s", ""); } - if (page > 0) - { - snprintf(font_path_dest, len, "%s%s_%d.bin", name_buf, res_buf, page + 1); - } - else - { - snprintf(font_path_dest, len, "%s%s.bin", name_buf, res_buf); - } + snprintf(font_path_dest, len, "%s%s.png", name_buf, res_buf); } -static int open_font(const char *filename, void **font, uint8_t page, uint8_t is_hd, font_variant_e font_variant) +static int open_font(const char *filename, void *fonts[], uint8_t is_hd, font_variant_e font_variant) { char file_path[255]; - get_font_path_with_prefix(file_path, filename, 255, is_hd, font_variant, page); + + get_font_path_with_prefix(file_path, filename, 255, is_hd, font_variant); DEBUG_PRINT("Opening font: %s\n", file_path); struct stat st; memset(&st, 0, sizeof(st)); stat(file_path, &st); size_t filesize = st.st_size; - display_info_t display_info = is_hd ? hd_display_info : sd_display_info; - size_t desired_filesize = display_info.font_height * display_info.font_width * NUM_CHARS * BYTES_PER_PIXEL; - if(filesize != desired_filesize) { - if (filesize != 0) { - DEBUG_PRINT("Font was wrong size: %s %d != %d\n", file_path, filesize, desired_filesize); - } + if(!(filesize > 0)) { + DEBUG_PRINT("Font file did not exist: %s\n", file_path); return -1; } - int fd = open(file_path, O_RDONLY, 0); + display_info_t display_info = is_hd ? hd_display_info : sd_display_info; + FILE *fd = fopen(file_path, "rb"); if (!fd) { DEBUG_PRINT("Could not open file %s\n", file_path); return -1; } - void* font_data = malloc(desired_filesize); - void* mmappedData = mmap(NULL, filesize, PROT_READ, MAP_PRIVATE, fd, 0); - if (mmappedData != MAP_FAILED) { - memcpy(font_data, mmappedData, desired_filesize); - *font = font_data; - } else { - DEBUG_PRINT("Could not map font %s\n", file_path); + + spng_ctx *ctx = spng_ctx_new(0); + DEBUG_PRINT("Allocated PNG context\n"); + // Set some kind of reasonable PNG limit so we don't get blown up + size_t limit = 1024 * 1024 * 64; + spng_set_chunk_limits(ctx, limit, limit); + DEBUG_PRINT("Set PNG chunk limits\n"); + spng_set_png_file(ctx, fd); + DEBUG_PRINT("Set PNG file\n"); + + struct spng_ihdr ihdr; + int ret = spng_get_ihdr(ctx, &ihdr); + DEBUG_PRINT("Got PNG header\n"); + + if(ret) + { + printf("spng_get_ihdr() error: %s\n", spng_strerror(ret)); + goto err; + } + + if(ihdr.height != display_info.font_height * NUM_CHARS) { + printf("font invalid height, got %d wanted %d\n", ihdr.height, display_info.font_height * NUM_CHARS); + goto err; + } + + if(ihdr.width % display_info.font_width != 0) { + printf("font invalid width, not a multiple of %d\n", display_info.font_width); + goto err; + } + + DEBUG_PRINT("Image pixel size %d x %d\n", ihdr.width, ihdr.height); + + int num_pages = ihdr.width / display_info.font_width; + + DEBUG_PRINT("Font has %d pages\n", num_pages); + + size_t image_size = 0; + int fmt = SPNG_FMT_RGBA8; + ret = spng_decoded_image_size(ctx, fmt, &image_size); + if(ret) { + goto err; + } + + DEBUG_PRINT("Allocating image size %d\n", image_size); + + void* font_data = malloc(image_size); + ret = spng_decode_image(ctx, font_data, image_size, SPNG_FMT_RGBA8, 0); + if(ret) { + printf("Failed to decode PNG!\n"); free(font_data); - *font = 0; + return -1; + } + + for(int page = 0; page < num_pages; page++) { + DEBUG_PRINT("Loading font page %d of %d, placing %x\n", page, num_pages, fonts); + fonts[page] = malloc(display_info.font_width * display_info.font_height * NUM_CHARS * BYTES_PER_PIXEL); + DEBUG_PRINT("Allocated %d bytes for font page buf at%x\n", display_info.font_width * display_info.font_height * NUM_CHARS * BYTES_PER_PIXEL, fonts[page]); + for(int char_num = 0; char_num < NUM_CHARS; char_num++) { + for(int y = 0; y < display_info.font_height; y++) { + // Copy each character line at a time into the correct font buffer + int char_width_bytes = display_info.font_width * BYTES_PER_PIXEL; + int char_size_bytes_dest = (display_info.font_width * display_info.font_height * BYTES_PER_PIXEL); + int char_size_bytes_src = (ihdr.width * display_info.font_height * BYTES_PER_PIXEL); + memcpy((uint8_t *)fonts[page] + (char_num * char_size_bytes_dest) + (y * char_width_bytes), (uint8_t *)font_data + (char_num * char_size_bytes_src) + (ihdr.width * y * BYTES_PER_PIXEL) + (page * char_width_bytes), char_width_bytes); + } + } } - close(fd); - munmap(mmappedData, desired_filesize); + + free(font_data); + spng_ctx_free(ctx); + fclose(fd); return 0; + err: + spng_ctx_free(ctx); + fclose(fd); + return -1; } -static void load_font(void **font_buffer, uint8_t page, uint8_t is_hd, font_variant_e font_variant) { +static void load_font(void **font_buffer[], uint8_t is_hd, font_variant_e font_variant) { // Note: load_font will not replace an existing font. if(*font_buffer == NULL) { - if (open_font(SDCARD_FONT_PATH, font_buffer, page, is_hd, font_variant) < 0) { - if (open_font(ENTWARE_FONT_PATH, font_buffer, page, is_hd, font_variant) < 0) { - open_font(FALLBACK_FONT_PATH, font_buffer, page, is_hd, font_variant); + if (open_font(SDCARD_FONT_PATH, font_buffer, is_hd, font_variant) < 0) { + if (open_font(ENTWARE_FONT_PATH, font_buffer, is_hd, font_variant) < 0) { + open_font(FALLBACK_FONT_PATH, font_buffer, is_hd, font_variant); } } } @@ -383,29 +434,21 @@ static void load_font(void **font_buffer, uint8_t page, uint8_t is_hd, font_vari static void load_fonts(font_variant_e font_variant) { char file_path[255]; - get_font_path_with_prefix(file_path, "FONT font", 255, 0, font_variant, 0); + get_font_path_with_prefix(file_path, "FONT font", 255, 0, font_variant); toast(file_path); - load_font(&sd_display_info.font_page_1, 0, 0, font_variant); - load_font(&sd_display_info.font_page_2, 1, 0, font_variant); - load_font(&hd_display_info.font_page_1, 0, 1, font_variant); - load_font(&hd_display_info.font_page_2, 1, 1, font_variant); - load_font(&full_display_info.font_page_1, 0, 1, font_variant); - load_font(&full_display_info.font_page_2, 1, 1, font_variant); - load_font(&overlay_display_info.font_page_1, 0, 1, font_variant); - load_font(&overlay_display_info.font_page_2, 1, 1, font_variant); + load_font(&sd_display_info.fonts, 0, font_variant); + load_font(&hd_display_info.fonts, 1, font_variant); + load_font(&full_display_info.fonts, 1, font_variant); + load_font(&overlay_display_info.fonts, 1, font_variant); } static void close_fonts(display_info_t *display_info) { - if (display_info->font_page_1 != NULL) - { - free(display_info->font_page_1); - display_info->font_page_1 = NULL; - } - if (display_info->font_page_2 != NULL) - { - free(display_info->font_page_2); - display_info->font_page_2 = NULL; + for(int i = 0; i < NUM_FONT_PAGES; i++) { + if(display_info->fonts[i] != NULL) { + free(display_info->fonts[i]); + display_info->fonts[i] = NULL; + } } } From c882e884061dcbb4ed6ef5cf09234601d3775353 Mon Sep 17 00:00:00 2001 From: bri3d Date: Sun, 11 Dec 2022 21:48:28 -0700 Subject: [PATCH 3/7] cleanup --- jni/osd_dji_overlay_udp.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/jni/osd_dji_overlay_udp.c b/jni/osd_dji_overlay_udp.c index 1208716..6018066 100644 --- a/jni/osd_dji_overlay_udp.c +++ b/jni/osd_dji_overlay_udp.c @@ -77,7 +77,7 @@ typedef enum { #ifdef DEBUG #define DEBUG_PRINT(fmt, args...) fprintf(stderr, fmt, ## args) #else -#define DEBUG_PRINT(fmt, args...) fprintf(stderr, fmt, ## args) +#define DEBUG_PRINT(fmt, args...) #endif #define SWAP32(data) \ @@ -393,7 +393,7 @@ static int open_font(const char *filename, void *fonts[], uint8_t is_hd, font_va if(ret) { printf("Failed to decode PNG!\n"); free(font_data); - return -1; + goto err; } for(int page = 0; page < num_pages; page++) { From bc8b8361a6d52cd14dc977022c4dac6e90b27106 Mon Sep 17 00:00:00 2001 From: bri3d Date: Tue, 13 Dec 2022 18:20:08 -0700 Subject: [PATCH 4/7] split font code into own file --- jni/Android.mk | 1 + jni/font/font.c | 187 ++++++++++++++++++++++++++++++++ jni/font/font.h | 16 +++ jni/osd_dji_overlay_udp.c | 222 +++----------------------------------- jni/util/display_info.h | 16 +++ jni/util/fs_util.c | 3 +- 6 files changed, 236 insertions(+), 209 deletions(-) create mode 100644 jni/font/font.c create mode 100644 jni/font/font.h create mode 100644 jni/util/display_info.h diff --git a/jni/Android.mk b/jni/Android.mk index 44f4ac6..a96bb86 100644 --- a/jni/Android.mk +++ b/jni/Android.mk @@ -16,6 +16,7 @@ LOCAL_SHARED_LIBRARIES := duml_hal LOCAL_SRC_FILES := \ displayport_osd_shim.c \ fakehd/fakehd.c \ + font/font.c \ hw/dji_display.c \ hw/dji_radio_shm.c \ hw/dji_services.c \ diff --git a/jni/font/font.c b/jni/font/font.c new file mode 100644 index 0000000..66f229e --- /dev/null +++ b/jni/font/font.c @@ -0,0 +1,187 @@ +#include +#include +#include + +#include "../libspng/spng.h" +#include "font.h" + +#define BYTES_PER_PIXEL 4 +#define FALLBACK_FONT_PATH "/blackbox/font" +#define ENTWARE_FONT_PATH "/opt/fonts/font" +#define SDCARD_FONT_PATH "/storage/sdcard0/font" + +#define HD_FONT_WIDTH 24 + +#ifdef DEBUG +#define DEBUG_PRINT(fmt, args...) fprintf(stderr, fmt, ## args) +#else +#define DEBUG_PRINT(fmt, args...) +#endif + +/* Font helper methods */ + +font_variant_e font_variant_from_string(char *variant_string) { + font_variant_e font_variant = FONT_VARIANT_GENERIC; + if(strncmp(variant_string, "ARDU", 4) == 0) { + font_variant = FONT_VARIANT_ARDUPILOT; + } else if (strncmp(variant_string, "BTFL", 4) == 0) { + font_variant = FONT_VARIANT_BETAFLIGHT; + } else if (strncmp(variant_string, "INAV", 4) == 0) { + font_variant = FONT_VARIANT_INAV; + } else if (strncmp(variant_string, "ULTR", 4) == 0) { + font_variant = FONT_VARIANT_KISS_ULTRA; + } + return font_variant; +} + +void get_font_path_with_prefix(char *font_path_dest, const char *font_path, uint8_t len, uint8_t is_hd, font_variant_e font_variant) +{ + char name_buf[len]; + char res_buf[len]; + + switch (font_variant) + { + case FONT_VARIANT_BETAFLIGHT: + snprintf(name_buf, len, "%s_bf", font_path); + break; + case FONT_VARIANT_INAV: + snprintf(name_buf, len, "%s_inav", font_path); + break; + case FONT_VARIANT_ARDUPILOT: + snprintf(name_buf, len, "%s_ardu", font_path); + break; + case FONT_VARIANT_KISS_ULTRA: + snprintf(name_buf, len, "%s_ultra", font_path); + break; + default: + snprintf(name_buf, len, "%s", font_path); + } + + if (is_hd) + { + // surely there's a better way... + snprintf(res_buf, len, "%s", "_hd"); + } else { + snprintf(res_buf, len, "%s", ""); + } + + snprintf(font_path_dest, len, "%s%s.png", name_buf, res_buf); +} + +static int open_font(const char *filename, display_info_t *display_info, font_variant_e font_variant) +{ + char file_path[255]; + int is_hd = (display_info->char_width == HD_FONT_WIDTH) ? 1 : 0; + get_font_path_with_prefix(file_path, filename, 255, is_hd, font_variant); + DEBUG_PRINT("Opening font: %s\n", file_path); + struct stat st; + memset(&st, 0, sizeof(st)); + stat(file_path, &st); + size_t filesize = st.st_size; + if(!(filesize > 0)) { + DEBUG_PRINT("Font file did not exist: %s\n", file_path); + return -1; + } + + FILE *fd = fopen(file_path, "rb"); + if (!fd) { + DEBUG_PRINT("Could not open file %s\n", file_path); + return -1; + } + + spng_ctx *ctx = spng_ctx_new(0); + DEBUG_PRINT("Allocated PNG context\n"); + // Set some kind of reasonable PNG limit so we don't get blown up + size_t limit = 1024 * 1024 * 64; + spng_set_chunk_limits(ctx, limit, limit); + DEBUG_PRINT("Set PNG chunk limits\n"); + spng_set_png_file(ctx, fd); + DEBUG_PRINT("Set PNG file\n"); + + struct spng_ihdr ihdr; + int ret = spng_get_ihdr(ctx, &ihdr); + DEBUG_PRINT("Got PNG header\n"); + + if(ret) + { + printf("spng_get_ihdr() error: %s\n", spng_strerror(ret)); + goto err; + } + + if(ihdr.height != display_info->font_height * NUM_CHARS) { + printf("font invalid height, got %d wanted %d\n", ihdr.height, display_info->font_height * NUM_CHARS); + goto err; + } + + if(ihdr.width % display_info->font_width != 0) { + printf("font invalid width, not a multiple of %d\n", display_info->font_width); + goto err; + } + + DEBUG_PRINT("Image pixel size %d x %d\n", ihdr.width, ihdr.height); + + int num_pages = ihdr.width / display_info->font_width; + + DEBUG_PRINT("Font has %d pages\n", num_pages); + + size_t image_size = 0; + int fmt = SPNG_FMT_RGBA8; + ret = spng_decoded_image_size(ctx, fmt, &image_size); + if(ret) { + goto err; + } + + DEBUG_PRINT("Allocating image size %d\n", image_size); + + void* font_data = malloc(image_size); + ret = spng_decode_image(ctx, font_data, image_size, SPNG_FMT_RGBA8, 0); + if(ret) { + printf("Failed to decode PNG!\n"); + free(font_data); + goto err; + } + + for(int page = 0; page < num_pages; page++) { + DEBUG_PRINT("Loading font page %d of %d, placing %x\n", page, num_pages, display_info->fonts); + display_info->fonts[page] = malloc(display_info->font_width * display_info->font_height * NUM_CHARS * BYTES_PER_PIXEL); + DEBUG_PRINT("Allocated %d bytes for font page buf at%x\n", display_info->font_width * display_info->font_height * NUM_CHARS * BYTES_PER_PIXEL, display_info->fonts[page]); + for(int char_num = 0; char_num < NUM_CHARS; char_num++) { + for(int y = 0; y < display_info->font_height; y++) { + // Copy each character line at a time into the correct font buffer + int char_width_bytes = display_info->font_width * BYTES_PER_PIXEL; + int char_size_bytes_dest = (display_info->font_width * display_info->font_height * BYTES_PER_PIXEL); + int char_size_bytes_src = (ihdr.width * display_info->font_height * BYTES_PER_PIXEL); + memcpy((uint8_t *)display_info->fonts[page] + (char_num * char_size_bytes_dest) + (y * char_width_bytes), (uint8_t *)font_data + (char_num * char_size_bytes_src) + (ihdr.width * y * BYTES_PER_PIXEL) + (page * char_width_bytes), char_width_bytes); + } + } + } + + free(font_data); + spng_ctx_free(ctx); + fclose(fd); + return 0; + err: + spng_ctx_free(ctx); + fclose(fd); + return -1; +} + +void load_font(display_info_t *display_info, font_variant_e font_variant) { + // Note: load_font will not replace an existing font. + if(display_info->fonts[0] == NULL) { + if (open_font(SDCARD_FONT_PATH, display_info, font_variant) < 0) { + if (open_font(ENTWARE_FONT_PATH, display_info, font_variant) < 0) { + open_font(FALLBACK_FONT_PATH, display_info, font_variant); + } + } + } +} + +void close_font(display_info_t *display_info) { + for(int i = 0; i < NUM_FONT_PAGES; i++) { + if(display_info->fonts[i] != NULL) { + free(display_info->fonts[i]); + display_info->fonts[i] = NULL; + } + } +} \ No newline at end of file diff --git a/jni/font/font.h b/jni/font/font.h new file mode 100644 index 0000000..2b7aebc --- /dev/null +++ b/jni/font/font.h @@ -0,0 +1,16 @@ +#include + +#include "../util/display_info.h" + +typedef enum { + FONT_VARIANT_GENERIC, + FONT_VARIANT_BETAFLIGHT, + FONT_VARIANT_INAV, + FONT_VARIANT_ARDUPILOT, + FONT_VARIANT_KISS_ULTRA +} font_variant_e; + +void load_font(display_info_t *display_info, font_variant_e font_variant); +void close_font(display_info_t *display_info); +void get_font_path_with_prefix(char *font_path_dest, const char *font_path, uint8_t len, uint8_t is_hd, font_variant_e font_variant); +font_variant_e font_variant_from_string(char *variant_string); \ No newline at end of file diff --git a/jni/osd_dji_overlay_udp.c b/jni/osd_dji_overlay_udp.c index 6018066..cf545d9 100644 --- a/jni/osd_dji_overlay_udp.c +++ b/jni/osd_dji_overlay_udp.c @@ -21,7 +21,7 @@ #include "hw/dji_services.h" #include "json/osd_config.h" #include "fakehd/fakehd.h" -#include "libspng/spng.h" +#include "font/font.h" #include "lz4/lz4.h" #include "toast/toast.h" #include "net/network.h" @@ -29,6 +29,7 @@ #include "msp/msp.h" #include "msp/msp_displayport.h" #include "rec/rec.h" +#include "util/display_info.h" #include "util/fs_util.h" #include "util/time_util.h" @@ -45,26 +46,11 @@ #define GOGGLES_V1_VOFFSET 575 #define GOGGLES_V2_VOFFSET 215 -#define NUM_CHARS 256 -#define NUM_FONT_PAGES 4 - #define INPUT_FILENAME "/dev/input/event0" #define SPLASH_STRING "OSD WAITING..." #define SHUTDOWN_STRING "SHUTTING DOWN..." #define SPLASH_KEY "show_waiting" -#define FALLBACK_FONT_PATH "/blackbox/font" -#define ENTWARE_FONT_PATH "/opt/fonts/font" -#define SDCARD_FONT_PATH "/storage/sdcard0/font" - -typedef enum { - FONT_VARIANT_GENERIC, - FONT_VARIANT_BETAFLIGHT, - FONT_VARIANT_INAV, - FONT_VARIANT_ARDUPILOT, - FONT_VARIANT_KISS_ULTRA -} font_variant_e; - #define FORCE_RENDER_HZ 2 #define TOAST_HZ 2 @@ -87,18 +73,7 @@ typedef enum { #define MAX_DISPLAY_X 60 #define MAX_DISPLAY_Y 22 -typedef struct display_info_s { - uint8_t char_width; - uint8_t char_height; - uint8_t font_width; - uint8_t font_height; - uint16_t x_offset; - uint16_t y_offset; - void *fonts[NUM_FONT_PAGES]; -} display_info_t; - static void rec_msp_draw_complete_hook(); -static font_variant_e font_variant_from_string(char *variant_string); static volatile sig_atomic_t quit = 0; static dji_display_state_t *dji_display; @@ -221,9 +196,9 @@ static void clear_framebuffer() { } static void draw_screen() { + clear_framebuffer(); + void *fb_addr = dji_display_get_fb_address(dji_display, which_fb); - // DJI has a backwards alpha channel - FF is transparent, 00 is opaque. - memset(fb_addr, 0x000000FF, WIDTH * HEIGHT * BYTES_PER_PIXEL); if (fakehd_is_enabled()) { fakehd_map_sd_character_map_to_hd(msp_character_map, msp_render_character_map); @@ -273,190 +248,21 @@ static void msp_callback(msp_msg_t *msp_message) displayport_process_message(display_driver, msp_message); } -/* Font helper methods */ - -static font_variant_e font_variant_from_string(char *variant_string) { - font_variant_e font_variant = FONT_VARIANT_GENERIC; - if(strncmp(current_fc_variant, "ARDU", 4) == 0) { - font_variant = FONT_VARIANT_ARDUPILOT; - } else if (strncmp(current_fc_variant, "BTFL", 4) == 0) { - font_variant = FONT_VARIANT_BETAFLIGHT; - } else if (strncmp(current_fc_variant, "INAV", 4) == 0) { - font_variant = FONT_VARIANT_INAV; - } else if (strncmp(current_fc_variant, "ULTR", 4) == 0) { - font_variant = FONT_VARIANT_KISS_ULTRA; - } - return font_variant; -} - -static void get_font_path_with_prefix(char *font_path_dest, const char *font_path, uint8_t len, uint8_t is_hd, font_variant_e font_variant) -{ - char name_buf[len]; - char res_buf[len]; - - switch (font_variant) - { - case FONT_VARIANT_BETAFLIGHT: - snprintf(name_buf, len, "%s_bf", font_path); - break; - case FONT_VARIANT_INAV: - snprintf(name_buf, len, "%s_inav", font_path); - break; - case FONT_VARIANT_ARDUPILOT: - snprintf(name_buf, len, "%s_ardu", font_path); - break; - case FONT_VARIANT_KISS_ULTRA: - snprintf(name_buf, len, "%s_ultra", font_path); - break; - default: - snprintf(name_buf, len, "%s", font_path); - } - - if (is_hd) - { - // surely there's a better way... - snprintf(res_buf, len, "%s", "_hd"); - } else { - snprintf(res_buf, len, "%s", ""); - } - - snprintf(font_path_dest, len, "%s%s.png", name_buf, res_buf); -} - -static int open_font(const char *filename, void *fonts[], uint8_t is_hd, font_variant_e font_variant) -{ - char file_path[255]; - - get_font_path_with_prefix(file_path, filename, 255, is_hd, font_variant); - DEBUG_PRINT("Opening font: %s\n", file_path); - struct stat st; - memset(&st, 0, sizeof(st)); - stat(file_path, &st); - size_t filesize = st.st_size; - if(!(filesize > 0)) { - DEBUG_PRINT("Font file did not exist: %s\n", file_path); - return -1; - } - display_info_t display_info = is_hd ? hd_display_info : sd_display_info; - FILE *fd = fopen(file_path, "rb"); - if (!fd) { - DEBUG_PRINT("Could not open file %s\n", file_path); - return -1; - } - - spng_ctx *ctx = spng_ctx_new(0); - DEBUG_PRINT("Allocated PNG context\n"); - // Set some kind of reasonable PNG limit so we don't get blown up - size_t limit = 1024 * 1024 * 64; - spng_set_chunk_limits(ctx, limit, limit); - DEBUG_PRINT("Set PNG chunk limits\n"); - spng_set_png_file(ctx, fd); - DEBUG_PRINT("Set PNG file\n"); - - struct spng_ihdr ihdr; - int ret = spng_get_ihdr(ctx, &ihdr); - DEBUG_PRINT("Got PNG header\n"); - - if(ret) - { - printf("spng_get_ihdr() error: %s\n", spng_strerror(ret)); - goto err; - } - - if(ihdr.height != display_info.font_height * NUM_CHARS) { - printf("font invalid height, got %d wanted %d\n", ihdr.height, display_info.font_height * NUM_CHARS); - goto err; - } - - if(ihdr.width % display_info.font_width != 0) { - printf("font invalid width, not a multiple of %d\n", display_info.font_width); - goto err; - } - - DEBUG_PRINT("Image pixel size %d x %d\n", ihdr.width, ihdr.height); - - int num_pages = ihdr.width / display_info.font_width; - - DEBUG_PRINT("Font has %d pages\n", num_pages); - - size_t image_size = 0; - int fmt = SPNG_FMT_RGBA8; - ret = spng_decoded_image_size(ctx, fmt, &image_size); - if(ret) { - goto err; - } - - DEBUG_PRINT("Allocating image size %d\n", image_size); - - void* font_data = malloc(image_size); - ret = spng_decode_image(ctx, font_data, image_size, SPNG_FMT_RGBA8, 0); - if(ret) { - printf("Failed to decode PNG!\n"); - free(font_data); - goto err; - } - - for(int page = 0; page < num_pages; page++) { - DEBUG_PRINT("Loading font page %d of %d, placing %x\n", page, num_pages, fonts); - fonts[page] = malloc(display_info.font_width * display_info.font_height * NUM_CHARS * BYTES_PER_PIXEL); - DEBUG_PRINT("Allocated %d bytes for font page buf at%x\n", display_info.font_width * display_info.font_height * NUM_CHARS * BYTES_PER_PIXEL, fonts[page]); - for(int char_num = 0; char_num < NUM_CHARS; char_num++) { - for(int y = 0; y < display_info.font_height; y++) { - // Copy each character line at a time into the correct font buffer - int char_width_bytes = display_info.font_width * BYTES_PER_PIXEL; - int char_size_bytes_dest = (display_info.font_width * display_info.font_height * BYTES_PER_PIXEL); - int char_size_bytes_src = (ihdr.width * display_info.font_height * BYTES_PER_PIXEL); - memcpy((uint8_t *)fonts[page] + (char_num * char_size_bytes_dest) + (y * char_width_bytes), (uint8_t *)font_data + (char_num * char_size_bytes_src) + (ihdr.width * y * BYTES_PER_PIXEL) + (page * char_width_bytes), char_width_bytes); - } - } - } - - free(font_data); - spng_ctx_free(ctx); - fclose(fd); - return 0; - err: - spng_ctx_free(ctx); - fclose(fd); - return -1; -} - -static void load_font(void **font_buffer[], uint8_t is_hd, font_variant_e font_variant) { - // Note: load_font will not replace an existing font. - if(*font_buffer == NULL) { - if (open_font(SDCARD_FONT_PATH, font_buffer, is_hd, font_variant) < 0) { - if (open_font(ENTWARE_FONT_PATH, font_buffer, is_hd, font_variant) < 0) { - open_font(FALLBACK_FONT_PATH, font_buffer, is_hd, font_variant); - } - } - } -} - static void load_fonts(font_variant_e font_variant) { char file_path[255]; get_font_path_with_prefix(file_path, "FONT font", 255, 0, font_variant); toast(file_path); - load_font(&sd_display_info.fonts, 0, font_variant); - load_font(&hd_display_info.fonts, 1, font_variant); - load_font(&full_display_info.fonts, 1, font_variant); - load_font(&overlay_display_info.fonts, 1, font_variant); -} - - -static void close_fonts(display_info_t *display_info) { - for(int i = 0; i < NUM_FONT_PAGES; i++) { - if(display_info->fonts[i] != NULL) { - free(display_info->fonts[i]); - display_info->fonts[i] = NULL; - } - } + load_font(&sd_display_info, font_variant); + load_font(&hd_display_info, font_variant); + load_font(&full_display_info, font_variant); + load_font(&overlay_display_info, font_variant); } static void close_all_fonts() { - close_fonts(&sd_display_info); - close_fonts(&hd_display_info); - close_fonts(&overlay_display_info); - close_fonts(&full_display_info); + close_font(&sd_display_info); + close_font(&hd_display_info); + close_font(&overlay_display_info); + close_font(&full_display_info); } static void msp_set_options(uint8_t font_num, msp_hd_options_e is_hd) { @@ -506,8 +312,8 @@ void dji_display_open_framebuffer_injected(dji_display_state_t *display_state, d display_state->pb_0->voffset = GOGGLES_V1_VOFFSET; display_state->pb_0->hoffset = 0; - // On Goggles V1, the UI and video are in Z-Order 1. On Goggles V2, they're in Z-Order 4. - // Unfortunately, this means we cannot draw below the DJI UI on Goggles V1. But, on Goggles V2 we get what we want. + // On Goggles V1, the UI and video are in Z-Order 1. + // On Goggles V2, they're in Z-Order 4, but we inline patch them to Z-Order 1 (see displayport_osd_shim.c) display_state->pb_0->order = 2; diff --git a/jni/util/display_info.h b/jni/util/display_info.h new file mode 100644 index 0000000..60c65d6 --- /dev/null +++ b/jni/util/display_info.h @@ -0,0 +1,16 @@ +#pragma once + +#include + +#define NUM_CHARS 256 +#define NUM_FONT_PAGES 4 + +typedef struct display_info_s { + uint8_t char_width; + uint8_t char_height; + uint8_t font_width; + uint8_t font_height; + uint16_t x_offset; + uint16_t y_offset; + void *fonts[NUM_FONT_PAGES]; +} display_info_t; \ No newline at end of file diff --git a/jni/util/fs_util.c b/jni/util/fs_util.c index c7f6896..f4c0987 100644 --- a/jni/util/fs_util.c +++ b/jni/util/fs_util.c @@ -2,6 +2,7 @@ #include #include #include +#include #include #include #include @@ -33,7 +34,7 @@ void *open_dict(int dict_version, int *size) { size_t filesize = st.st_size; int fd = open(file_path, O_RDONLY, 0); if (!fd) { - return -1; + return NULL; } void* dict = malloc(filesize); void* mmappedData = mmap(NULL, filesize, PROT_READ, MAP_PRIVATE, fd, 0); From bdd0735fd31f0bee682b0fc36ddda52886430aed Mon Sep 17 00:00:00 2001 From: bri3d Date: Wed, 14 Dec 2022 21:33:20 -0700 Subject: [PATCH 5/7] add font converter --- jni/font/font.c | 115 +++++++++++++++++++++++++++++++++++--- jni/font/font.h | 12 +++- jni/osd_dji_overlay_udp.c | 2 +- 3 files changed, 116 insertions(+), 13 deletions(-) diff --git a/jni/font/font.c b/jni/font/font.c index 66f229e..4d380a0 100644 --- a/jni/font/font.c +++ b/jni/font/font.c @@ -1,15 +1,14 @@ +#include +#include #include #include #include +#include #include "../libspng/spng.h" #include "font.h" #define BYTES_PER_PIXEL 4 -#define FALLBACK_FONT_PATH "/blackbox/font" -#define ENTWARE_FONT_PATH "/opt/fonts/font" -#define SDCARD_FONT_PATH "/storage/sdcard0/font" - #define HD_FONT_WIDTH 24 #ifdef DEBUG @@ -34,7 +33,7 @@ font_variant_e font_variant_from_string(char *variant_string) { return font_variant; } -void get_font_path_with_prefix(char *font_path_dest, const char *font_path, uint8_t len, uint8_t is_hd, font_variant_e font_variant) +void get_font_path_with_extension(char *font_path_dest, const char *font_path, const char *extension, uint8_t len, uint8_t is_hd, font_variant_e font_variant) { char name_buf[len]; char res_buf[len]; @@ -64,15 +63,14 @@ void get_font_path_with_prefix(char *font_path_dest, const char *font_path, uint } else { snprintf(res_buf, len, "%s", ""); } - - snprintf(font_path_dest, len, "%s%s.png", name_buf, res_buf); + snprintf(font_path_dest, len, "%s%s%s", name_buf, res_buf, extension); } static int open_font(const char *filename, display_info_t *display_info, font_variant_e font_variant) { char file_path[255]; int is_hd = (display_info->char_width == HD_FONT_WIDTH) ? 1 : 0; - get_font_path_with_prefix(file_path, filename, 255, is_hd, font_variant); + get_font_path_with_extension(file_path, filename, ".png", 255, is_hd, font_variant); DEBUG_PRINT("Opening font: %s\n", file_path); struct stat st; memset(&st, 0, sizeof(st)); @@ -184,4 +182,103 @@ void close_font(display_info_t *display_info) { display_info->fonts[i] = NULL; } } -} \ No newline at end of file +} + +void convert_bin_fonts(const char *file_location) +{ + display_info_t sd_display_info = { + .char_width = 30, + .char_height = 15, + .font_width = 36, + .font_height = 54, + .x_offset = 180, + .y_offset = 0, + .fonts = {NULL, NULL, NULL, NULL}, + }; + + static display_info_t hd_display_info = { + .char_width = 50, + .char_height = 18, + .font_width = 24, + .font_height = 36, + .x_offset = 120, + .y_offset = 80, + .fonts = {NULL, NULL, NULL, NULL}, + }; + + for(int is_hd = 0; is_hd < 2; is_hd++) { + for(int i = 0; i < FONT_VARIANT_COUNT; i++) { + int page_count = 1; + char file_path[255]; + get_font_path_with_extension(file_path, file_location, ".bin", 255, is_hd, i); + char page_2_file_path[255]; + get_font_path_with_extension(page_2_file_path, file_location, "_2.bin", 255, is_hd, i); + char *file_paths[2] = {file_path, page_2_file_path}; + struct stat st; + memset(&st, 0, sizeof(st)); + stat(file_path, &st); + size_t page_1_filesize = st.st_size; + stat(page_2_file_path, &st); + size_t page_2_filesize = st.st_size; + display_info_t display_info = is_hd ? hd_display_info : sd_display_info; + size_t desired_filesize = display_info.font_height * display_info.font_width * NUM_CHARS * BYTES_PER_PIXEL; + DEBUG_PRINT("Found a font candidate to convert: %s %d\n", file_path, page_1_filesize); + if(page_1_filesize == desired_filesize) { + DEBUG_PRINT("Found a font to convert: %s %d\n", file_path, desired_filesize); + } else { + continue; + } + if(page_2_filesize == desired_filesize) { + page_count = 2; + } + void *image_buf = malloc(desired_filesize * page_count); + for(int page = 0; page < page_count; page++) { + int fd = open(file_paths[page], O_RDONLY, 0); + if (!fd) { + DEBUG_PRINT("Could not open file %s\n", file_path); + continue; + } + void* mmappedData = mmap(NULL, desired_filesize, PROT_READ, MAP_PRIVATE, fd, 0); + if (mmappedData != MAP_FAILED) { + for(int char_num = 0; char_num < NUM_CHARS; char_num++) { + for(int y = 0; y < display_info.font_height; y++) { + // Copy each character line at a time into the correct font buffer + int char_width_bytes = display_info.font_width * BYTES_PER_PIXEL; + int char_size_bytes_src = (display_info.font_width * display_info.font_height * BYTES_PER_PIXEL); + int char_size_bytes_dest = (display_info.font_width * page_count * display_info.font_height * BYTES_PER_PIXEL); + memcpy((uint8_t *)image_buf + (char_num * char_size_bytes_dest) + (display_info.font_width * page_count * y * BYTES_PER_PIXEL) + (page * char_width_bytes), (uint8_t *)mmappedData + (char_num * char_size_bytes_src) + (y * char_width_bytes), char_width_bytes); + } + } + } else { + DEBUG_PRINT("Could not map font %s\n", file_path); + free(image_buf); + continue; + } + close(fd); + munmap(mmappedData, desired_filesize); + } + char out_file_path[255]; + get_font_path_with_extension(out_file_path, file_location, ".png", 255, is_hd, i); + FILE* out_fd = fopen(out_file_path, "wb"); + if(out_fd == NULL) { + DEBUG_PRINT("Could not open output %s\n", out_file_path); + continue; + } + spng_ctx *enc = spng_ctx_new(SPNG_CTX_ENCODER); + struct spng_ihdr ihdr = + { + .width = display_info.font_width * page_count, + .height = display_info.font_height * NUM_CHARS, + .bit_depth = 8, + .color_type = SPNG_COLOR_TYPE_TRUECOLOR_ALPHA + }; + spng_set_ihdr(enc, &ihdr); + spng_set_png_file(enc, out_fd); + spng_encode_image(enc, image_buf, desired_filesize * page_count, SPNG_FMT_PNG, SPNG_ENCODE_FINALIZE); + spng_ctx_free(enc); + free(image_buf); + fclose(out_fd); + } + } +} + diff --git a/jni/font/font.h b/jni/font/font.h index 2b7aebc..27fd7c9 100644 --- a/jni/font/font.h +++ b/jni/font/font.h @@ -2,15 +2,21 @@ #include "../util/display_info.h" +#define FALLBACK_FONT_PATH "/blackbox/font" +#define ENTWARE_FONT_PATH "/opt/fonts/font" +#define SDCARD_FONT_PATH "/storage/sdcard0/font" + typedef enum { FONT_VARIANT_GENERIC, FONT_VARIANT_BETAFLIGHT, FONT_VARIANT_INAV, FONT_VARIANT_ARDUPILOT, - FONT_VARIANT_KISS_ULTRA + FONT_VARIANT_KISS_ULTRA, + FONT_VARIANT_COUNT } font_variant_e; +void convert_bin_fonts(const char *file_location); void load_font(display_info_t *display_info, font_variant_e font_variant); void close_font(display_info_t *display_info); -void get_font_path_with_prefix(char *font_path_dest, const char *font_path, uint8_t len, uint8_t is_hd, font_variant_e font_variant); -font_variant_e font_variant_from_string(char *variant_string); \ No newline at end of file +void get_font_path_with_extension(char *font_path_dest, const char *font_path, const char *extension, uint8_t len, uint8_t is_hd, font_variant_e font_variant); +font_variant_e font_variant_from_string(char *variant_string); diff --git a/jni/osd_dji_overlay_udp.c b/jni/osd_dji_overlay_udp.c index cf545d9..97d9ed5 100644 --- a/jni/osd_dji_overlay_udp.c +++ b/jni/osd_dji_overlay_udp.c @@ -250,7 +250,7 @@ static void msp_callback(msp_msg_t *msp_message) static void load_fonts(font_variant_e font_variant) { char file_path[255]; - get_font_path_with_prefix(file_path, "FONT font", 255, 0, font_variant); + get_font_path_with_extension(file_path, "FONT font", ".png", 255, 0, font_variant); toast(file_path); load_font(&sd_display_info, font_variant); load_font(&hd_display_info, font_variant); From 089763f86f4f12370359678c3fd51e59b0c5b159 Mon Sep 17 00:00:00 2001 From: bri3d Date: Wed, 14 Dec 2022 21:46:13 -0700 Subject: [PATCH 6/7] swap to PNG fonts --- fonts/font.bin | Bin 1990656 -> 0 bytes fonts/font.png | Bin 0 -> 22962 bytes fonts/font_2.bin | Bin 1990656 -> 0 bytes fonts/font_ardu.bin | Bin 1990656 -> 0 bytes fonts/font_ardu.png | Bin 0 -> 32297 bytes fonts/font_ardu_2.bin | Bin 1990656 -> 0 bytes fonts/font_ardu_hd.bin | Bin 884736 -> 0 bytes fonts/font_ardu_hd.png | Bin 0 -> 22440 bytes fonts/font_ardu_hd_2.bin | Bin 884736 -> 0 bytes fonts/font_bf_hd.bin | Bin 884736 -> 0 bytes fonts/font_bf_hd.png | Bin 0 -> 113348 bytes fonts/font_bf_hd_2.bin | Bin 884736 -> 0 bytes fonts/font_hd.bin | Bin 884736 -> 0 bytes fonts/font_hd.png | Bin 0 -> 14217 bytes fonts/font_hd_2.bin | Bin 884736 -> 0 bytes fonts/font_inav.bin | Bin 1990656 -> 0 bytes fonts/font_inav.png | Bin 0 -> 33893 bytes fonts/font_inav_2.bin | Bin 1990656 -> 0 bytes fonts/font_inav_hd.bin | Bin 884736 -> 0 bytes fonts/font_inav_hd.png | Bin 0 -> 24131 bytes fonts/font_inav_hd_2.bin | Bin 884736 -> 0 bytes fonts/font_ultra.bin | Bin 1990656 -> 0 bytes fonts/font_ultra.png | Bin 0 -> 31983 bytes fonts/font_ultra_2.bin | Bin 1990656 -> 0 bytes fonts/font_ultra_hd.bin | Bin 884736 -> 0 bytes fonts/font_ultra_hd.png | Bin 0 -> 19540 bytes fonts/font_ultra_hd_2.bin | Bin 884736 -> 0 bytes jni/osd_dji_overlay_udp.c | 1 + 28 files changed, 1 insertion(+) delete mode 100644 fonts/font.bin create mode 100644 fonts/font.png delete mode 100644 fonts/font_2.bin delete mode 100644 fonts/font_ardu.bin create mode 100644 fonts/font_ardu.png delete mode 100644 fonts/font_ardu_2.bin delete mode 100644 fonts/font_ardu_hd.bin create mode 100644 fonts/font_ardu_hd.png delete mode 100644 fonts/font_ardu_hd_2.bin delete mode 100644 fonts/font_bf_hd.bin create mode 100644 fonts/font_bf_hd.png delete mode 100644 fonts/font_bf_hd_2.bin delete mode 100644 fonts/font_hd.bin create mode 100644 fonts/font_hd.png delete mode 100644 fonts/font_hd_2.bin delete mode 100644 fonts/font_inav.bin create mode 100644 fonts/font_inav.png delete mode 100644 fonts/font_inav_2.bin delete mode 100644 fonts/font_inav_hd.bin create mode 100644 fonts/font_inav_hd.png delete mode 100644 fonts/font_inav_hd_2.bin delete mode 100644 fonts/font_ultra.bin create mode 100644 fonts/font_ultra.png delete mode 100644 fonts/font_ultra_2.bin delete mode 100644 fonts/font_ultra_hd.bin create mode 100644 fonts/font_ultra_hd.png delete mode 100644 fonts/font_ultra_hd_2.bin diff --git a/fonts/font.bin b/fonts/font.bin deleted file mode 100644 index 7c50189d45b5313325f8bd498ff089bade41f0eb..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1990656 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 P5P$##AOL|MMBx7bvW%E3 diff --git a/fonts/font.png b/fonts/font.png new file mode 100644 index 0000000000000000000000000000000000000000..8f6ac600a63f8c458286d9915b50c76d8432c019 GIT binary patch literal 22962 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 literal 0 HcmV?d00001 diff --git a/fonts/font_2.bin b/fonts/font_2.bin deleted file mode 100644 index b671899be5f748383930ff7697366d16d279b50f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1990656 zcmeIu0Sy2E0K%a6Pi+o2h(KY$fB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj TFkrxd0RsjM7%*VK!0W&OVZs0b diff --git a/fonts/font_ardu.bin b/fonts/font_ardu.bin deleted file mode 100644 index f8f8d0365153ab3c53ae1d4dd519b60213809daf..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1990656 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�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

itzCQ`D!MJz*)s*Y zv&yV=peKDuW3R(!&xDhk`0(-8v)%1-bDq6JyS;9HM+auQy>8C4S846yv*C1GD*sgl zx*X-Z4xFbCY3z0Q?3r-#20nbe^=x;0Ij8?_&Am?F-GTY81LySLp|y+833Xd4&m9H2 zOzmO^>h#&}2boZZ&!hP8@z%5b=6l2r)agSS(IF55ArJx~5CS3aOalBnn`=l9wez2u zSMuqhKC{=It>n`~?J`&A%AEXMHuOyVs~zYc?rH|jso8;=9)`c5wRe&~^i2G#HHP`T zMz?EqUM!YAb5KJ*ycg7G?&G|MK20B?7>XgE=Dd79+`b=PzSli(`_;qASN1u{grF|r z^TmCJtlCiAI$iP8b4I%koHL(uYI@FSW;)IMiiiGHt$aS8)Gctyvs$3@FYRJaYIg4O zSKmIN&#*&xjq-5rn7DZnj&@CQqAEt6l9BwF{w#+WA-K%%pZX z^iVth>YSO>E{7g!=g&L@LLdY}AOu1n1VSJLLLdY}AOu1n1VSJLLLdY}AOu1n1VSJL zLLdY}AOu1n1VZ4M1oVIV(f!{YxwiEGr=9ule>&bBl)ufXJDc9hqriWb_!s^E?efq6 z)~h=zf16WxHocWcflcVsy`cY&KKqSr(sfgZe?A)h*ZGH;XNFz=umgK_{xhqGXS@7A y?=vi!VF-jk2!ucggg^*{KnR3D2!ucggg^*{KnR3D2!ucggg^*{KnOgL!2bhKqKaMs diff --git a/fonts/font_ardu.png b/fonts/font_ardu.png new file mode 100644 index 0000000000000000000000000000000000000000..5a5cd0b2df66d699724e46ede770e76c2b04edcd GIT binary patch literal 32297 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

(ChM#C4Ub1&car%_ zN#6&X;F1R=Q&a4ZIkkDBC~_H3Y@I4u&5MWb=Ew6KYd`}U(0~RspaBhNKm!`kfCe<6 z0S#zC0~*kP1~i}n4QN0E8qk0SG@tV&K1W(O>_w>t`3ga{v4NQ<`6W&Mtn(-O&Fo{vmf^ z|GW67+y(vb;!klO^e=zzH{O(|2fu%I^SR~eIS=}O760^{1^vH@e|XNq{$IuK&S9`2 z>-%;CSEL3spn+Ez*!_EK7r*=7P-Lw>=cW7y->|1SOmF29dX``^W1z&-7M7k?r5u>TGG?i>aivc8Wta7Ak1iGkDK zZ+se*1Ma?mck{VB{bfnr-ORYm-{rbb0~+{u4DkDaTzxaRSii+0DOu@9(w`zga%*H{&vY zmtXg1?;GX|{O&pO=Uy57W;sX6t1>S0`A%0fpn;!afZqq?>U+Z_SMe*4&nvRPSDhn& z?v=tfIk#)R3NAUn(@G6!Km!`kz*hr&o@DuT$F-S^%ltLkpX$1w?>kwR^1J8A|Ks}X z3BOsM?VVZ6xXjNmtkHl5{%r&NJ|I`$7B0DpUwQHKtH4*CBY*Cd!Z$g$YrYCDIluGY zuB<-Z`2EkT!|O^izbfI9tGIGBpn>-_!0&@BpWZCvGJls}_s8G+aa`bc&yhd(%HTK4 zIZ9rYahcC|x}pIM{1gNHJ|I`$8!owuUwI2Zw_;zr`SHAW9rL=9tM37qT*a@vH-7)T zd;h$Sysjkks}e4`iYrG08hBp={65I?>CG}O^LP1mfBf8v;{v~Xj{Lb-2ESR(QSz#c z%Y44m6%A-W0~*l4*Z`j=XZ~vvA4#BzI~+ z1OJKvejjA{^qv`)`MdnOKYnh-ae?1GNB-O^gWoLYD0x-JWj^2OiUu^G0S#zC0~*kP z1~i}n4QN0E8qk0SG@taF$Qc&A80p<=6f3|2^wCz6&q=cJpZs4_Q)oH#08tce(Dy=$NZqL@whc{P_10;{soD4!oGF_zj1C$t8YXz+cs;91Und0~*kP1~hkj^Q*FZ zy;niyXg~uR(0~Ts%s~A-0K>kbkjlWCh zHTw=)uT$KsOYT3)34T0x>YRp4edJ_g>T72GKj3rjET8(T`B(T0yl~IM{#Wx4c=cSG zc#v?ie1Pt@Mt--rV6dCNphXcH(0~Rspn+`$_#EVbIKDfd?R&~+f6eTB?A7_wY{zAM zm6O%OLrOD#bdSh+A)liU{^}mb1fP32i zYW@L__b+|iO*mQJ<+5)V_f>q(F*Tq84QN0E-_bz*oQ>Zrk&)^xO3bw8^@jakBXd{w3}SkN%sM>*Fr| zDR-jJtY7+n3I9T$qkid|r2cBMf0QHcX#Z$^H-B`#>l)C21~i}n4ZO}k{oLpKY&n+i z0joNADW7|g3+~hP50`wvKjp%YdEvZW{9D`$_t?c>!acdiOZd&}U(a*=`TJ_OkD}Ti z4QN0E8qk0SzPSOu5A14l7r%1(p1GmU1M-OF8m+;=#R-`_4Yf5XrO*h^L>mgB1WIzv-@W2 zqWjr>^m$m%eMZ^b7asjE-o@|E8TFa1H~qtlxvKxjWqiw1+1%{|c930N<{{2s;B(|9 zPYs{_qkIXUzM>DttT#F8oAs&Jq2W@`{@G+-=W79%^LO(P&uRK+{b_dh*ubYh&SAVd zck@^GD^CL&(0~TMmjOOU$kpA!C71H~enu8J=Ztcy54hw)e(ewL)ol96?y;L+&wbE0 zuTR$hZvG`dr5XAqPy42R)(`bfj`(#w<2M}oC8xL)ZRFQ};Ggt+t8aK4`Jak7Dc*1euwwC%8T_U{8KNH6UPmg*CqD9l^^>VjSu?G`mXmF@#6Xg{;8J}4*im~&x8N$ z=5r){%qIJ0bCyfpESEa=#bo_yMlR#0T=#200~*kP1~l+}4b;zjz9*J8SAYJm=65{$ zCKvR-nt#fp@0b_vv5S9;d*L3t_)EAa_jn1vdHw5ojz51d?eRFcj@(M_BH6k$J6uR+_(pa?dEe%%&Bv^U)($~-p!9KjLwVo zSI4{gSNpME0~*kP1~j07KL+@m{xkFOG&`Tw!OPZX=TGah?~zyMOS7EQ<3azg z;vb&V^v&x;-Q9$fey;MpIA&>#&)vH{{#Aaw5915> zI_)1`%&UCrBWHHZ{*v*B*YDOnIKM#QL_Xt7{DudYgctKAeEQ3&tZPlrcnK`A_?E zzXmj*0S#zir-Ax8$oI{15TA>y&U`7Kdyot6)AbLR+|B14^2T|m{lg`9^Ero{IPX&b zaLK3qW`FJDWL%aGe@^=^J4RgA58>?Rz9jQaX8T9;hy6F)QGb{C3%Q)z^}mb1f!p=} zLO$oNO5PvjDy|$2XdpMhzc(_kyte|Eyhr)EtMd39BTLz;b9VE&5&e?PuS&S&Dy|$2 zXg~uR(0~RspaBhNKm+e)fWM2#)&0XISMe*4zkA67Uv(_|8U7w{L16+Ub4VfowJ*d2l^$MUzKplRa`k5(0~RspaBhN zKm!`kfCk>p0Dl*etNVvbuHsi7fA^9FzUrLad_2%E$^5E>ORnO|(SQatpaBhNKm!`k zfCe=1ZU*?fh+N%2Tyhn^^7y-#Ebvw5?B?Tveo5w6C0ue9SB?fWpaBhNKm!`kfCe<6 zfp;^&-$mr={^63V_?5@sy<~x}I%hW@5A;hizbfI9tGIGBpaBhNKm!`kfCe<60S&yH z0sbx`SN9K>T*a?E{_Z6UeAPL-`FNmTlKE8$mt4h_qX7+QKm!`kfCe<60S){-1N>b< zt~LOdT*a?E{%#}-eAPL-`FNmTlKE8$mt4h_^Suo0etmcGD|f@cUtXPE{EkciWI6n) zuU-68F8z}??y-x1$Zh(o>x}82WWHqfvzyPkU7t)I7x>!6KjqRtdE*|t_=nu4zq-zt{z>LbW7Qi2WcIV0&$(TnOdjNHUEDgmZ?-P-9cw@X8qk0SH1K)@v!C0ub@2wX z`)2Fl*LuE>k!3M*Ms@IFj`nrua6Z}e5xH@Ecn+MH7r30Wn?H5VjlSWMr}tREKRjn4 z_f`Dv90nVb_x}d8NDXK}0~+`N2KXEyvn#VsW_59%dNQsvW}Rd{%UXBx{S3~i?r-rq z_prZsFUDmP_hSDjck?;_^qd=g!zFj~56@Z9H(av2#|D0P4ucI@@3Da^QUg~E@IEB7 zy{wa2U7V+$jO&b9Cz;Q(*719tEXC~al6A7F`&)d@J-i2f#+>LIF1edOb+0QvsoMvBF50}j9n2&XFOjB9?Xg%`cc(i}C9(i#*+CN&4yf_~1&(`6PrLKD& z8E5-P>u^cxfbeEUCMj8JGD-+yfuj>-Ddj9kV`xY196%KtE1J#6&D>xXZW`Be#*T*Z~60S#zC0~&Z|1AH!$ z@h+qJY#k2kB=h8G{&fB1`$^r$dN~YEH-E6+^~E}wakBY?eTRJZ$NJHjeL$P+?n&K< z7uVU>aCuzChZpl(@=KG4eZ}Upy688KvwaKsphovNT#x<6G4P3d+~wDO-;ICZ;q-n7 z^^Lmv*zG^4@7AM_gZjv4-1%g(N!FQSOfsJ(b!4oI^Nh(@?^pvG_&El4{~p-IuiOj2 zhp)b(^3RREtDmlK-allya$P^a`swN_K7Dj~(C4M~=6>Bi=2!9I#N?b4gSD@?Z+5(j z-*CEqn)&PsS^c4Jc-)V1250@CKJr0i{jeVMyVcWQ)>n7$1260!))lGK4a1!^NeH0b;hHFLmlIoah)+4>lu&MsU!bl zeQBZl>E36fzE~#y3~2c<3i`va$Tk%*XtMA6}13 zufqlItN7hHO@I9Rj7j~~jGSzIm215Qev$$H-R!#aE`H_mTemd7`kbx&jeXbGaW{X1 z@A&>({dz|JyN~hnmdX3`U9)-rzoq|ofAibF1~i}n4QN0E8u&&A_&&I+CHd!O|CS%l zoz3%Gd|jR8Qumc`JX7nh{vB3Ov*+yQb1V9pP4>;^ESI`j?&`YT=gU8T#opb|`R!cQ zfCe=1)d0WuVt%dsn2B|aUtM3%&A$JXW@2C8rM~N<>63oROFr=cFOHdS@)rMqn{lqr zXI`#yvU>TMnUDFG_$fz?-rwh4j#qc{#~pm{irs#;^8NjjzPYM*{ha$LtC=U>w`2xl zz02r5jyboE2i zJ?qqy%->BoS>ENc?|@sTx}Waf7yCw82>d(hUzkJ^E@s_qvt*9aNfTf9#+6TY18-Jl3D)LI1n? zc)I0^$EhoNwCA=X5+XUY)!7tNWFw0S#zC1A7fT{ahIBAFYpW zm+i0f6W?Dl{%HSbJ>xQ;?a$`fcQp@r54^y zSlr#uE^q;&S9w{?&TUna!>If93bj!h2NTkr&6aFWy021~j07pK4(D@6)aPg`ew(um5g-IkfuO zc+PG<-m-Ie{jVlm@}+!UkGsk1O7o2G^5Q;t8NXS->Ye%qT_1P(&$#jYyW_2VUYF8b z=Iw6Zb>D9OuD+W~Z}HObebj&kH1IA4_-jvI%~^P<+s&sH?me6A zo6T7+b+cUSG@t)_Y= ziO-$cI=JNQzS+8~T=c5zP+b@87w!24)6uL_vuQg?~Z?}yne@Jr{+a;dw@Z|do5l$ZRxfPb|g z>ouSO4QN0E-@(A>^ER$u?K$orjW6-}-Z7g6&iPa4%yOx_%5UoFYm`%cH$@{}TyM7e zr~wUVKm!^$HqduZ}aW^BT~A1~i}n4QN0E8qmO316RLqQ~#B8JVX7}Jf?-&yMO-_4E+RR zKiti4`k>KjPOq{`Wdp za|AEzFXeOIg&bX>>;D3GlQe)jaj{0{-ZH*EOI44QN0E z8qk0SG@tn?uf^8Y{6hURzicX3g$ zi@%F&-xxU0cl94{!NN%4~l&KjOvpjFZjB{n;^BE`3XZy4HxPLUx zINAJ&m#t^KY(C>;^BE_b&p4y`jF-)icyT@BWb<+V>^S3P^Rry)GEO$nzN=Yz2b;3_ zgVNKfjFZiu!d%pV1~i}n4ZN9w?DOvGe0J@toUA_bYu$yvv$FcgWt`PtorgzW-JjLN zi<#A5oqrXVbFTK6)x#sRx~uc>VqWEB^^qIL*}kjuk<0ihC##2-Ww!6?{NLhp?$v&? zdU!Fj`m6Ji8^@IwC(HQi`~jj)UFBr;8Q*ygXg~uR(7<;#u={guE5G?WYs)#i`Mfc9 zpR=3qJuonryIzl7TyC|Czl&?%7)W!=@6G14-TdY#A2px>4QN0EZ(|_)e9Y#rUM%Be z^OyM9_qJ^Q61)^=oNWFopZbiK&9iSdGfp-?%Z+szFPo41N8^l>&5wB5ddAD#|Z#FYdHvhM|oS*fV&9m=9X1|BC`3vY;nsKuE zt9ZoR{72>U@Lj9Y9=rG*H_BLWk6rwX zTj!(q8~517KjqRVdE*|t`Cr~5zk1~7%i`~ac#l|jGS2Q(w>0P0x)V-ZI^}*TzJ8Bg z{7c*$_t?#kEjiYJ1~j07H3sVM?}8%NQ2$Wil7Cj7Jyjl`=VU>yI%gNZ<3Xzo*T6e;UOBojqdH0-M z{8KJI$kP1Pd+g@Vz7BW2zlxuEis#?G$1eUQZoEwPzG~`r^P8i5)WDB3u>0TFZay#A zrE?~J@4zK@^QX?a(KlT3^d1ZNhvzKhzKY+SQwG%=lM53rxezT%0~*kP1~i}n4QSvS z8aVwvKI(Vkd-ZNUEnYfjqHnn5ZvNCcH~NN4p5EgIKjU@t88@4!*^(V6o6k7ee8b`K z^c?#5EdC9S^Q<4_Zazn5=hXEJKH$aN&F8%CoCSTuC3o|?bIPEe$K=9rWOhznzu*I2%+>si*Ue{rXY)#=PT3Bhv(q66Kfy~%>CCV8|NTFIOuz(8zywUd z1WdpLOuz(8zywUd1WdpLOuz(8zywUd1WdpLOuz(8zywUd1WdpL9z@`OnwQc4`zwnh zFaL@C)#nL*SN4449EIxswo?qaH%N(wYYh-eW zt2X1A#Y0bCs%JKf$yrV|H;ad!ynLD;dZQlt%+|Xa=b)mtpBJcGIb{1d*(3XTeK#i} zG0Aw|9jBS5?WX}Jhm23ii8Xg#)6$)Ds=c4=hu*ABzywUd1WdpLOuz(8zywUd1WdpL zOuz(s0@c3({gc;s*cSliEnTy(}HH#jo?Puw~trE|Td&E}i z&po2{e)Z1}`B1-smG+CX=z*F!LAT2-pQriZqMqi>ez-exeTCJ$^SQhBGv_ws(@HAw zdFOL?D|54)a}(!P*{n)@-r09ezywUd1WdpLOuz(8zywUd1a=Xq{Eo()U30TOoK?|T zpIz~a2j=XWoAuEw{w4BO#L2oe=dOpDq*CjvnNj}uf37S2xX#1(tyTYnIrJiX&b5`c_d_Gt9h_&;T z*6*^XG~db8t*vr`u1}n24*Sysb@0I2`IPxx_L1gX>YF^!p*(OFJy0_zX!g9KAM1x4 zr~?Q3zrrD_ReyS*wx9GpB6eVuao!al&78${&CUAEW{>V=eH=Fd6EFc2FaZ-VfnOsq z`mXe!*k66@rzbBa{QZc!l_;k#-yYE{dZ7M6KZi`nhx#T~_R}BxLndJ_lpo@K=W`MD z=XszGbCnQ4{UVXpE+yzg9(s3+%AZ=6+eWj}LDLq1`TloR6f&gbrG*5u46 z=Lh|e>W~AuQNNQFXVC*SbGWFD`e}T)GNoJQ9}=i*?cJOAD065(8JT%p-2U*n zqeJ^4jh7xW`NRGCWj|Vb+nS-~zEFq!ewWWhh8{SJ9;lgfZuGF~34Y{(>#gX!nN&P5 z=hysjz2rd6oTl&i==`+i()2*hoIA{f{!j43Wy(+HlgV$;_VWhF9$^9|U;-v!0w!Pr zCSU?4U;-v!0w!Pr4Zw#``;{R@7E9QgND>IP((zY)~1KRrq`>*C#JY+eCvx+}cvi_@a`h$w}*Szl9j{4o3v)V`5Dia^E5y7DQ_)E&75~?dZ2!%2hO4gYUWs*fC)UG0H5D0 zde=&?cwp_<`^kQeGu|MGNfy5dYS^E%sO^U|&S^3{v3E=RRdM)hez;!psl@Ntugcua zr~SO%kLEMya0efr+l_klNb7yL(F1#ar5~P$ik`6D!l&YaIlthC>!r@t&K&BHe|o>z zlREU*v%?(fkpK05xb}*^n@`09bAHWFSg+4B4@1*`#V4D4G2Y6TKI!^fmmT+(%xs!D z^L^S+I5xVx=-Gbe=WIJ4ZQMjm_SAkFw|DZ%W@XzK^0)6-=r0!b^CDnA{ogKlHvWoF zHuqw@l`nntytJx2^pcsIJaApBew=RtCh!~re3mQvZs!#b%=raBS}%XjR&;}-+Kr&p zv*Lj{_Cp%IHlLmeBRBEkqoK1MW@T~K-l4O(S^N$U?3vBY;;gkc0TXy8f$aHRjqh6B z>f9{*MLv84bhbm!)i`@z(W`T_{3{+< zoAqCfv!}HQn80Tdc-r%BKmGX;6aK8M=+;WLecRI!^{jYcj{T5Eug#}t!pKd0_#o(P zhgn&iwRh-jZWh181AAt3vp8$5O~3@6N#JSEul>x=Nydlqd567sIXBaLC(gTN9vGi@ z*n3xVC*Nn3vv>5cn`YThozEY#8t#|4>#*+d}vbMT9BGK@6_}_{Z0>@MGw@>u{Hq{FaZ-V z0TY-L;LlL%dDVS)>4EybiSy3%Ks~S8dslP)eSQe`X?$o>-dd2FIq%f;K>bb+oJ9}R z%&|5B6EFc2FaZ-V0TVC*6EFc2FaZoao@Akm{AMGdm+u)UW142I387t*n znVZ$xPe!JX2UdTwUv%}Yez-2KmwGiP+pN_-^gzAZ$9_ofrOD8I%!dScHW;U7j?WLt zytMhezI*j#%!g;=TlsK}Z_sVT@T2eZ?e07E(9D}XaJ`uy$4$TlOyHLZ@IASz@8GuT zf%!k>C;RTicmwh_KAf9r`+1Qe2eM+k={r6;582!-eutUX^CSF_2{ru(K3Z4E$>O10 zm&)hdOov%&65{GPiL;hkwV4OTL;qo)kfZ(~&RXg$|8$)Gse>Q(x1R>8$cL;}wPsZI zWskZ z+B@R*GpA}kAIhiM*4_m@U(w#XnFq%APMmk++)U3q_^t_Vr z!);}5mh)47_&a!}8xXR(l~3k@ar=4EAcrULu^&AedS19MnI<=N*emR3&QpBCUfdne zT-`l4>;EZ!GM`y|xZdn}WV|&T)@Fl>@nKKS&GfJNA&1G@#dDHh+?ruprN46M(|+{) z5bTf@xiR^KR{tV@$4@?70A&6@OA4w+2yS3NLavnKtO^G-k6Ec&Eoe$egm^yhHx^g!Jv4r@<4c@++O za&D$?^26l}y-nsapM7>|_FvVzJh0EI2j;VnwF#Jj37CKhn1BhGfC-p@37CKhn7}y# z{9QZK=Q^LO$~-WBuJgGn&dv0>&h@I{T>ibQwHoG3;`Ql$=5Ut%2$c9_OjhGzA2p~b z>}L+@kWb)0%+L08K6-d}*gx~YI6Y7^XE<>l{0Kjj^`7=W$D+H#{`NEH)9#8}rZa|F zTodO)b0>Y2LvLAr7N6VDUCo;GQO-mB$UOZ}7uUi*nbz7TJz1;#U-QHD22DQHLsrFF z_MyJg^GYo}P+#eJrIsG7O~3?9zywU-TM6iACBLUtbOWN=jd0Yn;(<9o;)kfkDy%(= zv-S?1&CTL>cwo)wF#Jj37CKhn1BgLBb zsO{&qA7nypK9AzV2SjK4&3i--)b>Lf)+S&ACSU?4U;-xa9s=2Suq=MJt88u-{{=r< zJAcor=mtl%8$qdO#RGGG#Lq_5ZuMpYI@{r_X7Ri2WplImFZj{g`EIG`u&29N+0UG$ z`Fs{1y4BvbU`4a`4qfrUoI5sYi$B1U;-v!0w!PrpH3kA{_|JsvY(#3nDF-q>Q}^eqQ@QCe-HhC_a2Zbhh8TNAy5#Kcr#(i3D_p`3|IRi&D-T7N}YDK>g!> zxCLVMW+wDNZ9k-8Z2~4>0w!PrCSU^ZA&`9s%i?#t%I0SAU+|-~^Y@yHZg5n)5tMpX zJTS+8NTb*0(=%b@CO&*Lbhg8+EY8|HbT&7O-{FBhv$UD~q%C4xP=-;&*sp&unfM zXRWmfn1BhGfC-p@37CKhn1BhGz;_UM+V6n&)1NCb;onuLTZwY|^6e4Lq6cdGdF=<8 zP@B)A`0xSI*?#jL(F3*pkcPDhn1BhGfC-p@3A~3u_8lyX-|Z@!o5g>@kJirLvnsm5 zQSC-h>RIu?oFDNc)LeT-tMDdK@xYv$Y^W_~RkRB46FS>%L`C1{VA43(OmlxoI@rVE5=uK*ms#> zoIO|LtgUGFry0iCXEn~+ie~>^enL;}dnHcKS$>w2#j`$@c%^5Slf^4@vz$uLEGLV% zS=r}s?<~PmH z*Z9fS&Ujn6)*CdLP%A&{Q;9Q&I(X158VFiBS)WRrIn*co(B7f9Nq^Ob9QI$;>RDW) z@`DG)S3NLaeIDXx=#9ZY)ME9A9yt1Ge(25G1WdpLOuz(8zywUd1g;R^cU|f$J+IW# z1ND`jS8C~j`by8$TFvF}lGLrCa#ow4$k!}-p#DKWLneVkCFjI;3`;7rDmlaECxVq( zm7Ei!RdS{Om0B4H;!4jewZVoiuk^f9D+57X>3O9#*wE#bo>yvRAc!kHx71$rBM+^Q z^ogG%si|w;2>*{SN@&rGJ9b1fulAuC z`dsa^E8l)zXC>olK1+OvOV8RJ=bSw`bfWEN0w>%OtL(X0jfeiLm-aI!WtbWf~&0k&nYX8;zukpj*i>ccJ zhfJ759r91}VNdGNU*4EQ9rEpmaGExs{_liDbT^-D7UR_R^PK(SzGV8H`;~cM+;U(i$G-u$K9&W?0Lf)Rmkp|874OZ_KeD z?$k@0&)B#f$Tf*YJ3;5)wx;zH~AT^G5m^mc-epq`~m-!B>aM(u;kO1fz|4k zX}?Yz2!+4qC#?67XUN~aU!lMK%+IIzWZXjhZTl7GW@g zAOwR4_F?~3%|6m$^ziZ~KlCp@oHaBPg3J$^{a3a9^u&ft0`p-`*fL#)+J53ZGMp89 z4s&E6h)_G9-rpV03O$E8!Ge-JwjHvc-P%+_K{cv4H6iQ=l(Cu>Rqy1`C(i&70tPOg}OsIW=ANrS{ z%x5vqo>#Q}T%qS$6EFc2FaZ-V0TVERUm&pSJ9E}&m0{LrSNv=I6n_;xOlv^M_B5Zv zLB$07nS(N)zvUD7^VzBB?a!C}yxw2gsVMSU-Ipw1XTW}jhz|J_xec422-?pan)!Sg zpSB$B=|s<0UB9bY#phc2!CQUeJX8I@%#YS}k(>Hl-&Co zqPFwNezR)^IP1`l`wS6@q4}5(&w!t=rGLX69v(6zTWaQHO_;-4YUa2P$-MN#`RF|y zd@A0r=+<>s?Rr>7Loe}+iUOW)xYVV_+&nVCCgRXkVxRJ>)g zvN(GNomtX;F+c0S8fVX-KgADyidDuTtZ_A;vnqPE|7w2419MjUujX@BMX&Z>&98W1 z&T9YFe9o%q)&8sb6%Wi&{}#MMb5=#);ekCX9+<=0J2Yomn}7+JfC-p@37CKhn7}Rq ztKVIB&CUAQPe$ey7oXzaJ?7o6-?g7PL-R48If40IpC9v?6PVxi`7xh4f%#pZAM=?L znBVpJF`qes`CXqM^O+Nv-}U+VP(IDJ_HLr*tGj-;;(4_fpCJ|n%||GP!hD8U6f_^97z*ML z$)B3}j8hk%l;K?Vr)GcZVot@JIHTh(k`P3o5T^@e4 z@9aa}Iw&X8%%=|dhh~`1KGe*~H1nxLe!D#U9Im}}P);_Baq7eAeS&6jZl=R5)iO@q zk2{R0XXb(NFiW+JQy)%0m!P@yR@CPv&a3Qa&WCr!isyv7B`b%8H)+kH2WtCS`gwQL zHmR-mODKjyeA?ZL9yZw+taxC~#?ix8oK?}oCJvf_37CKhn1BhGz)b|6_Wi_u<{K?O zfB5?&9oi3R1kF9lbSn|VP`>>#^T4?Mkj6^~CV#$P_Vao)xKm`3#hDZItKr4}o6XJQ z!Nc}*mCeoKcl%*~dZ=jD2Hh@Cf5g1vfjMoWYJ)y)hJ84zqFEdC7C-D+@xvU}2EFQS z$egn(I(T5uPxnLrT33ZhmJ?X9|Ejj1IWh4e^K4%jXMWK0iSxVmGv~v*hpbxiFo#Vx z>fx+6oSAG1PxC{cLvJmCapvExIXBaHdtm>}1LMrMHUSeb0TVC*6EFc2FaZ-V0TVC* z6EFc2FaZ-V0TVC*6EFc2FaZ-V0TVC*6EFc2FaZ-V0TZ}Rfd7qFrms(_cgQ?2Uhj52 zlXEkDeagIp=JLPK%yes|{CV5cchx`hz_|U8Mz77MXTpg2kVdb~r)R>5`H)7h&8KI= zi20C4ug#}t!if2hMz4R6Pg}A+`YzofnO5=}MCO6ZTd(vqx_qUseeDckJwMogc0*0jb58i&xDa5Bu?lNf z{I6Kq54UMaYwrTXr6wDb?PnuQw=w|}FaZ-V0TVC*6EFc2FaZ-V0TVC*6EFc2FaZ-V z0TVC*6EFc2FaZ-V0TVC*6EFc2FaZ-V0TVC*6EFc2SR$bRo;mw(<5%Ntx_T}-c_piM zb#9jbWqyeCG^>kD=z-dPNMo)KS+#QI%v)`_t64WaN2?~E=4aKv^G(16Ouz(8zywUd z1WdpLOuz(8zywUd1WdpLOuz(8zy#_9^zQ<#gu340mC0Ia_qonTJTLxRQl(F2zbbu{ zGij)t$+{-xx>f0;998u~IT!t~vwF55^$<|^L~XWf_S2KO!ldu^ zil}G1q|WjgSN?v(OLL??F zB5gj8A?KZ!_VZ5Ko@D|iU;-v!0w!PrCSU?4U;-v!0w!PrCSU?4U;-v! z0^dg<`?rQHem8+^ZWjLqKf|^A-x;;_<|7nCVLn4F!{Crr%go}#CL4p<+$_Fv^srSn zH;WIOIA{VUU;-v!0w!PrCSU?4U;-v!0w(a$1fKSH0Q>2Wlb96$hTM198?m3BrS=zwcO)>^-n%&;-hCRYr}-JOYC-vA!kaZcP`}xR#?b?{5-d!> z1WdpL4hiu6Nqty&Qvy9u-!$&9Ej>^l7H&+?T>o3}km}R;(B#v+*$;PTuFdMR_|UEQ zjx>60K0Omg%!f33Z9Y8{M$CsadTl;E6GqI3Gu^CfzJ~>kc|D1#$1b4OQW7w-FKHBsPCIN?@SNW^D5sp0TVC*6EFc2FoDk^ z!0$N~ovp4?%N+Ol_jhoz`H#*%$}9f&8_I7Dhq~Cuegde#^NkfT~P3}RP)W+v;;c(8PM$=Zo-w}u}vX?KVE&_GDY`h@t< zOvrhZpRmmBmtpOPe6|}14L{va@UOEJmU(!Y^$GEIIs9mDyF1i}20}vCC&Y(lLe69T zgeB`T^RI*;viuBAmLJ;ca##K*`VoX6GA3C(lu$%5@p?Kh96^ zpK&-`m-`G6WjwR^u!(~vU;-v!0w!PrCSU?4U;-v!0w!PrCh#K!vcH)y{!SE}n`!%L z|GvRb1434R!so~RkpECm_zd$eZerF`ar=2aGvu(UH$Hd6eX$=s1>zH!D^6BfPKc}d z38A^6r{X{ECqr7{lhxi4x1Tvx@o8z9o_E-LH}k;w-ih;WoSW%+2j4XT6EFc2FaZ-V z0TVC*6EFc2FaZ-V0TVC*6EFc2FaZ-V0TVC*6EK1AAdvl=X%@eG)!E!E{IPxx`3^XoMGw@>3HlC8T01>Z z2M@}>!^~tB=ThHfLv1;$qE&d4sCZz`O*Y)t1WdpLOuz(8zywUd1WdpLOuz(8AQ0g1 z<9FyV?(p&s5A1npASAH%4jslFUdjXi4t7PiiRyVcy-!f>6%VYnAJXWx`SeT}*~KUH z(K){uZ{>J;=}(|gu0b0XWnYdUCp8gYWsQZ2boZt z&olXiebG4&@pgIZC!3qaZ#C1JXLGao-G1EP1WdpLOuz(8zywUd1We$&31q)(WbwOc zWOK9lFZda*oqzYBZa|oS2OsvArU&XD@gojgFF9nI`5QOOetMX@n6OVjr5<4)>Fk^^ z-bN@t==$_NbJ&w}GaWpzPd{ZIVXbsFm+_4r=ujTmpK~+K{Gi!?RX@Sc6FiWc{gB2> zn@P`vk;n4M-Y1N=g$(_3ffu#Xrzi6UCfwq~{j#6*nGriMBHKIkXyz<-hX?kY z%^uxjt+ff5fC-p@37CKhn1Bg9fxzf{>nwJ+=h^JhyMdAxyCfYtQ1W zy+dbnv-lkz*fX1(#aU}@0w!PrCh#5t**lr>_c(b?;oMCBnjdk&rR>E9_xo3D*A3d6%Wj@AJXWx`SeT}xtmYuKYR~Na@wsepVhfp{uVQ> zN!EWgzRQpMn1BhGz%LV6efL)Kukft&U(NY+KUy!p!|c)xj`|ltDSwv-_OTz*nCl{| zTlb3&KiyC8FK(-GGNBHA+U4+bdT#4BtfdF)kUumNa)$j^bLfFO^vV3}ifb+OKy5#- z^F$`p7x{>P=yMpS2kOwLT`qkN=eBOc9D1M*`AcR(?Qm|ELl4v;zv4%8*=LuwpE=1Q zAMerpB!3*AuiJQAYkNg!uGI6U_mBDq|6k)L##bSDYTGLw>v5^3mMZZK&yiI^=IL6MFuYAI;@@ zD?0e!&ZOdjIrc*uy*8ho2_rZ0;d7y9EzDA!eyBq}dtT9+8~Q6w57Z(5iU-zeZs@N# zJy3^y_Pj&e&z!3H{3ajmdt3e%&1alC^v`H-@xWR1K+T-YOvu^djUK4Otjv-;u=WmZ zKXa;2;8XO#vvlkE`6fSME#h`D&b_GUU30TO6%WkG`s|8xmbD3(fC-quIRce;a@M(0 z%bcta-~T<$XLW9t|Dk@! zO=mS*t)tcsp@^Ia1#0TVER%DeQA zoQ(V(vnoA5&QJDtn_ck+gxn7K?3$bPv7e00D{emT;S)IX8M&fQKVSB<<-eE6_^-xw z2C~x__G`8OYW}DDk^jIgi{H&Bo14YI-cNSUEAgA#v|KXqb7R=4gK-F~{C z;9uNU<77e|`n1d8=k(mxZCFbW)FFRpCgcqJujbGLb?B4%*%jAX=z-dP{Jm~+*nZ*s zXpP}nSc>zRq7FSLsC8>;Zs@OCdY}&Z8aff`8ETi}^gtbYW;Qg7wRdRynNxiNpP~nz zrCZO>H~9%`5x0wR?nOoKnw#~hcwkP}XIGrFtWCfKOuz)L6L{MD*?#&x6_fcl&-&dq zLOuI&hY{7*C(bj!z|VFjBzA(2{mhT?A)mlp`6uFYC$GEe&wZypF;_i9?JxMLtno^Y z*m94kPcZ*wKjImcc&vF3we-kpK05$ZA!eU?tA0vnu)aQ=#X6?qhadH4Ep@9>PDQhpI@Au$Fo(6&%&BPBQis}hIs9nttfg*M${BWe z1(m~EYWLal@5|==I*-{={B%C@AD$P*`AkuV{9SxBH}qGW9;ie9*ZAQYujpNTu6SVW zhx*~UIy{qHZ$%fG&;zyokj7k#RZF{~=Tqu;uXtc>ed0WmJ+J8b6yG%g6EFc2$Ov3{ z_f~4Nxmmo@^GZ%OH;Z4HRjJM9W^whbeBWEmX+zaNGZ5m+U!7ISx1S27S5A@Dt@}l{ zpYA947q`_onNWv5?Q-}zJ-2lm*3tuY$RC;sIm7;|IrKms`ec4~#kCfCptheafA77r zUx$12=KZpt`EDNa@iXOTDjcE1GvjCc&(93E>~Oz+@EJd3;xjxy!%yS$gJ<|@&$yo{ z?ntjcj*p+I`8)6pd_L~XJniSgU-=1VL;D!w?ef-7HaCmkYNj>M=4SD`{kXpgn1BhG zKu;ihC$Gl)&gUYlbF=(&)BCEd|7yJNT#slLzvo=hZM1sUZ75T`8&p6an{_hkBW1zsYAXFOc1Mmlpp#lP7l-}KiJUaY9Hl?{)*EBb;y^2 zi8$=Z{uO<~1MS%lY4qBBdM1oKfzP3bW>`5DojrG-xtJp{Rp}*qAKJ-An+DG{h z@x!%H%jcW<&;zyo?ESrfY^lw8FK6*=kcaxs&)3icz5SY>Y`v>-GUNjlwD_;~U(Nqe zKg6}2RgnojP}>h_%(Ymxv@3c(rGEE{2iDdn&NJEbik?sLT@x??6EJ~Q0$1M2tX-X( z<+JA%o%LUhU-7`&)w#@9pVjZiS$=D-o*Y!vs?GYZ#=pSNb|x9aA}jmx-#3OwXxI4( zeRSTk_|QxXhWvIp{3y?TzLJmjx2sGal3zjbU+uq||Dk?} z?p9VsKK3*JzCk|J+PlE{FrJT?dRvBAKI3; z&~r7;o>%nh+${f!2i9i&SL5tyZ2~4>0w!Przf9n1KSS+jej3Fm`xf2Gl{0U(<*sJg z&yc7246!KqSU%06yiK$ga+9cdV9rf8)Rwa-tGF`iU;OgpE&QpSrt9+=DQ|f0w!PrCSU?4 z@O%Q5?>x-8dqtd8(Ld|QzYh+#UT4O9%x6eo9@P11X%#*1cKvR}19PrVoOj@?ik^4# zT@x??6EFc2FaZ;IK7q=29_HM=BF?JlpY`M42Zvj)GxLXh-L;>d z+Z86P?K_`~u%~qK%qaid=wTImO265U<~E1YZ}vbq@?by0VkSZ{6p!WehtCl~iI4pd zi?sO&#ZWw!PjmYOZ}MP2!}G(SS&>GspT>s{pXSYexI1%wh1I3%CmUA z^SR7yZWcc`rCycI&EoaW&NKlNFaZ-V0TVC*6EFc2_;do-1KHQ5xWMx0YZ5js6YKTR_r}2@o zCZ6Waez-exeTCJ$^SQhBGv{VL&*yVxk61fjY5gvHO8@xxB5`OKrGK0WPn4MaA)hCB zcp8(B@biby(U6b*5R3Hi`D%BwxC(C)+1xCClMS`a=4NpfT9|+dn1BhGfC-p@37CKh zn1BhGfC-p@37CKhn1BhGfC-p@37CKhn1BhGfC-p@37CKhn1BhGz>gEi{#&~&emAac zZWjLqKU#bC-`QsI21m6UL8)gpH;aFVL%p{ZLPOX5Q@Qb?(S#i3yog7x(4#EcU0S2kI<`aq6u0N>0`@i(i>_ zrPhA>cQKhzlQZ>|oJ#GkS(QHa^EwY1hb*44UCn17>a0%|&uUlm*@rsolf|>z)qM7$ zUhR|Rug2+tI_s0=WcjOc_NUJJWI0*>YMlM4vp&pO)y1Bztv*ZNNm`ZiEBc%KaJ|KK zk(Ge6&qOnynmwiMhlr%br$wYsuu^TYj|>E{+Gm(g57d)&1sl2?_Mh|_=Fl_t z#BdgSu4;M_;dL#gJ92x)MJeI!U-PH>;hDJG_I4%o0TVC*6ZkR$ zSAK4?b{7`*yrRF!k2tJ;Z_n}@9Q8Z_O0`-4)%X|q+0Gw2yD*Gc?nJ_5%jw5%rt*OZyUi{B!+lezNth#{c2>-~Vm@GyI7E zYX8;zHeIuZPF_LftoC2cx1Tw&Z{-u#rSq1>GfE-9T@F9$U+km&)@`VZeTHV(v)E_o z;Y6QZe%vQ)9QPuF!<wP33L70#E_`MMxigxMe;+fAy*q69Z|6FHB z`k(vN|8<|_`|N-BA>-q?37CKhn81rb_2QFm0!yML9GpC|iOC4(46;uvusom#KzHek(=KXq| z>!*dTCe~-Rw(Plj zqF5{4PpL<~z|R&A8L<<5?597~VnUup=EGX{3A&%&M}|G^N1()~$V7!V3HzCYH6Qbt z6PVxi`7xh4f%#pZAM=?LnBVpJF`qes`CXr%BA=GF%1ZgHE$YnGuxIgijbZJV`5`y0 zH{)|99=LICrtK#q)5pcC-I9Lue$kaY*blJ`^^g_0ozTNU#i0EZK{?F?Ouz)bn82=| z1-lU0&zz+AZ2a!0p7YVeyQ;OH`}kyR+eGmnPVa-t&w5^o|AL>eM)71kW5}GK+vV`1 z{wI1~sU4bW!7Dwl)b8@*KH(s7Pct~o3FW$Ej{69Ug!#PQ9Rd=B`IwL28{wg7mwqn% zT==>0a}myf-U~gMSL8?D8{)wA7MZX%;MJvaPV~G|D+57X>3O9#*wE!+&x~6o-lnL( zCeDTOEB#k?7mziSxVa!!tuYnXB56GoLuWtDf{g9cC$i5}!|;-&KElSk=MXeB%7B{g}_3!2IsV zou9TGc`oWXf%#p{%AWC}2lbhcJG`qtAL{3Dffo~2`CJ@#SZ+UaMCP-Xk9fAWS9In| zJvY98)N|tbYy4!~R^x%yX+EoSv-}VBLvA{U*&46Ji+t>7{`V;Iq1N67&b#8ARnfcV zW_>Cin3MI{73VB#6EFc2Fo8OOUGL$nPuAUt)gBh$yls@;-)^M28lJlGGh4E2x|xt-9%LB*i`6hS%71WdpLzL>!3 z&w>nv`@FuFy^T-y-LDzoUL5*ypCKYKG#~Tf8SwMvzq1XWh*!|>jpENiK2y};`4Z18 z&RXh_|Jt4Y|EfQ0sY4&-XK~h2hy32jE293ar4D_RpT${A9r9n(`~R!{ti40q&z!3H z{3f5U?|L4yct$DYx69#2{fm8+-?|NTvCq&9dlvf)J)G#X%a8knjpJTqaF`Ryb;%s} z5f%ya@$V^qF7!A^__^?N@rlnxIJepNoNQ@XeinD1=>+@qia{}|bK0oF&CosS3^J6}90`t2*Kjt$hFu&{bV?J{N z{oTVeqhHvAXsuM+w>=$E&oJ)r(thTM%;!(|@Ilbo4ttTsS$l`h=4SCbJg{drH;c2@ z+5}9%1We#>31si;EPl7!Y;G3+SwGpgqXvYm-p0p%hN!g{=3_oX0`s8HkNM0A%fhX;fh{C<*=4|(&whv)X?(pR+3Zu)j89BHAGJsSKUusLy2F;Vt`_BQl@o z@Ckcyc>Y6vyIlIL_Fv6kGSiY*`>*EzxgVZ1uD57xb-joAKkkRv4_UoozwCzxvgrwP z-3ukd%SoSI%>zt$V#^gx~EXK~h2XZcy2wbWUD7H2JW zmY>C0OP%Fsan@R!fC-p@3G@WA_h%OGJM4{QbF=u~>3z3sZWix5?2Tyd@Rz3g_sm_c z>}O8We9UJ~V1C!<$9(1l=68L5%x6wue%I&6eC7n^cYS`$XHH;#*XPH4<^<+X@eBc zhEC$DJ<;<@ZD#38&nvZW^RtVy`)JFC`))qwGdTl?XJ%3>ut8kud8Ibk(B+k$S88P- zh^3z7zpC3@%?ciPshrjRtNHdbCuTn8Gbb>=`>p4P>&ghM=Cu6mbND`Nh1+v7Gk46Y zFx=&b{xfYq|9757jNZ&A+xn$5pEcq7ysjZ7bAG*Fhj4s;^sX?U@B-o4$lx$1l{IM{*yk7gOj!L1 zANwJJy5?EUs+hwED(J&~&-ydYS&UONCwSoH$NAy9xZYLGJ_Hi%SWR0zXSk!g{aNwpPQ>m7Z5>hh|#v zO3y2`r~S}#)`U6PnP-ms^pwoUe`oV^;pZZpfx~yc-y42!gfqiSpCA8yzJIBkD=z-dPNMo+Ws-;!*yxaA=6%Wk0K5^cGvnqPt&38?}1WdpLDg-L;+bcO056rnT zt5VBZ6$`bQ>RyCb?bi7?YH^~>k`i_PA1eL zzg-SL>d#v0R;8SZW-WE79hzYdYpI!2(X6Eowe52F(b`!{-Kvx`?C=UIhqcu1^WsP* z)Hm_bzJ&gY(*t$LZUIW==)3mO9k7%i%|BWbGZgP1mfU zlUGnVcX(h=`yq{&E;8Zv-MU}D;3uq6Jd1JeMMbNBzx%^8pnUro@~JStk|X}b{kk%% zQfohRO6Frea{}|bK0oF&CosS3^Yfv6nr-dfM9)`u{cgnrbFNREci^mwo_F(I6EFc2 zFoAaxsJyqCbGJ9ns_0+vBM#Z$8M1hTquPz2)H9o##lP6kX(l(ZvY+{ZKjah6>T3Rc zdVhDd|7w0eaUNOiznVXv{<^!Xr~ABq4rI*D$9#rAhT4JA*~ktLbB0Y?kU8$tQ@V*y zCv*In*2X zuKRiTpE=ow9;mbYEY8}d`FWb3p|@;ZyW(vqInV>Oa(2zl`h2LLAuFz>xZXp~?8%`M zt)8s4p9!(ots%Eb)oT8v)$rD8|JD5A&`EH$|7!kZv~QV!37Ei75y;-3yW*=bcg@ZE ze2t&%yVjL>gF|i=R?5FJH>ZWGmiIK2-lf0qaLu^-at zwfXc+7`cN_=&AG1I6Y*V`AugZ^)L2OerqV5)iTcf%nWl_OU;~2Ge6Uzwp|WChihzA z$_X79m$n~K5)(4~Lq0NQKRVN7Lan{?ei4hb`MlnX0uqGzn9uOl(awp^MmRIPRL-zT z3x0Z^;6JYCpKCIq{^x%6e_2ait^X&FwbcLIul_Gf9`!JwMcscxG$7 z5S9ksHDxd2U=N&%XkNme~ zR`i@ke^)&}^gPS|U-8MfRpP;OzdL#g)(&G`a9BxY8m(d(!2p+k9V!6luY`Ot^6 zDtgHSXZ?tu3Pa|I=S_S#tD@~^PRV@U!$+LkxGnnP^R>kT*Yd4?vUTl>li}njYQJ{P z&HC6+Po~I(+jr}JeUqQC7IC{6=U!CwuDMyCiU;OoeRjn;%i07?zywU7PGHx2c(qUF zaJA2_{Ezd~f4kcoX+X&Kkk8)feK-5*nJ{8Lq|xhDJ|Umaf^ zsDIGU5LyU|TaiyF-+pO7bEM{DK63)|yFNeWGbb>=>+@qia{}|bK0oF&CosS3^J6}9 z0`t2*Kjt$hFu&{b^Pzm2ZSCDe&sTT-Zp8z0u1}nI;H-+Cck^8nFaZ-VfeL}j`<6Lb zPv%s#`^>)!9P+vNZzb9z_Zgx#pV#>u!f8SCF`wb9gJ&ZLlWFF^mN5Lk zhwEbh(DO>|&0bD_sU;>Vv09tnMK z7n~phtJQqYs_51JtN9fV%vtTfn$KAkz1n{@zv6*8tNmB=Ijf>q`>*C#JY+eCv%;gN z%hph}S@RQd_0*uEu%9_7^Z64#d;|{9_Dy?457hQU8of53o(UsQ<1_Tug7V3PH*0#J zezOgYqX%jwSeSqbn1BgvA;5QRMQ1}Rwajs!fB*a^oB!zSqrB|5hE}MYtO;}6XGlp5 z&BuIr2Kej@$-II-Kd<*thUl;OXl~d?#ktqiA%EApG&l5DoF1q{{#W|pda1c~#;KW; z!C?+-sqe`7CO>3#MU(RtK36=j)_zE%*XGkRVZ?k$qu0N{C#>=CXF4f`+IBhoToQ0#f7_NV*=p5m54 zn8aC|>8w1j9X8Bp%eek<@gAq9$^7)0|Q@F;!$b1N=Y4iD=-`~0Q-uL;wPgv=hVNRxZ zac2L}^B4TICF`@aUUJKH>#UxdQWvVt`me^n%nwPPW_6JXJy6>ZY4qBBdM1oKfzN3V z*?XxiP(8WWqE>Cze>MIEewLVo^5`H)7h&8KI=i20C4ug#}t!pLL!G?Vf+(Ok~va?3~k!}4|6rYL8kx0qpn83=+o6a80y zcFoQDXfFa5T?QsupIveLnUgdh^O+Nv-}U)1pE-f~U7sKGnG=}b_4zTMIf41zPd`8M z-Sidg=>&5Mi$JL%cq5o~i!9hAzWg<%jruO8u_-%Ro`s&m5Hbm`^wZde%y|bU;HVuP^tlqF+G-f}f(d$D#e%4+;8^|HkKHGCv<}>HRbM*#Re)jwKVHP=L z^@jbTH~S%tULW%Dv-YTW5qI!#?^?2QSa_4xES?!^`+3w^I^3@}@7>e<@G&{`=CeIN z+fU>3<7fNuJinQbpEVMg>%+bKt7k3DmCq2LukQNYY;G36K5^b5o14Yw-F(*sOuz(8 zAR~~yS6Aa%|JC^F+$?`}ZkC_*UyWz|SL2$?@0=Cg2B~&+=p-C)-bPkN7=@x|L@P`_AVg!~XO@{Ud&sn2-$IHnVi4=at&bkK-m_0w!Pr zCSU?4U;-v!0w!PrCSU?4U;-v!0w!PrCSU?4U;-v!0w!PrCSU?4U;-v!0(AnF|AyyE zPTk2X^UADB?I-%ty7=Ge-Ju&C&6fc zoAs%9U{2O&SDdq~O~3?9zywUd1WdpLOyCXz{O)>3|J9!M(-RYui@)FXozF$=XU@%h zp3i5vM|{4h+j5jYU)t%r>d(2Ewx5j5D{el2!e{9WXAU>+o&C&TN9OZd;g9j5D8_ zIhg_Gu$G!RL9^{HZ|Xx2)WL)DX(r2IAL@|LR_f1u>QJkEHpz0>hdSi5mHJQemBYe` zX1?^KKU-DumBYe`X1?^N`)TXdT7sUSIJ}khWSmVH&ouK_b=H${_GCQM%wN@6PsUe! zI^P6LzywUd1WdpLOuz(8;5P~I_Xz60qCpSTzwAdGiho16o0a|agojN2aKG&5#2&qQ zzYh242mLHDc>^E&x%eD$kEmN)vF%4JMbwA=SM`_q*}{YjFY>XU{zxw|3H%RhLw-NK zj~w=#oQK2O5A`!#S6GX3LY#z^Lx$9o+QUAfRMc1} z_G^oQ(8PWMkjbT3wH)e6$*s5Of%?{=ljih5Jt^@m6EFc2FaZ-V0TcL20{kvS{a1^n z2kKw*!?jDF_&s_TH+g6crGLba*2}e1lLIw#n%?#KWk09a&V9*r+aUI@>=*NgI-6CA ze~_Q;YtQ%;nb^_8*FGq=7Dh~TbO_en1BhGfC-p@37CKhn1Bg9iU5Ci zv;OzrW**Ihf5UmFZl`z1<((cl>*0R*u)mF4U_uYn_VYT+WKz*vxV1s-Q<u^(cwHUSeb0TVC*6EFc2FaZnm`)Pmw%RUXx zJGp6={S1$#_;6n`R*W-0=;5GZ(0+=b0&{WW9#wSKr*1=;^1z-I56oe0&>B<}PxC|D zTfA-LWz-ptB=v^9sqtmcTGz(*dMRcSs`70ufDk`M371AA6HFo(5=6Xywkd0?Mr zfU`cu&yr8Bk!xSo?2{P?ak3riRS(Sn0zU!Q@N&qFYbO(G<_tTZ3);^)Zmb$Ie8b++ z1GW8-MqLlN)yubM+Rt{RZfF7~U;-v!0w!PrLjwNZHN>Le6Zpu(AO4;tAWeLeAFYM! z;$lx|^*pg(s^l z_MG%Tto;H%r&*C(rcdy(9}=kR!?T+05#ty4i*D_QH0Js=tBw0bhxS7nbG^jsrv0Kr z`yq|FK4kTV{h~wrA&t2nvU>A=(V_j2#$1clAMO_&+7D@1n}7+JfC-p@37CKhn1Bhq zlR)Y@4&%&U)$EgL_EgT~Z|TZm;Y2fEdeWb*D*4J` z;Y2fE`kVYr)}r+WK8#DV4|S_mPS%I{)S>pU5A)fFnmG^mLwi~~*FqiErF_PjPt6<- zooMxEAL`Ik`HVB4nmH2>yrur^Lmhf5pK<0>GlxSbTK(B4)9jz+FwXpm2i~$D(wOTd zR@@irHbQ;o;|}kt5Bslb`g8vimbTap)U3zEA?S5HTRT-A+A1*7yGcS`mmOo z{aF~|>ce=k58J8_YpL0vnmL(fK8H@U{Y>DHXU2Rr&Yttp!@Gz3Wk0WB| zy&x0nH}9AIXlsVTe1=#QG#{ZD3iIi)95R`_4^`XRuIk>&E22J}o9PpC)j!mJrJsyj zC4L8=%G@l+etI&23D5SH^W0CIM?Tb#xXo8LzdKpG`e&OG;>w>-oZtOrKO5H`wq|&F zxL-f$XUJs2VF-3((0=AH#V731yz0KY_H!RwcQyeNFaZ-V0TVC*6EJ~Q0{(tJC-wwB z^1#0oHQS2Mm$3b==Gu?gnu$;h#S{1pJ^bMrwx9l}95Q+He%X)rs3$OwJmJhNd6+y? z>N8*R;a&CNtcq@(RU7o-&`E-NRy;5#cu=3otn8L**?*Tl;nRLzXN~)HE0fAzXZu*G zy(8yS{A4~IPv56H>u+S#M)_j`CSU?4U;-v!0w!PrCSU@G1S-F;95&gQU_URILk`*B zB3cRaH*SYovA^^W`qA3SJmbJP^Me-T6T*I8&`xu>X^-q@XLWq!nj>$;-b z)~jdGuTwGqzpB0BfwjSd`p<3XuJYOQioWPa#P6Ouy!)5a%Jq1*w_yPE8Ng@ASY~^gzuV zYZEX56EFc2FaZ-V0Tajw@H-@RmVbAg9;ol0oAsv$>MZ~6xIFN0IBlrnLEBFQ6`1h) zZa(aU^gwMtujh(PR`o`Phx=9W_QihqIBa2+@tiQE2WtCy{fr_L z>Rb76AKOsPqJf~5!`eIaFZc;-6x$Q=uuZyD&&nR1n5+JwRtADl{zLrG-l4bR8rk!T zwx2mY^D&<}f%#pZpE)1i9kOZ(iZl5QT66hx#C}9xd;$~3mHY<5xtV^04UNb=Fs@_^ z6EFc2FaZ-V0TVC*6EFc2XaxBC0`*_Pp$BUFc@Yp3|J`7CBtC-AAMV|dkNxN@9rAfI zEBn#b48;$q zo`?DD^Mig!TdV>H#ZRyr))xDy_SgJ`^>U9^b;dC3qx|9?Wqq=^`nLq?!~7rdlX1x6 zVt5muY;G2Rte<9B-ZJxVh|>f08%7UD&;#`_*+CO90TVC*6EJ}x0saiVTMrF{;N2eB zKa3t;GXHKpG|+;>x%~c2y_!F%wI9N1Ilwgv0nG|B(5W+E4M5vAVeSL$(ETqE^i}so>}Sqa zd?xR`d570s^=X%@n*CL4KjOH`M-0PWEcGe!*Q`mta_r|ti5w=}4)<$POXi1t>_>>i zjcloltcHD98?+1rG3;YMqBP_a*zU^F(23YJtI}s;L$@k@cI9a3L}*saxm!zTzXJ!yvd)LH-4c%^6NC!1C2d8O8VUT1ohA@iv#`<3Oe4>j|tnUm=(pKK8!QJX@2znndC3!wC2jEp7gh$#*80wBOJyj`QpEtQ^~iV7bWgR z&_txY2swAeIXBaH%*}dc9vIJR?}&45Ma#qFxybscwk1?_)`xNRu^(cQuJBP#s~YNz zZ5G$`Ua0@1Ryp?bqC^fAZp@)(pP<|2@T0xR`egCeZCG2$A3Avjhdr}dj8oGCHFJV) zm&4D{Pu6oa-X^O5aC#q9K4($0=W3j_{pexjBm9JQ4Lvg_<2EEP4<62{%>4yF50k4zs2=a>Jj_tSsgNY^WNFdi9HG>hYUmh>g8(x)%;KQL;qSkgA=`)KWR0*wc39* ze>ij!T_=nnl{t&)Ln}7+JfC-p@37CKhn1BhGfC-p@37CKh{44?gU2eYhPv9dDZ~k|# zjEwzcWcs*S^-LIf8lNY7dm5`J_<4c{pBWP9wfCrJ!pPJ3481Yy?%}kE`3$irXg)6# z;=nUQ{pRP(esn}7#DsfM(cDLMyDsdf&QPqvUS#ol=X06a+$?@>O1&zZo5ky$ooNCl zU;-v!0w!PrCSU?4U;-v!0w!PrCSU?4U;-xa%LMp$<_d?^{7O&etoC2c=d6le?Z2A8 zI=8Dtfj5YJSB-mUB4kraiKsj6gkpxOeqdTQcpZj!~@Y zCAVhU&#idf+yqR(1WdpLOuz(8zywUd1WdpLOuz(8zywU-%Lw>ys`Cwf0v~yJ^S^Ut zWb7v+^NO3#_wmu5wxv2&3!rHSqYwyt6 z+$?^F2lmY7W^vY9n}7+JfC-p@37CKhn1BhGfC-p@37CKhn1BhGz!M1Y@0s?~6LjDwr`DSuKkF!nFz&DJb}*>JP?lkkj7k_)o1acTkjod^!jOh=uqAm{6lR& ze+b{BO~3?9zywUd1WdpLOuz(8zywUd1WdpLOuz&_f&l-HTG4kes^Wn;zu-sf<-fC6 zbc3VXjiA)C;(?f>U3`2b5HmQ|nP4+@L_Vc3j1`gVwAhZ{g{R$ zLf!I}6Ke0c)GT_S{y{%xGCyfg;PV6zq+~y&@zQ3}GhxJhNTb*0(=%bjd`P3$=F>A_ z#C%Aj*XGkRVZ?k$qu1usGhxJhNTb(J<3oo}^JYKXow+uv&*DS3-aFFh_0#y!p}e&q zHFMsn>4Ey49yp60sF`DJ0w!PrCSU@;Mu0yPEBbCe6%Wk$SwH;ubm|7=Px#OSwf(&I zgG{K+$9yI)F+IyXGt@pmK0iJ`69V&Fe!k3SPGEl5=f`~J1m<^re#~c1V1C!<$9(1l z=64@^ewuB0o9OxKuHUVAV9xc4^A4O<(erM;YXT-<0w!PrCSU^3B#?d2`75{f(~}ny z{@Vm~D^X5gzCEH@^g#XNehA#GNTb(J<3oo}^JYKXow+tE^O+Nv-}U)1pE-f~U7sKG znG=}b_4zTMIf40IpC9v?6PVw9!uffE2U4;h(s*ez>6tL{1U^sj@H8e*_A~U>g4#zW zyjjx&^_y*I96eAg!NLSg;OhzS*{A-ih0_D|FZ&S({#zk+gQJ``fYK~_pthgaevk>Z z`8h_^xAxSCXDR1P^* zbYR7{>KSsf_^`I(fjME;uxH45lpn5znw}Y_=3=RtLtW{~eCkRqJy5d`b)_fssVlYg zK+QhXm7dI}uGG>4HTzIkdNQB7QcDli>_c7Y$$aWcEj>`P4|TEUqn>wq4*Fk9{^uUo zThag2{r7)|JwwjZ_|S8vhn_P&ll5l(SL61xO6-+CF-V^U)p^--q)R zUB7ETbB5;gS$ybLd)I>0%z3A#2kLiv;4FHeX3je`Jy5^X1830#HFMsn>4Ey49yp60 zsG0LlO%K%X^uSs4K+T-HwdVT!#t^mn46!I^K05B_q&_UXDS;lSZyI;lmL8}N3pXZcuHT14s^&AqqM-Q* z#i03C1iUC z*^4ZnJ+J7j|7!e-2iC66&GOmP+5}9%1WdpLOuz(8zywUd1WdpLOuz(8zywUd1WdpL zOuz(8zywU-MIih4wbl48o~v`S{BQCzT;u#-xBI&d$gs}|P{Tg`#CgPi%!g-SPNToe z+MwIz>Cff9_pv^{;9^^eNKQH_L)!b@7hn#gc0*0jb3l$!$)9vwkNZ)eD=Jev;M2`D;`+8IycK_Piqq} z0TVC*6EFc2FaZ-V0TVC*6EFc2FaZ-V0TVC*6EFc2FaZ-Vffs@7-`7^-yLhh7&GNs= z&v1?Xzi7`R4al(12~fj6^XdIv`{|i5Vm_qN>y3Q)2n^5mWLB2Xo>z3%e>Hx^18Z03 zX8G)CZ2~4>0w!PrCSU?4U;-v!0w!PrCSU?4U;-v!0w!PrCSU?4U;-xaB9Q(2+G>0k z&(*nE{x|sQIycMzCO^Y9_WzGej{y%@Xyz4Kl42>AM?5L zocjE{&JQ`P>MQ)S+EowC&w5^ov;V5TGIzC>-d1bx$hRNApRb%NpC6x}E9b|x^Yil~ zeA+Vg`SaiDiwU18>XxRQzI=N`v*>}^ejfF_ zd%xMKIeu~Ujc^>9xbF=ux{r!4B88^pGzy#_9_=Dht z&fYU8T5Tz@pB|%_WT&E)D5o#q9?>lO8L~B>Ar=Ln#z)4Qkhh?j^GWHTY8{AEZmr& zxqcrGsou>;{oC|R)0lEj?3ZdMvnn}1>!--P!f+`ko14Wi?(dlCni>{gu32gZzerZ@10Wb zMi12W4%ag^_r&|>`t-ho{q#&2F(14Ey49yp60sF`!O)?B|2 zhp5eGh($s35sE`0RxOkIu<)h?dZ4~(++kaKpgt_zn4r0S9}cOS&k&1(KgFl`jEG62 zv_)rgv-qyLS)Xif7SHUxL0ne;%tcS^k*Jy6#>T+h_p6Yrnv z)B6tg(=%bjd`P3$Pvb*}^45aX%z3A#2kLiv;4FHeX3pJObNxOXqBfr)76r{mC=P{K zwM^>6!kZH4f%>L#hi&PB`mk_gg68^tIHYPmLo5oKk5C*6v1*yrhlMvK&;#{N;||-> z1NC9y#stmv`*29re1=#QG#{a`_yPht&uuLgefN?p9+>m3ez->I>}OUMpX})>H+f*s zY;G23ZP1_SM@+KyG9K1@r8Z-ArRSAe`{7169roIM-oPh}Sh~Dpzm^PyWcvv~!ln5H zAmP${0+4WNJ^@I$G@k$@T$)b+5-!ar0121o6M%$E^9ex0rTGLP;nI8pkZ@@}0Z6zs zp8zCWnoj@{F3l$Z376&*fP_o)2|&W7`2-;0@)NHSoS$7D*vEcIqu1usGhxJhNTb*0(=%bjd`P3$=F>A_#C%Aj z*XGkRVZ?k$qu1usGhxJhNTb*0(=%bjd`P3$=F>A_#C%Aj*XGkRVZ?k$qt`_~EzO@V zBe44KDR(d5eqMx!9Qr4B9%-$HeNJrRu+MyYfA`D$h)KWFK9a4y&+H?iHrqb?@xLz* z&%l-Q6Kd6eHO^BVYTM=Tqgj($<+Kh+s~Y&`Iyg~!2GVykNM0A%FQ2n2`dj@B*FJxW`@3Q9*mIQ|Yo+^% z^T?O^S>lkbeNOCkH`Hc(XFsoZ)e@h;Rt#6;+{aLBKO6r(AJ}@o=4{Q!eEj~Ip8@kR zpTqa0f4=|g_rQ*q`Iyg@?`FHs5Bu!WVO>iSwgp{zY;S zne62%H~Z;{iOIn>{O|2-FHY3TFeY4oz%b(32-TPKQqqX)A?m=X-m#f_Drza*R2ix$!x3j%CQQJFt zMeOJG?porL?aOMM`xt8N=Zk-T4|}a=a5e7pGyUE{Jdv@VFF#-LOmx>gK;hZ+`SJPb z&PzBWJU%hk=f~$Ko{8?72Pm8^pC6x}?!1IE!s8QjeSUm?;+g2Kd4R&%^7--k>CQ_y zBRoDa*XL*B`S};V(7 zbba^okLJhw-|8o>^M9|q7s)}O!5Q{B0d3glV0?G`%lwE*x6nZ#Tl*lj3x(Qj`|Rg+ z-k10Uwqm#%=ca{P``P&WS77V?nzJ<@^YQyF+=O{&RS)e180X&fYDRxX+KzPvx9sIlIme`|Q%ebGsaV z^p4#%H|x`;Yu3=oE2x~T&#rjU&%~;4nScqHfC-p@37CKh{0ISkM{Vo1{!j+|JtEu3 zEQfLGtWPCg>67I!PF)>iT>IrNa}tWOqS?UUta@oa7uU+t6SXYp)q7QfP`(lg7+;`THD zx3*P2%-_YFJu_XIRmoxh)%?}k)&8sb_Va(=amiw&D{Lz{?7f=5TD#hRHQ#>DogZ?} zG}&gFwOLLUXKh7ieHdpS#w(h&6}{SXlHYFWqu+U3q^oXAVky$T`!2|FAa8ncL9aVNd(%`H(aDFrMjRzJ^YO_KUNM{Z(7cpV-hX z^?ZmQ87ul3=AWo#pG=F@gg9={bXcbaq;09-lf|J^`G0&UFGlc zz&_vPC#*%>HpaCn6LH7ftmnjrZe_K1#5MGUxZ>x;xWf|r=@AW?@O_f$){3=#=W`ME zl+HXb{%d}?cIv=E3`6|f?(|jaPY={#uJS{??|d$z{`5c{<|;qL&rR>Evi^$G8@2ts z-Y;ZAeK#M@%5?CcJ?)Rd>4HzTy}!HKe>K0KIFGFMU(KIS@9(bm zU(N3)&LgY+SM%r7`@5_CSM&Rc^T=U;zUwNwjZ@G0=;2+}R%TUle$7ul*n*FJnL%l19J*~$- zo6W^scANn|vlX4qyi&`al|Ia2Ej4p8&HPMfwORa1pRAT~&b=dE=~>Cy<+C!Yl4C!w z_vJ1QS)a;YRC2QZtMSULO3v!sEWa|Vl9TmcjaOz>a#rVN`IA}gmOjJ3SG2qDjLXcM z=VohsvLAZ0HUSeb0TVC*6EFc2FoEnl?K|V#g?G-)WShTlis5=45(x zZkEsfl^o_%XSJ*GN>AocXR|6fS8Cax`by6$we&!JrRSB}%maH;XZeg%vo_Prr_S;j z&+-|kW^JaKPo3p6p5-%6&Du;eKhvzelC!JUe*W)g$%yGLKI}t1nmLPAYFBeA`I)Cm z?P^XXKl9`G{5(I65BIvFGyhj=*|XAzIjp5-PNtck>8v)3U+I(8GS0bo#49~3IlFvT zW>s?R=k;FN#Ublc*^5d})_*l#nN`VIotx!XW>s>s{;ToItV+)6+$?`GtKHH^e}8C^ zztS@EhaR~0C;Oo{YZEX56EFc2FaZ;I0s(%H%5=piYb*I#4*O&}t7V+EjIV0;$#kVB zYb*K8QEm3SLl$R~rn5dF?eH?|a~Kbuv;2^Dc$xJ%jEBxyen=Z$X0_Yn!|8o+``qFg z>z%wJKjkN|%9t>IE1zHR(_o4rby&M{vN$(oqAPur^MihfjvN@zbe5mRvp!jTwNI9x z#k09te6>%OpT)DeS)6_D(AnH9euoG4%;sis*50ABxr}Qr-(z=Z4xMQGnZOCR#Hz*b z&|%!+nN!&2Kj?$do0g@`J23GYAcm@RpORIz4Ld zAlv1Q7Y$uL&eNqAtQ4O?y*qHR=sb%6-TpEH>REkRfV9YY5|H*bn7rWU&UyQ}^2>SR z-p^Q~5}v_%g(tf1iOQVt{92yD{gU=2pW+ZdCp9t zLblY+5ZtI2J+W5_&ZlMu>P3%=5p~X|W(Mj-PwX9tIG4p;l{teLaj7zAmnW7E#I9YH zIfEG8OEI&1^(gN03|7RYUAroCV(CCs=IrvQ7@YrvR(ncZ zWT0nu{;Z$7tWCfKOuz*865x08ir$rKB?EiEDNo!Ne`iy=-FVl}deXD3y7QeUFi!DN z+*p6*d2z4Ozm|vhOD2_i^US_3pPx3c>#5Xd!>F0F9F*UAj$Fb9~2N^5N&=37wt+=Sh%f`6U0-&-vwfIgdgV_3jy^$6)GhVjhc%!gqfpH~v zsSK?Da-Pb)D-Rha-QG^U;=I(ZO1*82IZ022VQ*!x@^DVlxAUYq>V7Nr*$nho=FfUK ze^$@#s`zI!*lz+RU;-v!0w!PrCSU?4U;-xa90B!roZ3h~J*-n#JoGEgIn?y4`mBe3 zrMZimepR3Kgn#zmN$783rslABR&y6M=cxLuhkm8Gi<*8_pY_mBt>&-P*-QQOUNxT? zsFnZeIx|qea(uO}u6XEgTD{_TjAUS)I@#i_@~}=FjY%jE>(r?|-YO64)X|uP@~}>w+T(4- z6J`q&FaZ-V0TVC*6EFc2FoBOI@NU2VJJ0!X3MM!HzK-5DwxZA5&y|?tJZCuMtoT&w z6%TiHlN`m%^Q!Esc)lr*x?kR-^32xL*>%rL&2*lF%o7|2%z0$p^Kza*WIpXd;`0z> z4iVSX^Y(OIF8k8uJIwPk5Y%l*T%-s-MW%8D}xx ze!lw4dD6Xi879y86zW$iyDFag#<8=qtKu1Nsb8(^s(9)f$Ii;Gif6o~ezmfz;;C;O zJ7ZU~t?2QV`qh;T?5%GcJ2`VjkGJ@$37EjA5a9Q~J7jjA^C<)q{^s0lQ9rjlT8X{R z6P&wD$cOp`XXiX|G$E##@Vuxuo}Kf=(S+E-gy%(l=G1WdpLOuz(wfq?oM{a5$yJZJL3Wbt?P^W=LK=Q(rhGU0hqxAyR#M{TLZeC}2H zNAgTDc>ycuIX~)Km~1>d=NX()`rZguFQ_xsEBC5h@0^F(tWCfKOuz(8zywUd1WdpL zOuz(8zywUd1WdpLOkfuQ{(I@JnJaUg=S(k{@V}chThz}jk5*!@^91KE6Y`;c!Pz-a z98HKRCOj|djc4aPaWo;eFyVPo-#9zxiK7V-OcKvm)+5XxX5jt4a~@{1HUSgZOMu@4 zf2Daxf0coI-#Je=8-GvOrQ0IKgc+#Azbgahd_kV=tZp!22I?(m_r-Z`v)agn8K|eu z?g#T+vU&j%W}xn#o%0Y;=wKC3Gm-Y|4Ng0g54AfiB?u+x> zX0?$CGf+>R-4EuuWc30j%s|~eJLe&y(7`Gye=D5lZ~1$>37CKhn1Bf=0{j{MSDM-W zDg*bvbDnNC{yV@f-4-b(%s?IfT^Ts%3-WAdb%O~rP;WWAFV1tD)kY@FKs|MKKbYr| z)eD#~19kW8oQH@)2dk+3t#F>d+(9rPAsimH+9w z^R$02=c@rBbMj$5^q{xvp`V(2Rh?nzrylhFY#zl#)mM13w`sn*{F~vjzR~k>d3Z+D zWJ0~@x#Yw7)XYG==y|t1@vK(vaq-?`S7na#kkVQI6`ymGqw<4!+AaHK0w!PrCSU?4 zU;-v!0w!PrCSU?4U;-v!0w!PrT>|m%;q5AQ*PJ}`Q?r+K>WWACS9&>Xk{0Bsk!$T^6-AiL23G*;KTVU z1MBp^VV?L-V@{QSrOsYz?p0d(SL*DgRvB1V{*^j=E1G$z*~>chtcQN3IiH$-)~RPb z^efHz)bz7XeZ$k*{W1X)FaZ-V0TVC*6EJ}-1iF8tZJB&;i1VDe1rz@5K;2rxb8g>W ziCxS<{eyYBOcIBRXV+m>c2zvi(>_~#r8703*YF|d?sNNsGhzm6=OK-;4pz-ZJ??t$ zDlcbXqHvxusO@}szBkU!dB*3(t6f%! zd3aQv=S7|T+^cl#8q5h#njdxcQYXL4z#m>A40Um4 zv&E}BKdzod*Ut>pt)2e!v~z`i>a+8x&=Z;&s9Q^T)IfR$y`0n4?4{=XK?Yum`GYy( zN%N!5Uh3rMUZuM;)12_AIx|ow|5OIfS<%G|%og{%vRCyw&zZ~(CXb%im*u%+mF_p5 z|3RHIS9I*+Q!&^Z{^VK7z}}euCV9Hq9=dn#s_0OQakd>@^jr&sdfE^3~gsyENB9CIC>bGf}8@qhe zUR6JjyS|`x2SdV>?q$$&c}dNT`d~tMoTp34 ze2PE+U;O;UxwKR3>R-;od#5I=RPR3g#bWSJGrRSQr?^+yx_g_sTYo_w=Df_nJk-q3 zfs5LC#sIr~(pgkI<1O{8m0cB2edE|!*;Vn3x7@oLdk5_m&!BzkQe{`gGqrSJuI#FK z1}owc=RBcfQBgdRfisIS!p7bwbSxT(*vp?gPv}7gUUDAN80%owY)|O%_Vd*zGH~X3 zyt9?qQAF`wU)ZAjFq2cFrz${%|NyDAe(yjk@!Up>_H2jHuhF@FzXqQokDWxmW3wA$sfUE}bz`WnlfU z@~FLoY?n7)G<5kmPnTY>QhWyW?!d*O^DF{%`xXM~IovY*#t`Q@LklJ^_?dFvey%vr znF%WuKH*{GLppX1o}chMl!0So*Qewe`CDnIM0SJm08^b@^L%vAYVS9?`GdI$fe z_eAd#Ggt2AoALyQc2iw_IOD4P`@$*cQFGsJ+IWvK>f-L+{Fyk^t@6t1NAF2a2GQ)%~$t1Z-#E2 zGpUt-P-h0}?p`&A8K{+iP-h0}cgw?UN=Ifgp>B=gQA0M?V;3_}JI`?*WI}B|<}>&_ z`tvn_!_N*sQ`Gc~M{T+4^BQ9`AM+U#7+>}CV?JX7@dXvX_#=OZV&V|fhsngjxPl9hg2}pYT=6v{Bvo-+} zc#c5)>}V@qsns35G6Q$La~|dl&98KxovJGj{nYeVwCYuL&ZI|a`YW1q=vQ^+p`V(5 zrImkIoqN^HibwU%)+@Uzp4q+1U)fdhsQHyTJ=EN*wDPai*-Nc5u&(?ob@ozouhP5x zvvXP=zAnF$n>jqxYOkuZH|h2^Ua@O-j`FK|+Zel&jxedN{JZMhtMsm2l{qQ{>yqk} zZ__w8cKN8is(v1OyYdlv+TBG?>c8T{4AjnZ5Fit3^LZaWJeM1~wQPBHKi6&YY<)|Z z8+%pGU3omm1WdpLOuz&_g~063MEcb|Ry>v7%A8%Ecg_>{$luASTlnx$@A4!#v5WJm znSpwj=MD38neg7J6^BZl9%{~~Uh$}2)|F-kYWi8HR-Q_o9%{~~Uh%B-G6VI>%#~hd zpkA4|(#s6goLSMTmvw5+WL;_cE1GlYXPvs@QGWI+t$JCf<{Z|QuK1Nl)t}hKnQE`9 zvzNN!U-49Wi+P$YUh%UmDrccQs(zkuR4V=zPo}FW@~8}~ z@7h(F!@WvZ=B#*PFF)f-w?*M!Svu&A`6>hJKa!`*g!itPsQQ3^<&yJ^DVdM?j0udd z`uQ32;niT(inE$?cInv+^zX{RIh;SMImg-rOuz(8zywUd1m2B+`rSt5q<_Uz>D{%f zGUuK1M1KCe1a%7^9_n451SfWJJ~cB?@AAB1o-PyKJGJ6asnbKv`P3^O)yull%s@>) z>(t6qsnbKv`P3_(m0o6`UYWVl%M8>jGgo?(rdXy3!TD@~HX~yEs$rRdx1KSNtoUN^dbwv&AcZmPO?(lt|taCo=)by-q&QzN7mB)1xFaZ-V0TVC*6L=*7{(eHOGVJnH=I`27 zne)zhB0v9rp>E;BL%ry^WWxE>%s{>9dFMRAf8`!kFY8K^Gd2CJQ!7uUP7gKbQ?Gbb zFY8J(12z4uQ!9_ES9jGgo?(rdXy3!TD@~C>-#n+ba-Zt=Z&KKwD@?HU;E%o+E~Vo|U3sue3US9(7skILz~37CKhn1Bhq8v*`Y zrdBz3c`EaF?W)Xq=RA?0e}_`H@Zq6e^jtFGd}?N(Ui7?kp5VW7kE)k-rOBC^e%7g# zr&6bfn)9hwJgS#Xn%*z05$(nH8;iS*PYq)|IBe zqB)0t)~PEV!DBQ;aio#*&IQhZchaigD_ern~J zt*e=wLrp)m^32xNOwOUEpPC+OdZ_84riXgqX|{NEKktLyE&jGW=0uW1M4cI^Q|}gk zn#oAr`Sh!7s?On+IkSGXSJh|d&-&F~RiB+d>sNbKJ&}NUe>AUp{{t8pS{!-KRwiHPS?ZVhpC&Hb3)TYUGXQ6^EAeM&GMmN%~5sL zOFuRJ)XFnkS2H<>ntp2KnXRjtoI_1NwenQz%2S!&JbZOOzs)dJcb1 z%YWc+7~^&M8EMY0XE1-(A7Ruk)~T6+njUI;sOf2%ukO7xL)2+bb>(3TJ=F9lUGdXH zU71<&b56xi4>jjd(?d;<(zAXwhjq?Wn*OJ?%E0>5891MNm8Sm*9eep1SGolV{}W+2 zUu9sO{x8lG%+TTkt`-_Gt;{@VdkqnbZk zPhw>7iD0x*q-; z1$8rXPH1|lEB@qhp2nE3Sw8fuIjXLD>8GZjT6t#cY9{AU(@(8DvvoC-bExU3R-Q^- zc`Eaphp+DEw;87D&T|kTH|lrb^UHZ=`49XJW4tauBhA_M4Cc@JBaGU`IyEy;(?d-U zH9bx9)xDQyh&s)wKI@^Mnk!hRriYpy>WYVc>Pjy?)SN?I@z76Q>Fs(3&p^yy@eF#M z=LNqXHprLfsLn{$S7xsCetI6}rzR6><(aLknVdsSKeh7A*40eTp{Ac&d1mXCnH7)P z%U*l~S2lW9w3^R4=d(^t&x+F+b@sAOO%L^yhks*Iw}G4!njY$k zKY6;DIg>i|I!}W`CW@7+t6uu4>8Dnn*}9s^In?x1E6;3Q&Ey8RQzfe>(rb{J@7EnW&XjO%Uo{vR_m*+J*f8f8|#WSVmOlo?l z>7k~lX})ehZ-e>WnFIf9p02+YV=oO!(?gwX-M1A#J=EQStw;~G^0Qv?(?iWU)bvo( zqx7s_&8gI1xyyOZ1cLwIb6xSAC*P}7c2zw0wx7EyyDFaZRw5z+}bG-in^(KkKh#pl5dete?9odS(7f zugbPEbEWrF@-S!IFN;OJ(yLai%v|aHlsqb@>n30VCSU?4@D2p{vsh{7tay~4b*0sO z*4fKCH9gc7kMgsZy5gsYTFvQt_;(g{GjmR8dZ;V@8DnnN?my>^P7jS?&r4|rs~df5Fj_|ci{8Od1mb+Qm9GGf>k*O%F9aP4m^gmu84M&8enttk8KYNu{Gg+VQRsKqydzDsmX8o6Q_*quE4dGtSj5>P< ze)dv#=Wr(VV19Sbz|RcS-8sxaJ(%B}Gw@$#V6V!c>XlvwNc!?#)LvD0p5t?6K4T8% zV?OG;XtB=r_OPoU@u^XX!VqWJ`ht}vf2mMFd(p9t1OWMlD0J+pZv7 zxzPknzywUd1WdpLOuz(8zywUd1iqet`geoBx^d?@lMf~j{dbV_#&N}Y_VNjyX)Nm% zo!aAV^cJ6=@W+HhuwK!rJ>Ev|2j#iU%zLTmMk8hhnL|XKbCUnk!`_Nc^BL)K7kjx& z)#*{1y$r)Tdn@&d=an;mIgjE@Ce+G5TURsH9Qvu1f3~h>syXyiEB|bLW#&q+%DFOg zrT3fiJi%dw&yVM6w;!+g*&3CzP@Y|NZd5ZX9@RTruk5OLX7?&TcUhZ&37CKhn1BhG zfC-p@37CKhn1BhGfC-quUlHKHUsZG^C+AfB^su+0*{d|?D37YMx1!Y?);WiDrNhsE zKd(|e_S5k3;9&)MGu)!U$S+c<8w00LHT`NW1i+? zK9y&{pRe(A@(`cy&kh!OcEvhv@$-nqqE@}Lb*@vr^eC-*XX~7=dg-w?0TVC*6EJ~q zCBUD9D|#27l??3traW<9{9SZKH#jl#2B_#=$-v$($kSz#?khaA^&6~W*Pu5%&T~*w z90m+qOT2<-(I1UXRC+6(*_rfHS9VoAvol}mpWXHJ{W?$k;4}#8f8K!)vpEmH=#p0F zNZSq1C3DWFzOgILdNAiB@~C@H^~-xn{@Z-ioK*kxJhS=fujpC+oVn7=In*mNS9+O& zdSzy%H#}|WlrDas%-+jX24?<(JeRC^kF%PrxTvV(TxRzw|Ci+<#$c81akkExD|&XX z@~>oIubMww=S*u8FaZ-V0TVC*6EFc2FaZ-Vf%hT6zwcBkdS0rhvc>Qa8z zRd1!vIn=6`9;H=pr9L}T`B|^*?RsYaElc@XZ;Nhc;~eTVGv?Eybn5MLP{rcRm*q+K z(%nlB^RrGp@HAVzVpmiS!Fp&lQ`Ot3%ih6WUWz%DnO~MC?!9tfFW~c2dB~iaocW-p zda$b0)qK{KPV*UQDg)y)tv9ml>$1W_G{mip91xb}>NG;VF*2ZTrwX z#1*X4z3i%US4HpItL9WP(4*$;s&kjM37CKhn1BiV8iCoLr%&^7o-^TKGW!d28x_6h zv9~KR(|Lm7Z6=E0;@LS*98HKRCW-$_Zv;qUW#&q6iV<&DX0G%`fFv$wHh*|hFW-h| z@w4VR=l}j?&h4S{b9j6X{rTd@A#^++<`YaP%*WrW-H%3lNaESx1Cw-kxG%SL{+VXX|ZC%%tX=Zjz%Iz4WhWW}xQG56Z)+w^@+`2eMw|!*=H(jj;|^ zWIoVpnwq2hs;=g!`s^I#S9P^l)o14@zw0Jo0w!Prbpq-;nf3a#btm^Ky}qSBL1kdQ zKJA_}cJcQ*>NYk!_f|}G#V%%`{=qz#OkT{#dB%^l`FtoJez)*5MNQB6Hg8{z=ZCwP zftsG%8^?|BmWOF08<|kQfRFQ#z*zgd%x6qseAUm7`HTsSulo5hpD}^)RX;!P&nM2P zMGej0390Exns*v=1|IsUyS>ano#wOmawZJ}&6%N@f%=tsxVNHHHr{ggzGxWeZm;tM zG4lx&UGcVjTH45VL-S_U9D0;iy|Z=BSH1Kot$JtcoUeN6u{Hq{FaZ-d6HwouEA{i1 zdSzv=>aA}-JJrmU`gzN^61ytD8_#;$>X<){5m&=MyQ|`No(iSIQ)Kn%c`@y$=Slg4 z+iaaosMDPGw)?uhw@vHzG6Qw;cf%x4cmAx08K~17m1kEy?u8kso#%L-$b@>4Pw-E3 zF6+!do#wQ+Q?JXtZCcmE4AjX#6(;p|_bLxFP$z#SPweHKUD|oZB#V4}M&l>>$jZMIH6>?IuKp?{ZFyPW4BY(C>BZI%!HFV<~cyei*UPkSOv6Ho7| z%x4~J6EFc2Fo83H%6I9k=e(s}ncY?K*SDXYmHD%t^OkWX=8u1Sxp%d#j``ylaW(w+ zHjcZTXUvCJi>w|!uW!necm}uGI+;+XIqhxtb$f4{*6n2m>g4Z+NuKWfSr0Q%r#ULm zu6o=HGf+Fv@jQ_U^+SB(T+;lgGXr({=_`YzfreQ@lxM)VQ4~mcGWApDxSZ}!)(?jU;-v!0tbQ0cd}wt>7_@_ zVV!=Z>8DnHRcEi#s+aYZ-l;kK9f`UH@SMg#z0Bu$KFp{4QH{@z`Irx%0e^4&$@fNl z9uxnl^NgsIzxy!L!(M87Dw@62skgoDzGm+${B2rSGXr(x1$zYCI3TuU)#x$9ay=B{@`doL%C4Sy$(q=2SA!bGbLo5C4zkA*+ghnolJIJTqZ%*>nGsHgZi4+$K)okf@7#xvrm?k=Ws zp8uT(Srjxm@6vHzh5gyPD+A}`9W(Da$Jzu;zywU-ATaYiy3?!p@7ysn>*Mn9cc&+G z144e6e4fa_na)ERXKg-bCamn@ljiU6BSzVBL90-OF@t=s!$dAiVU z6ob_wpBt;YEzZ-$5=HX~6kYKIpP1P;-qyv>7w30xa3uqKzbsF1Q}?y2t{A4na-Q~C z;p>%rct+IDa}XdC>IxtFH|jPjUh&y!73wggIz78|Wmm=XS9zGt+5}9%1We#e;EC_& z^OkzWdCshY34cFX(QQS{Jg>W~MDI!l_I^R0?MxQ=IM4VozT}gh$?)H(kCPl%V?NKF z`o`XvnRrSsho{Ku(eq;3Z_ShLD|o6pnNTNxd)s}*eD+eeuJBYed#O`zHw-=OrKYE%*-M>z z+uQCd?w!5Vtt&j;2}dzJ?4|acgCm(xn~(XVXCOXPtn-Tx8t~zz zF6U;LtygB!qx9@v<>&m0hkk0+J6o^Jq{rF>Ouz(8;2<#jeLL%)~FU&ygJje4yCe$zBb9qM2Gd`nt$5wS?!~-mQc`&FPv`vD=&GgeUc?x8YB7l%Mr(Z<-SxHV$<7(;U^( z^|P0{4GF&*nCjtAbCNCIcKz(7Ze8Jz31bodG)HxH{p_WFWuCMva;CbvFIAtNqx`C_ z_Nw~q9OYMawO7@5%~A7RHvtncfnOk?zDsB8yI9TcRsL_v6Zgp9b5?YN6Ekmsir$qB z?EQi~+nJCLb&-|x9M8CVyf67A&f!;eo)LBOI}hPB{ScpBoIU3?=arv>)B6-7-ahpF zoc5Bf!cXUGIZ>e9M-K+fdjbo>pKU*Jf8DEWE{QYD_ zw{A_Y3lDXF@*IMOM!9p8vkl{Xp?ddDhhQR5W|3Q*V3QeO*33tt&hg z%?#A3w;P5Y_EOWMhS0-aYI;0}WDflhpUY?IoWyx}7Ekk0^JnYKyz=>)-K+c`nuqA( zv!m{DrC#LYJmcRt$cH-4E^)rBt20e=xT~Ts_on&b|B*ZuhV(qmhr24;dB&8?=kadiby(?PH|K&VnLQT%Ebw|#zE?8r9I3XRrU3a;|Xf7 zs*k6wUyZ%~@6KJA=F`OzMe_+1U12_5EKxL{K+zTE)5Q|S;L|D<9gPo(N(Oo!iVXv1w!R{!Rqb`=jmc`(F9Du1WdpLOuz(8zywUd1WdpLOuz)bo`C;dXne%)z(-|J z_3<68UsZcmeSPD2g4(O<<7w+xW3T_aa~G!hbg@Lyd;&#Rm`@i=6wN14bcOkJu|zTW zv`R%s<3pm7fu4tA#8~dC=xBU_P#H^0TVC*6EFc2FaZ-V0TVC*6EFc2 zFoCZp;C~kyAMrczQ5jTyd`Ih7)m~L!-#DJ2_Nw}L+WOVl>;LZDg=s!rEKxL{K+zTE z)5Q`+^9dAPVLn|fQ4Bty!=b;!emb)rC8ebq(o)@g{u5g|%78gyx1WdpL zOuz(8zywUd1WdpLOuz(8;Ohza--X6U{0@9n2G+-SvG*$XD!q5(c$&(<`gp?LtFd?R z-<|hv98Yr|^BEHuU-k22K4SvotA2hyluwHtXP5N&j`m(v8Cc)DaXgKCl^#!c?yB>Q z*}fZ}aavzB0TVC*6EFc2FaZ-V0TXzFfcm>Y)t|_~nQE`9v-b(D_Nw}$8Pvb4t9lE= zoV&8cOtn|lzc|lrCJ(W4p7YZ_#UwqeE4}9=M`dN^O7GX?NoREXzC7pnIkEU%boor0 zvpK5|DW45Lhh0kkd>y~fcH#K>iQo0jCw+nN*-&ukN$v5L9?uCZAT*%N+xR2ud}6_tVY=e8e{V;6syqi(kFJROF+n1Py}AITH^$wBEC z@Nu5;gJ(V;%7>qwcldlc&-g)l6Fv-i`PpY?Ha?`CXAIVS%x6qseAUm7`HTsSulo5h zpD}^))n9vl;(i+zYEoi7bn*B3@N?im(@)J7)`gPfZ#i?& z8#(E(=)p|qX#mY<{1nadNq+L>^Tzs$=1is4eEOAVw$7PKtC{pG&upDDtxdoLOuz*0 z5t#k%t@!UHIl3zIXFZ>uC+>IrTg|znctP1!$9aTh(TKcTtHdCr8*=gfo^#V6If-$gI*v=#CCs|?&5VVYq5 zuQc;mn}7+JfC-EVJn>yU-Z;MMJZC<^gukoo(rsPLKd4{oz{GNDd$+S~5y_TDzF+sh2p$=?l=Jl*-T9%i6Ub5x#P^|%*ipmv_)c_I_) zhxo*~r1?>22I}N*Z@0W+Z=2TD%s`#|Tf(H7f0ZZp@_s8i<=@Vvl7SxQA&s*(pEDCy z9^%8#MSRxMuBbB)b@FrOijKW$e$<(PI{8;Jus8Om`B7&E>g4ClC$#g7shZF4@QJf- zx4d2RGftg$k@ofs+{Fyk^e{}SZ_maI)M;--QXbZy(9Sca`VM?lhIn}XG2lf%%G)I8 zGXpi3(a-uW&H2ob^!Cqq+ROQAb@wg(PwQ@gRD3!E=cmS0KZq2R%4Z4 z)zuu{WVYPNkQg%M9vwp4R9&|NS-gKd8)S%YP?|XY4<4@y49ZS$&D| z*}x<7A4!kr{0GhdfAb@J;(I3DZ`99Zj!N>YM`(6V_|yET|5_e(zq9qk^Y(eo?p6K| z%|mXN&!oEdO1;R(d5+)5$)Td->=Nh8x;ncwr;>r5%e`rS_YQKk&|lGNrm9zF+G7GHU;@8PKz)BcU02MX-mB(+Tps@3_=Iji$m){M z6B#(uc}U}|&F9R7m0f(&9DYVtbQ{}!#Z2A{b?XYxM%@j=`OH8~&qlo~kD9Zq9%n%& z)QQQiy=u;<=ZXA@o2n}gsvdKAM%2Z)eUR94d%s`#yhrd`?dsRK=Gs7;OGOG-% zI}d4`^`m@v?rnAKI>(4gc-Z@d{`5R4e{h?vE4FD)d)s~8-rJ^id%rAC7utVX76Gzh(mwXcQ@ZYF+1EgZi=ebkg z*c&rbZ(7}b8@9oZyZ-*4l_`v`Qb0t$J@_WV?HzN(kb(K`?=ygXC|yX%7^FPmc}jyNIE?1eL{b0 zo^)TqQ`HsQtBZ5GVK}omr<>u%oLzZ5CmkHmLcyUYwZ~g}JSVV( z_#i&r&urXC66wCWz4WB^cuP;ye066=V-l^g>sR&E9&eNXZSzFnCYYJ^Cp35c2M(6e zgYqMiyFM`w^X~%0nPfuEUCAHM6Fn_{rj6sb&U2g3AN*!u-}wlg6g>LM%WIi7L# zcwh2KoWrl`JR|DlcOJrN`XN5MID5`(&MQ9$r}rsFynX2TIqgq-Vt*FNx9jM3Z&)&Za$d=li&zyrv0~NaXxd=adsf%;EXLMuE*XJS63LpAcG)(_o?w!9Qt>^|PX5Ii5 zy(<~m`vrNnGa(=9A}i-P|N90X^-Dg9bNE%AXGER+%s?IU*-M?~gkRO!OP&18Kppeh zOP%I~U)9-5o&3x|9rM{s?K#JHI+;+vIiEP+lr!qQ7wY71Z@aJAIpJ^9x|$iNlfN5= z9`;hxQ_<|DPQC4I_Z9cZ-Y0b19=p0pj$(M8$iSH&nuq8fWmV+kJmcRt$cH-4E^)rB z^BJa2bGWObFZZVT;b#WwikSmr(L|eEql}an8^&($^W)_2AMDKk-f88@!_20ah`vG;Po`0G{3z)zYr(R zr@8*4=~>Zf?m5gq2E39#GQqMW)BJ9pW4mwFe43SKw$7PKtC{pG&upDD zt$&k1JTvOU->`(|1&Cso^IXynRxdsy70h`Q8P`p~1WdpLOuz(8;57vN``DQCJMf7N z{(Gl;Smx8k5=HX~6qh1cH7E6D<3k2!pnhoGc0xl4Aj4zCph@~u=^O8PZvuR%_mS? zieS~8)R&D98JL0kp>>yInSuJU(FPMR0TVC*6EFc2_)r4;orn6bZigADe>qQZ@ZZbb z$H08LSfXe?f#OmGtLCJ>Y<$ST4Ac*;yBy05)R&Dmn1BhGfC-p@37CKhn1BhGfC+pw z0sak0{Z}`|4Aj4zCph@u54(?n`E;>F(R>2Mr3hBdNqyP)kbxPfA6j=gmKmro8*MNF z6EFc2FaZ-Vfe$6X-+8G2>UNlc`j_(r2mig?eGJT}izSNY6DTf4uxd`~%f^Qc%s~Cn zy34W5Kz-S0!_N|k=fpq1y3fG7@nOiw){4~hyizj*^(!-Q7c)@PV{HN^U;-v!0w!Pr z-$a1F^HBfQJu(CJFXssk{`;%@7?@8NOBBr~P+W>&)tuCqjSm@^f%>6!mt&cM`m)gm z6EFc2FaZ-V0TcKj0{lIvqMyFCN(Opz`Om<<2>glDwwFhELux= z&h6VPvCDb7Y|W>OC5rFHCxSH**^;K`mD+h;N!zg@bk|9RuMGCP0PKi+=6Iy-;Xf8IE*T+ZirT}8KbF>}1S zdo_A1yDA>%Ia69>!h_p#Uca1&_kKR9qe2hi-_V!m#a+&GCO|&aXXlo)n>sJ&IiCWV zD1Gj_eRj9ci`jl55AXK{x~=HG;=J0`SL$w<7iZx8GEdaibNEC(-MjN7$Q3@x6X)pq zOF!FX?mS|ik*Zfb>{Xg`sOhiND;~~Nnscb>uhc6Z&QyAKj{OHob1(;fru;m7-}AsT zwSLdvE7G~Nx7}Cy_mtNCkN4@9^PC9>6MnB&bQ=}D=drgdF|(3^o-fXGn+f?)FS2r; z@#B5TC-I;4kGG$%&d#6ppEr&xv-4;DDS4?EG2(dE>Zp zIiKHk72Vdw%<<~()#$D4s(74dOv!xymQUh;`TQq;dpq@-oj>cJ3e(K9^Jo3elOAs} zpM}HTG&bJSLmh@B=xKW870*T+Lak=fvrBWAnn@3}@~_k@^XZ{p*{gavzoNTy(jzqW zwk_q%N(Oq^8+s~0GJk8Hbep%|?&5PhKx+K8Jn4SpnNRihcFQZ~C+zXIZ3)jnZwbTs z5g-YA2Kr@rQoQcllyfCpoJDt0vG~P#$kwb#!8E+h4jhUaAre-|G$f42T>dD8v<=eftVCbzs| zzB-q-B|HPYB@E|(N*7z^s5lGGpVeQShj`73G|u{M`K0GFaF+RUe?LE zqS;Hm(mOkcyVy%jkJ9ujt$JCH-W#9Cm0o6`UYWVl%M8>jGgo?%#~hdpq`q^@60x2s+UU#dTOTgkifd;nGVi~ zmoCq1CDpIx;r&*)(a%E}=&AGKeCIg`kV)cv$#&42M#bBenJc{!Ac>WkE4?X3yzS0x zSEC-zv!Ew5pY!4zPF|T4z1;g{dAh7v9Oy0|vbv$Uj`LYpn*LpyyEv0|rRm?L)h<=< z?&UK)tJ@;ZRC`sOy`g6_(EqJ@c#kW37oU|3?ESSo>3-vxPxbb8%PZ!SId$6-o`K#H zhVz+$nx27vSsrFnI^|r+7H6S$Rq9`yhiuJ?G|u{M`K0GFaz@!2`g#xr{8>~5dYkL2MA2CG&KUE~mc4qVin z8QOWeRA>2ghioi5&lslpn9rEN_^O{D^BEHuUwwz?Co;6Cq5bnc4lbDdA)m;g&SkdF zdx<-(3+H(OtHm=?32&d>kK`e@OI8mtVFqgFA&s#PR?S8|?t1PjGf+RbaXgtBsK;Ht zY62$k4g_XDv$Ou$dz_s=>;J?&agY4{yxmCD(@jOa=uhpJZ)fMv`Y!_{!|eQ7e_D6> zwlY6FZCdETd4-4mfo90)ot;1H|JFQ;L#0j+bz(JjUTRLIP7k&795l$`9r!p;{ak!r z$IlYQLDl)?ll0}!j={`sFa6Yf&Qk`y?apNHU}m?MernESfTX)K**loo?WLcZGgAij zHs&Y8Wqq)hz0_$%_pS0@)_){V7uuj0+y;CG?b|Q?TAsMyMp9`)Rvy;rpVgeBG-oOg z>-5iR&QY2(m4|iuD>{1l8KG`N!b44u()3rt&|jPx*_5Ak&i|%7yf1aXv-K4|&J*;y z&!_pAPY@UjKR++v!|z7wwmSHaW5m_)t2vcAJ=9;2CqNDEB^c72{Pa+#mZ`UDPNhx{ z^;CdlR&y$KdZ^P1zcm39_(KA-pUqkS?5)ktpY?xYp18;2&*EACZ6?msMOWb;o;D%$ zfMhw@M&q0G6-hq$v)X&A|b^I(*98{fO zK1pBx>=?}K_R>$y=R9TL+wM&E4rX?H>8IvQ21vR)lf8qP-Cp{sIWuKYZ)1Myy{r%R zs$P|Wb=7-W|B*bwO5N{lJq9j{*}clY7$e%%{MmX8tc&ims`j?AUH_n7PjWcB^M5=~ zFd+w}c^34jy7CMT&Uuc{fkM>fqxi4XRe)4?o&+SlHJ=0|y)~Z%B)v7C1SGxf^5M@N z>ek!!SL$i6dfT1P4Ahmq%C7>X`n%;}yvRllNh^P)PESQUPlb{_CSU?j5a9PuW&W(c zGLxR!`LllRs_5DIv;L_J#h=TOq3EwVM$s`s+~BYA?`;C{o?L~v7nRp*e3F3$OdJaLZ| z{)uh3_r@HK?arJ%FJ_=F&Uv>y!G!sh=KWGv{1s1SCg;#kO%L^~r{Y)hE4{NG0uCtf=*Yc=)R~%Hm&Eadyxo{VCTXZ>}VJdz#U-c@#sy~rOWvkSk zXX@{-?(@d8rdIrw=Lx^s#X2=JP}4(A4>dhXSN!x)S7tUpUvYM=sC30o4|Qc`#m_kv zKRwi(Lro7gJxW*n^iWr3(r;}7CSU?4FeaeBS7+wRmt4lI4-_Jo-G;3hq~Q9=Z|R|SLqKunA!EvPyJ1Kcwb7V`|Yw) zp5r(!|95w$^8~lxL(b&Gy3$2|EFB2v8Nf-Gg4KXOTf*Opp^Lqoqx9^|@PBch?mhB; zH)?e*tUC{BoOSTw=VF&`>tgV2Z# z4bX~D?3$g)Y_q*j_&*|#`mRuQp0)C@PR(AWm0#64M|oJMX0Ou9uj-tmJgif*ms)vT zKfZU&!5sW~IX(ryz=8K@{T9D_UH$&lj>#_*FaZ-V0TcK*0#`rZeEmKC4d`?Z{M)di z+mm^k@lS2`N7ZNN&-&F~RiB+t|Ln|4FK1T#vmW}XxmW3m zf7U}kwaUPH#s5kVvnlO7{hv3ASFc`S$i9KU*}AXp&&1~J)(7)v{oOEXud2Tw&s5Gq z9?l6?ML&C$j+xC6x;THlOd3hkk1ARl4G*hg!{?t#c-|nnMq@ z^3T>elUmK8hg$h(>zqlg=Fn5oo-?NOG#@qJ_5c0-@CGbe1iwtc1WdpLOuz(8;H?OB z|J|u2RQ0FBtG%lJ3wh$+$A590ucmX{#mafkByTf0pW0DbJUi!EJfp;aif8IQCpjuB zGgo@QCQsrVOjN!2S>qhCiu#Q?(aUT%=6pmR-eW~84zqQ_sq9sr*}cmD=6O=QskiYw zt9w`V#C&S$!0bE&IO)V4vE?0WGtqweM1@-Sy)Yei~$Ua6UZ`jr{Diy5ft zu{Hq{FaZ-V0TVC*6EFc2FaZ-V0Tb9ufPaHm^xo~~X_XB0oG0w9a92g|-F{4qz3SiJ zRK2xF@5W#;Q|(ptFV1tD$wRE1=lsA=F-gzrO7A(zQCXR}()-SN;=ahg_!;T;-k3u^ z-I>mFAW|G=>pY_yI?ii$ukzo>z~|&`^YFgZy{kHV;|AA7a8r9#{YUbU@FlBY+K4SvotA2jWXG~yx)z6Rlj0x1Q#WkE4?X3_wCgD8=s@@(m~OA25{1)OIAFu)*Jpb zXV=@9&%H`Jk0Nu_&F4?}Tt34*7nP8nrdM9hbEY@Nq_u~idgIx}{Nl{;e{r6;$0C#S zDW5AVGgo@gNsh|O%$43p^R(fS?Zuk+^;a3V_igj2&lKxCJJzY`p{9qL9%_1&uK4Mp zuFS0XIj7>MhnjP!>7lN8Dt%j!wl53b5{K9rB->A=Lx^s#X2=JP}4(A z4>dhXSN!x)S7s_d>q>JzJx|xUi~8xkYCbbiEB_O9&ZKr8(m3l^^5L#O)NOUV_bL+g+FEczg1_M&}uGGavIA6Bu9ptLNu(ulhNq>f_tIyy`rch{Dii z#dD!t>7kx#iJH>~)?lXY=V|iQ*^niOg{q_XOuqb6V5~ zpRe$+@rLFcYL1HfJLh3G>UJZMpEs2>J)w(px_z97TQ`I>zY3@~; zEnSb=tLhw>ba#I9u+A3NL#w^2&VfZ8yO>SQpRE@&(B?b`jYm1CbL2rJ?L5b4mso;{ z;`wx)VVZWH2AmuepXA9sPrhfQC-+omzjGdDvo-+}FaZ-V0TVC*6EFc2FaZ;I4FUD{ zZy$3IE-Ry0wtodBWaG>|zFL=Q++pF;Vrs#}w1L=fyK}o|m0hoCW#ENgX0Q z>RePk&8fVNUCm6*-l(g+s?H%r9lKtfr@Oa!U(u`lsy<*6Gs&SiCwi4%)gQ{kv5}4U zmGq@wb~uAQ~YP^-Hqd-^BjC0<)F@Sa5TqREQ2&1QVmQuo25u&2Cak=YPwZ*|x_aiT&jH?*1=^&iaBy?1h0(dpbPN9H_d zN?j(2ZFpAdJnJ-vsbbf_AD%R4sy>+i(Rl{<)#ao7s!llMul%acUTWo6^-s^kdtcGJ z_^f1L@3-dRea-48_{?UY{}=M`9#^#D)@Je*-?0OKcv|CaJ(&N_c`mc@zE*T%%e_j+ zS*+|;yAXv-%;7? zJmbIbSNM=~X!WXHoP!PXd*mZS#3C zpS14s?bGLV86X*cEl;{%fB%f12lFu>{!EGIL4A%E>)ch*&NHSIe9~haZ_{~=r>$Rg zo-sr7`EEXOzU?-Z9upW}jhXQQPhzk)dXs0oaeOsqrWo-y?F#>(KHfOK8uKH-4Y4ts z^DLg1Itz8I$v@tHzIu6HY5uJLym4Haoj>azZ$Dq1oj>b8ZyZ-<=g<1b+s{{L=g<1j z8^@KH-)v9l@%Ho8Co*v6dE>ak-Y4{UyRVvn37CKhn1BhGfC-p@37CKhd#xkDXLkOqpSvo0cK)n?Dg*z`ur;b(Q7`%{8R(gvKkMhNik_W6>#t;>r!qf0tugc; zo>ye}f;`=O;Q{d;sTKd(dSzF|GrL#$E4wNlHGj6=cEuU7m%8Gie^zrowVG4$sNPDQ z^Ql#D#iM#Fbh#k#TW2pd=TNVBR4?mFGXpjKtWzsb zrB08v37CKhn1BhGfC-p@30x9Le+z_vS3L$6#jd?-PBBK<)SO-QSTqo67yowHqSO3A zlH*eHZ^_Um$DB0(*_1D?M-9`K0-2`}uA1JI@&rE8F>S_zmqm z37Vhh1SGwEH$FLDd%ydcPAjI~?#}Yhyp`9V=Xtm1$9d|HQ(_g3yXrBpD0b~tbBZy- zrsnLb$07?8FaZ-V0TVC*6EFc2FaZ-V0TVC*6ZlO6EC06n1Tp71Qw=8kH?djW#>SlU zim6J>nax1|m*wd)N%t5Y))f;~FP>EF8q5jLkK~E_-Nl65s0Z_Te9qHAksIN#KHwSs z6%S`p4|*ACYS&<9%wY!VLGQ=q;k`Ve$&GMWe`2qi$-SSFCuP2TJ~#S_=#_ibu6NGE zY}O`V0w!PrCSU?4U;-v!0w!Pr?@6HY_vR~;JI|SRFuCz>JLhTZ73VoK>@qpqjtbAQ zRian$rHU@^SxrsOuM?%k|%n*=6l7MnRa!jB~SEr&G(8iGwte5OP=WMn(q~3 zX4=)AmORnhHQy`7%(SaJEqS81Yra>EnQ2#dTJl71*L<%SGY7jWo_pKRU6oxG&w28_ zN@Z8Yb8q{(tFo)&IZwVthywDItx{=Prm0=dsY43 zmU@@ktLpX1cA9_*ypn+W%(Cu0;%}D*<{wT^zv3*^?+mQBFyT+ZSf@_5%eT?Xy-GXJ zK_+nshKY96Z}3c`;%#@P^NjhBzhadH5|D z!JL?xJl*-p6TMyYQ4G(ZH#{o8nm?E+TmIcK=yjg<%vN6ivi#@&@+INJ#9rm62dz>n zznafM>{Whx*sHYitNEP6Ugb~q?sJ>wgeUDvqmH-96TMyYxk&$|PP@+2S|xcnv+GYq z`Y(0bl|~(JlZP|A{u{-ZIoMV4+*sXhsqCtFy2Ec2E4wP58>_o5m0cB2cleEBWmm;> zV|BNsva90h4!=>X?5cQftnRi{c2zvx;WvtvT@}xb)!mlLu8OBS{6?{|tKzw_y4zCO zRq=F(7mJno;b}9wdhqkE7$a;ke=svV&T~*w98`V4HV&dF;w%O;!{a8Sv+*X+ z594*SF{je$Ip@q3?L2jQ!781Fs@EsqbE>_nes4>?OYK$l`eZwQnE;=kci`}?d3ayc z73SgR&#%@P^~#XsVJ~&Eb>D{n%kp&Zt9Xx>y~Q~MemS$5!^1|_xmRiW(;U8yT{q@j z_HyP*9`>r4yXu7V%DpQ8C*~>M3vaFaERjFW1KpkDJVC6>hn$P7F6YF?vACS$Jjc%i za-inf4NzZl9`y23caHNAQRraRD%4?MT``=kb9mCsKuufJXZI>UhbJAoTAiAWyFF2#vb&e60@cc-gmHUm}ptmk!<_-SQyB;GZ z#LO?q6F0R{tnk?wBSyVLo^A#{Kh!OG_~S12ikQ#6N;{7tbJTC}3I4@n4gWaFPvx0n zLT>52Voo}Xs1JJC()F`fY3EU7#&yMwUCFcMyf~ja?dm=c$@5cr$f}|ft1i#VoL!zz z$)j?*{-58g;(7WbE^Vz}CSU?4U;+aI{GL{}T^==`^C&u)^ht5XEB%`p0*|Qz<)bTaeibd`nTudy;n4I zu7u&7%3kH+oNvvO?y>vK6g?}5R`#miZ_2ZBFYYw~6EFc2FaZ-V0TVC*6EFc2FoAC( zQ2BR&iib>Q{j`o8X*W1ElR##Be=QI1m#mal{-^8C^S{r)zbq8< zf3N@ZfBAZ%UYS|(?8;f$Rq;HLXLhg3Fgu5SrPVIhsaNKxUe?tv)~VS`tvr>w@>J$G z4_~)`elY`e8y+*M2cECY!+TGf_e)J~tW(pYH2u^oe$Js*Gg+sfnjUI;sAoO&Q*)-Z z37CKhn1BhGfC-p@37CKhkO2R7sA%>+p(`2ac_IU6a#uyOcbAU6{C9?mZULfqR~XK$ zWT1z=UzR60^L{J(i<$6{#dhR&?~<`0kC~ zFUu46RbjH?N!-+VInVKXnc~BGuu5#BK6_qi4tG^_>`il`{^NNR!zn(At(v(~cb+pn zGdVM1<>UCY@R6A}@{o>Q>O1fU^O(u_VfzR^FMe)GtjouFh$wWhipt*#=lNUy-fjXW zU;-v!0w!PrCSU?4U;-v^5a8dZ)a1ju()6$B%6#QveI)~XIg`5LQGWK$>X^xYUu{FW zb$Y1jpAC@w-MyU8y-L%c=Fh(U=sbzT<-N?p;e4J&rC#*RM!LL5m2+dB$WWQ-JjZv9 z;-Kmkwu6T!&WQ7sR=XboqlT*FaZ-V0TVC*6EFc2FaZ-V0TVC*6EFc2FaZ-V0TVC*6EFc2FaZ-V0TVC* z6EFc2FaZ-V0TVC*6EFc2FaZ-V0TVC*6EFc2FaZ-V0TVC*6EFc2FaZ-V0TVER4<+#b E0J;<@HUIzs diff --git a/fonts/font_ultra.png b/fonts/font_ultra.png new file mode 100644 index 0000000000000000000000000000000000000000..7364263f05d60aa1128d5a2a0a668745f320fe85 GIT binary patch literal 31983 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 literal 0 HcmV?d00001 diff --git a/fonts/font_ultra_2.bin b/fonts/font_ultra_2.bin deleted file mode 100644 index b671899be5f748383930ff7697366d16d279b50f..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1990656 zcmeIu0Sy2E0K%a6Pi+o2h(KY$fB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj TFkrxd0RsjM7%*VK!0W&OVZs0b diff --git a/fonts/font_ultra_hd.bin b/fonts/font_ultra_hd.bin deleted file mode 100644 index 6c28838edfd6151ed4f8defc262f0d164b7bc0dd..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 884736 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 lC@IM-?pn?DZ diff --git a/fonts/font_ultra_hd.png b/fonts/font_ultra_hd.png new file mode 100644 index 0000000000000000000000000000000000000000..34706d4a7a40b885cb64675c0fe0d10ae830adbc GIT binary patch literal 19540 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 literal 0 HcmV?d00001 diff --git a/fonts/font_ultra_hd_2.bin b/fonts/font_ultra_hd_2.bin deleted file mode 100644 index 77b85aca81c9c593b34f58c9506c2d4c80de135e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 884736 zcmeIuF#!Mo0K%a4Pi+Tph(KY$fB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* h1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^%~zyN^500961 diff --git a/jni/osd_dji_overlay_udp.c b/jni/osd_dji_overlay_udp.c index 97d9ed5..d2d6e77 100644 --- a/jni/osd_dji_overlay_udp.c +++ b/jni/osd_dji_overlay_udp.c @@ -545,6 +545,7 @@ void osd_directfb(duss_disp_instance_handle_t *disp, duss_hal_obj_handle_t ion_h load_fakehd_config(); rec_load_config(); check_is_au_overlay_enabled(); + convert_bin_fonts(SDCARD_FONT_PATH); uint8_t is_v2_goggles = dji_goggles_are_v2(); DEBUG_PRINT("Detected DJI goggles %s\n", is_v2_goggles ? "V2" : "V1"); From 9dd3f137d7ca52f99ce7d3f07bcdf044d7bbd324 Mon Sep 17 00:00:00 2001 From: bri3d Date: Tue, 27 Dec 2022 20:46:55 -0700 Subject: [PATCH 7/7] swap ipk to contain png --- Makefile.dji | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Makefile.dji b/Makefile.dji index cc56aa2..bed87d4 100644 --- a/Makefile.dji +++ b/Makefile.dji @@ -23,7 +23,7 @@ all: jni/* install: all install -d ipk/goggle/build/data/opt/fonts/ - install fonts/*.bin ipk/goggle/build/data/opt/fonts/ + install fonts/*.png ipk/goggle/build/data/opt/fonts/ install -d ipk/goggle/build/data/opt/mspdictionaries/ install dictionaries/*.bin ipk/goggle/build/data/opt/mspdictionaries/ install -d ipk/goggle/build/data/opt/etc/preload.d/

XeRS_N_D@=$e2>+0F&NhFPrtwWOZIsO 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 z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0wwUjE&B7L4!W_Ng8I7hhk9 zW1n^WvRW^BYNmaj%BwknZy}IB4}4XeP+zq}&VAc`;+Op|3;)9TvMv4_{LcGqyXEKV ztKz?i-e9M9-Y0hx6Cgl<009C72oNAZfB*pk1PBm#hCu#3;WPRl?P;GKvH$)i`hV&4 z5x?@QX4_}TUOwC1ieGH?>0JBV-c57J7y7ATCO;4#?SC}?=t@WXAI*QpKDEQvd>FU) zJItBY=D9v&-#&vp5^Cx z#LP!(mCU;uyST`=4agUXFKG1&B{I*x1N=s=b4{z=H$?w zxcX_zY{?yQrLYo;%FqS#6!?JI(&H^UP`SY==CrxvjR&XLD!gvpzX=C$71(J~=nz zmcKLN@>{jDeTKGthAef+rznO2pCL;fmd|#QaV30VV4p9&1&-KGw+f#8EPupb@@1cW z_ILByw$0DY{_^*Cv-V7!owHA#uf$nntUVL2%$nuY-2CjFiMK)3b2fD6 zylT(vkhO2VPd)FB$?R6vo{6)6_Q~^=IBU^5cvs`6mpL@wN$$w?o(&~IA-l@HxxPMY}cY0RN zY`2}-{pt62Yt~NB%DHf#Vb9#*8S!lY+4(be$ey#gv-7NdM!YgNbDpt7_FS2@l9N5p z#4EE_a?b3Kwa=K9Ju}X^uZ(ktj9?2tJ2NsSi2$f8OCGW&VbIROF$2oNAZ zfB*pk1PBlyK!5-N0t5&UI4Y3;?sl~H8Tt0PS1ptLSEu{5mz{j~eQN(r?DDw1qwGI> zL78)T{7v^Mhur_!ar->v`?Al5zvDBsYWcnXq3iq%wEnq6#t+SDy{A2Xz&>g9jJWKY z)iY+T^t8{4(k-W~)=Qq6X`iR^YEFOv0RjXF5FkK+0D*5U@a#V`9_@cL|0w>^{zvnl zu}|&L{*I{5j}C45)n~E)(fl^<)61j%kLG{6KucKZzmn71UUK>A+{Jf#$ue7$Z?Vsd zO=h;ATFnZdbpE#c`SzEWWRL-pOo-Jb&Kw z`_4Ic7T;IB<|Oxd&BXmFKXsp<`ds^ObN%jH`S|_e@Ws_TdN-eK+ppT~)44CU`Y!wA z2kg_GGx>q|X#b=6M^`%9|7iZR_sRaXTOM8*AMJlM|LCem`yb7J_C81Z%O^m9009C7 z2oNAZ;PnE}{&U39C$i6u*o*(pXJ?b!E&F^00Mhm0%# z3-?*sA$NXuY@Z$BozKZm)$?xI=TqDIJb#+`ngsj2#@Q4C1PBlyK!5-N0x6Kc4?h!U z&ol9v9kTY!4q2N$&&1jDXk2si&$(yfqYJcr`!tZ9%d*;X&cr(-4&6GlL)IP|x|5te z&%`?;+#*1L009C72oNAZfB*pk1WpQ^`7?Xgo?N5Kv*($(8lDW!?2xr*)~G&b{?0IK z&n&am+GicGtkUg)czxo2rhWE(+$BJOz;_qOpXa~oS#pPr?Q;_-llFVFI)4FF&B`4z z-gc-Q``l#GC4Tl3t?ZCF zzippqKd=7h1*SxkLKsBqw&hDm7Jq%yO}F4@gK#rWyFtIXF2wc9p2V1oG$SGx1f=b!LaG{gM0R@5j!>8_p$GXLiWipSn+bt~5Uy z|H#kt8~R-3tPcSK1PBlyK!5-N0t5&U_(=js{~lwOf0fCs|IzawxljI`+nIR7NzaF^ z&g_u2KXsq>TxotZe)t`=!lQF%`K|54m$Uvy&mUeuAprse2oNAZfB*pk1PHudp#7b| z>lbJf?bAT+FYC|gY4ug{ww`@<@Y6^9-)H4rEp}d|TW=_^eU5w)AV7cs0RjXF5FkK+ z009C72oNAZfWR*ixazN|ui~=Ly=0nfckAB}&%~|g{m`A0R{LxBNr#NjyqA^QoV60K z^gNTZvP0&anYB`zvoc<(m2=I{FIPC`yUX~B-g`ZA)=IqB>xz3TJ7mrkGxvJrtch*~@K)A7BOVTQNPqwV0t5&UAV7cs0RjXF5FkK+009C7E)>YW z-@dTz!>!(VpWN-M;tjU`egCU=$hq&lPwpoE?{o967WugnzrVotIr2q-009C72oNAZ zfB*pk1PBlyK!5;&cN3_8LwS?M>~sGj$|V0L{66hvC-%9gW^!+mC-30%4m-S?$-C|2 z9pxLjkKfHFH+;9nf0)KJ{Ks=IoRox@Dh3T#^Y8AV7cs0RjXF5FkK+z>gQW>hB6x`mA8C^tmeMyX;fX zyYu&2SLGZsu}^Vb<-gLWhVBF_eXh#cS)*=UHEX3$4Q;_n?NvE#^zibkSu1^p3$(+P zK3CS?w092GTCy%_rA;x83ZM zZ)ZPd_5MEIk$1E&aDUflhRMCa{>i(2X0~m={P*xp%svgoB>@5i2oNAZfB*pk1PBly z@TtJc-zTi(d^%_`VP)1z&f>UF(^h7!t2yoRwKCIV-bPa#m)o<|NN6%Mgt>he?oB1pKS8}rFnRsQ^O3s-bvUX+GN>27X8n5(U z$vHZAmcKGN3N>27X6R*r#$vLw_)~?K2$;qB4je0lflZYm7J4nC?`OG009C72oNAZfB*pk1a<^g{%n3#&dwTj>#A8ReQM}V zu+rzMoSijpw^sh{>#Cejm)R1onzhpBJMNP^uRP;bIXQP0Uo~r`&uoW0U+HsIPR?D4 zubR8k$38cu&0*!|)la!r%&*G%beWHbim%x-MoJod#Pzk3Q^`BQN}sE8W@}v4f2GfC zhdf{Db5%~xoyAwpTIuu7JLGOF&vI2x&Yi_q&06X6&O798E6;LOPR^ahSIt`KGuxq^ z=g;r$R$X3|Qw?{5t7fhA*;%7*t@ODnr-lj$5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t8+rkpI?`@yixygK~$ATiVMmbBByyw!k*1=H|bXW}G=MSj;~6$U~F+wA;xG-kp8! z@ei5YmtX$w>~oKNiOGH2hu@ujZomG_NSzZPK!5-N0t5&UAV7cs0RjYmn?U`2(e~gO zf0aY-knwNcryTO{;WK{myR*;zr*UXnUnFBTseOgM$#-N^D`$(zjB|pUR~Dn?(F$rawO$5R>JwfKKF))Ozz8XC-Lg4 z-*)FCKKfPlt>>XWt+sj|YH~}i+Sc<>t5#b*7n@Xm>$6zCpVoTTtevXLX|+2g>$h6Z znzhrRa$4<9$@;CJw9dbU}^&Ml{Ehslo}R?jwT*sbMM?J)WLVfD|s8E+#h z=lr-&JJhV)A>&`ZPXdYF4@2JtXVtFE2q`&l&s%sJ!{rZhstTSJ0ZSb@^3&GAH9LxpMw0jHFpk=4Vcne&s&7UOnT= zZuu;KHHqR`PUi2#_SwN{w^ppGBwkU~Z8tyStG=pln>Fm;a;kQi{McdjY_o>lT29pt zlg}Sk|D2ogHllLQkNdPk&B`4z{^k25U|GG`BzMTzKB*xlK!5-N0t5&UAV7cs0RjXF zyuU#GeNOxPw@Wr}J!{rZ^U7(pJ0x16dSCO>vqJ=?5d zx0X}2!{q(Ls%<^9YM9gVE9bAmNZQVaIhmh1QTkDrU)3jbGTxFa=dZ#@n&o7E=0xdN z?vv})Gp_8G&+=E3D4ykH{!VP49h`P+#i~l;6;<7K^CQ0MtNONC!~QL&YKO^>9ahga zYuK&jRP8YN{9*OaxfyRGD(C#TPdn7C+#%y%zE1*{)r(DXhm7r$8e#$j2oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF d5FkK+009C72oNAZfB*pk1PBlyK;T;l{6EY#q&ENn diff --git a/fonts/font_ardu_hd.bin b/fonts/font_ardu_hd.bin deleted file mode 100644 index dc295a88ebf1bf801df50312b96928999e5ec09d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 884736 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 z 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 literal 0 HcmV?d00001 diff --git a/fonts/font_ardu_hd_2.bin b/fonts/font_ardu_hd_2.bin deleted file mode 100644 index 2bd63bc8d2f379710feefc8bbd8367fbdc8eddd4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 884736 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 z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNCfw+Z}jyU>sSt@>J(-*W%= z>ubT~SLf%-t9-sHKj)~|1oHiUy5{t!bCcKd^XKj9`f>TEgFpX#$oo89KVD&bcslz> zo-YCf2oNAZfWTdW{7!Or-_`!5`T4bQyUf$)w7k{%x%Y$T?B07}em)1g=VtLjJ==e_ zes;ucf1BSn4|T_DSpQr4bI)3HzszS`YhBOytR^RY8P{6ZGfu7j8K14EFZB=hZ&w(; zhR@mAy|SLVCFOHAgm!~Jl3(waajmc3KRMZ-ajjYJJnG}FPtBQ)<!-^bPY z3%u*+@9FPn&HwJ>_PqsDW&e~< z&b?ZX-{SM?)!g)bPS~Gm{dfNzwnbe%XLWwwD)+fsv+ruXnw!3>xli}4K41RvckH|S z9KW4a0t5(r7Rb-NT0eLGoT+^oe|3L5clP_wcA0vwzomb;M|aQMH}#fh9FkYZneXaL z`8&C@oV)Wgm%BN$e)%(*pYvbhvmJHz`98ko`ReNY^Ber#9jkqo=KJ|G{ctsRKF2=W z>dYyh+tgW5)`wc%>p16j_0|0BYv<>jT6fO*+xmz1=Ed})4u&Tp4ra*q7tkHvTQx$(Kl=j&<>T>3Mf)%0Dhvz$8L^74JU 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 Z00@8p2!H?xfB*=900@8p2;6l9{vYZK`mg{1 diff --git a/fonts/font_bf_hd.png b/fonts/font_bf_hd.png new file mode 100644 index 0000000000000000000000000000000000000000..2b1316e6fad3273a6fcf027d6945cfc6276f952d GIT binary patch literal 113348 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!jP{X=tIebkWijS|nzo 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 literal 0 HcmV?d00001 diff --git a/fonts/font_bf_hd_2.bin b/fonts/font_bf_hd_2.bin deleted file mode 100644 index 77b85aca81c9c593b34f58c9506c2d4c80de135e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 884736 zcmeIuF#!Mo0K%a4Pi+Tph(KY$fB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* h1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^%~zyN^500961 diff --git a/fonts/font_hd.bin b/fonts/font_hd.bin deleted file mode 100644 index 58747c2650bb8e8cd0c6641a080b8901b61c12e4..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 884736 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 literal 0 HcmV?d00001 diff --git a/fonts/font_hd_2.bin b/fonts/font_hd_2.bin deleted file mode 100644 index 77b85aca81c9c593b34f58c9506c2d4c80de135e..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 884736 zcmeIuF#!Mo0K%a4Pi+Tph(KY$fB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ z0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VK zfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5 zV8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM z7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b* h1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^%~zyN^500961 diff --git a/fonts/font_inav.bin b/fonts/font_inav.bin deleted file mode 100644 index a7f3e016f0153cc9c98566b4ac05291a1bf71b25..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1990656 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 zNI(J-kbndvAOQ(TKmrnwfCMBU0SQPz0uqpb1SB8<2}nQ!5|DrdBp?9^NI(J-kbndv zAOQ(TKmrnwfCMBU0SQPz0uqpb1SB8<2}nQ!5|DrdBp?9^NI(J-kbndvAOQ(TKmrnw zfCMBU0SQPz0uqpb1SB8<2}nQ!5|DrdBp?9^NI(J-kbndvAOQ(TKmrnwfCMBU0SQPz z0uqpb1SB8<2}nQ!5|DrdBp?9^NI(J-kbndvAOQ(TKmrnwfCMBU0SQPz0uqpb1SB8< z2}nQ!5|DrdBp?9^NI(J-kbndvAOQ(TKmrnwfCMBU0SQPz0uqpb1SB8<2}nQ!5|Drd zBp?9^NI(J-kbndvAOQ(TKmrnwfCMBU0SQPz0uqpb1SB8<2}nQ!5|DrdBp?9^NI(J- zkbndvAOQ(TKmrnwfCMBU0SQPz0uqpb1SB8<2}nQ!5|DrdBp?9^NI(J-kbndvAOQ(T zKmrnwfCMBU0SQPz0uqpb1SB8<2}nQ!5|DrdBp?9^NI(J-kbndvAOQ(TKmrnwfCMBU z0SQPz0uqpb1SB8<2}nQ!5|DrdBp?9^NI(J-kbndvAOQ(TKmrnwfCMBU0SQPz0uqpb z1SB8<2}nQ!5|DrdBp?9^NI(J-kbndvAOQ(TKmrnwfCMBU0SQPz0uqpb1SB8<2}nQ! z5|DrdBp?9^NI(J-kbndvAOQ(TKmrnwfCMBU0SQPz0uqpb1SB8<2}nQ!5|DrdBp?9^ zNI(J-kbndvAOQ(TKmrnwfCMBU0SQPz0uqpb1SB8<2}nQ!5|DrdBp?9^NI(J-kbndv zAOQ(TKmrnwfCMBU0SQPz0uqpb1SB8<2}nQ!5|DrdBp?9^NI(J-kbndvAOQ(TKmrnw zfCMBU0SQPz0uqpb1SB8<2}nQ!5|DrdBp?9^NI(J-kbndvAOQ(TKmrnwfCMBU0SQPz z0uqpb1SB8<2}nQ!5|DrdBp?9^NI(J-kbndvAOQ(TKmrnwfCMBU0SQPz0uqpb1SB8< z2}nQ!5|DrdBp?9^NI(J-kbndvAOQ(TKmrnwfCMBU0SQPz0uqpb1SB8<2}nQ!5|Drd zBp?9^NI(J-kbndvAOQ(TKmrnwfCMBU0SQPz0uqpb1SB8<2}nQ!5|DrdBp?9^NI(J- zkbndvAOQ(TKmrnwfCMBU0SQPz0uqpb1SB8<2}nQ!5|DrdBp?9^NI(J-kbndvAOQ(T zKmrnwfCMBU0SQPz0uqpb1SB8<2}nQ!5|DrdBp?9^NI(J-kbndvAOQ(TKmrnwfCMBU z0SQPz0uqpb1SB8<2}nQ!5|DrdBp?9^NI(J-kbndvAOQ(TKmrnwfCMBU0SQPz0uqpb z1SB8<2}nQ!5|DrdBp?9^NI(J-kbndvAOQ(TKmrnwfCMBU0SQPz0uqpb1SB8<2}nQ! z5|DrdBp?9^NI(J-kbndvAOQ(TKmrnwfCMBU0SQPz0uqpb1SB8<2}nQ!5|DrdBp?9^ zNI(J-kbndvAOQ(TKmrnwfCMBU0SQPz0uqpb1SB8<2}nQ!5|DrdBp?9^NI(J-kbndv zAOQ(TKmrnwfCMBU0SQPz0uqpb1SB8<2}nQ!5|DrdBp?9^NI(J-kbndvAOQ(TKmrnw zfCMBU0SQPz0uqpb1SB8<2}nQ!5|DrdBp?9^NI(J-kbndvAOQ(TKmrnwfCMBU0SQPz z0uqpb1SB8<2}nQ!5|DrdBp?9^NI(J-kbndvAOQ(TKmrnwfCMBU0SQPz0uqpb1SB8< z2}nQ!5|DrdBp?9^NI(J-kbndvAOQ(TKmrnwfCMBU0SQPz0uqpb1SB8<2}nQ!5|Drd zBp?9^NI(J-kbndvAOQ(TKmrnwfCMBU0SQPz0uqpb1SB8<2}nQ!5|DrdBp?9^NZ?We z|JSLYWxHhTUaUd<47YFPe}^sxC8I_7df z*MI1l_@9UoONO&voM$&fw)fR~?0PQD^8_EB1vT%|YJDCfo(|88v#8DUpmBsl#xqW2 zE{5l2o`7}=pMz%vmMQ)w0_~|*K<1Td>SZ9CMsp&bQ*)!AZU-8hts-r*e zCv|JMdZ_8yj@zxoEcT@C`mg$T19XPf{;U3O z+|t{a)mBkwP3WP{{Ht~Lq|W-#L!J3o>+DIL^`VD4^IMmI1SB8<2}nQ!5|DrdBp?9^ zNI(J-kbndvAOQ(TKmrnwfCMBU0SQPz0uqpb1dbDk|6iT%|4%IIO#lCDYySR=<=w*Y zw>ouai?`v4hJS|SFZ%yx`Sag+bxXtF>eQVr-i9X{HW5#^g8nP=Y$vu#mn|~ zXA6J-4I3UTn&%)umrFnb5|DrdBp?9^NI(J-kbndvAOQ(TKmrnwfCMBU0SQRpLkRqT DiCJ0y diff --git a/fonts/font_inav.png b/fonts/font_inav.png new file mode 100644 index 0000000000000000000000000000000000000000..93ab13e6ee9af5c627cc0629587e77adb84f75d9 GIT binary patch literal 33893 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 z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk z1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs z0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZ zfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&U zAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C7 z2oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N z0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+ z009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBly zK!5-N0t5&UAV7cs0RjXF5FkK+009C72oNAZfB*pk1PBlyK!5-N0t5&UAV7cs0RjXF z5FkK+009C72oNAZfB*pk1PBoL|LxF$00000fFOVCK`w+07%*VKfB^#r3>YwAz<>b* z1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd z0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwA zz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEj zFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r z3>YwAz<>b*1`HT5V8DO@0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@ t0|pEjFkrxd0RsjM7%*VKfB^#r3>YwAz<>b*1`HT5V8DO@0|pFi2Lf$(ElmIb diff --git a/fonts/font_inav_hd.bin b/fonts/font_inav_hd.bin deleted file mode 100644 index 788ee1a0d3b1471e2b7309f54ceb6f0cfca3b2df..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 884736 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 Ifp0?K|NN{}>i_@% diff --git a/fonts/font_inav_hd.png b/fonts/font_inav_hd.png new file mode 100644 index 0000000000000000000000000000000000000000..f7e398847d65346299bea29c189acebbed8e2bef GIT binary patch literal 24131 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